xref: /third_party/openGLES/extensions/EXT/EXT_texture_sRGB_decode.txt

Name

    EXT_texture_sRGB_decode

Name Strings

    GL_EXT_texture_sRGB_decode

Contributors

    Matt Collins, Apple Inc
    Alex Eddy, Apple Inc
    Mark Kilgard, NVIDIA
    Chris Niederauer, Apple Inc
    Richard Schreyer, Apple Inc
    Henri Verbeet, CodeWeavers
    Brent Wilson, NVIDIA
    Jeff Bolz, NVIDIA
    Dan Omachi, Apple Inc
    Jason Green, TransGaming
    Daniel Koch, NVIDIA
    Mathias Heyer, NVIDIA

Contact

    Matt Collins, Apple Inc (matthew.collins 'at' apple.com)

Status

    Shipping on OS X 10.7

Version

    Date: November 8, 2017
    Revision: 0.91

Number

    OpenGL Extension #402
    OpenGL ES Extension #152

Dependencies

    OpenGL 2.1 or EXT_texture_sRGB requried for OpenGL

    OpenGL ES 3.0 or EXT_sRGB are required for OpenGL ES

    OpenGL 3.0 or later interacts with this extension.

    OpenGL ES 2.0 interacts with this extension.

    OpenGL ES 3.0 interacts with this extension.

    ARB_bindless_texture interacts with this extension.

    ARB_sampler_objects interacts with this extension.

    ARB_framebuffer_object interacts with this extension.

    EXT_direct_state_access interacts with this extension.

    EXT_texture_compression_s3tc interacts with this extension.

    EXT_texture_integer interacts with this extension.

    EXT_sRGB interacts with this extension.

    NV_sRGB_formats interacts with this extension.

    NV_generate_mipmap_sRGB interacts with this extension.

    KHR_texture_compression_astc_ldr interacts with this extension.

    ETC2 texure compression formats interact with this extension.

    This extension is written against the OpenGL 2.1 (December 1, 2006)
    specification.

Overview

    The EXT_texture_sRGB extension (promoted to core in OpenGL 2.1)
    provides a texture format stored in the sRGB color space. Sampling one
    of these textures will always return the color value decoded into a
    linear color space. However, an application may wish to sample and
    retrieve the undecoded sRGB data from the texture and manipulate
    that directly.

    This extension adds a Texture Parameter and Sampler Object parameter to
    allow sRGB textures to be read directly, without decoding.

    The new parameter, TEXTURE_SRGB_DECODE_EXT controls whether the
    decoding happens at sample time. It only applies to textures with an
    internal format that is sRGB and is ignored for all other textures.
    This value defaults to DECODE_EXT, which indicates the texture
    should be decoded to linear color space.

New Procedures and Functions

    None

New Tokens

    Accepted by the <pname> parameter of TexParameterf, TexParameteri,
    TexParameterfv, TexParameteriv, TexParameterIiv, TexParameterIuiv,
    TexParameterIivEXT, TexParameterIuivEXT, TextureParameterfEXT,
    TextureParameterfvEXT, TextureParameteriEXT, TextureParameterivEXT,
    TextureParameterIivEXT, TextureParameterIuivEXT,
    MultiTexParameterfEXT, MultiTexParameterfvEXT, MultiTexParameteriEXT,
    MultiTexParameterivEXT, MultiTexParameterIivEXT,
    MultiTexParameterIuivEXT, GetTexParameterfv, GetTexParameteriv,
    GetTexParameterIiv, GetTexParameterIuiv, GetTexParameterIivEXT,
    GetTexParameterIuivEXT, GetTextureParameterfEXT,
    GetTextureParameterfvEXT, GetTextureParameteriEXT,
    GetTextureParameterivEXT, GetTextureParameterIivEXT,
    GetTextureParameterIuivEXT, GetMultiTexParameterfEXT,
    GetMultiTexParameterfvEXT, GetMultiTexParameteriEXT,
    GetMultiTexParameterivEXT, GetMultiTexParameterIivEXT,
    GetMultiTexParameterIuivEXT, SamplerParameteri, SamplerParameterf,
    SamplerParameteriv, SamplerParameterfv, SamplerParameterIiv,
    SamplerParameterIuiv, GetSamplerParameteriv, GetSamplerParameterfv,
    GetSamplerParameterIiv, and GetSamplerParameterIuiv:

        TEXTURE_SRGB_DECODE_EXT        0x8A48

    Accepted by the <param> parameter of TexParameterf, TexParameteri,
    TexParameterfv, TexParameteriv, TexParameterIiv, TexParameterIuiv,
    TexParameterIivEXT, TexParameterIuivEXT, TextureParameterfEXT,
    TextureParameterfvEXT, TextureParameteriEXT, TextureParameterivEXT,
    TextureParameterIivEXT, TextureParameterIuivEXT,
    MultiTexParameterfEXT, MultiTexParameterfvEXT, MultiTexParameteriEXT,
    MultiTexParameterivEXT, MultiTexParameterIivEXT,
    MultiTexParameterIuivEXT, SamplerParameteri, SamplerParameterf,
    SamplerParameteriv, SamplerParameterfv, SamplerParameterIiv, and
    SamplerParameterIuiv:

        DECODE_EXT             0x8A49
        SKIP_DECODE_EXT        0x8A4A

Additions to Chapter 3 of the 2.1 Specification (Rasterization)

    Add 1 new row to Table 3.18 (page 169).

    Name                       Type       Initial value     Legal values
    ----                       ----       -------------     ------------
    TEXTURE_SRGB_DECODE_EXT    enum        DECODE_EXT       DECODE_EXT, SKIP_DECODE_EXT

-- OpenGL: Section 3.8.8, Texture Minification

    Add to the end of the "Automatic Mipmap Generation" subsection:

    If the automatic mipmap generation is applied to a texture
    whose internal format is one of SRGB_EXT, SRGB8_EXT,
    SRGB_ALPHA_EXT, SRGB8_ALPHA8_EXT, SLUMINANCE_ALPHA_EXT,
    SLUMINANCE8_ALPHA8_EXT, SLUMINANCE_EXT, SLUMINANCE8_EXT,
    COMPRESSED_SRGB_EXT, COMPRESSED_SRGB_ALPHA_EXT,
    COMPRESSED_SLUMINANCE_EXT, COMPRESSED_SLUMINANCE_ALPHA_EXT,
    COMPRESSED_SRGB_S3TC_DXT1_EXT, COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
    COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, or
    COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, and the TEXTURE_SRGB_DECODE_EXT
    parameter for the current texture unit is DECODE_EXT, the RGB
    texel components are decoded to a linear components as described
    in section 3.8.15 prior to downsampling; then after downsampling,
    the linear components are re-encoded as sRGB in the following manner:

    If cl is the linear color component, then the corresponding sRGB
    encoded component is encoded as follows

             {  cl * 12.92,                  cl < 0.0031308
        cs = {
             {  1.055 * cl^0.41666 - 0.055,  cl >= 0.0031308

    If the automatic mipmap generation is applied to a texture whose
    internal format is one of the sRGB formats listed previously and
    the TEXTURE_SRGB_DECODE_EXT parameter for the texture object is
    SKIP_DECODE_EXT, the sRGB decode and encode steps are skipped during
    mipmap generation.

-- OpenGL:  Section 3.8.15, sRGB Color Decoding

    (section was previously titled sRGB Color Conversion)

    Replace current text with the following:

    If the currently bound texture's internal format is one
    of SRGB_EXT, SRGB8_EXT, SRGB_ALPHA_EXT, SRGB8_ALPHA8_EXT,
    SLUMINANCE_ALPHA_EXT, SLUMINANCE8_ALPHA8_EXT, SLUMINANCE_EXT,
    SLUMINANCE8_EXT, COMPRESSED_SRGB_EXT, COMPRESSED_SRGB_ALPHA_EXT,
    COMPRESSED_SLUMINANCE_EXT, COMPRESSED_SLUMINANCE_ALPHA_EXT,
    COMPRESSED_SRGB_S3TC_DXT1_EXT, COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
    COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, or
    COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, and the TEXTURE_SRGB_DECODE_EXT
    parameter for the current texture unit is DECODE_EXT, the red, green, and blue
    components are decoded from an sRGB color space to a linear color
    space as part of filtering described in sections 3.8.8 and 3.8.9.
    Any alpha component is left unchanged. Ideally, implementations
    should perform this color decoding on each sample prior to filtering
    but implementations are allowed to perform this decoding after
    filtering (though this post-filtering approach is inferior to
    decoding from sRGB prior to filtering).

    The decoding from an sRGB encoded component, cs, to a linear
    component, cl, is as follows

            {  0,                          cs <= 0
            {
            {  cs / 12.92,                 0 < cs <= 0.04045
       cl = {
            {  ((cs + 0.055)/1.055)^2.4,   0.04045 < cs < 1
            {
            {  1,                          cs >= 1

    Assume cs is the sRGB component in the range [0,1].

    If the TEXTURE_SRGB_DECODE_EXT parameter is SKIP_DECODE_EXT, the value
    is returned without decoding. The TEXTURE_SRGB_DECODE_EXT
    parameter state is ignored for any texture with an internal format
    not explicitly listed above, as no decoding needs to be done.

--- OpenGL ES 3.2: Section 8.21, sRGB Texture Color Conversion
--- OpenGL ES 3.0: Section 3.8.16, sRGB Texture Color Conversion
--- OpenGL ES 2.0: Section 3.7.14, sRGB Texture Color Conversion

    Add after the first paragraph of the section:

   "The conversion of sRGB color space components to linear color space is
    always applied if the TEXTURE_SRGB_DECODE_EXT parameter is DECODE_EXT.
    Table X.1 describes whether the conversion is skipped if the
    TEXTURE_SRGB_DECODE_EXT parameter is SKIP_DECODE_EXT, depending on
    the function used for the access, whether the access occurs through a
    bindless sampler, and whether the texture is statically accessed
    elsewhere with a texelFetch function."

    Add a new table X.1, Whether the conversion of sRGB color space
    components to linear color space is skipped when the
    TEXTURE_SRGB_DECODE_EXT parameter is SKIP_DECODE_EXT.

                                       texelFetch       other builtin
      --------------------------------------------------------------------
      non-bindless sampler,            n/a              yes
      no accesses with
      texelFetch

      non-bindless sampler,            no               undefined
      statically accessed with
      texelFetch

      bindless sampler                 undefined        yes

Dependencies on ARB_bindless_texture

    If ARB_bindless_texture is NOT supported, delete all references to
    bindless samplers.

Dependencies on ARB_sampler_objects or OpenGL 3.3 or later

    If ARB_sampler_objects or OpenGL 3.3 or later is NOT supported,
    delete all references to SamplerParameter* and GetSamplerParameter*.

Dependencies on ARB_framebuffer_object or OpenGL 3.0 or later

    If ARB_framebuffer_object or OpenGL 3.0 or later is supported, the
    explanation in the "Automatic Mipmap Generation" section applies to
    the GenerateMipmap command as well.

Dependencies on EXT_texture_compression_s3tc

    If EXT_texture_compression_s3tc is NOT supported, delete
    COMPRESSED_SRGB_S3TC_DXT1_EXT, COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
    COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, and
    COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT from Section 3.8.15.

Dependencies on EXT_texture_integer

    If EXT_texture_integer is NOT supported, delete references to
    TexParameterIivEXT, TexParameterIuivEXT, GetTexParameterIivEXT,
    and GetTexParameterIuivEXT.

Dependencies on EXT_direct_state_access

    If EXT_direct_state_access is NOT supported, delete
    references to TextureParameterfEXT, TextureParameterfvEXT,
    TextureParameteriEXT, TextureParameterivEXT, TextureParameterIivEXT,
    TextureParameterIuivEXT, MultiTexParameterfEXT,
    MultiTexParameterfvEXT, MultiTexParameteriEXT, MultiTexParameterivEXT,
    MultiTexParameterIivEXT, MultiTexParameterIuivEXT,
    GetTextureParameterfEXT, GetTextureParameterfvEXT,
    GetTextureParameteriEXT, GetTextureParameterivEXT,
    GetTextureParameterIivEXT, GetTextureParameterIuivEXT,
    GetMultiTexParameterfEXT, GetMultiTexParameterfvEXT,
    GetMultiTexParameteriEXT, GetMultiTexParameterivEXT,
    GetMultiTexParameterIivEXT, and GetMultiTexParameterIuivEXT.

Dependencies on OpenGL 3.0

    If OpenGL 3.0 or later is NOT supported, delete references
    to TexParameterIiv, TexParameterIuiv, GetTexParameterIiv,
    and GetTexParameterIuiv.

Interactions with OpenGL ES

    If OpenGL ES 3.0 is NOT supported, delete references
    to TexParameterIiv, TexParameterIuiv, GetTexParameterIiv,
    and GetTexParameterIuiv, GetTexParameterfv, GetTexParameteriv.

    If OpenGL ES 3.0 or NV_generate_mipmap_sRGB is supported,
    TEXTURE_SRGB_DECODE_EXT will control the linearization of sRGB
    texture levels while generating the mipmap levels. The section
    "Automatic Mipmap Generation" applies to glGenerateMipmap instead.

    If neither OpenGL ES 3.0 nor NV_sampler_objects is supported,
    delete all references to SamplerParameter* and GetSamplerParameter*.

    If NV_sampler_objects is supported, substitue the ARB_sampler_objects
    references with corresponding commands of NV_sampler_objects.

Interactions with KHR_texture_compression_astc_ldr

    If KHR_texture_compression_astc_ldr is supported, the
    TEXTURE_SRGB_DECODE_EXT texture and/or sampler parameter affects the
    COMPRESSED_SRGB8_ALPHA8_ASTC_*_KHR formats as described in the Section
    3.8.16 edits.

Interactions with ETC2 compressed texture formats

    If the ETC2 texture compression formats (part of OpenGL ES 3.0 and OpenGL
    4.3) are supported, the TEXTURE_SRGB_DECODE_EXT texture and/or sampler
    parameter affects the COMPRESSED_SRGB8_*ETC2* formats as described in the
    Section 3.8.16 edits.

Interactions with NV_sRGB_formats

    If NV_sRGB_formats is supported, the TEXTURE_SRGB_DECODE_EXT texture and/or
    sampler parameter affects the new SRGB and SLUMINANCE formats as described
    in the Section 3.7.14 edits.

Errors

    INVALID_ENUM is generated if the <pname> parameter of
    TexParameter[i,f,Ii,Iui][v][EXT], MultiTexParameter[i,f,Ii,Iui][v]EXT,
    TextureParameter[i,f,Ii,Iui][v]EXT, SamplerParameter[i,f,Ii,Iui][v]
    is TEXTURE_SRGB_DECODE_EXT when the <param> parameter is not one of
    DECODE_EXT or SKIP_DECODE_EXT.

New State

    In table 6.20, Texture Objects, p. 384, add the following:

    Get Value                     Type  Get Command           Initial Value  Description       Sec.   Attribute
    ----------------------------  ----  --------------------  -------------  ----------------  -----  ---------
    TEXTURE_SRGB_DECODE_EXT       Z_2   GetTexParameter[if]v  DECODE_EXT     indicates when    3.8.15 texture
                                                                             sRGB textures
                                                                             are decoded from
                                                                             sRGB or the
                                                                             decoding step is
                                                                             skipped

    Add to Table 6.23 of ARB_sampler_objects, "Textures (state per sampler object)":

    Get Value                     Type  Get Command               Initial Value  Description       Sec.   Attribute
    ----------------------------  ----  ------------------------  -------------  ----------------  -----  ---------
    TEXTURE_SRGB_DECODE_EXT       Z_2   GetSamplerParameter[if]v  DECODE_EXT     indicates when    3.8.15 texture
                                                                                 sRGB textures
                                                                                 are decoded from
                                                                                 sRGB or the
                                                                                 decoding step is
                                                                                 skipped

Issues

    1) What should this extension be called?

        RESOLVED: EXT_texture_sRGB_decode

        The purpose of this extension is to allow developers to skip
        the sRGB-to-linear decoding detailed in Section 3.8.15.
        Since this is a decoding of the sRGB value into linear space, we
        use that word to describe the pname. The enum indicating this
        decoding is to happen is DECODE, as that is what the GL will do.
        The enum that indicates this decoding is to be skipped is then
        appropriately, SKIP_DECODE.

    2) Should this allow for filters other than NEAREST on undecoded
       sRGB values?

        RESOLVED: YES

        Hardware supports this, and it is left up to the programmer.

    3) Do we generate an error if TEXTURE_SRGB_DECODE_EXT is changed for normal
       textures?

        RESOLVED: NO

        This is similar to the ARB_shadow and ARB_framebuffer_sRGB extensions - the flag
        is ignored for non-sRGB texture internal formats.

    4) Should we add forward-looking support for ARB_sampler_objects?

        RESOLVED: YES

        If ARB_sampler_objects exists in the implementation, the sampler
        objects should also include this parameter per sampler.

    5) What is the expense of changing the sRGB-ness of a texture without
       this extension?

        RESOLVED:  If an application wants to use a texture with sRGB
        texels and then switch to using it with linear filtering (or vice
        versa), OpenGL without this extension requires the application
        to read back all the texels in all the mipmap levels of all the
        images, and respecify a different texture object with a different
        texture format.  This is very expensive.

        With this extension, the driver can simply change the underlying
        hardware texture format associated with the texture to perform
        sRGB conversion on filtering or not.  This is very inexpensive.

        However, note that the functionality of this extension can also
        be obtained using the more modern approach provided by
        ARB_texture_view (added to OpenGL 4.3) and OES_texture_view.

    6) Do any major games or game engines depend on the ability to
       change the sRGB-ness of textures?

        RESOLVED:  Yes, Valve's Source engine used by Half-Life 2,
        Counter-Strike: Source, and Left 4 Dead; and Unreal Engine 3
        games including Unreal Tournament 3 and BioShock.

        These games and their underlying engines repeatedly render linear
        color values into textures and then texture from the rendered
        textures with sRGB texture filtering.

    7) Why not simply allow changing whether a standard GL_RGBA8
       can perform an sRGB color space conversion for filtering?

        RESOLVED:  Allowing this would create a consistency problem.
        Why would the GL_TEXTURE_SRGB_DECODE_EXT parameter not
        apply to GL_RGB4 or GL_RGB12 textures too?  In practice,
        sRGB color conversion for texture filtering is only typically
        supported in hardware for a small subset of texture formats
        (corresponding to the sized internal formats introduced by the
        EXT_texture_sRGB specification).  It's essentially only 8-bit
        fixed-point unsigned textures where sRGB color conversion makes
        sense.  And the initial value of the parameter (GL_DECODE_EXT) would be
        appropriate for sRGB texture formats but not conventional linear
        texture formats (as no decoding needs to be done). Having the

        texture parameter apply just to sRGB texture eliminates the ambiguity
        of which conventional texture formats can and cannot have sRGB decoding
        applied to them. This also eliminates the burden of having every future

        texture format extension specify whether or not the sRGB decoding parameter
        applies to them.

        Direct3D 9 handles this situation by advertising for each surface
        format (which double as texture formats) a D3DUSAGE_QUERY_SRGBREAD
        parameter.  In practice, Direct3D 9 implementation only advertise
        the D3DUSAGE_QUERY_SRGBREAD parameter for 8-bit fixed-point
        unsigned RGB or luminance formats, corresponding to the formats
        available from EXT_texture_sRGB.

    8) Does there need to be a control for whether to update (and
       possibly blend) framebuffer pixels in sRGB or linear color space?

        RESOLVED:  The EXT_framebuffer_sRGB extension (made core in OpenGL
        3.0) already has this capability with the GL_FRAMEBUFFER_SRGB_EXT
        enable.

        The GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING query parameter
        roughly corresponds to Direct3D 9's D3DUSAGE_QUERY_SRGBWRITE
        parameter.

    9) How is the border color handled when toggling sRGB color
       conversion for blending of sRGB textures?

        RESOLVED:  Consistent with the EXT_texture_sRGB specification, the
        border color is always specified as a linear value (never sRGB).
        So changing the TEXTURE_SRGB_DECODE_EXT parameter will
        not affect the resulting sampled border color.

        If an implementation were to store the texture border color in a
        format consistent with the texel format (including the sRGB color
        space), this would require such implementations to convert the
        (linear) texture border RGB components to sRGB space.
        In this case, this would mean an implementation to re-specify
        the texture border color state in the hardware when the
        TEXTURE_SRGB_DECODE_EXT parameter for an sRGB texture
        changed.

        Alternatively, if the implementation stored the texture
        border color in texture formant-independent format (say 4
        floating-point values) and always treated this as a linear RGB
        color for purposes of texture filtering, no sRGB conversion
        of the texture border color would ever occur.  In this case,
        this would mean an implementation would NOT need to re-specify
        the texture border color state in the hardware when the
        TEXTURE_SRGB_DECODE_EXT parameter for an sRGB texture
        changed.

   10) How is mipmap generation of sRGB textures affected by the
       TEXTURE_SRGB_DECODE_EXT parameter?

        RESOLVED:  When the TEXTURE_SRGB_DECODE parameter is DECODE_EXT
        for an sRGB texture, mipmap generation should decode sRGB texels
        to a linear RGB color space, perform downsampling, then encode
        back to an sRGB color space.  (Issue 24 in the EXT_texture_sRGB
        specification provides a rationale for why.)  When the parameter
        is SKIP_DECODE_EXT instead, mipmap generation skips the encode
        and decode steps during mipmap generation.  By skipping the
        encode and decode steps, sRGB mipmap generation should match
        the mipmap generation for a non-sRGB texture.

        The TEXTURE_SRGB_DECODE_EXT texture parameter has no effect on
        mipmap generation of non-sRGB textures.

        Direct3D 10 and Direct3D 11 expect mipmap generation for sRGB
        textures to be "correctly done" (meaning sRGB decode samples,
        perform weighted average in linear space, then sRGB encode
        the result).

        Direct3D 9 expects to NOT perform sRGB-correct mipmap generation.
        Hence the ability to generate mipmaps from an sRGB texture
        where you skip the decode (and encode) during mipmap generation
        is important.

   11) Does automatic mipmap generation change the smaller mipmap levels
       when the TEXTURE_SRGB_DECODE texture parameter changes?

        RESOLVED:  No, automatic mipmap generation only happens when the
        base level is changed.

        This means if the TEXTURE_SRGB_DECODE parameter is changed from
        DECODE_EXT to SKIP_DECODE_EXT (or vice versa), the texels in the
        smaller mipmap levels are not modified.

        Use the glGenerateMipmap command to regenerate mipmaps explicitly
        to reflect a change in the TEXTURE_SRGB_DECODE parameter.

   12) How is this extension expected to be used for Direct3D 9 emulation?

        RESOLVED: Direct3D texture resources that are created with a
        format supporting either the SRGBREAD or SRGBWRITE capabilities
        should be created as an OpenGL texture object with an sRGB
        internal format.

        This means that normal "linear" RGBA8 textures for Direct3D 9
        should be created as GL_SRGB8_ALPHA8 textures so they can be used
        with samplers where the GL_TEXTURE_SRGB_DECODE_EXT parameter of
        the sampler (assuming ARB_sampler_objects) determines whether
        they operate as linear textures (the GL_SKIP_DECODE_EXT) state
        or sRGB textures (the GL_DECODE_EXT state).

        Example for a Direct3D9 CreateTexture with a D3DFMT_A8R8G8B8 format:

          glTexImage2D(GL_TEXTURE_2D, 0, GL_SRGB8_ALPHA8,
            width, height, border, GL_UNSIGNED_BYTE, GL_RGBA, texels);
          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SRGB_DECODE_EXT, GL_SKIP_DECODE_EXT);

        Notice the texture is created with a GL_SRGB_ALPHA8 format but
        immediately switched to GL_SKIP_DECODE_EXT.  This is because:

        1a) The format needs to be GL_SRGBA_ALPHA so that when used with
            a sampler configured with the (initial) value of zero (false)
            for D3DSAMP_SRGBTEXTURE, the texture will be filtered without
            sRGB decode.

        1b) Likewise, when D3DSAMP_SRGBTEXTURE is true for a sampler, the
            texture needs to be decoded to sRGB for filtering.  In this case,
            the OpenGL translation would use:

              glSamplerParameteri(sampler, GL_TEXTURE_SRGB_DECODE_EXT, GL_DECODE_EXT);

        2)  Direct3D9's D3DUSAGE_AUTOGENMIPMAP does not generate mipmaps
            in sRGB space (but rather in linear space).

        When rendering into a surface in Direct3D 9 with the
        D3DRS_SRGBWRITEENABLE render state (set by SetRenderState) set to false,
        the pixel updates (including blending) need to operate with
        GL_FRAMEBUFFER_SRGB disabled.  So:

          glDisable(GL_FRAMEBUFFER_SRGB);

        Likewise when the D3DRS_SRGBWRITEENABLE render state is true,
        OpenGL should operate

          glEnable(GL_FRAMEBUFFER_SRGB);

        Any texture with an sRGB internal format (for example,
        GL_SRGB8_ALPHA8 for the internal format) will perform sRGB decode
        before blending and encode after blending.  This matches the Direct3D9
        semantics when D3DUSAGE_QUERY_SRGBWRITE is true of the resource format.

   13) How is this extension expected to be used for Direct3D 10 and
       11 emulation?

        RESOLVED:  Direct3D 10 and 11 support non-mutable formats for sRGB
        textures (matching the original behavior of EXT_texture_sRGB,
        unextended by this extension).  So the DXGI_FORMAT_*_SRGB
        formats are always decoded from sRGB to linear (and vice versa)
        as necessary.  Formats not suffixed with _SRGB are never decoded
        or encoded to sRGB.

        Direct3D 10 and 11 support "typeless" resources with resource views
        that can have different formats.  So you can create a texture
        with a format of DXGI_FORMAT_R8G8B8A8_TYPELESS and then create
        shader resource views with the DXGI_FORMAT_R8G8B8A8_UNORM and
        DXGI_FORMAT_R8G8B8A8_UNORM_SRGB formats on that. This is a much
        more generic approach to decoupling storage and interpretation in
        Direct3D 10 and 11.  However support for "typeless" resources
        and resource views is beyond the scope of this extension.

        These two questions from Microsoft's Direct3D 10 Frequently Asked
        Questions list provide helpful context:

            "Q:  Where did the D3DSAMP_SRGBTEXTURE state go?

            A: SRGB was removed as part of the sampler state and now
            is tied to the texture format. Binding an SRGB texture will
            result in the same sampling you would get if you specified
            D3DSAMP_SRGBTEXTURE in Direct3D 9.

            Q:  What are these new SRGB formats?

            A:  SRGB was removed as part of the sampler state and is
            now tied to the texture format. Binding an SRGB texture will
            result in the same sampling you would get if you specified
            D3DSAMP_SRGBTEXTURE in Direct3D 9."

        This means that normal "linear" textures, such as
        DXGI_FORMAT_R8G8B8A8_UNORM, would be created as GL_RGBA8 textures
        (not sRGB), so that they will always behave as linear textures
        (never sRGB-decoded).

        On the other hand, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB would be
        created as GL_SRGB8_ALPHA8.  Its texture sRGB decode parameter
        would be left with the initial value of GL_DECODE_EXT.  Mipmap
        generation for a texture using DXGI_FORMAT_R8G8B8A8_UNORM_SRGB
        (GL_RGB8_ALPHA8 in OpenGL) would perform the proper sRGB decode
        and encode needed for automatic mipmap generation.

        In Direct3D 10 and 11 emulation, the GL_TEXTURE_SRGB_DECODE_EXT
        parameter of sampler objects would simply be left at its initial
        value of GL_DECODE_EXT.  Unlike Direct3D 9 where the sampler
        controlled sRGB decode (via the D3DSAMP_SRGBTEXTURE), that parameter
        is not present in Direct3D 10 and 11 (see the FAQ questions above).

        The conclusion of this issue's discussion is that Direct3D
        10 and 11 emulation software should simply ignore the
        EXT_texture_sRGB_decode extension.  This is to be expected
        because the EXT_texture_sRGB_decode extension is meant to match
        the legacy functionality of Direct3D 9.

   14) Why does Table X.1 show "Undefined", and why does it appear in
       different columns depending on whether bindless samplers are used
       or not?

        RESOLVED: Conceptually, TEXTURE_SRGB_DECODE_EXT is part of the
        sampler state and should therefore not apply to texelFetch. However,
        not all hardware has the required bit in the sampler state.

        With bindless samplers, texture handles are *always* statically
        accessed by texelFetch (because an application could choose to do so
        at any time), so applying the same rules as for non-bindless
        samplers would make the functionality provided in this extension
        useless.

Revision History

        Rev.    Date    Author    Changes
        ----  --------  --------  -------------------------------------
        0.91  11/08/17  nhaehnle  Add interaction with bindless textures
                                  (API issue #51)
        0.90  04/27/16  Jon Leech Add interaction with texelFetch builtins
                                  (Bug 14934)
        0.89  08/14/13  dkoch     Add interactions with ASTC/ETC2/NV_sRGB_formats
        0.88  07/24/13  mheyer    Add OpenGL ES interactions
        0.87  08/22/11  mjk       correction to issue #8 from Jason
        0.86  08/22/11  mjk       corrections from Daniel + more interactions
        0.85  08/13/11  mjk       corrections to issues from Jason and Henri
        0.84  08/05/11  mjk       New issues to explain Direct3D interactions;
                                  fix table Get Command.
        0.83  07/15/11  mjk       "current texture unit" -> "texture
                                  object" for mipmap generation
        0.82  04/12/11  mjk       Mipmap generation interactions.
        0.81  11/18/10  mattc     Fixed language in error section.
                                  Cleaned up which functions take which tokens.
        0.8   11/18/10  mattc     Added issues from EXT_texture_sRGB_decode

                                  for background info. Cleaned up layout.
        0.71  11/18/10  mattc     Adapted apple_texture_linearize_srgb into
                                  this specification.