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