| Name |
| |
| SGI_color_table |
| |
| Name Strings |
| |
| GL_SGI_color_table |
| |
| Version |
| |
| $Date: 1997/03/24 22:02:31 $ $Revision: 1.32 $ |
| |
| Number |
| |
| 14 |
| |
| Dependencies |
| |
| EXT_abgr affects the definition of this extension |
| EXT_texture is required |
| EXT_texture3D affects the definition of this extension |
| EXT_subtexture affects the defnition of this extension |
| EXT_copy_texture affects the definition of this extension |
| EXT_convolution affects the definition of this extension |
| SGI_color_matrix affects the definition of this extension |
| |
| Overview |
| |
| This extension defines a new RGBA-format color lookup mechanism. It does |
| not replace the color lookups defined by the GL Specification, but rather |
| provides additional lookup capabilities with different operation. The key |
| difference is that the new lookup tables are treated as 1-dimensional images |
| with internal formats, like texture images and convolution filter images. |
| From this follows the fact that the new tables can operate on a subset of |
| the components of passing pixel groups. For example, a table with internal |
| format ALPHA modifies only the A component of each pixel group, leaving the |
| R, G, and B components unmodified. |
| |
| If EXT_copy_texture is implemented, this extension also defines methods to |
| initialize the color lookup tables from the framebuffer, in addition to the |
| standard memory source mechanisms. |
| |
| Issues |
| |
| * Should a minimum maximum-table-size be imposed? That is, should all |
| implementations support a table size of 256 entries? |
| |
| New Procedures and Functions |
| |
| void ColorTableSGI(enum target, |
| enum internalformat, |
| sizei width, |
| enum format, |
| enum type, |
| const void* table); |
| |
| void CopyColorTableSGI(enum target, |
| enum internalformat, |
| int x, |
| int y, |
| sizei width); |
| |
| void ColorTableParameterivSGI(enum target, |
| enum pname, |
| const int* params); |
| |
| void ColorTableParameterfvSGI(enum target, |
| enum pname, |
| const float* params); |
| |
| void GetColorTableSGI(enum target, |
| enum format, |
| enum type, |
| void* table); |
| |
| void GetColorTableParameterivSGI(enum target, |
| enum pname, |
| int* params); |
| |
| void GetColorTableParameterfvSGI(enum target, |
| enum pname, |
| float* params); |
| |
| New Tokens |
| |
| Accepted by the <cap> parameter of Enable, Disable, and IsEnabled, by the |
| <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev, |
| and by the <target> parameter of ColorTableSGI, CopyColorTableSGI, |
| ColorTableParameterivSGI, ColorTableParameterfvSGI, GetColorTableSGI, |
| GetColorTableParameterivSGI, and GetColorTableParameterfvSGI: |
| |
| COLOR_TABLE_SGI 0x80D0 |
| POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D1 |
| POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D2 |
| |
| Accepted by the <target> parameter of ColorTableSGI, |
| GetColorTableParameterivSGI, and GetColorTableParameterfvSGI: |
| |
| PROXY_COLOR_TABLE_SGI 0x80D3 |
| PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D4 |
| PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D5 |
| |
| Accepted by the <pname> parameter of ColorTableParameterivSGI, |
| ColorTableParameterfvSGI, GetColorTableParameterivSGI, and |
| GetColorTableParameterfvSGI: |
| |
| COLOR_TABLE_SCALE_SGI 0x80D6 |
| COLOR_TABLE_BIAS_SGI 0x80D7 |
| |
| Accepted by the <pname> parameter of GetColorTableParameterivSGI and |
| GetColorTableParameterfvSGI: |
| |
| COLOR_TABLE_FORMAT_SGI 0x80D8 |
| COLOR_TABLE_WIDTH_SGI 0x80D9 |
| COLOR_TABLE_RED_SIZE_SGI 0x80DA |
| COLOR_TABLE_GREEN_SIZE_SGI 0x80DB |
| COLOR_TABLE_BLUE_SIZE_SGI 0x80DC |
| COLOR_TABLE_ALPHA_SIZE_SGI 0x80DD |
| COLOR_TABLE_LUMINANCE_SIZE_SGI 0x80DE |
| COLOR_TABLE_INTENSITY_SIZE_SGI 0x80DF |
| |
| Additions to Chapter 2 of the 1.0 Specification (OpenGL Operation) |
| |
| None |
| |
| Additions to Chapter 3 of the 1.0 Specification (Rasterization) |
| |
| The specification of color lookup tables is added to the GL Specification in |
| section 3.6.2, "Pixel Transfer Modes." A color lookup table is specified |
| using the ColorTableSGI command. Its <target> parameter must be |
| COLOR_TABLE_SGI, POST_CONVOLUTION_COLOR_TABLE_SGI, or |
| POST_COLOR_MATRIX_COLOR_TABLE_SGI if a color lookup table is to be |
| specified. (Optional target values PROXY_COLOR_TABLE_SGI, |
| PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI, and |
| PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI are described below.) Its <width> |
| parameter specifies the number of entries in the color lookup table, and its |
| <internalformat> parameter specifies the format of each table entry. The |
| error INVALID_VALUE results if <width> is not zero or a non-negative power |
| of two. The error TABLE_TOO_LARGE_EXT results if the specified color lookup |
| table is too large for the implementation. (See the PROXY discussion |
| below.) The error INVALID_ENUM results if <internalformat> is not one of |
| the values accepted by the <components> parameter of TexImage2D (as defined |
| by EXT_texture), or is 1, 2, 3, or 4. |
| |
| If no error results from the execution of ColorTableSGI, the specified color |
| lookup table is redefined to have <width> entries, each with the specified |
| internal format. The entries are indexed as zero through N-1, where N is |
| the <width> of the table. The values in the previous color lookup table, if |
| any, are lost. The new values are specified by the contents of the |
| 1-dimensional image pointed to by <table>, whose memory format and data type |
| are specified by <format> and <type>. The specified image is extracted from |
| memory and processed just as if DrawPixels were called, stopping after the |
| Final Expansion to RGBA step. The R, G, B, and A components of each pixel |
| are then scaled by the four COLOR_TABLE_SCALE_SGI parameters, then biased by |
| the four COLOR_TABLE_BIAS_SGI parameters. The R, G, B, and A values are |
| then clamped to [0,1]. The scale and bias parameters are specified by |
| calling ColorTableParameterivSGI or ColorTableParameterfvSGI with <target> |
| specifying one of the three color tables (COLOR_TABLE_SGI, |
| POST_CONVOLUTION_COLOR_TABLE_SGI, or POST_COLOR_MATRIX_COLOR_TABLE_SGI), |
| <pname> COLOR_TABLE_SCALE_SGI or COLOR_TABLE_BIAS_SGI, and <params> pointing |
| to a vector of four values: red, green, blue, and alpha, in that order. |
| |
| Each pixel is then converted to have the specified internal format. This |
| conversion simply maps the component values of the pixel (R, G, B, and A) to |
| the values included in the internal format (red, green, blue, alpha, |
| luminance, intensity). The mapping is as follows: |
| |
| Stored values |
| Base Internal ---------------------------------------- |
| Format red green blue alpha luminance intensity |
| ---------------- --- ----- ---- ----- --------- --------- |
| ALPHA A |
| LUMINANCE R |
| LUMINANCE_ALPHA A R |
| INTENSITY R |
| RGB R G B |
| RGBA R G B A |
| |
| (The relationship of internal format tokens to "base internal formats" is |
| described in EXT_texture.) |
| |
| It is acceptable for an implementation to vary its allocation of internal |
| component resolution based any ColorTableSGI parameter, but the allocation |
| must not be a function of any other factor, and cannot be changed once it is |
| established. In particular, allocations must be invariant -- the same |
| allocation must be made each time a color table is specified with the same |
| parameter values. Provision is made for an application to determine what |
| component resolutions are available without having to fully specify the |
| color table (see below). |
| |
| If EXT_copy_texture is supported, color tables can also be defined using |
| image data in the framebuffer. CopyColorTableSGI accepts image data from a |
| <width> pixel wide by one pixel high color buffer region whose lower-left |
| pixel has window coordinates <x>,<y>. If any pixels within this region are |
| outside the window that is associated with the GL context, the values |
| obtained for those pixels are undefined. |
| |
| These pixel values are obtained from the framebuffer exactly as if |
| ReadPixels had been called with <format> set to RGBA, with processing |
| continuing through Conversion of RGBA values. At this point all pixel |
| component values are treated exactly as if ColorTableSGI had been called, |
| beginning with the scaling of the color components by COLOR_TABLE_SCALE_SGI. |
| The semantics and accepted values of the <target> and <internalformat> |
| parameters are exactly equivalent to their ColorTableSGI counterparts. |
| |
| The operations of the color lookup tables are added to the GL Specification |
| in section 3.6.3, "Rasterization of Pixel Rectangles. The three lookup |
| tables exist at different points alongppp the pixel processing path. |
| COLOR_TABLE_SGI is located immediately after the subsection "Index Lookup", |
| and immediately prior to the convolution operation. |
| POST_CONVOLUTION_COLOR_TABLE_SGI is located immediately after the |
| convolution operation (including its scale and bias operations), and |
| immediately prior to the color matrix operation. Finally, |
| POST_COLOR_MATRIX_COLOR_TABLE_SGI is located immediately after the color |
| matrix operation (including its scale and bias operations) and immediately |
| prior to the histogram operation. Color tables are enabled and disabled by |
| calling Enable and Disable with color table name passed as the <cap> |
| parameter. Color table lookup is performed only for RGBA groups, though |
| these groups may have been specified as color indexes and converted to RGBA |
| by index-to-RGBA pixel map table. When enabled, a color lookup table is |
| applied to all RGBA pixel groups, regardless of the command that they are |
| associated with. These commands are DrawPixels, CopyPixels, ReadPixels, |
| TexImage1D, TexImage2D, GetTexImage, and the SGI extension commands |
| TexImage3DEXT, TexSubImage1DEXT, TexSubImage2DEXT, TexSubImage3DEXT, |
| CopyTexImage1DEXT, CopyTexImage2DEXT, CopyTexSubImage1DEXT, and |
| CopyTexSubImage2DEXT. |
| |
| If a color table is enabled, and its width is non-zero, then its contents |
| are used to replace a subset of the components of each RGBA pixel group, |
| based on the internal format of the table. The mappings that are applied |
| are: |
| |
| Components of a Pixel |
| Base Internal Format ------------------------------------- |
| of the Color Table R G B A |
| -------------------- - - - - |
| |
| ALPHA alpha |
| LUMINANCE luminance luminance luminance |
| LUMINANCE_ALPHA luminance luminance luminance alpha |
| INTENSITY intensity intensity intensity intensity |
| RGB red green blue |
| RGBA red green blue alpha |
| |
| Table E14.2 - Assignment of table component to pixel group |
| components. When there is no assignment, the pixel group component |
| is not changed by the table. |
| |
| The color components of each group that are being replaced by table values |
| are converted to indices by clamping the components to [0,1], multiplying |
| each by one less than the width of the color table, and rounding each to the |
| nearest integer. The component value (R, G, B, or A) is then replaced by |
| the value in color table indicated in table E14.2, at the computed index. |
| |
| If a zero-width color table is enabled, no change is made to the component |
| values of any pixel group. |
| |
| Query support |
| ------------- |
| |
| Alternate sets of partial color lookup table state are defined for the proxy |
| tables PROXY_COLOR_TABLE_SGI, PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI, and |
| PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI. Specifically, |
| COLOR_TABLE_FORMAT_SGI, COLOR_TABLE_WIDTH_SGI, COLOR_TABLE_RED_SIZE_SGI, |
| COLOR_TABLE_GREEN_SIZE_SGI, COLOR_TABLE_BLUE_SIZE_SGI, |
| COLOR_TABLE_ALPHA_SIZE_SGI, COLOR_TABLE_LUMINANCE_SIZE_SGI, and |
| COLOR_TABLE_INTENSITY_SIZE_SGI are maintained for proxy tables. When |
| ColorTableSGI is called with <target> set to one of these proxy values, |
| these proxy state values are always recomputed and updated, even if the |
| color table is too large to actually be defined. If the color table is too |
| large, all of these state variables are set to zero. If the color table |
| could be accommodated by ColorTableSGI called with <target> set to the |
| corresponding non-proxy target, these values are set as though that target |
| were being defined. (COLOR_TABLE_SGI is the non-proxy target corresponding |
| to proxy target PROXY_COLOR_TABLE_SGI, for example.) All of these state |
| values can be queried with GetColorTableParameterivSGI or |
| GetColorTableParameterfvSGI with <target> set to the appropriate proxy |
| target. Calling ColorTableSGI with a proxy <target> has no effect on the |
| image or state of any actual color table. |
| |
| There is no image associated with any of the proxy targets. Therefore |
| PROXY_COLOR_TABLE_SGI, PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI, and |
| PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI cannot be used as color tables, and |
| their images must never be queried using GetColorTableSGI. (The error |
| INVALID_ENUM results if this is attempted.) |
| |
| Additions to Chapter 4 of the 1.0 Specification (Per-Fragment Operations |
| and the Framebuffer) |
| |
| The operation of color table lookup during pixel copy and query operations |
| is identical to the operation during pixel drawing and texture image |
| definition. |
| |
| Additions to Chapter 5 of the 1.0 Specification (Special Functions) |
| |
| ColorTableSGI with a proxy target, GetColorTableSGI, |
| GetColorTableParameterivSGI, and GetColorTableParameterfvSGI are not |
| included in display lists, but are instead executed immediately. |
| |
| Additions to Chapter 6 of the 1.0 Specification (State and State Requests) |
| |
| Integer and floating point query functions GetColorTableParameterivSGI and |
| GetColorTableParameterfvSGI are provided. <target> must be COLOR_TABLE_SGI, |
| POST_CONVOLUTION_COLOR_TABLE_SGI, POST_COLOR_MATRIX_COLOR_TABLE_SGI, |
| PROXY_COLOR_TABLE_SGI, PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI, or |
| PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI. <pname> is one of |
| COLOR_TABLE_SCALE_SGI, COLOR_TABLE_BIAS_SGI, COLOR_TABLE_FORMAT_SGI, |
| COLOR_TABLE_WIDTH_SGI, COLOR_TABLE_RED_SIZE_SGI, COLOR_TABLE_GREEN_SIZE_SGI, |
| COLOR_TABLE_BLUE_SIZE_SGI, COLOR_TABLE_ALPHA_SIZE_SGI, |
| COLOR_TABLE_LUMINANCE_SIZE_SGI, or COLOR_TABLE_INTENSITY_SIZE_SGI. The |
| value of the specified parameter is returned in <params>. |
| |
| The current contents of a color table are queried using GetColorTableSGI. |
| <target> must be COLOR_TABLE_SGI, POST_CONVOLUTION_COLOR_TABLE_SGI, or |
| POST_COLOR_MATRIX_COLOR_TABLE_SGI. <format> must be one of RED, GREEN, |
| BLUE, ALPHA, RGB, RGBA, ABGR_EXT, LUMINANCE, or LUMINANCE_ALPHA. <type> |
| must be UNSIGNED_BYTE, BYTE, UNSIGNED_SHORT, SHORT, UNSIGNED_INT, INT, or |
| FLOAT. The 1-dimensional color table image is returned to <table>. No |
| pixel transfer operations are performed on this image, but pixel storage |
| modes that are applicable to ReadPixels are performed. Color components |
| that are requested in the specified <format>, but which are not included in |
| the internal format of the color lookup table, are returned as zero. The |
| assignments of internal color components to the components requested by |
| <format> are: |
| |
| internal component resulting component |
| ------------------ ------------------- |
| red red |
| green green |
| blue blue |
| alpha alpha |
| luminance red |
| intensity red |
| |
| Additions to the GLX Specification |
| |
| None |
| |
| |
| GLX Protocol |
| |
| Seven new GL commands are added. |
| |
| The following three rendering commands are sent to the server as part of |
| a glXRender request: |
| |
| CopyColorTableSGI |
| 2 24 rendering command length |
| 2 2056 rendering command opcode |
| 4 ENUM target |
| 4 ENUM internalformat |
| 4 INT32 x |
| 4 INT32 y |
| 4 INT32 width |
| |
| ColorTableParameterivSGI |
| 2 12+4*n rendering command length |
| 2 2055 rendering command opcode |
| 4 ENUM target |
| 4 ENUM pname |
| 0x80D6 n=4 COLOR_TABLE_SCALE_SGI |
| 0x80D7 n=4 COLOR_TABLE_BIAS_SGI |
| 4*n LISTofINT32 params |
| |
| ColorTableParameterfvSGI |
| 2 12+4*n rendering command length |
| 2 2054 rendering command opcode |
| 4 ENUM target |
| 4 ENUM pname |
| 0x80D6 n=4 COLOR_TABLE_SCALE_SGI |
| 0x80D7 n=4 COLOR_TABLE_BIAS_SGI |
| 4*n LISTofFLOAT32 params |
| |
| The following rendering command contain pixel data and is thus |
| sent to the server as part of a glXRender request or as part of a |
| glXRenderLarge request: |
| |
| ColorTableSGI |
| 2 44+n+p rendering command length |
| 2 2053 rendering command opcode |
| 1 BOOL swap_bytes |
| 1 BOOL lsb_first |
| 2 unused |
| 4 CARD32 row_length |
| 4 CARD32 skip_rows |
| 4 CARD32 skip_pixels |
| 4 CARD32 alignment |
| 4 ENUM target |
| 4 ENUM internalformat |
| 4 INT32 width |
| 4 ENUM format |
| 4 ENUM type |
| n LISTofBYTE table |
| p unused, p=pad(n) |
| |
| If the command is encoded in a glXRenderLarge request, the |
| command opcode and command length fields above are expanded to |
| 4 bytes each: |
| 4 48+n+p rendering command length |
| 4 2053 rendering command opcode |
| |
| If <width> < 0, <format> is invalid or <type> is invalid, then the |
| command is erroneous and n=0. The structure of <table> is described |
| in Appendix A of the GLX Protocol Specification, "Pixel Data", using |
| the parameters <swap_bytes>, <lsb_first>, <row_length>, <skip_rows>, |
| <skip_pixels>, <alignment>, <width>, <format>, and <type> as given |
| in the request, and a height of 1. |
| |
| |
| The remaining commands are non-rendering commands. These commands are |
| sent separately (i.e., not as part of a glXRender or glXRenderLarge |
| request), using the glXVendorPrivateWithReply request: |
| |
| GetColorTableParameterivSGI |
| 1 CARD8 opcode (X assigned) |
| 1 17 GLX opcode (glXVendorPrivateWithReply) |
| 2 5 request length |
| 4 4100 vendor specific opcode |
| 4 GLX_CONTEXT_TAG context tag |
| 4 ENUM target |
| 4 ENUM pname |
| => |
| 1 1 reply |
| 1 unused |
| 2 CARD16 sequence number |
| 4 m reply length, m = (n==1 ? 0 : n) |
| 4 unused |
| 4 CARD32 n |
| |
| this follows: |
| |
| 16 unused |
| n*4 LISTofINT32 params |
| |
| Note that n may be zero, indicating that a GL error occurred. |
| |
| |
| GetColorTableParameterfvSGI |
| 1 CARD8 opcode (X assigned) |
| 1 17 GLX opcode (glXVendorPrivateWithReply) |
| 2 5 request length |
| 4 4099 vendor specific opcode |
| 4 GLX_CONTEXT_TAG context tag |
| 4 ENUM target |
| 4 ENUM pname |
| => |
| 1 1 reply |
| 1 unused |
| 2 CARD16 sequence number |
| 4 m reply length, m = (n==1 ? 0 : n) |
| 4 unused |
| 4 CARD32 n |
| |
| this follows: |
| |
| 16 unused |
| n*4 LISTofFLOAT32 params |
| |
| Note that n may be zero, indicating that a GL error occurred. |
| |
| |
| GetColorTableSGI |
| 1 CARD8 opcode (X assigned) |
| 1 17 GLX opcode (glXVendorPrivateWithReply) |
| 2 7 request length |
| 4 4098 vendor specific opcode |
| 4 GLX_CONTEXT_TAG context tag |
| 4 ENUM target |
| 4 ENUM format |
| 4 ENUM type |
| 1 BOOL swap_bytes |
| 3 unused |
| => |
| 1 1 reply |
| 1 unused |
| 2 CARD16 sequence number |
| 4 n reply length |
| 8 unused |
| 4 INT32 width |
| 4 INT32 height |
| 8 unused |
| 4*n LISTofBYTE table |
| |
| Note that n may be zero, indicating that a GL error occurred. |
| |
| If <format> or <type> is invalid then the command is erroneous and |
| n=0. The structure of <table> is described in Appendix A of the GLX |
| Protocol Specification, "Pixel Data", using the parameters |
| <swap_bytes>, <format>, and <type>. No extra padding is needed after |
| <pixels> because the image format already pads to 32 bits. |
| |
| |
| Dependencies on EXT_abgr |
| |
| If EXT_abgr is supported, the <format> parameters of ColorTableSGI and |
| GetColorTableSGI accept ABGR_EXT. Otherwise they do not. |
| |
| Dependencies on EXT_texture |
| |
| EXT_texture is required. This extension builds on the notion of internal |
| image format, which is defined by EXT_texture. |
| |
| Dependencies on EXT_texture3D |
| |
| If EXT_texture3D is not supported, references to TexImage3DEXT are invalid |
| and should be ignored. |
| |
| Dependencies on EXT_subtexture |
| |
| If EXT_subtexture is not supported, references to TexSubImage1DEXT, |
| TexSubImage2DEXT, TexSubImage3DEXT, CopyTexSubImage1DEXT, and |
| CopyTexSubImage2DEXT are invalid and should be ignored. |
| |
| Dependencies on EXT_copy_texture |
| |
| If EXT_copy_texture is not supported, CopyColorTableSGI is not supported, |
| and references to CopyTexImage1DEXT, CopyTexImage2DEXT, |
| CopyTexSubImage1DEXT, and CopyTexSubImage2DEXT are invalid and should be |
| ignored. |
| |
| Dependencies on EXT_convolution |
| |
| If EXT_convolution is not supported, targets |
| POST_CONVOLUTION_COLOR_TABLE_SGI and PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI |
| are not defined by this specification. |
| |
| Dependencies on SGI_color_matrix |
| |
| If SGI_color_matrix is not supported, targets |
| POST_COLOR_MATRIX_COLOR_TABLE_SGI and |
| PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI are not defined by this |
| specification. |
| |
| Errors |
| |
| INVALID_ENUM is generated if ColorTableSGI parameter <target> is not |
| COLOR_TABLE_SGI, POST_CONVOLUTION_COLOR_TABLE_SGI, |
| POST_COLOR_MATRIX_COLOR_TABLE_SGI, PROXY_COLOR_TABLE_SGI, |
| PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI, or |
| PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI. |
| |
| INVALID_ENUM is generated if ColorTableSGI parameter <internalformat> is not |
| ALPHA, RGB, RGBA, LUMINANCE, LUMINANCE_ALPHA, or one of the tokens defined |
| by EXT_texture. |
| |
| INVALID_VALUE is generated if ColorTableSGI parameter <width> is not zero or |
| a non-negative power of two. |
| |
| INVALID_ENUM is generated if ColorTableSGI parameter <format> is not RED, |
| GREEN, BLUE, ALPHA, RGB, RGBA, ABGR_EXT, LUMINANCE, or LUMINANCE_ALPHA. |
| |
| INVALID_ENUM is generated if ColorTableSGI parameter <type> is not BYTE, |
| UNSIGNED_BYTE, SHORT, UNSIGNED_SHORT, INT, UNSIGNED_INT, or FLOAT. |
| |
| INVALID_ENUM is generated if CopyColorTableSGI parameter <target> is not |
| COLOR_TABLE_SGI, POST_CONVOLUTION_COLOR_TABLE_SGI, or |
| POST_COLOR_MATRIX_COLOR_TABLE_SGI. |
| |
| INVALID_ENUM is generated if CopyColorTableSGI parameter <internalformat> is |
| not ALPHA, RGB, RGBA, LUMINANCE, LUMINANCE_ALPHA, or one of the tokens |
| defined by EXT_texture. |
| |
| INVALID_VALUE is generated if CopyColorTableSGI parameter <width> is not |
| zero or a non-negative power of two. |
| |
| INVALID_ENUM is generated if GetColorTableSGI parameter <target> is not |
| COLOR_TABLE_SGI, POST_CONVOLUTION_COLOR_TABLE_SGI, or |
| POST_COLOR_MATRIX_COLOR_TABLE_SGI. |
| |
| INVALID_ENUM is generated if GetColorTableSGI parameter <format> is not RED, |
| GREEN, BLUE, ALPHA, RGB, RGBA, ABGR_EXT, LUMINANCE, or LUMINANCE_ALPHA. |
| |
| INVALID_ENUM is generated if GetColorTableSGI parameter <type> is not BYTE, |
| UNSIGNED_BYTE, SHORT, UNSIGNED_SHORT, INT, UNSIGNED_INT, or FLOAT. |
| |
| INVALID_ENUM is generated if ColorTableParameterivSGI or |
| ColorTableParameterfvSGI parameter <target> is not COLOR_TABLE_SGI, |
| POST_CONVOLUTION_COLOR_TABLE_SGI, or POST_C0LOR_MATRIX_COLOR_TABLE_SGI. |
| |
| INVALID_ENUM is generated if ColorTableParameterivSGI or |
| ColorTableParameterfvSGI parameter <pname> is not COLOR_TABLE_SCALE_SGI or |
| COLOR_TABLE_BIAS_SGI. |
| |
| INVALID_ENUM is generated if GetColorTableParameterivSGI or |
| GetColorTableParameterfvSGI parameter <target> is not COLOR_TABLE_SGI, |
| POST_CONVOLUTION_COLOR_TABLE_SGI, POST_COLOR_MATRIX_COLOR_TABLE_SGI, |
| PROXY_COLOR_TABLE_SGI, PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI, or |
| PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI. |
| |
| INVALID_ENUM is generated if GetColorTableParameterivSGI or |
| GetColorTableParameterfvSGI parameter <pname> is not COLOR_TABLE_SCALE_SGI, |
| COLOR_TABLE_BIAS_SGI, COLOR_TABLE_FORMAT_SGI, COLOR_TABLE_WIDTH_SGI, |
| COLOR_TABLE_RED_SIZE_SGI, COLOR_TABLE_GREEN_SIZE_SGI, |
| COLOR_TABLE_BLUE_SIZE_SGI, COLOR_TABLE_ALPHA_SIZE_SGI, |
| COLOR_TABLE_LUMINANCE_SIZE_SGI, or COLOR_TABLE_INTENSITY_SIZE_SGI. |
| INVALID_ENUM is also generated if GetColorTableParameterivSGI or |
| GetColorTableParameterfvSGI parameter <target> specifies a proxy table |
| target and <pname> specifies a piece of state which is not maintained for |
| proxy tables. |
| |
| TABLE_TOO_LARGE_EXT is generated if the color table requested by |
| ColorTableSGI or CopyColorTableSGI is larger than can be supported by the |
| implementation, and the <target> parameter is COLOR_TABLE_SGI, |
| POST_CONVOLUTION_COLOR_TABLE_SGI, or POST_COLOR_MATRIX_COLOR_TABLE_SGI. |
| |
| INVALID_OPERATION is generated if ColorTableSGI, CopyColorTableSGI, |
| ColorTableParameterivSGI, ColorTableParameterfvSGI, GetColorTableSGI, |
| GetColorTableParameterivSGI, or GetColorTableParameterfvSGI is called |
| between execution of Begin and the corresponding execution of End. |
| |
| New State |
| |
| Get Value Get Command Type Initial Value Attribute |
| --------- ----------- ---- ------------- --------- |
| COLOR_TABLE_SGI IsEnabled B False pixel/enable |
| POST_CONVOLUTION_COLOR_TABLE_SGI IsEnabled B False pixel/enable |
| POST_COLOR_MATRIX_COLOR_TABLE_SGI IsEnabled B False pixel/enable |
| COLOR_TABLE GetColorTableSGI 3 x I empty - |
| COLOR_TABLE_FORMAT_SGI GetColorTableParameterivSGI 2 x 3 x Z38 RGBA - |
| COLOR_TABLE_WIDTH_SGI GetColorTableParameterivSGI 2 x 3 x Z+ 0 - |
| COLOR_TABLE_RED_SIZE_SGI GetColorTableParameterivSGI 2 x 3 x Z+ 0 - |
| COLOR_TABLE_GREEN_SIZE_SGI GetColorTableParameterivSGI 2 x 3 x Z+ 0 - |
| COLOR_TABLE_BLUE_SIZE_SGI GetColorTableParameterivSGI 2 x 3 x Z+ 0 - |
| COLOR_TABLE_ALPHA_SIZE_SGI GetColorTableParameterivSGI 2 x 3 x Z+ 0 - |
| COLOR_TABLE_LUMINANCE_SIZE_SGI GetColorTableParameterivSGI 2 x 3 x Z+ 0 - |
| COLOR_TABLE_INTENSITY_SIZE_SGI GetColorTableParameterivSGI 2 x 3 x Z+ 0 - |
| COLOR_TABLE_SCALE_SGI GetColorTableParameterfvSGI 3 x R4 (1,1,1,1) pixel |
| COLOR_TABLE_BIAS_SGI GetColorTableParameterfvSGI 3 x R4 (0,0,0,0) pixel |
| |
| New Implementation Dependent State |
| |
| None |
| |
| Revision History |
| |
| 2006/08/24 - Fixed protocol for GetColorTableSGI per Ian Romanick |
| (opcode was used as the request length). |
