1 /* $XFree86: xc/lib/GL/glx/single2.c,v 1.10 2004/02/11 19:48:16 dawes Exp $ */
3 ** License Applicability. Except to the extent portions of this file are
4 ** made subject to an alternative license as permitted in the SGI Free
5 ** Software License B, Version 1.1 (the "License"), the contents of this
6 ** file are subject only to the provisions of the License. You may not use
7 ** this file except in compliance with the License. You may obtain a copy
8 ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
9 ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
11 ** http://oss.sgi.com/projects/FreeB
13 ** Note that, as provided in the License, the Software is distributed on an
14 ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
15 ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
16 ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
17 ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
19 ** Original Code. The Original Code is: OpenGL Sample Implementation,
20 ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
21 ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
22 ** Copyright in any portions created by third parties is as indicated
23 ** elsewhere herein. All Rights Reserved.
25 ** Additional Notice Provisions: The application programming interfaces
26 ** established by SGI in conjunction with the Original Code are The
27 ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
28 ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
29 ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
30 ** Window System(R) (Version 1.3), released October 19, 1998. This software
31 ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
32 ** published by SGI, but has not been independently verified as being
33 ** compliant with the OpenGL(R) version 1.2.1 Specification.
38 #include "glxclient.h"
39 #include "packsingle.h"
40 #include "glxextensions.h"
42 /* Used for GL_ARB_transpose_matrix */
43 static void TransposeMatrixf(GLfloat m[16])
46 for (i = 0; i < 4; i++) {
47 for (j = 0; j < i; j++) {
48 GLfloat tmp = m[i*4+j];
55 /* Used for GL_ARB_transpose_matrix */
56 static void TransposeMatrixb(GLboolean m[16])
59 for (i = 0; i < 4; i++) {
60 for (j = 0; j < i; j++) {
61 GLboolean tmp = m[i*4+j];
68 /* Used for GL_ARB_transpose_matrix */
69 static void TransposeMatrixd(GLdouble m[16])
72 for (i = 0; i < 4; i++) {
73 for (j = 0; j < i; j++) {
74 GLdouble tmp = m[i*4+j];
81 /* Used for GL_ARB_transpose_matrix */
82 static void TransposeMatrixi(GLint m[16])
85 for (i = 0; i < 4; i++) {
86 for (j = 0; j < i; j++) {
94 GLenum __indirect_glGetError(void)
96 __GLX_SINGLE_DECLARE_VARIABLES();
97 GLuint retval = GL_NO_ERROR;
98 xGLXGetErrorReply reply;
101 /* Use internal error first */
103 gc->error = GL_NO_ERROR;
107 __GLX_SINGLE_LOAD_VARIABLES();
108 __GLX_SINGLE_BEGIN(X_GLsop_GetError,0);
109 __GLX_SINGLE_READ_XREPLY();
110 retval = reply.error;
116 void __indirect_glGetClipPlane(GLenum plane, GLdouble *equation)
118 __GLX_SINGLE_DECLARE_VARIABLES();
119 xGLXSingleReply reply;
120 __GLX_SINGLE_LOAD_VARIABLES();
121 __GLX_SINGLE_BEGIN(X_GLsop_GetClipPlane,4);
122 __GLX_SINGLE_PUT_LONG(0,plane);
123 __GLX_SINGLE_READ_XREPLY();
124 if (reply.length == 8) {
125 __GLX_SINGLE_GET_DOUBLE_ARRAY(equation,4);
130 #define CASE_ARRAY_ENABLE(enum_name,array,dest,gl_type) \
131 case GL_ ## enum_name ## _ARRAY: \
132 *dest = (gl_type) (IS_ARRAY_ENABLED(state, array)); break
133 #define CASE_ARRAY_SIZE(enum_name,array,dest,gl_type) \
134 case GL_ ## enum_name ## _ARRAY_SIZE: \
135 *dest = (gl_type) state->vertArray.arrays[array ## _ARRAY].size ; break
136 #define CASE_ARRAY_TYPE(enum_name,array,dest,gl_type) \
137 case GL_ ## enum_name ## _ARRAY_TYPE: \
138 *dest = (gl_type) state->vertArray.arrays[array ## _ARRAY].type ; break
139 #define CASE_ARRAY_STRIDE(enum_name,array,dest,gl_type) \
140 case GL_ ## enum_name ## _ARRAY_STRIDE: \
141 *dest = (gl_type) state->vertArray.arrays[array ## _ARRAY].stride ; break
143 #define CASE_ARRAY_ALL(enum_name,array,dest,gl_type) \
144 CASE_ARRAY_ENABLE(enum_name,array,dest,gl_type); \
145 CASE_ARRAY_STRIDE(enum_name,array,dest,gl_type); \
146 CASE_ARRAY_TYPE(enum_name,array,dest,gl_type); \
147 CASE_ARRAY_SIZE(enum_name,array,dest,gl_type)
149 void __indirect_glGetBooleanv(GLenum val, GLboolean *b)
151 const GLenum origVal = val;
152 __GLX_SINGLE_DECLARE_VARIABLES();
153 __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
154 xGLXSingleReply reply;
156 if (val == GL_TRANSPOSE_MODELVIEW_MATRIX_ARB) {
157 val = GL_MODELVIEW_MATRIX;
159 else if (val == GL_TRANSPOSE_PROJECTION_MATRIX_ARB) {
160 val = GL_PROJECTION_MATRIX;
162 else if (val == GL_TRANSPOSE_TEXTURE_MATRIX_ARB) {
163 val = GL_TEXTURE_MATRIX;
165 else if (val == GL_TRANSPOSE_COLOR_MATRIX_ARB) {
166 val = GL_COLOR_MATRIX;
169 __GLX_SINGLE_LOAD_VARIABLES();
170 __GLX_SINGLE_BEGIN(X_GLsop_GetBooleanv,4);
171 __GLX_SINGLE_PUT_LONG(0,val);
172 __GLX_SINGLE_READ_XREPLY();
173 __GLX_SINGLE_GET_SIZE(compsize);
177 ** Error occured; don't modify user's buffer.
181 ** For all the queries listed here, we use the locally stored
182 ** values rather than the one returned by the server. Note that
183 ** we still needed to send the request to the server in order to
184 ** find out whether it was legal to make a query (it's illegal,
185 ** for example, to call a query between glBegin() and glEnd()).
188 case GL_PACK_ROW_LENGTH:
189 *b = (GLboolean)state->storePack.rowLength;
191 case GL_PACK_IMAGE_HEIGHT:
192 *b = (GLboolean)state->storePack.imageHeight;
194 case GL_PACK_SKIP_ROWS:
195 *b = (GLboolean)state->storePack.skipRows;
197 case GL_PACK_SKIP_PIXELS:
198 *b = (GLboolean)state->storePack.skipPixels;
200 case GL_PACK_SKIP_IMAGES:
201 *b = (GLboolean)state->storePack.skipImages;
203 case GL_PACK_ALIGNMENT:
204 *b = (GLboolean)state->storePack.alignment;
206 case GL_PACK_SWAP_BYTES:
207 *b = (GLboolean)state->storePack.swapEndian;
209 case GL_PACK_LSB_FIRST:
210 *b = (GLboolean)state->storePack.lsbFirst;
212 case GL_UNPACK_ROW_LENGTH:
213 *b = (GLboolean)state->storeUnpack.rowLength;
215 case GL_UNPACK_IMAGE_HEIGHT:
216 *b = (GLboolean)state->storeUnpack.imageHeight;
218 case GL_UNPACK_SKIP_ROWS:
219 *b = (GLboolean)state->storeUnpack.skipRows;
221 case GL_UNPACK_SKIP_PIXELS:
222 *b = (GLboolean)state->storeUnpack.skipPixels;
224 case GL_UNPACK_SKIP_IMAGES:
225 *b = (GLboolean)state->storeUnpack.skipImages;
227 case GL_UNPACK_ALIGNMENT:
228 *b = (GLboolean)state->storeUnpack.alignment;
230 case GL_UNPACK_SWAP_BYTES:
231 *b = (GLboolean)state->storeUnpack.swapEndian;
233 case GL_UNPACK_LSB_FIRST:
234 *b = (GLboolean)state->storeUnpack.lsbFirst;
237 CASE_ARRAY_ALL(VERTEX, vertex, b, GLboolean);
239 CASE_ARRAY_ENABLE(NORMAL, normal, b, GLboolean);
240 CASE_ARRAY_TYPE(NORMAL, normal, b, GLboolean);
241 CASE_ARRAY_STRIDE(NORMAL, normal, b, GLboolean);
243 CASE_ARRAY_ALL(COLOR, color, b, GLboolean);
245 CASE_ARRAY_ENABLE(INDEX, index, b, GLboolean);
246 CASE_ARRAY_TYPE(INDEX, index, b, GLboolean);
247 CASE_ARRAY_STRIDE(INDEX, index, b, GLboolean);
249 case GL_TEXTURE_COORD_ARRAY:
250 *b = (GLboolean)IS_TEXARRAY_ENABLED(state, state->vertArray.activeTexture);
252 case GL_TEXTURE_COORD_ARRAY_SIZE:
253 *b = (GLboolean)state->vertArray.texCoord[state->vertArray.activeTexture].size;
255 case GL_TEXTURE_COORD_ARRAY_TYPE:
256 *b = (GLboolean)state->vertArray.texCoord[state->vertArray.activeTexture].type;
258 case GL_TEXTURE_COORD_ARRAY_STRIDE:
259 *b = (GLboolean)state->vertArray.texCoord[state->vertArray.activeTexture].stride;
262 CASE_ARRAY_ENABLE(EDGE_FLAG, edgeFlag, b, GLboolean);
263 CASE_ARRAY_STRIDE(EDGE_FLAG, edgeFlag, b, GLboolean);
265 CASE_ARRAY_ALL(SECONDARY_COLOR, secondaryColor, b, GLboolean);
267 CASE_ARRAY_ENABLE(FOG_COORD, fogCoord, b, GLboolean);
268 CASE_ARRAY_TYPE(FOG_COORD, fogCoord, b, GLboolean);
269 CASE_ARRAY_STRIDE(FOG_COORD, fogCoord, b, GLboolean);
271 case GL_MAX_ELEMENTS_VERTICES:
272 *b = (GLboolean)state->vertArray.maxElementsVertices;
274 case GL_MAX_ELEMENTS_INDICES:
275 *b = (GLboolean)state->vertArray.maxElementsIndices;
277 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
278 *b = (GLboolean)__GL_CLIENT_ATTRIB_STACK_DEPTH;
280 case GL_CLIENT_ACTIVE_TEXTURE_ARB:
281 *b = (GLboolean)(state->vertArray.activeTexture + GL_TEXTURE0_ARB);
285 ** Not a local value, so use what we got from the server.
288 __GLX_SINGLE_GET_CHAR(b);
290 __GLX_SINGLE_GET_CHAR_ARRAY(b,compsize);
291 if (val != origVal) {
292 /* matrix transpose */
301 void __indirect_glGetDoublev(GLenum val, GLdouble *d)
303 const GLenum origVal = val;
304 __GLX_SINGLE_DECLARE_VARIABLES();
305 __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
306 xGLXSingleReply reply;
308 if (val == GL_TRANSPOSE_MODELVIEW_MATRIX_ARB) {
309 val = GL_MODELVIEW_MATRIX;
311 else if (val == GL_TRANSPOSE_PROJECTION_MATRIX_ARB) {
312 val = GL_PROJECTION_MATRIX;
314 else if (val == GL_TRANSPOSE_TEXTURE_MATRIX_ARB) {
315 val = GL_TEXTURE_MATRIX;
317 else if (val == GL_TRANSPOSE_COLOR_MATRIX_ARB) {
318 val = GL_COLOR_MATRIX;
321 __GLX_SINGLE_LOAD_VARIABLES();
322 __GLX_SINGLE_BEGIN(X_GLsop_GetDoublev,4);
323 __GLX_SINGLE_PUT_LONG(0,val);
324 __GLX_SINGLE_READ_XREPLY();
325 __GLX_SINGLE_GET_SIZE(compsize);
329 ** Error occured; don't modify user's buffer.
333 ** For all the queries listed here, we use the locally stored
334 ** values rather than the one returned by the server. Note that
335 ** we still needed to send the request to the server in order to
336 ** find out whether it was legal to make a query (it's illegal,
337 ** for example, to call a query between glBegin() and glEnd()).
340 case GL_PACK_ROW_LENGTH:
341 *d = (GLdouble)state->storePack.rowLength;
343 case GL_PACK_IMAGE_HEIGHT:
344 *d = (GLdouble)state->storePack.imageHeight;
346 case GL_PACK_SKIP_ROWS:
347 *d = (GLdouble)state->storePack.skipRows;
349 case GL_PACK_SKIP_PIXELS:
350 *d = (GLdouble)state->storePack.skipPixels;
352 case GL_PACK_SKIP_IMAGES:
353 *d = (GLdouble)state->storePack.skipImages;
355 case GL_PACK_ALIGNMENT:
356 *d = (GLdouble)state->storePack.alignment;
358 case GL_PACK_SWAP_BYTES:
359 *d = (GLdouble)state->storePack.swapEndian;
361 case GL_PACK_LSB_FIRST:
362 *d = (GLdouble)state->storePack.lsbFirst;
364 case GL_UNPACK_ROW_LENGTH:
365 *d = (GLdouble)state->storeUnpack.rowLength;
367 case GL_UNPACK_IMAGE_HEIGHT:
368 *d = (GLdouble)state->storeUnpack.imageHeight;
370 case GL_UNPACK_SKIP_ROWS:
371 *d = (GLdouble)state->storeUnpack.skipRows;
373 case GL_UNPACK_SKIP_PIXELS:
374 *d = (GLdouble)state->storeUnpack.skipPixels;
376 case GL_UNPACK_SKIP_IMAGES:
377 *d = (GLdouble)state->storeUnpack.skipImages;
379 case GL_UNPACK_ALIGNMENT:
380 *d = (GLdouble)state->storeUnpack.alignment;
382 case GL_UNPACK_SWAP_BYTES:
383 *d = (GLdouble)state->storeUnpack.swapEndian;
385 case GL_UNPACK_LSB_FIRST:
386 *d = (GLdouble)state->storeUnpack.lsbFirst;
389 CASE_ARRAY_ALL(VERTEX, vertex, d, GLdouble);
391 CASE_ARRAY_ENABLE(NORMAL, normal, d, GLdouble);
392 CASE_ARRAY_TYPE(NORMAL, normal, d, GLdouble);
393 CASE_ARRAY_STRIDE(NORMAL, normal, d, GLdouble);
395 CASE_ARRAY_ALL(COLOR, color, d, GLdouble);
397 CASE_ARRAY_ENABLE(INDEX, index, d, GLdouble);
398 CASE_ARRAY_TYPE(INDEX, index, d, GLdouble);
399 CASE_ARRAY_STRIDE(INDEX, index, d, GLdouble);
401 case GL_TEXTURE_COORD_ARRAY:
402 *d = (GLdouble) IS_TEXARRAY_ENABLED(state, state->vertArray.activeTexture);
404 case GL_TEXTURE_COORD_ARRAY_SIZE:
405 *d = (GLdouble)state->vertArray.texCoord[state->vertArray.activeTexture].size;
407 case GL_TEXTURE_COORD_ARRAY_TYPE:
408 *d = (GLdouble)state->vertArray.texCoord[state->vertArray.activeTexture].type;
410 case GL_TEXTURE_COORD_ARRAY_STRIDE:
411 *d = (GLdouble)state->vertArray.texCoord[state->vertArray.activeTexture].stride;
414 CASE_ARRAY_ENABLE(EDGE_FLAG, edgeFlag, d, GLdouble);
415 CASE_ARRAY_STRIDE(EDGE_FLAG, edgeFlag, d, GLdouble);
417 CASE_ARRAY_ALL(SECONDARY_COLOR, secondaryColor, d, GLdouble);
419 CASE_ARRAY_ENABLE(FOG_COORD, fogCoord, d, GLdouble);
420 CASE_ARRAY_TYPE(FOG_COORD, fogCoord, d, GLdouble);
421 CASE_ARRAY_STRIDE(FOG_COORD, fogCoord, d, GLdouble);
423 case GL_MAX_ELEMENTS_VERTICES:
424 *d = (GLdouble)state->vertArray.maxElementsVertices;
426 case GL_MAX_ELEMENTS_INDICES:
427 *d = (GLdouble)state->vertArray.maxElementsIndices;
429 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
430 *d = (GLdouble)__GL_CLIENT_ATTRIB_STACK_DEPTH;
432 case GL_CLIENT_ACTIVE_TEXTURE_ARB:
433 *d = (GLdouble)(state->vertArray.activeTexture + GL_TEXTURE0_ARB);
437 ** Not a local value, so use what we got from the server.
440 __GLX_SINGLE_GET_DOUBLE(d);
442 __GLX_SINGLE_GET_DOUBLE_ARRAY(d,compsize);
443 if (val != origVal) {
444 /* matrix transpose */
453 void __indirect_glGetFloatv(GLenum val, GLfloat *f)
455 const GLenum origVal = val;
456 __GLX_SINGLE_DECLARE_VARIABLES();
457 __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
458 xGLXSingleReply reply;
460 if (val == GL_TRANSPOSE_MODELVIEW_MATRIX_ARB) {
461 val = GL_MODELVIEW_MATRIX;
463 else if (val == GL_TRANSPOSE_PROJECTION_MATRIX_ARB) {
464 val = GL_PROJECTION_MATRIX;
466 else if (val == GL_TRANSPOSE_TEXTURE_MATRIX_ARB) {
467 val = GL_TEXTURE_MATRIX;
469 else if (val == GL_TRANSPOSE_COLOR_MATRIX_ARB) {
470 val = GL_COLOR_MATRIX;
473 __GLX_SINGLE_LOAD_VARIABLES();
474 __GLX_SINGLE_BEGIN(X_GLsop_GetFloatv,4);
475 __GLX_SINGLE_PUT_LONG(0,val);
476 __GLX_SINGLE_READ_XREPLY();
477 __GLX_SINGLE_GET_SIZE(compsize);
481 ** Error occured; don't modify user's buffer.
485 ** For all the queries listed here, we use the locally stored
486 ** values rather than the one returned by the server. Note that
487 ** we still needed to send the request to the server in order to
488 ** find out whether it was legal to make a query (it's illegal,
489 ** for example, to call a query between glBegin() and glEnd()).
492 case GL_PACK_ROW_LENGTH:
493 *f = (GLfloat)state->storePack.rowLength;
495 case GL_PACK_IMAGE_HEIGHT:
496 *f = (GLfloat)state->storePack.imageHeight;
498 case GL_PACK_SKIP_ROWS:
499 *f = (GLfloat)state->storePack.skipRows;
501 case GL_PACK_SKIP_PIXELS:
502 *f = (GLfloat)state->storePack.skipPixels;
504 case GL_PACK_SKIP_IMAGES:
505 *f = (GLfloat)state->storePack.skipImages;
507 case GL_PACK_ALIGNMENT:
508 *f = (GLfloat)state->storePack.alignment;
510 case GL_PACK_SWAP_BYTES:
511 *f = (GLfloat)state->storePack.swapEndian;
513 case GL_PACK_LSB_FIRST:
514 *f = (GLfloat)state->storePack.lsbFirst;
516 case GL_UNPACK_ROW_LENGTH:
517 *f = (GLfloat)state->storeUnpack.rowLength;
519 case GL_UNPACK_IMAGE_HEIGHT:
520 *f = (GLfloat)state->storeUnpack.imageHeight;
522 case GL_UNPACK_SKIP_ROWS:
523 *f = (GLfloat)state->storeUnpack.skipRows;
525 case GL_UNPACK_SKIP_PIXELS:
526 *f = (GLfloat)state->storeUnpack.skipPixels;
528 case GL_UNPACK_SKIP_IMAGES:
529 *f = (GLfloat)state->storeUnpack.skipImages;
531 case GL_UNPACK_ALIGNMENT:
532 *f = (GLfloat)state->storeUnpack.alignment;
534 case GL_UNPACK_SWAP_BYTES:
535 *f = (GLfloat)state->storeUnpack.swapEndian;
537 case GL_UNPACK_LSB_FIRST:
538 *f = (GLfloat)state->storeUnpack.lsbFirst;
541 CASE_ARRAY_ALL(VERTEX, vertex, f, GLfloat);
543 CASE_ARRAY_ENABLE(NORMAL, normal, f, GLfloat);
544 CASE_ARRAY_TYPE(NORMAL, normal, f, GLfloat);
545 CASE_ARRAY_STRIDE(NORMAL, normal, f, GLfloat);
547 CASE_ARRAY_ALL(COLOR, color, f, GLfloat);
549 CASE_ARRAY_ENABLE(INDEX, index, f, GLfloat);
550 CASE_ARRAY_TYPE(INDEX, index, f, GLfloat);
551 CASE_ARRAY_STRIDE(INDEX, index, f, GLfloat);
553 case GL_TEXTURE_COORD_ARRAY:
554 *f = (GLfloat) IS_TEXARRAY_ENABLED(state, state->vertArray.activeTexture);
556 case GL_TEXTURE_COORD_ARRAY_SIZE:
557 *f = (GLfloat)state->vertArray.texCoord[state->vertArray.activeTexture].size;
559 case GL_TEXTURE_COORD_ARRAY_TYPE:
560 *f = (GLfloat)state->vertArray.texCoord[state->vertArray.activeTexture].type;
562 case GL_TEXTURE_COORD_ARRAY_STRIDE:
563 *f = (GLfloat)state->vertArray.texCoord[state->vertArray.activeTexture].stride;
566 CASE_ARRAY_ENABLE(EDGE_FLAG, edgeFlag, f, GLfloat);
567 CASE_ARRAY_STRIDE(EDGE_FLAG, edgeFlag, f, GLfloat);
569 CASE_ARRAY_ALL(SECONDARY_COLOR, secondaryColor, f, GLfloat);
571 CASE_ARRAY_ENABLE(FOG_COORD, fogCoord, f, GLfloat);
572 CASE_ARRAY_TYPE(FOG_COORD, fogCoord, f, GLfloat);
573 CASE_ARRAY_STRIDE(FOG_COORD, fogCoord, f, GLfloat);
575 case GL_MAX_ELEMENTS_VERTICES:
576 *f = (GLfloat)state->vertArray.maxElementsVertices;
578 case GL_MAX_ELEMENTS_INDICES:
579 *f = (GLfloat)state->vertArray.maxElementsIndices;
581 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
582 *f = (GLfloat)__GL_CLIENT_ATTRIB_STACK_DEPTH;
584 case GL_CLIENT_ACTIVE_TEXTURE_ARB:
585 *f = (GLfloat)(state->vertArray.activeTexture + GL_TEXTURE0_ARB);
589 ** Not a local value, so use what we got from the server.
592 __GLX_SINGLE_GET_FLOAT(f);
594 __GLX_SINGLE_GET_FLOAT_ARRAY(f,compsize);
595 if (val != origVal) {
596 /* matrix transpose */
605 void __indirect_glGetIntegerv(GLenum val, GLint *i)
607 const GLenum origVal = val;
608 __GLX_SINGLE_DECLARE_VARIABLES();
609 __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
610 xGLXSingleReply reply;
612 if (val == GL_TRANSPOSE_MODELVIEW_MATRIX_ARB) {
613 val = GL_MODELVIEW_MATRIX;
615 else if (val == GL_TRANSPOSE_PROJECTION_MATRIX_ARB) {
616 val = GL_PROJECTION_MATRIX;
618 else if (val == GL_TRANSPOSE_TEXTURE_MATRIX_ARB) {
619 val = GL_TEXTURE_MATRIX;
621 else if (val == GL_TRANSPOSE_COLOR_MATRIX_ARB) {
622 val = GL_COLOR_MATRIX;
625 __GLX_SINGLE_LOAD_VARIABLES();
626 __GLX_SINGLE_BEGIN(X_GLsop_GetIntegerv,4);
627 __GLX_SINGLE_PUT_LONG(0,val);
628 __GLX_SINGLE_READ_XREPLY();
629 __GLX_SINGLE_GET_SIZE(compsize);
633 ** Error occured; don't modify user's buffer.
637 ** For all the queries listed here, we use the locally stored
638 ** values rather than the one returned by the server. Note that
639 ** we still needed to send the request to the server in order to
640 ** find out whether it was legal to make a query (it's illegal,
641 ** for example, to call a query between glBegin() and glEnd()).
644 case GL_PACK_ROW_LENGTH:
645 *i = (GLint)state->storePack.rowLength;
647 case GL_PACK_IMAGE_HEIGHT:
648 *i = (GLint)state->storePack.imageHeight;
650 case GL_PACK_SKIP_ROWS:
651 *i = (GLint)state->storePack.skipRows;
653 case GL_PACK_SKIP_PIXELS:
654 *i = (GLint)state->storePack.skipPixels;
656 case GL_PACK_SKIP_IMAGES:
657 *i = (GLint)state->storePack.skipImages;
659 case GL_PACK_ALIGNMENT:
660 *i = (GLint)state->storePack.alignment;
662 case GL_PACK_SWAP_BYTES:
663 *i = (GLint)state->storePack.swapEndian;
665 case GL_PACK_LSB_FIRST:
666 *i = (GLint)state->storePack.lsbFirst;
668 case GL_UNPACK_ROW_LENGTH:
669 *i = (GLint)state->storeUnpack.rowLength;
671 case GL_UNPACK_IMAGE_HEIGHT:
672 *i = (GLint)state->storeUnpack.imageHeight;
674 case GL_UNPACK_SKIP_ROWS:
675 *i = (GLint)state->storeUnpack.skipRows;
677 case GL_UNPACK_SKIP_PIXELS:
678 *i = (GLint)state->storeUnpack.skipPixels;
680 case GL_UNPACK_SKIP_IMAGES:
681 *i = (GLint)state->storeUnpack.skipImages;
683 case GL_UNPACK_ALIGNMENT:
684 *i = (GLint)state->storeUnpack.alignment;
686 case GL_UNPACK_SWAP_BYTES:
687 *i = (GLint)state->storeUnpack.swapEndian;
689 case GL_UNPACK_LSB_FIRST:
690 *i = (GLint)state->storeUnpack.lsbFirst;
693 CASE_ARRAY_ALL(VERTEX, vertex, i, GLint);
695 CASE_ARRAY_ENABLE(NORMAL, normal, i, GLint);
696 CASE_ARRAY_TYPE(NORMAL, normal, i, GLint);
697 CASE_ARRAY_STRIDE(NORMAL, normal, i, GLint);
699 CASE_ARRAY_ALL(COLOR, color, i, GLint);
701 CASE_ARRAY_ENABLE(INDEX, index, i, GLint);
702 CASE_ARRAY_TYPE(INDEX, index, i, GLint);
703 CASE_ARRAY_STRIDE(INDEX, index, i, GLint);
705 case GL_TEXTURE_COORD_ARRAY:
706 *i = (GLint) IS_TEXARRAY_ENABLED(state, state->vertArray.activeTexture);
708 case GL_TEXTURE_COORD_ARRAY_SIZE:
709 *i = (GLint)state->vertArray.texCoord[state->vertArray.activeTexture].size;
711 case GL_TEXTURE_COORD_ARRAY_TYPE:
712 *i = (GLint)state->vertArray.texCoord[state->vertArray.activeTexture].type;
714 case GL_TEXTURE_COORD_ARRAY_STRIDE:
715 *i = (GLint)state->vertArray.texCoord[state->vertArray.activeTexture].stride;
718 CASE_ARRAY_ENABLE(EDGE_FLAG, edgeFlag, i, GLint);
719 CASE_ARRAY_STRIDE(EDGE_FLAG, edgeFlag, i, GLint);
721 CASE_ARRAY_ALL(SECONDARY_COLOR, secondaryColor, i, GLint);
723 CASE_ARRAY_ENABLE(FOG_COORD, fogCoord, i, GLint);
724 CASE_ARRAY_TYPE(FOG_COORD, fogCoord, i, GLint);
725 CASE_ARRAY_STRIDE(FOG_COORD, fogCoord, i, GLint);
727 case GL_MAX_ELEMENTS_VERTICES:
728 *i = (GLint)state->vertArray.maxElementsVertices;
730 case GL_MAX_ELEMENTS_INDICES:
731 *i = (GLint)state->vertArray.maxElementsIndices;
733 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
734 *i = (GLint)__GL_CLIENT_ATTRIB_STACK_DEPTH;
736 case GL_CLIENT_ACTIVE_TEXTURE_ARB:
737 *i = (GLint)(state->vertArray.activeTexture + GL_TEXTURE0_ARB);
741 ** Not a local value, so use what we got from the server.
744 __GLX_SINGLE_GET_LONG(i);
746 __GLX_SINGLE_GET_LONG_ARRAY(i,compsize);
747 if (val != origVal) {
748 /* matrix transpose */
758 ** Send all pending commands to server.
760 void __indirect_glFlush(void)
762 __GLX_SINGLE_DECLARE_VARIABLES();
766 __GLX_SINGLE_LOAD_VARIABLES();
767 __GLX_SINGLE_BEGIN(X_GLsop_Flush,0);
770 /* And finally flush the X protocol data */
774 void __indirect_glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
776 __GLX_SINGLE_DECLARE_VARIABLES();
780 __GLX_SINGLE_LOAD_VARIABLES();
781 __GLX_SINGLE_BEGIN(X_GLsop_FeedbackBuffer,8);
782 __GLX_SINGLE_PUT_LONG(0,size);
783 __GLX_SINGLE_PUT_LONG(4,type);
786 gc->feedbackBuf = buffer;
789 void __indirect_glSelectBuffer(GLsizei numnames, GLuint *buffer)
791 __GLX_SINGLE_DECLARE_VARIABLES();
795 __GLX_SINGLE_LOAD_VARIABLES();
796 __GLX_SINGLE_BEGIN(X_GLsop_SelectBuffer,4);
797 __GLX_SINGLE_PUT_LONG(0,numnames);
800 gc->selectBuf = buffer;
803 GLint __indirect_glRenderMode(GLenum mode)
805 __GLX_SINGLE_DECLARE_VARIABLES();
807 xGLXRenderModeReply reply;
811 __GLX_SINGLE_LOAD_VARIABLES();
812 __GLX_SINGLE_BEGIN(X_GLsop_RenderMode,4);
813 __GLX_SINGLE_PUT_LONG(0,mode);
814 __GLX_SINGLE_READ_XREPLY();
815 __GLX_SINGLE_GET_RETVAL(retval,GLint);
817 if (reply.newMode != mode) {
819 ** Switch to new mode did not take effect, therefore an error
820 ** occured. When an error happens the server won't send us any
824 /* Read the feedback or selection data */
825 if (gc->renderMode == GL_FEEDBACK) {
826 __GLX_SINGLE_GET_SIZE(compsize);
827 __GLX_SINGLE_GET_FLOAT_ARRAY(gc->feedbackBuf, compsize);
829 if (gc->renderMode == GL_SELECT) {
830 __GLX_SINGLE_GET_SIZE(compsize);
831 __GLX_SINGLE_GET_LONG_ARRAY(gc->selectBuf, compsize);
833 gc->renderMode = mode;
840 void __indirect_glFinish(void)
842 __GLX_SINGLE_DECLARE_VARIABLES();
843 xGLXSingleReply reply;
845 __GLX_SINGLE_LOAD_VARIABLES();
846 __GLX_SINGLE_BEGIN(X_GLsop_Finish,0);
847 __GLX_SINGLE_READ_XREPLY();
853 * Extract the major and minor version numbers from a version string.
856 version_from_string( const char * ver,
857 int * major_version, int * minor_version )
863 major = strtol( ver, (char **) & end, 10 );
864 minor = strtol( end + 1, NULL, 10 );
865 *major_version = major;
866 *minor_version = minor;
870 const GLubyte *__indirect_glGetString(GLenum name)
872 __GLXcontext *gc = __glXGetCurrentContext();
873 Display *dpy = gc->currentDpy;
879 ** Return the cached copy if the string has already been fetched
883 if (gc->vendor) return gc->vendor;
886 if (gc->renderer) return gc->renderer;
889 if (gc->version) return gc->version;
892 if (gc->extensions) return gc->extensions;
895 __glXSetError(gc, GL_INVALID_ENUM);
900 ** Get requested string from server
903 (void) __glXFlushRenderBuffer( gc, gc->pc );
904 s = (GLubyte *) __glXGetStringFromServer( dpy, gc->majorOpcode,
905 X_GLsop_GetString, gc->currentContextTag,
908 /* Throw data on the floor */
909 __glXSetError(gc, GL_OUT_OF_MEMORY);
912 ** Update local cache
927 version_from_string( (char *) s,
928 & gc->server_major, & gc->server_minor );
929 __glXGetGLVersion( & client_major, & client_minor );
931 if ( (gc->server_major < client_major)
932 || ((gc->server_major == client_major)
933 && (gc->server_minor <= client_minor)) ) {
937 /* Allow 7 bytes for the client-side GL version. This allows
938 * for upto version 999.999. I'm not holding my breath for
939 * that one! The extra 4 is for the ' ()\0' that will be
942 const size_t size = 7 + strlen( (char *) s ) + 4;
944 gc->version = Xmalloc( size );
945 if ( gc->version == NULL ) {
946 /* If we couldn't allocate memory for the new string,
947 * make a best-effort and just copy the client-side version
948 * to the string and use that. It probably doesn't
949 * matter what is done here. If there not memory available
950 * for a short string, the system is probably going to die
953 snprintf( (char *) s, strlen( (char *) s ) + 1, "%u.%u",
954 client_major, client_minor );
958 snprintf( (char *)gc->version, size, "%u.%u (%s)",
959 client_major, client_minor, s );
967 case GL_EXTENSIONS: {
971 /* This code is currently disabled. I was reminded that some
972 * vendors intentionally exclude some extensions from their
973 * extension string that are part of the core version they
974 * advertise. In particular, on Nvidia drivers this means that
975 * the functionality is supported by the driver, but is not
976 * hardware accelerated. For example, a TNT will show core
977 * version 1.5, but most of the post-1.2 functionality is a
980 * I don't want to break applications that rely on this odd
981 * behavior. At the same time, the code is written and tested,
982 * so I didn't want to throw it away. Therefore, the code is here
983 * but disabled. In the future, we may wish to and an environment
984 * variable to enable it.
988 /* Call glGetString just to make sure that gc->server_major and
989 * gc->server_minor are set. This version may be higher than we
990 * can completely support, but it may imply support for some
991 * extensions that we can support.
993 * For example, at the time of this writing, the client-side
994 * library only supports upto core GL version 1.2. However, cubic
995 * textures, multitexture, multisampling, and some other 1.3
996 * features are supported. If the server reports back version
997 * 1.3, but does not report all of those extensions, we will
1000 (void *) glGetString( GL_VERSION );
1001 major = gc->server_major,
1002 minor = gc->server_minor;
1005 __glXCalculateUsableGLExtensions( gc, (char *) s, major, minor );
1015 GLboolean __indirect_glIsEnabled(GLenum cap)
1017 __GLX_SINGLE_DECLARE_VARIABLES();
1018 __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
1019 xGLXSingleReply reply;
1020 GLboolean retval = 0;
1025 case GL_VERTEX_ARRAY:
1026 return IS_ARRAY_ENABLED(state, vertex);
1027 case GL_NORMAL_ARRAY:
1028 return IS_ARRAY_ENABLED(state, normal);
1029 case GL_COLOR_ARRAY:
1030 return IS_ARRAY_ENABLED(state, color);
1031 case GL_INDEX_ARRAY:
1032 return IS_ARRAY_ENABLED(state, index);
1033 case GL_TEXTURE_COORD_ARRAY:
1034 return IS_TEXARRAY_ENABLED(state, state->vertArray.activeTexture);
1035 case GL_EDGE_FLAG_ARRAY:
1036 return IS_ARRAY_ENABLED(state, edgeFlag);
1037 case GL_SECONDARY_COLOR_ARRAY:
1038 return IS_ARRAY_ENABLED(state, secondaryColor);
1039 case GL_FOG_COORD_ARRAY:
1040 return IS_ARRAY_ENABLED(state, fogCoord);
1043 __GLX_SINGLE_LOAD_VARIABLES();
1044 __GLX_SINGLE_BEGIN(X_GLsop_IsEnabled,4);
1045 __GLX_SINGLE_PUT_LONG(0,cap);
1046 __GLX_SINGLE_READ_XREPLY();
1047 __GLX_SINGLE_GET_RETVAL(retval, GLboolean);
1052 void __indirect_glGetPointerv(GLenum pname, void **params)
1054 __GLXcontext *gc = __glXGetCurrentContext();
1055 __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
1056 Display *dpy = gc->currentDpy;
1061 case GL_VERTEX_ARRAY_POINTER:
1062 *params = (void *)state->vertArray.arrays[ vertex_ARRAY ].ptr;
1064 case GL_NORMAL_ARRAY_POINTER:
1065 *params = (void *)state->vertArray.arrays[ normal_ARRAY ].ptr;
1067 case GL_COLOR_ARRAY_POINTER:
1068 *params = (void *)state->vertArray.arrays[ color_ARRAY ].ptr;
1070 case GL_INDEX_ARRAY_POINTER:
1071 *params = (void *)state->vertArray.arrays[ index_ARRAY ].ptr;
1073 case GL_TEXTURE_COORD_ARRAY_POINTER:
1074 *params = (void *)state->vertArray.texCoord[state->vertArray.activeTexture].ptr;
1076 case GL_EDGE_FLAG_ARRAY_POINTER:
1077 *params = (void *)state->vertArray.arrays[ edgeFlag_ARRAY ].ptr;
1079 case GL_SECONDARY_COLOR_ARRAY_POINTER:
1080 *params = (void *)state->vertArray.arrays[ secondaryColor_ARRAY ].ptr;
1082 case GL_FOG_COORD_ARRAY_POINTER:
1083 *params = (void *)state->vertArray.arrays[ fogCoord_ARRAY ].ptr;
1085 case GL_FEEDBACK_BUFFER_POINTER:
1086 *params = (void *)gc->feedbackBuf;
1088 case GL_SELECTION_BUFFER_POINTER:
1089 *params = (void *)gc->selectBuf;
1092 __glXSetError(gc, GL_INVALID_ENUM);