Added __glExtensionBiIsEnabled and __GLXcontext::gl_extension_bits. This

[mesa.git] / src / glx / x11 / indirect_vertex_array.c

/*
 * (C) Copyright IBM Corporation 2004, 2005
 * All Rights Reserved.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sub license,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
 * IBM,
 * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <inttypes.h>
#include <assert.h>
#include "glxclient.h"
#include "packrender.h"
#include "indirect.h"
#include <string.h>

#include <GL/glxproto.h>
#include "glxextensions.h"
#include "indirect_vertex_array.h"

/**
 * \file indirect_vertex_array.c
 * Implement GLX protocol for vertex arrays and vertex buffer objects.
 * 
 * The most important function in this fill is \c fill_array_info_cache.
 * The \c array_state_vector contains a cache of the ARRAY_INFO data sent
 * in the DrawArrays protocol.  Certain operations, such as enabling or
 * disabling an array, can invalidate this cache.  \c fill_array_info_cache
 * fills-in this data.  Additionally, it examines the enabled state and
 * other factors to determine what "version" of DrawArrays protocoal can be
 * used.
 * 
 * Current, only two versions of DrawArrays protocol are implemented.  The
 * first version is the "none" protocol.  This is the fallback when the
 * server does not support GL 1.1 / EXT_vertex_arrays.  It is implemented
 * by sending batches of immediate mode commands that are equivalent to the
 * DrawArrays protocol.
 *
 * The other protocol that is currently implemented is the "old" protocol.
 * This is the GL 1.1 DrawArrays protocol.  The only difference between GL
 * 1.1 and EXT_vertex_arrays is the opcode used for the DrawArrays command.
 * This protocol is called "old" because the ARB is in the process of
 * defining a new protocol, which will probably be called wither "new" or
 * "vbo", to support multiple texture coordinate arrays, generic attributes,
 * and vertex buffer objects.
 *
 * \author Ian Romanick <idr@us.ibm.com>
 */


/**
 * State descriptor for a single array of vertex data.
 */
struct array_state {
    /**
     * Pointer to the application supplied data.
     */
    const void * data;
    
    /**
     * Enum representing the type of the application supplied data.
     */
    GLenum data_type;

    /**
     * Stride value supplied by the application.  This value is not used
     * internally.  It is only kept so that it can be queried by the
     * application using glGet*v.
     */
    GLsizei user_stride;

    /**
     * Calculated size, in bytes, of a single element in the array.  This
     * is calculated based on \c count and the size of the data type
     * represented by \c data_type.
     */
    GLsizei element_size;

    /**
     * Actual byte-stride from one element to the next.  This value will
     * be equal to either \c user_stride or \c element_stride.
     */
    GLsizei true_stride;

    /**
     * Number of data values in each element.
     */
    GLint count;

    /**
     * Pre-calculated GLX protocol command header.
     */
    uint32_t header[2];
    
    /**
     * Size of the header data.  For simple data, like glColorPointerfv,
     * this is 4.  For complex data that requires either a count (e.g.,
     * glWeightfvARB), an index (e.g., glVertexAttrib1fvARB), or a
     * selector enum (e.g., glMultiTexCoord2fv) this is 8.
     */
    unsigned header_size;
    
    /**
     * Set to \c GL_TRUE if this array is enabled.  Otherwise, it is set
     * to \c GL_FALSE.
     */
    GLboolean  enabled;

    /**
     * For multi-arrayed data (e.g., texture coordinates, generic vertex
     * program attributes, etc.), this specifies which array this is.
     */
    unsigned index;
    
    /**
     * Per-array-type key.  For most arrays, this will be the GL enum for
     * that array (e.g., GL_VERTEX_ARRAY for vertex data, GL_NORMAL_ARRAY
     * for normal data, GL_TEXTURE_COORD_ARRAY for texture coordinate data,
     * etc.).
     */
    GLenum key;

    /**
     * If this array can be used with the "classic" \c glDrawArrays protocol,
     * this is set to \c GL_TRUE.  Otherwise, it is set to \c GL_FALSE.
     */
    GLboolean old_DrawArrays_possible;
};


/**
 * Array state that is pushed / poped by \c glPushClientAttrib and
 * \c glPopClientAttrib.
 */
struct array_stack_state {
    /**
     * Pointer to the application supplied data.
     */
    const void * data;
    
    /**
     * Enum representing the type of the application supplied data.
     */
    GLenum data_type;

    /**
     * Stride value supplied by the application.  This value is not used
     * internally.  It is only kept so that it can be queried by the
     * application using glGet*v.
     */
    GLsizei user_stride;

    /**
     * Number of data values in each element.
     */
    GLint count;

    /**
     * Per-array-type key.  For most arrays, this will be the GL enum for
     * that array (e.g., GL_VERTEX_ARRAY for vertex data, GL_NORMAL_ARRAY
     * for normal data, GL_TEXTURE_COORD_ARRAY for texture coordinate data,
     * etc.).
     */
    GLenum key;

    /**
     * For multi-arrayed data (e.g., texture coordinates, generic vertex
     * program attributes, etc.), this specifies which array this is.
     */
    unsigned index;

    /**
     * Set to \c GL_TRUE if this array is enabled.  Otherwise, it is set
     * to \c GL_FALSE.
     */
    GLboolean  enabled;
};


/**
 * Collection of all the vertex array state.
 */
struct array_state_vector {
    /**
     * Number of arrays tracked by \c ::arrays.
     */
    size_t num_arrays;

    /**
     * Array of vertex array state.  This array contains all of the valid
     * vertex arrays.  If a vertex array isn't in this array, then it isn't
     * valid.  For example, if an implementation does not support
     * EXT_fog_coord, there won't be a GL_FOG_COORD_ARRAY entry in this
     * array.
     */
    struct array_state * arrays;

    /**
     * Number of currently enabled arrays.  The value of this field is
     * only valid if \c array_info_cache_valid is true.
     */
    size_t enabled_array_count;

    /**
     * \name ARRAY_INFO cache.
     * 
     * These fields track the state of the ARRAY_INFO cache.  The
     * \c array_info_cache_size is the size of the actual data stored in
     * \c array_info_cache.  \c array_info_cache_buffer_size is the size of
     * the buffer.  This will always be greater than or equal to
     * \c array_info_cache_size.
     *
     * \c large_header doesn't completely belong in this group.  This is a
     * pointer to a buffer to hold the header information for DrawArrays in
     * a RenderLarge command.  This buffer is immediately before
     * \c array_info_cache.  The idea is that the header data will be written
     * to \c large_header and a single call to \c __glXSendLargeChunk can be
     * made to send the header and the ARRAY_INFO data.
     * 
     * \note
     * \c array_info_cache_size and \c array_info_cache_buffer_size do
     * NOT include the size of \c large_header.
     */
    /*@{*/
    size_t array_info_cache_size;
    size_t array_info_cache_buffer_size;
    void * array_info_cache;
    GLubyte * large_header;
    /*@}*/


    /**
     * Is the cache of ARRAY_INFO data valid?  The cache can become invalid
     * when one of several state changes occur.  Among these chages are
     * modifying the array settings for an enabled array and enabling /
     * disabling an array.
     */
    GLboolean array_info_cache_valid;

    /**
     * Is it possible to use the GL 1.1 / EXT_vertex_arrays protocol?  Use
     * of this protocol is disabled with really old servers (i.e., servers
     * that don't support GL 1.1 or EXT_vertex_arrays) or when an environment
     * variable is set.
     * 
     * \todo
     * GL 1.1 and EXT_vertex_arrays use identical protocol, but have different
     * opcodes for \c glDrawArrays.  For servers that advertise one or the
     * other, there should be a way to select which opcode to use.
     */
    GLboolean old_DrawArrays_possible;

    /**
     * Is it possible to use the new GL X.X / ARB_vertex_buffer_object
     * protocol?
     * 
     * \todo
     * This protocol has not yet been defined by the ARB, but is currently a
     * work in progress.  This field is a place-holder.
     */
    GLboolean new_DrawArrays_possible;

    /**
     * Active texture unit set by \c glClientActiveTexture.
     * 
     * \sa __glXGetActiveTextureUnit
     */
    unsigned active_texture_unit;
    
    /**
     * Number of supported texture units.  Even if ARB_multitexture /
     * GL 1.3 are not supported, this will be at least 1.  When multitexture
     * is supported, this will be the value queried by calling
     * \c glGetIntegerv with \c GL_MAX_TEXTURE_UNITS.
     * 
     * \todo
     * Investigate if this should be the value of \c GL_MAX_TEXTURE_COORDS
     * instead (if GL 2.0 / ARB_fragment_shader / ARB_fragment_program /
     * NV_fragment_program are supported).
     */
    unsigned num_texture_units;

    /**
     * \n Methods for implementing various GL functions.
     * 
     * These method pointers are only valid \c array_info_cache_valid is set.
     * When each function starts, it much check \c array_info_cache_valid.
     * If it is not set, it must call \c fill_array_info_cache and call
     * the new method.
     * 
     * \sa fill_array_info_cache
     * 
     * \todo
     * Write code to plug these functions directly into the dispatch table.
     */
    /*@{*/
    void (*DrawArrays)( GLenum, GLint, GLsizei );
    void (*DrawElements)( GLenum mode, GLsizei count, GLenum type,
                          const GLvoid *indices );
    /*@}*/

    struct array_stack_state * stack;
    unsigned active_texture_unit_stack[ __GL_CLIENT_ATTRIB_STACK_DEPTH ];
    unsigned stack_index;
};


static void emit_DrawArrays_none( GLenum mode, GLint first, GLsizei count );
static void emit_DrawArrays_old ( GLenum mode, GLint first, GLsizei count );

static void emit_DrawElements_none( GLenum mode, GLsizei count, GLenum type,
    const GLvoid *indices );
static void emit_DrawElements_old ( GLenum mode, GLsizei count, GLenum type,
    const GLvoid *indices );


static GLubyte * emit_element_none( GLubyte * dst,
    const struct array_state_vector * arrays, unsigned index );
static GLubyte * emit_element_old( GLubyte * dst,
    const struct array_state_vector * arrays, unsigned index );
static struct array_state * get_array_entry(
    const struct array_state_vector * arrays, GLenum key, unsigned index );
static void fill_array_info_cache( struct array_state_vector * arrays );
static GLboolean glx_validate_array_args(__GLXcontext *gc, GLenum mode,
    GLsizei count);


/**
 * Table of sizes, in bytes, of a GL types.  All of the type enums are be in 
 * the range 0x1400 - 0x140F.  That includes types added by extensions (i.e.,
 * \c GL_HALF_FLOAT_NV).  This elements of this table correspond to the
 * type enums masked with 0x0f.
 * 
 * \notes
 * \c GL_HALF_FLOAT_NV is not included.  Neither are \c GL_2_BYTES,
 * \c GL_3_BYTES, or \c GL_4_BYTES.
 */
const GLuint __glXTypeSize_table[16] = {
    1, 1, 2, 2, 4, 4, 4, 0, 0, 0, 8, 0, 0, 0, 0, 0
};



/**
 * Initialize vertex array state of a GLX context.
 * 
 * \param gc  GLX context whose vertex array state is to be initialized.
 * 
 * \warning
 * This function may only be called after __GLXcontext::gl_extension_bits,
 * __GLXcontext::server_minor, and __GLXcontext::server_major have been
 * initialized.  These values are used to determine what vertex arrays are
 * supported.
 * 
 * \bug
 * Return values from malloc are not properly tested.
 */
void
__glXInitVertexArrayState( __GLXcontext * gc )
{
    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
    struct array_state_vector * arrays;

    unsigned array_count;
    unsigned texture_units = 1;
    unsigned i;

    GLboolean got_fog = GL_FALSE;
    GLboolean got_secondary_color = GL_FALSE;


    arrays = malloc( sizeof( struct array_state_vector ) );
    state->array_state = arrays;
    arrays->enabled_array_count = 0;
    arrays->array_info_cache = NULL;
    arrays->array_info_cache_size = 0;
    arrays->array_info_cache_buffer_size = 0;
    arrays->array_info_cache_valid= GL_FALSE;

    arrays->old_DrawArrays_possible = !state->NoDrawArraysProtocol;
    arrays->new_DrawArrays_possible = GL_FALSE;
    arrays->DrawArrays = NULL;

    arrays->active_texture_unit = 0;


    /* Determine how many arrays are actually needed.  Only arrays that
     * are supported by the server are create.  For example, if the server
     * supports only 2 texture units, then only 2 texture coordinate arrays
     * are created.
     * 
     * At the very least, GL_VERTEX_ARRAY, GL_NORMAL_ARRAY,
     * GL_COLOR_ARRAY, GL_INDEX_ARRAY, GL_TEXTURE_COORD_ARRAY, and
     * GL_EDGE_FLAG_ARRAY are supported.
     */
    
    array_count = 5;
    
    if ( __glExtensionBitIsEnabled( gc, GL_EXT_fog_coord_bit )
         || (gc->server_major > 1) || (gc->server_minor >= 4) ) {
        got_fog = GL_TRUE;
        array_count++;
    }

    if ( __glExtensionBitIsEnabled( gc, GL_EXT_secondary_color_bit )
         || (gc->server_major > 1) || (gc->server_minor >= 4) ) {
        got_secondary_color = GL_TRUE;
        array_count++;
    }

    if ( __glExtensionBitIsEnabled( gc, GL_ARB_multitexture_bit )
         || (gc->server_major > 1) || (gc->server_minor >= 3) ) {
        glGetIntegerv( GL_MAX_TEXTURE_UNITS, & texture_units );
    }
    else {
        texture_units = 1;
    }

    arrays->num_texture_units = texture_units;
    array_count += texture_units;
    arrays->num_arrays = array_count;
    arrays->arrays = malloc( sizeof( struct array_state ) * array_count );
    
    (void) memset( arrays->arrays, 0,
                   sizeof( struct array_state ) * array_count );


    arrays->arrays[0].data_type = GL_FLOAT;
    arrays->arrays[0].count = 3;
    arrays->arrays[0].key = GL_NORMAL_ARRAY;
    arrays->arrays[0].old_DrawArrays_possible = GL_TRUE;

    arrays->arrays[1].data_type = GL_FLOAT;
    arrays->arrays[1].count = 4;
    arrays->arrays[1].key = GL_COLOR_ARRAY;
    arrays->arrays[1].old_DrawArrays_possible = GL_TRUE;

    arrays->arrays[2].data_type = GL_FLOAT;
    arrays->arrays[2].count = 1;
    arrays->arrays[2].key = GL_INDEX_ARRAY;
    arrays->arrays[2].old_DrawArrays_possible = GL_TRUE;

    arrays->arrays[3].data_type = GL_UNSIGNED_BYTE;
    arrays->arrays[3].count = 1;
    arrays->arrays[3].key = GL_EDGE_FLAG_ARRAY;
    arrays->arrays[3].old_DrawArrays_possible = GL_TRUE;

    for ( i = 0 ; i < texture_units ; i++ ) {
        arrays->arrays[4 + i].data_type = GL_FLOAT;
        arrays->arrays[4 + i].count = 4;
        arrays->arrays[4 + i].key = GL_TEXTURE_COORD_ARRAY;
        
        arrays->arrays[4 + i].old_DrawArrays_possible = (i == 0);
        arrays->arrays[4 + i].index = i;

        arrays->arrays[4 + i].header[1] = i + GL_TEXTURE0;
    }
    
    i = 4 + texture_units;

    if ( got_fog ) {
        arrays->arrays[i].data_type = GL_FLOAT;
        arrays->arrays[i].count = 1;
        arrays->arrays[i].key = GL_FOG_COORDINATE_ARRAY;
        arrays->arrays[i].old_DrawArrays_possible = GL_TRUE;
        i++;
    }

    if ( got_secondary_color ) {
        arrays->arrays[i].data_type = GL_FLOAT;
        arrays->arrays[i].count = 3;
        arrays->arrays[i].key = GL_SECONDARY_COLOR_ARRAY;
        arrays->arrays[i].old_DrawArrays_possible = GL_TRUE;
        i++;
    }


    /* Vertex array *must* be last becuase of the way that
     * emit_DrawArrays_none works.
     */

    arrays->arrays[i].data_type = GL_FLOAT;
    arrays->arrays[i].count = 4;
    arrays->arrays[i].key = GL_VERTEX_ARRAY;
    arrays->arrays[i].old_DrawArrays_possible = GL_TRUE;


    arrays->stack_index = 0;
    arrays->stack = malloc( sizeof( struct array_stack_state )
                            * arrays->num_arrays );
}


/**
 * Calculate the size of a single vertex for the "none" protocol.  This is
 * essentially the size of all the immediate-mode commands required to
 * implement the enabled vertex arrays.
 */
static size_t
calculate_single_vertex_size_none( const struct array_state_vector * arrays )
{
    size_t single_vertex_size = 0;
    unsigned   i;


    for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
        if ( arrays->arrays[i].enabled ) {
            single_vertex_size += __GLX_PAD(arrays->arrays[i].element_size)
              + arrays->arrays[i].header_size;
        }
    }
    
    return single_vertex_size;
}


/**
 * Emit a single element using non-DrawArrays protocol.
 */
GLubyte *
emit_element_none( GLubyte * dst,
                   const struct array_state_vector * arrays,
                   unsigned index )
{
    unsigned i;


    for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
        if ( arrays->arrays[i].enabled ) {
            const size_t offset = index * arrays->arrays[i].true_stride;

            (void) memcpy( dst, arrays->arrays[i].header, 
                           arrays->arrays[i].header_size );

            dst += arrays->arrays[i].header_size;

            (void) memcpy( dst, ((GLubyte *) arrays->arrays[i].data) + offset,
                           arrays->arrays[i].element_size );

            dst += __GLX_PAD( arrays->arrays[i].element_size );
        }
    }

    return dst;
}


/**
 * Emit a single element using "old" DrawArrays protocol from
 * EXT_vertex_arrays / OpenGL 1.1.
 */
GLubyte *
emit_element_old( GLubyte * dst,
                  const struct array_state_vector * arrays,
                  unsigned index )
{
    unsigned i;


    for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
        if ( arrays->arrays[i].enabled ) {
            const size_t offset = index * arrays->arrays[i].true_stride;

            (void) memcpy( dst, ((GLubyte *) arrays->arrays[i].data) + offset,
                           arrays->arrays[i].element_size );

            dst += __GLX_PAD( arrays->arrays[i].element_size );
        }
    }

    return dst;
}


struct array_state *
get_array_entry( const struct array_state_vector * arrays,
                 GLenum key, unsigned index )
{
    unsigned  i;

    for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
        if ( (arrays->arrays[i].key == key)
             && (arrays->arrays[i].index == index) ) {
            return & arrays->arrays[i];
        }
    }
    
    return NULL;
}


static GLboolean
allocate_array_info_cache( struct array_state_vector * arrays,
                           size_t required_size )
{
    if ( arrays->array_info_cache_buffer_size < required_size ) {
        GLubyte * temp = realloc( arrays->array_info_cache, required_size + 20 );

        if ( temp == NULL ) {
            return GL_FALSE;
        }

        arrays->large_header = temp;
        arrays->array_info_cache = temp + 20;
        arrays->array_info_cache_buffer_size = required_size;
    }

    arrays->array_info_cache_size = required_size;
    return GL_TRUE;
}


/**
 */
void
fill_array_info_cache( struct array_state_vector * arrays )
{
    GLboolean old_DrawArrays_possible;
    unsigned  i;


    /* Determine how many arrays are enabled.
     */

    arrays->enabled_array_count = 0;
    old_DrawArrays_possible = arrays->old_DrawArrays_possible;
    for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
        if ( arrays->arrays[i].enabled ) {
            arrays->enabled_array_count++;
            old_DrawArrays_possible &= arrays->arrays[i].old_DrawArrays_possible;
        }
    }
    
    
    if ( arrays->new_DrawArrays_possible ) {
        assert( ! arrays->new_DrawArrays_possible );
    }
    else if ( old_DrawArrays_possible ) {
        const size_t required_size = arrays->enabled_array_count * 12;
        uint32_t * info;


        if ( ! allocate_array_info_cache( arrays, required_size ) ) {
            return;
        }


        info = (uint32_t *) arrays->array_info_cache;
        for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
            if ( arrays->arrays[i].enabled ) {
                *(info++) = arrays->arrays[i].data_type;
                *(info++) = arrays->arrays[i].count;
                *(info++) = arrays->arrays[i].key;
            }
        }

        arrays->array_info_cache_valid = GL_TRUE;
        arrays->DrawArrays = emit_DrawArrays_old;
        arrays->DrawElements = emit_DrawElements_old;
    }
    else {
        arrays->DrawArrays = emit_DrawArrays_none;
        arrays->DrawElements = emit_DrawElements_none;
    }
}


/**
 * Emit a \c glDrawArrays command using the "none" protocol.  That is,
 * emit immediate-mode commands that are equivalent to the requiested
 * \c glDrawArrays command.  This is used with servers that don't support
 * the OpenGL 1.1 / EXT_vertex_arrays DrawArrays protocol or in cases where
 * vertex state is enabled that is not compatible with that protocol.
 */
void
emit_DrawArrays_none( GLenum mode, GLint first, GLsizei count )
{
    __GLXcontext *gc = __glXGetCurrentContext();
    const __GLXattribute * state = 
       (const __GLXattribute *)(gc->client_state_private);
    struct array_state_vector * arrays = state->array_state;

    size_t single_vertex_size;
    GLubyte * pc;
    unsigned  i;
    static const uint16_t begin_cmd[2] = { 8, X_GLrop_Begin };
    static const uint16_t end_cmd[2]   = { 4, X_GLrop_End };


    single_vertex_size = calculate_single_vertex_size_none( arrays );

    pc = gc->pc;

    (void) memcpy( pc, begin_cmd, 4 );
    *(int *)(pc +  4) = mode;

    pc += 8;

    for ( i = 0 ; i < count ; i++ ) {
        if ( (pc + single_vertex_size) >= gc->bufEnd ) {
            pc = __glXFlushRenderBuffer(gc, gc->pc);
        }

        pc = emit_element_none( pc, arrays, first + i );
    }

    if ( (pc + 4) >= gc->bufEnd ) {
        pc = __glXFlushRenderBuffer(gc, gc->pc);
    }

    (void) memcpy( pc, end_cmd, 4 );
    pc += 4;

    gc->pc = pc;
    if ( gc->pc > gc->limit ) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}


/**
 * Emit the header data for the GL 1.1 / EXT_vertex_arrays DrawArrays
 * protocol.
 * 
 * \param gc                    GLX context.
 * \param arrays                Array state.
 * \param elements_per_request  Location to store the number of elements that
 *                              can fit in a single Render / RenderLarge
 *                              command.
 * \param total_request         Total number of requests for a RenderLarge
 *                              command.  If a Render command is used, this
 *                              will be zero.
 * \param mode                  Drawing mode.
 * \param count                 Number of vertices.
 * 
 * \returns
 * A pointer to the buffer for array data.
 */
static GLubyte *
emit_DrawArrays_header_old( __GLXcontext * gc,
                            struct array_state_vector * arrays,
                            size_t * elements_per_request,
                            size_t * total_requests,
                            GLenum mode, GLsizei count )
{
    size_t command_size;
    size_t single_vertex_size;
    const unsigned header_size = 16;
    unsigned  i;
    GLubyte * pc;


    /* Determine the size of the whole command.  This includes the header,
     * the ARRAY_INFO data and the array data.  Once this size is calculated,
     * it will be known whether a Render or RenderLarge command is needed.
     */

    single_vertex_size = 0;
    for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
        if ( arrays->arrays[i].enabled ) {
            single_vertex_size += __GLX_PAD( arrays->arrays[i].element_size );
        }
    }

    command_size = arrays->array_info_cache_size + header_size 
      + (single_vertex_size * count);


    /* Write the header for either a Render command or a RenderLarge
     * command.  After the header is written, write the ARRAY_INFO data.
     */

    if ( command_size > gc->maxSmallRenderCommandSize ) {
        /* maxSize is the maximum amount of data can be stuffed into a single
         * packet.  sz_xGLXRenderReq is added because bufSize is the maximum
         * packet size minus sz_xGLXRenderReq.
         */
        const size_t maxSize = (gc->bufSize + sz_xGLXRenderReq)
          - sz_xGLXRenderLargeReq;
        unsigned vertex_requests;


        /* Calculate the number of data packets that will be required to send
         * the whole command.  To do this, the number of verticies that
         * will fit in a single buffer must be calculated.
         * 
         * The important value here is elements_per_request.  This is the
         * number of complete array elements that will fit in a single
         * buffer.  There may be some wasted space at the end of the buffer,
         * but splitting elements across buffer boundries would be painful.
         */

        elements_per_request[0] = maxSize / single_vertex_size;

        vertex_requests = (count + elements_per_request[0] - 1)
          / elements_per_request[0];
          
        *total_requests = vertex_requests + 1;


        __glXFlushRenderBuffer(gc, gc->pc);

        command_size += 4;

        pc = arrays->large_header;
        *(uint32_t *)(pc +  0) = command_size;
        *(uint32_t *)(pc +  4) = X_GLrop_DrawArrays;
        *(uint32_t *)(pc +  8) = count;
        *(uint32_t *)(pc + 12) = arrays->enabled_array_count;
        *(uint32_t *)(pc + 16) = mode;

        __glXSendLargeChunk( gc, 1, *total_requests, pc,
                             header_size + 4 + arrays->array_info_cache_size );

        pc = gc->pc;
    }
    else {
        if ( (gc->pc + command_size) >= gc->bufEnd ) {
            (void) __glXFlushRenderBuffer(gc, gc->pc);
        }

        pc = gc->pc;
        *(uint16_t *)(pc +  0) = command_size;
        *(uint16_t *)(pc +  2) = X_GLrop_DrawArrays;
        *(uint32_t *)(pc +  4) = count;
        *(uint32_t *)(pc +  8) = arrays->enabled_array_count;
        *(uint32_t *)(pc + 12) = mode;

        pc += header_size;

        (void) memcpy( pc, arrays->array_info_cache,
                       arrays->array_info_cache_size );
        pc += arrays->array_info_cache_size;
        
        *elements_per_request = count;
        *total_requests = 0;
    }


    return pc;
}


/**
 */
void
emit_DrawArrays_old( GLenum mode, GLint first, GLsizei count )
{
    __GLXcontext *gc = __glXGetCurrentContext();
    const __GLXattribute * state = 
       (const __GLXattribute *)(gc->client_state_private);
    struct array_state_vector * arrays = state->array_state;

    GLubyte * pc;
    size_t elements_per_request;
    unsigned total_requests = 0;
    unsigned i;
    size_t total_sent = 0;


    pc = emit_DrawArrays_header_old( gc, arrays, & elements_per_request,
                                     & total_requests, mode, count);

    
    /* Write the arrays.
     */

    if ( total_requests == 0 ) {
        assert( elements_per_request >= count );

        for ( i = 0 ; i < count ; i++ ) {
            pc = emit_element_old( pc, arrays, i + first );
        }

        assert( pc <= gc->bufEnd );

        gc->pc = pc;
        if ( gc->pc > gc->limit ) {
            (void) __glXFlushRenderBuffer(gc, gc->pc);
        }
    }
    else {
        unsigned req;


        for ( req = 2 ; req <= total_requests ; req++ ) {
            if ( count < elements_per_request ) {
                elements_per_request = count;
            }

            pc = gc->pc;
            for ( i = 0 ; i < elements_per_request ; i++ ) {
                pc = emit_element_old( pc, arrays, i + first );
            }

            first += elements_per_request;

            total_sent += (size_t) (pc - gc->pc);
            __glXSendLargeChunk( gc, req, total_requests, gc->pc,
                                 pc - gc->pc );

            count -= elements_per_request;
        }
    }
}


void
emit_DrawElements_none( GLenum mode, GLsizei count, GLenum type,
                        const GLvoid *indices )
{
    __GLXcontext *gc = __glXGetCurrentContext();
    const __GLXattribute * state = 
       (const __GLXattribute *)(gc->client_state_private);
    struct array_state_vector * arrays = state->array_state;
    static const uint16_t begin_cmd[2] = { 8, X_GLrop_Begin };
    static const uint16_t end_cmd[2]   = { 4, X_GLrop_End };

    GLubyte * pc;
    size_t single_vertex_size;
    unsigned  i;


    single_vertex_size = calculate_single_vertex_size_none( arrays );


    if ( (gc->pc + single_vertex_size) >= gc->bufEnd ) {
        gc->pc = __glXFlushRenderBuffer(gc, gc->pc);
    }

    pc = gc->pc;

    (void) memcpy( pc, begin_cmd, 4 );
    *(int *)(pc +  4) = mode;

    pc += 8;

    for ( i = 0 ; i < count ; i++ ) {
        unsigned  index;

        if ( (pc + single_vertex_size) >= gc->bufEnd ) {
            pc = __glXFlushRenderBuffer(gc, gc->pc);
        }

        switch( type ) {
        case GL_UNSIGNED_INT:
            index = (unsigned) (((GLuint *) indices)[i]);
            break;
        case GL_UNSIGNED_SHORT:
            index = (unsigned) (((GLushort *) indices)[i]);
            break;
        case GL_UNSIGNED_BYTE:
            index = (unsigned) (((GLubyte *) indices)[i]);
            break;
        }
        pc = emit_element_none( pc, arrays, index );
    }

    if ( (pc + 4) >= gc->bufEnd ) {
        pc = __glXFlushRenderBuffer(gc, gc->pc);
    }

    (void) memcpy( pc, end_cmd, 4 );
    pc += 4;

    gc->pc = pc;
    if ( gc->pc > gc->limit ) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}


/**
 */
void
emit_DrawElements_old( GLenum mode, GLsizei count, GLenum type,
                       const GLvoid *indices )
{
    __GLXcontext *gc = __glXGetCurrentContext();
    const __GLXattribute * state = 
       (const __GLXattribute *)(gc->client_state_private);
    struct array_state_vector * arrays = state->array_state;

    GLubyte * pc;
    size_t elements_per_request;
    unsigned total_requests = 0;
    unsigned i;
    unsigned req;
    const GLuint   * ui_ptr = (const GLuint   *) indices;
    const GLushort * us_ptr = (const GLushort *) indices;
    const GLubyte  * ub_ptr = (const GLubyte  *) indices;


    pc = emit_DrawArrays_header_old( gc, arrays, & elements_per_request,
                                     & total_requests, mode, count);

    
    /* Write the arrays.
     */

    req = 2;
    while ( count > 0 ) {
        if ( count < elements_per_request ) {
            elements_per_request = count;
        }

        switch( type ) {
        case GL_UNSIGNED_INT:
            for ( i = 0 ; i < elements_per_request ; i++ ) {
                const GLint index = (GLint) *(ui_ptr++);
                pc = emit_element_old( pc, arrays, index );
            }
            break;
        case GL_UNSIGNED_SHORT:
            for ( i = 0 ; i < elements_per_request ; i++ ) {
                const GLint index = (GLint) *(us_ptr++);
                pc = emit_element_old( pc, arrays, index );
            }
            break;
        case GL_UNSIGNED_BYTE:
            for ( i = 0 ; i < elements_per_request ; i++ ) {
                const GLint index = (GLint) *(ub_ptr++);
                pc = emit_element_old( pc, arrays, index );
            }
            break;
        }

        if ( total_requests != 0 ) {
            __glXSendLargeChunk( gc, req, total_requests, gc->pc,
                                 pc - gc->pc );
            pc = gc->pc;
            req++;
        }

        count -= elements_per_request;
    }


    assert( (total_requests == 0) || ((req - 1) == total_requests) );

    if ( total_requests == 0 ) {
        assert( pc <= gc->bufEnd );

        gc->pc = pc;
        if ( gc->pc > gc->limit ) {
            (void) __glXFlushRenderBuffer(gc, gc->pc);
        }
    }
}


/**
 * Validate that the \c mode parameter to \c glDrawArrays, et. al. is valid.
 * If it is not valid, then an error code is set in the GLX context.
 * 
 * \returns
 * \c GL_TRUE if the argument is valid, \c GL_FALSE if is not.
 */
static GLboolean
validate_mode(__GLXcontext *gc, GLenum mode)
{
    switch(mode) {
      case GL_POINTS:
      case GL_LINE_STRIP:
      case GL_LINE_LOOP:
      case GL_LINES:
      case GL_TRIANGLE_STRIP:
      case GL_TRIANGLE_FAN:
      case GL_TRIANGLES:
      case GL_QUAD_STRIP:
      case GL_QUADS:
      case GL_POLYGON:
        break;
      default:
        __glXSetError(gc, GL_INVALID_ENUM);
        return GL_FALSE;
    }
    
    return GL_TRUE;
}


/**
 * Validate that the \c count parameter to \c glDrawArrays, et. al. is valid.
 * A value less than zero is invalid and will result in \c GL_INVALID_VALUE
 * being set.  A value of zero will not result in an error being set, but
 * will result in \c GL_FALSE being returned.
 * 
 * \returns
 * \c GL_TRUE if the argument is valid, \c GL_FALSE if it is not.
 */
static GLboolean
validate_count(__GLXcontext *gc, GLsizei count)
{
    if (count < 0) {
        __glXSetError(gc, GL_INVALID_VALUE);
    }

    return (count > 0);
}


void __indirect_glDrawArrays(GLenum mode, GLint first, GLsizei count)
{
    __GLXcontext *gc = __glXGetCurrentContext();
    const __GLXattribute * state = 
       (const __GLXattribute *)(gc->client_state_private);
    struct array_state_vector * arrays = state->array_state;
    

    if ( validate_mode(gc, mode) && validate_count(gc, count) ) {
        if ( ! arrays->array_info_cache_valid ) {
            fill_array_info_cache( arrays );
        }

        arrays->DrawArrays(mode, first, count);
    }
}


void __indirect_glArrayElement(GLint index)
{
    __GLXcontext *gc = __glXGetCurrentContext();
    const __GLXattribute * state = 
       (const __GLXattribute *)(gc->client_state_private);
    struct array_state_vector * arrays = state->array_state;

    size_t single_vertex_size;


    single_vertex_size = calculate_single_vertex_size_none( arrays );

    if ( (gc->pc + single_vertex_size) >= gc->bufEnd ) {
        gc->pc = __glXFlushRenderBuffer(gc, gc->pc);
    }

    gc->pc = emit_element_none( gc->pc, arrays, index );

    if ( gc->pc > gc->limit ) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}


void __indirect_glDrawElements(GLenum mode, GLsizei count, GLenum type,
                    const GLvoid *indices)
{
    __GLXcontext *gc = __glXGetCurrentContext();
    const __GLXattribute * state = 
       (const __GLXattribute *)(gc->client_state_private);
    struct array_state_vector * arrays = state->array_state;


    if ( validate_mode(gc, mode) && validate_count(gc, count)  ) {
        if ( ! arrays->array_info_cache_valid ) {
            fill_array_info_cache( arrays );
        }

        arrays->DrawElements(mode, count, type, indices);
    }
}


void __indirect_glDrawRangeElements(GLenum mode, GLuint start, GLuint end,
                                    GLsizei count, GLenum type,
                                    const GLvoid *indices)
{
    __GLXcontext *gc = __glXGetCurrentContext();
    const __GLXattribute * state = 
       (const __GLXattribute *)(gc->client_state_private);
    struct array_state_vector * arrays = state->array_state;


    if ( validate_mode(gc, mode) && validate_count(gc, count) ) {
        if (end < start) {
            __glXSetError(gc, GL_INVALID_VALUE);
            return;
        }

        if ( ! arrays->array_info_cache_valid ) {
            fill_array_info_cache( arrays );
        }

        arrays->DrawElements(mode, count, type, indices);
    }
}


void __indirect_glMultiDrawArraysEXT(GLenum mode, GLint *first, GLsizei *count,
                       GLsizei primcount)
{
    __GLXcontext *gc = __glXGetCurrentContext();
    const __GLXattribute * state = 
       (const __GLXattribute *)(gc->client_state_private);
    struct array_state_vector * arrays = state->array_state;
    GLsizei  i;


    if ( validate_mode(gc, mode) ) {
        if ( ! arrays->array_info_cache_valid ) {
            fill_array_info_cache( arrays );
        }

        for ( i = 0 ; i < primcount ; i++ ) {
            if ( validate_count( gc, count[i] ) ) {
                arrays->DrawArrays(mode, first[i], count[i]);
            }
        }
    }
}


void __indirect_glMultiDrawElementsEXT(GLenum mode, const GLsizei *count,
                         GLenum type, const GLvoid ** indices,
                         GLsizei primcount)
{
    __GLXcontext *gc = __glXGetCurrentContext();
    const __GLXattribute * state = 
       (const __GLXattribute *)(gc->client_state_private);
    struct array_state_vector * arrays = state->array_state;
    GLsizei  i;


    if ( validate_mode(gc, mode) ) {
        if ( ! arrays->array_info_cache_valid ) {
            fill_array_info_cache( arrays );
        }

        for ( i = 0 ; i < primcount ; i++ ) {
            if ( validate_count( gc, count[i] ) ) {
                arrays->DrawElements(mode, count[i], type, indices[i]);
            }
        }
    }
}


#define COMMON_ARRAY_DATA_INIT(a, PTR, TYPE, STRIDE, COUNT, HDR_SIZE, OPCODE) \
    do { \
        (a)->data = PTR; \
        (a)->data_type = TYPE; \
        (a)->user_stride = STRIDE; \
        (a)->count = COUNT; \
        \
        (a)->element_size = __glXTypeSize( TYPE ) * COUNT; \
        (a)->true_stride = (STRIDE == 0) \
          ? (a)->element_size : STRIDE; \
        \
        (a)->header_size = HDR_SIZE; \
        ((uint16_t *) (a)->header)[0] = __GLX_PAD((a)->header_size + (a)->element_size); \
        ((uint16_t *) (a)->header)[1] = OPCODE; \
    } while(0)


void __indirect_glVertexPointer( GLint size, GLenum type, GLsizei stride,
                                 const GLvoid * pointer )
{
    static const uint16_t short_ops[5] = {
        0, 0, X_GLrop_Vertex2sv, X_GLrop_Vertex3sv, X_GLrop_Vertex4sv
    };
    static const uint16_t int_ops[5] = {
        0, 0, X_GLrop_Vertex2iv, X_GLrop_Vertex3iv, X_GLrop_Vertex4iv
    };
    static const uint16_t float_ops[5] = {
        0, 0, X_GLrop_Vertex2fv, X_GLrop_Vertex3fv, X_GLrop_Vertex4fv
    };
    static const uint16_t double_ops[5] = {
        0, 0, X_GLrop_Vertex2dv, X_GLrop_Vertex3dv, X_GLrop_Vertex4dv
    };
    uint16_t opcode;
    __GLXcontext *gc = __glXGetCurrentContext();
    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
    struct array_state_vector * arrays = state->array_state;
    struct array_state * a;


    if (size < 2 || size > 4 || stride < 0) {
        __glXSetError(gc, GL_INVALID_VALUE);
        return;
    }
    
    switch ( type ) {
    case GL_SHORT:      opcode = short_ops[size]; break;
    case GL_INT:        opcode = int_ops[size]; break;
    case GL_FLOAT:      opcode = float_ops[size]; break;
    case GL_DOUBLE:     opcode = double_ops[size]; break;
    default:
        __glXSetError(gc, GL_INVALID_ENUM);
        return;
    }

    a = get_array_entry( arrays, GL_VERTEX_ARRAY, 0 );
    assert( a != NULL );
    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, 4, opcode );

    if ( a->enabled ) {
        arrays->array_info_cache_valid = GL_FALSE;
    }
}


void __indirect_glNormalPointer( GLenum type, GLsizei stride,
                                 const GLvoid * pointer )
{
    uint16_t opcode;
    __GLXcontext *gc = __glXGetCurrentContext();
    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
    struct array_state_vector * arrays = state->array_state;
    struct array_state * a;


    if (stride < 0) {
        __glXSetError(gc, GL_INVALID_VALUE);
        return;
    }
    
    switch ( type ) {
    case GL_BYTE:       opcode = X_GLrop_Normal3bv; break;
    case GL_SHORT:      opcode = X_GLrop_Normal3sv; break;
    case GL_INT:        opcode = X_GLrop_Normal3iv; break;
    case GL_FLOAT:      opcode = X_GLrop_Normal3fv; break;
    case GL_DOUBLE:     opcode = X_GLrop_Normal3dv; break;
    default:
        __glXSetError(gc, GL_INVALID_ENUM);
        return;
    }

    a = get_array_entry( arrays, GL_NORMAL_ARRAY, 0 );
    assert( a != NULL );
    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, 3, 4, opcode );

    if ( a->enabled ) {
        arrays->array_info_cache_valid = GL_FALSE;
    }
}


void __indirect_glColorPointer( GLint size, GLenum type, GLsizei stride,
                                const GLvoid * pointer )
{
    static const uint16_t byte_ops[5] = {
        0, 0, 0, X_GLrop_Color3bv, X_GLrop_Color4bv
    };
    static const uint16_t ubyte_ops[5] = {
        0, 0, 0, X_GLrop_Color3ubv, X_GLrop_Color4ubv
    };
    static const uint16_t short_ops[5] = {
        0, 0, 0, X_GLrop_Color3sv, X_GLrop_Color4sv
    };
    static const uint16_t ushort_ops[5] = {
        0, 0, 0, X_GLrop_Color3usv, X_GLrop_Color4usv
    };
    static const uint16_t int_ops[5] = {
        0, 0, 0, X_GLrop_Color3iv, X_GLrop_Color4iv
    };
    static const uint16_t uint_ops[5] = {
        0, 0, 0, X_GLrop_Color3uiv, X_GLrop_Color4uiv
    };
    static const uint16_t float_ops[5] = {
        0, 0, 0, X_GLrop_Color3fv, X_GLrop_Color4fv
    };
    static const uint16_t double_ops[5] = {
        0, 0, 0, X_GLrop_Color3dv, X_GLrop_Color4dv
    };
    uint16_t opcode;
    __GLXcontext *gc = __glXGetCurrentContext();
    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
    struct array_state_vector * arrays = state->array_state;
    struct array_state * a;


    if (size < 3 || size > 4 || stride < 0) {
        __glXSetError(gc, GL_INVALID_VALUE);
        return;
    }
    
    switch ( type ) {
    case GL_BYTE:               opcode = byte_ops[size]; break;
    case GL_UNSIGNED_BYTE:      opcode = ubyte_ops[size]; break;
    case GL_SHORT:              opcode = short_ops[size]; break;
    case GL_UNSIGNED_SHORT:     opcode = ushort_ops[size]; break;
    case GL_INT:                opcode = int_ops[size]; break;
    case GL_UNSIGNED_INT:       opcode = uint_ops[size]; break;
    case GL_FLOAT:              opcode = float_ops[size]; break;
    case GL_DOUBLE:             opcode = double_ops[size]; break;
    default:
        __glXSetError(gc, GL_INVALID_ENUM);
        return;
    }

    a = get_array_entry( arrays, GL_COLOR_ARRAY, 0 );
    assert( a != NULL );
    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, 4, opcode );

    if ( a->enabled ) {
        arrays->array_info_cache_valid = GL_FALSE;
    }
}


void __indirect_glIndexPointer( GLenum type, GLsizei stride,
                                const GLvoid * pointer )
{
    uint16_t opcode;
    __GLXcontext *gc = __glXGetCurrentContext();
    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
    struct array_state_vector * arrays = state->array_state;
    struct array_state * a;


    if (stride < 0) {
        __glXSetError(gc, GL_INVALID_VALUE);
        return;
    }
    
    switch ( type ) {
    case GL_UNSIGNED_BYTE:      opcode = X_GLrop_Indexubv; break;
    case GL_SHORT:              opcode = X_GLrop_Indexsv; break;
    case GL_INT:                opcode = X_GLrop_Indexiv; break;
    case GL_FLOAT:              opcode = X_GLrop_Indexfv; break;
    case GL_DOUBLE:             opcode = X_GLrop_Indexdv; break;
    default:
        __glXSetError(gc, GL_INVALID_ENUM);
        return;
    }

    a = get_array_entry( arrays, GL_INDEX_ARRAY, 0 );
    assert( a != NULL );
    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, 1, 4, opcode );

    if ( a->enabled ) {
        arrays->array_info_cache_valid = GL_FALSE;
    }
}


void __indirect_glEdgeFlagPointer( GLsizei stride, const GLvoid * pointer )
{
    __GLXcontext *gc = __glXGetCurrentContext();
    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
    struct array_state_vector * arrays = state->array_state;
    struct array_state * a;


    if (stride < 0) {
        __glXSetError(gc, GL_INVALID_VALUE);
        return;
    }
    

    a = get_array_entry( arrays, GL_EDGE_FLAG_ARRAY, 0 );
    assert( a != NULL );
    COMMON_ARRAY_DATA_INIT( a, pointer, GL_UNSIGNED_BYTE, stride, 1, 4, X_GLrop_EdgeFlagv );

    if ( a->enabled ) {
        arrays->array_info_cache_valid = GL_FALSE;
    }
}


void __indirect_glTexCoordPointer( GLint size, GLenum type, GLsizei stride,
                                   const GLvoid * pointer )
{
    static const uint16_t short_ops[5] = {
        0, X_GLrop_TexCoord1sv, X_GLrop_TexCoord2sv, X_GLrop_TexCoord3sv, X_GLrop_TexCoord4sv
    };
    static const uint16_t int_ops[5] = {
        0, X_GLrop_TexCoord1iv, X_GLrop_TexCoord2iv, X_GLrop_TexCoord3iv, X_GLrop_TexCoord4iv
    };
    static const uint16_t float_ops[5] = {
        0, X_GLrop_TexCoord1dv, X_GLrop_TexCoord2fv, X_GLrop_TexCoord3fv, X_GLrop_TexCoord4fv
    };
    static const uint16_t double_ops[5] = {
        0, X_GLrop_TexCoord1dv, X_GLrop_TexCoord2dv, X_GLrop_TexCoord3dv, X_GLrop_TexCoord4dv
    };

    static const uint16_t mshort_ops[5] = {
        0, X_GLrop_MultiTexCoord1svARB, X_GLrop_MultiTexCoord2svARB, X_GLrop_MultiTexCoord3svARB, X_GLrop_MultiTexCoord4svARB
    };
    static const uint16_t mint_ops[5] = {
        0, X_GLrop_MultiTexCoord1ivARB, X_GLrop_MultiTexCoord2ivARB, X_GLrop_MultiTexCoord3ivARB, X_GLrop_MultiTexCoord4ivARB
    };
    static const uint16_t mfloat_ops[5] = {
        0, X_GLrop_MultiTexCoord1dvARB, X_GLrop_MultiTexCoord2fvARB, X_GLrop_MultiTexCoord3fvARB, X_GLrop_MultiTexCoord4fvARB
    };
    static const uint16_t mdouble_ops[5] = {
        0, X_GLrop_MultiTexCoord1dvARB, X_GLrop_MultiTexCoord2dvARB, X_GLrop_MultiTexCoord3dvARB, X_GLrop_MultiTexCoord4dvARB
    };

    uint16_t opcode;
    __GLXcontext *gc = __glXGetCurrentContext();
    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
    struct array_state_vector * arrays = state->array_state;
    struct array_state * a;
    unsigned header_size;
    unsigned index;


    if (size < 1 || size > 4 || stride < 0) {
        __glXSetError(gc, GL_INVALID_VALUE);
        return;
    }
    
    index = arrays->active_texture_unit;
    if ( index == 0 ) {
        switch ( type ) {
        case GL_SHORT:          opcode = short_ops[size]; break;
        case GL_INT:            opcode = int_ops[size]; break;
        case GL_FLOAT:          opcode = float_ops[size]; break;
        case GL_DOUBLE:         opcode = double_ops[size]; break;
        default:
            __glXSetError(gc, GL_INVALID_ENUM);
            return;
        }

        header_size = 4;
    }
    else {
        switch ( type ) {
        case GL_SHORT:          opcode = mshort_ops[size]; break;
        case GL_INT:            opcode = mint_ops[size]; break;
        case GL_FLOAT:          opcode = mfloat_ops[size]; break;
        case GL_DOUBLE:         opcode = mdouble_ops[size]; break;
        default:
            __glXSetError(gc, GL_INVALID_ENUM);
            return;
        }

        header_size = 8;
    }

    a = get_array_entry( arrays, GL_TEXTURE_COORD_ARRAY, index );
    assert( a != NULL );
    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, header_size, opcode );

    if ( a->enabled ) {
        arrays->array_info_cache_valid = GL_FALSE;
    }
}


void __indirect_glSecondaryColorPointerEXT( GLint size, GLenum type, GLsizei stride,
                                const GLvoid * pointer )
{
    uint16_t opcode;
    __GLXcontext *gc = __glXGetCurrentContext();
    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
    struct array_state_vector * arrays = state->array_state;
    struct array_state * a;


    if (size != 3 || stride < 0) {
        __glXSetError(gc, GL_INVALID_VALUE);
        return;
    }
    
    switch ( type ) {
    case GL_BYTE:               opcode = 4126; break;
    case GL_UNSIGNED_BYTE:      opcode = 4131; break;
    case GL_SHORT:              opcode = 4127; break;
    case GL_UNSIGNED_SHORT:     opcode = 4132; break;
    case GL_INT:                opcode = 4128; break;
    case GL_UNSIGNED_INT:       opcode = 4133; break;
    case GL_FLOAT:              opcode = 4129; break;
    case GL_DOUBLE:             opcode = 4130; break;
    default:
        __glXSetError(gc, GL_INVALID_ENUM);
        return;
    }

    a = get_array_entry( arrays, GL_SECONDARY_COLOR_ARRAY, 0 );
    if ( a == NULL ) {
        __glXSetError(gc, GL_INVALID_OPERATION);
        return;
    }

    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, 4, opcode );

    if ( a->enabled ) {
        arrays->array_info_cache_valid = GL_FALSE;
    }
}


void __indirect_glFogCoordPointerEXT( GLenum type, GLsizei stride,
                                const GLvoid * pointer )
{
    uint16_t opcode;
    __GLXcontext *gc = __glXGetCurrentContext();
    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
    struct array_state_vector * arrays = state->array_state;
    struct array_state * a;


    if (stride < 0) {
        __glXSetError(gc, GL_INVALID_VALUE);
        return;
    }
    
    switch ( type ) {
    case GL_FLOAT:              opcode = 4124; break;
    case GL_DOUBLE:             opcode = 4125; break;
    default:
        __glXSetError(gc, GL_INVALID_ENUM);
        return;
    }

    a = get_array_entry( arrays, GL_FOG_COORD_ARRAY, 0 );
    if ( a == NULL ) {
        __glXSetError(gc, GL_INVALID_OPERATION);
        return;
    }

    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, 1, 4, opcode );

    if ( a->enabled ) {
        arrays->array_info_cache_valid = GL_FALSE;
    }
}


void __indirect_glClientActiveTextureARB(GLenum texture)
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    __GLXattribute * const state = (__GLXattribute *)(gc->client_state_private);
    struct array_state_vector * const arrays = state->array_state;
    const GLint unit = (GLint) texture - GL_TEXTURE0;


    if ( (unit < 0) || (unit > arrays->num_texture_units) ) {
        __glXSetError(gc, GL_INVALID_ENUM);
        return;
    }

    arrays->active_texture_unit = unit;
}


/**
 */
GLboolean
__glXSetArrayEnable( __GLXattribute * state,
                     GLenum key, unsigned index, GLboolean enable )
{
    struct array_state_vector * arrays = state->array_state;
    struct array_state * a;
    

    if ( key == GL_TEXTURE_COORD_ARRAY ) {
        index = arrays->active_texture_unit;
    }

    a = get_array_entry( arrays, key, index );

    if ( (a != NULL) && (a->enabled != enable) ) {
        a->enabled = enable;
        arrays->array_info_cache_valid = GL_FALSE;
    }

    return (a != NULL);
}


void
__glXArrayDisableAll( __GLXattribute * state )
{
    struct array_state_vector * arrays = state->array_state;
    unsigned  i;


    for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
        arrays->arrays[i].enabled = GL_FALSE;
    }

    arrays->array_info_cache_valid = GL_FALSE;
}


/**
 */
GLboolean
__glXGetArrayEnable( const __GLXattribute * const state,
                     GLenum key, unsigned index, GLintptr * dest )
{
    const struct array_state_vector * arrays = state->array_state;
    const struct array_state * a = get_array_entry( (struct array_state_vector *) arrays,
                                                    key, index );

    if ( a != NULL ) {
        *dest = (GLintptr) a->enabled;
    }

    return (a != NULL);
}


/**
 */
GLboolean
__glXGetArrayType( const __GLXattribute * const state,
                     GLenum key, unsigned index, GLintptr * dest )
{
    const struct array_state_vector * arrays = state->array_state;
    const struct array_state * a = get_array_entry( (struct array_state_vector *) arrays,
                                                    key, index );

    if ( a != NULL ) {
        *dest = (GLintptr) a->enabled;
    }

    return (a != NULL);
}


/**
 */
GLboolean
__glXGetArraySize( const __GLXattribute * const state,
                     GLenum key, unsigned index, GLintptr * dest )
{
    const struct array_state_vector * arrays = state->array_state;
    const struct array_state * a = get_array_entry( (struct array_state_vector *) arrays,
                                                    key, index );

    if ( a != NULL ) {
        *dest = (GLintptr) a->count;
    }

    return (a != NULL);
}


/**
 */
GLboolean
__glXGetArrayStride( const __GLXattribute * const state,
                     GLenum key, unsigned index, GLintptr * dest )
{
    const struct array_state_vector * arrays = state->array_state;
    const struct array_state * a = get_array_entry( (struct array_state_vector *) arrays,
                                                    key, index );

    if ( a != NULL ) {
        *dest = (GLintptr) a->user_stride;
    }

    return (a != NULL);
}


/**
 */
GLboolean
__glXGetArrayPointer( const __GLXattribute * const state,
                      GLenum key, unsigned index, void ** dest )
{
    const struct array_state_vector * arrays = state->array_state;
    const struct array_state * a = get_array_entry( (struct array_state_vector *) arrays,
                                                    key, index );


    if ( a != NULL ) {
        *dest = a->data;
    }

    return (a != NULL);
}


/**
 */
GLuint
__glXGetActiveTextureUnit( const __GLXattribute * const state )
{
    return state->array_state->active_texture_unit;
}


void
__glXPushArrayState( __GLXattribute * state )
{
    struct array_state_vector * arrays = state->array_state;
    struct array_stack_state * stack = & arrays->stack[ (arrays->stack_index * arrays->num_arrays)];
    unsigned  i;


    for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
        stack[i].data = arrays->arrays[i].data;
        stack[i].data_type = arrays->arrays[i].data_type;
        stack[i].user_stride = arrays->arrays[i].user_stride;
        stack[i].count = arrays->arrays[i].count;
        stack[i].key = arrays->arrays[i].key;
        stack[i].enabled = arrays->arrays[i].enabled;
    }

    arrays->active_texture_unit_stack[ arrays->stack_index ] =
      arrays->active_texture_unit;

    arrays->stack_index++;
}


void
__glXPopArrayState( __GLXattribute * state )
{
    struct array_state_vector * arrays = state->array_state;
    struct array_stack_state * stack;
    unsigned  i;


    arrays->stack_index--;
    stack = & arrays->stack[ (arrays->stack_index * arrays->num_arrays) ];

    for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
        switch ( stack[i].key ) {
        case GL_NORMAL_ARRAY:
            __indirect_glNormalPointer( stack[i].data_type,
                                        stack[i].user_stride,
                                        stack[i].data );
            break;
        case GL_COLOR_ARRAY:
            __indirect_glColorPointer( stack[i].count,
                                       stack[i].data_type,
                                       stack[i].user_stride,
                                       stack[i].data );
            break;
        case GL_INDEX_ARRAY:
            __indirect_glIndexPointer( stack[i].data_type,
                                       stack[i].user_stride,
                                       stack[i].data );
            break;
        case GL_EDGE_FLAG_ARRAY:
            __indirect_glEdgeFlagPointer( stack[i].user_stride,
                                          stack[i].data );
            break;
        case GL_TEXTURE_COORD_ARRAY:
            arrays->active_texture_unit = stack[i].index;
            __indirect_glTexCoordPointer( stack[i].count,
                                          stack[i].data_type,
                                          stack[i].user_stride,
                                          stack[i].data );
            break;
        case GL_SECONDARY_COLOR_ARRAY:
            __indirect_glSecondaryColorPointerEXT( stack[i].count,
                                                   stack[i].data_type,
                                                   stack[i].user_stride,
                                                   stack[i].data );
            break;
        case GL_FOG_COORDINATE_ARRAY:
            __indirect_glFogCoordPointerEXT( stack[i].data_type,
                                             stack[i].user_stride,
                                             stack[i].data );
            break;

        }
        
        __glXSetArrayEnable( state, stack[i].key, stack[i].index,
                             stack[i].enabled );
    }

    arrays->active_texture_unit = arrays->active_texture_unit_stack[ arrays->stack_index ];
}