IMG_texture_filter_cubic

GL_IMG_texture_filter_cubic

Copyright Imagination Technologies Limited, 2014.

Simon Fenney, Imagination Technologies
Ben Bowman, Imagination Technologies

Tobias Hector, Imagination Technologies (tobias.hector 'at' imgtec.com)

Complete

0.5, 08 July 2015

Unassigned

This extension is written against version 3.0.3 of the OpenGL ES 3.0 API
Specification.

OpenGL ES 1.0 is required.

OpenGL ES provides two sampling methods available; nearest neighbor or
linear filtering, with optional MIP Map sampling modes added to move between
differently sized textures when downsampling.

This extension adds an additional, high quality cubic filtering mode, using
a Catmull-Rom bicubic filter. Performing this kind of filtering can be done
in a shader by using 16 samples, but this can be inefficient. The cubic
filter mode exposes an optimized high quality texture sampling using fixed
functionality.

This extension affects the way textures are sampled, by modifying the way
texels within the same MIP-Map level are sampled and resolved. It does not
affect MIP-Map filtering, which is still limited to linear or nearest.

None.

Accepted by the <params> parameters of TexParameterf, TexParameterfv,
TexParameteri, TexParameteriv, SamplerParameterf, SamplerParameterfv,
SamperParameteri and SamplerParameteriv, and returned in <params> by
GetTexParameterfv, GetTexParameteriv, GetSamplerParameterfv and
GetSamplerParameteriv when <pname> is TEXTURE_MIN_FILTER or
TEXTURE_MAG_FILTER in either case:

    CUBIC_IMG                            0x9139

Accepted as above only when <pname> is TEXTURE_MIN_FILTER:

    CUBIC_MIPMAP_NEAREST_IMG             0x913A
    CUBIC_MIPMAP_LINEAR_IMG              0x913B

Add the following to the TEXTURE_MIN_FILTER entry in Table 3.20:

    Name                        Type    Legal Values
    --------------------------  ------  --------------------------
    TEXTURE_MIN_FILTER          enum    CUBIC_MIPMAP_NEAREST_IMG
                                        CUBIC_MIPMAP_LINEAR_IMG
                                        CUBIC_IMG

Add the following to the TEXTURE_MAG_FILTER entry in Table 3.20:

    Name                        Type    Legal Values
    --------------------------  ------  --------------------------
    TEXTURE_MAG_FILTER          enum    CUBIC_IMG

Modify the third sentence in the first paragraph to read:

    In the GL this mapping is approximated by one of three simple filtering
    schemes.

Add a section immediately before "Rendering Feedback Loops" that describes
cubic filtering.

    When the value of TEXTURE_MIN_FILTER is CUBIC_IMG, a 4 x 4 square of
    texels in the image array of level levelbase is selected. Let

        i0 = wrap([u'-1.5])
        j0 = wrap([v'-1.5])
        i1 = wrap([u'-0.5])
        j1 = wrap([v'-0.5])
        i2 = wrap([u'+0.5])
        j2 = wrap([v'+0.5])
        i3 = wrap([u'+1.5])
        j3 = wrap([v'+1.5])
        a  = frac(u' - 0.5)
        b  = frac(v' - 0.5)

    Catmull-Rom splines are used to evaluate the final texture color, as
    these exhibit the following desirable properties:

        - If the sample location lies exactly on a texel centre, it will
          return that texel value.
            - This means that a 1:1 sampling (with the appropriate offset)
              will return the original data.
            - This matches the behaviour of bilinear sampling.
        - Although the bilinear function is continuous at the junctions
          between neighboring sets of filtered regions, the first derivative
          is discontinuous.
            - The Catmull-Rom has the advantage of having a continuous first
              derivative.

    Catmull-Rom splines are evaluated using four points along an axis, and
    only operate in one dimension. To apply these to the 4x4 square of
    samples needed for a bicubic filter, each row is evaluated in turn,
    according to the equation

    for each row
        rn = clamp(ri1jn +
            ((-0.5 * ri0jn) + (0.5 * ri2jn)) * a +
            (ri0jn - (2.5 * ri1jn) + (2 * ri2jn) - (0.5 * ri3jn)) * a^2 +
            ((-0.5 * ri0jn) + (1.5 * ri1jn) - (1.5 * ri2jn) - 0.5 * ri3jn) * a^3)

    where n is the index of each row, r is the result for a given row, and
    clamp(x) returns the gives a value of x that has been restricted to
    between the minimum and maximum allowable value by the color format.

    The final color is then calculated using the same equation, replacing
    rij with the evaluated value for each row (rj) along the y-axis,
    according to v'.

    Only two-dimensional textures are supported by cubic filtering; three-
    dimensional textures will result in an incomplete texture, as defined in
    section 3.8.13.

    For    two-dimensional array textures, all texels are obtained from layer
    l, where

        l = clamp([r + 0.5], 0, dt-1):

Modify the last bullet point in the "Rendering Feedback Loops" subsection to
read:

    - The value of TEXTURE_MIN_FILTER is NEAREST, LINEAR or CUBIC_IMG, and
      the value of FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL for attachment point
      A is equal to the value of levelbase

      -or-

      The value of TEXTURE_MIN_FILTER is NEAREST_MIPMAP_NEAREST,
      NEAREST_MIPMAP_LINEAR, LINEAR_MIPMAP_NEAREST, LINEAR_MIPMAP_LINEAR,
      CUBIC_MIPMAP_NEAREST_IMG or CUBIC_MIPMAP_LINEAR_IMG, and the value of
      FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL for attachment point A is within
      the inclusive range from levelbase to q (see below).

Add references to the new tokens in the first paragraph of the "Mipmapping"
subsection:

    TEXTURE_MIN_FILTER values NEAREST_MIPMAP_NEAREST, NEAREST_MIPMAP_LINEAR,
    LINEAR_MIPMAP_NEAREST, LINEAR_MIPMAP_LINEAR, CUBIC_MIPMAP_NEAREST_IMG
    and CUBIC_MIPMAP_LINEAR_IMG each require the use of a mipmap. A mipmap
    is an ordered set of arrays representing the same image; each array has
    a resolution lower than the previous one.

Add references to the new tokens in the "Mipmapping" subsection:

    For mipmap filters NEAREST_MIPMAP_NEAREST, LINEAR_MIPMAP_NEAREST, and
    CUBIC_MIPMAP_NEAREST_IMG, the dth mipmap array is selected, where

        (Figure 3.21)

    The rules for NEAREST, LINEAR or CUBIC_IMG filtering are then applied to
    the selected array. Specifically, the coordinate (u, v, w) is computed
    as in equation 3.17, with wt, ht, and dt equal to the width, height, and
    depth of the image array whose level is d.

    For mipmap filters NEAREST_MIPMAP_LINEAR, LINEAR_MIPMAP_LINEAR and
    CUBIC_MIPMAP_LINEAR_IMG, the level d1 and d2 mipmap arrays are selected,
    where

        (Figure 3.22)
        (Figure 3.23)

    The rules for NEAREST, LINEAR or CUBIC_IMG filtering are then applied to
    each of the selected arrays, yielding two corresponding texture values
    r1 and r2. Specifically, for level d1, the coordinate (u, v, w) is
    computed as in equation 3.17, with wt, ht, and dt equal to the width,
    height, and depth of the image array whose level is d1. For level d2 the
    coordinate (u', v', w') is computed as in equation 3.17, with wt, ht,
    and dt equal to the width, height, and depth of the image array whose
    level is d2.

    The final texture value is then found as
        r = [1  frac(h)]r1 + frac(h)r2

Modify the first paragraph to read:

    When ,\ indicates magnification, the value assigned to TEXTURE_MAG_FILTER
    determines how the texture value is obtained. There are three possible
    values for TEXTURE_MAG_FILTER: NEAREST, LINEAR and CUBIC_IMG. NEAREST
    behaves exactly as NEAREST for TEXTURE_MIN_FILTER, LINEAR behaves
    exactly as LINEAR for TEXTURE_MIN_FILTER and CUBIC_IMG behaves exactly
    as CUBIC_IMG for TEXTURE_MIN_FILTER as described in section 3.8.10,
    including the texture coordinate wrap modes specified in table 3.19. The
    level-of-detail levelbase texel array is always used for magnification.

Modify the last paragraph of the introduction section to read:

    Using the preceding definitions, a texture is complete unless any of the
    following conditions hold true:

    - Any dimension of the levelbase array is not positive.

    - The texture is a cube map texture, and is not cube complete.

    - The minification filter requires a mipmap (is not NEAREST, LINEAR or
      CUBIC_IMG), and the texture is not mipmap complete.

    - The internalformat specified for the texture arrays is a sized
      internal color format that is not texture-filterable (see table 3.12),
      and either the magnification filter is not NEAREST or the minification
      filter is neither NEAREST nor NEAREST_MIPMAP_NEAREST.

    - The internalformat specified for the texture arrays is a sized
      internal depth or depth and stencil format (see table 3.13), the value
      of TEXTURE_COMPARE_MODE is NONE, and either the magnification filter
      is not NEAREST or the minification filter is neither NEAREST nor
      NEAREST_MIPMAP_NEAREST.

    - The texture target is TEXTURE_3D or TEXTURE_CUBE_MAP, and either the
      magnification filter is CUBIC_IMG or the minification filter is
      CUBIC_IMG, CUBIC_MIPMAP_NEAREST_IMG or CUBIC_MIPMAP_LINEAR_IMG.

    - The bit depth of any of the texture's channels is greater than 8 bits,
      and either the magnification filter is CUBIC_IMG or the minification
      filter is CUBIC_IMG, CUBIC_MIPMAP_NEAREST_IMG or CUBIC_MIPMAP_LINEAR_-
      IMG.

    - The texture format is in sRGB colorspace.

Modify the last two bullet points in "Rendering Feedback Loops" after "while
either of the following is true:" to read:

    - the value of TEXTURE_MIN_FILTER for texture object T is NEAREST,
      LINEAR or CUBIC_IMG, and the value of FRAMEBUFFER_ATTACHMENT_TEXTURE_-
      LEVEL for attachment point A is equal to the value of TEXTURE_BASE_-
      LEVEL for the texture object T

    - the value of TEXTURE_MIN_FILTER for texture object T is one of
      NEAREST_MIPMAP_NEAREST, NEAREST_MIPMAP_LINEAR, LINEAR_MIPMAP_NEAREST,
      LINEAR_MIPMAP_LINEAR, CUBIC_MIPMAP_NEAREST_IMG, or CUBIC_MIPMAP_-
      LINEAR_IMG, and the value of FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL for
      attachment point A is within the range specified by the current values
      of TEXTURE_BASE_LEVEL to q, inclusive, for the texture object T. (q is
      defined in the Mipmapping discussion of section 3.8.10).

Change the whole paragraph specified to:

"When <target> is TEXTURE_EXTERNAL_OES only NEAREST, LINEAR and CUBIC_IMG
are  accepted as TEXTURE_MIN_FILTER and only CLAMP_TO_EDGE is accepted as
TEXTURE_WRAP_S and TEXTURE_WRAP_T.  Attempting to set other values for
TEXTURE_MIN_FILTER, TEXTURE_WRAP_S, or TEXTURE_WRAP_T will result in
an INVALID_ENUM error."

Change the third sentence specified to:

"It is an INVALID_ENUM error to set the min filter value to anything other
than LINEAR, NEAREST or CUBIC_IMG."

None.

None.

None.

None

0.5   08/07/2015  tjh:  Corrected restrictions on formats and texture types
                        by adding language to texture completeness.
0.4,  25/09/2014  tjh:  Updated to latest OpenGL ES 3.0 specification.
0.3,  17/06/2013  tjh:  First complete draft.
0.2,  22/04/2013  tjh:  Second revision.
0.1,  01/07/2011  bcb:  Initial revision.