back  Return to list

GL_EXT_vertex_array
homeprevnext Name
  
    EXT_vertex_array  
  
homeprevnext Name Strings
  
    GL_EXT_vertex_array  
  
homeprevnext Version
  
    $Date: 1995/10/03 05:39:58 $ $Revision: 1.16 $  FINAL  
  
homeprevnext Number
  
    30  
  
homeprevnext Dependencies
  
    None  
  
homeprevnext Overview
  
    This extension adds the ability to specify multiple geometric primitives  
    with very few subroutine calls.  Instead of calling an OpenGL procedure  
    to pass each individual vertex, normal, or color, separate arrays  
    of vertexes, normals, and colors are prespecified, and are used to  
    define a sequence of primitives (all of the same type) when a single  
    call is made to DrawArraysEXT.  A stride mechanism is provided so that  
    an application can choose to keep all vertex data staggered in a  
    single array, or sparsely in separate arrays.  Single-array storage  
    may optimize performance on some implementations.  
  
    This extension also supports the rendering of individual array elements,  
    each specified as an index into the enabled arrays.  
  
homeprevnext Issues
  
    *   Should arrays for material parameters be provided?  If so, how?  
  
        A: No.  Let's leave this to a separate extension, and keep this  
           extension lean.  
  
    *   Should a FORTRAN interface be specified in this document?  
  
    *   It may not be possible to implement GetPointervEXT in FORTRAN.  If  
        not, should we eliminate it from this proposal?  
  
        A: Leave it in.  
  
    *   Should a stride be specified by DrawArraysEXT which, if non-zero,  
        would override the strides specified for the individual arrays?  
        This might improve the efficiency of single-array transfers.  
  
        A: No, it's not worth the effort and complexity.  
  
    *   Should entry points for byte vertexes, byte indexes, and byte  
        texture coordinates be added in this extension?  
  
        A: No, do this in a separate extension, which defines byte support  
           for arrays and for the current procedural interface.  
  
    *   Should support for meshes (not strips) of rectangles be provided?  
  
        A: No. If this is necessary, define a separate quad_mesh extension  
           that supports both immediate mode and arrays.  (Add QUAD_MESH_EXT  
           as an token accepted by Begin and DrawArraysEXT.  Add  
           QuadMeshLengthEXT to specify the length of the mesh.)  
  
Reasoning  
  
    *   DrawArraysEXT requires that VERTEX_ARRAY_EXT be enabled so that  
        future extensions can support evaluation as well as direct  
        specification of vertex coordinates.  
  
    *   This extension does not support evaluation.  It could be extended  
        to provide such support by adding arrays of points to be evaluated,  
        and by adding enables to indicate that the arrays are to be  
        evaluated.  I think we may choose to add an array version of  
        EvalMesh, rather than extending the operation of DrawArraysEXT,  
        so I'd rather wait on this one.  
  
    *   <size> is specified before <type> to match the order of the  
        information in immediate mode commands, such as Vertex3f.  
        (first 3, then f)  
  
    *   It seems reasonable to allow attribute values to be undefined after  
        DrawArraysEXT executes.  This avoids implementation overhead in  
        the case where an incomplete primitive is specified, and will allow  
        optimization on multiprocessor systems.  I don't expect this to be  
        a burden to programmers.  
  
    *   It is not an error to call VertexPointerEXT, NormalPointerEXT,  
        ColorPointerEXT, IndexPointerEXT, TexCoordPointerEXT,  
        or EdgeFlagPointerEXT between the execution of Begin and the  
        corresponding execution of End.  Because these commands will  
        typically be implemented on the client side with no protocol,  
        testing for between-Begin-End status requires that the client  
        track this state, or that a round trip be made.  Neither is  
        desirable.  
  
    *   Arrays are enabled and disabled individually, rather than with a  
        single mask parameter, for two reasons.  First, we have had trouble  
        allocating bits in masks, so eliminating a mask eliminates potential  
        trouble down the road.  We may eventually require a larger number of  
        array types than there are bits in a mask.  Second, making the  
        enables into state eliminates a parameter in ArrayElementEXT, and  
        may allow it to execute more efficiently.  Of course this state  
        model may result in programming errors, but OpenGL is full of such  
        hazards anyway!  
  
    *   ArrayElementEXT is provided to support applications that construct  
        primitives by indexing vertex data, rather than by streaming through  
        arrays of data in first-to-last order.  Because each call specifies  
        only a single vertex, it is possible for an application to explicitly  
        specify per-primitive attributes, such as a single normal per  
        individual triangle.  
  
    *   The <count> parameters are added to the *PointerEXT commands to  
        allow implementations to cache array data, and in particular to  
        cache the transformed results of array data that are rendered  
        repeatedly by ArrayElementEXT.  Implementations that do not wish  
        to perform such caching can ignore the <count> parameter.  
  
    *   The <first> parameter of DrawArraysEXT allows a single set of  
        arrays to be used repeatedly, possibly improving performance.  
  
homeprevnext New Procedures and Functions
  
    void ArrayElementEXT(int i);  
  
    void DrawArraysEXT(enum mode,  
                       int first,  
                       sizei count);  
  
    void VertexPointerEXT(int size,  
                          enum type,  
                          sizei stride,  
                          sizei count,  
                          const void* pointer);  
  
    void NormalPointerEXT(enum type,  
                          sizei stride,  
                          sizei count,  
                          const void* pointer);  
  
    void ColorPointerEXT(int size,  
                         enum type,  
                         sizei stride,  
                         sizei count,  
                         const void* pointer);  
  
    void IndexPointerEXT(enum type,  
                         sizei stride,  
                         sizei count,  
                         const void* pointer);  
  
    void TexCoordPointerEXT(int size,  
                            enum type,  
                            sizei stride,  
                            sizei count,  
                            const void* pointer);  
  
    void EdgeFlagPointerEXT(sizei stride,  
                            sizei count,  
                            const Boolean* pointer);  
  
    void GetPointervEXT(enum pname,  
                       void** params);  
  
homeprevnext New Tokens
  
    Accepted by the <cap> parameter of Enable, Disable, and IsEnabled, and  
    by the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, and  
    GetDoublev:  
  
        VERTEX_ARRAY_EXT               0x8074  
        NORMAL_ARRAY_EXT               0x8075  
        COLOR_ARRAY_EXT                0x8076  
        INDEX_ARRAY_EXT                0x8077  
        TEXTURE_COORD_ARRAY_EXT        0x8078  
        EDGE_FLAG_ARRAY_EXT            0x8079  
  
    Accepted by the <type> parameter of VertexPointerEXT, NormalPointerEXT,  
    ColorPointerEXT, IndexPointerEXT, and TexCoordPointerEXT:  
  
        DOUBLE_EXT                     0x140A  
  
    Accepted by the <pname> parameter of GetBooleanv, GetIntegerv,  
    GetFloatv, and GetDoublev:  
  
        VERTEX_ARRAY_SIZE_EXT          0x807A  
        VERTEX_ARRAY_TYPE_EXT          0x807B  
        VERTEX_ARRAY_STRIDE_EXT        0x807C  
        VERTEX_ARRAY_COUNT_EXT         0x807D  
        NORMAL_ARRAY_TYPE_EXT          0x807E  
        NORMAL_ARRAY_STRIDE_EXT        0x807F  
        NORMAL_ARRAY_COUNT_EXT         0x8080  
        COLOR_ARRAY_SIZE_EXT           0x8081  
        COLOR_ARRAY_TYPE_EXT           0x8082  
        COLOR_ARRAY_STRIDE_EXT         0x8083  
        COLOR_ARRAY_COUNT_EXT          0x8084  
        INDEX_ARRAY_TYPE_EXT           0x8085  
        INDEX_ARRAY_STRIDE_EXT         0x8086  
        INDEX_ARRAY_COUNT_EXT          0x8087  
        TEXTURE_COORD_ARRAY_SIZE_EXT   0x8088  
        TEXTURE_COORD_ARRAY_TYPE_EXT   0x8089  
        TEXTURE_COORD_ARRAY_STRIDE_EXT 0x808A  
        TEXTURE_COORD_ARRAY_COUNT_EXT  0x808B  
        EDGE_FLAG_ARRAY_STRIDE_EXT     0x808C  
        EDGE_FLAG_ARRAY_COUNT_EXT      0x808D  
  
    Accepted by the <pname> parameter of GetPointervEXT:  
  
        VERTEX_ARRAY_POINTER_EXT       0x808E  
        NORMAL_ARRAY_POINTER_EXT       0x808F  
        COLOR_ARRAY_POINTER_EXT        0x8090  
        INDEX_ARRAY_POINTER_EXT        0x8091  
        TEXTURE_COORD_ARRAY_POINTER_EXT 0x8092  
        EDGE_FLAG_ARRAY_POINTER_EXT    0x8093  
  
homeprevnext Additions to Chapter 2 of the 1.0 Specification (OpenGL Operation)
  
    Array Specification  
    -------------------  
  
    Individual array pointers and associated data are maintained for an  
    array of vertexes, an array of normals, an array of colors, an array  
    of color indexes, an array of texture coordinates, and an array of edge  
    flags.  The data associated with each array specify the data type of  
    the values in the array, the number of values per element in the array  
    (e.g.  vertexes of 2, 3, or 4 coordinates), the byte stride from one  
    array element to the next, and the number of elements (counting from  
    the first) that are static.  Static elements may be modified by the  
    application, but once they are modified, the application must explicitly  
    respecify the array before using it for any rendering.  When an array is  
    specified, the pointer and associated data are saved as client-side  
    state, and static elements may be cached by the implementation.  Non-  
    static (dynamic) elements are never accessed until ArrayElementEXT or  
    DrawArraysEXT is issued.  
  
    VertexPointerEXT specifies the location and data format of an array  
    of vertex coordinates.  <pointer> specifies a pointer to the first  
    coordinate of the first vertex in the array.  <type> specifies the data  
    type of each coordinate in the array, and must be one of SHORT, INT,  
    FLOAT, or DOUBLE_EXT, implying GL data types short, int, float, and  
    double respectively.  <size> specifies the number of coordinates per  
    vertex, and must be 2, 3, or 4.  <stride> specifies the byte offset  
    between pointers to consecutive vertexes.  If <stride> is zero, the  
    vertex data are understood to be tightly packed in the array.  <count>  
    specifies the number of vertexes, counting from the first, that are  
    static.  
  
    NormalPointerEXT specifies the location and data format of an array  
    of normals.  <pointer> specifies a pointer to the first coordinate  
    of the first normal in the array.  <type> specifies the data type  
    of each coordinate in the array, and must be one of BYTE, SHORT, INT,  
    FLOAT, or DOUBLE_EXT, implying GL data types byte, short, int, float,  
    and double respectively.  It is understood that each normal comprises  
    three coordinates.  <stride> specifies the byte offset between  
    pointers to consecutive normals.  If <stride> is zero, the normal  
    data are understood to be tightly packed in the array.  <count>  
    specifies the number of normals, counting from the first, that are  
    static.  
  
    ColorPointerEXT specifies the location and data format of an array  
    of color components.  <pointer> specifies a pointer to the first  
    component of the first color element in the array.  <type> specifies the  
    data type of each component in the array, and must be one of BYTE,  
    UNSIGNED_BYTE, SHORT, UNSIGNED_SHORT, INT, UNSIGNED_INT, FLOAT, or  
    DOUBLE_EXT, implying GL data types byte, ubyte, short, ushort, int,  
    uint, float, and double respectively.  <size> specifies the number of  
    components per color, and must be 3 or 4.  <stride> specifies the byte  
    offset between pointers to consecutive colors.  If <stride> is zero,  
    the color data are understood to be tightly packed in the array.  
    <count> specifies the number of colors, counting from the first, that  
    are static.  
  
    IndexPointerEXT specifies the location and data format of an array  
    of color indexes.  <pointer> specifies a pointer to the first index in  
    the array.  <type> specifies the data type of each index in the  
    array, and must be one of SHORT, INT, FLOAT, or DOUBLE_EXT, implying  
    GL data types short, int, float, and double respectively.  <stride>  
    specifies the byte offset between pointers to consecutive indexes.  If  
    <stride> is zero, the index data are understood to be tightly packed  
    in the array.  <count> specifies the number of indexes, counting from  
    the first, that are static.  
  
    TexCoordPointerEXT specifies the location and data format of an array  
    of texture coordinates.  <pointer> specifies a pointer to the first  
    coordinate of the first element in the array.  <type> specifies the data  
    type of each coordinate in the array, and must be one of SHORT, INT,  
    FLOAT, or DOUBLE_EXT, implying GL data types short, int, float, and  
    double respectively.  <size> specifies the number of coordinates per  
    element, and must be 1, 2, 3, or 4.  <stride> specifies the byte offset  
    between pointers to consecutive elements of coordinates.  If <stride> is  
    zero, the coordinate data are understood to be tightly packed in the  
    array.  <count> specifies the number of texture coordinate elements,  
    counting from the first, that are static.  
  
    EdgeFlagPointerEXT specifies the location and data format of an array  
    of boolean edge flags.  <pointer> specifies a pointer to the first flag  
    in the array.  <stride> specifies the byte offset between pointers to  
    consecutive edge flags.  If <stride> is zero, the edge flag data are  
    understood to be tightly packed in the array.  <count> specifies the  
    number of edge flags, counting from the first, that are static.  
  
    The table below summarizes the sizes and data types accepted (or  
    understood implicitly) by each of the six pointer-specification commands.  
  
        Command               Sizes     Types  
        -------               -----     -----  
        VertexPointerEXT      2,3,4     short, int, float, double  
        NormalPointerEXT      3         byte, short, int, float, double  
        ColorPointerEXT       3,4       byte, short, int, float, double,  
                                        ubyte, ushort, uint  
        IndexPointerEXT       1         short, int, float, double  
        TexCoordPointerEXT    1,2,3,4   short, int, float, double  
        EdgeFlagPointerEXT    1         boolean  
  
    Rendering the Arrays  
    --------------------  
  
    By default all the arrays are disabled, meaning that they will not  
    be accessed when either ArrayElementEXT or DrawArraysEXT is called.  
    An individual array is enabled or disabled by calling Enable or  
    Disable with <cap> set to appropriate value, as specified in the  
    table below:  
  
        Array Specification Command     Enable Token  
        ---------------------------     ------------  
        VertexPointerEXT                VERTEX_ARRAY_EXT  
        NormalPointerEXT                NORMAL_ARRAY_EXT  
        ColorPointerEXT                 COLOR_ARRAY_EXT  
        IndexPointerEXT                 INDEX_ARRAY_EXT  
        TexCoordPointerEXT              TEXTURE_COORD_ARRAY_EXT  
        EdgeFlagPointerEXT              EDGE_FLAG_ARRAY_EXT  
  
    When ArrayElementEXT is called, a single vertex is drawn, using vertex  
    and attribute data taken from location <i> of the enabled arrays.  The  
    semantics of ArrayElementEXT are defined in the C-code below:  
  
        void ArrayElementEXT (int i) {  
            byte* p;  
            if (NORMAL_ARRAY_EXT) {  
                if (normal_stride == 0)  
                    p = (byte*)normal_pointer + i * 3 * sizeof(normal_type);  
                else  
                    p = (byte*)normal_pointer + i * normal_stride;  
                Normal3<normal_type>v ((normal_type*)p);  
            }  
            if (COLOR_ARRAY_EXT) {  
                if (color_stride == 0)  
                    p = (byte*)color_pointer +  
                        i * color_size * sizeof(color_type);  
                else  
                    p = (byte*)color_pointer + i * color_stride;  
                Color<color_size><color_type>v ((color_type*)p);  
            }  
            if (INDEX_ARRAY_EXT) {  
                if (index_stride == 0)  
                    p = (byte*)index_pointer + i * sizeof(index_type);  
                else  
                    p = (byte*)index_pointer + i * index_stride;  
                Index<index_type>v ((index_type*)p);  
            }  
            if (TEXTURE_COORD_ARRAY_EXT) {  
                if (texcoord_stride == 0)  
                    p = (byte*)texcoord_pointer +  
                        i * texcoord_size * sizeof(texcoord_type);  
                else  
                    p = (byte*)texcoord_pointer + i * texcoord_stride;  
                TexCoord<texcoord_size><texcoord_type>v ((texcoord_type*)p);  
            }  
            if (EDGE_FLAG_ARRAY_EXT) {  
                if (edgeflag_stride == 0)  
                    p = (byte*)edgeflag_pointer + i * sizeof(boolean);  
                else  
                    p = (byte*)edgeflag_pointer + i * edgeflag_stride;  
                EdgeFlagv ((boolean*)p);  
            }  
            if (VERTEX_ARRAY_EXT) {  
                if (vertex_stride == 0)  
                    p = (byte*)vertex_pointer +  
                        i * vertex_size * sizeof(vertex_type);  
                else  
                    p = (byte*)vertex_pointer + i * vertex_stride;  
                Vertex<vertex_size><vertex_type>v ((vertex_type*)p);  
            }  
        }  
  
    ArrayElementEXT executes even if VERTEX_ARRAY_EXT is not enabled.  No  
    drawing occurs in this case, but the attributes corresponding to  
    enabled arrays are modified.  
  
    When DrawArraysEXT is called, <count> sequential elements from each  
    enabled array are used to construct a sequence of geometric primitives,  
    beginning with element <first>.  <mode> specifies what kind of  
    primitives are constructed, and how the array elements are used to  
    construct these primitives.  Accepted values for <mode> are POINTS,  
    LINE_STRIP, LINE_LOOP, LINES, TRIANGLE_STRIP, TRIANGLE_FAN, TRIANGLES,  
    QUAD_STRIP, QUADS, and POLYGON.  If VERTEX_ARRAY_EXT is not enabled, no  
    geometric primitives are generated.  
  
    The semantics of DrawArraysEXT are defined in the C-code below:  
  
        void DrawArraysEXT(enum mode, int first, sizei count) {  
            int i;  
            if (count < 0)  
                /* generate INVALID_VALUE error and abort */  
            else {  
                Begin (mode);  
                for (i=0; i < count; i++)  
                    ArrayElementEXT(first + i);  
                End ();  
            }  
        }  
  
    The ways in which the execution of DrawArraysEXT differs from the  
    semantics indicated in the pseudo-code above are:  
  
        1.  Vertex attributes that are modified by DrawArraysEXT have an  
            unspecified value after DrawArraysEXT returns.  For example, if  
            COLOR_ARRAY_EXT is enabled, the value of the current color is  
            undefined after DrawArraysEXT executes.  Attributes that aren't  
            modified remain well defined.  
  
        2.  Operation of DrawArraysEXT is atomic with respect to error  
            generation.  If an error is generated, no other operations take  
            place.  
  
    Although it is not an error to respecify an array between the execution  
    of Begin and the corresponding execution of End, the result of such  
    respecification is undefined.  Static array data may be read and cached  
    by the implementation at any time.  If static array data are modified by  
    the application, the results of any subsequently issued ArrayElementEXT  
    or DrawArraysEXT commands are undefined.  
  
homeprevnext Additions to Chapter 3 of the 1.0 Specification (Rasterization)
  
    None  
  
homeprevnext Additions to Chapter 4 of the 1.0 Specification (Per-Fragment Operations and the Frame buffer)
  
    None  
  
homeprevnext Additions to Chapter 5 of the 1.0 Specification (Special Functions)
  
    ArrayElementEXT and DrawArraysEXT are included in display lists.  
    When either command is entered into a display list, the necessary  
    array data (determined by the array pointers and enables) is also  
    entered into the display list.  Because the array pointers and  
    enables are client side state, their values affect display lists  
    when the lists are created, not when the lists are executed.  
  
    Array specification commands VertexPointerEXT, NormalPointerEXT,  
    ColorPointerEXT, IndexPointerEXT, TexCoordPointerEXT, and  
    EdgeFlagPointerEXT specify client side state, and are therefore  
    not included in display lists.  Likewise Enable and Disable, when  
    called with <cap> set to VERTEX_ARRAY_EXT, NORMAL_ARRAY_EXT,  
    COLOR_ARRAY_EXT, INDEX_ARRAY_EXT, TEXTURE_COORD_ARRAY_EXT, or  
    EDGE_FLAG_ARRAY_EXT, are not included in display lists.  
    GetPointervEXT returns state information, and so is not included  
    in display lists.  
  
homeprevnext Additions to Chapter 6 of the 1.0 Specification (State and State Requests)
  
    GetPointervEXT returns in <param> the array pointer value specified  
    by <pname>.  Accepted values for <pname> are VERTEX_ARRAY_POINTER_EXT,  
    NORMAL_ARRAY_POINTER_EXT, COLOR_ARRAY_POINTER_EXT,  
    INDEX_ARRAY_POINTER_EXT, TEXTURE_COORD_ARRAY_POINTER_EXT,  
    and EDGE_FLAG_ARRAY_POINTER_EXT.  
  
    All array data are client side state, and are not saved or restored  
    by PushAttrib and PopAttrib.  
  
homeprevnext Additions to the GLX Specification
  
    None  
  
homeprevnext GLX Protocol
  
    A new rendering command is added; it can be sent to the server as part of a   
    glXRender request or as part of a glXRenderLarge request:  
  
        The DrawArraysEXT command consists of three sections, in the following order:   
        (1) header information, (2) a list of array information, containing the type   
        and size of the array values for each enabled array and (3) a list of vertex   
        data. Each element in the list of vertex data contains information for a single   
        vertex taken from the enabled arrays.  
     
        DrawArraysEXT  
            2           16+(12*m)+(s*n) rendering command length  
            2           4116            rendering command opcode  
            4           CARD32          n (number of array elements)  
            4           CARD32          m (number of enabled arrays)  
            4           ENUM            mode    /* GL_POINTS etc */  
            12*m        LISTofARRAY_INFO   
            s*n         LISTofVERTEX_DATA   
       
            Where s = ns + cs + is + ts + es + vs + np + cp + ip + tp + ep + vp. (See  
            description below, under VERTEX_DATA.) Note that if an array is disabled   
            then no information is sent for it. For example, when the normal array is   
            disabled, there is no ARRAY_INFO record for the normal array and ns and np   
            are both zero.  
  
            Note that the list of ARRAY_INFO is unordered: since the ARRAY_INFO  
            record contains the array type, the arrays in the list may be stored  
            in any order. Also, the VERTEX_DATA list is a packed list of vertices.  
            For each vertex, data is retrieved from the enabled arrays, and stored  
            in the list.  
  
            If the command is encoded in a glXRenderLarge request, the command  
            opcode and command length fields above are expanded to 4 bytes each:  
  
            4           20+(12*m)+(s*n) rendering command length  
            4           4116            rendering command opcode  
  
        ARRAY_INFO  
            4           ENUM                    data type  
                        0x1400  i=1             BYTE   
                        0x1401  i=1             UNSIGNED_BYTE  
                        0x1402  i=2             SHORT         
                        0x1403  i=2             UNSIGNED_SHORT  
                        0x1404  i=4             INT    
                        0x1405  i=4             UNSIGNED_INT  
                        0x1406  i=4             FLOAT  
                        0x140A  i=8             DOUBLE_EXT  
            4           INT32                   j (number of values in array element)  
            4           ENUM                    array type  
                        0x8074  j=2/3/4         VERTEX_ARRAY_EXT                 
                        0x8075  j=3             NORMAL_ARRAY_EXT                 
                        0x8076  j=3/4           COLOR_ARRAY_EXT                  
                        0x8077  j=1             INDEX_ARRAY_EXT                  
                        0x8078  j=1/2/3/4       TEXTURE_COORD_ARRAY_EXT          
                        0x8079  j=1             EDGE_FLAG_ARRAY_EXT   
  
            For each array, the size of an array element is i*j. Some arrays  
            (e.g., the texture coordinate array) support different data sizes;  
            for these arrays, the size, j, is specified when the array is defined.  
   
        VERTEX_DATA  
            if the normal array is enabled:  
  
            ns          LISTofBYTE              normal array element  
            np                                  unused, np=pad(ns)  
  
            if the color array is enabled:  
  
            cs          LISTofBYTE              color array element  
            cp                                  unused, cp=pad(cs)  
  
            if the index array is enabled:  
  
            is          LISTofBYTE              index array element  
            ip                                  unused, ip=pad(is)  
  
            if the texture coord array is enabled:  
  
            ts          LISTofBYTE              texture coord array element  
            tp                                  unused, tp=pad(ts)  
  
            if the edge flag array is enabled:  
  
            es          LISTofBYTE              edge flag array element  
            ep                                  unused, ep=pad(es)  
  
            if the vertex array is enabled:  
  
            vs          LISTofBYTE              vertex array element  
            vp                                  unused, vp=pad(vs)  
  
            where ns, cs, is, ts, es, vs is the size of the normal, color, index,   
            texture, edge and vertex array elements and np, cp, ip, tp, ep, vp is   
            the padding for the normal, color, index, texture, edge and vertex array   
            elements, respectively.  
  
homeprevnext Errors
  
    INVALID_OPERATION is generated if DrawArraysEXT is called between the  
    execution of Begin and the corresponding execution of End.  
  
    INVALID_ENUM is generated if DrawArraysEXT parameter <mode> is not  
    POINTS, LINE_STRIP, LINE_LOOP, LINES, TRIANGLE_STRIP, TRIANGLE_FAN,  
    TRIANGLES, QUAD_STRIP, QUADS, or POLYGON.  
  
    INVALID_VALUE is generated if DrawArraysEXT parameter <count> is  
    negative.  
  
    INVALID_VALUE is generated if VertexPointerEXT parameter <size> is not  
    2, 3, or 4.  
  
    INVALID_ENUM is generated if VertexPointerEXT parameter <type> is not  
    SHORT, INT, FLOAT, or DOUBLE_EXT.  
  
    INVALID_VALUE is generated if VertexPointerEXT parameter <stride> or  
    <count> is negative.  
  
    INVALID_ENUM is generated if NormalPointerEXT parameter <type> is not  
    BYTE, SHORT, INT, FLOAT, or DOUBLE_EXT.  
  
    INVALID_VALUE is generated if NormalPointerEXT parameter <stride> or  
    <count> is negative.  
  
    INVALID_VALUE is generated if ColorPointerEXT parameter <size> is not  
    3 or 4.  
  
    INVALID_ENUM is generated if ColorPointerEXT parameter <type> is not  
    BYTE, UNSIGNED_BYTE, SHORT, UNSIGNED_SHORT, INT, UNSIGNED_INT, FLOAT,  
    or DOUBLE_EXT.  
  
    INVALID_VALUE is generated if ColorPointerEXT parameter <stride> or  
    <count> is negative.  
  
    INVALID_ENUM is generated if IndexPointerEXT parameter <type> is not  
    SHORT, INT, FLOAT, or DOUBLE_EXT.  
  
    INVALID_VALUE is generated if IndexPointerEXT parameter <stride> or  
    <count> is negative.  
  
    INVALID_VALUE is generated if TexCoordPointerEXT parameter <size> is not  
    1, 2, 3, or 4.  
  
    INVALID_ENUM is generated if TexCoordPointerEXT parameter <type> is not  
    SHORT, INT, FLOAT, or DOUBLE_EXT.  
  
    INVALID_VALUE is generated if TexCoordPointerEXT parameter <stride> or  
    <count> is negative.  
  
    INVALID_VALUE is generated if EdgeFlagPointerEXT parameter <stride> or  
    <count> is negative.  
  
    INVALID_ENUM is generated if GetPointervEXT parameter <pname> is not  
    VERTEX_ARRAY_POINTER_EXT, NORMAL_ARRAY_POINTER_EXT,  
    COLOR_ARRAY_POINTER_EXT, INDEX_ARRAY_POINTER_EXT,  
    TEXTURE_COORD_ARRAY_POINTER_EXT, or EDGE_FLAG_ARRAY_POINTER_EXT.  
  
homeprevnext New State
                                                                Initial  
    Get Value                           Get Command     Type    Value   Attrib  
    ---------                           -----------     ----    ------- ------  
    VERTEX_ARRAY_EXT                    IsEnabled       B       False   client  
    VERTEX_ARRAY_SIZE_EXT               GetIntegerv     Z+      4       client  
    VERTEX_ARRAY_TYPE_EXT               GetIntegerv     Z4      FLOAT   client  
    VERTEX_ARRAY_STRIDE_EXT             GetIntegerv     Z+      0       client  
    VERTEX_ARRAY_COUNT_EXT              GetIntegerv     Z+      0       client  
    VERTEX_ARRAY_POINTER_EXT            GetPointervEXT  Z+      0       client  
    NORMAL_ARRAY_EXT                    IsEnabled       B       False   client  
    NORMAL_ARRAY_TYPE_EXT               GetIntegerv     Z5      FLOAT   client  
    NORMAL_ARRAY_STRIDE_EXT             GetIntegerv     Z+      0       client  
    NORMAL_ARRAY_COUNT_EXT              GetIntegerv     Z+      0       client  
    NORMAL_ARRAY_POINTER_EXT            GetPointervEXT  Z+      0       client  
    COLOR_ARRAY_EXT                     IsEnabled       B       False   client  
    COLOR_ARRAY_SIZE_EXT                GetIntegerv     Z+      4       client  
    COLOR_ARRAY_TYPE_EXT                GetIntegerv     Z8      FLOAT   client  
    COLOR_ARRAY_STRIDE_EXT              GetIntegerv     Z+      0       client  
    COLOR_ARRAY_COUNT_EXT               GetIntegerv     Z+      0       client  
    COLOR_ARRAY_POINTER_EXT             GetPointervEXT  Z+      0       client  
    INDEX_ARRAY_EXT                     IsEnabled       B       False   client  
    INDEX_ARRAY_TYPE_EXT                GetIntegerv     Z4      FLOAT   client  
    INDEX_ARRAY_STRIDE_EXT              GetIntegerv     Z+      0       client  
    INDEX_ARRAY_COUNT_EXT               GetIntegerv     Z+      0       client  
    INDEX_ARRAY_POINTER_EXT             GetPointervEXT  Z+      0       client  
    TEXTURE_COORD_ARRAY_EXT             IsEnabled       B       False   client  
    TEXTURE_COORD_ARRAY_SIZE_EXT        GetIntegerv     Z+      4       client  
    TEXTURE_COORD_ARRAY_TYPE_EXT        GetIntegerv     Z4      FLOAT   client  
    TEXTURE_COORD_ARRAY_STRIDE_EXT      GetIntegerv     Z+      0       client  
    TEXTURE_COORD_ARRAY_COUNT_EXT       GetIntegerv     Z+      0       client  
    TEXTURE_COORD_ARRAY_POINTER_EXT     GetPointervEXT  Z+      0       client  
    EDGE_FLAG_ARRAY_EXT                 IsEnabled       B       False   client  
    EDGE_FLAG_ARRAY_STRIDE_EXT          GetIntegerv     Z+      0       client  
    EDGE_FLAG_ARRAY_COUNT_EXT           GetIntegerv     Z+      0       client  
    EDGE_FLAG_ARRAY_POINTER_EXT         GetPointervEXT  Z+      0       client  
  
homeprevnext New Implementation Dependent State
  
    None  
    None  
Valid XHTML 1.1! Valid CSS! Last update: November 14, 2006.
Cette page doit être lue avec un navigateur récent respectant le standard XHTML 1.1.