1 /* -*- mode: c; tab-width: 3; indent-tabs-mode: nil; c-basic-offset: 3; coding: utf-8-unix -*- */
3 * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
4 * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
13 * The above copyright notice including the dates of first publication and
14 * either this permission notice or a reference to
15 * http://oss.sgi.com/projects/FreeB/
16 * shall be included in all copies or substantial portions of the Software.
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
22 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
23 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
26 * Except as contained in this notice, the name of Silicon Graphics, Inc.
27 * shall not be used in advertising or otherwise to promote the sale, use or
28 * other dealings in this Software without prior written authorization from
29 * Silicon Graphics, Inc.
34 #include "glxclient.h"
35 #include "packsingle.h"
36 #include "glxextensions.h"
38 #include "indirect_vertex_array.h"
40 /* Used for GL_ARB_transpose_matrix */
42 TransposeMatrixf(GLfloat m
[16])
45 for (i
= 0; i
< 4; i
++) {
46 for (j
= 0; j
< i
; j
++) {
47 GLfloat tmp
= m
[i
* 4 + j
];
48 m
[i
* 4 + j
] = m
[j
* 4 + i
];
54 /* Used for GL_ARB_transpose_matrix */
56 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
];
62 m
[i
* 4 + j
] = m
[j
* 4 + i
];
68 /* Used for GL_ARB_transpose_matrix */
70 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
];
76 m
[i
* 4 + j
] = m
[j
* 4 + i
];
82 /* Used for GL_ARB_transpose_matrix */
84 TransposeMatrixi(GLint m
[16])
87 for (i
= 0; i
< 4; i
++) {
88 for (j
= 0; j
< i
; j
++) {
89 GLint tmp
= m
[i
* 4 + j
];
90 m
[i
* 4 + j
] = m
[j
* 4 + i
];
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
;
118 __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(__GLXcontext
* gc
, GLenum cap
, GLintptr
* data
)
150 GLboolean retval
= GL_TRUE
;
151 __GLXattribute
*state
= (__GLXattribute
*) (gc
->client_state_private
);
152 const GLint tex_unit
= __glXGetActiveTextureUnit(state
);
156 case GL_VERTEX_ARRAY
:
157 case GL_NORMAL_ARRAY
:
160 case GL_EDGE_FLAG_ARRAY
:
161 case GL_SECONDARY_COLOR_ARRAY
:
162 case GL_FOG_COORD_ARRAY
:
163 retval
= __glXGetArrayEnable(state
, cap
, 0, data
);
166 case GL_VERTEX_ARRAY_SIZE
:
167 retval
= __glXGetArraySize(state
, GL_VERTEX_ARRAY
, 0, data
);
169 case GL_COLOR_ARRAY_SIZE
:
170 retval
= __glXGetArraySize(state
, GL_COLOR_ARRAY
, 0, data
);
172 case GL_SECONDARY_COLOR_ARRAY_SIZE
:
173 retval
= __glXGetArraySize(state
, GL_SECONDARY_COLOR_ARRAY
, 0, data
);
176 case GL_VERTEX_ARRAY_TYPE
:
177 retval
= __glXGetArrayType(state
, GL_VERTEX_ARRAY
, 0, data
);
179 case GL_NORMAL_ARRAY_TYPE
:
180 retval
= __glXGetArrayType(state
, GL_NORMAL_ARRAY
, 0, data
);
182 case GL_INDEX_ARRAY_TYPE
:
183 retval
= __glXGetArrayType(state
, GL_INDEX_ARRAY
, 0, data
);
185 case GL_COLOR_ARRAY_TYPE
:
186 retval
= __glXGetArrayType(state
, GL_COLOR_ARRAY
, 0, data
);
188 case GL_SECONDARY_COLOR_ARRAY_TYPE
:
189 retval
= __glXGetArrayType(state
, GL_SECONDARY_COLOR_ARRAY
, 0, data
);
191 case GL_FOG_COORD_ARRAY_TYPE
:
192 retval
= __glXGetArrayType(state
, GL_FOG_COORD_ARRAY
, 0, data
);
195 case GL_VERTEX_ARRAY_STRIDE
:
196 retval
= __glXGetArrayStride(state
, GL_VERTEX_ARRAY
, 0, data
);
198 case GL_NORMAL_ARRAY_STRIDE
:
199 retval
= __glXGetArrayStride(state
, GL_NORMAL_ARRAY
, 0, data
);
201 case GL_INDEX_ARRAY_STRIDE
:
202 retval
= __glXGetArrayStride(state
, GL_INDEX_ARRAY
, 0, data
);
204 case GL_EDGE_FLAG_ARRAY_STRIDE
:
205 retval
= __glXGetArrayStride(state
, GL_EDGE_FLAG_ARRAY
, 0, data
);
207 case GL_COLOR_ARRAY_STRIDE
:
208 retval
= __glXGetArrayStride(state
, GL_COLOR_ARRAY
, 0, data
);
210 case GL_SECONDARY_COLOR_ARRAY_STRIDE
:
211 retval
= __glXGetArrayStride(state
, GL_SECONDARY_COLOR_ARRAY
, 0, data
);
213 case GL_FOG_COORD_ARRAY_STRIDE
:
214 retval
= __glXGetArrayStride(state
, GL_FOG_COORD_ARRAY
, 0, data
);
217 case GL_TEXTURE_COORD_ARRAY
:
219 __glXGetArrayEnable(state
, GL_TEXTURE_COORD_ARRAY
, tex_unit
, data
);
221 case GL_TEXTURE_COORD_ARRAY_SIZE
:
223 __glXGetArraySize(state
, GL_TEXTURE_COORD_ARRAY
, tex_unit
, data
);
225 case GL_TEXTURE_COORD_ARRAY_TYPE
:
227 __glXGetArrayType(state
, GL_TEXTURE_COORD_ARRAY
, tex_unit
, data
);
229 case GL_TEXTURE_COORD_ARRAY_STRIDE
:
231 __glXGetArrayStride(state
, GL_TEXTURE_COORD_ARRAY
, tex_unit
, data
);
234 case GL_MAX_ELEMENTS_VERTICES
:
235 case GL_MAX_ELEMENTS_INDICES
:
241 case GL_PACK_ROW_LENGTH
:
242 *data
= (GLintptr
) state
->storePack
.rowLength
;
244 case GL_PACK_IMAGE_HEIGHT
:
245 *data
= (GLintptr
) state
->storePack
.imageHeight
;
247 case GL_PACK_SKIP_ROWS
:
248 *data
= (GLintptr
) state
->storePack
.skipRows
;
250 case GL_PACK_SKIP_PIXELS
:
251 *data
= (GLintptr
) state
->storePack
.skipPixels
;
253 case GL_PACK_SKIP_IMAGES
:
254 *data
= (GLintptr
) state
->storePack
.skipImages
;
256 case GL_PACK_ALIGNMENT
:
257 *data
= (GLintptr
) state
->storePack
.alignment
;
259 case GL_PACK_SWAP_BYTES
:
260 *data
= (GLintptr
) state
->storePack
.swapEndian
;
262 case GL_PACK_LSB_FIRST
:
263 *data
= (GLintptr
) state
->storePack
.lsbFirst
;
265 case GL_UNPACK_ROW_LENGTH
:
266 *data
= (GLintptr
) state
->storeUnpack
.rowLength
;
268 case GL_UNPACK_IMAGE_HEIGHT
:
269 *data
= (GLintptr
) state
->storeUnpack
.imageHeight
;
271 case GL_UNPACK_SKIP_ROWS
:
272 *data
= (GLintptr
) state
->storeUnpack
.skipRows
;
274 case GL_UNPACK_SKIP_PIXELS
:
275 *data
= (GLintptr
) state
->storeUnpack
.skipPixels
;
277 case GL_UNPACK_SKIP_IMAGES
:
278 *data
= (GLintptr
) state
->storeUnpack
.skipImages
;
280 case GL_UNPACK_ALIGNMENT
:
281 *data
= (GLintptr
) state
->storeUnpack
.alignment
;
283 case GL_UNPACK_SWAP_BYTES
:
284 *data
= (GLintptr
) state
->storeUnpack
.swapEndian
;
286 case GL_UNPACK_LSB_FIRST
:
287 *data
= (GLintptr
) state
->storeUnpack
.lsbFirst
;
289 case GL_CLIENT_ATTRIB_STACK_DEPTH
:
290 *data
= (GLintptr
) (gc
->attributes
.stackPointer
- gc
->attributes
.stack
);
292 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH
:
293 *data
= (GLintptr
) __GL_CLIENT_ATTRIB_STACK_DEPTH
;
295 case GL_CLIENT_ACTIVE_TEXTURE
:
296 *data
= (GLintptr
) (tex_unit
+ GL_TEXTURE0
);
310 __indirect_glGetBooleanv(GLenum val
, GLboolean
* b
)
312 const GLenum origVal
= val
;
313 __GLX_SINGLE_DECLARE_VARIABLES();
314 xGLXSingleReply reply
;
316 val
= RemapTransposeEnum(val
);
318 __GLX_SINGLE_LOAD_VARIABLES();
319 __GLX_SINGLE_BEGIN(X_GLsop_GetBooleanv
, 4);
320 __GLX_SINGLE_PUT_LONG(0, val
);
321 __GLX_SINGLE_READ_XREPLY();
322 __GLX_SINGLE_GET_SIZE(compsize
);
326 ** Error occured; don't modify user's buffer.
333 ** We still needed to send the request to the server in order to
334 ** find out whether it was legal to make a query (it's illegal,
335 ** for example, to call a query between glBegin() and glEnd()).
338 if (get_client_data(gc
, val
, &data
)) {
339 *b
= (GLboolean
) data
;
343 ** Not a local value, so use what we got from the server.
346 __GLX_SINGLE_GET_CHAR(b
);
349 __GLX_SINGLE_GET_CHAR_ARRAY(b
, compsize
);
350 if (val
!= origVal
) {
351 /* matrix transpose */
361 __indirect_glGetDoublev(GLenum val
, GLdouble
* d
)
363 const GLenum origVal
= val
;
364 __GLX_SINGLE_DECLARE_VARIABLES();
365 xGLXSingleReply reply
;
367 val
= RemapTransposeEnum(val
);
369 __GLX_SINGLE_LOAD_VARIABLES();
370 __GLX_SINGLE_BEGIN(X_GLsop_GetDoublev
, 4);
371 __GLX_SINGLE_PUT_LONG(0, val
);
372 __GLX_SINGLE_READ_XREPLY();
373 __GLX_SINGLE_GET_SIZE(compsize
);
377 ** Error occured; don't modify user's buffer.
384 ** We still needed to send the request to the server in order to
385 ** find out whether it was legal to make a query (it's illegal,
386 ** for example, to call a query between glBegin() and glEnd()).
389 if (get_client_data(gc
, val
, &data
)) {
390 *d
= (GLdouble
) data
;
394 ** Not a local value, so use what we got from the server.
397 __GLX_SINGLE_GET_DOUBLE(d
);
400 __GLX_SINGLE_GET_DOUBLE_ARRAY(d
, compsize
);
401 if (val
!= origVal
) {
402 /* matrix transpose */
412 __indirect_glGetFloatv(GLenum val
, GLfloat
* f
)
414 const GLenum origVal
= val
;
415 __GLX_SINGLE_DECLARE_VARIABLES();
416 xGLXSingleReply reply
;
418 val
= RemapTransposeEnum(val
);
420 __GLX_SINGLE_LOAD_VARIABLES();
421 __GLX_SINGLE_BEGIN(X_GLsop_GetFloatv
, 4);
422 __GLX_SINGLE_PUT_LONG(0, val
);
423 __GLX_SINGLE_READ_XREPLY();
424 __GLX_SINGLE_GET_SIZE(compsize
);
428 ** Error occured; don't modify user's buffer.
435 ** We still needed to send the request to the server in order to
436 ** find out whether it was legal to make a query (it's illegal,
437 ** for example, to call a query between glBegin() and glEnd()).
440 if (get_client_data(gc
, val
, &data
)) {
445 ** Not a local value, so use what we got from the server.
448 __GLX_SINGLE_GET_FLOAT(f
);
451 __GLX_SINGLE_GET_FLOAT_ARRAY(f
, compsize
);
452 if (val
!= origVal
) {
453 /* matrix transpose */
463 __indirect_glGetIntegerv(GLenum val
, GLint
* i
)
465 const GLenum origVal
= val
;
466 __GLX_SINGLE_DECLARE_VARIABLES();
467 xGLXSingleReply reply
;
469 val
= RemapTransposeEnum(val
);
471 __GLX_SINGLE_LOAD_VARIABLES();
472 __GLX_SINGLE_BEGIN(X_GLsop_GetIntegerv
, 4);
473 __GLX_SINGLE_PUT_LONG(0, val
);
474 __GLX_SINGLE_READ_XREPLY();
475 __GLX_SINGLE_GET_SIZE(compsize
);
479 ** Error occured; don't modify user's buffer.
486 ** We still needed to send the request to the server in order to
487 ** find out whether it was legal to make a query (it's illegal,
488 ** for example, to call a query between glBegin() and glEnd()).
491 if (get_client_data(gc
, val
, &data
)) {
496 ** Not a local value, so use what we got from the server.
499 __GLX_SINGLE_GET_LONG(i
);
502 __GLX_SINGLE_GET_LONG_ARRAY(i
, compsize
);
503 if (val
!= origVal
) {
504 /* matrix transpose */
514 ** Send all pending commands to server.
517 __indirect_glFlush(void)
519 __GLX_SINGLE_DECLARE_VARIABLES();
524 __GLX_SINGLE_LOAD_VARIABLES();
525 __GLX_SINGLE_BEGIN(X_GLsop_Flush
, 0);
528 /* And finally flush the X protocol data */
533 __indirect_glFeedbackBuffer(GLsizei size
, GLenum type
, GLfloat
* buffer
)
535 __GLX_SINGLE_DECLARE_VARIABLES();
540 __GLX_SINGLE_LOAD_VARIABLES();
541 __GLX_SINGLE_BEGIN(X_GLsop_FeedbackBuffer
, 8);
542 __GLX_SINGLE_PUT_LONG(0, size
);
543 __GLX_SINGLE_PUT_LONG(4, type
);
546 gc
->feedbackBuf
= buffer
;
550 __indirect_glSelectBuffer(GLsizei numnames
, GLuint
* buffer
)
552 __GLX_SINGLE_DECLARE_VARIABLES();
557 __GLX_SINGLE_LOAD_VARIABLES();
558 __GLX_SINGLE_BEGIN(X_GLsop_SelectBuffer
, 4);
559 __GLX_SINGLE_PUT_LONG(0, numnames
);
562 gc
->selectBuf
= buffer
;
566 __indirect_glRenderMode(GLenum mode
)
568 __GLX_SINGLE_DECLARE_VARIABLES();
570 xGLXRenderModeReply reply
;
575 __GLX_SINGLE_LOAD_VARIABLES();
576 __GLX_SINGLE_BEGIN(X_GLsop_RenderMode
, 4);
577 __GLX_SINGLE_PUT_LONG(0, mode
);
578 __GLX_SINGLE_READ_XREPLY();
579 __GLX_SINGLE_GET_RETVAL(retval
, GLint
);
581 if (reply
.newMode
!= mode
) {
583 ** Switch to new mode did not take effect, therefore an error
584 ** occured. When an error happens the server won't send us any
589 /* Read the feedback or selection data */
590 if (gc
->renderMode
== GL_FEEDBACK
) {
591 __GLX_SINGLE_GET_SIZE(compsize
);
592 __GLX_SINGLE_GET_FLOAT_ARRAY(gc
->feedbackBuf
, compsize
);
594 else if (gc
->renderMode
== GL_SELECT
) {
595 __GLX_SINGLE_GET_SIZE(compsize
);
596 __GLX_SINGLE_GET_LONG_ARRAY(gc
->selectBuf
, compsize
);
598 gc
->renderMode
= mode
;
606 __indirect_glFinish(void)
608 __GLX_SINGLE_DECLARE_VARIABLES();
609 xGLXSingleReply reply
;
611 __GLX_SINGLE_LOAD_VARIABLES();
612 __GLX_SINGLE_BEGIN(X_GLsop_Finish
, 0);
613 __GLX_SINGLE_READ_XREPLY();
619 * Extract the major and minor version numbers from a version string.
622 version_from_string(const char *ver
, int *major_version
, int *minor_version
)
628 major
= strtol(ver
, (char **) &end
, 10);
629 minor
= strtol(end
+ 1, NULL
, 10);
630 *major_version
= major
;
631 *minor_version
= minor
;
636 __indirect_glGetString(GLenum name
)
638 __GLXcontext
*gc
= __glXGetCurrentContext();
639 Display
*dpy
= gc
->currentDpy
;
646 ** Return the cached copy if the string has already been fetched
663 return gc
->extensions
;
666 __glXSetError(gc
, GL_INVALID_ENUM
);
671 ** Get requested string from server
674 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
675 s
= (GLubyte
*) __glXGetStringFromServer(dpy
, gc
->majorOpcode
,
677 gc
->currentContextTag
, name
);
679 /* Throw data on the floor */
680 __glXSetError(gc
, GL_OUT_OF_MEMORY
);
684 ** Update local cache
699 version_from_string((char *) s
,
700 &gc
->server_major
, &gc
->server_minor
);
701 __glXGetGLVersion(&client_major
, &client_minor
);
703 if ((gc
->server_major
< client_major
)
704 || ((gc
->server_major
== client_major
)
705 && (gc
->server_minor
<= client_minor
))) {
709 /* Allow 7 bytes for the client-side GL version. This allows
710 * for upto version 999.999. I'm not holding my breath for
711 * that one! The extra 4 is for the ' ()\0' that will be
714 const size_t size
= 7 + strlen((char *) s
) + 4;
716 gc
->version
= Xmalloc(size
);
717 if (gc
->version
== NULL
) {
718 /* If we couldn't allocate memory for the new string,
719 * make a best-effort and just copy the client-side version
720 * to the string and use that. It probably doesn't
721 * matter what is done here. If there not memory available
722 * for a short string, the system is probably going to die
725 snprintf((char *) s
, strlen((char *) s
) + 1, "%u.%u",
726 client_major
, client_minor
);
730 snprintf((char *) gc
->version
, size
, "%u.%u (%s)",
731 client_major
, client_minor
, s
);
743 /* This code is currently disabled. I was reminded that some
744 * vendors intentionally exclude some extensions from their
745 * extension string that are part of the core version they
746 * advertise. In particular, on Nvidia drivers this means that
747 * the functionality is supported by the driver, but is not
748 * hardware accelerated. For example, a TNT will show core
749 * version 1.5, but most of the post-1.2 functionality is a
752 * I don't want to break applications that rely on this odd
753 * behavior. At the same time, the code is written and tested,
754 * so I didn't want to throw it away. Therefore, the code is here
755 * but disabled. In the future, we may wish to and an environment
756 * variable to enable it.
760 /* Call glGetString just to make sure that gc->server_major and
761 * gc->server_minor are set. This version may be higher than we
762 * can completely support, but it may imply support for some
763 * extensions that we can support.
765 * For example, at the time of this writing, the client-side
766 * library only supports upto core GL version 1.2. However, cubic
767 * textures, multitexture, multisampling, and some other 1.3
768 * features are supported. If the server reports back version
769 * 1.3, but does not report all of those extensions, we will
772 (void *) glGetString(GL_VERSION
);
773 major
= gc
->server_major
, minor
= gc
->server_minor
;
776 __glXCalculateUsableGLExtensions(gc
, (char *) s
, major
, minor
);
787 __indirect_glIsEnabled(GLenum cap
)
789 __GLX_SINGLE_DECLARE_VARIABLES();
790 __GLXattribute
*state
= (__GLXattribute
*) (gc
->client_state_private
);
791 xGLXSingleReply reply
;
792 GLboolean retval
= 0;
799 case GL_VERTEX_ARRAY
:
800 case GL_NORMAL_ARRAY
:
803 case GL_EDGE_FLAG_ARRAY
:
804 case GL_SECONDARY_COLOR_ARRAY
:
805 case GL_FOG_COORD_ARRAY
:
806 retval
= __glXGetArrayEnable(state
, cap
, 0, &enable
);
808 return (GLboolean
) enable
;
810 case GL_TEXTURE_COORD_ARRAY
:
811 retval
= __glXGetArrayEnable(state
, GL_TEXTURE_COORD_ARRAY
,
812 __glXGetActiveTextureUnit(state
), &enable
);
814 return (GLboolean
) enable
;
818 __GLX_SINGLE_LOAD_VARIABLES();
819 __GLX_SINGLE_BEGIN(X_GLsop_IsEnabled
, 4);
820 __GLX_SINGLE_PUT_LONG(0, cap
);
821 __GLX_SINGLE_READ_XREPLY();
822 __GLX_SINGLE_GET_RETVAL(retval
, GLboolean
);
828 __indirect_glGetPointerv(GLenum pname
, void **params
)
830 __GLXcontext
*gc
= __glXGetCurrentContext();
831 __GLXattribute
*state
= (__GLXattribute
*) (gc
->client_state_private
);
832 Display
*dpy
= gc
->currentDpy
;
838 case GL_VERTEX_ARRAY_POINTER
:
839 case GL_NORMAL_ARRAY_POINTER
:
840 case GL_COLOR_ARRAY_POINTER
:
841 case GL_INDEX_ARRAY_POINTER
:
842 case GL_EDGE_FLAG_ARRAY_POINTER
:
843 __glXGetArrayPointer(state
, pname
- GL_VERTEX_ARRAY_POINTER
844 + GL_VERTEX_ARRAY
, 0, params
);
846 case GL_TEXTURE_COORD_ARRAY_POINTER
:
847 __glXGetArrayPointer(state
, GL_TEXTURE_COORD_ARRAY
,
848 __glXGetActiveTextureUnit(state
), params
);
850 case GL_SECONDARY_COLOR_ARRAY_POINTER
:
851 case GL_FOG_COORD_ARRAY_POINTER
:
852 __glXGetArrayPointer(state
, pname
- GL_FOG_COORD_ARRAY_POINTER
853 + GL_FOG_COORD_ARRAY
, 0, params
);
855 case GL_FEEDBACK_BUFFER_POINTER
:
856 *params
= (void *) gc
->feedbackBuf
;
858 case GL_SELECTION_BUFFER_POINTER
:
859 *params
= (void *) gc
->selectBuf
;
862 __glXSetError(gc
, GL_INVALID_ENUM
);