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