skia / external / github.com / KhronosGroup / OpenGL-Registry / 01ac568838ce3a93385d885362e3ddc7bca54b08 / . / extensions / SGI / SGI_complex_type.txt

XXX - Not complete yet!!! | |

Name | |

SGI_complex_type | |

Name Strings | |

GL_SGI_complex_type | |

Version | |

$Date: 1996/11/15 20:52:37 $ $Revision: 1.5 $ | |

Number | |

88 | |

Dependencies | |

SGI_complex is required | |

EXT_texture3D affects the definition of this extension | |

EXT_subtexture affects the definition of this extension | |

EXT_convolution affects the definition of this extension | |

EXT_histogram affects the definition of this extension | |

SGI_color_table affects the definition of this extension | |

SGIS_texture4D affects the definition of this extension | |

Overview | |

This extension defines complex pixel types which can be used | |

as the type parameter in any OpenGL command which accepts | |

a pixel image parameter (e.g. DrawPixels, ReadPixels, etc). | |

New Procedures and Functions | |

None | |

New Tokens | |

Accepted by the <type> parameter of DrawPixels, ReadPixels, | |

TexImage1D, TexImage2D, TexImage3DEXT, TexImage4DSGIS, TexSubImage1DEXT, | |

TexSubImage2DEXT, TexSubImage3DEXT, TexSubImage4DSGIS, GetTexImage, | |

ColorTableSGI, GetColorTableSGI, ConvolutionFilter1DEXT, | |

ConvolutionFilter2DEXT, ConvolutionFilter3DEXT, GetConvolutionFilterEXT, | |

SeparableFilter2DEXT, SeparableFilter3DEXT, GetSeparableFilterEXT, | |

GetHistogramEXT, and GetMinmaxEXT: | |

COMPLEX_UNSIGNED_BYTE_SGI 0x81BD | |

COMPLEX_BYTE_SGI 0x81BE | |

COMPLEX_UNSIGNED_SHORT_SGI 0x81BF | |

COMPLEX_SHORT_SGI 0x81C0 | |

COMPLEX_UNSIGNED_INT_SGI 0x81C1 | |

COMPLEX_INT_SGI 0x81C2 | |

COMPLEX_FLOAT_SGI 0x81C3 | |

Additions to Chapter 2 of the 1.0 Specification (OpenGL Operation) | |

None | |

Additions to Chapter 3 of the 1.0 Specification (Rasterization) | |

The seven tokens defined by this extension are added to Table 3.4: | |

<type> Parameter Corresponding Special | |

Token Value GL Data Type Interpretation | |

---------------- ------------- -------------- | |

UNSIGNED_BYTE ubyte No | |

BYTE byte No | |

UNSIGNED_SHORT ushort No | |

SHORT short No | |

UNSIGNED_INT uint No | |

INT int No | |

FLOAT float No | |

BITMAP ubyte Yes | |

UNSIGNED_BYTE_3_3_2_EXT ubyte Yes | |

UNSIGNED_SHORT_4_4_4_4_EXT ushort Yes | |

UNSIGNED_SHORT_5_5_5_1_EXT ushort Yes | |

UNSIGNED_INT_8_8_8_8_EXT uint Yes | |

UNSIGNED_INT_10_10_10_2_EXT uint Yes | |

COMPLEX_UNSIGNED_BYTE_SGI ubyte No | |

COMPLEX_BYTE_SGI byte No | |

COMPLEX_UNSIGNED_SHORT_SGI ushort No | |

COMPLEX_SHORT_SGI short No | |

COMPLEX_UNSIGNED_INT_SGI uint No | |

COMPLEX_INT_SGI int No | |

COMPLEX_FLOAT_SGI float No | |

Table 3.4: DrawPixels and ReadPixels <type> parameter values and the | |

corresponding GL data types. Refer to table 2.2 for definitions of | |

GL data types. Special interpretations are described near the end | |

of section 3.6.3. | |

[Section 3.6.3 of the GL Specification (Rasterization of Pixel | |

Rectangles) has the following paragraphs added immediately before | |

the discussion of the Bitmap type:] | |

Calling DrawPixels with a <type> of COMPLEX_UNSIGNED_BYTE_SGI, | |

COMPLEX_BYTE_SGI, COMPLEX_UNSIGNED_SHORT_SGI, COMPLEX_SHORT_SGI, | |

COMPLEX_UNSIGNED_INT_SGI, COMPLEX_INT_SGI, or COMPLEX_FLOAT_SGI is a | |

special case in which the elements in each group are actually pairs of | |

real and imaginary parts of a single complex element. The number of | |

elements is fixed by the <format> parameter and the underlying type of | |

each of the constituent parts of the complex element (subcomponent) is | |

indicated by the <type> parameter in the obvious way. Complex components | |

are placed with the real part first in memory and the imaginary part | |

second. For the purposes of determining the location of an element in a | |

row, the element size should be considered twice the size of the GL type | |

corresponding to the subcomponent type. e.g., if <type. is | |

COMPLEX_SHORT_SGI, then the element size is 2*2 = 4. If | |

UNPACK_SWAP_BYTES is TRUE, byte swapping is performed on the individual | |

subcomponents of the element. | |

Conversion to floating-point | |

This step applies only to groups of components. It is not performed on | |

indices. Each element in a group is converted to a floating-point value | |

according to the appropriate formula in Table 2.4 (section 2.12). | |

The real and imaginary parts of complex elements are each converted to | |

floating-point values use the formula in Table 2.4. | |

Unsigned integer bitfields extracted from packed pixels are interpreted | |

using the formula | |

f = c / ((2**N)-1) | |

where c is the value of the bitfield (interpreted as an unsigned | |

integer), N is the number of bits in the bitfield, and the division is | |

performed in floating point. | |

[End of changes to Section 3.6.3] | |

If this extension is supported, all commands that accept pixel data | |

also accept packed pixel data. These commands are DrawPixels, | |

TexImage1D, TexImage2D, TexImage3DEXT, TexSubImage1DEXT, | |

TexSubImage2DEXT, TexSubImage3DEXT, ConvolutionFilter1DEXT, | |

ConvolutionFilter2DEXT, ConvolutionFilter3DEXT, SeparableFilter2DEXT, | |

SeparableFilter3DEXT, ColorTableSGI, TexImage4DSGIS, and | |

TexSubImage4DSGIS. | |

Additions to Chapter 4 of the 1.0 Specification (Per-Fragment Operations | |

and the Frame Buffer) | |

[Make the following changes to Section 4.3.2 (Reading Pixels):] | |

Final Conversion | |

For an index, if the <type> is not FLOAT, final conversion consists of | |

masking the index with the value given in Table 4.6; if the <type> is | |

FLOAT, then the integer index is converted to a GL float data value. | |

For a component, each component is first clamped to [0,1]. Then, | |

the appropriate conversion formula from Table 4.7 is applied to the | |

component. | |

<type> Parameter Index Mask | |

---------------- ---------- | |

UNSIGNED_BYTE 2**8 - 1 | |

BITMAP 1 | |

BYTE 2**7 - 1 | |

UNSIGNED_SHORT 2**16 - 1 | |

SHORT 2**15 - 1 | |

UNSIGNED_INT 2**32 - 1 | |

INT 2**31 - 1 | |

Table 4.6: Index masks used by ReadPixels. Floating point data | |

are not masked. | |

<type> GL Data Component/Subcomponent | |

Parameter Type Conversion Formula | |

--------- ------- ------------------ | |

UNSIGNED_BYTE ubyte c = ((2**8)-1)*f | |

BYTE byte c = (((2**8)-1)*f-1)/2 | |

UNSIGNED_SHORT ushort c = ((2**16)-1)*f | |

SHORT short c = (((2**16)-1)*f-1)/2 | |

UNSIGNED_INT uint c = ((2**32)-1)*f | |

INT int c = (((2**32)-1)*f-1)/2 | |

FLOAT float c = f | |

UNSIGNED_BYTE_3_3_2_EXT ubyte c = ((2**N)-1)*f | |

UNSIGNED_SHORT_4_4_4_4_EXT ushort c = ((2**N)-1)*f | |

UNSIGNED_SHORT_5_5_5_1_EXT ushort c = ((2**N)-1)*f | |

UNSIGNED_INT_8_8_8_8_EXT uint c = ((2**N)-1)*f | |

UNSIGNED_INT_10_10_10_2_EXT uint c = ((2**N)-1)*f | |

COMPLEX_UNSIGNED_BYTE ubyte cs = ((2**8)-1)*fs | |

COMPLEX_BYTE byte cs = (((2**8)-1)*fs-1)/2 | |

COMPLEX_UNSIGNED_SHORT ushort cs = ((2**16)-1)*fs | |

COMPLEX_SHORT short cs = (((2**16)-1)*fs-1)/2 | |

COMPLEX_UNSIGNED_INT uint cs = ((2**32)-1)*fs | |

COMPLEX_INT int cs = (((2**32)-1)*fs-1)/2 | |

COMPLEX_FLOAT float cs = fs | |

Table 4.7: Reversed component conversions - used when component data | |

are being returned to client memory. Color, normal, and depth | |

components are converted from the internal floating-point | |

representation (f) to a datum of the specified GL data type (c) using | |

the equations in this table. All arithmetic is done in the internal | |

floating point format. These conversions apply to component data | |

returned by GL query commands and to components of pixel data returned | |

to client memory. The equations remain the same even if the | |

implemented ranges of the GL data types are greater than the minimum | |

required ranges. (Refer to table 2.2.) Equations with N as the | |

exponent are performed for each bitfield of the packed data type, | |

with N set to the number of bits in the bitfield. | |

Placement in Client Memory | |

Groups of elements are placed in memory just as they are taken from memory | |

for DrawPixels. That is, the ith group of the jth row (corresponding to | |

the ith pixel in the jth row) is placed in memory must where the ith group | |

of the jth row would be taken from for DrawPixels. See Unpacking under | |

section 3.6.3. The only difference is that the storage mode parameters | |

whose names begin with PACK_ are used instead of those whose names begin | |

with UNPACK_. If the <type> parameter is complex then both the real | |

and imaginary parts are written to memory and the element size should be | |

considered twice the size of the size of the subcomponent type. If the | |

<type> parameter is not complex, then only the real part is placed in | |

memory. | |

[End of changes to Section 4.3.2] | |

If this extension is supported, all commands that return pixel data | |

also return packed pixel data. These commands are ReadPixels, | |

GetTexImage, GetHistogramEXT, GetMinmaxEXT, GetConvolutionFilterEXT, | |

GetSeparableFilterEXT, and GetColorTableSGI. | |

Additions to Chapter 5 of the 1.0 Specification (Special Functions) | |

None | |

Additions to Chapter 6 of the 1.0 Specification (State and State Requests) | |

None | |

Additions to the GLX Specification | |

None | |

GLX Protocol | |

None | |

Dependencies on EXT_texture3D | |

If EXT_texture3D is not implemented, then the references to | |

TexImage3DEXT in this file are invalid, and should be ignored. | |

Dependencies on EXT_subtexture | |

If EXT_subtexture is not implemented, then the references to | |

TexSubImage1DEXT, TexSubImage2DEXT, and TexSubImage3DEXT in this file | |

are invalid, and should be ignored. | |

Dependencies on EXT_histogram | |

If EXT_histogram is not implemented, then the references to | |

GetHistogramEXT and GetMinmaxEXT in this file are invalid, and should be | |

ignored. | |

Dependencies on EXT_convolution | |

If EXT_convolution is not implemented, then the references to | |

ConvolutionFilter1DEXT, ConvolutionFilter2DEXT, ConvolutionFilter3DEXT, | |

GetConvolutionFilterEXT, SeparableFilter2DEXT, SeparableFilter3DEXT, and | |

GetSeparableFilterEXT in this file are invalid, and should be ignored. | |

Dependencies on SGI_color_table | |

If SGI_color_table is not implemented, then the references to | |

ColorTableSGI and GetColorTableSGI in this file are invalid, and should | |

be ignored. | |

Dependencies on SGIS_texture4D | |

If SGIS_texture4D is not implemented, then the references to | |

TexImage4DSGIS and TexSubImage4DSGIS in this file are invalid, and should | |

be ignored. | |

Errors | |

None | |

New State | |

None | |

New Implementation Dependent State | |

None |