blob: 861db54d1046b810be12c5dd0eba379d3c0e1ebd [file] [log] [blame]
Name
NV_texture_array
Name Strings
GL_NV_texture_array
Contributors
Contributors to the OpenGL EXT_texture_array extension
Mathias Heyer, NVIDIA
Greg Roth, NVIDIA
Ian Stewart, NVIDIA
Nuno Subtil, NVIDIA
Contact
Ian Stewart, NVIDIA Corporation (istewart 'at' nvidia.com)
Status
Complete.
Version
Last Modifed Date: Sep 25, 2012
NVIDIA Revision: 4
Number
OpenGL ES Extension #133
Dependencies
This extension is written against the OpenGL ES 2.0.25
Specification.
This extension depends on EXT_unpack_subimage.
This extension interacts with OES_texture_3D.
This extension interacts with OES_depth_texture.
This extension interacts with OES_packed_depth_stencil.
This extension interacts with OES_texture_npot.
This extension interacts with NV_pixel_buffer_object.
This extension interacts with NV_texture_npot_2D_mipmap.
This extension interacts with NV_framebuffer_blit.
Overview
This extension introduces the notion of two-dimensional array
textures. An array texture is a collection of two-dimensional
images of identical size and format, arranged in layers. Array
textures are specified using TexImage3DNV, where the depth is
used to indicate the number of layers in the image.
An array texture is accessed as a single unit in a programmable
shader, using a single coordinate vector. A single layer is
selected, using the "p" texture coordinate, and that layer is then
accessed as though it were a two-dimensional texture. The layer
coordinate is provided as an unnormalized floating-point value in
the range [0,<n>-1], where <n> is the number of layers in the
array texture. Texture lookups do not filter between layers,
though such filtering can be achieved using programmable shaders.
When mipmapping is used, each level of an array texture has the
same number of layers as the base level; the number of layers is
not reduced as the image size decreases.
Single layers of array textures can be rendered to by binding them
to a framebuffer object using the FramebufferTextureLayerNV
function.
New Procedures and Functions
void TexImage3DNV(enum target, int level, enum internalFormat,
sizei width, sizei height, sizei depth, int border,
enum format, enum type, const void *pixels)
void TexSubImage3DNV(enum target, int level,
int xoffset, int yoffset, int zoffset,
sizei width, sizei height, sizei depth,
enum format, enum type, const void *pixels)
void CopyTexSubImage3DNV(enum target, int level,
int xoffset, int yoffset, int zoffset,
int x, int y, sizei width, sizei height)
void CompressedTexImage3DNV(enum target, int level, enum internalformat,
sizei width, sizei height, sizei depth,
int border, sizei imageSize, const void *data)
void CompressedTexSubImage3DNV(enum target, int level,
int xoffset, int yoffset, int zoffset,
sizei width, sizei height, sizei depth,
enum format, sizei imageSize,
const void *data)
void FramebufferTextureLayerNV(enum target, enum attachment,
uint texture, int level, int layer);
New Tokens
Accepted by the <target> parameter of TexImage3DNV,
TexSubImage3DNV, CopyTexSubImage3DNV, CompressedTexImage3DNV,
CompressedTexSubImage3DNV, TexParameteri, TexParameteriv,
TexParameterf, TexParameterfv, GenerateMipmap, and BindTexture:
TEXTURE_2D_ARRAY_NV 0x8C1A
Accepted by the <pname> parameter of GetBooleanv, GetIntegerv and
GetFloatv:
TEXTURE_BINDING_2D_ARRAY_NV 0x8C1D
MAX_ARRAY_TEXTURE_LAYERS_NV 0x88FF
Accepted by the <pname> parameter of
GetFramebufferAttachmentParameteriv:
FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_NV 0x8CD4
Returned by the <type> parameter of GetActiveUniform:
SAMPLER_2D_ARRAY_NV 0x8DC1
Accepted by the <pname> parameter of PixelStorei, GetBooleanv,
GetIntegerv and GetFloatv:
UNPACK_SKIP_IMAGES_NV 0x806D
UNPACK_IMAGE_HEIGHT_NV 0x806E
New GLSL defines
#define GL_NV_texture_array 1
New GLSL sampler types
sampler2DArrayNV
GLSL Grammar Changes
The token SAMPLER2DARRAYNV is added to the list of tokens returned
from lexical analysis and the type_specifier_no_prec production.
New GLSL functions
texture2DArrayNV()
texture2DArrayLodNV()
Additions to Chapter 2 of the OpenGL ES 2.0.25 Specification
Modify section 2.10.4, "Shader Variables"
(add the following new return type to the description of
GetActiveUniform)
SAMPLER_2D_ARRAY_NV
Additions to Chapter 3 of the OpenGL ES 2.0.25 Specification
Modify Section 3.6.1, "Pixel Storage Modes"
Replace the first sentence:
Pixel storage modes affect the operation of TexImage*D,
TexSubImage*D, and ReadPixels when one of these commands is issued.
Add to table 3.1
Parameter Name Type Initial Value Valid Range
---------------------- ------- ------------- ------------
UNPACK_SKIP_IMAGES_NV integer 0 [0,Infinity)
UNPACK_IMAGE_HEIGHT_NV integer 0 [0,Infinity)
Modify Section 3.7.1, "Texture Image Specification"
Replace the entire section with:
The command
void TexImage3DNV(enum target, int level, int internalformat,
sizei width, sizei height, sizei depth, int border,
enum format, enum type, void *data);
is used to specify a three-dimensional image for a two-dimensional
array texture. <target> must be TEXTURE_2D_ARRAY_NV. <format>,
<type>, and <data> specify the format of the image data, the type of
those data, and a reference to the image data in the currently bound
pixel unpack buffer or client memory, as described in section 3.6.2.
The groups in memory are treated as being arranged in a sequence of
adjacent rectangles. Each rectangle is a two-dimensional image,
whose size and organization are specified by the <width> and
<height> parameters to TexImage3DNV. The values of UNPACK_ROW_-
LENGTH_EXT and UNPACK_ALIGNMENT control the row-to-row spacing in
these images as described in section 3.6.2. If the value of the
integer parameter UNPACK_IMAGE_HEIGHT_NV is zero, then the number of
rows in each two-dimensional image is height; otherwise the number
of rows is UNPACK_IMAGE_HEIGHT_NV. Each two-dimensional image
comprises an integral number of rows, and is exactly adjacent to its
neighbor images.
The mechanism for selecting a sub-volume of a three-dimensional
image relies on the integer parameter UNPACK_SKIP_IMAGES_NV. If
UNPACK_SKIP_IMAGES_NV is positive, the pointer is advanced by
UNPACK_SKIP_IMAGES_NV times the number of elements in one two-
dimensional image before obtaining the first group from memory.
Then <depth> two-dimensional images are processed, each having a
subimage extracted as described in section 3.6.2.
The selected groups are transferred to the GL as described in
section 3.6.2 and then clamped to the representable range of the
internal format. For color component groups, if the <internalformat>
of the texture is signed or unsigned normalized fixed-point,
components are clamped to [-1, 1] or [0, 1], respectively. For depth
component groups, the depth value is clamped to [0, 1]. Otherwise,
values are not modified.
Components are then selected from the resulting R, G, B, A, depth,
or stencil values to obtain a texture with the base internal format
specified by <internalformat>. Table 3.8 summarizes the mapping of
R, G, B, A, depth, or stencil values to texture components, as a
function of the base internal format of the texture image.
<internalformat> may be one of the five internal format symbolic
constants listed in table 3.8. Specifying a value for
<internalformat> that is not one of the above values generates the
error INVALID_VALUE. If internalformat does not match format, the
error INVALID_OPERATION is generated.
The GL stores the resulting texture with internal component
resolutions of its own choosing. The allocation of internal
component resolution may vary based on any TexImage3DNV or
TexImage2D (see below) parameter (except target), but the allocation
must not be a function of any other state and cannot be changed once
established. Allocations must be invariant; the same allocation must
be chosen each time a texture image is specified with the same
parameter values.
The image itself (referred to by data) is a sequence of groups of
values. The first group is the lower left back corner of the texture
image. Subsequent groups fill out rows of width width from left to
right; height rows are stacked from bottom to top forming a single
two-dimensional image slice; and depth slices are stacked from back
to front. When the final R, G, B, and A components have been
computed for a group, they are assigned to components of a texel as
described by table 3.8. Counting from zero, each resulting Nth texel
is assigned internal integer coordinates (i, j, k), where
i = (N mod width)
j = (floor(N/width) mod height)
k = (floor(N/(width * height) mod depth)
Thus the last two-dimensional image slice of the three-dimensional
image is indexed with the highest value of k.
If the internal data type of the image array is signed or unsigned
normalized fixed-point, each color component is converted as
described in section 2.1.2. If the internal type is floating-point,
components are clamped to the representable range of the
corresponding internal component, but are not converted.
The <level> argument to TexImage3DNV is an integer level-of-detail
number. Levels of detail are discussed below, under Mipmapping. The
main texture image has a level of detail number of 0. If a level-of-
detail less than zero is specified, the error INVALID_VALUE is
generated. If <level> is greater than zero, and either width or
height is not a power of two, the error INVALID_VALUE is generated.
If <border> is not zero, then the error INVALID_VALUE is generated.
If <width>, <height>, or <depth> are less than zero, then the error
INVALID_VALUE is generated.
The maximum allowable width and height of a texel array for a two-
dimensional texture or two-dimensional array texture is an
implementation-dependent function of the level-of-detail and
internal format of the resulting image array. It must be at least
2^(k-lod) for image arrays of level-of-detail 0 through k, where k
is the log base 2 of MAX_TEXTURE_SIZE and lod is the level-of-detail
of the image array. The maximum allowable width and height of a cube
map texture must be the same, and must be at least 2^(k-lod) for
image arrays level 0 through k, where k is the log base 2 of
MAX_CUBE_MAP_TEXTURE_SIZE. The maximum number of layers for two-
dimensional array textures (depth) must be at least MAX_ARRAY_-
TEXTURE_LAYERS_NV for for image arrays level 0 through k. The
maximum width, height, and depth may be zero for image arrays of any
level-of-detail greater than k. The error INVALID_VALUE is generated
if the specified image is too large to be stored under any
conditions.
An implementation may allow an image of level zero to be created
only if that single image can be supported. Additional constraints
on the creation of images of level one or greater are described in
more detail in section 3.7.10.
If a pixel unpack buffer object is bound and storing texture data
would access memory beyond the end of the pixel unpack buffer, an
INVALID_OPERATION error results.
The command
void TexImage2D(enum target, int level, int internalformat,
sizei width, sizei height, int border, enum format,
enum type, const void *data);
is used to specify a two-dimensional texture image. target must be
one of TEXTURE_2D for a two-dimensional texture, or one of TEXTURE_-
CUBE_MAP_POSITIVE_X, TEXTURE_CUBE_MAP_NEGATIVE_X, TEXTURE_CUBE_MAP_-
POSITIVE_Y, TEXTURE_CUBE_MAP_NEGATIVE_Y, TEXTURE_CUBE_MAP_POSITIVE_Z,
or TEXTURE_CUBE_MAP_NEGATIVE_Z for a cube map texture. The other
parameters match the corresponding parameters of TexImage3DNV.
For the purposes of decoding the texture image, TexImage2D is
equivalent to calling TexImage3DNV with corresponding arguments and
depth of 1, except that UNPACK_SKIP_IMAGES_NV is ignored.
A two-dimensional texture consists of a single two-dimensional
texture image. A cube map texture is a set of six two-dimensional
texture images. The six cube map texture targets form a single cube
map texture though each target names a distinct face of the cube
map. The TEXTURE_CUBE_MAP_* targets listed above update their
appropriate cube map face 2D texture image. Note that the six cube
map two-dimensional image tokens such as TEXTURE_CUBE_MAP_POSITIVE_X
are used when specifying, updating, or querying one of a cube map's
six two-dimensional images, but when binding to a cube map texture
object (that is when the cube map is accessed as a whole as opposed
to a particular two-dimensional image), the TEXTURE_CUBE_MAP target
is specified.
When the target parameter to TexImage2D is one of the six cube map
two-dimensional image targets, the error INVALID_VALUE is generated
if the width and height parameters are not equal.
An INVALID_VALUE error is generated if border is non-zero.
The image indicated to the GL by the image pointer is decoded and
copied into the GL's internal memory.
We shall refer to the decoded image as the texel array. A three-
dimensional texel array has width, height, and depth <wt>, <ht>, and
<dt>. A two-dimensional texel array has depth <dt> = 1, with height
<ht> and width <wt> as above.
An element (i, j, k) of the texel array is called a texel (for a
non-array two-dimensional texture, k is irrelevant). The texture
value used in texturing a fragment is determined by sampling the
texture in a shader, but may not correspond to any actual texel. See
figure 3.6.
If the <data> argument of TexImage2D or TexImage3DNV is a NULL
pointer, and the pixel unpack buffer object is zero, a two- or
three-dimensional texel array is created with the specified target,
level, internalformat, border, width, height, and depth, but with
unspecified image contents. In this case no pixel values are
accessed in client memory, and no pixel processing is performed.
Errors are generated, however, exactly as though the data pointer
were valid. Otherwise if the pixel unpack buffer object is non-zero,
the data argument is treatedly normally to refer to the beginning of
the pixel unpack buffer object's data.
Modify Section 3.7.2, "Alternate Texture Image Specification
Commands"
Replace paragraphs 4 through 6 starting with the description of
additional commands:
Four additional commands,
void TexSubImage3DNV(enum target, int level, int xoffset,
int yoffset, int zoffset, sizei width,
sizei height, sizei depth, enum format,
enum type, const void *data);
void TexSubImage2D(enum target, int level, int xoffset,
int yoffset, sizei width, sizei height,
enum format, enum type, const void *data);
void CopyTexSubImage3DNV(enum target, int level, int xoffset,
int yoffset, int zoffset, int x, int y,
sizei width, sizei height);
void CopyTexSubImage2D(enum target, int level, int xoffset,
int yoffset, int x, int y, sizei width,
sizei height);
respecify only a rectangular subregion of an existing texel array.
No change is made to the <internalformat>, <width>, <height>,
<depth>, or <border> parameters of the specified texel array, nor is
any change made to texel values outside the specified subregion.
The <target> arguments of TexSubImage2D and CopyTexSubImage2D must
be one of TEXTURE_2D, TEXTURE_CUBE_MAP_POSITIVE_X, TEXTURE_CUBE_-
MAP_NEGATIVE_X, TEXTURE_CUBE_MAP_POSITIVE_Y, TEXTURE_CUBE_MAP_-
NEGATIVE_Y, TEXTURE_CUBE_MAP_POSITIVE_Z, or TEXTURE_CUBE_MAP_-
NEGATIVE_Z, and the <target> arguments of TexSubImage3DNV and
CopyTexSubImage3DNV must be TEXTURE_2D_ARRAY_NV. The
<level> parameter of each command specifies the level of the texel
array that is modified. If level is less than zero or greater than
the base 2 logarithm of the maximum texture width, height, or depth,
the error INVALID_VALUE is generated.
TexSubImage3DNV arguments <width>, <height>, <depth>, <format>,
<type>, and <data> match the corresponding arguments to
TexImage3DNV, meaning that they are specified using the same values,
and have the same meanings. Likewise, TexSubImage2D arguments
<width>, <height>, <format>, <type>, and <data> match the
corresponding arguments to TexImage2D.
CopyTexSubImage3DNV and CopyTexSubImage2D arguments <x>, <y>,
<width>, and <height> match the corresponding arguments to
CopyTexImage2D. Each of the TexSubImage commands interprets and
processes pixel groups in exactly the manner of its TexImage
counterpart, except that the assignment of R, G, B, A, depth, and
stencil pixel group values to the texture components is controlled
by the <internalformat> of the texel array, not by an argument to
the command. The same constraints and errors apply to the
TexSubImage commands' argument <format> and the <internalformat> of
the texel array being respecified as apply to the <format> and
<internalformat> arguments of its TexImage counterparts.
Arguments <xoffset>, <yoffset>, and <zoffset> of TexSubImage3DNV and
CopyTexSubImage3DNV specify the lower left texel coordinates of a
<width>-wide by <height>-high by <depth>-deep rectangular subregion
of the texel array. The <depth> argument associated with
CopyTexSubImage3DNV is always 1, because framebuffer memory is two-
dimensional - only a portion of a single <s>, <t> slice of a three-
dimensional texture is replaced by CopyTexSubImage3DNV.
Taking <wt>, <ht>, and <dt> to be the specified width, height, and
depth of the texel array, and taking <x>, <y>, <z>, <w>, <h>, and
<d> to be the <xoffset>, <yoffset>, <zoffset>, <width>, <height>,
and <depth> argument values, any of the following relationships
generates the error INVALID_VALUE:
x < 0
x + w > wt
y < 0
y + h > ht
z < 0
z + d > dt
Counting from zero, the <n>th pixel group is assigned to the texel
with internal integer coordinates [i, j, k], where
i = x + (n mod w)
j = y + (floor(n/w) mod h)
k = z + (floor (n/(width*height)) mod d)
Replace the last two paragraphs of 3.7.2:
Calling CopyTexSubImage3DNV, CopyTexImage2D, or CopyTexSubImage2D
will result in an INVALID_FRAMEBUFFER_OPERATION error if the object
bound to READ_FRAMEBUFFER_BINDING_NV is not framebuffer complete
(see section 4.4.5).
"Texture Copying Feedback Loops"
Calling CopyTexSubImage3DNV, CopyTexImage2D, or CopyTexSubImage2D
will result in undefined behavior if the destination texture image
level is also bound to the selected read buffer (see section 4.3.1)
of the read framebuffer. This situation is discussed in more detail
in the description of feedback loops in section 4.4.4.
Modify Section 3.7.3, "Compressed Texture Images"
Replace the second paragraph:
The commands
void CompressedTexImage2D(enum target, int level,
enum internalformat, sizei width,
sizei height, int border,
sizei imageSize, const void *data);
void CompressedTexImage3DNV(enum target, int level,
enum internalformat, sizei width,
sizei height, sizei depth,
int border, sizei imageSize,
const void *data);
define two- and three-dimensional texture images, respectively, with
incoming data stored in a compressed image format. The <target>,
<level>, <internalformat>, <width>, <height>, <depth>, and <border>
parameters have the same meaning as in TexImage2D and TexImage3DNV.
<data> refers to compressed image data stored in the compressed
image format corresponding to <internalformat>. If a pixel unpack
buffer is bound (as indicated by a non-zero value of PIXEL_UNPACK_-
BUFFER_BINDING), <data> is an offset into the pixel unpack buffer
and the compressed data is read from the buffer relative to this
offset; otherwise, data is a pointer to client memory and the
compressed data is read from client memory relative to the pointer.
Replace fifth through the seventh paragraph of 3.7.3:
Any restrictions imposed by specific compressed internal formats
will be invariant with respect to image contents, meaning that if
the GL accepts and stores a texture image in compressed form,
CompressedTexImage2D or CompressedTexImage3DNV will accept any
properly encoded compressed texture image of the same width, height,
compressed image size, and compressed internal format for storage at
the same texture level.
Respecifying Subimages of Compressed Textures
The commands
void CompressedTexSubImage2D(enum target, int level, int xoffset,
int yoffset, sizei width, sizei height,
enum format, sizei imageSize, void *data);
void CompressedTexSubImage3DNV(enum target, int level, int xoffset,
int yoffset, int zoffset, sizei width,
sizei height, sizei depth,
enum format, sizei imageSize,
const void *data);
respecify only a rectangular region of an existing texel array, with
incoming data stored in a known compressed image format. The
<target>, <level>, <xoffset>, <yoffset>, <zoffset>, <width>,
<height>, <depth>, and <format> parameters have the same meaning as
in TexSubImage2D and TexSubImage3DNV. data points to compressed
image data stored in the compressed image format corresponding to
<format>.
The image pointed to by <data> and the <imageSize> parameter are
interpreted as though they were provided to CompressedTexImage2D and
CompressedTexImage3DNV. These commands do not provide for image
format conversion, so an INVALID_OPERATION error results if <format>
does not match the internal format of the texture image being
modified. If the <imageSize> parameter is not consistent with the
format, dimensions, and contents of the compressed image (too little
or too much data), an INVALID_VALUE error results.
Replace the last two paragraphs of section 3.7.3:
Any restrictions imposed by specific compressed internal formats
will be invariant with respect to image contents, meaning that if GL
accepts and stores a texture image in compressed form, Compressed-
TexSubImage2D or CompressedTexSubImage3DNV will accept any properly
encoded compressed texture image of the same width, height,
compressed image size, and compressed internal format for storage at
the same texture level.
Calling CompressedTexSubImage2D or CompressedTexSubImage3DNV will
result in an INVALID_OPERATION error if <xoffset>, <yoffset>, or
<zoffset> are not equal to zero, or if <width>, <height>, and
<depth> do not match the dimensions of the texture level. These
restrictions may be relaxed for specific compressed internal formats
whose images are easily modified.
Modify Section 3.7.10, "Texture Completeness and Non-Power-Of-Two
Textures"
(modify second paragraph)
A two-dimensional texture or two-dimensional texture array is
complete if the following conditions all hold true:
Modify Section 3.7.11, "Mipmap Generation"
(modify first paragraph)
Mipmaps can be generated with the command
void GenerateMipmap(enum target);
where <target> is the target, which muct be TEXTURE_2D,
TEXTURE_2D_ARRAY_NV, or TEXTURE_CUBE_MAP.
Modify Section 3.7.13, "Texture Objects"
In addition to the default textures TEXTURE_2D,
TEXTURE_2D_ARRAY_NV, and TEXTURE_CUBE_MAP, named two-dimensional,
two-dimensional array, and cube map texture objects can be created
and operated upon. The name space for texture objects is the
unsigned integers, with zero reserved by the GL.
A texture object is created by binding an unused name to
TEXTURE_2D, TEXTURE_2D_ARRAY_NV, or TEXTURE_CUBE_MAP. The binding
is effected by calling
void BindTexture(enum target, uint texture);
with <target> set to the desired texture target and <texture> set
to the unused name. The resulting texture object is a new state
vector, comprising all the state values listed in section 3.7.12,
set to the same initial values. If the new texture object is bound
to TEXTURE_2D, TEXTURE_2D_ARRAY_NV, or TEXTURE_CUBE_MAP, it is and
remains a two-dimensional, two-dimensional array, or cube map
texture respectively until it is deleted.
BindTexture may also be used to bind an existing texture object to
TEXTURE_2D, TEXTURE_2D_ARRAY_NV, or TEXTURE_CUBE_MAP. The error
INVALID_OPERATION is generated if an attempt is made to bind a
texture object of different dimensionality than the specified
target. If the bind is successful no change is made to the state
of the bound texture object, and any previous binding to target is
broken. While a texture object is bound, GL operations on the
target to which it is bound affect the bound object, and queries
of the target to which it is bound return state from the bound
object.
In the initial state, TEXTURE_2D, TEXTURE_2D_ARRAY_NV, and
TEXTURE_CUBE_MAP have two-dimensional, two-dimensional array, and
cube map texture state vectors respectively associated with them.
In order that access to these initial textures not be lost, they
are treated as texture objects all of whose names are 0. The
initial two-dimensional, two-dimensional array, and cube map
texture are therefore operated upon, queried, and applied as
TEXTURE_2D, TEXTURE_2D_ARRAY_NV, or TEXTURE_CUBE_MAP respectively
while 0 is bound to the corresponding targets.
Texture objects are deleted by calling
void DeleteTextures(sizei n, uint *textures);
<textures> contains <n> names of texture objects to be deleted.
After a texture object is deleted, it has no contents or
dimensionality, and its name is again unused. If a texture that is
currently bound to one of the targets TEXTURE_2D,
TEXTURE_2D_ARRAY_NV, or TEXTURE_CUBE_MAP is deleted, it is as
though BindTexture had been executed with the same target and
texture zero. Unused names in textures are silently ignored, as is
the value zero.
Additions to Chapter 4 of the OpenGL ES 2.0.25 Specification
Modify Section 4.3, "Reading Pixels"
Pixels may be read from the framebuffer to client memory using the
ReadPixels commands, as described below. Pixels may also be copied
from client memory or the framebuffer to texture images in the GL
using the CopyTexImage2D, CopyTexSubImage2D, and
CopyTexSubImage3DNV commands, as described in section 3.7.2.
Modify Section 4.4.3, "Renderbuffer Objects"
(modify paragraph following "Attaching Texture Images to a
Framebuffer")
OpenGL ES supports copying the rendered contents of the
framebuffer into the images of a texture object through the use of
the routines CopyTexImage2D, CopyTexSubImage2D, and
CopyTexSubImage3DNV. Additionally, OpenGL ES supports rendering
directly into the images of a texture object.
(add the following to the end of the section)
The command
void FramebufferTextureLayerNV(enum target, enum attachment,
uint texture, int level, int layer);
operates similarly to FramebufferTexture2D, except that it
attaches a single layer of a two-dimensional array texture level.
<layer> specifies the layer of the two-dimensional image within
<texture>. An INVALID_VALUE error is generated if <layer> is
larger than the value of MAX_ARRAY_TEXTURE_LAYERS_NV minus one.
The error INVALID_VALUE is generated if <texture> is non-zero and
<layer> is negative.
<level> must be greater than or equal to zero and no larger than
log2 of the value of MAX_TEXTURE_SIZE. Otherwise, an INVALID_VALUE
error is generated.
The error INVALID_OPERATION is generated if <texture> is non-zero
and is not the name of a two-dimensional array texture. Unlike
FramebufferTexture2D, no <textarget> parameter is accepted.
If <texture> is non-zero and the command does not result in an
error, the framebuffer attachment state corresponding to
<attachment> is updated as in FramebufferTexture2D, except that
the value of FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_NV is set to
<layer>.
Modify Section 4.4.5, "Framebuffer Completeness"
(modify fourth bullet of actions that may change the framebuffer
completeness)
* Changing the width, height, or internal format of a texture
image that is attached to the framebuffer by calling
TexImage2D, CopyTexImage2D, CompressedTexImage2D,
TexImage3DNV, or CompressedTexImage3DNV.
Additions to Chapter 6 of the OpenGL ES 2.0.25 Specification
Modify Section 6.1.3, "Enumerated Queries"
(modify first paragraph)
The command
void GetTexParameter{if}v(enum target, enum value, T data);
returns information about <target>, which may be
one of TEXTURE_2D, TEXTURE_2D_ARRAY, or TEXTURE_CUBE_MAP,
indicating the currently bound two-dimensional, two-dimensional
array, or cube map texture object.
(add the following item after "If the value of
FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is TEXTURE, then")
* If <pname> is FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_NV and the
texture object named FRAMEBUFFER_ATTACHMENT_OBJECT_NAME is a
two-dimensional array texture, then <params> will contain the
number of texture layer attached to the attachment point.
Otherwise, <params> will contain the value zero.
Additions to Chapter 4 of the OpenGL ES Shading Language Specification
Add the following to the table of basic types in section 4.1:
sampler2DArrayNV a handle for accessing a 2D array texture
Additions to Chapter 8 of the OpenGL ES Shading Language Specification
The built-in texture lookup functions texture2DArrayNV and
texture2DArrayLodNV are optional, and must be enabled by
#extension GL_NV_texture_array : enable
before being used.
Syntax:
vec4 texture2DArrayNV(sampler2DArrayNV sampler, vec3 coord [, float bias])
vec4 texture2DArrayLodNV(sampler2DArrayNV sampler, vec3 coord, float lod)
Description:
Use the first two elements (coord.s, coord.t) of texture
coordinate coord to do a texture lookup in the layer indicated by
the third coordinate (coord.p) of the 2D texture array currently
bound to sampler. The layer to access is computed by layer =
max (0, min(d - 1, floor (coord.p + 0.5)) where 'd' is the depth
of the texture array.
Interactions with OES_texture_3D
FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_NV is an alias for the
FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES token provided in
OES_texture_3D. This extension generalizes the notion of
"<zoffset>" to include layers of an array texture.
If OES_texture_3D is supported, descriptions of TexImage3DNV,
TexSubImage3DNV, CopyTexSubImage3DNV, CompressedTexImage3DNV, and
CompressedTexSubImage3DNV should be merged with the *OES
counterparts added by that extension and should be considered
equivalents to the OES counterparts.
Interactions with OES_depth_texture
If OES_depth_texture is not supported, all references to depth
texture data should be ignored.
Interactions with OES_packed_depth_stencil
If OES_packed_depth_stencil is not supported, all references to
stencil texture data should be ignored.
Interactions with OES_texture_npot and NV_texture_npot_2D_mipmap
If either OES_texture_npot or NV_texture_npot_2D_mipmap are
supported, ignore INVALID_VALUE error generation by TexImage3DNV
when level is greater than zero and width or height are non-power-
of-two.
Interactions with NV_pixel_buffer_object
If NV_pixel_buffer_object is not supported, ignore all references to
non-zero unpack buffer objects and corresponding behavior.
Interactions with NV_framebuffer_blit
If NV_framebuffer_blit is not supported, replace the reference to
READ_FRAMEBUFFER_BINDING_NV in section 3.7.2 to FRAMEBUFFER_BINDING.
Errors
None.
New State
Initial
Get Value Type Get Command Value Description
--------------------------- ---- ----------- ----- -------------------------------------------
TEXTURE_BINDING_2D_ARRAY_NV Z+ GetIntegerv 0 texture object bound to TEXTURE_2D_ARRAY_NV
New Implementation Dependent State
Minimum
Get Value Type Get Command Value Description
--------------------------- ---- ----------- ----- ------------------------------------------
MAX_ARRAY_TEXTURE_LAYERS_NV Z+ GetIntegerv 64 maximum number of layers for texture array
Issues
None
Revision History
Rev. Date Author Changes
---- -------- --------- -------------------------------------
4 25 Sep 2012 groth Minor typographical fixes. fbo_blit interaction
3 13 Sep 2012 groth Added missing suffixes. Removed tex_3d
language. Added more interactions.
Clarified enumerated additions.
2 05 Sep 2012 groth Addition of lots of detail in chapter 3
and interactions with other extensions
1 30 Aug 2012 istewart First revision, based of the
EXT_texture_array specification.