Subversion Repositories Kolibri OS

/*

 * (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 

#include 

#include 

#include "glxclient.h"

#include "indirect.h"

#include 

#include "glxextensions.h"

#include "indirect_vertex_array.h"

#include "indirect_vertex_array_priv.h"

#define __GLX_PAD(n) (((n)+3) & ~3)

/**

 * \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 

 */

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 validate_mode(struct glx_context * gc, GLenum mode);

static GLboolean validate_count(struct glx_context * gc, GLsizei count);

static GLboolean validate_type(struct glx_context * gc, GLenum type);

/**

 * 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

};

/**

 * Free the per-context array state that was allocated with

 * __glXInitVertexArrayState().

 */

void

__glXFreeVertexArrayState(struct glx_context * gc)

{

   __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);

   struct array_state_vector *arrays = state->array_state;

   if (arrays) {

      free(arrays->stack);

      arrays->stack = NULL;

      free(arrays->arrays);

      arrays->arrays = NULL;

      free(arrays);

      state->array_state = NULL;

   }

}

/**

 * 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 struct glx_context::gl_extension_bits,

 * struct glx_context::server_minor, and __GLXcontext::server_major have been

 * initialized.  These values are used to determine what vertex arrays are

 * supported.

 */

void

__glXInitVertexArrayState(struct glx_context * gc)

{

   __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);

   struct array_state_vector *arrays;

   unsigned array_count;

   int texture_units = 1, vertex_program_attribs = 0;

   unsigned i, j;

   GLboolean got_fog = GL_FALSE;

   GLboolean got_secondary_color = GL_FALSE;

   arrays = calloc(1, sizeof(struct array_state_vector));

   if (arrays == NULL) {

      __glXSetError(gc, GL_OUT_OF_MEMORY);

      return;

   }

   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)) {

      __indirect_glGetIntegerv(GL_MAX_TEXTURE_UNITS, &texture_units);

   }

   if (__glExtensionBitIsEnabled(gc, GL_ARB_vertex_program_bit)) {

      __indirect_glGetProgramivARB(GL_VERTEX_PROGRAM_ARB,

                                   GL_MAX_PROGRAM_ATTRIBS_ARB,

                                   &vertex_program_attribs);

   }

   arrays->num_texture_units = texture_units;

   arrays->num_vertex_program_attribs = vertex_program_attribs;

   array_count += texture_units + vertex_program_attribs;

   arrays->num_arrays = array_count;

   arrays->arrays = calloc(array_count, sizeof(struct array_state));

   if (arrays->arrays == NULL) {

      free(arrays);

      __glXSetError(gc, GL_OUT_OF_MEMORY);

      return;

   }

   arrays->arrays[0].data_type = GL_FLOAT;

   arrays->arrays[0].count = 3;

   arrays->arrays[0].key = GL_NORMAL_ARRAY;

   arrays->arrays[0].normalized = GL_TRUE;

   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].normalized = GL_TRUE;

   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;

      arrays->arrays[i].normalized = GL_TRUE;

      i++;

   }

   for (j = 0; j < vertex_program_attribs; j++) {

      const unsigned idx = (vertex_program_attribs - (j + 1));

      arrays->arrays[idx + i].data_type = GL_FLOAT;

      arrays->arrays[idx + i].count = 4;

      arrays->arrays[idx + i].key = GL_VERTEX_ATTRIB_ARRAY_POINTER;

      arrays->arrays[idx + i].old_DrawArrays_possible = 0;

      arrays->arrays[idx + i].index = idx;

      arrays->arrays[idx + i].header[1] = idx;

   }

   i += vertex_program_attribs;

   /* Vertex array *must* be last because 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;

   assert((i + 1) == arrays->num_arrays);

   arrays->stack_index = 0;

   arrays->stack = malloc(sizeof(struct array_stack_state)

                          * arrays->num_arrays

                          * __GL_CLIENT_ATTRIB_STACK_DEPTH);

   if (arrays->stack == NULL) {

      free(arrays->arrays);

      free(arrays);

      __glXSetError(gc, GL_OUT_OF_MEMORY);

      return;

   }

   /* Everything went ok so we put vertex array state in place

    * in context.

    */

   state->array_state = 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 += ((uint16_t *) arrays->arrays[i].header)[0];

      }

   }

   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;

         /* The generic attributes can have more data than is in the

          * elements.  This is because a vertex array can be a 2 element,

          * normalized, unsigned short, but the "closest" immediate mode

          * protocol is for a 4Nus.  Since the sizes are small, the

          * performance impact on modern processors should be negligible.

          */

         (void) memset(dst, 0, ((uint16_t *) arrays->arrays[i].header)[0]);

         (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)

{

#define MAX_HEADER_SIZE 20

   if (arrays->array_info_cache_buffer_size < required_size) {

      GLubyte *temp = realloc(arrays->array_info_cache_base,

                              required_size + MAX_HEADER_SIZE);

      if (temp == NULL) {

         return GL_FALSE;

      }

      arrays->array_info_cache_base = temp;

      arrays->array_info_cache = temp + MAX_HEADER_SIZE;

      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_client_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_client_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_client_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->DrawArrays = emit_DrawArrays_old;

      arrays->DrawElements = emit_DrawElements_old;

   }

   else {

      arrays->DrawArrays = emit_DrawArrays_none;

      arrays->DrawElements = emit_DrawElements_none;

   }

   arrays->array_info_cache_valid = GL_TRUE;

}

/**

 * 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)

{

   struct glx_context *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, pc);

      }

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

   }

   if ((pc + 4) >= gc->bufEnd) {

      pc = __glXFlushRenderBuffer(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(struct glx_context * gc,

                           struct array_state_vector *arrays,

                           size_t * elements_per_request,

                           unsigned int *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 = ((GLubyte *) arrays->array_info_cache) - (header_size + 4);

      *(uint32_t *) (pc + 0) = command_size;

      *(uint32_t *) (pc + 4) = X_GLrop_DrawArrays;

      *(uint32_t *) (pc + 8) = count;

      *(uint32_t *) (pc + 12) = arrays->enabled_client_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_client_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)

{

   struct glx_context *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)

{

   struct glx_context *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 = 0;

      if ((pc + single_vertex_size) >= gc->bufEnd) {

         pc = __glXFlushRenderBuffer(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, 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)

{

   struct glx_context *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;

   unsigned req_element = 0;

   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:{

            const GLuint *ui_ptr = (const GLuint *) indices + req_element;

            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:{

            const GLushort *us_ptr = (const GLushort *) indices + req_element;

            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:{

            const GLubyte *ub_ptr = (const GLubyte *) indices + req_element;

            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;

      req_element += 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(struct glx_context * 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(struct glx_context * gc, GLsizei count)

{

   if (count < 0) {

      __glXSetError(gc, GL_INVALID_VALUE);

   }

   return (count > 0);

}

/**

 * Validate that the \c type parameter to \c glDrawElements, et. al. is

 * valid.  Only \c GL_UNSIGNED_BYTE, \c GL_UNSIGNED_SHORT, and

 * \c GL_UNSIGNED_INT are valid.

 *

 * \returns

 * \c GL_TRUE if the argument is valid, \c GL_FALSE if it is not.

 */

static GLboolean

validate_type(struct glx_context * gc, GLenum type)

{

   switch (type) {

   case GL_UNSIGNED_INT:

   case GL_UNSIGNED_SHORT:

   case GL_UNSIGNED_BYTE:

      return GL_TRUE;

   default:

      __glXSetError(gc, GL_INVALID_ENUM);

      return GL_FALSE;

   }

}

void

__indirect_glDrawArrays(GLenum mode, GLint first, GLsizei count)

{

   struct glx_context *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)

{

   struct glx_context *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)

{

   struct glx_context *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)

       && validate_type(gc, type)) {

      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)

{

   struct glx_context *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)

       && validate_type(gc, type)) {

      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_glMultiDrawArrays(GLenum mode, const GLint *first,

                                const GLsizei *count, GLsizei primcount)

{

   struct glx_context *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 * const * indices,

                                  GLsizei primcount)

{

   struct glx_context *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) && validate_type(gc, type)) {

      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, NORMALIZED, HDR_SIZE, OPCODE) \

  do {                                                                  \

    (a)->data = PTR;                                                    \

    (a)->data_type = TYPE;                                              \

    (a)->user_stride = STRIDE;                                          \

    (a)->count = COUNT;                                                 \

    (a)->normalized = NORMALIZED;                                       \

                                                                        \

    (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

   };