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.
39 #include "glxclient.h"
40 #include "packsingle.h"
41 #include "glxextensions.h"
43 #include "indirect_vertex_array.h"
45 /* Used for GL_ARB_transpose_matrix */
46 static void TransposeMatrixf(GLfloat m
[16])
49 for (i
= 0; i
< 4; i
++) {
50 for (j
= 0; j
< i
; j
++) {
51 GLfloat tmp
= m
[i
*4+j
];
58 /* Used for GL_ARB_transpose_matrix */
59 static void TransposeMatrixb(GLboolean m
[16])
62 for (i
= 0; i
< 4; i
++) {
63 for (j
= 0; j
< i
; j
++) {
64 GLboolean tmp
= m
[i
*4+j
];
71 /* Used for GL_ARB_transpose_matrix */
72 static void TransposeMatrixd(GLdouble m
[16])
75 for (i
= 0; i
< 4; i
++) {
76 for (j
= 0; j
< i
; j
++) {
77 GLdouble tmp
= m
[i
*4+j
];
84 /* Used for GL_ARB_transpose_matrix */
85 static void TransposeMatrixi(GLint m
[16])
88 for (i
= 0; i
< 4; i
++) {
89 for (j
= 0; j
< i
; j
++) {
99 * Remap a transpose-matrix enum to a non-transpose-matrix enum. Enums
100 * that are not transpose-matrix enums are unaffected.
103 RemapTransposeEnum( GLenum e
)
106 case GL_TRANSPOSE_MODELVIEW_MATRIX
:
107 case GL_TRANSPOSE_PROJECTION_MATRIX
:
108 case GL_TRANSPOSE_TEXTURE_MATRIX
:
109 return e
- (GL_TRANSPOSE_MODELVIEW_MATRIX
- GL_MODELVIEW_MATRIX
);
110 case GL_TRANSPOSE_COLOR_MATRIX
:
111 return GL_COLOR_MATRIX
;
118 GLenum
__indirect_glGetError(void)
120 __GLX_SINGLE_DECLARE_VARIABLES();
121 GLuint retval
= GL_NO_ERROR
;
122 xGLXGetErrorReply reply
;
125 /* Use internal error first */
127 gc
->error
= GL_NO_ERROR
;
131 __GLX_SINGLE_LOAD_VARIABLES();
132 __GLX_SINGLE_BEGIN(X_GLsop_GetError
,0);
133 __GLX_SINGLE_READ_XREPLY();
134 retval
= reply
.error
;
142 * Get the selected attribute from the client state.
145 * On success \c GL_TRUE is returned. Otherwise, \c GL_FALSE is returned.
148 get_client_data( __GLXattribute
* state
, GLenum cap
, GLintptr
* data
)
150 GLboolean retval
= GL_TRUE
;
151 const GLint tex_unit
= __glXGetActiveTextureUnit( state
);
155 case GL_VERTEX_ARRAY
:
156 case GL_NORMAL_ARRAY
:
159 case GL_EDGE_FLAG_ARRAY
:
160 case GL_SECONDARY_COLOR_ARRAY
:
161 case GL_FOG_COORD_ARRAY
:
162 retval
= __glXGetArrayEnable( state
, cap
, 0, data
);
165 case GL_VERTEX_ARRAY_SIZE
:
166 retval
= __glXGetArraySize( state
, GL_VERTEX_ARRAY
, 0, data
);
168 case GL_COLOR_ARRAY_SIZE
:
169 retval
= __glXGetArraySize( state
, GL_COLOR_ARRAY
, 0, data
);
171 case GL_SECONDARY_COLOR_ARRAY_SIZE
:
172 retval
= __glXGetArraySize( state
, GL_SECONDARY_COLOR_ARRAY
, 0, data
);
175 case GL_VERTEX_ARRAY_TYPE
:
176 retval
= __glXGetArrayType( state
, GL_VERTEX_ARRAY
, 0, data
);
178 case GL_NORMAL_ARRAY_TYPE
:
179 retval
= __glXGetArrayType( state
, GL_NORMAL_ARRAY
, 0, data
);
181 case GL_INDEX_ARRAY_TYPE
:
182 retval
= __glXGetArrayType( state
, GL_INDEX_ARRAY
, 0, data
);
184 case GL_COLOR_ARRAY_TYPE
:
185 retval
= __glXGetArrayType( state
, GL_COLOR_ARRAY
, 0, data
);
187 case GL_SECONDARY_COLOR_ARRAY_TYPE
:
188 retval
= __glXGetArrayType( state
, GL_SECONDARY_COLOR_ARRAY
, 0, data
);
190 case GL_FOG_COORD_ARRAY_TYPE
:
191 retval
= __glXGetArrayType( state
, GL_FOG_COORD_ARRAY
, 0, data
);
194 case GL_VERTEX_ARRAY_STRIDE
:
195 retval
= __glXGetArrayStride( state
, GL_VERTEX_ARRAY
, 0, data
);
197 case GL_NORMAL_ARRAY_STRIDE
:
198 retval
= __glXGetArrayStride( state
, GL_NORMAL_ARRAY
, 0, data
);
200 case GL_INDEX_ARRAY_STRIDE
:
201 retval
= __glXGetArrayStride( state
, GL_INDEX_ARRAY
, 0, data
);
203 case GL_EDGE_FLAG_ARRAY_STRIDE
:
204 retval
= __glXGetArrayStride( state
, GL_EDGE_FLAG_ARRAY
, 0, data
);
206 case GL_COLOR_ARRAY_STRIDE
:
207 retval
= __glXGetArrayStride( state
, GL_COLOR_ARRAY
, 0, data
);
209 case GL_SECONDARY_COLOR_ARRAY_STRIDE
:
210 retval
= __glXGetArrayStride( state
, GL_SECONDARY_COLOR_ARRAY
, 0, data
);
212 case GL_FOG_COORD_ARRAY_STRIDE
:
213 retval
= __glXGetArrayStride( state
, GL_FOG_COORD_ARRAY
, 0, data
);
216 case GL_TEXTURE_COORD_ARRAY
:
217 retval
= __glXGetArrayEnable( state
, GL_TEXTURE_COORD_ARRAY
, tex_unit
, data
);
219 case GL_TEXTURE_COORD_ARRAY_SIZE
:
220 retval
= __glXGetArraySize( state
, GL_TEXTURE_COORD_ARRAY
, tex_unit
, data
);
222 case GL_TEXTURE_COORD_ARRAY_TYPE
:
223 retval
= __glXGetArrayType( state
, GL_TEXTURE_COORD_ARRAY
, tex_unit
, data
);
225 case GL_TEXTURE_COORD_ARRAY_STRIDE
:
226 retval
= __glXGetArrayStride( state
, GL_TEXTURE_COORD_ARRAY
, tex_unit
, data
);
229 case GL_MAX_ELEMENTS_VERTICES
:
230 case GL_MAX_ELEMENTS_INDICES
:
236 case GL_PACK_ROW_LENGTH
:
237 *data
= (GLintptr
)state
->storePack
.rowLength
;
239 case GL_PACK_IMAGE_HEIGHT
:
240 *data
= (GLintptr
)state
->storePack
.imageHeight
;
242 case GL_PACK_SKIP_ROWS
:
243 *data
= (GLintptr
)state
->storePack
.skipRows
;
245 case GL_PACK_SKIP_PIXELS
:
246 *data
= (GLintptr
)state
->storePack
.skipPixels
;
248 case GL_PACK_SKIP_IMAGES
:
249 *data
= (GLintptr
)state
->storePack
.skipImages
;
251 case GL_PACK_ALIGNMENT
:
252 *data
= (GLintptr
)state
->storePack
.alignment
;
254 case GL_PACK_SWAP_BYTES
:
255 *data
= (GLintptr
)state
->storePack
.swapEndian
;
257 case GL_PACK_LSB_FIRST
:
258 *data
= (GLintptr
)state
->storePack
.lsbFirst
;
260 case GL_UNPACK_ROW_LENGTH
:
261 *data
= (GLintptr
)state
->storeUnpack
.rowLength
;
263 case GL_UNPACK_IMAGE_HEIGHT
:
264 *data
= (GLintptr
)state
->storeUnpack
.imageHeight
;
266 case GL_UNPACK_SKIP_ROWS
:
267 *data
= (GLintptr
)state
->storeUnpack
.skipRows
;
269 case GL_UNPACK_SKIP_PIXELS
:
270 *data
= (GLintptr
)state
->storeUnpack
.skipPixels
;
272 case GL_UNPACK_SKIP_IMAGES
:
273 *data
= (GLintptr
)state
->storeUnpack
.skipImages
;
275 case GL_UNPACK_ALIGNMENT
:
276 *data
= (GLintptr
)state
->storeUnpack
.alignment
;
278 case GL_UNPACK_SWAP_BYTES
:
279 *data
= (GLintptr
)state
->storeUnpack
.swapEndian
;
281 case GL_UNPACK_LSB_FIRST
:
282 *data
= (GLintptr
)state
->storeUnpack
.lsbFirst
;
284 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH
:
285 *data
= (GLintptr
)__GL_CLIENT_ATTRIB_STACK_DEPTH
;
287 case GL_CLIENT_ACTIVE_TEXTURE
:
288 *data
= (GLintptr
)(tex_unit
+ GL_TEXTURE0
);
301 void __indirect_glGetBooleanv(GLenum val
, GLboolean
*b
)
303 const GLenum origVal
= val
;
304 __GLX_SINGLE_DECLARE_VARIABLES();
305 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
306 xGLXSingleReply reply
;
308 val
= RemapTransposeEnum( val
);
310 __GLX_SINGLE_LOAD_VARIABLES();
311 __GLX_SINGLE_BEGIN(X_GLsop_GetBooleanv
,4);
312 __GLX_SINGLE_PUT_LONG(0,val
);
313 __GLX_SINGLE_READ_XREPLY();
314 __GLX_SINGLE_GET_SIZE(compsize
);
318 ** Error occured; don't modify user's buffer.
324 ** We still needed to send the request to the server in order to
325 ** find out whether it was legal to make a query (it's illegal,
326 ** for example, to call a query between glBegin() and glEnd()).
329 if ( get_client_data( state
, val
, & data
) ) {
330 *b
= (GLboolean
) data
;
334 ** Not a local value, so use what we got from the server.
337 __GLX_SINGLE_GET_CHAR(b
);
339 __GLX_SINGLE_GET_CHAR_ARRAY(b
,compsize
);
340 if (val
!= origVal
) {
341 /* matrix transpose */
350 void __indirect_glGetDoublev(GLenum val
, GLdouble
*d
)
352 const GLenum origVal
= val
;
353 __GLX_SINGLE_DECLARE_VARIABLES();
354 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
355 xGLXSingleReply reply
;
357 val
= RemapTransposeEnum( val
);
359 __GLX_SINGLE_LOAD_VARIABLES();
360 __GLX_SINGLE_BEGIN(X_GLsop_GetDoublev
,4);
361 __GLX_SINGLE_PUT_LONG(0,val
);
362 __GLX_SINGLE_READ_XREPLY();
363 __GLX_SINGLE_GET_SIZE(compsize
);
367 ** Error occured; don't modify user's buffer.
373 ** We still needed to send the request to the server in order to
374 ** find out whether it was legal to make a query (it's illegal,
375 ** for example, to call a query between glBegin() and glEnd()).
378 if ( get_client_data( state
, val
, & data
) ) {
379 *d
= (GLdouble
) data
;
383 ** Not a local value, so use what we got from the server.
386 __GLX_SINGLE_GET_DOUBLE(d
);
388 __GLX_SINGLE_GET_DOUBLE_ARRAY(d
,compsize
);
389 if (val
!= origVal
) {
390 /* matrix transpose */
399 void __indirect_glGetFloatv(GLenum val
, GLfloat
*f
)
401 const GLenum origVal
= val
;
402 __GLX_SINGLE_DECLARE_VARIABLES();
403 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
404 xGLXSingleReply reply
;
406 val
= RemapTransposeEnum( val
);
408 __GLX_SINGLE_LOAD_VARIABLES();
409 __GLX_SINGLE_BEGIN(X_GLsop_GetFloatv
,4);
410 __GLX_SINGLE_PUT_LONG(0,val
);
411 __GLX_SINGLE_READ_XREPLY();
412 __GLX_SINGLE_GET_SIZE(compsize
);
416 ** Error occured; don't modify user's buffer.
422 ** We still needed to send the request to the server in order to
423 ** find out whether it was legal to make a query (it's illegal,
424 ** for example, to call a query between glBegin() and glEnd()).
427 if ( get_client_data( state
, val
, & data
) ) {
432 ** Not a local value, so use what we got from the server.
435 __GLX_SINGLE_GET_FLOAT(f
);
437 __GLX_SINGLE_GET_FLOAT_ARRAY(f
,compsize
);
438 if (val
!= origVal
) {
439 /* matrix transpose */
448 void __indirect_glGetIntegerv(GLenum val
, GLint
*i
)
450 const GLenum origVal
= val
;
451 __GLX_SINGLE_DECLARE_VARIABLES();
452 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
453 xGLXSingleReply reply
;
455 val
= RemapTransposeEnum( val
);
457 __GLX_SINGLE_LOAD_VARIABLES();
458 __GLX_SINGLE_BEGIN(X_GLsop_GetIntegerv
,4);
459 __GLX_SINGLE_PUT_LONG(0,val
);
460 __GLX_SINGLE_READ_XREPLY();
461 __GLX_SINGLE_GET_SIZE(compsize
);
465 ** Error occured; don't modify user's buffer.
471 ** We still needed to send the request to the server in order to
472 ** find out whether it was legal to make a query (it's illegal,
473 ** for example, to call a query between glBegin() and glEnd()).
476 if ( get_client_data( state
, val
, & data
) ) {
481 ** Not a local value, so use what we got from the server.
484 __GLX_SINGLE_GET_LONG(i
);
486 __GLX_SINGLE_GET_LONG_ARRAY(i
,compsize
);
487 if (val
!= origVal
) {
488 /* matrix transpose */
498 ** Send all pending commands to server.
500 void __indirect_glFlush(void)
502 __GLX_SINGLE_DECLARE_VARIABLES();
506 __GLX_SINGLE_LOAD_VARIABLES();
507 __GLX_SINGLE_BEGIN(X_GLsop_Flush
,0);
510 /* And finally flush the X protocol data */
514 void __indirect_glFeedbackBuffer(GLsizei size
, GLenum type
, GLfloat
*buffer
)
516 __GLX_SINGLE_DECLARE_VARIABLES();
520 __GLX_SINGLE_LOAD_VARIABLES();
521 __GLX_SINGLE_BEGIN(X_GLsop_FeedbackBuffer
,8);
522 __GLX_SINGLE_PUT_LONG(0,size
);
523 __GLX_SINGLE_PUT_LONG(4,type
);
526 gc
->feedbackBuf
= buffer
;
529 void __indirect_glSelectBuffer(GLsizei numnames
, GLuint
*buffer
)
531 __GLX_SINGLE_DECLARE_VARIABLES();
535 __GLX_SINGLE_LOAD_VARIABLES();
536 __GLX_SINGLE_BEGIN(X_GLsop_SelectBuffer
,4);
537 __GLX_SINGLE_PUT_LONG(0,numnames
);
540 gc
->selectBuf
= buffer
;
543 GLint
__indirect_glRenderMode(GLenum mode
)
545 __GLX_SINGLE_DECLARE_VARIABLES();
547 xGLXRenderModeReply reply
;
551 __GLX_SINGLE_LOAD_VARIABLES();
552 __GLX_SINGLE_BEGIN(X_GLsop_RenderMode
,4);
553 __GLX_SINGLE_PUT_LONG(0,mode
);
554 __GLX_SINGLE_READ_XREPLY();
555 __GLX_SINGLE_GET_RETVAL(retval
,GLint
);
557 if (reply
.newMode
!= mode
) {
559 ** Switch to new mode did not take effect, therefore an error
560 ** occured. When an error happens the server won't send us any
564 /* Read the feedback or selection data */
565 if (gc
->renderMode
== GL_FEEDBACK
) {
566 __GLX_SINGLE_GET_SIZE(compsize
);
567 __GLX_SINGLE_GET_FLOAT_ARRAY(gc
->feedbackBuf
, compsize
);
569 if (gc
->renderMode
== GL_SELECT
) {
570 __GLX_SINGLE_GET_SIZE(compsize
);
571 __GLX_SINGLE_GET_LONG_ARRAY(gc
->selectBuf
, compsize
);
573 gc
->renderMode
= mode
;
580 void __indirect_glFinish(void)
582 __GLX_SINGLE_DECLARE_VARIABLES();
583 xGLXSingleReply reply
;
585 __GLX_SINGLE_LOAD_VARIABLES();
586 __GLX_SINGLE_BEGIN(X_GLsop_Finish
,0);
587 __GLX_SINGLE_READ_XREPLY();
593 * Extract the major and minor version numbers from a version string.
596 version_from_string( const char * ver
,
597 int * major_version
, int * minor_version
)
603 major
= strtol( ver
, (char **) & end
, 10 );
604 minor
= strtol( end
+ 1, NULL
, 10 );
605 *major_version
= major
;
606 *minor_version
= minor
;
610 const GLubyte
*__indirect_glGetString(GLenum name
)
612 __GLXcontext
*gc
= __glXGetCurrentContext();
613 Display
*dpy
= gc
->currentDpy
;
619 ** Return the cached copy if the string has already been fetched
623 if (gc
->vendor
) return gc
->vendor
;
626 if (gc
->renderer
) return gc
->renderer
;
629 if (gc
->version
) return gc
->version
;
632 if (gc
->extensions
) return gc
->extensions
;
635 __glXSetError(gc
, GL_INVALID_ENUM
);
640 ** Get requested string from server
643 (void) __glXFlushRenderBuffer( gc
, gc
->pc
);
644 s
= (GLubyte
*) __glXGetStringFromServer( dpy
, gc
->majorOpcode
,
645 X_GLsop_GetString
, gc
->currentContextTag
,
648 /* Throw data on the floor */
649 __glXSetError(gc
, GL_OUT_OF_MEMORY
);
652 ** Update local cache
667 version_from_string( (char *) s
,
668 & gc
->server_major
, & gc
->server_minor
);
669 __glXGetGLVersion( & client_major
, & client_minor
);
671 if ( (gc
->server_major
< client_major
)
672 || ((gc
->server_major
== client_major
)
673 && (gc
->server_minor
<= client_minor
)) ) {
677 /* Allow 7 bytes for the client-side GL version. This allows
678 * for upto version 999.999. I'm not holding my breath for
679 * that one! The extra 4 is for the ' ()\0' that will be
682 const size_t size
= 7 + strlen( (char *) s
) + 4;
684 gc
->version
= Xmalloc( size
);
685 if ( gc
->version
== NULL
) {
686 /* If we couldn't allocate memory for the new string,
687 * make a best-effort and just copy the client-side version
688 * to the string and use that. It probably doesn't
689 * matter what is done here. If there not memory available
690 * for a short string, the system is probably going to die
693 snprintf( (char *) s
, strlen( (char *) s
) + 1, "%u.%u",
694 client_major
, client_minor
);
698 snprintf( (char *)gc
->version
, size
, "%u.%u (%s)",
699 client_major
, client_minor
, s
);
707 case GL_EXTENSIONS
: {
711 /* This code is currently disabled. I was reminded that some
712 * vendors intentionally exclude some extensions from their
713 * extension string that are part of the core version they
714 * advertise. In particular, on Nvidia drivers this means that
715 * the functionality is supported by the driver, but is not
716 * hardware accelerated. For example, a TNT will show core
717 * version 1.5, but most of the post-1.2 functionality is a
720 * I don't want to break applications that rely on this odd
721 * behavior. At the same time, the code is written and tested,
722 * so I didn't want to throw it away. Therefore, the code is here
723 * but disabled. In the future, we may wish to and an environment
724 * variable to enable it.
728 /* Call glGetString just to make sure that gc->server_major and
729 * gc->server_minor are set. This version may be higher than we
730 * can completely support, but it may imply support for some
731 * extensions that we can support.
733 * For example, at the time of this writing, the client-side
734 * library only supports upto core GL version 1.2. However, cubic
735 * textures, multitexture, multisampling, and some other 1.3
736 * features are supported. If the server reports back version
737 * 1.3, but does not report all of those extensions, we will
740 (void *) glGetString( GL_VERSION
);
741 major
= gc
->server_major
,
742 minor
= gc
->server_minor
;
745 __glXCalculateUsableGLExtensions( gc
, (char *) s
, major
, minor
);
755 GLboolean
__indirect_glIsEnabled(GLenum cap
)
757 __GLX_SINGLE_DECLARE_VARIABLES();
758 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
759 xGLXSingleReply reply
;
760 GLboolean retval
= 0;
766 case GL_VERTEX_ARRAY
:
767 case GL_NORMAL_ARRAY
:
770 case GL_EDGE_FLAG_ARRAY
:
771 case GL_SECONDARY_COLOR_ARRAY
:
772 case GL_FOG_COORD_ARRAY
:
773 retval
= __glXGetArrayEnable( state
, cap
, 0, & enable
);
775 return (GLboolean
) enable
;
777 case GL_TEXTURE_COORD_ARRAY
:
778 retval
= __glXGetArrayEnable( state
, GL_TEXTURE_COORD_ARRAY
,
779 __glXGetActiveTextureUnit( state
), & enable
);
781 return (GLboolean
) enable
;
785 __GLX_SINGLE_LOAD_VARIABLES();
786 __GLX_SINGLE_BEGIN(X_GLsop_IsEnabled
,4);
787 __GLX_SINGLE_PUT_LONG(0,cap
);
788 __GLX_SINGLE_READ_XREPLY();
789 __GLX_SINGLE_GET_RETVAL(retval
, GLboolean
);
794 void __indirect_glGetPointerv(GLenum pname
, void **params
)
796 __GLXcontext
*gc
= __glXGetCurrentContext();
797 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
798 Display
*dpy
= gc
->currentDpy
;
803 case GL_VERTEX_ARRAY_POINTER
:
804 case GL_NORMAL_ARRAY_POINTER
:
805 case GL_COLOR_ARRAY_POINTER
:
806 case GL_INDEX_ARRAY_POINTER
:
807 case GL_EDGE_FLAG_ARRAY_POINTER
:
808 __glXGetArrayPointer( state
, pname
- GL_VERTEX_ARRAY_POINTER
812 case GL_TEXTURE_COORD_ARRAY_POINTER
:
813 __glXGetArrayPointer( state
, GL_TEXTURE_COORD_ARRAY
,
814 __glXGetActiveTextureUnit( state
), params
);
816 case GL_SECONDARY_COLOR_ARRAY_POINTER
:
817 case GL_FOG_COORD_ARRAY_POINTER
:
818 __glXGetArrayPointer( state
, pname
- GL_FOG_COORD_ARRAY_POINTER
819 + GL_FOG_COORD_ARRAY
,
822 case GL_FEEDBACK_BUFFER_POINTER
:
823 *params
= (void *)gc
->feedbackBuf
;
825 case GL_SELECTION_BUFFER_POINTER
:
826 *params
= (void *)gc
->selectBuf
;
829 __glXSetError(gc
, GL_INVALID_ENUM
);