Name

    ARB_sparse_texture_clamp

Name Strings

    GL_ARB_sparse_texture_clamp

Contact

    Eric Werness, NVIDIA Corporation (ewerness 'at' nvidia.com)

Contributors

    Pat Brown, NVIDIA Corporation
    Piers Daniell, NVIDIA Corporation
    Jeff Bolz, NVIDIA Corporation
    Mathias Heyer, NVIDIA Corporation

Notice

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

Status

    Complete. Approved by the ARB on June 26, 2015.
    Ratified by the Khronos Board of Promoters on August 7, 2015.

Version

    Last Modified Date:         April 30, 2015
    Revision:                   2

Number

    ARB Extension #187

Dependencies

    This extension is written against the OpenGL 4.5 Specification
    (Compatibility Profile), dated February 2, 2015.

    This extension is written against the OpenGL Shading Language
    Specification, version 4.50, revision 5.

    This extension requires and extends ARB_sparse_texture2.

    This extension interacts with NV_gpu_program4 and NV_gpu_program5.

Overview

    This extension builds on the ARB_sparse_texture2 extension, providing the
    following new functionality:

      * New built-in GLSL texture lookup functions are provided that specify a
        minimum level of detail to use for lookups where the level of detail
        is computed automatically.  This allows shaders to avoid accessing
        unpopulated portions of high-resolution levels of detail when it knows
        that the memory accessed is unpopulated, either from a priori
        knowledge or from feedback provided by the return value of previously
        executed "sparse" texture lookup functions.

New Procedures and Functions

    None.

New Tokens

    None.

Modifications to the OpenGL 4.5 Specification (Compatibility Profile)

    Modify Section 8.14.1, Scale Factor and Level of Detail, p. 280

    (move the third paragraph, p. 281, describing lod_min and lod_max
     in equation 8.6, up one paragraph and modify it to read as follows)

    lod_min and lod_max indicate minimum and maximum clamps on the computed
    level of detail.  lod_max is taken directly from the TEXTURE_MAX_LOD
    texture or sampler parameter.  If a texture access is performed in a
    fragment shader with a minimum level of detail clamp specified in the
    built-in texture lookup function, lod_min is the larger of the
    TEXTURE_MIN_LOD texture or sampler parameter and the minimum level of
    detail provided by the shader.  Otherwise, lod_min is taken directly from
    the TEXTURE_MIN_LOD texture or sampler parameter.  The initial values of
    the TEXTURE_MIN_LOD and TEXTURE_MAX_LOD texture and sampler parameters are
    chosen so as to never clamp the range of lambda values.

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_ARB_sparse_texture_clamp : <behavior>

    where <behavior> is as specified in section 3.3.

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

      #define GL_ARB_sparse_texture_clamp            1

    Modify Section 8.9, Texture Functions, p. 158

    (insert after first paragraph, p. 159)

    The texture lookup functions with an <lodClamp> parameter specify a
    minimum clamp applied to the automatic level of detail computations.
    Since automatic level of detail calculations are only supported by
    fragment shaders, these lookup functions are also only available in
    fragment shaders.  No functions with the <lodClamp> parameter are provided
    for rectangle textures, multisample textures, and texture buffers because
    mipmaps are not allowed for these types of textures.


    Modify Section 8.9.2, Texel Lookup Functions, p. 162

    (The combination of this extension and ARB_sparse_texture2 adds two new
    variants of texture lookup functions.  The "sparse" functions are like
    normal texture lookup functions, except that they return a sparse texture
    residency status to the caller and return the actual filtered texel value in
    an "out" parameter.  The "Clamp" variants are functions adding a new
    parameter specifying a minimum LOD to use for texture lookup functions where
    level of detail is computed automatically.

    For each set of texture functions, we provide one to three new variants
    based on whether sparse and LOD clamping functionality are desired.  These
    new variants copy the existing functions, add suffixes to the function
    names, and add one or more new parameters.

    We create new variants only for the targets for which sparse storage is
    supported -- no new functions are added for the following sampler types:
    gsampler1D, sampler1DShadow, gsampler1DArray, sampler1DArrayShadow.
    Additionally, to reduce the number of new functions added, we are not
    including any new variants for textureProj*() built-ins.  To use the new
    features with projective texture lookups, shaders can divide through by q
    and use non-projective variants.  We also chose not to provide "Clamp"
    variants of functions like textureLod() expecting an explicit
    level-of-detail.)

    (insert new lookup function table cells, at the end of the section,
    p. 168)

    Syntax:

      int sparseTextureClampARB(gsampler2D sampler, vec2 P,
                                float lodClamp, out gvec4 texel
                                [, float bias]);
      int sparseTextureClampARB(gsampler3D sampler, vec3 P,
                                float lodClamp, out gvec4 texel
                                [, float bias]);
      int sparseTextureClampARB(gsamplerCube sampler, vec3 P,
                                float lodClamp, out gvec4 texel
                                [, float bias]);
      int sparseTextureClampARB(sampler2DShadow sampler, vec3 P,
                                float lodClamp, out float texel
                                [, float bias]);
      int sparseTextureClampARB(samplerCubeShadow sampler, vec4 P,
                                float lodClamp, out float texel
                                [, float bias]);
      int sparseTextureClampARB(gsampler2DArray sampler, vec3 P,
                                float lodClamp, out gvec4 texel
                                [, float bias]);
      int sparseTextureClampARB(gsamplerCubeArray sampler, vec4 P,
                                float lodClamp, out gvec4 texel
                                [, float bias]);
      int sparseTextureClampARB(sampler2DArrayShadow sampler, vec4 P,
                                float lodClamp, out float texel);
      int sparseTextureClampARB(samplerCubeArrayShadow sampler, vec4 P,
                                float compare, float lodClamp,
                                out float texel);

    Description:

    Do a filtered texture lookup as in texture(), but return texture access
    residency information from the function and the filtered lookup result in
    the out parameter <texel>.  Additionally, clamp the automatically computed
    level of detail to be greater than or equal to <lodClamp>.

    --

    Syntax:

      gvec4 textureClampARB(gsampler1D sampler, float P,
                            float lodClamp [, float bias]);
      gvec4 textureClampARB(gsampler2D sampler, vec2 P,
                            float lodClamp [, float bias]);
      gvec4 textureClampARB(gsampler3D sampler, vec3 P,
                            float lodClamp [, float bias]);
      gvec4 textureClampARB(gsamplerCube sampler, vec3 P,
                            float lodClamp [, float bias]);
      float textureClampARB(sampler1DShadow sampler, vec3 P,
                            float lodClamp [, float bias]);
      float textureClampARB(sampler2DShadow sampler, vec3 P,
                            float lodClamp [, float bias]);
      float textureClampARB(samplerCubeShadow sampler, vec4 P,
                            float lodClamp [, float bias]);
      gvec4 textureClampARB(gsampler1DArray sampler, vec2 P,
                            float lodClamp [, float bias]);
      gvec4 textureClampARB(gsampler2DArray sampler, vec3 P,
                            float lodClamp [, float bias]);
      gvec4 textureClampARB(gsamplerCubeArray sampler, vec4 P,
                            float lodClamp [, float bias]);
      float textureClampARB(sampler1DArrayShadow sampler, vec3 P,
                            float lodClamp [, float bias]);
      float textureClampARB(sampler2DArrayShadow sampler, vec4 P,
                            float lodClamp);
      float textureClampARB(samplerCubeArrayShadow sampler, vec4 P,
                            float compare, float lodClamp);

    Description:

    Do a filtered texture lookup as in texture(), but clamp the automatically
    computed level of detail to be greater than or equal to <lodClamp>.

    --

    Syntax:

      int sparseTextureOffsetClampARB(gsampler2D sampler, vec2 P,
                                      ivec2 offset, float lodClamp,
                                      out gvec4 texel [, float bias]);
      int sparseTextureOffsetClampARB(gsampler3D sampler, vec3 P,
                                      ivec3 offset, float lodClamp,
                                      out gvec4 texel [, float bias]);
      int sparseTextureOffsetClampARB(sampler2DShadow sampler, vec3 P,
                                      ivec2 offset, float lodClamp,
                                      out float texel [, float bias]);
      int sparseTextureOffsetClampARB(gsampler2DArray sampler, vec3 P,
                                      ivec2 offset, float lodClamp,
                                      out gvec4 texel [, float bias]);
      int sparseTextureOffsetClampARB(sampler2DArrayShadow sampler, vec4 P,
                                      ivec2 offset, float lodClamp,
                                      out float texel);

    Description:

    Do a filtered texture lookup as in textureOffset(), but return texture
    access residency information from the function and the filtered lookup
    result in the out parameter <texel>.  Additionally, clamp the
    automatically computed level of detail to be greater than or equal to
    <lodClamp>.

    --

    Syntax:

      gvec4 textureOffsetClampARB(gsampler1D sampler, float P,
                                  int offset, float lodClamp [, float bias]);
      gvec4 textureOffsetClampARB(gsampler2D sampler, vec2 P,
                                  ivec2 offset, float lodClamp [, float bias]);
      gvec4 textureOffsetClampARB(gsampler3D sampler, vec3 P,
                                  ivec3 offset, float lodClamp [, float bias]);
      float textureOffsetClampARB(sampler1DShadow sampler, vec3 P,
                                  int offset, float lodClamp [, float bias]);
      float textureOffsetClampARB(sampler2DShadow sampler, vec3 P,
                                  ivec2 offset, float lodClamp [, float bias]);
      gvec4 textureOffsetClampARB(gsampler1DArray sampler, vec2 P,
                                  int offset, float lodClamp [, float bias]);
      gvec4 textureOffsetClampARB(gsampler2DArray sampler, vec3 P,
                                  ivec2 offset, float lodClamp [, float bias]);
      float textureOffsetClampARB(sampler1DArrayShadow sampler, vec3 P,
                                  int offset, float lodClamp [, float bias]);
      float textureOffsetClampARB(sampler2DArrayShadow sampler, vec4 P,
                                  ivec2 offset, float lodClamp);

    Description:

    Do a filtered texture lookup as in textureOffset(), but clamp the
    automatically computed level of detail to be greater than or equal to
    <lodClamp>.

    --

    Syntax:

      int sparseTextureGradClampARB(gsampler2D sampler, vec2 P,
                                    vec2 dPdx, vec2 dPdy, float lodClamp,
                                    out gvec4 texel);
      int sparseTextureGradClampARB(gsampler3D sampler, vec3 P,
                                    vec3 dPdx, vec3 dPdy, float lodClamp,
                                    out gvec4 texel);
      int sparseTextureGradClampARB(gsamplerCube sampler, vec3 P,
                                    vec3 dPdx, vec3 dPdy, float lodClamp,
                                    out gvec4 texel);
      int sparseTextureGradClampARB(sampler2DShadow sampler, vec3 P,
                                    vec2 dPdx, vec2 dPdy, float lodClamp,
                                    out float texel);
      int sparseTextureGradClampARB(samplerCubeShadow sampler, vec4 P,
                                    vec3 dPdx, vec3 dPdy, float lodClamp,
                                    out float texel);
      int sparseTextureGradClampARB(gsampler2DArray sampler, vec3 P,
                                    vec2 dPdx, vec2 dPdy, float lodClamp,
                                    out gvec4 texel);
      int sparseTextureGradClampARB(sampler2DArrayShadow sampler, vec4 P,
                                    vec2 dPdx, vec2 dPdy, float lodClamp,
                                    out float texel);
      int sparseTextureGradClampARB(gsamplerCubeArray sampler, vec4 P,
                                    vec3 dPdx, vec3 dPdy, float lodClamp,
                                    out gvec4 texel);

    Description:

    Do a filtered texture lookup as in textureGrad(), but return texture
    access residency information from the function and the filtered lookup
    result in the out parameter <texel>.  Additionally, clamp the
    automatically computed level of detail to be greater than or equal to
    <lodClamp>.

    --

    Syntax:

      gvec4 textureGradClampARB(gsampler1D sampler, float P,
                                float dPdx, float dPdy, float lodClamp);
      gvec4 textureGradClampARB(gsampler2D sampler, vec2 P,
                                vec2 dPdx, vec2 dPdy, float lodClamp);
      gvec4 textureGradClampARB(gsampler3D sampler, vec3 P,
                                vec3 dPdx, vec3 dPdy, float lodClamp);
      gvec4 textureGradClampARB(gsamplerCube sampler, vec3 P,
                                vec3 dPdx, vec3 dPdy, float lodClamp);
      float textureGradClampARB(sampler1DShadow sampler, vec3 P,
                                float dPdx, float dPdy, float lodClamp);
      float textureGradClampARB(sampler2DShadow sampler, vec3 P,
                                vec2 dPdx, vec2 dPdy, float lodClamp);
      float textureGradClampARB(samplerCubeShadow sampler, vec4 P,
                                vec3 dPdx, vec3 dPdy, float lodClamp);
      gvec4 textureGradClampARB(gsampler1DArray sampler, vec2 P,
                                float dPdx, float dPdy, float lodClamp);
      gvec4 textureGradClampARB(gsampler2DArray sampler, vec3 P,
                                vec2 dPdx, vec2 dPdy, float lodClamp);
      float textureGradClampARB(sampler1DArrayShadow sampler, vec3 P,
                                float dPdx, float dPdy, float lodClamp);
      float textureGradClampARB(sampler2DArrayShadow sampler, vec4 P,
                                vec2 dPdx, vec2 dPdy, float lodClamp);
      gvec4 textureGradClampARB(gsamplerCubeArray sampler, vec4 P,
                                vec3 dPdx, vec3 dPdy, float lodClamp);

    Description:

    Do a filtered texture lookup as in textureGrad(), but clamp the
    automatically computed level of detail to be greater than or equal to
    <lodClamp>.

    --

    Syntax:

      int sparseTextureGradOffsetClampARB(gsampler2D sampler, vec2 P,
                                          vec2 dPdx, vec2 dPdy, ivec2 offset,
                                          float lodClamp, out gvec4 texel);
      int sparseTextureGradOffsetClampARB(gsampler3D sampler, vec3 P,
                                          vec3 dPdx, vec3 dPdy, ivec3 offset,
                                          float lodClamp, out gvec4 texel);
      int sparseTextureGradOffsetClampARB(sampler2DShadow sampler, vec3 P,
                                          vec2 dPdx, vec2 dPdy, ivec2 offset,
                                          float lodClamp, out float texel);
      int sparseTextureGradOffsetClampARB(gsampler2DArray sampler, vec3 P,
                                          vec2 dPdx, vec2 dPdy, ivec2 offset,
                                          float lodClamp, out gvec4 texel);
      int sparseTextureGradOffsetClampARB(sampler2DArrayShadow sampler, vec4 P,
                                          vec2 dPdx, vec2 dPdy, ivec2 offset,
                                          float lodClamp, out float texel);

    Description:

    Do a filtered texture lookup as in textureGradOffset(), but return texture
    access residency information from the function and the filtered lookup
    result in the out parameter <texel>.  Additionally, clamp the
    automatically computed level of detail to be greater than or equal to
    <lodClamp>.

    --

    Syntax:

      gvec4 textureGradOffsetClampARB(gsampler1D sampler, float P,
                                      float dPdx, float dPdy, int offset,
                                      float lodClamp);
      gvec4 textureGradOffsetClampARB(gsampler2D sampler, vec2 P,
                                      vec2 dPdx, vec2 dPdy, ivec2 offset,
                                      float lodClamp);
      gvec4 textureGradOffsetClampARB(gsampler3D sampler, vec3 P,
                                      vec3 dPdx, vec3 dPdy, ivec3 offset,
                                      float lodClamp);
      float textureGradOffsetClampARB(sampler1DShadow sampler, vec3 P,
                                      float dPdx, float dPdy, int offset,
                                      float lodClamp);
      float textureGradOffsetClampARB(sampler2DShadow sampler, vec3 P,
                                      vec2 dPdx, vec2 dPdy, ivec2 offset,
                                      float lodClamp);
      gvec4 textureGradOffsetClampARB(gsampler1DArray sampler, vec2 P,
                                      float dPdx, float dPdy, int offset,
                                      float lodClamp);
      gvec4 textureGradOffsetClampARB(gsampler2DArray sampler, vec3 P,
                                      vec2 dPdx, vec2 dPdy, ivec2 offset,
                                      float lodClamp);
      float textureGradOffsetClampARB(sampler1DArrayShadow sampler, vec3 P,
                                      float dPdx, float dPdy, int offset,
                                      float lodClamp);
      float textureGradOffsetClampARB(sampler2DArrayShadow sampler, vec4 P,
                                      vec2 dPdx, vec2 dPdy, ivec2 offset,
                                      float lodClamp);

    Description:

    Do a filtered texture lookup as in textureGrad(), but clamp the
    automatically computed level of detail to be greater than or equal to
    <lodClamp>.

Additions to the AGL/GLX/WGL Specifications

    None.

Errors

    None.

New State

    None.

New Implementation Dependent State

    None.

Dependencies on NV_gpu_program4 and NV_gpu_program5

    Modify Section 2.X.2, Program Grammar

    <opModifier>            ::= "LODCLAMP"

    Modify Section 2.X.4.1, Program Instruction Modifiers

    (Update the discussion of instruction precision modifiers.  If
     GL_NV_gpu_program_fp64 is not found in the extension string, the "F64"
     instruction modifier described below is not supported.)

    (add to Table X.14 of the NV_gpu_program4 specification.)

      Modifier  Description
      --------  ------------------------------------------------------
      LODCLAMP  Clamp the LOD used by texture lookups to a specified
                value

    For texture fetch instructions with implicit LOD calcuations (TEX, TXB,
    TXD), the "LODCLAMP" modifier specifies that the instruction includes an
    extra floating-point component indicating a minimum level of detail to be
    used for the texture lookup.  If the implicitly computed level of detail
    is less than the level of detail provided in the instruction data, that
    level should be used instead.

    Modify Section 2.X.4.4, Program Texture Access

    (modify the prototype of the TextureSample utility function, adding
     <coord2> and removing <lod>)

      result_t_vec
        TextureSample(float_vec coord, float_vec coord2,
                      float_vec ddx, float_vec ddy, int_vec offset);

    (modify the description of <coord> to add <coord2>)

    <coord> and <coord2> are two four-component floating-point vectors from
    which the (s,t,r) texture coordinates used for the texture access, the
    layer used for array textures, and the reference value used for depth
    comparisons (section 3.8.14) are extracted according to Table X.17. ...

    (replace the paragraph discussing <lod>)

    <ddx> and <ddy> specify partial derivatives (ds/dx, dt/dx, dr/dx, ds/dy,
    dt/dy, and dr/dy) for the texture coordinates, and may be used for level
    of detail calculations and to derive footprint shapes for anisotropic
    texture filtering.

    The level of detail used for the texture lookup is a function of the
    texture instruction type, texture target, LODCLAMP qualifier, and the
    inputs <ddx> and <ddy>.  For TEX, TXB, TXD, and TXP instructions in a base
    level of detail is computed based on the partial derivatives <ddx> and
    <ddy>.  For the TXB and TXL instruction, an additional level of detail
    value is taken from the component in <coord> or <coord2> identified by the
    first entry in the "lod" column of Table X.17.  For TXB, this value is
    added to the computed base level of detail; for TXL, it specifies the base
    level of detail.  After that, per-texture and per-texture unit LOD biases
    are added to the level of detail.  Finally, if the LODCLAMP opcode
    modifier is specified, an LOD clamp value is extracted from <coord> or
    <coord2> according to the second entry in the "lod" column of Table X.17.
    The computed level of detail is clamped to be greater than or equal to
    this LOD clamp value.

                                                     coordinates used
      texTarget          Texture Type               s t r lay shd  lod
      ----------------   ---------------------      ----- --- ---  -----
      1D                 TEXTURE_1D                 x - -  -   -   w,x2
      2D                 TEXTURE_2D                 x y -  -   -   w,x2
      3D                 TEXTURE_3D                 x y z  -   -   w,x2
      CUBE               TEXTURE_CUBE_MAP           x y z  -   -   w,x2
      RECT               TEXTURE_RECTANGLE_ARB      x y -  -   -   -,-
      ARRAY1D            TEXTURE_1D_ARRAY_EXT       x - -  y   -   w,x2
      ARRAY2D            TEXTURE_2D_ARRAY_EXT       x y -  z   -   w,x2
      ARRAYCUBE          TEXTURE_CUBE_MAP_ARRAY     x y z  w   -   x2,y2
      SHADOW1D           TEXTURE_1D                 x - -  -   z   w,x2
      SHADOW2D           TEXTURE_2D                 x y -  -   z   w,x2
      SHADOWRECT         TEXTURE_RECTANGLE_ARB      x y -  -   z   -,-
      SHADOWCUBE         TEXTURE_CUBE_MAP           x y z  -   w   x2,y2
      SHADOWARRAY1D      TEXTURE_1D_ARRAY_EXT       x - -  y   z   w,x2
      SHADOWARRAY2D      TEXTURE_2D_ARRAY_EXT       x y -  z   w   -,x2
      SHADOWARRAYCUBE    TEXTURE_CUBE_MAP_ARRAY     x y z  w   x2  -,y2
      BUFFER             TEXTURE_BUFFER_EXT           <not supported>
      RENDERBUFFER       TEXTURE_RENDERBUFFER         <not supported>
      2DMS               TEXTURE_2D_MULTISAMPLE       <not supported>
      ARRAY2DMS          TEXTURE_2D_MULTISAMPLE_      <not supported>
                           ARRAY

      Table X.17:  Texture types accessed for each of the <texTarget>, and
      coordinate mappings.  Components "x", "y", "z", and "w" are taken from
      the first coordinate vector <coord>; "x2" and "y2" are taken from the
      second vector <coord2>.  The "SHADOW" and "ARRAY" targets are special
      pseudo-targets described below.  The "coordinates used" column indicate
      the input values used for each coordinate of the texture lookup, the
      layer selector for array textures, the reference value for texture
      comparisons, and up to two components of level-of-detail information.
      Buffer textures are not supported by normal texture lookup functions,
      but are supported by TXF and TXQ, described below.  Renderbuffer and
      multisample textures are not supported by normal texture lookup
      functions, but are supported by TXFMS.  The TXB and TXL instructions are
      not supported for the targets SHADOWARRAY2D and SHADOWARRAYCUBE, so the
      first column of "lod" is ignored.

    Modify Section 2.X.8.Z, TXD:  Texture Sample with Partials

    ... The partial derivatives of the texture coordinates with respect to X
    and Y are specified by the second and third floating-point source vectors.
    If the LODCLAMP instruction modifier is specified, floating-point
    level-of-detail clamp value is specified in the <w> component of the third
    floating-point source vector.  The level of detail is computed
    automatically using the provided partial derivatives.


Issues

    (1) How does this extension compare to the ARB_sparse_texture2 extension?

      RESOLVED: We extend the mechanisms provided by ARB_sparse_texture2 in
      adding built-in texture and image lookup functions clamping the final
      level of detail computed based on texture coordinates, derivatives, and
      LOD bias to a minimum LOD specified in the shader.

    (2) The combination of this extension and GL_ARB_sparse_texture2 add a
        *large* number of new built-in functions.
        What can we do to control this?

      RESOLVED:  We chose not to add any "sparse" or "LOD clamp" variants of
      projective texture lookups (e.g., textureProj).  If required, you can
      divide through by the "q" texture coordinate and use an equivalent
      non-projective lookup.

      We obviously don't support features that make no sense -- for example,
      LOD clamp on single-level rectangle textures.

      We considered the possibility of more significant GLSL syntax changes to
      reduce the cross-product of different features.  For example, the AMD
      extension has a function:

        int sparseTextureProjGradOffset(...);

      that combines four separate "optional" features (sparse, projection,
      explicitly specified gradients, and texel offsets) and is supported for
      six separate texture targets.  One might consider an approach like:

        #define TEX_IS_PROJECTIVE       0x1
        #define TEX_HAS_GRADIENTS       0x2
        #define TEX_HAS_TEXEL_OFFSET    0x4
        #define TEX_WANTS_SPARSE_STATUS 0x8
        struct TexLookup3D {
          uint          flags;          /* in */
          float         q;              /* in */
          vec3          ddx, ddy;       /* in */
          ivec3         texelOffset;    /* in */
          int           sparseStatus;   /* out */
        };
        ...
        TexLookup3D lookup;
        lookup.flags = (TEX_IS_PROJECTIVE | TEX_HAS_GRADIENTS |
                        TEX_HAS_TEXEL_OFFSET | TEX_WANTS_SPARSE_STATUS);
        lookup.q = coords.w;
        lookup.ddx = ddx;
        lookup.ddy = ddy;
        lookup.texelOffset = ivec3(-1,+1,+2);
        texture(sampler, lookup);

      to handle all possible cases in one interface.  Alternately, a
      "prettier" C++-style approach with methods on sampler classes could be
      used.

      Given that either such feature might involve a large change to the
      shading language, it seems more appropriate to address this issue in a
      future core version of a shading language rather than an extension.

    (3) For new "LOD clamp" functions, how does the LOD clamp interact with
        the LOD bias?

      RESOLVED:  The LOD clamp is applied after the LOD bias.  Clamping to the
      LOD provided in the shader is logically applied at the same point in the
      pipeline where the LOD clamps based on the texture/sampler parameters
      TEXTURE_{MIN,MAX}_LOD are applied.

Revision History

    Revision 1
      - Split clamp functions from ARB_sparse_texture2