Name

    AMD_texture_gather_bias_lod

Name Strings

    GL_AMD_texture_gather_bias_lod

Contact

    Rex Xu, AMD (Rex.Xu 'at' amd.com)

Contributors

    Rex Xu, AMD
    Timothy Lottes, AMD
    Qun Lin, AMD
    Daniel Rakos, AMD
    Graham Sellers, AMD
    Dominik Witczak, AMD
    Matthäus G. Chajdas, AMD


Status

    Shipping

Version

    Last Modified Date:         05/10/2017
    Author Revision:            5

Number

    502

Dependencies

    This extension is written against the OpenGL 4.5 (Core Profile) Specification.

    This extension is written against version 4.50 of the OpenGL Shading Language Specification.

    OpenGL 4.0 and GLSL 4.00 are required.

    This extension interacts with ARB_sparse_texture2.

Overview

    This extension was developed based on existing built-in texture gather functions to allow
    implementations supporting bias of implicit level of detail and explicit control of level of
    detail in texture gather operations.

New Procedures and Functions

    None.

New Tokens

    None.

Modifications to the OpenGL Shading Language Specification, Version 4.50

    Including the following line in a shader can be used to control the language features described
    in this extension:

        #extension GL_AMD_texture_gather_bias_lod : <behavior>

    where <behavior> is as specified in section 3.3.

    New preprocessor #defines are added to the OpenGL Shading Language:

        #define GL_AMD_texture_gather_bias_lod      1

Additions to Chapter 8 of the OpenGL Shading Language Specification (Built-in Functions)

    Modify Section 8.9.3 Texture Gather Functions

    (modify the first sentence of the first paragraph on p. 170)

    The texture gather functions take components of a single floating-point vector operand as a
    texture coordinate, determine a set of four texels to sample either from the base level of
    detail and its bias (if present) of the specified texture image or from the explicit level of
    detail (if present) of this texture image, and return one component from each texel in a four-
    component result vector.

    (modify certain functions in the "Syntax" table cell of each gather function group, adding
     an optional <bias> parameter for those sampler types: gsampler2D, gsampler2DArray,
     gsamplerCube, gsamplerCubeArray, and modify four-texel sampling formulas in the "Description"
     table cell of textureGather() on p. 171-172)

    +--------------------------------------------------------------+------------------------------+
    | Syntax                                                       | Description                  |
    +--------------------------------------------------------------+------------------------------+
    | gvec4 textureGather(gsampler2D sampler, vec2 P [, int comp   | Returns the value            |
    |                     [, float bias]])                         |                              |
    | gvec4 textureGather(gsampler2DArray sampler, vec3 P          | gvec4(                       |
    |                     [, int comp [, float bias]])             |   Sample_i0_j1(              |
    | gvec4 textureGather(gsamplerCube sampler, vec3 P             |     P, base, bias).comp,     |
    |                     [, int comp [, float bias]])             |   Sample_i1_j1(              |
    | gvec4 textureGather(gsamplerCubeArray sampler, vec4 P        |     P, base, bias).comp,     |
    |                     [, int comp [, float bias]])             |   Sample_i1_j0(              |
    | ...                                                          |     P, base, bias).comp,     |
    |                                                              |   Sample_i0_j0(              |
    |                                                              |     P, base, bias).comp)     |
    |                                                              | ...                          |
    +--------------------------------------------------------------+------------------------------+
    | gvec4 textureGatherOffset(gsampler2D sampler, vec2 P,        | Perform a texture gather     |
    |                           ivec2 offset [, int comp           | operation as in              |
    |                           [, float bias]])                   | textureGather() by <offset>  |
    | gvec4 textureGatherOffset(gsampler2DArray sampler, vec3 P,   | as described in              |
    |                           ivec2 offset [, int comp           | textureOffset() except that  |
    |                           [, float bias]])                   | the <offset> can be variable |
    | ...                                                          | (non constant) and ...       |
    +--------------------------------------------------------------+------------------------------+
    | gvec4 textureGatherOffsets(gsampler2D sampler, vec2 P,       | Operate identically to       |
    |                            ivec2 offsets[4] [, int comp      | textureGatherOffset() except |
    |                            [, float bias]])                  | that <offsets> is used to    |
    | gvec4 textureGatherOffsets(gsampler2DArray sampler, vec3 P,  | determine the location of the|
    |                            ivec2 offsets[4] [, int comp      | four texels to sample. ...   |
    |                            [, float bias]])                  |                              |
    | ...                                                          |                              |
    +--------------------------------------------------------------+------------------------------+

    (insert new gather function table cells, at the end of the section, p. 172)

    +--------------------------------------------------------------+------------------------------+
    | Syntax                                                       | Description                  |
    +--------------------------------------------------------------+------------------------------+
    | gvec4 textureGatherLodAMD(gsampler2D sampler, vec2 P,        | Perform a texture gather     |
    |                           float lod [, int comp])            | operation as in              |
    | gvec4 textureGatherLodAMD(gsampler2DArray sampler, vec3 P,   | textureGather() with explicit|
    |                           float lod [, int comp])            | LOD, but the four-texel      |
    | gvec4 textureGatherLodAMD(gsamplerCube sampler, vec3 P,      | sampling is modified as      |
    |                           float lod [, int comp])            | follow:                      |
    | gvec4 textureGatherLodAMD(gsamplerCubeArray sampler, vec4 P, |                              |
    |                           float lod [, int comp])            | gvec4(                       |
    |                                                              |   Sample_i0_j1(P, lod).comp, |
    |                                                              |   Sample_i1_j1(P, lod).comp, |
    |                                                              |   Sample_i1_j0(P, lod).comp, |
    |                                                              |   Sample_i0_j0(P, lod).comp) |
    +--------------------------------------------------------------+------------------------------+
    | gvec4 textureGatherLodOffsetAMD(gsampler2D sampler, vec2 P,  | Perform a texture gather     |
    |                                 float lod, ivec2 offset      | operation as in              |
    |                                 [, int comp])                | textureGatherOffset() but    |
    | gvec4 textureGatherLodOffsetAMD(gsampler2DArray sampler,     | with explicit LOD.           |
    |                                 vec3 P, float lod,           |                              |
    |                                 ivec2 offset [, int comp])   |                              |
    +--------------------------------------------------------------+------------------------------+
    | gvec4 textureGatherLodOffsetsAMD(gsampler2D sampler, vec2 P, | Perform a texture gather     |
    |                                  float lod, ivec2 offsets[4] | operation as in              |
    |                                  [, int comp])               | textureGatherOffsets() but   |
    | gvec4 textureGatherLodOffsetsAMD(gsampler2DArray sampler,    | with explicit LOD.           |
    |                                  vec3 P, float lod,          |                              |
    |                                  ivec2 offsets[4]            |                              |
    |                                  [, int comp])               |                              |
    +--------------------------------------------------------------+------------------------------+

Dependencies on ARB_sparse_texture2

    If the shader enables ARB_sparse_texture2, this extension modifies certain variants of
    sparseTextureGather*(), adding optional <bias> parameter for those sampler types: gsampler2D,
    gsampler2DArray, gsamplerCube, gsamplerCubeArray.

    +--------------------------------------------------------------+------------------------------+
    | Syntax                                                       | Description                  |
    +--------------------------------------------------------------+------------------------------+
    | int sparseTextureGatherARB(gsampler2D sampler, vec2 P,       | Do a texture gather operation|
    |                            out gvec4 texel [, int comp       | as in textureGather(), but   |
    |                            [, float bias]])                  | return texture access        |
    | int sparseTextureGatherARB(gsampler2DArray sampler, vec3 P,  | residency information from   |
    |                            out gvec4 texel [, int comp       | the function and the filtered|
    |                            [, float bias]])                  | lookup result in the out     |
    | int sparseTextureGatherARB(gsamplerCube sampler, vec3 P,     | parameter <texel>.           |
    |                            out gvec4 texel [, int comp       |                              |
    |                            [, float bias]])                  |                              |
    | int sparseTextureGatherARB(gsamplerCubeArray sampler, vec4 P,|                              |
    |                            out gvec4 texel [, int comp       |                              |
    |                            [, float bias]])                  |                              |
    | ...                                                          |                              |
    +--------------------------------------------------------------+------------------------------+
    | int sparseTextureGatherOffsetARB(gsampler2D sampler, vec2 P, | Do a texture gather operation|
    |                                  ivec2 offset,               | as in textureGatherOffset(), |
    |                                  out gvec4 texel             | but return texture access    |
    |                                  [, int comp [, float bias]])| residency information from   |
    | int sparseTextureGatherOffsetARB(gsampler2DArray sampler,    | the function and the filtered|
    |                                  vec3 P, ivec2 offset,       | lookup result in the out     |
    |                                  out gvec4 texel             | parameter <texel>.           |
    |                                  [, int comp [, float bias]])|                              |
    | ...                                                          |                              |
    +--------------------------------------------------------------+------------------------------+
    | int sparseTextureGatherOffsetsARB(gsampler2D sampler, vec2 P,| Do a texture gather operation|
    |                                   ivec2 offsets[4],          | as in textureGatherOffsets(),|
    |                                   out gvec4 texel            | but return texture access    |
    |                                   [, int comp                | residency information from   |
    |                                   [, float bias]])           | the function and the filtered|
    | int sparseTextureGatherOffsetsARB(gsampler2DArray sampler,   | lookup result in the out     |
    |                                   vec3 P, ivec2 offsets[4],  | parameter <texel>.           |
    |                                   out gvec4 texel            |                              |
    |                                   [, int comp                |                              |
    |                                   [, float bias]])           |                              |
    | ...                                                          |                              |
    +--------------------------------------------------------------+------------------------------+

    Meanwhile, this extension adds additional texture gather functions as follow if the shader
    enables ARB_sparse_texture2, providing explicit control of level of detail.

    +--------------------------------------------------------------+------------------------------+
    | Syntax                                                       | Description                  |
    +--------------------------------------------------------------+------------------------------+
    | int sparseTextureGatherLodAMD(gsampler2D sampler, vec2 P,    | Do a texture gather operation|
    |                               float lod, out gvec4 texel     | as in textureGather() with,  |
    |                               [, int comp])                  | explicit LOD, but return     |
    | int sparseTextureGatherLodAMD(gsampler2DArray sampler,       | texture access residency     |
    |                               vec3 P, float lod,             | information from the function|
    |                               out gvec4 texel [, int comp])  | and the filtered lookup      |
    | int sparseTextureGatherLodAMD(gsamplerCube sampler, vec3 P,  | result in the out parameter  |
    |                               float lod, out gvec4 texel     | <texel>.                     |
    |                               [, int comp])                  |                              |
    | int sparseTextureGatherLodAMD(gsamplerCubeArray sampler,     |                              |
    |                               vec4 P, float lod,             |                              |
    |                               out gvec4 texel [, int comp])  |                              |
    +--------------------------------------------------------------+------------------------------+
    | int sparseTextureGatherLodOffsetAMD(gsampler2D sampler,      | Do a texture gather operation|
    |                                     vec2 P, float lod,       | as in textureGatherOffset()  |
    |                                     ivec2 offset,            | with explicit LOD, but return|
    |                                     out gvec4 texel          | texture access residency     |
    |                                     [, int comp])            | information from the function|
    | int sparseTextureGatherLodOffsetAMD(gsampler2DArray sampler, | and the filtered lookup      |
    |                                     vec3 P, float lod,       | result in the out parameter  |
    |                                     ivec2 offset,            | <texel>.                     |
    |                                     out gvec4 texel          |                              |
    |                                     [, int comp])            |                              |
    +--------------------------------------------------------------+------------------------------+
    | int sparseTextureGatherLodOffsetsAMD(gsampler2D sampler,     | Do a texture gather operation|
    |                                      vec2 P, float lod,      | as in textureGatherOffsets() |
    |                                      ivec2 offsets[4],       | with explicit LOD, but return|
    |                                      out gvec4 texel         | texture access residency     |
    |                                      [, int comp])           | information from the function|
    | int sparseTextureGatherLodOffsetsAMD(gsampler2DArray sampler,| and the filtered lookup      |
    |                                      vec3 P, float lod,      | result in the out parameter  |
    |                                      ivec2 offsets[4],       | <texel>.                     |
    |                                      out gvec4 texel         |                              |
    |                                      [, int comp])           |                              |
    +--------------------------------------------------------------+------------------------------+

Errors

    None.

New State

    None.

New Implementation Dependent State

    None.

Issues

    (1) Could you explain the function syntax since <bias> is added as another optional parameter?

      RESOLVED: This extension adds <bias> as another optional parameter apart from the existing
      parameter <comp>. The function syntax is somewhat similar to rules of default parameters in
      C++. To be exact, when <comp> is not specified, <bias> should not be specified as well; when
      <comp> is specified, <bias> could be specified or not. For example,

          uniform sampler2D samp2D;

          vec2  P;
          int   comp;
          float bias;

          ...

          textureGather(samp2D, P);              // legal, both comp and bias are not specified
          textureGather(samp2D, P, bias);        // illegal, bias is specified while comp is not
          textureGather(samp2D, P, comp);        // legal, comp is specified while bias is not
          textureGather(samp2D, p, comp, bias);  // legal both comp and bias are specified

    (2) Which level-of-detail do texture gather functions use, if the extension is defined?

      RESOLVED: If GL_AMD_texture_gather_bias_lod extension is *enabled*, *all* texture
      gather functions (ie. the ones which do not take the extra bias argument and
      the ones that do) fetch texels from implicit LOD in fragment shader stage. In all
      other shader stages, base level is used instead.

      If the extension is *disabled*, all texture gather functions always fetch texels
      from the base mip level.


Revision History

    Rev.    Date    Author    Changes
    ----  --------  --------  ---------------------------------------------------------------------
     5    05/10/17  dwitczak  Added issue 2.

     4    01/24/17  dwitczak  Fix sparseTextureGatherOffsetsARB() and
                              sparseTextureGatherLodOffsetAMD() function prototypes.

     3    11/17/16  rexu      Clarify that when <bias> parameter is specified, the optional <comp>
                              parameter, prior to <bias>, should be specified as well based on
                              the calling rules of default parameters.

     2    11/16/16  rexu      Add the interaction with ARB_sparse_texture2.

     1    11/15/16  rexu      Initial draft.