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.
37 #define NEED_GL_FUNCS_WRAPPED
39 #include "glxclient.h"
40 #include "packsingle.h"
41 #include "glxextensions.h"
43 /* Used for GL_ARB_transpose_matrix */
44 static void TransposeMatrixf(GLfloat m
[16])
47 for (i
= 0; i
< 4; i
++) {
48 for (j
= 0; j
< i
; j
++) {
49 GLfloat tmp
= m
[i
*4+j
];
56 /* Used for GL_ARB_transpose_matrix */
57 static void TransposeMatrixb(GLboolean m
[16])
60 for (i
= 0; i
< 4; i
++) {
61 for (j
= 0; j
< i
; j
++) {
62 GLboolean tmp
= m
[i
*4+j
];
69 /* Used for GL_ARB_transpose_matrix */
70 static void TransposeMatrixd(GLdouble m
[16])
73 for (i
= 0; i
< 4; i
++) {
74 for (j
= 0; j
< i
; j
++) {
75 GLdouble tmp
= m
[i
*4+j
];
82 /* Used for GL_ARB_transpose_matrix */
83 static void TransposeMatrixi(GLint m
[16])
86 for (i
= 0; i
< 4; i
++) {
87 for (j
= 0; j
< i
; j
++) {
95 GLenum
glGetError(void)
97 __GLX_SINGLE_DECLARE_VARIABLES();
98 GLuint retval
= GL_NO_ERROR
;
99 xGLXGetErrorReply reply
;
102 /* Use internal error first */
104 gc
->error
= GL_NO_ERROR
;
108 __GLX_SINGLE_LOAD_VARIABLES();
109 __GLX_SINGLE_BEGIN(X_GLsop_GetError
,0);
110 __GLX_SINGLE_READ_XREPLY();
111 retval
= reply
.error
;
117 void glGetClipPlane(GLenum plane
, GLdouble
*equation
)
119 __GLX_SINGLE_DECLARE_VARIABLES();
120 xGLXSingleReply reply
;
121 __GLX_SINGLE_LOAD_VARIABLES();
122 __GLX_SINGLE_BEGIN(X_GLsop_GetClipPlane
,4);
123 __GLX_SINGLE_PUT_LONG(0,plane
);
124 __GLX_SINGLE_READ_XREPLY();
125 if (reply
.length
== 8) {
126 __GLX_SINGLE_GET_DOUBLE_ARRAY(equation
,4);
131 #define CASE_ARRAY_ENABLE(enum_name,array,dest,gl_type) \
132 case GL_ ## enum_name ## _ARRAY: \
133 *dest = (gl_type) (IS_ARRAY_ENABLED(state, array)); break
134 #define CASE_ARRAY_SIZE(enum_name,array,dest,gl_type) \
135 case GL_ ## enum_name ## _ARRAY_SIZE: \
136 *dest = (gl_type) state->vertArray.arrays[array ## _ARRAY].size ; break
137 #define CASE_ARRAY_TYPE(enum_name,array,dest,gl_type) \
138 case GL_ ## enum_name ## _ARRAY_TYPE: \
139 *dest = (gl_type) state->vertArray.arrays[array ## _ARRAY].type ; break
140 #define CASE_ARRAY_STRIDE(enum_name,array,dest,gl_type) \
141 case GL_ ## enum_name ## _ARRAY_STRIDE: \
142 *dest = (gl_type) state->vertArray.arrays[array ## _ARRAY].stride ; break
144 #define CASE_ARRAY_ALL(enum_name,array,dest,gl_type) \
145 CASE_ARRAY_ENABLE(enum_name,array,dest,gl_type); \
146 CASE_ARRAY_STRIDE(enum_name,array,dest,gl_type); \
147 CASE_ARRAY_TYPE(enum_name,array,dest,gl_type); \
148 CASE_ARRAY_SIZE(enum_name,array,dest,gl_type)
150 void glGetBooleanv(GLenum val
, GLboolean
*b
)
152 const GLenum origVal
= val
;
153 __GLX_SINGLE_DECLARE_VARIABLES();
154 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
155 xGLXSingleReply reply
;
157 if (val
== GL_TRANSPOSE_MODELVIEW_MATRIX_ARB
) {
158 val
= GL_MODELVIEW_MATRIX
;
160 else if (val
== GL_TRANSPOSE_PROJECTION_MATRIX_ARB
) {
161 val
= GL_PROJECTION_MATRIX
;
163 else if (val
== GL_TRANSPOSE_TEXTURE_MATRIX_ARB
) {
164 val
= GL_TEXTURE_MATRIX
;
166 else if (val
== GL_TRANSPOSE_COLOR_MATRIX_ARB
) {
167 val
= GL_COLOR_MATRIX
;
170 __GLX_SINGLE_LOAD_VARIABLES();
171 __GLX_SINGLE_BEGIN(X_GLsop_GetBooleanv
,4);
172 __GLX_SINGLE_PUT_LONG(0,val
);
173 __GLX_SINGLE_READ_XREPLY();
174 __GLX_SINGLE_GET_SIZE(compsize
);
178 ** Error occured; don't modify user's buffer.
182 ** For all the queries listed here, we use the locally stored
183 ** values rather than the one returned by the server. Note that
184 ** we still needed to send the request to the server in order to
185 ** find out whether it was legal to make a query (it's illegal,
186 ** for example, to call a query between glBegin() and glEnd()).
189 case GL_PACK_ROW_LENGTH
:
190 *b
= (GLboolean
)state
->storePack
.rowLength
;
192 case GL_PACK_IMAGE_HEIGHT
:
193 *b
= (GLboolean
)state
->storePack
.imageHeight
;
195 case GL_PACK_SKIP_ROWS
:
196 *b
= (GLboolean
)state
->storePack
.skipRows
;
198 case GL_PACK_SKIP_PIXELS
:
199 *b
= (GLboolean
)state
->storePack
.skipPixels
;
201 case GL_PACK_SKIP_IMAGES
:
202 *b
= (GLboolean
)state
->storePack
.skipImages
;
204 case GL_PACK_ALIGNMENT
:
205 *b
= (GLboolean
)state
->storePack
.alignment
;
207 case GL_PACK_SWAP_BYTES
:
208 *b
= (GLboolean
)state
->storePack
.swapEndian
;
210 case GL_PACK_LSB_FIRST
:
211 *b
= (GLboolean
)state
->storePack
.lsbFirst
;
213 case GL_UNPACK_ROW_LENGTH
:
214 *b
= (GLboolean
)state
->storeUnpack
.rowLength
;
216 case GL_UNPACK_IMAGE_HEIGHT
:
217 *b
= (GLboolean
)state
->storeUnpack
.imageHeight
;
219 case GL_UNPACK_SKIP_ROWS
:
220 *b
= (GLboolean
)state
->storeUnpack
.skipRows
;
222 case GL_UNPACK_SKIP_PIXELS
:
223 *b
= (GLboolean
)state
->storeUnpack
.skipPixels
;
225 case GL_UNPACK_SKIP_IMAGES
:
226 *b
= (GLboolean
)state
->storeUnpack
.skipImages
;
228 case GL_UNPACK_ALIGNMENT
:
229 *b
= (GLboolean
)state
->storeUnpack
.alignment
;
231 case GL_UNPACK_SWAP_BYTES
:
232 *b
= (GLboolean
)state
->storeUnpack
.swapEndian
;
234 case GL_UNPACK_LSB_FIRST
:
235 *b
= (GLboolean
)state
->storeUnpack
.lsbFirst
;
238 CASE_ARRAY_ALL(VERTEX
, vertex
, b
, GLboolean
);
240 CASE_ARRAY_ENABLE(NORMAL
, normal
, b
, GLboolean
);
241 CASE_ARRAY_TYPE(NORMAL
, normal
, b
, GLboolean
);
242 CASE_ARRAY_STRIDE(NORMAL
, normal
, b
, GLboolean
);
244 CASE_ARRAY_ALL(COLOR
, color
, b
, GLboolean
);
246 CASE_ARRAY_ENABLE(INDEX
, index
, b
, GLboolean
);
247 CASE_ARRAY_TYPE(INDEX
, index
, b
, GLboolean
);
248 CASE_ARRAY_STRIDE(INDEX
, index
, b
, GLboolean
);
250 case GL_TEXTURE_COORD_ARRAY
:
251 *b
= (GLboolean
)IS_TEXARRAY_ENABLED(state
, state
->vertArray
.activeTexture
);
253 case GL_TEXTURE_COORD_ARRAY_SIZE
:
254 *b
= (GLboolean
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].size
;
256 case GL_TEXTURE_COORD_ARRAY_TYPE
:
257 *b
= (GLboolean
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].type
;
259 case GL_TEXTURE_COORD_ARRAY_STRIDE
:
260 *b
= (GLboolean
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].stride
;
263 CASE_ARRAY_ENABLE(EDGE_FLAG
, edgeFlag
, b
, GLboolean
);
264 CASE_ARRAY_STRIDE(EDGE_FLAG
, edgeFlag
, b
, GLboolean
);
266 CASE_ARRAY_ALL(SECONDARY_COLOR
, secondaryColor
, b
, GLboolean
);
268 CASE_ARRAY_ENABLE(FOG_COORD
, fogCoord
, b
, GLboolean
);
269 CASE_ARRAY_TYPE(FOG_COORD
, fogCoord
, b
, GLboolean
);
270 CASE_ARRAY_STRIDE(FOG_COORD
, fogCoord
, b
, GLboolean
);
272 case GL_MAX_ELEMENTS_VERTICES
:
273 *b
= (GLboolean
)state
->vertArray
.maxElementsVertices
;
275 case GL_MAX_ELEMENTS_INDICES
:
276 *b
= (GLboolean
)state
->vertArray
.maxElementsIndices
;
278 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH
:
279 *b
= (GLboolean
)__GL_CLIENT_ATTRIB_STACK_DEPTH
;
281 case GL_CLIENT_ACTIVE_TEXTURE_ARB
:
282 *b
= (GLboolean
)(state
->vertArray
.activeTexture
+ GL_TEXTURE0_ARB
);
286 ** Not a local value, so use what we got from the server.
289 __GLX_SINGLE_GET_CHAR(b
);
291 __GLX_SINGLE_GET_CHAR_ARRAY(b
,compsize
);
292 if (val
!= origVal
) {
293 /* matrix transpose */
302 void glGetDoublev(GLenum val
, GLdouble
*d
)
304 const GLenum origVal
= val
;
305 __GLX_SINGLE_DECLARE_VARIABLES();
306 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
307 xGLXSingleReply reply
;
309 if (val
== GL_TRANSPOSE_MODELVIEW_MATRIX_ARB
) {
310 val
= GL_MODELVIEW_MATRIX
;
312 else if (val
== GL_TRANSPOSE_PROJECTION_MATRIX_ARB
) {
313 val
= GL_PROJECTION_MATRIX
;
315 else if (val
== GL_TRANSPOSE_TEXTURE_MATRIX_ARB
) {
316 val
= GL_TEXTURE_MATRIX
;
318 else if (val
== GL_TRANSPOSE_COLOR_MATRIX_ARB
) {
319 val
= GL_COLOR_MATRIX
;
322 __GLX_SINGLE_LOAD_VARIABLES();
323 __GLX_SINGLE_BEGIN(X_GLsop_GetDoublev
,4);
324 __GLX_SINGLE_PUT_LONG(0,val
);
325 __GLX_SINGLE_READ_XREPLY();
326 __GLX_SINGLE_GET_SIZE(compsize
);
330 ** Error occured; don't modify user's buffer.
334 ** For all the queries listed here, we use the locally stored
335 ** values rather than the one returned by the server. Note that
336 ** we still needed to send the request to the server in order to
337 ** find out whether it was legal to make a query (it's illegal,
338 ** for example, to call a query between glBegin() and glEnd()).
341 case GL_PACK_ROW_LENGTH
:
342 *d
= (GLdouble
)state
->storePack
.rowLength
;
344 case GL_PACK_IMAGE_HEIGHT
:
345 *d
= (GLdouble
)state
->storePack
.imageHeight
;
347 case GL_PACK_SKIP_ROWS
:
348 *d
= (GLdouble
)state
->storePack
.skipRows
;
350 case GL_PACK_SKIP_PIXELS
:
351 *d
= (GLdouble
)state
->storePack
.skipPixels
;
353 case GL_PACK_SKIP_IMAGES
:
354 *d
= (GLdouble
)state
->storePack
.skipImages
;
356 case GL_PACK_ALIGNMENT
:
357 *d
= (GLdouble
)state
->storePack
.alignment
;
359 case GL_PACK_SWAP_BYTES
:
360 *d
= (GLdouble
)state
->storePack
.swapEndian
;
362 case GL_PACK_LSB_FIRST
:
363 *d
= (GLdouble
)state
->storePack
.lsbFirst
;
365 case GL_UNPACK_ROW_LENGTH
:
366 *d
= (GLdouble
)state
->storeUnpack
.rowLength
;
368 case GL_UNPACK_IMAGE_HEIGHT
:
369 *d
= (GLdouble
)state
->storeUnpack
.imageHeight
;
371 case GL_UNPACK_SKIP_ROWS
:
372 *d
= (GLdouble
)state
->storeUnpack
.skipRows
;
374 case GL_UNPACK_SKIP_PIXELS
:
375 *d
= (GLdouble
)state
->storeUnpack
.skipPixels
;
377 case GL_UNPACK_SKIP_IMAGES
:
378 *d
= (GLdouble
)state
->storeUnpack
.skipImages
;
380 case GL_UNPACK_ALIGNMENT
:
381 *d
= (GLdouble
)state
->storeUnpack
.alignment
;
383 case GL_UNPACK_SWAP_BYTES
:
384 *d
= (GLdouble
)state
->storeUnpack
.swapEndian
;
386 case GL_UNPACK_LSB_FIRST
:
387 *d
= (GLdouble
)state
->storeUnpack
.lsbFirst
;
390 CASE_ARRAY_ALL(VERTEX
, vertex
, d
, GLdouble
);
392 CASE_ARRAY_ENABLE(NORMAL
, normal
, d
, GLdouble
);
393 CASE_ARRAY_TYPE(NORMAL
, normal
, d
, GLdouble
);
394 CASE_ARRAY_STRIDE(NORMAL
, normal
, d
, GLdouble
);
396 CASE_ARRAY_ALL(COLOR
, color
, d
, GLdouble
);
398 CASE_ARRAY_ENABLE(INDEX
, index
, d
, GLdouble
);
399 CASE_ARRAY_TYPE(INDEX
, index
, d
, GLdouble
);
400 CASE_ARRAY_STRIDE(INDEX
, index
, d
, GLdouble
);
402 case GL_TEXTURE_COORD_ARRAY
:
403 *d
= (GLdouble
) IS_TEXARRAY_ENABLED(state
, state
->vertArray
.activeTexture
);
405 case GL_TEXTURE_COORD_ARRAY_SIZE
:
406 *d
= (GLdouble
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].size
;
408 case GL_TEXTURE_COORD_ARRAY_TYPE
:
409 *d
= (GLdouble
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].type
;
411 case GL_TEXTURE_COORD_ARRAY_STRIDE
:
412 *d
= (GLdouble
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].stride
;
415 CASE_ARRAY_ENABLE(EDGE_FLAG
, edgeFlag
, d
, GLdouble
);
416 CASE_ARRAY_STRIDE(EDGE_FLAG
, edgeFlag
, d
, GLdouble
);
418 CASE_ARRAY_ALL(SECONDARY_COLOR
, secondaryColor
, d
, GLdouble
);
420 CASE_ARRAY_ENABLE(FOG_COORD
, fogCoord
, d
, GLdouble
);
421 CASE_ARRAY_TYPE(FOG_COORD
, fogCoord
, d
, GLdouble
);
422 CASE_ARRAY_STRIDE(FOG_COORD
, fogCoord
, d
, GLdouble
);
424 case GL_MAX_ELEMENTS_VERTICES
:
425 *d
= (GLdouble
)state
->vertArray
.maxElementsVertices
;
427 case GL_MAX_ELEMENTS_INDICES
:
428 *d
= (GLdouble
)state
->vertArray
.maxElementsIndices
;
430 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH
:
431 *d
= (GLdouble
)__GL_CLIENT_ATTRIB_STACK_DEPTH
;
433 case GL_CLIENT_ACTIVE_TEXTURE_ARB
:
434 *d
= (GLdouble
)(state
->vertArray
.activeTexture
+ GL_TEXTURE0_ARB
);
438 ** Not a local value, so use what we got from the server.
441 __GLX_SINGLE_GET_DOUBLE(d
);
443 __GLX_SINGLE_GET_DOUBLE_ARRAY(d
,compsize
);
444 if (val
!= origVal
) {
445 /* matrix transpose */
454 void glGetFloatv(GLenum val
, GLfloat
*f
)
456 const GLenum origVal
= val
;
457 __GLX_SINGLE_DECLARE_VARIABLES();
458 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
459 xGLXSingleReply reply
;
461 if (val
== GL_TRANSPOSE_MODELVIEW_MATRIX_ARB
) {
462 val
= GL_MODELVIEW_MATRIX
;
464 else if (val
== GL_TRANSPOSE_PROJECTION_MATRIX_ARB
) {
465 val
= GL_PROJECTION_MATRIX
;
467 else if (val
== GL_TRANSPOSE_TEXTURE_MATRIX_ARB
) {
468 val
= GL_TEXTURE_MATRIX
;
470 else if (val
== GL_TRANSPOSE_COLOR_MATRIX_ARB
) {
471 val
= GL_COLOR_MATRIX
;
474 __GLX_SINGLE_LOAD_VARIABLES();
475 __GLX_SINGLE_BEGIN(X_GLsop_GetFloatv
,4);
476 __GLX_SINGLE_PUT_LONG(0,val
);
477 __GLX_SINGLE_READ_XREPLY();
478 __GLX_SINGLE_GET_SIZE(compsize
);
482 ** Error occured; don't modify user's buffer.
486 ** For all the queries listed here, we use the locally stored
487 ** values rather than the one returned by the server. Note that
488 ** we still needed to send the request to the server in order to
489 ** find out whether it was legal to make a query (it's illegal,
490 ** for example, to call a query between glBegin() and glEnd()).
493 case GL_PACK_ROW_LENGTH
:
494 *f
= (GLfloat
)state
->storePack
.rowLength
;
496 case GL_PACK_IMAGE_HEIGHT
:
497 *f
= (GLfloat
)state
->storePack
.imageHeight
;
499 case GL_PACK_SKIP_ROWS
:
500 *f
= (GLfloat
)state
->storePack
.skipRows
;
502 case GL_PACK_SKIP_PIXELS
:
503 *f
= (GLfloat
)state
->storePack
.skipPixels
;
505 case GL_PACK_SKIP_IMAGES
:
506 *f
= (GLfloat
)state
->storePack
.skipImages
;
508 case GL_PACK_ALIGNMENT
:
509 *f
= (GLfloat
)state
->storePack
.alignment
;
511 case GL_PACK_SWAP_BYTES
:
512 *f
= (GLfloat
)state
->storePack
.swapEndian
;
514 case GL_PACK_LSB_FIRST
:
515 *f
= (GLfloat
)state
->storePack
.lsbFirst
;
517 case GL_UNPACK_ROW_LENGTH
:
518 *f
= (GLfloat
)state
->storeUnpack
.rowLength
;
520 case GL_UNPACK_IMAGE_HEIGHT
:
521 *f
= (GLfloat
)state
->storeUnpack
.imageHeight
;
523 case GL_UNPACK_SKIP_ROWS
:
524 *f
= (GLfloat
)state
->storeUnpack
.skipRows
;
526 case GL_UNPACK_SKIP_PIXELS
:
527 *f
= (GLfloat
)state
->storeUnpack
.skipPixels
;
529 case GL_UNPACK_SKIP_IMAGES
:
530 *f
= (GLfloat
)state
->storeUnpack
.skipImages
;
532 case GL_UNPACK_ALIGNMENT
:
533 *f
= (GLfloat
)state
->storeUnpack
.alignment
;
535 case GL_UNPACK_SWAP_BYTES
:
536 *f
= (GLfloat
)state
->storeUnpack
.swapEndian
;
538 case GL_UNPACK_LSB_FIRST
:
539 *f
= (GLfloat
)state
->storeUnpack
.lsbFirst
;
542 CASE_ARRAY_ALL(VERTEX
, vertex
, f
, GLfloat
);
544 CASE_ARRAY_ENABLE(NORMAL
, normal
, f
, GLfloat
);
545 CASE_ARRAY_TYPE(NORMAL
, normal
, f
, GLfloat
);
546 CASE_ARRAY_STRIDE(NORMAL
, normal
, f
, GLfloat
);
548 CASE_ARRAY_ALL(COLOR
, color
, f
, GLfloat
);
550 CASE_ARRAY_ENABLE(INDEX
, index
, f
, GLfloat
);
551 CASE_ARRAY_TYPE(INDEX
, index
, f
, GLfloat
);
552 CASE_ARRAY_STRIDE(INDEX
, index
, f
, GLfloat
);
554 case GL_TEXTURE_COORD_ARRAY
:
555 *f
= (GLfloat
) IS_TEXARRAY_ENABLED(state
, state
->vertArray
.activeTexture
);
557 case GL_TEXTURE_COORD_ARRAY_SIZE
:
558 *f
= (GLfloat
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].size
;
560 case GL_TEXTURE_COORD_ARRAY_TYPE
:
561 *f
= (GLfloat
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].type
;
563 case GL_TEXTURE_COORD_ARRAY_STRIDE
:
564 *f
= (GLfloat
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].stride
;
567 CASE_ARRAY_ENABLE(EDGE_FLAG
, edgeFlag
, f
, GLfloat
);
568 CASE_ARRAY_STRIDE(EDGE_FLAG
, edgeFlag
, f
, GLfloat
);
570 CASE_ARRAY_ALL(SECONDARY_COLOR
, secondaryColor
, f
, GLfloat
);
572 CASE_ARRAY_ENABLE(FOG_COORD
, fogCoord
, f
, GLfloat
);
573 CASE_ARRAY_TYPE(FOG_COORD
, fogCoord
, f
, GLfloat
);
574 CASE_ARRAY_STRIDE(FOG_COORD
, fogCoord
, f
, GLfloat
);
576 case GL_MAX_ELEMENTS_VERTICES
:
577 *f
= (GLfloat
)state
->vertArray
.maxElementsVertices
;
579 case GL_MAX_ELEMENTS_INDICES
:
580 *f
= (GLfloat
)state
->vertArray
.maxElementsIndices
;
582 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH
:
583 *f
= (GLfloat
)__GL_CLIENT_ATTRIB_STACK_DEPTH
;
585 case GL_CLIENT_ACTIVE_TEXTURE_ARB
:
586 *f
= (GLfloat
)(state
->vertArray
.activeTexture
+ GL_TEXTURE0_ARB
);
590 ** Not a local value, so use what we got from the server.
593 __GLX_SINGLE_GET_FLOAT(f
);
595 __GLX_SINGLE_GET_FLOAT_ARRAY(f
,compsize
);
596 if (val
!= origVal
) {
597 /* matrix transpose */
606 void glGetIntegerv(GLenum val
, GLint
*i
)
608 const GLenum origVal
= val
;
609 __GLX_SINGLE_DECLARE_VARIABLES();
610 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
611 xGLXSingleReply reply
;
613 if (val
== GL_TRANSPOSE_MODELVIEW_MATRIX_ARB
) {
614 val
= GL_MODELVIEW_MATRIX
;
616 else if (val
== GL_TRANSPOSE_PROJECTION_MATRIX_ARB
) {
617 val
= GL_PROJECTION_MATRIX
;
619 else if (val
== GL_TRANSPOSE_TEXTURE_MATRIX_ARB
) {
620 val
= GL_TEXTURE_MATRIX
;
622 else if (val
== GL_TRANSPOSE_COLOR_MATRIX_ARB
) {
623 val
= GL_COLOR_MATRIX
;
626 __GLX_SINGLE_LOAD_VARIABLES();
627 __GLX_SINGLE_BEGIN(X_GLsop_GetIntegerv
,4);
628 __GLX_SINGLE_PUT_LONG(0,val
);
629 __GLX_SINGLE_READ_XREPLY();
630 __GLX_SINGLE_GET_SIZE(compsize
);
634 ** Error occured; don't modify user's buffer.
638 ** For all the queries listed here, we use the locally stored
639 ** values rather than the one returned by the server. Note that
640 ** we still needed to send the request to the server in order to
641 ** find out whether it was legal to make a query (it's illegal,
642 ** for example, to call a query between glBegin() and glEnd()).
645 case GL_PACK_ROW_LENGTH
:
646 *i
= (GLint
)state
->storePack
.rowLength
;
648 case GL_PACK_IMAGE_HEIGHT
:
649 *i
= (GLint
)state
->storePack
.imageHeight
;
651 case GL_PACK_SKIP_ROWS
:
652 *i
= (GLint
)state
->storePack
.skipRows
;
654 case GL_PACK_SKIP_PIXELS
:
655 *i
= (GLint
)state
->storePack
.skipPixels
;
657 case GL_PACK_SKIP_IMAGES
:
658 *i
= (GLint
)state
->storePack
.skipImages
;
660 case GL_PACK_ALIGNMENT
:
661 *i
= (GLint
)state
->storePack
.alignment
;
663 case GL_PACK_SWAP_BYTES
:
664 *i
= (GLint
)state
->storePack
.swapEndian
;
666 case GL_PACK_LSB_FIRST
:
667 *i
= (GLint
)state
->storePack
.lsbFirst
;
669 case GL_UNPACK_ROW_LENGTH
:
670 *i
= (GLint
)state
->storeUnpack
.rowLength
;
672 case GL_UNPACK_IMAGE_HEIGHT
:
673 *i
= (GLint
)state
->storeUnpack
.imageHeight
;
675 case GL_UNPACK_SKIP_ROWS
:
676 *i
= (GLint
)state
->storeUnpack
.skipRows
;
678 case GL_UNPACK_SKIP_PIXELS
:
679 *i
= (GLint
)state
->storeUnpack
.skipPixels
;
681 case GL_UNPACK_SKIP_IMAGES
:
682 *i
= (GLint
)state
->storeUnpack
.skipImages
;
684 case GL_UNPACK_ALIGNMENT
:
685 *i
= (GLint
)state
->storeUnpack
.alignment
;
687 case GL_UNPACK_SWAP_BYTES
:
688 *i
= (GLint
)state
->storeUnpack
.swapEndian
;
690 case GL_UNPACK_LSB_FIRST
:
691 *i
= (GLint
)state
->storeUnpack
.lsbFirst
;
694 CASE_ARRAY_ALL(VERTEX
, vertex
, i
, GLint
);
696 CASE_ARRAY_ENABLE(NORMAL
, normal
, i
, GLint
);
697 CASE_ARRAY_TYPE(NORMAL
, normal
, i
, GLint
);
698 CASE_ARRAY_STRIDE(NORMAL
, normal
, i
, GLint
);
700 CASE_ARRAY_ALL(COLOR
, color
, i
, GLint
);
702 CASE_ARRAY_ENABLE(INDEX
, index
, i
, GLint
);
703 CASE_ARRAY_TYPE(INDEX
, index
, i
, GLint
);
704 CASE_ARRAY_STRIDE(INDEX
, index
, i
, GLint
);
706 case GL_TEXTURE_COORD_ARRAY
:
707 *i
= (GLint
) IS_TEXARRAY_ENABLED(state
, state
->vertArray
.activeTexture
);
709 case GL_TEXTURE_COORD_ARRAY_SIZE
:
710 *i
= (GLint
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].size
;
712 case GL_TEXTURE_COORD_ARRAY_TYPE
:
713 *i
= (GLint
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].type
;
715 case GL_TEXTURE_COORD_ARRAY_STRIDE
:
716 *i
= (GLint
)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].stride
;
719 CASE_ARRAY_ENABLE(EDGE_FLAG
, edgeFlag
, i
, GLint
);
720 CASE_ARRAY_STRIDE(EDGE_FLAG
, edgeFlag
, i
, GLint
);
722 CASE_ARRAY_ALL(SECONDARY_COLOR
, secondaryColor
, i
, GLint
);
724 CASE_ARRAY_ENABLE(FOG_COORD
, fogCoord
, i
, GLint
);
725 CASE_ARRAY_TYPE(FOG_COORD
, fogCoord
, i
, GLint
);
726 CASE_ARRAY_STRIDE(FOG_COORD
, fogCoord
, i
, GLint
);
728 case GL_MAX_ELEMENTS_VERTICES
:
729 *i
= (GLint
)state
->vertArray
.maxElementsVertices
;
731 case GL_MAX_ELEMENTS_INDICES
:
732 *i
= (GLint
)state
->vertArray
.maxElementsIndices
;
734 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH
:
735 *i
= (GLint
)__GL_CLIENT_ATTRIB_STACK_DEPTH
;
737 case GL_CLIENT_ACTIVE_TEXTURE_ARB
:
738 *i
= (GLint
)(state
->vertArray
.activeTexture
+ GL_TEXTURE0_ARB
);
742 ** Not a local value, so use what we got from the server.
745 __GLX_SINGLE_GET_LONG(i
);
747 __GLX_SINGLE_GET_LONG_ARRAY(i
,compsize
);
748 if (val
!= origVal
) {
749 /* matrix transpose */
759 ** Send all pending commands to server.
763 __GLX_SINGLE_DECLARE_VARIABLES();
767 __GLX_SINGLE_LOAD_VARIABLES();
768 __GLX_SINGLE_BEGIN(X_GLsop_Flush
,0);
771 /* And finally flush the X protocol data */
775 void glFeedbackBuffer(GLsizei size
, GLenum type
, GLfloat
*buffer
)
777 __GLX_SINGLE_DECLARE_VARIABLES();
781 __GLX_SINGLE_LOAD_VARIABLES();
782 __GLX_SINGLE_BEGIN(X_GLsop_FeedbackBuffer
,8);
783 __GLX_SINGLE_PUT_LONG(0,size
);
784 __GLX_SINGLE_PUT_LONG(4,type
);
787 gc
->feedbackBuf
= buffer
;
790 void glSelectBuffer(GLsizei numnames
, GLuint
*buffer
)
792 __GLX_SINGLE_DECLARE_VARIABLES();
796 __GLX_SINGLE_LOAD_VARIABLES();
797 __GLX_SINGLE_BEGIN(X_GLsop_SelectBuffer
,4);
798 __GLX_SINGLE_PUT_LONG(0,numnames
);
801 gc
->selectBuf
= buffer
;
804 GLint
glRenderMode(GLenum mode
)
806 __GLX_SINGLE_DECLARE_VARIABLES();
808 xGLXRenderModeReply reply
;
812 __GLX_SINGLE_LOAD_VARIABLES();
813 __GLX_SINGLE_BEGIN(X_GLsop_RenderMode
,4);
814 __GLX_SINGLE_PUT_LONG(0,mode
);
815 __GLX_SINGLE_READ_XREPLY();
816 __GLX_SINGLE_GET_RETVAL(retval
,GLint
);
818 if (reply
.newMode
!= mode
) {
820 ** Switch to new mode did not take effect, therefore an error
821 ** occured. When an error happens the server won't send us any
825 /* Read the feedback or selection data */
826 if (gc
->renderMode
== GL_FEEDBACK
) {
827 __GLX_SINGLE_GET_SIZE(compsize
);
828 __GLX_SINGLE_GET_FLOAT_ARRAY(gc
->feedbackBuf
, compsize
);
830 if (gc
->renderMode
== GL_SELECT
) {
831 __GLX_SINGLE_GET_SIZE(compsize
);
832 __GLX_SINGLE_GET_LONG_ARRAY(gc
->selectBuf
, compsize
);
834 gc
->renderMode
= mode
;
843 __GLX_SINGLE_DECLARE_VARIABLES();
844 xGLXSingleReply reply
;
846 __GLX_SINGLE_LOAD_VARIABLES();
847 __GLX_SINGLE_BEGIN(X_GLsop_Finish
,0);
848 __GLX_SINGLE_READ_XREPLY();
854 * Extract the major and minor version numbers from a version string.
857 version_from_string( const char * ver
,
858 int * major_version
, int * minor_version
)
864 major
= strtol( ver
, (char **) & end
, 10 );
865 minor
= strtol( end
+ 1, NULL
, 10 );
866 *major_version
= major
;
867 *minor_version
= minor
;
871 const GLubyte
*glGetString(GLenum name
)
873 __GLXcontext
*gc
= __glXGetCurrentContext();
874 Display
*dpy
= gc
->currentDpy
;
880 ** Return the cached copy if the string has already been fetched
884 if (gc
->vendor
) return gc
->vendor
;
887 if (gc
->renderer
) return gc
->renderer
;
890 if (gc
->version
) return gc
->version
;
893 if (gc
->extensions
) return gc
->extensions
;
896 __glXSetError(gc
, GL_INVALID_ENUM
);
901 ** Get requested string from server
904 (void) __glXFlushRenderBuffer( gc
, gc
->pc
);
905 s
= (GLubyte
*) __glXGetStringFromServer( dpy
, gc
->majorOpcode
,
906 X_GLsop_GetString
, gc
->currentContextTag
,
909 /* Throw data on the floor */
910 __glXSetError(gc
, GL_OUT_OF_MEMORY
);
913 ** Update local cache
928 version_from_string( (char *) s
,
929 & gc
->server_major
, & gc
->server_minor
);
930 __glXGetGLVersion( & client_major
, & client_minor
);
932 if ( (gc
->server_major
< client_major
)
933 || ((gc
->server_major
== client_major
)
934 && (gc
->server_minor
<= client_minor
)) ) {
938 /* Allow 7 bytes for the client-side GL version. This allows
939 * for upto version 999.999. I'm not holding my breath for
940 * that one! The extra 4 is for the ' ()\0' that will be
943 const size_t size
= 7 + strlen( (char *) s
) + 4;
945 gc
->version
= Xmalloc( size
);
946 if ( gc
->version
== NULL
) {
947 /* If we couldn't allocate memory for the new string,
948 * make a best-effort and just copy the client-side version
949 * to the string and use that. It probably doesn't
950 * matter what is done here. If there not memory available
951 * for a short string, the system is probably going to die
954 snprintf( (char *) s
, strlen( (char *) s
) + 1, "%u.%u",
955 client_major
, client_minor
);
959 snprintf( (char *)gc
->version
, size
, "%u.%u (%s)",
960 client_major
, client_minor
, s
);
968 case GL_EXTENSIONS
: {
972 /* This code is currently disabled. I was reminded that some
973 * vendors intentionally exclude some extensions from their
974 * extension string that are part of the core version they
975 * advertise. In particular, on Nvidia drivers this means that
976 * the functionality is supported by the driver, but is not
977 * hardware accelerated. For example, a TNT will show core
978 * version 1.5, but most of the post-1.2 functionality is a
981 * I don't want to break applications that rely on this odd
982 * behavior. At the same time, the code is written and tested,
983 * so I didn't want to throw it away. Therefore, the code is here
984 * but disabled. In the future, we may wish to and an environment
985 * variable to enable it.
989 /* Call glGetString just to make sure that gc->server_major and
990 * gc->server_minor are set. This version may be higher than we
991 * can completely support, but it may imply support for some
992 * extensions that we can support.
994 * For example, at the time of this writing, the client-side
995 * library only supports upto core GL version 1.2. However, cubic
996 * textures, multitexture, multisampling, and some other 1.3
997 * features are supported. If the server reports back version
998 * 1.3, but does not report all of those extensions, we will
1001 (void *) glGetString( GL_VERSION
);
1002 major
= gc
->server_major
,
1003 minor
= gc
->server_minor
;
1006 __glXCalculateUsableGLExtensions( gc
, (char *) s
, major
, minor
);
1016 GLboolean
glIsEnabled(GLenum cap
)
1018 __GLX_SINGLE_DECLARE_VARIABLES();
1019 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
1020 xGLXSingleReply reply
;
1021 GLboolean retval
= 0;
1026 case GL_VERTEX_ARRAY
:
1027 return IS_ARRAY_ENABLED(state
, vertex
);
1028 case GL_NORMAL_ARRAY
:
1029 return IS_ARRAY_ENABLED(state
, normal
);
1030 case GL_COLOR_ARRAY
:
1031 return IS_ARRAY_ENABLED(state
, color
);
1032 case GL_INDEX_ARRAY
:
1033 return IS_ARRAY_ENABLED(state
, index
);
1034 case GL_TEXTURE_COORD_ARRAY
:
1035 return IS_TEXARRAY_ENABLED(state
, state
->vertArray
.activeTexture
);
1036 case GL_EDGE_FLAG_ARRAY
:
1037 return IS_ARRAY_ENABLED(state
, edgeFlag
);
1038 case GL_SECONDARY_COLOR_ARRAY
:
1039 return IS_ARRAY_ENABLED(state
, secondaryColor
);
1040 case GL_FOG_COORD_ARRAY
:
1041 return IS_ARRAY_ENABLED(state
, fogCoord
);
1044 __GLX_SINGLE_LOAD_VARIABLES();
1045 __GLX_SINGLE_BEGIN(X_GLsop_IsEnabled
,4);
1046 __GLX_SINGLE_PUT_LONG(0,cap
);
1047 __GLX_SINGLE_READ_XREPLY();
1048 __GLX_SINGLE_GET_RETVAL(retval
, GLboolean
);
1053 void glGetPointerv(GLenum pname
, void **params
)
1055 __GLXcontext
*gc
= __glXGetCurrentContext();
1056 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
1057 Display
*dpy
= gc
->currentDpy
;
1062 case GL_VERTEX_ARRAY_POINTER
:
1063 *params
= (void *)state
->vertArray
.arrays
[ vertex_ARRAY
].ptr
;
1065 case GL_NORMAL_ARRAY_POINTER
:
1066 *params
= (void *)state
->vertArray
.arrays
[ normal_ARRAY
].ptr
;
1068 case GL_COLOR_ARRAY_POINTER
:
1069 *params
= (void *)state
->vertArray
.arrays
[ color_ARRAY
].ptr
;
1071 case GL_INDEX_ARRAY_POINTER
:
1072 *params
= (void *)state
->vertArray
.arrays
[ index_ARRAY
].ptr
;
1074 case GL_TEXTURE_COORD_ARRAY_POINTER
:
1075 *params
= (void *)state
->vertArray
.texCoord
[state
->vertArray
.activeTexture
].ptr
;
1077 case GL_EDGE_FLAG_ARRAY_POINTER
:
1078 *params
= (void *)state
->vertArray
.arrays
[ edgeFlag_ARRAY
].ptr
;
1080 case GL_SECONDARY_COLOR_ARRAY_POINTER
:
1081 *params
= (void *)state
->vertArray
.arrays
[ secondaryColor_ARRAY
].ptr
;
1083 case GL_FOG_COORD_ARRAY_POINTER
:
1084 *params
= (void *)state
->vertArray
.arrays
[ fogCoord_ARRAY
].ptr
;
1086 case GL_FEEDBACK_BUFFER_POINTER
:
1087 *params
= (void *)gc
->feedbackBuf
;
1089 case GL_SELECTION_BUFFER_POINTER
:
1090 *params
= (void *)gc
->selectBuf
;
1093 __glXSetError(gc
, GL_INVALID_ENUM
);