Apply second half of [#21590] .dds textures: fix for DXT1n format + sync with upstrea...
[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@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 evaluatePaletteNV5x(Color32 color_array[4]) const;
82
83         void evaluatePalette3(Color32 color_array[4]) const;
84         void evaluatePalette4(Color32 color_array[4]) const;
85         
86         void decodeBlock(ColorBlock * block) const;
87         void decodeBlockNV5x(ColorBlock * block) const;
88         
89         void setIndices(int * idx);
90
91         void flip4();
92         void flip2();
93 };
94
95 /// Return true if the block uses four color mode, false otherwise.
96 inline bool BlockDXT1::isFourColorMode() const
97 {
98         return col0.u > col1.u;
99 }
100
101
102 /// DXT3 alpha block with explicit alpha.
103 struct AlphaBlockDXT3
104 {
105         union {
106                 struct {
107                         uint alpha0 : 4;
108                         uint alpha1 : 4;
109                         uint alpha2 : 4;
110                         uint alpha3 : 4;
111                         uint alpha4 : 4;
112                         uint alpha5 : 4;
113                         uint alpha6 : 4;
114                         uint alpha7 : 4;
115                         uint alpha8 : 4;
116                         uint alpha9 : 4;
117                         uint alphaA : 4;
118                         uint alphaB : 4;
119                         uint alphaC : 4;
120                         uint alphaD : 4;
121                         uint alphaE : 4;
122                         uint alphaF : 4;
123                 };
124                 uint16 row[4];
125         };
126         
127         void decodeBlock(ColorBlock * block) const;
128         
129         void flip4();
130         void flip2();
131 };
132
133
134 /// DXT3 block.
135 struct BlockDXT3
136 {
137         AlphaBlockDXT3 alpha;
138         BlockDXT1 color;
139         
140         void decodeBlock(ColorBlock * block) const;
141         void decodeBlockNV5x(ColorBlock * block) const;
142         
143         void flip4();
144         void flip2();
145 };
146
147
148 /// DXT5 alpha block.
149 struct AlphaBlockDXT5
150 {
151         // uint64 unions do not compile on all platforms
152         /*
153         union {
154                 struct {
155                         uint64 alpha0 : 8;      // 8
156                         uint64 alpha1 : 8;      // 16
157                         uint64 bits0 : 3;               // 3 - 19
158                         uint64 bits1 : 3;       // 6 - 22
159                         uint64 bits2 : 3;       // 9 - 25
160                         uint64 bits3 : 3;               // 12 - 28
161                         uint64 bits4 : 3;               // 15 - 31
162                         uint64 bits5 : 3;               // 18 - 34
163                         uint64 bits6 : 3;               // 21 - 37
164                         uint64 bits7 : 3;               // 24 - 40
165                         uint64 bits8 : 3;               // 27 - 43
166                         uint64 bits9 : 3;       // 30 - 46
167                         uint64 bitsA : 3;       // 33 - 49
168                         uint64 bitsB : 3;               // 36 - 52
169                         uint64 bitsC : 3;               // 39 - 55
170                         uint64 bitsD : 3;               // 42 - 58
171                         uint64 bitsE : 3;               // 45 - 61
172                         uint64 bitsF : 3;               // 48 - 64
173                 };
174                 uint64 u;
175         };
176         */
177         uint64 u;
178         uint8 alpha0() const { return u & 0xffLL; };
179         uint8 alpha1() const { return (u >> 8) & 0xffLL; };
180         uint8 bits0() const { return (u >> 16) & 0x7LL; };
181         uint8 bits1() const { return (u >> 19) & 0x7LL; };
182         uint8 bits2() const { return (u >> 22) & 0x7LL; };
183         uint8 bits3() const { return (u >> 25) & 0x7LL; };
184         uint8 bits4() const { return (u >> 28) & 0x7LL; };
185         uint8 bits5() const { return (u >> 31) & 0x7LL; };
186         uint8 bits6() const { return (u >> 34) & 0x7LL; };
187         uint8 bits7() const { return (u >> 37) & 0x7LL; };
188         uint8 bits8() const { return (u >> 40) & 0x7LL; };
189         uint8 bits9() const { return (u >> 43) & 0x7LL; };
190         uint8 bitsA() const { return (u >> 46) & 0x7LL; };
191         uint8 bitsB() const { return (u >> 49) & 0x7LL; };
192         uint8 bitsC() const { return (u >> 52) & 0x7LL; };
193         uint8 bitsD() const { return (u >> 55) & 0x7LL; };
194         uint8 bitsE() const { return (u >> 58) & 0x7LL; };
195         uint8 bitsF() const { return (u >> 61) & 0x7LL; };
196         
197         void evaluatePalette(uint8 alpha[8]) const;
198         void evaluatePalette8(uint8 alpha[8]) const;
199         void evaluatePalette6(uint8 alpha[8]) const;
200         void indices(uint8 index_array[16]) const;
201
202         uint index(uint index) const;
203         void setIndex(uint index, uint value);
204         
205         void decodeBlock(ColorBlock * block) const;
206         
207         void flip4();
208         void flip2();
209 };
210
211
212 /// DXT5 block.
213 struct BlockDXT5
214 {
215         AlphaBlockDXT5 alpha;
216         BlockDXT1 color;
217         
218         void decodeBlock(ColorBlock * block) const;
219         void decodeBlockNV5x(ColorBlock * block) const;
220         
221         void flip4();
222         void flip2();
223 };
224
225 /// ATI1 block.
226 struct BlockATI1
227 {
228         AlphaBlockDXT5 alpha;
229         
230         void decodeBlock(ColorBlock * block) const;
231         
232         void flip4();
233         void flip2();
234 };
235
236 /// ATI2 block.
237 struct BlockATI2
238 {
239         AlphaBlockDXT5 x;
240         AlphaBlockDXT5 y;
241         
242         void decodeBlock(ColorBlock * block) const;
243         
244         void flip4();
245         void flip2();
246 };
247
248 /// CTX1 block.
249 struct BlockCTX1
250 {
251         uint8 col0[2];
252         uint8 col1[2];
253         union {
254                 uint8 row[4];
255                 uint indices;
256         };
257
258         void evaluatePalette(Color32 color_array[4]) const;
259         void setIndices(int * idx);
260
261         void decodeBlock(ColorBlock * block) const;
262         
263         void flip4();
264         void flip2();
265 };
266
267 void mem_read(Stream & mem, BlockDXT1 & block);
268 void mem_read(Stream & mem, AlphaBlockDXT3 & block);
269 void mem_read(Stream & mem, BlockDXT3 & block);
270 void mem_read(Stream & mem, AlphaBlockDXT5 & block);
271 void mem_read(Stream & mem, BlockDXT5 & block);
272 void mem_read(Stream & mem, BlockATI1 & block);
273 void mem_read(Stream & mem, BlockATI2 & block);
274 void mem_read(Stream & mem, BlockCTX1 & block);
275
276 #endif // _DDS_BLOCKDXT_H