Name

    ARB_texture_filter_minmax

Name Strings

    GL_ARB_texture_filter_minmax

Contact

    Jon Leech (oddhack 'at' sonic.net)
    Pat Brown, NVIDIA Corporation (pbrown 'at' nvidia.com)

Contributors

    Jeff Bolz, NVIDIA Corporation
    Mark Kilgard, NVIDIA Corporation
    Eric Werness, NVIDIA Corporation
    James Helferty, NVIDIA Corporation
    Daniel Koch, 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

    Version 6, April 20, 2015

Number

    ARB Extension #188

Dependencies

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

    OpenGL 3.3 is required.

    This extension interacts with EXT_texture_filter_anisotropic.

Overview

    In unextended OpenGL, minification and magnification filters such as
    LINEAR allow texture lookups to returned a filtered texel value produced
    by computing an weighted average of a collection of texels in the
    neighborhood of the texture coordinate provided.

    This extension provides a new texture and sampler parameter
    (TEXTURE_REDUCTION_MODE_ARB) which allows applications to produce a
    filtered texel value by computing a component-wise minimum (MIN) or
    maximum (MAX) of the texels that would normally be averaged.  The
    reduction mode is orthogonal to the minification and magnification filter
    parameters.  The filter parameters are used to identify the set of texels
    used to produce a final filtered value; the reduction mode identifies how
    these texels are combined.

New Procedures and Functions

    None.

New Tokens

    Accepted by the <pname> parameter to SamplerParameter{i f}{v},
    SamplerParameterI{u}iv, GetSamplerParameter{i f}v,
    GetSamplerParameterI{u}iv, TexParameter{i f}{v}, TexParameterI{u}iv,
    GetTexParameter{i f}v, GetTexParameterI{u}iv, TextureParameter{i f}{v},
    TextureParameterI{u}iv, GetTextureParameter{i f}v,
    and GetTextureParameterI{u}iv:

        TEXTURE_REDUCTION_MODE_ARB                  0x9366

    Accepted by the <param> or <params> parameter to SamplerParameter{i f}{v},
    SamplerParameterI{u}iv, TexParameter{i f}{v}, TexParameterI{u}iv,
    TextureParameter{i f}{v}, and TextureParameterI{u}iv when <pname> is
    TEXTURE_REDUCTION_MODE_ARB:

        WEIGHTED_AVERAGE_ARB                        0x9367
        MIN                                         (reused from core)
        MAX                                         (reused from core)

Modifications to the OpenGL 4.3 Specification (Compatibility Profile)

    Modify Section 8.10, Texture Parameters

    (add to Table 8.17, pp 227-228.)

      Name                              Type    Legal Values
      --------------------------        ----    --------------------
      TEXTURE_REDUCTION_MODE_ARB        enum    WEIGHTED_AVERAGE_ARB,
                                                MIN, MAX

[[ jon - Note that the generalized error language for Tex*Parameter* and
   SamplerParameter* catches the pname/param mismatch for this parameter,
   previously mentioned explicitly in the "Errors" section of the EXT spec.
   ]]


    Modify Section 8.14.2, Coordinate Wrapping and Texel Selection

    (add below the equations specifying the values i_0, j_0, ... beta, gamma
    on p. 246):

    ... where frac(x) denotes the fractional part of <x>, and may be
    quantized to a fixed-point value with implementation-dependent
    precision.


    Modify Section 8.14.3, Mipmapping

    (modify the last paragraph in the section, p. 251)

    The final texture value is then found as:

      tau = (1 - frac(lambda)) * tau_1 + frac(lambda) * tau_2,

    where frac(x) denotes the fractional part of <x> and may be quantized to
    a fixed-point value with implementation-dependent precision.


    Modify Section 8.17, Texture Completeness

[[ Jon - this change is with regard to the 20150421 GL 4.5 spec update and
   the changes in the completeness list resulting from bug 12791 ]]

    (modify the last bullet in the section, p. 264, so that this point only
    applies when the reduction mode samples from two mip levels):

    * Any of

      - The internal format of the texture arrays is integer (see tables
        8.19- 8.20), and the texture reduction mode is WEIGHTED_AVERAGE_ARB;

      - THe internal format is STENCIL_INDEX;

      - The internal format is DEPTH_STENCIL, the value of
        DEPTH_STENCIL_TEXTURE_MODE for the texture is STENCIL_INDEX, and the
        texture reduction mode is WEIGHTED_AVERAGE_ARB

      and either the magnification filter is not NEAREST, or the
      minification filter is neither NEAREST nor NEAREST_MIPMAP_NEAREST.

    (add a new bullet point expressing the constraints on supported texture
    formats)

      * The texture reduction mode is MIN or MAX, and that reduction mode is
        not supported for the texture dimensionality, multisample state, and
        internal format. Support for these reduction modes is only
        guaranteed in the following cases:

        - The texture is not multisampled (see section 8.8)
        - The internal format of the texture image is RED
            [[ Compatibility profile only: add LUMINANCE and INTENSITY ]]
        - The data type of the texture image is fixed- or floating-point.

        Implementations may also support these reduction modes for other
        formats. Such support can be determined by calling
        GetInternalformat* (see section 22.3) with <pname>
        TEXTURE_REDUCTION_MODE_ARB.


    Insert before Section 8.24, sRGB Texture Color Conversion (p. 271)

    Section 8.23post, Texture Reduction Modes

    When using minification and magnification filters such as LINEAR, or when
    using anisotropic texture filtering, the values of multiple texels will
    normally be combined using a weighted average to produce a filtered
    texture value.  However, a filtered texture value may also be produced by
    computing per-component minimum and maximum values over the set of texels
    that would normally be averaged.  The texture and sampler parameter
    TEXTURE_REDUCTION_MODE_EXT controls the process by which multiple texels
    are combined to produce a filtered texture value.  When set to its default
    state of WEIGHTED_AVERAGE_EXT, a weighted average will be computed, as
    described in previous sections.

    When TEXTURE_REDUCTION_MODE_ARB is MIN or MAX, the equations to produce a
    filtered texel value for LINEAR minification or magnification filters
    (equation 8.10 and subsequent unnumbered ones) are replaced with

      tau = reduce((1-alpha)*(1-beta)*(1-gamma), tau_i0_j0_k0,
                   (  alpha)*(1-beta)*(1-gamma), tau_i1_j0_k0,
                   (1-alpha)*(  beta)*(1-gamma), tau_i0_j1_k0,
                   (  alpha)*(  beta)*(1-gamma), tau_i1_j1_k0,
                   (1-alpha)*(1-beta)*(  gamma), tau_i0_j0_k1,
                   (  alpha)*(1-beta)*(  gamma), tau_i1_j0_k1,
                   (1-alpha)*(  beta)*(  gamma), tau_i0_j1_k1,
                   (  alpha)*(  beta)*(  gamma), tau_i1_j1_k1),

      tau = reduce((1-alpha)*(1-beta), tau_i0_j0,
                   (  alpha)*(1-beta), tau_i1_j0,
                   (1-alpha)*(  beta), tau_i0_j1,
                   (  alpha)*(  beta), tau_i1_j1), or

      tau = reduce((1-alpha), tau_i0,
                   (  alpha), tau_i1)

    for three-, two-, and one-dimensional texture accesses, respectively.  The
    function reduce() is defined to operate on pairs of weights and texel
    values.  If the reduction mode is MIN or MAX, reduce() computes a
    component-wise minimum or maximum, respectively, of the R, G, B, and A
    components of the set of provided texels with non-zero weights.

    For minification filters involving two texture levels
    (NEAREST_MIPMAP_LINEAR and LINEAR_MIPMAP_LINEAR), filtered values for the
    two selected levels, tau_1 and tau_2, are produced as described in section
    8.14.3, but using the reductions described immediately above.  The two
    filtered values will be combined to generate a final result using the
    equation

      tau = reduce((1-frac(lambda)), tau_1,
                   (  frac(lambda)), tau_2),

    where tau_1 and tau_2 are filtered values for levels d_1 and d_2, and
    frac(lambda) is the fractional portion of the texture level of detail and
    may be quantized to a fixed-point value with implementation-dependent
    precision.

    If anisotropic texture filtering is enabled, a reduction mode of
    WEIGHTED_AVERAGE_ARB will produce a filtered texel value by computing a
    weighted average of texel values, using an implementation-dependent set of
    selected texels and weights.  When using reduction modes of MIN or MAX, a
    filtered texel value will be produced using the equation

      tau = reduce(tau_1, ..., tau_N)

    where tau_1 through tau_N are the <N> texels that would be used with
    non-zero weights when a reduction mode of WEIGHTED_AVERAGE_ARB is used.

    If a texture access using a reduction mode of MIN or MAX is used with a
    texture access with depth comparisons enabled (see section 8.23.1), the
    individual tau values used in the reduce() functions should reflect the
    results of the depth comparison (0.0 or 1.0), not the original values in
    the depth texture.


    Modify Section 22.3.1, Supported Operation Queries

    (add to the table of support pnames starting on p. 542)

    * TEXTURE_REDUCTION_MODE_ARB: Support for filtering with reduction modes
      MIN and MAX is returned in <params>.


Additions to the AGL/GLX/WGL Specifications

    None.

New State

    Add to Table 23.23, Textures (state per sampler object)

                                                           Initial
    Get Value                   Type  Get Command           Value              Description                Sec.
    --------------------------  ----  -----------------   -------------------- ------------------------   -----
    TEXTURE_REDUCTION_MODE_ARB  E     GetTexParameteriv   WEIGHTED_AVERAGE_ARB Texture reduction mode     8.10
                                                                               (average, minimum, maximum)

New Implementation Dependent State

    None.

Dependencies on EXT_texture_filter_anisotropic

    If EXT_texture_filter_anisotropic is not supported, references to
    anisotropic filtering in the discussion of texture reduction modes should
    be removed.

Interactions with the compatibility profile

    If the compatibility profile is supported, then LUMINANCE and INTENSITY
    are added to the list of formats guaranteed to support MIN and MAX
    reduction modes.

Issues

    (1) What should this extension be called?

      RESOLVED: ARB_texture_filter_minmax, like EXT_texture_filter_minmax on
      which it is based.

    (2) How does this extension interact with restrictions on min/mag filters
        textures with integer components?

      RESOLVED:  In unextended OpenGL 4.3, a texture with integer components
      (e.g., RGBA8I) is considered incomplete if used with minification or
      magnification filters that normally average multiple samples (anything
      other than NEAREST and NEAREST_MIPMAP_NEAREST).  This restriction exists
      to avoid the need to define semantics for computing a weighted average
      of integer values with non-integer weights, which will produce an
      arithmetic result that is not an integer.  Given that the MIN and MAX
      reduction modes don't do any arithmetic and won't produce non-integer
      values, we allow these reduction modes to be used with arbitrary
      filters.

    (3) How does this extension interact with TEXTURE_COMPARE_MODE set
        to COMPARE_R_TO_TEXTURE for depth textures?

      RESOLVED: This extension does not require support for DEPTH_COMPONENT
      textures with the new filter modes, but if they are supported, the
      per-sample comparison should be performed prior to the min/max
      reduction.

      This implies the MIN mode for TEXTURE_REDUCTION_MODE_ARB in this case
      returns a FALSE value if *any* of the texels compare FALSE; to return
      TRUE, every comparison must be TRUE. Likewise this implies the MAX
      mode for TEXTURE_REDUCTION_MODE_ARB in this case returns a TRUE value
      if *any* of the texels compare TRUE; to return FALSE, every comparison
      must be FALSE.

      Note that unextended OpenGL 4.5 doesn't require that linear filtering
      actually average depth comparison results of 0.0 and 1.0, but behaving
      this way appears to be common practice and may be required for other
      3D graphics APIs.

    (4) Do interpolation weights figure into the min/max reductions?

      RESOLVED: Yes. Texels that would have a weight of zero for the normal
      WEIGHTED_AVERAGE_ARB reduction modes should not be considered when
      performing MIN or MAX reductions.

      Note that implementations may end up quantize the interpolation
      weights to fixed-point values with implementation-dependent precision.
      This may cause samples to be ignored in WEIGHTED_AVERAGE_ARB or
      MIN/MAX reductions. For example, if you are using a minification
      filter of LINEAR_MIPMAP_LINEAR and the computed LOD is 2.00001, the
      implementation may round the LOD as being exactly 2.0 and ignore the
      texels in level 3 for the purposes of trilinear filtering.

    (5) Should TEXTURE_REDUCTION_MODE_ARB work with stencil textures?

      RESOLVED:  Yes.

    (6) What are the constraints on supported texture targets and formats?

      RESOLVED: After conducting a voting exercise, we concluded that the
      set of supported formats would be limited to single-channel (R/L/I),
      fixed- or floating-point, and that the GetInternalformat query should
      be used to expose support for additional formats.

      RESOLVED: Formats which don't support MIN/MAX reduction are treated as
      incomplete textures when those reduction modes are set.

      RESOLVED: TexParameter* does not generate an error when setting
      MIN/MAX reduction for unsupported texture types. This can't catch all
      misuse even when not using separate sampler objects, so only having
      the mismatch affect completeness seems cleaner.

      DISCUSSION: Different vendors all had different constraints. There
      were problems with multi-channel textures, multisampled textures,
      integer textures, and depth component and stencil index textures.

Revision History

    Version 1, 2015/02/20 (Jon Leech)
      - Branch from EXT_texture_filter_minmax and add issue 6 from ARB
        discussion.

    Version 2, 2015/02/25 (Jon Leech)
      - Rebase against GL 4.5 and change suffixes to ARB. Change minimum
        required GL version from 1.0 to 3.3 (which is where
        SamplerParameter* commands were introduced). Add constraints on
        texture types guaranteed to support MIN/MAX reduction in sections
        8.17, and query for additional supported types in section 22.3.1.
        Remove no longer needed Errors section. Update issue 6 with proposed
        resolution of the format compatibility issue.

    Version 3, 2015/02/26 (Jon Leech)
      - Remove DEPTH_COMPONENT from formats guaranteed to be supported, and
        add LUMINANCE and INTENSITY in the compatibility profile. Clean up
        state table entry.

    Version 4, 2015/03/20 (Jon Leech)
      - Remove nonexistent GREEN and BLUE internal formats. Remove
        restriction to two-dimensional images (Intel determined they do not
        require it). Update issues 3 and 6 to track restrictions of various
        vendor hardware.

    Version 5, 2015/04/01 (Jon Leech)
      - Reduce required format support to single-channel (R/L/I), fixed- and
        floating-point textures only. Remove guaranteed ALPHA format support
        in the compatibility profile. Reflow text of Issues.

    Version 6, 2015/04/20 (Jon Leech)
      - Modify edits to the completeness conditions in section 8.17 based on
        changes to the GL spec in this area (Bug 12791).