| Name |
| |
| 3DFX_texture_compression_FXT1 |
| |
| Name Strings |
| |
| GL_3DFX_texture_compression_FXT1 |
| |
| Contact |
| |
| Don Mullis, 3dfx Interactive (dwm 'at' 3dfx.com) |
| |
| Status |
| |
| CANDIDATE FOR FINAL DRAFT -- NOT YET COMPLETE |
| |
| Version |
| |
| Draft 0.4, 12 Apr 2000 |
| |
| Number |
| |
| 206 |
| |
| Dependencies |
| |
| OpenGL 1.1 is required. |
| GL_ARB_texture_compression is required. |
| This extension is written against the OpenGL 1.2.1 Specification. |
| |
| Overview |
| |
| This extension additional texture compression functionality 's FXT1 |
| format, specific to 3dfxsubject to all the requirements and |
| limitations described by the extension GL_ARB_texture_compression. |
| The FXT1 texture format supports only 2D and 3D images without |
| borders. |
| |
| Because 3dfx expects to make continual improvement to its FXT1 |
| compressor implementation, 3dfx recommends that to achieve best |
| visual quality applications adopt the following procedure with |
| respect to reuse of textures compressed by the GL: |
| |
| 1) Save the RENDERER and VERSION strings along with images |
| compressed by the GL; |
| 2) Before reuse of the textures, compare the stored strings with |
| strings newly returned from the current GL; |
| 3) If out-of-date, repeat the compression and storage steps. |
| |
| IP Status |
| |
| A royalty-free license is available from 3dfx Interactive |
| (http://www.3dfx.com/). |
| |
| Issues |
| |
| (1) Two or only one internalformat tokens: |
| GL_COMPRESSED_RGBA_FXT1_3DFX and GL_COMPRESSED_RGB_FXT1_3DFX, or |
| GL_COMPRESSED_RGBA_FXT1_3DFX only. These names are placeholders, |
| the point in question is whether there should be separate tokens |
| reflecting extrinsic knowledge of whether the image contains any |
| non-unity alpha values. This arises because the FXT1 image |
| format distinguishes non-unity alpha only at the level of an |
| individual 8x4 compression block. If there are two distinct |
| tokens, passing GL_COMPRESSED_RGB_FXT1_3DFX to |
| CompressedTexImage with an image that contained non-unity-alpha |
| blocks would be an error. |
| |
| RESOLVED. Two distinct tokens specified. This is largely to |
| follow the usual usage by apps of non-compressed tokens. |
| |
| (2) Support for borders. |
| |
| RESOLVED. Not supported. |
| |
| (3) Support for TexSubImage at a level more general than that |
| guaranteed by ARB_texture_compression. |
| |
| RESOLVED. Not supported; See issue (5) of the |
| GL_ARB_texture_compression spec. |
| |
| New Procedures and Functions |
| |
| None |
| |
| New Tokens |
| |
| Accepted by the <internalformat> parameter of TexImage2D, |
| CopyTexImage2D, TexImage3D, CopyTexImage3D, and by the |
| <internalformat> and <format> parameters of |
| CompressedTexImage2D_ARB, CompressedTexSubImage2D_ARB, |
| CompressedTexImage3D_ARB, CompressedTexSubImage3D_ARB: |
| |
| COMPRESSED_RGB_FXT1_3DFX 0x86B0 |
| COMPRESSED_RGBA_FXT1_3DFX 0x86B1 |
| |
| Additions to Chapter 2 of the OpenGL 1.2.1 Specification (OpenGL Operation) |
| |
| None. |
| |
| Additions to Chapter 3 of the OpenGL 1.2.1 Specification (Rasterization) |
| |
| Add Table 3.16.1: Specific Compressed Internal Formats |
| |
| Compressed Internal Format Base Internal Format |
| ========================== ==================== |
| COMPRESSED_RGB_FXT1_3DFX RGB |
| COMPRESSED_RGBA_FXT1_3DFX RGBA |
| |
| Add to Section 3.8.2, Alternate Image Specification (adding to the |
| end of the CompressedTexImage section introduced by the |
| ARB_texture_compression spec) |
| |
| If <internalformat> is COMPRESSED_RGB_FXT1_3DFX, |
| COMPRESSED_RGBA_FXT1_3DFX, the compressed texture is stored using |
| one of several FXT1 compressed texture image formats. FXT1 texture |
| compression supports only 2D images without borders. |
| CompressedTexImage1DARB and CompressedTexImage3DARB produce an |
| INVALID_ENUM error if <internalformat> is an FXT1 format. |
| CompressedTexImage2DARB will produce an INVALID_OPERATION error if |
| <border> is non-zero. |
| |
| |
| Add to Section 3.8.2, Alternate Image Specification (adding to the |
| end of the CompressedTexSubImage section introduced by the |
| ARB_texture_compression spec) |
| |
| If the internal format of the texture image being modified is |
| COMPRESSED_RGB_FXT1_3DFX, COMPRESSED_RGBA_FXT1_3DFX, the texture is |
| stored using one of the several FXT1 compressed texture image |
| formats. Since the FXT1 texture compression algorithm supports only |
| 2D images, CompressedTexSubImage1DARB and CompressedTexSubImage3DARB |
| produce an INVALID_ENUM error if <format> is an FXT1 format. |
| |
| Additions to Chapter 4 of the OpenGL 1.2.1 Specification (Per-Fragment |
| Operations and the Frame Buffer) |
| |
| None. |
| |
| Additions to Chapter 5 of the OpenGL 1.2.1 Specification (Special Functions) |
| |
| None. |
| |
| Additions to Chapter 6 of the OpenGL 1.2.1 Specification (State and |
| State Requests) |
| |
| None. |
| |
| Additions to Appendix A of the OpenGL 1.2.1 Specification (Invariance) |
| |
| None. |
| |
| Additions to the AGL/GLX/WGL Specifications |
| |
| None. |
| |
| GLX Protocol |
| |
| None. |
| |
| Errors |
| |
| INVALID_ENUM is generated by CompressedTexImage1DARB if |
| <internalformat> is GL_COMPRESSED_RGB_FXT1_3DFX or |
| GL_COMPRESSED_RGBA_FXT1_3DFX. |
| |
| INVALID_OPERATION is generated by CompressedTexImage2DARB or |
| CompressedTexImage3DARB if <internalformat> is |
| GL_COMPRESSED_RGB_FXT1_3DFX or GL_COMPRESSED_RGBA_FXT1_3DFX and |
| <border> is not equal to zero. |
| |
| INVALID_ENUM is generated by CompressedTexSubImage1DARB if <format> |
| is GL_COMPRESSED_RGB_FXT1_3DFX or GL_COMPRESSED_RGBA_FXT1_3DFX. |
| |
| Appendix |
| |
| FXT1 comprises four different compressed texture formats. Each of |
| the formats compress an 8x4 texel blocks into 128 bits. During the |
| compression phase, the encoder selects one of the four formats for |
| each block based on which encoding scheme results in best overall |
| visual quality. Unused pixel locations along the right or bottom |
| edges within a block should contain a repetition of the values in |
| used locations. The total size of an image is ceil(width/8) * |
| ceil(height/4) * 16 bytes. |
| |
| In each compression format, the 32 texels of the 8x4 block are |
| partitioned into two 4x4 sub-blocks according to the following |
| diagram: |
| |
| t0 t1 t2 t3 t16 t17 t18 t19 |
| t4 t5 t6 t7 t20 t21 t22 t23 |
| t8 t9 t10 t11 t24 t25 t26 t27 |
| t12 t13 t14 t15 t28 t29 t30 t31 |
| |
| In the following bit-level descriptions, bits of increasing index |
| are stored in bytes at likewise increasing offsets, i.e. the order |
| is "little-endian". |
| |
| |
| 1. FXT1 Compressed Texture Format CC_HI: |
| |
| (rgb555) (3-bit/texel) |
| mode[1:0] color1 color0 texel 31 to 16 texel 15 to 0 |
| 2 15 15 48 48 |
| |
| |
| [127:126] mode[1:0] |
| [125:121] red of color1 |
| [120:116] green of color1 |
| [115:111] blue of color1 |
| [110:106] red of color0 |
| [105:101] green of color0 |
| [100:96] blue of color0 |
| [95:93] texel 31 |
| ... |
| [50:48] texel 16 |
| [47:45] texel 15 |
| ... |
| [2:0] texel 0 |
| |
| In CC_HI format, mode = 00b, the 15-bit color1 (RGB555 format) and |
| color0 (RGB555 format) colors are converted into 24-bit RGB888 |
| colors by duplicating the upper 3 bits for the 3 LSBs. The 24-bit |
| converted color1 and color0 are then used to linearly interpolate 5 |
| more levels of color to create seven total levels of colors and 1 |
| alpha (transparent) color. The first seven colors always have |
| alpha=ffh (opaque), while the eighth color is defined to be |
| transparent black (r,g,b=00h, alpha=00h). |
| |
| These eight 32-bit colors are used as the contents of an 8-entry (3 |
| bit index) lookup table. For all 32 texels in the block, each |
| texel's 3-bit index value is used to index the lookup table, the |
| output from the lookup table representing the 32-bit color |
| (ARGB8888) for that texel. |
| |
| Generating RGB888 from RGB555: |
| |
| Color1 (red) = {[125:121], [125:123]} |
| Color1 (green) = {[120:116], [120:118]} |
| Color1 (blue) = {[115:111], [115:113]} |
| |
| Color0 (red) = {[110:106], [110:108]} |
| Color0 (green) = {[105:101], [105:103]} |
| Color0 (blue) = {[100:96], [100:98]} |
| |
| Creating seven ARGB8888 colors from two RGB888 colors (operations |
| performed individually for each color channel): |
| |
| Color[0] = color0[r,g,b], alpha[0] = ffh |
| Color[1] = (5*color0[r,g,b] + color1[r,g,b] +3 )/6 alpha[1] = ffh |
| Color[2] = (4*color0[r,g,b] + 2*color1[r,g,b] +3 )/6 alpha[2] = ffh |
| Color[3] = (3*color0[r,g,b] + 3*color1[r,g,b] +3 )/6 alpha[3] = ffh |
| Color[4] = (2*color0[r,g,b] + 4*color1[r,g,b] +3 )/6 alpha[4] = ffh |
| Color[5] = (color0[r,g,b] + 5*color1[r,g,b] +3 )/6 alpha[5] = ffh |
| Color[6] = color1[r,g,b], alpha[6] = ffh |
| Color[7] = where r,g,b = 00h, alpha[7]=00h |
| |
| Table Lookup: |
| 3-bit index of Color for texel 31 to texel 0 |
| texel31 to texel0 (ARGB8888) |
| |
| 0 color[0] => {a[7:0], r[7:0], g[7:0], b[7:0]} |
| 1 color[1] |
| 2 color[2] |
| 3 color[3] |
| 4 color[4] |
| 5 color[5] |
| 6 color[6] |
| 7 color[7] |
| |
| |
| 2. FXT1 Compressed Texture Format CC_CHROMA: |
| |
| (rgb555) (2-bit/texel) |
| Mode[2:0] unused color3 color2 color1 color0 texel 31 to 16 texel 15 to 0 |
| 3 1 15 15 15 15 32 32 |
| |
| [127:125] mode[2:0] |
| [124] unused |
| [123:119] color3(r5) |
| [118:114] color3(g5) |
| [113:109] color3(b5) |
| [108:104] color2(r5) |
| [103:99] color2(g5) |
| [98:94] color2(b5) |
| [93:89] color1(r5) |
| [88:84] color1(g5) |
| [83:79] color1(b5) |
| [78:74] color0(r5) |
| [73:69] color0(g5) |
| [68:64] color0(b5) |
| [63:62] texel 31 |
| ... |
| [33:32] texel 16 |
| [31:30] texel 15 |
| ... |
| [1:0] texel 0 |
| |
| In CC_CHROMA format, mode=010b, the 15-bit colors color[3:0] |
| (RGB555) are converted into 24-bit RGB888 colors exactly the same as |
| in the CC_HI format via bit replication. Color3 to Color0 are used |
| as they are (after conversion to RGB888 format), but without |
| interpolation. The 24-bit converted colors color3, color2, color1, |
| and color0 are used as the contents of a 4-entry (2-bit index) |
| lookup table. The Alpha channel of the output of the lookup table is |
| always opaque(ffh), regardless of the 2-bit index value. The 32-bit |
| (ARGB8888) color value for each texel is obtained by performing |
| table lookup using that texel's 2-bit index. |
| |
| Table Lookup: |
| |
| 2-bit index of Color for texel 31 to texel 0 |
| texel 31 to texel 0 (ARGB8888) |
| |
| 0 color0, alpha = ffh |
| 1 color1, alpha = ffh |
| 2 color2, alpha = ffh |
| 3 color3, alpha = ffh |
| |
| |
| 3. FXT1 Compressed Texture Format CC_MIXED: |
| |
| (rgb555) (2-bit/texel) |
| mode[0] glsb[1:0] alpha[0] color3 color2 color1 color0 texel 31to16 texel 15to0 |
| 1 2 1 15 15 15 15 32 32 |
| |
| |
| [127] mode[0] |
| [126:125] glsb[1:0] (lsbs of green for color 1 & color 3) |
| [124] alpha[0] |
| [123:119] color3(r5) |
| [118:114] color3(g5) |
| [113:109] color3(b5) |
| [108:104] color2(r5) |
| [103:99] color2(g5) |
| [98:94] color2(b5) |
| [93:89] color1(r5) |
| [88:84] color1(g5) |
| [83:79] color1(b5) |
| [78:74] color0(r5) |
| [73:69] color0(g5) |
| [68:64] color0(b5) |
| [63:62] texel 31 |
| ... |
| [33:32] texel 16 |
| [31:30] texel 15 |
| ... |
| [1:0] texel 0 |
| |
| In CC_MIXED format, mode[0]=1 (only one bit), color2 and color3 are |
| used for texels 31 to 16, and color0 and color1 are used for texels |
| 15 to 0. When alpha[0] = 0, the two pairs of colors (colors 0 and 1 |
| for texels 15 to 0 and colors 2 and 3 for texels 31 to 16) are |
| interpreted as 16-bit RGB565 colors. For color1 and color3, the LSB |
| (bit 0) of the green channel comes from the glsb bits |
| (color1.green[0] = bit 125, color3.green[0] = bit 126). For color0 |
| and color2, the LSB (bit 0) of the green channel comes from the |
| upper select bit for texel 0 and texel 16, respectively |
| (color0.green[0] = bit 1 xor bit 125, color2.green[0] = bit 33 xor |
| bit 126). The two 16-bit colors are then expanded to a 24-bit RGB888 |
| format by bit replication (most significant bits replicated in the |
| least significant bits), and are then used to create 2 more levels |
| of color in between the color0/2 and color1/3 values through linear |
| interpolation. A total of 4 colors are therefore available for 2-bit |
| index per texel selection. |
| |
| When alpha[0]=1, color0 and color2 are interpreted as 15-bit RGB555 |
| colors, and color 1 and color3 are interpreted as RGB565 colors. For |
| color0 and color2, the 15-bit RGB555 colors are expanded to 24-bit |
| RGB888 colors by bit replication. For color1 and color3, the LSB |
| (bit 0) of the green channel comes from the glsb bits |
| (color1.green[0] = bit 125, color3.green[0] = bit 126), and then bit |
| replication is used to convert from the 16-bit RGB565 format to a |
| 24-bit RGB888 format. A third color is created by linear |
| interpolation (interpolating between the converted 24-bit RGB888 |
| color0 and color1 for texels 15 to 0, and interpolating between the |
| converted 24-bit RGB888 color2 and color3 for texels 31 to 16). |
| Finally, a fourth color (texel index 0x3) is defined to be |
| transparent black (r,g,b=00h, alpha=00h). A total of 4 colors are |
| therefore available for 2-bit index per texel selection. The 32-bit |
| (ARGB8888) color value for all texels is obtained by performing |
| table lookup using each texel's 2-bit index. |
| |
| Creating the 24-bit (RGB888) base colors color3 and color2: |
| |
| Color3(red) = {[123:119], [123:121]} |
| Color3(green) = {[118:114], [126], [118:117]} |
| Color3(blue) = {[113:109], [113:111]} |
| Color2(red) = {[108:104], [108:106]} |
| Color2(green) = (alpha[0]=1) ? {[103:99],[103:101]} |
| : {[103:99],[33]^[126],[103:102]} |
| Color2(blue) = {[98:94], [98:96]} |
| |
| Creating the 24-bit (RGB888) base colors color1 and color0: |
| |
| Color1(red) = {[93:89], [93:91]} |
| Color1(green) = {[88:84], [125], [88:87]} |
| Color1(blue) = {[83:79], [83:81]} |
| Color0(red) = {[78:74], [78:76]} |
| Color0(green) = (alpha[0]=1) ? {[73:69, [73:71]} |
| : {[73:69], [1]^[125], [73:72]} |
| Color0(blue) = {[68:64], [68:66]} |
| |
| When alpha[0]=0, because one of the texel select bits is used to |
| determine a bit of color0 and color2, the software encoder must |
| perform some very tricky operations. The method below describes how |
| to generate color0 and color1 and the associated select bits (the |
| same method applies to determining the lsb of green for color2 and |
| color3): |
| |
| 1. Determine the 16-bit RGB565 color values for color0 & color1. |
| |
| 2. Determine the select bits for each pixel in the 4x4 sub-block. |
| |
| 3. If (pixel[0].select[1] != color0.green[0]^color1.green[0]) then |
| swap color0 &color1, and invert all the select bits. |
| |
| Below is a snippet of psuedo-C code to generate bits 0-31, bits |
| 64-93 & bit 125 based on the initial color0, color1 and pixel |
| indices: |
| |
| struct RGB565 {Byte red; Byte green; Byte blue}; |
| |
| struct CSels {Byte index[16]}; |
| |
| // cc_mixed_right_half derives bits[93:64] of the 128 bit data word of a |
| // CC_MIXED non-alpha compression block and returns them in 'bits_64_to_31'. |
| // Plus, as a bonus, you will receive bit 125, containing the lsb of |
| // the green channel of color1, and bits_0_to_31, containing all of the pixel indices. |
| void |
| cc_mixed_right_half( RGB565 color0, RGB565 color1, |
| CSels pix, |
| Dword &bits_0_to_31, |
| Dword &bits_64_to_93, |
| Bit &bit125) |
| { |
| RGB565 o_color0; |
| RGB565 o_color1; |
| |
| // Determine if we need to switch color0 & color1 |
| if (((pix.index[0] >> 1) & 1) != ((color0.green ^ color1.green) & 1)) { |
| o_color1 = color0; |
| o_color0 = color1; |
| |
| for (int i=0; i<16; i++) |
| pix.index[i] = ~pix.index[i] & 3; |
| } else { |
| o_color0 = color0; |
| o_color1 = color1; |
| } |
| |
| // Save lsb of color1.green in bit125 |
| bit125 = o_color1.green & 1; |
| |
| // Convert color0 & color1 to RGB555, and then munge into bits 64 to 93 |
| o_color0.green >>= 1; |
| o_color1.green >>= 1; |
| |
| bits_64_to_93 = ( (o_color1.red<<25) | (o_color1.green<<20) | (o_color1.blue<<15) |
| | (o_color0.red<<10) | (o_color0.green<<5) | (o_color0.blue) ); |
| |
| // Munge the pixel indices into bits 0 to 31 |
| bits_0_to_31 = 0; |
| |
| for (int i=0; i<16; i++) |
| bits_0_to_31 |= pix.index[i]<<(i*2); |
| } |
| |
| |
| Generating the 4-entry lookup table for texels 31 to 16: |
| |
| If alpha[0]=0, |
| Color[0] = color2[r,g,b] , alpha=ffh |
| Color[1] = (2 * color2[r,g,b] + color3[r,g,b] + 1) / 3, alpha=ffh |
| Color[2] = (color2[r,g,b] + 2 * color3[r,g,b] +1) / 3, alpha=ffh |
| Color[3] = color3[r,g,b], alpha=ffh |
| |
| If alpha[0]=1, |
| Color[0] = color2[r,g,b], alpha=ffh |
| Color[1] = (color2[r,g,b] + color3[r,g,b]) / 2, alpha=ffh |
| Color[2] = color3[r,g,b], alpha=ffh |
| Color[3] = [a,r,g,b] = 00h |
| |
| Generating the 4-entry lookup table for texels 15 to 0: |
| |
| If alpha[0]=0, |
| Color[0] = color0[r,g,b] , alpha=ffh |
| Color[1] = (2 * color0[r,g,b] + color1[r,g,b] + 1) / 3, alpha=ffh |
| Color[2] = (color0[r,g,b] + 2 * color1[r,g,b] + 1) / 3, alpha=ffh |
| Color[3] = color1[r,g,b], alpha=ffh |
| |
| If alpha[0]=1, |
| Color[0] = color0[r,g,b], alpha=ffh |
| Color[1] = (color0[r,g,b] + color1[r,g,b]) / 2, alpha=ffh |
| Color[2] = color1[r,g,b], alpha=ffh |
| Color[3] = [a,r,g,b] = 00h |
| |
| Table Lookup: |
| 2-bit index of Color for texel 31 to texel 0 |
| texel 31 to texel 0 ARGB8888 |
| |
| 0 color[0], {a[7:0], r[7:0], g[7:0], b[7:0]} |
| 1 color[1] |
| 2 color[2] |
| 3 color[3] |
| |
| |
| 4. FXT1 Compressed Texture format CC_ALPHA: |
| |
| (argb5555) (2-bit/texel) |
| mode[2:0] lerp alpha2 alpha1 alpha0 color2 color1 color0 texel 31 to 16 texel 15 to 0 |
| 3 1 5 5 5 15 15 15 32 32 |
| |
| [127:125] mode[2:0] |
| [124] lerp |
| [123:119] color2(a5) |
| [118:114] color1(a5) |
| [113:109] color0(a5) |
| [108:104] color2(r5) |
| [103:99] color2(g5) |
| [98:94] color2(b5) |
| [93:89] color1(r5) |
| [88:84] color1(g5) |
| [83:79] color1(b5) |
| [78:74] color0(r5) |
| [73:69] color0(g5) |
| [68:64] color0(b5) |
| [63:62] texel 31 |
| ... |
| [33:32] texel 16 |
| [31:30] texel 15 |
| ... |
| [1:0] texel 0 |
| |
| In CC_ALPHA format, mode[2:0]=011b, three 20-bit colors color2, |
| color1 and color0 (ARGB5555) are converted to a 32-bit (ARGB8888) |
| format by duplicating the upper 3-bits for the 3 LSBs (all the color |
| channels and the alpha channel are converted from 5-bit formats to |
| 8-bit formats using this bit duplication). |
| |
| Creating the 32-bit (RGB8888) base colors color2, color1, and color0: |
| |
| Color2(alpha) = {[123:119], [123:121]} |
| Color2(red) = {[108:104], [108:106]} |
| Color2(green) = {[103:99], [103:101]} |
| Color2(blue) = {[98:94], [98:96]} |
| Color1(alpha) = {[118:114], [118:116]} |
| Color1(red) = {[93:89], [93:91]} |
| Color1(green) = {[88:84], [88:86]} |
| Color1(blue) = {[83:79], [83:81]} |
| Color0(alpha) = {[113:109], [113:111]} |
| Color0(red) = {[78:74], [78:76]} |
| Color0(green) = {[73:69], [73:71]} |
| Color0(blue) = {[68:64], [68:66]} |
| |
| When lerp = 0 (bit 124 = 0), the converted 32-bit colors color2, |
| color1, and color0 are used directly as the first 3 entries in the |
| 4-entry lookup table. The last entry in the 4-entry lookup table, |
| accessed with index=3, is defined to be transparent black (rgb=00h, |
| alpha=00h). A total of 4 colors are therefore available for 2-bit |
| index per texel selection, and the 32-bit (ARGB8888) color value for |
| all texels is obtained by performing table lookup using each texel's |
| 2-bit index. |
| |
| Table Lookup (when lerp = 0): |
| |
| Index of texel 31 to 0 Color for texel 31 to texel 0 |
| (ARGB8888) |
| |
| 0 Color[0] = color0 alpha = alpha0 |
| 1 Color[1] = color1 alpha = alpha1 |
| 2 Color[2] = color2 alpha = alpha2 |
| 3 Color[3] = 000000h alpha = 00h |
| |
| When lerp = 1 (bit 124 = 1), the converted 32-bit colors color2 and |
| color1 are used as the 32-bit base colors for texels 31 to 16, and |
| the converted 32-bit colors color1 and color0 are used as the base |
| colors for texels 15 to 0. The 32-bit base colors are then used to |
| create 2 more levels of color through linear interpolation. A total |
| of 4 colors are therefore available for 2-bit index per texel |
| selection, and the 32-bit (ARGB8888) color value for all texels is |
| obtained by performing table lookup using each texel's 2-bit index. |
| |
| Creating the 4 colors used in the 4-entry lookup table from the |
| 32-bit base colors (when lerp = 1): |
| |
| For texel 31 to texel 16 |
| Color[0] = color2[a,r,g,b] |
| Color[1] = (2 * color2[a,r,g,b] + color1[a,r,g,b] + 1) / 3 |
| Color[2] = (color2[a,r,g,b] + 2 * color1[a,r,g,b] +1) / 3 |
| Color[3] = color1[a,r,g,b] |
| |
| For texel 15 to texel 0 |
| Color[0] = color0[a,r,g,b] |
| Color[1] = (2 * color0[a,r,g,b] + color1[a,r,g,b] +1) / 3 |
| Color[2] = (color0[a,r,g,b] + 2 * color1[a,r,g,b] +1) / 3 |
| Color[3] = color1[a,r,g,b] |
| |
| Table Lookup (when lerp = 1): |
| |
| Index of texel 31 to 0 Color for texel 31 to texel 0 |
| (ARGB8888) |
| |
| 0 color[0] |
| 1 color[1] |
| 2 color[2] |
| 3 color[3] |
| |
| Revision History |
| |
| 0.1, 01/12/00 dwm: Initial revision. |
| 0.2, 02/09/00 dwm: Respond to feedback from Intel. |
| 0.3, 02/23/00 dwm: Respond to feedback from Intel. |
| 0.4, 04/12/00 dwm: Updated to reflect final version of the |
| ARB_texture_compression extension. |
| |
| |
| Copyright 1999-2000, 3dfx Interactive, Inc. |
| All rights reserved. |