blob: 034e6a57ecab57a587fa0cca6eb2b3a6ad805cd7 [file] [log] [blame]
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.