1/*
2 * (C) Copyright IBM Corporation 2004, 2005
3 * All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sub license,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
14 * Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
19 * IBM,
20 * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
22 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 * SOFTWARE.
24 */
25
26#include <inttypes.h>
27#include <assert.h>
28#include <string.h>
29
30#include "glxclient.h"
31#include "indirect.h"
32#include <GL/glxproto.h>
33#include "glxextensions.h"
34#include "indirect_vertex_array.h"
35#include "indirect_vertex_array_priv.h"
36
37#define __GLX_PAD(n) (((n)+3) & ~3)
38
39/**
40 * \file indirect_vertex_array.c
41 * Implement GLX protocol for vertex arrays and vertex buffer objects.
42 *
43 * The most important function in this fill is \c fill_array_info_cache.
44 * The \c array_state_vector contains a cache of the ARRAY_INFO data sent
45 * in the DrawArrays protocol.  Certain operations, such as enabling or
46 * disabling an array, can invalidate this cache.  \c fill_array_info_cache
47 * fills-in this data.  Additionally, it examines the enabled state and
48 * other factors to determine what "version" of DrawArrays protocoal can be
49 * used.
50 *
51 * Current, only two versions of DrawArrays protocol are implemented.  The
52 * first version is the "none" protocol.  This is the fallback when the
53 * server does not support GL 1.1 / EXT_vertex_arrays.  It is implemented
54 * by sending batches of immediate mode commands that are equivalent to the
55 * DrawArrays protocol.
56 *
57 * The other protocol that is currently implemented is the "old" protocol.
58 * This is the GL 1.1 DrawArrays protocol.  The only difference between GL
59 * 1.1 and EXT_vertex_arrays is the opcode used for the DrawArrays command.
60 * This protocol is called "old" because the ARB is in the process of
61 * defining a new protocol, which will probably be called wither "new" or
62 * "vbo", to support multiple texture coordinate arrays, generic attributes,
63 * and vertex buffer objects.
64 *
65 * \author Ian Romanick <ian.d.romanick@intel.com>
66 */
67
68static void emit_DrawArrays_none(GLenum mode, GLint first, GLsizei count);
69static void emit_DrawArrays_old(GLenum mode, GLint first, GLsizei count);
70
71static void emit_DrawElements_none(GLenum mode, GLsizei count, GLenum type,
72                                   const GLvoid * indices);
73static void emit_DrawElements_old(GLenum mode, GLsizei count, GLenum type,
74                                  const GLvoid * indices);
75
76
77static GLubyte *emit_element_none(GLubyte * dst,
78                                  const struct array_state_vector *arrays,
79                                  unsigned index);
80static GLubyte *emit_element_old(GLubyte * dst,
81                                 const struct array_state_vector *arrays,
82                                 unsigned index);
83static struct array_state *get_array_entry(const struct array_state_vector
84                                           *arrays, GLenum key,
85                                           unsigned index);
86static void fill_array_info_cache(struct array_state_vector *arrays);
87static GLboolean validate_mode(struct glx_context * gc, GLenum mode);
88static GLboolean validate_count(struct glx_context * gc, GLsizei count);
89static GLboolean validate_type(struct glx_context * gc, GLenum type);
90
91
92/**
93 * Table of sizes, in bytes, of a GL types.  All of the type enums are be in
94 * the range 0x1400 - 0x140F.  That includes types added by extensions (i.e.,
95 * \c GL_HALF_FLOAT_NV).  This elements of this table correspond to the
96 * type enums masked with 0x0f.
97 *
98 * \notes
99 * \c GL_HALF_FLOAT_NV is not included.  Neither are \c GL_2_BYTES,
100 * \c GL_3_BYTES, or \c GL_4_BYTES.
101 */
102const GLuint __glXTypeSize_table[16] = {
103   1, 1, 2, 2, 4, 4, 4, 0, 0, 0, 8, 0, 0, 0, 0, 0
104};
105
106
107/**
108 * Free the per-context array state that was allocated with
109 * __glXInitVertexArrayState().
110 */
111void
112__glXFreeVertexArrayState(struct glx_context * gc)
113{
114   __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
115   struct array_state_vector *arrays = state->array_state;
116
117   if (arrays) {
118      if (arrays->stack) {
119         free(arrays->stack);
120         arrays->stack = NULL;
121      }
122      if (arrays->arrays) {
123         free(arrays->arrays);
124         arrays->arrays = NULL;
125      }
126      free(arrays);
127      state->array_state = NULL;
128   }
129}
130
131
132/**
133 * Initialize vertex array state of a GLX context.
134 *
135 * \param gc  GLX context whose vertex array state is to be initialized.
136 *
137 * \warning
138 * This function may only be called after struct glx_context::gl_extension_bits,
139 * struct glx_context::server_minor, and __GLXcontext::server_major have been
140 * initialized.  These values are used to determine what vertex arrays are
141 * supported.
142 *
143 * \bug
144 * Return values from malloc are not properly tested.
145 */
146void
147__glXInitVertexArrayState(struct glx_context * gc)
148{
149   __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
150   struct array_state_vector *arrays;
151
152   unsigned array_count;
153   int texture_units = 1, vertex_program_attribs = 0;
154   unsigned i, j;
155
156   GLboolean got_fog = GL_FALSE;
157   GLboolean got_secondary_color = GL_FALSE;
158
159
160   arrays = calloc(1, sizeof(struct array_state_vector));
161   state->array_state = arrays;
162
163   arrays->old_DrawArrays_possible = !state->NoDrawArraysProtocol;
164   arrays->new_DrawArrays_possible = GL_FALSE;
165   arrays->DrawArrays = NULL;
166
167   arrays->active_texture_unit = 0;
168
169
170   /* Determine how many arrays are actually needed.  Only arrays that
171    * are supported by the server are create.  For example, if the server
172    * supports only 2 texture units, then only 2 texture coordinate arrays
173    * are created.
174    *
175    * At the very least, GL_VERTEX_ARRAY, GL_NORMAL_ARRAY,
176    * GL_COLOR_ARRAY, GL_INDEX_ARRAY, GL_TEXTURE_COORD_ARRAY, and
177    * GL_EDGE_FLAG_ARRAY are supported.
178    */
179
180   array_count = 5;
181
182   if (__glExtensionBitIsEnabled(gc, GL_EXT_fog_coord_bit)
183       || (gc->server_major > 1) || (gc->server_minor >= 4)) {
184      got_fog = GL_TRUE;
185      array_count++;
186   }
187
188   if (__glExtensionBitIsEnabled(gc, GL_EXT_secondary_color_bit)
189       || (gc->server_major > 1) || (gc->server_minor >= 4)) {
190      got_secondary_color = GL_TRUE;
191      array_count++;
192   }
193
194   if (__glExtensionBitIsEnabled(gc, GL_ARB_multitexture_bit)
195       || (gc->server_major > 1) || (gc->server_minor >= 3)) {
196      __indirect_glGetIntegerv(GL_MAX_TEXTURE_UNITS, &texture_units);
197   }
198
199   if (__glExtensionBitIsEnabled(gc, GL_ARB_vertex_program_bit)) {
200      __indirect_glGetProgramivARB(GL_VERTEX_PROGRAM_ARB,
201                                   GL_MAX_PROGRAM_ATTRIBS_ARB,
202                                   &vertex_program_attribs);
203   }
204
205   arrays->num_texture_units = texture_units;
206   arrays->num_vertex_program_attribs = vertex_program_attribs;
207   array_count += texture_units + vertex_program_attribs;
208   arrays->num_arrays = array_count;
209   arrays->arrays = calloc(array_count, sizeof(struct array_state));
210
211   arrays->arrays[0].data_type = GL_FLOAT;
212   arrays->arrays[0].count = 3;
213   arrays->arrays[0].key = GL_NORMAL_ARRAY;
214   arrays->arrays[0].normalized = GL_TRUE;
215   arrays->arrays[0].old_DrawArrays_possible = GL_TRUE;
216
217   arrays->arrays[1].data_type = GL_FLOAT;
218   arrays->arrays[1].count = 4;
219   arrays->arrays[1].key = GL_COLOR_ARRAY;
220   arrays->arrays[1].normalized = GL_TRUE;
221   arrays->arrays[1].old_DrawArrays_possible = GL_TRUE;
222
223   arrays->arrays[2].data_type = GL_FLOAT;
224   arrays->arrays[2].count = 1;
225   arrays->arrays[2].key = GL_INDEX_ARRAY;
226   arrays->arrays[2].old_DrawArrays_possible = GL_TRUE;
227
228   arrays->arrays[3].data_type = GL_UNSIGNED_BYTE;
229   arrays->arrays[3].count = 1;
230   arrays->arrays[3].key = GL_EDGE_FLAG_ARRAY;
231   arrays->arrays[3].old_DrawArrays_possible = GL_TRUE;
232
233   for (i = 0; i < texture_units; i++) {
234      arrays->arrays[4 + i].data_type = GL_FLOAT;
235      arrays->arrays[4 + i].count = 4;
236      arrays->arrays[4 + i].key = GL_TEXTURE_COORD_ARRAY;
237
238      arrays->arrays[4 + i].old_DrawArrays_possible = (i == 0);
239      arrays->arrays[4 + i].index = i;
240
241      arrays->arrays[4 + i].header[1] = i + GL_TEXTURE0;
242   }
243
244   i = 4 + texture_units;
245
246   if (got_fog) {
247      arrays->arrays[i].data_type = GL_FLOAT;
248      arrays->arrays[i].count = 1;
249      arrays->arrays[i].key = GL_FOG_COORDINATE_ARRAY;
250      arrays->arrays[i].old_DrawArrays_possible = GL_TRUE;
251      i++;
252   }
253
254   if (got_secondary_color) {
255      arrays->arrays[i].data_type = GL_FLOAT;
256      arrays->arrays[i].count = 3;
257      arrays->arrays[i].key = GL_SECONDARY_COLOR_ARRAY;
258      arrays->arrays[i].old_DrawArrays_possible = GL_TRUE;
259      arrays->arrays[i].normalized = GL_TRUE;
260      i++;
261   }
262
263
264   for (j = 0; j < vertex_program_attribs; j++) {
265      const unsigned idx = (vertex_program_attribs - (j + 1));
266
267
268      arrays->arrays[idx + i].data_type = GL_FLOAT;
269      arrays->arrays[idx + i].count = 4;
270      arrays->arrays[idx + i].key = GL_VERTEX_ATTRIB_ARRAY_POINTER;
271
272      arrays->arrays[idx + i].old_DrawArrays_possible = 0;
273      arrays->arrays[idx + i].index = idx;
274
275      arrays->arrays[idx + i].header[1] = idx;
276   }
277
278   i += vertex_program_attribs;
279
280
281   /* Vertex array *must* be last becuase of the way that
282    * emit_DrawArrays_none works.
283    */
284
285   arrays->arrays[i].data_type = GL_FLOAT;
286   arrays->arrays[i].count = 4;
287   arrays->arrays[i].key = GL_VERTEX_ARRAY;
288   arrays->arrays[i].old_DrawArrays_possible = GL_TRUE;
289
290   assert((i + 1) == arrays->num_arrays);
291
292   arrays->stack_index = 0;
293   arrays->stack = malloc(sizeof(struct array_stack_state)
294                          * arrays->num_arrays
295                          * __GL_CLIENT_ATTRIB_STACK_DEPTH);
296}
297
298
299/**
300 * Calculate the size of a single vertex for the "none" protocol.  This is
301 * essentially the size of all the immediate-mode commands required to
302 * implement the enabled vertex arrays.
303 */
304static size_t
305calculate_single_vertex_size_none(const struct array_state_vector *arrays)
306{
307   size_t single_vertex_size = 0;
308   unsigned i;
309
310
311   for (i = 0; i < arrays->num_arrays; i++) {
312      if (arrays->arrays[i].enabled) {
313         single_vertex_size += ((uint16_t *) arrays->arrays[i].header)[0];
314      }
315   }
316
317   return single_vertex_size;
318}
319
320
321/**
322 * Emit a single element using non-DrawArrays protocol.
323 */
324GLubyte *
325emit_element_none(GLubyte * dst,
326                  const struct array_state_vector * arrays, unsigned index)
327{
328   unsigned i;
329
330
331   for (i = 0; i < arrays->num_arrays; i++) {
332      if (arrays->arrays[i].enabled) {
333         const size_t offset = index * arrays->arrays[i].true_stride;
334
335         /* The generic attributes can have more data than is in the
336          * elements.  This is because a vertex array can be a 2 element,
337          * normalized, unsigned short, but the "closest" immediate mode
338          * protocol is for a 4Nus.  Since the sizes are small, the
339          * performance impact on modern processors should be negligible.
340          */
341         (void) memset(dst, 0, ((uint16_t *) arrays->arrays[i].header)[0]);
342
343         (void) memcpy(dst, arrays->arrays[i].header,
344                       arrays->arrays[i].header_size);
345
346         dst += arrays->arrays[i].header_size;
347
348         (void) memcpy(dst, ((GLubyte *) arrays->arrays[i].data) + offset,
349                       arrays->arrays[i].element_size);
350
351         dst += __GLX_PAD(arrays->arrays[i].element_size);
352      }
353   }
354
355   return dst;
356}
357
358
359/**
360 * Emit a single element using "old" DrawArrays protocol from
361 * EXT_vertex_arrays / OpenGL 1.1.
362 */
363GLubyte *
364emit_element_old(GLubyte * dst,
365                 const struct array_state_vector * arrays, unsigned index)
366{
367   unsigned i;
368
369
370   for (i = 0; i < arrays->num_arrays; i++) {
371      if (arrays->arrays[i].enabled) {
372         const size_t offset = index * arrays->arrays[i].true_stride;
373
374         (void) memcpy(dst, ((GLubyte *) arrays->arrays[i].data) + offset,
375                       arrays->arrays[i].element_size);
376
377         dst += __GLX_PAD(arrays->arrays[i].element_size);
378      }
379   }
380
381   return dst;
382}
383
384
385struct array_state *
386get_array_entry(const struct array_state_vector *arrays,
387                GLenum key, unsigned index)
388{
389   unsigned i;
390
391   for (i = 0; i < arrays->num_arrays; i++) {
392      if ((arrays->arrays[i].key == key)
393          && (arrays->arrays[i].index == index)) {
394         return &arrays->arrays[i];
395      }
396   }
397
398   return NULL;
399}
400
401
402static GLboolean
403allocate_array_info_cache(struct array_state_vector *arrays,
404                          size_t required_size)
405{
406#define MAX_HEADER_SIZE 20
407   if (arrays->array_info_cache_buffer_size < required_size) {
408      GLubyte *temp = realloc(arrays->array_info_cache_base,
409                              required_size + MAX_HEADER_SIZE);
410
411      if (temp == NULL) {
412         return GL_FALSE;
413      }
414
415      arrays->array_info_cache_base = temp;
416      arrays->array_info_cache = temp + MAX_HEADER_SIZE;
417      arrays->array_info_cache_buffer_size = required_size;
418   }
419
420   arrays->array_info_cache_size = required_size;
421   return GL_TRUE;
422}
423
424
425/**
426 */
427void
428fill_array_info_cache(struct array_state_vector *arrays)
429{
430   GLboolean old_DrawArrays_possible;
431   unsigned i;
432
433
434   /* Determine how many arrays are enabled.
435    */
436
437   arrays->enabled_client_array_count = 0;
438   old_DrawArrays_possible = arrays->old_DrawArrays_possible;
439   for (i = 0; i < arrays->num_arrays; i++) {
440      if (arrays->arrays[i].enabled) {
441         arrays->enabled_client_array_count++;
442         old_DrawArrays_possible &= arrays->arrays[i].old_DrawArrays_possible;
443      }
444   }
445
446   if (arrays->new_DrawArrays_possible) {
447      assert(!arrays->new_DrawArrays_possible);
448   }
449   else if (old_DrawArrays_possible) {
450      const size_t required_size = arrays->enabled_client_array_count * 12;
451      uint32_t *info;
452
453
454      if (!allocate_array_info_cache(arrays, required_size)) {
455         return;
456      }
457
458
459      info = (uint32_t *) arrays->array_info_cache;
460      for (i = 0; i < arrays->num_arrays; i++) {
461         if (arrays->arrays[i].enabled) {
462            *(info++) = arrays->arrays[i].data_type;
463            *(info++) = arrays->arrays[i].count;
464            *(info++) = arrays->arrays[i].key;
465         }
466      }
467
468      arrays->DrawArrays = emit_DrawArrays_old;
469      arrays->DrawElements = emit_DrawElements_old;
470   }
471   else {
472      arrays->DrawArrays = emit_DrawArrays_none;
473      arrays->DrawElements = emit_DrawElements_none;
474   }
475
476   arrays->array_info_cache_valid = GL_TRUE;
477}
478
479
480/**
481 * Emit a \c glDrawArrays command using the "none" protocol.  That is,
482 * emit immediate-mode commands that are equivalent to the requiested
483 * \c glDrawArrays command.  This is used with servers that don't support
484 * the OpenGL 1.1 / EXT_vertex_arrays DrawArrays protocol or in cases where
485 * vertex state is enabled that is not compatible with that protocol.
486 */
487void
488emit_DrawArrays_none(GLenum mode, GLint first, GLsizei count)
489{
490   struct glx_context *gc = __glXGetCurrentContext();
491   const __GLXattribute *state =
492      (const __GLXattribute *) (gc->client_state_private);
493   struct array_state_vector *arrays = state->array_state;
494
495   size_t single_vertex_size;
496   GLubyte *pc;
497   unsigned i;
498   static const uint16_t begin_cmd[2] = { 8, X_GLrop_Begin };
499   static const uint16_t end_cmd[2] = { 4, X_GLrop_End };
500
501
502   single_vertex_size = calculate_single_vertex_size_none(arrays);
503
504   pc = gc->pc;
505
506   (void) memcpy(pc, begin_cmd, 4);
507   *(int *) (pc + 4) = mode;
508
509   pc += 8;
510
511   for (i = 0; i < count; i++) {
512      if ((pc + single_vertex_size) >= gc->bufEnd) {
513         pc = __glXFlushRenderBuffer(gc, pc);
514      }
515
516      pc = emit_element_none(pc, arrays, first + i);
517   }
518
519   if ((pc + 4) >= gc->bufEnd) {
520      pc = __glXFlushRenderBuffer(gc, pc);
521   }
522
523   (void) memcpy(pc, end_cmd, 4);
524   pc += 4;
525
526   gc->pc = pc;
527   if (gc->pc > gc->limit) {
528      (void) __glXFlushRenderBuffer(gc, gc->pc);
529   }
530}
531
532
533/**
534 * Emit the header data for the GL 1.1 / EXT_vertex_arrays DrawArrays
535 * protocol.
536 *
537 * \param gc                    GLX context.
538 * \param arrays                Array state.
539 * \param elements_per_request  Location to store the number of elements that
540 *                              can fit in a single Render / RenderLarge
541 *                              command.
542 * \param total_request         Total number of requests for a RenderLarge
543 *                              command.  If a Render command is used, this
544 *                              will be zero.
545 * \param mode                  Drawing mode.
546 * \param count                 Number of vertices.
547 *
548 * \returns
549 * A pointer to the buffer for array data.
550 */
551static GLubyte *
552emit_DrawArrays_header_old(struct glx_context * gc,
553                           struct array_state_vector *arrays,
554                           size_t * elements_per_request,
555                           unsigned int *total_requests,
556                           GLenum mode, GLsizei count)
557{
558   size_t command_size;
559   size_t single_vertex_size;
560   const unsigned header_size = 16;
561   unsigned i;
562   GLubyte *pc;
563
564
565   /* Determine the size of the whole command.  This includes the header,
566    * the ARRAY_INFO data and the array data.  Once this size is calculated,
567    * it will be known whether a Render or RenderLarge command is needed.
568    */
569
570   single_vertex_size = 0;
571   for (i = 0; i < arrays->num_arrays; i++) {
572      if (arrays->arrays[i].enabled) {
573         single_vertex_size += __GLX_PAD(arrays->arrays[i].element_size);
574      }
575   }
576
577   command_size = arrays->array_info_cache_size + header_size
578      + (single_vertex_size * count);
579
580
581   /* Write the header for either a Render command or a RenderLarge
582    * command.  After the header is written, write the ARRAY_INFO data.
583    */
584
585   if (command_size > gc->maxSmallRenderCommandSize) {
586      /* maxSize is the maximum amount of data can be stuffed into a single
587       * packet.  sz_xGLXRenderReq is added because bufSize is the maximum
588       * packet size minus sz_xGLXRenderReq.
589       */
590      const size_t maxSize = (gc->bufSize + sz_xGLXRenderReq)
591         - sz_xGLXRenderLargeReq;
592      unsigned vertex_requests;
593
594
595      /* Calculate the number of data packets that will be required to send
596       * the whole command.  To do this, the number of verticies that
597       * will fit in a single buffer must be calculated.
598       *
599       * The important value here is elements_per_request.  This is the
600       * number of complete array elements that will fit in a single
601       * buffer.  There may be some wasted space at the end of the buffer,
602       * but splitting elements across buffer boundries would be painful.
603       */
604
605      elements_per_request[0] = maxSize / single_vertex_size;
606
607      vertex_requests = (count + elements_per_request[0] - 1)
608         / elements_per_request[0];
609
610      *total_requests = vertex_requests + 1;
611
612
613      __glXFlushRenderBuffer(gc, gc->pc);
614
615      command_size += 4;
616
617      pc = ((GLubyte *) arrays->array_info_cache) - (header_size + 4);
618      *(uint32_t *) (pc + 0) = command_size;
619      *(uint32_t *) (pc + 4) = X_GLrop_DrawArrays;
620      *(uint32_t *) (pc + 8) = count;
621      *(uint32_t *) (pc + 12) = arrays->enabled_client_array_count;
622      *(uint32_t *) (pc + 16) = mode;
623
624      __glXSendLargeChunk(gc, 1, *total_requests, pc,
625                          header_size + 4 + arrays->array_info_cache_size);
626
627      pc = gc->pc;
628   }
629   else {
630      if ((gc->pc + command_size) >= gc->bufEnd) {
631         (void) __glXFlushRenderBuffer(gc, gc->pc);
632      }
633
634      pc = gc->pc;
635      *(uint16_t *) (pc + 0) = command_size;
636      *(uint16_t *) (pc + 2) = X_GLrop_DrawArrays;
637      *(uint32_t *) (pc + 4) = count;
638      *(uint32_t *) (pc + 8) = arrays->enabled_client_array_count;
639      *(uint32_t *) (pc + 12) = mode;
640
641      pc += header_size;
642
643      (void) memcpy(pc, arrays->array_info_cache,
644                    arrays->array_info_cache_size);
645      pc += arrays->array_info_cache_size;
646
647      *elements_per_request = count;
648      *total_requests = 0;
649   }
650
651
652   return pc;
653}
654
655
656/**
657 */
658void
659emit_DrawArrays_old(GLenum mode, GLint first, GLsizei count)
660{
661   struct glx_context *gc = __glXGetCurrentContext();
662   const __GLXattribute *state =
663      (const __GLXattribute *) (gc->client_state_private);
664   struct array_state_vector *arrays = state->array_state;
665
666   GLubyte *pc;
667   size_t elements_per_request;
668   unsigned total_requests = 0;
669   unsigned i;
670   size_t total_sent = 0;
671
672
673   pc = emit_DrawArrays_header_old(gc, arrays, &elements_per_request,
674                                   &total_requests, mode, count);
675
676
677   /* Write the arrays.
678    */
679
680   if (total_requests == 0) {
681      assert(elements_per_request >= count);
682
683      for (i = 0; i < count; i++) {
684         pc = emit_element_old(pc, arrays, i + first);
685      }
686
687      assert(pc <= gc->bufEnd);
688
689      gc->pc = pc;
690      if (gc->pc > gc->limit) {
691         (void) __glXFlushRenderBuffer(gc, gc->pc);
692      }
693   }
694   else {
695      unsigned req;
696
697
698      for (req = 2; req <= total_requests; req++) {
699         if (count < elements_per_request) {
700            elements_per_request = count;
701         }
702
703         pc = gc->pc;
704         for (i = 0; i < elements_per_request; i++) {
705            pc = emit_element_old(pc, arrays, i + first);
706         }
707
708         first += elements_per_request;
709
710         total_sent += (size_t) (pc - gc->pc);
711         __glXSendLargeChunk(gc, req, total_requests, gc->pc, pc - gc->pc);
712
713         count -= elements_per_request;
714      }
715   }
716}
717
718
719void
720emit_DrawElements_none(GLenum mode, GLsizei count, GLenum type,
721                       const GLvoid * indices)
722{
723   struct glx_context *gc = __glXGetCurrentContext();
724   const __GLXattribute *state =
725      (const __GLXattribute *) (gc->client_state_private);
726   struct array_state_vector *arrays = state->array_state;
727   static const uint16_t begin_cmd[2] = { 8, X_GLrop_Begin };
728   static const uint16_t end_cmd[2] = { 4, X_GLrop_End };
729
730   GLubyte *pc;
731   size_t single_vertex_size;
732   unsigned i;
733
734
735   single_vertex_size = calculate_single_vertex_size_none(arrays);
736
737
738   if ((gc->pc + single_vertex_size) >= gc->bufEnd) {
739      gc->pc = __glXFlushRenderBuffer(gc, gc->pc);
740   }
741
742   pc = gc->pc;
743
744   (void) memcpy(pc, begin_cmd, 4);
745   *(int *) (pc + 4) = mode;
746
747   pc += 8;
748
749   for (i = 0; i < count; i++) {
750      unsigned index = 0;
751
752      if ((pc + single_vertex_size) >= gc->bufEnd) {
753         pc = __glXFlushRenderBuffer(gc, pc);
754      }
755
756      switch (type) {
757      case GL_UNSIGNED_INT:
758         index = (unsigned) (((GLuint *) indices)[i]);
759         break;
760      case GL_UNSIGNED_SHORT:
761         index = (unsigned) (((GLushort *) indices)[i]);
762         break;
763      case GL_UNSIGNED_BYTE:
764         index = (unsigned) (((GLubyte *) indices)[i]);
765         break;
766      }
767      pc = emit_element_none(pc, arrays, index);
768   }
769
770   if ((pc + 4) >= gc->bufEnd) {
771      pc = __glXFlushRenderBuffer(gc, pc);
772   }
773
774   (void) memcpy(pc, end_cmd, 4);
775   pc += 4;
776
777   gc->pc = pc;
778   if (gc->pc > gc->limit) {
779      (void) __glXFlushRenderBuffer(gc, gc->pc);
780   }
781}
782
783
784/**
785 */
786void
787emit_DrawElements_old(GLenum mode, GLsizei count, GLenum type,
788                      const GLvoid * indices)
789{
790   struct glx_context *gc = __glXGetCurrentContext();
791   const __GLXattribute *state =
792      (const __GLXattribute *) (gc->client_state_private);
793   struct array_state_vector *arrays = state->array_state;
794
795   GLubyte *pc;
796   size_t elements_per_request;
797   unsigned total_requests = 0;
798   unsigned i;
799   unsigned req;
800   unsigned req_element = 0;
801
802
803   pc = emit_DrawArrays_header_old(gc, arrays, &elements_per_request,
804                                   &total_requests, mode, count);
805
806
807   /* Write the arrays.
808    */
809
810   req = 2;
811   while (count > 0) {
812      if (count < elements_per_request) {
813         elements_per_request = count;
814      }
815
816      switch (type) {
817      case GL_UNSIGNED_INT:{
818            const GLuint *ui_ptr = (const GLuint *) indices + req_element;
819
820            for (i = 0; i < elements_per_request; i++) {
821               const GLint index = (GLint) * (ui_ptr++);
822               pc = emit_element_old(pc, arrays, index);
823            }
824            break;
825         }
826      case GL_UNSIGNED_SHORT:{
827            const GLushort *us_ptr = (const GLushort *) indices + req_element;
828
829            for (i = 0; i < elements_per_request; i++) {
830               const GLint index = (GLint) * (us_ptr++);
831               pc = emit_element_old(pc, arrays, index);
832            }
833            break;
834         }
835      case GL_UNSIGNED_BYTE:{
836            const GLubyte *ub_ptr = (const GLubyte *) indices + req_element;
837
838            for (i = 0; i < elements_per_request; i++) {
839               const GLint index = (GLint) * (ub_ptr++);
840               pc = emit_element_old(pc, arrays, index);
841            }
842            break;
843         }
844      }
845
846      if (total_requests != 0) {
847         __glXSendLargeChunk(gc, req, total_requests, gc->pc, pc - gc->pc);
848         pc = gc->pc;
849         req++;
850      }
851
852      count -= elements_per_request;
853      req_element += elements_per_request;
854   }
855
856
857   assert((total_requests == 0) || ((req - 1) == total_requests));
858
859   if (total_requests == 0) {
860      assert(pc <= gc->bufEnd);
861
862      gc->pc = pc;
863      if (gc->pc > gc->limit) {
864         (void) __glXFlushRenderBuffer(gc, gc->pc);
865      }
866   }
867}
868
869
870/**
871 * Validate that the \c mode parameter to \c glDrawArrays, et. al. is valid.
872 * If it is not valid, then an error code is set in the GLX context.
873 *
874 * \returns
875 * \c GL_TRUE if the argument is valid, \c GL_FALSE if is not.
876 */
877static GLboolean
878validate_mode(struct glx_context * gc, GLenum mode)
879{
880   switch (mode) {
881   case GL_POINTS:
882   case GL_LINE_STRIP:
883   case GL_LINE_LOOP:
884   case GL_LINES:
885   case GL_TRIANGLE_STRIP:
886   case GL_TRIANGLE_FAN:
887   case GL_TRIANGLES:
888   case GL_QUAD_STRIP:
889   case GL_QUADS:
890   case GL_POLYGON:
891      break;
892   default:
893      __glXSetError(gc, GL_INVALID_ENUM);
894      return GL_FALSE;
895   }
896
897   return GL_TRUE;
898}
899
900
901/**
902 * Validate that the \c count parameter to \c glDrawArrays, et. al. is valid.
903 * A value less than zero is invalid and will result in \c GL_INVALID_VALUE
904 * being set.  A value of zero will not result in an error being set, but
905 * will result in \c GL_FALSE being returned.
906 *
907 * \returns
908 * \c GL_TRUE if the argument is valid, \c GL_FALSE if it is not.
909 */
910static GLboolean
911validate_count(struct glx_context * gc, GLsizei count)
912{
913   if (count < 0) {
914      __glXSetError(gc, GL_INVALID_VALUE);
915   }
916
917   return (count > 0);
918}
919
920
921/**
922 * Validate that the \c type parameter to \c glDrawElements, et. al. is
923 * valid.  Only \c GL_UNSIGNED_BYTE, \c GL_UNSIGNED_SHORT, and
924 * \c GL_UNSIGNED_INT are valid.
925 *
926 * \returns
927 * \c GL_TRUE if the argument is valid, \c GL_FALSE if it is not.
928 */
929static GLboolean
930validate_type(struct glx_context * gc, GLenum type)
931{
932   switch (type) {
933   case GL_UNSIGNED_INT:
934   case GL_UNSIGNED_SHORT:
935   case GL_UNSIGNED_BYTE:
936      return GL_TRUE;
937   default:
938      __glXSetError(gc, GL_INVALID_ENUM);
939      return GL_FALSE;
940   }
941}
942
943
944void
945__indirect_glDrawArrays(GLenum mode, GLint first, GLsizei count)
946{
947   struct glx_context *gc = __glXGetCurrentContext();
948   const __GLXattribute *state =
949      (const __GLXattribute *) (gc->client_state_private);
950   struct array_state_vector *arrays = state->array_state;
951
952
953   if (validate_mode(gc, mode) && validate_count(gc, count)) {
954      if (!arrays->array_info_cache_valid) {
955         fill_array_info_cache(arrays);
956      }
957
958      arrays->DrawArrays(mode, first, count);
959   }
960}
961
962
963void
964__indirect_glArrayElement(GLint index)
965{
966   struct glx_context *gc = __glXGetCurrentContext();
967   const __GLXattribute *state =
968      (const __GLXattribute *) (gc->client_state_private);
969   struct array_state_vector *arrays = state->array_state;
970
971   size_t single_vertex_size;
972
973
974   single_vertex_size = calculate_single_vertex_size_none(arrays);
975
976   if ((gc->pc + single_vertex_size) >= gc->bufEnd) {
977      gc->pc = __glXFlushRenderBuffer(gc, gc->pc);
978   }
979
980   gc->pc = emit_element_none(gc->pc, arrays, index);
981
982   if (gc->pc > gc->limit) {
983      (void) __glXFlushRenderBuffer(gc, gc->pc);
984   }
985}
986
987
988void
989__indirect_glDrawElements(GLenum mode, GLsizei count, GLenum type,
990                          const GLvoid * indices)
991{
992   struct glx_context *gc = __glXGetCurrentContext();
993   const __GLXattribute *state =
994      (const __GLXattribute *) (gc->client_state_private);
995   struct array_state_vector *arrays = state->array_state;
996
997
998   if (validate_mode(gc, mode) && validate_count(gc, count)
999       && validate_type(gc, type)) {
1000      if (!arrays->array_info_cache_valid) {
1001         fill_array_info_cache(arrays);
1002      }
1003
1004      arrays->DrawElements(mode, count, type, indices);
1005   }
1006}
1007
1008
1009void
1010__indirect_glDrawRangeElements(GLenum mode, GLuint start, GLuint end,
1011                               GLsizei count, GLenum type,
1012                               const GLvoid * indices)
1013{
1014   struct glx_context *gc = __glXGetCurrentContext();
1015   const __GLXattribute *state =
1016      (const __GLXattribute *) (gc->client_state_private);
1017   struct array_state_vector *arrays = state->array_state;
1018
1019
1020   if (validate_mode(gc, mode) && validate_count(gc, count)
1021       && validate_type(gc, type)) {
1022      if (end < start) {
1023         __glXSetError(gc, GL_INVALID_VALUE);
1024         return;
1025      }
1026
1027      if (!arrays->array_info_cache_valid) {
1028         fill_array_info_cache(arrays);
1029      }
1030
1031      arrays->DrawElements(mode, count, type, indices);
1032   }
1033}
1034
1035
1036void
1037__indirect_glMultiDrawArraysEXT(GLenum mode, const GLint *first,
1038                                const GLsizei *count, GLsizei primcount)
1039{
1040   struct glx_context *gc = __glXGetCurrentContext();
1041   const __GLXattribute *state =
1042      (const __GLXattribute *) (gc->client_state_private);
1043   struct array_state_vector *arrays = state->array_state;
1044   GLsizei i;
1045
1046
1047   if (validate_mode(gc, mode)) {
1048      if (!arrays->array_info_cache_valid) {
1049         fill_array_info_cache(arrays);
1050      }
1051
1052      for (i = 0; i < primcount; i++) {
1053         if (validate_count(gc, count[i])) {
1054            arrays->DrawArrays(mode, first[i], count[i]);
1055         }
1056      }
1057   }
1058}
1059
1060
1061void
1062__indirect_glMultiDrawElementsEXT(GLenum mode, const GLsizei * count,
1063                                  GLenum type, const GLvoid ** indices,
1064                                  GLsizei primcount)
1065{
1066   struct glx_context *gc = __glXGetCurrentContext();
1067   const __GLXattribute *state =
1068      (const __GLXattribute *) (gc->client_state_private);
1069   struct array_state_vector *arrays = state->array_state;
1070   GLsizei i;
1071
1072
1073   if (validate_mode(gc, mode) && validate_type(gc, type)) {
1074      if (!arrays->array_info_cache_valid) {
1075         fill_array_info_cache(arrays);
1076      }
1077
1078      for (i = 0; i < primcount; i++) {
1079         if (validate_count(gc, count[i])) {
1080            arrays->DrawElements(mode, count[i], type, indices[i]);
1081         }
1082      }
1083   }
1084}
1085
1086
1087#define COMMON_ARRAY_DATA_INIT(a, PTR, TYPE, STRIDE, COUNT, NORMALIZED, HDR_SIZE, OPCODE) \
1088  do {                                                                  \
1089    (a)->data = PTR;                                                    \
1090    (a)->data_type = TYPE;                                              \
1091    (a)->user_stride = STRIDE;                                          \
1092    (a)->count = COUNT;                                                 \
1093    (a)->normalized = NORMALIZED;                                       \
1094                                                                        \
1095    (a)->element_size = __glXTypeSize( TYPE ) * COUNT;                  \
1096    (a)->true_stride = (STRIDE == 0)                                    \
1097      ? (a)->element_size : STRIDE;                                     \
1098                                                                        \
1099    (a)->header_size = HDR_SIZE;                                        \
1100    ((uint16_t *) (a)->header)[0] = __GLX_PAD((a)->header_size + (a)->element_size); \
1101    ((uint16_t *) (a)->header)[1] = OPCODE;                             \
1102  } while(0)
1103
1104
1105void
1106__indirect_glVertexPointer(GLint size, GLenum type, GLsizei stride,
1107                           const GLvoid * pointer)
1108{
1109   static const uint16_t short_ops[5] = {
1110      0, 0, X_GLrop_Vertex2sv, X_GLrop_Vertex3sv, X_GLrop_Vertex4sv
1111   };
1112   static const uint16_t int_ops[5] = {
1113      0, 0, X_GLrop_Vertex2iv, X_GLrop_Vertex3iv, X_GLrop_Vertex4iv
1114   };
1115   static const uint16_t float_ops[5] = {
1116      0, 0, X_GLrop_Vertex2fv, X_GLrop_Vertex3fv, X_GLrop_Vertex4fv
1117   };
1118   static const uint16_t double_ops[5] = {
1119      0, 0, X_GLrop_Vertex2dv, X_GLrop_Vertex3dv, X_GLrop_Vertex4dv
1120   };
1121   uint16_t opcode;
1122   struct glx_context *gc = __glXGetCurrentContext();
1123   __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
1124   struct array_state_vector *arrays = state->array_state;
1125   struct array_state *a;
1126
1127
1128   if (size < 2 || size > 4 || stride < 0) {
1129      __glXSetError(gc, GL_INVALID_VALUE);
1130      return;
1131   }
1132
1133   switch (type) {
1134   case GL_SHORT:
1135      opcode = short_ops[size];
1136      break;
1137   case GL_INT:
1138      opcode = int_ops[size];
1139      break;
1140   case GL_FLOAT:
1141      opcode = float_ops[size];
1142      break;
1143   case GL_DOUBLE:
1144      opcode = double_ops[size];
1145      break;
1146   default:
1147      __glXSetError(gc, GL_INVALID_ENUM);
1148      return;
1149   }
1150
1151   a = get_array_entry(arrays, GL_VERTEX_ARRAY, 0);
1152   assert(a != NULL);
1153   COMMON_ARRAY_DATA_INIT(a, pointer, type, stride, size, GL_FALSE, 4,
1154                          opcode);
1155
1156   if (a->enabled) {
1157      arrays->array_info_cache_valid = GL_FALSE;
1158   }
1159}
1160
1161
1162void
1163__indirect_glNormalPointer(GLenum type, GLsizei stride,
1164                           const GLvoid * pointer)
1165{
1166   uint16_t opcode;
1167   struct glx_context *gc = __glXGetCurrentContext();
1168   __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
1169   struct array_state_vector *arrays = state->array_state;
1170   struct array_state *a;
1171
1172
1173   if (stride < 0) {
1174      __glXSetError(gc, GL_INVALID_VALUE);
1175      return;
1176   }
1177
1178   switch (type) {
1179   case GL_BYTE:
1180      opcode = X_GLrop_Normal3bv;
1181      break;
1182   case GL_SHORT:
1183      opcode = X_GLrop_Normal3sv;
1184      break;
1185   case GL_INT:
1186      opcode = X_GLrop_Normal3iv;
1187      break;
1188   case GL_FLOAT:
1189      opcode = X_GLrop_Normal3fv;
1190      break;
1191   case GL_DOUBLE:
1192      opcode = X_GLrop_Normal3dv;
1193      break;
1194   default:
1195      __glXSetError(gc, GL_INVALID_ENUM);
1196      return;
1197   }
1198
1199   a = get_array_entry(arrays, GL_NORMAL_ARRAY, 0);
1200   assert(a != NULL);
1201   COMMON_ARRAY_DATA_INIT(a, pointer, type, stride, 3, GL_TRUE, 4, opcode);
1202
1203   if (a->enabled) {
1204      arrays->array_info_cache_valid = GL_FALSE;
1205   }
1206}
1207
1208
1209void
1210__indirect_glColorPointer(GLint size, GLenum type, GLsizei stride,
1211                          const GLvoid * pointer)
1212{
1213   static const uint16_t byte_ops[5] = {
1214      0, 0, 0, X_GLrop_Color3bv, X_GLrop_Color4bv
1215   };
1216   static const uint16_t ubyte_ops[5] = {
1217      0, 0, 0, X_GLrop_Color3ubv, X_GLrop_Color4ubv
1218   };
1219   static const uint16_t short_ops[5] = {
1220      0, 0, 0, X_GLrop_Color3sv, X_GLrop_Color4sv
1221   };
1222   static const uint16_t ushort_ops[5] = {
1223      0, 0, 0, X_GLrop_Color3usv, X_GLrop_Color4usv
1224   };
1225   static const uint16_t int_ops[5] = {
1226      0, 0, 0, X_GLrop_Color3iv, X_GLrop_Color4iv
1227   };
1228   static const uint16_t uint_ops[5] = {
1229      0, 0, 0, X_GLrop_Color3uiv, X_GLrop_Color4uiv
1230   };
1231   static const uint16_t float_ops[5] = {
1232      0, 0, 0, X_GLrop_Color3fv, X_GLrop_Color4fv
1233   };
1234   static const uint16_t double_ops[5] = {
1235      0, 0, 0, X_GLrop_Color3dv, X_GLrop_Color4dv
1236   };
1237   uint16_t opcode;
1238   struct glx_context *gc = __glXGetCurrentContext();
1239   __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
1240   struct array_state_vector *arrays = state->array_state;
1241   struct array_state *a;
1242
1243
1244   if (size < 3 || size > 4 || stride < 0) {
1245      __glXSetError(gc, GL_INVALID_VALUE);
1246      return;
1247   }
1248
1249   switch (type) {
1250   case GL_BYTE:
1251      opcode = byte_ops[size];
1252      break;
1253   case GL_UNSIGNED_BYTE:
1254      opcode = ubyte_ops[size];
1255      break;
1256   case GL_SHORT:
1257      opcode = short_ops[size];
1258      break;
1259   case GL_UNSIGNED_SHORT:
1260      opcode = ushort_ops[size];
1261      break;
1262   case GL_INT:
1263      opcode = int_ops[size];
1264      break;
1265   case GL_UNSIGNED_INT:
1266      opcode = uint_ops[size];
1267      break;
1268   case GL_FLOAT:
1269      opcode = float_ops[size];
1270      break;
1271   case GL_DOUBLE:
1272      opcode = double_ops[size];
1273      break;
1274   default:
1275      __glXSetError(gc, GL_INVALID_ENUM);
1276      return;
1277   }
1278
1279   a = get_array_entry(arrays, GL_COLOR_ARRAY, 0);
1280   assert(a != NULL);
1281   COMMON_ARRAY_DATA_INIT(a, pointer, type, stride, size, GL_TRUE, 4, opcode);
1282
1283   if (a->enabled) {
1284      arrays->array_info_cache_valid = GL_FALSE;
1285   }
1286}
1287
1288
1289void
1290__indirect_glIndexPointer(GLenum type, GLsizei stride, const GLvoid * pointer)
1291{
1292   uint16_t opcode;
1293   struct glx_context *gc = __glXGetCurrentContext();
1294   __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
1295   struct array_state_vector *arrays = state->array_state;
1296   struct array_state *a;
1297
1298
1299   if (stride < 0) {
1300      __glXSetError(gc, GL_INVALID_VALUE);
1301      return;
1302   }
1303
1304   switch (type) {
1305   case GL_UNSIGNED_BYTE:
1306      opcode = X_GLrop_Indexubv;
1307      break;
1308   case GL_SHORT:
1309      opcode = X_GLrop_Indexsv;
1310      break;
1311   case GL_INT:
1312      opcode = X_GLrop_Indexiv;
1313      break;
1314   case GL_FLOAT:
1315      opcode = X_GLrop_Indexfv;
1316      break;
1317   case GL_DOUBLE:
1318      opcode = X_GLrop_Indexdv;
1319      break;
1320   default:
1321      __glXSetError(gc, GL_INVALID_ENUM);
1322      return;
1323   }
1324
1325   a = get_array_entry(arrays, GL_INDEX_ARRAY, 0);
1326   assert(a != NULL);
1327   COMMON_ARRAY_DATA_INIT(a, pointer, type, stride, 1, GL_FALSE, 4, opcode);
1328
1329   if (a->enabled) {
1330      arrays->array_info_cache_valid = GL_FALSE;
1331   }
1332}
1333
1334
1335void
1336__indirect_glEdgeFlagPointer(GLsizei stride, const GLvoid * pointer)
1337{
1338   struct glx_context *gc = __glXGetCurrentContext();
1339   __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
1340   struct array_state_vector *arrays = state->array_state;
1341   struct array_state *a;
1342
1343
1344   if (stride < 0) {
1345      __glXSetError(gc, GL_INVALID_VALUE);
1346      return;
1347   }
1348
1349
1350   a = get_array_entry(arrays, GL_EDGE_FLAG_ARRAY, 0);
1351   assert(a != NULL);
1352   COMMON_ARRAY_DATA_INIT(a, pointer, GL_UNSIGNED_BYTE, stride, 1, GL_FALSE,
1353                          4, X_GLrop_EdgeFlagv);
1354
1355   if (a->enabled) {
1356      arrays->array_info_cache_valid = GL_FALSE;
1357   }
1358}
1359
1360
1361void
1362__indirect_glTexCoordPointer(GLint size, GLenum type, GLsizei stride,
1363                             const GLvoid * pointer)
1364{
1365   static const uint16_t short_ops[5] = {
1366      0, X_GLrop_TexCoord1sv, X_GLrop_TexCoord2sv, X_GLrop_TexCoord3sv,
1367      X_GLrop_TexCoord4sv
1368   };
1369   static const uint16_t int_ops[5] = {
1370      0, X_GLrop_TexCoord1iv, X_GLrop_TexCoord2iv, X_GLrop_TexCoord3iv,
1371      X_GLrop_TexCoord4iv
1372   };
1373   static const uint16_t float_ops[5] = {
1374      0, X_GLrop_TexCoord1dv, X_GLrop_TexCoord2fv, X_GLrop_TexCoord3fv,
1375      X_GLrop_TexCoord4fv
1376   };
1377   static const uint16_t double_ops[5] = {
1378      0, X_GLrop_TexCoord1dv, X_GLrop_TexCoord2dv, X_GLrop_TexCoord3dv,
1379      X_GLrop_TexCoord4dv
1380   };
1381
1382   static const uint16_t mshort_ops[5] = {
1383      0, X_GLrop_MultiTexCoord1svARB, X_GLrop_MultiTexCoord2svARB,
1384      X_GLrop_MultiTexCoord3svARB, X_GLrop_MultiTexCoord4svARB
1385   };
1386   static const uint16_t mint_ops[5] = {
1387      0, X_GLrop_MultiTexCoord1ivARB, X_GLrop_MultiTexCoord2ivARB,
1388      X_GLrop_MultiTexCoord3ivARB, X_GLrop_MultiTexCoord4ivARB
1389   };
1390   static const uint16_t mfloat_ops[5] = {
1391      0, X_GLrop_MultiTexCoord1dvARB, X_GLrop_MultiTexCoord2fvARB,
1392      X_GLrop_MultiTexCoord3fvARB, X_GLrop_MultiTexCoord4fvARB
1393   };
1394   static const uint16_t mdouble_ops[5] = {
1395      0, X_GLrop_MultiTexCoord1dvARB, X_GLrop_MultiTexCoord2dvARB,
1396      X_GLrop_MultiTexCoord3dvARB, X_GLrop_MultiTexCoord4dvARB
1397   };
1398
1399   uint16_t opcode;
1400   struct glx_context *gc = __glXGetCurrentContext();
1401   __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
1402   struct array_state_vector *arrays = state->array_state;
1403   struct array_state *a;
1404   unsigned header_size;
1405   unsigned index;
1406
1407
1408   if (size < 1 || size > 4 || stride < 0) {
1409      __glXSetError(gc, GL_INVALID_VALUE);
1410      return;
1411   }
1412
1413   index = arrays->active_texture_unit;
1414   if (index == 0) {
1415      switch (type) {
1416      case GL_SHORT:
1417         opcode = short_ops[size];
1418         break;
1419      case GL_INT:
1420         opcode = int_ops[size];
1421         break;
1422      case GL_FLOAT:
1423         opcode = float_ops[size];
1424         break;
1425      case GL_DOUBLE:
1426         opcode = double_ops[size];
1427         break;
1428      default:
1429         __glXSetError(gc, GL_INVALID_ENUM);
1430         return;
1431      }
1432
1433      header_size = 4;
1434   }
1435   else {
1436      switch (type) {
1437      case GL_SHORT:
1438         opcode = mshort_ops[size];
1439         break;
1440      case GL_INT:
1441         opcode = mint_ops[size];
1442         break;
1443      case GL_FLOAT:
1444         opcode = mfloat_ops[size];
1445         break;
1446      case GL_DOUBLE:
1447         opcode = mdouble_ops[size];
1448         break;
1449      default:
1450         __glXSetError(gc, GL_INVALID_ENUM);
1451         return;
1452      }
1453
1454      header_size = 8;
1455   }
1456
1457   a = get_array_entry(arrays, GL_TEXTURE_COORD_ARRAY, index);
1458   assert(a != NULL);
1459   COMMON_ARRAY_DATA_INIT(a, pointer, type, stride, size, GL_FALSE,
1460                          header_size, opcode);
1461
1462   if (a->enabled) {
1463      arrays->array_info_cache_valid = GL_FALSE;
1464   }
1465}
1466
1467
1468void
1469__indirect_glSecondaryColorPointerEXT(GLint size, GLenum type, GLsizei stride,
1470                                      const GLvoid * pointer)
1471{
1472   uint16_t opcode;
1473   struct glx_context *gc = __glXGetCurrentContext();
1474   __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
1475   struct array_state_vector *arrays = state->array_state;
1476   struct array_state *a;
1477
1478
1479   if (size != 3 || stride < 0) {
1480      __glXSetError(gc, GL_INVALID_VALUE);
1481      return;
1482   }
1483
1484   switch (type) {
1485   case GL_BYTE:
1486      opcode = 4126;
1487      break;
1488   case GL_UNSIGNED_BYTE:
1489      opcode = 4131;
1490      break;
1491   case GL_SHORT:
1492      opcode = 4127;
1493      break;
1494   case GL_UNSIGNED_SHORT:
1495      opcode = 4132;
1496      break;
1497   case GL_INT:
1498      opcode = 4128;
1499      break;
1500   case GL_UNSIGNED_INT:
1501      opcode = 4133;
1502      break;
1503   case GL_FLOAT:
1504      opcode = 4129;
1505      break;
1506   case GL_DOUBLE:
1507      opcode = 4130;
1508      break;
1509   default:
1510      __glXSetError(gc, GL_INVALID_ENUM);
1511      return;
1512   }
1513
1514   a = get_array_entry(arrays, GL_SECONDARY_COLOR_ARRAY, 0);
1515   if (a == NULL) {
1516      __glXSetError(gc, GL_INVALID_OPERATION);
1517      return;
1518   }
1519
1520   COMMON_ARRAY_DATA_INIT(a, pointer, type, stride, size, GL_TRUE, 4, opcode);
1521
1522   if (a->enabled) {
1523      arrays->array_info_cache_valid = GL_FALSE;
1524   }
1525}
1526
1527
1528void
1529__indirect_glFogCoordPointerEXT(GLenum type, GLsizei stride,
1530                                const GLvoid * pointer)
1531{
1532   uint16_t opcode;
1533   struct glx_context *gc = __glXGetCurrentContext();
1534   __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
1535   struct array_state_vector *arrays = state->array_state;
1536   struct array_state *a;
1537
1538
1539   if (stride < 0) {
1540      __glXSetError(gc, GL_INVALID_VALUE);
1541      return;
1542   }
1543
1544   switch (type) {
1545   case GL_FLOAT:
1546      opcode = 4124;
1547      break;
1548   case GL_DOUBLE:
1549      opcode = 4125;
1550      break;
1551   default:
1552      __glXSetError(gc, GL_INVALID_ENUM);
1553      return;
1554   }
1555
1556   a = get_array_entry(arrays, GL_FOG_COORD_ARRAY, 0);
1557   if (a == NULL) {
1558      __glXSetError(gc, GL_INVALID_OPERATION);
1559      return;
1560   }
1561
1562   COMMON_ARRAY_DATA_INIT(a, pointer, type, stride, 1, GL_FALSE, 4, opcode);
1563
1564   if (a->enabled) {
1565      arrays->array_info_cache_valid = GL_FALSE;
1566   }
1567}
1568
1569
1570void
1571__indirect_glVertexAttribPointerARB(GLuint index, GLint size,
1572                                    GLenum type, GLboolean normalized,
1573                                    GLsizei stride, const GLvoid * pointer)
1574{
1575   static const uint16_t short_ops[5] = { 0, 4189, 4190, 4191, 4192 };
1576   static const uint16_t float_ops[5] = { 0, 4193, 4194, 4195, 4196 };
1577   static const uint16_t double_ops[5] = { 0, 4197, 4198, 4199, 4200 };
1578
1579   uint16_t opcode;
1580   struct glx_context *gc = __glXGetCurrentContext();
1581   __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
1582   struct array_state_vector *arrays = state->array_state;
1583   struct array_state *a;
1584   unsigned true_immediate_count;
1585   unsigned true_immediate_size;
1586
1587
1588   if ((size < 1) || (size > 4) || (stride < 0)
1589       || (index > arrays->num_vertex_program_attribs)) {
1590      __glXSetError(gc, GL_INVALID_VALUE);
1591      return;
1592   }
1593
1594   if (normalized && (type != GL_FLOAT) && (type != GL_DOUBLE)) {
1595      switch (type) {
1596      case GL_BYTE:
1597         opcode = X_GLrop_VertexAttrib4NbvARB;
1598         break;
1599      case GL_UNSIGNED_BYTE:
1600         opcode = X_GLrop_VertexAttrib4NubvARB;
1601         break;
1602      case GL_SHORT:
1603         opcode = X_GLrop_VertexAttrib4NsvARB;
1604         break;
1605      case GL_UNSIGNED_SHORT:
1606         opcode = X_GLrop_VertexAttrib4NusvARB;
1607         break;
1608      case GL_INT:
1609         opcode = X_GLrop_VertexAttrib4NivARB;
1610         break;
1611      case GL_UNSIGNED_INT:
1612         opcode = X_GLrop_VertexAttrib4NuivARB;
1613         break;
1614      default:
1615         __glXSetError(gc, GL_INVALID_ENUM);
1616         return;
1617      }
1618
1619      true_immediate_count = 4;
1620   }
1621   else {
1622      true_immediate_count = size;
1623
1624      switch (type) {
1625      case GL_BYTE:
1626         opcode = X_GLrop_VertexAttrib4bvARB;
1627         true_immediate_count = 4;
1628         break;
1629      case GL_UNSIGNED_BYTE:
1630         opcode = X_GLrop_VertexAttrib4ubvARB;
1631         true_immediate_count = 4;
1632         break;
1633      case GL_SHORT:
1634         opcode = short_ops[size];
1635         break;
1636      case GL_UNSIGNED_SHORT:
1637         opcode = X_GLrop_VertexAttrib4usvARB;
1638         true_immediate_count = 4;
1639         break;
1640      case GL_INT:
1641         opcode = X_GLrop_VertexAttrib4ivARB;
1642         true_immediate_count = 4;
1643         break;
1644      case GL_UNSIGNED_INT:
1645         opcode = X_GLrop_VertexAttrib4uivARB;
1646         true_immediate_count = 4;
1647         break;
1648      case GL_FLOAT:
1649         opcode = float_ops[size];
1650         break;
1651      case GL_DOUBLE:
1652         opcode = double_ops[size];
1653         break;
1654      default:
1655         __glXSetError(gc, GL_INVALID_ENUM);
1656         return;
1657      }
1658   }
1659
1660   a = get_array_entry(arrays, GL_VERTEX_ATTRIB_ARRAY_POINTER, index);
1661   if (a == NULL) {
1662      __glXSetError(gc, GL_INVALID_OPERATION);
1663      return;
1664   }
1665
1666   COMMON_ARRAY_DATA_INIT(a, pointer, type, stride, size, normalized, 8,
1667                          opcode);
1668
1669   true_immediate_size = __glXTypeSize(type) * true_immediate_count;
1670   ((uint16_t *) (a)->header)[0] = __GLX_PAD(a->header_size
1671                                             + true_immediate_size);
1672
1673   if (a->enabled) {
1674      arrays->array_info_cache_valid = GL_FALSE;
1675   }
1676}
1677
1678
1679/**
1680 * I don't have 100% confidence that this is correct.  The different rules
1681 * about whether or not generic vertex attributes alias "classic" vertex
1682 * attributes (i.e., attrib1 ?= primary color) between ARB_vertex_program,
1683 * ARB_vertex_shader, and NV_vertex_program are a bit confusing.  My
1684 * feeling is that the client-side doesn't have to worry about it.  The
1685 * client just sends all the data to the server and lets the server deal
1686 * with it.
1687 */
1688void
1689__indirect_glVertexAttribPointerNV(GLuint index, GLint size,
1690                                   GLenum type, GLsizei stride,
1691                                   const GLvoid * pointer)
1692{
1693   struct glx_context *gc = __glXGetCurrentContext();
1694   GLboolean normalized = GL_FALSE;
1695
1696
1697   switch (type) {
1698   case GL_UNSIGNED_BYTE:
1699      if (size != 4) {
1700         __glXSetError(gc, GL_INVALID_VALUE);
1701         return;
1702      }
1703      normalized = GL_TRUE;
1704
1705   case GL_SHORT:
1706   case GL_FLOAT:
1707   case GL_DOUBLE:
1708      __indirect_glVertexAttribPointerARB(index, size, type,
1709                                          normalized, stride, pointer);
1710      return;
1711   default:
1712      __glXSetError(gc, GL_INVALID_ENUM);
1713      return;
1714   }
1715}
1716
1717
1718void
1719__indirect_glClientActiveTextureARB(GLenum texture)
1720{
1721   struct glx_context *const gc = __glXGetCurrentContext();
1722   __GLXattribute *const state =
1723      (__GLXattribute *) (gc->client_state_private);
1724   struct array_state_vector *const arrays = state->array_state;
1725   const GLint unit = (GLint) texture - GL_TEXTURE0;
1726
1727
1728   if ((unit < 0) || (unit >= arrays->num_texture_units)) {
1729      __glXSetError(gc, GL_INVALID_ENUM);
1730      return;
1731   }
1732
1733   arrays->active_texture_unit = unit;
1734}
1735
1736
1737/**
1738 * Modify the enable state for the selected array
1739 */
1740GLboolean
1741__glXSetArrayEnable(__GLXattribute * state, GLenum key, unsigned index,
1742                    GLboolean enable)
1743{
1744   struct array_state_vector *arrays = state->array_state;
1745   struct array_state *a;
1746
1747
1748   /* Texture coordinate arrays have an implict index set when the
1749    * application calls glClientActiveTexture.
1750    */
1751   if (key == GL_TEXTURE_COORD_ARRAY) {
1752      index = arrays->active_texture_unit;
1753   }
1754
1755   a = get_array_entry(arrays, key, index);
1756
1757   if ((a != NULL) && (a->enabled != enable)) {
1758      a->enabled = enable;
1759      arrays->array_info_cache_valid = GL_FALSE;
1760   }
1761
1762   return (a != NULL);
1763}
1764
1765
1766void
1767__glXArrayDisableAll(__GLXattribute * state)
1768{
1769   struct array_state_vector *arrays = state->array_state;
1770   unsigned i;
1771
1772
1773   for (i = 0; i < arrays->num_arrays; i++) {
1774      arrays->arrays[i].enabled = GL_FALSE;
1775   }
1776
1777   arrays->array_info_cache_valid = GL_FALSE;
1778}
1779
1780
1781/**
1782 */
1783GLboolean
1784__glXGetArrayEnable(const __GLXattribute * const state,
1785                    GLenum key, unsigned index, GLintptr * dest)
1786{
1787   const struct array_state_vector *arrays = state->array_state;
1788   const struct array_state *a =
1789      get_array_entry((struct array_state_vector *) arrays,
1790                      key, index);
1791
1792   if (a != NULL) {
1793      *dest = (GLintptr) a->enabled;
1794   }
1795
1796   return (a != NULL);
1797}
1798
1799
1800/**
1801 */
1802GLboolean
1803__glXGetArrayType(const __GLXattribute * const state,
1804                  GLenum key, unsigned index, GLintptr * dest)
1805{
1806   const struct array_state_vector *arrays = state->array_state;
1807   const struct array_state *a =
1808      get_array_entry((struct array_state_vector *) arrays,
1809                      key, index);
1810
1811   if (a != NULL) {
1812      *dest = (GLintptr) a->data_type;
1813   }
1814
1815   return (a != NULL);
1816}
1817
1818
1819/**
1820 */
1821GLboolean
1822__glXGetArraySize(const __GLXattribute * const state,
1823                  GLenum key, unsigned index, GLintptr * dest)
1824{
1825   const struct array_state_vector *arrays = state->array_state;
1826   const struct array_state *a =
1827      get_array_entry((struct array_state_vector *) arrays,
1828                      key, index);
1829
1830   if (a != NULL) {
1831      *dest = (GLintptr) a->count;
1832   }
1833
1834   return (a != NULL);
1835}
1836
1837
1838/**
1839 */
1840GLboolean
1841__glXGetArrayStride(const __GLXattribute * const state,
1842                    GLenum key, unsigned index, GLintptr * dest)
1843{
1844   const struct array_state_vector *arrays = state->array_state;
1845   const struct array_state *a =
1846      get_array_entry((struct array_state_vector *) arrays,
1847                      key, index);
1848
1849   if (a != NULL) {
1850      *dest = (GLintptr) a->user_stride;
1851   }
1852
1853   return (a != NULL);
1854}
1855
1856
1857/**
1858 */
1859GLboolean
1860__glXGetArrayPointer(const __GLXattribute * const state,
1861                     GLenum key, unsigned index, void **dest)
1862{
1863   const struct array_state_vector *arrays = state->array_state;
1864   const struct array_state *a =
1865      get_array_entry((struct array_state_vector *) arrays,
1866                      key, index);
1867
1868
1869   if (a != NULL) {
1870      *dest = (void *) (a->data);
1871   }
1872
1873   return (a != NULL);
1874}
1875
1876
1877/**
1878 */
1879GLboolean
1880__glXGetArrayNormalized(const __GLXattribute * const state,
1881                        GLenum key, unsigned index, GLintptr * dest)
1882{
1883   const struct array_state_vector *arrays = state->array_state;
1884   const struct array_state *a =
1885      get_array_entry((struct array_state_vector *) arrays,
1886                      key, index);
1887
1888
1889   if (a != NULL) {
1890      *dest = (GLintptr) a->normalized;
1891   }
1892
1893   return (a != NULL);
1894}
1895
1896
1897/**
1898 */
1899GLuint
1900__glXGetActiveTextureUnit(const __GLXattribute * const state)
1901{
1902   return state->array_state->active_texture_unit;
1903}
1904
1905
1906void
1907__glXPushArrayState(__GLXattribute * state)
1908{
1909   struct array_state_vector *arrays = state->array_state;
1910   struct array_stack_state *stack =
1911      &arrays->stack[(arrays->stack_index * arrays->num_arrays)];
1912   unsigned i;
1913
1914   /* XXX are we pushing _all_ the necessary fields? */
1915   for (i = 0; i < arrays->num_arrays; i++) {
1916      stack[i].data = arrays->arrays[i].data;
1917      stack[i].data_type = arrays->arrays[i].data_type;
1918      stack[i].user_stride = arrays->arrays[i].user_stride;
1919      stack[i].count = arrays->arrays[i].count;
1920      stack[i].key = arrays->arrays[i].key;
1921      stack[i].index = arrays->arrays[i].index;
1922      stack[i].enabled = arrays->arrays[i].enabled;
1923   }
1924
1925   arrays->active_texture_unit_stack[arrays->stack_index] =
1926      arrays->active_texture_unit;
1927
1928   arrays->stack_index++;
1929}
1930
1931
1932void
1933__glXPopArrayState(__GLXattribute * state)
1934{
1935   struct array_state_vector *arrays = state->array_state;
1936   struct array_stack_state *stack;
1937   unsigned i;
1938
1939
1940   arrays->stack_index--;
1941   stack = &arrays->stack[(arrays->stack_index * arrays->num_arrays)];
1942
1943   for (i = 0; i < arrays->num_arrays; i++) {
1944      switch (stack[i].key) {
1945      case GL_NORMAL_ARRAY:
1946         __indirect_glNormalPointer(stack[i].data_type,
1947                                    stack[i].user_stride, stack[i].data);
1948         break;
1949      case GL_COLOR_ARRAY:
1950         __indirect_glColorPointer(stack[i].count,
1951                                   stack[i].data_type,
1952                                   stack[i].user_stride, stack[i].data);
1953         break;
1954      case GL_INDEX_ARRAY:
1955         __indirect_glIndexPointer(stack[i].data_type,
1956                                   stack[i].user_stride, stack[i].data);
1957         break;
1958      case GL_EDGE_FLAG_ARRAY:
1959         __indirect_glEdgeFlagPointer(stack[i].user_stride, stack[i].data);
1960         break;
1961      case GL_TEXTURE_COORD_ARRAY:
1962         arrays->active_texture_unit = stack[i].index;
1963         __indirect_glTexCoordPointer(stack[i].count,
1964                                      stack[i].data_type,
1965                                      stack[i].user_stride, stack[i].data);
1966         break;
1967      case GL_SECONDARY_COLOR_ARRAY:
1968         __indirect_glSecondaryColorPointerEXT(stack[i].count,
1969                                               stack[i].data_type,
1970                                               stack[i].user_stride,
1971                                               stack[i].data);
1972         break;
1973      case GL_FOG_COORDINATE_ARRAY:
1974         __indirect_glFogCoordPointerEXT(stack[i].data_type,
1975                                         stack[i].user_stride, stack[i].data);
1976         break;
1977
1978      }
1979
1980      __glXSetArrayEnable(state, stack[i].key, stack[i].index,
1981                          stack[i].enabled);
1982   }
1983
1984   arrays->active_texture_unit =
1985      arrays->active_texture_unit_stack[arrays->stack_index];
1986}
1987