projects / mesa.git / blob
? search:


83a250522206779e24a73bfe6aa1a2e77e0ad9ec
[mesa.git] / src / glx / x11 / single2.c
1 /*
2 * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
3 * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
4 *
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:
11 *
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.
16 *
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
23 * SOFTWARE.
24 *
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.
29 */
30
31 #include <stdio.h>
32 #include <assert.h>
33 #include "glxclient.h"
34 #include "packsingle.h"
35 #include "glxextensions.h"
36 #include "indirect.h"
37 #include "indirect_vertex_array.h"
38 #include "dispatch.h"
39 #include "glapi.h"
40 #ifdef USE_XCB
41 #include <xcb/xcb.h>
42 #include <xcb/glx.h>
43 #include <X11/Xlib-xcb.h>
44 #endif /* USE_XCB */
45
46
47 /* Used for GL_ARB_transpose_matrix */
48 static void
49 TransposeMatrixf(GLfloat m[16])
50 {
51 int i, j;
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];
56 m[j * 4 + i] = tmp;
57 }
58 }
59 }
60
61 /* Used for GL_ARB_transpose_matrix */
62 static void
63 TransposeMatrixb(GLboolean m[16])
64 {
65 int i, j;
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];
70 m[j * 4 + i] = tmp;
71 }
72 }
73 }
74
75 /* Used for GL_ARB_transpose_matrix */
76 static void
77 TransposeMatrixd(GLdouble m[16])
78 {
79 int i, j;
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];
84 m[j * 4 + i] = tmp;
85 }
86 }
87 }
88
89 /* Used for GL_ARB_transpose_matrix */
90 static void
91 TransposeMatrixi(GLint m[16])
92 {
93 int i, j;
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];
98 m[j * 4 + i] = tmp;
99 }
100 }
101 }
102
103
104 /**
105 * Remap a transpose-matrix enum to a non-transpose-matrix enum. Enums
106 * that are not transpose-matrix enums are unaffected.
107 */
108 static GLenum
109 RemapTransposeEnum(GLenum e)
110 {
111 switch (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;
118 default:
119 return e;
120 };
121 }
122
123
124 GLenum
125 __indirect_glGetError(void)
126 {
127 __GLX_SINGLE_DECLARE_VARIABLES();
128 GLuint retval = GL_NO_ERROR;
129 xGLXGetErrorReply reply;
130
131 if (gc->error) {
132 /* Use internal error first */
133 retval = gc->error;
134 gc->error = GL_NO_ERROR;
135 return retval;
136 }
137
138 __GLX_SINGLE_LOAD_VARIABLES();
139 __GLX_SINGLE_BEGIN(X_GLsop_GetError, 0);
140 __GLX_SINGLE_READ_XREPLY();
141 retval = reply.error;
142 __GLX_SINGLE_END();
143
144 return retval;
145 }
146
147
148 /**
149 * Get the selected attribute from the client state.
150 *
151 * \returns
152 * On success \c GL_TRUE is returned. Otherwise, \c GL_FALSE is returned.
153 */
154 static GLboolean
155 get_client_data(__GLXcontext * gc, GLenum cap, GLintptr * data)
156 {
157 GLboolean retval = GL_TRUE;
158 __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
159 const GLint tex_unit = __glXGetActiveTextureUnit(state);
160
161
162 switch (cap) {
163 case GL_VERTEX_ARRAY:
164 case GL_NORMAL_ARRAY:
165 case GL_COLOR_ARRAY:
166 case GL_INDEX_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);
171 break;
172
173 case GL_VERTEX_ARRAY_SIZE:
174 retval = __glXGetArraySize(state, GL_VERTEX_ARRAY, 0, data);
175 break;
176 case GL_COLOR_ARRAY_SIZE:
177 retval = __glXGetArraySize(state, GL_COLOR_ARRAY, 0, data);
178 break;
179 case GL_SECONDARY_COLOR_ARRAY_SIZE:
180 retval = __glXGetArraySize(state, GL_SECONDARY_COLOR_ARRAY, 0, data);
181 break;
182
183 case GL_VERTEX_ARRAY_TYPE:
184 retval = __glXGetArrayType(state, GL_VERTEX_ARRAY, 0, data);
185 break;
186 case GL_NORMAL_ARRAY_TYPE:
187 retval = __glXGetArrayType(state, GL_NORMAL_ARRAY, 0, data);
188 break;
189 case GL_INDEX_ARRAY_TYPE:
190 retval = __glXGetArrayType(state, GL_INDEX_ARRAY, 0, data);
191 break;
192 case GL_COLOR_ARRAY_TYPE:
193 retval = __glXGetArrayType(state, GL_COLOR_ARRAY, 0, data);
194 break;
195 case GL_SECONDARY_COLOR_ARRAY_TYPE:
196 retval = __glXGetArrayType(state, GL_SECONDARY_COLOR_ARRAY, 0, data);
197 break;
198 case GL_FOG_COORD_ARRAY_TYPE:
199 retval = __glXGetArrayType(state, GL_FOG_COORD_ARRAY, 0, data);
200 break;
201
202 case GL_VERTEX_ARRAY_STRIDE:
203 retval = __glXGetArrayStride(state, GL_VERTEX_ARRAY, 0, data);
204 break;
205 case GL_NORMAL_ARRAY_STRIDE:
206 retval = __glXGetArrayStride(state, GL_NORMAL_ARRAY, 0, data);
207 break;
208 case GL_INDEX_ARRAY_STRIDE:
209 retval = __glXGetArrayStride(state, GL_INDEX_ARRAY, 0, data);
210 break;
211 case GL_EDGE_FLAG_ARRAY_STRIDE:
212 retval = __glXGetArrayStride(state, GL_EDGE_FLAG_ARRAY, 0, data);
213 break;
214 case GL_COLOR_ARRAY_STRIDE:
215 retval = __glXGetArrayStride(state, GL_COLOR_ARRAY, 0, data);
216 break;
217 case GL_SECONDARY_COLOR_ARRAY_STRIDE:
218 retval = __glXGetArrayStride(state, GL_SECONDARY_COLOR_ARRAY, 0, data);
219 break;
220 case GL_FOG_COORD_ARRAY_STRIDE:
221 retval = __glXGetArrayStride(state, GL_FOG_COORD_ARRAY, 0, data);
222 break;
223
224 case GL_TEXTURE_COORD_ARRAY:
225 retval =
226 __glXGetArrayEnable(state, GL_TEXTURE_COORD_ARRAY, tex_unit, data);
227 break;
228 case GL_TEXTURE_COORD_ARRAY_SIZE:
229 retval =
230 __glXGetArraySize(state, GL_TEXTURE_COORD_ARRAY, tex_unit, data);
231 break;
232 case GL_TEXTURE_COORD_ARRAY_TYPE:
233 retval =
234 __glXGetArrayType(state, GL_TEXTURE_COORD_ARRAY, tex_unit, data);
235 break;
236 case GL_TEXTURE_COORD_ARRAY_STRIDE:
237 retval =
238 __glXGetArrayStride(state, GL_TEXTURE_COORD_ARRAY, tex_unit, data);
239 break;
240
241 case GL_MAX_ELEMENTS_VERTICES:
242 case GL_MAX_ELEMENTS_INDICES:
243 retval = GL_TRUE;
244 *data = ~0UL;
245 break;
246
247
248 case GL_PACK_ROW_LENGTH:
249 *data = (GLintptr) state->storePack.rowLength;
250 break;
251 case GL_PACK_IMAGE_HEIGHT:
252 *data = (GLintptr) state->storePack.imageHeight;
253 break;
254 case GL_PACK_SKIP_ROWS:
255 *data = (GLintptr) state->storePack.skipRows;
256 break;
257 case GL_PACK_SKIP_PIXELS:
258 *data = (GLintptr) state->storePack.skipPixels;
259 break;
260 case GL_PACK_SKIP_IMAGES:
261 *data = (GLintptr) state->storePack.skipImages;
262 break;
263 case GL_PACK_ALIGNMENT:
264 *data = (GLintptr) state->storePack.alignment;
265 break;
266 case GL_PACK_SWAP_BYTES:
267 *data = (GLintptr) state->storePack.swapEndian;
268 break;
269 case GL_PACK_LSB_FIRST:
270 *data = (GLintptr) state->storePack.lsbFirst;
271 break;
272 case GL_UNPACK_ROW_LENGTH:
273 *data = (GLintptr) state->storeUnpack.rowLength;
274 break;
275 case GL_UNPACK_IMAGE_HEIGHT:
276 *data = (GLintptr) state->storeUnpack.imageHeight;
277 break;
278 case GL_UNPACK_SKIP_ROWS:
279 *data = (GLintptr) state->storeUnpack.skipRows;
280 break;
281 case GL_UNPACK_SKIP_PIXELS:
282 *data = (GLintptr) state->storeUnpack.skipPixels;
283 break;
284 case GL_UNPACK_SKIP_IMAGES:
285 *data = (GLintptr) state->storeUnpack.skipImages;
286 break;
287 case GL_UNPACK_ALIGNMENT:
288 *data = (GLintptr) state->storeUnpack.alignment;
289 break;
290 case GL_UNPACK_SWAP_BYTES:
291 *data = (GLintptr) state->storeUnpack.swapEndian;
292 break;
293 case GL_UNPACK_LSB_FIRST:
294 *data = (GLintptr) state->storeUnpack.lsbFirst;
295 break;
296 case GL_CLIENT_ATTRIB_STACK_DEPTH:
297 *data = (GLintptr) (gc->attributes.stackPointer - gc->attributes.stack);
298 break;
299 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
300 *data = (GLintptr) __GL_CLIENT_ATTRIB_STACK_DEPTH;
301 break;
302 case GL_CLIENT_ACTIVE_TEXTURE:
303 *data = (GLintptr) (tex_unit + GL_TEXTURE0);
304 break;
305
306 default:
307 retval = GL_FALSE;
308 break;
309 }
310
311
312 return retval;
313 }
314
315
316 void
317 __indirect_glGetBooleanv(GLenum val, GLboolean * b)
318 {
319 const GLenum origVal = val;
320 __GLX_SINGLE_DECLARE_VARIABLES();
321 xGLXSingleReply reply;
322
323 val = RemapTransposeEnum(val);
324
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);
330
331 if (compsize == 0) {
332 /*
333 ** Error occured; don't modify user's buffer.
334 */
335 }
336 else {
337 GLintptr data;
338
339 /*
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()).
343 */
344
345 if (get_client_data(gc, val, &data)) {
346 *b = (GLboolean) data;
347 }
348 else {
349 /*
350 ** Not a local value, so use what we got from the server.
351 */
352 if (compsize == 1) {
353 __GLX_SINGLE_GET_CHAR(b);
354 }
355 else {
356 __GLX_SINGLE_GET_CHAR_ARRAY(b, compsize);
357 if (val != origVal) {
358 /* matrix transpose */
359 TransposeMatrixb(b);
360 }
361 }
362 }
363 }
364 __GLX_SINGLE_END();
365 }
366
367 void
368 __indirect_glGetDoublev(GLenum val, GLdouble * d)
369 {
370 const GLenum origVal = val;
371 __GLX_SINGLE_DECLARE_VARIABLES();
372 xGLXSingleReply reply;
373
374 val = RemapTransposeEnum(val);
375
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);
381
382 if (compsize == 0) {
383 /*
384 ** Error occured; don't modify user's buffer.
385 */
386 }
387 else {
388 GLintptr data;
389
390 /*
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()).
394 */
395
396 if (get_client_data(gc, val, &data)) {
397 *d = (GLdouble) data;
398 }
399 else {
400 /*
401 ** Not a local value, so use what we got from the server.
402 */
403 if (compsize == 1) {
404 __GLX_SINGLE_GET_DOUBLE(d);
405 }
406 else {
407 __GLX_SINGLE_GET_DOUBLE_ARRAY(d, compsize);
408 if (val != origVal) {
409 /* matrix transpose */
410 TransposeMatrixd(d);
411 }
412 }
413 }
414 }
415 __GLX_SINGLE_END();
416 }
417
418 void
419 __indirect_glGetFloatv(GLenum val, GLfloat * f)
420 {
421 const GLenum origVal = val;
422 __GLX_SINGLE_DECLARE_VARIABLES();
423 xGLXSingleReply reply;
424
425 val = RemapTransposeEnum(val);
426
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);
432
433 if (compsize == 0) {
434 /*
435 ** Error occured; don't modify user's buffer.
436 */
437 }
438 else {
439 GLintptr data;
440
441 /*
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()).
445 */
446
447 if (get_client_data(gc, val, &data)) {
448 *f = (GLfloat) data;
449 }
450 else {
451 /*
452 ** Not a local value, so use what we got from the server.
453 */
454 if (compsize == 1) {
455 __GLX_SINGLE_GET_FLOAT(f);
456 }
457 else {
458 __GLX_SINGLE_GET_FLOAT_ARRAY(f, compsize);
459 if (val != origVal) {
460 /* matrix transpose */
461 TransposeMatrixf(f);
462 }
463 }
464 }
465 }
466 __GLX_SINGLE_END();
467 }
468
469 void
470 __indirect_glGetIntegerv(GLenum val, GLint * i)
471 {
472 const GLenum origVal = val;
473 __GLX_SINGLE_DECLARE_VARIABLES();
474 xGLXSingleReply reply;
475
476 val = RemapTransposeEnum(val);
477
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);
483
484 if (compsize == 0) {
485 /*
486 ** Error occured; don't modify user's buffer.
487 */
488 }
489 else {
490 GLintptr data;
491
492 /*
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()).
496 */
497
498 if (get_client_data(gc, val, &data)) {
499 *i = (GLint) data;
500 }
501 else {
502 /*
503 ** Not a local value, so use what we got from the server.
504 */
505 if (compsize == 1) {
506 __GLX_SINGLE_GET_LONG(i);
507 }
508 else {
509 __GLX_SINGLE_GET_LONG_ARRAY(i, compsize);
510 if (val != origVal) {
511 /* matrix transpose */
512 TransposeMatrixi(i);
513 }
514 }
515 }
516 }
517 __GLX_SINGLE_END();
518 }
519
520 /*
521 ** Send all pending commands to server.
522 */
523 void
524 __indirect_glFlush(void)
525 {
526 __GLX_SINGLE_DECLARE_VARIABLES();
527
528 if (!dpy)
529 return;
530
531 __GLX_SINGLE_LOAD_VARIABLES();
532 __GLX_SINGLE_BEGIN(X_GLsop_Flush, 0);
533 __GLX_SINGLE_END();
534
535 /* And finally flush the X protocol data */
536 XFlush(dpy);
537 }
538
539 void
540 __indirect_glFeedbackBuffer(GLsizei size, GLenum type, GLfloat * buffer)
541 {
542 __GLX_SINGLE_DECLARE_VARIABLES();
543
544 if (!dpy)
545 return;
546
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);
551 __GLX_SINGLE_END();
552
553 gc->feedbackBuf = buffer;
554 }
555
556 void
557 __indirect_glSelectBuffer(GLsizei numnames, GLuint * buffer)
558 {
559 __GLX_SINGLE_DECLARE_VARIABLES();
560
561 if (!dpy)
562 return;
563
564 __GLX_SINGLE_LOAD_VARIABLES();
565 __GLX_SINGLE_BEGIN(X_GLsop_SelectBuffer, 4);
566 __GLX_SINGLE_PUT_LONG(0, numnames);
567 __GLX_SINGLE_END();
568
569 gc->selectBuf = buffer;
570 }
571
572 GLint
573 __indirect_glRenderMode(GLenum mode)
574 {
575 __GLX_SINGLE_DECLARE_VARIABLES();
576 GLint retval = 0;
577 xGLXRenderModeReply reply;
578
579 if (!dpy)
580 return -1;
581
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);
587
588 if (reply.newMode != mode) {
589 /*
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
592 ** other data.
593 */
594 }
595 else {
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);
600 }
601 else if (gc->renderMode == GL_SELECT) {
602 __GLX_SINGLE_GET_SIZE(compsize);
603 __GLX_SINGLE_GET_LONG_ARRAY(gc->selectBuf, compsize);
604 }
605 gc->renderMode = mode;
606 }
607 __GLX_SINGLE_END();
608
609 return retval;
610 }
611
612 void
613 __indirect_glFinish(void)
614 {
615 __GLX_SINGLE_DECLARE_VARIABLES();
616 xGLXSingleReply reply;
617
618 __GLX_SINGLE_LOAD_VARIABLES();
619 __GLX_SINGLE_BEGIN(X_GLsop_Finish, 0);
620 __GLX_SINGLE_READ_XREPLY();
621 __GLX_SINGLE_END();
622 }
623
624
625 /**
626 * Extract the major and minor version numbers from a version string.
627 */
628 static void
629 version_from_string(const char *ver, int *major_version, int *minor_version)
630 {
631 const char *end;
632 long major;
633 long minor;
634
635 major = strtol(ver, (char **) &end, 10);
636 minor = strtol(end + 1, NULL, 10);
637 *major_version = major;
638 *minor_version = minor;
639 }
640
641
642 const GLubyte *
643 __indirect_glGetString(GLenum name)
644 {
645 __GLXcontext *gc = __glXGetCurrentContext();
646 Display *dpy = gc->currentDpy;
647 GLubyte *s = NULL;
648
649 if (!dpy)
650 return 0;
651
652 /*
653 ** Return the cached copy if the string has already been fetched
654 */
655 switch (name) {
656 case GL_VENDOR:
657 if (gc->vendor)
658 return gc->vendor;
659 break;
660 case GL_RENDERER:
661 if (gc->renderer)
662 return gc->renderer;
663 break;
664 case GL_VERSION:
665 if (gc->version)
666 return gc->version;
667 break;
668 case GL_EXTENSIONS:
669 if (gc->extensions)
670 return gc->extensions;
671 break;
672 default:
673 __glXSetError(gc, GL_INVALID_ENUM);
674 return 0;
675 }
676
677 /*
678 ** Get requested string from server
679 */
680
681 (void) __glXFlushRenderBuffer(gc, gc->pc);
682 s = (GLubyte *) __glXGetStringFromServer(dpy, gc->majorOpcode,
683 X_GLsop_GetString,
684 gc->currentContextTag, name);
685 if (!s) {
686 /* Throw data on the floor */
687 __glXSetError(gc, GL_OUT_OF_MEMORY);
688 }
689 else {
690 /*
691 ** Update local cache
692 */
693 switch (name) {
694 case GL_VENDOR:
695 gc->vendor = s;
696 break;
697
698 case GL_RENDERER:
699 gc->renderer = s;
700 break;
701
702 case GL_VERSION:{
703 int client_major;
704 int client_minor;
705
706 version_from_string((char *) s,
707 &gc->server_major, &gc->server_minor);
708 __glXGetGLVersion(&client_major, &client_minor);
709
710 if ((gc->server_major < client_major)
711 || ((gc->server_major == client_major)
712 && (gc->server_minor <= client_minor))) {
713 gc->version = s;
714 }
715 else {
716 /* Allow 7 bytes for the client-side GL version. This allows
717 * for upto version 999.999. I'm not holding my breath for
718 * that one! The extra 4 is for the ' ()\0' that will be
719 * added.
720 */
721 const size_t size = 7 + strlen((char *) s) + 4;
722
723 gc->version = Xmalloc(size);
724 if (gc->version == NULL) {
725 /* If we couldn't allocate memory for the new string,
726 * make a best-effort and just copy the client-side version
727 * to the string and use that. It probably doesn't
728 * matter what is done here. If there not memory available
729 * for a short string, the system is probably going to die
730 * soon anyway.
731 */
732 snprintf((char *) s, strlen((char *) s) + 1, "%u.%u",
733 client_major, client_minor);
734 gc->version = s;
735 }
736 else {
737 snprintf((char *) gc->version, size, "%u.%u (%s)",
738 client_major, client_minor, s);
739 Xfree(s);
740 s = gc->version;
741 }
742 }
743 break;
744 }
745
746 case GL_EXTENSIONS:{
747 int major = 1;
748 int minor = 0;
749
750 /* This code is currently disabled. I was reminded that some
751 * vendors intentionally exclude some extensions from their
752 * extension string that are part of the core version they
753 * advertise. In particular, on Nvidia drivers this means that
754 * the functionality is supported by the driver, but is not
755 * hardware accelerated. For example, a TNT will show core
756 * version 1.5, but most of the post-1.2 functionality is a
757 * software fallback.
758 *
759 * I don't want to break applications that rely on this odd
760 * behavior. At the same time, the code is written and tested,
761 * so I didn't want to throw it away. Therefore, the code is here
762 * but disabled. In the future, we may wish to and an environment
763 * variable to enable it.
764 */
765
766 #if 0
767 /* Call glGetString just to make sure that gc->server_major and
768 * gc->server_minor are set. This version may be higher than we
769 * can completely support, but it may imply support for some
770 * extensions that we can support.
771 *
772 * For example, at the time of this writing, the client-side
773 * library only supports upto core GL version 1.2. However, cubic
774 * textures, multitexture, multisampling, and some other 1.3
775 * features are supported. If the server reports back version
776 * 1.3, but does not report all of those extensions, we will
777 * enable them.
778 */
779 (void *) glGetString(GL_VERSION);
780 major = gc->server_major, minor = gc->server_minor;
781 #endif
782
783 __glXCalculateUsableGLExtensions(gc, (char *) s, major, minor);
784 XFree(s);
785 s = gc->extensions;
786 break;
787 }
788 }
789 }
790 return s;
791 }
792
793 GLboolean
794 __indirect_glIsEnabled(GLenum cap)
795 {
796 __GLX_SINGLE_DECLARE_VARIABLES();
797 __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
798 xGLXSingleReply reply;
799 GLboolean retval = 0;
800 GLintptr enable;
801
802 if (!dpy)
803 return 0;
804
805 switch (cap) {
806 case GL_VERTEX_ARRAY:
807 case GL_NORMAL_ARRAY:
808 case GL_COLOR_ARRAY:
809 case GL_INDEX_ARRAY:
810 case GL_EDGE_FLAG_ARRAY:
811 case GL_SECONDARY_COLOR_ARRAY:
812 case GL_FOG_COORD_ARRAY:
813 retval = __glXGetArrayEnable(state, cap, 0, &enable);
814 assert(retval);
815 return (GLboolean) enable;
816 break;
817 case GL_TEXTURE_COORD_ARRAY:
818 retval = __glXGetArrayEnable(state, GL_TEXTURE_COORD_ARRAY,
819 __glXGetActiveTextureUnit(state), &enable);
820 assert(retval);
821 return (GLboolean) enable;
822 break;
823 }
824
825 __GLX_SINGLE_LOAD_VARIABLES();
826 __GLX_SINGLE_BEGIN(X_GLsop_IsEnabled, 4);
827 __GLX_SINGLE_PUT_LONG(0, cap);
828 __GLX_SINGLE_READ_XREPLY();
829 __GLX_SINGLE_GET_RETVAL(retval, GLboolean);
830 __GLX_SINGLE_END();
831 return retval;
832 }
833
834 void
835 __indirect_glGetPointerv(GLenum pname, void **params)
836 {
837 __GLXcontext *gc = __glXGetCurrentContext();
838 __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
839 Display *dpy = gc->currentDpy;
840
841 if (!dpy)
842 return;
843
844 switch (pname) {
845 case GL_VERTEX_ARRAY_POINTER:
846 case GL_NORMAL_ARRAY_POINTER:
847 case GL_COLOR_ARRAY_POINTER:
848 case GL_INDEX_ARRAY_POINTER:
849 case GL_EDGE_FLAG_ARRAY_POINTER:
850 __glXGetArrayPointer(state, pname - GL_VERTEX_ARRAY_POINTER
851 + GL_VERTEX_ARRAY, 0, params);
852 return;
853 case GL_TEXTURE_COORD_ARRAY_POINTER:
854 __glXGetArrayPointer(state, GL_TEXTURE_COORD_ARRAY,
855 __glXGetActiveTextureUnit(state), params);
856 return;
857 case GL_SECONDARY_COLOR_ARRAY_POINTER:
858 case GL_FOG_COORD_ARRAY_POINTER:
859 __glXGetArrayPointer(state, pname - GL_FOG_COORD_ARRAY_POINTER
860 + GL_FOG_COORD_ARRAY, 0, params);
861 return;
862 case GL_FEEDBACK_BUFFER_POINTER:
863 *params = (void *) gc->feedbackBuf;
864 return;
865 case GL_SELECTION_BUFFER_POINTER:
866 *params = (void *) gc->selectBuf;
867 return;
868 default:
869 __glXSetError(gc, GL_INVALID_ENUM);
870 return;
871 }
872 }
873
874
875
876 /**
877 * This was previously auto-generated, but we need to special-case
878 * how we handle writing into the 'residences' buffer when n%4!=0.
879 */
880 #define X_GLsop_AreTexturesResident 143
881 GLboolean
882 __indirect_glAreTexturesResident(GLsizei n, const GLuint * textures,
883 GLboolean * residences)
884 {
885 __GLXcontext *const gc = __glXGetCurrentContext();
886 Display *const dpy = gc->currentDpy;
887 GLboolean retval = (GLboolean) 0;
888 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
889 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
890 #ifdef USE_XCB
891 xcb_connection_t *c = XGetXCBConnection(dpy);
892 (void) __glXFlushRenderBuffer(gc, gc->pc);
893 xcb_glx_are_textures_resident_reply_t *reply =
894 xcb_glx_are_textures_resident_reply(c,
895 xcb_glx_are_textures_resident
896 (c, gc->currentContextTag, n,
897 textures), NULL);
898 (void) memcpy(residences, xcb_glx_are_textures_resident_data(reply),
899 xcb_glx_are_textures_resident_data_length(reply) *
900 sizeof(GLboolean));
901 retval = reply->ret_val;
902 free(reply);
903 #else
904 GLubyte const *pc =
905 __glXSetupSingleRequest(gc, X_GLsop_AreTexturesResident, cmdlen);
906 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
907 (void) memcpy((void *) (pc + 4), (void *) (textures), (n * 4));
908 if (n & 3) {
909 /* n is not a multiple of four.
910 * When reply_is_always_array is TRUE, __glXReadReply() will
911 * put a multiple of four bytes into the dest buffer. If the
912 * caller's buffer is not a multiple of four in size, we'll write
913 * out of bounds. So use a temporary buffer that's a few bytes
914 * larger.
915 */
916 GLboolean *res4 = malloc((n + 3) & ~3);
917 retval = (GLboolean) __glXReadReply(dpy, 1, res4, GL_TRUE);
918 memcpy(residences, res4, n);
919 free(res4);
920 }
921 else {
922 retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_TRUE);
923 }
924 UnlockDisplay(dpy);
925 SyncHandle();
926 #endif /* USE_XCB */
927 }
928 return retval;
929 }
930
931
932 /**
933 * This was previously auto-generated, but we need to special-case
934 * how we handle writing into the 'residences' buffer when n%4!=0.
935 */
936 #define X_GLvop_AreTexturesResidentEXT 11
937 GLboolean
938 glAreTexturesResidentEXT(GLsizei n, const GLuint * textures,
939 GLboolean * residences)
940 {
941 __GLXcontext *const gc = __glXGetCurrentContext();
942
943 if (gc->isDirect) {
944 return CALL_AreTexturesResident(GET_DISPATCH(),
945 (n, textures, residences));
946 } else {
947 __GLXcontext *const gc = __glXGetCurrentContext();
948 Display *const dpy = gc->currentDpy;
949 GLboolean retval = (GLboolean) 0;
950 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
951 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
952 GLubyte const *pc =
953 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
954 X_GLvop_AreTexturesResidentEXT,
955 cmdlen);
956 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
957 (void) memcpy((void *) (pc + 4), (void *) (textures), (n * 4));
958 if (n & 3) {
959 /* see comments in __indirect_glAreTexturesResident() */
960 GLboolean *res4 = malloc((n + 3) & ~3);
961 retval = (GLboolean) __glXReadReply(dpy, 1, res4, GL_TRUE);
962 memcpy(residences, res4, n);
963 free(res4);
964 }
965 else {
966 retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_TRUE);
967 }
968 UnlockDisplay(dpy);
969 SyncHandle();
970 }
971 return retval;
972 }
973 }