Name

    ARB_texture_float

Name Strings

    GL_ARB_texture_float

Contributors

    Pat Brown
    Jon Leech
    Rob Mace
    Brian Paul

Contact

    Dale Kirkland, NVIDIA (dkirkland 'at' nvidia.com)

Notice

    Copyright (c) 2004-2013 The Khronos Group Inc. Copyright terms at
        http://www.khronos.org/registry/speccopyright.html

Status

    Complete. Approved by the ARB on October 22, 2004.

Version

    Based on the ATI_texture_float extension, verion 4

    Last Modified Date:  February 19, 2008
    Version:             7

Number

    ARB Extension #41

Dependencies

    This extension is written against the OpenGL 2.0 Specification
    but will work with the OpenGL 1.5 Specification.

    OpenGL 1.1 or EXT_texture is required.

    This extension interacts with ARB_color_buffer_float.

Overview

    This extension adds texture internal formats with 16- and 32-bit
    floating-point components.  The 32-bit floating-point components
    are in the standard IEEE float format.  The 16-bit floating-point
    components have 1 sign bit, 5 exponent bits, and 10 mantissa bits.
    Floating-point components are clamped to the limits of the range
    representable by their format.


IP Status

    SGI owns US Patent #6,650,327, issued November 18, 2003. SGI
    believes this patent contains necessary IP for graphics systems
    implementing floating point (FP) rasterization and FP framebuffer
    capabilities.

    SGI will not grant the ARB royalty-free use of this IP for use in
    OpenGL, but will discuss licensing on RAND terms, on an individual
    basis with companies wishing to use this IP in the context of
    conformant OpenGL implementations. SGI does not plan to make any
    special exemption for open source implementations.

    Contact Doug Crisman at SGI Legal for the complete IP disclosure.

Issues

    1. How is this extension different from the ATI_texture_float
       extension?

       This extension expands on the definition of float16 values
       and adds a query to determine if the components of a texture
       are stored as floats.

    2. Should the new names of the internal formats be changed to a
       different spelling?

       RESOLVED:  Internal format names have been updated to the
       same convention as the EXT_framebuffer_object extension.

    3. Is it allowable for an implementation to fall back to a non
       floating-point internal format if it does not support the
       requested format?

       RESOLVED:  No.  An application that requests floating-point
       formats should expect to get them.  Only the precision of the
       internal format can be changed.  When this extension is
       promoted to the core, this issue may need to be readdressed.

    4. Do the new internal formats apply to any other commands?

       RESOLVED:  Since color tables support the same <internalFormat>
       values as textures, they are also extended with this extension,
       except the individual component types cannot be queried.

    5. Are the floating-point values clamped before they are stored
       into the texture memory or color tables?

       RESOLVED:  The values are clamped to the representatable
       range of the storage format.  Overflows could produce
       +/-INF and underflows could produce denorms or zero.  This
       matches the behavior of the ATI extension.

    6. Should this extension modify the clamping of the texture border
       color components?

       RESOLVED:  Yes.  The border color components are unclamped.
       When used, the border color components are interpreted in a
       manner consistent with the texture's internal format.  For
       fixed-point textures, this means that the border color is
       clamped to [0, 1] when used.

    7. Are floating-point values clamped for the fixed-function GL?

       RESOLVED:  This extension introduces texel values that can be
       outside [0, 1].  No clamping occurs to these values during
       texture filtering.  For the fixed-function pipeline, the
       filtered texel is now clamped before it is used for texture
       environment blending.  The ARB_color_buffer_float extension
       can be used to control this clamping.  For the programmable
       pipelines, no clamping occurs.

    8. Should the query for the border color return the unclamped
       values?

       RESOLVED:  There is language in the ARB_color_buffer_float
       extension that handles this.  Since there is no clamp control
       in this specification, it would be hard to do anything other
       than return the clamped values.

New Procedures and Functions

   None

New Tokens

    Accepted by the <value> parameter of GetTexLevelParameter:

        TEXTURE_RED_TYPE_ARB             0x8C10
        TEXTURE_GREEN_TYPE_ARB           0x8C11
        TEXTURE_BLUE_TYPE_ARB            0x8C12
        TEXTURE_ALPHA_TYPE_ARB           0x8C13
        TEXTURE_LUMINANCE_TYPE_ARB       0x8C14
        TEXTURE_INTENSITY_TYPE_ARB       0x8C15
        TEXTURE_DEPTH_TYPE_ARB           0x8C16

    Returned by the <params> parameter of GetTexLevelParameter:

        UNSIGNED_NORMALIZED_ARB          0x8C17

    Accepted by the <internalFormat> parameter of TexImage1D,
    TexImage2D, and TexImage3D:

        RGBA32F_ARB                      0x8814
        RGB32F_ARB                       0x8815
        ALPHA32F_ARB                     0x8816
        INTENSITY32F_ARB                 0x8817
        LUMINANCE32F_ARB                 0x8818
        LUMINANCE_ALPHA32F_ARB           0x8819
        RGBA16F_ARB                      0x881A
        RGB16F_ARB                       0x881B
        ALPHA16F_ARB                     0x881C
        INTENSITY16F_ARB                 0x881D
        LUMINANCE16F_ARB                 0x881E
        LUMINANCE_ALPHA16F_ARB           0x881F

Additions to Chapter 2 of the OpenGL 2.0 Specification (OpenGL Operation)

    Add a new Section 2.1.2, (p. 6):

    2.1.2  16-Bit Floating-Point Numbers

    A 16-bit floating-point number has a 1-bit sign (S), a 5-bit
    exponent (E), and a 10-bit mantissa (M).  The value of a 16-bit
    floating-point number is determined by the following:

        (-1)^S * 0.0,                        if E == 0 and M == 0,
        (-1)^S * 2^-14 * (M / 2^10),         if E == 0 and M != 0,
        (-1)^S * 2^(E-15) * (1 + M/2^10),    if 0 < E < 31,
        (-1)^S * INF,                        if E == 31 and M == 0, or
        NaN,                                 if E == 31 and M != 0,

    where

        S = floor((N mod 65536) / 32768),
        E = floor((N mod 32768) / 1024), and
        M = N mod 1024.

    Implementations are also allowed to use any of the following
    alternative encodings:

        (-1)^S * 0.0,                        if E == 0 and M != 0,
        (-1)^S * 2^(E-15) * (1 + M/2^10),    if E == 31 and M == 0, or
        (-1)^S * 2^(E-15) * (1 + M/2^10),    if E == 31 and M != 0,

    Any representable 16-bit floating-point value is legal as input
    to a GL command that accepts 16-bit floating-point data.  The
    result of providing a value that is not a floating-point number
    (such as infinity or NaN) to such a command is unspecified, but
    must not lead to GL interruption or termination.  Providing a
    denormalized number or negative zero to GL must yield predictable
    results.

Additions to Chapter 3 of the OpenGL 2.0 Specification (Rasterization)

    Modify Section 3.6.3 (Pixel Transfer Modes), p. 116

    (modify first paragraph, p. 118) The specified image is taken from
    memory and processed just as if DrawPixels were called, stopping
    after the final expansion to RGBA. The R, G, B, and A components of
    each pixel are then scaled by the four COLOR TABLE SCALE parameters
    and biased by the four COLOR TABLE BIAS parameters.  These
    parameters are set by calling ColorTableParameterfv as described
    below.  If fragment color clamping is enable or the
    <internalformat> is fixed-point, the components are clamped to
    [0, 1]. Otherwise, the components are not modified.

    Modify Section 3.8.1 (Texture Image Specification), p. 150

    (modify second paragraph, p. 151) The selected groups are processed
    exactly as for DrawPixels, stopping just before final conversion.
    For R, G, B, and A, if the <internalformat> of the texture is
    fixed-point, the components are clamped to [0, 1].  Otherwise, the
    components are not modified.  The depth value so generated is
    clamped to [0, 1].

    (modify the second paragraph, p. 152) The internal component resolution
    is the number of bits allocated to each value in a texture image. If
    <internalformat> is specified as a base internal format, the GL stores
    the resulting texture with internal component resolutions of its own
    choosing.  If a sized internal format is specified, the mapping of the
    R, G, B, A, and depth values to texture components is equivalent to the
    mapping of the corresponding base internal format's components, as
    specified in table 3.15, the type (unsigned int, float, etc.) is
    assigned the same type specified by <internalFormat>, and the memory
    allocation per texture component is assigned by the GL to match the
    allocations listed in table 3.16 as closely as possible. (The definition
    of closely is left up to the implementation.  Implementations are not
    required to support more than one resolution of each type (unsigned int,
    float, etc.) for each base internal format.) If a compressed internal
    format is specified, the mapping of the R, G, B, A, and depth 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.

    (add the following to table 3.16, p. 154)

      Sized                       Base             R    G    B    A    L    I
      Internal Format             Internal Format bits bits bits bits bits bits
      --------------------------- --------------- ---- ---- ---- ---- ---- ----
      RGBA32F_ARB                 RGBA            f32  f32  f32  f32
      RGB32F_ARB                  RGB             f32  f32  f32
      ALPHA32F_ARB                ALPHA                          f32
      INTENSITY32F_ARB            INTENSITY                                f32
      LUMINANCE32F_ARB            LUMINANCE                           f32
      LUMINANCE_ALPHA32F_ARB      LUMINANCE_ALPHA                f32  f32
      RGBA16F_ARB                 RGBA            f16  f16  f16  f16
      RGB16F_ARB                  RGB             f16  f16  f16
      ALPHA16F_ARB                ALPHA                          f16
      INTENSITY16F_ARB            INTENSITY                                f16
      LUMINANCE16F_ARB            LUMINANCE                           f16
      LUMINANCE_ALPHA16F_ARB      LUMINANCE_ALPHA                f16  f16

      Table 3.16: Correspondence of sized internal formats to base
      internal formats, and desired component resolutions for each
      sized internal format.  The notation <f16> and <f32> imply
      16- and 32-bit floating-point, respectively.

    Modify Section 3.8.4 (Texture Parameters), p. 166

    (remove TEXTURE_BORDER_COLOR from end of first paragraph, p. 166)

    ... If the values for TEXTURE_BORDER_COLOR or the value for
    TEXTURE_PRIORITY are specified as integers, the conversion for signed
    integers from table 2.9 is applied to convert this value to
    floating-point.  Regardless of the original data type, the value for
    TEXTURE_PRIORITY is clamped to lie in [0, 1].

    ... If the value for TEXTURE_PRIORITY is specified as an integer,
    the conversion for signed integers from table 2.9 is applied to
    convert this value to floating-point, followed by clamping the
    value to lie in [0, 1].

    Modify Section 3.8.8 (Texture Minification), p. 170

    (modify last paragraph, p. 174) ... If the texture contains color
    components, the values of TEXTURE BORDER COLOR are interpreted as
    an RGBA color to match the texture's internal format in a manner
    consistent with table 3.15.  The border values for texture
    components stored as fixed-point values are clamped to [0, 1]
    before they are used.  If the texture contains depth ...

    Modify Section 3.8.11 (Texture State and Proxy State) p. 178

    (modify the first section, p. 178) ...Each array has associated with
    it a width, height (two- and three-dimensional and cubemap only), and
    depth (three-dimensional only), a border width, an integer describing
    the internal format of the image, six integer values describing the
    resolutions of each of the red, green, blue, alpha, luminance, and
    intensity components of the image, six values that describe the type
    (unsigned int, floats, etc.) of each of the red, green, blue, alpha,
    luminance, and intensity components of the image, a boolean describing
    whether the image is compressed or not, and an integer size of a
    compressed image.  Each initial...

    (modify the first paragraph, p. 179) ...Each proxy array includes width,
    height (two- and three- dimensional arrays only), depth
    (three-dimensional arrays only), border width, and internal format state
    values, as well as state for the red, green, blue, alpha, luminance, and
    intensity component resolutions and types (unsigned int, floats, etc.).
    Proxy arrays do not include image data, nor do they include texture
    properties. When TexImage3D is executed with target specified as PROXY
    TEXTURE 3D, the three-dimensional proxy state values of the specified
    level-of-detail are recomputed and updated. If the image array would not
    be supported by TexImage3D called with target set to TEXTURE 3D, no
    error is generated, but the proxy width, height, depth, border width,
    and component resolutions are set to zero, and the component types are
    set to NONE. If the image...

    Modify Section 3.8.13 (Texture Environments and Functions), p.182

    (replace the sixth paragraph of p. 183) All of these color values
    are clamped to the range [0, 1].  The texture functions are
    specified in tables 3.22, 3.23, and 3.24.

Additions to Chapter 4 of the OpenGL 2.0 Specification (Per-Fragment
Operations and the Frame Buffer)

    None

Additions to Chapter 5 of the OpenGL 2.0 Specification (Special
Functions)

    None

Additions to Chapter 6 of the OpenGL 2.0 Specification (State and
State Requests)

    Modify Section 6.1.3 (Enumerated Queries), p. 246

    (modify second paragraph, p. 247) For texture images with uncompressed
    internal formats, queries of <value> of TEXTURE_RED_TYPE_ARB,
    TEXTURE_GREEN_TYPE_ARB, TEXTURE_BLUE_TYPE_ARB, TEXTURE_ALPHA_TYPE_ARB,
    TEXTURE_LUMINANCE_TYPE_ARB, TEXTURE_INTENSITY_TYPE_ARB, and
    TEXTURE_DEPTH_TYPE_ARB, return either NONE, UNSIGNED_NORMALIZED_ARB, or
    FLOAT indicating how the components are stored, and the queries of
    <value> of TEXTURE_RED_SIZE, TEXTURE_GREEN_SIZE, TEXTURE_BLUE_SIZE,
    TEXTURE_ALPHA_SIZE, TEXTURE_LUMINANCE_SIZE, TEXTURE_DEPTH_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.

Additions to the AGL/GLX/WGL Specifications

    None

Dependencies on ARB_color_buffer_float extension

    The ARB_color_buffer_float extension allows clamping to be
    controlled in various parts of the GL.  Specifically, clamping
    of filtered texel values used for texture environment blending
    can be disable.

Errors

    None

New State

    (Table 6.17, p. 278) add the following entries:

    Get Value                        Type   Get Command           Minimum Value  Description      Section   Attribute
    -------------------------------  -----  --------------------  -------------  ---------------  --------  ----------
    TEXTURE_RED_TYPE_ARB             Z3     GetTexLevelParameter  -              storage type     6.1.3     -
    TEXTURE_GREEN_TYPE_ARB           Z3     GetTexLevelParameter  -              storage type     6.1.3     -
    TEXTURE_BLUE_TYPE_ARB            Z3     GetTexLevelParameter  -              storage type     6.1.3     -
    TEXTURE_ALPHA_TYPE_ARB           Z3     GetTexLevelParameter  -              storage type     6.1.3     -
    TEXTURE_LUMINANCE_TYPE_ARB       Z3     GetTexLevelParameter  -              storage type     6.1.3     -
    TEXTURE_INTENSITY_TYPE_ARB       Z3     GetTexLevelParameter  -              storage type     6.1.3     -
    TEXTURE_DEPTH_TYPE_ARB           Z3     GetTexLevelParameter  -              storage type     6.1.3     -

New Implementation Dependent State

    None

Revision History

    Rev.    Date    Author     Changes
    ----  -------- ---------  ----------------------------------------
      1   2/26/04  kirkland   Initial version based on the ATI
                              extension.

      2   3/11/04  kirkland   Updated language for float16 number
                              handling.
                              Added bit encodings for half values.
                              Added an issue for color tables.
                              Added separate queries for component
                              types.
                              Changed the internal format names to
                              match the uber buffer extension.
                              Added language to not allow textures to
                              change the type of the internal formats,
                              only the precision.

      3   7/23/04  kirkland   Added alternative encodings options for
                              float16 format.

      4   9/17/04  kirkland   Updated to reference the OpenGL 2.0 spec.
                              Added interaction with clamp control.
                              Removed the clamping of color table data.

      5   10/1/04  Kirkland   Updated IP section.
                              Reviewed by the ARB and closed all
                              UNRESOLVED issues.

      6    7/6/06  pbrown     Fixed broken language for border color 
                              handling.  TexParameteriv border colors
                              should still be converted to integer; we
                              only intended to remove the [0,1] clamping.

      7   2/8/07   Jon Leech  Move 3.8.13 changes to appropriate section.
