This is patches:
[blender.git] / source / blender / imbuf / intern / dds / BlockDXT.h
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version. The Blender
10  * Foundation also sells licenses for use in proprietary software under
11  * the Blender License.  See http://www.blender.org/BL/ for information
12  * about this.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  *
23  * Contributors: Amorilia (amorilia@gamebox.net)
24  *
25  * ***** END GPL/BL DUAL LICENSE BLOCK *****
26  */
27
28 /*
29  * This file is based on a similar file from the NVIDIA texture tools
30  * (http://nvidia-texture-tools.googlecode.com/)
31  *
32  * Original license from NVIDIA follows.
33  */
34
35 // Copyright NVIDIA Corporation 2007 -- Ignacio Castano <icastano@nvidia.com>
36 // 
37 // Permission is hereby granted, free of charge, to any person
38 // obtaining a copy of this software and associated documentation
39 // files (the "Software"), to deal in the Software without
40 // restriction, including without limitation the rights to use,
41 // copy, modify, merge, publish, distribute, sublicense, and/or sell
42 // copies of the Software, and to permit persons to whom the
43 // Software is furnished to do so, subject to the following
44 // conditions:
45 // 
46 // The above copyright notice and this permission notice shall be
47 // included in all copies or substantial portions of the Software.
48 // 
49 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
50 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
51 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
52 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
53 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
54 // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
55 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
56 // OTHER DEALINGS IN THE SOFTWARE.
57
58 #ifndef _DDS_BLOCKDXT_H
59 #define _DDS_BLOCKDXT_H
60
61 #include <Common.h>
62 #include <Color.h>
63 #include <ColorBlock.h>
64 #include <Stream.h>
65
66 /// DXT1 block.
67 struct BlockDXT1
68 {
69         Color16 col0;
70         Color16 col1;
71         union {
72                 uint8 row[4];
73                 uint indices;
74         };
75
76         bool isFourColorMode() const;
77
78         uint evaluatePalette(Color32 color_array[4]) const;
79         uint evaluatePaletteFast(Color32 color_array[4]) const;
80         void evaluatePalette3(Color32 color_array[4]) const;
81         void evaluatePalette4(Color32 color_array[4]) const;
82         
83         void decodeBlock(ColorBlock * block) const;
84         
85         void setIndices(int * idx);
86
87         void flip4();
88         void flip2();
89 };
90
91 /// Return true if the block uses four color mode, false otherwise.
92 inline bool BlockDXT1::isFourColorMode() const
93 {
94         return col0.u > col1.u;
95 }
96
97
98 /// DXT3 alpha block with explicit alpha.
99 struct AlphaBlockDXT3
100 {
101         union {
102                 struct {
103                         uint alpha0 : 4;
104                         uint alpha1 : 4;
105                         uint alpha2 : 4;
106                         uint alpha3 : 4;
107                         uint alpha4 : 4;
108                         uint alpha5 : 4;
109                         uint alpha6 : 4;
110                         uint alpha7 : 4;
111                         uint alpha8 : 4;
112                         uint alpha9 : 4;
113                         uint alphaA : 4;
114                         uint alphaB : 4;
115                         uint alphaC : 4;
116                         uint alphaD : 4;
117                         uint alphaE : 4;
118                         uint alphaF : 4;
119                 };
120                 uint16 row[4];
121         };
122         
123         void decodeBlock(ColorBlock * block) const;
124         
125         void flip4();
126         void flip2();
127 };
128
129
130 /// DXT3 block.
131 struct BlockDXT3
132 {
133         AlphaBlockDXT3 alpha;
134         BlockDXT1 color;
135         
136         void decodeBlock(ColorBlock * block) const;
137         
138         void flip4();
139         void flip2();
140 };
141
142
143 /// DXT5 alpha block.
144 struct AlphaBlockDXT5
145 {
146         // uint64 unions do not compile on all platforms
147         /*
148         union {
149                 struct {
150                         uint64 alpha0 : 8;      // 8
151                         uint64 alpha1 : 8;      // 16
152                         uint64 bits0 : 3;               // 3 - 19
153                         uint64 bits1 : 3;       // 6 - 22
154                         uint64 bits2 : 3;       // 9 - 25
155                         uint64 bits3 : 3;               // 12 - 28
156                         uint64 bits4 : 3;               // 15 - 31
157                         uint64 bits5 : 3;               // 18 - 34
158                         uint64 bits6 : 3;               // 21 - 37
159                         uint64 bits7 : 3;               // 24 - 40
160                         uint64 bits8 : 3;               // 27 - 43
161                         uint64 bits9 : 3;       // 30 - 46
162                         uint64 bitsA : 3;       // 33 - 49
163                         uint64 bitsB : 3;               // 36 - 52
164                         uint64 bitsC : 3;               // 39 - 55
165                         uint64 bitsD : 3;               // 42 - 58
166                         uint64 bitsE : 3;               // 45 - 61
167                         uint64 bitsF : 3;               // 48 - 64
168                 };
169                 uint64 u;
170         };
171         */
172         uint64 u;
173         uint8 alpha0() const { return u & 0xffLL; };
174         uint8 alpha1() const { return (u >> 8) & 0xffLL; };
175         uint8 bits0() const { return (u >> 16) & 0x7LL; };
176         uint8 bits1() const { return (u >> 19) & 0x7LL; };
177         uint8 bits2() const { return (u >> 22) & 0x7LL; };
178         uint8 bits3() const { return (u >> 25) & 0x7LL; };
179         uint8 bits4() const { return (u >> 28) & 0x7LL; };
180         uint8 bits5() const { return (u >> 31) & 0x7LL; };
181         uint8 bits6() const { return (u >> 34) & 0x7LL; };
182         uint8 bits7() const { return (u >> 37) & 0x7LL; };
183         uint8 bits8() const { return (u >> 40) & 0x7LL; };
184         uint8 bits9() const { return (u >> 43) & 0x7LL; };
185         uint8 bitsA() const { return (u >> 46) & 0x7LL; };
186         uint8 bitsB() const { return (u >> 49) & 0x7LL; };
187         uint8 bitsC() const { return (u >> 52) & 0x7LL; };
188         uint8 bitsD() const { return (u >> 55) & 0x7LL; };
189         uint8 bitsE() const { return (u >> 58) & 0x7LL; };
190         uint8 bitsF() const { return (u >> 61) & 0x7LL; };
191         
192         void evaluatePalette(uint8 alpha[8]) const;
193         void evaluatePalette8(uint8 alpha[8]) const;
194         void evaluatePalette6(uint8 alpha[8]) const;
195         void indices(uint8 index_array[16]) const;
196
197         uint index(uint index) const;
198         void setIndex(uint index, uint value);
199         
200         void decodeBlock(ColorBlock * block) const;
201         
202         void flip4();
203         void flip2();
204 };
205
206
207 /// DXT5 block.
208 struct BlockDXT5
209 {
210         AlphaBlockDXT5 alpha;
211         BlockDXT1 color;
212         
213         void decodeBlock(ColorBlock * block) const;
214         
215         void flip4();
216         void flip2();
217 };
218
219 /// ATI1 block.
220 struct BlockATI1
221 {
222         AlphaBlockDXT5 alpha;
223         
224         void decodeBlock(ColorBlock * block) const;
225         
226         void flip4();
227         void flip2();
228 };
229
230 /// ATI2 block.
231 struct BlockATI2
232 {
233         AlphaBlockDXT5 x;
234         AlphaBlockDXT5 y;
235         
236         void decodeBlock(ColorBlock * block) const;
237         
238         void flip4();
239         void flip2();
240 };
241
242 /// CTX1 block.
243 struct BlockCTX1
244 {
245         uint8 col0[2];
246         uint8 col1[2];
247         union {
248                 uint8 row[4];
249                 uint indices;
250         };
251
252         void evaluatePalette(Color32 color_array[4]) const;
253         void setIndices(int * idx);
254
255         void decodeBlock(ColorBlock * block) const;
256         
257         void flip4();
258         void flip2();
259 };
260
261 void mem_read(Stream & mem, BlockDXT1 & block);
262 void mem_read(Stream & mem, AlphaBlockDXT3 & block);
263 void mem_read(Stream & mem, BlockDXT3 & block);
264 void mem_read(Stream & mem, AlphaBlockDXT5 & block);
265 void mem_read(Stream & mem, BlockDXT5 & block);
266 void mem_read(Stream & mem, BlockATI1 & block);
267 void mem_read(Stream & mem, BlockATI2 & block);
268 void mem_read(Stream & mem, BlockCTX1 & block);
269
270 #endif // _DDS_BLOCKDXT_H