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 #define NEED_GL_FUNCS_WRAPPED
  38 #include <stdio.h>
  39 #include "glxclient.h"
  40 #include "packsingle.h"
  41 #include "glxextensions.h"
  42
  43 /* Used for GL_ARB_transpose_matrix */
  44 static void TransposeMatrixf(GLfloat m[16])
  45 {
  46     int i, j;
  47     for (i = 0; i < 4; i++) {
  48         for (j = 0; j < i; j++) {
  49             GLfloat tmp = m[i*4+j];
  50             m[i*4+j] = m[j*4+i];
  51             m[j*4+i] = tmp;
  52         }
  53     }
  54 }
  55
  56 /* Used for GL_ARB_transpose_matrix */
  57 static void TransposeMatrixb(GLboolean m[16])
  58 {
  59     int i, j;
  60     for (i = 0; i < 4; i++) {
  61         for (j = 0; j < i; j++) {
  62             GLboolean tmp = m[i*4+j];
  63             m[i*4+j] = m[j*4+i];
  64             m[j*4+i] = tmp;
  65         }
  66     }
  67 }
  68
  69 /* Used for GL_ARB_transpose_matrix */
  70 static void TransposeMatrixd(GLdouble m[16])
  71 {
  72     int i, j;
  73     for (i = 0; i < 4; i++) {
  74         for (j = 0; j < i; j++) {
  75             GLdouble tmp = m[i*4+j];
  76             m[i*4+j] = m[j*4+i];
  77             m[j*4+i] = tmp;
  78         }
  79     }
  80 }
  81
  82 /* Used for GL_ARB_transpose_matrix */
  83 static void TransposeMatrixi(GLint m[16])
  84 {
  85     int i, j;
  86     for (i = 0; i < 4; i++) {
  87         for (j = 0; j < i; j++) {
  88             GLint tmp = m[i*4+j];
  89             m[i*4+j] = m[j*4+i];
  90             m[j*4+i] = tmp;
  91         }
  92     }
  93 }
  94
  95 GLenum glGetError(void)
  96 {
  97     __GLX_SINGLE_DECLARE_VARIABLES();
  98     GLuint retval = GL_NO_ERROR;
  99     xGLXGetErrorReply reply;
 100
 101     if (gc->error) {
 102         /* Use internal error first */
 103         retval = gc->error;
 104         gc->error = GL_NO_ERROR;
 105         return retval;
 106     }
 107
 108     __GLX_SINGLE_LOAD_VARIABLES();
 109     __GLX_SINGLE_BEGIN(X_GLsop_GetError,0);
 110     __GLX_SINGLE_READ_XREPLY();
 111     retval = reply.error;
 112     __GLX_SINGLE_END();
 113
 114     return retval;
 115 }
 116
 117 void glGetClipPlane(GLenum plane, GLdouble *equation)
 118 {
 119     __GLX_SINGLE_DECLARE_VARIABLES();
 120     xGLXSingleReply reply;
 121     __GLX_SINGLE_LOAD_VARIABLES();
 122     __GLX_SINGLE_BEGIN(X_GLsop_GetClipPlane,4);
 123     __GLX_SINGLE_PUT_LONG(0,plane);
 124     __GLX_SINGLE_READ_XREPLY();
 125     if (reply.length == 8) {
 126         __GLX_SINGLE_GET_DOUBLE_ARRAY(equation,4);
 127     }
 128     __GLX_SINGLE_END();
 129 }
 130
 131 #define CASE_ARRAY_ENABLE(enum_name,array,dest,gl_type) \
 132     case GL_ ## enum_name ## _ARRAY: \
 133       *dest = (gl_type) (IS_ARRAY_ENABLED(state, array)); break
 134 #define CASE_ARRAY_SIZE(enum_name,array,dest,gl_type) \
 135     case GL_ ## enum_name ## _ARRAY_SIZE: \
 136       *dest = (gl_type) state->vertArray.arrays[array ## _ARRAY].size ; break
 137 #define CASE_ARRAY_TYPE(enum_name,array,dest,gl_type) \
 138     case GL_ ## enum_name ## _ARRAY_TYPE: \
 139       *dest = (gl_type) state->vertArray.arrays[array ## _ARRAY].type ; break
 140 #define CASE_ARRAY_STRIDE(enum_name,array,dest,gl_type) \
 141     case GL_ ## enum_name ## _ARRAY_STRIDE: \
 142       *dest = (gl_type) state->vertArray.arrays[array ## _ARRAY].stride ; break
 143
 144 #define CASE_ARRAY_ALL(enum_name,array,dest,gl_type) \
 145         CASE_ARRAY_ENABLE(enum_name,array,dest,gl_type); \
 146         CASE_ARRAY_STRIDE(enum_name,array,dest,gl_type); \
 147         CASE_ARRAY_TYPE(enum_name,array,dest,gl_type); \
 148         CASE_ARRAY_SIZE(enum_name,array,dest,gl_type)
 149
 150 void glGetBooleanv(GLenum val, GLboolean *b)
 151 {
 152     const GLenum origVal = val;
 153     __GLX_SINGLE_DECLARE_VARIABLES();
 154     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 155     xGLXSingleReply reply;
 156
 157     if (val == GL_TRANSPOSE_MODELVIEW_MATRIX_ARB) {
 158        val = GL_MODELVIEW_MATRIX;
 159     }
 160     else if (val == GL_TRANSPOSE_PROJECTION_MATRIX_ARB) {
 161        val = GL_PROJECTION_MATRIX;
 162     }
 163     else if (val == GL_TRANSPOSE_TEXTURE_MATRIX_ARB) {
 164        val = GL_TEXTURE_MATRIX;
 165     }
 166     else if (val == GL_TRANSPOSE_COLOR_MATRIX_ARB) {
 167        val = GL_COLOR_MATRIX;
 168     }
 169
 170     __GLX_SINGLE_LOAD_VARIABLES();
 171     __GLX_SINGLE_BEGIN(X_GLsop_GetBooleanv,4);
 172     __GLX_SINGLE_PUT_LONG(0,val);
 173     __GLX_SINGLE_READ_XREPLY();
 174     __GLX_SINGLE_GET_SIZE(compsize);
 175
 176     if (compsize == 0) {
 177         /*
 178         ** Error occured; don't modify user's buffer.
 179         */
 180     } else {
 181         /*
 182         ** For all the queries listed here, we use the locally stored
 183         ** values rather than the one returned by the server.  Note that
 184         ** we still needed to send the request to the server in order to
 185         ** find out whether it was legal to make a query (it's illegal,
 186         ** for example, to call a query between glBegin() and glEnd()).
 187         */
 188         switch (val) {
 189           case GL_PACK_ROW_LENGTH:
 190             *b = (GLboolean)state->storePack.rowLength;
 191             break;
 192           case GL_PACK_IMAGE_HEIGHT:
 193             *b = (GLboolean)state->storePack.imageHeight;
 194             break;
 195           case GL_PACK_SKIP_ROWS:
 196             *b = (GLboolean)state->storePack.skipRows;
 197             break;
 198           case GL_PACK_SKIP_PIXELS:
 199             *b = (GLboolean)state->storePack.skipPixels;
 200             break;
 201           case GL_PACK_SKIP_IMAGES:
 202             *b = (GLboolean)state->storePack.skipImages;
 203             break;
 204           case GL_PACK_ALIGNMENT:
 205             *b = (GLboolean)state->storePack.alignment;
 206             break;
 207           case GL_PACK_SWAP_BYTES:
 208             *b = (GLboolean)state->storePack.swapEndian;
 209             break;
 210           case GL_PACK_LSB_FIRST:
 211             *b = (GLboolean)state->storePack.lsbFirst;
 212             break;
 213           case GL_UNPACK_ROW_LENGTH:
 214             *b = (GLboolean)state->storeUnpack.rowLength;
 215             break;
 216           case GL_UNPACK_IMAGE_HEIGHT:
 217             *b = (GLboolean)state->storeUnpack.imageHeight;
 218             break;
 219           case GL_UNPACK_SKIP_ROWS:
 220             *b = (GLboolean)state->storeUnpack.skipRows;
 221             break;
 222           case GL_UNPACK_SKIP_PIXELS:
 223             *b = (GLboolean)state->storeUnpack.skipPixels;
 224             break;
 225           case GL_UNPACK_SKIP_IMAGES:
 226             *b = (GLboolean)state->storeUnpack.skipImages;
 227             break;
 228           case GL_UNPACK_ALIGNMENT:
 229             *b = (GLboolean)state->storeUnpack.alignment;
 230             break;
 231           case GL_UNPACK_SWAP_BYTES:
 232             *b = (GLboolean)state->storeUnpack.swapEndian;
 233             break;
 234           case GL_UNPACK_LSB_FIRST:
 235             *b = (GLboolean)state->storeUnpack.lsbFirst;
 236             break;
 237
 238           CASE_ARRAY_ALL(VERTEX, vertex, b, GLboolean);
 239
 240           CASE_ARRAY_ENABLE(NORMAL, normal, b, GLboolean);
 241           CASE_ARRAY_TYPE(NORMAL, normal, b, GLboolean);
 242           CASE_ARRAY_STRIDE(NORMAL, normal, b, GLboolean);
 243
 244           CASE_ARRAY_ALL(COLOR, color, b, GLboolean);
 245
 246           CASE_ARRAY_ENABLE(INDEX, index, b, GLboolean);
 247           CASE_ARRAY_TYPE(INDEX, index, b, GLboolean);
 248           CASE_ARRAY_STRIDE(INDEX, index, b, GLboolean);
 249
 250           case GL_TEXTURE_COORD_ARRAY:
 251             *b = (GLboolean)IS_TEXARRAY_ENABLED(state, state->vertArray.activeTexture);
 252             break;
 253           case GL_TEXTURE_COORD_ARRAY_SIZE:
 254             *b = (GLboolean)state->vertArray.texCoord[state->vertArray.activeTexture].size;
 255             break;
 256           case GL_TEXTURE_COORD_ARRAY_TYPE:
 257             *b = (GLboolean)state->vertArray.texCoord[state->vertArray.activeTexture].type;
 258             break;
 259           case GL_TEXTURE_COORD_ARRAY_STRIDE:
 260             *b = (GLboolean)state->vertArray.texCoord[state->vertArray.activeTexture].stride;
 261             break;
 262
 263           CASE_ARRAY_ENABLE(EDGE_FLAG, edgeFlag, b, GLboolean);
 264           CASE_ARRAY_STRIDE(EDGE_FLAG, edgeFlag, b, GLboolean);
 265
 266           CASE_ARRAY_ALL(SECONDARY_COLOR, secondaryColor, b, GLboolean);
 267
 268           CASE_ARRAY_ENABLE(FOG_COORD, fogCoord, b, GLboolean);
 269           CASE_ARRAY_TYPE(FOG_COORD, fogCoord, b, GLboolean);
 270           CASE_ARRAY_STRIDE(FOG_COORD, fogCoord, b, GLboolean);
 271
 272           case GL_MAX_ELEMENTS_VERTICES:
 273             *b = (GLboolean)state->vertArray.maxElementsVertices;
 274             break;
 275           case GL_MAX_ELEMENTS_INDICES:
 276             *b = (GLboolean)state->vertArray.maxElementsIndices;
 277             break;
 278           case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
 279             *b = (GLboolean)__GL_CLIENT_ATTRIB_STACK_DEPTH;
 280             break;
 281           case GL_CLIENT_ACTIVE_TEXTURE_ARB:
 282             *b = (GLboolean)(state->vertArray.activeTexture + GL_TEXTURE0_ARB);
 283             break;
 284           default:
 285             /*
 286             ** Not a local value, so use what we got from the server.
 287             */
 288             if (compsize == 1) {
 289                 __GLX_SINGLE_GET_CHAR(b);
 290             } else {
 291                 __GLX_SINGLE_GET_CHAR_ARRAY(b,compsize);
 292                 if (val != origVal) {
 293                    /* matrix transpose */
 294                    TransposeMatrixb(b);
 295                 }
 296             }
 297         }
 298     }
 299     __GLX_SINGLE_END();
 300 }
 301
 302 void glGetDoublev(GLenum val, GLdouble *d)
 303 {
 304     const GLenum origVal = val;
 305     __GLX_SINGLE_DECLARE_VARIABLES();
 306     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 307     xGLXSingleReply reply;
 308
 309     if (val == GL_TRANSPOSE_MODELVIEW_MATRIX_ARB) {
 310        val = GL_MODELVIEW_MATRIX;
 311     }
 312     else if (val == GL_TRANSPOSE_PROJECTION_MATRIX_ARB) {
 313        val = GL_PROJECTION_MATRIX;
 314     }
 315     else if (val == GL_TRANSPOSE_TEXTURE_MATRIX_ARB) {
 316        val = GL_TEXTURE_MATRIX;
 317     }
 318     else if (val == GL_TRANSPOSE_COLOR_MATRIX_ARB) {
 319        val = GL_COLOR_MATRIX;
 320     }
 321
 322     __GLX_SINGLE_LOAD_VARIABLES();
 323     __GLX_SINGLE_BEGIN(X_GLsop_GetDoublev,4);
 324     __GLX_SINGLE_PUT_LONG(0,val);
 325     __GLX_SINGLE_READ_XREPLY();
 326     __GLX_SINGLE_GET_SIZE(compsize);
 327
 328     if (compsize == 0) {
 329         /*
 330         ** Error occured; don't modify user's buffer.
 331         */
 332     } else {
 333         /*
 334         ** For all the queries listed here, we use the locally stored
 335         ** values rather than the one returned by the server.  Note that
 336         ** we still needed to send the request to the server in order to
 337         ** find out whether it was legal to make a query (it's illegal,
 338         ** for example, to call a query between glBegin() and glEnd()).
 339         */
 340         switch (val) {
 341           case GL_PACK_ROW_LENGTH:
 342             *d = (GLdouble)state->storePack.rowLength;
 343             break;
 344           case GL_PACK_IMAGE_HEIGHT:
 345             *d = (GLdouble)state->storePack.imageHeight;
 346             break;
 347           case GL_PACK_SKIP_ROWS:
 348             *d = (GLdouble)state->storePack.skipRows;
 349             break;
 350           case GL_PACK_SKIP_PIXELS:
 351             *d = (GLdouble)state->storePack.skipPixels;
 352             break;
 353           case GL_PACK_SKIP_IMAGES:
 354             *d = (GLdouble)state->storePack.skipImages;
 355             break;
 356           case GL_PACK_ALIGNMENT:
 357             *d = (GLdouble)state->storePack.alignment;
 358             break;
 359           case GL_PACK_SWAP_BYTES:
 360             *d = (GLdouble)state->storePack.swapEndian;
 361             break;
 362           case GL_PACK_LSB_FIRST:
 363             *d = (GLdouble)state->storePack.lsbFirst;
 364             break;
 365           case GL_UNPACK_ROW_LENGTH:
 366             *d = (GLdouble)state->storeUnpack.rowLength;
 367             break;
 368           case GL_UNPACK_IMAGE_HEIGHT:
 369             *d = (GLdouble)state->storeUnpack.imageHeight;
 370             break;
 371           case GL_UNPACK_SKIP_ROWS:
 372             *d = (GLdouble)state->storeUnpack.skipRows;
 373             break;
 374           case GL_UNPACK_SKIP_PIXELS:
 375             *d = (GLdouble)state->storeUnpack.skipPixels;
 376             break;
 377           case GL_UNPACK_SKIP_IMAGES:
 378             *d = (GLdouble)state->storeUnpack.skipImages;
 379             break;
 380           case GL_UNPACK_ALIGNMENT:
 381             *d = (GLdouble)state->storeUnpack.alignment;
 382             break;
 383           case GL_UNPACK_SWAP_BYTES:
 384             *d = (GLdouble)state->storeUnpack.swapEndian;
 385             break;
 386           case GL_UNPACK_LSB_FIRST:
 387             *d = (GLdouble)state->storeUnpack.lsbFirst;
 388             break;
 389
 390           CASE_ARRAY_ALL(VERTEX, vertex, d, GLdouble);
 391
 392           CASE_ARRAY_ENABLE(NORMAL, normal, d, GLdouble);
 393           CASE_ARRAY_TYPE(NORMAL, normal, d, GLdouble);
 394           CASE_ARRAY_STRIDE(NORMAL, normal, d, GLdouble);
 395
 396           CASE_ARRAY_ALL(COLOR, color, d, GLdouble);
 397
 398           CASE_ARRAY_ENABLE(INDEX, index, d, GLdouble);
 399           CASE_ARRAY_TYPE(INDEX, index, d, GLdouble);
 400           CASE_ARRAY_STRIDE(INDEX, index, d, GLdouble);
 401
 402           case GL_TEXTURE_COORD_ARRAY:
 403             *d = (GLdouble) IS_TEXARRAY_ENABLED(state, state->vertArray.activeTexture);
 404             break;
 405           case GL_TEXTURE_COORD_ARRAY_SIZE:
 406             *d = (GLdouble)state->vertArray.texCoord[state->vertArray.activeTexture].size;
 407             break;
 408           case GL_TEXTURE_COORD_ARRAY_TYPE:
 409             *d = (GLdouble)state->vertArray.texCoord[state->vertArray.activeTexture].type;
 410             break;
 411           case GL_TEXTURE_COORD_ARRAY_STRIDE:
 412             *d = (GLdouble)state->vertArray.texCoord[state->vertArray.activeTexture].stride;
 413             break;
 414
 415           CASE_ARRAY_ENABLE(EDGE_FLAG, edgeFlag, d, GLdouble);
 416           CASE_ARRAY_STRIDE(EDGE_FLAG, edgeFlag, d, GLdouble);
 417
 418           CASE_ARRAY_ALL(SECONDARY_COLOR, secondaryColor, d, GLdouble);
 419
 420           CASE_ARRAY_ENABLE(FOG_COORD, fogCoord, d, GLdouble);
 421           CASE_ARRAY_TYPE(FOG_COORD, fogCoord, d, GLdouble);
 422           CASE_ARRAY_STRIDE(FOG_COORD, fogCoord, d, GLdouble);
 423
 424           case GL_MAX_ELEMENTS_VERTICES:
 425             *d = (GLdouble)state->vertArray.maxElementsVertices;
 426             break;
 427           case GL_MAX_ELEMENTS_INDICES:
 428             *d = (GLdouble)state->vertArray.maxElementsIndices;
 429             break;
 430           case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
 431             *d = (GLdouble)__GL_CLIENT_ATTRIB_STACK_DEPTH;
 432             break;
 433           case GL_CLIENT_ACTIVE_TEXTURE_ARB:
 434             *d = (GLdouble)(state->vertArray.activeTexture + GL_TEXTURE0_ARB);
 435             break;
 436           default:
 437             /*
 438              ** Not a local value, so use what we got from the server.
 439              */
 440             if (compsize == 1) {
 441                 __GLX_SINGLE_GET_DOUBLE(d);
 442             } else {
 443                 __GLX_SINGLE_GET_DOUBLE_ARRAY(d,compsize);
 444                 if (val != origVal) {
 445                    /* matrix transpose */
 446                    TransposeMatrixd(d);
 447                 }
 448             }
 449         }
 450     }
 451     __GLX_SINGLE_END();
 452 }
 453
 454 void glGetFloatv(GLenum val, GLfloat *f)
 455 {
 456     const GLenum origVal = val;
 457     __GLX_SINGLE_DECLARE_VARIABLES();
 458     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 459     xGLXSingleReply reply;
 460
 461     if (val == GL_TRANSPOSE_MODELVIEW_MATRIX_ARB) {
 462        val = GL_MODELVIEW_MATRIX;
 463     }
 464     else if (val == GL_TRANSPOSE_PROJECTION_MATRIX_ARB) {
 465        val = GL_PROJECTION_MATRIX;
 466     }
 467     else if (val == GL_TRANSPOSE_TEXTURE_MATRIX_ARB) {
 468        val = GL_TEXTURE_MATRIX;
 469     }
 470     else if (val == GL_TRANSPOSE_COLOR_MATRIX_ARB) {
 471        val = GL_COLOR_MATRIX;
 472     }
 473
 474     __GLX_SINGLE_LOAD_VARIABLES();
 475     __GLX_SINGLE_BEGIN(X_GLsop_GetFloatv,4);
 476     __GLX_SINGLE_PUT_LONG(0,val);
 477     __GLX_SINGLE_READ_XREPLY();
 478     __GLX_SINGLE_GET_SIZE(compsize);
 479
 480     if (compsize == 0) {
 481         /*
 482         ** Error occured; don't modify user's buffer.
 483         */
 484     } else {
 485         /*
 486         ** For all the queries listed here, we use the locally stored
 487         ** values rather than the one returned by the server.  Note that
 488         ** we still needed to send the request to the server in order to
 489         ** find out whether it was legal to make a query (it's illegal,
 490         ** for example, to call a query between glBegin() and glEnd()).
 491         */
 492         switch (val) {
 493           case GL_PACK_ROW_LENGTH:
 494             *f = (GLfloat)state->storePack.rowLength;
 495             break;
 496           case GL_PACK_IMAGE_HEIGHT:
 497             *f = (GLfloat)state->storePack.imageHeight;
 498             break;
 499           case GL_PACK_SKIP_ROWS:
 500             *f = (GLfloat)state->storePack.skipRows;
 501             break;
 502           case GL_PACK_SKIP_PIXELS:
 503             *f = (GLfloat)state->storePack.skipPixels;
 504             break;
 505           case GL_PACK_SKIP_IMAGES:
 506             *f = (GLfloat)state->storePack.skipImages;
 507             break;
 508           case GL_PACK_ALIGNMENT:
 509             *f = (GLfloat)state->storePack.alignment;
 510             break;
 511           case GL_PACK_SWAP_BYTES:
 512             *f = (GLfloat)state->storePack.swapEndian;
 513             break;
 514           case GL_PACK_LSB_FIRST:
 515             *f = (GLfloat)state->storePack.lsbFirst;
 516             break;
 517           case GL_UNPACK_ROW_LENGTH:
 518             *f = (GLfloat)state->storeUnpack.rowLength;
 519             break;
 520           case GL_UNPACK_IMAGE_HEIGHT:
 521             *f = (GLfloat)state->storeUnpack.imageHeight;
 522             break;
 523           case GL_UNPACK_SKIP_ROWS:
 524             *f = (GLfloat)state->storeUnpack.skipRows;
 525             break;
 526           case GL_UNPACK_SKIP_PIXELS:
 527             *f = (GLfloat)state->storeUnpack.skipPixels;
 528             break;
 529           case GL_UNPACK_SKIP_IMAGES:
 530             *f = (GLfloat)state->storeUnpack.skipImages;
 531             break;
 532           case GL_UNPACK_ALIGNMENT:
 533             *f = (GLfloat)state->storeUnpack.alignment;
 534             break;
 535           case GL_UNPACK_SWAP_BYTES:
 536             *f = (GLfloat)state->storeUnpack.swapEndian;
 537             break;
 538           case GL_UNPACK_LSB_FIRST:
 539             *f = (GLfloat)state->storeUnpack.lsbFirst;
 540             break;
 541
 542           CASE_ARRAY_ALL(VERTEX, vertex, f, GLfloat);
 543
 544           CASE_ARRAY_ENABLE(NORMAL, normal, f, GLfloat);
 545           CASE_ARRAY_TYPE(NORMAL, normal, f, GLfloat);
 546           CASE_ARRAY_STRIDE(NORMAL, normal, f, GLfloat);
 547
 548           CASE_ARRAY_ALL(COLOR, color, f, GLfloat);
 549
 550           CASE_ARRAY_ENABLE(INDEX, index, f, GLfloat);
 551           CASE_ARRAY_TYPE(INDEX, index, f, GLfloat);
 552           CASE_ARRAY_STRIDE(INDEX, index, f, GLfloat);
 553
 554           case GL_TEXTURE_COORD_ARRAY:
 555             *f = (GLfloat) IS_TEXARRAY_ENABLED(state, state->vertArray.activeTexture);
 556             break;
 557           case GL_TEXTURE_COORD_ARRAY_SIZE:
 558             *f = (GLfloat)state->vertArray.texCoord[state->vertArray.activeTexture].size;
 559             break;
 560           case GL_TEXTURE_COORD_ARRAY_TYPE:
 561             *f = (GLfloat)state->vertArray.texCoord[state->vertArray.activeTexture].type;
 562             break;
 563           case GL_TEXTURE_COORD_ARRAY_STRIDE:
 564             *f = (GLfloat)state->vertArray.texCoord[state->vertArray.activeTexture].stride;
 565             break;
 566
 567           CASE_ARRAY_ENABLE(EDGE_FLAG, edgeFlag, f, GLfloat);
 568           CASE_ARRAY_STRIDE(EDGE_FLAG, edgeFlag, f, GLfloat);
 569
 570           CASE_ARRAY_ALL(SECONDARY_COLOR, secondaryColor, f, GLfloat);
 571
 572           CASE_ARRAY_ENABLE(FOG_COORD, fogCoord, f, GLfloat);
 573           CASE_ARRAY_TYPE(FOG_COORD, fogCoord, f, GLfloat);
 574           CASE_ARRAY_STRIDE(FOG_COORD, fogCoord, f, GLfloat);
 575
 576           case GL_MAX_ELEMENTS_VERTICES:
 577             *f = (GLfloat)state->vertArray.maxElementsVertices;
 578             break;
 579           case GL_MAX_ELEMENTS_INDICES:
 580             *f = (GLfloat)state->vertArray.maxElementsIndices;
 581             break;
 582           case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
 583             *f = (GLfloat)__GL_CLIENT_ATTRIB_STACK_DEPTH;
 584             break;
 585           case GL_CLIENT_ACTIVE_TEXTURE_ARB:
 586             *f = (GLfloat)(state->vertArray.activeTexture + GL_TEXTURE0_ARB);
 587             break;
 588           default:
 589             /*
 590             ** Not a local value, so use what we got from the server.
 591             */
 592             if (compsize == 1) {
 593                 __GLX_SINGLE_GET_FLOAT(f);
 594             } else {
 595                 __GLX_SINGLE_GET_FLOAT_ARRAY(f,compsize);
 596                 if (val != origVal) {
 597                    /* matrix transpose */
 598                    TransposeMatrixf(f);
 599                 }
 600             }
 601         }
 602     }
 603     __GLX_SINGLE_END();
 604 }
 605
 606 void glGetIntegerv(GLenum val, GLint *i)
 607 {
 608     const GLenum origVal = val;
 609     __GLX_SINGLE_DECLARE_VARIABLES();
 610     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 611     xGLXSingleReply reply;
 612
 613     if (val == GL_TRANSPOSE_MODELVIEW_MATRIX_ARB) {
 614        val = GL_MODELVIEW_MATRIX;
 615     }
 616     else if (val == GL_TRANSPOSE_PROJECTION_MATRIX_ARB) {
 617        val = GL_PROJECTION_MATRIX;
 618     }
 619     else if (val == GL_TRANSPOSE_TEXTURE_MATRIX_ARB) {
 620        val = GL_TEXTURE_MATRIX;
 621     }
 622     else if (val == GL_TRANSPOSE_COLOR_MATRIX_ARB) {
 623        val = GL_COLOR_MATRIX;
 624     }
 625
 626     __GLX_SINGLE_LOAD_VARIABLES();
 627     __GLX_SINGLE_BEGIN(X_GLsop_GetIntegerv,4);
 628     __GLX_SINGLE_PUT_LONG(0,val);
 629     __GLX_SINGLE_READ_XREPLY();
 630     __GLX_SINGLE_GET_SIZE(compsize);
 631
 632     if (compsize == 0) {
 633         /*
 634         ** Error occured; don't modify user's buffer.
 635         */
 636     } else {
 637         /*
 638         ** For all the queries listed here, we use the locally stored
 639         ** values rather than the one returned by the server.  Note that
 640         ** we still needed to send the request to the server in order to
 641         ** find out whether it was legal to make a query (it's illegal,
 642         ** for example, to call a query between glBegin() and glEnd()).
 643         */
 644         switch (val) {
 645           case GL_PACK_ROW_LENGTH:
 646             *i = (GLint)state->storePack.rowLength;
 647             break;
 648           case GL_PACK_IMAGE_HEIGHT:
 649             *i = (GLint)state->storePack.imageHeight;
 650             break;
 651           case GL_PACK_SKIP_ROWS:
 652             *i = (GLint)state->storePack.skipRows;
 653             break;
 654           case GL_PACK_SKIP_PIXELS:
 655             *i = (GLint)state->storePack.skipPixels;
 656             break;
 657           case GL_PACK_SKIP_IMAGES:
 658             *i = (GLint)state->storePack.skipImages;
 659             break;
 660           case GL_PACK_ALIGNMENT:
 661             *i = (GLint)state->storePack.alignment;
 662             break;
 663           case GL_PACK_SWAP_BYTES:
 664             *i = (GLint)state->storePack.swapEndian;
 665             break;
 666           case GL_PACK_LSB_FIRST:
 667             *i = (GLint)state->storePack.lsbFirst;
 668             break;
 669           case GL_UNPACK_ROW_LENGTH:
 670             *i = (GLint)state->storeUnpack.rowLength;
 671             break;
 672           case GL_UNPACK_IMAGE_HEIGHT:
 673             *i = (GLint)state->storeUnpack.imageHeight;
 674             break;
 675           case GL_UNPACK_SKIP_ROWS:
 676             *i = (GLint)state->storeUnpack.skipRows;
 677             break;
 678           case GL_UNPACK_SKIP_PIXELS:
 679             *i = (GLint)state->storeUnpack.skipPixels;
 680             break;
 681           case GL_UNPACK_SKIP_IMAGES:
 682             *i = (GLint)state->storeUnpack.skipImages;
 683             break;
 684           case GL_UNPACK_ALIGNMENT:
 685             *i = (GLint)state->storeUnpack.alignment;
 686             break;
 687           case GL_UNPACK_SWAP_BYTES:
 688             *i = (GLint)state->storeUnpack.swapEndian;
 689             break;
 690           case GL_UNPACK_LSB_FIRST:
 691             *i = (GLint)state->storeUnpack.lsbFirst;
 692             break;
 693
 694           CASE_ARRAY_ALL(VERTEX, vertex, i, GLint);
 695
 696           CASE_ARRAY_ENABLE(NORMAL, normal, i, GLint);
 697           CASE_ARRAY_TYPE(NORMAL, normal, i, GLint);
 698           CASE_ARRAY_STRIDE(NORMAL, normal, i, GLint);
 699
 700           CASE_ARRAY_ALL(COLOR, color, i, GLint);
 701
 702           CASE_ARRAY_ENABLE(INDEX, index, i, GLint);
 703           CASE_ARRAY_TYPE(INDEX, index, i, GLint);
 704           CASE_ARRAY_STRIDE(INDEX, index, i, GLint);
 705
 706           case GL_TEXTURE_COORD_ARRAY:
 707             *i = (GLint) IS_TEXARRAY_ENABLED(state, state->vertArray.activeTexture);
 708             break;
 709           case GL_TEXTURE_COORD_ARRAY_SIZE:
 710             *i = (GLint)state->vertArray.texCoord[state->vertArray.activeTexture].size;
 711             break;
 712           case GL_TEXTURE_COORD_ARRAY_TYPE:
 713             *i = (GLint)state->vertArray.texCoord[state->vertArray.activeTexture].type;
 714             break;
 715           case GL_TEXTURE_COORD_ARRAY_STRIDE:
 716             *i = (GLint)state->vertArray.texCoord[state->vertArray.activeTexture].stride;
 717             break;
 718
 719           CASE_ARRAY_ENABLE(EDGE_FLAG, edgeFlag, i, GLint);
 720           CASE_ARRAY_STRIDE(EDGE_FLAG, edgeFlag, i, GLint);
 721
 722           CASE_ARRAY_ALL(SECONDARY_COLOR, secondaryColor, i, GLint);
 723
 724           CASE_ARRAY_ENABLE(FOG_COORD, fogCoord, i, GLint);
 725           CASE_ARRAY_TYPE(FOG_COORD, fogCoord, i, GLint);
 726           CASE_ARRAY_STRIDE(FOG_COORD, fogCoord, i, GLint);
 727
 728           case GL_MAX_ELEMENTS_VERTICES:
 729             *i = (GLint)state->vertArray.maxElementsVertices;
 730             break;
 731           case GL_MAX_ELEMENTS_INDICES:
 732             *i = (GLint)state->vertArray.maxElementsIndices;
 733             break;
 734           case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
 735             *i = (GLint)__GL_CLIENT_ATTRIB_STACK_DEPTH;
 736             break;
 737           case GL_CLIENT_ACTIVE_TEXTURE_ARB:
 738             *i = (GLint)(state->vertArray.activeTexture + GL_TEXTURE0_ARB);
 739             break;
 740           default:
 741             /*
 742             ** Not a local value, so use what we got from the server.
 743             */
 744             if (compsize == 1) {
 745                 __GLX_SINGLE_GET_LONG(i);
 746             } else {
 747                 __GLX_SINGLE_GET_LONG_ARRAY(i,compsize);
 748                 if (val != origVal) {
 749                    /* matrix transpose */
 750                    TransposeMatrixi(i);
 751                 }
 752             }
 753         }
 754     }
 755     __GLX_SINGLE_END();
 756 }
 757
 758 /*
 759 ** Send all pending commands to server.
 760 */
 761 void glFlush(void)
 762 {
 763     __GLX_SINGLE_DECLARE_VARIABLES();
 764
 765     if (!dpy) return;
 766
 767     __GLX_SINGLE_LOAD_VARIABLES();
 768     __GLX_SINGLE_BEGIN(X_GLsop_Flush,0);
 769     __GLX_SINGLE_END();
 770
 771     /* And finally flush the X protocol data */
 772     XFlush(dpy);
 773 }
 774
 775 void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 776 {
 777     __GLX_SINGLE_DECLARE_VARIABLES();
 778
 779     if (!dpy) return;
 780
 781     __GLX_SINGLE_LOAD_VARIABLES();
 782     __GLX_SINGLE_BEGIN(X_GLsop_FeedbackBuffer,8);
 783     __GLX_SINGLE_PUT_LONG(0,size);
 784     __GLX_SINGLE_PUT_LONG(4,type);
 785     __GLX_SINGLE_END();
 786
 787     gc->feedbackBuf = buffer;
 788 }
 789
 790 void glSelectBuffer(GLsizei numnames, GLuint *buffer)
 791 {
 792     __GLX_SINGLE_DECLARE_VARIABLES();
 793
 794     if (!dpy) return;
 795
 796     __GLX_SINGLE_LOAD_VARIABLES();
 797     __GLX_SINGLE_BEGIN(X_GLsop_SelectBuffer,4);
 798     __GLX_SINGLE_PUT_LONG(0,numnames);
 799     __GLX_SINGLE_END();
 800
 801     gc->selectBuf = buffer;
 802 }
 803
 804 GLint glRenderMode(GLenum mode)
 805 {
 806     __GLX_SINGLE_DECLARE_VARIABLES();
 807     GLint retval = 0;
 808     xGLXRenderModeReply reply;
 809
 810     if (!dpy) return -1;
 811
 812     __GLX_SINGLE_LOAD_VARIABLES();
 813     __GLX_SINGLE_BEGIN(X_GLsop_RenderMode,4);
 814     __GLX_SINGLE_PUT_LONG(0,mode);
 815     __GLX_SINGLE_READ_XREPLY();
 816     __GLX_SINGLE_GET_RETVAL(retval,GLint);
 817
 818     if (reply.newMode != mode) {
 819         /*
 820         ** Switch to new mode did not take effect, therefore an error
 821         ** occured.  When an error happens the server won't send us any
 822         ** other data.
 823         */
 824     } else {
 825         /* Read the feedback or selection data */
 826         if (gc->renderMode == GL_FEEDBACK) {
 827             __GLX_SINGLE_GET_SIZE(compsize);
 828             __GLX_SINGLE_GET_FLOAT_ARRAY(gc->feedbackBuf, compsize);
 829         } else
 830         if (gc->renderMode == GL_SELECT) {
 831             __GLX_SINGLE_GET_SIZE(compsize);
 832             __GLX_SINGLE_GET_LONG_ARRAY(gc->selectBuf, compsize);
 833         }
 834         gc->renderMode = mode;
 835     }
 836     __GLX_SINGLE_END();
 837
 838     return retval;
 839 }
 840
 841 void glFinish(void)
 842 {
 843     __GLX_SINGLE_DECLARE_VARIABLES();
 844     xGLXSingleReply reply;
 845
 846     __GLX_SINGLE_LOAD_VARIABLES();
 847     __GLX_SINGLE_BEGIN(X_GLsop_Finish,0);
 848     __GLX_SINGLE_READ_XREPLY();
 849     __GLX_SINGLE_END();
 850 }
 851
 852
 853 /**
 854  * Extract the major and minor version numbers from a version string.
 855  */
 856 static void
 857 version_from_string( const char * ver,
 858                      int * major_version, int * minor_version )
 859 {
 860     const char * end;
 861     long major;
 862     long minor;
 863
 864     major = strtol( ver, (char **) & end, 10 );
 865     minor = strtol( end + 1, NULL, 10 );
 866     *major_version = major;
 867     *minor_version = minor;
 868 }
 869
 870
 871 const GLubyte *glGetString(GLenum name)
 872 {
 873     __GLXcontext *gc = __glXGetCurrentContext();
 874     Display *dpy = gc->currentDpy;
 875     GLubyte *s = NULL;
 876
 877     if (!dpy) return 0;
 878
 879     /*
 880     ** Return the cached copy if the string has already been fetched
 881     */
 882     switch(name) {
 883       case GL_VENDOR:
 884         if (gc->vendor) return gc->vendor;
 885         break;
 886       case GL_RENDERER:
 887         if (gc->renderer) return gc->renderer;
 888         break;
 889       case GL_VERSION:
 890         if (gc->version) return gc->version;
 891         break;
 892       case GL_EXTENSIONS:
 893         if (gc->extensions) return gc->extensions;
 894         break;
 895       default:
 896         __glXSetError(gc, GL_INVALID_ENUM);
 897         return 0;
 898     }
 899
 900     /*
 901     ** Get requested string from server
 902     */
 903
 904     (void) __glXFlushRenderBuffer( gc, gc->pc );
 905     s = (GLubyte *) __glXGetStringFromServer( dpy, gc->majorOpcode,
 906                                   X_GLsop_GetString, gc->currentContextTag,
 907                                   name );
 908     if (!s) {
 909         /* Throw data on the floor */
 910         __glXSetError(gc, GL_OUT_OF_MEMORY);
 911     } else {
 912         /*
 913         ** Update local cache
 914         */
 915         switch(name) {
 916         case GL_VENDOR:
 917             gc->vendor = s;
 918             break;
 919
 920         case GL_RENDERER:
 921             gc->renderer = s;
 922             break;
 923
 924         case GL_VERSION: {
 925             int client_major;
 926             int client_minor;
 927
 928             version_from_string( (char *) s,
 929                                  & gc->server_major, & gc->server_minor );
 930             __glXGetGLVersion( & client_major, & client_minor );
 931
 932             if ( (gc->server_major < client_major)
 933                  || ((gc->server_major == client_major)
 934                      && (gc->server_minor <= client_minor)) ) {
 935                 gc->version = s;
 936             }
 937             else {
 938                 /* Allow 7 bytes for the client-side GL version.  This allows
 939                  * for upto version 999.999.  I'm not holding my breath for
 940                  * that one!  The extra 4 is for the ' ()\0' that will be
 941                  * added.
 942                  */
 943                 const size_t size = 7 + strlen( (char *) s ) + 4;
 944
 945                 gc->version = Xmalloc( size );
 946                 if ( gc->version == NULL ) {
 947                     /* If we couldn't allocate memory for the new string,
 948                      * make a best-effort and just copy the client-side version
 949                      * to the string and use that.  It probably doesn't
 950                      * matter what is done here.  If there not memory available
 951                      * for a short string, the system is probably going to die
 952                      * soon anyway.
 953                      */
 954                     snprintf( (char *) s, strlen( (char *) s ) + 1, "%u.%u",
 955                               client_major, client_minor );
 956                     gc->version = s;
 957                 }
 958                 else {
 959                     snprintf( (char *)gc->version, size, "%u.%u (%s)",
 960                               client_major, client_minor, s );
 961                     Xfree( s );
 962                     s = gc->version;
 963                 }
 964             }
 965             break;
 966         }
 967
 968         case GL_EXTENSIONS: {
 969             int major = 1;
 970             int minor = 0;
 971
 972             /* This code is currently disabled.  I was reminded that some
 973              * vendors intentionally exclude some extensions from their
 974              * extension string that are part of the core version they
 975              * advertise.  In particular, on Nvidia drivers this means that
 976              * the functionality is supported by the driver, but is not
 977              * hardware accelerated.  For example, a TNT will show core
 978              * version 1.5, but most of the post-1.2 functionality is a
 979              * software fallback.
 980              *
 981              * I don't want to break applications that rely on this odd
 982              * behavior.  At the same time, the code is written and tested,
 983              * so I didn't want to throw it away.  Therefore, the code is here
 984              * but disabled.  In the future, we may wish to and an environment
 985              * variable to enable it.
 986              */
 987
 988 #if 0
 989             /* Call glGetString just to make sure that gc->server_major and
 990              * gc->server_minor are set.  This version may be higher than we
 991              * can completely support, but it may imply support for some
 992              * extensions that we can support.
 993              *
 994              * For example, at the time of this writing, the client-side
 995              * library only supports upto core GL version 1.2.  However, cubic
 996              * textures, multitexture, multisampling, and some other 1.3
 997              * features are supported.  If the server reports back version
 998              * 1.3, but does not report all of those extensions, we will
 999              * enable them.
1000              */
1001             (void *) glGetString( GL_VERSION );
1002             major = gc->server_major,
1003             minor = gc->server_minor;
1004 #endif
1005
1006             __glXCalculateUsableGLExtensions( gc, (char *) s, major, minor );
1007             XFree( s );
1008             s = gc->extensions;
1009             break;
1010         }
1011         }
1012     }
1013     return s;
1014 }
1015
1016 GLboolean glIsEnabled(GLenum cap)
1017 {
1018     __GLX_SINGLE_DECLARE_VARIABLES();
1019     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
1020     xGLXSingleReply reply;
1021     GLboolean retval = 0;
1022
1023     if (!dpy) return 0;
1024
1025     switch(cap) {
1026       case GL_VERTEX_ARRAY:
1027           return IS_ARRAY_ENABLED(state, vertex);
1028       case GL_NORMAL_ARRAY:
1029           return IS_ARRAY_ENABLED(state, normal);
1030       case GL_COLOR_ARRAY:
1031           return IS_ARRAY_ENABLED(state, color);
1032       case GL_INDEX_ARRAY:
1033           return IS_ARRAY_ENABLED(state, index);
1034       case GL_TEXTURE_COORD_ARRAY:
1035           return IS_TEXARRAY_ENABLED(state, state->vertArray.activeTexture);
1036       case GL_EDGE_FLAG_ARRAY:
1037           return IS_ARRAY_ENABLED(state, edgeFlag);
1038       case GL_SECONDARY_COLOR_ARRAY:
1039           return IS_ARRAY_ENABLED(state, secondaryColor);
1040       case GL_FOG_COORD_ARRAY:
1041           return IS_ARRAY_ENABLED(state, fogCoord);
1042     }
1043
1044     __GLX_SINGLE_LOAD_VARIABLES();
1045     __GLX_SINGLE_BEGIN(X_GLsop_IsEnabled,4);
1046     __GLX_SINGLE_PUT_LONG(0,cap);
1047     __GLX_SINGLE_READ_XREPLY();
1048     __GLX_SINGLE_GET_RETVAL(retval, GLboolean);
1049     __GLX_SINGLE_END();
1050     return retval;
1051 }
1052
1053 void glGetPointerv(GLenum pname, void **params)
1054 {
1055     __GLXcontext *gc = __glXGetCurrentContext();
1056     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
1057     Display *dpy = gc->currentDpy;
1058
1059     if (!dpy) return;
1060
1061     switch(pname) {
1062       case GL_VERTEX_ARRAY_POINTER:
1063           *params = (void *)state->vertArray.arrays[ vertex_ARRAY ].ptr;
1064           return;
1065       case GL_NORMAL_ARRAY_POINTER:
1066           *params = (void *)state->vertArray.arrays[ normal_ARRAY ].ptr;
1067           return;
1068       case GL_COLOR_ARRAY_POINTER:
1069           *params = (void *)state->vertArray.arrays[ color_ARRAY ].ptr;
1070           return;
1071       case GL_INDEX_ARRAY_POINTER:
1072           *params = (void *)state->vertArray.arrays[ index_ARRAY ].ptr;
1073           return;
1074       case GL_TEXTURE_COORD_ARRAY_POINTER:
1075           *params = (void *)state->vertArray.texCoord[state->vertArray.activeTexture].ptr;
1076           return;
1077       case GL_EDGE_FLAG_ARRAY_POINTER:
1078           *params = (void *)state->vertArray.arrays[ edgeFlag_ARRAY ].ptr;
1079         return;
1080       case GL_SECONDARY_COLOR_ARRAY_POINTER:
1081           *params = (void *)state->vertArray.arrays[ secondaryColor_ARRAY ].ptr;
1082         return;
1083       case GL_FOG_COORD_ARRAY_POINTER:
1084           *params = (void *)state->vertArray.arrays[ fogCoord_ARRAY ].ptr;
1085         return;
1086       case GL_FEEDBACK_BUFFER_POINTER:
1087         *params = (void *)gc->feedbackBuf;
1088         return;
1089       case GL_SELECTION_BUFFER_POINTER:
1090         *params = (void *)gc->selectBuf;
1091         return;
1092       default:
1093         __glXSetError(gc, GL_INVALID_ENUM);
1094         return;
1095     }
1096 }
1097