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
++) {
96 * Remap a transpose-matrix enum to a non-transpose-matrix enum. Enums
97 * that are not transpose-matrix enums are unaffected.
100 RemapTransposeEnum( GLenum e
)
103 case GL_TRANSPOSE_MODELVIEW_MATRIX
:
104 case GL_TRANSPOSE_PROJECTION_MATRIX
:
105 case GL_TRANSPOSE_TEXTURE_MATRIX
:
106 return e
- (GL_TRANSPOSE_MODELVIEW_MATRIX
- GL_MODELVIEW_MATRIX
);
107 case GL_TRANSPOSE_COLOR_MATRIX
:
108 return GL_COLOR_MATRIX
;
115 GLenum
__indirect_glGetError(void)
117 __GLX_SINGLE_DECLARE_VARIABLES();
118 GLuint retval
= GL_NO_ERROR
;
119 xGLXGetErrorReply reply
;
122 /* Use internal error first */
124 gc
->error
= GL_NO_ERROR
;
128 __GLX_SINGLE_LOAD_VARIABLES();
129 __GLX_SINGLE_BEGIN(X_GLsop_GetError
,0);
130 __GLX_SINGLE_READ_XREPLY();
131 retval
= reply
.error
;
137 #define CASE_ARRAY_ENABLE(enum_name,array,dest,gl_type) \
138 case GL_ ## enum_name ## _ARRAY: \
139 *dest = (gl_type) (IS_ARRAY_ENABLED(state, array)); break
140 #define CASE_ARRAY_SIZE(enum_name,array,dest,gl_type) \
141 case GL_ ## enum_name ## _ARRAY_SIZE: \
142 *dest = (gl_type) state->vertArray.arrays[array ## _ARRAY].size ; break
143 #define CASE_ARRAY_TYPE(enum_name,array,dest,gl_type) \
144 case GL_ ## enum_name ## _ARRAY_TYPE: \
145 *dest = (gl_type) state->vertArray.arrays[array ## _ARRAY].type ; break
146 #define CASE_ARRAY_STRIDE(enum_name,array,dest,gl_type) \
147 case GL_ ## enum_name ## _ARRAY_STRIDE: \
148 *dest = (gl_type) state->vertArray.arrays[array ## _ARRAY].stride ; break
150 #define CASE_ARRAY_ALL(enum_name,array,dest,gl_type) \
151 CASE_ARRAY_ENABLE(enum_name,array,dest,gl_type); \
152 CASE_ARRAY_STRIDE(enum_name,array,dest,gl_type); \
153 CASE_ARRAY_TYPE(enum_name,array,dest,gl_type); \
154 CASE_ARRAY_SIZE(enum_name,array,dest,gl_type)
156 void __indirect_glGetBooleanv(GLenum val
, GLboolean
*b
)
158 const GLenum origVal
= val
;
159 __GLX_SINGLE_DECLARE_VARIABLES();
160 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
161 xGLXSingleReply reply
;
163 val
= RemapTransposeEnum( val
);
165 __GLX_SINGLE_LOAD_VARIABLES();
166 __GLX_SINGLE_BEGIN(X_GLsop_GetBooleanv
,4);
167 __GLX_SINGLE_PUT_LONG(0,val
);
168 __GLX_SINGLE_READ_XREPLY();
169 __GLX_SINGLE_GET_SIZE(compsize
);
173 ** Error occured; don't modify user's buffer.
177 ** For all the queries listed here, we use the locally stored
178 ** values rather than the one returned by the server. Note that
179 ** we still needed to send the request to the server in order to
180 ** find out whether it was legal to make a query (it's illegal,
181 ** for example, to call a query between glBegin() and glEnd()).
184 case GL_PACK_ROW_LENGTH
:
185 *b
= (GLboolean
)state
->storePack
.rowLength
;
187 case GL_PACK_IMAGE_HEIGHT
:
188 *b
= (GLboolean
)state
->storePack
.imageHeight
;
190 case GL_PACK_SKIP_ROWS
:
191 *b
= (GLboolean
)state
->storePack
.skipRows
;
193 case GL_PACK_SKIP_PIXELS
:
194 *b
= (GLboolean
)state
->storePack
.skipPixels
;
196 case GL_PACK_SKIP_IMAGES
:
197 *b
= (GLboolean
)state
->storePack
.skipImages
;
199 case GL_PACK_ALIGNMENT
:
200 *b
= (GLboolean
)state
->storePack
.alignment
;
202 case GL_PACK_SWAP_BYTES
:
203 *b
= (GLboolean
)state
->storePack
.swapEndian
;
205 case GL_PACK_LSB_FIRST
:
206 *b
= (GLboolean
)state
->storePack
.lsbFirst
;
208 case GL_UNPACK_ROW_LENGTH
:
209 *b
= (GLboolean
)state
->storeUnpack
.rowLength
;
211 case GL_UNPACK_IMAGE_HEIGHT
:
212 *b
= (GLboolean
)state
->storeUnpack
.imageHeight
;
214 case GL_UNPACK_SKIP_ROWS
:
215 *b
= (GLboolean
)state
->storeUnpack
.skipRows
;
217 case GL_UNPACK_SKIP_PIXELS
:
218 *b
= (GLboolean
)state
->storeUnpack
.skipPixels
;
220 case GL_UNPACK_SKIP_IMAGES
:
221 *b
= (GLboolean
)state
->storeUnpack
.skipImages
;
223 case GL_UNPACK_ALIGNMENT
:
224 *b
= (GLboolean
)state
->storeUnpack
.alignment
;
226 case GL_UNPACK_SWAP_BYTES
:
227 *b
= (GLboolean
)state
->storeUnpack
.swapEndian
;
229 case GL_UNPACK_LSB_FIRST
:
230 *b
= (GLboolean
)state
->storeUnpack
.lsbFirst
;
233 CASE_ARRAY_ALL(VERTEX
, vertex
, b
, GLboolean
);
235 CASE_ARRAY_ENABLE(NORMAL
, normal
, b
, GLboolean
);
236 CASE_ARRAY_TYPE(NORMAL
, normal
, b
, GLboolean
);
237 CASE_ARRAY_STRIDE(NORMAL
, normal
, b
, GLboolean
);
239 CASE_ARRAY_ALL(COLOR
, color
, b
, GLboolean
);
241 CASE_ARRAY_ENABLE(INDEX
, index
, b
, GLboolean
);
242 CASE_ARRAY_TYPE(INDEX
, index
, b
, GLboolean
);
243 CASE_ARRAY_STRIDE(INDEX
, index
, b
, GLboolean
);
245 case GL_TEXTURE_COORD_ARRAY
:
246 *b
= (GLboolean
)IS_TEXARRAY_ENABLED(state
, state
->vertArray
.activeTexture
);
248 case GL_TEXTURE_COORD_ARRAY_SIZE
:
249 *b
= (GLboolean
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].size
;
251 case GL_TEXTURE_COORD_ARRAY_TYPE
:
252 *b
= (GLboolean
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].type
;
254 case GL_TEXTURE_COORD_ARRAY_STRIDE
:
255 *b
= (GLboolean
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].stride
;
258 CASE_ARRAY_ENABLE(EDGE_FLAG
, edgeFlag
, b
, GLboolean
);
259 CASE_ARRAY_STRIDE(EDGE_FLAG
, edgeFlag
, b
, GLboolean
);
261 CASE_ARRAY_ALL(SECONDARY_COLOR
, secondaryColor
, b
, GLboolean
);
263 CASE_ARRAY_ENABLE(FOG_COORD
, fogCoord
, b
, GLboolean
);
264 CASE_ARRAY_TYPE(FOG_COORD
, fogCoord
, b
, GLboolean
);
265 CASE_ARRAY_STRIDE(FOG_COORD
, fogCoord
, b
, GLboolean
);
267 case GL_MAX_ELEMENTS_VERTICES
:
268 *b
= (GLboolean
)state
->vertArray
.maxElementsVertices
;
270 case GL_MAX_ELEMENTS_INDICES
:
271 *b
= (GLboolean
)state
->vertArray
.maxElementsIndices
;
273 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH
:
274 *b
= (GLboolean
)__GL_CLIENT_ATTRIB_STACK_DEPTH
;
276 case GL_CLIENT_ACTIVE_TEXTURE_ARB
:
277 *b
= (GLboolean
)(state
->vertArray
.activeTexture
+ GL_TEXTURE0_ARB
);
281 ** Not a local value, so use what we got from the server.
284 __GLX_SINGLE_GET_CHAR(b
);
286 __GLX_SINGLE_GET_CHAR_ARRAY(b
,compsize
);
287 if (val
!= origVal
) {
288 /* matrix transpose */
297 void __indirect_glGetDoublev(GLenum val
, GLdouble
*d
)
299 const GLenum origVal
= val
;
300 __GLX_SINGLE_DECLARE_VARIABLES();
301 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
302 xGLXSingleReply reply
;
304 val
= RemapTransposeEnum( val
);
306 __GLX_SINGLE_LOAD_VARIABLES();
307 __GLX_SINGLE_BEGIN(X_GLsop_GetDoublev
,4);
308 __GLX_SINGLE_PUT_LONG(0,val
);
309 __GLX_SINGLE_READ_XREPLY();
310 __GLX_SINGLE_GET_SIZE(compsize
);
314 ** Error occured; don't modify user's buffer.
318 ** For all the queries listed here, we use the locally stored
319 ** values rather than the one returned by the server. Note that
320 ** we still needed to send the request to the server in order to
321 ** find out whether it was legal to make a query (it's illegal,
322 ** for example, to call a query between glBegin() and glEnd()).
325 case GL_PACK_ROW_LENGTH
:
326 *d
= (GLdouble
)state
->storePack
.rowLength
;
328 case GL_PACK_IMAGE_HEIGHT
:
329 *d
= (GLdouble
)state
->storePack
.imageHeight
;
331 case GL_PACK_SKIP_ROWS
:
332 *d
= (GLdouble
)state
->storePack
.skipRows
;
334 case GL_PACK_SKIP_PIXELS
:
335 *d
= (GLdouble
)state
->storePack
.skipPixels
;
337 case GL_PACK_SKIP_IMAGES
:
338 *d
= (GLdouble
)state
->storePack
.skipImages
;
340 case GL_PACK_ALIGNMENT
:
341 *d
= (GLdouble
)state
->storePack
.alignment
;
343 case GL_PACK_SWAP_BYTES
:
344 *d
= (GLdouble
)state
->storePack
.swapEndian
;
346 case GL_PACK_LSB_FIRST
:
347 *d
= (GLdouble
)state
->storePack
.lsbFirst
;
349 case GL_UNPACK_ROW_LENGTH
:
350 *d
= (GLdouble
)state
->storeUnpack
.rowLength
;
352 case GL_UNPACK_IMAGE_HEIGHT
:
353 *d
= (GLdouble
)state
->storeUnpack
.imageHeight
;
355 case GL_UNPACK_SKIP_ROWS
:
356 *d
= (GLdouble
)state
->storeUnpack
.skipRows
;
358 case GL_UNPACK_SKIP_PIXELS
:
359 *d
= (GLdouble
)state
->storeUnpack
.skipPixels
;
361 case GL_UNPACK_SKIP_IMAGES
:
362 *d
= (GLdouble
)state
->storeUnpack
.skipImages
;
364 case GL_UNPACK_ALIGNMENT
:
365 *d
= (GLdouble
)state
->storeUnpack
.alignment
;
367 case GL_UNPACK_SWAP_BYTES
:
368 *d
= (GLdouble
)state
->storeUnpack
.swapEndian
;
370 case GL_UNPACK_LSB_FIRST
:
371 *d
= (GLdouble
)state
->storeUnpack
.lsbFirst
;
374 CASE_ARRAY_ALL(VERTEX
, vertex
, d
, GLdouble
);
376 CASE_ARRAY_ENABLE(NORMAL
, normal
, d
, GLdouble
);
377 CASE_ARRAY_TYPE(NORMAL
, normal
, d
, GLdouble
);
378 CASE_ARRAY_STRIDE(NORMAL
, normal
, d
, GLdouble
);
380 CASE_ARRAY_ALL(COLOR
, color
, d
, GLdouble
);
382 CASE_ARRAY_ENABLE(INDEX
, index
, d
, GLdouble
);
383 CASE_ARRAY_TYPE(INDEX
, index
, d
, GLdouble
);
384 CASE_ARRAY_STRIDE(INDEX
, index
, d
, GLdouble
);
386 case GL_TEXTURE_COORD_ARRAY
:
387 *d
= (GLdouble
) IS_TEXARRAY_ENABLED(state
, state
->vertArray
.activeTexture
);
389 case GL_TEXTURE_COORD_ARRAY_SIZE
:
390 *d
= (GLdouble
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].size
;
392 case GL_TEXTURE_COORD_ARRAY_TYPE
:
393 *d
= (GLdouble
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].type
;
395 case GL_TEXTURE_COORD_ARRAY_STRIDE
:
396 *d
= (GLdouble
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].stride
;
399 CASE_ARRAY_ENABLE(EDGE_FLAG
, edgeFlag
, d
, GLdouble
);
400 CASE_ARRAY_STRIDE(EDGE_FLAG
, edgeFlag
, d
, GLdouble
);
402 CASE_ARRAY_ALL(SECONDARY_COLOR
, secondaryColor
, d
, GLdouble
);
404 CASE_ARRAY_ENABLE(FOG_COORD
, fogCoord
, d
, GLdouble
);
405 CASE_ARRAY_TYPE(FOG_COORD
, fogCoord
, d
, GLdouble
);
406 CASE_ARRAY_STRIDE(FOG_COORD
, fogCoord
, d
, GLdouble
);
408 case GL_MAX_ELEMENTS_VERTICES
:
409 *d
= (GLdouble
)state
->vertArray
.maxElementsVertices
;
411 case GL_MAX_ELEMENTS_INDICES
:
412 *d
= (GLdouble
)state
->vertArray
.maxElementsIndices
;
414 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH
:
415 *d
= (GLdouble
)__GL_CLIENT_ATTRIB_STACK_DEPTH
;
417 case GL_CLIENT_ACTIVE_TEXTURE_ARB
:
418 *d
= (GLdouble
)(state
->vertArray
.activeTexture
+ GL_TEXTURE0_ARB
);
422 ** Not a local value, so use what we got from the server.
425 __GLX_SINGLE_GET_DOUBLE(d
);
427 __GLX_SINGLE_GET_DOUBLE_ARRAY(d
,compsize
);
428 if (val
!= origVal
) {
429 /* matrix transpose */
438 void __indirect_glGetFloatv(GLenum val
, GLfloat
*f
)
440 const GLenum origVal
= val
;
441 __GLX_SINGLE_DECLARE_VARIABLES();
442 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
443 xGLXSingleReply reply
;
445 val
= RemapTransposeEnum( val
);
447 __GLX_SINGLE_LOAD_VARIABLES();
448 __GLX_SINGLE_BEGIN(X_GLsop_GetFloatv
,4);
449 __GLX_SINGLE_PUT_LONG(0,val
);
450 __GLX_SINGLE_READ_XREPLY();
451 __GLX_SINGLE_GET_SIZE(compsize
);
455 ** Error occured; don't modify user's buffer.
459 ** For all the queries listed here, we use the locally stored
460 ** values rather than the one returned by the server. Note that
461 ** we still needed to send the request to the server in order to
462 ** find out whether it was legal to make a query (it's illegal,
463 ** for example, to call a query between glBegin() and glEnd()).
466 case GL_PACK_ROW_LENGTH
:
467 *f
= (GLfloat
)state
->storePack
.rowLength
;
469 case GL_PACK_IMAGE_HEIGHT
:
470 *f
= (GLfloat
)state
->storePack
.imageHeight
;
472 case GL_PACK_SKIP_ROWS
:
473 *f
= (GLfloat
)state
->storePack
.skipRows
;
475 case GL_PACK_SKIP_PIXELS
:
476 *f
= (GLfloat
)state
->storePack
.skipPixels
;
478 case GL_PACK_SKIP_IMAGES
:
479 *f
= (GLfloat
)state
->storePack
.skipImages
;
481 case GL_PACK_ALIGNMENT
:
482 *f
= (GLfloat
)state
->storePack
.alignment
;
484 case GL_PACK_SWAP_BYTES
:
485 *f
= (GLfloat
)state
->storePack
.swapEndian
;
487 case GL_PACK_LSB_FIRST
:
488 *f
= (GLfloat
)state
->storePack
.lsbFirst
;
490 case GL_UNPACK_ROW_LENGTH
:
491 *f
= (GLfloat
)state
->storeUnpack
.rowLength
;
493 case GL_UNPACK_IMAGE_HEIGHT
:
494 *f
= (GLfloat
)state
->storeUnpack
.imageHeight
;
496 case GL_UNPACK_SKIP_ROWS
:
497 *f
= (GLfloat
)state
->storeUnpack
.skipRows
;
499 case GL_UNPACK_SKIP_PIXELS
:
500 *f
= (GLfloat
)state
->storeUnpack
.skipPixels
;
502 case GL_UNPACK_SKIP_IMAGES
:
503 *f
= (GLfloat
)state
->storeUnpack
.skipImages
;
505 case GL_UNPACK_ALIGNMENT
:
506 *f
= (GLfloat
)state
->storeUnpack
.alignment
;
508 case GL_UNPACK_SWAP_BYTES
:
509 *f
= (GLfloat
)state
->storeUnpack
.swapEndian
;
511 case GL_UNPACK_LSB_FIRST
:
512 *f
= (GLfloat
)state
->storeUnpack
.lsbFirst
;
515 CASE_ARRAY_ALL(VERTEX
, vertex
, f
, GLfloat
);
517 CASE_ARRAY_ENABLE(NORMAL
, normal
, f
, GLfloat
);
518 CASE_ARRAY_TYPE(NORMAL
, normal
, f
, GLfloat
);
519 CASE_ARRAY_STRIDE(NORMAL
, normal
, f
, GLfloat
);
521 CASE_ARRAY_ALL(COLOR
, color
, f
, GLfloat
);
523 CASE_ARRAY_ENABLE(INDEX
, index
, f
, GLfloat
);
524 CASE_ARRAY_TYPE(INDEX
, index
, f
, GLfloat
);
525 CASE_ARRAY_STRIDE(INDEX
, index
, f
, GLfloat
);
527 case GL_TEXTURE_COORD_ARRAY
:
528 *f
= (GLfloat
) IS_TEXARRAY_ENABLED(state
, state
->vertArray
.activeTexture
);
530 case GL_TEXTURE_COORD_ARRAY_SIZE
:
531 *f
= (GLfloat
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].size
;
533 case GL_TEXTURE_COORD_ARRAY_TYPE
:
534 *f
= (GLfloat
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].type
;
536 case GL_TEXTURE_COORD_ARRAY_STRIDE
:
537 *f
= (GLfloat
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].stride
;
540 CASE_ARRAY_ENABLE(EDGE_FLAG
, edgeFlag
, f
, GLfloat
);
541 CASE_ARRAY_STRIDE(EDGE_FLAG
, edgeFlag
, f
, GLfloat
);
543 CASE_ARRAY_ALL(SECONDARY_COLOR
, secondaryColor
, f
, GLfloat
);
545 CASE_ARRAY_ENABLE(FOG_COORD
, fogCoord
, f
, GLfloat
);
546 CASE_ARRAY_TYPE(FOG_COORD
, fogCoord
, f
, GLfloat
);
547 CASE_ARRAY_STRIDE(FOG_COORD
, fogCoord
, f
, GLfloat
);
549 case GL_MAX_ELEMENTS_VERTICES
:
550 *f
= (GLfloat
)state
->vertArray
.maxElementsVertices
;
552 case GL_MAX_ELEMENTS_INDICES
:
553 *f
= (GLfloat
)state
->vertArray
.maxElementsIndices
;
555 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH
:
556 *f
= (GLfloat
)__GL_CLIENT_ATTRIB_STACK_DEPTH
;
558 case GL_CLIENT_ACTIVE_TEXTURE_ARB
:
559 *f
= (GLfloat
)(state
->vertArray
.activeTexture
+ GL_TEXTURE0_ARB
);
563 ** Not a local value, so use what we got from the server.
566 __GLX_SINGLE_GET_FLOAT(f
);
568 __GLX_SINGLE_GET_FLOAT_ARRAY(f
,compsize
);
569 if (val
!= origVal
) {
570 /* matrix transpose */
579 void __indirect_glGetIntegerv(GLenum val
, GLint
*i
)
581 const GLenum origVal
= val
;
582 __GLX_SINGLE_DECLARE_VARIABLES();
583 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
584 xGLXSingleReply reply
;
586 val
= RemapTransposeEnum( val
);
588 __GLX_SINGLE_LOAD_VARIABLES();
589 __GLX_SINGLE_BEGIN(X_GLsop_GetIntegerv
,4);
590 __GLX_SINGLE_PUT_LONG(0,val
);
591 __GLX_SINGLE_READ_XREPLY();
592 __GLX_SINGLE_GET_SIZE(compsize
);
596 ** Error occured; don't modify user's buffer.
600 ** For all the queries listed here, we use the locally stored
601 ** values rather than the one returned by the server. Note that
602 ** we still needed to send the request to the server in order to
603 ** find out whether it was legal to make a query (it's illegal,
604 ** for example, to call a query between glBegin() and glEnd()).
607 case GL_PACK_ROW_LENGTH
:
608 *i
= (GLint
)state
->storePack
.rowLength
;
610 case GL_PACK_IMAGE_HEIGHT
:
611 *i
= (GLint
)state
->storePack
.imageHeight
;
613 case GL_PACK_SKIP_ROWS
:
614 *i
= (GLint
)state
->storePack
.skipRows
;
616 case GL_PACK_SKIP_PIXELS
:
617 *i
= (GLint
)state
->storePack
.skipPixels
;
619 case GL_PACK_SKIP_IMAGES
:
620 *i
= (GLint
)state
->storePack
.skipImages
;
622 case GL_PACK_ALIGNMENT
:
623 *i
= (GLint
)state
->storePack
.alignment
;
625 case GL_PACK_SWAP_BYTES
:
626 *i
= (GLint
)state
->storePack
.swapEndian
;
628 case GL_PACK_LSB_FIRST
:
629 *i
= (GLint
)state
->storePack
.lsbFirst
;
631 case GL_UNPACK_ROW_LENGTH
:
632 *i
= (GLint
)state
->storeUnpack
.rowLength
;
634 case GL_UNPACK_IMAGE_HEIGHT
:
635 *i
= (GLint
)state
->storeUnpack
.imageHeight
;
637 case GL_UNPACK_SKIP_ROWS
:
638 *i
= (GLint
)state
->storeUnpack
.skipRows
;
640 case GL_UNPACK_SKIP_PIXELS
:
641 *i
= (GLint
)state
->storeUnpack
.skipPixels
;
643 case GL_UNPACK_SKIP_IMAGES
:
644 *i
= (GLint
)state
->storeUnpack
.skipImages
;
646 case GL_UNPACK_ALIGNMENT
:
647 *i
= (GLint
)state
->storeUnpack
.alignment
;
649 case GL_UNPACK_SWAP_BYTES
:
650 *i
= (GLint
)state
->storeUnpack
.swapEndian
;
652 case GL_UNPACK_LSB_FIRST
:
653 *i
= (GLint
)state
->storeUnpack
.lsbFirst
;
656 CASE_ARRAY_ALL(VERTEX
, vertex
, i
, GLint
);
658 CASE_ARRAY_ENABLE(NORMAL
, normal
, i
, GLint
);
659 CASE_ARRAY_TYPE(NORMAL
, normal
, i
, GLint
);
660 CASE_ARRAY_STRIDE(NORMAL
, normal
, i
, GLint
);
662 CASE_ARRAY_ALL(COLOR
, color
, i
, GLint
);
664 CASE_ARRAY_ENABLE(INDEX
, index
, i
, GLint
);
665 CASE_ARRAY_TYPE(INDEX
, index
, i
, GLint
);
666 CASE_ARRAY_STRIDE(INDEX
, index
, i
, GLint
);
668 case GL_TEXTURE_COORD_ARRAY
:
669 *i
= (GLint
) IS_TEXARRAY_ENABLED(state
, state
->vertArray
.activeTexture
);
671 case GL_TEXTURE_COORD_ARRAY_SIZE
:
672 *i
= (GLint
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].size
;
674 case GL_TEXTURE_COORD_ARRAY_TYPE
:
675 *i
= (GLint
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].type
;
677 case GL_TEXTURE_COORD_ARRAY_STRIDE
:
678 *i
= (GLint
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].stride
;
681 CASE_ARRAY_ENABLE(EDGE_FLAG
, edgeFlag
, i
, GLint
);
682 CASE_ARRAY_STRIDE(EDGE_FLAG
, edgeFlag
, i
, GLint
);
684 CASE_ARRAY_ALL(SECONDARY_COLOR
, secondaryColor
, i
, GLint
);
686 CASE_ARRAY_ENABLE(FOG_COORD
, fogCoord
, i
, GLint
);
687 CASE_ARRAY_TYPE(FOG_COORD
, fogCoord
, i
, GLint
);
688 CASE_ARRAY_STRIDE(FOG_COORD
, fogCoord
, i
, GLint
);
690 case GL_MAX_ELEMENTS_VERTICES
:
691 *i
= (GLint
)state
->vertArray
.maxElementsVertices
;
693 case GL_MAX_ELEMENTS_INDICES
:
694 *i
= (GLint
)state
->vertArray
.maxElementsIndices
;
696 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH
:
697 *i
= (GLint
)__GL_CLIENT_ATTRIB_STACK_DEPTH
;
699 case GL_CLIENT_ACTIVE_TEXTURE_ARB
:
700 *i
= (GLint
)(state
->vertArray
.activeTexture
+ GL_TEXTURE0_ARB
);
704 ** Not a local value, so use what we got from the server.
707 __GLX_SINGLE_GET_LONG(i
);
709 __GLX_SINGLE_GET_LONG_ARRAY(i
,compsize
);
710 if (val
!= origVal
) {
711 /* matrix transpose */
721 ** Send all pending commands to server.
723 void __indirect_glFlush(void)
725 __GLX_SINGLE_DECLARE_VARIABLES();
729 __GLX_SINGLE_LOAD_VARIABLES();
730 __GLX_SINGLE_BEGIN(X_GLsop_Flush
,0);
733 /* And finally flush the X protocol data */
737 void __indirect_glFeedbackBuffer(GLsizei size
, GLenum type
, GLfloat
*buffer
)
739 __GLX_SINGLE_DECLARE_VARIABLES();
743 __GLX_SINGLE_LOAD_VARIABLES();
744 __GLX_SINGLE_BEGIN(X_GLsop_FeedbackBuffer
,8);
745 __GLX_SINGLE_PUT_LONG(0,size
);
746 __GLX_SINGLE_PUT_LONG(4,type
);
749 gc
->feedbackBuf
= buffer
;
752 void __indirect_glSelectBuffer(GLsizei numnames
, GLuint
*buffer
)
754 __GLX_SINGLE_DECLARE_VARIABLES();
758 __GLX_SINGLE_LOAD_VARIABLES();
759 __GLX_SINGLE_BEGIN(X_GLsop_SelectBuffer
,4);
760 __GLX_SINGLE_PUT_LONG(0,numnames
);
763 gc
->selectBuf
= buffer
;
766 GLint
__indirect_glRenderMode(GLenum mode
)
768 __GLX_SINGLE_DECLARE_VARIABLES();
770 xGLXRenderModeReply reply
;
774 __GLX_SINGLE_LOAD_VARIABLES();
775 __GLX_SINGLE_BEGIN(X_GLsop_RenderMode
,4);
776 __GLX_SINGLE_PUT_LONG(0,mode
);
777 __GLX_SINGLE_READ_XREPLY();
778 __GLX_SINGLE_GET_RETVAL(retval
,GLint
);
780 if (reply
.newMode
!= mode
) {
782 ** Switch to new mode did not take effect, therefore an error
783 ** occured. When an error happens the server won't send us any
787 /* Read the feedback or selection data */
788 if (gc
->renderMode
== GL_FEEDBACK
) {
789 __GLX_SINGLE_GET_SIZE(compsize
);
790 __GLX_SINGLE_GET_FLOAT_ARRAY(gc
->feedbackBuf
, compsize
);
792 if (gc
->renderMode
== GL_SELECT
) {
793 __GLX_SINGLE_GET_SIZE(compsize
);
794 __GLX_SINGLE_GET_LONG_ARRAY(gc
->selectBuf
, compsize
);
796 gc
->renderMode
= mode
;
803 void __indirect_glFinish(void)
805 __GLX_SINGLE_DECLARE_VARIABLES();
806 xGLXSingleReply reply
;
808 __GLX_SINGLE_LOAD_VARIABLES();
809 __GLX_SINGLE_BEGIN(X_GLsop_Finish
,0);
810 __GLX_SINGLE_READ_XREPLY();
816 * Extract the major and minor version numbers from a version string.
819 version_from_string( const char * ver
,
820 int * major_version
, int * minor_version
)
826 major
= strtol( ver
, (char **) & end
, 10 );
827 minor
= strtol( end
+ 1, NULL
, 10 );
828 *major_version
= major
;
829 *minor_version
= minor
;
833 const GLubyte
*__indirect_glGetString(GLenum name
)
835 __GLXcontext
*gc
= __glXGetCurrentContext();
836 Display
*dpy
= gc
->currentDpy
;
842 ** Return the cached copy if the string has already been fetched
846 if (gc
->vendor
) return gc
->vendor
;
849 if (gc
->renderer
) return gc
->renderer
;
852 if (gc
->version
) return gc
->version
;
855 if (gc
->extensions
) return gc
->extensions
;
858 __glXSetError(gc
, GL_INVALID_ENUM
);
863 ** Get requested string from server
866 (void) __glXFlushRenderBuffer( gc
, gc
->pc
);
867 s
= (GLubyte
*) __glXGetStringFromServer( dpy
, gc
->majorOpcode
,
868 X_GLsop_GetString
, gc
->currentContextTag
,
871 /* Throw data on the floor */
872 __glXSetError(gc
, GL_OUT_OF_MEMORY
);
875 ** Update local cache
890 version_from_string( (char *) s
,
891 & gc
->server_major
, & gc
->server_minor
);
892 __glXGetGLVersion( & client_major
, & client_minor
);
894 if ( (gc
->server_major
< client_major
)
895 || ((gc
->server_major
== client_major
)
896 && (gc
->server_minor
<= client_minor
)) ) {
900 /* Allow 7 bytes for the client-side GL version. This allows
901 * for upto version 999.999. I'm not holding my breath for
902 * that one! The extra 4 is for the ' ()\0' that will be
905 const size_t size
= 7 + strlen( (char *) s
) + 4;
907 gc
->version
= Xmalloc( size
);
908 if ( gc
->version
== NULL
) {
909 /* If we couldn't allocate memory for the new string,
910 * make a best-effort and just copy the client-side version
911 * to the string and use that. It probably doesn't
912 * matter what is done here. If there not memory available
913 * for a short string, the system is probably going to die
916 snprintf( (char *) s
, strlen( (char *) s
) + 1, "%u.%u",
917 client_major
, client_minor
);
921 snprintf( (char *)gc
->version
, size
, "%u.%u (%s)",
922 client_major
, client_minor
, s
);
930 case GL_EXTENSIONS
: {
934 /* This code is currently disabled. I was reminded that some
935 * vendors intentionally exclude some extensions from their
936 * extension string that are part of the core version they
937 * advertise. In particular, on Nvidia drivers this means that
938 * the functionality is supported by the driver, but is not
939 * hardware accelerated. For example, a TNT will show core
940 * version 1.5, but most of the post-1.2 functionality is a
943 * I don't want to break applications that rely on this odd
944 * behavior. At the same time, the code is written and tested,
945 * so I didn't want to throw it away. Therefore, the code is here
946 * but disabled. In the future, we may wish to and an environment
947 * variable to enable it.
951 /* Call glGetString just to make sure that gc->server_major and
952 * gc->server_minor are set. This version may be higher than we
953 * can completely support, but it may imply support for some
954 * extensions that we can support.
956 * For example, at the time of this writing, the client-side
957 * library only supports upto core GL version 1.2. However, cubic
958 * textures, multitexture, multisampling, and some other 1.3
959 * features are supported. If the server reports back version
960 * 1.3, but does not report all of those extensions, we will
963 (void *) glGetString( GL_VERSION
);
964 major
= gc
->server_major
,
965 minor
= gc
->server_minor
;
968 __glXCalculateUsableGLExtensions( gc
, (char *) s
, major
, minor
);
978 GLboolean
__indirect_glIsEnabled(GLenum cap
)
980 __GLX_SINGLE_DECLARE_VARIABLES();
981 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
982 xGLXSingleReply reply
;
983 GLboolean retval
= 0;
988 case GL_VERTEX_ARRAY
:
989 return IS_ARRAY_ENABLED(state
, vertex
);
990 case GL_NORMAL_ARRAY
:
991 return IS_ARRAY_ENABLED(state
, normal
);
993 return IS_ARRAY_ENABLED(state
, color
);
995 return IS_ARRAY_ENABLED(state
, index
);
996 case GL_TEXTURE_COORD_ARRAY
:
997 return IS_TEXARRAY_ENABLED(state
, state
->vertArray
.activeTexture
);
998 case GL_EDGE_FLAG_ARRAY
:
999 return IS_ARRAY_ENABLED(state
, edgeFlag
);
1000 case GL_SECONDARY_COLOR_ARRAY
:
1001 return IS_ARRAY_ENABLED(state
, secondaryColor
);
1002 case GL_FOG_COORD_ARRAY
:
1003 return IS_ARRAY_ENABLED(state
, fogCoord
);
1006 __GLX_SINGLE_LOAD_VARIABLES();
1007 __GLX_SINGLE_BEGIN(X_GLsop_IsEnabled
,4);
1008 __GLX_SINGLE_PUT_LONG(0,cap
);
1009 __GLX_SINGLE_READ_XREPLY();
1010 __GLX_SINGLE_GET_RETVAL(retval
, GLboolean
);
1015 void __indirect_glGetPointerv(GLenum pname
, void **params
)
1017 __GLXcontext
*gc
= __glXGetCurrentContext();
1018 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
1019 Display
*dpy
= gc
->currentDpy
;
1024 case GL_VERTEX_ARRAY_POINTER
:
1025 *params
= (void *)state
->vertArray
.arrays
[ vertex_ARRAY
].ptr
;
1027 case GL_NORMAL_ARRAY_POINTER
:
1028 *params
= (void *)state
->vertArray
.arrays
[ normal_ARRAY
].ptr
;
1030 case GL_COLOR_ARRAY_POINTER
:
1031 *params
= (void *)state
->vertArray
.arrays
[ color_ARRAY
].ptr
;
1033 case GL_INDEX_ARRAY_POINTER
:
1034 *params
= (void *)state
->vertArray
.arrays
[ index_ARRAY
].ptr
;
1036 case GL_TEXTURE_COORD_ARRAY_POINTER
:
1037 *params
= (void *)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].ptr
;
1039 case GL_EDGE_FLAG_ARRAY_POINTER
:
1040 *params
= (void *)state
->vertArray
.arrays
[ edgeFlag_ARRAY
].ptr
;
1042 case GL_SECONDARY_COLOR_ARRAY_POINTER
:
1043 *params
= (void *)state
->vertArray
.arrays
[ secondaryColor_ARRAY
].ptr
;
1045 case GL_FOG_COORD_ARRAY_POINTER
:
1046 *params
= (void *)state
->vertArray
.arrays
[ fogCoord_ARRAY
].ptr
;
1048 case GL_FEEDBACK_BUFFER_POINTER
:
1049 *params
= (void *)gc
->feedbackBuf
;
1051 case GL_SELECTION_BUFFER_POINTER
:
1052 *params
= (void *)gc
->selectBuf
;
1055 __glXSetError(gc
, GL_INVALID_ENUM
);