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.