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_vertex_array.h"
  43
  44 /* Used for GL_ARB_transpose_matrix */
  45 static void TransposeMatrixf(GLfloat m[16])
  46 {
  47     int i, j;
  48     for (i = 0; i < 4; i++) {
  49         for (j = 0; j < i; j++) {
  50             GLfloat tmp = m[i*4+j];
  51             m[i*4+j] = m[j*4+i];
  52             m[j*4+i] = tmp;
  53         }
  54     }
  55 }
  56
  57 /* Used for GL_ARB_transpose_matrix */
  58 static void TransposeMatrixb(GLboolean m[16])
  59 {
  60     int i, j;
  61     for (i = 0; i < 4; i++) {
  62         for (j = 0; j < i; j++) {
  63             GLboolean tmp = m[i*4+j];
  64             m[i*4+j] = m[j*4+i];
  65             m[j*4+i] = tmp;
  66         }
  67     }
  68 }
  69
  70 /* Used for GL_ARB_transpose_matrix */
  71 static void TransposeMatrixd(GLdouble m[16])
  72 {
  73     int i, j;
  74     for (i = 0; i < 4; i++) {
  75         for (j = 0; j < i; j++) {
  76             GLdouble tmp = m[i*4+j];
  77             m[i*4+j] = m[j*4+i];
  78             m[j*4+i] = tmp;
  79         }
  80     }
  81 }
  82
  83 /* Used for GL_ARB_transpose_matrix */
  84 static void TransposeMatrixi(GLint m[16])
  85 {
  86     int i, j;
  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];
  91             m[j*4+i] = tmp;
  92         }
  93     }
  94 }
  95
  96
  97 /**
  98  * Remap a transpose-matrix enum to a non-transpose-matrix enum.  Enums
  99  * that are not transpose-matrix enums are unaffected.
 100  */
 101 static GLenum
 102 RemapTransposeEnum( GLenum e )
 103 {
 104     switch( 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;
 111     default:
 112         return e;
 113     };
 114 }
 115
 116
 117 GLenum __indirect_glGetError(void)
 118 {
 119     __GLX_SINGLE_DECLARE_VARIABLES();
 120     GLuint retval = GL_NO_ERROR;
 121     xGLXGetErrorReply reply;
 122
 123     if (gc->error) {
 124         /* Use internal error first */
 125         retval = gc->error;
 126         gc->error = GL_NO_ERROR;
 127         return retval;
 128     }
 129
 130     __GLX_SINGLE_LOAD_VARIABLES();
 131     __GLX_SINGLE_BEGIN(X_GLsop_GetError,0);
 132     __GLX_SINGLE_READ_XREPLY();
 133     retval = reply.error;
 134     __GLX_SINGLE_END();
 135
 136     return retval;
 137 }
 138
 139
 140 /**
 141  * Get the selected attribute from the client state.
 142  *
 143  * \returns
 144  * On success \c GL_TRUE is returned.  Otherwise, \c GL_FALSE is returned.
 145  */
 146 static GLboolean
 147 get_client_data( __GLXattribute * state, GLenum cap, GLintptr * data )
 148 {
 149     GLboolean retval = GL_TRUE;
 150     const GLint tex_unit = __glXGetActiveTextureUnit( state );
 151
 152
 153     switch( cap ) {
 154     case GL_VERTEX_ARRAY:
 155     case GL_NORMAL_ARRAY:
 156     case GL_COLOR_ARRAY:
 157     case GL_INDEX_ARRAY:
 158     case GL_EDGE_FLAG_ARRAY:
 159     case GL_SECONDARY_COLOR_ARRAY:
 160     case GL_FOG_COORD_ARRAY:
 161         retval = __glXGetArrayEnable( state, cap, 0, data );
 162         break;
 163
 164     case GL_VERTEX_ARRAY_SIZE:
 165         retval = __glXGetArraySize( state, GL_VERTEX_ARRAY, 0, data );
 166         break;
 167     case GL_COLOR_ARRAY_SIZE:
 168         retval = __glXGetArraySize( state, GL_COLOR_ARRAY, 0, data );
 169         break;
 170     case GL_SECONDARY_COLOR_ARRAY_SIZE:
 171         retval = __glXGetArraySize( state, GL_SECONDARY_COLOR_ARRAY, 0, data );
 172         break;
 173
 174     case GL_VERTEX_ARRAY_TYPE:
 175         retval = __glXGetArrayType( state, GL_VERTEX_ARRAY, 0, data );
 176         break;
 177     case GL_NORMAL_ARRAY_TYPE:
 178         retval = __glXGetArrayType( state, GL_NORMAL_ARRAY, 0, data );
 179         break;
 180     case GL_INDEX_ARRAY_TYPE:
 181         retval = __glXGetArrayType( state, GL_INDEX_ARRAY, 0, data );
 182         break;
 183     case GL_COLOR_ARRAY_TYPE:
 184         retval = __glXGetArrayType( state, GL_COLOR_ARRAY, 0, data );
 185         break;
 186     case GL_SECONDARY_COLOR_ARRAY_TYPE:
 187         retval = __glXGetArrayType( state, GL_SECONDARY_COLOR_ARRAY, 0, data );
 188         break;
 189     case GL_FOG_COORD_ARRAY_TYPE:
 190         retval = __glXGetArrayType( state, GL_FOG_COORD_ARRAY, 0, data );
 191         break;
 192
 193     case GL_VERTEX_ARRAY_STRIDE:
 194         retval = __glXGetArrayStride( state, GL_VERTEX_ARRAY, 0, data );
 195         break;
 196     case GL_NORMAL_ARRAY_STRIDE:
 197         retval = __glXGetArrayStride( state, GL_NORMAL_ARRAY, 0, data );
 198         break;
 199     case GL_INDEX_ARRAY_STRIDE:
 200         retval = __glXGetArrayStride( state, GL_INDEX_ARRAY, 0, data );
 201         break;
 202     case GL_EDGE_FLAG_ARRAY_STRIDE:
 203         retval = __glXGetArrayStride( state, GL_EDGE_FLAG_ARRAY, 0, data );
 204         break;
 205     case GL_COLOR_ARRAY_STRIDE:
 206         retval = __glXGetArrayStride( state, GL_COLOR_ARRAY, 0, data );
 207         break;
 208     case GL_SECONDARY_COLOR_ARRAY_STRIDE:
 209         retval = __glXGetArrayStride( state, GL_SECONDARY_COLOR_ARRAY, 0, data );
 210         break;
 211     case GL_FOG_COORD_ARRAY_STRIDE:
 212         retval = __glXGetArrayStride( state, GL_FOG_COORD_ARRAY, 0, data );
 213         break;
 214
 215     case GL_TEXTURE_COORD_ARRAY:
 216         retval = __glXGetArrayEnable( state, GL_TEXTURE_COORD_ARRAY, tex_unit, data );
 217         break;
 218     case GL_TEXTURE_COORD_ARRAY_SIZE:
 219         retval = __glXGetArraySize( state, GL_TEXTURE_COORD_ARRAY, tex_unit, data );
 220         break;
 221     case GL_TEXTURE_COORD_ARRAY_TYPE:
 222         retval = __glXGetArrayType( state, GL_TEXTURE_COORD_ARRAY, tex_unit, data );
 223         break;
 224     case GL_TEXTURE_COORD_ARRAY_STRIDE:
 225         retval = __glXGetArrayStride( state, GL_TEXTURE_COORD_ARRAY, tex_unit, data );
 226         break;
 227
 228     case GL_MAX_ELEMENTS_VERTICES:
 229     case GL_MAX_ELEMENTS_INDICES:
 230         retval = GL_TRUE;
 231         *data = ~0UL;
 232         break;
 233
 234
 235     case GL_PACK_ROW_LENGTH:
 236         *data = (GLintptr)state->storePack.rowLength;
 237         break;
 238     case GL_PACK_IMAGE_HEIGHT:
 239         *data = (GLintptr)state->storePack.imageHeight;
 240         break;
 241     case GL_PACK_SKIP_ROWS:
 242         *data = (GLintptr)state->storePack.skipRows;
 243         break;
 244     case GL_PACK_SKIP_PIXELS:
 245         *data = (GLintptr)state->storePack.skipPixels;
 246         break;
 247     case GL_PACK_SKIP_IMAGES:
 248         *data = (GLintptr)state->storePack.skipImages;
 249         break;
 250     case GL_PACK_ALIGNMENT:
 251         *data = (GLintptr)state->storePack.alignment;
 252         break;
 253     case GL_PACK_SWAP_BYTES:
 254         *data = (GLintptr)state->storePack.swapEndian;
 255         break;
 256     case GL_PACK_LSB_FIRST:
 257         *data = (GLintptr)state->storePack.lsbFirst;
 258         break;
 259     case GL_UNPACK_ROW_LENGTH:
 260         *data = (GLintptr)state->storeUnpack.rowLength;
 261         break;
 262     case GL_UNPACK_IMAGE_HEIGHT:
 263         *data = (GLintptr)state->storeUnpack.imageHeight;
 264         break;
 265     case GL_UNPACK_SKIP_ROWS:
 266         *data = (GLintptr)state->storeUnpack.skipRows;
 267         break;
 268     case GL_UNPACK_SKIP_PIXELS:
 269         *data = (GLintptr)state->storeUnpack.skipPixels;
 270         break;
 271     case GL_UNPACK_SKIP_IMAGES:
 272         *data = (GLintptr)state->storeUnpack.skipImages;
 273         break;
 274     case GL_UNPACK_ALIGNMENT:
 275         *data = (GLintptr)state->storeUnpack.alignment;
 276         break;
 277     case GL_UNPACK_SWAP_BYTES:
 278         *data = (GLintptr)state->storeUnpack.swapEndian;
 279         break;
 280     case GL_UNPACK_LSB_FIRST:
 281         *data = (GLintptr)state->storeUnpack.lsbFirst;
 282         break;
 283     case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
 284         *data = (GLintptr)__GL_CLIENT_ATTRIB_STACK_DEPTH;
 285         break;
 286     case GL_CLIENT_ACTIVE_TEXTURE:
 287         *data = (GLintptr)(tex_unit + GL_TEXTURE0);
 288         break;
 289
 290     default:
 291         retval = GL_FALSE;
 292         break;
 293     }
 294
 295
 296     return retval;
 297 }
 298
 299
 300 void __indirect_glGetBooleanv(GLenum val, GLboolean *b)
 301 {
 302     const GLenum origVal = val;
 303     __GLX_SINGLE_DECLARE_VARIABLES();
 304     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 305     xGLXSingleReply reply;
 306
 307     val = RemapTransposeEnum( val );
 308
 309     __GLX_SINGLE_LOAD_VARIABLES();
 310     __GLX_SINGLE_BEGIN(X_GLsop_GetBooleanv,4);
 311     __GLX_SINGLE_PUT_LONG(0,val);
 312     __GLX_SINGLE_READ_XREPLY();
 313     __GLX_SINGLE_GET_SIZE(compsize);
 314
 315     if (compsize == 0) {
 316         /*
 317         ** Error occured; don't modify user's buffer.
 318         */
 319     } else {
 320         GLintptr data;
 321
 322         /*
 323         ** We still needed to send the request to the server in order to
 324         ** find out whether it was legal to make a query (it's illegal,
 325         ** for example, to call a query between glBegin() and glEnd()).
 326         */
 327
 328         if ( get_client_data( state, val, & data ) ) {
 329             *b = (GLboolean) data;
 330         }
 331         else {
 332             /*
 333              ** Not a local value, so use what we got from the server.
 334              */
 335             if (compsize == 1) {
 336                 __GLX_SINGLE_GET_CHAR(b);
 337             } else {
 338                 __GLX_SINGLE_GET_CHAR_ARRAY(b,compsize);
 339                 if (val != origVal) {
 340                     /* matrix transpose */
 341                     TransposeMatrixb(b);
 342                 }
 343             }
 344         }
 345     }
 346     __GLX_SINGLE_END();
 347 }
 348
 349 void __indirect_glGetDoublev(GLenum val, GLdouble *d)
 350 {
 351     const GLenum origVal = val;
 352     __GLX_SINGLE_DECLARE_VARIABLES();
 353     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 354     xGLXSingleReply reply;
 355
 356     val = RemapTransposeEnum( val );
 357
 358     __GLX_SINGLE_LOAD_VARIABLES();
 359     __GLX_SINGLE_BEGIN(X_GLsop_GetDoublev,4);
 360     __GLX_SINGLE_PUT_LONG(0,val);
 361     __GLX_SINGLE_READ_XREPLY();
 362     __GLX_SINGLE_GET_SIZE(compsize);
 363
 364     if (compsize == 0) {
 365         /*
 366         ** Error occured; don't modify user's buffer.
 367         */
 368     } else {
 369         GLintptr data;
 370
 371         /*
 372         ** We still needed to send the request to the server in order to
 373         ** find out whether it was legal to make a query (it's illegal,
 374         ** for example, to call a query between glBegin() and glEnd()).
 375         */
 376
 377         if ( get_client_data( state, val, & data ) ) {
 378             *d = (GLdouble) data;
 379         }
 380         else {
 381             /*
 382              ** Not a local value, so use what we got from the server.
 383              */
 384             if (compsize == 1) {
 385                 __GLX_SINGLE_GET_DOUBLE(d);
 386             } else {
 387                 __GLX_SINGLE_GET_DOUBLE_ARRAY(d,compsize);
 388                 if (val != origVal) {
 389                     /* matrix transpose */
 390                     TransposeMatrixd(d);
 391                 }
 392             }
 393         }
 394     }
 395     __GLX_SINGLE_END();
 396 }
 397
 398 void __indirect_glGetFloatv(GLenum val, GLfloat *f)
 399 {
 400     const GLenum origVal = val;
 401     __GLX_SINGLE_DECLARE_VARIABLES();
 402     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 403     xGLXSingleReply reply;
 404
 405     val = RemapTransposeEnum( val );
 406
 407     __GLX_SINGLE_LOAD_VARIABLES();
 408     __GLX_SINGLE_BEGIN(X_GLsop_GetFloatv,4);
 409     __GLX_SINGLE_PUT_LONG(0,val);
 410     __GLX_SINGLE_READ_XREPLY();
 411     __GLX_SINGLE_GET_SIZE(compsize);
 412
 413     if (compsize == 0) {
 414         /*
 415         ** Error occured; don't modify user's buffer.
 416         */
 417     } else {
 418         GLintptr data;
 419
 420         /*
 421         ** We still needed to send the request to the server in order to
 422         ** find out whether it was legal to make a query (it's illegal,
 423         ** for example, to call a query between glBegin() and glEnd()).
 424         */
 425
 426         if ( get_client_data( state, val, & data ) ) {
 427             *f = (GLfloat) data;
 428         }
 429         else {
 430             /*
 431              ** Not a local value, so use what we got from the server.
 432              */
 433             if (compsize == 1) {
 434                 __GLX_SINGLE_GET_FLOAT(f);
 435             } else {
 436                 __GLX_SINGLE_GET_FLOAT_ARRAY(f,compsize);
 437                 if (val != origVal) {
 438                     /* matrix transpose */
 439                     TransposeMatrixf(f);
 440                 }
 441             }
 442         }
 443     }
 444     __GLX_SINGLE_END();
 445 }
 446
 447 void __indirect_glGetIntegerv(GLenum val, GLint *i)
 448 {
 449     const GLenum origVal = val;
 450     __GLX_SINGLE_DECLARE_VARIABLES();
 451     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 452     xGLXSingleReply reply;
 453
 454     val = RemapTransposeEnum( val );
 455
 456     __GLX_SINGLE_LOAD_VARIABLES();
 457     __GLX_SINGLE_BEGIN(X_GLsop_GetIntegerv,4);
 458     __GLX_SINGLE_PUT_LONG(0,val);
 459     __GLX_SINGLE_READ_XREPLY();
 460     __GLX_SINGLE_GET_SIZE(compsize);
 461
 462     if (compsize == 0) {
 463         /*
 464         ** Error occured; don't modify user's buffer.
 465         */
 466     } else {
 467         GLintptr data;
 468
 469         /*
 470         ** We still needed to send the request to the server in order to
 471         ** find out whether it was legal to make a query (it's illegal,
 472         ** for example, to call a query between glBegin() and glEnd()).
 473         */
 474
 475         if ( get_client_data( state, val, & data ) ) {
 476             *i = (GLint) data;
 477         }
 478         else {
 479             /*
 480              ** Not a local value, so use what we got from the server.
 481              */
 482             if (compsize == 1) {
 483                 __GLX_SINGLE_GET_LONG(i);
 484             } else {
 485                 __GLX_SINGLE_GET_LONG_ARRAY(i,compsize);
 486                 if (val != origVal) {
 487                     /* matrix transpose */
 488                     TransposeMatrixi(i);
 489                 }
 490             }
 491         }
 492     }
 493     __GLX_SINGLE_END();
 494 }
 495
 496 /*
 497 ** Send all pending commands to server.
 498 */
 499 void __indirect_glFlush(void)
 500 {
 501     __GLX_SINGLE_DECLARE_VARIABLES();
 502
 503     if (!dpy) return;
 504
 505     __GLX_SINGLE_LOAD_VARIABLES();
 506     __GLX_SINGLE_BEGIN(X_GLsop_Flush,0);
 507     __GLX_SINGLE_END();
 508
 509     /* And finally flush the X protocol data */
 510     XFlush(dpy);
 511 }
 512
 513 void __indirect_glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 514 {
 515     __GLX_SINGLE_DECLARE_VARIABLES();
 516
 517     if (!dpy) return;
 518
 519     __GLX_SINGLE_LOAD_VARIABLES();
 520     __GLX_SINGLE_BEGIN(X_GLsop_FeedbackBuffer,8);
 521     __GLX_SINGLE_PUT_LONG(0,size);
 522     __GLX_SINGLE_PUT_LONG(4,type);
 523     __GLX_SINGLE_END();
 524
 525     gc->feedbackBuf = buffer;
 526 }
 527
 528 void __indirect_glSelectBuffer(GLsizei numnames, GLuint *buffer)
 529 {
 530     __GLX_SINGLE_DECLARE_VARIABLES();
 531
 532     if (!dpy) return;
 533
 534     __GLX_SINGLE_LOAD_VARIABLES();
 535     __GLX_SINGLE_BEGIN(X_GLsop_SelectBuffer,4);
 536     __GLX_SINGLE_PUT_LONG(0,numnames);
 537     __GLX_SINGLE_END();
 538
 539     gc->selectBuf = buffer;
 540 }
 541
 542 GLint __indirect_glRenderMode(GLenum mode)
 543 {
 544     __GLX_SINGLE_DECLARE_VARIABLES();
 545     GLint retval = 0;
 546     xGLXRenderModeReply reply;
 547
 548     if (!dpy) return -1;
 549
 550     __GLX_SINGLE_LOAD_VARIABLES();
 551     __GLX_SINGLE_BEGIN(X_GLsop_RenderMode,4);
 552     __GLX_SINGLE_PUT_LONG(0,mode);
 553     __GLX_SINGLE_READ_XREPLY();
 554     __GLX_SINGLE_GET_RETVAL(retval,GLint);
 555
 556     if (reply.newMode != mode) {
 557         /*
 558         ** Switch to new mode did not take effect, therefore an error
 559         ** occured.  When an error happens the server won't send us any
 560         ** other data.
 561         */
 562     } else {
 563         /* Read the feedback or selection data */
 564         if (gc->renderMode == GL_FEEDBACK) {
 565             __GLX_SINGLE_GET_SIZE(compsize);
 566             __GLX_SINGLE_GET_FLOAT_ARRAY(gc->feedbackBuf, compsize);
 567         } else
 568         if (gc->renderMode == GL_SELECT) {
 569             __GLX_SINGLE_GET_SIZE(compsize);
 570             __GLX_SINGLE_GET_LONG_ARRAY(gc->selectBuf, compsize);
 571         }
 572         gc->renderMode = mode;
 573     }
 574     __GLX_SINGLE_END();
 575
 576     return retval;
 577 }
 578
 579 void __indirect_glFinish(void)
 580 {
 581     __GLX_SINGLE_DECLARE_VARIABLES();
 582     xGLXSingleReply reply;
 583
 584     __GLX_SINGLE_LOAD_VARIABLES();
 585     __GLX_SINGLE_BEGIN(X_GLsop_Finish,0);
 586     __GLX_SINGLE_READ_XREPLY();
 587     __GLX_SINGLE_END();
 588 }
 589
 590
 591 /**
 592  * Extract the major and minor version numbers from a version string.
 593  */
 594 static void
 595 version_from_string( const char * ver,
 596                      int * major_version, int * minor_version )
 597 {
 598     const char * end;
 599     long major;
 600     long minor;
 601
 602     major = strtol( ver, (char **) & end, 10 );
 603     minor = strtol( end + 1, NULL, 10 );
 604     *major_version = major;
 605     *minor_version = minor;
 606 }
 607
 608
 609 const GLubyte *__indirect_glGetString(GLenum name)
 610 {
 611     __GLXcontext *gc = __glXGetCurrentContext();
 612     Display *dpy = gc->currentDpy;
 613     GLubyte *s = NULL;
 614
 615     if (!dpy) return 0;
 616
 617     /*
 618     ** Return the cached copy if the string has already been fetched
 619     */
 620     switch(name) {
 621       case GL_VENDOR:
 622         if (gc->vendor) return gc->vendor;
 623         break;
 624       case GL_RENDERER:
 625         if (gc->renderer) return gc->renderer;
 626         break;
 627       case GL_VERSION:
 628         if (gc->version) return gc->version;
 629         break;
 630       case GL_EXTENSIONS:
 631         if (gc->extensions) return gc->extensions;
 632         break;
 633       default:
 634         __glXSetError(gc, GL_INVALID_ENUM);
 635         return 0;
 636     }
 637
 638     /*
 639     ** Get requested string from server
 640     */
 641
 642     (void) __glXFlushRenderBuffer( gc, gc->pc );
 643     s = (GLubyte *) __glXGetStringFromServer( dpy, gc->majorOpcode,
 644                                   X_GLsop_GetString, gc->currentContextTag,
 645                                   name );
 646     if (!s) {
 647         /* Throw data on the floor */
 648         __glXSetError(gc, GL_OUT_OF_MEMORY);
 649     } else {
 650         /*
 651         ** Update local cache
 652         */
 653         switch(name) {
 654         case GL_VENDOR:
 655             gc->vendor = s;
 656             break;
 657
 658         case GL_RENDERER:
 659             gc->renderer = s;
 660             break;
 661
 662         case GL_VERSION: {
 663             int client_major;
 664             int client_minor;
 665
 666             version_from_string( (char *) s,
 667                                  & gc->server_major, & gc->server_minor );
 668             __glXGetGLVersion( & client_major, & client_minor );
 669
 670             if ( (gc->server_major < client_major)
 671                  || ((gc->server_major == client_major)
 672                      && (gc->server_minor <= client_minor)) ) {
 673                 gc->version = s;
 674             }
 675             else {
 676                 /* Allow 7 bytes for the client-side GL version.  This allows
 677                  * for upto version 999.999.  I'm not holding my breath for
 678                  * that one!  The extra 4 is for the ' ()\0' that will be
 679                  * added.
 680                  */
 681                 const size_t size = 7 + strlen( (char *) s ) + 4;
 682
 683                 gc->version = Xmalloc( size );
 684                 if ( gc->version == NULL ) {
 685                     /* If we couldn't allocate memory for the new string,
 686                      * make a best-effort and just copy the client-side version
 687                      * to the string and use that.  It probably doesn't
 688                      * matter what is done here.  If there not memory available
 689                      * for a short string, the system is probably going to die
 690                      * soon anyway.
 691                      */
 692                     snprintf( (char *) s, strlen( (char *) s ) + 1, "%u.%u",
 693                               client_major, client_minor );
 694                     gc->version = s;
 695                 }
 696                 else {
 697                     snprintf( (char *)gc->version, size, "%u.%u (%s)",
 698                               client_major, client_minor, s );
 699                     Xfree( s );
 700                     s = gc->version;
 701                 }
 702             }
 703             break;
 704         }
 705
 706         case GL_EXTENSIONS: {
 707             int major = 1;
 708             int minor = 0;
 709
 710             /* This code is currently disabled.  I was reminded that some
 711              * vendors intentionally exclude some extensions from their
 712              * extension string that are part of the core version they
 713              * advertise.  In particular, on Nvidia drivers this means that
 714              * the functionality is supported by the driver, but is not
 715              * hardware accelerated.  For example, a TNT will show core
 716              * version 1.5, but most of the post-1.2 functionality is a
 717              * software fallback.
 718              *
 719              * I don't want to break applications that rely on this odd
 720              * behavior.  At the same time, the code is written and tested,
 721              * so I didn't want to throw it away.  Therefore, the code is here
 722              * but disabled.  In the future, we may wish to and an environment
 723              * variable to enable it.
 724              */
 725
 726 #if 0
 727             /* Call glGetString just to make sure that gc->server_major and
 728              * gc->server_minor are set.  This version may be higher than we
 729              * can completely support, but it may imply support for some
 730              * extensions that we can support.
 731              *
 732              * For example, at the time of this writing, the client-side
 733              * library only supports upto core GL version 1.2.  However, cubic
 734              * textures, multitexture, multisampling, and some other 1.3
 735              * features are supported.  If the server reports back version
 736              * 1.3, but does not report all of those extensions, we will
 737              * enable them.
 738              */
 739             (void *) glGetString( GL_VERSION );
 740             major = gc->server_major,
 741             minor = gc->server_minor;
 742 #endif
 743
 744             __glXCalculateUsableGLExtensions( gc, (char *) s, major, minor );
 745             XFree( s );
 746             s = gc->extensions;
 747             break;
 748         }
 749         }
 750     }
 751     return s;
 752 }
 753
 754 GLboolean __indirect_glIsEnabled(GLenum cap)
 755 {
 756     __GLX_SINGLE_DECLARE_VARIABLES();
 757     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 758     xGLXSingleReply reply;
 759     GLboolean retval = 0;
 760     GLintptr enable;
 761
 762     if (!dpy) return 0;
 763
 764     switch(cap) {
 765     case GL_VERTEX_ARRAY:
 766     case GL_NORMAL_ARRAY:
 767     case GL_COLOR_ARRAY:
 768     case GL_INDEX_ARRAY:
 769     case GL_EDGE_FLAG_ARRAY:
 770     case GL_SECONDARY_COLOR_ARRAY:
 771     case GL_FOG_COORD_ARRAY:
 772         retval = __glXGetArrayEnable( state, cap, 0, & enable );
 773         assert( retval );
 774         return (GLboolean) enable;
 775         break;
 776     case GL_TEXTURE_COORD_ARRAY:
 777         retval = __glXGetArrayEnable( state, GL_TEXTURE_COORD_ARRAY,
 778                                       __glXGetActiveTextureUnit( state ), & enable );
 779         assert( retval );
 780         return (GLboolean) enable;
 781         break;
 782     }
 783
 784     __GLX_SINGLE_LOAD_VARIABLES();
 785     __GLX_SINGLE_BEGIN(X_GLsop_IsEnabled,4);
 786     __GLX_SINGLE_PUT_LONG(0,cap);
 787     __GLX_SINGLE_READ_XREPLY();
 788     __GLX_SINGLE_GET_RETVAL(retval, GLboolean);
 789     __GLX_SINGLE_END();
 790     return retval;
 791 }
 792
 793 void __indirect_glGetPointerv(GLenum pname, void **params)
 794 {
 795     __GLXcontext *gc = __glXGetCurrentContext();
 796     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 797     Display *dpy = gc->currentDpy;
 798
 799     if (!dpy) return;
 800
 801     switch(pname) {
 802     case GL_VERTEX_ARRAY_POINTER:
 803     case GL_NORMAL_ARRAY_POINTER:
 804     case GL_COLOR_ARRAY_POINTER:
 805     case GL_INDEX_ARRAY_POINTER:
 806     case GL_EDGE_FLAG_ARRAY_POINTER:
 807         __glXGetArrayPointer( state, pname - GL_VERTEX_ARRAY_POINTER
 808                               + GL_VERTEX_ARRAY,
 809                               0, params );
 810         return;
 811     case GL_TEXTURE_COORD_ARRAY_POINTER:
 812         __glXGetArrayPointer( state, GL_TEXTURE_COORD_ARRAY,
 813                               __glXGetActiveTextureUnit( state ), params );
 814         return;
 815     case GL_SECONDARY_COLOR_ARRAY_POINTER:
 816     case GL_FOG_COORD_ARRAY_POINTER:
 817         __glXGetArrayPointer( state, pname - GL_FOG_COORD_ARRAY_POINTER
 818                               + GL_FOG_COORD_ARRAY,
 819                               0, params );
 820         return;
 821     case GL_FEEDBACK_BUFFER_POINTER:
 822         *params = (void *)gc->feedbackBuf;
 823         return;
 824     case GL_SELECTION_BUFFER_POINTER:
 825         *params = (void *)gc->selectBuf;
 826         return;
 827     default:
 828         __glXSetError(gc, GL_INVALID_ENUM);
 829         return;
 830     }
 831 }
 832