| Name |
| |
| ARB_texture_compression |
| |
| Name Strings |
| |
| GL_ARB_texture_compression |
| |
| Contact |
| |
| Pat Brown, Intel Corporation (patrick.r.brown 'at' intel.com) |
| |
| Notice |
| |
| Copyright (c) 2000-2013 The Khronos Group Inc. Copyright terms at |
| http://www.khronos.org/registry/speccopyright.html |
| |
| Specification Update Policy |
| |
| Khronos-approved extension specifications are updated in response to |
| issues and bugs prioritized by the Khronos OpenGL Working Group. For |
| extensions which have been promoted to a core Specification, fixes will |
| first appear in the latest version of that core Specification, and will |
| eventually be backported to the extension document. This policy is |
| described in more detail at |
| https://www.khronos.org/registry/OpenGL/docs/update_policy.php |
| |
| Status |
| |
| Complete. Approved by ARB on March 16, 2000 |
| |
| Version |
| |
| Last Modified Date: May 23, 2000 |
| Author Revision: 1.03 |
| |
| Number |
| |
| ARB Extension #12 |
| |
| Dependencies |
| |
| OpenGL 1.1 is required. |
| |
| This extension is written against the OpenGL 1.2.1 Specification. |
| |
| This extension is written against the GLX Extensions for OpenGL |
| Specification (Version 1.3). |
| |
| Depends on GL_ARB_texture_cube_map, as cube maps may be stored in |
| compressed form. |
| |
| Overview |
| |
| Compressing texture images can reduce texture memory utilization and |
| improve performance when rendering textured primitives. This extension |
| allows OpenGL applications to use compressed texture images by providing: |
| |
| (1) A framework upon which extensions providing specific compressed |
| image formats can be built. |
| |
| (2) A set of generic compressed internal formats that allow |
| applications to specify that texture images should be stored in |
| compressed form without needing to code for specific compression |
| formats. |
| |
| An application can define compressed texture images by providing a texture |
| image stored in a specific compressed image format. This extension does |
| not define any specific compressed image formats, but it does provide the |
| mechanisms necessary to enable other extensions that do. |
| |
| An application can also define compressed texture images by providing an |
| uncompressed texture image but specifying a compressed internal format. |
| In this case, the GL will automatically compress the texture image using |
| the appropriate image format. Compressed internal formats can either be |
| specific (as above) or generic. Generic compressed internal formats are |
| not actual image formats, but are instead mapped into one of the specific |
| compressed formats provided by the GL (or to an uncompressed base internal |
| format if no appropriate compressed format is available). Generic |
| compressed internal formats allow applications to use texture compression |
| without needing to code to any particular compression algorithm. Generic |
| compressed formats allow the use of texture compression across a wide |
| range of platforms with differing compression algorithms and also allow |
| future GL implementations to substitute improved compression methods |
| transparently. |
| |
| Compressed texture images can be obtained from the GL in uncompressed form |
| by calling GetTexImage and in compressed form by calling |
| GetCompressedTexImageARB. Queried compressed images can be saved and |
| later reused by calling CompressedTexImage[123]DARB. Pre-compressed |
| texture images do not need to be processed by the GL and should |
| significantly improve texture loading performance relative to uncompressed |
| images. |
| |
| This extension does not define specific compressed image formats (e.g., |
| S3TC, FXT1), nor does it provide means to encode or decode such images. |
| To support images in a specific compressed format, a hardware vendor |
| would: |
| |
| (1) Provide a new extension defininig specific compressed |
| <internalformat> and <format> tokens for TexImage[123]D, |
| TexSubImage[123]D, CopyTexImage[12]D, CompressedTexImage[123]DARB, |
| CompressedTexSubImage[123]DARB, and GetCompressedTexImageARB calls. |
| |
| (2) Specify the encoding of compressed images of that specific format. |
| |
| (3) Specify a method for deriving the size of compressed images of that |
| specific format, using the <internalformat>, <width>, <height>, |
| <depth> parameters, and (if necessary) the compressed image itself. |
| |
| IP Status |
| |
| No known intellectual property issues on this general extension. |
| |
| Specific compression algorithms used to implement this extension (and any |
| other specific texture compression extensions) may be protected and |
| require licensing agreements. |
| |
| Issues |
| |
| (1) Should we define additional internal formats that strongly tie an |
| underlying compression algorithm to the format? |
| |
| RESOLVED: Not here. Explicit compressed formats will be provided by |
| other extensions built on top of this one. |
| |
| (2) Should we provide additional compression state that gives more control |
| on the level/quality of compression? If so, how? |
| |
| RESOLVED: Yes, as a hint. Could have also been implemented as a [0.0, |
| 1.0] floating-point TexParameter "quality" state variable (such as the |
| JPEG quality scale found in many apps). This control will affect only |
| the speed (and quality) with which a driver compresses incoming images, |
| but will not affect the compressed image format selected by the driver. |
| |
| As the spec is currently formulated, the requirement that quality |
| control not affect compression format selection could have been relaxed |
| by loosening the invariance requirements (so that the quality control |
| can affect the choice of internal format). The risk was the potential |
| for subtle mipmap consistency issues if the hint changes. |
| |
| (3) Most current compression algorithms handle primarily RGB and RGBA |
| images. Does it make sense having generic compressed formats for alpha, |
| intensity, luminance, and luminance-alpha? |
| |
| RESOLVED: Yes. It is conceivable that some or all of these formats may |
| be compressed. Implementations not having compression algorithms for |
| these formats can simply choose not to compress and use the appropriate |
| base internal format instead. |
| |
| (4) Full GetTexImage support requires that the renderer decompress the |
| whole image. Should this extra implementation burden be imposed on the |
| renderer? |
| |
| RESOLVED: Yes, returning the uncompressed image is a useful feature for |
| evaluating the quality of the compressed image. A decompression engine |
| may also be required for a number of other areas, including software |
| rasterization. |
| |
| (5) Full TexSubImage support may require that the renderer decompress |
| portions of the image (or perhaps the whole image), do a merge, and then |
| recompress. Even if this were done, portions of the image outside the |
| "modified" area may also be modified due to lossy compression. Should this |
| extra implementation burden be imposed on the renderer? |
| |
| RESOLVED: No. To avoid the complications involved with modifying a |
| compressed texture image, only the lower-left corner may be modified by |
| TexSubImage. In addition, after calling TexSubImage, the "unmodified" |
| portion of the image is left undefined. An INVALID_OPERATION error |
| results from any other TexSubImage calls. |
| |
| This behavior allows for the use of compressed images whose dimensions |
| are not powers of two, which TexImage will not accept. The recommended |
| sequence of calls for defining such images is to first call TexImage |
| with a NULL <data> pointer and the image size parameters padded out to |
| the next power of two, and then call CompressedTexSubImageARB or |
| TexSubImage with <xoffset>, <yoffset>, and <zoffset> parameters of zero |
| and the compressed data pointed to by <data>. This behavior also allows |
| TexSubImage to be used as a light-weight replacement of TexImage, where |
| only the image contents are modified. |
| |
| Certain compressed formats may allow a wider variety of edits -- their |
| specifications will document the restrictions under which these edits |
| are permitted. it is impossible to document such restrictions for |
| unknown generic formats. It is desirable to keep the behavior of |
| generic formats and the specific formats they map to as consistent as |
| possible. |
| |
| (6) What do the return values of the component sizes (RED_BITS, |
| GREEN_BITS, ...) give for compressed textures? Compressed proxy textures? |
| |
| RESOLVED: Some behavior has to be defined. For both normal and proxy |
| textures, we return the bit depths of an uncompressed sized image that |
| would most closely match the quality of the compression algorithm for an |
| "average" texture image. Since compressed image quality is highly data |
| dependent, the actual compressed image quality may be better or worse |
| than the renderer's best guess at the best matching sized internal |
| format. To implement this feature in a driver, it is expected that an |
| error analysis would be done on a set of representative images, and the |
| resultant "equivalent bit depths" would be hardwired constants. |
| |
| (7) What should GetTexLevelParameter with TEXTURE_COMPRESSED_ |
| IMAGE_SIZE_ARB return for existing uncompressed formats? For proxy |
| textures? |
| |
| RESOLVED: For both, an INVALID_OPERATION error results. The actual |
| image to be compressed is not available for proxies, so actually |
| compressing the specified image is not an option. |
| |
| For uncompressed internal formats, we could return the actual amount of |
| memory taken by the texture image. Such a mechanism might be useful as |
| a metric of "how much space does this texture image take". It's not |
| particularly useful for an application based texture management scheme, |
| since there is no information available indicating the amount of |
| available memory. In addition, because of implementation-dependent |
| hardware constraints, the amount of texture memory consumed by a texture |
| object is not necessarily equal to the sum of the memory consumed by |
| each of its mipmaps. The OpenGL ARB decided against adopting this |
| behavior when this specification was approved. |
| |
| (8) What about texture borders? |
| |
| RESOLVED: Not a problem for generic compressed formats since a base |
| internal format can be used if borders are not supported in the |
| compressed image format. Borders may pose problems for specific |
| compression extensions, and compressed textures with borders might well |
| be disallowed by those extensions. |
| |
| (9) Should certain pixel operations be disallowed for compressed texture |
| internal formats (e.g., PixelStorage, PixelTransfer)? What about byte |
| swapping? |
| |
| RESOLVED: For uncompressed source images, all pixel storage and pixel |
| transfer modes will be applied prior to compression. For compressed |
| source images, all pixel storage and transfer modes will be ignored. |
| The encoding of compressed images should be specified as a byte stream |
| that matches the disk file format defined for the corresponding image |
| type. |
| |
| (10) Should functionality be provided to allow applications to save |
| compressed images to disk and reuse them in subsequent runs without |
| programming to specific formats? If so, how? |
| |
| RESOLVED: Yes. This can be done without knowledge of specific |
| compression formats in the following manner: |
| |
| * Call TexImage with an uncompressed image and a generic compressed |
| internal format. The texture image will be compressed by the GL, if |
| possible. |
| |
| * Call GetTexLevelParameteriv with a <value> of TEXTURE_COMPRESSED_ARB |
| to determine if the GL was able to store the image in compressed |
| form. |
| |
| * Call GetTexLevelParameteriv with a <value> of |
| TEXTURE_INTERNAL_FORMAT to determine the specific compressed image |
| format in which the image is stored. |
| |
| * Call GetTexLevelParameteriv with a <value> of |
| TEXTURE_COMPRESSED_IMAGE_SIZE_ARB to determine the size (in ubytes) |
| of the compressed image that will be returned by the GL. Allocate a |
| buffer of at least this size. |
| |
| * Call GetCompressedTexImageARB. The GL will write the compressed |
| texture image into the allocated buffer. |
| |
| * Save the returned compressed image to disk, along with the |
| associated width, height, depth, border parameters and the returned |
| values of TEXTURE_COMPRESSED_IMAGE_SIZE_ARB and |
| TEXTURE_INTERNAL_FORMAT. |
| |
| * Load the compressed image and its parameters, and call |
| CompressedTexImage_[123]DARB to use the compressed image. The value |
| of TEXTURE_INTERNAL_FORMAT should be used as <internalFormat> and |
| the value of TEXTURE_COMPRESSED_IMAGE_SIZE_ARB should be used as |
| <imageSize>. |
| |
| The saved images will be valid as long as they are used on a device |
| supporting the returned <internalFormat> parameter. If the saved images |
| are used on a device that does not support the compressed internal |
| format, an INVALID_ENUM error would be generated by the call to |
| CompressedTexImage_[123]D because of the unknown format. |
| |
| Note also that to reliably determine if the GL will compress an image |
| without actually compressing it, an application need only define a proxy |
| texture image and query TEXTURE_COMPRESSED_ARB as above. |
| |
| (11) Without knowing of the compressed image format, there is no |
| convenient way for the client-side GLX library or tracing tools to |
| ascertain the size of a compressed texture image when sending a |
| TexImage1D, TexImage2D, or TexImage3D packet or interpret pixel storage |
| modes. To complicate matters further, it is possible to create both |
| indirect (that might not understand an image format) and direct rendering |
| contexts (that might understand an image format) on the same renderer. |
| How should this be solved? |
| |
| RESOLVED: A separate set of CompressedTexImage and |
| CompressedTexSubImage calls has been created that allows libraries to |
| pass compressed images along to the renderer without needing to |
| understand their specific image formats or how to interpret pixel |
| storage modes. |
| |
| (12) Are the CompressedTexImage[123]DARB entry points really needed? |
| |
| RESOLVED: Yes. To robustly support images of unknown format, specific |
| compressed entry points are required. While the extension does not |
| support images in a completely unspecified format (early drafts did), |
| having a separate call means that GLX and tools such as GLS (stream |
| encoder) do not need intimate knowledge of every compressed image |
| format. Having separate calls also cleanly solves the problem where |
| pixel storage and pixel transfer operations apply if and only if the |
| source image is uncompressed. |
| |
| (13) Is variable-ratio compression supported? |
| |
| RESOLVED: Yes. Fixed-ratio compression is currently the predominant |
| texture compression format, but this spec should not preclude the use of |
| other compression schemes. |
| |
| (14) Should the <imageSize> parameter be validated on CompressedTexImage |
| calls? |
| |
| RESOLVED: Yes. Enforcement overhead is generally trivial. Without |
| enforcement, an application could specify incorrect image sizes but |
| notice them only when run on an indirect renderer, causing portability |
| problems. There is also a reliability issue with respect to the GLX |
| environment -- if the compressed image size provided by the user is less |
| than the required image size, the GLX server may run off the end of the |
| image and access invalid memory. A size check may thus be desirable to |
| prevent server crashes (even though that could be considered an |
| "undefined" result). |
| |
| While enforcing correct <imageSize> parameters is trivial for current |
| compressed internal formats, it might not be reasonable on others |
| (particular variable-ratio compression formats). For such formats, this |
| restriction should be overridden in the spec defining the formats. The |
| <imageSize> check was made mandatory only in the final draft approved at |
| the March 2000 OpenGL ARB meeting. |
| |
| (15) Should TexImage calls fall back to uncompressed image formats when |
| <internalformat> is a specific compressed format but its use in |
| combination with other parameter values passed is not supported by the |
| renderer? |
| |
| RESOLVED: Yes. Advantages: Works in exactly the same way as generic |
| formats, meaning no extra code/error checking. Inherent limitations of |
| TexImage on specific formats should be documented in their specs and |
| observed by their users. One simple query can detect fallback cases. |
| Disadvantages: Silent fallback to a format not requested by the user. |
| |
| (16) Should the texture format invariance requirements disallow scanning |
| of the image data to select a compression method? What about for a base |
| (uncompressed) internal format? |
| |
| RESOLVED: The primary issue is mipmap consistency. The 1.2.1 spec |
| defines a set of mipmaps as consistent if all are specified using the |
| same internal format. However, it doesn't require that all mipmaps are |
| allocated using the same format -- the renderer is responsible for |
| ensuring mipmap consistency if it selects different formats for |
| different images. There is no reason to disallow scanning for base |
| internal formats; the renderer is responsible for doing the right thing. |
| |
| The selection of a specific compressed internal format is different. It |
| must be independent of the the image data because the GL treats the |
| texture image as though it were specified using the specific compressed |
| internal format chosen by the renderer. |
| |
| (17) Should functionality be provided to enumerate the specific compressed |
| formats supported by the renderer? If so, how and what will it accomplish? |
| |
| RESOLVED: Yes. A glGet* query is added to return the number of |
| compressed internal formats supported by the renderer and the |
| <internalformat> tokens for each. These tokens can subsequently be used |
| as <internalformat> parameters for normal TexImage calls and the new |
| CompressedTexImage calls. |
| |
| Providing an internal format enumeration allows applications to weigh |
| the suitability of the various compression methods provided to it by the |
| renderer without needing specific knowledge of the formats. |
| Applications can query the component sizes (see issue 6) to determine |
| the base format and approximate precision. Applications can directly |
| evaluate image compression quality by having the renderer generate |
| compressed texture images (using the returned <internalformat> values) |
| and return them in uncompressed form using GetTexImage. Applications |
| should also be aware that the use of the internal formats returned by |
| this query is subject to the restrictions imposed by the specification |
| defining them. The use of proxy textures allows the application to |
| determine if a specific set of TexImage parameters is supported for a |
| given internal format. |
| |
| The renderer should enumerate all supported compression formats EXCEPT |
| those that operate fundamentally differently from a normal uncompressed |
| format. For example, the DirectX DXT1 compression format is |
| fundamentally an RGB format, but it has a "transparent" encoding where |
| the red, green, and blue component values are forced to zero, regardless |
| of their original (uncompressed) values. Since such formats may have |
| caveats that must be understood before being used, they should not be |
| enumerated by this query. |
| |
| This allows for forward compatibility -- an application can exploit |
| compression techniques provided by future renderers. |
| |
| (18) Should the separate GetCompressedTexImageARB function exist, or is |
| GetTexImage with special <format> and/or <type> parameters |
| sufficient? |
| |
| RESOLVED: Provide a separate GetCompressedTexImageARB function. The |
| primary rationale is for GLX indirect rendering. The client GetTexImage |
| would require information to determine if an image is uncompressed (and |
| should be decoded using pixel storage state) or compressed (pixel |
| storage ignored). In addition, if the image is compressed, the actual |
| image size would be required, but the only image size that could be |
| inferred from the GLX protocol is padded out to a multiple of four |
| bytes. A separate call is the cleanest solution to both issues. |
| |
| New Procedures and Functions |
| |
| void CompressedTexImage3DARB(enum target, int level, |
| enum internalformat, sizei width, |
| sizei height, sizei depth, |
| int border, sizei imageSize, |
| const void *data); |
| void CompressedTexImage2DARB(enum target, int level, |
| enum internalformat, sizei width, |
| sizei height, int border, |
| sizei imageSize, const void *data); |
| void CompressedTexImage1DARB(enum target, int level, |
| enum internalformat, sizei width, |
| int border, sizei imageSize, |
| const void *data); |
| void CompressedTexSubImage3DARB(enum target, int level, |
| int xoffset, int yoffset, |
| int zoffset, sizei width, |
| sizei height, sizei depth, |
| enum format, sizei imageSize, |
| const void *data); |
| void CompressedTexSubImage2DARB(enum target, int level, |
| int xoffset, int yoffset, |
| sizei width, sizei height, |
| enum format, sizei imageSize, |
| const void *data); |
| void CompressedTexSubImage1DARB(enum target, int level, |
| int xoffset, sizei width, |
| enum format, sizei imageSize, |
| const void *data); |
| void GetCompressedTexImageARB(enum target, int lod, |
| void *img); |
| |
| New Tokens |
| |
| Accepted by the <internalformat> parameter of TexImage1D, TexImage2D, |
| TexImage3D, CopyTexImage1D, and CopyTexImage2D: |
| |
| COMPRESSED_ALPHA_ARB 0x84E9 |
| COMPRESSED_LUMINANCE_ARB 0x84EA |
| COMPRESSED_LUMINANCE_ALPHA_ARB 0x84EB |
| COMPRESSED_INTENSITY_ARB 0x84EC |
| COMPRESSED_RGB_ARB 0x84ED |
| COMPRESSED_RGBA_ARB 0x84EE |
| |
| Accepted by the <target> parameter of Hint and the <value> parameter of |
| GetIntegerv, GetBooleanv, GetFloatv, and GetDoublev: |
| |
| TEXTURE_COMPRESSION_HINT_ARB 0x84EF |
| |
| Accepted by the <value> parameter of GetTexLevelParameter: |
| |
| TEXTURE_COMPRESSED_IMAGE_SIZE_ARB 0x86A0 |
| TEXTURE_COMPRESSED_ARB 0x86A1 |
| |
| Accepted by the <value> parameter of GetIntegerv, GetBooleanv, GetFloatv, |
| and GetDoublev: |
| |
| NUM_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A2 |
| COMPRESSED_TEXTURE_FORMATS_ARB 0x86A3 |
| |
| 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) |
| |
| Modify Section 3.8.1, Texture Image Specification (p.113) |
| |
| (p.113, modify 3rd paragraph) <internalformat> may be specified as one of |
| the six base internal format symbolic constants listed in table 3.15, as |
| one of the sized internal format symbolic constants listed in table 3.16, |
| as one of the specific compressed internal format symbolic constants |
| listed in table 3.16.1, or as one of the six generic compressed internal |
| format symbolic constants listed in table 3.16.2. |
| |
| (p.113, add after 3rd paragraph) |
| |
| The ARB_texture_compression specification provides no specific compressed |
| internal formats but does provide a mechanism to obtain the enums for such |
| formats provided by other specifications. If the ARB_texture_compression |
| extension is supported, the number of specific compressed internal format |
| symbolic constants supported by the renderer can be obtained by querying |
| the value of NUM_COMPRESSED_TEXTURE_FORMATS_ARB. The set of specific |
| compressed internal format symbolic constants supported by the renderer |
| can be obtained by querying the value of COMPRESSED_TEXTURE_FORMATS_ARB. |
| The only symbolic constants returned by this query are those suitable for |
| general-purpose usage. The renderer will not enumerate formats with |
| restrictions that need to be specifically understood prior to use. |
| |
| Generic compressed internal formats are never used directly as the |
| internal formats of texture images. If <internalformat> is one of the six |
| generic compressed internal formats, its value is replaced by the symbolic |
| constant for a specific compressed internal format of the GL's choosing |
| with the same base internal format. If no specific compressed format is |
| available, <internalformat> is instead replaced by the corresponding base |
| internal format. If <internalformat> is given as or mapped to a specific |
| compressed internal format, but the GL can not support images compressed |
| in the chosen internal format for any reason (e.g., the compression format |
| might not support 3D textures or borders), <internalformat> is replaced by |
| the corresponding base internal format and the texture image will not be |
| compressed by the GL. |
| |
| (p.113, modify 4th paragraph) ... If a compressed internal format is |
| specified, the mapping of the R, G, B, and A values to texture components |
| is equivalent to the mapping of the corresponding base internal format's |
| components, as specified in table 3.15. The specified image is compressed |
| using a (possibly lossy) compression algorithm chosen by the GL. |
| |
| (p.113, 5th paragraph) A GL implementation may vary its allocation of |
| internal component resolution or compressed internal format based on any |
| TexImage3D, TexImage2D, or TexImage1D (see below) parameter (except |
| <target>, but the allocation and chosen compressed image format must not |
| be a function of any other state and cannot be changed once they are |
| established. In addition, the choice of a compressed image format may not |
| be affected by the <data> parameter. Allocations must be invariant; the |
| same allocation and compressed image format must be chosen each time a |
| texture image is specified with the same parameter values. These |
| allocation rules also apply to proxy textures, which are described in |
| section 3.8.7. |
| |
| Add Table 3.16.1: Specific Compressed Internal Formats |
| |
| Compressed Internal Format Base Internal Format |
| ========================== ==================== |
| none provided here -- defined by dependent extensions |
| |
| |
| Add Table 3.16.2: Generic Compressed Internal Formats |
| |
| Generic Compressed Internal |
| Format Base Internal Format |
| ========================== ==================== |
| COMPRESSED_ALPHA_ARB ALPHA |
| COMPRESSED_LUMINANCE_ARB LUMINANCE |
| COMPRESSED_LUMINANCE_ALPHA_ARB LUMINANCE_ALPHA |
| COMPRESSED_INTENSITY_ARB INTENSITY |
| COMPRESSED_RGB_ARB RGB |
| COMPRESSED_RGBA_ARB RGBA |
| |
| |
| Modify Section 3.8.2, Alternate Image Specification |
| |
| (add to end of TexSubImage discussion, p.123) |
| |
| Texture images with compressed internal formats may be stored in such a |
| way that it is not possible to edit an image with subimage commands |
| without having to decompress and recompress the texture image being |
| edited. Even if the image were edited in this manner, it may not be |
| possible to preserve the contents of some of the texels outside the region |
| being modified. To avoid these complications, the GL does not support |
| arbitrary edits to texture images with compressed internal formats. |
| Calling TexSubImage3D, CopyTexSubImage3D, TexSubImage2D, |
| CopyTexSubImage2D, TexSubImage1D, or CopyTexSubImage1D will result in an |
| INVALID_OPERATION error if <xoffset>, <yoffset>, or <zoffset> is not equal |
| to -b_s (border). In addition, the contents of any texel outside the |
| region modified by such a call are undefined. These restrictions may be |
| relaxed for specific compressed internal formats whose images are easily |
| edited. |
| |
| (add new subsection at end of section, p.123) |
| |
| Compressed Texture Images |
| |
| Texture images may also be specified or modified using image data already |
| stored in a known compressed image format. The ARB_texture_compression |
| extension defines no such formats, but provides the mechanisms for other |
| extensions that do. |
| |
| The commands |
| |
| void CompressedTexImage1DARB(enum target, int level, |
| enum internalformat, sizei width, |
| int border, sizei imageSize, |
| const void *data); |
| void CompressedTexImage2DARB(enum target, int level, |
| enum internalformat, sizei width, |
| sizei height, int border, |
| sizei imageSize, const void *data); |
| void CompressedTexImage3DARB(enum target, int level, |
| enum internalformat, sizei width, |
| sizei height, sizei depth, |
| int border, sizei imageSize, |
| const void *data); |
| |
| define one-, two-, and three-dimensional texture images, respectively, |
| with incoming data stored in a specific compressed image format. The |
| <target>, <level>, <internalformat>, <width>, <height>, <depth>, and |
| <border> parameters have the same meaning as in TexImage1D, TexImage2D, |
| and TexImage3D. <data> points to compressed image data stored in the |
| compressed image format corresponding to <internalformat>. Since this |
| extension provides no specific image formats, using any of the six generic |
| compressed internal formats as <internalformat> will result in an |
| INVALID_ENUM error. |
| |
| For all other compressed internal formats, the compressed image will be |
| decoded according to the specification defining the <internalformat> |
| token. Compressed texture images are treated as an array of <imageSize> |
| ubytes beginning at address <data>. All pixel storage and pixel transfer |
| modes are ignored when decoding a compressed texture image. If the |
| <imageSize> parameter is not consistent with the format, dimensions, and |
| contents of the compressed image, an INVALID_VALUE error results. If the |
| compressed image is not encoded according to the defined image format, the |
| results of the call are undefined. |
| |
| Specific compressed internal formats may impose format-specific |
| restrictions on the use of the compressed image specification calls or |
| parameters. For example, the compressed image format might be supported |
| only for 2D textures or may not allow non-zero <border> values. Any such |
| restrictions will be documented in the specification defining the |
| compressed internal format; violating these restrictions will result in an |
| INVALID_OPERATION error. |
| |
| Any restrictions imposed by specific compressed internal formats will be |
| invariant, meaning that if the GL accepts and stores a texture image in |
| compressed form, providing the same image to CompressedTexImage1DARB, |
| CompressedTexImage2DARB, CompressedTexImage3DARB will not result in an |
| INVALID_OPERATION error if the following restrictions are satisfied: |
| |
| * <data> points to a compressed texture image returned by |
| GetCompressedTexImageARB (Section 6.1.4). |
| |
| * <target>, <level>, and <internalformat> match the <target>, <level> |
| and <format> parameters provided to the GetCompressedTexImageARB call |
| returning <data>. |
| |
| * <width>, <height>, <depth>, <border>, <internalformat>, and |
| <imageSize> match the values of TEXTURE_WIDTH, TEXTURE_HEIGHT, |
| TEXTURE_DEPTH, TEXTURE_BORDER, TEXTURE_INTERNAL_FORMAT, and |
| TEXTURE_COMPRESSED_IMAGE_SIZE_ARB for image level <level> in effect at |
| the time of the GetCompressedTexImageARB call returning <data>. |
| |
| This guarantee applies not just to images returned by |
| GetCompressedTexImageARB, but also to any other properly encoded |
| compressed texture image of the same size and format. |
| |
| |
| The commands |
| |
| void CompressedTexSubImage1DARB(enum target, int level, |
| int xoffset, sizei width, |
| enum format, sizei imageSize, |
| const void *data); |
| void CompressedTexSubImage2DARB(enum target, int level, |
| int xoffset, int yoffset, |
| sizei width, sizei height, |
| enum format, sizei imageSize, |
| const void *data); |
| void CompressedTexSubImage3DARB(enum target, int level, |
| int xoffset, int yoffset, |
| int zoffset, sizei width, |
| sizei height, sizei depth, |
| enum format, sizei imageSize, |
| const void *data); |
| |
| |
| respecify only a rectangular region of an existing texture array, with |
| incoming data stored in a known compressed image format. The <target>, |
| <level>, <xoffset>, <yoffset>, <zoffset>, <width>, <height>, and <depth> |
| parameters have the same meaning as in TexSubImage1D, TexSubImage2D, and |
| TexSubImage3D. <data> points to compressed image data stored in the |
| compressed image format corresponding to <format>. Since this extension |
| provides no specific image formats, using any of these six generic |
| compressed internal formats as <format> will result in an INVALID_ENUM |
| error. |
| |
| The image pointed to by <data> and the <imageSize> parameter are |
| interpreted as though they were provided to CompressedTexImage1DARB, |
| CompressedTexImage2DARB, and CompressedTexImage3DARB. These commands do |
| not provide for image format conversion, so an INVALID_OPERATION error |
| results if <format> does not match the internal format of the texture |
| image being modified. If the <imageSize> parameter is not consistent with |
| the format, dimensions, and contents of the compressed image (too little |
| or too much data), an INVALID_VALUE error results. |
| |
| As with CompressedTexImage calls, compressed internal formats may have |
| additional restrictions on the use of the compressed image specification |
| calls or parameters. Any such restrictions will be documented in the |
| specification defining the compressed internal format; violating these |
| restrictions will result in an INVALID_OPERATION error. |
| |
| Any restrictions imposed by specific compressed internal formats will be |
| invariant, meaning that if the GL accepts and stores a texture image in |
| compressed form, providing the same image to CompressedTexSubImage1DARB, |
| CompressedTexSubImage2DARB, CompressedTexSubImage3DARB will not result in |
| an INVALID_OPERATION error if the following restrictions are satisfied: |
| |
| * <data> points to a compressed texture image returned by |
| GetCompressedTexImageARB (Section 6.1.4). |
| |
| * <target>, <level>, and <format> match the <target>, <level> and |
| <format> parameters provided to the GetCompressedTexImageARB call |
| returning <data>. |
| |
| * <width>, <height>, <depth>, <format>, and <imageSize> match the values |
| of TEXTURE_WIDTH, TEXTURE_HEIGHT, TEXTURE_DEPTH, |
| TEXTURE_INTERNAL_FORMAT, and TEXTURE_COMPRESSED_IMAGE_SIZE_ARB for |
| image level <level> in effect at the time of the |
| GetCompressedTexImageARB call returning <data>. |
| |
| * <width>, <height>, <depth>, <format> match the values of |
| TEXTURE_WIDTH, TEXTURE_HEIGHT, TEXTURE_DEPTH, and |
| TEXTURE_INTERNAL_FORMAT currently in effect for image level <level>. |
| |
| * <xoffset>, <yoffset>, and <zoffset> are all "-<b>", where <b> is the |
| value of TEXTURE_BORDER currently in effect for image level <level>. |
| |
| This guarantee applies not just to images returned by |
| GetCompressedTexImageARB, but also to any other properly encoded |
| compressed texture image of the same size. |
| |
| Calling CompressedTexSubImage3D, CompressedTexSubImage2D, or |
| CompressedTexSubImage1D will result in an INVALID_OPERATION error if |
| <xoffset>, <yoffset>, or <zoffset> is not equal to -b_s (border), or if |
| <width>, <height>, and <depth> do not match the values of TEXTURE_WIDTH, |
| TEXTURE_HEIGHT, or TEXTURE_DEPTH, respectively. The contents of any texel |
| outside the region modified by the call are undefined. These restrictions |
| may be relaxed for specific compressed internal formats whose images are |
| easily edited. |
| |
| 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) |
| |
| Modify Section 5.6, Hints (p.180) |
| |
| (p.180, modify first paragraph) |
| |
| ...; FOG_HINT, indicating whether fog calculations are done per pixel or |
| per vertex; and TEXTURE_COMPRESSION_HINT_ARB, indicating the desired |
| quality and performance of compressing texture images. |
| |
| For the texture compression hint, a <hint> of FASTEST indicates that |
| texture images should be compressed as quickly as possible, while NICEST |
| indicates that the texture images be compressed with as little image |
| degradation as possible. FASTEST should be used for one-time texture |
| compression, and NICEST should be used if the compression results are to |
| be retrieved by GetCompressedTexImageARB (Section 6.1.4) for reuse. |
| |
| Additions to Chapter 6 of the OpenGL 1.2.1 Specification (State and |
| State Requests) |
| |
| Modify Section 6.1.3, Enumerated Queries (p.183) |
| |
| (p.183, modify next-to-last paragraph) |
| |
| For texture images with uncompressed internal formats, queries of |
| TEXTURE_RED_SIZE, TEXTURE_GREEN_SIZE, TEXTURE_BLUE_SIZE, |
| TEXTURE_ALPHA_SIZE, TEXTURE_LUMINANCE_SIZE, and TEXTURE_INTENSITY_SIZE |
| return the actual resolutions of the stored image array components, not |
| the resolutions specified when the image array was defined. For texture |
| images with a compressed internal format, the resolutions returned specify |
| the component resolution of an uncompressed internal format that produces |
| an image of roughly the same quality as the compressed image in question. |
| Since the quality of the implementation's compression algorithm is likely |
| data-dependent, the returned component sizes should be treated only as |
| rough approximations. ... |
| |
| (p.183, add to end of next-to-last paragraph) |
| |
| TEXTURE_COMPRESSED_IMAGE_SIZE_ARB returns the size (in ubytes) of the |
| compressed texture image that would be returned by |
| GetCompressedTexImageARB (Section 6.1.4). Querying |
| TEXTURE_COMPRESSED_IMAGE_SIZE_ARB is not allowed on texture images with an |
| uncompressed internal format or on proxy targets and will result in an |
| INVALID_OPERATION error if attempted. |
| |
| Modify Section 6.1.4, Texture Queries (p.184) |
| |
| (add immediately after the GetTexImage section and before the IsTexture |
| section) |
| |
| The command |
| |
| void GetCompressedTexImageARB(enum target, int lod, |
| void *img); |
| |
| is used to obtain texture images stored in compressed form. The |
| parameters <target>, <lod>, and <img> are interpreted in the same manner |
| as in GetTexImage. When called, GetCompressedTexImageARB writes |
| TEXTURE_COMPRESSED_IMAGE_SIZE_ARB ubytes of compressed image data to the |
| memory pointed to by <img>. The compressed image data is formatted |
| according to the specification defining INTERNAL_FORMAT. All pixel |
| storage and pixel transfer modes are ignored when returning a compressed |
| texture image. |
| |
| Calling GetCompressedTexImageARB with an <lod> value less than zero or |
| greater than the maximum allowable causes an INVALID_VALUE error. Calling |
| GetCompressedTexImageARB with a texture image stored with an uncompressed |
| internal format causes an INVALID_OPERATION error. |
| |
| Additions to Appendix A of the OpenGL 1.2.1 Specification (Invariance) |
| |
| None. |
| |
| |
| Additions to the AGL/GLX/WGL Specifications |
| |
| None. |
| |
| GLX Protocol |
| |
| (Add after GetTexImage to Section 2.2.2 of the GLX 1.3 encoding spec, |
| p.74) |
| |
| GetCompressedTexImageARB |
| |
| 1 CARD8 opcode (X assigned) |
| 1 160 GLX opcode |
| 2 4 request length |
| 4 GLX_CONTEXT_TAG context tag |
| 4 ENUM target |
| 4 INT32 level |
| |
| --> |
| |
| 1 1 Reply |
| 1 1 unused |
| 2 CARD16 sequence number |
| 4 n reply length |
| 8 unused |
| 4 INT32 compressed image size (in bytes) -- |
| should be between 4n-3 and 4n |
| 12 unused |
| 4*n LISTofBYTE teximage |
| |
| Note that n may be zero, indicating that a GL error occurred. |
| |
| Since pixel storage modes do not apply to compressed texture images, |
| teximage is simply an array of bytes. The client library will ignore |
| pixel storage modes and should copy only <compressed image size> bytes, |
| regardless of the value of <reply length>. |
| |
| (Add to end of Section 2.3 of the GLX 1.3 encoding spec, p.147) |
| |
| CompressedTexImage1DARB |
| |
| 2 32+n+p rendering command length |
| 2 214 rendering command opcode |
| 4 ENUM target |
| 4 INT32 level |
| 4 ENUM internalformat |
| 4 INT32 width |
| 4 unused |
| 4 INT32 border |
| n LISTofBYTE image |
| 4 INT32 imageSize |
| p unused, p=pad(n) |
| |
| If the command is encoded in a glXRenderLarge request, the command |
| opcode and command length fields are expanded to 4 bytes each. |
| |
| 4 36+n+p rendering command length |
| 4 214 rendering command opcode |
| |
| CompressedTexImage2DARB |
| |
| 2 32+n+p rendering command length |
| 2 215 rendering command opcode |
| 4 ENUM target |
| 4 INT32 level |
| 4 ENUM internalformat |
| 4 INT32 width |
| 4 INT32 height |
| 4 INT32 border |
| 4 INT32 imageSize |
| n LISTofBYTE image |
| p unused, p=pad(n) |
| |
| If the command is encoded in a glXRenderLarge request, the command |
| opcode and command length fields are expanded to 4 bytes each. |
| |
| 4 36+n+p rendering command length |
| 4 215 rendering command opcode |
| |
| CompressedTexImage3DARB |
| |
| 2 36+n+p rendering command length |
| 2 216 rendering command opcode |
| 4 ENUM target |
| 4 INT32 level |
| 4 INT32 internalformat |
| 4 INT32 width |
| 4 INT32 height |
| 4 INT32 depth |
| 4 INT32 border |
| 4 INT32 imageSize |
| n LISTofBYTE image |
| p unused, p=pad(n) |
| |
| If the command is encoded in a glXRenderLarge request, the command |
| opcode and command length fields are expanded to 4 bytes each. |
| |
| 4 36+n+p rendering command length |
| 4 216 rendering command opcode |
| |
| CompressedTexSubImage1DARB |
| |
| 2 36+n+p rendering command length |
| 2 217 rendering command opcode |
| 4 ENUM target |
| 4 INT32 level |
| 4 INT32 xoffset |
| 4 unused |
| 4 INT32 width |
| 4 unused |
| 4 ENUM format |
| 4 INT32 imageSize |
| n LISTofBYTE image |
| p unused, p=pad(n) |
| |
| If the command is encoded in a glXRenderLarge request, the command |
| opcode and command length fields are expanded to 4 bytes each. |
| |
| 4 40+n+p rendering command length |
| 4 217 rendering command opcode |
| |
| CompressedTexSubImage2DARB |
| |
| 2 36+n+p rendering command length |
| 2 218 rendering command opcode |
| 4 ENUM target |
| 4 INT32 level |
| 4 INT32 xoffset |
| 4 INT32 yoffset |
| 4 INT32 width |
| 4 INT32 height |
| 4 ENUM format |
| 4 INT32 imageSize |
| n LISTofBYTE image |
| p unused, p=pad(n) |
| |
| If the command is encoded in a glXRenderLarge request, the command |
| opcode and command length fields are expanded to 4 bytes each. |
| |
| 4 40+n+p rendering command length |
| 4 218 rendering command opcode |
| |
| CompressedTexSubImage3DARB |
| |
| 2 44+n+p rendering command length |
| 2 219 rendering command opcode |
| 4 ENUM target |
| 4 INT32 level |
| 4 INT32 xoffset |
| 4 INT32 yoffset |
| 4 INT32 zoffset |
| 4 INT32 width |
| 4 INT32 height |
| 4 INT32 depth |
| 4 ENUM format |
| 4 INT32 imageSize |
| n LISTofBYTE image |
| p unused, p=pad(n) |
| |
| If the command is encoded in a glXRenderLarge request, the command |
| opcode and command length fields are expanded to 4 bytes each. |
| |
| 4 48+n+p rendering command length |
| 4 219 rendering command opcode |
| |
| |
| Errors |
| |
| Errors for compressed TexImage and TexSubImage calls specific to |
| compression: |
| |
| INVALID_OPERATION is generated by TexSubImage1D, TexSubImage2D, |
| TexSubImage3D, CopyTexSubImage1D, CopyTexSubImage2D, or CopyTexSubImage3D |
| if the internal format of the texture image is compressed and <xoffset>, |
| <yoffset>, or <zoffset> does not equal -b, where b is value of |
| TEXTURE_BORDER. |
| |
| INVALID_VALUE is generated by CompressedTexSubImage1DARB, |
| CompressedTexSubImage2DARB, or CompressedTexSubImage3DARB if the entire |
| texture image is not being edited: if <xoffset>, <yoffset>, or <zoffset> |
| is greater than -b, <xoffset> + <width> is less than w+b, <yoffset> + |
| <height> is less than h+b, or <zoffset> + <depth> is less than d+b, where |
| b is the value of TEXTURE_BORDER, w is the value of TEXTURE_WIDTH, h is |
| the value of TEXTURE_HEIGHT, and d is the value of TEXTURE_DEPTH. |
| |
| INVALID_ENUM is generated by CompressedTexImage1DARB, |
| CompressedTexImage2DARB, or CompressedTexImage3DARB, |
| CompressedTexSubImage1DARB, CompressedTexSubImage2DARB, or |
| CompressedTexSubImage3DARB, if <internalformat> is any of the six generic |
| compressed internal formats (e.g., COMPRESSED_RGBA_ARB) |
| |
| INVALID_OPERATION is generated by CompressedTexImage1DARB, |
| CompressedTexImage2DARB, CompressedTexImage3DARB, |
| CompressedTexSubImage1DARB, CompressedTexSubImage2DARB, or |
| CompressedTexSubImage3DARB, if any parameter combinations are not |
| supported by the specific compressed internal format. Such invalid |
| combinations are documented in the specification defining the internal |
| format. |
| |
| INVALID_VALUE is generated by CompressedTexImage1DARB, |
| CompressedTexImage2DARB, or CompressedTexImage3DARB, |
| CompressedTexSubImage1DARB, CompressedTexSubImage2DARB, or |
| CompressedTexSubImage3DARB, if <imageSize> is not consistent with the |
| format, dimensions, and contents of the specified image. The appropriate |
| value for the <imageSize> parameter is documented in the specification |
| defining the compressed internal format. |
| |
| Undefined results (including abnormal program termination) are generated |
| by CompressedTexImage1DARB, CompressedTexImage2DARB, or |
| CompressedTexImage3DARB, CompressedTexSubImage1DARB, |
| CompressedTexSubImage2DARB, or CompressedTexSubImage3DARB, is not encoded |
| in a manner consistent with the specification defining the internal |
| format. |
| |
| INVALID_OPERATION is generated by CompressedTexSubImage1DARB, |
| CompressedTexSubImage2DARB, or CompressedTexSubImage3DARB if <format> does |
| not match the internal format of the texture image being modified. |
| |
| INVALID_OPERATION is generated by GetTexLevelParameter[if]v if <target> is |
| PROXY_TEXTURE_1D, PROXY_TEXTURE_2D, or PROXY_TEXTURE_3D and <value> is |
| TEXTURE_COMPRESSED_IMAGE_SIZE_ARB. |
| |
| INVALID_OPERATION is generated by GetTexLevelParameter[if]v if the |
| internal format of the queried texture image is not compressed and <value> |
| is TEXTURE_COMPRESSED_IMAGE_SIZE_ARB. |
| |
| INVALID_OPERATION is generated by GetCompressedTexImageARB if the internal |
| format of the queried texture image is not compressed. |
| |
| |
| Errors for compressed TexImage and TexSubImage calls not specific to |
| compression: |
| |
| INVALID_ENUM is generated by CompressedTexImage3DARB or |
| CompressedTexSubImage3DARB if <target> is not TEXTURE_3D. |
| |
| INVALID_ENUM is generated by CompressedTexImage2DARB or |
| CompressedTexSubImage2DARB if <target> is not TEXTURE_2D, |
| TEXTURE_CUBE_MAP_POSITIVE_X_ARB, TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, |
| TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, |
| TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, or TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB. |
| |
| INVALID_ENUM is generated by CompressedTexImage1DARB or |
| CompressedTexSubImage1DARB if <target> is not TEXTURE_1D. |
| |
| INVALID_VALUE is generated by CompressedTexImage1DARB, |
| CompressedTexImage2DARB, CompressedTexImage3DARB, |
| CompressedTexSubImage1DARB, CompressedTexSubImage1DARB, or |
| CompressedTexSubImage3DARB if <level> is negative. |
| |
| INVALID_VALUE is generated by CompressedTexImage1DARB, |
| CompressedTexImage2DARB, CompressedTexImage3DARB, |
| CompressedTexSubImage1DARB, CompressedTexSubImage2DARB, or |
| CompressedTexSubImage3DARB, if <width>, <height>, or <depth> is negative. |
| |
| INVALID_VALUE is generated by CompressedTexImage1DARB, |
| CompressedTexImage2DARB, or CompressedTexImage3DARB if <width>, <height>, |
| or <depth> can not be represented as 2^k+2 for some integer value k. |
| |
| INVALID_VALUE is generated by CompressedTexImage1DARB, |
| CompressedTexImage2DARB, or CompressedTexImage3DARB if <border> is not |
| zero or one. |
| |
| INVALID_VALUE is generated by CompressedTexImage1DARB, |
| CompressedTexImage2DARB, CompressedTexImage3DARB, |
| CompressedTexSubImage1DARB, CompressedTexSubImage1DARB, or |
| CompressedTexSubImage3DARB if the call is made between a call to Begin and |
| the corresponding call to End. |
| |
| INVALID_VALUE is generated by CompressedTexSubImage1DARB, |
| CompressedTexSubImage2DARB, or CompressedTexSubImage3DARB if <xoffset>, |
| <yoffset>, or <zoffset> is less than -b, <xoffset> + <width> is greater |
| than w+b, <yoffset> + <height> is greater than h+b, or <zoffset> + <depth> |
| is greater than d+b, where b is the value of TEXTURE_BORDER, w is the |
| value of TEXTURE_WIDTH, h is the value of TEXTURE_HEIGHT, and d is the |
| value of TEXTURE_DEPTH. |
| |
| INVALID_VALUE is generated by GetCompressedTexImageARB if <lod> is |
| negative or greater than the maximum allowable level. |
| |
| New State |
| |
| (table 6.12, p.202) |
| Initial |
| Get Value Type Get Command Value Description Sec. Attribute |
| --------- ---- ----------- ------- ----------- ---- --------- |
| TEXTURE_COMPRESSED_IMAGE_SIZE_ARB n x Z+ GetTexLevel- 0 size (in 3.8 - |
| Parameter ubytes) |
| of xD compressed |
| texture image i. |
| TEXTURE_COMPRESSED_ARB n x B GetTexLevel- FALSE True if xD 3.8 - |
| Parameter image i has |
| a compressed |
| internal format |
| |
| (table 6.23, p.213) |
| Initial |
| Get Value Type Get Command Value Description Sec. Attribute |
| --------- ---- ----------- ------- ----------- ---- --------- |
| TEXTURE_COMPRESSION_HINT_ARB Z_3 GetIntegerv DONT_ Texture 5.6 hint |
| CARE compression |
| quality hint |
| |
| (table 6.25, p. 215) |
| Minimum |
| Get Value Type Get Command Value Description Sec. Attribute |
| --------- ---- ----------- ------- ----------- ---- --------- |
| NUM_COMPRESSED_TEXTURE_FORMATS_ARB Z GetIntegerv 0 Number of 3.8 - |
| enumerated |
| compressed |
| texture |
| formats |
| |
| COMPRESSED_TEXTURE_FORMATS_ARB 0* x Z GetIntegerv - Enumerated 3.8 - |
| compressed |
| texture |
| formats |
| |
| Revision History |
| |
| 1.03, 05/23/00 prbrown1: Removed stray "None." paragraph in modifications |
| to Chapter 5. |
| |
| 1.02, 05/08/00 prbrown1: Fixed prototype of GetCompressedTexImageARB (no |
| "const" qualifiers) in "New Procedures and |
| Functions" section. Changed <internalformat> |
| parameter of CompressedTexImage functions to be |
| an "enum" instead of an "int". "int" was carried |
| over only on TexImage calls as a 1.0 legacy -- |
| the newer CopyTexImage call takes an "enum". |
| |
| 1.01, 04/11/00 prbrown1: Minor bug fixes to the first published version. |
| Fixed prototypes to match extension spec |
| standards (no "GL" type prefixes). Fixed a |
| couple erroneous function names. Added "const" |
| qualifier to prototypes involving image data not |
| modified by the GL. Added text to indicate that |
| compressed formats apply to texture maps |
| supported by GL_ARB_texture_cube_map. |
| |
| 1.0, 03/24/00 prbrown1: Applied changes approved as part of the extension |
| at the March 2000 ARB meeting, as follows: |
| |
| * CompressedTexSubImage: Only allowed if the |
| entire image is replaced. Document that this |
| restriction can be relaxed for specific |
| compression extensions. |
| * Renamed TEXTURE_IMAGE_SIZE_ARB to |
| TEXTURE_COMPRESSED_IMAGE_SIZE_ARB. |
| * Querying image size on uncompressed images is |
| now an INVALID_OPERATION error. |
| * INVALID_VALUE error is generated if <imageSize> |
| is inconsistent with the image data. This |
| restriction may be overridden by specific |
| extensions only if requiring an image size |
| check is unreasonable. |
| * Added documentaion of undefined behavior for |
| CompressedTexImage/SubImage if the image data |
| is encoded in a manner inconsistent with the |
| spec defining the compressed image format. |
| * Fixed issue (16). Text was truncated. |
| * Modified invariance section. <data> can not |
| affect the choice of compressed internal |
| format, but can theoretically affect regular |
| component resolution. |
| * Add new function GetCompressedTexImage to deal |
| with subtle GLX issues. |
| * GLX protocol for CompressedTexImage/SubImage |
| and GetCompressedTexImage holds both a padded |
| image size (for GLX data transfer) and actual |
| image size (for packing in user buffers). |
| |
| Minor wording clean-ups. |
| |
| Added enum and GLX opcode values allocated from |
| OpenGL Extensions and GLX registries. |
| |
| 0.81, 03/07/00 prbrown1: Fixed error documentation for TexSubImage calls |
| of arbitrary alignment (did not document that the |
| internal format had to be compressed). Removed |
| references to CopyTexImage3D, which doesn't |
| actually exist. |
| |
| Per Kurt Akeley suggestions: (1) Renamed |
| TexImageCompressed to CompressedTexImage to |
| conform with naming conventions, (2) clarified |
| that the main feature distinguishing |
| CompressedTex[Sub]Image calls from normal |
| Tex[Sub]Image calls is compressed input data, (3) |
| added query to explicitly determine whether the |
| internal format of a texture is compressed. |
| |
| 0.8, 02/23/00 prbrown1: Marked previously unresolved issues as resolved |
| per the ARB working group. Added docs for errors |
| not specific to compression for the new |
| CompressedTexImage and CompressedTexSubImage |
| calls. Added queries to enumerate specific |
| compressed texture formats. |
| 0.76, 02/16/00 prbrown1: Removed "gl" and "GL_" prefixes. |
| 0.75, 02/07/00 prbrown1: Incorporated feedback from 12/99 ARB meeting |
| and a number of other revisions. |
| 0.7, 12/03/99 prbrown1: Incorporated comments from public review of 0.2 |
| document. |
| 0.2, 10/28/99 prbrown1: Renamed to ARB_texture_compression. Significant |
| functional changes. |
| 0.11, 10/21/99 prbrown1: Edits suggested by 3dfx. |
| 0.1, 10/19/99 prbrown1: Initial revision. |
| |