2 ** License Applicability. Except to the extent portions of this file are
3 ** made subject to an alternative license as permitted in the SGI Free
4 ** Software License B, Version 1.1 (the "License"), the contents of this
5 ** file are subject only to the provisions of the License. You may not use
6 ** this file except in compliance with the License. You may obtain a copy
7 ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
8 ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
10 ** http://oss.sgi.com/projects/FreeB
12 ** Note that, as provided in the License, the Software is distributed on an
13 ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
14 ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
15 ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
16 ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
18 ** Original Code. The Original Code is: OpenGL Sample Implementation,
19 ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
20 ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
21 ** Copyright in any portions created by third parties is as indicated
22 ** elsewhere herein. All Rights Reserved.
24 ** Additional Notice Provisions: The application programming interfaces
25 ** established by SGI in conjunction with the Original Code are The
26 ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
27 ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
28 ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
29 ** Window System(R) (Version 1.3), released October 19, 1998. This software
30 ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
31 ** published by SGI, but has not been independently verified as being
32 ** compliant with the OpenGL(R) version 1.2.1 Specification.
38 #include "glxclient.h"
39 #include "packsingle.h"
40 #include "glxextensions.h"
42 #include "indirect_vertex_array.h"
44 /* Used for GL_ARB_transpose_matrix */
45 static void TransposeMatrixf(GLfloat m
[16])
48 for (i
= 0; i
< 4; i
++) {
49 for (j
= 0; j
< i
; j
++) {
50 GLfloat tmp
= m
[i
*4+j
];
57 /* Used for GL_ARB_transpose_matrix */
58 static void TransposeMatrixb(GLboolean m
[16])
61 for (i
= 0; i
< 4; i
++) {
62 for (j
= 0; j
< i
; j
++) {
63 GLboolean tmp
= m
[i
*4+j
];
70 /* Used for GL_ARB_transpose_matrix */
71 static void TransposeMatrixd(GLdouble m
[16])
74 for (i
= 0; i
< 4; i
++) {
75 for (j
= 0; j
< i
; j
++) {
76 GLdouble tmp
= m
[i
*4+j
];
83 /* Used for GL_ARB_transpose_matrix */
84 static void TransposeMatrixi(GLint m
[16])
87 for (i
= 0; i
< 4; i
++) {
88 for (j
= 0; j
< i
; j
++) {
98 * Remap a transpose-matrix enum to a non-transpose-matrix enum. Enums
99 * that are not transpose-matrix enums are unaffected.
102 RemapTransposeEnum( GLenum e
)
105 case GL_TRANSPOSE_MODELVIEW_MATRIX
:
106 case GL_TRANSPOSE_PROJECTION_MATRIX
:
107 case GL_TRANSPOSE_TEXTURE_MATRIX
:
108 return e
- (GL_TRANSPOSE_MODELVIEW_MATRIX
- GL_MODELVIEW_MATRIX
);
109 case GL_TRANSPOSE_COLOR_MATRIX
:
110 return GL_COLOR_MATRIX
;
117 GLenum
__indirect_glGetError(void)
119 __GLX_SINGLE_DECLARE_VARIABLES();
120 GLuint retval
= GL_NO_ERROR
;
121 xGLXGetErrorReply reply
;
124 /* Use internal error first */
126 gc
->error
= GL_NO_ERROR
;
130 __GLX_SINGLE_LOAD_VARIABLES();
131 __GLX_SINGLE_BEGIN(X_GLsop_GetError
,0);
132 __GLX_SINGLE_READ_XREPLY();
133 retval
= reply
.error
;
141 * Get the selected attribute from the client state.
144 * On success \c GL_TRUE is returned. Otherwise, \c GL_FALSE is returned.
147 get_client_data( __GLXcontext
* gc
, GLenum cap
, GLintptr
* data
)
149 GLboolean retval
= GL_TRUE
;
150 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
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_CLIENT_ATTRIB_STACK_DEPTH
:
285 *data
= (GLintptr
)(gc
->attributes
.stackPointer
- gc
->attributes
.stack
);
287 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH
:
288 *data
= (GLintptr
)__GL_CLIENT_ATTRIB_STACK_DEPTH
;
290 case GL_CLIENT_ACTIVE_TEXTURE
:
291 *data
= (GLintptr
)(tex_unit
+ GL_TEXTURE0
);
304 void __indirect_glGetBooleanv(GLenum val
, GLboolean
*b
)
306 const GLenum origVal
= val
;
307 __GLX_SINGLE_DECLARE_VARIABLES();
308 xGLXSingleReply reply
;
310 val
= RemapTransposeEnum( val
);
312 __GLX_SINGLE_LOAD_VARIABLES();
313 __GLX_SINGLE_BEGIN(X_GLsop_GetBooleanv
,4);
314 __GLX_SINGLE_PUT_LONG(0,val
);
315 __GLX_SINGLE_READ_XREPLY();
316 __GLX_SINGLE_GET_SIZE(compsize
);
320 ** Error occured; don't modify user's buffer.
326 ** We still needed to send the request to the server in order to
327 ** find out whether it was legal to make a query (it's illegal,
328 ** for example, to call a query between glBegin() and glEnd()).
331 if ( get_client_data( gc
, val
, & data
) ) {
332 *b
= (GLboolean
) data
;
336 ** Not a local value, so use what we got from the server.
339 __GLX_SINGLE_GET_CHAR(b
);
341 __GLX_SINGLE_GET_CHAR_ARRAY(b
,compsize
);
342 if (val
!= origVal
) {
343 /* matrix transpose */
352 void __indirect_glGetDoublev(GLenum val
, GLdouble
*d
)
354 const GLenum origVal
= val
;
355 __GLX_SINGLE_DECLARE_VARIABLES();
356 xGLXSingleReply reply
;
358 val
= RemapTransposeEnum( val
);
360 __GLX_SINGLE_LOAD_VARIABLES();
361 __GLX_SINGLE_BEGIN(X_GLsop_GetDoublev
,4);
362 __GLX_SINGLE_PUT_LONG(0,val
);
363 __GLX_SINGLE_READ_XREPLY();
364 __GLX_SINGLE_GET_SIZE(compsize
);
368 ** Error occured; don't modify user's buffer.
374 ** We still needed to send the request to the server in order to
375 ** find out whether it was legal to make a query (it's illegal,
376 ** for example, to call a query between glBegin() and glEnd()).
379 if ( get_client_data( gc
, val
, & data
) ) {
380 *d
= (GLdouble
) data
;
384 ** Not a local value, so use what we got from the server.
387 __GLX_SINGLE_GET_DOUBLE(d
);
389 __GLX_SINGLE_GET_DOUBLE_ARRAY(d
,compsize
);
390 if (val
!= origVal
) {
391 /* matrix transpose */
400 void __indirect_glGetFloatv(GLenum val
, GLfloat
*f
)
402 const GLenum origVal
= val
;
403 __GLX_SINGLE_DECLARE_VARIABLES();
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( gc
, 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 xGLXSingleReply reply
;
454 val
= RemapTransposeEnum( val
);
456 __GLX_SINGLE_LOAD_VARIABLES();
457 __GLX_SINGLE_BEGIN(X_GLsop_GetIntegerv
,4);
458 __GLX_SINGLE_PUT_LONG(0,val
);
459 __GLX_SINGLE_READ_XREPLY();
460 __GLX_SINGLE_GET_SIZE(compsize
);
464 ** Error occured; don't modify user's buffer.
470 ** We still needed to send the request to the server in order to
471 ** find out whether it was legal to make a query (it's illegal,
472 ** for example, to call a query between glBegin() and glEnd()).
475 if ( get_client_data( gc
, val
, & data
) ) {
480 ** Not a local value, so use what we got from the server.
483 __GLX_SINGLE_GET_LONG(i
);
485 __GLX_SINGLE_GET_LONG_ARRAY(i
,compsize
);
486 if (val
!= origVal
) {
487 /* matrix transpose */
497 ** Send all pending commands to server.
499 void __indirect_glFlush(void)
501 __GLX_SINGLE_DECLARE_VARIABLES();
505 __GLX_SINGLE_LOAD_VARIABLES();
506 __GLX_SINGLE_BEGIN(X_GLsop_Flush
,0);
509 /* And finally flush the X protocol data */
513 void __indirect_glFeedbackBuffer(GLsizei size
, GLenum type
, GLfloat
*buffer
)
515 __GLX_SINGLE_DECLARE_VARIABLES();
519 __GLX_SINGLE_LOAD_VARIABLES();
520 __GLX_SINGLE_BEGIN(X_GLsop_FeedbackBuffer
,8);
521 __GLX_SINGLE_PUT_LONG(0,size
);
522 __GLX_SINGLE_PUT_LONG(4,type
);
525 gc
->feedbackBuf
= buffer
;
528 void __indirect_glSelectBuffer(GLsizei numnames
, GLuint
*buffer
)
530 __GLX_SINGLE_DECLARE_VARIABLES();
534 __GLX_SINGLE_LOAD_VARIABLES();
535 __GLX_SINGLE_BEGIN(X_GLsop_SelectBuffer
,4);
536 __GLX_SINGLE_PUT_LONG(0,numnames
);
539 gc
->selectBuf
= buffer
;
542 GLint
__indirect_glRenderMode(GLenum mode
)
544 __GLX_SINGLE_DECLARE_VARIABLES();
546 xGLXRenderModeReply reply
;
550 __GLX_SINGLE_LOAD_VARIABLES();
551 __GLX_SINGLE_BEGIN(X_GLsop_RenderMode
,4);
552 __GLX_SINGLE_PUT_LONG(0,mode
);
553 __GLX_SINGLE_READ_XREPLY();
554 __GLX_SINGLE_GET_RETVAL(retval
,GLint
);
556 if (reply
.newMode
!= mode
) {
558 ** Switch to new mode did not take effect, therefore an error
559 ** occured. When an error happens the server won't send us any
563 /* Read the feedback or selection data */
564 if (gc
->renderMode
== GL_FEEDBACK
) {
565 __GLX_SINGLE_GET_SIZE(compsize
);
566 __GLX_SINGLE_GET_FLOAT_ARRAY(gc
->feedbackBuf
, compsize
);
568 if (gc
->renderMode
== GL_SELECT
) {
569 __GLX_SINGLE_GET_SIZE(compsize
);
570 __GLX_SINGLE_GET_LONG_ARRAY(gc
->selectBuf
, compsize
);
572 gc
->renderMode
= mode
;
579 void __indirect_glFinish(void)
581 __GLX_SINGLE_DECLARE_VARIABLES();
582 xGLXSingleReply reply
;
584 __GLX_SINGLE_LOAD_VARIABLES();
585 __GLX_SINGLE_BEGIN(X_GLsop_Finish
,0);
586 __GLX_SINGLE_READ_XREPLY();
592 * Extract the major and minor version numbers from a version string.
595 version_from_string( const char * ver
,
596 int * major_version
, int * minor_version
)
602 major
= strtol( ver
, (char **) & end
, 10 );
603 minor
= strtol( end
+ 1, NULL
, 10 );
604 *major_version
= major
;
605 *minor_version
= minor
;
609 const GLubyte
*__indirect_glGetString(GLenum name
)
611 __GLXcontext
*gc
= __glXGetCurrentContext();
612 Display
*dpy
= gc
->currentDpy
;
618 ** Return the cached copy if the string has already been fetched
622 if (gc
->vendor
) return gc
->vendor
;
625 if (gc
->renderer
) return gc
->renderer
;
628 if (gc
->version
) return gc
->version
;
631 if (gc
->extensions
) return gc
->extensions
;
634 __glXSetError(gc
, GL_INVALID_ENUM
);
639 ** Get requested string from server
642 (void) __glXFlushRenderBuffer( gc
, gc
->pc
);
643 s
= (GLubyte
*) __glXGetStringFromServer( dpy
, gc
->majorOpcode
,
644 X_GLsop_GetString
, gc
->currentContextTag
,
647 /* Throw data on the floor */
648 __glXSetError(gc
, GL_OUT_OF_MEMORY
);
651 ** Update local cache
666 version_from_string( (char *) s
,
667 & gc
->server_major
, & gc
->server_minor
);
668 __glXGetGLVersion( & client_major
, & client_minor
);
670 if ( (gc
->server_major
< client_major
)
671 || ((gc
->server_major
== client_major
)
672 && (gc
->server_minor
<= client_minor
)) ) {
676 /* Allow 7 bytes for the client-side GL version. This allows
677 * for upto version 999.999. I'm not holding my breath for
678 * that one! The extra 4 is for the ' ()\0' that will be
681 const size_t size
= 7 + strlen( (char *) s
) + 4;
683 gc
->version
= Xmalloc( size
);
684 if ( gc
->version
== NULL
) {
685 /* If we couldn't allocate memory for the new string,
686 * make a best-effort and just copy the client-side version
687 * to the string and use that. It probably doesn't
688 * matter what is done here. If there not memory available
689 * for a short string, the system is probably going to die
692 snprintf( (char *) s
, strlen( (char *) s
) + 1, "%u.%u",
693 client_major
, client_minor
);
697 snprintf( (char *)gc
->version
, size
, "%u.%u (%s)",
698 client_major
, client_minor
, s
);
706 case GL_EXTENSIONS
: {
710 /* This code is currently disabled. I was reminded that some
711 * vendors intentionally exclude some extensions from their
712 * extension string that are part of the core version they
713 * advertise. In particular, on Nvidia drivers this means that
714 * the functionality is supported by the driver, but is not
715 * hardware accelerated. For example, a TNT will show core
716 * version 1.5, but most of the post-1.2 functionality is a
719 * I don't want to break applications that rely on this odd
720 * behavior. At the same time, the code is written and tested,
721 * so I didn't want to throw it away. Therefore, the code is here
722 * but disabled. In the future, we may wish to and an environment
723 * variable to enable it.
727 /* Call glGetString just to make sure that gc->server_major and
728 * gc->server_minor are set. This version may be higher than we
729 * can completely support, but it may imply support for some
730 * extensions that we can support.
732 * For example, at the time of this writing, the client-side
733 * library only supports upto core GL version 1.2. However, cubic
734 * textures, multitexture, multisampling, and some other 1.3
735 * features are supported. If the server reports back version
736 * 1.3, but does not report all of those extensions, we will
739 (void *) glGetString( GL_VERSION
);
740 major
= gc
->server_major
,
741 minor
= gc
->server_minor
;
744 __glXCalculateUsableGLExtensions( gc
, (char *) s
, major
, minor
);
754 GLboolean
__indirect_glIsEnabled(GLenum cap
)
756 __GLX_SINGLE_DECLARE_VARIABLES();
757 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
758 xGLXSingleReply reply
;
759 GLboolean retval
= 0;
765 case GL_VERTEX_ARRAY
:
766 case GL_NORMAL_ARRAY
:
769 case GL_EDGE_FLAG_ARRAY
:
770 case GL_SECONDARY_COLOR_ARRAY
:
771 case GL_FOG_COORD_ARRAY
:
772 retval
= __glXGetArrayEnable( state
, cap
, 0, & enable
);
774 return (GLboolean
) enable
;
776 case GL_TEXTURE_COORD_ARRAY
:
777 retval
= __glXGetArrayEnable( state
, GL_TEXTURE_COORD_ARRAY
,
778 __glXGetActiveTextureUnit( state
), & enable
);
780 return (GLboolean
) enable
;
784 __GLX_SINGLE_LOAD_VARIABLES();
785 __GLX_SINGLE_BEGIN(X_GLsop_IsEnabled
,4);
786 __GLX_SINGLE_PUT_LONG(0,cap
);
787 __GLX_SINGLE_READ_XREPLY();
788 __GLX_SINGLE_GET_RETVAL(retval
, GLboolean
);
793 void __indirect_glGetPointerv(GLenum pname
, void **params
)
795 __GLXcontext
*gc
= __glXGetCurrentContext();
796 __GLXattribute
* state
= (__GLXattribute
*)(gc
->client_state_private
);
797 Display
*dpy
= gc
->currentDpy
;
802 case GL_VERTEX_ARRAY_POINTER
:
803 case GL_NORMAL_ARRAY_POINTER
:
804 case GL_COLOR_ARRAY_POINTER
:
805 case GL_INDEX_ARRAY_POINTER
:
806 case GL_EDGE_FLAG_ARRAY_POINTER
:
807 __glXGetArrayPointer( state
, pname
- GL_VERTEX_ARRAY_POINTER
811 case GL_TEXTURE_COORD_ARRAY_POINTER
:
812 __glXGetArrayPointer( state
, GL_TEXTURE_COORD_ARRAY
,
813 __glXGetActiveTextureUnit( state
), params
);
815 case GL_SECONDARY_COLOR_ARRAY_POINTER
:
816 case GL_FOG_COORD_ARRAY_POINTER
:
817 __glXGetArrayPointer( state
, pname
- GL_FOG_COORD_ARRAY_POINTER
818 + GL_FOG_COORD_ARRAY
,
821 case GL_FEEDBACK_BUFFER_POINTER
:
822 *params
= (void *)gc
->feedbackBuf
;
824 case GL_SELECTION_BUFFER_POINTER
:
825 *params
= (void *)gc
->selectBuf
;
828 __glXSetError(gc
, GL_INVALID_ENUM
);