src/glx/x11/single2.c

   1 /* $XFree86: xc/lib/GL/glx/single2.c,v 1.10 2004/02/11 19:48:16 dawes Exp $ */
   2 /*
   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:
  10 **
  11 ** http://oss.sgi.com/projects/FreeB
  12 **
  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.
  18 **
  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.
  24 **
  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.
  34 **
  35 */
  36
  37 #include <stdio.h>
  38 #include <assert.h>
  39 #include "glxclient.h"
  40 #include "packsingle.h"
  41 #include "glxextensions.h"
  42 #include "indirect.h"
  43 #include "indirect_vertex_array.h"
  44
  45 /* Used for GL_ARB_transpose_matrix */
  46 static void TransposeMatrixf(GLfloat m[16])
  47 {
  48     int i, j;
  49     for (i = 0; i < 4; i++) {
  50         for (j = 0; j < i; j++) {
  51             GLfloat tmp = m[i*4+j];
  52             m[i*4+j] = m[j*4+i];
  53             m[j*4+i] = tmp;
  54         }
  55     }
  56 }
  57
  58 /* Used for GL_ARB_transpose_matrix */
  59 static void TransposeMatrixb(GLboolean m[16])
  60 {
  61     int i, j;
  62     for (i = 0; i < 4; i++) {
  63         for (j = 0; j < i; j++) {
  64             GLboolean tmp = m[i*4+j];
  65             m[i*4+j] = m[j*4+i];
  66             m[j*4+i] = tmp;
  67         }
  68     }
  69 }
  70
  71 /* Used for GL_ARB_transpose_matrix */
  72 static void TransposeMatrixd(GLdouble m[16])
  73 {
  74     int i, j;
  75     for (i = 0; i < 4; i++) {
  76         for (j = 0; j < i; j++) {
  77             GLdouble tmp = m[i*4+j];
  78             m[i*4+j] = m[j*4+i];
  79             m[j*4+i] = tmp;
  80         }
  81     }
  82 }
  83
  84 /* Used for GL_ARB_transpose_matrix */
  85 static void TransposeMatrixi(GLint m[16])
  86 {
  87     int i, j;
  88     for (i = 0; i < 4; i++) {
  89         for (j = 0; j < i; j++) {
  90             GLint tmp = m[i*4+j];
  91             m[i*4+j] = m[j*4+i];
  92             m[j*4+i] = tmp;
  93         }
  94     }
  95 }
  96
  97
  98 /**
  99  * Remap a transpose-matrix enum to a non-transpose-matrix enum.  Enums
 100  * that are not transpose-matrix enums are unaffected.
 101  */
 102 static GLenum
 103 RemapTransposeEnum( GLenum e )
 104 {
 105     switch( 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;
 112     default:
 113         return e;
 114     };
 115 }
 116
 117
 118 GLenum __indirect_glGetError(void)
 119 {
 120     __GLX_SINGLE_DECLARE_VARIABLES();
 121     GLuint retval = GL_NO_ERROR;
 122     xGLXGetErrorReply reply;
 123
 124     if (gc->error) {
 125         /* Use internal error first */
 126         retval = gc->error;
 127         gc->error = GL_NO_ERROR;
 128         return retval;
 129     }
 130
 131     __GLX_SINGLE_LOAD_VARIABLES();
 132     __GLX_SINGLE_BEGIN(X_GLsop_GetError,0);
 133     __GLX_SINGLE_READ_XREPLY();
 134     retval = reply.error;
 135     __GLX_SINGLE_END();
 136
 137     return retval;
 138 }
 139
 140
 141 /**
 142  * Get the selected attribute from the client state.
 143  *
 144  * \returns
 145  * On success \c GL_TRUE is returned.  Otherwise, \c GL_FALSE is returned.
 146  */
 147 static GLboolean
 148 get_client_data( __GLXattribute * state, GLenum cap, GLintptr * data )
 149 {
 150     GLboolean retval = GL_TRUE;
 151     const GLint tex_unit = __glXGetActiveTextureUnit( state );
 152
 153
 154     switch( cap ) {
 155     case GL_VERTEX_ARRAY:
 156     case GL_NORMAL_ARRAY:
 157     case GL_COLOR_ARRAY:
 158     case GL_INDEX_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 );
 163         break;
 164
 165     case GL_VERTEX_ARRAY_SIZE:
 166         retval = __glXGetArraySize( state, GL_VERTEX_ARRAY, 0, data );
 167         break;
 168     case GL_COLOR_ARRAY_SIZE:
 169         retval = __glXGetArraySize( state, GL_COLOR_ARRAY, 0, data );
 170         break;
 171     case GL_SECONDARY_COLOR_ARRAY_SIZE:
 172         retval = __glXGetArraySize( state, GL_SECONDARY_COLOR_ARRAY, 0, data );
 173         break;
 174
 175     case GL_VERTEX_ARRAY_TYPE:
 176         retval = __glXGetArrayType( state, GL_VERTEX_ARRAY, 0, data );
 177         break;
 178     case GL_NORMAL_ARRAY_TYPE:
 179         retval = __glXGetArrayType( state, GL_NORMAL_ARRAY, 0, data );
 180         break;
 181     case GL_INDEX_ARRAY_TYPE:
 182         retval = __glXGetArrayType( state, GL_INDEX_ARRAY, 0, data );
 183         break;
 184     case GL_COLOR_ARRAY_TYPE:
 185         retval = __glXGetArrayType( state, GL_COLOR_ARRAY, 0, data );
 186         break;
 187     case GL_SECONDARY_COLOR_ARRAY_TYPE:
 188         retval = __glXGetArrayType( state, GL_SECONDARY_COLOR_ARRAY, 0, data );
 189         break;
 190     case GL_FOG_COORD_ARRAY_TYPE:
 191         retval = __glXGetArrayType( state, GL_FOG_COORD_ARRAY, 0, data );
 192         break;
 193
 194     case GL_VERTEX_ARRAY_STRIDE:
 195         retval = __glXGetArrayStride( state, GL_VERTEX_ARRAY, 0, data );
 196         break;
 197     case GL_NORMAL_ARRAY_STRIDE:
 198         retval = __glXGetArrayStride( state, GL_NORMAL_ARRAY, 0, data );
 199         break;
 200     case GL_INDEX_ARRAY_STRIDE:
 201         retval = __glXGetArrayStride( state, GL_INDEX_ARRAY, 0, data );
 202         break;
 203     case GL_EDGE_FLAG_ARRAY_STRIDE:
 204         retval = __glXGetArrayStride( state, GL_EDGE_FLAG_ARRAY, 0, data );
 205         break;
 206     case GL_COLOR_ARRAY_STRIDE:
 207         retval = __glXGetArrayStride( state, GL_COLOR_ARRAY, 0, data );
 208         break;
 209     case GL_SECONDARY_COLOR_ARRAY_STRIDE:
 210         retval = __glXGetArrayStride( state, GL_SECONDARY_COLOR_ARRAY, 0, data );
 211         break;
 212     case GL_FOG_COORD_ARRAY_STRIDE:
 213         retval = __glXGetArrayStride( state, GL_FOG_COORD_ARRAY, 0, data );
 214         break;
 215
 216     case GL_TEXTURE_COORD_ARRAY:
 217         retval = __glXGetArrayEnable( state, GL_TEXTURE_COORD_ARRAY, tex_unit, data );
 218         break;
 219     case GL_TEXTURE_COORD_ARRAY_SIZE:
 220         retval = __glXGetArraySize( state, GL_TEXTURE_COORD_ARRAY, tex_unit, data );
 221         break;
 222     case GL_TEXTURE_COORD_ARRAY_TYPE:
 223         retval = __glXGetArrayType( state, GL_TEXTURE_COORD_ARRAY, tex_unit, data );
 224         break;
 225     case GL_TEXTURE_COORD_ARRAY_STRIDE:
 226         retval = __glXGetArrayStride( state, GL_TEXTURE_COORD_ARRAY, tex_unit, data );
 227         break;
 228
 229     case GL_MAX_ELEMENTS_VERTICES:
 230     case GL_MAX_ELEMENTS_INDICES:
 231         retval = GL_TRUE;
 232         *data = ~0UL;
 233         break;
 234
 235
 236     case GL_PACK_ROW_LENGTH:
 237         *data = (GLintptr)state->storePack.rowLength;
 238         break;
 239     case GL_PACK_IMAGE_HEIGHT:
 240         *data = (GLintptr)state->storePack.imageHeight;
 241         break;
 242     case GL_PACK_SKIP_ROWS:
 243         *data = (GLintptr)state->storePack.skipRows;
 244         break;
 245     case GL_PACK_SKIP_PIXELS:
 246         *data = (GLintptr)state->storePack.skipPixels;
 247         break;
 248     case GL_PACK_SKIP_IMAGES:
 249         *data = (GLintptr)state->storePack.skipImages;
 250         break;
 251     case GL_PACK_ALIGNMENT:
 252         *data = (GLintptr)state->storePack.alignment;
 253         break;
 254     case GL_PACK_SWAP_BYTES:
 255         *data = (GLintptr)state->storePack.swapEndian;
 256         break;
 257     case GL_PACK_LSB_FIRST:
 258         *data = (GLintptr)state->storePack.lsbFirst;
 259         break;
 260     case GL_UNPACK_ROW_LENGTH:
 261         *data = (GLintptr)state->storeUnpack.rowLength;
 262         break;
 263     case GL_UNPACK_IMAGE_HEIGHT:
 264         *data = (GLintptr)state->storeUnpack.imageHeight;
 265         break;
 266     case GL_UNPACK_SKIP_ROWS:
 267         *data = (GLintptr)state->storeUnpack.skipRows;
 268         break;
 269     case GL_UNPACK_SKIP_PIXELS:
 270         *data = (GLintptr)state->storeUnpack.skipPixels;
 271         break;
 272     case GL_UNPACK_SKIP_IMAGES:
 273         *data = (GLintptr)state->storeUnpack.skipImages;
 274         break;
 275     case GL_UNPACK_ALIGNMENT:
 276         *data = (GLintptr)state->storeUnpack.alignment;
 277         break;
 278     case GL_UNPACK_SWAP_BYTES:
 279         *data = (GLintptr)state->storeUnpack.swapEndian;
 280         break;
 281     case GL_UNPACK_LSB_FIRST:
 282         *data = (GLintptr)state->storeUnpack.lsbFirst;
 283         break;
 284     case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
 285         *data = (GLintptr)__GL_CLIENT_ATTRIB_STACK_DEPTH;
 286         break;
 287     case GL_CLIENT_ACTIVE_TEXTURE:
 288         *data = (GLintptr)(tex_unit + GL_TEXTURE0);
 289         break;
 290
 291     default:
 292         retval = GL_FALSE;
 293         break;
 294     }
 295
 296
 297     return retval;
 298 }
 299
 300
 301 void __indirect_glGetBooleanv(GLenum val, GLboolean *b)
 302 {
 303     const GLenum origVal = val;
 304     __GLX_SINGLE_DECLARE_VARIABLES();
 305     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 306     xGLXSingleReply reply;
 307
 308     val = RemapTransposeEnum( val );
 309
 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);
 315
 316     if (compsize == 0) {
 317         /*
 318         ** Error occured; don't modify user's buffer.
 319         */
 320     } else {
 321         GLintptr data;
 322
 323         /*
 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()).
 327         */
 328
 329         if ( get_client_data( state, val, & data ) ) {
 330             *b = (GLboolean) data;
 331         }
 332         else {
 333             /*
 334              ** Not a local value, so use what we got from the server.
 335              */
 336             if (compsize == 1) {
 337                 __GLX_SINGLE_GET_CHAR(b);
 338             } else {
 339                 __GLX_SINGLE_GET_CHAR_ARRAY(b,compsize);
 340                 if (val != origVal) {
 341                     /* matrix transpose */
 342                     TransposeMatrixb(b);
 343                 }
 344             }
 345         }
 346     }
 347     __GLX_SINGLE_END();
 348 }
 349
 350 void __indirect_glGetDoublev(GLenum val, GLdouble *d)
 351 {
 352     const GLenum origVal = val;
 353     __GLX_SINGLE_DECLARE_VARIABLES();
 354     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 355     xGLXSingleReply reply;
 356
 357     val = RemapTransposeEnum( val );
 358
 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);
 364
 365     if (compsize == 0) {
 366         /*
 367         ** Error occured; don't modify user's buffer.
 368         */
 369     } else {
 370         GLintptr data;
 371
 372         /*
 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()).
 376         */
 377
 378         if ( get_client_data( state, val, & data ) ) {
 379             *d = (GLdouble) data;
 380         }
 381         else {
 382             /*
 383              ** Not a local value, so use what we got from the server.
 384              */
 385             if (compsize == 1) {
 386                 __GLX_SINGLE_GET_DOUBLE(d);
 387             } else {
 388                 __GLX_SINGLE_GET_DOUBLE_ARRAY(d,compsize);
 389                 if (val != origVal) {
 390                     /* matrix transpose */
 391                     TransposeMatrixd(d);
 392                 }
 393             }
 394         }
 395     }
 396     __GLX_SINGLE_END();
 397 }
 398
 399 void __indirect_glGetFloatv(GLenum val, GLfloat *f)
 400 {
 401     const GLenum origVal = val;
 402     __GLX_SINGLE_DECLARE_VARIABLES();
 403     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 404     xGLXSingleReply reply;
 405
 406     val = RemapTransposeEnum( val );
 407
 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);
 413
 414     if (compsize == 0) {
 415         /*
 416         ** Error occured; don't modify user's buffer.
 417         */
 418     } else {
 419         GLintptr data;
 420
 421         /*
 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()).
 425         */
 426
 427         if ( get_client_data( state, val, & data ) ) {
 428             *f = (GLfloat) data;
 429         }
 430         else {
 431             /*
 432              ** Not a local value, so use what we got from the server.
 433              */
 434             if (compsize == 1) {
 435                 __GLX_SINGLE_GET_FLOAT(f);
 436             } else {
 437                 __GLX_SINGLE_GET_FLOAT_ARRAY(f,compsize);
 438                 if (val != origVal) {
 439                     /* matrix transpose */
 440                     TransposeMatrixf(f);
 441                 }
 442             }
 443         }
 444     }
 445     __GLX_SINGLE_END();
 446 }
 447
 448 void __indirect_glGetIntegerv(GLenum val, GLint *i)
 449 {
 450     const GLenum origVal = val;
 451     __GLX_SINGLE_DECLARE_VARIABLES();
 452     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 453     xGLXSingleReply reply;
 454
 455     val = RemapTransposeEnum( val );
 456
 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);
 462
 463     if (compsize == 0) {
 464         /*
 465         ** Error occured; don't modify user's buffer.
 466         */
 467     } else {
 468         GLintptr data;
 469
 470         /*
 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()).
 474         */
 475
 476         if ( get_client_data( state, val, & data ) ) {
 477             *i = (GLint) data;
 478         }
 479         else {
 480             /*
 481              ** Not a local value, so use what we got from the server.
 482              */
 483             if (compsize == 1) {
 484                 __GLX_SINGLE_GET_LONG(i);
 485             } else {
 486                 __GLX_SINGLE_GET_LONG_ARRAY(i,compsize);
 487                 if (val != origVal) {
 488                     /* matrix transpose */
 489                     TransposeMatrixi(i);
 490                 }
 491             }
 492         }
 493     }
 494     __GLX_SINGLE_END();
 495 }
 496
 497 /*
 498 ** Send all pending commands to server.
 499 */
 500 void __indirect_glFlush(void)
 501 {
 502     __GLX_SINGLE_DECLARE_VARIABLES();
 503
 504     if (!dpy) return;
 505
 506     __GLX_SINGLE_LOAD_VARIABLES();
 507     __GLX_SINGLE_BEGIN(X_GLsop_Flush,0);
 508     __GLX_SINGLE_END();
 509
 510     /* And finally flush the X protocol data */
 511     XFlush(dpy);
 512 }
 513
 514 void __indirect_glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 515 {
 516     __GLX_SINGLE_DECLARE_VARIABLES();
 517
 518     if (!dpy) return;
 519
 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);
 524     __GLX_SINGLE_END();
 525
 526     gc->feedbackBuf = buffer;
 527 }
 528
 529 void __indirect_glSelectBuffer(GLsizei numnames, GLuint *buffer)
 530 {
 531     __GLX_SINGLE_DECLARE_VARIABLES();
 532
 533     if (!dpy) return;
 534
 535     __GLX_SINGLE_LOAD_VARIABLES();
 536     __GLX_SINGLE_BEGIN(X_GLsop_SelectBuffer,4);
 537     __GLX_SINGLE_PUT_LONG(0,numnames);
 538     __GLX_SINGLE_END();
 539
 540     gc->selectBuf = buffer;
 541 }
 542
 543 GLint __indirect_glRenderMode(GLenum mode)
 544 {
 545     __GLX_SINGLE_DECLARE_VARIABLES();
 546     GLint retval = 0;
 547     xGLXRenderModeReply reply;
 548
 549     if (!dpy) return -1;
 550
 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);
 556
 557     if (reply.newMode != mode) {
 558         /*
 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
 561         ** other data.
 562         */
 563     } else {
 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);
 568         } else
 569         if (gc->renderMode == GL_SELECT) {
 570             __GLX_SINGLE_GET_SIZE(compsize);
 571             __GLX_SINGLE_GET_LONG_ARRAY(gc->selectBuf, compsize);
 572         }
 573         gc->renderMode = mode;
 574     }
 575     __GLX_SINGLE_END();
 576
 577     return retval;
 578 }
 579
 580 void __indirect_glFinish(void)
 581 {
 582     __GLX_SINGLE_DECLARE_VARIABLES();
 583     xGLXSingleReply reply;
 584
 585     __GLX_SINGLE_LOAD_VARIABLES();
 586     __GLX_SINGLE_BEGIN(X_GLsop_Finish,0);
 587     __GLX_SINGLE_READ_XREPLY();
 588     __GLX_SINGLE_END();
 589 }
 590
 591
 592 /**
 593  * Extract the major and minor version numbers from a version string.
 594  */
 595 static void
 596 version_from_string( const char * ver,
 597                      int * major_version, int * minor_version )
 598 {
 599     const char * end;
 600     long major;
 601     long minor;
 602
 603     major = strtol( ver, (char **) & end, 10 );
 604     minor = strtol( end + 1, NULL, 10 );
 605     *major_version = major;
 606     *minor_version = minor;
 607 }
 608
 609
 610 const GLubyte *__indirect_glGetString(GLenum name)
 611 {
 612     __GLXcontext *gc = __glXGetCurrentContext();
 613     Display *dpy = gc->currentDpy;
 614     GLubyte *s = NULL;
 615
 616     if (!dpy) return 0;
 617
 618     /*
 619     ** Return the cached copy if the string has already been fetched
 620     */
 621     switch(name) {
 622       case GL_VENDOR:
 623         if (gc->vendor) return gc->vendor;
 624         break;
 625       case GL_RENDERER:
 626         if (gc->renderer) return gc->renderer;
 627         break;
 628       case GL_VERSION:
 629         if (gc->version) return gc->version;
 630         break;
 631       case GL_EXTENSIONS:
 632         if (gc->extensions) return gc->extensions;
 633         break;
 634       default:
 635         __glXSetError(gc, GL_INVALID_ENUM);
 636         return 0;
 637     }
 638
 639     /*
 640     ** Get requested string from server
 641     */
 642
 643     (void) __glXFlushRenderBuffer( gc, gc->pc );
 644     s = (GLubyte *) __glXGetStringFromServer( dpy, gc->majorOpcode,
 645                                   X_GLsop_GetString, gc->currentContextTag,
 646                                   name );
 647     if (!s) {
 648         /* Throw data on the floor */
 649         __glXSetError(gc, GL_OUT_OF_MEMORY);
 650     } else {
 651         /*
 652         ** Update local cache
 653         */
 654         switch(name) {
 655         case GL_VENDOR:
 656             gc->vendor = s;
 657             break;
 658
 659         case GL_RENDERER:
 660             gc->renderer = s;
 661             break;
 662
 663         case GL_VERSION: {
 664             int client_major;
 665             int client_minor;
 666
 667             version_from_string( (char *) s,
 668                                  & gc->server_major, & gc->server_minor );
 669             __glXGetGLVersion( & client_major, & client_minor );
 670
 671             if ( (gc->server_major < client_major)
 672                  || ((gc->server_major == client_major)
 673                      && (gc->server_minor <= client_minor)) ) {
 674                 gc->version = s;
 675             }
 676             else {
 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
 680                  * added.
 681                  */
 682                 const size_t size = 7 + strlen( (char *) s ) + 4;
 683
 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
 691                      * soon anyway.
 692                      */
 693                     snprintf( (char *) s, strlen( (char *) s ) + 1, "%u.%u",
 694                               client_major, client_minor );
 695                     gc->version = s;
 696                 }
 697                 else {
 698                     snprintf( (char *)gc->version, size, "%u.%u (%s)",
 699                               client_major, client_minor, s );
 700                     Xfree( s );
 701                     s = gc->version;
 702                 }
 703             }
 704             break;
 705         }
 706
 707         case GL_EXTENSIONS: {
 708             int major = 1;
 709             int minor = 0;
 710
 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
 718              * software fallback.
 719              *
 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.
 725              */
 726
 727 #if 0
 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.
 732              *
 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
 738              * enable them.
 739              */
 740             (void *) glGetString( GL_VERSION );
 741             major = gc->server_major,
 742             minor = gc->server_minor;
 743 #endif
 744
 745             __glXCalculateUsableGLExtensions( gc, (char *) s, major, minor );
 746             XFree( s );
 747             s = gc->extensions;
 748             break;
 749         }
 750         }
 751     }
 752     return s;
 753 }
 754
 755 GLboolean __indirect_glIsEnabled(GLenum cap)
 756 {
 757     __GLX_SINGLE_DECLARE_VARIABLES();
 758     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 759     xGLXSingleReply reply;
 760     GLboolean retval = 0;
 761     GLintptr enable;
 762
 763     if (!dpy) return 0;
 764
 765     switch(cap) {
 766     case GL_VERTEX_ARRAY:
 767     case GL_NORMAL_ARRAY:
 768     case GL_COLOR_ARRAY:
 769     case GL_INDEX_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 );
 774         assert( retval );
 775         return (GLboolean) enable;
 776         break;
 777     case GL_TEXTURE_COORD_ARRAY:
 778         retval = __glXGetArrayEnable( state, GL_TEXTURE_COORD_ARRAY,
 779                                       __glXGetActiveTextureUnit( state ), & enable );
 780         assert( retval );
 781         return (GLboolean) enable;
 782         break;
 783     }
 784
 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);
 790     __GLX_SINGLE_END();
 791     return retval;
 792 }
 793
 794 void __indirect_glGetPointerv(GLenum pname, void **params)
 795 {
 796     __GLXcontext *gc = __glXGetCurrentContext();
 797     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 798     Display *dpy = gc->currentDpy;
 799
 800     if (!dpy) return;
 801
 802     switch(pname) {
 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
 809                               + GL_VERTEX_ARRAY,
 810                               0, params );
 811         return;
 812     case GL_TEXTURE_COORD_ARRAY_POINTER:
 813         __glXGetArrayPointer( state, GL_TEXTURE_COORD_ARRAY,
 814                               __glXGetActiveTextureUnit( state ), params );
 815         return;
 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,
 820                               0, params );
 821         return;
 822     case GL_FEEDBACK_BUFFER_POINTER:
 823         *params = (void *)gc->feedbackBuf;
 824         return;
 825     case GL_SELECTION_BUFFER_POINTER:
 826         *params = (void *)gc->selectBuf;
 827         return;
 828     default:
 829         __glXSetError(gc, GL_INVALID_ENUM);
 830         return;
 831     }
 832 }
 833