6e9e555d96344bcf48113dc6f9d30428e10a1397
[blender-staging.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@users.sourceforge.net)
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 /** \file blender/imbuf/intern/dds/BlockDXT.h
26  *  \ingroup imbdds
27  */
28
29
30 /*
31  * This file is based on a similar file from the NVIDIA texture tools
32  * (http://nvidia-texture-tools.googlecode.com/)
33  *
34  * Original license from NVIDIA follows.
35  */
36
37 // Copyright NVIDIA Corporation 2007 -- Ignacio Castano <icastano@nvidia.com>
38 // 
39 // Permission is hereby granted, free of charge, to any person
40 // obtaining a copy of this software and associated documentation
41 // files (the "Software"), to deal in the Software without
42 // restriction, including without limitation the rights to use,
43 // copy, modify, merge, publish, distribute, sublicense, and/or sell
44 // copies of the Software, and to permit persons to whom the
45 // Software is furnished to do so, subject to the following
46 // conditions:
47 // 
48 // The above copyright notice and this permission notice shall be
49 // included in all copies or substantial portions of the Software.
50 // 
51 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
52 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
53 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
54 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
55 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
56 // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
57 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
58 // OTHER DEALINGS IN THE SOFTWARE.
59
60 #ifndef _DDS_BLOCKDXT_H
61 #define _DDS_BLOCKDXT_H
62
63 #include <Common.h>
64 #include <Color.h>
65 #include <ColorBlock.h>
66 #include <Stream.h>
67
68 /// DXT1 block.
69 struct BlockDXT1
70 {
71         Color16 col0;
72         Color16 col1;
73         union {
74                 uint8 row[4];
75                 uint indices;
76         };
77
78         bool isFourColorMode() const;
79
80         uint evaluatePalette(Color32 color_array[4]) const;
81         uint evaluatePaletteFast(Color32 color_array[4]) const;
82         void evaluatePalette3(Color32 color_array[4]) const;
83         void evaluatePalette4(Color32 color_array[4]) const;
84         
85         void decodeBlock(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         
140         void flip4();
141         void flip2();
142 };
143
144
145 /// DXT5 alpha block.
146 struct AlphaBlockDXT5
147 {
148         // uint64 unions do not compile on all platforms
149         /*
150         union {
151                 struct {
152                         uint64 alpha0 : 8;      // 8
153                         uint64 alpha1 : 8;      // 16
154                         uint64 bits0 : 3;               // 3 - 19
155                         uint64 bits1 : 3;       // 6 - 22
156                         uint64 bits2 : 3;       // 9 - 25
157                         uint64 bits3 : 3;               // 12 - 28
158                         uint64 bits4 : 3;               // 15 - 31
159                         uint64 bits5 : 3;               // 18 - 34
160                         uint64 bits6 : 3;               // 21 - 37
161                         uint64 bits7 : 3;               // 24 - 40
162                         uint64 bits8 : 3;               // 27 - 43
163                         uint64 bits9 : 3;       // 30 - 46
164                         uint64 bitsA : 3;       // 33 - 49
165                         uint64 bitsB : 3;               // 36 - 52
166                         uint64 bitsC : 3;               // 39 - 55
167                         uint64 bitsD : 3;               // 42 - 58
168                         uint64 bitsE : 3;               // 45 - 61
169                         uint64 bitsF : 3;               // 48 - 64
170                 };
171                 uint64 u;
172         };
173         */
174         uint64 u;
175         uint8 alpha0() const { return u & 0xffLL; };
176         uint8 alpha1() const { return (u >> 8) & 0xffLL; };
177         uint8 bits0() const { return (u >> 16) & 0x7LL; };
178         uint8 bits1() const { return (u >> 19) & 0x7LL; };
179         uint8 bits2() const { return (u >> 22) & 0x7LL; };
180         uint8 bits3() const { return (u >> 25) & 0x7LL; };
181         uint8 bits4() const { return (u >> 28) & 0x7LL; };
182         uint8 bits5() const { return (u >> 31) & 0x7LL; };
183         uint8 bits6() const { return (u >> 34) & 0x7LL; };
184         uint8 bits7() const { return (u >> 37) & 0x7LL; };
185         uint8 bits8() const { return (u >> 40) & 0x7LL; };
186         uint8 bits9() const { return (u >> 43) & 0x7LL; };
187         uint8 bitsA() const { return (u >> 46) & 0x7LL; };
188         uint8 bitsB() const { return (u >> 49) & 0x7LL; };
189         uint8 bitsC() const { return (u >> 52) & 0x7LL; };
190         uint8 bitsD() const { return (u >> 55) & 0x7LL; };
191         uint8 bitsE() const { return (u >> 58) & 0x7LL; };
192         uint8 bitsF() const { return (u >> 61) & 0x7LL; };
193         
194         void evaluatePalette(uint8 alpha[8]) const;
195         void evaluatePalette8(uint8 alpha[8]) const;
196         void evaluatePalette6(uint8 alpha[8]) const;
197         void indices(uint8 index_array[16]) const;
198
199         uint index(uint index) const;
200         void setIndex(uint index, uint value);
201         
202         void decodeBlock(ColorBlock * block) const;
203         
204         void flip4();
205         void flip2();
206 };
207
208
209 /// DXT5 block.
210 struct BlockDXT5
211 {
212         AlphaBlockDXT5 alpha;
213         BlockDXT1 color;
214         
215         void decodeBlock(ColorBlock * block) const;
216         
217         void flip4();
218         void flip2();
219 };
220
221 /// ATI1 block.
222 struct BlockATI1
223 {
224         AlphaBlockDXT5 alpha;
225         
226         void decodeBlock(ColorBlock * block) const;
227         
228         void flip4();
229         void flip2();
230 };
231
232 /// ATI2 block.
233 struct BlockATI2
234 {
235         AlphaBlockDXT5 x;
236         AlphaBlockDXT5 y;
237         
238         void decodeBlock(ColorBlock * block) const;
239         
240         void flip4();
241         void flip2();
242 };
243
244 /// CTX1 block.
245 struct BlockCTX1
246 {
247         uint8 col0[2];
248         uint8 col1[2];
249         union {
250                 uint8 row[4];
251                 uint indices;
252         };
253
254         void evaluatePalette(Color32 color_array[4]) const;
255         void setIndices(int * idx);
256
257         void decodeBlock(ColorBlock * block) const;
258         
259         void flip4();
260         void flip2();
261 };
262
263 void mem_read(Stream & mem, BlockDXT1 & block);
264 void mem_read(Stream & mem, AlphaBlockDXT3 & block);
265 void mem_read(Stream & mem, BlockDXT3 & block);
266 void mem_read(Stream & mem, AlphaBlockDXT5 & block);
267 void mem_read(Stream & mem, BlockDXT5 & block);
268 void mem_read(Stream & mem, BlockATI1 & block);
269 void mem_read(Stream & mem, BlockATI2 & block);
270 void mem_read(Stream & mem, BlockCTX1 & block);
271
272 #endif // _DDS_BLOCKDXT_H