src/glx/x11/g_single.c

   1 /* $XFree86$ */
   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: This software was created using the
  26 ** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
  27 ** not been independently verified as being compliant with the OpenGL(R)
  28 ** version 1.2.1 Specification.
  29 */
  30
  31 #include "packsingle.h"
  32 #include "indirect.h"
  33
  34 void __indirect_glNewList(GLuint list, GLenum mode)
  35 {
  36         __GLX_SINGLE_DECLARE_VARIABLES();
  37         __GLX_SINGLE_LOAD_VARIABLES();
  38         __GLX_SINGLE_BEGIN(X_GLsop_NewList,8);
  39         __GLX_SINGLE_PUT_LONG(0,list);
  40         __GLX_SINGLE_PUT_LONG(4,mode);
  41         __GLX_SINGLE_END();
  42 }
  43
  44 void __indirect_glEndList(void)
  45 {
  46         __GLX_SINGLE_DECLARE_VARIABLES();
  47         __GLX_SINGLE_LOAD_VARIABLES();
  48         __GLX_SINGLE_BEGIN(X_GLsop_EndList,0);
  49         __GLX_SINGLE_END();
  50 }
  51
  52 void __indirect_glDeleteLists(GLuint list, GLsizei range)
  53 {
  54         __GLX_SINGLE_DECLARE_VARIABLES();
  55         __GLX_SINGLE_LOAD_VARIABLES();
  56         __GLX_SINGLE_BEGIN(X_GLsop_DeleteLists,8);
  57         __GLX_SINGLE_PUT_LONG(0,list);
  58         __GLX_SINGLE_PUT_LONG(4,range);
  59         __GLX_SINGLE_END();
  60 }
  61
  62 GLuint __indirect_glGenLists(GLsizei range)
  63 {
  64         __GLX_SINGLE_DECLARE_VARIABLES();
  65         GLuint    retval = 0;
  66         xGLXSingleReply reply;
  67         __GLX_SINGLE_LOAD_VARIABLES();
  68         __GLX_SINGLE_BEGIN(X_GLsop_GenLists,4);
  69         __GLX_SINGLE_PUT_LONG(0,range);
  70         __GLX_SINGLE_READ_XREPLY();
  71         __GLX_SINGLE_GET_RETVAL(retval, GLuint);
  72         __GLX_SINGLE_END();
  73         return retval;
  74 }
  75
  76 void __indirect_glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
  77 {
  78         __GLX_SINGLE_DECLARE_VARIABLES();
  79         xGLXSingleReply reply;
  80         __GLX_SINGLE_LOAD_VARIABLES();
  81         __GLX_SINGLE_BEGIN(X_GLsop_GetLightfv,8);
  82         __GLX_SINGLE_PUT_LONG(0,light);
  83         __GLX_SINGLE_PUT_LONG(4,pname);
  84         __GLX_SINGLE_READ_XREPLY();
  85         __GLX_SINGLE_GET_SIZE(compsize);
  86         if (compsize == 1) {
  87             __GLX_SINGLE_GET_FLOAT(params);
  88         } else {
  89             __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
  90         }
  91         __GLX_SINGLE_END();
  92 }
  93
  94 void __indirect_glGetLightiv(GLenum light, GLenum pname, GLint *params)
  95 {
  96         __GLX_SINGLE_DECLARE_VARIABLES();
  97         xGLXSingleReply reply;
  98         __GLX_SINGLE_LOAD_VARIABLES();
  99         __GLX_SINGLE_BEGIN(X_GLsop_GetLightiv,8);
 100         __GLX_SINGLE_PUT_LONG(0,light);
 101         __GLX_SINGLE_PUT_LONG(4,pname);
 102         __GLX_SINGLE_READ_XREPLY();
 103         __GLX_SINGLE_GET_SIZE(compsize);
 104         if (compsize == 1) {
 105             __GLX_SINGLE_GET_LONG(params);
 106         } else {
 107             __GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
 108         }
 109         __GLX_SINGLE_END();
 110 }
 111
 112 void __indirect_glGetMapdv(GLenum target, GLenum query, GLdouble *v)
 113 {
 114         __GLX_SINGLE_DECLARE_VARIABLES();
 115         xGLXSingleReply reply;
 116         __GLX_SINGLE_LOAD_VARIABLES();
 117         __GLX_SINGLE_BEGIN(X_GLsop_GetMapdv,8);
 118         __GLX_SINGLE_PUT_LONG(0,target);
 119         __GLX_SINGLE_PUT_LONG(4,query);
 120         __GLX_SINGLE_READ_XREPLY();
 121         __GLX_SINGLE_GET_SIZE(compsize);
 122         if (compsize == 1) {
 123             __GLX_SINGLE_GET_DOUBLE(v);
 124         } else {
 125             __GLX_SINGLE_GET_DOUBLE_ARRAY(v,compsize);
 126         }
 127         __GLX_SINGLE_END();
 128 }
 129
 130 void __indirect_glGetMapfv(GLenum target, GLenum query, GLfloat *v)
 131 {
 132         __GLX_SINGLE_DECLARE_VARIABLES();
 133         xGLXSingleReply reply;
 134         __GLX_SINGLE_LOAD_VARIABLES();
 135         __GLX_SINGLE_BEGIN(X_GLsop_GetMapfv,8);
 136         __GLX_SINGLE_PUT_LONG(0,target);
 137         __GLX_SINGLE_PUT_LONG(4,query);
 138         __GLX_SINGLE_READ_XREPLY();
 139         __GLX_SINGLE_GET_SIZE(compsize);
 140         if (compsize == 1) {
 141             __GLX_SINGLE_GET_FLOAT(v);
 142         } else {
 143             __GLX_SINGLE_GET_FLOAT_ARRAY(v,compsize);
 144         }
 145         __GLX_SINGLE_END();
 146 }
 147
 148 void __indirect_glGetMapiv(GLenum target, GLenum query, GLint *v)
 149 {
 150         __GLX_SINGLE_DECLARE_VARIABLES();
 151         xGLXSingleReply reply;
 152         __GLX_SINGLE_LOAD_VARIABLES();
 153         __GLX_SINGLE_BEGIN(X_GLsop_GetMapiv,8);
 154         __GLX_SINGLE_PUT_LONG(0,target);
 155         __GLX_SINGLE_PUT_LONG(4,query);
 156         __GLX_SINGLE_READ_XREPLY();
 157         __GLX_SINGLE_GET_SIZE(compsize);
 158         if (compsize == 1) {
 159             __GLX_SINGLE_GET_LONG(v);
 160         } else {
 161             __GLX_SINGLE_GET_LONG_ARRAY(v,compsize);
 162         }
 163         __GLX_SINGLE_END();
 164 }
 165
 166 void __indirect_glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 167 {
 168         __GLX_SINGLE_DECLARE_VARIABLES();
 169         xGLXSingleReply reply;
 170         __GLX_SINGLE_LOAD_VARIABLES();
 171         __GLX_SINGLE_BEGIN(X_GLsop_GetMaterialfv,8);
 172         __GLX_SINGLE_PUT_LONG(0,face);
 173         __GLX_SINGLE_PUT_LONG(4,pname);
 174         __GLX_SINGLE_READ_XREPLY();
 175         __GLX_SINGLE_GET_SIZE(compsize);
 176         if (compsize == 1) {
 177             __GLX_SINGLE_GET_FLOAT(params);
 178         } else {
 179             __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
 180         }
 181         __GLX_SINGLE_END();
 182 }
 183
 184 void __indirect_glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
 185 {
 186         __GLX_SINGLE_DECLARE_VARIABLES();
 187         xGLXSingleReply reply;
 188         __GLX_SINGLE_LOAD_VARIABLES();
 189         __GLX_SINGLE_BEGIN(X_GLsop_GetMaterialiv,8);
 190         __GLX_SINGLE_PUT_LONG(0,face);
 191         __GLX_SINGLE_PUT_LONG(4,pname);
 192         __GLX_SINGLE_READ_XREPLY();
 193         __GLX_SINGLE_GET_SIZE(compsize);
 194         if (compsize == 1) {
 195             __GLX_SINGLE_GET_LONG(params);
 196         } else {
 197             __GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
 198         }
 199         __GLX_SINGLE_END();
 200 }
 201
 202 void __indirect_glGetPixelMapfv(GLenum map, GLfloat *values)
 203 {
 204         __GLX_SINGLE_DECLARE_VARIABLES();
 205         xGLXSingleReply reply;
 206         __GLX_SINGLE_LOAD_VARIABLES();
 207         __GLX_SINGLE_BEGIN(X_GLsop_GetPixelMapfv,4);
 208         __GLX_SINGLE_PUT_LONG(0,map);
 209         __GLX_SINGLE_READ_XREPLY();
 210         __GLX_SINGLE_GET_SIZE(compsize);
 211         if (compsize == 1) {
 212             __GLX_SINGLE_GET_FLOAT(values);
 213         } else {
 214             __GLX_SINGLE_GET_FLOAT_ARRAY(values,compsize);
 215         }
 216         __GLX_SINGLE_END();
 217 }
 218
 219 void __indirect_glGetPixelMapuiv(GLenum map, GLuint *values)
 220 {
 221         __GLX_SINGLE_DECLARE_VARIABLES();
 222         xGLXSingleReply reply;
 223         __GLX_SINGLE_LOAD_VARIABLES();
 224         __GLX_SINGLE_BEGIN(X_GLsop_GetPixelMapuiv,4);
 225         __GLX_SINGLE_PUT_LONG(0,map);
 226         __GLX_SINGLE_READ_XREPLY();
 227         __GLX_SINGLE_GET_SIZE(compsize);
 228         if (compsize == 1) {
 229             __GLX_SINGLE_GET_LONG(values);
 230         } else {
 231             __GLX_SINGLE_GET_LONG_ARRAY(values,compsize);
 232         }
 233         __GLX_SINGLE_END();
 234 }
 235
 236 void __indirect_glGetPixelMapusv(GLenum map, GLushort *values)
 237 {
 238         __GLX_SINGLE_DECLARE_VARIABLES();
 239         xGLXSingleReply reply;
 240         __GLX_SINGLE_LOAD_VARIABLES();
 241         __GLX_SINGLE_BEGIN(X_GLsop_GetPixelMapusv,4);
 242         __GLX_SINGLE_PUT_LONG(0,map);
 243         __GLX_SINGLE_READ_XREPLY();
 244         __GLX_SINGLE_GET_SIZE(compsize);
 245         if (compsize == 1) {
 246             __GLX_SINGLE_GET_SHORT(values);
 247         } else {
 248             __GLX_SINGLE_GET_SHORT_ARRAY(values,compsize);
 249         }
 250         __GLX_SINGLE_END();
 251 }
 252
 253 void __indirect_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
 254 {
 255         __GLX_SINGLE_DECLARE_VARIABLES();
 256         xGLXSingleReply reply;
 257         __GLX_SINGLE_LOAD_VARIABLES();
 258         __GLX_SINGLE_BEGIN(X_GLsop_GetTexEnvfv,8);
 259         __GLX_SINGLE_PUT_LONG(0,target);
 260         __GLX_SINGLE_PUT_LONG(4,pname);
 261         __GLX_SINGLE_READ_XREPLY();
 262         __GLX_SINGLE_GET_SIZE(compsize);
 263         if (compsize == 1) {
 264             __GLX_SINGLE_GET_FLOAT(params);
 265         } else {
 266             __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
 267         }
 268         __GLX_SINGLE_END();
 269 }
 270
 271 void __indirect_glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
 272 {
 273         __GLX_SINGLE_DECLARE_VARIABLES();
 274         xGLXSingleReply reply;
 275         __GLX_SINGLE_LOAD_VARIABLES();
 276         __GLX_SINGLE_BEGIN(X_GLsop_GetTexEnviv,8);
 277         __GLX_SINGLE_PUT_LONG(0,target);
 278         __GLX_SINGLE_PUT_LONG(4,pname);
 279         __GLX_SINGLE_READ_XREPLY();
 280         __GLX_SINGLE_GET_SIZE(compsize);
 281         if (compsize == 1) {
 282             __GLX_SINGLE_GET_LONG(params);
 283         } else {
 284             __GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
 285         }
 286         __GLX_SINGLE_END();
 287 }
 288
 289 void __indirect_glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
 290 {
 291         __GLX_SINGLE_DECLARE_VARIABLES();
 292         xGLXSingleReply reply;
 293         __GLX_SINGLE_LOAD_VARIABLES();
 294         __GLX_SINGLE_BEGIN(X_GLsop_GetTexGendv,8);
 295         __GLX_SINGLE_PUT_LONG(0,coord);
 296         __GLX_SINGLE_PUT_LONG(4,pname);
 297         __GLX_SINGLE_READ_XREPLY();
 298         __GLX_SINGLE_GET_SIZE(compsize);
 299         if (compsize == 1) {
 300             __GLX_SINGLE_GET_DOUBLE(params);
 301         } else {
 302             __GLX_SINGLE_GET_DOUBLE_ARRAY(params,compsize);
 303         }
 304         __GLX_SINGLE_END();
 305 }
 306
 307 void __indirect_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
 308 {
 309         __GLX_SINGLE_DECLARE_VARIABLES();
 310         xGLXSingleReply reply;
 311         __GLX_SINGLE_LOAD_VARIABLES();
 312         __GLX_SINGLE_BEGIN(X_GLsop_GetTexGenfv,8);
 313         __GLX_SINGLE_PUT_LONG(0,coord);
 314         __GLX_SINGLE_PUT_LONG(4,pname);
 315         __GLX_SINGLE_READ_XREPLY();
 316         __GLX_SINGLE_GET_SIZE(compsize);
 317         if (compsize == 1) {
 318             __GLX_SINGLE_GET_FLOAT(params);
 319         } else {
 320             __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
 321         }
 322         __GLX_SINGLE_END();
 323 }
 324
 325 void __indirect_glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
 326 {
 327         __GLX_SINGLE_DECLARE_VARIABLES();
 328         xGLXSingleReply reply;
 329         __GLX_SINGLE_LOAD_VARIABLES();
 330         __GLX_SINGLE_BEGIN(X_GLsop_GetTexGeniv,8);
 331         __GLX_SINGLE_PUT_LONG(0,coord);
 332         __GLX_SINGLE_PUT_LONG(4,pname);
 333         __GLX_SINGLE_READ_XREPLY();
 334         __GLX_SINGLE_GET_SIZE(compsize);
 335         if (compsize == 1) {
 336             __GLX_SINGLE_GET_LONG(params);
 337         } else {
 338             __GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
 339         }
 340         __GLX_SINGLE_END();
 341 }
 342
 343 void __indirect_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 344 {
 345         __GLX_SINGLE_DECLARE_VARIABLES();
 346         xGLXSingleReply reply;
 347         __GLX_SINGLE_LOAD_VARIABLES();
 348         __GLX_SINGLE_BEGIN(X_GLsop_GetTexParameterfv,8);
 349         __GLX_SINGLE_PUT_LONG(0,target);
 350         __GLX_SINGLE_PUT_LONG(4,pname);
 351         __GLX_SINGLE_READ_XREPLY();
 352         __GLX_SINGLE_GET_SIZE(compsize);
 353         if (compsize == 1) {
 354             __GLX_SINGLE_GET_FLOAT(params);
 355         } else {
 356             __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
 357         }
 358         __GLX_SINGLE_END();
 359 }
 360
 361 void __indirect_glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 362 {
 363         __GLX_SINGLE_DECLARE_VARIABLES();
 364         xGLXSingleReply reply;
 365         __GLX_SINGLE_LOAD_VARIABLES();
 366         __GLX_SINGLE_BEGIN(X_GLsop_GetTexParameteriv,8);
 367         __GLX_SINGLE_PUT_LONG(0,target);
 368         __GLX_SINGLE_PUT_LONG(4,pname);
 369         __GLX_SINGLE_READ_XREPLY();
 370         __GLX_SINGLE_GET_SIZE(compsize);
 371         if (compsize == 1) {
 372             __GLX_SINGLE_GET_LONG(params);
 373         } else {
 374             __GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
 375         }
 376         __GLX_SINGLE_END();
 377 }
 378
 379 void __indirect_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 380 {
 381         __GLX_SINGLE_DECLARE_VARIABLES();
 382         xGLXSingleReply reply;
 383         __GLX_SINGLE_LOAD_VARIABLES();
 384         __GLX_SINGLE_BEGIN(X_GLsop_GetTexLevelParameterfv,12);
 385         __GLX_SINGLE_PUT_LONG(0,target);
 386         __GLX_SINGLE_PUT_LONG(4,level);
 387         __GLX_SINGLE_PUT_LONG(8,pname);
 388         __GLX_SINGLE_READ_XREPLY();
 389         __GLX_SINGLE_GET_SIZE(compsize);
 390         if (compsize == 1) {
 391             __GLX_SINGLE_GET_FLOAT(params);
 392         } else {
 393             __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
 394         }
 395         __GLX_SINGLE_END();
 396 }
 397
 398 void __indirect_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 399 {
 400         __GLX_SINGLE_DECLARE_VARIABLES();
 401         xGLXSingleReply reply;
 402         __GLX_SINGLE_LOAD_VARIABLES();
 403         __GLX_SINGLE_BEGIN(X_GLsop_GetTexLevelParameteriv,12);
 404         __GLX_SINGLE_PUT_LONG(0,target);
 405         __GLX_SINGLE_PUT_LONG(4,level);
 406         __GLX_SINGLE_PUT_LONG(8,pname);
 407         __GLX_SINGLE_READ_XREPLY();
 408         __GLX_SINGLE_GET_SIZE(compsize);
 409         if (compsize == 1) {
 410             __GLX_SINGLE_GET_LONG(params);
 411         } else {
 412             __GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
 413         }
 414         __GLX_SINGLE_END();
 415 }
 416
 417 GLboolean __indirect_glIsList(GLuint list)
 418 {
 419         __GLX_SINGLE_DECLARE_VARIABLES();
 420         GLboolean    retval = 0;
 421         xGLXSingleReply reply;
 422         __GLX_SINGLE_LOAD_VARIABLES();
 423         __GLX_SINGLE_BEGIN(X_GLsop_IsList,4);
 424         __GLX_SINGLE_PUT_LONG(0,list);
 425         __GLX_SINGLE_READ_XREPLY();
 426         __GLX_SINGLE_GET_RETVAL(retval, GLboolean);
 427         __GLX_SINGLE_END();
 428         return retval;
 429 }
 430
 431 /*
 432  * Somewhere between GLX 1.2 and 1.3 (in SGI's code anyway) the
 433  * protocol for glAreTexturesResident, glDeleteTextures, glGenTextures,
 434  * and glIsTexture() was changed.  Before, calls to these functions
 435  * generated protocol for the old GL_EXT_texture_object versions of those
 436  * calls.  In the newer code, this is actually corrected; calls to the
 437  * 1.1 functions generate 1.1 protocol and calls to the EXT functions
 438  * generate EXT protocol.
 439  * Unfortunately, this correction causes an incompatibility.  Specifically,
 440  * an updated libGL.so will send protocol requests that the server won't
 441  * be able to handle.  For example, calling glGenTextures will generate a
 442  * BadRequest error.
 443  * For now, we'll keep generating EXT protocol from libGL.  We'll update
 444  * the server to understand both the 1.1 and EXT protocol ASAP.  At some point
 445  * in the future we'll correct libGL.so as well.  That should be a smoother
 446  * transition path.
 447  */
 448
 449 GLboolean __indirect_glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
 450 {
 451 #if 0 /* see comments above */
 452         __GLX_SINGLE_DECLARE_VARIABLES();
 453         GLboolean    retval = 0;
 454         xGLXSingleReply reply;
 455         __GLX_SINGLE_LOAD_VARIABLES();
 456         if (n < 0) return retval;
 457         cmdlen = 4+n*4;
 458         __GLX_SINGLE_BEGIN(X_GLsop_AreTexturesResident,cmdlen);
 459         __GLX_SINGLE_PUT_LONG(0,n);
 460         __GLX_PUT_LONG_ARRAY(4,textures,n);
 461         __GLX_SINGLE_READ_XREPLY();
 462         __GLX_SINGLE_GET_RETVAL(retval, GLboolean);
 463         __GLX_SINGLE_GET_CHAR_ARRAY(residences,n);
 464         __GLX_SINGLE_END();
 465         return retval;
 466 #else
 467         return __indirect_glAreTexturesResidentEXT(n, textures, residences);
 468 #endif
 469 }
 470
 471 void __indirect_glDeleteTextures(GLsizei n, const GLuint *textures)
 472 {
 473 #if 0 /* see comments above */
 474         __GLX_SINGLE_DECLARE_VARIABLES();
 475         __GLX_SINGLE_LOAD_VARIABLES();
 476         if (n < 0) return;
 477         cmdlen = 4+n*4;
 478         __GLX_SINGLE_BEGIN(X_GLsop_DeleteTextures,cmdlen);
 479         __GLX_SINGLE_PUT_LONG(0,n);
 480         __GLX_PUT_LONG_ARRAY(4,textures,n);
 481         __GLX_SINGLE_END();
 482 #else
 483         __indirect_glDeleteTexturesEXT(n, textures);
 484 #endif
 485 }
 486
 487 void __indirect_glGenTextures(GLsizei n, GLuint *textures)
 488 {
 489 #if 0 /* see comments above */
 490         __GLX_SINGLE_DECLARE_VARIABLES();
 491         xGLXSingleReply reply;
 492         __GLX_SINGLE_LOAD_VARIABLES();
 493         __GLX_SINGLE_BEGIN(X_GLsop_GenTextures,4);
 494         __GLX_SINGLE_PUT_LONG(0,n);
 495         __GLX_SINGLE_READ_XREPLY();
 496         __GLX_SINGLE_GET_LONG_ARRAY(textures,n);
 497         __GLX_SINGLE_END();
 498 #else
 499         __indirect_glGenTexturesEXT(n, textures);
 500 #endif
 501 }
 502
 503 GLboolean __indirect_glIsTexture(GLuint texture)
 504 {
 505 #if 0 /* see comments above */
 506         __GLX_SINGLE_DECLARE_VARIABLES();
 507         GLboolean    retval = 0;
 508         xGLXSingleReply reply;
 509         __GLX_SINGLE_LOAD_VARIABLES();
 510         __GLX_SINGLE_BEGIN(X_GLsop_IsTexture,4);
 511         __GLX_SINGLE_PUT_LONG(0,texture);
 512         __GLX_SINGLE_READ_XREPLY();
 513         __GLX_SINGLE_GET_RETVAL(retval, GLboolean);
 514         __GLX_SINGLE_END();
 515         return retval;
 516 #else
 517         return __indirect_glIsTextureEXT(texture);
 518 #endif
 519 }
 520
 521 void __indirect_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
 522 {
 523         __GLX_SINGLE_DECLARE_VARIABLES();
 524         xGLXSingleReply reply;
 525         __GLX_SINGLE_LOAD_VARIABLES();
 526         __GLX_SINGLE_BEGIN(X_GLsop_GetColorTableParameterfv,8);
 527         __GLX_SINGLE_PUT_LONG(0,target);
 528         __GLX_SINGLE_PUT_LONG(4,pname);
 529         __GLX_SINGLE_READ_XREPLY();
 530         __GLX_SINGLE_GET_SIZE(compsize);
 531         if (compsize == 1) {
 532             __GLX_SINGLE_GET_FLOAT(params);
 533         } else {
 534             __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
 535         }
 536         __GLX_SINGLE_END();
 537 }
 538
 539 void __indirect_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
 540 {
 541         __GLX_SINGLE_DECLARE_VARIABLES();
 542         xGLXSingleReply reply;
 543         __GLX_SINGLE_LOAD_VARIABLES();
 544         __GLX_SINGLE_BEGIN(X_GLsop_GetColorTableParameteriv,8);
 545         __GLX_SINGLE_PUT_LONG(0,target);
 546         __GLX_SINGLE_PUT_LONG(4,pname);
 547         __GLX_SINGLE_READ_XREPLY();
 548         __GLX_SINGLE_GET_SIZE(compsize);
 549         if (compsize == 1) {
 550             __GLX_SINGLE_GET_LONG(params);
 551         } else {
 552             __GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
 553         }
 554         __GLX_SINGLE_END();
 555 }
 556
 557 void __indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
 558 {
 559         __GLX_SINGLE_DECLARE_VARIABLES();
 560         xGLXSingleReply reply;
 561         __GLX_SINGLE_LOAD_VARIABLES();
 562         __GLX_SINGLE_BEGIN(X_GLsop_GetConvolutionParameterfv,8);
 563         __GLX_SINGLE_PUT_LONG(0,target);
 564         __GLX_SINGLE_PUT_LONG(4,pname);
 565         __GLX_SINGLE_READ_XREPLY();
 566         __GLX_SINGLE_GET_SIZE(compsize);
 567         if (compsize == 1) {
 568             __GLX_SINGLE_GET_FLOAT(params);
 569         } else {
 570             __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
 571         }
 572         __GLX_SINGLE_END();
 573 }
 574
 575 void __indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
 576 {
 577         __GLX_SINGLE_DECLARE_VARIABLES();
 578         xGLXSingleReply reply;
 579         __GLX_SINGLE_LOAD_VARIABLES();
 580         __GLX_SINGLE_BEGIN(X_GLsop_GetConvolutionParameteriv,8);
 581         __GLX_SINGLE_PUT_LONG(0,target);
 582         __GLX_SINGLE_PUT_LONG(4,pname);
 583         __GLX_SINGLE_READ_XREPLY();
 584         __GLX_SINGLE_GET_SIZE(compsize);
 585         if (compsize == 1) {
 586             __GLX_SINGLE_GET_LONG(params);
 587         } else {
 588             __GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
 589         }
 590         __GLX_SINGLE_END();
 591 }
 592
 593 void __indirect_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
 594 {
 595         __GLX_SINGLE_DECLARE_VARIABLES();
 596         xGLXSingleReply reply;
 597         __GLX_SINGLE_LOAD_VARIABLES();
 598         __GLX_SINGLE_BEGIN(X_GLsop_GetHistogramParameterfv,8);
 599         __GLX_SINGLE_PUT_LONG(0,target);
 600         __GLX_SINGLE_PUT_LONG(4,pname);
 601         __GLX_SINGLE_READ_XREPLY();
 602         __GLX_SINGLE_GET_SIZE(compsize);
 603         if (compsize == 1) {
 604             __GLX_SINGLE_GET_FLOAT(params);
 605         } else {
 606             __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
 607         }
 608         __GLX_SINGLE_END();
 609 }
 610
 611 void __indirect_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
 612 {
 613         __GLX_SINGLE_DECLARE_VARIABLES();
 614         xGLXSingleReply reply;
 615         __GLX_SINGLE_LOAD_VARIABLES();
 616         __GLX_SINGLE_BEGIN(X_GLsop_GetHistogramParameteriv,8);
 617         __GLX_SINGLE_PUT_LONG(0,target);
 618         __GLX_SINGLE_PUT_LONG(4,pname);
 619         __GLX_SINGLE_READ_XREPLY();
 620         __GLX_SINGLE_GET_SIZE(compsize);
 621         if (compsize == 1) {
 622             __GLX_SINGLE_GET_LONG(params);
 623         } else {
 624             __GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
 625         }
 626         __GLX_SINGLE_END();
 627 }
 628
 629 void __indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
 630 {
 631         __GLX_SINGLE_DECLARE_VARIABLES();
 632         xGLXSingleReply reply;
 633         __GLX_SINGLE_LOAD_VARIABLES();
 634         __GLX_SINGLE_BEGIN(X_GLsop_GetMinmaxParameterfv,8);
 635         __GLX_SINGLE_PUT_LONG(0,target);
 636         __GLX_SINGLE_PUT_LONG(4,pname);
 637         __GLX_SINGLE_READ_XREPLY();
 638         __GLX_SINGLE_GET_SIZE(compsize);
 639         if (compsize == 1) {
 640             __GLX_SINGLE_GET_FLOAT(params);
 641         } else {
 642             __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
 643         }
 644         __GLX_SINGLE_END();
 645 }
 646
 647 void __indirect_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
 648 {
 649         __GLX_SINGLE_DECLARE_VARIABLES();
 650         xGLXSingleReply reply;
 651         __GLX_SINGLE_LOAD_VARIABLES();
 652         __GLX_SINGLE_BEGIN(X_GLsop_GetMinmaxParameteriv,8);
 653         __GLX_SINGLE_PUT_LONG(0,target);
 654         __GLX_SINGLE_PUT_LONG(4,pname);
 655         __GLX_SINGLE_READ_XREPLY();
 656         __GLX_SINGLE_GET_SIZE(compsize);
 657         if (compsize == 1) {
 658             __GLX_SINGLE_GET_LONG(params);
 659         } else {
 660             __GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
 661         }
 662         __GLX_SINGLE_END();
 663 }
 664