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