blob: fb6c04cf6723c977ae238cf08cf61fc0b90506a7 [file] [log] [blame]
Name
IMG_texture_filter_cubic
Name Strings
GL_IMG_texture_filter_cubic
Notice
Copyright Imagination Technologies Limited, 2014.
Contributors
Simon Fenney, Imagination Technologies
Ben Bowman, Imagination Technologies
Contact
Tobias Hector, Imagination Technologies (tobias.hector 'at' imgtec.com)
Status
Complete
Version
0.5, 08 July 2015
Number
Unassigned
Dependencies
This extension is written against version 3.0.3 of the OpenGL ES 3.0 API
Specification.
OpenGL ES 1.0 is required.
Overview
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.
New Procedures and Functions
None.
New Tokens
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
Changes to Chapter 3 of the OpenGL ES 3 API Specification
-- Section 3.8.7 "Texture Parameters"
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
-- Section 3.8.10 "Texture Minification"
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
-- Section 3.8.11 "Texture Magnification"
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.
-- Section 3.8.13 "Texture Completeness"
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.
Changes to Chapter 4 of the OpenGL ES 3 API Specification
-- Section 4.4.3 "Feedback Loops Between Textures and the Framebuffer"
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).
Changes to OES_EGL_image_external:
-- Section 3.7.4 "Texture Parameters"
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."
-- Section 3.7.14 "External Textures"
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."
Errors
None.
New State
None.
New Implementation Dependent State
None.
Issues
None
Revision History
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.