style cleanup
[blender.git] / source / blender / imbuf / intern / dds / BlockDXT.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributors: Amorilia (amorilia@users.sourceforge.net)
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/imbuf/intern/dds/BlockDXT.h
24  *  \ingroup imbdds
25  */
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 __BLOCKDXT_H__
59 #define __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 evaluatePaletteNV5x(Color32 color_array[4]) const;
80
81         void evaluatePalette3(Color32 color_array[4]) const;
82         void evaluatePalette4(Color32 color_array[4]) const;
83         
84         void decodeBlock(ColorBlock * block) const;
85         void decodeBlockNV5x(ColorBlock * block) const;
86         
87         void setIndices(int * idx);
88
89         void flip4();
90         void flip2();
91 };
92
93 /// Return true if the block uses four color mode, false otherwise.
94 inline bool BlockDXT1::isFourColorMode() const
95 {
96         return col0.u > col1.u;
97 }
98
99
100 /// DXT3 alpha block with explicit alpha.
101 struct AlphaBlockDXT3
102 {
103         union {
104                 struct {
105                         uint alpha0 : 4;
106                         uint alpha1 : 4;
107                         uint alpha2 : 4;
108                         uint alpha3 : 4;
109                         uint alpha4 : 4;
110                         uint alpha5 : 4;
111                         uint alpha6 : 4;
112                         uint alpha7 : 4;
113                         uint alpha8 : 4;
114                         uint alpha9 : 4;
115                         uint alphaA : 4;
116                         uint alphaB : 4;
117                         uint alphaC : 4;
118                         uint alphaD : 4;
119                         uint alphaE : 4;
120                         uint alphaF : 4;
121                 };
122                 uint16 row[4];
123         };
124         
125         void decodeBlock(ColorBlock * block) const;
126         
127         void flip4();
128         void flip2();
129 };
130
131
132 /// DXT3 block.
133 struct BlockDXT3
134 {
135         AlphaBlockDXT3 alpha;
136         BlockDXT1 color;
137         
138         void decodeBlock(ColorBlock * block) const;
139         void decodeBlockNV5x(ColorBlock * block) const;
140         
141         void flip4();
142         void flip2();
143 };
144
145
146 /// DXT5 alpha block.
147 struct AlphaBlockDXT5
148 {
149         // uint64 unions do not compile on all platforms
150         /*
151         union {
152                 struct {
153                         uint64 alpha0 : 8;      // 8
154                         uint64 alpha1 : 8;      // 16
155                         uint64 bits0 : 3;               // 3 - 19
156                         uint64 bits1 : 3;       // 6 - 22
157                         uint64 bits2 : 3;       // 9 - 25
158                         uint64 bits3 : 3;               // 12 - 28
159                         uint64 bits4 : 3;               // 15 - 31
160                         uint64 bits5 : 3;               // 18 - 34
161                         uint64 bits6 : 3;               // 21 - 37
162                         uint64 bits7 : 3;               // 24 - 40
163                         uint64 bits8 : 3;               // 27 - 43
164                         uint64 bits9 : 3;       // 30 - 46
165                         uint64 bitsA : 3;       // 33 - 49
166                         uint64 bitsB : 3;               // 36 - 52
167                         uint64 bitsC : 3;               // 39 - 55
168                         uint64 bitsD : 3;               // 42 - 58
169                         uint64 bitsE : 3;               // 45 - 61
170                         uint64 bitsF : 3;               // 48 - 64
171                 };
172                 uint64 u;
173         };
174         */
175         uint64 u;
176         uint8 alpha0() const { return u & 0xffLL; };
177         uint8 alpha1() const { return (u >> 8) & 0xffLL; };
178         uint8 bits0() const { return (u >> 16) & 0x7LL; };
179         uint8 bits1() const { return (u >> 19) & 0x7LL; };
180         uint8 bits2() const { return (u >> 22) & 0x7LL; };
181         uint8 bits3() const { return (u >> 25) & 0x7LL; };
182         uint8 bits4() const { return (u >> 28) & 0x7LL; };
183         uint8 bits5() const { return (u >> 31) & 0x7LL; };
184         uint8 bits6() const { return (u >> 34) & 0x7LL; };
185         uint8 bits7() const { return (u >> 37) & 0x7LL; };
186         uint8 bits8() const { return (u >> 40) & 0x7LL; };
187         uint8 bits9() const { return (u >> 43) & 0x7LL; };
188         uint8 bitsA() const { return (u >> 46) & 0x7LL; };
189         uint8 bitsB() const { return (u >> 49) & 0x7LL; };
190         uint8 bitsC() const { return (u >> 52) & 0x7LL; };
191         uint8 bitsD() const { return (u >> 55) & 0x7LL; };
192         uint8 bitsE() const { return (u >> 58) & 0x7LL; };
193         uint8 bitsF() const { return (u >> 61) & 0x7LL; };
194         
195         void evaluatePalette(uint8 alpha[8]) const;
196         void evaluatePalette8(uint8 alpha[8]) const;
197         void evaluatePalette6(uint8 alpha[8]) const;
198         void indices(uint8 index_array[16]) const;
199
200         uint index(uint index) const;
201         void setIndex(uint index, uint value);
202         
203         void decodeBlock(ColorBlock * block) const;
204         
205         void flip4();
206         void flip2();
207 };
208
209
210 /// DXT5 block.
211 struct BlockDXT5
212 {
213         AlphaBlockDXT5 alpha;
214         BlockDXT1 color;
215         
216         void decodeBlock(ColorBlock * block) const;
217         void decodeBlockNV5x(ColorBlock * block) const;
218         
219         void flip4();
220         void flip2();
221 };
222
223 /// ATI1 block.
224 struct BlockATI1
225 {
226         AlphaBlockDXT5 alpha;
227         
228         void decodeBlock(ColorBlock * block) const;
229         
230         void flip4();
231         void flip2();
232 };
233
234 /// ATI2 block.
235 struct BlockATI2
236 {
237         AlphaBlockDXT5 x;
238         AlphaBlockDXT5 y;
239         
240         void decodeBlock(ColorBlock * block) const;
241         
242         void flip4();
243         void flip2();
244 };
245
246 /// CTX1 block.
247 struct BlockCTX1
248 {
249         uint8 col0[2];
250         uint8 col1[2];
251         union {
252                 uint8 row[4];
253                 uint indices;
254         };
255
256         void evaluatePalette(Color32 color_array[4]) const;
257         void setIndices(int * idx);
258
259         void decodeBlock(ColorBlock * block) const;
260         
261         void flip4();
262         void flip2();
263 };
264
265 void mem_read(Stream & mem, BlockDXT1 & block);
266 void mem_read(Stream & mem, AlphaBlockDXT3 & block);
267 void mem_read(Stream & mem, BlockDXT3 & block);
268 void mem_read(Stream & mem, AlphaBlockDXT5 & block);
269 void mem_read(Stream & mem, BlockDXT5 & block);
270 void mem_read(Stream & mem, BlockATI1 & block);
271 void mem_read(Stream & mem, BlockATI2 & block);
272 void mem_read(Stream & mem, BlockCTX1 & block);
273
274 #endif  /* __BLOCKDXT_H__ */