Blender  V3.3
BlockDXT.cpp
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 
7 /*
8  * This file is based on a similar file from the NVIDIA texture tools
9  * (http://nvidia-texture-tools.googlecode.com/)
10  *
11  * Original license from NVIDIA follows.
12  */
13 
14 /* Copyright NVIDIA Corporation 2007 -- Ignacio Castano <icastano@nvidia.com>
15  *
16  * Permission is hereby granted, free of charge, to any person
17  * obtaining a copy of this software and associated documentation
18  * files (the "Software"), to deal in the Software without
19  * restriction, including without limitation the rights to use,
20  * copy, modify, merge, publish, distribute, sublicense, and/or sell
21  * copies of the Software, and to permit persons to whom the
22  * Software is furnished to do so, subject to the following
23  * conditions:
24  *
25  * The above copyright notice and this permission notice shall be
26  * included in all copies or substantial portions of the Software.
27  *
28  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
29  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
30  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
31  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
32  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
33  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
34  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
35  * OTHER DEALINGS IN THE SOFTWARE. */
36 
37 #include <BlockDXT.h>
38 #include <ColorBlock.h>
39 #include <Common.h>
40 #include <Stream.h>
41 
42 /* ---------------------------------------------------------------------------
43  * BlockDXT1
44  * --------------------------------------------------------------------------*/
45 
47 {
48  /* Does bit expansion before interpolation. */
49  color_array[0].b = (col0.b << 3) | (col0.b >> 2);
50  color_array[0].g = (col0.g << 2) | (col0.g >> 4);
51  color_array[0].r = (col0.r << 3) | (col0.r >> 2);
52  color_array[0].a = 0xFF;
53 
54  /* @@ Same as above, but faster?
55  * Color32 c;
56  * c.u = ((col0.u << 3) & 0xf8) | ((col0.u << 5) & 0xfc00) | ((col0.u << 8) & 0xf80000);
57  * c.u |= (c.u >> 5) & 0x070007;
58  * c.u |= (c.u >> 6) & 0x000300;
59  * color_array[0].u = c.u; */
60 
61  color_array[1].r = (col1.r << 3) | (col1.r >> 2);
62  color_array[1].g = (col1.g << 2) | (col1.g >> 4);
63  color_array[1].b = (col1.b << 3) | (col1.b >> 2);
64  color_array[1].a = 0xFF;
65 
66  /* @@ Same as above, but faster?
67  * c.u = ((col1.u << 3) & 0xf8) | ((col1.u << 5) & 0xfc00) | ((col1.u << 8) & 0xf80000);
68  * c.u |= (c.u >> 5) & 0x070007;
69  * c.u |= (c.u >> 6) & 0x000300;
70  * color_array[1].u = c.u; */
71 
72  if (col0.u > col1.u) {
73  /* Four-color block: derive the other two colors. */
74  color_array[2].r = (2 * color_array[0].r + color_array[1].r) / 3;
75  color_array[2].g = (2 * color_array[0].g + color_array[1].g) / 3;
76  color_array[2].b = (2 * color_array[0].b + color_array[1].b) / 3;
77  color_array[2].a = 0xFF;
78 
79  color_array[3].r = (2 * color_array[1].r + color_array[0].r) / 3;
80  color_array[3].g = (2 * color_array[1].g + color_array[0].g) / 3;
81  color_array[3].b = (2 * color_array[1].b + color_array[0].b) / 3;
82  color_array[3].a = 0xFF;
83 
84  return 4;
85  }
86 
87  /* Three-color block: derive the other color. */
88  color_array[2].r = (color_array[0].r + color_array[1].r) / 2;
89  color_array[2].g = (color_array[0].g + color_array[1].g) / 2;
90  color_array[2].b = (color_array[0].b + color_array[1].b) / 2;
91  color_array[2].a = 0xFF;
92 
93  /* Set all components to 0 to match DXT specs. */
94  color_array[3].r = 0x00; /* color_array[2].r; */
95  color_array[3].g = 0x00; /* color_array[2].g; */
96  color_array[3].b = 0x00; /* color_array[2].b; */
97  color_array[3].a = 0x00;
98 
99  return 3;
100 }
101 
103 {
104  /* Does bit expansion before interpolation. */
105  color_array[0].b = (3 * col0.b * 22) / 8;
106  color_array[0].g = (col0.g << 2) | (col0.g >> 4);
107  color_array[0].r = (3 * col0.r * 22) / 8;
108  color_array[0].a = 0xFF;
109 
110  color_array[1].r = (3 * col1.r * 22) / 8;
111  color_array[1].g = (col1.g << 2) | (col1.g >> 4);
112  color_array[1].b = (3 * col1.b * 22) / 8;
113  color_array[1].a = 0xFF;
114 
115  int gdiff = color_array[1].g - color_array[0].g;
116 
117  if (col0.u > col1.u) {
118  /* Four-color block: derive the other two colors. */
119  color_array[2].r = ((2 * col0.r + col1.r) * 22) / 8;
120  color_array[2].g = (256 * color_array[0].g + gdiff / 4 + 128 + gdiff * 80) / 256;
121  color_array[2].b = ((2 * col0.b + col1.b) * 22) / 8;
122  color_array[2].a = 0xFF;
123 
124  color_array[3].r = ((2 * col1.r + col0.r) * 22) / 8;
125  color_array[3].g = (256 * color_array[1].g - gdiff / 4 + 128 - gdiff * 80) / 256;
126  color_array[3].b = ((2 * col1.b + col0.b) * 22) / 8;
127  color_array[3].a = 0xFF;
128 
129  return 4;
130  }
131 
132  /* Three-color block: derive the other color. */
133  color_array[2].r = ((col0.r + col1.r) * 33) / 8;
134  color_array[2].g = (256 * color_array[0].g + gdiff / 4 + 128 + gdiff * 128) / 256;
135  color_array[2].b = ((col0.b + col1.b) * 33) / 8;
136  color_array[2].a = 0xFF;
137 
138  /* Set all components to 0 to match DXT specs. */
139  color_array[3].r = 0x00; /* color_array[2].r; */
140  color_array[3].g = 0x00; /* color_array[2].g; */
141  color_array[3].b = 0x00; /* color_array[2].b; */
142  color_array[3].a = 0x00;
143 
144  return 3;
145 }
146 
147 void BlockDXT1::evaluatePalette3(Color32 color_array[4]) const
148 {
149  color_array[0].b = (col0.b << 3) | (col0.b >> 2);
150  color_array[0].g = (col0.g << 2) | (col0.g >> 4);
151  color_array[0].r = (col0.r << 3) | (col0.r >> 2);
152  color_array[0].a = 0xFF;
153 
154  color_array[1].r = (col1.r << 3) | (col1.r >> 2);
155  color_array[1].g = (col1.g << 2) | (col1.g >> 4);
156  color_array[1].b = (col1.b << 3) | (col1.b >> 2);
157  color_array[1].a = 0xFF;
158 
159  /* Three-color block: derive the other color. */
160  color_array[2].r = (color_array[0].r + color_array[1].r) / 2;
161  color_array[2].g = (color_array[0].g + color_array[1].g) / 2;
162  color_array[2].b = (color_array[0].b + color_array[1].b) / 2;
163  color_array[2].a = 0xFF;
164 
165  /* Set all components to 0 to match DXT specs. */
166  color_array[3].r = 0x00; /* color_array[2].r; */
167  color_array[3].g = 0x00; /* color_array[2].g; */
168  color_array[3].b = 0x00; /* color_array[2].b; */
169  color_array[3].a = 0x00;
170 }
171 
172 void BlockDXT1::evaluatePalette4(Color32 color_array[4]) const
173 {
174  color_array[0].b = (col0.b << 3) | (col0.b >> 2);
175  color_array[0].g = (col0.g << 2) | (col0.g >> 4);
176  color_array[0].r = (col0.r << 3) | (col0.r >> 2);
177  color_array[0].a = 0xFF;
178 
179  color_array[1].r = (col1.r << 3) | (col1.r >> 2);
180  color_array[1].g = (col1.g << 2) | (col1.g >> 4);
181  color_array[1].b = (col1.b << 3) | (col1.b >> 2);
182  color_array[1].a = 0xFF;
183 
184  /* Four-color block: derive the other two colors. */
185  color_array[2].r = (2 * color_array[0].r + color_array[1].r) / 3;
186  color_array[2].g = (2 * color_array[0].g + color_array[1].g) / 3;
187  color_array[2].b = (2 * color_array[0].b + color_array[1].b) / 3;
188  color_array[2].a = 0xFF;
189 
190  color_array[3].r = (2 * color_array[1].r + color_array[0].r) / 3;
191  color_array[3].g = (2 * color_array[1].g + color_array[0].g) / 3;
192  color_array[3].b = (2 * color_array[1].b + color_array[0].b) / 3;
193  color_array[3].a = 0xFF;
194 }
195 
197 {
198  /* Decode color block. */
199  Color32 color_array[4];
200  evaluatePalette(color_array);
201 
202  /* Write color block. */
203  for (uint j = 0; j < 4; j++) {
204  for (uint i = 0; i < 4; i++) {
205  uint idx = (row[j] >> (2 * i)) & 3;
206  block->color(i, j) = color_array[idx];
207  }
208  }
209 }
210 
212 {
213  /* Decode color block. */
214  Color32 color_array[4];
215  evaluatePaletteNV5x(color_array);
216 
217  /* Write color block. */
218  for (uint j = 0; j < 4; j++) {
219  for (uint i = 0; i < 4; i++) {
220  uint idx = (row[j] >> (2 * i)) & 3;
221  block->color(i, j) = color_array[idx];
222  }
223  }
224 }
225 
226 void BlockDXT1::setIndices(const int *idx)
227 {
228  indices = 0;
229  for (uint i = 0; i < 16; i++) {
230  indices |= (idx[i] & 3) << (2 * i);
231  }
232 }
233 
234 inline void BlockDXT1::flip4()
235 {
236  swap(row[0], row[3]);
237  swap(row[1], row[2]);
238 }
239 
240 inline void BlockDXT1::flip2()
241 {
242  swap(row[0], row[1]);
243 }
244 
245 /* ---------------------------------------------------------------------------
246  * BlockDXT3
247  * ---------------------------------------------------------------------------*/
248 
250 {
251  /* Decode color. */
252  color.decodeBlock(block);
253 
254  /* Decode alpha. */
255  alpha.decodeBlock(block);
256 }
257 
259 {
260  color.decodeBlockNV5x(block);
261  alpha.decodeBlock(block);
262 }
263 
265 {
266  block->color(0x0).a = (alpha0 << 4) | alpha0;
267  block->color(0x1).a = (alpha1 << 4) | alpha1;
268  block->color(0x2).a = (alpha2 << 4) | alpha2;
269  block->color(0x3).a = (alpha3 << 4) | alpha3;
270  block->color(0x4).a = (alpha4 << 4) | alpha4;
271  block->color(0x5).a = (alpha5 << 4) | alpha5;
272  block->color(0x6).a = (alpha6 << 4) | alpha6;
273  block->color(0x7).a = (alpha7 << 4) | alpha7;
274  block->color(0x8).a = (alpha8 << 4) | alpha8;
275  block->color(0x9).a = (alpha9 << 4) | alpha9;
276  block->color(0xA).a = (alphaA << 4) | alphaA;
277  block->color(0xB).a = (alphaB << 4) | alphaB;
278  block->color(0xC).a = (alphaC << 4) | alphaC;
279  block->color(0xD).a = (alphaD << 4) | alphaD;
280  block->color(0xE).a = (alphaE << 4) | alphaE;
281  block->color(0xF).a = (alphaF << 4) | alphaF;
282 }
283 
285 {
286  swap(row[0], row[3]);
287  swap(row[1], row[2]);
288 }
289 
291 {
292  swap(row[0], row[1]);
293 }
294 
296 {
297  alpha.flip4();
298  color.flip4();
299 }
300 
302 {
303  alpha.flip2();
304  color.flip2();
305 }
306 
307 /* ---------------------------------------------------------------------------
308  * BlockDXT5
309  * ---------------------------------------------------------------------------*/
310 
312 {
313  if (alpha0() > alpha1()) {
314  evaluatePalette8(alpha);
315  }
316  else {
317  evaluatePalette6(alpha);
318  }
319 }
320 
322 {
323  /* 8-alpha block: derive the other six alphas.
324  * Bit code 000 = alpha0, 001 = alpha1, others are interpolated. */
325  alpha[0] = alpha0();
326  alpha[1] = alpha1();
327  alpha[2] = (6 * alpha[0] + 1 * alpha[1]) / 7; /* bit code 010 */
328  alpha[3] = (5 * alpha[0] + 2 * alpha[1]) / 7; /* bit code 011 */
329  alpha[4] = (4 * alpha[0] + 3 * alpha[1]) / 7; /* bit code 100 */
330  alpha[5] = (3 * alpha[0] + 4 * alpha[1]) / 7; /* bit code 101 */
331  alpha[6] = (2 * alpha[0] + 5 * alpha[1]) / 7; /* bit code 110 */
332  alpha[7] = (1 * alpha[0] + 6 * alpha[1]) / 7; /* bit code 111 */
333 }
334 
336 {
337  /* 6-alpha block.
338  * Bit code 000 = alpha0, 001 = alpha1, others are interpolated. */
339  alpha[0] = alpha0();
340  alpha[1] = alpha1();
341  alpha[2] = (4 * alpha[0] + 1 * alpha[1]) / 5; /* Bit code 010 */
342  alpha[3] = (3 * alpha[0] + 2 * alpha[1]) / 5; /* Bit code 011 */
343  alpha[4] = (2 * alpha[0] + 3 * alpha[1]) / 5; /* Bit code 100 */
344  alpha[5] = (1 * alpha[0] + 4 * alpha[1]) / 5; /* Bit code 101 */
345  alpha[6] = 0x00; /* Bit code 110 */
346  alpha[7] = 0xFF; /* Bit code 111 */
347 }
348 
349 void AlphaBlockDXT5::indices(uint8 index_array[16]) const
350 {
351  index_array[0x0] = bits0();
352  index_array[0x1] = bits1();
353  index_array[0x2] = bits2();
354  index_array[0x3] = bits3();
355  index_array[0x4] = bits4();
356  index_array[0x5] = bits5();
357  index_array[0x6] = bits6();
358  index_array[0x7] = bits7();
359  index_array[0x8] = bits8();
360  index_array[0x9] = bits9();
361  index_array[0xA] = bitsA();
362  index_array[0xB] = bitsB();
363  index_array[0xC] = bitsC();
364  index_array[0xD] = bitsD();
365  index_array[0xE] = bitsE();
366  index_array[0xF] = bitsF();
367 }
368 
370 {
371  int offset = (3 * index + 16);
372  return uint((this->u >> offset) & 0x7);
373 }
374 
376 {
377  int offset = (3 * index + 16);
378  uint64 mask = uint64(0x7) << offset;
379  this->u = (this->u & ~mask) | (uint64(value) << offset);
380 }
381 
383 {
384  uint8 alpha_array[8];
385  evaluatePalette(alpha_array);
386 
387  uint8 index_array[16];
388  indices(index_array);
389 
390  for (uint i = 0; i < 16; i++) {
391  block->color(i).a = alpha_array[index_array[i]];
392  }
393 }
394 
396 {
397  uint64 *b = (uint64 *)this;
398 
399  /* @@ The masks might have to be byte swapped. */
400  uint64 tmp = (*b & (uint64)(0x000000000000FFFFLL));
401  tmp |= (*b & (uint64)(0x000000000FFF0000LL)) << 36;
402  tmp |= (*b & (uint64)(0x000000FFF0000000LL)) << 12;
403  tmp |= (*b & (uint64)(0x000FFF0000000000LL)) >> 12;
404  tmp |= (*b & (uint64)(0xFFF0000000000000LL)) >> 36;
405 
406  *b = tmp;
407 }
408 
410 {
411  uint *b = (uint *)this;
412 
413  /* @@ The masks might have to be byte swapped. */
414  uint tmp = (*b & 0xFF000000);
415  tmp |= (*b & 0x00000FFF) << 12;
416  tmp |= (*b & 0x00FFF000) >> 12;
417 
418  *b = tmp;
419 }
420 
422 {
423  /* Decode color. */
424  color.decodeBlock(block);
425 
426  /* Decode alpha. */
427  alpha.decodeBlock(block);
428 }
429 
431 {
432  /* Decode color. */
433  color.decodeBlockNV5x(block);
434 
435  /* Decode alpha. */
436  alpha.decodeBlock(block);
437 }
438 
440 {
441  alpha.flip4();
442  color.flip4();
443 }
444 
446 {
447  alpha.flip2();
448  color.flip2();
449 }
450 
452 {
453  uint8 alpha_array[8];
454  alpha.evaluatePalette(alpha_array);
455 
456  uint8 index_array[16];
457  alpha.indices(index_array);
458 
459  for (uint i = 0; i < 16; i++) {
460  Color32 &c = block->color(i);
461  c.b = c.g = c.r = alpha_array[index_array[i]];
462  c.a = 255;
463  }
464 }
465 
467 {
468  alpha.flip4();
469 }
470 
472 {
473  alpha.flip2();
474 }
475 
477 {
478  uint8 alpha_array[8];
479  uint8 index_array[16];
480 
481  x.evaluatePalette(alpha_array);
482  x.indices(index_array);
483 
484  for (uint i = 0; i < 16; i++) {
485  Color32 &c = block->color(i);
486  c.r = alpha_array[index_array[i]];
487  }
488 
489  y.evaluatePalette(alpha_array);
490  y.indices(index_array);
491 
492  for (uint i = 0; i < 16; i++) {
493  Color32 &c = block->color(i);
494  c.g = alpha_array[index_array[i]];
495  c.b = 0;
496  c.a = 255;
497  }
498 }
499 
501 {
502  x.flip4();
503  y.flip4();
504 }
505 
507 {
508  x.flip2();
509  y.flip2();
510 }
511 
512 void BlockCTX1::evaluatePalette(Color32 color_array[4]) const
513 {
514  /* Does bit expansion before interpolation. */
515  color_array[0].b = 0x00;
516  color_array[0].g = col0[1];
517  color_array[0].r = col0[0];
518  color_array[0].a = 0xFF;
519 
520  color_array[1].r = 0x00;
521  color_array[1].g = col0[1];
522  color_array[1].b = col1[0];
523  color_array[1].a = 0xFF;
524 
525  color_array[2].r = 0x00;
526  color_array[2].g = (2 * color_array[0].g + color_array[1].g) / 3;
527  color_array[2].b = (2 * color_array[0].b + color_array[1].b) / 3;
528  color_array[2].a = 0xFF;
529 
530  color_array[3].r = 0x00;
531  color_array[3].g = (2 * color_array[1].g + color_array[0].g) / 3;
532  color_array[3].b = (2 * color_array[1].b + color_array[0].b) / 3;
533  color_array[3].a = 0xFF;
534 }
535 
537 {
538  /* Decode color block. */
539  Color32 color_array[4];
540  evaluatePalette(color_array);
541 
542  /* Write color block. */
543  for (uint j = 0; j < 4; j++) {
544  for (uint i = 0; i < 4; i++) {
545  uint idx = (row[j] >> (2 * i)) & 3;
546  block->color(i, j) = color_array[idx];
547  }
548  }
549 }
550 
551 void BlockCTX1::setIndices(const int *idx)
552 {
553  indices = 0;
554  for (uint i = 0; i < 16; i++) {
555  indices |= (idx[i] & 3) << (2 * i);
556  }
557 }
558 
559 inline void BlockCTX1::flip4()
560 {
561  swap(row[0], row[3]);
562  swap(row[1], row[2]);
563 }
564 
565 inline void BlockCTX1::flip2()
566 {
567  swap(row[0], row[1]);
568 }
569 
570 void mem_read(Stream &mem, BlockDXT1 &block)
571 {
572  mem_read(mem, block.col0.u);
573  mem_read(mem, block.col1.u);
574  mem_read(mem, block.indices);
575 }
576 
577 void mem_read(Stream &mem, AlphaBlockDXT3 &block)
578 {
579  for (unsigned short &alpha : block.row) {
580  mem_read(mem, alpha);
581  }
582 }
583 
584 void mem_read(Stream &mem, BlockDXT3 &block)
585 {
586  mem_read(mem, block.alpha);
587  mem_read(mem, block.color);
588 }
589 
590 void mem_read(Stream &mem, AlphaBlockDXT5 &block)
591 {
592  mem_read(mem, block.u);
593 }
594 
595 void mem_read(Stream &mem, BlockDXT5 &block)
596 {
597  mem_read(mem, block.alpha);
598  mem_read(mem, block.color);
599 }
600 
601 void mem_read(Stream &mem, BlockATI1 &block)
602 {
603  mem_read(mem, block.alpha);
604 }
605 
606 void mem_read(Stream &mem, BlockATI2 &block)
607 {
608  mem_read(mem, block.x);
609  mem_read(mem, block.y);
610 }
611 
612 void mem_read(Stream &mem, BlockCTX1 &block)
613 {
614  mem_read(mem, block.col0[0]);
615  mem_read(mem, block.col0[1]);
616  mem_read(mem, block.col1[0]);
617  mem_read(mem, block.col1[1]);
618  mem_read(mem, block.indices);
619 }
unsigned int uint
Definition: BLI_sys_types.h:67
void mem_read(Stream &mem, BlockDXT1 &block)
Definition: BlockDXT.cpp:570
unsigned long long uint64
Definition: Common.h:30
void swap(T &a, T &b)
Definition: Common.h:19
unsigned char uint8
Definition: Common.h:26
unsigned short g
Definition: Color.h:97
unsigned short b
Definition: Color.h:96
unsigned short u
Definition: Color.h:100
unsigned short r
Definition: Color.h:98
Definition: Color.h:19
unsigned char g
Definition: Color.h:75
unsigned char b
Definition: Color.h:75
unsigned char r
Definition: Color.h:75
unsigned char a
Definition: Color.h:75
ccl_gpu_kernel_postfix ccl_global float int int int int float bool int offset
ccl_device_inline float4 mask(const int4 &mask, const float4 &a)
Definition: math_float4.h:513
static unsigned c
Definition: RandGen.cpp:83
static const pxr::TfToken b("b", pxr::TfToken::Immortal)
void decodeBlock(ColorBlock *block) const
Definition: BlockDXT.cpp:264
uint16 row[4]
Definition: BlockDXT.h:101
void indices(uint8 index_array[16]) const
Definition: BlockDXT.cpp:349
uint index(uint index) const
Definition: BlockDXT.cpp:369
uint8 bits6() const
Definition: BlockDXT.h:187
void setIndex(uint index, uint value)
Definition: BlockDXT.cpp:375
uint8 alpha0() const
Definition: BlockDXT.h:155
uint8 bitsF() const
Definition: BlockDXT.h:223
uint8 bitsD() const
Definition: BlockDXT.h:215
uint8 bits9() const
Definition: BlockDXT.h:199
uint8 bits2() const
Definition: BlockDXT.h:171
void decodeBlock(ColorBlock *block) const
Definition: BlockDXT.cpp:382
uint8 bits0() const
Definition: BlockDXT.h:163
uint8 bitsC() const
Definition: BlockDXT.h:211
void evaluatePalette8(uint8 alpha[8]) const
Definition: BlockDXT.cpp:321
void evaluatePalette(uint8 alpha[8]) const
Definition: BlockDXT.cpp:311
uint8 bitsB() const
Definition: BlockDXT.h:207
uint8 bits7() const
Definition: BlockDXT.h:191
void evaluatePalette6(uint8 alpha[8]) const
Definition: BlockDXT.cpp:335
uint8 bits5() const
Definition: BlockDXT.h:183
uint8 bits4() const
Definition: BlockDXT.h:179
uint8 bitsE() const
Definition: BlockDXT.h:219
uint8 alpha1() const
Definition: BlockDXT.h:159
uint8 bits8() const
Definition: BlockDXT.h:195
uint8 bits3() const
Definition: BlockDXT.h:175
uint8 bits1() const
Definition: BlockDXT.h:167
uint8 bitsA() const
Definition: BlockDXT.h:203
void decodeBlock(ColorBlock *block) const
Definition: BlockDXT.cpp:451
void flip2()
Definition: BlockDXT.cpp:471
AlphaBlockDXT5 alpha
Definition: BlockDXT.h:258
void flip4()
Definition: BlockDXT.cpp:466
AlphaBlockDXT5 y
Definition: BlockDXT.h:272
void decodeBlock(ColorBlock *block) const
Definition: BlockDXT.cpp:476
AlphaBlockDXT5 x
Definition: BlockDXT.h:271
void flip2()
Definition: BlockDXT.cpp:506
void flip4()
Definition: BlockDXT.cpp:500
void flip4()
Definition: BlockDXT.cpp:559
uint indices
Definition: BlockDXT.h:289
uint8 col1[2]
Definition: BlockDXT.h:286
void decodeBlock(ColorBlock *block) const
Definition: BlockDXT.cpp:536
void flip2()
Definition: BlockDXT.cpp:565
void setIndices(const int *idx)
Definition: BlockDXT.cpp:551
uint8 row[4]
Definition: BlockDXT.h:288
uint8 col0[2]
Definition: BlockDXT.h:285
void evaluatePalette(Color32 color_array[4]) const
Definition: BlockDXT.cpp:512
Color16 col1
Definition: BlockDXT.h:47
void evaluatePalette3(Color32 color_array[4]) const
Definition: BlockDXT.cpp:147
void decodeBlock(ColorBlock *block) const
Definition: BlockDXT.cpp:196
void evaluatePalette4(Color32 color_array[4]) const
Definition: BlockDXT.cpp:172
void setIndices(const int *idx)
Definition: BlockDXT.cpp:226
void flip4()
Definition: BlockDXT.cpp:234
Color16 col0
Definition: BlockDXT.h:46
uint evaluatePalette(Color32 color_array[4]) const
Definition: BlockDXT.cpp:46
void flip2()
Definition: BlockDXT.cpp:240
uint indices
Definition: BlockDXT.h:50
void decodeBlockNV5x(ColorBlock *block) const
Definition: BlockDXT.cpp:211
uint8 row[4]
Definition: BlockDXT.h:49
uint evaluatePaletteNV5x(Color32 color_array[4]) const
Definition: BlockDXT.cpp:102
void decodeBlockNV5x(ColorBlock *block) const
Definition: BlockDXT.cpp:258
void flip4()
Definition: BlockDXT.cpp:295
void decodeBlock(ColorBlock *block) const
Definition: BlockDXT.cpp:249
BlockDXT1 color
Definition: BlockDXT.h:115
void flip2()
Definition: BlockDXT.cpp:301
AlphaBlockDXT3 alpha
Definition: BlockDXT.h:114
BlockDXT1 color
Definition: BlockDXT.h:245
void decodeBlockNV5x(ColorBlock *block) const
Definition: BlockDXT.cpp:430
void flip4()
Definition: BlockDXT.cpp:439
void flip2()
Definition: BlockDXT.cpp:445
AlphaBlockDXT5 alpha
Definition: BlockDXT.h:244
void decodeBlock(ColorBlock *block) const
Definition: BlockDXT.cpp:421
Color32 color(uint i) const
Definition: ColorBlock.h:62
Definition: Stream.h:11