2 * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
3 * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
12 * The above copyright notice including the dates of first publication and
13 * either this permission notice or a reference to
14 * http://oss.sgi.com/projects/FreeB/
15 * shall be included in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
22 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25 * Except as contained in this notice, the name of Silicon Graphics, Inc.
26 * shall not be used in advertising or otherwise to promote the sale, use or
27 * other dealings in this Software without prior written authorization from
28 * Silicon Graphics, Inc.
33 #include "glxclient.h"
34 #include "packsingle.h"
35 #include "glxextensions.h"
37 #include "indirect_vertex_array.h"
41 #include <X11/Xlib-xcb.h>
43 #if !defined(__GNUC__)
44 # define __builtin_expect(x, y) x
47 /* Used for GL_ARB_transpose_matrix */
49 TransposeMatrixf(GLfloat m
[16])
52 for (i
= 0; i
< 4; i
++) {
53 for (j
= 0; j
< i
; j
++) {
54 GLfloat tmp
= m
[i
* 4 + j
];
55 m
[i
* 4 + j
] = m
[j
* 4 + i
];
61 /* Used for GL_ARB_transpose_matrix */
63 TransposeMatrixb(GLboolean m
[16])
66 for (i
= 0; i
< 4; i
++) {
67 for (j
= 0; j
< i
; j
++) {
68 GLboolean tmp
= m
[i
* 4 + j
];
69 m
[i
* 4 + j
] = m
[j
* 4 + i
];
75 /* Used for GL_ARB_transpose_matrix */
77 TransposeMatrixd(GLdouble m
[16])
80 for (i
= 0; i
< 4; i
++) {
81 for (j
= 0; j
< i
; j
++) {
82 GLdouble tmp
= m
[i
* 4 + j
];
83 m
[i
* 4 + j
] = m
[j
* 4 + i
];
89 /* Used for GL_ARB_transpose_matrix */
91 TransposeMatrixi(GLint m
[16])
94 for (i
= 0; i
< 4; i
++) {
95 for (j
= 0; j
< i
; j
++) {
96 GLint tmp
= m
[i
* 4 + j
];
97 m
[i
* 4 + j
] = m
[j
* 4 + i
];
105 * Remap a transpose-matrix enum to a non-transpose-matrix enum. Enums
106 * that are not transpose-matrix enums are unaffected.
109 RemapTransposeEnum(GLenum e
)
112 case GL_TRANSPOSE_MODELVIEW_MATRIX
:
113 case GL_TRANSPOSE_PROJECTION_MATRIX
:
114 case GL_TRANSPOSE_TEXTURE_MATRIX
:
115 return e
- (GL_TRANSPOSE_MODELVIEW_MATRIX
- GL_MODELVIEW_MATRIX
);
116 case GL_TRANSPOSE_COLOR_MATRIX
:
117 return GL_COLOR_MATRIX
;
125 __indirect_glGetError(void)
127 __GLX_SINGLE_DECLARE_VARIABLES();
128 GLuint retval
= GL_NO_ERROR
;
129 xGLXGetErrorReply reply
;
132 /* Use internal error first */
134 gc
->error
= GL_NO_ERROR
;
138 __GLX_SINGLE_LOAD_VARIABLES();
139 __GLX_SINGLE_BEGIN(X_GLsop_GetError
, 0);
140 __GLX_SINGLE_READ_XREPLY();
141 retval
= reply
.error
;
149 * Get the selected attribute from the client state.
152 * On success \c GL_TRUE is returned. Otherwise, \c GL_FALSE is returned.
155 get_client_data(struct glx_context
* gc
, GLenum cap
, GLintptr
* data
)
157 GLboolean retval
= GL_TRUE
;
158 __GLXattribute
*state
= (__GLXattribute
*) (gc
->client_state_private
);
159 const GLint tex_unit
= __glXGetActiveTextureUnit(state
);
163 case GL_VERTEX_ARRAY
:
164 case GL_NORMAL_ARRAY
:
167 case GL_EDGE_FLAG_ARRAY
:
168 case GL_SECONDARY_COLOR_ARRAY
:
169 case GL_FOG_COORD_ARRAY
:
170 retval
= __glXGetArrayEnable(state
, cap
, 0, data
);
173 case GL_VERTEX_ARRAY_SIZE
:
174 retval
= __glXGetArraySize(state
, GL_VERTEX_ARRAY
, 0, data
);
176 case GL_COLOR_ARRAY_SIZE
:
177 retval
= __glXGetArraySize(state
, GL_COLOR_ARRAY
, 0, data
);
179 case GL_SECONDARY_COLOR_ARRAY_SIZE
:
180 retval
= __glXGetArraySize(state
, GL_SECONDARY_COLOR_ARRAY
, 0, data
);
183 case GL_VERTEX_ARRAY_TYPE
:
184 retval
= __glXGetArrayType(state
, GL_VERTEX_ARRAY
, 0, data
);
186 case GL_NORMAL_ARRAY_TYPE
:
187 retval
= __glXGetArrayType(state
, GL_NORMAL_ARRAY
, 0, data
);
189 case GL_INDEX_ARRAY_TYPE
:
190 retval
= __glXGetArrayType(state
, GL_INDEX_ARRAY
, 0, data
);
192 case GL_COLOR_ARRAY_TYPE
:
193 retval
= __glXGetArrayType(state
, GL_COLOR_ARRAY
, 0, data
);
195 case GL_SECONDARY_COLOR_ARRAY_TYPE
:
196 retval
= __glXGetArrayType(state
, GL_SECONDARY_COLOR_ARRAY
, 0, data
);
198 case GL_FOG_COORD_ARRAY_TYPE
:
199 retval
= __glXGetArrayType(state
, GL_FOG_COORD_ARRAY
, 0, data
);
202 case GL_VERTEX_ARRAY_STRIDE
:
203 retval
= __glXGetArrayStride(state
, GL_VERTEX_ARRAY
, 0, data
);
205 case GL_NORMAL_ARRAY_STRIDE
:
206 retval
= __glXGetArrayStride(state
, GL_NORMAL_ARRAY
, 0, data
);
208 case GL_INDEX_ARRAY_STRIDE
:
209 retval
= __glXGetArrayStride(state
, GL_INDEX_ARRAY
, 0, data
);
211 case GL_EDGE_FLAG_ARRAY_STRIDE
:
212 retval
= __glXGetArrayStride(state
, GL_EDGE_FLAG_ARRAY
, 0, data
);
214 case GL_COLOR_ARRAY_STRIDE
:
215 retval
= __glXGetArrayStride(state
, GL_COLOR_ARRAY
, 0, data
);
217 case GL_SECONDARY_COLOR_ARRAY_STRIDE
:
218 retval
= __glXGetArrayStride(state
, GL_SECONDARY_COLOR_ARRAY
, 0, data
);
220 case GL_FOG_COORD_ARRAY_STRIDE
:
221 retval
= __glXGetArrayStride(state
, GL_FOG_COORD_ARRAY
, 0, data
);
224 case GL_TEXTURE_COORD_ARRAY
:
226 __glXGetArrayEnable(state
, GL_TEXTURE_COORD_ARRAY
, tex_unit
, data
);
228 case GL_TEXTURE_COORD_ARRAY_SIZE
:
230 __glXGetArraySize(state
, GL_TEXTURE_COORD_ARRAY
, tex_unit
, data
);
232 case GL_TEXTURE_COORD_ARRAY_TYPE
:
234 __glXGetArrayType(state
, GL_TEXTURE_COORD_ARRAY
, tex_unit
, data
);
236 case GL_TEXTURE_COORD_ARRAY_STRIDE
:
238 __glXGetArrayStride(state
, GL_TEXTURE_COORD_ARRAY
, tex_unit
, data
);
241 case GL_MAX_ELEMENTS_VERTICES
:
242 case GL_MAX_ELEMENTS_INDICES
:
248 case GL_PACK_ROW_LENGTH
:
249 *data
= (GLintptr
) state
->storePack
.rowLength
;
251 case GL_PACK_IMAGE_HEIGHT
:
252 *data
= (GLintptr
) state
->storePack
.imageHeight
;
254 case GL_PACK_SKIP_ROWS
:
255 *data
= (GLintptr
) state
->storePack
.skipRows
;
257 case GL_PACK_SKIP_PIXELS
:
258 *data
= (GLintptr
) state
->storePack
.skipPixels
;
260 case GL_PACK_SKIP_IMAGES
:
261 *data
= (GLintptr
) state
->storePack
.skipImages
;
263 case GL_PACK_ALIGNMENT
:
264 *data
= (GLintptr
) state
->storePack
.alignment
;
266 case GL_PACK_SWAP_BYTES
:
267 *data
= (GLintptr
) state
->storePack
.swapEndian
;
269 case GL_PACK_LSB_FIRST
:
270 *data
= (GLintptr
) state
->storePack
.lsbFirst
;
272 case GL_UNPACK_ROW_LENGTH
:
273 *data
= (GLintptr
) state
->storeUnpack
.rowLength
;
275 case GL_UNPACK_IMAGE_HEIGHT
:
276 *data
= (GLintptr
) state
->storeUnpack
.imageHeight
;
278 case GL_UNPACK_SKIP_ROWS
:
279 *data
= (GLintptr
) state
->storeUnpack
.skipRows
;
281 case GL_UNPACK_SKIP_PIXELS
:
282 *data
= (GLintptr
) state
->storeUnpack
.skipPixels
;
284 case GL_UNPACK_SKIP_IMAGES
:
285 *data
= (GLintptr
) state
->storeUnpack
.skipImages
;
287 case GL_UNPACK_ALIGNMENT
:
288 *data
= (GLintptr
) state
->storeUnpack
.alignment
;
290 case GL_UNPACK_SWAP_BYTES
:
291 *data
= (GLintptr
) state
->storeUnpack
.swapEndian
;
293 case GL_UNPACK_LSB_FIRST
:
294 *data
= (GLintptr
) state
->storeUnpack
.lsbFirst
;
296 case GL_CLIENT_ATTRIB_STACK_DEPTH
:
297 *data
= (GLintptr
) (gc
->attributes
.stackPointer
- gc
->attributes
.stack
);
299 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH
:
300 *data
= (GLintptr
) __GL_CLIENT_ATTRIB_STACK_DEPTH
;
302 case GL_CLIENT_ACTIVE_TEXTURE
:
303 *data
= (GLintptr
) (tex_unit
+ GL_TEXTURE0
);
317 __indirect_glGetBooleanv(GLenum val
, GLboolean
* b
)
319 const GLenum origVal
= val
;
320 __GLX_SINGLE_DECLARE_VARIABLES();
321 xGLXSingleReply reply
;
323 val
= RemapTransposeEnum(val
);
325 __GLX_SINGLE_LOAD_VARIABLES();
326 __GLX_SINGLE_BEGIN(X_GLsop_GetBooleanv
, 4);
327 __GLX_SINGLE_PUT_LONG(0, val
);
328 __GLX_SINGLE_READ_XREPLY();
329 __GLX_SINGLE_GET_SIZE(compsize
);
333 ** Error occured; don't modify user's buffer.
340 ** We still needed to send the request to the server in order to
341 ** find out whether it was legal to make a query (it's illegal,
342 ** for example, to call a query between glBegin() and glEnd()).
345 if (get_client_data(gc
, val
, &data
)) {
346 *b
= (GLboolean
) data
;
350 ** Not a local value, so use what we got from the server.
353 __GLX_SINGLE_GET_CHAR(b
);
356 __GLX_SINGLE_GET_CHAR_ARRAY(b
, compsize
);
357 if (val
!= origVal
) {
358 /* matrix transpose */
368 __indirect_glGetDoublev(GLenum val
, GLdouble
* d
)
370 const GLenum origVal
= val
;
371 __GLX_SINGLE_DECLARE_VARIABLES();
372 xGLXSingleReply reply
;
374 val
= RemapTransposeEnum(val
);
376 __GLX_SINGLE_LOAD_VARIABLES();
377 __GLX_SINGLE_BEGIN(X_GLsop_GetDoublev
, 4);
378 __GLX_SINGLE_PUT_LONG(0, val
);
379 __GLX_SINGLE_READ_XREPLY();
380 __GLX_SINGLE_GET_SIZE(compsize
);
384 ** Error occured; don't modify user's buffer.
391 ** We still needed to send the request to the server in order to
392 ** find out whether it was legal to make a query (it's illegal,
393 ** for example, to call a query between glBegin() and glEnd()).
396 if (get_client_data(gc
, val
, &data
)) {
397 *d
= (GLdouble
) data
;
401 ** Not a local value, so use what we got from the server.
404 __GLX_SINGLE_GET_DOUBLE(d
);
407 __GLX_SINGLE_GET_DOUBLE_ARRAY(d
, compsize
);
408 if (val
!= origVal
) {
409 /* matrix transpose */
419 __indirect_glGetFloatv(GLenum val
, GLfloat
* f
)
421 const GLenum origVal
= val
;
422 __GLX_SINGLE_DECLARE_VARIABLES();
423 xGLXSingleReply reply
;
425 val
= RemapTransposeEnum(val
);
427 __GLX_SINGLE_LOAD_VARIABLES();
428 __GLX_SINGLE_BEGIN(X_GLsop_GetFloatv
, 4);
429 __GLX_SINGLE_PUT_LONG(0, val
);
430 __GLX_SINGLE_READ_XREPLY();
431 __GLX_SINGLE_GET_SIZE(compsize
);
435 ** Error occured; don't modify user's buffer.
442 ** We still needed to send the request to the server in order to
443 ** find out whether it was legal to make a query (it's illegal,
444 ** for example, to call a query between glBegin() and glEnd()).
447 if (get_client_data(gc
, val
, &data
)) {
452 ** Not a local value, so use what we got from the server.
455 __GLX_SINGLE_GET_FLOAT(f
);
458 __GLX_SINGLE_GET_FLOAT_ARRAY(f
, compsize
);
459 if (val
!= origVal
) {
460 /* matrix transpose */
470 __indirect_glGetIntegerv(GLenum val
, GLint
* i
)
472 const GLenum origVal
= val
;
473 __GLX_SINGLE_DECLARE_VARIABLES();
474 xGLXSingleReply reply
;
476 val
= RemapTransposeEnum(val
);
478 __GLX_SINGLE_LOAD_VARIABLES();
479 __GLX_SINGLE_BEGIN(X_GLsop_GetIntegerv
, 4);
480 __GLX_SINGLE_PUT_LONG(0, val
);
481 __GLX_SINGLE_READ_XREPLY();
482 __GLX_SINGLE_GET_SIZE(compsize
);
486 ** Error occured; don't modify user's buffer.
493 ** We still needed to send the request to the server in order to
494 ** find out whether it was legal to make a query (it's illegal,
495 ** for example, to call a query between glBegin() and glEnd()).
498 if (get_client_data(gc
, val
, &data
)) {
503 ** Not a local value, so use what we got from the server.
506 __GLX_SINGLE_GET_LONG(i
);
509 __GLX_SINGLE_GET_LONG_ARRAY(i
, compsize
);
510 if (val
!= origVal
) {
511 /* matrix transpose */
521 ** Send all pending commands to server.
524 __indirect_glFlush(void)
526 __GLX_SINGLE_DECLARE_VARIABLES();
531 __GLX_SINGLE_LOAD_VARIABLES();
532 __GLX_SINGLE_BEGIN(X_GLsop_Flush
, 0);
535 /* And finally flush the X protocol data */
540 __indirect_glFeedbackBuffer(GLsizei size
, GLenum type
, GLfloat
* buffer
)
542 __GLX_SINGLE_DECLARE_VARIABLES();
547 __GLX_SINGLE_LOAD_VARIABLES();
548 __GLX_SINGLE_BEGIN(X_GLsop_FeedbackBuffer
, 8);
549 __GLX_SINGLE_PUT_LONG(0, size
);
550 __GLX_SINGLE_PUT_LONG(4, type
);
553 gc
->feedbackBuf
= buffer
;
557 __indirect_glSelectBuffer(GLsizei numnames
, GLuint
* buffer
)
559 __GLX_SINGLE_DECLARE_VARIABLES();
564 __GLX_SINGLE_LOAD_VARIABLES();
565 __GLX_SINGLE_BEGIN(X_GLsop_SelectBuffer
, 4);
566 __GLX_SINGLE_PUT_LONG(0, numnames
);
569 gc
->selectBuf
= buffer
;
573 __indirect_glRenderMode(GLenum mode
)
575 __GLX_SINGLE_DECLARE_VARIABLES();
577 xGLXRenderModeReply reply
;
582 __GLX_SINGLE_LOAD_VARIABLES();
583 __GLX_SINGLE_BEGIN(X_GLsop_RenderMode
, 4);
584 __GLX_SINGLE_PUT_LONG(0, mode
);
585 __GLX_SINGLE_READ_XREPLY();
586 __GLX_SINGLE_GET_RETVAL(retval
, GLint
);
588 if (reply
.newMode
!= mode
) {
590 ** Switch to new mode did not take effect, therefore an error
591 ** occured. When an error happens the server won't send us any
596 /* Read the feedback or selection data */
597 if (gc
->renderMode
== GL_FEEDBACK
) {
598 __GLX_SINGLE_GET_SIZE(compsize
);
599 __GLX_SINGLE_GET_FLOAT_ARRAY(gc
->feedbackBuf
, compsize
);
601 else if (gc
->renderMode
== GL_SELECT
) {
602 __GLX_SINGLE_GET_SIZE(compsize
);
603 __GLX_SINGLE_GET_LONG_ARRAY(gc
->selectBuf
, compsize
);
605 gc
->renderMode
= mode
;
613 __indirect_glFinish(void)
615 __GLX_SINGLE_DECLARE_VARIABLES();
616 xGLXSingleReply reply
;
618 __GLX_SINGLE_LOAD_VARIABLES();
619 __GLX_SINGLE_BEGIN(X_GLsop_Finish
, 0);
620 __GLX_SINGLE_READ_XREPLY();
626 * Extract the major and minor version numbers from a version string.
629 version_from_string(const char *ver
, int *major_version
, int *minor_version
)
635 major
= strtol(ver
, (char **) &end
, 10);
636 minor
= strtol(end
+ 1, NULL
, 10);
637 *major_version
= major
;
638 *minor_version
= minor
;
643 __indirect_glGetString(GLenum name
)
645 struct glx_context
*gc
= __glXGetCurrentContext();
646 Display
*dpy
= gc
->currentDpy
;
653 ** Return the cached copy if the string has already been fetched
670 return gc
->extensions
;
673 __glXSetError(gc
, GL_INVALID_ENUM
);
678 ** Get requested string from server
681 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
682 s
= (GLubyte
*) __glXGetString(dpy
, gc
->majorOpcode
, gc
->currentContextTag
,
685 /* Throw data on the floor */
686 __glXSetError(gc
, GL_OUT_OF_MEMORY
);
690 ** Update local cache
705 version_from_string((char *) s
,
706 &gc
->server_major
, &gc
->server_minor
);
707 __glXGetGLVersion(&client_major
, &client_minor
);
709 if ((gc
->server_major
< client_major
)
710 || ((gc
->server_major
== client_major
)
711 && (gc
->server_minor
<= client_minor
))) {
715 /* Allow 7 bytes for the client-side GL version. This allows
716 * for upto version 999.999. I'm not holding my breath for
717 * that one! The extra 4 is for the ' ()\0' that will be
720 const size_t size
= 7 + strlen((char *) s
) + 4;
722 gc
->version
= malloc(size
);
723 if (gc
->version
== NULL
) {
724 /* If we couldn't allocate memory for the new string,
725 * make a best-effort and just copy the client-side version
726 * to the string and use that. It probably doesn't
727 * matter what is done here. If there not memory available
728 * for a short string, the system is probably going to die
731 snprintf((char *) s
, strlen((char *) s
) + 1, "%u.%u",
732 client_major
, client_minor
);
736 snprintf((char *) gc
->version
, size
, "%u.%u (%s)",
737 client_major
, client_minor
, s
);
749 /* This code is currently disabled. I was reminded that some
750 * vendors intentionally exclude some extensions from their
751 * extension string that are part of the core version they
752 * advertise. In particular, on Nvidia drivers this means that
753 * the functionality is supported by the driver, but is not
754 * hardware accelerated. For example, a TNT will show core
755 * version 1.5, but most of the post-1.2 functionality is a
758 * I don't want to break applications that rely on this odd
759 * behavior. At the same time, the code is written and tested,
760 * so I didn't want to throw it away. Therefore, the code is here
761 * but disabled. In the future, we may wish to and an environment
762 * variable to enable it.
766 /* Call glGetString just to make sure that gc->server_major and
767 * gc->server_minor are set. This version may be higher than we
768 * can completely support, but it may imply support for some
769 * extensions that we can support.
771 * For example, at the time of this writing, the client-side
772 * library only supports upto core GL version 1.2. However, cubic
773 * textures, multitexture, multisampling, and some other 1.3
774 * features are supported. If the server reports back version
775 * 1.3, but does not report all of those extensions, we will
778 (void *) glGetString(GL_VERSION
);
779 major
= gc
->server_major
, minor
= gc
->server_minor
;
782 __glXCalculateUsableGLExtensions(gc
, (char *) s
, major
, minor
);
793 __indirect_glIsEnabled(GLenum cap
)
795 __GLX_SINGLE_DECLARE_VARIABLES();
796 __GLXattribute
*state
= (__GLXattribute
*) (gc
->client_state_private
);
797 xGLXSingleReply reply
;
798 GLboolean retval
= 0;
805 case GL_VERTEX_ARRAY
:
806 case GL_NORMAL_ARRAY
:
809 case GL_EDGE_FLAG_ARRAY
:
810 case GL_SECONDARY_COLOR_ARRAY
:
811 case GL_FOG_COORD_ARRAY
:
812 retval
= __glXGetArrayEnable(state
, cap
, 0, &enable
);
814 return (GLboolean
) enable
;
816 case GL_TEXTURE_COORD_ARRAY
:
817 retval
= __glXGetArrayEnable(state
, GL_TEXTURE_COORD_ARRAY
,
818 __glXGetActiveTextureUnit(state
), &enable
);
820 return (GLboolean
) enable
;
824 __GLX_SINGLE_LOAD_VARIABLES();
825 __GLX_SINGLE_BEGIN(X_GLsop_IsEnabled
, 4);
826 __GLX_SINGLE_PUT_LONG(0, cap
);
827 __GLX_SINGLE_READ_XREPLY();
828 __GLX_SINGLE_GET_RETVAL(retval
, GLboolean
);
834 __indirect_glGetPointerv(GLenum pname
, void **params
)
836 struct glx_context
*gc
= __glXGetCurrentContext();
837 __GLXattribute
*state
= (__GLXattribute
*) (gc
->client_state_private
);
838 Display
*dpy
= gc
->currentDpy
;
844 case GL_VERTEX_ARRAY_POINTER
:
845 case GL_NORMAL_ARRAY_POINTER
:
846 case GL_COLOR_ARRAY_POINTER
:
847 case GL_INDEX_ARRAY_POINTER
:
848 case GL_EDGE_FLAG_ARRAY_POINTER
:
849 __glXGetArrayPointer(state
, pname
- GL_VERTEX_ARRAY_POINTER
850 + GL_VERTEX_ARRAY
, 0, params
);
852 case GL_TEXTURE_COORD_ARRAY_POINTER
:
853 __glXGetArrayPointer(state
, GL_TEXTURE_COORD_ARRAY
,
854 __glXGetActiveTextureUnit(state
), params
);
856 case GL_SECONDARY_COLOR_ARRAY_POINTER
:
857 case GL_FOG_COORD_ARRAY_POINTER
:
858 __glXGetArrayPointer(state
, pname
- GL_FOG_COORD_ARRAY_POINTER
859 + GL_FOG_COORD_ARRAY
, 0, params
);
861 case GL_FEEDBACK_BUFFER_POINTER
:
862 *params
= (void *) gc
->feedbackBuf
;
864 case GL_SELECTION_BUFFER_POINTER
:
865 *params
= (void *) gc
->selectBuf
;
868 __glXSetError(gc
, GL_INVALID_ENUM
);
876 * This was previously auto-generated, but we need to special-case
877 * how we handle writing into the 'residences' buffer when n%4!=0.
879 #define X_GLsop_AreTexturesResident 143
881 __indirect_glAreTexturesResident(GLsizei n
, const GLuint
* textures
,
882 GLboolean
* residences
)
884 struct glx_context
*const gc
= __glXGetCurrentContext();
885 Display
*const dpy
= gc
->currentDpy
;
886 GLboolean retval
= (GLboolean
) 0;
887 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
888 xcb_connection_t
*c
= XGetXCBConnection(dpy
);
889 xcb_glx_are_textures_resident_reply_t
*reply
;
890 (void) __glXFlushRenderBuffer(gc
, gc
->pc
);
892 xcb_glx_are_textures_resident_reply(c
,
893 xcb_glx_are_textures_resident
894 (c
, gc
->currentContextTag
, n
,
896 (void) memcpy(residences
, xcb_glx_are_textures_resident_data(reply
),
897 xcb_glx_are_textures_resident_data_length(reply
) *
899 retval
= reply
->ret_val
;
907 * This was previously auto-generated, but we need to special-case
908 * how we handle writing into the 'residences' buffer when n%4!=0.
910 #define X_GLvop_AreTexturesResidentEXT 11
912 glAreTexturesResidentEXT(GLsizei n
, const GLuint
* textures
,
913 GLboolean
* residences
)
915 struct glx_context
*const gc
= __glXGetCurrentContext();
918 const _glapi_proc
*const table
= (_glapi_proc
*) GET_DISPATCH();
919 PFNGLARETEXTURESRESIDENTEXTPROC p
=
920 (PFNGLARETEXTURESRESIDENTEXTPROC
) table
[332];
922 return p(n
, textures
, residences
);
925 struct glx_context
*const gc
= __glXGetCurrentContext();
926 Display
*const dpy
= gc
->currentDpy
;
927 GLboolean retval
= (GLboolean
) 0;
928 const GLuint cmdlen
= 4 + __GLX_PAD((n
* 4));
929 if (__builtin_expect((n
>= 0) && (dpy
!= NULL
), 1)) {
931 __glXSetupVendorRequest(gc
, X_GLXVendorPrivateWithReply
,
932 X_GLvop_AreTexturesResidentEXT
,
934 (void) memcpy((void *) (pc
+ 0), (void *) (&n
), 4);
935 (void) memcpy((void *) (pc
+ 4), (void *) (textures
), (n
* 4));
937 /* see comments in __indirect_glAreTexturesResident() */
938 GLboolean
*res4
= malloc((n
+ 3) & ~3);
939 retval
= (GLboolean
) __glXReadReply(dpy
, 1, res4
, GL_TRUE
);
940 memcpy(residences
, res4
, n
);
944 retval
= (GLboolean
) __glXReadReply(dpy
, 1, residences
, GL_TRUE
);