| 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. |