OLD | NEW |
(Empty) | |
| 1 /* DO NOT EDIT - This file generated automatically by glX_proto_send.py (from Me
sa) script */ |
| 2 |
| 3 /* |
| 4 * (C) Copyright IBM Corporation 2004, 2005 |
| 5 * All Rights Reserved. |
| 6 * |
| 7 * Permission is hereby granted, free of charge, to any person obtaining a |
| 8 * copy of this software and associated documentation files (the "Software"), |
| 9 * to deal in the Software without restriction, including without limitation |
| 10 * the rights to use, copy, modify, merge, publish, distribute, sub license, |
| 11 * and/or sell copies of the Software, and to permit persons to whom the |
| 12 * Software is furnished to do so, subject to the following conditions: |
| 13 * |
| 14 * The above copyright notice and this permission notice (including the next |
| 15 * paragraph) shall be included in all copies or substantial portions of the |
| 16 * Software. |
| 17 * |
| 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 20 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| 21 * IBM, |
| 22 * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, |
| 23 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF |
| 24 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| 25 * SOFTWARE. |
| 26 */ |
| 27 |
| 28 |
| 29 #include <GL/gl.h> |
| 30 #include "indirect.h" |
| 31 #include "glxclient.h" |
| 32 #include "indirect_size.h" |
| 33 #include "glapi.h" |
| 34 #include "glthread.h" |
| 35 #include <GL/glxproto.h> |
| 36 #ifdef USE_XCB |
| 37 #include <X11/Xlib-xcb.h> |
| 38 #include <xcb/xcb.h> |
| 39 #include <xcb/glx.h> |
| 40 #endif /* USE_XCB */ |
| 41 |
| 42 #define __GLX_PAD(n) (((n) + 3) & ~3) |
| 43 |
| 44 # if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined
(__MINGW32__) |
| 45 # define FASTCALL __attribute__((fastcall)) |
| 46 # else |
| 47 # define FASTCALL |
| 48 # endif |
| 49 # if defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)) |
| 50 # define NOINLINE __attribute__((noinline)) |
| 51 # else |
| 52 # define NOINLINE |
| 53 # endif |
| 54 |
| 55 #ifndef __GNUC__ |
| 56 # define __builtin_expect(x, y) x |
| 57 #endif |
| 58 |
| 59 /* If the size and opcode values are known at compile-time, this will, on |
| 60 * x86 at least, emit them with a single instruction. |
| 61 */ |
| 62 #define emit_header(dest, op, size) \ |
| 63 do { union { short s[2]; int i; } temp; \ |
| 64 temp.s[0] = (size); temp.s[1] = (op); \ |
| 65 *((int *)(dest)) = temp.i; } while(0) |
| 66 |
| 67 NOINLINE CARD32 |
| 68 __glXReadReply( Display *dpy, size_t size, void * dest, GLboolean reply_is_alway
s_array ) |
| 69 { |
| 70 xGLXSingleReply reply; |
| 71 |
| 72 (void) _XReply(dpy, (xReply *) & reply, 0, False); |
| 73 if (size != 0) { |
| 74 if ((reply.length > 0) || reply_is_always_array) { |
| 75 const GLint bytes = (reply_is_always_array) |
| 76 ? (4 * reply.length) : (reply.size * size); |
| 77 const GLint extra = 4 - (bytes & 3); |
| 78 |
| 79 _XRead(dpy, dest, bytes); |
| 80 if ( extra < 4 ) { |
| 81 _XEatData(dpy, extra); |
| 82 } |
| 83 } |
| 84 else { |
| 85 (void) memcpy( dest, &(reply.pad3), size); |
| 86 } |
| 87 } |
| 88 |
| 89 return reply.retval; |
| 90 } |
| 91 |
| 92 NOINLINE void |
| 93 __glXReadPixelReply( Display *dpy, struct glx_context * gc, unsigned max_dim, |
| 94 GLint width, GLint height, GLint depth, GLenum format, GLenum type, |
| 95 void * dest, GLboolean dimensions_in_reply ) |
| 96 { |
| 97 xGLXSingleReply reply; |
| 98 GLint size; |
| 99 |
| 100 (void) _XReply(dpy, (xReply *) & reply, 0, False); |
| 101 |
| 102 if ( dimensions_in_reply ) { |
| 103 width = reply.pad3; |
| 104 height = reply.pad4; |
| 105 depth = reply.pad5; |
| 106 |
| 107 if ((height == 0) || (max_dim < 2)) { height = 1; } |
| 108 if ((depth == 0) || (max_dim < 3)) { depth = 1; } |
| 109 } |
| 110 |
| 111 size = reply.length * 4; |
| 112 if (size != 0) { |
| 113 void * buf = Xmalloc( size ); |
| 114 |
| 115 if ( buf == NULL ) { |
| 116 _XEatData(dpy, size); |
| 117 __glXSetError(gc, GL_OUT_OF_MEMORY); |
| 118 } |
| 119 else { |
| 120 const GLint extra = 4 - (size & 3); |
| 121 |
| 122 _XRead(dpy, buf, size); |
| 123 if ( extra < 4 ) { |
| 124 _XEatData(dpy, extra); |
| 125 } |
| 126 |
| 127 __glEmptyImage(gc, 3, width, height, depth, format, type, |
| 128 buf, dest); |
| 129 Xfree(buf); |
| 130 } |
| 131 } |
| 132 } |
| 133 |
| 134 #define X_GLXSingle 0 |
| 135 |
| 136 NOINLINE FASTCALL GLubyte * |
| 137 __glXSetupSingleRequest( struct glx_context * gc, GLint sop, GLint cmdlen ) |
| 138 { |
| 139 xGLXSingleReq * req; |
| 140 Display * const dpy = gc->currentDpy; |
| 141 |
| 142 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 143 LockDisplay(dpy); |
| 144 GetReqExtra(GLXSingle, cmdlen, req); |
| 145 req->reqType = gc->majorOpcode; |
| 146 req->contextTag = gc->currentContextTag; |
| 147 req->glxCode = sop; |
| 148 return (GLubyte *)(req) + sz_xGLXSingleReq; |
| 149 } |
| 150 |
| 151 NOINLINE FASTCALL GLubyte * |
| 152 __glXSetupVendorRequest( struct glx_context * gc, GLint code, GLint vop, GLint c
mdlen ) |
| 153 { |
| 154 xGLXVendorPrivateReq * req; |
| 155 Display * const dpy = gc->currentDpy; |
| 156 |
| 157 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 158 LockDisplay(dpy); |
| 159 GetReqExtra(GLXVendorPrivate, cmdlen, req); |
| 160 req->reqType = gc->majorOpcode; |
| 161 req->glxCode = code; |
| 162 req->vendorCode = vop; |
| 163 req->contextTag = gc->currentContextTag; |
| 164 return (GLubyte *)(req) + sz_xGLXVendorPrivateReq; |
| 165 } |
| 166 |
| 167 const GLuint __glXDefaultPixelStore[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 }; |
| 168 |
| 169 #define zero (__glXDefaultPixelStore+0) |
| 170 #define one (__glXDefaultPixelStore+8) |
| 171 #define default_pixel_store_1D (__glXDefaultPixelStore+4) |
| 172 #define default_pixel_store_1D_size 20 |
| 173 #define default_pixel_store_2D (__glXDefaultPixelStore+4) |
| 174 #define default_pixel_store_2D_size 20 |
| 175 #define default_pixel_store_3D (__glXDefaultPixelStore+0) |
| 176 #define default_pixel_store_3D_size 36 |
| 177 #define default_pixel_store_4D (__glXDefaultPixelStore+0) |
| 178 #define default_pixel_store_4D_size 36 |
| 179 |
| 180 static FASTCALL NOINLINE void |
| 181 generic_3_byte( GLint rop, const void * ptr ) |
| 182 { |
| 183 struct glx_context * const gc = __glXGetCurrentContext(); |
| 184 const GLuint cmdlen = 8; |
| 185 |
| 186 emit_header(gc->pc, rop, cmdlen); |
| 187 (void) memcpy((void *)(gc->pc + 4), ptr, 4); |
| 188 gc->pc += cmdlen; |
| 189 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer
(gc, gc->pc); } |
| 190 } |
| 191 |
| 192 static FASTCALL NOINLINE void |
| 193 generic_4_byte( GLint rop, const void * ptr ) |
| 194 { |
| 195 struct glx_context * const gc = __glXGetCurrentContext(); |
| 196 const GLuint cmdlen = 8; |
| 197 |
| 198 emit_header(gc->pc, rop, cmdlen); |
| 199 (void) memcpy((void *)(gc->pc + 4), ptr, 4); |
| 200 gc->pc += cmdlen; |
| 201 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer
(gc, gc->pc); } |
| 202 } |
| 203 |
| 204 static FASTCALL NOINLINE void |
| 205 generic_6_byte( GLint rop, const void * ptr ) |
| 206 { |
| 207 struct glx_context * const gc = __glXGetCurrentContext(); |
| 208 const GLuint cmdlen = 12; |
| 209 |
| 210 emit_header(gc->pc, rop, cmdlen); |
| 211 (void) memcpy((void *)(gc->pc + 4), ptr, 8); |
| 212 gc->pc += cmdlen; |
| 213 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer
(gc, gc->pc); } |
| 214 } |
| 215 |
| 216 static FASTCALL NOINLINE void |
| 217 generic_8_byte( GLint rop, const void * ptr ) |
| 218 { |
| 219 struct glx_context * const gc = __glXGetCurrentContext(); |
| 220 const GLuint cmdlen = 12; |
| 221 |
| 222 emit_header(gc->pc, rop, cmdlen); |
| 223 (void) memcpy((void *)(gc->pc + 4), ptr, 8); |
| 224 gc->pc += cmdlen; |
| 225 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer
(gc, gc->pc); } |
| 226 } |
| 227 |
| 228 static FASTCALL NOINLINE void |
| 229 generic_12_byte( GLint rop, const void * ptr ) |
| 230 { |
| 231 struct glx_context * const gc = __glXGetCurrentContext(); |
| 232 const GLuint cmdlen = 16; |
| 233 |
| 234 emit_header(gc->pc, rop, cmdlen); |
| 235 (void) memcpy((void *)(gc->pc + 4), ptr, 12); |
| 236 gc->pc += cmdlen; |
| 237 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer
(gc, gc->pc); } |
| 238 } |
| 239 |
| 240 static FASTCALL NOINLINE void |
| 241 generic_16_byte( GLint rop, const void * ptr ) |
| 242 { |
| 243 struct glx_context * const gc = __glXGetCurrentContext(); |
| 244 const GLuint cmdlen = 20; |
| 245 |
| 246 emit_header(gc->pc, rop, cmdlen); |
| 247 (void) memcpy((void *)(gc->pc + 4), ptr, 16); |
| 248 gc->pc += cmdlen; |
| 249 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer
(gc, gc->pc); } |
| 250 } |
| 251 |
| 252 static FASTCALL NOINLINE void |
| 253 generic_24_byte( GLint rop, const void * ptr ) |
| 254 { |
| 255 struct glx_context * const gc = __glXGetCurrentContext(); |
| 256 const GLuint cmdlen = 28; |
| 257 |
| 258 emit_header(gc->pc, rop, cmdlen); |
| 259 (void) memcpy((void *)(gc->pc + 4), ptr, 24); |
| 260 gc->pc += cmdlen; |
| 261 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer
(gc, gc->pc); } |
| 262 } |
| 263 |
| 264 static FASTCALL NOINLINE void |
| 265 generic_32_byte( GLint rop, const void * ptr ) |
| 266 { |
| 267 struct glx_context * const gc = __glXGetCurrentContext(); |
| 268 const GLuint cmdlen = 36; |
| 269 |
| 270 emit_header(gc->pc, rop, cmdlen); |
| 271 (void) memcpy((void *)(gc->pc + 4), ptr, 32); |
| 272 gc->pc += cmdlen; |
| 273 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer
(gc, gc->pc); } |
| 274 } |
| 275 |
| 276 #define X_GLsop_NewList 101 |
| 277 void __indirect_glNewList(GLuint list, GLenum mode) |
| 278 { |
| 279 struct glx_context * const gc = __glXGetCurrentContext(); |
| 280 Display * const dpy = gc->currentDpy; |
| 281 #ifndef USE_XCB |
| 282 const GLuint cmdlen = 8; |
| 283 #endif |
| 284 if (__builtin_expect(dpy != NULL, 1)) { |
| 285 #ifdef USE_XCB |
| 286 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 287 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 288 xcb_glx_new_list(c, gc->currentContextTag, list, mode); |
| 289 #else |
| 290 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_NewList, cmdlen
); |
| 291 (void) memcpy((void *)(pc + 0), (void *)(&list), 4); |
| 292 (void) memcpy((void *)(pc + 4), (void *)(&mode), 4); |
| 293 UnlockDisplay(dpy); SyncHandle(); |
| 294 #endif /* USE_XCB */ |
| 295 } |
| 296 return; |
| 297 } |
| 298 |
| 299 #define X_GLsop_EndList 102 |
| 300 void __indirect_glEndList(void) |
| 301 { |
| 302 struct glx_context * const gc = __glXGetCurrentContext(); |
| 303 Display * const dpy = gc->currentDpy; |
| 304 #ifndef USE_XCB |
| 305 const GLuint cmdlen = 0; |
| 306 #endif |
| 307 if (__builtin_expect(dpy != NULL, 1)) { |
| 308 #ifdef USE_XCB |
| 309 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 310 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 311 xcb_glx_end_list(c, gc->currentContextTag); |
| 312 #else |
| 313 (void) __glXSetupSingleRequest(gc, X_GLsop_EndList, cmdlen); |
| 314 UnlockDisplay(dpy); SyncHandle(); |
| 315 #endif /* USE_XCB */ |
| 316 } |
| 317 return; |
| 318 } |
| 319 |
| 320 #define X_GLrop_CallList 1 |
| 321 void __indirect_glCallList(GLuint list) |
| 322 { |
| 323 struct glx_context * const gc = __glXGetCurrentContext(); |
| 324 const GLuint cmdlen = 8; |
| 325 emit_header(gc->pc, X_GLrop_CallList, cmdlen); |
| 326 (void) memcpy((void *)(gc->pc + 4), (void *)(&list), 4); |
| 327 gc->pc += cmdlen; |
| 328 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 329 } |
| 330 |
| 331 #define X_GLrop_CallLists 2 |
| 332 void __indirect_glCallLists(GLsizei n, GLenum type, const GLvoid * lists) |
| 333 { |
| 334 struct glx_context * const gc = __glXGetCurrentContext(); |
| 335 const GLuint compsize = __glCallLists_size(type); |
| 336 const GLuint cmdlen = 12 + __GLX_PAD((compsize * n)); |
| 337 if (n < 0) { |
| 338 __glXSetError(gc, GL_INVALID_VALUE); |
| 339 return; |
| 340 } |
| 341 if (__builtin_expect((n >= 0) && (gc->currentDpy != NULL), 1)) { |
| 342 if (cmdlen <= gc->maxSmallRenderCommandSize) { |
| 343 if ( (gc->pc + cmdlen) > gc->bufEnd ) { |
| 344 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 345 } |
| 346 emit_header(gc->pc, X_GLrop_CallLists, cmdlen); |
| 347 (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4); |
| 348 (void) memcpy((void *)(gc->pc + 8), (void *)(&type), 4); |
| 349 (void) memcpy((void *)(gc->pc + 12), (void *)(lists), (compsize * n)); |
| 350 gc->pc += cmdlen; |
| 351 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 352 } |
| 353 else { |
| 354 const GLint op = X_GLrop_CallLists; |
| 355 const GLuint cmdlenLarge = cmdlen + 4; |
| 356 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); |
| 357 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); |
| 358 (void) memcpy((void *)(pc + 4), (void *)(&op), 4); |
| 359 (void) memcpy((void *)(pc + 8), (void *)(&n), 4); |
| 360 (void) memcpy((void *)(pc + 12), (void *)(&type), 4); |
| 361 __glXSendLargeCommand(gc, pc, 16, lists, (compsize * n)); |
| 362 } |
| 363 } |
| 364 } |
| 365 |
| 366 #define X_GLsop_DeleteLists 103 |
| 367 void __indirect_glDeleteLists(GLuint list, GLsizei range) |
| 368 { |
| 369 struct glx_context * const gc = __glXGetCurrentContext(); |
| 370 Display * const dpy = gc->currentDpy; |
| 371 #ifndef USE_XCB |
| 372 const GLuint cmdlen = 8; |
| 373 #endif |
| 374 if (__builtin_expect(dpy != NULL, 1)) { |
| 375 #ifdef USE_XCB |
| 376 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 377 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 378 xcb_glx_delete_lists(c, gc->currentContextTag, list, range); |
| 379 #else |
| 380 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_DeleteLists, cm
dlen); |
| 381 (void) memcpy((void *)(pc + 0), (void *)(&list), 4); |
| 382 (void) memcpy((void *)(pc + 4), (void *)(&range), 4); |
| 383 UnlockDisplay(dpy); SyncHandle(); |
| 384 #endif /* USE_XCB */ |
| 385 } |
| 386 return; |
| 387 } |
| 388 |
| 389 #define X_GLsop_GenLists 104 |
| 390 GLuint __indirect_glGenLists(GLsizei range) |
| 391 { |
| 392 struct glx_context * const gc = __glXGetCurrentContext(); |
| 393 Display * const dpy = gc->currentDpy; |
| 394 GLuint retval = (GLuint) 0; |
| 395 #ifndef USE_XCB |
| 396 const GLuint cmdlen = 4; |
| 397 #endif |
| 398 if (__builtin_expect(dpy != NULL, 1)) { |
| 399 #ifdef USE_XCB |
| 400 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 401 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 402 xcb_glx_gen_lists_reply_t *reply = xcb_glx_gen_lists_reply(c, xcb_glx_ge
n_lists(c, gc->currentContextTag, range), NULL); |
| 403 retval = reply->ret_val; |
| 404 free(reply); |
| 405 #else |
| 406 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenLists, cmdle
n); |
| 407 (void) memcpy((void *)(pc + 0), (void *)(&range), 4); |
| 408 retval = (GLuint) __glXReadReply(dpy, 0, NULL, GL_FALSE); |
| 409 UnlockDisplay(dpy); SyncHandle(); |
| 410 #endif /* USE_XCB */ |
| 411 } |
| 412 return retval; |
| 413 } |
| 414 |
| 415 #define X_GLrop_ListBase 3 |
| 416 void __indirect_glListBase(GLuint base) |
| 417 { |
| 418 struct glx_context * const gc = __glXGetCurrentContext(); |
| 419 const GLuint cmdlen = 8; |
| 420 emit_header(gc->pc, X_GLrop_ListBase, cmdlen); |
| 421 (void) memcpy((void *)(gc->pc + 4), (void *)(&base), 4); |
| 422 gc->pc += cmdlen; |
| 423 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 424 } |
| 425 |
| 426 #define X_GLrop_Begin 4 |
| 427 void __indirect_glBegin(GLenum mode) |
| 428 { |
| 429 struct glx_context * const gc = __glXGetCurrentContext(); |
| 430 const GLuint cmdlen = 8; |
| 431 emit_header(gc->pc, X_GLrop_Begin, cmdlen); |
| 432 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4); |
| 433 gc->pc += cmdlen; |
| 434 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 435 } |
| 436 |
| 437 #define X_GLrop_Bitmap 5 |
| 438 void __indirect_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat y
orig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap) |
| 439 { |
| 440 struct glx_context * const gc = __glXGetCurrentContext(); |
| 441 const GLuint compsize = (bitmap != NULL) ? __glImageSize(width, height, 1, G
L_COLOR_INDEX, GL_BITMAP, 0) : 0; |
| 442 const GLuint cmdlen = 48 + __GLX_PAD(compsize); |
| 443 if (__builtin_expect(gc->currentDpy != NULL, 1)) { |
| 444 if (cmdlen <= gc->maxSmallRenderCommandSize) { |
| 445 if ( (gc->pc + cmdlen) > gc->bufEnd ) { |
| 446 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 447 } |
| 448 emit_header(gc->pc, X_GLrop_Bitmap, cmdlen); |
| 449 (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4); |
| 450 (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4); |
| 451 (void) memcpy((void *)(gc->pc + 32), (void *)(&xorig), 4); |
| 452 (void) memcpy((void *)(gc->pc + 36), (void *)(&yorig), 4); |
| 453 (void) memcpy((void *)(gc->pc + 40), (void *)(&xmove), 4); |
| 454 (void) memcpy((void *)(gc->pc + 44), (void *)(&ymove), 4); |
| 455 if (compsize > 0) { |
| 456 (*gc->fillImage)(gc, 2, width, height, 1, GL_COLOR_INDEX, GL_BITMAP, bitmap,
gc->pc + 48, gc->pc + 4); |
| 457 } else { |
| 458 (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_si
ze ); |
| 459 } |
| 460 gc->pc += cmdlen; |
| 461 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } |
| 462 } |
| 463 else { |
| 464 const GLint op = X_GLrop_Bitmap; |
| 465 const GLuint cmdlenLarge = cmdlen + 4; |
| 466 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); |
| 467 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); |
| 468 (void) memcpy((void *)(pc + 4), (void *)(&op), 4); |
| 469 (void) memcpy((void *)(pc + 28), (void *)(&width), 4); |
| 470 (void) memcpy((void *)(pc + 32), (void *)(&height), 4); |
| 471 (void) memcpy((void *)(pc + 36), (void *)(&xorig), 4); |
| 472 (void) memcpy((void *)(pc + 40), (void *)(&yorig), 4); |
| 473 (void) memcpy((void *)(pc + 44), (void *)(&xmove), 4); |
| 474 (void) memcpy((void *)(pc + 48), (void *)(&ymove), 4); |
| 475 __glXSendLargeImage(gc, compsize, 2, width, height, 1, GL_COLOR_INDEX, GL_BITMAP
, bitmap, pc + 52, pc + 8); |
| 476 } |
| 477 } |
| 478 } |
| 479 |
| 480 #define X_GLrop_Color3bv 6 |
| 481 void __indirect_glColor3b(GLbyte red, GLbyte green, GLbyte blue) |
| 482 { |
| 483 struct glx_context * const gc = __glXGetCurrentContext(); |
| 484 const GLuint cmdlen = 8; |
| 485 emit_header(gc->pc, X_GLrop_Color3bv, cmdlen); |
| 486 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1); |
| 487 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1); |
| 488 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1); |
| 489 gc->pc += cmdlen; |
| 490 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 491 } |
| 492 |
| 493 #define X_GLrop_Color3bv 6 |
| 494 void __indirect_glColor3bv(const GLbyte * v) |
| 495 { |
| 496 generic_3_byte( X_GLrop_Color3bv, v ); |
| 497 } |
| 498 |
| 499 #define X_GLrop_Color3dv 7 |
| 500 void __indirect_glColor3d(GLdouble red, GLdouble green, GLdouble blue) |
| 501 { |
| 502 struct glx_context * const gc = __glXGetCurrentContext(); |
| 503 const GLuint cmdlen = 28; |
| 504 emit_header(gc->pc, X_GLrop_Color3dv, cmdlen); |
| 505 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8); |
| 506 (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8); |
| 507 (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8); |
| 508 gc->pc += cmdlen; |
| 509 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 510 } |
| 511 |
| 512 #define X_GLrop_Color3dv 7 |
| 513 void __indirect_glColor3dv(const GLdouble * v) |
| 514 { |
| 515 generic_24_byte( X_GLrop_Color3dv, v ); |
| 516 } |
| 517 |
| 518 #define X_GLrop_Color3fv 8 |
| 519 void __indirect_glColor3f(GLfloat red, GLfloat green, GLfloat blue) |
| 520 { |
| 521 struct glx_context * const gc = __glXGetCurrentContext(); |
| 522 const GLuint cmdlen = 16; |
| 523 emit_header(gc->pc, X_GLrop_Color3fv, cmdlen); |
| 524 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); |
| 525 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); |
| 526 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); |
| 527 gc->pc += cmdlen; |
| 528 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 529 } |
| 530 |
| 531 #define X_GLrop_Color3fv 8 |
| 532 void __indirect_glColor3fv(const GLfloat * v) |
| 533 { |
| 534 generic_12_byte( X_GLrop_Color3fv, v ); |
| 535 } |
| 536 |
| 537 #define X_GLrop_Color3iv 9 |
| 538 void __indirect_glColor3i(GLint red, GLint green, GLint blue) |
| 539 { |
| 540 struct glx_context * const gc = __glXGetCurrentContext(); |
| 541 const GLuint cmdlen = 16; |
| 542 emit_header(gc->pc, X_GLrop_Color3iv, cmdlen); |
| 543 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); |
| 544 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); |
| 545 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); |
| 546 gc->pc += cmdlen; |
| 547 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 548 } |
| 549 |
| 550 #define X_GLrop_Color3iv 9 |
| 551 void __indirect_glColor3iv(const GLint * v) |
| 552 { |
| 553 generic_12_byte( X_GLrop_Color3iv, v ); |
| 554 } |
| 555 |
| 556 #define X_GLrop_Color3sv 10 |
| 557 void __indirect_glColor3s(GLshort red, GLshort green, GLshort blue) |
| 558 { |
| 559 struct glx_context * const gc = __glXGetCurrentContext(); |
| 560 const GLuint cmdlen = 12; |
| 561 emit_header(gc->pc, X_GLrop_Color3sv, cmdlen); |
| 562 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2); |
| 563 (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2); |
| 564 (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2); |
| 565 gc->pc += cmdlen; |
| 566 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 567 } |
| 568 |
| 569 #define X_GLrop_Color3sv 10 |
| 570 void __indirect_glColor3sv(const GLshort * v) |
| 571 { |
| 572 generic_6_byte( X_GLrop_Color3sv, v ); |
| 573 } |
| 574 |
| 575 #define X_GLrop_Color3ubv 11 |
| 576 void __indirect_glColor3ub(GLubyte red, GLubyte green, GLubyte blue) |
| 577 { |
| 578 struct glx_context * const gc = __glXGetCurrentContext(); |
| 579 const GLuint cmdlen = 8; |
| 580 emit_header(gc->pc, X_GLrop_Color3ubv, cmdlen); |
| 581 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1); |
| 582 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1); |
| 583 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1); |
| 584 gc->pc += cmdlen; |
| 585 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 586 } |
| 587 |
| 588 #define X_GLrop_Color3ubv 11 |
| 589 void __indirect_glColor3ubv(const GLubyte * v) |
| 590 { |
| 591 generic_3_byte( X_GLrop_Color3ubv, v ); |
| 592 } |
| 593 |
| 594 #define X_GLrop_Color3uiv 12 |
| 595 void __indirect_glColor3ui(GLuint red, GLuint green, GLuint blue) |
| 596 { |
| 597 struct glx_context * const gc = __glXGetCurrentContext(); |
| 598 const GLuint cmdlen = 16; |
| 599 emit_header(gc->pc, X_GLrop_Color3uiv, cmdlen); |
| 600 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); |
| 601 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); |
| 602 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); |
| 603 gc->pc += cmdlen; |
| 604 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 605 } |
| 606 |
| 607 #define X_GLrop_Color3uiv 12 |
| 608 void __indirect_glColor3uiv(const GLuint * v) |
| 609 { |
| 610 generic_12_byte( X_GLrop_Color3uiv, v ); |
| 611 } |
| 612 |
| 613 #define X_GLrop_Color3usv 13 |
| 614 void __indirect_glColor3us(GLushort red, GLushort green, GLushort blue) |
| 615 { |
| 616 struct glx_context * const gc = __glXGetCurrentContext(); |
| 617 const GLuint cmdlen = 12; |
| 618 emit_header(gc->pc, X_GLrop_Color3usv, cmdlen); |
| 619 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2); |
| 620 (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2); |
| 621 (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2); |
| 622 gc->pc += cmdlen; |
| 623 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 624 } |
| 625 |
| 626 #define X_GLrop_Color3usv 13 |
| 627 void __indirect_glColor3usv(const GLushort * v) |
| 628 { |
| 629 generic_6_byte( X_GLrop_Color3usv, v ); |
| 630 } |
| 631 |
| 632 #define X_GLrop_Color4bv 14 |
| 633 void __indirect_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) |
| 634 { |
| 635 struct glx_context * const gc = __glXGetCurrentContext(); |
| 636 const GLuint cmdlen = 8; |
| 637 emit_header(gc->pc, X_GLrop_Color4bv, cmdlen); |
| 638 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1); |
| 639 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1); |
| 640 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1); |
| 641 (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1); |
| 642 gc->pc += cmdlen; |
| 643 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 644 } |
| 645 |
| 646 #define X_GLrop_Color4bv 14 |
| 647 void __indirect_glColor4bv(const GLbyte * v) |
| 648 { |
| 649 generic_4_byte( X_GLrop_Color4bv, v ); |
| 650 } |
| 651 |
| 652 #define X_GLrop_Color4dv 15 |
| 653 void __indirect_glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble
alpha) |
| 654 { |
| 655 struct glx_context * const gc = __glXGetCurrentContext(); |
| 656 const GLuint cmdlen = 36; |
| 657 emit_header(gc->pc, X_GLrop_Color4dv, cmdlen); |
| 658 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8); |
| 659 (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8); |
| 660 (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8); |
| 661 (void) memcpy((void *)(gc->pc + 28), (void *)(&alpha), 8); |
| 662 gc->pc += cmdlen; |
| 663 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 664 } |
| 665 |
| 666 #define X_GLrop_Color4dv 15 |
| 667 void __indirect_glColor4dv(const GLdouble * v) |
| 668 { |
| 669 generic_32_byte( X_GLrop_Color4dv, v ); |
| 670 } |
| 671 |
| 672 #define X_GLrop_Color4fv 16 |
| 673 void __indirect_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alph
a) |
| 674 { |
| 675 struct glx_context * const gc = __glXGetCurrentContext(); |
| 676 const GLuint cmdlen = 20; |
| 677 emit_header(gc->pc, X_GLrop_Color4fv, cmdlen); |
| 678 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); |
| 679 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); |
| 680 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); |
| 681 (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4); |
| 682 gc->pc += cmdlen; |
| 683 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 684 } |
| 685 |
| 686 #define X_GLrop_Color4fv 16 |
| 687 void __indirect_glColor4fv(const GLfloat * v) |
| 688 { |
| 689 generic_16_byte( X_GLrop_Color4fv, v ); |
| 690 } |
| 691 |
| 692 #define X_GLrop_Color4iv 17 |
| 693 void __indirect_glColor4i(GLint red, GLint green, GLint blue, GLint alpha) |
| 694 { |
| 695 struct glx_context * const gc = __glXGetCurrentContext(); |
| 696 const GLuint cmdlen = 20; |
| 697 emit_header(gc->pc, X_GLrop_Color4iv, cmdlen); |
| 698 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); |
| 699 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); |
| 700 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); |
| 701 (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4); |
| 702 gc->pc += cmdlen; |
| 703 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 704 } |
| 705 |
| 706 #define X_GLrop_Color4iv 17 |
| 707 void __indirect_glColor4iv(const GLint * v) |
| 708 { |
| 709 generic_16_byte( X_GLrop_Color4iv, v ); |
| 710 } |
| 711 |
| 712 #define X_GLrop_Color4sv 18 |
| 713 void __indirect_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alph
a) |
| 714 { |
| 715 struct glx_context * const gc = __glXGetCurrentContext(); |
| 716 const GLuint cmdlen = 12; |
| 717 emit_header(gc->pc, X_GLrop_Color4sv, cmdlen); |
| 718 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2); |
| 719 (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2); |
| 720 (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2); |
| 721 (void) memcpy((void *)(gc->pc + 10), (void *)(&alpha), 2); |
| 722 gc->pc += cmdlen; |
| 723 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 724 } |
| 725 |
| 726 #define X_GLrop_Color4sv 18 |
| 727 void __indirect_glColor4sv(const GLshort * v) |
| 728 { |
| 729 generic_8_byte( X_GLrop_Color4sv, v ); |
| 730 } |
| 731 |
| 732 #define X_GLrop_Color4ubv 19 |
| 733 void __indirect_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alp
ha) |
| 734 { |
| 735 struct glx_context * const gc = __glXGetCurrentContext(); |
| 736 const GLuint cmdlen = 8; |
| 737 emit_header(gc->pc, X_GLrop_Color4ubv, cmdlen); |
| 738 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1); |
| 739 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1); |
| 740 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1); |
| 741 (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1); |
| 742 gc->pc += cmdlen; |
| 743 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 744 } |
| 745 |
| 746 #define X_GLrop_Color4ubv 19 |
| 747 void __indirect_glColor4ubv(const GLubyte * v) |
| 748 { |
| 749 generic_4_byte( X_GLrop_Color4ubv, v ); |
| 750 } |
| 751 |
| 752 #define X_GLrop_Color4uiv 20 |
| 753 void __indirect_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha) |
| 754 { |
| 755 struct glx_context * const gc = __glXGetCurrentContext(); |
| 756 const GLuint cmdlen = 20; |
| 757 emit_header(gc->pc, X_GLrop_Color4uiv, cmdlen); |
| 758 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); |
| 759 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); |
| 760 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); |
| 761 (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4); |
| 762 gc->pc += cmdlen; |
| 763 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 764 } |
| 765 |
| 766 #define X_GLrop_Color4uiv 20 |
| 767 void __indirect_glColor4uiv(const GLuint * v) |
| 768 { |
| 769 generic_16_byte( X_GLrop_Color4uiv, v ); |
| 770 } |
| 771 |
| 772 #define X_GLrop_Color4usv 21 |
| 773 void __indirect_glColor4us(GLushort red, GLushort green, GLushort blue, GLushort
alpha) |
| 774 { |
| 775 struct glx_context * const gc = __glXGetCurrentContext(); |
| 776 const GLuint cmdlen = 12; |
| 777 emit_header(gc->pc, X_GLrop_Color4usv, cmdlen); |
| 778 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2); |
| 779 (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2); |
| 780 (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2); |
| 781 (void) memcpy((void *)(gc->pc + 10), (void *)(&alpha), 2); |
| 782 gc->pc += cmdlen; |
| 783 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 784 } |
| 785 |
| 786 #define X_GLrop_Color4usv 21 |
| 787 void __indirect_glColor4usv(const GLushort * v) |
| 788 { |
| 789 generic_8_byte( X_GLrop_Color4usv, v ); |
| 790 } |
| 791 |
| 792 #define X_GLrop_EdgeFlagv 22 |
| 793 void __indirect_glEdgeFlag(GLboolean flag) |
| 794 { |
| 795 struct glx_context * const gc = __glXGetCurrentContext(); |
| 796 const GLuint cmdlen = 8; |
| 797 emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen); |
| 798 (void) memcpy((void *)(gc->pc + 4), (void *)(&flag), 1); |
| 799 gc->pc += cmdlen; |
| 800 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 801 } |
| 802 |
| 803 #define X_GLrop_EdgeFlagv 22 |
| 804 void __indirect_glEdgeFlagv(const GLboolean * flag) |
| 805 { |
| 806 struct glx_context * const gc = __glXGetCurrentContext(); |
| 807 const GLuint cmdlen = 8; |
| 808 emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen); |
| 809 (void) memcpy((void *)(gc->pc + 4), (void *)(flag), 1); |
| 810 gc->pc += cmdlen; |
| 811 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 812 } |
| 813 |
| 814 #define X_GLrop_End 23 |
| 815 void __indirect_glEnd(void) |
| 816 { |
| 817 struct glx_context * const gc = __glXGetCurrentContext(); |
| 818 const GLuint cmdlen = 4; |
| 819 emit_header(gc->pc, X_GLrop_End, cmdlen); |
| 820 gc->pc += cmdlen; |
| 821 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 822 } |
| 823 |
| 824 #define X_GLrop_Indexdv 24 |
| 825 void __indirect_glIndexd(GLdouble c) |
| 826 { |
| 827 struct glx_context * const gc = __glXGetCurrentContext(); |
| 828 const GLuint cmdlen = 12; |
| 829 emit_header(gc->pc, X_GLrop_Indexdv, cmdlen); |
| 830 (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 8); |
| 831 gc->pc += cmdlen; |
| 832 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 833 } |
| 834 |
| 835 #define X_GLrop_Indexdv 24 |
| 836 void __indirect_glIndexdv(const GLdouble * c) |
| 837 { |
| 838 generic_8_byte( X_GLrop_Indexdv, c ); |
| 839 } |
| 840 |
| 841 #define X_GLrop_Indexfv 25 |
| 842 void __indirect_glIndexf(GLfloat c) |
| 843 { |
| 844 struct glx_context * const gc = __glXGetCurrentContext(); |
| 845 const GLuint cmdlen = 8; |
| 846 emit_header(gc->pc, X_GLrop_Indexfv, cmdlen); |
| 847 (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4); |
| 848 gc->pc += cmdlen; |
| 849 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 850 } |
| 851 |
| 852 #define X_GLrop_Indexfv 25 |
| 853 void __indirect_glIndexfv(const GLfloat * c) |
| 854 { |
| 855 generic_4_byte( X_GLrop_Indexfv, c ); |
| 856 } |
| 857 |
| 858 #define X_GLrop_Indexiv 26 |
| 859 void __indirect_glIndexi(GLint c) |
| 860 { |
| 861 struct glx_context * const gc = __glXGetCurrentContext(); |
| 862 const GLuint cmdlen = 8; |
| 863 emit_header(gc->pc, X_GLrop_Indexiv, cmdlen); |
| 864 (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4); |
| 865 gc->pc += cmdlen; |
| 866 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 867 } |
| 868 |
| 869 #define X_GLrop_Indexiv 26 |
| 870 void __indirect_glIndexiv(const GLint * c) |
| 871 { |
| 872 generic_4_byte( X_GLrop_Indexiv, c ); |
| 873 } |
| 874 |
| 875 #define X_GLrop_Indexsv 27 |
| 876 void __indirect_glIndexs(GLshort c) |
| 877 { |
| 878 struct glx_context * const gc = __glXGetCurrentContext(); |
| 879 const GLuint cmdlen = 8; |
| 880 emit_header(gc->pc, X_GLrop_Indexsv, cmdlen); |
| 881 (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 2); |
| 882 gc->pc += cmdlen; |
| 883 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 884 } |
| 885 |
| 886 #define X_GLrop_Indexsv 27 |
| 887 void __indirect_glIndexsv(const GLshort * c) |
| 888 { |
| 889 struct glx_context * const gc = __glXGetCurrentContext(); |
| 890 const GLuint cmdlen = 8; |
| 891 emit_header(gc->pc, X_GLrop_Indexsv, cmdlen); |
| 892 (void) memcpy((void *)(gc->pc + 4), (void *)(c), 2); |
| 893 gc->pc += cmdlen; |
| 894 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 895 } |
| 896 |
| 897 #define X_GLrop_Normal3bv 28 |
| 898 void __indirect_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz) |
| 899 { |
| 900 struct glx_context * const gc = __glXGetCurrentContext(); |
| 901 const GLuint cmdlen = 8; |
| 902 emit_header(gc->pc, X_GLrop_Normal3bv, cmdlen); |
| 903 (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 1); |
| 904 (void) memcpy((void *)(gc->pc + 5), (void *)(&ny), 1); |
| 905 (void) memcpy((void *)(gc->pc + 6), (void *)(&nz), 1); |
| 906 gc->pc += cmdlen; |
| 907 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 908 } |
| 909 |
| 910 #define X_GLrop_Normal3bv 28 |
| 911 void __indirect_glNormal3bv(const GLbyte * v) |
| 912 { |
| 913 generic_3_byte( X_GLrop_Normal3bv, v ); |
| 914 } |
| 915 |
| 916 #define X_GLrop_Normal3dv 29 |
| 917 void __indirect_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz) |
| 918 { |
| 919 struct glx_context * const gc = __glXGetCurrentContext(); |
| 920 const GLuint cmdlen = 28; |
| 921 emit_header(gc->pc, X_GLrop_Normal3dv, cmdlen); |
| 922 (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 8); |
| 923 (void) memcpy((void *)(gc->pc + 12), (void *)(&ny), 8); |
| 924 (void) memcpy((void *)(gc->pc + 20), (void *)(&nz), 8); |
| 925 gc->pc += cmdlen; |
| 926 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 927 } |
| 928 |
| 929 #define X_GLrop_Normal3dv 29 |
| 930 void __indirect_glNormal3dv(const GLdouble * v) |
| 931 { |
| 932 generic_24_byte( X_GLrop_Normal3dv, v ); |
| 933 } |
| 934 |
| 935 #define X_GLrop_Normal3fv 30 |
| 936 void __indirect_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) |
| 937 { |
| 938 struct glx_context * const gc = __glXGetCurrentContext(); |
| 939 const GLuint cmdlen = 16; |
| 940 emit_header(gc->pc, X_GLrop_Normal3fv, cmdlen); |
| 941 (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 4); |
| 942 (void) memcpy((void *)(gc->pc + 8), (void *)(&ny), 4); |
| 943 (void) memcpy((void *)(gc->pc + 12), (void *)(&nz), 4); |
| 944 gc->pc += cmdlen; |
| 945 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 946 } |
| 947 |
| 948 #define X_GLrop_Normal3fv 30 |
| 949 void __indirect_glNormal3fv(const GLfloat * v) |
| 950 { |
| 951 generic_12_byte( X_GLrop_Normal3fv, v ); |
| 952 } |
| 953 |
| 954 #define X_GLrop_Normal3iv 31 |
| 955 void __indirect_glNormal3i(GLint nx, GLint ny, GLint nz) |
| 956 { |
| 957 struct glx_context * const gc = __glXGetCurrentContext(); |
| 958 const GLuint cmdlen = 16; |
| 959 emit_header(gc->pc, X_GLrop_Normal3iv, cmdlen); |
| 960 (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 4); |
| 961 (void) memcpy((void *)(gc->pc + 8), (void *)(&ny), 4); |
| 962 (void) memcpy((void *)(gc->pc + 12), (void *)(&nz), 4); |
| 963 gc->pc += cmdlen; |
| 964 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 965 } |
| 966 |
| 967 #define X_GLrop_Normal3iv 31 |
| 968 void __indirect_glNormal3iv(const GLint * v) |
| 969 { |
| 970 generic_12_byte( X_GLrop_Normal3iv, v ); |
| 971 } |
| 972 |
| 973 #define X_GLrop_Normal3sv 32 |
| 974 void __indirect_glNormal3s(GLshort nx, GLshort ny, GLshort nz) |
| 975 { |
| 976 struct glx_context * const gc = __glXGetCurrentContext(); |
| 977 const GLuint cmdlen = 12; |
| 978 emit_header(gc->pc, X_GLrop_Normal3sv, cmdlen); |
| 979 (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 2); |
| 980 (void) memcpy((void *)(gc->pc + 6), (void *)(&ny), 2); |
| 981 (void) memcpy((void *)(gc->pc + 8), (void *)(&nz), 2); |
| 982 gc->pc += cmdlen; |
| 983 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 984 } |
| 985 |
| 986 #define X_GLrop_Normal3sv 32 |
| 987 void __indirect_glNormal3sv(const GLshort * v) |
| 988 { |
| 989 generic_6_byte( X_GLrop_Normal3sv, v ); |
| 990 } |
| 991 |
| 992 #define X_GLrop_RasterPos2dv 33 |
| 993 void __indirect_glRasterPos2d(GLdouble x, GLdouble y) |
| 994 { |
| 995 struct glx_context * const gc = __glXGetCurrentContext(); |
| 996 const GLuint cmdlen = 20; |
| 997 emit_header(gc->pc, X_GLrop_RasterPos2dv, cmdlen); |
| 998 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8); |
| 999 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8); |
| 1000 gc->pc += cmdlen; |
| 1001 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1002 } |
| 1003 |
| 1004 #define X_GLrop_RasterPos2dv 33 |
| 1005 void __indirect_glRasterPos2dv(const GLdouble * v) |
| 1006 { |
| 1007 generic_16_byte( X_GLrop_RasterPos2dv, v ); |
| 1008 } |
| 1009 |
| 1010 #define X_GLrop_RasterPos2fv 34 |
| 1011 void __indirect_glRasterPos2f(GLfloat x, GLfloat y) |
| 1012 { |
| 1013 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1014 const GLuint cmdlen = 12; |
| 1015 emit_header(gc->pc, X_GLrop_RasterPos2fv, cmdlen); |
| 1016 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); |
| 1017 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); |
| 1018 gc->pc += cmdlen; |
| 1019 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1020 } |
| 1021 |
| 1022 #define X_GLrop_RasterPos2fv 34 |
| 1023 void __indirect_glRasterPos2fv(const GLfloat * v) |
| 1024 { |
| 1025 generic_8_byte( X_GLrop_RasterPos2fv, v ); |
| 1026 } |
| 1027 |
| 1028 #define X_GLrop_RasterPos2iv 35 |
| 1029 void __indirect_glRasterPos2i(GLint x, GLint y) |
| 1030 { |
| 1031 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1032 const GLuint cmdlen = 12; |
| 1033 emit_header(gc->pc, X_GLrop_RasterPos2iv, cmdlen); |
| 1034 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); |
| 1035 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); |
| 1036 gc->pc += cmdlen; |
| 1037 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1038 } |
| 1039 |
| 1040 #define X_GLrop_RasterPos2iv 35 |
| 1041 void __indirect_glRasterPos2iv(const GLint * v) |
| 1042 { |
| 1043 generic_8_byte( X_GLrop_RasterPos2iv, v ); |
| 1044 } |
| 1045 |
| 1046 #define X_GLrop_RasterPos2sv 36 |
| 1047 void __indirect_glRasterPos2s(GLshort x, GLshort y) |
| 1048 { |
| 1049 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1050 const GLuint cmdlen = 8; |
| 1051 emit_header(gc->pc, X_GLrop_RasterPos2sv, cmdlen); |
| 1052 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2); |
| 1053 (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2); |
| 1054 gc->pc += cmdlen; |
| 1055 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1056 } |
| 1057 |
| 1058 #define X_GLrop_RasterPos2sv 36 |
| 1059 void __indirect_glRasterPos2sv(const GLshort * v) |
| 1060 { |
| 1061 generic_4_byte( X_GLrop_RasterPos2sv, v ); |
| 1062 } |
| 1063 |
| 1064 #define X_GLrop_RasterPos3dv 37 |
| 1065 void __indirect_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z) |
| 1066 { |
| 1067 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1068 const GLuint cmdlen = 28; |
| 1069 emit_header(gc->pc, X_GLrop_RasterPos3dv, cmdlen); |
| 1070 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8); |
| 1071 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8); |
| 1072 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8); |
| 1073 gc->pc += cmdlen; |
| 1074 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1075 } |
| 1076 |
| 1077 #define X_GLrop_RasterPos3dv 37 |
| 1078 void __indirect_glRasterPos3dv(const GLdouble * v) |
| 1079 { |
| 1080 generic_24_byte( X_GLrop_RasterPos3dv, v ); |
| 1081 } |
| 1082 |
| 1083 #define X_GLrop_RasterPos3fv 38 |
| 1084 void __indirect_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z) |
| 1085 { |
| 1086 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1087 const GLuint cmdlen = 16; |
| 1088 emit_header(gc->pc, X_GLrop_RasterPos3fv, cmdlen); |
| 1089 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); |
| 1090 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); |
| 1091 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); |
| 1092 gc->pc += cmdlen; |
| 1093 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1094 } |
| 1095 |
| 1096 #define X_GLrop_RasterPos3fv 38 |
| 1097 void __indirect_glRasterPos3fv(const GLfloat * v) |
| 1098 { |
| 1099 generic_12_byte( X_GLrop_RasterPos3fv, v ); |
| 1100 } |
| 1101 |
| 1102 #define X_GLrop_RasterPos3iv 39 |
| 1103 void __indirect_glRasterPos3i(GLint x, GLint y, GLint z) |
| 1104 { |
| 1105 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1106 const GLuint cmdlen = 16; |
| 1107 emit_header(gc->pc, X_GLrop_RasterPos3iv, cmdlen); |
| 1108 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); |
| 1109 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); |
| 1110 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); |
| 1111 gc->pc += cmdlen; |
| 1112 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1113 } |
| 1114 |
| 1115 #define X_GLrop_RasterPos3iv 39 |
| 1116 void __indirect_glRasterPos3iv(const GLint * v) |
| 1117 { |
| 1118 generic_12_byte( X_GLrop_RasterPos3iv, v ); |
| 1119 } |
| 1120 |
| 1121 #define X_GLrop_RasterPos3sv 40 |
| 1122 void __indirect_glRasterPos3s(GLshort x, GLshort y, GLshort z) |
| 1123 { |
| 1124 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1125 const GLuint cmdlen = 12; |
| 1126 emit_header(gc->pc, X_GLrop_RasterPos3sv, cmdlen); |
| 1127 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2); |
| 1128 (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2); |
| 1129 (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2); |
| 1130 gc->pc += cmdlen; |
| 1131 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1132 } |
| 1133 |
| 1134 #define X_GLrop_RasterPos3sv 40 |
| 1135 void __indirect_glRasterPos3sv(const GLshort * v) |
| 1136 { |
| 1137 generic_6_byte( X_GLrop_RasterPos3sv, v ); |
| 1138 } |
| 1139 |
| 1140 #define X_GLrop_RasterPos4dv 41 |
| 1141 void __indirect_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) |
| 1142 { |
| 1143 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1144 const GLuint cmdlen = 36; |
| 1145 emit_header(gc->pc, X_GLrop_RasterPos4dv, cmdlen); |
| 1146 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8); |
| 1147 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8); |
| 1148 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8); |
| 1149 (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8); |
| 1150 gc->pc += cmdlen; |
| 1151 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1152 } |
| 1153 |
| 1154 #define X_GLrop_RasterPos4dv 41 |
| 1155 void __indirect_glRasterPos4dv(const GLdouble * v) |
| 1156 { |
| 1157 generic_32_byte( X_GLrop_RasterPos4dv, v ); |
| 1158 } |
| 1159 |
| 1160 #define X_GLrop_RasterPos4fv 42 |
| 1161 void __indirect_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) |
| 1162 { |
| 1163 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1164 const GLuint cmdlen = 20; |
| 1165 emit_header(gc->pc, X_GLrop_RasterPos4fv, cmdlen); |
| 1166 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); |
| 1167 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); |
| 1168 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); |
| 1169 (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4); |
| 1170 gc->pc += cmdlen; |
| 1171 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1172 } |
| 1173 |
| 1174 #define X_GLrop_RasterPos4fv 42 |
| 1175 void __indirect_glRasterPos4fv(const GLfloat * v) |
| 1176 { |
| 1177 generic_16_byte( X_GLrop_RasterPos4fv, v ); |
| 1178 } |
| 1179 |
| 1180 #define X_GLrop_RasterPos4iv 43 |
| 1181 void __indirect_glRasterPos4i(GLint x, GLint y, GLint z, GLint w) |
| 1182 { |
| 1183 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1184 const GLuint cmdlen = 20; |
| 1185 emit_header(gc->pc, X_GLrop_RasterPos4iv, cmdlen); |
| 1186 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); |
| 1187 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); |
| 1188 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); |
| 1189 (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4); |
| 1190 gc->pc += cmdlen; |
| 1191 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1192 } |
| 1193 |
| 1194 #define X_GLrop_RasterPos4iv 43 |
| 1195 void __indirect_glRasterPos4iv(const GLint * v) |
| 1196 { |
| 1197 generic_16_byte( X_GLrop_RasterPos4iv, v ); |
| 1198 } |
| 1199 |
| 1200 #define X_GLrop_RasterPos4sv 44 |
| 1201 void __indirect_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w) |
| 1202 { |
| 1203 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1204 const GLuint cmdlen = 12; |
| 1205 emit_header(gc->pc, X_GLrop_RasterPos4sv, cmdlen); |
| 1206 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2); |
| 1207 (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2); |
| 1208 (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2); |
| 1209 (void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2); |
| 1210 gc->pc += cmdlen; |
| 1211 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1212 } |
| 1213 |
| 1214 #define X_GLrop_RasterPos4sv 44 |
| 1215 void __indirect_glRasterPos4sv(const GLshort * v) |
| 1216 { |
| 1217 generic_8_byte( X_GLrop_RasterPos4sv, v ); |
| 1218 } |
| 1219 |
| 1220 #define X_GLrop_Rectdv 45 |
| 1221 void __indirect_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) |
| 1222 { |
| 1223 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1224 const GLuint cmdlen = 36; |
| 1225 emit_header(gc->pc, X_GLrop_Rectdv, cmdlen); |
| 1226 (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 8); |
| 1227 (void) memcpy((void *)(gc->pc + 12), (void *)(&y1), 8); |
| 1228 (void) memcpy((void *)(gc->pc + 20), (void *)(&x2), 8); |
| 1229 (void) memcpy((void *)(gc->pc + 28), (void *)(&y2), 8); |
| 1230 gc->pc += cmdlen; |
| 1231 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1232 } |
| 1233 |
| 1234 #define X_GLrop_Rectdv 45 |
| 1235 void __indirect_glRectdv(const GLdouble * v1, const GLdouble * v2) |
| 1236 { |
| 1237 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1238 const GLuint cmdlen = 36; |
| 1239 emit_header(gc->pc, X_GLrop_Rectdv, cmdlen); |
| 1240 (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 16); |
| 1241 (void) memcpy((void *)(gc->pc + 20), (void *)(v2), 16); |
| 1242 gc->pc += cmdlen; |
| 1243 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1244 } |
| 1245 |
| 1246 #define X_GLrop_Rectfv 46 |
| 1247 void __indirect_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) |
| 1248 { |
| 1249 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1250 const GLuint cmdlen = 20; |
| 1251 emit_header(gc->pc, X_GLrop_Rectfv, cmdlen); |
| 1252 (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 4); |
| 1253 (void) memcpy((void *)(gc->pc + 8), (void *)(&y1), 4); |
| 1254 (void) memcpy((void *)(gc->pc + 12), (void *)(&x2), 4); |
| 1255 (void) memcpy((void *)(gc->pc + 16), (void *)(&y2), 4); |
| 1256 gc->pc += cmdlen; |
| 1257 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1258 } |
| 1259 |
| 1260 #define X_GLrop_Rectfv 46 |
| 1261 void __indirect_glRectfv(const GLfloat * v1, const GLfloat * v2) |
| 1262 { |
| 1263 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1264 const GLuint cmdlen = 20; |
| 1265 emit_header(gc->pc, X_GLrop_Rectfv, cmdlen); |
| 1266 (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 8); |
| 1267 (void) memcpy((void *)(gc->pc + 12), (void *)(v2), 8); |
| 1268 gc->pc += cmdlen; |
| 1269 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1270 } |
| 1271 |
| 1272 #define X_GLrop_Rectiv 47 |
| 1273 void __indirect_glRecti(GLint x1, GLint y1, GLint x2, GLint y2) |
| 1274 { |
| 1275 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1276 const GLuint cmdlen = 20; |
| 1277 emit_header(gc->pc, X_GLrop_Rectiv, cmdlen); |
| 1278 (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 4); |
| 1279 (void) memcpy((void *)(gc->pc + 8), (void *)(&y1), 4); |
| 1280 (void) memcpy((void *)(gc->pc + 12), (void *)(&x2), 4); |
| 1281 (void) memcpy((void *)(gc->pc + 16), (void *)(&y2), 4); |
| 1282 gc->pc += cmdlen; |
| 1283 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1284 } |
| 1285 |
| 1286 #define X_GLrop_Rectiv 47 |
| 1287 void __indirect_glRectiv(const GLint * v1, const GLint * v2) |
| 1288 { |
| 1289 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1290 const GLuint cmdlen = 20; |
| 1291 emit_header(gc->pc, X_GLrop_Rectiv, cmdlen); |
| 1292 (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 8); |
| 1293 (void) memcpy((void *)(gc->pc + 12), (void *)(v2), 8); |
| 1294 gc->pc += cmdlen; |
| 1295 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1296 } |
| 1297 |
| 1298 #define X_GLrop_Rectsv 48 |
| 1299 void __indirect_glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2) |
| 1300 { |
| 1301 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1302 const GLuint cmdlen = 12; |
| 1303 emit_header(gc->pc, X_GLrop_Rectsv, cmdlen); |
| 1304 (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 2); |
| 1305 (void) memcpy((void *)(gc->pc + 6), (void *)(&y1), 2); |
| 1306 (void) memcpy((void *)(gc->pc + 8), (void *)(&x2), 2); |
| 1307 (void) memcpy((void *)(gc->pc + 10), (void *)(&y2), 2); |
| 1308 gc->pc += cmdlen; |
| 1309 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1310 } |
| 1311 |
| 1312 #define X_GLrop_Rectsv 48 |
| 1313 void __indirect_glRectsv(const GLshort * v1, const GLshort * v2) |
| 1314 { |
| 1315 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1316 const GLuint cmdlen = 12; |
| 1317 emit_header(gc->pc, X_GLrop_Rectsv, cmdlen); |
| 1318 (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 4); |
| 1319 (void) memcpy((void *)(gc->pc + 8), (void *)(v2), 4); |
| 1320 gc->pc += cmdlen; |
| 1321 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1322 } |
| 1323 |
| 1324 #define X_GLrop_TexCoord1dv 49 |
| 1325 void __indirect_glTexCoord1d(GLdouble s) |
| 1326 { |
| 1327 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1328 const GLuint cmdlen = 12; |
| 1329 emit_header(gc->pc, X_GLrop_TexCoord1dv, cmdlen); |
| 1330 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8); |
| 1331 gc->pc += cmdlen; |
| 1332 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1333 } |
| 1334 |
| 1335 #define X_GLrop_TexCoord1dv 49 |
| 1336 void __indirect_glTexCoord1dv(const GLdouble * v) |
| 1337 { |
| 1338 generic_8_byte( X_GLrop_TexCoord1dv, v ); |
| 1339 } |
| 1340 |
| 1341 #define X_GLrop_TexCoord1fv 50 |
| 1342 void __indirect_glTexCoord1f(GLfloat s) |
| 1343 { |
| 1344 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1345 const GLuint cmdlen = 8; |
| 1346 emit_header(gc->pc, X_GLrop_TexCoord1fv, cmdlen); |
| 1347 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4); |
| 1348 gc->pc += cmdlen; |
| 1349 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1350 } |
| 1351 |
| 1352 #define X_GLrop_TexCoord1fv 50 |
| 1353 void __indirect_glTexCoord1fv(const GLfloat * v) |
| 1354 { |
| 1355 generic_4_byte( X_GLrop_TexCoord1fv, v ); |
| 1356 } |
| 1357 |
| 1358 #define X_GLrop_TexCoord1iv 51 |
| 1359 void __indirect_glTexCoord1i(GLint s) |
| 1360 { |
| 1361 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1362 const GLuint cmdlen = 8; |
| 1363 emit_header(gc->pc, X_GLrop_TexCoord1iv, cmdlen); |
| 1364 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4); |
| 1365 gc->pc += cmdlen; |
| 1366 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1367 } |
| 1368 |
| 1369 #define X_GLrop_TexCoord1iv 51 |
| 1370 void __indirect_glTexCoord1iv(const GLint * v) |
| 1371 { |
| 1372 generic_4_byte( X_GLrop_TexCoord1iv, v ); |
| 1373 } |
| 1374 |
| 1375 #define X_GLrop_TexCoord1sv 52 |
| 1376 void __indirect_glTexCoord1s(GLshort s) |
| 1377 { |
| 1378 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1379 const GLuint cmdlen = 8; |
| 1380 emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen); |
| 1381 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2); |
| 1382 gc->pc += cmdlen; |
| 1383 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1384 } |
| 1385 |
| 1386 #define X_GLrop_TexCoord1sv 52 |
| 1387 void __indirect_glTexCoord1sv(const GLshort * v) |
| 1388 { |
| 1389 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1390 const GLuint cmdlen = 8; |
| 1391 emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen); |
| 1392 (void) memcpy((void *)(gc->pc + 4), (void *)(v), 2); |
| 1393 gc->pc += cmdlen; |
| 1394 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1395 } |
| 1396 |
| 1397 #define X_GLrop_TexCoord2dv 53 |
| 1398 void __indirect_glTexCoord2d(GLdouble s, GLdouble t) |
| 1399 { |
| 1400 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1401 const GLuint cmdlen = 20; |
| 1402 emit_header(gc->pc, X_GLrop_TexCoord2dv, cmdlen); |
| 1403 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8); |
| 1404 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8); |
| 1405 gc->pc += cmdlen; |
| 1406 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1407 } |
| 1408 |
| 1409 #define X_GLrop_TexCoord2dv 53 |
| 1410 void __indirect_glTexCoord2dv(const GLdouble * v) |
| 1411 { |
| 1412 generic_16_byte( X_GLrop_TexCoord2dv, v ); |
| 1413 } |
| 1414 |
| 1415 #define X_GLrop_TexCoord2fv 54 |
| 1416 void __indirect_glTexCoord2f(GLfloat s, GLfloat t) |
| 1417 { |
| 1418 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1419 const GLuint cmdlen = 12; |
| 1420 emit_header(gc->pc, X_GLrop_TexCoord2fv, cmdlen); |
| 1421 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4); |
| 1422 (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4); |
| 1423 gc->pc += cmdlen; |
| 1424 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1425 } |
| 1426 |
| 1427 #define X_GLrop_TexCoord2fv 54 |
| 1428 void __indirect_glTexCoord2fv(const GLfloat * v) |
| 1429 { |
| 1430 generic_8_byte( X_GLrop_TexCoord2fv, v ); |
| 1431 } |
| 1432 |
| 1433 #define X_GLrop_TexCoord2iv 55 |
| 1434 void __indirect_glTexCoord2i(GLint s, GLint t) |
| 1435 { |
| 1436 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1437 const GLuint cmdlen = 12; |
| 1438 emit_header(gc->pc, X_GLrop_TexCoord2iv, cmdlen); |
| 1439 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4); |
| 1440 (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4); |
| 1441 gc->pc += cmdlen; |
| 1442 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1443 } |
| 1444 |
| 1445 #define X_GLrop_TexCoord2iv 55 |
| 1446 void __indirect_glTexCoord2iv(const GLint * v) |
| 1447 { |
| 1448 generic_8_byte( X_GLrop_TexCoord2iv, v ); |
| 1449 } |
| 1450 |
| 1451 #define X_GLrop_TexCoord2sv 56 |
| 1452 void __indirect_glTexCoord2s(GLshort s, GLshort t) |
| 1453 { |
| 1454 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1455 const GLuint cmdlen = 8; |
| 1456 emit_header(gc->pc, X_GLrop_TexCoord2sv, cmdlen); |
| 1457 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2); |
| 1458 (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2); |
| 1459 gc->pc += cmdlen; |
| 1460 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1461 } |
| 1462 |
| 1463 #define X_GLrop_TexCoord2sv 56 |
| 1464 void __indirect_glTexCoord2sv(const GLshort * v) |
| 1465 { |
| 1466 generic_4_byte( X_GLrop_TexCoord2sv, v ); |
| 1467 } |
| 1468 |
| 1469 #define X_GLrop_TexCoord3dv 57 |
| 1470 void __indirect_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r) |
| 1471 { |
| 1472 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1473 const GLuint cmdlen = 28; |
| 1474 emit_header(gc->pc, X_GLrop_TexCoord3dv, cmdlen); |
| 1475 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8); |
| 1476 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8); |
| 1477 (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8); |
| 1478 gc->pc += cmdlen; |
| 1479 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1480 } |
| 1481 |
| 1482 #define X_GLrop_TexCoord3dv 57 |
| 1483 void __indirect_glTexCoord3dv(const GLdouble * v) |
| 1484 { |
| 1485 generic_24_byte( X_GLrop_TexCoord3dv, v ); |
| 1486 } |
| 1487 |
| 1488 #define X_GLrop_TexCoord3fv 58 |
| 1489 void __indirect_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r) |
| 1490 { |
| 1491 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1492 const GLuint cmdlen = 16; |
| 1493 emit_header(gc->pc, X_GLrop_TexCoord3fv, cmdlen); |
| 1494 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4); |
| 1495 (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4); |
| 1496 (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4); |
| 1497 gc->pc += cmdlen; |
| 1498 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1499 } |
| 1500 |
| 1501 #define X_GLrop_TexCoord3fv 58 |
| 1502 void __indirect_glTexCoord3fv(const GLfloat * v) |
| 1503 { |
| 1504 generic_12_byte( X_GLrop_TexCoord3fv, v ); |
| 1505 } |
| 1506 |
| 1507 #define X_GLrop_TexCoord3iv 59 |
| 1508 void __indirect_glTexCoord3i(GLint s, GLint t, GLint r) |
| 1509 { |
| 1510 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1511 const GLuint cmdlen = 16; |
| 1512 emit_header(gc->pc, X_GLrop_TexCoord3iv, cmdlen); |
| 1513 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4); |
| 1514 (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4); |
| 1515 (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4); |
| 1516 gc->pc += cmdlen; |
| 1517 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1518 } |
| 1519 |
| 1520 #define X_GLrop_TexCoord3iv 59 |
| 1521 void __indirect_glTexCoord3iv(const GLint * v) |
| 1522 { |
| 1523 generic_12_byte( X_GLrop_TexCoord3iv, v ); |
| 1524 } |
| 1525 |
| 1526 #define X_GLrop_TexCoord3sv 60 |
| 1527 void __indirect_glTexCoord3s(GLshort s, GLshort t, GLshort r) |
| 1528 { |
| 1529 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1530 const GLuint cmdlen = 12; |
| 1531 emit_header(gc->pc, X_GLrop_TexCoord3sv, cmdlen); |
| 1532 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2); |
| 1533 (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2); |
| 1534 (void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2); |
| 1535 gc->pc += cmdlen; |
| 1536 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1537 } |
| 1538 |
| 1539 #define X_GLrop_TexCoord3sv 60 |
| 1540 void __indirect_glTexCoord3sv(const GLshort * v) |
| 1541 { |
| 1542 generic_6_byte( X_GLrop_TexCoord3sv, v ); |
| 1543 } |
| 1544 |
| 1545 #define X_GLrop_TexCoord4dv 61 |
| 1546 void __indirect_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q) |
| 1547 { |
| 1548 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1549 const GLuint cmdlen = 36; |
| 1550 emit_header(gc->pc, X_GLrop_TexCoord4dv, cmdlen); |
| 1551 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8); |
| 1552 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8); |
| 1553 (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8); |
| 1554 (void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8); |
| 1555 gc->pc += cmdlen; |
| 1556 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1557 } |
| 1558 |
| 1559 #define X_GLrop_TexCoord4dv 61 |
| 1560 void __indirect_glTexCoord4dv(const GLdouble * v) |
| 1561 { |
| 1562 generic_32_byte( X_GLrop_TexCoord4dv, v ); |
| 1563 } |
| 1564 |
| 1565 #define X_GLrop_TexCoord4fv 62 |
| 1566 void __indirect_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) |
| 1567 { |
| 1568 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1569 const GLuint cmdlen = 20; |
| 1570 emit_header(gc->pc, X_GLrop_TexCoord4fv, cmdlen); |
| 1571 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4); |
| 1572 (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4); |
| 1573 (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4); |
| 1574 (void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4); |
| 1575 gc->pc += cmdlen; |
| 1576 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1577 } |
| 1578 |
| 1579 #define X_GLrop_TexCoord4fv 62 |
| 1580 void __indirect_glTexCoord4fv(const GLfloat * v) |
| 1581 { |
| 1582 generic_16_byte( X_GLrop_TexCoord4fv, v ); |
| 1583 } |
| 1584 |
| 1585 #define X_GLrop_TexCoord4iv 63 |
| 1586 void __indirect_glTexCoord4i(GLint s, GLint t, GLint r, GLint q) |
| 1587 { |
| 1588 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1589 const GLuint cmdlen = 20; |
| 1590 emit_header(gc->pc, X_GLrop_TexCoord4iv, cmdlen); |
| 1591 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4); |
| 1592 (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4); |
| 1593 (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4); |
| 1594 (void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4); |
| 1595 gc->pc += cmdlen; |
| 1596 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1597 } |
| 1598 |
| 1599 #define X_GLrop_TexCoord4iv 63 |
| 1600 void __indirect_glTexCoord4iv(const GLint * v) |
| 1601 { |
| 1602 generic_16_byte( X_GLrop_TexCoord4iv, v ); |
| 1603 } |
| 1604 |
| 1605 #define X_GLrop_TexCoord4sv 64 |
| 1606 void __indirect_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q) |
| 1607 { |
| 1608 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1609 const GLuint cmdlen = 12; |
| 1610 emit_header(gc->pc, X_GLrop_TexCoord4sv, cmdlen); |
| 1611 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2); |
| 1612 (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2); |
| 1613 (void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2); |
| 1614 (void) memcpy((void *)(gc->pc + 10), (void *)(&q), 2); |
| 1615 gc->pc += cmdlen; |
| 1616 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1617 } |
| 1618 |
| 1619 #define X_GLrop_TexCoord4sv 64 |
| 1620 void __indirect_glTexCoord4sv(const GLshort * v) |
| 1621 { |
| 1622 generic_8_byte( X_GLrop_TexCoord4sv, v ); |
| 1623 } |
| 1624 |
| 1625 #define X_GLrop_Vertex2dv 65 |
| 1626 void __indirect_glVertex2d(GLdouble x, GLdouble y) |
| 1627 { |
| 1628 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1629 const GLuint cmdlen = 20; |
| 1630 emit_header(gc->pc, X_GLrop_Vertex2dv, cmdlen); |
| 1631 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8); |
| 1632 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8); |
| 1633 gc->pc += cmdlen; |
| 1634 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1635 } |
| 1636 |
| 1637 #define X_GLrop_Vertex2dv 65 |
| 1638 void __indirect_glVertex2dv(const GLdouble * v) |
| 1639 { |
| 1640 generic_16_byte( X_GLrop_Vertex2dv, v ); |
| 1641 } |
| 1642 |
| 1643 #define X_GLrop_Vertex2fv 66 |
| 1644 void __indirect_glVertex2f(GLfloat x, GLfloat y) |
| 1645 { |
| 1646 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1647 const GLuint cmdlen = 12; |
| 1648 emit_header(gc->pc, X_GLrop_Vertex2fv, cmdlen); |
| 1649 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); |
| 1650 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); |
| 1651 gc->pc += cmdlen; |
| 1652 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1653 } |
| 1654 |
| 1655 #define X_GLrop_Vertex2fv 66 |
| 1656 void __indirect_glVertex2fv(const GLfloat * v) |
| 1657 { |
| 1658 generic_8_byte( X_GLrop_Vertex2fv, v ); |
| 1659 } |
| 1660 |
| 1661 #define X_GLrop_Vertex2iv 67 |
| 1662 void __indirect_glVertex2i(GLint x, GLint y) |
| 1663 { |
| 1664 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1665 const GLuint cmdlen = 12; |
| 1666 emit_header(gc->pc, X_GLrop_Vertex2iv, cmdlen); |
| 1667 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); |
| 1668 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); |
| 1669 gc->pc += cmdlen; |
| 1670 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1671 } |
| 1672 |
| 1673 #define X_GLrop_Vertex2iv 67 |
| 1674 void __indirect_glVertex2iv(const GLint * v) |
| 1675 { |
| 1676 generic_8_byte( X_GLrop_Vertex2iv, v ); |
| 1677 } |
| 1678 |
| 1679 #define X_GLrop_Vertex2sv 68 |
| 1680 void __indirect_glVertex2s(GLshort x, GLshort y) |
| 1681 { |
| 1682 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1683 const GLuint cmdlen = 8; |
| 1684 emit_header(gc->pc, X_GLrop_Vertex2sv, cmdlen); |
| 1685 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2); |
| 1686 (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2); |
| 1687 gc->pc += cmdlen; |
| 1688 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1689 } |
| 1690 |
| 1691 #define X_GLrop_Vertex2sv 68 |
| 1692 void __indirect_glVertex2sv(const GLshort * v) |
| 1693 { |
| 1694 generic_4_byte( X_GLrop_Vertex2sv, v ); |
| 1695 } |
| 1696 |
| 1697 #define X_GLrop_Vertex3dv 69 |
| 1698 void __indirect_glVertex3d(GLdouble x, GLdouble y, GLdouble z) |
| 1699 { |
| 1700 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1701 const GLuint cmdlen = 28; |
| 1702 emit_header(gc->pc, X_GLrop_Vertex3dv, cmdlen); |
| 1703 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8); |
| 1704 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8); |
| 1705 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8); |
| 1706 gc->pc += cmdlen; |
| 1707 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1708 } |
| 1709 |
| 1710 #define X_GLrop_Vertex3dv 69 |
| 1711 void __indirect_glVertex3dv(const GLdouble * v) |
| 1712 { |
| 1713 generic_24_byte( X_GLrop_Vertex3dv, v ); |
| 1714 } |
| 1715 |
| 1716 #define X_GLrop_Vertex3fv 70 |
| 1717 void __indirect_glVertex3f(GLfloat x, GLfloat y, GLfloat z) |
| 1718 { |
| 1719 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1720 const GLuint cmdlen = 16; |
| 1721 emit_header(gc->pc, X_GLrop_Vertex3fv, cmdlen); |
| 1722 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); |
| 1723 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); |
| 1724 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); |
| 1725 gc->pc += cmdlen; |
| 1726 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1727 } |
| 1728 |
| 1729 #define X_GLrop_Vertex3fv 70 |
| 1730 void __indirect_glVertex3fv(const GLfloat * v) |
| 1731 { |
| 1732 generic_12_byte( X_GLrop_Vertex3fv, v ); |
| 1733 } |
| 1734 |
| 1735 #define X_GLrop_Vertex3iv 71 |
| 1736 void __indirect_glVertex3i(GLint x, GLint y, GLint z) |
| 1737 { |
| 1738 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1739 const GLuint cmdlen = 16; |
| 1740 emit_header(gc->pc, X_GLrop_Vertex3iv, cmdlen); |
| 1741 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); |
| 1742 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); |
| 1743 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); |
| 1744 gc->pc += cmdlen; |
| 1745 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1746 } |
| 1747 |
| 1748 #define X_GLrop_Vertex3iv 71 |
| 1749 void __indirect_glVertex3iv(const GLint * v) |
| 1750 { |
| 1751 generic_12_byte( X_GLrop_Vertex3iv, v ); |
| 1752 } |
| 1753 |
| 1754 #define X_GLrop_Vertex3sv 72 |
| 1755 void __indirect_glVertex3s(GLshort x, GLshort y, GLshort z) |
| 1756 { |
| 1757 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1758 const GLuint cmdlen = 12; |
| 1759 emit_header(gc->pc, X_GLrop_Vertex3sv, cmdlen); |
| 1760 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2); |
| 1761 (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2); |
| 1762 (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2); |
| 1763 gc->pc += cmdlen; |
| 1764 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1765 } |
| 1766 |
| 1767 #define X_GLrop_Vertex3sv 72 |
| 1768 void __indirect_glVertex3sv(const GLshort * v) |
| 1769 { |
| 1770 generic_6_byte( X_GLrop_Vertex3sv, v ); |
| 1771 } |
| 1772 |
| 1773 #define X_GLrop_Vertex4dv 73 |
| 1774 void __indirect_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) |
| 1775 { |
| 1776 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1777 const GLuint cmdlen = 36; |
| 1778 emit_header(gc->pc, X_GLrop_Vertex4dv, cmdlen); |
| 1779 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8); |
| 1780 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8); |
| 1781 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8); |
| 1782 (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8); |
| 1783 gc->pc += cmdlen; |
| 1784 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1785 } |
| 1786 |
| 1787 #define X_GLrop_Vertex4dv 73 |
| 1788 void __indirect_glVertex4dv(const GLdouble * v) |
| 1789 { |
| 1790 generic_32_byte( X_GLrop_Vertex4dv, v ); |
| 1791 } |
| 1792 |
| 1793 #define X_GLrop_Vertex4fv 74 |
| 1794 void __indirect_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) |
| 1795 { |
| 1796 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1797 const GLuint cmdlen = 20; |
| 1798 emit_header(gc->pc, X_GLrop_Vertex4fv, cmdlen); |
| 1799 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); |
| 1800 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); |
| 1801 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); |
| 1802 (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4); |
| 1803 gc->pc += cmdlen; |
| 1804 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1805 } |
| 1806 |
| 1807 #define X_GLrop_Vertex4fv 74 |
| 1808 void __indirect_glVertex4fv(const GLfloat * v) |
| 1809 { |
| 1810 generic_16_byte( X_GLrop_Vertex4fv, v ); |
| 1811 } |
| 1812 |
| 1813 #define X_GLrop_Vertex4iv 75 |
| 1814 void __indirect_glVertex4i(GLint x, GLint y, GLint z, GLint w) |
| 1815 { |
| 1816 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1817 const GLuint cmdlen = 20; |
| 1818 emit_header(gc->pc, X_GLrop_Vertex4iv, cmdlen); |
| 1819 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); |
| 1820 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); |
| 1821 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); |
| 1822 (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4); |
| 1823 gc->pc += cmdlen; |
| 1824 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1825 } |
| 1826 |
| 1827 #define X_GLrop_Vertex4iv 75 |
| 1828 void __indirect_glVertex4iv(const GLint * v) |
| 1829 { |
| 1830 generic_16_byte( X_GLrop_Vertex4iv, v ); |
| 1831 } |
| 1832 |
| 1833 #define X_GLrop_Vertex4sv 76 |
| 1834 void __indirect_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w) |
| 1835 { |
| 1836 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1837 const GLuint cmdlen = 12; |
| 1838 emit_header(gc->pc, X_GLrop_Vertex4sv, cmdlen); |
| 1839 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2); |
| 1840 (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2); |
| 1841 (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2); |
| 1842 (void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2); |
| 1843 gc->pc += cmdlen; |
| 1844 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1845 } |
| 1846 |
| 1847 #define X_GLrop_Vertex4sv 76 |
| 1848 void __indirect_glVertex4sv(const GLshort * v) |
| 1849 { |
| 1850 generic_8_byte( X_GLrop_Vertex4sv, v ); |
| 1851 } |
| 1852 |
| 1853 #define X_GLrop_ClipPlane 77 |
| 1854 void __indirect_glClipPlane(GLenum plane, const GLdouble * equation) |
| 1855 { |
| 1856 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1857 const GLuint cmdlen = 40; |
| 1858 emit_header(gc->pc, X_GLrop_ClipPlane, cmdlen); |
| 1859 (void) memcpy((void *)(gc->pc + 4), (void *)(equation), 32); |
| 1860 (void) memcpy((void *)(gc->pc + 36), (void *)(&plane), 4); |
| 1861 gc->pc += cmdlen; |
| 1862 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1863 } |
| 1864 |
| 1865 #define X_GLrop_ColorMaterial 78 |
| 1866 void __indirect_glColorMaterial(GLenum face, GLenum mode) |
| 1867 { |
| 1868 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1869 const GLuint cmdlen = 12; |
| 1870 emit_header(gc->pc, X_GLrop_ColorMaterial, cmdlen); |
| 1871 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4); |
| 1872 (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4); |
| 1873 gc->pc += cmdlen; |
| 1874 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1875 } |
| 1876 |
| 1877 #define X_GLrop_CullFace 79 |
| 1878 void __indirect_glCullFace(GLenum mode) |
| 1879 { |
| 1880 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1881 const GLuint cmdlen = 8; |
| 1882 emit_header(gc->pc, X_GLrop_CullFace, cmdlen); |
| 1883 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4); |
| 1884 gc->pc += cmdlen; |
| 1885 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1886 } |
| 1887 |
| 1888 #define X_GLrop_Fogf 80 |
| 1889 void __indirect_glFogf(GLenum pname, GLfloat param) |
| 1890 { |
| 1891 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1892 const GLuint cmdlen = 12; |
| 1893 emit_header(gc->pc, X_GLrop_Fogf, cmdlen); |
| 1894 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); |
| 1895 (void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4); |
| 1896 gc->pc += cmdlen; |
| 1897 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1898 } |
| 1899 |
| 1900 #define X_GLrop_Fogfv 81 |
| 1901 void __indirect_glFogfv(GLenum pname, const GLfloat * params) |
| 1902 { |
| 1903 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1904 const GLuint compsize = __glFogfv_size(pname); |
| 1905 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4)); |
| 1906 emit_header(gc->pc, X_GLrop_Fogfv, cmdlen); |
| 1907 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); |
| 1908 (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4)); |
| 1909 gc->pc += cmdlen; |
| 1910 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1911 } |
| 1912 |
| 1913 #define X_GLrop_Fogi 82 |
| 1914 void __indirect_glFogi(GLenum pname, GLint param) |
| 1915 { |
| 1916 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1917 const GLuint cmdlen = 12; |
| 1918 emit_header(gc->pc, X_GLrop_Fogi, cmdlen); |
| 1919 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); |
| 1920 (void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4); |
| 1921 gc->pc += cmdlen; |
| 1922 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1923 } |
| 1924 |
| 1925 #define X_GLrop_Fogiv 83 |
| 1926 void __indirect_glFogiv(GLenum pname, const GLint * params) |
| 1927 { |
| 1928 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1929 const GLuint compsize = __glFogiv_size(pname); |
| 1930 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4)); |
| 1931 emit_header(gc->pc, X_GLrop_Fogiv, cmdlen); |
| 1932 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); |
| 1933 (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4)); |
| 1934 gc->pc += cmdlen; |
| 1935 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1936 } |
| 1937 |
| 1938 #define X_GLrop_FrontFace 84 |
| 1939 void __indirect_glFrontFace(GLenum mode) |
| 1940 { |
| 1941 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1942 const GLuint cmdlen = 8; |
| 1943 emit_header(gc->pc, X_GLrop_FrontFace, cmdlen); |
| 1944 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4); |
| 1945 gc->pc += cmdlen; |
| 1946 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1947 } |
| 1948 |
| 1949 #define X_GLrop_Hint 85 |
| 1950 void __indirect_glHint(GLenum target, GLenum mode) |
| 1951 { |
| 1952 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1953 const GLuint cmdlen = 12; |
| 1954 emit_header(gc->pc, X_GLrop_Hint, cmdlen); |
| 1955 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 1956 (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4); |
| 1957 gc->pc += cmdlen; |
| 1958 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1959 } |
| 1960 |
| 1961 #define X_GLrop_Lightf 86 |
| 1962 void __indirect_glLightf(GLenum light, GLenum pname, GLfloat param) |
| 1963 { |
| 1964 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1965 const GLuint cmdlen = 16; |
| 1966 emit_header(gc->pc, X_GLrop_Lightf, cmdlen); |
| 1967 (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4); |
| 1968 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 1969 (void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4); |
| 1970 gc->pc += cmdlen; |
| 1971 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1972 } |
| 1973 |
| 1974 #define X_GLrop_Lightfv 87 |
| 1975 void __indirect_glLightfv(GLenum light, GLenum pname, const GLfloat * params) |
| 1976 { |
| 1977 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1978 const GLuint compsize = __glLightfv_size(pname); |
| 1979 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4)); |
| 1980 emit_header(gc->pc, X_GLrop_Lightfv, cmdlen); |
| 1981 (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4); |
| 1982 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 1983 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4)); |
| 1984 gc->pc += cmdlen; |
| 1985 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1986 } |
| 1987 |
| 1988 #define X_GLrop_Lighti 88 |
| 1989 void __indirect_glLighti(GLenum light, GLenum pname, GLint param) |
| 1990 { |
| 1991 struct glx_context * const gc = __glXGetCurrentContext(); |
| 1992 const GLuint cmdlen = 16; |
| 1993 emit_header(gc->pc, X_GLrop_Lighti, cmdlen); |
| 1994 (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4); |
| 1995 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 1996 (void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4); |
| 1997 gc->pc += cmdlen; |
| 1998 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 1999 } |
| 2000 |
| 2001 #define X_GLrop_Lightiv 89 |
| 2002 void __indirect_glLightiv(GLenum light, GLenum pname, const GLint * params) |
| 2003 { |
| 2004 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2005 const GLuint compsize = __glLightiv_size(pname); |
| 2006 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4)); |
| 2007 emit_header(gc->pc, X_GLrop_Lightiv, cmdlen); |
| 2008 (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4); |
| 2009 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 2010 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4)); |
| 2011 gc->pc += cmdlen; |
| 2012 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2013 } |
| 2014 |
| 2015 #define X_GLrop_LightModelf 90 |
| 2016 void __indirect_glLightModelf(GLenum pname, GLfloat param) |
| 2017 { |
| 2018 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2019 const GLuint cmdlen = 12; |
| 2020 emit_header(gc->pc, X_GLrop_LightModelf, cmdlen); |
| 2021 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); |
| 2022 (void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4); |
| 2023 gc->pc += cmdlen; |
| 2024 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2025 } |
| 2026 |
| 2027 #define X_GLrop_LightModelfv 91 |
| 2028 void __indirect_glLightModelfv(GLenum pname, const GLfloat * params) |
| 2029 { |
| 2030 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2031 const GLuint compsize = __glLightModelfv_size(pname); |
| 2032 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4)); |
| 2033 emit_header(gc->pc, X_GLrop_LightModelfv, cmdlen); |
| 2034 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); |
| 2035 (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4)); |
| 2036 gc->pc += cmdlen; |
| 2037 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2038 } |
| 2039 |
| 2040 #define X_GLrop_LightModeli 92 |
| 2041 void __indirect_glLightModeli(GLenum pname, GLint param) |
| 2042 { |
| 2043 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2044 const GLuint cmdlen = 12; |
| 2045 emit_header(gc->pc, X_GLrop_LightModeli, cmdlen); |
| 2046 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); |
| 2047 (void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4); |
| 2048 gc->pc += cmdlen; |
| 2049 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2050 } |
| 2051 |
| 2052 #define X_GLrop_LightModeliv 93 |
| 2053 void __indirect_glLightModeliv(GLenum pname, const GLint * params) |
| 2054 { |
| 2055 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2056 const GLuint compsize = __glLightModeliv_size(pname); |
| 2057 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4)); |
| 2058 emit_header(gc->pc, X_GLrop_LightModeliv, cmdlen); |
| 2059 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); |
| 2060 (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4)); |
| 2061 gc->pc += cmdlen; |
| 2062 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2063 } |
| 2064 |
| 2065 #define X_GLrop_LineStipple 94 |
| 2066 void __indirect_glLineStipple(GLint factor, GLushort pattern) |
| 2067 { |
| 2068 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2069 const GLuint cmdlen = 12; |
| 2070 emit_header(gc->pc, X_GLrop_LineStipple, cmdlen); |
| 2071 (void) memcpy((void *)(gc->pc + 4), (void *)(&factor), 4); |
| 2072 (void) memcpy((void *)(gc->pc + 8), (void *)(&pattern), 2); |
| 2073 gc->pc += cmdlen; |
| 2074 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2075 } |
| 2076 |
| 2077 #define X_GLrop_LineWidth 95 |
| 2078 void __indirect_glLineWidth(GLfloat width) |
| 2079 { |
| 2080 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2081 const GLuint cmdlen = 8; |
| 2082 emit_header(gc->pc, X_GLrop_LineWidth, cmdlen); |
| 2083 (void) memcpy((void *)(gc->pc + 4), (void *)(&width), 4); |
| 2084 gc->pc += cmdlen; |
| 2085 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2086 } |
| 2087 |
| 2088 #define X_GLrop_Materialf 96 |
| 2089 void __indirect_glMaterialf(GLenum face, GLenum pname, GLfloat param) |
| 2090 { |
| 2091 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2092 const GLuint cmdlen = 16; |
| 2093 emit_header(gc->pc, X_GLrop_Materialf, cmdlen); |
| 2094 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4); |
| 2095 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 2096 (void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4); |
| 2097 gc->pc += cmdlen; |
| 2098 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2099 } |
| 2100 |
| 2101 #define X_GLrop_Materialfv 97 |
| 2102 void __indirect_glMaterialfv(GLenum face, GLenum pname, const GLfloat * params) |
| 2103 { |
| 2104 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2105 const GLuint compsize = __glMaterialfv_size(pname); |
| 2106 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4)); |
| 2107 emit_header(gc->pc, X_GLrop_Materialfv, cmdlen); |
| 2108 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4); |
| 2109 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 2110 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4)); |
| 2111 gc->pc += cmdlen; |
| 2112 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2113 } |
| 2114 |
| 2115 #define X_GLrop_Materiali 98 |
| 2116 void __indirect_glMateriali(GLenum face, GLenum pname, GLint param) |
| 2117 { |
| 2118 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2119 const GLuint cmdlen = 16; |
| 2120 emit_header(gc->pc, X_GLrop_Materiali, cmdlen); |
| 2121 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4); |
| 2122 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 2123 (void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4); |
| 2124 gc->pc += cmdlen; |
| 2125 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2126 } |
| 2127 |
| 2128 #define X_GLrop_Materialiv 99 |
| 2129 void __indirect_glMaterialiv(GLenum face, GLenum pname, const GLint * params) |
| 2130 { |
| 2131 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2132 const GLuint compsize = __glMaterialiv_size(pname); |
| 2133 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4)); |
| 2134 emit_header(gc->pc, X_GLrop_Materialiv, cmdlen); |
| 2135 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4); |
| 2136 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 2137 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4)); |
| 2138 gc->pc += cmdlen; |
| 2139 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2140 } |
| 2141 |
| 2142 #define X_GLrop_PointSize 100 |
| 2143 void __indirect_glPointSize(GLfloat size) |
| 2144 { |
| 2145 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2146 const GLuint cmdlen = 8; |
| 2147 emit_header(gc->pc, X_GLrop_PointSize, cmdlen); |
| 2148 (void) memcpy((void *)(gc->pc + 4), (void *)(&size), 4); |
| 2149 gc->pc += cmdlen; |
| 2150 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2151 } |
| 2152 |
| 2153 #define X_GLrop_PolygonMode 101 |
| 2154 void __indirect_glPolygonMode(GLenum face, GLenum mode) |
| 2155 { |
| 2156 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2157 const GLuint cmdlen = 12; |
| 2158 emit_header(gc->pc, X_GLrop_PolygonMode, cmdlen); |
| 2159 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4); |
| 2160 (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4); |
| 2161 gc->pc += cmdlen; |
| 2162 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2163 } |
| 2164 |
| 2165 #define X_GLrop_PolygonStipple 102 |
| 2166 void __indirect_glPolygonStipple(const GLubyte * mask) |
| 2167 { |
| 2168 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2169 const GLuint compsize = (mask != NULL) ? __glImageSize(32, 32, 1, GL_COLOR_I
NDEX, GL_BITMAP, 0) : 0; |
| 2170 const GLuint cmdlen = 24 + __GLX_PAD(compsize); |
| 2171 emit_header(gc->pc, X_GLrop_PolygonStipple, cmdlen); |
| 2172 if (compsize > 0) { |
| 2173 (*gc->fillImage)(gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, mask, gc->pc +
24, gc->pc + 4); |
| 2174 } else { |
| 2175 (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_si
ze ); |
| 2176 } |
| 2177 gc->pc += cmdlen; |
| 2178 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } |
| 2179 } |
| 2180 |
| 2181 #define X_GLrop_Scissor 103 |
| 2182 void __indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height) |
| 2183 { |
| 2184 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2185 const GLuint cmdlen = 20; |
| 2186 emit_header(gc->pc, X_GLrop_Scissor, cmdlen); |
| 2187 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); |
| 2188 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); |
| 2189 (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4); |
| 2190 (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4); |
| 2191 gc->pc += cmdlen; |
| 2192 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2193 } |
| 2194 |
| 2195 #define X_GLrop_ShadeModel 104 |
| 2196 void __indirect_glShadeModel(GLenum mode) |
| 2197 { |
| 2198 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2199 const GLuint cmdlen = 8; |
| 2200 emit_header(gc->pc, X_GLrop_ShadeModel, cmdlen); |
| 2201 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4); |
| 2202 gc->pc += cmdlen; |
| 2203 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2204 } |
| 2205 |
| 2206 #define X_GLrop_TexParameterf 105 |
| 2207 void __indirect_glTexParameterf(GLenum target, GLenum pname, GLfloat param) |
| 2208 { |
| 2209 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2210 const GLuint cmdlen = 16; |
| 2211 emit_header(gc->pc, X_GLrop_TexParameterf, cmdlen); |
| 2212 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 2213 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 2214 (void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4); |
| 2215 gc->pc += cmdlen; |
| 2216 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2217 } |
| 2218 |
| 2219 #define X_GLrop_TexParameterfv 106 |
| 2220 void __indirect_glTexParameterfv(GLenum target, GLenum pname, const GLfloat * pa
rams) |
| 2221 { |
| 2222 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2223 const GLuint compsize = __glTexParameterfv_size(pname); |
| 2224 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4)); |
| 2225 emit_header(gc->pc, X_GLrop_TexParameterfv, cmdlen); |
| 2226 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 2227 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 2228 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4)); |
| 2229 gc->pc += cmdlen; |
| 2230 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2231 } |
| 2232 |
| 2233 #define X_GLrop_TexParameteri 107 |
| 2234 void __indirect_glTexParameteri(GLenum target, GLenum pname, GLint param) |
| 2235 { |
| 2236 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2237 const GLuint cmdlen = 16; |
| 2238 emit_header(gc->pc, X_GLrop_TexParameteri, cmdlen); |
| 2239 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 2240 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 2241 (void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4); |
| 2242 gc->pc += cmdlen; |
| 2243 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2244 } |
| 2245 |
| 2246 #define X_GLrop_TexParameteriv 108 |
| 2247 void __indirect_glTexParameteriv(GLenum target, GLenum pname, const GLint * para
ms) |
| 2248 { |
| 2249 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2250 const GLuint compsize = __glTexParameteriv_size(pname); |
| 2251 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4)); |
| 2252 emit_header(gc->pc, X_GLrop_TexParameteriv, cmdlen); |
| 2253 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 2254 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 2255 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4)); |
| 2256 gc->pc += cmdlen; |
| 2257 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2258 } |
| 2259 |
| 2260 static void |
| 2261 __glx_TexImage_1D2D( unsigned opcode, unsigned dim, GLenum target, GLint level,
GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format
, GLenum type, const GLvoid * pixels ) |
| 2262 { |
| 2263 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2264 const GLuint compsize = __glImageSize(width, height, 1, format, type, target
); |
| 2265 const GLuint cmdlen = 56 + __GLX_PAD(compsize); |
| 2266 if (__builtin_expect(gc->currentDpy != NULL, 1)) { |
| 2267 if (cmdlen <= gc->maxSmallRenderCommandSize) { |
| 2268 if ( (gc->pc + cmdlen) > gc->bufEnd ) { |
| 2269 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 2270 } |
| 2271 emit_header(gc->pc, opcode, cmdlen); |
| 2272 (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4); |
| 2273 (void) memcpy((void *)(gc->pc + 28), (void *)(&level), 4); |
| 2274 (void) memcpy((void *)(gc->pc + 32), (void *)(&internalformat), 4); |
| 2275 (void) memcpy((void *)(gc->pc + 36), (void *)(&width), 4); |
| 2276 (void) memcpy((void *)(gc->pc + 40), (void *)(&height), 4); |
| 2277 (void) memcpy((void *)(gc->pc + 44), (void *)(&border), 4); |
| 2278 (void) memcpy((void *)(gc->pc + 48), (void *)(&format), 4); |
| 2279 (void) memcpy((void *)(gc->pc + 52), (void *)(&type), 4); |
| 2280 if ((compsize > 0) && (pixels != NULL)) { |
| 2281 (*gc->fillImage)(gc, dim, width, height, 1, format, type, pixels, gc->pc + 5
6, gc->pc + 4); |
| 2282 } else { |
| 2283 (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_si
ze ); |
| 2284 } |
| 2285 gc->pc += cmdlen; |
| 2286 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } |
| 2287 } |
| 2288 else { |
| 2289 const GLint op = opcode; |
| 2290 const GLuint cmdlenLarge = cmdlen + 4; |
| 2291 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); |
| 2292 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); |
| 2293 (void) memcpy((void *)(pc + 4), (void *)(&op), 4); |
| 2294 (void) memcpy((void *)(pc + 28), (void *)(&target), 4); |
| 2295 (void) memcpy((void *)(pc + 32), (void *)(&level), 4); |
| 2296 (void) memcpy((void *)(pc + 36), (void *)(&internalformat), 4); |
| 2297 (void) memcpy((void *)(pc + 40), (void *)(&width), 4); |
| 2298 (void) memcpy((void *)(pc + 44), (void *)(&height), 4); |
| 2299 (void) memcpy((void *)(pc + 48), (void *)(&border), 4); |
| 2300 (void) memcpy((void *)(pc + 52), (void *)(&format), 4); |
| 2301 (void) memcpy((void *)(pc + 56), (void *)(&type), 4); |
| 2302 __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, pixels, p
c + 60, pc + 8); |
| 2303 } |
| 2304 } |
| 2305 } |
| 2306 |
| 2307 #define X_GLrop_TexImage1D 109 |
| 2308 void __indirect_glTexImage1D(GLenum target, GLint level, GLint internalformat, G
Lsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels) |
| 2309 { |
| 2310 __glx_TexImage_1D2D(X_GLrop_TexImage1D, 1, target, level, internalformat, wi
dth, 1, border, format, type, pixels ); |
| 2311 } |
| 2312 |
| 2313 #define X_GLrop_TexImage2D 110 |
| 2314 void __indirect_glTexImage2D(GLenum target, GLint level, GLint internalformat, G
Lsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GL
void * pixels) |
| 2315 { |
| 2316 __glx_TexImage_1D2D(X_GLrop_TexImage2D, 2, target, level, internalformat, wi
dth, height, border, format, type, pixels ); |
| 2317 } |
| 2318 |
| 2319 #define X_GLrop_TexEnvf 111 |
| 2320 void __indirect_glTexEnvf(GLenum target, GLenum pname, GLfloat param) |
| 2321 { |
| 2322 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2323 const GLuint cmdlen = 16; |
| 2324 emit_header(gc->pc, X_GLrop_TexEnvf, cmdlen); |
| 2325 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 2326 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 2327 (void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4); |
| 2328 gc->pc += cmdlen; |
| 2329 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2330 } |
| 2331 |
| 2332 #define X_GLrop_TexEnvfv 112 |
| 2333 void __indirect_glTexEnvfv(GLenum target, GLenum pname, const GLfloat * params) |
| 2334 { |
| 2335 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2336 const GLuint compsize = __glTexEnvfv_size(pname); |
| 2337 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4)); |
| 2338 emit_header(gc->pc, X_GLrop_TexEnvfv, cmdlen); |
| 2339 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 2340 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 2341 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4)); |
| 2342 gc->pc += cmdlen; |
| 2343 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2344 } |
| 2345 |
| 2346 #define X_GLrop_TexEnvi 113 |
| 2347 void __indirect_glTexEnvi(GLenum target, GLenum pname, GLint param) |
| 2348 { |
| 2349 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2350 const GLuint cmdlen = 16; |
| 2351 emit_header(gc->pc, X_GLrop_TexEnvi, cmdlen); |
| 2352 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 2353 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 2354 (void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4); |
| 2355 gc->pc += cmdlen; |
| 2356 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2357 } |
| 2358 |
| 2359 #define X_GLrop_TexEnviv 114 |
| 2360 void __indirect_glTexEnviv(GLenum target, GLenum pname, const GLint * params) |
| 2361 { |
| 2362 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2363 const GLuint compsize = __glTexEnviv_size(pname); |
| 2364 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4)); |
| 2365 emit_header(gc->pc, X_GLrop_TexEnviv, cmdlen); |
| 2366 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 2367 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 2368 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4)); |
| 2369 gc->pc += cmdlen; |
| 2370 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2371 } |
| 2372 |
| 2373 #define X_GLrop_TexGend 115 |
| 2374 void __indirect_glTexGend(GLenum coord, GLenum pname, GLdouble param) |
| 2375 { |
| 2376 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2377 const GLuint cmdlen = 20; |
| 2378 emit_header(gc->pc, X_GLrop_TexGend, cmdlen); |
| 2379 (void) memcpy((void *)(gc->pc + 4), (void *)(¶m), 8); |
| 2380 (void) memcpy((void *)(gc->pc + 12), (void *)(&coord), 4); |
| 2381 (void) memcpy((void *)(gc->pc + 16), (void *)(&pname), 4); |
| 2382 gc->pc += cmdlen; |
| 2383 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2384 } |
| 2385 |
| 2386 #define X_GLrop_TexGendv 116 |
| 2387 void __indirect_glTexGendv(GLenum coord, GLenum pname, const GLdouble * params) |
| 2388 { |
| 2389 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2390 const GLuint compsize = __glTexGendv_size(pname); |
| 2391 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8)); |
| 2392 emit_header(gc->pc, X_GLrop_TexGendv, cmdlen); |
| 2393 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4); |
| 2394 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 2395 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 8)); |
| 2396 gc->pc += cmdlen; |
| 2397 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2398 } |
| 2399 |
| 2400 #define X_GLrop_TexGenf 117 |
| 2401 void __indirect_glTexGenf(GLenum coord, GLenum pname, GLfloat param) |
| 2402 { |
| 2403 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2404 const GLuint cmdlen = 16; |
| 2405 emit_header(gc->pc, X_GLrop_TexGenf, cmdlen); |
| 2406 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4); |
| 2407 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 2408 (void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4); |
| 2409 gc->pc += cmdlen; |
| 2410 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2411 } |
| 2412 |
| 2413 #define X_GLrop_TexGenfv 118 |
| 2414 void __indirect_glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params) |
| 2415 { |
| 2416 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2417 const GLuint compsize = __glTexGenfv_size(pname); |
| 2418 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4)); |
| 2419 emit_header(gc->pc, X_GLrop_TexGenfv, cmdlen); |
| 2420 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4); |
| 2421 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 2422 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4)); |
| 2423 gc->pc += cmdlen; |
| 2424 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2425 } |
| 2426 |
| 2427 #define X_GLrop_TexGeni 119 |
| 2428 void __indirect_glTexGeni(GLenum coord, GLenum pname, GLint param) |
| 2429 { |
| 2430 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2431 const GLuint cmdlen = 16; |
| 2432 emit_header(gc->pc, X_GLrop_TexGeni, cmdlen); |
| 2433 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4); |
| 2434 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 2435 (void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4); |
| 2436 gc->pc += cmdlen; |
| 2437 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2438 } |
| 2439 |
| 2440 #define X_GLrop_TexGeniv 120 |
| 2441 void __indirect_glTexGeniv(GLenum coord, GLenum pname, const GLint * params) |
| 2442 { |
| 2443 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2444 const GLuint compsize = __glTexGeniv_size(pname); |
| 2445 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4)); |
| 2446 emit_header(gc->pc, X_GLrop_TexGeniv, cmdlen); |
| 2447 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4); |
| 2448 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 2449 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4)); |
| 2450 gc->pc += cmdlen; |
| 2451 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2452 } |
| 2453 |
| 2454 #define X_GLrop_InitNames 121 |
| 2455 void __indirect_glInitNames(void) |
| 2456 { |
| 2457 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2458 const GLuint cmdlen = 4; |
| 2459 emit_header(gc->pc, X_GLrop_InitNames, cmdlen); |
| 2460 gc->pc += cmdlen; |
| 2461 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2462 } |
| 2463 |
| 2464 #define X_GLrop_LoadName 122 |
| 2465 void __indirect_glLoadName(GLuint name) |
| 2466 { |
| 2467 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2468 const GLuint cmdlen = 8; |
| 2469 emit_header(gc->pc, X_GLrop_LoadName, cmdlen); |
| 2470 (void) memcpy((void *)(gc->pc + 4), (void *)(&name), 4); |
| 2471 gc->pc += cmdlen; |
| 2472 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2473 } |
| 2474 |
| 2475 #define X_GLrop_PassThrough 123 |
| 2476 void __indirect_glPassThrough(GLfloat token) |
| 2477 { |
| 2478 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2479 const GLuint cmdlen = 8; |
| 2480 emit_header(gc->pc, X_GLrop_PassThrough, cmdlen); |
| 2481 (void) memcpy((void *)(gc->pc + 4), (void *)(&token), 4); |
| 2482 gc->pc += cmdlen; |
| 2483 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2484 } |
| 2485 |
| 2486 #define X_GLrop_PopName 124 |
| 2487 void __indirect_glPopName(void) |
| 2488 { |
| 2489 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2490 const GLuint cmdlen = 4; |
| 2491 emit_header(gc->pc, X_GLrop_PopName, cmdlen); |
| 2492 gc->pc += cmdlen; |
| 2493 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2494 } |
| 2495 |
| 2496 #define X_GLrop_PushName 125 |
| 2497 void __indirect_glPushName(GLuint name) |
| 2498 { |
| 2499 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2500 const GLuint cmdlen = 8; |
| 2501 emit_header(gc->pc, X_GLrop_PushName, cmdlen); |
| 2502 (void) memcpy((void *)(gc->pc + 4), (void *)(&name), 4); |
| 2503 gc->pc += cmdlen; |
| 2504 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2505 } |
| 2506 |
| 2507 #define X_GLrop_DrawBuffer 126 |
| 2508 void __indirect_glDrawBuffer(GLenum mode) |
| 2509 { |
| 2510 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2511 const GLuint cmdlen = 8; |
| 2512 emit_header(gc->pc, X_GLrop_DrawBuffer, cmdlen); |
| 2513 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4); |
| 2514 gc->pc += cmdlen; |
| 2515 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2516 } |
| 2517 |
| 2518 #define X_GLrop_Clear 127 |
| 2519 void __indirect_glClear(GLbitfield mask) |
| 2520 { |
| 2521 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2522 const GLuint cmdlen = 8; |
| 2523 emit_header(gc->pc, X_GLrop_Clear, cmdlen); |
| 2524 (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4); |
| 2525 gc->pc += cmdlen; |
| 2526 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2527 } |
| 2528 |
| 2529 #define X_GLrop_ClearAccum 128 |
| 2530 void __indirect_glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat a
lpha) |
| 2531 { |
| 2532 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2533 const GLuint cmdlen = 20; |
| 2534 emit_header(gc->pc, X_GLrop_ClearAccum, cmdlen); |
| 2535 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); |
| 2536 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); |
| 2537 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); |
| 2538 (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4); |
| 2539 gc->pc += cmdlen; |
| 2540 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2541 } |
| 2542 |
| 2543 #define X_GLrop_ClearIndex 129 |
| 2544 void __indirect_glClearIndex(GLfloat c) |
| 2545 { |
| 2546 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2547 const GLuint cmdlen = 8; |
| 2548 emit_header(gc->pc, X_GLrop_ClearIndex, cmdlen); |
| 2549 (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4); |
| 2550 gc->pc += cmdlen; |
| 2551 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2552 } |
| 2553 |
| 2554 #define X_GLrop_ClearColor 130 |
| 2555 void __indirect_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclam
pf alpha) |
| 2556 { |
| 2557 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2558 const GLuint cmdlen = 20; |
| 2559 emit_header(gc->pc, X_GLrop_ClearColor, cmdlen); |
| 2560 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); |
| 2561 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); |
| 2562 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); |
| 2563 (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4); |
| 2564 gc->pc += cmdlen; |
| 2565 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2566 } |
| 2567 |
| 2568 #define X_GLrop_ClearStencil 131 |
| 2569 void __indirect_glClearStencil(GLint s) |
| 2570 { |
| 2571 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2572 const GLuint cmdlen = 8; |
| 2573 emit_header(gc->pc, X_GLrop_ClearStencil, cmdlen); |
| 2574 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4); |
| 2575 gc->pc += cmdlen; |
| 2576 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2577 } |
| 2578 |
| 2579 #define X_GLrop_ClearDepth 132 |
| 2580 void __indirect_glClearDepth(GLclampd depth) |
| 2581 { |
| 2582 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2583 const GLuint cmdlen = 12; |
| 2584 emit_header(gc->pc, X_GLrop_ClearDepth, cmdlen); |
| 2585 (void) memcpy((void *)(gc->pc + 4), (void *)(&depth), 8); |
| 2586 gc->pc += cmdlen; |
| 2587 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2588 } |
| 2589 |
| 2590 #define X_GLrop_StencilMask 133 |
| 2591 void __indirect_glStencilMask(GLuint mask) |
| 2592 { |
| 2593 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2594 const GLuint cmdlen = 8; |
| 2595 emit_header(gc->pc, X_GLrop_StencilMask, cmdlen); |
| 2596 (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4); |
| 2597 gc->pc += cmdlen; |
| 2598 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2599 } |
| 2600 |
| 2601 #define X_GLrop_ColorMask 134 |
| 2602 void __indirect_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLbo
olean alpha) |
| 2603 { |
| 2604 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2605 const GLuint cmdlen = 8; |
| 2606 emit_header(gc->pc, X_GLrop_ColorMask, cmdlen); |
| 2607 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1); |
| 2608 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1); |
| 2609 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1); |
| 2610 (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1); |
| 2611 gc->pc += cmdlen; |
| 2612 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2613 } |
| 2614 |
| 2615 #define X_GLrop_DepthMask 135 |
| 2616 void __indirect_glDepthMask(GLboolean flag) |
| 2617 { |
| 2618 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2619 const GLuint cmdlen = 8; |
| 2620 emit_header(gc->pc, X_GLrop_DepthMask, cmdlen); |
| 2621 (void) memcpy((void *)(gc->pc + 4), (void *)(&flag), 1); |
| 2622 gc->pc += cmdlen; |
| 2623 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2624 } |
| 2625 |
| 2626 #define X_GLrop_IndexMask 136 |
| 2627 void __indirect_glIndexMask(GLuint mask) |
| 2628 { |
| 2629 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2630 const GLuint cmdlen = 8; |
| 2631 emit_header(gc->pc, X_GLrop_IndexMask, cmdlen); |
| 2632 (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4); |
| 2633 gc->pc += cmdlen; |
| 2634 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2635 } |
| 2636 |
| 2637 #define X_GLrop_Accum 137 |
| 2638 void __indirect_glAccum(GLenum op, GLfloat value) |
| 2639 { |
| 2640 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2641 const GLuint cmdlen = 12; |
| 2642 emit_header(gc->pc, X_GLrop_Accum, cmdlen); |
| 2643 (void) memcpy((void *)(gc->pc + 4), (void *)(&op), 4); |
| 2644 (void) memcpy((void *)(gc->pc + 8), (void *)(&value), 4); |
| 2645 gc->pc += cmdlen; |
| 2646 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2647 } |
| 2648 |
| 2649 #define X_GLrop_PopAttrib 141 |
| 2650 void __indirect_glPopAttrib(void) |
| 2651 { |
| 2652 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2653 const GLuint cmdlen = 4; |
| 2654 emit_header(gc->pc, X_GLrop_PopAttrib, cmdlen); |
| 2655 gc->pc += cmdlen; |
| 2656 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2657 } |
| 2658 |
| 2659 #define X_GLrop_PushAttrib 142 |
| 2660 void __indirect_glPushAttrib(GLbitfield mask) |
| 2661 { |
| 2662 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2663 const GLuint cmdlen = 8; |
| 2664 emit_header(gc->pc, X_GLrop_PushAttrib, cmdlen); |
| 2665 (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4); |
| 2666 gc->pc += cmdlen; |
| 2667 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2668 } |
| 2669 |
| 2670 #define X_GLrop_MapGrid1d 147 |
| 2671 void __indirect_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2) |
| 2672 { |
| 2673 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2674 const GLuint cmdlen = 24; |
| 2675 emit_header(gc->pc, X_GLrop_MapGrid1d, cmdlen); |
| 2676 (void) memcpy((void *)(gc->pc + 4), (void *)(&u1), 8); |
| 2677 (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 8); |
| 2678 (void) memcpy((void *)(gc->pc + 20), (void *)(&un), 4); |
| 2679 gc->pc += cmdlen; |
| 2680 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2681 } |
| 2682 |
| 2683 #define X_GLrop_MapGrid1f 148 |
| 2684 void __indirect_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2) |
| 2685 { |
| 2686 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2687 const GLuint cmdlen = 16; |
| 2688 emit_header(gc->pc, X_GLrop_MapGrid1f, cmdlen); |
| 2689 (void) memcpy((void *)(gc->pc + 4), (void *)(&un), 4); |
| 2690 (void) memcpy((void *)(gc->pc + 8), (void *)(&u1), 4); |
| 2691 (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 4); |
| 2692 gc->pc += cmdlen; |
| 2693 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2694 } |
| 2695 |
| 2696 #define X_GLrop_MapGrid2d 149 |
| 2697 void __indirect_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdoub
le v1, GLdouble v2) |
| 2698 { |
| 2699 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2700 const GLuint cmdlen = 44; |
| 2701 emit_header(gc->pc, X_GLrop_MapGrid2d, cmdlen); |
| 2702 (void) memcpy((void *)(gc->pc + 4), (void *)(&u1), 8); |
| 2703 (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 8); |
| 2704 (void) memcpy((void *)(gc->pc + 20), (void *)(&v1), 8); |
| 2705 (void) memcpy((void *)(gc->pc + 28), (void *)(&v2), 8); |
| 2706 (void) memcpy((void *)(gc->pc + 36), (void *)(&un), 4); |
| 2707 (void) memcpy((void *)(gc->pc + 40), (void *)(&vn), 4); |
| 2708 gc->pc += cmdlen; |
| 2709 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2710 } |
| 2711 |
| 2712 #define X_GLrop_MapGrid2f 150 |
| 2713 void __indirect_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat
v1, GLfloat v2) |
| 2714 { |
| 2715 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2716 const GLuint cmdlen = 28; |
| 2717 emit_header(gc->pc, X_GLrop_MapGrid2f, cmdlen); |
| 2718 (void) memcpy((void *)(gc->pc + 4), (void *)(&un), 4); |
| 2719 (void) memcpy((void *)(gc->pc + 8), (void *)(&u1), 4); |
| 2720 (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 4); |
| 2721 (void) memcpy((void *)(gc->pc + 16), (void *)(&vn), 4); |
| 2722 (void) memcpy((void *)(gc->pc + 20), (void *)(&v1), 4); |
| 2723 (void) memcpy((void *)(gc->pc + 24), (void *)(&v2), 4); |
| 2724 gc->pc += cmdlen; |
| 2725 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2726 } |
| 2727 |
| 2728 #define X_GLrop_EvalCoord1dv 151 |
| 2729 void __indirect_glEvalCoord1d(GLdouble u) |
| 2730 { |
| 2731 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2732 const GLuint cmdlen = 12; |
| 2733 emit_header(gc->pc, X_GLrop_EvalCoord1dv, cmdlen); |
| 2734 (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 8); |
| 2735 gc->pc += cmdlen; |
| 2736 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2737 } |
| 2738 |
| 2739 #define X_GLrop_EvalCoord1dv 151 |
| 2740 void __indirect_glEvalCoord1dv(const GLdouble * u) |
| 2741 { |
| 2742 generic_8_byte( X_GLrop_EvalCoord1dv, u ); |
| 2743 } |
| 2744 |
| 2745 #define X_GLrop_EvalCoord1fv 152 |
| 2746 void __indirect_glEvalCoord1f(GLfloat u) |
| 2747 { |
| 2748 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2749 const GLuint cmdlen = 8; |
| 2750 emit_header(gc->pc, X_GLrop_EvalCoord1fv, cmdlen); |
| 2751 (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 4); |
| 2752 gc->pc += cmdlen; |
| 2753 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2754 } |
| 2755 |
| 2756 #define X_GLrop_EvalCoord1fv 152 |
| 2757 void __indirect_glEvalCoord1fv(const GLfloat * u) |
| 2758 { |
| 2759 generic_4_byte( X_GLrop_EvalCoord1fv, u ); |
| 2760 } |
| 2761 |
| 2762 #define X_GLrop_EvalCoord2dv 153 |
| 2763 void __indirect_glEvalCoord2d(GLdouble u, GLdouble v) |
| 2764 { |
| 2765 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2766 const GLuint cmdlen = 20; |
| 2767 emit_header(gc->pc, X_GLrop_EvalCoord2dv, cmdlen); |
| 2768 (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 8); |
| 2769 (void) memcpy((void *)(gc->pc + 12), (void *)(&v), 8); |
| 2770 gc->pc += cmdlen; |
| 2771 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2772 } |
| 2773 |
| 2774 #define X_GLrop_EvalCoord2dv 153 |
| 2775 void __indirect_glEvalCoord2dv(const GLdouble * u) |
| 2776 { |
| 2777 generic_16_byte( X_GLrop_EvalCoord2dv, u ); |
| 2778 } |
| 2779 |
| 2780 #define X_GLrop_EvalCoord2fv 154 |
| 2781 void __indirect_glEvalCoord2f(GLfloat u, GLfloat v) |
| 2782 { |
| 2783 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2784 const GLuint cmdlen = 12; |
| 2785 emit_header(gc->pc, X_GLrop_EvalCoord2fv, cmdlen); |
| 2786 (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 4); |
| 2787 (void) memcpy((void *)(gc->pc + 8), (void *)(&v), 4); |
| 2788 gc->pc += cmdlen; |
| 2789 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2790 } |
| 2791 |
| 2792 #define X_GLrop_EvalCoord2fv 154 |
| 2793 void __indirect_glEvalCoord2fv(const GLfloat * u) |
| 2794 { |
| 2795 generic_8_byte( X_GLrop_EvalCoord2fv, u ); |
| 2796 } |
| 2797 |
| 2798 #define X_GLrop_EvalMesh1 155 |
| 2799 void __indirect_glEvalMesh1(GLenum mode, GLint i1, GLint i2) |
| 2800 { |
| 2801 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2802 const GLuint cmdlen = 16; |
| 2803 emit_header(gc->pc, X_GLrop_EvalMesh1, cmdlen); |
| 2804 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4); |
| 2805 (void) memcpy((void *)(gc->pc + 8), (void *)(&i1), 4); |
| 2806 (void) memcpy((void *)(gc->pc + 12), (void *)(&i2), 4); |
| 2807 gc->pc += cmdlen; |
| 2808 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2809 } |
| 2810 |
| 2811 #define X_GLrop_EvalPoint1 156 |
| 2812 void __indirect_glEvalPoint1(GLint i) |
| 2813 { |
| 2814 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2815 const GLuint cmdlen = 8; |
| 2816 emit_header(gc->pc, X_GLrop_EvalPoint1, cmdlen); |
| 2817 (void) memcpy((void *)(gc->pc + 4), (void *)(&i), 4); |
| 2818 gc->pc += cmdlen; |
| 2819 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2820 } |
| 2821 |
| 2822 #define X_GLrop_EvalMesh2 157 |
| 2823 void __indirect_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) |
| 2824 { |
| 2825 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2826 const GLuint cmdlen = 24; |
| 2827 emit_header(gc->pc, X_GLrop_EvalMesh2, cmdlen); |
| 2828 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4); |
| 2829 (void) memcpy((void *)(gc->pc + 8), (void *)(&i1), 4); |
| 2830 (void) memcpy((void *)(gc->pc + 12), (void *)(&i2), 4); |
| 2831 (void) memcpy((void *)(gc->pc + 16), (void *)(&j1), 4); |
| 2832 (void) memcpy((void *)(gc->pc + 20), (void *)(&j2), 4); |
| 2833 gc->pc += cmdlen; |
| 2834 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2835 } |
| 2836 |
| 2837 #define X_GLrop_EvalPoint2 158 |
| 2838 void __indirect_glEvalPoint2(GLint i, GLint j) |
| 2839 { |
| 2840 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2841 const GLuint cmdlen = 12; |
| 2842 emit_header(gc->pc, X_GLrop_EvalPoint2, cmdlen); |
| 2843 (void) memcpy((void *)(gc->pc + 4), (void *)(&i), 4); |
| 2844 (void) memcpy((void *)(gc->pc + 8), (void *)(&j), 4); |
| 2845 gc->pc += cmdlen; |
| 2846 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2847 } |
| 2848 |
| 2849 #define X_GLrop_AlphaFunc 159 |
| 2850 void __indirect_glAlphaFunc(GLenum func, GLclampf ref) |
| 2851 { |
| 2852 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2853 const GLuint cmdlen = 12; |
| 2854 emit_header(gc->pc, X_GLrop_AlphaFunc, cmdlen); |
| 2855 (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4); |
| 2856 (void) memcpy((void *)(gc->pc + 8), (void *)(&ref), 4); |
| 2857 gc->pc += cmdlen; |
| 2858 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2859 } |
| 2860 |
| 2861 #define X_GLrop_BlendFunc 160 |
| 2862 void __indirect_glBlendFunc(GLenum sfactor, GLenum dfactor) |
| 2863 { |
| 2864 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2865 const GLuint cmdlen = 12; |
| 2866 emit_header(gc->pc, X_GLrop_BlendFunc, cmdlen); |
| 2867 (void) memcpy((void *)(gc->pc + 4), (void *)(&sfactor), 4); |
| 2868 (void) memcpy((void *)(gc->pc + 8), (void *)(&dfactor), 4); |
| 2869 gc->pc += cmdlen; |
| 2870 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2871 } |
| 2872 |
| 2873 #define X_GLrop_LogicOp 161 |
| 2874 void __indirect_glLogicOp(GLenum opcode) |
| 2875 { |
| 2876 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2877 const GLuint cmdlen = 8; |
| 2878 emit_header(gc->pc, X_GLrop_LogicOp, cmdlen); |
| 2879 (void) memcpy((void *)(gc->pc + 4), (void *)(&opcode), 4); |
| 2880 gc->pc += cmdlen; |
| 2881 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2882 } |
| 2883 |
| 2884 #define X_GLrop_StencilFunc 162 |
| 2885 void __indirect_glStencilFunc(GLenum func, GLint ref, GLuint mask) |
| 2886 { |
| 2887 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2888 const GLuint cmdlen = 16; |
| 2889 emit_header(gc->pc, X_GLrop_StencilFunc, cmdlen); |
| 2890 (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4); |
| 2891 (void) memcpy((void *)(gc->pc + 8), (void *)(&ref), 4); |
| 2892 (void) memcpy((void *)(gc->pc + 12), (void *)(&mask), 4); |
| 2893 gc->pc += cmdlen; |
| 2894 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2895 } |
| 2896 |
| 2897 #define X_GLrop_StencilOp 163 |
| 2898 void __indirect_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) |
| 2899 { |
| 2900 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2901 const GLuint cmdlen = 16; |
| 2902 emit_header(gc->pc, X_GLrop_StencilOp, cmdlen); |
| 2903 (void) memcpy((void *)(gc->pc + 4), (void *)(&fail), 4); |
| 2904 (void) memcpy((void *)(gc->pc + 8), (void *)(&zfail), 4); |
| 2905 (void) memcpy((void *)(gc->pc + 12), (void *)(&zpass), 4); |
| 2906 gc->pc += cmdlen; |
| 2907 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2908 } |
| 2909 |
| 2910 #define X_GLrop_DepthFunc 164 |
| 2911 void __indirect_glDepthFunc(GLenum func) |
| 2912 { |
| 2913 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2914 const GLuint cmdlen = 8; |
| 2915 emit_header(gc->pc, X_GLrop_DepthFunc, cmdlen); |
| 2916 (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4); |
| 2917 gc->pc += cmdlen; |
| 2918 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2919 } |
| 2920 |
| 2921 #define X_GLrop_PixelZoom 165 |
| 2922 void __indirect_glPixelZoom(GLfloat xfactor, GLfloat yfactor) |
| 2923 { |
| 2924 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2925 const GLuint cmdlen = 12; |
| 2926 emit_header(gc->pc, X_GLrop_PixelZoom, cmdlen); |
| 2927 (void) memcpy((void *)(gc->pc + 4), (void *)(&xfactor), 4); |
| 2928 (void) memcpy((void *)(gc->pc + 8), (void *)(&yfactor), 4); |
| 2929 gc->pc += cmdlen; |
| 2930 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2931 } |
| 2932 |
| 2933 #define X_GLrop_PixelTransferf 166 |
| 2934 void __indirect_glPixelTransferf(GLenum pname, GLfloat param) |
| 2935 { |
| 2936 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2937 const GLuint cmdlen = 12; |
| 2938 emit_header(gc->pc, X_GLrop_PixelTransferf, cmdlen); |
| 2939 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); |
| 2940 (void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4); |
| 2941 gc->pc += cmdlen; |
| 2942 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2943 } |
| 2944 |
| 2945 #define X_GLrop_PixelTransferi 167 |
| 2946 void __indirect_glPixelTransferi(GLenum pname, GLint param) |
| 2947 { |
| 2948 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2949 const GLuint cmdlen = 12; |
| 2950 emit_header(gc->pc, X_GLrop_PixelTransferi, cmdlen); |
| 2951 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); |
| 2952 (void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4); |
| 2953 gc->pc += cmdlen; |
| 2954 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2955 } |
| 2956 |
| 2957 #define X_GLrop_PixelMapfv 168 |
| 2958 void __indirect_glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat * values
) |
| 2959 { |
| 2960 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2961 const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4)); |
| 2962 if (mapsize < 0) { |
| 2963 __glXSetError(gc, GL_INVALID_VALUE); |
| 2964 return; |
| 2965 } |
| 2966 if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) { |
| 2967 if (cmdlen <= gc->maxSmallRenderCommandSize) { |
| 2968 if ( (gc->pc + cmdlen) > gc->bufEnd ) { |
| 2969 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 2970 } |
| 2971 emit_header(gc->pc, X_GLrop_PixelMapfv, cmdlen); |
| 2972 (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4); |
| 2973 (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4); |
| 2974 (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 4)); |
| 2975 gc->pc += cmdlen; |
| 2976 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 2977 } |
| 2978 else { |
| 2979 const GLint op = X_GLrop_PixelMapfv; |
| 2980 const GLuint cmdlenLarge = cmdlen + 4; |
| 2981 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); |
| 2982 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); |
| 2983 (void) memcpy((void *)(pc + 4), (void *)(&op), 4); |
| 2984 (void) memcpy((void *)(pc + 8), (void *)(&map), 4); |
| 2985 (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4); |
| 2986 __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4)); |
| 2987 } |
| 2988 } |
| 2989 } |
| 2990 |
| 2991 #define X_GLrop_PixelMapuiv 169 |
| 2992 void __indirect_glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint * values
) |
| 2993 { |
| 2994 struct glx_context * const gc = __glXGetCurrentContext(); |
| 2995 const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4)); |
| 2996 if (mapsize < 0) { |
| 2997 __glXSetError(gc, GL_INVALID_VALUE); |
| 2998 return; |
| 2999 } |
| 3000 if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) { |
| 3001 if (cmdlen <= gc->maxSmallRenderCommandSize) { |
| 3002 if ( (gc->pc + cmdlen) > gc->bufEnd ) { |
| 3003 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3004 } |
| 3005 emit_header(gc->pc, X_GLrop_PixelMapuiv, cmdlen); |
| 3006 (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4); |
| 3007 (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4); |
| 3008 (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 4)); |
| 3009 gc->pc += cmdlen; |
| 3010 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 3011 } |
| 3012 else { |
| 3013 const GLint op = X_GLrop_PixelMapuiv; |
| 3014 const GLuint cmdlenLarge = cmdlen + 4; |
| 3015 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); |
| 3016 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); |
| 3017 (void) memcpy((void *)(pc + 4), (void *)(&op), 4); |
| 3018 (void) memcpy((void *)(pc + 8), (void *)(&map), 4); |
| 3019 (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4); |
| 3020 __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4)); |
| 3021 } |
| 3022 } |
| 3023 } |
| 3024 |
| 3025 #define X_GLrop_PixelMapusv 170 |
| 3026 void __indirect_glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort * valu
es) |
| 3027 { |
| 3028 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3029 const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 2)); |
| 3030 if (mapsize < 0) { |
| 3031 __glXSetError(gc, GL_INVALID_VALUE); |
| 3032 return; |
| 3033 } |
| 3034 if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) { |
| 3035 if (cmdlen <= gc->maxSmallRenderCommandSize) { |
| 3036 if ( (gc->pc + cmdlen) > gc->bufEnd ) { |
| 3037 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3038 } |
| 3039 emit_header(gc->pc, X_GLrop_PixelMapusv, cmdlen); |
| 3040 (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4); |
| 3041 (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4); |
| 3042 (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 2)); |
| 3043 gc->pc += cmdlen; |
| 3044 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 3045 } |
| 3046 else { |
| 3047 const GLint op = X_GLrop_PixelMapusv; |
| 3048 const GLuint cmdlenLarge = cmdlen + 4; |
| 3049 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); |
| 3050 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); |
| 3051 (void) memcpy((void *)(pc + 4), (void *)(&op), 4); |
| 3052 (void) memcpy((void *)(pc + 8), (void *)(&map), 4); |
| 3053 (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4); |
| 3054 __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 2)); |
| 3055 } |
| 3056 } |
| 3057 } |
| 3058 |
| 3059 #define X_GLrop_ReadBuffer 171 |
| 3060 void __indirect_glReadBuffer(GLenum mode) |
| 3061 { |
| 3062 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3063 const GLuint cmdlen = 8; |
| 3064 emit_header(gc->pc, X_GLrop_ReadBuffer, cmdlen); |
| 3065 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4); |
| 3066 gc->pc += cmdlen; |
| 3067 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 3068 } |
| 3069 |
| 3070 #define X_GLrop_CopyPixels 172 |
| 3071 void __indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GL
enum type) |
| 3072 { |
| 3073 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3074 const GLuint cmdlen = 24; |
| 3075 emit_header(gc->pc, X_GLrop_CopyPixels, cmdlen); |
| 3076 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); |
| 3077 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); |
| 3078 (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4); |
| 3079 (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4); |
| 3080 (void) memcpy((void *)(gc->pc + 20), (void *)(&type), 4); |
| 3081 gc->pc += cmdlen; |
| 3082 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 3083 } |
| 3084 |
| 3085 #define X_GLsop_ReadPixels 111 |
| 3086 void __indirect_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GL
enum format, GLenum type, GLvoid * pixels) |
| 3087 { |
| 3088 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3089 const __GLXattribute * const state = gc->client_state_private; |
| 3090 Display * const dpy = gc->currentDpy; |
| 3091 #ifndef USE_XCB |
| 3092 const GLuint cmdlen = 28; |
| 3093 #endif |
| 3094 if (__builtin_expect(dpy != NULL, 1)) { |
| 3095 #ifdef USE_XCB |
| 3096 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3097 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3098 xcb_glx_read_pixels_reply_t *reply = xcb_glx_read_pixels_reply(c, xcb_gl
x_read_pixels(c, gc->currentContextTag, x, y, width, height, format, type, state
->storePack.swapEndian, 0), NULL); |
| 3099 __glEmptyImage(gc, 3, width, height, 1, format, type, xcb_glx_read_pixel
s_data(reply), pixels); |
| 3100 free(reply); |
| 3101 #else |
| 3102 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_ReadPixels, cmd
len); |
| 3103 (void) memcpy((void *)(pc + 0), (void *)(&x), 4); |
| 3104 (void) memcpy((void *)(pc + 4), (void *)(&y), 4); |
| 3105 (void) memcpy((void *)(pc + 8), (void *)(&width), 4); |
| 3106 (void) memcpy((void *)(pc + 12), (void *)(&height), 4); |
| 3107 (void) memcpy((void *)(pc + 16), (void *)(&format), 4); |
| 3108 (void) memcpy((void *)(pc + 20), (void *)(&type), 4); |
| 3109 *(int32_t *)(pc + 24) = 0; |
| 3110 * (int8_t *)(pc + 24) = state->storePack.swapEndian; |
| 3111 __glXReadPixelReply(dpy, gc, 2, width, height, 1, format, type, pixels,
GL_FALSE); |
| 3112 UnlockDisplay(dpy); SyncHandle(); |
| 3113 #endif /* USE_XCB */ |
| 3114 } |
| 3115 return; |
| 3116 } |
| 3117 |
| 3118 #define X_GLrop_DrawPixels 173 |
| 3119 void __indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenu
m type, const GLvoid * pixels) |
| 3120 { |
| 3121 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3122 const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, 1, f
ormat, type, 0) : 0; |
| 3123 const GLuint cmdlen = 40 + __GLX_PAD(compsize); |
| 3124 if (__builtin_expect(gc->currentDpy != NULL, 1)) { |
| 3125 if (cmdlen <= gc->maxSmallRenderCommandSize) { |
| 3126 if ( (gc->pc + cmdlen) > gc->bufEnd ) { |
| 3127 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3128 } |
| 3129 emit_header(gc->pc, X_GLrop_DrawPixels, cmdlen); |
| 3130 (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4); |
| 3131 (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4); |
| 3132 (void) memcpy((void *)(gc->pc + 32), (void *)(&format), 4); |
| 3133 (void) memcpy((void *)(gc->pc + 36), (void *)(&type), 4); |
| 3134 if (compsize > 0) { |
| 3135 (*gc->fillImage)(gc, 2, width, height, 1, format, type, pixels, gc->pc + 40,
gc->pc + 4); |
| 3136 } else { |
| 3137 (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_si
ze ); |
| 3138 } |
| 3139 gc->pc += cmdlen; |
| 3140 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } |
| 3141 } |
| 3142 else { |
| 3143 const GLint op = X_GLrop_DrawPixels; |
| 3144 const GLuint cmdlenLarge = cmdlen + 4; |
| 3145 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); |
| 3146 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); |
| 3147 (void) memcpy((void *)(pc + 4), (void *)(&op), 4); |
| 3148 (void) memcpy((void *)(pc + 28), (void *)(&width), 4); |
| 3149 (void) memcpy((void *)(pc + 32), (void *)(&height), 4); |
| 3150 (void) memcpy((void *)(pc + 36), (void *)(&format), 4); |
| 3151 (void) memcpy((void *)(pc + 40), (void *)(&type), 4); |
| 3152 __glXSendLargeImage(gc, compsize, 2, width, height, 1, format, type, pixels, pc
+ 44, pc + 8); |
| 3153 } |
| 3154 } |
| 3155 } |
| 3156 |
| 3157 #define X_GLsop_GetClipPlane 113 |
| 3158 void __indirect_glGetClipPlane(GLenum plane, GLdouble * equation) |
| 3159 { |
| 3160 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3161 Display * const dpy = gc->currentDpy; |
| 3162 #ifndef USE_XCB |
| 3163 const GLuint cmdlen = 4; |
| 3164 #endif |
| 3165 if (__builtin_expect(dpy != NULL, 1)) { |
| 3166 #ifdef USE_XCB |
| 3167 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3168 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3169 xcb_glx_get_clip_plane_reply_t *reply = xcb_glx_get_clip_plane_reply(c,
xcb_glx_get_clip_plane(c, gc->currentContextTag, plane), NULL); |
| 3170 (void)memcpy(equation, xcb_glx_get_clip_plane_data(reply), xcb_glx_get_c
lip_plane_data_length(reply) * sizeof(GLdouble)); |
| 3171 free(reply); |
| 3172 #else |
| 3173 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetClipPlane, c
mdlen); |
| 3174 (void) memcpy((void *)(pc + 0), (void *)(&plane), 4); |
| 3175 (void) __glXReadReply(dpy, 8, equation, GL_TRUE); |
| 3176 UnlockDisplay(dpy); SyncHandle(); |
| 3177 #endif /* USE_XCB */ |
| 3178 } |
| 3179 return; |
| 3180 } |
| 3181 |
| 3182 #define X_GLsop_GetLightfv 118 |
| 3183 void __indirect_glGetLightfv(GLenum light, GLenum pname, GLfloat * params) |
| 3184 { |
| 3185 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3186 Display * const dpy = gc->currentDpy; |
| 3187 #ifndef USE_XCB |
| 3188 const GLuint cmdlen = 8; |
| 3189 #endif |
| 3190 if (__builtin_expect(dpy != NULL, 1)) { |
| 3191 #ifdef USE_XCB |
| 3192 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3193 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3194 xcb_glx_get_lightfv_reply_t *reply = xcb_glx_get_lightfv_reply(c, xcb_gl
x_get_lightfv(c, gc->currentContextTag, light, pname), NULL); |
| 3195 if (xcb_glx_get_lightfv_data_length(reply) == 0) |
| 3196 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 3197 else |
| 3198 (void)memcpy(params, xcb_glx_get_lightfv_data(reply), xcb_glx_get_li
ghtfv_data_length(reply) * sizeof(GLfloat)); |
| 3199 free(reply); |
| 3200 #else |
| 3201 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetLightfv, cmd
len); |
| 3202 (void) memcpy((void *)(pc + 0), (void *)(&light), 4); |
| 3203 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 3204 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 3205 UnlockDisplay(dpy); SyncHandle(); |
| 3206 #endif /* USE_XCB */ |
| 3207 } |
| 3208 return; |
| 3209 } |
| 3210 |
| 3211 #define X_GLsop_GetLightiv 119 |
| 3212 void __indirect_glGetLightiv(GLenum light, GLenum pname, GLint * params) |
| 3213 { |
| 3214 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3215 Display * const dpy = gc->currentDpy; |
| 3216 #ifndef USE_XCB |
| 3217 const GLuint cmdlen = 8; |
| 3218 #endif |
| 3219 if (__builtin_expect(dpy != NULL, 1)) { |
| 3220 #ifdef USE_XCB |
| 3221 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3222 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3223 xcb_glx_get_lightiv_reply_t *reply = xcb_glx_get_lightiv_reply(c, xcb_gl
x_get_lightiv(c, gc->currentContextTag, light, pname), NULL); |
| 3224 if (xcb_glx_get_lightiv_data_length(reply) == 0) |
| 3225 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 3226 else |
| 3227 (void)memcpy(params, xcb_glx_get_lightiv_data(reply), xcb_glx_get_li
ghtiv_data_length(reply) * sizeof(GLint)); |
| 3228 free(reply); |
| 3229 #else |
| 3230 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetLightiv, cmd
len); |
| 3231 (void) memcpy((void *)(pc + 0), (void *)(&light), 4); |
| 3232 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 3233 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 3234 UnlockDisplay(dpy); SyncHandle(); |
| 3235 #endif /* USE_XCB */ |
| 3236 } |
| 3237 return; |
| 3238 } |
| 3239 |
| 3240 #define X_GLsop_GetMapdv 120 |
| 3241 void __indirect_glGetMapdv(GLenum target, GLenum query, GLdouble * v) |
| 3242 { |
| 3243 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3244 Display * const dpy = gc->currentDpy; |
| 3245 #ifndef USE_XCB |
| 3246 const GLuint cmdlen = 8; |
| 3247 #endif |
| 3248 if (__builtin_expect(dpy != NULL, 1)) { |
| 3249 #ifdef USE_XCB |
| 3250 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3251 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3252 xcb_glx_get_mapdv_reply_t *reply = xcb_glx_get_mapdv_reply(c, xcb_glx_ge
t_mapdv(c, gc->currentContextTag, target, query), NULL); |
| 3253 if (xcb_glx_get_mapdv_data_length(reply) == 0) |
| 3254 (void)memcpy(v, &reply->datum, sizeof(reply->datum)); |
| 3255 else |
| 3256 (void)memcpy(v, xcb_glx_get_mapdv_data(reply), xcb_glx_get_mapdv_dat
a_length(reply) * sizeof(GLdouble)); |
| 3257 free(reply); |
| 3258 #else |
| 3259 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapdv, cmdle
n); |
| 3260 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 3261 (void) memcpy((void *)(pc + 4), (void *)(&query), 4); |
| 3262 (void) __glXReadReply(dpy, 8, v, GL_FALSE); |
| 3263 UnlockDisplay(dpy); SyncHandle(); |
| 3264 #endif /* USE_XCB */ |
| 3265 } |
| 3266 return; |
| 3267 } |
| 3268 |
| 3269 #define X_GLsop_GetMapfv 121 |
| 3270 void __indirect_glGetMapfv(GLenum target, GLenum query, GLfloat * v) |
| 3271 { |
| 3272 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3273 Display * const dpy = gc->currentDpy; |
| 3274 #ifndef USE_XCB |
| 3275 const GLuint cmdlen = 8; |
| 3276 #endif |
| 3277 if (__builtin_expect(dpy != NULL, 1)) { |
| 3278 #ifdef USE_XCB |
| 3279 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3280 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3281 xcb_glx_get_mapfv_reply_t *reply = xcb_glx_get_mapfv_reply(c, xcb_glx_ge
t_mapfv(c, gc->currentContextTag, target, query), NULL); |
| 3282 if (xcb_glx_get_mapfv_data_length(reply) == 0) |
| 3283 (void)memcpy(v, &reply->datum, sizeof(reply->datum)); |
| 3284 else |
| 3285 (void)memcpy(v, xcb_glx_get_mapfv_data(reply), xcb_glx_get_mapfv_dat
a_length(reply) * sizeof(GLfloat)); |
| 3286 free(reply); |
| 3287 #else |
| 3288 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapfv, cmdle
n); |
| 3289 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 3290 (void) memcpy((void *)(pc + 4), (void *)(&query), 4); |
| 3291 (void) __glXReadReply(dpy, 4, v, GL_FALSE); |
| 3292 UnlockDisplay(dpy); SyncHandle(); |
| 3293 #endif /* USE_XCB */ |
| 3294 } |
| 3295 return; |
| 3296 } |
| 3297 |
| 3298 #define X_GLsop_GetMapiv 122 |
| 3299 void __indirect_glGetMapiv(GLenum target, GLenum query, GLint * v) |
| 3300 { |
| 3301 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3302 Display * const dpy = gc->currentDpy; |
| 3303 #ifndef USE_XCB |
| 3304 const GLuint cmdlen = 8; |
| 3305 #endif |
| 3306 if (__builtin_expect(dpy != NULL, 1)) { |
| 3307 #ifdef USE_XCB |
| 3308 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3309 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3310 xcb_glx_get_mapiv_reply_t *reply = xcb_glx_get_mapiv_reply(c, xcb_glx_ge
t_mapiv(c, gc->currentContextTag, target, query), NULL); |
| 3311 if (xcb_glx_get_mapiv_data_length(reply) == 0) |
| 3312 (void)memcpy(v, &reply->datum, sizeof(reply->datum)); |
| 3313 else |
| 3314 (void)memcpy(v, xcb_glx_get_mapiv_data(reply), xcb_glx_get_mapiv_dat
a_length(reply) * sizeof(GLint)); |
| 3315 free(reply); |
| 3316 #else |
| 3317 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapiv, cmdle
n); |
| 3318 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 3319 (void) memcpy((void *)(pc + 4), (void *)(&query), 4); |
| 3320 (void) __glXReadReply(dpy, 4, v, GL_FALSE); |
| 3321 UnlockDisplay(dpy); SyncHandle(); |
| 3322 #endif /* USE_XCB */ |
| 3323 } |
| 3324 return; |
| 3325 } |
| 3326 |
| 3327 #define X_GLsop_GetMaterialfv 123 |
| 3328 void __indirect_glGetMaterialfv(GLenum face, GLenum pname, GLfloat * params) |
| 3329 { |
| 3330 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3331 Display * const dpy = gc->currentDpy; |
| 3332 #ifndef USE_XCB |
| 3333 const GLuint cmdlen = 8; |
| 3334 #endif |
| 3335 if (__builtin_expect(dpy != NULL, 1)) { |
| 3336 #ifdef USE_XCB |
| 3337 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3338 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3339 xcb_glx_get_materialfv_reply_t *reply = xcb_glx_get_materialfv_reply(c,
xcb_glx_get_materialfv(c, gc->currentContextTag, face, pname), NULL); |
| 3340 if (xcb_glx_get_materialfv_data_length(reply) == 0) |
| 3341 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 3342 else |
| 3343 (void)memcpy(params, xcb_glx_get_materialfv_data(reply), xcb_glx_get
_materialfv_data_length(reply) * sizeof(GLfloat)); |
| 3344 free(reply); |
| 3345 #else |
| 3346 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMaterialfv,
cmdlen); |
| 3347 (void) memcpy((void *)(pc + 0), (void *)(&face), 4); |
| 3348 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 3349 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 3350 UnlockDisplay(dpy); SyncHandle(); |
| 3351 #endif /* USE_XCB */ |
| 3352 } |
| 3353 return; |
| 3354 } |
| 3355 |
| 3356 #define X_GLsop_GetMaterialiv 124 |
| 3357 void __indirect_glGetMaterialiv(GLenum face, GLenum pname, GLint * params) |
| 3358 { |
| 3359 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3360 Display * const dpy = gc->currentDpy; |
| 3361 #ifndef USE_XCB |
| 3362 const GLuint cmdlen = 8; |
| 3363 #endif |
| 3364 if (__builtin_expect(dpy != NULL, 1)) { |
| 3365 #ifdef USE_XCB |
| 3366 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3367 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3368 xcb_glx_get_materialiv_reply_t *reply = xcb_glx_get_materialiv_reply(c,
xcb_glx_get_materialiv(c, gc->currentContextTag, face, pname), NULL); |
| 3369 if (xcb_glx_get_materialiv_data_length(reply) == 0) |
| 3370 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 3371 else |
| 3372 (void)memcpy(params, xcb_glx_get_materialiv_data(reply), xcb_glx_get
_materialiv_data_length(reply) * sizeof(GLint)); |
| 3373 free(reply); |
| 3374 #else |
| 3375 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMaterialiv,
cmdlen); |
| 3376 (void) memcpy((void *)(pc + 0), (void *)(&face), 4); |
| 3377 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 3378 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 3379 UnlockDisplay(dpy); SyncHandle(); |
| 3380 #endif /* USE_XCB */ |
| 3381 } |
| 3382 return; |
| 3383 } |
| 3384 |
| 3385 #define X_GLsop_GetPixelMapfv 125 |
| 3386 void __indirect_glGetPixelMapfv(GLenum map, GLfloat * values) |
| 3387 { |
| 3388 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3389 Display * const dpy = gc->currentDpy; |
| 3390 #ifndef USE_XCB |
| 3391 const GLuint cmdlen = 4; |
| 3392 #endif |
| 3393 if (__builtin_expect(dpy != NULL, 1)) { |
| 3394 #ifdef USE_XCB |
| 3395 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3396 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3397 xcb_glx_get_pixel_mapfv_reply_t *reply = xcb_glx_get_pixel_mapfv_reply(c
, xcb_glx_get_pixel_mapfv(c, gc->currentContextTag, map), NULL); |
| 3398 if (xcb_glx_get_pixel_mapfv_data_length(reply) == 0) |
| 3399 (void)memcpy(values, &reply->datum, sizeof(reply->datum)); |
| 3400 else |
| 3401 (void)memcpy(values, xcb_glx_get_pixel_mapfv_data(reply), xcb_glx_ge
t_pixel_mapfv_data_length(reply) * sizeof(GLfloat)); |
| 3402 free(reply); |
| 3403 #else |
| 3404 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapfv,
cmdlen); |
| 3405 (void) memcpy((void *)(pc + 0), (void *)(&map), 4); |
| 3406 (void) __glXReadReply(dpy, 4, values, GL_FALSE); |
| 3407 UnlockDisplay(dpy); SyncHandle(); |
| 3408 #endif /* USE_XCB */ |
| 3409 } |
| 3410 return; |
| 3411 } |
| 3412 |
| 3413 #define X_GLsop_GetPixelMapuiv 126 |
| 3414 void __indirect_glGetPixelMapuiv(GLenum map, GLuint * values) |
| 3415 { |
| 3416 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3417 Display * const dpy = gc->currentDpy; |
| 3418 #ifndef USE_XCB |
| 3419 const GLuint cmdlen = 4; |
| 3420 #endif |
| 3421 if (__builtin_expect(dpy != NULL, 1)) { |
| 3422 #ifdef USE_XCB |
| 3423 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3424 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3425 xcb_glx_get_pixel_mapuiv_reply_t *reply = xcb_glx_get_pixel_mapuiv_reply
(c, xcb_glx_get_pixel_mapuiv(c, gc->currentContextTag, map), NULL); |
| 3426 if (xcb_glx_get_pixel_mapuiv_data_length(reply) == 0) |
| 3427 (void)memcpy(values, &reply->datum, sizeof(reply->datum)); |
| 3428 else |
| 3429 (void)memcpy(values, xcb_glx_get_pixel_mapuiv_data(reply), xcb_glx_g
et_pixel_mapuiv_data_length(reply) * sizeof(GLuint)); |
| 3430 free(reply); |
| 3431 #else |
| 3432 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapuiv,
cmdlen); |
| 3433 (void) memcpy((void *)(pc + 0), (void *)(&map), 4); |
| 3434 (void) __glXReadReply(dpy, 4, values, GL_FALSE); |
| 3435 UnlockDisplay(dpy); SyncHandle(); |
| 3436 #endif /* USE_XCB */ |
| 3437 } |
| 3438 return; |
| 3439 } |
| 3440 |
| 3441 #define X_GLsop_GetPixelMapusv 127 |
| 3442 void __indirect_glGetPixelMapusv(GLenum map, GLushort * values) |
| 3443 { |
| 3444 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3445 Display * const dpy = gc->currentDpy; |
| 3446 #ifndef USE_XCB |
| 3447 const GLuint cmdlen = 4; |
| 3448 #endif |
| 3449 if (__builtin_expect(dpy != NULL, 1)) { |
| 3450 #ifdef USE_XCB |
| 3451 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3452 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3453 xcb_glx_get_pixel_mapusv_reply_t *reply = xcb_glx_get_pixel_mapusv_reply
(c, xcb_glx_get_pixel_mapusv(c, gc->currentContextTag, map), NULL); |
| 3454 if (xcb_glx_get_pixel_mapusv_data_length(reply) == 0) |
| 3455 (void)memcpy(values, &reply->datum, sizeof(reply->datum)); |
| 3456 else |
| 3457 (void)memcpy(values, xcb_glx_get_pixel_mapusv_data(reply), xcb_glx_g
et_pixel_mapusv_data_length(reply) * sizeof(GLushort)); |
| 3458 free(reply); |
| 3459 #else |
| 3460 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapusv,
cmdlen); |
| 3461 (void) memcpy((void *)(pc + 0), (void *)(&map), 4); |
| 3462 (void) __glXReadReply(dpy, 2, values, GL_FALSE); |
| 3463 UnlockDisplay(dpy); SyncHandle(); |
| 3464 #endif /* USE_XCB */ |
| 3465 } |
| 3466 return; |
| 3467 } |
| 3468 |
| 3469 #define X_GLsop_GetPolygonStipple 128 |
| 3470 void __indirect_glGetPolygonStipple(GLubyte * mask) |
| 3471 { |
| 3472 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3473 Display * const dpy = gc->currentDpy; |
| 3474 #ifndef USE_XCB |
| 3475 const GLuint cmdlen = 4; |
| 3476 #endif |
| 3477 if (__builtin_expect(dpy != NULL, 1)) { |
| 3478 #ifdef USE_XCB |
| 3479 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3480 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3481 xcb_glx_get_polygon_stipple_reply_t *reply = xcb_glx_get_polygon_stipple
_reply(c, xcb_glx_get_polygon_stipple(c, gc->currentContextTag, 0), NULL); |
| 3482 __glEmptyImage(gc, 3, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, xcb_glx_get_
polygon_stipple_data(reply), mask); |
| 3483 free(reply); |
| 3484 #else |
| 3485 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPolygonStipp
le, cmdlen); |
| 3486 *(int32_t *)(pc + 0) = 0; |
| 3487 __glXReadPixelReply(dpy, gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, ma
sk, GL_FALSE); |
| 3488 UnlockDisplay(dpy); SyncHandle(); |
| 3489 #endif /* USE_XCB */ |
| 3490 } |
| 3491 return; |
| 3492 } |
| 3493 |
| 3494 #define X_GLsop_GetTexEnvfv 130 |
| 3495 void __indirect_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat * params) |
| 3496 { |
| 3497 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3498 Display * const dpy = gc->currentDpy; |
| 3499 #ifndef USE_XCB |
| 3500 const GLuint cmdlen = 8; |
| 3501 #endif |
| 3502 if (__builtin_expect(dpy != NULL, 1)) { |
| 3503 #ifdef USE_XCB |
| 3504 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3505 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3506 xcb_glx_get_tex_envfv_reply_t *reply = xcb_glx_get_tex_envfv_reply(c, xc
b_glx_get_tex_envfv(c, gc->currentContextTag, target, pname), NULL); |
| 3507 if (xcb_glx_get_tex_envfv_data_length(reply) == 0) |
| 3508 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 3509 else |
| 3510 (void)memcpy(params, xcb_glx_get_tex_envfv_data(reply), xcb_glx_get_
tex_envfv_data_length(reply) * sizeof(GLfloat)); |
| 3511 free(reply); |
| 3512 #else |
| 3513 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexEnvfv, cm
dlen); |
| 3514 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 3515 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 3516 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 3517 UnlockDisplay(dpy); SyncHandle(); |
| 3518 #endif /* USE_XCB */ |
| 3519 } |
| 3520 return; |
| 3521 } |
| 3522 |
| 3523 #define X_GLsop_GetTexEnviv 131 |
| 3524 void __indirect_glGetTexEnviv(GLenum target, GLenum pname, GLint * params) |
| 3525 { |
| 3526 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3527 Display * const dpy = gc->currentDpy; |
| 3528 #ifndef USE_XCB |
| 3529 const GLuint cmdlen = 8; |
| 3530 #endif |
| 3531 if (__builtin_expect(dpy != NULL, 1)) { |
| 3532 #ifdef USE_XCB |
| 3533 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3534 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3535 xcb_glx_get_tex_enviv_reply_t *reply = xcb_glx_get_tex_enviv_reply(c, xc
b_glx_get_tex_enviv(c, gc->currentContextTag, target, pname), NULL); |
| 3536 if (xcb_glx_get_tex_enviv_data_length(reply) == 0) |
| 3537 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 3538 else |
| 3539 (void)memcpy(params, xcb_glx_get_tex_enviv_data(reply), xcb_glx_get_
tex_enviv_data_length(reply) * sizeof(GLint)); |
| 3540 free(reply); |
| 3541 #else |
| 3542 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexEnviv, cm
dlen); |
| 3543 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 3544 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 3545 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 3546 UnlockDisplay(dpy); SyncHandle(); |
| 3547 #endif /* USE_XCB */ |
| 3548 } |
| 3549 return; |
| 3550 } |
| 3551 |
| 3552 #define X_GLsop_GetTexGendv 132 |
| 3553 void __indirect_glGetTexGendv(GLenum coord, GLenum pname, GLdouble * params) |
| 3554 { |
| 3555 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3556 Display * const dpy = gc->currentDpy; |
| 3557 #ifndef USE_XCB |
| 3558 const GLuint cmdlen = 8; |
| 3559 #endif |
| 3560 if (__builtin_expect(dpy != NULL, 1)) { |
| 3561 #ifdef USE_XCB |
| 3562 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3563 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3564 xcb_glx_get_tex_gendv_reply_t *reply = xcb_glx_get_tex_gendv_reply(c, xc
b_glx_get_tex_gendv(c, gc->currentContextTag, coord, pname), NULL); |
| 3565 if (xcb_glx_get_tex_gendv_data_length(reply) == 0) |
| 3566 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 3567 else |
| 3568 (void)memcpy(params, xcb_glx_get_tex_gendv_data(reply), xcb_glx_get_
tex_gendv_data_length(reply) * sizeof(GLdouble)); |
| 3569 free(reply); |
| 3570 #else |
| 3571 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGendv, cm
dlen); |
| 3572 (void) memcpy((void *)(pc + 0), (void *)(&coord), 4); |
| 3573 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 3574 (void) __glXReadReply(dpy, 8, params, GL_FALSE); |
| 3575 UnlockDisplay(dpy); SyncHandle(); |
| 3576 #endif /* USE_XCB */ |
| 3577 } |
| 3578 return; |
| 3579 } |
| 3580 |
| 3581 #define X_GLsop_GetTexGenfv 133 |
| 3582 void __indirect_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat * params) |
| 3583 { |
| 3584 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3585 Display * const dpy = gc->currentDpy; |
| 3586 #ifndef USE_XCB |
| 3587 const GLuint cmdlen = 8; |
| 3588 #endif |
| 3589 if (__builtin_expect(dpy != NULL, 1)) { |
| 3590 #ifdef USE_XCB |
| 3591 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3592 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3593 xcb_glx_get_tex_genfv_reply_t *reply = xcb_glx_get_tex_genfv_reply(c, xc
b_glx_get_tex_genfv(c, gc->currentContextTag, coord, pname), NULL); |
| 3594 if (xcb_glx_get_tex_genfv_data_length(reply) == 0) |
| 3595 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 3596 else |
| 3597 (void)memcpy(params, xcb_glx_get_tex_genfv_data(reply), xcb_glx_get_
tex_genfv_data_length(reply) * sizeof(GLfloat)); |
| 3598 free(reply); |
| 3599 #else |
| 3600 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGenfv, cm
dlen); |
| 3601 (void) memcpy((void *)(pc + 0), (void *)(&coord), 4); |
| 3602 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 3603 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 3604 UnlockDisplay(dpy); SyncHandle(); |
| 3605 #endif /* USE_XCB */ |
| 3606 } |
| 3607 return; |
| 3608 } |
| 3609 |
| 3610 #define X_GLsop_GetTexGeniv 134 |
| 3611 void __indirect_glGetTexGeniv(GLenum coord, GLenum pname, GLint * params) |
| 3612 { |
| 3613 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3614 Display * const dpy = gc->currentDpy; |
| 3615 #ifndef USE_XCB |
| 3616 const GLuint cmdlen = 8; |
| 3617 #endif |
| 3618 if (__builtin_expect(dpy != NULL, 1)) { |
| 3619 #ifdef USE_XCB |
| 3620 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3621 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3622 xcb_glx_get_tex_geniv_reply_t *reply = xcb_glx_get_tex_geniv_reply(c, xc
b_glx_get_tex_geniv(c, gc->currentContextTag, coord, pname), NULL); |
| 3623 if (xcb_glx_get_tex_geniv_data_length(reply) == 0) |
| 3624 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 3625 else |
| 3626 (void)memcpy(params, xcb_glx_get_tex_geniv_data(reply), xcb_glx_get_
tex_geniv_data_length(reply) * sizeof(GLint)); |
| 3627 free(reply); |
| 3628 #else |
| 3629 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGeniv, cm
dlen); |
| 3630 (void) memcpy((void *)(pc + 0), (void *)(&coord), 4); |
| 3631 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 3632 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 3633 UnlockDisplay(dpy); SyncHandle(); |
| 3634 #endif /* USE_XCB */ |
| 3635 } |
| 3636 return; |
| 3637 } |
| 3638 |
| 3639 #define X_GLsop_GetTexImage 135 |
| 3640 void __indirect_glGetTexImage(GLenum target, GLint level, GLenum format, GLenum
type, GLvoid * pixels) |
| 3641 { |
| 3642 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3643 const __GLXattribute * const state = gc->client_state_private; |
| 3644 Display * const dpy = gc->currentDpy; |
| 3645 #ifndef USE_XCB |
| 3646 const GLuint cmdlen = 20; |
| 3647 #endif |
| 3648 if (__builtin_expect(dpy != NULL, 1)) { |
| 3649 #ifdef USE_XCB |
| 3650 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3651 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3652 xcb_glx_get_tex_image_reply_t *reply = xcb_glx_get_tex_image_reply(c, xc
b_glx_get_tex_image(c, gc->currentContextTag, target, level, format, type, state
->storePack.swapEndian), NULL); |
| 3653 if (reply->height == 0) { reply->height = 1; } |
| 3654 if (reply->depth == 0) { reply->depth = 1; } |
| 3655 __glEmptyImage(gc, 3, reply->width, reply->height, reply->depth, format,
type, xcb_glx_get_tex_image_data(reply), pixels); |
| 3656 free(reply); |
| 3657 #else |
| 3658 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexImage, cm
dlen); |
| 3659 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 3660 (void) memcpy((void *)(pc + 4), (void *)(&level), 4); |
| 3661 (void) memcpy((void *)(pc + 8), (void *)(&format), 4); |
| 3662 (void) memcpy((void *)(pc + 12), (void *)(&type), 4); |
| 3663 *(int32_t *)(pc + 16) = 0; |
| 3664 * (int8_t *)(pc + 16) = state->storePack.swapEndian; |
| 3665 __glXReadPixelReply(dpy, gc, 3, 0, 0, 0, format, type, pixels, GL_TRUE); |
| 3666 UnlockDisplay(dpy); SyncHandle(); |
| 3667 #endif /* USE_XCB */ |
| 3668 } |
| 3669 return; |
| 3670 } |
| 3671 |
| 3672 #define X_GLsop_GetTexParameterfv 136 |
| 3673 void __indirect_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat * param
s) |
| 3674 { |
| 3675 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3676 Display * const dpy = gc->currentDpy; |
| 3677 #ifndef USE_XCB |
| 3678 const GLuint cmdlen = 8; |
| 3679 #endif |
| 3680 if (__builtin_expect(dpy != NULL, 1)) { |
| 3681 #ifdef USE_XCB |
| 3682 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3683 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3684 xcb_glx_get_tex_parameterfv_reply_t *reply = xcb_glx_get_tex_parameterfv
_reply(c, xcb_glx_get_tex_parameterfv(c, gc->currentContextTag, target, pname),
NULL); |
| 3685 if (xcb_glx_get_tex_parameterfv_data_length(reply) == 0) |
| 3686 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 3687 else |
| 3688 (void)memcpy(params, xcb_glx_get_tex_parameterfv_data(reply), xcb_gl
x_get_tex_parameterfv_data_length(reply) * sizeof(GLfloat)); |
| 3689 free(reply); |
| 3690 #else |
| 3691 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexParameter
fv, cmdlen); |
| 3692 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 3693 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 3694 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 3695 UnlockDisplay(dpy); SyncHandle(); |
| 3696 #endif /* USE_XCB */ |
| 3697 } |
| 3698 return; |
| 3699 } |
| 3700 |
| 3701 #define X_GLsop_GetTexParameteriv 137 |
| 3702 void __indirect_glGetTexParameteriv(GLenum target, GLenum pname, GLint * params) |
| 3703 { |
| 3704 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3705 Display * const dpy = gc->currentDpy; |
| 3706 #ifndef USE_XCB |
| 3707 const GLuint cmdlen = 8; |
| 3708 #endif |
| 3709 if (__builtin_expect(dpy != NULL, 1)) { |
| 3710 #ifdef USE_XCB |
| 3711 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3712 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3713 xcb_glx_get_tex_parameteriv_reply_t *reply = xcb_glx_get_tex_parameteriv
_reply(c, xcb_glx_get_tex_parameteriv(c, gc->currentContextTag, target, pname),
NULL); |
| 3714 if (xcb_glx_get_tex_parameteriv_data_length(reply) == 0) |
| 3715 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 3716 else |
| 3717 (void)memcpy(params, xcb_glx_get_tex_parameteriv_data(reply), xcb_gl
x_get_tex_parameteriv_data_length(reply) * sizeof(GLint)); |
| 3718 free(reply); |
| 3719 #else |
| 3720 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexParameter
iv, cmdlen); |
| 3721 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 3722 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 3723 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 3724 UnlockDisplay(dpy); SyncHandle(); |
| 3725 #endif /* USE_XCB */ |
| 3726 } |
| 3727 return; |
| 3728 } |
| 3729 |
| 3730 #define X_GLsop_GetTexLevelParameterfv 138 |
| 3731 void __indirect_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pnam
e, GLfloat * params) |
| 3732 { |
| 3733 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3734 Display * const dpy = gc->currentDpy; |
| 3735 #ifndef USE_XCB |
| 3736 const GLuint cmdlen = 12; |
| 3737 #endif |
| 3738 if (__builtin_expect(dpy != NULL, 1)) { |
| 3739 #ifdef USE_XCB |
| 3740 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3741 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3742 xcb_glx_get_tex_level_parameterfv_reply_t *reply = xcb_glx_get_tex_level
_parameterfv_reply(c, xcb_glx_get_tex_level_parameterfv(c, gc->currentContextTag
, target, level, pname), NULL); |
| 3743 if (xcb_glx_get_tex_level_parameterfv_data_length(reply) == 0) |
| 3744 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 3745 else |
| 3746 (void)memcpy(params, xcb_glx_get_tex_level_parameterfv_data(reply),
xcb_glx_get_tex_level_parameterfv_data_length(reply) * sizeof(GLfloat)); |
| 3747 free(reply); |
| 3748 #else |
| 3749 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelPara
meterfv, cmdlen); |
| 3750 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 3751 (void) memcpy((void *)(pc + 4), (void *)(&level), 4); |
| 3752 (void) memcpy((void *)(pc + 8), (void *)(&pname), 4); |
| 3753 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 3754 UnlockDisplay(dpy); SyncHandle(); |
| 3755 #endif /* USE_XCB */ |
| 3756 } |
| 3757 return; |
| 3758 } |
| 3759 |
| 3760 #define X_GLsop_GetTexLevelParameteriv 139 |
| 3761 void __indirect_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pnam
e, GLint * params) |
| 3762 { |
| 3763 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3764 Display * const dpy = gc->currentDpy; |
| 3765 #ifndef USE_XCB |
| 3766 const GLuint cmdlen = 12; |
| 3767 #endif |
| 3768 if (__builtin_expect(dpy != NULL, 1)) { |
| 3769 #ifdef USE_XCB |
| 3770 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3771 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3772 xcb_glx_get_tex_level_parameteriv_reply_t *reply = xcb_glx_get_tex_level
_parameteriv_reply(c, xcb_glx_get_tex_level_parameteriv(c, gc->currentContextTag
, target, level, pname), NULL); |
| 3773 if (xcb_glx_get_tex_level_parameteriv_data_length(reply) == 0) |
| 3774 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 3775 else |
| 3776 (void)memcpy(params, xcb_glx_get_tex_level_parameteriv_data(reply),
xcb_glx_get_tex_level_parameteriv_data_length(reply) * sizeof(GLint)); |
| 3777 free(reply); |
| 3778 #else |
| 3779 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelPara
meteriv, cmdlen); |
| 3780 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 3781 (void) memcpy((void *)(pc + 4), (void *)(&level), 4); |
| 3782 (void) memcpy((void *)(pc + 8), (void *)(&pname), 4); |
| 3783 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 3784 UnlockDisplay(dpy); SyncHandle(); |
| 3785 #endif /* USE_XCB */ |
| 3786 } |
| 3787 return; |
| 3788 } |
| 3789 |
| 3790 #define X_GLsop_IsList 141 |
| 3791 GLboolean __indirect_glIsList(GLuint list) |
| 3792 { |
| 3793 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3794 Display * const dpy = gc->currentDpy; |
| 3795 GLboolean retval = (GLboolean) 0; |
| 3796 #ifndef USE_XCB |
| 3797 const GLuint cmdlen = 4; |
| 3798 #endif |
| 3799 if (__builtin_expect(dpy != NULL, 1)) { |
| 3800 #ifdef USE_XCB |
| 3801 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 3802 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 3803 xcb_glx_is_list_reply_t *reply = xcb_glx_is_list_reply(c, xcb_glx_is_lis
t(c, gc->currentContextTag, list), NULL); |
| 3804 retval = reply->ret_val; |
| 3805 free(reply); |
| 3806 #else |
| 3807 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsList, cmdlen)
; |
| 3808 (void) memcpy((void *)(pc + 0), (void *)(&list), 4); |
| 3809 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE); |
| 3810 UnlockDisplay(dpy); SyncHandle(); |
| 3811 #endif /* USE_XCB */ |
| 3812 } |
| 3813 return retval; |
| 3814 } |
| 3815 |
| 3816 #define X_GLrop_DepthRange 174 |
| 3817 void __indirect_glDepthRange(GLclampd zNear, GLclampd zFar) |
| 3818 { |
| 3819 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3820 const GLuint cmdlen = 20; |
| 3821 emit_header(gc->pc, X_GLrop_DepthRange, cmdlen); |
| 3822 (void) memcpy((void *)(gc->pc + 4), (void *)(&zNear), 8); |
| 3823 (void) memcpy((void *)(gc->pc + 12), (void *)(&zFar), 8); |
| 3824 gc->pc += cmdlen; |
| 3825 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 3826 } |
| 3827 |
| 3828 #define X_GLrop_Frustum 175 |
| 3829 void __indirect_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdoub
le top, GLdouble zNear, GLdouble zFar) |
| 3830 { |
| 3831 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3832 const GLuint cmdlen = 52; |
| 3833 emit_header(gc->pc, X_GLrop_Frustum, cmdlen); |
| 3834 (void) memcpy((void *)(gc->pc + 4), (void *)(&left), 8); |
| 3835 (void) memcpy((void *)(gc->pc + 12), (void *)(&right), 8); |
| 3836 (void) memcpy((void *)(gc->pc + 20), (void *)(&bottom), 8); |
| 3837 (void) memcpy((void *)(gc->pc + 28), (void *)(&top), 8); |
| 3838 (void) memcpy((void *)(gc->pc + 36), (void *)(&zNear), 8); |
| 3839 (void) memcpy((void *)(gc->pc + 44), (void *)(&zFar), 8); |
| 3840 gc->pc += cmdlen; |
| 3841 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 3842 } |
| 3843 |
| 3844 #define X_GLrop_LoadIdentity 176 |
| 3845 void __indirect_glLoadIdentity(void) |
| 3846 { |
| 3847 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3848 const GLuint cmdlen = 4; |
| 3849 emit_header(gc->pc, X_GLrop_LoadIdentity, cmdlen); |
| 3850 gc->pc += cmdlen; |
| 3851 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 3852 } |
| 3853 |
| 3854 #define X_GLrop_LoadMatrixf 177 |
| 3855 void __indirect_glLoadMatrixf(const GLfloat * m) |
| 3856 { |
| 3857 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3858 const GLuint cmdlen = 68; |
| 3859 emit_header(gc->pc, X_GLrop_LoadMatrixf, cmdlen); |
| 3860 (void) memcpy((void *)(gc->pc + 4), (void *)(m), 64); |
| 3861 gc->pc += cmdlen; |
| 3862 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 3863 } |
| 3864 |
| 3865 #define X_GLrop_LoadMatrixd 178 |
| 3866 void __indirect_glLoadMatrixd(const GLdouble * m) |
| 3867 { |
| 3868 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3869 const GLuint cmdlen = 132; |
| 3870 emit_header(gc->pc, X_GLrop_LoadMatrixd, cmdlen); |
| 3871 (void) memcpy((void *)(gc->pc + 4), (void *)(m), 128); |
| 3872 gc->pc += cmdlen; |
| 3873 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 3874 } |
| 3875 |
| 3876 #define X_GLrop_MatrixMode 179 |
| 3877 void __indirect_glMatrixMode(GLenum mode) |
| 3878 { |
| 3879 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3880 const GLuint cmdlen = 8; |
| 3881 emit_header(gc->pc, X_GLrop_MatrixMode, cmdlen); |
| 3882 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4); |
| 3883 gc->pc += cmdlen; |
| 3884 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 3885 } |
| 3886 |
| 3887 #define X_GLrop_MultMatrixf 180 |
| 3888 void __indirect_glMultMatrixf(const GLfloat * m) |
| 3889 { |
| 3890 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3891 const GLuint cmdlen = 68; |
| 3892 emit_header(gc->pc, X_GLrop_MultMatrixf, cmdlen); |
| 3893 (void) memcpy((void *)(gc->pc + 4), (void *)(m), 64); |
| 3894 gc->pc += cmdlen; |
| 3895 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 3896 } |
| 3897 |
| 3898 #define X_GLrop_MultMatrixd 181 |
| 3899 void __indirect_glMultMatrixd(const GLdouble * m) |
| 3900 { |
| 3901 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3902 const GLuint cmdlen = 132; |
| 3903 emit_header(gc->pc, X_GLrop_MultMatrixd, cmdlen); |
| 3904 (void) memcpy((void *)(gc->pc + 4), (void *)(m), 128); |
| 3905 gc->pc += cmdlen; |
| 3906 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 3907 } |
| 3908 |
| 3909 #define X_GLrop_Ortho 182 |
| 3910 void __indirect_glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble
top, GLdouble zNear, GLdouble zFar) |
| 3911 { |
| 3912 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3913 const GLuint cmdlen = 52; |
| 3914 emit_header(gc->pc, X_GLrop_Ortho, cmdlen); |
| 3915 (void) memcpy((void *)(gc->pc + 4), (void *)(&left), 8); |
| 3916 (void) memcpy((void *)(gc->pc + 12), (void *)(&right), 8); |
| 3917 (void) memcpy((void *)(gc->pc + 20), (void *)(&bottom), 8); |
| 3918 (void) memcpy((void *)(gc->pc + 28), (void *)(&top), 8); |
| 3919 (void) memcpy((void *)(gc->pc + 36), (void *)(&zNear), 8); |
| 3920 (void) memcpy((void *)(gc->pc + 44), (void *)(&zFar), 8); |
| 3921 gc->pc += cmdlen; |
| 3922 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 3923 } |
| 3924 |
| 3925 #define X_GLrop_PopMatrix 183 |
| 3926 void __indirect_glPopMatrix(void) |
| 3927 { |
| 3928 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3929 const GLuint cmdlen = 4; |
| 3930 emit_header(gc->pc, X_GLrop_PopMatrix, cmdlen); |
| 3931 gc->pc += cmdlen; |
| 3932 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 3933 } |
| 3934 |
| 3935 #define X_GLrop_PushMatrix 184 |
| 3936 void __indirect_glPushMatrix(void) |
| 3937 { |
| 3938 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3939 const GLuint cmdlen = 4; |
| 3940 emit_header(gc->pc, X_GLrop_PushMatrix, cmdlen); |
| 3941 gc->pc += cmdlen; |
| 3942 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 3943 } |
| 3944 |
| 3945 #define X_GLrop_Rotated 185 |
| 3946 void __indirect_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) |
| 3947 { |
| 3948 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3949 const GLuint cmdlen = 36; |
| 3950 emit_header(gc->pc, X_GLrop_Rotated, cmdlen); |
| 3951 (void) memcpy((void *)(gc->pc + 4), (void *)(&angle), 8); |
| 3952 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8); |
| 3953 (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8); |
| 3954 (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8); |
| 3955 gc->pc += cmdlen; |
| 3956 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 3957 } |
| 3958 |
| 3959 #define X_GLrop_Rotatef 186 |
| 3960 void __indirect_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) |
| 3961 { |
| 3962 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3963 const GLuint cmdlen = 20; |
| 3964 emit_header(gc->pc, X_GLrop_Rotatef, cmdlen); |
| 3965 (void) memcpy((void *)(gc->pc + 4), (void *)(&angle), 4); |
| 3966 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4); |
| 3967 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4); |
| 3968 (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4); |
| 3969 gc->pc += cmdlen; |
| 3970 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 3971 } |
| 3972 |
| 3973 #define X_GLrop_Scaled 187 |
| 3974 void __indirect_glScaled(GLdouble x, GLdouble y, GLdouble z) |
| 3975 { |
| 3976 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3977 const GLuint cmdlen = 28; |
| 3978 emit_header(gc->pc, X_GLrop_Scaled, cmdlen); |
| 3979 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8); |
| 3980 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8); |
| 3981 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8); |
| 3982 gc->pc += cmdlen; |
| 3983 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 3984 } |
| 3985 |
| 3986 #define X_GLrop_Scalef 188 |
| 3987 void __indirect_glScalef(GLfloat x, GLfloat y, GLfloat z) |
| 3988 { |
| 3989 struct glx_context * const gc = __glXGetCurrentContext(); |
| 3990 const GLuint cmdlen = 16; |
| 3991 emit_header(gc->pc, X_GLrop_Scalef, cmdlen); |
| 3992 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); |
| 3993 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); |
| 3994 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); |
| 3995 gc->pc += cmdlen; |
| 3996 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 3997 } |
| 3998 |
| 3999 #define X_GLrop_Translated 189 |
| 4000 void __indirect_glTranslated(GLdouble x, GLdouble y, GLdouble z) |
| 4001 { |
| 4002 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4003 const GLuint cmdlen = 28; |
| 4004 emit_header(gc->pc, X_GLrop_Translated, cmdlen); |
| 4005 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8); |
| 4006 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8); |
| 4007 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8); |
| 4008 gc->pc += cmdlen; |
| 4009 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4010 } |
| 4011 |
| 4012 #define X_GLrop_Translatef 190 |
| 4013 void __indirect_glTranslatef(GLfloat x, GLfloat y, GLfloat z) |
| 4014 { |
| 4015 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4016 const GLuint cmdlen = 16; |
| 4017 emit_header(gc->pc, X_GLrop_Translatef, cmdlen); |
| 4018 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); |
| 4019 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); |
| 4020 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); |
| 4021 gc->pc += cmdlen; |
| 4022 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4023 } |
| 4024 |
| 4025 #define X_GLrop_Viewport 191 |
| 4026 void __indirect_glViewport(GLint x, GLint y, GLsizei width, GLsizei height) |
| 4027 { |
| 4028 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4029 const GLuint cmdlen = 20; |
| 4030 emit_header(gc->pc, X_GLrop_Viewport, cmdlen); |
| 4031 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); |
| 4032 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); |
| 4033 (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4); |
| 4034 (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4); |
| 4035 gc->pc += cmdlen; |
| 4036 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4037 } |
| 4038 |
| 4039 #define X_GLrop_BindTexture 4117 |
| 4040 void __indirect_glBindTexture(GLenum target, GLuint texture) |
| 4041 { |
| 4042 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4043 const GLuint cmdlen = 12; |
| 4044 emit_header(gc->pc, X_GLrop_BindTexture, cmdlen); |
| 4045 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 4046 (void) memcpy((void *)(gc->pc + 8), (void *)(&texture), 4); |
| 4047 gc->pc += cmdlen; |
| 4048 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4049 } |
| 4050 |
| 4051 #define X_GLrop_Indexubv 194 |
| 4052 void __indirect_glIndexub(GLubyte c) |
| 4053 { |
| 4054 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4055 const GLuint cmdlen = 8; |
| 4056 emit_header(gc->pc, X_GLrop_Indexubv, cmdlen); |
| 4057 (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 1); |
| 4058 gc->pc += cmdlen; |
| 4059 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4060 } |
| 4061 |
| 4062 #define X_GLrop_Indexubv 194 |
| 4063 void __indirect_glIndexubv(const GLubyte * c) |
| 4064 { |
| 4065 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4066 const GLuint cmdlen = 8; |
| 4067 emit_header(gc->pc, X_GLrop_Indexubv, cmdlen); |
| 4068 (void) memcpy((void *)(gc->pc + 4), (void *)(c), 1); |
| 4069 gc->pc += cmdlen; |
| 4070 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4071 } |
| 4072 |
| 4073 #define X_GLrop_PolygonOffset 192 |
| 4074 void __indirect_glPolygonOffset(GLfloat factor, GLfloat units) |
| 4075 { |
| 4076 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4077 const GLuint cmdlen = 12; |
| 4078 emit_header(gc->pc, X_GLrop_PolygonOffset, cmdlen); |
| 4079 (void) memcpy((void *)(gc->pc + 4), (void *)(&factor), 4); |
| 4080 (void) memcpy((void *)(gc->pc + 8), (void *)(&units), 4); |
| 4081 gc->pc += cmdlen; |
| 4082 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4083 } |
| 4084 |
| 4085 #define X_GLrop_CopyTexImage1D 4119 |
| 4086 void __indirect_glCopyTexImage1D(GLenum target, GLint level, GLenum internalform
at, GLint x, GLint y, GLsizei width, GLint border) |
| 4087 { |
| 4088 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4089 const GLuint cmdlen = 32; |
| 4090 emit_header(gc->pc, X_GLrop_CopyTexImage1D, cmdlen); |
| 4091 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 4092 (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4); |
| 4093 (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4); |
| 4094 (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4); |
| 4095 (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4); |
| 4096 (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4); |
| 4097 (void) memcpy((void *)(gc->pc + 28), (void *)(&border), 4); |
| 4098 gc->pc += cmdlen; |
| 4099 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4100 } |
| 4101 |
| 4102 #define X_GLrop_CopyTexImage2D 4120 |
| 4103 void __indirect_glCopyTexImage2D(GLenum target, GLint level, GLenum internalform
at, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) |
| 4104 { |
| 4105 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4106 const GLuint cmdlen = 36; |
| 4107 emit_header(gc->pc, X_GLrop_CopyTexImage2D, cmdlen); |
| 4108 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 4109 (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4); |
| 4110 (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4); |
| 4111 (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4); |
| 4112 (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4); |
| 4113 (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4); |
| 4114 (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4); |
| 4115 (void) memcpy((void *)(gc->pc + 32), (void *)(&border), 4); |
| 4116 gc->pc += cmdlen; |
| 4117 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4118 } |
| 4119 |
| 4120 #define X_GLrop_CopyTexSubImage1D 4121 |
| 4121 void __indirect_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, G
Lint x, GLint y, GLsizei width) |
| 4122 { |
| 4123 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4124 const GLuint cmdlen = 28; |
| 4125 emit_header(gc->pc, X_GLrop_CopyTexSubImage1D, cmdlen); |
| 4126 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 4127 (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4); |
| 4128 (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4); |
| 4129 (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4); |
| 4130 (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4); |
| 4131 (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4); |
| 4132 gc->pc += cmdlen; |
| 4133 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4134 } |
| 4135 |
| 4136 #define X_GLrop_CopyTexSubImage2D 4122 |
| 4137 void __indirect_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, G
Lint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) |
| 4138 { |
| 4139 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4140 const GLuint cmdlen = 36; |
| 4141 emit_header(gc->pc, X_GLrop_CopyTexSubImage2D, cmdlen); |
| 4142 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 4143 (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4); |
| 4144 (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4); |
| 4145 (void) memcpy((void *)(gc->pc + 16), (void *)(&yoffset), 4); |
| 4146 (void) memcpy((void *)(gc->pc + 20), (void *)(&x), 4); |
| 4147 (void) memcpy((void *)(gc->pc + 24), (void *)(&y), 4); |
| 4148 (void) memcpy((void *)(gc->pc + 28), (void *)(&width), 4); |
| 4149 (void) memcpy((void *)(gc->pc + 32), (void *)(&height), 4); |
| 4150 gc->pc += cmdlen; |
| 4151 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4152 } |
| 4153 |
| 4154 #define X_GLsop_DeleteTextures 144 |
| 4155 void __indirect_glDeleteTextures(GLsizei n, const GLuint * textures) |
| 4156 { |
| 4157 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4158 Display * const dpy = gc->currentDpy; |
| 4159 #ifndef USE_XCB |
| 4160 const GLuint cmdlen = 4 + __GLX_PAD((n * 4)); |
| 4161 #endif |
| 4162 if (n < 0) { |
| 4163 __glXSetError(gc, GL_INVALID_VALUE); |
| 4164 return; |
| 4165 } |
| 4166 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { |
| 4167 #ifdef USE_XCB |
| 4168 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 4169 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 4170 xcb_glx_delete_textures(c, gc->currentContextTag, n, textures); |
| 4171 #else |
| 4172 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_DeleteTextures,
cmdlen); |
| 4173 (void) memcpy((void *)(pc + 0), (void *)(&n), 4); |
| 4174 (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4)); |
| 4175 UnlockDisplay(dpy); SyncHandle(); |
| 4176 #endif /* USE_XCB */ |
| 4177 } |
| 4178 return; |
| 4179 } |
| 4180 |
| 4181 #define X_GLvop_DeleteTexturesEXT 12 |
| 4182 void glDeleteTexturesEXT(GLsizei n, const GLuint * textures) |
| 4183 { |
| 4184 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4185 |
| 4186 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) |
| 4187 if (gc->isDirect) { |
| 4188 const _glapi_proc *const disp_table = GET_DISPATCH(); |
| 4189 PFNGLDELETETEXTURESEXTPROC p = |
| 4190 (PFNGLDELETETEXTURESEXTPROC) disp_table[327]; |
| 4191 p(n, textures); |
| 4192 } else |
| 4193 #endif |
| 4194 { |
| 4195 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4196 Display * const dpy = gc->currentDpy; |
| 4197 const GLuint cmdlen = 4 + __GLX_PAD((n * 4)); |
| 4198 if (n < 0) { |
| 4199 __glXSetError(gc, GL_INVALID_VALUE); |
| 4200 return; |
| 4201 } |
| 4202 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { |
| 4203 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivate, X_G
Lvop_DeleteTexturesEXT, cmdlen); |
| 4204 (void) memcpy((void *)(pc + 0), (void *)(&n), 4); |
| 4205 (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4)); |
| 4206 UnlockDisplay(dpy); SyncHandle(); |
| 4207 } |
| 4208 return; |
| 4209 } |
| 4210 } |
| 4211 |
| 4212 #define X_GLsop_GenTextures 145 |
| 4213 void __indirect_glGenTextures(GLsizei n, GLuint * textures) |
| 4214 { |
| 4215 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4216 Display * const dpy = gc->currentDpy; |
| 4217 #ifndef USE_XCB |
| 4218 const GLuint cmdlen = 4; |
| 4219 #endif |
| 4220 if (n < 0) { |
| 4221 __glXSetError(gc, GL_INVALID_VALUE); |
| 4222 return; |
| 4223 } |
| 4224 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { |
| 4225 #ifdef USE_XCB |
| 4226 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 4227 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 4228 xcb_glx_gen_textures_reply_t *reply = xcb_glx_gen_textures_reply(c, xcb_
glx_gen_textures(c, gc->currentContextTag, n), NULL); |
| 4229 (void)memcpy(textures, xcb_glx_gen_textures_data(reply), xcb_glx_gen_tex
tures_data_length(reply) * sizeof(GLuint)); |
| 4230 free(reply); |
| 4231 #else |
| 4232 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenTextures, cm
dlen); |
| 4233 (void) memcpy((void *)(pc + 0), (void *)(&n), 4); |
| 4234 (void) __glXReadReply(dpy, 4, textures, GL_TRUE); |
| 4235 UnlockDisplay(dpy); SyncHandle(); |
| 4236 #endif /* USE_XCB */ |
| 4237 } |
| 4238 return; |
| 4239 } |
| 4240 |
| 4241 #define X_GLvop_GenTexturesEXT 13 |
| 4242 void glGenTexturesEXT(GLsizei n, GLuint * textures) |
| 4243 { |
| 4244 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4245 |
| 4246 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) |
| 4247 if (gc->isDirect) { |
| 4248 const _glapi_proc *const disp_table = GET_DISPATCH(); |
| 4249 PFNGLGENTEXTURESEXTPROC p = |
| 4250 (PFNGLGENTEXTURESEXTPROC) disp_table[328]; |
| 4251 p(n, textures); |
| 4252 } else |
| 4253 #endif |
| 4254 { |
| 4255 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4256 Display * const dpy = gc->currentDpy; |
| 4257 const GLuint cmdlen = 4; |
| 4258 if (n < 0) { |
| 4259 __glXSetError(gc, GL_INVALID_VALUE); |
| 4260 return; |
| 4261 } |
| 4262 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { |
| 4263 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GenTexturesEXT, cmdlen); |
| 4264 (void) memcpy((void *)(pc + 0), (void *)(&n), 4); |
| 4265 (void) __glXReadReply(dpy, 4, textures, GL_TRUE); |
| 4266 UnlockDisplay(dpy); SyncHandle(); |
| 4267 } |
| 4268 return; |
| 4269 } |
| 4270 } |
| 4271 |
| 4272 #define X_GLsop_IsTexture 146 |
| 4273 GLboolean __indirect_glIsTexture(GLuint texture) |
| 4274 { |
| 4275 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4276 Display * const dpy = gc->currentDpy; |
| 4277 GLboolean retval = (GLboolean) 0; |
| 4278 #ifndef USE_XCB |
| 4279 const GLuint cmdlen = 4; |
| 4280 #endif |
| 4281 if (__builtin_expect(dpy != NULL, 1)) { |
| 4282 #ifdef USE_XCB |
| 4283 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 4284 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 4285 xcb_glx_is_texture_reply_t *reply = xcb_glx_is_texture_reply(c, xcb_glx_
is_texture(c, gc->currentContextTag, texture), NULL); |
| 4286 retval = reply->ret_val; |
| 4287 free(reply); |
| 4288 #else |
| 4289 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsTexture, cmdl
en); |
| 4290 (void) memcpy((void *)(pc + 0), (void *)(&texture), 4); |
| 4291 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE); |
| 4292 UnlockDisplay(dpy); SyncHandle(); |
| 4293 #endif /* USE_XCB */ |
| 4294 } |
| 4295 return retval; |
| 4296 } |
| 4297 |
| 4298 #define X_GLvop_IsTextureEXT 14 |
| 4299 GLboolean glIsTextureEXT(GLuint texture) |
| 4300 { |
| 4301 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4302 |
| 4303 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) |
| 4304 if (gc->isDirect) { |
| 4305 const _glapi_proc *const disp_table = GET_DISPATCH(); |
| 4306 PFNGLISTEXTUREEXTPROC p = |
| 4307 (PFNGLISTEXTUREEXTPROC) disp_table[330]; |
| 4308 return p(texture); |
| 4309 } else |
| 4310 #endif |
| 4311 { |
| 4312 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4313 Display * const dpy = gc->currentDpy; |
| 4314 GLboolean retval = (GLboolean) 0; |
| 4315 const GLuint cmdlen = 4; |
| 4316 if (__builtin_expect(dpy != NULL, 1)) { |
| 4317 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_IsTextureEXT, cmdlen); |
| 4318 (void) memcpy((void *)(pc + 0), (void *)(&texture), 4); |
| 4319 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE); |
| 4320 UnlockDisplay(dpy); SyncHandle(); |
| 4321 } |
| 4322 return retval; |
| 4323 } |
| 4324 } |
| 4325 |
| 4326 #define X_GLrop_PrioritizeTextures 4118 |
| 4327 void __indirect_glPrioritizeTextures(GLsizei n, const GLuint * textures, const G
Lclampf * priorities) |
| 4328 { |
| 4329 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4330 const GLuint cmdlen = 8 + __GLX_PAD((n * 4)) + __GLX_PAD((n * 4)); |
| 4331 if (n < 0) { |
| 4332 __glXSetError(gc, GL_INVALID_VALUE); |
| 4333 return; |
| 4334 } |
| 4335 if (__builtin_expect(n >= 0, 1)) { |
| 4336 emit_header(gc->pc, X_GLrop_PrioritizeTextures, cmdlen); |
| 4337 (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4); |
| 4338 (void) memcpy((void *)(gc->pc + 8), (void *)(textures), (n * 4)); |
| 4339 (void) memcpy((void *)(gc->pc + 8 + (n * 4)), (void *)(priorities), (n * 4)); |
| 4340 gc->pc += cmdlen; |
| 4341 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4342 } |
| 4343 } |
| 4344 |
| 4345 static void |
| 4346 __glx_TexSubImage_1D2D( unsigned opcode, unsigned dim, GLenum target, GLint leve
l, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, G
Lenum type, const GLvoid * pixels ) |
| 4347 { |
| 4348 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4349 const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, 1, f
ormat, type, target) : 0; |
| 4350 const GLuint cmdlen = 60 + __GLX_PAD(compsize); |
| 4351 if (__builtin_expect(gc->currentDpy != NULL, 1)) { |
| 4352 if (cmdlen <= gc->maxSmallRenderCommandSize) { |
| 4353 if ( (gc->pc + cmdlen) > gc->bufEnd ) { |
| 4354 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 4355 } |
| 4356 emit_header(gc->pc, opcode, cmdlen); |
| 4357 (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4); |
| 4358 (void) memcpy((void *)(gc->pc + 28), (void *)(&level), 4); |
| 4359 (void) memcpy((void *)(gc->pc + 32), (void *)(&xoffset), 4); |
| 4360 (void) memcpy((void *)(gc->pc + 36), (void *)(&yoffset), 4); |
| 4361 (void) memcpy((void *)(gc->pc + 40), (void *)(&width), 4); |
| 4362 (void) memcpy((void *)(gc->pc + 44), (void *)(&height), 4); |
| 4363 (void) memcpy((void *)(gc->pc + 48), (void *)(&format), 4); |
| 4364 (void) memcpy((void *)(gc->pc + 52), (void *)(&type), 4); |
| 4365 (void) memset((void *)(gc->pc + 56), 0, 4); |
| 4366 if (compsize > 0) { |
| 4367 (*gc->fillImage)(gc, dim, width, height, 1, format, type, pixels, gc->pc + 6
0, gc->pc + 4); |
| 4368 } else { |
| 4369 (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_si
ze ); |
| 4370 } |
| 4371 gc->pc += cmdlen; |
| 4372 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } |
| 4373 } |
| 4374 else { |
| 4375 const GLint op = opcode; |
| 4376 const GLuint cmdlenLarge = cmdlen + 4; |
| 4377 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); |
| 4378 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); |
| 4379 (void) memcpy((void *)(pc + 4), (void *)(&op), 4); |
| 4380 (void) memcpy((void *)(pc + 28), (void *)(&target), 4); |
| 4381 (void) memcpy((void *)(pc + 32), (void *)(&level), 4); |
| 4382 (void) memcpy((void *)(pc + 36), (void *)(&xoffset), 4); |
| 4383 (void) memcpy((void *)(pc + 40), (void *)(&yoffset), 4); |
| 4384 (void) memcpy((void *)(pc + 44), (void *)(&width), 4); |
| 4385 (void) memcpy((void *)(pc + 48), (void *)(&height), 4); |
| 4386 (void) memcpy((void *)(pc + 52), (void *)(&format), 4); |
| 4387 (void) memcpy((void *)(pc + 56), (void *)(&type), 4); |
| 4388 (void) memset((void *)(pc + 60), 0, 4); |
| 4389 __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, pixels, p
c + 64, pc + 8); |
| 4390 } |
| 4391 } |
| 4392 } |
| 4393 |
| 4394 #define X_GLrop_TexSubImage1D 4099 |
| 4395 void __indirect_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsiz
ei width, GLenum format, GLenum type, const GLvoid * pixels) |
| 4396 { |
| 4397 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage1D, 1, target, level, xoffset, 1,
width, 1, format, type, pixels ); |
| 4398 } |
| 4399 |
| 4400 #define X_GLrop_TexSubImage2D 4100 |
| 4401 void __indirect_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint
yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoi
d * pixels) |
| 4402 { |
| 4403 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage2D, 2, target, level, xoffset, yof
fset, width, height, format, type, pixels ); |
| 4404 } |
| 4405 |
| 4406 #define X_GLrop_BlendColor 4096 |
| 4407 void __indirect_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclam
pf alpha) |
| 4408 { |
| 4409 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4410 const GLuint cmdlen = 20; |
| 4411 emit_header(gc->pc, X_GLrop_BlendColor, cmdlen); |
| 4412 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); |
| 4413 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); |
| 4414 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); |
| 4415 (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4); |
| 4416 gc->pc += cmdlen; |
| 4417 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4418 } |
| 4419 |
| 4420 #define X_GLrop_BlendEquation 4097 |
| 4421 void __indirect_glBlendEquation(GLenum mode) |
| 4422 { |
| 4423 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4424 const GLuint cmdlen = 8; |
| 4425 emit_header(gc->pc, X_GLrop_BlendEquation, cmdlen); |
| 4426 (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4); |
| 4427 gc->pc += cmdlen; |
| 4428 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4429 } |
| 4430 |
| 4431 #define X_GLrop_ColorTable 2053 |
| 4432 void __indirect_glColorTable(GLenum target, GLenum internalformat, GLsizei width
, GLenum format, GLenum type, const GLvoid * table) |
| 4433 { |
| 4434 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4435 const GLuint compsize = (table != NULL) ? __glImageSize(width, 1, 1, format,
type, target) : 0; |
| 4436 const GLuint cmdlen = 44 + __GLX_PAD(compsize); |
| 4437 if (__builtin_expect(gc->currentDpy != NULL, 1)) { |
| 4438 if (cmdlen <= gc->maxSmallRenderCommandSize) { |
| 4439 if ( (gc->pc + cmdlen) > gc->bufEnd ) { |
| 4440 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 4441 } |
| 4442 emit_header(gc->pc, X_GLrop_ColorTable, cmdlen); |
| 4443 (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4); |
| 4444 (void) memcpy((void *)(gc->pc + 28), (void *)(&internalformat), 4); |
| 4445 (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4); |
| 4446 (void) memcpy((void *)(gc->pc + 36), (void *)(&format), 4); |
| 4447 (void) memcpy((void *)(gc->pc + 40), (void *)(&type), 4); |
| 4448 if (compsize > 0) { |
| 4449 (*gc->fillImage)(gc, 1, width, 1, 1, format, type, table, gc->pc + 44, gc->p
c + 4); |
| 4450 } else { |
| 4451 (void) memcpy( gc->pc + 4, default_pixel_store_1D, default_pixel_store_1D_si
ze ); |
| 4452 } |
| 4453 gc->pc += cmdlen; |
| 4454 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } |
| 4455 } |
| 4456 else { |
| 4457 const GLint op = X_GLrop_ColorTable; |
| 4458 const GLuint cmdlenLarge = cmdlen + 4; |
| 4459 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); |
| 4460 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); |
| 4461 (void) memcpy((void *)(pc + 4), (void *)(&op), 4); |
| 4462 (void) memcpy((void *)(pc + 28), (void *)(&target), 4); |
| 4463 (void) memcpy((void *)(pc + 32), (void *)(&internalformat), 4); |
| 4464 (void) memcpy((void *)(pc + 36), (void *)(&width), 4); |
| 4465 (void) memcpy((void *)(pc + 40), (void *)(&format), 4); |
| 4466 (void) memcpy((void *)(pc + 44), (void *)(&type), 4); |
| 4467 __glXSendLargeImage(gc, compsize, 1, width, 1, 1, format, type, table, pc + 48,
pc + 8); |
| 4468 } |
| 4469 } |
| 4470 } |
| 4471 |
| 4472 #define X_GLrop_ColorTableParameterfv 2054 |
| 4473 void __indirect_glColorTableParameterfv(GLenum target, GLenum pname, const GLflo
at * params) |
| 4474 { |
| 4475 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4476 const GLuint compsize = __glColorTableParameterfv_size(pname); |
| 4477 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4)); |
| 4478 emit_header(gc->pc, X_GLrop_ColorTableParameterfv, cmdlen); |
| 4479 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 4480 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 4481 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4)); |
| 4482 gc->pc += cmdlen; |
| 4483 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4484 } |
| 4485 |
| 4486 #define X_GLrop_ColorTableParameteriv 2055 |
| 4487 void __indirect_glColorTableParameteriv(GLenum target, GLenum pname, const GLint
* params) |
| 4488 { |
| 4489 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4490 const GLuint compsize = __glColorTableParameteriv_size(pname); |
| 4491 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4)); |
| 4492 emit_header(gc->pc, X_GLrop_ColorTableParameteriv, cmdlen); |
| 4493 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 4494 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 4495 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4)); |
| 4496 gc->pc += cmdlen; |
| 4497 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4498 } |
| 4499 |
| 4500 #define X_GLrop_CopyColorTable 2056 |
| 4501 void __indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x,
GLint y, GLsizei width) |
| 4502 { |
| 4503 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4504 const GLuint cmdlen = 24; |
| 4505 emit_header(gc->pc, X_GLrop_CopyColorTable, cmdlen); |
| 4506 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 4507 (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4); |
| 4508 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4); |
| 4509 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4); |
| 4510 (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4); |
| 4511 gc->pc += cmdlen; |
| 4512 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4513 } |
| 4514 |
| 4515 #define X_GLsop_GetColorTable 147 |
| 4516 void __indirect_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoi
d * table) |
| 4517 { |
| 4518 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4519 const __GLXattribute * const state = gc->client_state_private; |
| 4520 Display * const dpy = gc->currentDpy; |
| 4521 #ifndef USE_XCB |
| 4522 const GLuint cmdlen = 16; |
| 4523 #endif |
| 4524 if (__builtin_expect(dpy != NULL, 1)) { |
| 4525 #ifdef USE_XCB |
| 4526 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 4527 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 4528 xcb_glx_get_color_table_reply_t *reply = xcb_glx_get_color_table_reply(c
, xcb_glx_get_color_table(c, gc->currentContextTag, target, format, type, state-
>storePack.swapEndian), NULL); |
| 4529 __glEmptyImage(gc, 3, reply->width, 1, 1, format, type, xcb_glx_get_colo
r_table_data(reply), table); |
| 4530 free(reply); |
| 4531 #else |
| 4532 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTable,
cmdlen); |
| 4533 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 4534 (void) memcpy((void *)(pc + 4), (void *)(&format), 4); |
| 4535 (void) memcpy((void *)(pc + 8), (void *)(&type), 4); |
| 4536 *(int32_t *)(pc + 12) = 0; |
| 4537 * (int8_t *)(pc + 12) = state->storePack.swapEndian; |
| 4538 __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table, GL_TRUE); |
| 4539 UnlockDisplay(dpy); SyncHandle(); |
| 4540 #endif /* USE_XCB */ |
| 4541 } |
| 4542 return; |
| 4543 } |
| 4544 |
| 4545 #define X_GLvop_GetColorTableSGI 4098 |
| 4546 void glGetColorTableEXT(GLenum target, GLenum format, GLenum type, GLvoid * tabl
e) |
| 4547 { |
| 4548 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4549 |
| 4550 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) |
| 4551 if (gc->isDirect) { |
| 4552 const _glapi_proc *const disp_table = GET_DISPATCH(); |
| 4553 PFNGLGETCOLORTABLESGIPROC p = |
| 4554 (PFNGLGETCOLORTABLESGIPROC) disp_table[343]; |
| 4555 p(target, format, type, table); |
| 4556 } else |
| 4557 #endif |
| 4558 { |
| 4559 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4560 const __GLXattribute * const state = gc->client_state_private; |
| 4561 Display * const dpy = gc->currentDpy; |
| 4562 const GLuint cmdlen = 16; |
| 4563 if (__builtin_expect(dpy != NULL, 1)) { |
| 4564 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetColorTableSGI, cmdlen); |
| 4565 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 4566 (void) memcpy((void *)(pc + 4), (void *)(&format), 4); |
| 4567 (void) memcpy((void *)(pc + 8), (void *)(&type), 4); |
| 4568 *(int32_t *)(pc + 12) = 0; |
| 4569 * (int8_t *)(pc + 12) = state->storePack.swapEndian; |
| 4570 __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table, GL_TRUE); |
| 4571 UnlockDisplay(dpy); SyncHandle(); |
| 4572 } |
| 4573 return; |
| 4574 } |
| 4575 } |
| 4576 |
| 4577 #define X_GLsop_GetColorTableParameterfv 148 |
| 4578 void __indirect_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat
* params) |
| 4579 { |
| 4580 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4581 Display * const dpy = gc->currentDpy; |
| 4582 #ifndef USE_XCB |
| 4583 const GLuint cmdlen = 8; |
| 4584 #endif |
| 4585 if (__builtin_expect(dpy != NULL, 1)) { |
| 4586 #ifdef USE_XCB |
| 4587 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 4588 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 4589 xcb_glx_get_color_table_parameterfv_reply_t *reply = xcb_glx_get_color_t
able_parameterfv_reply(c, xcb_glx_get_color_table_parameterfv(c, gc->currentCont
extTag, target, pname), NULL); |
| 4590 if (xcb_glx_get_color_table_parameterfv_data_length(reply) == 0) |
| 4591 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 4592 else |
| 4593 (void)memcpy(params, xcb_glx_get_color_table_parameterfv_data(reply)
, xcb_glx_get_color_table_parameterfv_data_length(reply) * sizeof(GLfloat)); |
| 4594 free(reply); |
| 4595 #else |
| 4596 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTablePa
rameterfv, cmdlen); |
| 4597 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 4598 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 4599 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 4600 UnlockDisplay(dpy); SyncHandle(); |
| 4601 #endif /* USE_XCB */ |
| 4602 } |
| 4603 return; |
| 4604 } |
| 4605 |
| 4606 #define X_GLvop_GetColorTableParameterfvSGI 4099 |
| 4607 void glGetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat * params
) |
| 4608 { |
| 4609 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4610 |
| 4611 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) |
| 4612 if (gc->isDirect) { |
| 4613 const _glapi_proc *const disp_table = GET_DISPATCH(); |
| 4614 PFNGLGETCOLORTABLEPARAMETERFVSGIPROC p = |
| 4615 (PFNGLGETCOLORTABLEPARAMETERFVSGIPROC) disp_table[344]; |
| 4616 p(target, pname, params); |
| 4617 } else |
| 4618 #endif |
| 4619 { |
| 4620 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4621 Display * const dpy = gc->currentDpy; |
| 4622 const GLuint cmdlen = 8; |
| 4623 if (__builtin_expect(dpy != NULL, 1)) { |
| 4624 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetColorTableParameterfvSGI, cmdlen); |
| 4625 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 4626 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 4627 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 4628 UnlockDisplay(dpy); SyncHandle(); |
| 4629 } |
| 4630 return; |
| 4631 } |
| 4632 } |
| 4633 |
| 4634 #define X_GLsop_GetColorTableParameteriv 149 |
| 4635 void __indirect_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *
params) |
| 4636 { |
| 4637 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4638 Display * const dpy = gc->currentDpy; |
| 4639 #ifndef USE_XCB |
| 4640 const GLuint cmdlen = 8; |
| 4641 #endif |
| 4642 if (__builtin_expect(dpy != NULL, 1)) { |
| 4643 #ifdef USE_XCB |
| 4644 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 4645 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 4646 xcb_glx_get_color_table_parameteriv_reply_t *reply = xcb_glx_get_color_t
able_parameteriv_reply(c, xcb_glx_get_color_table_parameteriv(c, gc->currentCont
extTag, target, pname), NULL); |
| 4647 if (xcb_glx_get_color_table_parameteriv_data_length(reply) == 0) |
| 4648 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 4649 else |
| 4650 (void)memcpy(params, xcb_glx_get_color_table_parameteriv_data(reply)
, xcb_glx_get_color_table_parameteriv_data_length(reply) * sizeof(GLint)); |
| 4651 free(reply); |
| 4652 #else |
| 4653 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTablePa
rameteriv, cmdlen); |
| 4654 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 4655 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 4656 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 4657 UnlockDisplay(dpy); SyncHandle(); |
| 4658 #endif /* USE_XCB */ |
| 4659 } |
| 4660 return; |
| 4661 } |
| 4662 |
| 4663 #define X_GLvop_GetColorTableParameterivSGI 4100 |
| 4664 void glGetColorTableParameterivEXT(GLenum target, GLenum pname, GLint * params) |
| 4665 { |
| 4666 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4667 |
| 4668 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) |
| 4669 if (gc->isDirect) { |
| 4670 const _glapi_proc *const disp_table = GET_DISPATCH(); |
| 4671 PFNGLGETCOLORTABLEPARAMETERIVSGIPROC p = |
| 4672 (PFNGLGETCOLORTABLEPARAMETERIVSGIPROC) disp_table[345]; |
| 4673 p(target, pname, params); |
| 4674 } else |
| 4675 #endif |
| 4676 { |
| 4677 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4678 Display * const dpy = gc->currentDpy; |
| 4679 const GLuint cmdlen = 8; |
| 4680 if (__builtin_expect(dpy != NULL, 1)) { |
| 4681 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetColorTableParameterivSGI, cmdlen); |
| 4682 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 4683 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 4684 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 4685 UnlockDisplay(dpy); SyncHandle(); |
| 4686 } |
| 4687 return; |
| 4688 } |
| 4689 } |
| 4690 |
| 4691 #define X_GLrop_ColorSubTable 195 |
| 4692 void __indirect_glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLe
num format, GLenum type, const GLvoid * data) |
| 4693 { |
| 4694 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4695 const GLuint compsize = (data != NULL) ? __glImageSize(count, 1, 1, format,
type, target) : 0; |
| 4696 const GLuint cmdlen = 44 + __GLX_PAD(compsize); |
| 4697 if (__builtin_expect(gc->currentDpy != NULL, 1)) { |
| 4698 if (cmdlen <= gc->maxSmallRenderCommandSize) { |
| 4699 if ( (gc->pc + cmdlen) > gc->bufEnd ) { |
| 4700 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 4701 } |
| 4702 emit_header(gc->pc, X_GLrop_ColorSubTable, cmdlen); |
| 4703 (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4); |
| 4704 (void) memcpy((void *)(gc->pc + 28), (void *)(&start), 4); |
| 4705 (void) memcpy((void *)(gc->pc + 32), (void *)(&count), 4); |
| 4706 (void) memcpy((void *)(gc->pc + 36), (void *)(&format), 4); |
| 4707 (void) memcpy((void *)(gc->pc + 40), (void *)(&type), 4); |
| 4708 if (compsize > 0) { |
| 4709 (*gc->fillImage)(gc, 1, count, 1, 1, format, type, data, gc->pc + 44, gc->pc
+ 4); |
| 4710 } else { |
| 4711 (void) memcpy( gc->pc + 4, default_pixel_store_1D, default_pixel_store_1D_si
ze ); |
| 4712 } |
| 4713 gc->pc += cmdlen; |
| 4714 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } |
| 4715 } |
| 4716 else { |
| 4717 const GLint op = X_GLrop_ColorSubTable; |
| 4718 const GLuint cmdlenLarge = cmdlen + 4; |
| 4719 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); |
| 4720 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); |
| 4721 (void) memcpy((void *)(pc + 4), (void *)(&op), 4); |
| 4722 (void) memcpy((void *)(pc + 28), (void *)(&target), 4); |
| 4723 (void) memcpy((void *)(pc + 32), (void *)(&start), 4); |
| 4724 (void) memcpy((void *)(pc + 36), (void *)(&count), 4); |
| 4725 (void) memcpy((void *)(pc + 40), (void *)(&format), 4); |
| 4726 (void) memcpy((void *)(pc + 44), (void *)(&type), 4); |
| 4727 __glXSendLargeImage(gc, compsize, 1, count, 1, 1, format, type, data, pc + 48, p
c + 8); |
| 4728 } |
| 4729 } |
| 4730 } |
| 4731 |
| 4732 #define X_GLrop_CopyColorSubTable 196 |
| 4733 void __indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint
y, GLsizei width) |
| 4734 { |
| 4735 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4736 const GLuint cmdlen = 24; |
| 4737 emit_header(gc->pc, X_GLrop_CopyColorSubTable, cmdlen); |
| 4738 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 4739 (void) memcpy((void *)(gc->pc + 8), (void *)(&start), 4); |
| 4740 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4); |
| 4741 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4); |
| 4742 (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4); |
| 4743 gc->pc += cmdlen; |
| 4744 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4745 } |
| 4746 |
| 4747 static void |
| 4748 __glx_ConvolutionFilter_1D2D( unsigned opcode, unsigned dim, GLenum target, GLen
um internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, co
nst GLvoid * image ) |
| 4749 { |
| 4750 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4751 const GLuint compsize = (image != NULL) ? __glImageSize(width, height, 1, fo
rmat, type, target) : 0; |
| 4752 const GLuint cmdlen = 48 + __GLX_PAD(compsize); |
| 4753 if (__builtin_expect(gc->currentDpy != NULL, 1)) { |
| 4754 if (cmdlen <= gc->maxSmallRenderCommandSize) { |
| 4755 if ( (gc->pc + cmdlen) > gc->bufEnd ) { |
| 4756 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 4757 } |
| 4758 emit_header(gc->pc, opcode, cmdlen); |
| 4759 (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4); |
| 4760 (void) memcpy((void *)(gc->pc + 28), (void *)(&internalformat), 4); |
| 4761 (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4); |
| 4762 (void) memcpy((void *)(gc->pc + 36), (void *)(&height), 4); |
| 4763 (void) memcpy((void *)(gc->pc + 40), (void *)(&format), 4); |
| 4764 (void) memcpy((void *)(gc->pc + 44), (void *)(&type), 4); |
| 4765 if (compsize > 0) { |
| 4766 (*gc->fillImage)(gc, dim, width, height, 1, format, type, image, gc->pc + 48
, gc->pc + 4); |
| 4767 } else { |
| 4768 (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_si
ze ); |
| 4769 } |
| 4770 gc->pc += cmdlen; |
| 4771 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } |
| 4772 } |
| 4773 else { |
| 4774 const GLint op = opcode; |
| 4775 const GLuint cmdlenLarge = cmdlen + 4; |
| 4776 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); |
| 4777 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); |
| 4778 (void) memcpy((void *)(pc + 4), (void *)(&op), 4); |
| 4779 (void) memcpy((void *)(pc + 28), (void *)(&target), 4); |
| 4780 (void) memcpy((void *)(pc + 32), (void *)(&internalformat), 4); |
| 4781 (void) memcpy((void *)(pc + 36), (void *)(&width), 4); |
| 4782 (void) memcpy((void *)(pc + 40), (void *)(&height), 4); |
| 4783 (void) memcpy((void *)(pc + 44), (void *)(&format), 4); |
| 4784 (void) memcpy((void *)(pc + 48), (void *)(&type), 4); |
| 4785 __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, image, pc
+ 52, pc + 8); |
| 4786 } |
| 4787 } |
| 4788 } |
| 4789 |
| 4790 #define X_GLrop_ConvolutionFilter1D 4101 |
| 4791 void __indirect_glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsi
zei width, GLenum format, GLenum type, const GLvoid * image) |
| 4792 { |
| 4793 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter1D, 1, target, interna
lformat, width, 1, format, type, image ); |
| 4794 } |
| 4795 |
| 4796 #define X_GLrop_ConvolutionFilter2D 4102 |
| 4797 void __indirect_glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsi
zei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image) |
| 4798 { |
| 4799 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter2D, 2, target, interna
lformat, width, height, format, type, image ); |
| 4800 } |
| 4801 |
| 4802 #define X_GLrop_ConvolutionParameterf 4103 |
| 4803 void __indirect_glConvolutionParameterf(GLenum target, GLenum pname, GLfloat par
ams) |
| 4804 { |
| 4805 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4806 const GLuint cmdlen = 16; |
| 4807 emit_header(gc->pc, X_GLrop_ConvolutionParameterf, cmdlen); |
| 4808 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 4809 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 4810 (void) memcpy((void *)(gc->pc + 12), (void *)(¶ms), 4); |
| 4811 gc->pc += cmdlen; |
| 4812 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4813 } |
| 4814 |
| 4815 #define X_GLrop_ConvolutionParameterfv 4104 |
| 4816 void __indirect_glConvolutionParameterfv(GLenum target, GLenum pname, const GLfl
oat * params) |
| 4817 { |
| 4818 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4819 const GLuint compsize = __glConvolutionParameterfv_size(pname); |
| 4820 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4)); |
| 4821 emit_header(gc->pc, X_GLrop_ConvolutionParameterfv, cmdlen); |
| 4822 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 4823 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 4824 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4)); |
| 4825 gc->pc += cmdlen; |
| 4826 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4827 } |
| 4828 |
| 4829 #define X_GLrop_ConvolutionParameteri 4105 |
| 4830 void __indirect_glConvolutionParameteri(GLenum target, GLenum pname, GLint param
s) |
| 4831 { |
| 4832 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4833 const GLuint cmdlen = 16; |
| 4834 emit_header(gc->pc, X_GLrop_ConvolutionParameteri, cmdlen); |
| 4835 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 4836 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 4837 (void) memcpy((void *)(gc->pc + 12), (void *)(¶ms), 4); |
| 4838 gc->pc += cmdlen; |
| 4839 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4840 } |
| 4841 |
| 4842 #define X_GLrop_ConvolutionParameteriv 4106 |
| 4843 void __indirect_glConvolutionParameteriv(GLenum target, GLenum pname, const GLin
t * params) |
| 4844 { |
| 4845 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4846 const GLuint compsize = __glConvolutionParameteriv_size(pname); |
| 4847 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4)); |
| 4848 emit_header(gc->pc, X_GLrop_ConvolutionParameteriv, cmdlen); |
| 4849 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 4850 (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); |
| 4851 (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4)); |
| 4852 gc->pc += cmdlen; |
| 4853 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4854 } |
| 4855 |
| 4856 #define X_GLrop_CopyConvolutionFilter1D 4107 |
| 4857 void __indirect_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat,
GLint x, GLint y, GLsizei width) |
| 4858 { |
| 4859 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4860 const GLuint cmdlen = 24; |
| 4861 emit_header(gc->pc, X_GLrop_CopyConvolutionFilter1D, cmdlen); |
| 4862 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 4863 (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4); |
| 4864 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4); |
| 4865 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4); |
| 4866 (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4); |
| 4867 gc->pc += cmdlen; |
| 4868 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4869 } |
| 4870 |
| 4871 #define X_GLrop_CopyConvolutionFilter2D 4108 |
| 4872 void __indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat,
GLint x, GLint y, GLsizei width, GLsizei height) |
| 4873 { |
| 4874 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4875 const GLuint cmdlen = 28; |
| 4876 emit_header(gc->pc, X_GLrop_CopyConvolutionFilter2D, cmdlen); |
| 4877 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 4878 (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4); |
| 4879 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4); |
| 4880 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4); |
| 4881 (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4); |
| 4882 (void) memcpy((void *)(gc->pc + 24), (void *)(&height), 4); |
| 4883 gc->pc += cmdlen; |
| 4884 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 4885 } |
| 4886 |
| 4887 #define X_GLsop_GetConvolutionFilter 150 |
| 4888 void __indirect_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type
, GLvoid * image) |
| 4889 { |
| 4890 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4891 const __GLXattribute * const state = gc->client_state_private; |
| 4892 Display * const dpy = gc->currentDpy; |
| 4893 #ifndef USE_XCB |
| 4894 const GLuint cmdlen = 16; |
| 4895 #endif |
| 4896 if (__builtin_expect(dpy != NULL, 1)) { |
| 4897 #ifdef USE_XCB |
| 4898 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 4899 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 4900 xcb_glx_get_convolution_filter_reply_t *reply = xcb_glx_get_convolution_
filter_reply(c, xcb_glx_get_convolution_filter(c, gc->currentContextTag, target,
format, type, state->storePack.swapEndian), NULL); |
| 4901 if (reply->height == 0) { reply->height = 1; } |
| 4902 __glEmptyImage(gc, 3, reply->width, reply->height, 1, format, type, xcb_
glx_get_convolution_filter_data(reply), image); |
| 4903 free(reply); |
| 4904 #else |
| 4905 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionF
ilter, cmdlen); |
| 4906 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 4907 (void) memcpy((void *)(pc + 4), (void *)(&format), 4); |
| 4908 (void) memcpy((void *)(pc + 8), (void *)(&type), 4); |
| 4909 *(int32_t *)(pc + 12) = 0; |
| 4910 * (int8_t *)(pc + 12) = state->storePack.swapEndian; |
| 4911 __glXReadPixelReply(dpy, gc, 2, 0, 0, 0, format, type, image, GL_TRUE); |
| 4912 UnlockDisplay(dpy); SyncHandle(); |
| 4913 #endif /* USE_XCB */ |
| 4914 } |
| 4915 return; |
| 4916 } |
| 4917 |
| 4918 #define X_GLvop_GetConvolutionFilterEXT 1 |
| 4919 void gl_dispatch_stub_356(GLenum target, GLenum format, GLenum type, GLvoid * im
age) |
| 4920 { |
| 4921 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4922 |
| 4923 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) |
| 4924 if (gc->isDirect) { |
| 4925 const _glapi_proc *const disp_table = GET_DISPATCH(); |
| 4926 PFNGLGETCONVOLUTIONFILTEREXTPROC p = |
| 4927 (PFNGLGETCONVOLUTIONFILTEREXTPROC) disp_table[356]; |
| 4928 p(target, format, type, image); |
| 4929 } else |
| 4930 #endif |
| 4931 { |
| 4932 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4933 const __GLXattribute * const state = gc->client_state_private; |
| 4934 Display * const dpy = gc->currentDpy; |
| 4935 const GLuint cmdlen = 16; |
| 4936 if (__builtin_expect(dpy != NULL, 1)) { |
| 4937 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetConvolutionFilterEXT, cmdlen); |
| 4938 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 4939 (void) memcpy((void *)(pc + 4), (void *)(&format), 4); |
| 4940 (void) memcpy((void *)(pc + 8), (void *)(&type), 4); |
| 4941 *(int32_t *)(pc + 12) = 0; |
| 4942 * (int8_t *)(pc + 12) = state->storePack.swapEndian; |
| 4943 __glXReadPixelReply(dpy, gc, 2, 0, 0, 0, format, type, image, GL_TRUE); |
| 4944 UnlockDisplay(dpy); SyncHandle(); |
| 4945 } |
| 4946 return; |
| 4947 } |
| 4948 } |
| 4949 |
| 4950 #define X_GLsop_GetConvolutionParameterfv 151 |
| 4951 void __indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat
* params) |
| 4952 { |
| 4953 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4954 Display * const dpy = gc->currentDpy; |
| 4955 #ifndef USE_XCB |
| 4956 const GLuint cmdlen = 8; |
| 4957 #endif |
| 4958 if (__builtin_expect(dpy != NULL, 1)) { |
| 4959 #ifdef USE_XCB |
| 4960 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 4961 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 4962 xcb_glx_get_convolution_parameterfv_reply_t *reply = xcb_glx_get_convolu
tion_parameterfv_reply(c, xcb_glx_get_convolution_parameterfv(c, gc->currentCont
extTag, target, pname), NULL); |
| 4963 if (xcb_glx_get_convolution_parameterfv_data_length(reply) == 0) |
| 4964 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 4965 else |
| 4966 (void)memcpy(params, xcb_glx_get_convolution_parameterfv_data(reply)
, xcb_glx_get_convolution_parameterfv_data_length(reply) * sizeof(GLfloat)); |
| 4967 free(reply); |
| 4968 #else |
| 4969 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionP
arameterfv, cmdlen); |
| 4970 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 4971 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 4972 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 4973 UnlockDisplay(dpy); SyncHandle(); |
| 4974 #endif /* USE_XCB */ |
| 4975 } |
| 4976 return; |
| 4977 } |
| 4978 |
| 4979 #define X_GLvop_GetConvolutionParameterfvEXT 2 |
| 4980 void gl_dispatch_stub_357(GLenum target, GLenum pname, GLfloat * params) |
| 4981 { |
| 4982 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4983 |
| 4984 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) |
| 4985 if (gc->isDirect) { |
| 4986 const _glapi_proc *const disp_table = GET_DISPATCH(); |
| 4987 PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC p = |
| 4988 (PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC) disp_table[357]; |
| 4989 p(target, pname, params); |
| 4990 } else |
| 4991 #endif |
| 4992 { |
| 4993 struct glx_context * const gc = __glXGetCurrentContext(); |
| 4994 Display * const dpy = gc->currentDpy; |
| 4995 const GLuint cmdlen = 8; |
| 4996 if (__builtin_expect(dpy != NULL, 1)) { |
| 4997 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetConvolutionParameterfvEXT, cmdlen); |
| 4998 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 4999 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 5000 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 5001 UnlockDisplay(dpy); SyncHandle(); |
| 5002 } |
| 5003 return; |
| 5004 } |
| 5005 } |
| 5006 |
| 5007 #define X_GLsop_GetConvolutionParameteriv 152 |
| 5008 void __indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *
params) |
| 5009 { |
| 5010 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5011 Display * const dpy = gc->currentDpy; |
| 5012 #ifndef USE_XCB |
| 5013 const GLuint cmdlen = 8; |
| 5014 #endif |
| 5015 if (__builtin_expect(dpy != NULL, 1)) { |
| 5016 #ifdef USE_XCB |
| 5017 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 5018 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 5019 xcb_glx_get_convolution_parameteriv_reply_t *reply = xcb_glx_get_convolu
tion_parameteriv_reply(c, xcb_glx_get_convolution_parameteriv(c, gc->currentCont
extTag, target, pname), NULL); |
| 5020 if (xcb_glx_get_convolution_parameteriv_data_length(reply) == 0) |
| 5021 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 5022 else |
| 5023 (void)memcpy(params, xcb_glx_get_convolution_parameteriv_data(reply)
, xcb_glx_get_convolution_parameteriv_data_length(reply) * sizeof(GLint)); |
| 5024 free(reply); |
| 5025 #else |
| 5026 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionP
arameteriv, cmdlen); |
| 5027 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 5028 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 5029 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 5030 UnlockDisplay(dpy); SyncHandle(); |
| 5031 #endif /* USE_XCB */ |
| 5032 } |
| 5033 return; |
| 5034 } |
| 5035 |
| 5036 #define X_GLvop_GetConvolutionParameterivEXT 3 |
| 5037 void gl_dispatch_stub_358(GLenum target, GLenum pname, GLint * params) |
| 5038 { |
| 5039 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5040 |
| 5041 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) |
| 5042 if (gc->isDirect) { |
| 5043 const _glapi_proc *const disp_table = GET_DISPATCH(); |
| 5044 PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC p = |
| 5045 (PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC) disp_table[358]; |
| 5046 p(target, pname, params); |
| 5047 } else |
| 5048 #endif |
| 5049 { |
| 5050 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5051 Display * const dpy = gc->currentDpy; |
| 5052 const GLuint cmdlen = 8; |
| 5053 if (__builtin_expect(dpy != NULL, 1)) { |
| 5054 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetConvolutionParameterivEXT, cmdlen); |
| 5055 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 5056 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 5057 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 5058 UnlockDisplay(dpy); SyncHandle(); |
| 5059 } |
| 5060 return; |
| 5061 } |
| 5062 } |
| 5063 |
| 5064 #define X_GLsop_GetHistogram 154 |
| 5065 void __indirect_glGetHistogram(GLenum target, GLboolean reset, GLenum format, GL
enum type, GLvoid * values) |
| 5066 { |
| 5067 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5068 const __GLXattribute * const state = gc->client_state_private; |
| 5069 Display * const dpy = gc->currentDpy; |
| 5070 #ifndef USE_XCB |
| 5071 const GLuint cmdlen = 16; |
| 5072 #endif |
| 5073 if (__builtin_expect(dpy != NULL, 1)) { |
| 5074 #ifdef USE_XCB |
| 5075 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 5076 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 5077 xcb_glx_get_histogram_reply_t *reply = xcb_glx_get_histogram_reply(c, xc
b_glx_get_histogram(c, gc->currentContextTag, target, reset, format, type, state
->storePack.swapEndian), NULL); |
| 5078 __glEmptyImage(gc, 3, reply->width, 1, 1, format, type, xcb_glx_get_hist
ogram_data(reply), values); |
| 5079 free(reply); |
| 5080 #else |
| 5081 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogram, c
mdlen); |
| 5082 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 5083 (void) memcpy((void *)(pc + 4), (void *)(&format), 4); |
| 5084 (void) memcpy((void *)(pc + 8), (void *)(&type), 4); |
| 5085 *(int32_t *)(pc + 12) = 0; |
| 5086 * (int8_t *)(pc + 12) = state->storePack.swapEndian; |
| 5087 * (int8_t *)(pc + 13) = reset; |
| 5088 __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, values, GL_TRUE); |
| 5089 UnlockDisplay(dpy); SyncHandle(); |
| 5090 #endif /* USE_XCB */ |
| 5091 } |
| 5092 return; |
| 5093 } |
| 5094 |
| 5095 #define X_GLvop_GetHistogramEXT 5 |
| 5096 void gl_dispatch_stub_361(GLenum target, GLboolean reset, GLenum format, GLenum
type, GLvoid * values) |
| 5097 { |
| 5098 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5099 |
| 5100 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) |
| 5101 if (gc->isDirect) { |
| 5102 const _glapi_proc *const disp_table = GET_DISPATCH(); |
| 5103 PFNGLGETHISTOGRAMEXTPROC p = |
| 5104 (PFNGLGETHISTOGRAMEXTPROC) disp_table[361]; |
| 5105 p(target, reset, format, type, values); |
| 5106 } else |
| 5107 #endif |
| 5108 { |
| 5109 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5110 const __GLXattribute * const state = gc->client_state_private; |
| 5111 Display * const dpy = gc->currentDpy; |
| 5112 const GLuint cmdlen = 16; |
| 5113 if (__builtin_expect(dpy != NULL, 1)) { |
| 5114 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetHistogramEXT, cmdlen); |
| 5115 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 5116 (void) memcpy((void *)(pc + 4), (void *)(&format), 4); |
| 5117 (void) memcpy((void *)(pc + 8), (void *)(&type), 4); |
| 5118 *(int32_t *)(pc + 12) = 0; |
| 5119 * (int8_t *)(pc + 12) = state->storePack.swapEndian; |
| 5120 * (int8_t *)(pc + 13) = reset; |
| 5121 __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, values, GL_TRUE); |
| 5122 UnlockDisplay(dpy); SyncHandle(); |
| 5123 } |
| 5124 return; |
| 5125 } |
| 5126 } |
| 5127 |
| 5128 #define X_GLsop_GetHistogramParameterfv 155 |
| 5129 void __indirect_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *
params) |
| 5130 { |
| 5131 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5132 Display * const dpy = gc->currentDpy; |
| 5133 #ifndef USE_XCB |
| 5134 const GLuint cmdlen = 8; |
| 5135 #endif |
| 5136 if (__builtin_expect(dpy != NULL, 1)) { |
| 5137 #ifdef USE_XCB |
| 5138 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 5139 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 5140 xcb_glx_get_histogram_parameterfv_reply_t *reply = xcb_glx_get_histogram
_parameterfv_reply(c, xcb_glx_get_histogram_parameterfv(c, gc->currentContextTag
, target, pname), NULL); |
| 5141 if (xcb_glx_get_histogram_parameterfv_data_length(reply) == 0) |
| 5142 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 5143 else |
| 5144 (void)memcpy(params, xcb_glx_get_histogram_parameterfv_data(reply),
xcb_glx_get_histogram_parameterfv_data_length(reply) * sizeof(GLfloat)); |
| 5145 free(reply); |
| 5146 #else |
| 5147 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogramPar
ameterfv, cmdlen); |
| 5148 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 5149 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 5150 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 5151 UnlockDisplay(dpy); SyncHandle(); |
| 5152 #endif /* USE_XCB */ |
| 5153 } |
| 5154 return; |
| 5155 } |
| 5156 |
| 5157 #define X_GLvop_GetHistogramParameterfvEXT 6 |
| 5158 void gl_dispatch_stub_362(GLenum target, GLenum pname, GLfloat * params) |
| 5159 { |
| 5160 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5161 |
| 5162 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) |
| 5163 if (gc->isDirect) { |
| 5164 const _glapi_proc *const disp_table = GET_DISPATCH(); |
| 5165 PFNGLGETHISTOGRAMPARAMETERFVEXTPROC p = |
| 5166 (PFNGLGETHISTOGRAMPARAMETERFVEXTPROC) disp_table[362]; |
| 5167 p(target, pname, params); |
| 5168 } else |
| 5169 #endif |
| 5170 { |
| 5171 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5172 Display * const dpy = gc->currentDpy; |
| 5173 const GLuint cmdlen = 8; |
| 5174 if (__builtin_expect(dpy != NULL, 1)) { |
| 5175 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetHistogramParameterfvEXT, cmdlen); |
| 5176 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 5177 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 5178 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 5179 UnlockDisplay(dpy); SyncHandle(); |
| 5180 } |
| 5181 return; |
| 5182 } |
| 5183 } |
| 5184 |
| 5185 #define X_GLsop_GetHistogramParameteriv 156 |
| 5186 void __indirect_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint * p
arams) |
| 5187 { |
| 5188 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5189 Display * const dpy = gc->currentDpy; |
| 5190 #ifndef USE_XCB |
| 5191 const GLuint cmdlen = 8; |
| 5192 #endif |
| 5193 if (__builtin_expect(dpy != NULL, 1)) { |
| 5194 #ifdef USE_XCB |
| 5195 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 5196 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 5197 xcb_glx_get_histogram_parameteriv_reply_t *reply = xcb_glx_get_histogram
_parameteriv_reply(c, xcb_glx_get_histogram_parameteriv(c, gc->currentContextTag
, target, pname), NULL); |
| 5198 if (xcb_glx_get_histogram_parameteriv_data_length(reply) == 0) |
| 5199 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 5200 else |
| 5201 (void)memcpy(params, xcb_glx_get_histogram_parameteriv_data(reply),
xcb_glx_get_histogram_parameteriv_data_length(reply) * sizeof(GLint)); |
| 5202 free(reply); |
| 5203 #else |
| 5204 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogramPar
ameteriv, cmdlen); |
| 5205 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 5206 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 5207 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 5208 UnlockDisplay(dpy); SyncHandle(); |
| 5209 #endif /* USE_XCB */ |
| 5210 } |
| 5211 return; |
| 5212 } |
| 5213 |
| 5214 #define X_GLvop_GetHistogramParameterivEXT 7 |
| 5215 void gl_dispatch_stub_363(GLenum target, GLenum pname, GLint * params) |
| 5216 { |
| 5217 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5218 |
| 5219 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) |
| 5220 if (gc->isDirect) { |
| 5221 const _glapi_proc *const disp_table = GET_DISPATCH(); |
| 5222 PFNGLGETHISTOGRAMPARAMETERIVEXTPROC p = |
| 5223 (PFNGLGETHISTOGRAMPARAMETERIVEXTPROC) disp_table[363]; |
| 5224 p(target, pname, params); |
| 5225 } else |
| 5226 #endif |
| 5227 { |
| 5228 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5229 Display * const dpy = gc->currentDpy; |
| 5230 const GLuint cmdlen = 8; |
| 5231 if (__builtin_expect(dpy != NULL, 1)) { |
| 5232 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetHistogramParameterivEXT, cmdlen); |
| 5233 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 5234 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 5235 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 5236 UnlockDisplay(dpy); SyncHandle(); |
| 5237 } |
| 5238 return; |
| 5239 } |
| 5240 } |
| 5241 |
| 5242 #define X_GLsop_GetMinmax 157 |
| 5243 void __indirect_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenu
m type, GLvoid * values) |
| 5244 { |
| 5245 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5246 const __GLXattribute * const state = gc->client_state_private; |
| 5247 Display * const dpy = gc->currentDpy; |
| 5248 #ifndef USE_XCB |
| 5249 const GLuint cmdlen = 16; |
| 5250 #endif |
| 5251 if (__builtin_expect(dpy != NULL, 1)) { |
| 5252 #ifdef USE_XCB |
| 5253 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 5254 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 5255 xcb_glx_get_minmax_reply_t *reply = xcb_glx_get_minmax_reply(c, xcb_glx_
get_minmax(c, gc->currentContextTag, target, reset, format, type, state->storePa
ck.swapEndian), NULL); |
| 5256 __glEmptyImage(gc, 3, 2, 1, 1, format, type, xcb_glx_get_minmax_data(rep
ly), values); |
| 5257 free(reply); |
| 5258 #else |
| 5259 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmax, cmdl
en); |
| 5260 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 5261 (void) memcpy((void *)(pc + 4), (void *)(&format), 4); |
| 5262 (void) memcpy((void *)(pc + 8), (void *)(&type), 4); |
| 5263 *(int32_t *)(pc + 12) = 0; |
| 5264 * (int8_t *)(pc + 12) = state->storePack.swapEndian; |
| 5265 * (int8_t *)(pc + 13) = reset; |
| 5266 __glXReadPixelReply(dpy, gc, 1, 2, 1, 1, format, type, values, GL_FALSE)
; |
| 5267 UnlockDisplay(dpy); SyncHandle(); |
| 5268 #endif /* USE_XCB */ |
| 5269 } |
| 5270 return; |
| 5271 } |
| 5272 |
| 5273 #define X_GLvop_GetMinmaxEXT 8 |
| 5274 void gl_dispatch_stub_364(GLenum target, GLboolean reset, GLenum format, GLenum
type, GLvoid * values) |
| 5275 { |
| 5276 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5277 |
| 5278 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) |
| 5279 if (gc->isDirect) { |
| 5280 const _glapi_proc *const disp_table = GET_DISPATCH(); |
| 5281 PFNGLGETMINMAXEXTPROC p = |
| 5282 (PFNGLGETMINMAXEXTPROC) disp_table[364]; |
| 5283 p(target, reset, format, type, values); |
| 5284 } else |
| 5285 #endif |
| 5286 { |
| 5287 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5288 const __GLXattribute * const state = gc->client_state_private; |
| 5289 Display * const dpy = gc->currentDpy; |
| 5290 const GLuint cmdlen = 16; |
| 5291 if (__builtin_expect(dpy != NULL, 1)) { |
| 5292 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetMinmaxEXT, cmdlen); |
| 5293 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 5294 (void) memcpy((void *)(pc + 4), (void *)(&format), 4); |
| 5295 (void) memcpy((void *)(pc + 8), (void *)(&type), 4); |
| 5296 *(int32_t *)(pc + 12) = 0; |
| 5297 * (int8_t *)(pc + 12) = state->storePack.swapEndian; |
| 5298 * (int8_t *)(pc + 13) = reset; |
| 5299 __glXReadPixelReply(dpy, gc, 1, 2, 1, 1, format, type, values, GL_FALSE)
; |
| 5300 UnlockDisplay(dpy); SyncHandle(); |
| 5301 } |
| 5302 return; |
| 5303 } |
| 5304 } |
| 5305 |
| 5306 #define X_GLsop_GetMinmaxParameterfv 158 |
| 5307 void __indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat * pa
rams) |
| 5308 { |
| 5309 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5310 Display * const dpy = gc->currentDpy; |
| 5311 #ifndef USE_XCB |
| 5312 const GLuint cmdlen = 8; |
| 5313 #endif |
| 5314 if (__builtin_expect(dpy != NULL, 1)) { |
| 5315 #ifdef USE_XCB |
| 5316 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 5317 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 5318 xcb_glx_get_minmax_parameterfv_reply_t *reply = xcb_glx_get_minmax_param
eterfv_reply(c, xcb_glx_get_minmax_parameterfv(c, gc->currentContextTag, target,
pname), NULL); |
| 5319 if (xcb_glx_get_minmax_parameterfv_data_length(reply) == 0) |
| 5320 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 5321 else |
| 5322 (void)memcpy(params, xcb_glx_get_minmax_parameterfv_data(reply), xcb
_glx_get_minmax_parameterfv_data_length(reply) * sizeof(GLfloat)); |
| 5323 free(reply); |
| 5324 #else |
| 5325 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParame
terfv, cmdlen); |
| 5326 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 5327 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 5328 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 5329 UnlockDisplay(dpy); SyncHandle(); |
| 5330 #endif /* USE_XCB */ |
| 5331 } |
| 5332 return; |
| 5333 } |
| 5334 |
| 5335 #define X_GLvop_GetMinmaxParameterfvEXT 9 |
| 5336 void gl_dispatch_stub_365(GLenum target, GLenum pname, GLfloat * params) |
| 5337 { |
| 5338 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5339 |
| 5340 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) |
| 5341 if (gc->isDirect) { |
| 5342 const _glapi_proc *const disp_table = GET_DISPATCH(); |
| 5343 PFNGLGETMINMAXPARAMETERFVEXTPROC p = |
| 5344 (PFNGLGETMINMAXPARAMETERFVEXTPROC) disp_table[365]; |
| 5345 p(target, pname, params); |
| 5346 } else |
| 5347 #endif |
| 5348 { |
| 5349 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5350 Display * const dpy = gc->currentDpy; |
| 5351 const GLuint cmdlen = 8; |
| 5352 if (__builtin_expect(dpy != NULL, 1)) { |
| 5353 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetMinmaxParameterfvEXT, cmdlen); |
| 5354 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 5355 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 5356 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 5357 UnlockDisplay(dpy); SyncHandle(); |
| 5358 } |
| 5359 return; |
| 5360 } |
| 5361 } |
| 5362 |
| 5363 #define X_GLsop_GetMinmaxParameteriv 159 |
| 5364 void __indirect_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint * para
ms) |
| 5365 { |
| 5366 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5367 Display * const dpy = gc->currentDpy; |
| 5368 #ifndef USE_XCB |
| 5369 const GLuint cmdlen = 8; |
| 5370 #endif |
| 5371 if (__builtin_expect(dpy != NULL, 1)) { |
| 5372 #ifdef USE_XCB |
| 5373 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 5374 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 5375 xcb_glx_get_minmax_parameteriv_reply_t *reply = xcb_glx_get_minmax_param
eteriv_reply(c, xcb_glx_get_minmax_parameteriv(c, gc->currentContextTag, target,
pname), NULL); |
| 5376 if (xcb_glx_get_minmax_parameteriv_data_length(reply) == 0) |
| 5377 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 5378 else |
| 5379 (void)memcpy(params, xcb_glx_get_minmax_parameteriv_data(reply), xcb
_glx_get_minmax_parameteriv_data_length(reply) * sizeof(GLint)); |
| 5380 free(reply); |
| 5381 #else |
| 5382 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParame
teriv, cmdlen); |
| 5383 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 5384 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 5385 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 5386 UnlockDisplay(dpy); SyncHandle(); |
| 5387 #endif /* USE_XCB */ |
| 5388 } |
| 5389 return; |
| 5390 } |
| 5391 |
| 5392 #define X_GLvop_GetMinmaxParameterivEXT 10 |
| 5393 void gl_dispatch_stub_366(GLenum target, GLenum pname, GLint * params) |
| 5394 { |
| 5395 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5396 |
| 5397 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) |
| 5398 if (gc->isDirect) { |
| 5399 const _glapi_proc *const disp_table = GET_DISPATCH(); |
| 5400 PFNGLGETMINMAXPARAMETERIVEXTPROC p = |
| 5401 (PFNGLGETMINMAXPARAMETERIVEXTPROC) disp_table[366]; |
| 5402 p(target, pname, params); |
| 5403 } else |
| 5404 #endif |
| 5405 { |
| 5406 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5407 Display * const dpy = gc->currentDpy; |
| 5408 const GLuint cmdlen = 8; |
| 5409 if (__builtin_expect(dpy != NULL, 1)) { |
| 5410 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetMinmaxParameterivEXT, cmdlen); |
| 5411 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 5412 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 5413 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 5414 UnlockDisplay(dpy); SyncHandle(); |
| 5415 } |
| 5416 return; |
| 5417 } |
| 5418 } |
| 5419 |
| 5420 #define X_GLrop_Histogram 4110 |
| 5421 void __indirect_glHistogram(GLenum target, GLsizei width, GLenum internalformat,
GLboolean sink) |
| 5422 { |
| 5423 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5424 const GLuint cmdlen = 20; |
| 5425 emit_header(gc->pc, X_GLrop_Histogram, cmdlen); |
| 5426 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5427 (void) memcpy((void *)(gc->pc + 8), (void *)(&width), 4); |
| 5428 (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4); |
| 5429 (void) memcpy((void *)(gc->pc + 16), (void *)(&sink), 1); |
| 5430 gc->pc += cmdlen; |
| 5431 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5432 } |
| 5433 |
| 5434 #define X_GLrop_Minmax 4111 |
| 5435 void __indirect_glMinmax(GLenum target, GLenum internalformat, GLboolean sink) |
| 5436 { |
| 5437 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5438 const GLuint cmdlen = 16; |
| 5439 emit_header(gc->pc, X_GLrop_Minmax, cmdlen); |
| 5440 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5441 (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4); |
| 5442 (void) memcpy((void *)(gc->pc + 12), (void *)(&sink), 1); |
| 5443 gc->pc += cmdlen; |
| 5444 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5445 } |
| 5446 |
| 5447 #define X_GLrop_ResetHistogram 4112 |
| 5448 void __indirect_glResetHistogram(GLenum target) |
| 5449 { |
| 5450 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5451 const GLuint cmdlen = 8; |
| 5452 emit_header(gc->pc, X_GLrop_ResetHistogram, cmdlen); |
| 5453 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5454 gc->pc += cmdlen; |
| 5455 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5456 } |
| 5457 |
| 5458 #define X_GLrop_ResetMinmax 4113 |
| 5459 void __indirect_glResetMinmax(GLenum target) |
| 5460 { |
| 5461 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5462 const GLuint cmdlen = 8; |
| 5463 emit_header(gc->pc, X_GLrop_ResetMinmax, cmdlen); |
| 5464 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5465 gc->pc += cmdlen; |
| 5466 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5467 } |
| 5468 |
| 5469 static void |
| 5470 __glx_TexImage_3D4D( unsigned opcode, unsigned dim, GLenum target, GLint level,
GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei exte
nt, GLint border, GLenum format, GLenum type, const GLvoid * pixels ) |
| 5471 { |
| 5472 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5473 const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, dept
h, format, type, target) : 0; |
| 5474 const GLuint cmdlen = 84 + __GLX_PAD(compsize); |
| 5475 if (__builtin_expect(gc->currentDpy != NULL, 1)) { |
| 5476 if (cmdlen <= gc->maxSmallRenderCommandSize) { |
| 5477 if ( (gc->pc + cmdlen) > gc->bufEnd ) { |
| 5478 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 5479 } |
| 5480 emit_header(gc->pc, opcode, cmdlen); |
| 5481 (void) memcpy((void *)(gc->pc + 40), (void *)(&target), 4); |
| 5482 (void) memcpy((void *)(gc->pc + 44), (void *)(&level), 4); |
| 5483 (void) memcpy((void *)(gc->pc + 48), (void *)(&internalformat), 4); |
| 5484 (void) memcpy((void *)(gc->pc + 52), (void *)(&width), 4); |
| 5485 (void) memcpy((void *)(gc->pc + 56), (void *)(&height), 4); |
| 5486 (void) memcpy((void *)(gc->pc + 60), (void *)(&depth), 4); |
| 5487 (void) memcpy((void *)(gc->pc + 64), (void *)(&extent), 4); |
| 5488 (void) memcpy((void *)(gc->pc + 68), (void *)(&border), 4); |
| 5489 (void) memcpy((void *)(gc->pc + 72), (void *)(&format), 4); |
| 5490 (void) memcpy((void *)(gc->pc + 76), (void *)(&type), 4); |
| 5491 (void) memcpy((void *)(gc->pc + 80), (void *)((pixels == NULL) ? one : zero), 4)
; |
| 5492 if (compsize > 0) { |
| 5493 (*gc->fillImage)(gc, dim, width, height, depth, format, type, pixels, gc->pc
+ 84, gc->pc + 4); |
| 5494 } else { |
| 5495 (void) memcpy( gc->pc + 4, default_pixel_store_4D, default_pixel_store_4D_si
ze ); |
| 5496 } |
| 5497 gc->pc += cmdlen; |
| 5498 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } |
| 5499 } |
| 5500 else { |
| 5501 const GLint op = opcode; |
| 5502 const GLuint cmdlenLarge = cmdlen + 4; |
| 5503 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); |
| 5504 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); |
| 5505 (void) memcpy((void *)(pc + 4), (void *)(&op), 4); |
| 5506 (void) memcpy((void *)(pc + 44), (void *)(&target), 4); |
| 5507 (void) memcpy((void *)(pc + 48), (void *)(&level), 4); |
| 5508 (void) memcpy((void *)(pc + 52), (void *)(&internalformat), 4); |
| 5509 (void) memcpy((void *)(pc + 56), (void *)(&width), 4); |
| 5510 (void) memcpy((void *)(pc + 60), (void *)(&height), 4); |
| 5511 (void) memcpy((void *)(pc + 64), (void *)(&depth), 4); |
| 5512 (void) memcpy((void *)(pc + 68), (void *)(&extent), 4); |
| 5513 (void) memcpy((void *)(pc + 72), (void *)(&border), 4); |
| 5514 (void) memcpy((void *)(pc + 76), (void *)(&format), 4); |
| 5515 (void) memcpy((void *)(pc + 80), (void *)(&type), 4); |
| 5516 (void) memcpy((void *)(pc + 84), zero, 4); |
| 5517 __glXSendLargeImage(gc, compsize, dim, width, height, depth, format, type, pixel
s, pc + 88, pc + 8); |
| 5518 } |
| 5519 } |
| 5520 } |
| 5521 |
| 5522 #define X_GLrop_TexImage3D 4114 |
| 5523 void __indirect_glTexImage3D(GLenum target, GLint level, GLint internalformat, G
Lsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum
type, const GLvoid * pixels) |
| 5524 { |
| 5525 __glx_TexImage_3D4D(X_GLrop_TexImage3D, 3, target, level, internalformat, wi
dth, height, depth, 1, border, format, type, pixels ); |
| 5526 } |
| 5527 |
| 5528 static void |
| 5529 __glx_TexSubImage_3D4D( unsigned opcode, unsigned dim, GLenum target, GLint leve
l, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GL
sizei height, GLsizei depth, GLsizei extent, GLenum format, GLenum type, const G
Lvoid * pixels ) |
| 5530 { |
| 5531 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5532 const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, dept
h, format, type, target) : 0; |
| 5533 const GLuint cmdlen = 92 + __GLX_PAD(compsize); |
| 5534 if (__builtin_expect(gc->currentDpy != NULL, 1)) { |
| 5535 if (cmdlen <= gc->maxSmallRenderCommandSize) { |
| 5536 if ( (gc->pc + cmdlen) > gc->bufEnd ) { |
| 5537 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 5538 } |
| 5539 emit_header(gc->pc, opcode, cmdlen); |
| 5540 (void) memcpy((void *)(gc->pc + 40), (void *)(&target), 4); |
| 5541 (void) memcpy((void *)(gc->pc + 44), (void *)(&level), 4); |
| 5542 (void) memcpy((void *)(gc->pc + 48), (void *)(&xoffset), 4); |
| 5543 (void) memcpy((void *)(gc->pc + 52), (void *)(&yoffset), 4); |
| 5544 (void) memcpy((void *)(gc->pc + 56), (void *)(&zoffset), 4); |
| 5545 (void) memcpy((void *)(gc->pc + 60), (void *)(&woffset), 4); |
| 5546 (void) memcpy((void *)(gc->pc + 64), (void *)(&width), 4); |
| 5547 (void) memcpy((void *)(gc->pc + 68), (void *)(&height), 4); |
| 5548 (void) memcpy((void *)(gc->pc + 72), (void *)(&depth), 4); |
| 5549 (void) memcpy((void *)(gc->pc + 76), (void *)(&extent), 4); |
| 5550 (void) memcpy((void *)(gc->pc + 80), (void *)(&format), 4); |
| 5551 (void) memcpy((void *)(gc->pc + 84), (void *)(&type), 4); |
| 5552 (void) memset((void *)(gc->pc + 88), 0, 4); |
| 5553 if (compsize > 0) { |
| 5554 (*gc->fillImage)(gc, dim, width, height, depth, format, type, pixels, gc->pc
+ 92, gc->pc + 4); |
| 5555 } else { |
| 5556 (void) memcpy( gc->pc + 4, default_pixel_store_4D, default_pixel_store_4D_si
ze ); |
| 5557 } |
| 5558 gc->pc += cmdlen; |
| 5559 if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } |
| 5560 } |
| 5561 else { |
| 5562 const GLint op = opcode; |
| 5563 const GLuint cmdlenLarge = cmdlen + 4; |
| 5564 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); |
| 5565 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); |
| 5566 (void) memcpy((void *)(pc + 4), (void *)(&op), 4); |
| 5567 (void) memcpy((void *)(pc + 44), (void *)(&target), 4); |
| 5568 (void) memcpy((void *)(pc + 48), (void *)(&level), 4); |
| 5569 (void) memcpy((void *)(pc + 52), (void *)(&xoffset), 4); |
| 5570 (void) memcpy((void *)(pc + 56), (void *)(&yoffset), 4); |
| 5571 (void) memcpy((void *)(pc + 60), (void *)(&zoffset), 4); |
| 5572 (void) memcpy((void *)(pc + 64), (void *)(&woffset), 4); |
| 5573 (void) memcpy((void *)(pc + 68), (void *)(&width), 4); |
| 5574 (void) memcpy((void *)(pc + 72), (void *)(&height), 4); |
| 5575 (void) memcpy((void *)(pc + 76), (void *)(&depth), 4); |
| 5576 (void) memcpy((void *)(pc + 80), (void *)(&extent), 4); |
| 5577 (void) memcpy((void *)(pc + 84), (void *)(&format), 4); |
| 5578 (void) memcpy((void *)(pc + 88), (void *)(&type), 4); |
| 5579 (void) memset((void *)(pc + 92), 0, 4); |
| 5580 __glXSendLargeImage(gc, compsize, dim, width, height, depth, format, type, pixel
s, pc + 96, pc + 8); |
| 5581 } |
| 5582 } |
| 5583 } |
| 5584 |
| 5585 #define X_GLrop_TexSubImage3D 4115 |
| 5586 void __indirect_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint
yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum fo
rmat, GLenum type, const GLvoid * pixels) |
| 5587 { |
| 5588 __glx_TexSubImage_3D4D(X_GLrop_TexSubImage3D, 3, target, level, xoffset, yof
fset, zoffset, 1, width, height, depth, 1, format, type, pixels ); |
| 5589 } |
| 5590 |
| 5591 #define X_GLrop_CopyTexSubImage3D 4123 |
| 5592 void __indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, G
Lint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) |
| 5593 { |
| 5594 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5595 const GLuint cmdlen = 40; |
| 5596 emit_header(gc->pc, X_GLrop_CopyTexSubImage3D, cmdlen); |
| 5597 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5598 (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4); |
| 5599 (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4); |
| 5600 (void) memcpy((void *)(gc->pc + 16), (void *)(&yoffset), 4); |
| 5601 (void) memcpy((void *)(gc->pc + 20), (void *)(&zoffset), 4); |
| 5602 (void) memcpy((void *)(gc->pc + 24), (void *)(&x), 4); |
| 5603 (void) memcpy((void *)(gc->pc + 28), (void *)(&y), 4); |
| 5604 (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4); |
| 5605 (void) memcpy((void *)(gc->pc + 36), (void *)(&height), 4); |
| 5606 gc->pc += cmdlen; |
| 5607 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5608 } |
| 5609 |
| 5610 #define X_GLrop_ActiveTextureARB 197 |
| 5611 void __indirect_glActiveTextureARB(GLenum texture) |
| 5612 { |
| 5613 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5614 const GLuint cmdlen = 8; |
| 5615 emit_header(gc->pc, X_GLrop_ActiveTextureARB, cmdlen); |
| 5616 (void) memcpy((void *)(gc->pc + 4), (void *)(&texture), 4); |
| 5617 gc->pc += cmdlen; |
| 5618 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5619 } |
| 5620 |
| 5621 #define X_GLrop_MultiTexCoord1dvARB 198 |
| 5622 void __indirect_glMultiTexCoord1dARB(GLenum target, GLdouble s) |
| 5623 { |
| 5624 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5625 const GLuint cmdlen = 16; |
| 5626 emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen); |
| 5627 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8); |
| 5628 (void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4); |
| 5629 gc->pc += cmdlen; |
| 5630 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5631 } |
| 5632 |
| 5633 #define X_GLrop_MultiTexCoord1dvARB 198 |
| 5634 void __indirect_glMultiTexCoord1dvARB(GLenum target, const GLdouble * v) |
| 5635 { |
| 5636 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5637 const GLuint cmdlen = 16; |
| 5638 emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen); |
| 5639 (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8); |
| 5640 (void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4); |
| 5641 gc->pc += cmdlen; |
| 5642 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5643 } |
| 5644 |
| 5645 #define X_GLrop_MultiTexCoord1fvARB 199 |
| 5646 void __indirect_glMultiTexCoord1fARB(GLenum target, GLfloat s) |
| 5647 { |
| 5648 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5649 const GLuint cmdlen = 12; |
| 5650 emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen); |
| 5651 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5652 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4); |
| 5653 gc->pc += cmdlen; |
| 5654 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5655 } |
| 5656 |
| 5657 #define X_GLrop_MultiTexCoord1fvARB 199 |
| 5658 void __indirect_glMultiTexCoord1fvARB(GLenum target, const GLfloat * v) |
| 5659 { |
| 5660 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5661 const GLuint cmdlen = 12; |
| 5662 emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen); |
| 5663 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5664 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); |
| 5665 gc->pc += cmdlen; |
| 5666 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5667 } |
| 5668 |
| 5669 #define X_GLrop_MultiTexCoord1ivARB 200 |
| 5670 void __indirect_glMultiTexCoord1iARB(GLenum target, GLint s) |
| 5671 { |
| 5672 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5673 const GLuint cmdlen = 12; |
| 5674 emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen); |
| 5675 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5676 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4); |
| 5677 gc->pc += cmdlen; |
| 5678 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5679 } |
| 5680 |
| 5681 #define X_GLrop_MultiTexCoord1ivARB 200 |
| 5682 void __indirect_glMultiTexCoord1ivARB(GLenum target, const GLint * v) |
| 5683 { |
| 5684 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5685 const GLuint cmdlen = 12; |
| 5686 emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen); |
| 5687 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5688 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); |
| 5689 gc->pc += cmdlen; |
| 5690 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5691 } |
| 5692 |
| 5693 #define X_GLrop_MultiTexCoord1svARB 201 |
| 5694 void __indirect_glMultiTexCoord1sARB(GLenum target, GLshort s) |
| 5695 { |
| 5696 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5697 const GLuint cmdlen = 12; |
| 5698 emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen); |
| 5699 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5700 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2); |
| 5701 gc->pc += cmdlen; |
| 5702 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5703 } |
| 5704 |
| 5705 #define X_GLrop_MultiTexCoord1svARB 201 |
| 5706 void __indirect_glMultiTexCoord1svARB(GLenum target, const GLshort * v) |
| 5707 { |
| 5708 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5709 const GLuint cmdlen = 12; |
| 5710 emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen); |
| 5711 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5712 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2); |
| 5713 gc->pc += cmdlen; |
| 5714 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5715 } |
| 5716 |
| 5717 #define X_GLrop_MultiTexCoord2dvARB 202 |
| 5718 void __indirect_glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t) |
| 5719 { |
| 5720 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5721 const GLuint cmdlen = 24; |
| 5722 emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen); |
| 5723 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8); |
| 5724 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8); |
| 5725 (void) memcpy((void *)(gc->pc + 20), (void *)(&target), 4); |
| 5726 gc->pc += cmdlen; |
| 5727 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5728 } |
| 5729 |
| 5730 #define X_GLrop_MultiTexCoord2dvARB 202 |
| 5731 void __indirect_glMultiTexCoord2dvARB(GLenum target, const GLdouble * v) |
| 5732 { |
| 5733 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5734 const GLuint cmdlen = 24; |
| 5735 emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen); |
| 5736 (void) memcpy((void *)(gc->pc + 4), (void *)(v), 16); |
| 5737 (void) memcpy((void *)(gc->pc + 20), (void *)(&target), 4); |
| 5738 gc->pc += cmdlen; |
| 5739 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5740 } |
| 5741 |
| 5742 #define X_GLrop_MultiTexCoord2fvARB 203 |
| 5743 void __indirect_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t) |
| 5744 { |
| 5745 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5746 const GLuint cmdlen = 16; |
| 5747 emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen); |
| 5748 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5749 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4); |
| 5750 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4); |
| 5751 gc->pc += cmdlen; |
| 5752 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5753 } |
| 5754 |
| 5755 #define X_GLrop_MultiTexCoord2fvARB 203 |
| 5756 void __indirect_glMultiTexCoord2fvARB(GLenum target, const GLfloat * v) |
| 5757 { |
| 5758 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5759 const GLuint cmdlen = 16; |
| 5760 emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen); |
| 5761 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5762 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); |
| 5763 gc->pc += cmdlen; |
| 5764 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5765 } |
| 5766 |
| 5767 #define X_GLrop_MultiTexCoord2ivARB 204 |
| 5768 void __indirect_glMultiTexCoord2iARB(GLenum target, GLint s, GLint t) |
| 5769 { |
| 5770 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5771 const GLuint cmdlen = 16; |
| 5772 emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen); |
| 5773 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5774 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4); |
| 5775 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4); |
| 5776 gc->pc += cmdlen; |
| 5777 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5778 } |
| 5779 |
| 5780 #define X_GLrop_MultiTexCoord2ivARB 204 |
| 5781 void __indirect_glMultiTexCoord2ivARB(GLenum target, const GLint * v) |
| 5782 { |
| 5783 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5784 const GLuint cmdlen = 16; |
| 5785 emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen); |
| 5786 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5787 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); |
| 5788 gc->pc += cmdlen; |
| 5789 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5790 } |
| 5791 |
| 5792 #define X_GLrop_MultiTexCoord2svARB 205 |
| 5793 void __indirect_glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t) |
| 5794 { |
| 5795 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5796 const GLuint cmdlen = 12; |
| 5797 emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen); |
| 5798 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5799 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2); |
| 5800 (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2); |
| 5801 gc->pc += cmdlen; |
| 5802 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5803 } |
| 5804 |
| 5805 #define X_GLrop_MultiTexCoord2svARB 205 |
| 5806 void __indirect_glMultiTexCoord2svARB(GLenum target, const GLshort * v) |
| 5807 { |
| 5808 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5809 const GLuint cmdlen = 12; |
| 5810 emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen); |
| 5811 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5812 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); |
| 5813 gc->pc += cmdlen; |
| 5814 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5815 } |
| 5816 |
| 5817 #define X_GLrop_MultiTexCoord3dvARB 206 |
| 5818 void __indirect_glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdo
uble r) |
| 5819 { |
| 5820 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5821 const GLuint cmdlen = 32; |
| 5822 emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen); |
| 5823 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8); |
| 5824 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8); |
| 5825 (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8); |
| 5826 (void) memcpy((void *)(gc->pc + 28), (void *)(&target), 4); |
| 5827 gc->pc += cmdlen; |
| 5828 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5829 } |
| 5830 |
| 5831 #define X_GLrop_MultiTexCoord3dvARB 206 |
| 5832 void __indirect_glMultiTexCoord3dvARB(GLenum target, const GLdouble * v) |
| 5833 { |
| 5834 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5835 const GLuint cmdlen = 32; |
| 5836 emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen); |
| 5837 (void) memcpy((void *)(gc->pc + 4), (void *)(v), 24); |
| 5838 (void) memcpy((void *)(gc->pc + 28), (void *)(&target), 4); |
| 5839 gc->pc += cmdlen; |
| 5840 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5841 } |
| 5842 |
| 5843 #define X_GLrop_MultiTexCoord3fvARB 207 |
| 5844 void __indirect_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloa
t r) |
| 5845 { |
| 5846 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5847 const GLuint cmdlen = 20; |
| 5848 emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen); |
| 5849 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5850 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4); |
| 5851 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4); |
| 5852 (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4); |
| 5853 gc->pc += cmdlen; |
| 5854 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5855 } |
| 5856 |
| 5857 #define X_GLrop_MultiTexCoord3fvARB 207 |
| 5858 void __indirect_glMultiTexCoord3fvARB(GLenum target, const GLfloat * v) |
| 5859 { |
| 5860 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5861 const GLuint cmdlen = 20; |
| 5862 emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen); |
| 5863 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5864 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12); |
| 5865 gc->pc += cmdlen; |
| 5866 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5867 } |
| 5868 |
| 5869 #define X_GLrop_MultiTexCoord3ivARB 208 |
| 5870 void __indirect_glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r) |
| 5871 { |
| 5872 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5873 const GLuint cmdlen = 20; |
| 5874 emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen); |
| 5875 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5876 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4); |
| 5877 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4); |
| 5878 (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4); |
| 5879 gc->pc += cmdlen; |
| 5880 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5881 } |
| 5882 |
| 5883 #define X_GLrop_MultiTexCoord3ivARB 208 |
| 5884 void __indirect_glMultiTexCoord3ivARB(GLenum target, const GLint * v) |
| 5885 { |
| 5886 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5887 const GLuint cmdlen = 20; |
| 5888 emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen); |
| 5889 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5890 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12); |
| 5891 gc->pc += cmdlen; |
| 5892 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5893 } |
| 5894 |
| 5895 #define X_GLrop_MultiTexCoord3svARB 209 |
| 5896 void __indirect_glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshor
t r) |
| 5897 { |
| 5898 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5899 const GLuint cmdlen = 16; |
| 5900 emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen); |
| 5901 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5902 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2); |
| 5903 (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2); |
| 5904 (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 2); |
| 5905 gc->pc += cmdlen; |
| 5906 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5907 } |
| 5908 |
| 5909 #define X_GLrop_MultiTexCoord3svARB 209 |
| 5910 void __indirect_glMultiTexCoord3svARB(GLenum target, const GLshort * v) |
| 5911 { |
| 5912 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5913 const GLuint cmdlen = 16; |
| 5914 emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen); |
| 5915 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5916 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6); |
| 5917 gc->pc += cmdlen; |
| 5918 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5919 } |
| 5920 |
| 5921 #define X_GLrop_MultiTexCoord4dvARB 210 |
| 5922 void __indirect_glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdo
uble r, GLdouble q) |
| 5923 { |
| 5924 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5925 const GLuint cmdlen = 40; |
| 5926 emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen); |
| 5927 (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8); |
| 5928 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8); |
| 5929 (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8); |
| 5930 (void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8); |
| 5931 (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4); |
| 5932 gc->pc += cmdlen; |
| 5933 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5934 } |
| 5935 |
| 5936 #define X_GLrop_MultiTexCoord4dvARB 210 |
| 5937 void __indirect_glMultiTexCoord4dvARB(GLenum target, const GLdouble * v) |
| 5938 { |
| 5939 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5940 const GLuint cmdlen = 40; |
| 5941 emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen); |
| 5942 (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32); |
| 5943 (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4); |
| 5944 gc->pc += cmdlen; |
| 5945 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5946 } |
| 5947 |
| 5948 #define X_GLrop_MultiTexCoord4fvARB 211 |
| 5949 void __indirect_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloa
t r, GLfloat q) |
| 5950 { |
| 5951 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5952 const GLuint cmdlen = 24; |
| 5953 emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen); |
| 5954 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5955 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4); |
| 5956 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4); |
| 5957 (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4); |
| 5958 (void) memcpy((void *)(gc->pc + 20), (void *)(&q), 4); |
| 5959 gc->pc += cmdlen; |
| 5960 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5961 } |
| 5962 |
| 5963 #define X_GLrop_MultiTexCoord4fvARB 211 |
| 5964 void __indirect_glMultiTexCoord4fvARB(GLenum target, const GLfloat * v) |
| 5965 { |
| 5966 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5967 const GLuint cmdlen = 24; |
| 5968 emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen); |
| 5969 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5970 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16); |
| 5971 gc->pc += cmdlen; |
| 5972 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5973 } |
| 5974 |
| 5975 #define X_GLrop_MultiTexCoord4ivARB 212 |
| 5976 void __indirect_glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, G
Lint q) |
| 5977 { |
| 5978 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5979 const GLuint cmdlen = 24; |
| 5980 emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen); |
| 5981 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5982 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4); |
| 5983 (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4); |
| 5984 (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4); |
| 5985 (void) memcpy((void *)(gc->pc + 20), (void *)(&q), 4); |
| 5986 gc->pc += cmdlen; |
| 5987 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 5988 } |
| 5989 |
| 5990 #define X_GLrop_MultiTexCoord4ivARB 212 |
| 5991 void __indirect_glMultiTexCoord4ivARB(GLenum target, const GLint * v) |
| 5992 { |
| 5993 struct glx_context * const gc = __glXGetCurrentContext(); |
| 5994 const GLuint cmdlen = 24; |
| 5995 emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen); |
| 5996 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 5997 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16); |
| 5998 gc->pc += cmdlen; |
| 5999 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6000 } |
| 6001 |
| 6002 #define X_GLrop_MultiTexCoord4svARB 213 |
| 6003 void __indirect_glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshor
t r, GLshort q) |
| 6004 { |
| 6005 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6006 const GLuint cmdlen = 16; |
| 6007 emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen); |
| 6008 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 6009 (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2); |
| 6010 (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2); |
| 6011 (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 2); |
| 6012 (void) memcpy((void *)(gc->pc + 14), (void *)(&q), 2); |
| 6013 gc->pc += cmdlen; |
| 6014 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6015 } |
| 6016 |
| 6017 #define X_GLrop_MultiTexCoord4svARB 213 |
| 6018 void __indirect_glMultiTexCoord4svARB(GLenum target, const GLshort * v) |
| 6019 { |
| 6020 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6021 const GLuint cmdlen = 16; |
| 6022 emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen); |
| 6023 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 6024 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); |
| 6025 gc->pc += cmdlen; |
| 6026 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6027 } |
| 6028 |
| 6029 #define X_GLrop_SampleCoverageARB 229 |
| 6030 void __indirect_glSampleCoverageARB(GLclampf value, GLboolean invert) |
| 6031 { |
| 6032 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6033 const GLuint cmdlen = 12; |
| 6034 emit_header(gc->pc, X_GLrop_SampleCoverageARB, cmdlen); |
| 6035 (void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4); |
| 6036 (void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1); |
| 6037 gc->pc += cmdlen; |
| 6038 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6039 } |
| 6040 |
| 6041 #define X_GLvop_GetProgramStringARB 1308 |
| 6042 void __indirect_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * stri
ng) |
| 6043 { |
| 6044 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6045 Display * const dpy = gc->currentDpy; |
| 6046 const GLuint cmdlen = 8; |
| 6047 if (__builtin_expect(dpy != NULL, 1)) { |
| 6048 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetProgramStringARB, cmdlen); |
| 6049 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 6050 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 6051 (void) __glXReadReply(dpy, 1, string, GL_TRUE); |
| 6052 UnlockDisplay(dpy); SyncHandle(); |
| 6053 } |
| 6054 return; |
| 6055 } |
| 6056 |
| 6057 #define X_GLvop_GetProgramivARB 1307 |
| 6058 void __indirect_glGetProgramivARB(GLenum target, GLenum pname, GLint * params) |
| 6059 { |
| 6060 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6061 Display * const dpy = gc->currentDpy; |
| 6062 const GLuint cmdlen = 8; |
| 6063 if (__builtin_expect(dpy != NULL, 1)) { |
| 6064 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetProgramivARB, cmdlen); |
| 6065 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 6066 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 6067 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 6068 UnlockDisplay(dpy); SyncHandle(); |
| 6069 } |
| 6070 return; |
| 6071 } |
| 6072 |
| 6073 #define X_GLrop_ProgramEnvParameter4dvARB 4185 |
| 6074 void __indirect_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble
x, GLdouble y, GLdouble z, GLdouble w) |
| 6075 { |
| 6076 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6077 const GLuint cmdlen = 44; |
| 6078 emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen); |
| 6079 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 6080 (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4); |
| 6081 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8); |
| 6082 (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8); |
| 6083 (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8); |
| 6084 (void) memcpy((void *)(gc->pc + 36), (void *)(&w), 8); |
| 6085 gc->pc += cmdlen; |
| 6086 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6087 } |
| 6088 |
| 6089 #define X_GLrop_ProgramEnvParameter4dvARB 4185 |
| 6090 void __indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index, const G
Ldouble * params) |
| 6091 { |
| 6092 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6093 const GLuint cmdlen = 44; |
| 6094 emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen); |
| 6095 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 6096 (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4); |
| 6097 (void) memcpy((void *)(gc->pc + 12), (void *)(params), 32); |
| 6098 gc->pc += cmdlen; |
| 6099 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6100 } |
| 6101 |
| 6102 #define X_GLrop_ProgramEnvParameter4fvARB 4184 |
| 6103 void __indirect_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat
x, GLfloat y, GLfloat z, GLfloat w) |
| 6104 { |
| 6105 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6106 const GLuint cmdlen = 28; |
| 6107 emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen); |
| 6108 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 6109 (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4); |
| 6110 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4); |
| 6111 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4); |
| 6112 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4); |
| 6113 (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4); |
| 6114 gc->pc += cmdlen; |
| 6115 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6116 } |
| 6117 |
| 6118 #define X_GLrop_ProgramEnvParameter4fvARB 4184 |
| 6119 void __indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index, const G
Lfloat * params) |
| 6120 { |
| 6121 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6122 const GLuint cmdlen = 28; |
| 6123 emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen); |
| 6124 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 6125 (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4); |
| 6126 (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16); |
| 6127 gc->pc += cmdlen; |
| 6128 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6129 } |
| 6130 |
| 6131 #define X_GLrop_ProgramLocalParameter4dvARB 4216 |
| 6132 void __indirect_glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdoub
le x, GLdouble y, GLdouble z, GLdouble w) |
| 6133 { |
| 6134 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6135 const GLuint cmdlen = 44; |
| 6136 emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen); |
| 6137 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 6138 (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4); |
| 6139 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8); |
| 6140 (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8); |
| 6141 (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8); |
| 6142 (void) memcpy((void *)(gc->pc + 36), (void *)(&w), 8); |
| 6143 gc->pc += cmdlen; |
| 6144 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6145 } |
| 6146 |
| 6147 #define X_GLrop_ProgramLocalParameter4dvARB 4216 |
| 6148 void __indirect_glProgramLocalParameter4dvARB(GLenum target, GLuint index, const
GLdouble * params) |
| 6149 { |
| 6150 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6151 const GLuint cmdlen = 44; |
| 6152 emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen); |
| 6153 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 6154 (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4); |
| 6155 (void) memcpy((void *)(gc->pc + 12), (void *)(params), 32); |
| 6156 gc->pc += cmdlen; |
| 6157 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6158 } |
| 6159 |
| 6160 #define X_GLrop_ProgramLocalParameter4fvARB 4215 |
| 6161 void __indirect_glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloa
t x, GLfloat y, GLfloat z, GLfloat w) |
| 6162 { |
| 6163 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6164 const GLuint cmdlen = 28; |
| 6165 emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen); |
| 6166 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 6167 (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4); |
| 6168 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4); |
| 6169 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4); |
| 6170 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4); |
| 6171 (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4); |
| 6172 gc->pc += cmdlen; |
| 6173 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6174 } |
| 6175 |
| 6176 #define X_GLrop_ProgramLocalParameter4fvARB 4215 |
| 6177 void __indirect_glProgramLocalParameter4fvARB(GLenum target, GLuint index, const
GLfloat * params) |
| 6178 { |
| 6179 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6180 const GLuint cmdlen = 28; |
| 6181 emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen); |
| 6182 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 6183 (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4); |
| 6184 (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16); |
| 6185 gc->pc += cmdlen; |
| 6186 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6187 } |
| 6188 |
| 6189 #define X_GLrop_ProgramStringARB 4217 |
| 6190 void __indirect_glProgramStringARB(GLenum target, GLenum format, GLsizei len, co
nst GLvoid * string) |
| 6191 { |
| 6192 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6193 const GLuint cmdlen = 16 + __GLX_PAD(len); |
| 6194 if (len < 0) { |
| 6195 __glXSetError(gc, GL_INVALID_VALUE); |
| 6196 return; |
| 6197 } |
| 6198 if (__builtin_expect((len >= 0) && (gc->currentDpy != NULL), 1)) { |
| 6199 if (cmdlen <= gc->maxSmallRenderCommandSize) { |
| 6200 if ( (gc->pc + cmdlen) > gc->bufEnd ) { |
| 6201 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 6202 } |
| 6203 emit_header(gc->pc, X_GLrop_ProgramStringARB, cmdlen); |
| 6204 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 6205 (void) memcpy((void *)(gc->pc + 8), (void *)(&format), 4); |
| 6206 (void) memcpy((void *)(gc->pc + 12), (void *)(&len), 4); |
| 6207 (void) memcpy((void *)(gc->pc + 16), (void *)(string), len); |
| 6208 gc->pc += cmdlen; |
| 6209 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6210 } |
| 6211 else { |
| 6212 const GLint op = X_GLrop_ProgramStringARB; |
| 6213 const GLuint cmdlenLarge = cmdlen + 4; |
| 6214 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); |
| 6215 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); |
| 6216 (void) memcpy((void *)(pc + 4), (void *)(&op), 4); |
| 6217 (void) memcpy((void *)(pc + 8), (void *)(&target), 4); |
| 6218 (void) memcpy((void *)(pc + 12), (void *)(&format), 4); |
| 6219 (void) memcpy((void *)(pc + 16), (void *)(&len), 4); |
| 6220 __glXSendLargeCommand(gc, pc, 20, string, len); |
| 6221 } |
| 6222 } |
| 6223 } |
| 6224 |
| 6225 #define X_GLrop_VertexAttrib1dvARB 4197 |
| 6226 void __indirect_glVertexAttrib1dARB(GLuint index, GLdouble x) |
| 6227 { |
| 6228 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6229 const GLuint cmdlen = 16; |
| 6230 emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen); |
| 6231 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6232 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8); |
| 6233 gc->pc += cmdlen; |
| 6234 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6235 } |
| 6236 |
| 6237 #define X_GLrop_VertexAttrib1dvARB 4197 |
| 6238 void __indirect_glVertexAttrib1dvARB(GLuint index, const GLdouble * v) |
| 6239 { |
| 6240 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6241 const GLuint cmdlen = 16; |
| 6242 emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen); |
| 6243 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6244 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); |
| 6245 gc->pc += cmdlen; |
| 6246 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6247 } |
| 6248 |
| 6249 #define X_GLrop_VertexAttrib1fvARB 4193 |
| 6250 void __indirect_glVertexAttrib1fARB(GLuint index, GLfloat x) |
| 6251 { |
| 6252 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6253 const GLuint cmdlen = 12; |
| 6254 emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen); |
| 6255 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6256 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4); |
| 6257 gc->pc += cmdlen; |
| 6258 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6259 } |
| 6260 |
| 6261 #define X_GLrop_VertexAttrib1fvARB 4193 |
| 6262 void __indirect_glVertexAttrib1fvARB(GLuint index, const GLfloat * v) |
| 6263 { |
| 6264 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6265 const GLuint cmdlen = 12; |
| 6266 emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen); |
| 6267 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6268 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); |
| 6269 gc->pc += cmdlen; |
| 6270 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6271 } |
| 6272 |
| 6273 #define X_GLrop_VertexAttrib1svARB 4189 |
| 6274 void __indirect_glVertexAttrib1sARB(GLuint index, GLshort x) |
| 6275 { |
| 6276 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6277 const GLuint cmdlen = 12; |
| 6278 emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen); |
| 6279 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6280 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2); |
| 6281 gc->pc += cmdlen; |
| 6282 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6283 } |
| 6284 |
| 6285 #define X_GLrop_VertexAttrib1svARB 4189 |
| 6286 void __indirect_glVertexAttrib1svARB(GLuint index, const GLshort * v) |
| 6287 { |
| 6288 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6289 const GLuint cmdlen = 12; |
| 6290 emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen); |
| 6291 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6292 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2); |
| 6293 gc->pc += cmdlen; |
| 6294 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6295 } |
| 6296 |
| 6297 #define X_GLrop_VertexAttrib2dvARB 4198 |
| 6298 void __indirect_glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y) |
| 6299 { |
| 6300 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6301 const GLuint cmdlen = 24; |
| 6302 emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen); |
| 6303 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6304 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8); |
| 6305 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8); |
| 6306 gc->pc += cmdlen; |
| 6307 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6308 } |
| 6309 |
| 6310 #define X_GLrop_VertexAttrib2dvARB 4198 |
| 6311 void __indirect_glVertexAttrib2dvARB(GLuint index, const GLdouble * v) |
| 6312 { |
| 6313 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6314 const GLuint cmdlen = 24; |
| 6315 emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen); |
| 6316 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6317 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16); |
| 6318 gc->pc += cmdlen; |
| 6319 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6320 } |
| 6321 |
| 6322 #define X_GLrop_VertexAttrib2fvARB 4194 |
| 6323 void __indirect_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y) |
| 6324 { |
| 6325 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6326 const GLuint cmdlen = 16; |
| 6327 emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen); |
| 6328 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6329 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4); |
| 6330 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4); |
| 6331 gc->pc += cmdlen; |
| 6332 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6333 } |
| 6334 |
| 6335 #define X_GLrop_VertexAttrib2fvARB 4194 |
| 6336 void __indirect_glVertexAttrib2fvARB(GLuint index, const GLfloat * v) |
| 6337 { |
| 6338 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6339 const GLuint cmdlen = 16; |
| 6340 emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen); |
| 6341 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6342 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); |
| 6343 gc->pc += cmdlen; |
| 6344 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6345 } |
| 6346 |
| 6347 #define X_GLrop_VertexAttrib2svARB 4190 |
| 6348 void __indirect_glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y) |
| 6349 { |
| 6350 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6351 const GLuint cmdlen = 12; |
| 6352 emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen); |
| 6353 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6354 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2); |
| 6355 (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2); |
| 6356 gc->pc += cmdlen; |
| 6357 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6358 } |
| 6359 |
| 6360 #define X_GLrop_VertexAttrib2svARB 4190 |
| 6361 void __indirect_glVertexAttrib2svARB(GLuint index, const GLshort * v) |
| 6362 { |
| 6363 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6364 const GLuint cmdlen = 12; |
| 6365 emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen); |
| 6366 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6367 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); |
| 6368 gc->pc += cmdlen; |
| 6369 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6370 } |
| 6371 |
| 6372 #define X_GLrop_VertexAttrib3dvARB 4199 |
| 6373 void __indirect_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdoub
le z) |
| 6374 { |
| 6375 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6376 const GLuint cmdlen = 32; |
| 6377 emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen); |
| 6378 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6379 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8); |
| 6380 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8); |
| 6381 (void) memcpy((void *)(gc->pc + 24), (void *)(&z), 8); |
| 6382 gc->pc += cmdlen; |
| 6383 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6384 } |
| 6385 |
| 6386 #define X_GLrop_VertexAttrib3dvARB 4199 |
| 6387 void __indirect_glVertexAttrib3dvARB(GLuint index, const GLdouble * v) |
| 6388 { |
| 6389 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6390 const GLuint cmdlen = 32; |
| 6391 emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen); |
| 6392 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6393 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 24); |
| 6394 gc->pc += cmdlen; |
| 6395 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6396 } |
| 6397 |
| 6398 #define X_GLrop_VertexAttrib3fvARB 4195 |
| 6399 void __indirect_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat
z) |
| 6400 { |
| 6401 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6402 const GLuint cmdlen = 20; |
| 6403 emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen); |
| 6404 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6405 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4); |
| 6406 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4); |
| 6407 (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4); |
| 6408 gc->pc += cmdlen; |
| 6409 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6410 } |
| 6411 |
| 6412 #define X_GLrop_VertexAttrib3fvARB 4195 |
| 6413 void __indirect_glVertexAttrib3fvARB(GLuint index, const GLfloat * v) |
| 6414 { |
| 6415 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6416 const GLuint cmdlen = 20; |
| 6417 emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen); |
| 6418 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6419 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12); |
| 6420 gc->pc += cmdlen; |
| 6421 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6422 } |
| 6423 |
| 6424 #define X_GLrop_VertexAttrib3svARB 4191 |
| 6425 void __indirect_glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort
z) |
| 6426 { |
| 6427 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6428 const GLuint cmdlen = 16; |
| 6429 emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen); |
| 6430 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6431 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2); |
| 6432 (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2); |
| 6433 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2); |
| 6434 gc->pc += cmdlen; |
| 6435 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6436 } |
| 6437 |
| 6438 #define X_GLrop_VertexAttrib3svARB 4191 |
| 6439 void __indirect_glVertexAttrib3svARB(GLuint index, const GLshort * v) |
| 6440 { |
| 6441 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6442 const GLuint cmdlen = 16; |
| 6443 emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen); |
| 6444 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6445 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6); |
| 6446 gc->pc += cmdlen; |
| 6447 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6448 } |
| 6449 |
| 6450 #define X_GLrop_VertexAttrib4NbvARB 4235 |
| 6451 void __indirect_glVertexAttrib4NbvARB(GLuint index, const GLbyte * v) |
| 6452 { |
| 6453 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6454 const GLuint cmdlen = 12; |
| 6455 emit_header(gc->pc, X_GLrop_VertexAttrib4NbvARB, cmdlen); |
| 6456 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6457 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); |
| 6458 gc->pc += cmdlen; |
| 6459 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6460 } |
| 6461 |
| 6462 #define X_GLrop_VertexAttrib4NivARB 4237 |
| 6463 void __indirect_glVertexAttrib4NivARB(GLuint index, const GLint * v) |
| 6464 { |
| 6465 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6466 const GLuint cmdlen = 24; |
| 6467 emit_header(gc->pc, X_GLrop_VertexAttrib4NivARB, cmdlen); |
| 6468 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6469 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16); |
| 6470 gc->pc += cmdlen; |
| 6471 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6472 } |
| 6473 |
| 6474 #define X_GLrop_VertexAttrib4NsvARB 4236 |
| 6475 void __indirect_glVertexAttrib4NsvARB(GLuint index, const GLshort * v) |
| 6476 { |
| 6477 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6478 const GLuint cmdlen = 16; |
| 6479 emit_header(gc->pc, X_GLrop_VertexAttrib4NsvARB, cmdlen); |
| 6480 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6481 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); |
| 6482 gc->pc += cmdlen; |
| 6483 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6484 } |
| 6485 |
| 6486 #define X_GLrop_VertexAttrib4NubvARB 4201 |
| 6487 void __indirect_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyt
e z, GLubyte w) |
| 6488 { |
| 6489 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6490 const GLuint cmdlen = 12; |
| 6491 emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen); |
| 6492 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6493 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 1); |
| 6494 (void) memcpy((void *)(gc->pc + 9), (void *)(&y), 1); |
| 6495 (void) memcpy((void *)(gc->pc + 10), (void *)(&z), 1); |
| 6496 (void) memcpy((void *)(gc->pc + 11), (void *)(&w), 1); |
| 6497 gc->pc += cmdlen; |
| 6498 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6499 } |
| 6500 |
| 6501 #define X_GLrop_VertexAttrib4NubvARB 4201 |
| 6502 void __indirect_glVertexAttrib4NubvARB(GLuint index, const GLubyte * v) |
| 6503 { |
| 6504 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6505 const GLuint cmdlen = 12; |
| 6506 emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen); |
| 6507 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6508 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); |
| 6509 gc->pc += cmdlen; |
| 6510 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6511 } |
| 6512 |
| 6513 #define X_GLrop_VertexAttrib4NuivARB 4239 |
| 6514 void __indirect_glVertexAttrib4NuivARB(GLuint index, const GLuint * v) |
| 6515 { |
| 6516 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6517 const GLuint cmdlen = 24; |
| 6518 emit_header(gc->pc, X_GLrop_VertexAttrib4NuivARB, cmdlen); |
| 6519 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6520 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16); |
| 6521 gc->pc += cmdlen; |
| 6522 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6523 } |
| 6524 |
| 6525 #define X_GLrop_VertexAttrib4NusvARB 4238 |
| 6526 void __indirect_glVertexAttrib4NusvARB(GLuint index, const GLushort * v) |
| 6527 { |
| 6528 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6529 const GLuint cmdlen = 16; |
| 6530 emit_header(gc->pc, X_GLrop_VertexAttrib4NusvARB, cmdlen); |
| 6531 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6532 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); |
| 6533 gc->pc += cmdlen; |
| 6534 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6535 } |
| 6536 |
| 6537 #define X_GLrop_VertexAttrib4bvARB 4230 |
| 6538 void __indirect_glVertexAttrib4bvARB(GLuint index, const GLbyte * v) |
| 6539 { |
| 6540 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6541 const GLuint cmdlen = 12; |
| 6542 emit_header(gc->pc, X_GLrop_VertexAttrib4bvARB, cmdlen); |
| 6543 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6544 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); |
| 6545 gc->pc += cmdlen; |
| 6546 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6547 } |
| 6548 |
| 6549 #define X_GLrop_VertexAttrib4dvARB 4200 |
| 6550 void __indirect_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdoub
le z, GLdouble w) |
| 6551 { |
| 6552 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6553 const GLuint cmdlen = 40; |
| 6554 emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen); |
| 6555 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6556 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8); |
| 6557 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8); |
| 6558 (void) memcpy((void *)(gc->pc + 24), (void *)(&z), 8); |
| 6559 (void) memcpy((void *)(gc->pc + 32), (void *)(&w), 8); |
| 6560 gc->pc += cmdlen; |
| 6561 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6562 } |
| 6563 |
| 6564 #define X_GLrop_VertexAttrib4dvARB 4200 |
| 6565 void __indirect_glVertexAttrib4dvARB(GLuint index, const GLdouble * v) |
| 6566 { |
| 6567 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6568 const GLuint cmdlen = 40; |
| 6569 emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen); |
| 6570 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6571 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 32); |
| 6572 gc->pc += cmdlen; |
| 6573 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6574 } |
| 6575 |
| 6576 #define X_GLrop_VertexAttrib4fvARB 4196 |
| 6577 void __indirect_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat
z, GLfloat w) |
| 6578 { |
| 6579 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6580 const GLuint cmdlen = 24; |
| 6581 emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen); |
| 6582 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6583 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4); |
| 6584 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4); |
| 6585 (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4); |
| 6586 (void) memcpy((void *)(gc->pc + 20), (void *)(&w), 4); |
| 6587 gc->pc += cmdlen; |
| 6588 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6589 } |
| 6590 |
| 6591 #define X_GLrop_VertexAttrib4fvARB 4196 |
| 6592 void __indirect_glVertexAttrib4fvARB(GLuint index, const GLfloat * v) |
| 6593 { |
| 6594 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6595 const GLuint cmdlen = 24; |
| 6596 emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen); |
| 6597 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6598 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16); |
| 6599 gc->pc += cmdlen; |
| 6600 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6601 } |
| 6602 |
| 6603 #define X_GLrop_VertexAttrib4ivARB 4231 |
| 6604 void __indirect_glVertexAttrib4ivARB(GLuint index, const GLint * v) |
| 6605 { |
| 6606 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6607 const GLuint cmdlen = 24; |
| 6608 emit_header(gc->pc, X_GLrop_VertexAttrib4ivARB, cmdlen); |
| 6609 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6610 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16); |
| 6611 gc->pc += cmdlen; |
| 6612 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6613 } |
| 6614 |
| 6615 #define X_GLrop_VertexAttrib4svARB 4192 |
| 6616 void __indirect_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort
z, GLshort w) |
| 6617 { |
| 6618 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6619 const GLuint cmdlen = 16; |
| 6620 emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen); |
| 6621 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6622 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2); |
| 6623 (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2); |
| 6624 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2); |
| 6625 (void) memcpy((void *)(gc->pc + 14), (void *)(&w), 2); |
| 6626 gc->pc += cmdlen; |
| 6627 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6628 } |
| 6629 |
| 6630 #define X_GLrop_VertexAttrib4svARB 4192 |
| 6631 void __indirect_glVertexAttrib4svARB(GLuint index, const GLshort * v) |
| 6632 { |
| 6633 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6634 const GLuint cmdlen = 16; |
| 6635 emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen); |
| 6636 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6637 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); |
| 6638 gc->pc += cmdlen; |
| 6639 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6640 } |
| 6641 |
| 6642 #define X_GLrop_VertexAttrib4ubvARB 4232 |
| 6643 void __indirect_glVertexAttrib4ubvARB(GLuint index, const GLubyte * v) |
| 6644 { |
| 6645 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6646 const GLuint cmdlen = 12; |
| 6647 emit_header(gc->pc, X_GLrop_VertexAttrib4ubvARB, cmdlen); |
| 6648 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6649 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); |
| 6650 gc->pc += cmdlen; |
| 6651 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6652 } |
| 6653 |
| 6654 #define X_GLrop_VertexAttrib4uivARB 4234 |
| 6655 void __indirect_glVertexAttrib4uivARB(GLuint index, const GLuint * v) |
| 6656 { |
| 6657 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6658 const GLuint cmdlen = 24; |
| 6659 emit_header(gc->pc, X_GLrop_VertexAttrib4uivARB, cmdlen); |
| 6660 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6661 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16); |
| 6662 gc->pc += cmdlen; |
| 6663 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6664 } |
| 6665 |
| 6666 #define X_GLrop_VertexAttrib4usvARB 4233 |
| 6667 void __indirect_glVertexAttrib4usvARB(GLuint index, const GLushort * v) |
| 6668 { |
| 6669 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6670 const GLuint cmdlen = 16; |
| 6671 emit_header(gc->pc, X_GLrop_VertexAttrib4usvARB, cmdlen); |
| 6672 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 6673 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); |
| 6674 gc->pc += cmdlen; |
| 6675 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6676 } |
| 6677 |
| 6678 #define X_GLrop_BeginQueryARB 231 |
| 6679 void __indirect_glBeginQueryARB(GLenum target, GLuint id) |
| 6680 { |
| 6681 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6682 const GLuint cmdlen = 12; |
| 6683 emit_header(gc->pc, X_GLrop_BeginQueryARB, cmdlen); |
| 6684 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 6685 (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4); |
| 6686 gc->pc += cmdlen; |
| 6687 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6688 } |
| 6689 |
| 6690 #define X_GLsop_DeleteQueriesARB 161 |
| 6691 void __indirect_glDeleteQueriesARB(GLsizei n, const GLuint * ids) |
| 6692 { |
| 6693 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6694 Display * const dpy = gc->currentDpy; |
| 6695 #ifndef USE_XCB |
| 6696 const GLuint cmdlen = 4 + __GLX_PAD((n * 4)); |
| 6697 #endif |
| 6698 if (n < 0) { |
| 6699 __glXSetError(gc, GL_INVALID_VALUE); |
| 6700 return; |
| 6701 } |
| 6702 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { |
| 6703 #ifdef USE_XCB |
| 6704 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 6705 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 6706 xcb_glx_delete_queries_arb(c, gc->currentContextTag, n, ids); |
| 6707 #else |
| 6708 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_DeleteQueriesAR
B, cmdlen); |
| 6709 (void) memcpy((void *)(pc + 0), (void *)(&n), 4); |
| 6710 (void) memcpy((void *)(pc + 4), (void *)(ids), (n * 4)); |
| 6711 UnlockDisplay(dpy); SyncHandle(); |
| 6712 #endif /* USE_XCB */ |
| 6713 } |
| 6714 return; |
| 6715 } |
| 6716 |
| 6717 #define X_GLrop_EndQueryARB 232 |
| 6718 void __indirect_glEndQueryARB(GLenum target) |
| 6719 { |
| 6720 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6721 const GLuint cmdlen = 8; |
| 6722 emit_header(gc->pc, X_GLrop_EndQueryARB, cmdlen); |
| 6723 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 6724 gc->pc += cmdlen; |
| 6725 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6726 } |
| 6727 |
| 6728 #define X_GLsop_GenQueriesARB 162 |
| 6729 void __indirect_glGenQueriesARB(GLsizei n, GLuint * ids) |
| 6730 { |
| 6731 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6732 Display * const dpy = gc->currentDpy; |
| 6733 #ifndef USE_XCB |
| 6734 const GLuint cmdlen = 4; |
| 6735 #endif |
| 6736 if (n < 0) { |
| 6737 __glXSetError(gc, GL_INVALID_VALUE); |
| 6738 return; |
| 6739 } |
| 6740 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { |
| 6741 #ifdef USE_XCB |
| 6742 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 6743 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 6744 xcb_glx_gen_queries_arb_reply_t *reply = xcb_glx_gen_queries_arb_reply(c
, xcb_glx_gen_queries_arb(c, gc->currentContextTag, n), NULL); |
| 6745 (void)memcpy(ids, xcb_glx_gen_queries_arb_data(reply), xcb_glx_gen_queri
es_arb_data_length(reply) * sizeof(GLuint)); |
| 6746 free(reply); |
| 6747 #else |
| 6748 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenQueriesARB,
cmdlen); |
| 6749 (void) memcpy((void *)(pc + 0), (void *)(&n), 4); |
| 6750 (void) __glXReadReply(dpy, 4, ids, GL_TRUE); |
| 6751 UnlockDisplay(dpy); SyncHandle(); |
| 6752 #endif /* USE_XCB */ |
| 6753 } |
| 6754 return; |
| 6755 } |
| 6756 |
| 6757 #define X_GLsop_GetQueryObjectivARB 165 |
| 6758 void __indirect_glGetQueryObjectivARB(GLuint id, GLenum pname, GLint * params) |
| 6759 { |
| 6760 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6761 Display * const dpy = gc->currentDpy; |
| 6762 #ifndef USE_XCB |
| 6763 const GLuint cmdlen = 8; |
| 6764 #endif |
| 6765 if (__builtin_expect(dpy != NULL, 1)) { |
| 6766 #ifdef USE_XCB |
| 6767 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 6768 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 6769 xcb_glx_get_query_objectiv_arb_reply_t *reply = xcb_glx_get_query_object
iv_arb_reply(c, xcb_glx_get_query_objectiv_arb(c, gc->currentContextTag, id, pna
me), NULL); |
| 6770 if (xcb_glx_get_query_objectiv_arb_data_length(reply) == 0) |
| 6771 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 6772 else |
| 6773 (void)memcpy(params, xcb_glx_get_query_objectiv_arb_data(reply), xcb
_glx_get_query_objectiv_arb_data_length(reply) * sizeof(GLint)); |
| 6774 free(reply); |
| 6775 #else |
| 6776 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjecti
vARB, cmdlen); |
| 6777 (void) memcpy((void *)(pc + 0), (void *)(&id), 4); |
| 6778 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 6779 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 6780 UnlockDisplay(dpy); SyncHandle(); |
| 6781 #endif /* USE_XCB */ |
| 6782 } |
| 6783 return; |
| 6784 } |
| 6785 |
| 6786 #define X_GLsop_GetQueryObjectuivARB 166 |
| 6787 void __indirect_glGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint * params) |
| 6788 { |
| 6789 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6790 Display * const dpy = gc->currentDpy; |
| 6791 #ifndef USE_XCB |
| 6792 const GLuint cmdlen = 8; |
| 6793 #endif |
| 6794 if (__builtin_expect(dpy != NULL, 1)) { |
| 6795 #ifdef USE_XCB |
| 6796 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 6797 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 6798 xcb_glx_get_query_objectuiv_arb_reply_t *reply = xcb_glx_get_query_objec
tuiv_arb_reply(c, xcb_glx_get_query_objectuiv_arb(c, gc->currentContextTag, id,
pname), NULL); |
| 6799 if (xcb_glx_get_query_objectuiv_arb_data_length(reply) == 0) |
| 6800 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 6801 else |
| 6802 (void)memcpy(params, xcb_glx_get_query_objectuiv_arb_data(reply), xc
b_glx_get_query_objectuiv_arb_data_length(reply) * sizeof(GLuint)); |
| 6803 free(reply); |
| 6804 #else |
| 6805 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectu
ivARB, cmdlen); |
| 6806 (void) memcpy((void *)(pc + 0), (void *)(&id), 4); |
| 6807 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 6808 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 6809 UnlockDisplay(dpy); SyncHandle(); |
| 6810 #endif /* USE_XCB */ |
| 6811 } |
| 6812 return; |
| 6813 } |
| 6814 |
| 6815 #define X_GLsop_GetQueryivARB 164 |
| 6816 void __indirect_glGetQueryivARB(GLenum target, GLenum pname, GLint * params) |
| 6817 { |
| 6818 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6819 Display * const dpy = gc->currentDpy; |
| 6820 #ifndef USE_XCB |
| 6821 const GLuint cmdlen = 8; |
| 6822 #endif |
| 6823 if (__builtin_expect(dpy != NULL, 1)) { |
| 6824 #ifdef USE_XCB |
| 6825 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 6826 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 6827 xcb_glx_get_queryiv_arb_reply_t *reply = xcb_glx_get_queryiv_arb_reply(c
, xcb_glx_get_queryiv_arb(c, gc->currentContextTag, target, pname), NULL); |
| 6828 if (xcb_glx_get_queryiv_arb_data_length(reply) == 0) |
| 6829 (void)memcpy(params, &reply->datum, sizeof(reply->datum)); |
| 6830 else |
| 6831 (void)memcpy(params, xcb_glx_get_queryiv_arb_data(reply), xcb_glx_ge
t_queryiv_arb_data_length(reply) * sizeof(GLint)); |
| 6832 free(reply); |
| 6833 #else |
| 6834 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryivARB,
cmdlen); |
| 6835 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 6836 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 6837 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 6838 UnlockDisplay(dpy); SyncHandle(); |
| 6839 #endif /* USE_XCB */ |
| 6840 } |
| 6841 return; |
| 6842 } |
| 6843 |
| 6844 #define X_GLsop_IsQueryARB 163 |
| 6845 GLboolean __indirect_glIsQueryARB(GLuint id) |
| 6846 { |
| 6847 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6848 Display * const dpy = gc->currentDpy; |
| 6849 GLboolean retval = (GLboolean) 0; |
| 6850 #ifndef USE_XCB |
| 6851 const GLuint cmdlen = 4; |
| 6852 #endif |
| 6853 if (__builtin_expect(dpy != NULL, 1)) { |
| 6854 #ifdef USE_XCB |
| 6855 xcb_connection_t *c = XGetXCBConnection(dpy); |
| 6856 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 6857 xcb_glx_is_query_arb_reply_t *reply = xcb_glx_is_query_arb_reply(c, xcb_
glx_is_query_arb(c, gc->currentContextTag, id), NULL); |
| 6858 retval = reply->ret_val; |
| 6859 free(reply); |
| 6860 #else |
| 6861 GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsQueryARB, cmd
len); |
| 6862 (void) memcpy((void *)(pc + 0), (void *)(&id), 4); |
| 6863 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE); |
| 6864 UnlockDisplay(dpy); SyncHandle(); |
| 6865 #endif /* USE_XCB */ |
| 6866 } |
| 6867 return retval; |
| 6868 } |
| 6869 |
| 6870 #define X_GLrop_DrawBuffersARB 233 |
| 6871 void __indirect_glDrawBuffersARB(GLsizei n, const GLenum * bufs) |
| 6872 { |
| 6873 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6874 const GLuint cmdlen = 8 + __GLX_PAD((n * 4)); |
| 6875 if (n < 0) { |
| 6876 __glXSetError(gc, GL_INVALID_VALUE); |
| 6877 return; |
| 6878 } |
| 6879 if (__builtin_expect((n >= 0) && (gc->currentDpy != NULL), 1)) { |
| 6880 if (cmdlen <= gc->maxSmallRenderCommandSize) { |
| 6881 if ( (gc->pc + cmdlen) > gc->bufEnd ) { |
| 6882 (void) __glXFlushRenderBuffer(gc, gc->pc); |
| 6883 } |
| 6884 emit_header(gc->pc, X_GLrop_DrawBuffersARB, cmdlen); |
| 6885 (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4); |
| 6886 (void) memcpy((void *)(gc->pc + 8), (void *)(bufs), (n * 4)); |
| 6887 gc->pc += cmdlen; |
| 6888 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6889 } |
| 6890 else { |
| 6891 const GLint op = X_GLrop_DrawBuffersARB; |
| 6892 const GLuint cmdlenLarge = cmdlen + 4; |
| 6893 GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); |
| 6894 (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); |
| 6895 (void) memcpy((void *)(pc + 4), (void *)(&op), 4); |
| 6896 (void) memcpy((void *)(pc + 8), (void *)(&n), 4); |
| 6897 __glXSendLargeCommand(gc, pc, 12, bufs, (n * 4)); |
| 6898 } |
| 6899 } |
| 6900 } |
| 6901 |
| 6902 #define X_GLrop_ClampColorARB 234 |
| 6903 void __indirect_glClampColorARB(GLenum target, GLenum clamp) |
| 6904 { |
| 6905 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6906 const GLuint cmdlen = 12; |
| 6907 emit_header(gc->pc, X_GLrop_ClampColorARB, cmdlen); |
| 6908 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 6909 (void) memcpy((void *)(gc->pc + 8), (void *)(&clamp), 4); |
| 6910 gc->pc += cmdlen; |
| 6911 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6912 } |
| 6913 |
| 6914 #define X_GLrop_RenderbufferStorageMultisample 4331 |
| 6915 void __indirect_glRenderbufferStorageMultisample(GLenum target, GLsizei samples,
GLenum internalformat, GLsizei width, GLsizei height) |
| 6916 { |
| 6917 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6918 const GLuint cmdlen = 24; |
| 6919 emit_header(gc->pc, X_GLrop_RenderbufferStorageMultisample, cmdlen); |
| 6920 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 6921 (void) memcpy((void *)(gc->pc + 8), (void *)(&samples), 4); |
| 6922 (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4); |
| 6923 (void) memcpy((void *)(gc->pc + 16), (void *)(&width), 4); |
| 6924 (void) memcpy((void *)(gc->pc + 20), (void *)(&height), 4); |
| 6925 gc->pc += cmdlen; |
| 6926 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6927 } |
| 6928 |
| 6929 #define X_GLrop_SampleMaskSGIS 2048 |
| 6930 void __indirect_glSampleMaskSGIS(GLclampf value, GLboolean invert) |
| 6931 { |
| 6932 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6933 const GLuint cmdlen = 12; |
| 6934 emit_header(gc->pc, X_GLrop_SampleMaskSGIS, cmdlen); |
| 6935 (void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4); |
| 6936 (void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1); |
| 6937 gc->pc += cmdlen; |
| 6938 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6939 } |
| 6940 |
| 6941 #define X_GLrop_SamplePatternSGIS 2049 |
| 6942 void __indirect_glSamplePatternSGIS(GLenum pattern) |
| 6943 { |
| 6944 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6945 const GLuint cmdlen = 8; |
| 6946 emit_header(gc->pc, X_GLrop_SamplePatternSGIS, cmdlen); |
| 6947 (void) memcpy((void *)(gc->pc + 4), (void *)(&pattern), 4); |
| 6948 gc->pc += cmdlen; |
| 6949 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6950 } |
| 6951 |
| 6952 #define X_GLrop_PointParameterfEXT 2065 |
| 6953 void __indirect_glPointParameterfEXT(GLenum pname, GLfloat param) |
| 6954 { |
| 6955 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6956 const GLuint cmdlen = 12; |
| 6957 emit_header(gc->pc, X_GLrop_PointParameterfEXT, cmdlen); |
| 6958 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); |
| 6959 (void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4); |
| 6960 gc->pc += cmdlen; |
| 6961 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6962 } |
| 6963 |
| 6964 #define X_GLrop_PointParameterfvEXT 2066 |
| 6965 void __indirect_glPointParameterfvEXT(GLenum pname, const GLfloat * params) |
| 6966 { |
| 6967 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6968 const GLuint compsize = __glPointParameterfvEXT_size(pname); |
| 6969 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4)); |
| 6970 emit_header(gc->pc, X_GLrop_PointParameterfvEXT, cmdlen); |
| 6971 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); |
| 6972 (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4)); |
| 6973 gc->pc += cmdlen; |
| 6974 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6975 } |
| 6976 |
| 6977 #define X_GLrop_SecondaryColor3bvEXT 4126 |
| 6978 void __indirect_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue) |
| 6979 { |
| 6980 struct glx_context * const gc = __glXGetCurrentContext(); |
| 6981 const GLuint cmdlen = 8; |
| 6982 emit_header(gc->pc, X_GLrop_SecondaryColor3bvEXT, cmdlen); |
| 6983 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1); |
| 6984 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1); |
| 6985 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1); |
| 6986 gc->pc += cmdlen; |
| 6987 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 6988 } |
| 6989 |
| 6990 #define X_GLrop_SecondaryColor3bvEXT 4126 |
| 6991 void __indirect_glSecondaryColor3bvEXT(const GLbyte * v) |
| 6992 { |
| 6993 generic_3_byte( X_GLrop_SecondaryColor3bvEXT, v ); |
| 6994 } |
| 6995 |
| 6996 #define X_GLrop_SecondaryColor3dvEXT 4130 |
| 6997 void __indirect_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blu
e) |
| 6998 { |
| 6999 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7000 const GLuint cmdlen = 28; |
| 7001 emit_header(gc->pc, X_GLrop_SecondaryColor3dvEXT, cmdlen); |
| 7002 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8); |
| 7003 (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8); |
| 7004 (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8); |
| 7005 gc->pc += cmdlen; |
| 7006 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7007 } |
| 7008 |
| 7009 #define X_GLrop_SecondaryColor3dvEXT 4130 |
| 7010 void __indirect_glSecondaryColor3dvEXT(const GLdouble * v) |
| 7011 { |
| 7012 generic_24_byte( X_GLrop_SecondaryColor3dvEXT, v ); |
| 7013 } |
| 7014 |
| 7015 #define X_GLrop_SecondaryColor3fvEXT 4129 |
| 7016 void __indirect_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue) |
| 7017 { |
| 7018 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7019 const GLuint cmdlen = 16; |
| 7020 emit_header(gc->pc, X_GLrop_SecondaryColor3fvEXT, cmdlen); |
| 7021 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); |
| 7022 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); |
| 7023 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); |
| 7024 gc->pc += cmdlen; |
| 7025 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7026 } |
| 7027 |
| 7028 #define X_GLrop_SecondaryColor3fvEXT 4129 |
| 7029 void __indirect_glSecondaryColor3fvEXT(const GLfloat * v) |
| 7030 { |
| 7031 generic_12_byte( X_GLrop_SecondaryColor3fvEXT, v ); |
| 7032 } |
| 7033 |
| 7034 #define X_GLrop_SecondaryColor3ivEXT 4128 |
| 7035 void __indirect_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue) |
| 7036 { |
| 7037 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7038 const GLuint cmdlen = 16; |
| 7039 emit_header(gc->pc, X_GLrop_SecondaryColor3ivEXT, cmdlen); |
| 7040 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); |
| 7041 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); |
| 7042 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); |
| 7043 gc->pc += cmdlen; |
| 7044 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7045 } |
| 7046 |
| 7047 #define X_GLrop_SecondaryColor3ivEXT 4128 |
| 7048 void __indirect_glSecondaryColor3ivEXT(const GLint * v) |
| 7049 { |
| 7050 generic_12_byte( X_GLrop_SecondaryColor3ivEXT, v ); |
| 7051 } |
| 7052 |
| 7053 #define X_GLrop_SecondaryColor3svEXT 4127 |
| 7054 void __indirect_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue) |
| 7055 { |
| 7056 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7057 const GLuint cmdlen = 12; |
| 7058 emit_header(gc->pc, X_GLrop_SecondaryColor3svEXT, cmdlen); |
| 7059 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2); |
| 7060 (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2); |
| 7061 (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2); |
| 7062 gc->pc += cmdlen; |
| 7063 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7064 } |
| 7065 |
| 7066 #define X_GLrop_SecondaryColor3svEXT 4127 |
| 7067 void __indirect_glSecondaryColor3svEXT(const GLshort * v) |
| 7068 { |
| 7069 generic_6_byte( X_GLrop_SecondaryColor3svEXT, v ); |
| 7070 } |
| 7071 |
| 7072 #define X_GLrop_SecondaryColor3ubvEXT 4131 |
| 7073 void __indirect_glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue) |
| 7074 { |
| 7075 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7076 const GLuint cmdlen = 8; |
| 7077 emit_header(gc->pc, X_GLrop_SecondaryColor3ubvEXT, cmdlen); |
| 7078 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1); |
| 7079 (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1); |
| 7080 (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1); |
| 7081 gc->pc += cmdlen; |
| 7082 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7083 } |
| 7084 |
| 7085 #define X_GLrop_SecondaryColor3ubvEXT 4131 |
| 7086 void __indirect_glSecondaryColor3ubvEXT(const GLubyte * v) |
| 7087 { |
| 7088 generic_3_byte( X_GLrop_SecondaryColor3ubvEXT, v ); |
| 7089 } |
| 7090 |
| 7091 #define X_GLrop_SecondaryColor3uivEXT 4133 |
| 7092 void __indirect_glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue) |
| 7093 { |
| 7094 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7095 const GLuint cmdlen = 16; |
| 7096 emit_header(gc->pc, X_GLrop_SecondaryColor3uivEXT, cmdlen); |
| 7097 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); |
| 7098 (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); |
| 7099 (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); |
| 7100 gc->pc += cmdlen; |
| 7101 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7102 } |
| 7103 |
| 7104 #define X_GLrop_SecondaryColor3uivEXT 4133 |
| 7105 void __indirect_glSecondaryColor3uivEXT(const GLuint * v) |
| 7106 { |
| 7107 generic_12_byte( X_GLrop_SecondaryColor3uivEXT, v ); |
| 7108 } |
| 7109 |
| 7110 #define X_GLrop_SecondaryColor3usvEXT 4132 |
| 7111 void __indirect_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort bl
ue) |
| 7112 { |
| 7113 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7114 const GLuint cmdlen = 12; |
| 7115 emit_header(gc->pc, X_GLrop_SecondaryColor3usvEXT, cmdlen); |
| 7116 (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2); |
| 7117 (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2); |
| 7118 (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2); |
| 7119 gc->pc += cmdlen; |
| 7120 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7121 } |
| 7122 |
| 7123 #define X_GLrop_SecondaryColor3usvEXT 4132 |
| 7124 void __indirect_glSecondaryColor3usvEXT(const GLushort * v) |
| 7125 { |
| 7126 generic_6_byte( X_GLrop_SecondaryColor3usvEXT, v ); |
| 7127 } |
| 7128 |
| 7129 #define X_GLrop_FogCoorddvEXT 4125 |
| 7130 void __indirect_glFogCoorddEXT(GLdouble coord) |
| 7131 { |
| 7132 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7133 const GLuint cmdlen = 12; |
| 7134 emit_header(gc->pc, X_GLrop_FogCoorddvEXT, cmdlen); |
| 7135 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 8); |
| 7136 gc->pc += cmdlen; |
| 7137 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7138 } |
| 7139 |
| 7140 #define X_GLrop_FogCoorddvEXT 4125 |
| 7141 void __indirect_glFogCoorddvEXT(const GLdouble * coord) |
| 7142 { |
| 7143 generic_8_byte( X_GLrop_FogCoorddvEXT, coord ); |
| 7144 } |
| 7145 |
| 7146 #define X_GLrop_FogCoordfvEXT 4124 |
| 7147 void __indirect_glFogCoordfEXT(GLfloat coord) |
| 7148 { |
| 7149 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7150 const GLuint cmdlen = 8; |
| 7151 emit_header(gc->pc, X_GLrop_FogCoordfvEXT, cmdlen); |
| 7152 (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4); |
| 7153 gc->pc += cmdlen; |
| 7154 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7155 } |
| 7156 |
| 7157 #define X_GLrop_FogCoordfvEXT 4124 |
| 7158 void __indirect_glFogCoordfvEXT(const GLfloat * coord) |
| 7159 { |
| 7160 generic_4_byte( X_GLrop_FogCoordfvEXT, coord ); |
| 7161 } |
| 7162 |
| 7163 #define X_GLrop_BlendFuncSeparateEXT 4134 |
| 7164 void __indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLe
num sfactorAlpha, GLenum dfactorAlpha) |
| 7165 { |
| 7166 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7167 const GLuint cmdlen = 20; |
| 7168 emit_header(gc->pc, X_GLrop_BlendFuncSeparateEXT, cmdlen); |
| 7169 (void) memcpy((void *)(gc->pc + 4), (void *)(&sfactorRGB), 4); |
| 7170 (void) memcpy((void *)(gc->pc + 8), (void *)(&dfactorRGB), 4); |
| 7171 (void) memcpy((void *)(gc->pc + 12), (void *)(&sfactorAlpha), 4); |
| 7172 (void) memcpy((void *)(gc->pc + 16), (void *)(&dfactorAlpha), 4); |
| 7173 gc->pc += cmdlen; |
| 7174 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7175 } |
| 7176 |
| 7177 #define X_GLrop_WindowPos3fvMESA 230 |
| 7178 void __indirect_glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z) |
| 7179 { |
| 7180 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7181 const GLuint cmdlen = 16; |
| 7182 emit_header(gc->pc, X_GLrop_WindowPos3fvMESA, cmdlen); |
| 7183 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); |
| 7184 (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); |
| 7185 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); |
| 7186 gc->pc += cmdlen; |
| 7187 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7188 } |
| 7189 |
| 7190 #define X_GLrop_WindowPos3fvMESA 230 |
| 7191 void __indirect_glWindowPos3fvMESA(const GLfloat * v) |
| 7192 { |
| 7193 generic_12_byte( X_GLrop_WindowPos3fvMESA, v ); |
| 7194 } |
| 7195 |
| 7196 #define X_GLvop_AreProgramsResidentNV 1293 |
| 7197 GLboolean __indirect_glAreProgramsResidentNV(GLsizei n, const GLuint * ids, GLbo
olean * residences) |
| 7198 { |
| 7199 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7200 Display * const dpy = gc->currentDpy; |
| 7201 GLboolean retval = (GLboolean) 0; |
| 7202 const GLuint cmdlen = 4 + __GLX_PAD((n * 4)); |
| 7203 if (n < 0) { |
| 7204 __glXSetError(gc, GL_INVALID_VALUE); |
| 7205 return 0; |
| 7206 } |
| 7207 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { |
| 7208 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_AreProgramsResidentNV, cmdlen); |
| 7209 (void) memcpy((void *)(pc + 0), (void *)(&n), 4); |
| 7210 (void) memcpy((void *)(pc + 4), (void *)(ids), (n * 4)); |
| 7211 retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_FALSE); |
| 7212 UnlockDisplay(dpy); SyncHandle(); |
| 7213 } |
| 7214 return retval; |
| 7215 } |
| 7216 |
| 7217 #define X_GLrop_BindProgramNV 4180 |
| 7218 void __indirect_glBindProgramNV(GLenum target, GLuint program) |
| 7219 { |
| 7220 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7221 const GLuint cmdlen = 12; |
| 7222 emit_header(gc->pc, X_GLrop_BindProgramNV, cmdlen); |
| 7223 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 7224 (void) memcpy((void *)(gc->pc + 8), (void *)(&program), 4); |
| 7225 gc->pc += cmdlen; |
| 7226 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7227 } |
| 7228 |
| 7229 #define X_GLvop_DeleteProgramsNV 1294 |
| 7230 void __indirect_glDeleteProgramsNV(GLsizei n, const GLuint * programs) |
| 7231 { |
| 7232 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7233 Display * const dpy = gc->currentDpy; |
| 7234 const GLuint cmdlen = 4 + __GLX_PAD((n * 4)); |
| 7235 if (n < 0) { |
| 7236 __glXSetError(gc, GL_INVALID_VALUE); |
| 7237 return; |
| 7238 } |
| 7239 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { |
| 7240 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivate, X_G
Lvop_DeleteProgramsNV, cmdlen); |
| 7241 (void) memcpy((void *)(pc + 0), (void *)(&n), 4); |
| 7242 (void) memcpy((void *)(pc + 4), (void *)(programs), (n * 4)); |
| 7243 UnlockDisplay(dpy); SyncHandle(); |
| 7244 } |
| 7245 return; |
| 7246 } |
| 7247 |
| 7248 #define X_GLrop_ExecuteProgramNV 4181 |
| 7249 void __indirect_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat * par
ams) |
| 7250 { |
| 7251 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7252 const GLuint cmdlen = 28; |
| 7253 emit_header(gc->pc, X_GLrop_ExecuteProgramNV, cmdlen); |
| 7254 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 7255 (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4); |
| 7256 (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16); |
| 7257 gc->pc += cmdlen; |
| 7258 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7259 } |
| 7260 |
| 7261 #define X_GLvop_GenProgramsNV 1295 |
| 7262 void __indirect_glGenProgramsNV(GLsizei n, GLuint * programs) |
| 7263 { |
| 7264 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7265 Display * const dpy = gc->currentDpy; |
| 7266 const GLuint cmdlen = 4; |
| 7267 if (n < 0) { |
| 7268 __glXSetError(gc, GL_INVALID_VALUE); |
| 7269 return; |
| 7270 } |
| 7271 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { |
| 7272 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GenProgramsNV, cmdlen); |
| 7273 (void) memcpy((void *)(pc + 0), (void *)(&n), 4); |
| 7274 (void) __glXReadReply(dpy, 4, programs, GL_TRUE); |
| 7275 UnlockDisplay(dpy); SyncHandle(); |
| 7276 } |
| 7277 return; |
| 7278 } |
| 7279 |
| 7280 #define X_GLvop_GetProgramParameterdvNV 1297 |
| 7281 void __indirect_glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pn
ame, GLdouble * params) |
| 7282 { |
| 7283 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7284 Display * const dpy = gc->currentDpy; |
| 7285 const GLuint cmdlen = 12; |
| 7286 if (__builtin_expect(dpy != NULL, 1)) { |
| 7287 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetProgramParameterdvNV, cmdlen); |
| 7288 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 7289 (void) memcpy((void *)(pc + 4), (void *)(&index), 4); |
| 7290 (void) memcpy((void *)(pc + 8), (void *)(&pname), 4); |
| 7291 (void) __glXReadReply(dpy, 8, params, GL_FALSE); |
| 7292 UnlockDisplay(dpy); SyncHandle(); |
| 7293 } |
| 7294 return; |
| 7295 } |
| 7296 |
| 7297 #define X_GLvop_GetProgramParameterfvNV 1296 |
| 7298 void __indirect_glGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pn
ame, GLfloat * params) |
| 7299 { |
| 7300 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7301 Display * const dpy = gc->currentDpy; |
| 7302 const GLuint cmdlen = 12; |
| 7303 if (__builtin_expect(dpy != NULL, 1)) { |
| 7304 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetProgramParameterfvNV, cmdlen); |
| 7305 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 7306 (void) memcpy((void *)(pc + 4), (void *)(&index), 4); |
| 7307 (void) memcpy((void *)(pc + 8), (void *)(&pname), 4); |
| 7308 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 7309 UnlockDisplay(dpy); SyncHandle(); |
| 7310 } |
| 7311 return; |
| 7312 } |
| 7313 |
| 7314 #define X_GLvop_GetProgramStringNV 1299 |
| 7315 void __indirect_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte * program) |
| 7316 { |
| 7317 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7318 Display * const dpy = gc->currentDpy; |
| 7319 const GLuint cmdlen = 8; |
| 7320 if (__builtin_expect(dpy != NULL, 1)) { |
| 7321 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetProgramStringNV, cmdlen); |
| 7322 (void) memcpy((void *)(pc + 0), (void *)(&id), 4); |
| 7323 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 7324 (void) __glXReadReply(dpy, 1, program, GL_TRUE); |
| 7325 UnlockDisplay(dpy); SyncHandle(); |
| 7326 } |
| 7327 return; |
| 7328 } |
| 7329 |
| 7330 #define X_GLvop_GetProgramivNV 1298 |
| 7331 void __indirect_glGetProgramivNV(GLuint id, GLenum pname, GLint * params) |
| 7332 { |
| 7333 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7334 Display * const dpy = gc->currentDpy; |
| 7335 const GLuint cmdlen = 8; |
| 7336 if (__builtin_expect(dpy != NULL, 1)) { |
| 7337 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetProgramivNV, cmdlen); |
| 7338 (void) memcpy((void *)(pc + 0), (void *)(&id), 4); |
| 7339 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 7340 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 7341 UnlockDisplay(dpy); SyncHandle(); |
| 7342 } |
| 7343 return; |
| 7344 } |
| 7345 |
| 7346 #define X_GLvop_GetTrackMatrixivNV 1300 |
| 7347 void __indirect_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname
, GLint * params) |
| 7348 { |
| 7349 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7350 Display * const dpy = gc->currentDpy; |
| 7351 const GLuint cmdlen = 12; |
| 7352 if (__builtin_expect(dpy != NULL, 1)) { |
| 7353 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetTrackMatrixivNV, cmdlen); |
| 7354 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 7355 (void) memcpy((void *)(pc + 4), (void *)(&address), 4); |
| 7356 (void) memcpy((void *)(pc + 8), (void *)(&pname), 4); |
| 7357 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 7358 UnlockDisplay(dpy); SyncHandle(); |
| 7359 } |
| 7360 return; |
| 7361 } |
| 7362 |
| 7363 #define X_GLvop_GetVertexAttribdvNV 1301 |
| 7364 void __indirect_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble * par
ams) |
| 7365 { |
| 7366 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7367 Display * const dpy = gc->currentDpy; |
| 7368 const GLuint cmdlen = 8; |
| 7369 if (__builtin_expect(dpy != NULL, 1)) { |
| 7370 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetVertexAttribdvNV, cmdlen); |
| 7371 (void) memcpy((void *)(pc + 0), (void *)(&index), 4); |
| 7372 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 7373 (void) __glXReadReply(dpy, 8, params, GL_FALSE); |
| 7374 UnlockDisplay(dpy); SyncHandle(); |
| 7375 } |
| 7376 return; |
| 7377 } |
| 7378 |
| 7379 #define X_GLvop_GetVertexAttribfvNV 1302 |
| 7380 void __indirect_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * para
ms) |
| 7381 { |
| 7382 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7383 Display * const dpy = gc->currentDpy; |
| 7384 const GLuint cmdlen = 8; |
| 7385 if (__builtin_expect(dpy != NULL, 1)) { |
| 7386 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetVertexAttribfvNV, cmdlen); |
| 7387 (void) memcpy((void *)(pc + 0), (void *)(&index), 4); |
| 7388 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 7389 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 7390 UnlockDisplay(dpy); SyncHandle(); |
| 7391 } |
| 7392 return; |
| 7393 } |
| 7394 |
| 7395 #define X_GLvop_GetVertexAttribivNV 1303 |
| 7396 void __indirect_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params
) |
| 7397 { |
| 7398 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7399 Display * const dpy = gc->currentDpy; |
| 7400 const GLuint cmdlen = 8; |
| 7401 if (__builtin_expect(dpy != NULL, 1)) { |
| 7402 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetVertexAttribivNV, cmdlen); |
| 7403 (void) memcpy((void *)(pc + 0), (void *)(&index), 4); |
| 7404 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 7405 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 7406 UnlockDisplay(dpy); SyncHandle(); |
| 7407 } |
| 7408 return; |
| 7409 } |
| 7410 |
| 7411 #define X_GLvop_IsProgramNV 1304 |
| 7412 GLboolean __indirect_glIsProgramNV(GLuint program) |
| 7413 { |
| 7414 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7415 Display * const dpy = gc->currentDpy; |
| 7416 GLboolean retval = (GLboolean) 0; |
| 7417 const GLuint cmdlen = 4; |
| 7418 if (__builtin_expect(dpy != NULL, 1)) { |
| 7419 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_IsProgramNV, cmdlen); |
| 7420 (void) memcpy((void *)(pc + 0), (void *)(&program), 4); |
| 7421 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE); |
| 7422 UnlockDisplay(dpy); SyncHandle(); |
| 7423 } |
| 7424 return retval; |
| 7425 } |
| 7426 |
| 7427 #define X_GLrop_LoadProgramNV 4183 |
| 7428 void __indirect_glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLu
byte * program) |
| 7429 { |
| 7430 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7431 const GLuint cmdlen = 16 + __GLX_PAD(len); |
| 7432 if (len < 0) { |
| 7433 __glXSetError(gc, GL_INVALID_VALUE); |
| 7434 return; |
| 7435 } |
| 7436 if (__builtin_expect(len >= 0, 1)) { |
| 7437 emit_header(gc->pc, X_GLrop_LoadProgramNV, cmdlen); |
| 7438 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 7439 (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4); |
| 7440 (void) memcpy((void *)(gc->pc + 12), (void *)(&len), 4); |
| 7441 (void) memcpy((void *)(gc->pc + 16), (void *)(program), len); |
| 7442 gc->pc += cmdlen; |
| 7443 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7444 } |
| 7445 } |
| 7446 |
| 7447 #define X_GLrop_ProgramParameters4dvNV 4187 |
| 7448 void __indirect_glProgramParameters4dvNV(GLenum target, GLuint index, GLsizei nu
m, const GLdouble * params) |
| 7449 { |
| 7450 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7451 const GLuint cmdlen = 16 + __GLX_PAD((num * 32)); |
| 7452 if (num < 0) { |
| 7453 __glXSetError(gc, GL_INVALID_VALUE); |
| 7454 return; |
| 7455 } |
| 7456 if (__builtin_expect(num >= 0, 1)) { |
| 7457 emit_header(gc->pc, X_GLrop_ProgramParameters4dvNV, cmdlen); |
| 7458 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 7459 (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4); |
| 7460 (void) memcpy((void *)(gc->pc + 12), (void *)(&num), 4); |
| 7461 (void) memcpy((void *)(gc->pc + 16), (void *)(params), (num * 32)); |
| 7462 gc->pc += cmdlen; |
| 7463 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7464 } |
| 7465 } |
| 7466 |
| 7467 #define X_GLrop_ProgramParameters4fvNV 4186 |
| 7468 void __indirect_glProgramParameters4fvNV(GLenum target, GLuint index, GLsizei nu
m, const GLfloat * params) |
| 7469 { |
| 7470 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7471 const GLuint cmdlen = 16 + __GLX_PAD((num * 16)); |
| 7472 if (num < 0) { |
| 7473 __glXSetError(gc, GL_INVALID_VALUE); |
| 7474 return; |
| 7475 } |
| 7476 if (__builtin_expect(num >= 0, 1)) { |
| 7477 emit_header(gc->pc, X_GLrop_ProgramParameters4fvNV, cmdlen); |
| 7478 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 7479 (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4); |
| 7480 (void) memcpy((void *)(gc->pc + 12), (void *)(&num), 4); |
| 7481 (void) memcpy((void *)(gc->pc + 16), (void *)(params), (num * 16)); |
| 7482 gc->pc += cmdlen; |
| 7483 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7484 } |
| 7485 } |
| 7486 |
| 7487 #define X_GLrop_RequestResidentProgramsNV 4182 |
| 7488 void __indirect_glRequestResidentProgramsNV(GLsizei n, const GLuint * ids) |
| 7489 { |
| 7490 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7491 const GLuint cmdlen = 8 + __GLX_PAD((n * 4)); |
| 7492 if (n < 0) { |
| 7493 __glXSetError(gc, GL_INVALID_VALUE); |
| 7494 return; |
| 7495 } |
| 7496 if (__builtin_expect(n >= 0, 1)) { |
| 7497 emit_header(gc->pc, X_GLrop_RequestResidentProgramsNV, cmdlen); |
| 7498 (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4); |
| 7499 (void) memcpy((void *)(gc->pc + 8), (void *)(ids), (n * 4)); |
| 7500 gc->pc += cmdlen; |
| 7501 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7502 } |
| 7503 } |
| 7504 |
| 7505 #define X_GLrop_TrackMatrixNV 4188 |
| 7506 void __indirect_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GL
enum transform) |
| 7507 { |
| 7508 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7509 const GLuint cmdlen = 20; |
| 7510 emit_header(gc->pc, X_GLrop_TrackMatrixNV, cmdlen); |
| 7511 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 7512 (void) memcpy((void *)(gc->pc + 8), (void *)(&address), 4); |
| 7513 (void) memcpy((void *)(gc->pc + 12), (void *)(&matrix), 4); |
| 7514 (void) memcpy((void *)(gc->pc + 16), (void *)(&transform), 4); |
| 7515 gc->pc += cmdlen; |
| 7516 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7517 } |
| 7518 |
| 7519 #define X_GLrop_VertexAttrib1dvNV 4273 |
| 7520 void __indirect_glVertexAttrib1dNV(GLuint index, GLdouble x) |
| 7521 { |
| 7522 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7523 const GLuint cmdlen = 16; |
| 7524 emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen); |
| 7525 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7526 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8); |
| 7527 gc->pc += cmdlen; |
| 7528 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7529 } |
| 7530 |
| 7531 #define X_GLrop_VertexAttrib1dvNV 4273 |
| 7532 void __indirect_glVertexAttrib1dvNV(GLuint index, const GLdouble * v) |
| 7533 { |
| 7534 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7535 const GLuint cmdlen = 16; |
| 7536 emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen); |
| 7537 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7538 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); |
| 7539 gc->pc += cmdlen; |
| 7540 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7541 } |
| 7542 |
| 7543 #define X_GLrop_VertexAttrib1fvNV 4269 |
| 7544 void __indirect_glVertexAttrib1fNV(GLuint index, GLfloat x) |
| 7545 { |
| 7546 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7547 const GLuint cmdlen = 12; |
| 7548 emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen); |
| 7549 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7550 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4); |
| 7551 gc->pc += cmdlen; |
| 7552 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7553 } |
| 7554 |
| 7555 #define X_GLrop_VertexAttrib1fvNV 4269 |
| 7556 void __indirect_glVertexAttrib1fvNV(GLuint index, const GLfloat * v) |
| 7557 { |
| 7558 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7559 const GLuint cmdlen = 12; |
| 7560 emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen); |
| 7561 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7562 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); |
| 7563 gc->pc += cmdlen; |
| 7564 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7565 } |
| 7566 |
| 7567 #define X_GLrop_VertexAttrib1svNV 4265 |
| 7568 void __indirect_glVertexAttrib1sNV(GLuint index, GLshort x) |
| 7569 { |
| 7570 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7571 const GLuint cmdlen = 12; |
| 7572 emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen); |
| 7573 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7574 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2); |
| 7575 gc->pc += cmdlen; |
| 7576 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7577 } |
| 7578 |
| 7579 #define X_GLrop_VertexAttrib1svNV 4265 |
| 7580 void __indirect_glVertexAttrib1svNV(GLuint index, const GLshort * v) |
| 7581 { |
| 7582 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7583 const GLuint cmdlen = 12; |
| 7584 emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen); |
| 7585 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7586 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2); |
| 7587 gc->pc += cmdlen; |
| 7588 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7589 } |
| 7590 |
| 7591 #define X_GLrop_VertexAttrib2dvNV 4274 |
| 7592 void __indirect_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y) |
| 7593 { |
| 7594 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7595 const GLuint cmdlen = 24; |
| 7596 emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen); |
| 7597 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7598 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8); |
| 7599 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8); |
| 7600 gc->pc += cmdlen; |
| 7601 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7602 } |
| 7603 |
| 7604 #define X_GLrop_VertexAttrib2dvNV 4274 |
| 7605 void __indirect_glVertexAttrib2dvNV(GLuint index, const GLdouble * v) |
| 7606 { |
| 7607 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7608 const GLuint cmdlen = 24; |
| 7609 emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen); |
| 7610 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7611 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16); |
| 7612 gc->pc += cmdlen; |
| 7613 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7614 } |
| 7615 |
| 7616 #define X_GLrop_VertexAttrib2fvNV 4270 |
| 7617 void __indirect_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y) |
| 7618 { |
| 7619 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7620 const GLuint cmdlen = 16; |
| 7621 emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen); |
| 7622 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7623 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4); |
| 7624 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4); |
| 7625 gc->pc += cmdlen; |
| 7626 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7627 } |
| 7628 |
| 7629 #define X_GLrop_VertexAttrib2fvNV 4270 |
| 7630 void __indirect_glVertexAttrib2fvNV(GLuint index, const GLfloat * v) |
| 7631 { |
| 7632 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7633 const GLuint cmdlen = 16; |
| 7634 emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen); |
| 7635 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7636 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); |
| 7637 gc->pc += cmdlen; |
| 7638 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7639 } |
| 7640 |
| 7641 #define X_GLrop_VertexAttrib2svNV 4266 |
| 7642 void __indirect_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y) |
| 7643 { |
| 7644 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7645 const GLuint cmdlen = 12; |
| 7646 emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen); |
| 7647 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7648 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2); |
| 7649 (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2); |
| 7650 gc->pc += cmdlen; |
| 7651 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7652 } |
| 7653 |
| 7654 #define X_GLrop_VertexAttrib2svNV 4266 |
| 7655 void __indirect_glVertexAttrib2svNV(GLuint index, const GLshort * v) |
| 7656 { |
| 7657 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7658 const GLuint cmdlen = 12; |
| 7659 emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen); |
| 7660 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7661 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); |
| 7662 gc->pc += cmdlen; |
| 7663 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7664 } |
| 7665 |
| 7666 #define X_GLrop_VertexAttrib3dvNV 4275 |
| 7667 void __indirect_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdoubl
e z) |
| 7668 { |
| 7669 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7670 const GLuint cmdlen = 32; |
| 7671 emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen); |
| 7672 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7673 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8); |
| 7674 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8); |
| 7675 (void) memcpy((void *)(gc->pc + 24), (void *)(&z), 8); |
| 7676 gc->pc += cmdlen; |
| 7677 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7678 } |
| 7679 |
| 7680 #define X_GLrop_VertexAttrib3dvNV 4275 |
| 7681 void __indirect_glVertexAttrib3dvNV(GLuint index, const GLdouble * v) |
| 7682 { |
| 7683 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7684 const GLuint cmdlen = 32; |
| 7685 emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen); |
| 7686 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7687 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 24); |
| 7688 gc->pc += cmdlen; |
| 7689 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7690 } |
| 7691 |
| 7692 #define X_GLrop_VertexAttrib3fvNV 4271 |
| 7693 void __indirect_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z
) |
| 7694 { |
| 7695 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7696 const GLuint cmdlen = 20; |
| 7697 emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen); |
| 7698 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7699 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4); |
| 7700 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4); |
| 7701 (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4); |
| 7702 gc->pc += cmdlen; |
| 7703 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7704 } |
| 7705 |
| 7706 #define X_GLrop_VertexAttrib3fvNV 4271 |
| 7707 void __indirect_glVertexAttrib3fvNV(GLuint index, const GLfloat * v) |
| 7708 { |
| 7709 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7710 const GLuint cmdlen = 20; |
| 7711 emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen); |
| 7712 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7713 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12); |
| 7714 gc->pc += cmdlen; |
| 7715 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7716 } |
| 7717 |
| 7718 #define X_GLrop_VertexAttrib3svNV 4267 |
| 7719 void __indirect_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z
) |
| 7720 { |
| 7721 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7722 const GLuint cmdlen = 16; |
| 7723 emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen); |
| 7724 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7725 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2); |
| 7726 (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2); |
| 7727 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2); |
| 7728 gc->pc += cmdlen; |
| 7729 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7730 } |
| 7731 |
| 7732 #define X_GLrop_VertexAttrib3svNV 4267 |
| 7733 void __indirect_glVertexAttrib3svNV(GLuint index, const GLshort * v) |
| 7734 { |
| 7735 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7736 const GLuint cmdlen = 16; |
| 7737 emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen); |
| 7738 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7739 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6); |
| 7740 gc->pc += cmdlen; |
| 7741 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7742 } |
| 7743 |
| 7744 #define X_GLrop_VertexAttrib4dvNV 4276 |
| 7745 void __indirect_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdoubl
e z, GLdouble w) |
| 7746 { |
| 7747 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7748 const GLuint cmdlen = 40; |
| 7749 emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen); |
| 7750 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7751 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8); |
| 7752 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8); |
| 7753 (void) memcpy((void *)(gc->pc + 24), (void *)(&z), 8); |
| 7754 (void) memcpy((void *)(gc->pc + 32), (void *)(&w), 8); |
| 7755 gc->pc += cmdlen; |
| 7756 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7757 } |
| 7758 |
| 7759 #define X_GLrop_VertexAttrib4dvNV 4276 |
| 7760 void __indirect_glVertexAttrib4dvNV(GLuint index, const GLdouble * v) |
| 7761 { |
| 7762 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7763 const GLuint cmdlen = 40; |
| 7764 emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen); |
| 7765 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7766 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 32); |
| 7767 gc->pc += cmdlen; |
| 7768 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7769 } |
| 7770 |
| 7771 #define X_GLrop_VertexAttrib4fvNV 4272 |
| 7772 void __indirect_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z
, GLfloat w) |
| 7773 { |
| 7774 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7775 const GLuint cmdlen = 24; |
| 7776 emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen); |
| 7777 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7778 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4); |
| 7779 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4); |
| 7780 (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4); |
| 7781 (void) memcpy((void *)(gc->pc + 20), (void *)(&w), 4); |
| 7782 gc->pc += cmdlen; |
| 7783 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7784 } |
| 7785 |
| 7786 #define X_GLrop_VertexAttrib4fvNV 4272 |
| 7787 void __indirect_glVertexAttrib4fvNV(GLuint index, const GLfloat * v) |
| 7788 { |
| 7789 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7790 const GLuint cmdlen = 24; |
| 7791 emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen); |
| 7792 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7793 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16); |
| 7794 gc->pc += cmdlen; |
| 7795 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7796 } |
| 7797 |
| 7798 #define X_GLrop_VertexAttrib4svNV 4268 |
| 7799 void __indirect_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z
, GLshort w) |
| 7800 { |
| 7801 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7802 const GLuint cmdlen = 16; |
| 7803 emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen); |
| 7804 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7805 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2); |
| 7806 (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2); |
| 7807 (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2); |
| 7808 (void) memcpy((void *)(gc->pc + 14), (void *)(&w), 2); |
| 7809 gc->pc += cmdlen; |
| 7810 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7811 } |
| 7812 |
| 7813 #define X_GLrop_VertexAttrib4svNV 4268 |
| 7814 void __indirect_glVertexAttrib4svNV(GLuint index, const GLshort * v) |
| 7815 { |
| 7816 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7817 const GLuint cmdlen = 16; |
| 7818 emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen); |
| 7819 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7820 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); |
| 7821 gc->pc += cmdlen; |
| 7822 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7823 } |
| 7824 |
| 7825 #define X_GLrop_VertexAttrib4ubvNV 4277 |
| 7826 void __indirect_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte
z, GLubyte w) |
| 7827 { |
| 7828 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7829 const GLuint cmdlen = 12; |
| 7830 emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen); |
| 7831 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7832 (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 1); |
| 7833 (void) memcpy((void *)(gc->pc + 9), (void *)(&y), 1); |
| 7834 (void) memcpy((void *)(gc->pc + 10), (void *)(&z), 1); |
| 7835 (void) memcpy((void *)(gc->pc + 11), (void *)(&w), 1); |
| 7836 gc->pc += cmdlen; |
| 7837 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7838 } |
| 7839 |
| 7840 #define X_GLrop_VertexAttrib4ubvNV 4277 |
| 7841 void __indirect_glVertexAttrib4ubvNV(GLuint index, const GLubyte * v) |
| 7842 { |
| 7843 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7844 const GLuint cmdlen = 12; |
| 7845 emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen); |
| 7846 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7847 (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); |
| 7848 gc->pc += cmdlen; |
| 7849 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7850 } |
| 7851 |
| 7852 #define X_GLrop_VertexAttribs1dvNV 4210 |
| 7853 void __indirect_glVertexAttribs1dvNV(GLuint index, GLsizei n, const GLdouble * v
) |
| 7854 { |
| 7855 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7856 const GLuint cmdlen = 12 + __GLX_PAD((n * 8)); |
| 7857 if (n < 0) { |
| 7858 __glXSetError(gc, GL_INVALID_VALUE); |
| 7859 return; |
| 7860 } |
| 7861 if (__builtin_expect(n >= 0, 1)) { |
| 7862 emit_header(gc->pc, X_GLrop_VertexAttribs1dvNV, cmdlen); |
| 7863 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7864 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); |
| 7865 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8)); |
| 7866 gc->pc += cmdlen; |
| 7867 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7868 } |
| 7869 } |
| 7870 |
| 7871 #define X_GLrop_VertexAttribs1fvNV 4206 |
| 7872 void __indirect_glVertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat * v) |
| 7873 { |
| 7874 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7875 const GLuint cmdlen = 12 + __GLX_PAD((n * 4)); |
| 7876 if (n < 0) { |
| 7877 __glXSetError(gc, GL_INVALID_VALUE); |
| 7878 return; |
| 7879 } |
| 7880 if (__builtin_expect(n >= 0, 1)) { |
| 7881 emit_header(gc->pc, X_GLrop_VertexAttribs1fvNV, cmdlen); |
| 7882 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7883 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); |
| 7884 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4)); |
| 7885 gc->pc += cmdlen; |
| 7886 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7887 } |
| 7888 } |
| 7889 |
| 7890 #define X_GLrop_VertexAttribs1svNV 4202 |
| 7891 void __indirect_glVertexAttribs1svNV(GLuint index, GLsizei n, const GLshort * v) |
| 7892 { |
| 7893 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7894 const GLuint cmdlen = 12 + __GLX_PAD((n * 2)); |
| 7895 if (n < 0) { |
| 7896 __glXSetError(gc, GL_INVALID_VALUE); |
| 7897 return; |
| 7898 } |
| 7899 if (__builtin_expect(n >= 0, 1)) { |
| 7900 emit_header(gc->pc, X_GLrop_VertexAttribs1svNV, cmdlen); |
| 7901 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7902 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); |
| 7903 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 2)); |
| 7904 gc->pc += cmdlen; |
| 7905 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7906 } |
| 7907 } |
| 7908 |
| 7909 #define X_GLrop_VertexAttribs2dvNV 4211 |
| 7910 void __indirect_glVertexAttribs2dvNV(GLuint index, GLsizei n, const GLdouble * v
) |
| 7911 { |
| 7912 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7913 const GLuint cmdlen = 12 + __GLX_PAD((n * 16)); |
| 7914 if (n < 0) { |
| 7915 __glXSetError(gc, GL_INVALID_VALUE); |
| 7916 return; |
| 7917 } |
| 7918 if (__builtin_expect(n >= 0, 1)) { |
| 7919 emit_header(gc->pc, X_GLrop_VertexAttribs2dvNV, cmdlen); |
| 7920 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7921 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); |
| 7922 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 16)); |
| 7923 gc->pc += cmdlen; |
| 7924 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7925 } |
| 7926 } |
| 7927 |
| 7928 #define X_GLrop_VertexAttribs2fvNV 4207 |
| 7929 void __indirect_glVertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat * v) |
| 7930 { |
| 7931 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7932 const GLuint cmdlen = 12 + __GLX_PAD((n * 8)); |
| 7933 if (n < 0) { |
| 7934 __glXSetError(gc, GL_INVALID_VALUE); |
| 7935 return; |
| 7936 } |
| 7937 if (__builtin_expect(n >= 0, 1)) { |
| 7938 emit_header(gc->pc, X_GLrop_VertexAttribs2fvNV, cmdlen); |
| 7939 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7940 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); |
| 7941 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8)); |
| 7942 gc->pc += cmdlen; |
| 7943 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7944 } |
| 7945 } |
| 7946 |
| 7947 #define X_GLrop_VertexAttribs2svNV 4203 |
| 7948 void __indirect_glVertexAttribs2svNV(GLuint index, GLsizei n, const GLshort * v) |
| 7949 { |
| 7950 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7951 const GLuint cmdlen = 12 + __GLX_PAD((n * 4)); |
| 7952 if (n < 0) { |
| 7953 __glXSetError(gc, GL_INVALID_VALUE); |
| 7954 return; |
| 7955 } |
| 7956 if (__builtin_expect(n >= 0, 1)) { |
| 7957 emit_header(gc->pc, X_GLrop_VertexAttribs2svNV, cmdlen); |
| 7958 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7959 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); |
| 7960 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4)); |
| 7961 gc->pc += cmdlen; |
| 7962 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7963 } |
| 7964 } |
| 7965 |
| 7966 #define X_GLrop_VertexAttribs3dvNV 4212 |
| 7967 void __indirect_glVertexAttribs3dvNV(GLuint index, GLsizei n, const GLdouble * v
) |
| 7968 { |
| 7969 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7970 const GLuint cmdlen = 12 + __GLX_PAD((n * 24)); |
| 7971 if (n < 0) { |
| 7972 __glXSetError(gc, GL_INVALID_VALUE); |
| 7973 return; |
| 7974 } |
| 7975 if (__builtin_expect(n >= 0, 1)) { |
| 7976 emit_header(gc->pc, X_GLrop_VertexAttribs3dvNV, cmdlen); |
| 7977 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7978 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); |
| 7979 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 24)); |
| 7980 gc->pc += cmdlen; |
| 7981 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 7982 } |
| 7983 } |
| 7984 |
| 7985 #define X_GLrop_VertexAttribs3fvNV 4208 |
| 7986 void __indirect_glVertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat * v) |
| 7987 { |
| 7988 struct glx_context * const gc = __glXGetCurrentContext(); |
| 7989 const GLuint cmdlen = 12 + __GLX_PAD((n * 12)); |
| 7990 if (n < 0) { |
| 7991 __glXSetError(gc, GL_INVALID_VALUE); |
| 7992 return; |
| 7993 } |
| 7994 if (__builtin_expect(n >= 0, 1)) { |
| 7995 emit_header(gc->pc, X_GLrop_VertexAttribs3fvNV, cmdlen); |
| 7996 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 7997 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); |
| 7998 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 12)); |
| 7999 gc->pc += cmdlen; |
| 8000 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8001 } |
| 8002 } |
| 8003 |
| 8004 #define X_GLrop_VertexAttribs3svNV 4204 |
| 8005 void __indirect_glVertexAttribs3svNV(GLuint index, GLsizei n, const GLshort * v) |
| 8006 { |
| 8007 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8008 const GLuint cmdlen = 12 + __GLX_PAD((n * 6)); |
| 8009 if (n < 0) { |
| 8010 __glXSetError(gc, GL_INVALID_VALUE); |
| 8011 return; |
| 8012 } |
| 8013 if (__builtin_expect(n >= 0, 1)) { |
| 8014 emit_header(gc->pc, X_GLrop_VertexAttribs3svNV, cmdlen); |
| 8015 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 8016 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); |
| 8017 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 6)); |
| 8018 gc->pc += cmdlen; |
| 8019 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8020 } |
| 8021 } |
| 8022 |
| 8023 #define X_GLrop_VertexAttribs4dvNV 4213 |
| 8024 void __indirect_glVertexAttribs4dvNV(GLuint index, GLsizei n, const GLdouble * v
) |
| 8025 { |
| 8026 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8027 const GLuint cmdlen = 12 + __GLX_PAD((n * 32)); |
| 8028 if (n < 0) { |
| 8029 __glXSetError(gc, GL_INVALID_VALUE); |
| 8030 return; |
| 8031 } |
| 8032 if (__builtin_expect(n >= 0, 1)) { |
| 8033 emit_header(gc->pc, X_GLrop_VertexAttribs4dvNV, cmdlen); |
| 8034 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 8035 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); |
| 8036 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 32)); |
| 8037 gc->pc += cmdlen; |
| 8038 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8039 } |
| 8040 } |
| 8041 |
| 8042 #define X_GLrop_VertexAttribs4fvNV 4209 |
| 8043 void __indirect_glVertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat * v) |
| 8044 { |
| 8045 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8046 const GLuint cmdlen = 12 + __GLX_PAD((n * 16)); |
| 8047 if (n < 0) { |
| 8048 __glXSetError(gc, GL_INVALID_VALUE); |
| 8049 return; |
| 8050 } |
| 8051 if (__builtin_expect(n >= 0, 1)) { |
| 8052 emit_header(gc->pc, X_GLrop_VertexAttribs4fvNV, cmdlen); |
| 8053 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 8054 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); |
| 8055 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 16)); |
| 8056 gc->pc += cmdlen; |
| 8057 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8058 } |
| 8059 } |
| 8060 |
| 8061 #define X_GLrop_VertexAttribs4svNV 4205 |
| 8062 void __indirect_glVertexAttribs4svNV(GLuint index, GLsizei n, const GLshort * v) |
| 8063 { |
| 8064 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8065 const GLuint cmdlen = 12 + __GLX_PAD((n * 8)); |
| 8066 if (n < 0) { |
| 8067 __glXSetError(gc, GL_INVALID_VALUE); |
| 8068 return; |
| 8069 } |
| 8070 if (__builtin_expect(n >= 0, 1)) { |
| 8071 emit_header(gc->pc, X_GLrop_VertexAttribs4svNV, cmdlen); |
| 8072 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 8073 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); |
| 8074 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8)); |
| 8075 gc->pc += cmdlen; |
| 8076 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8077 } |
| 8078 } |
| 8079 |
| 8080 #define X_GLrop_VertexAttribs4ubvNV 4214 |
| 8081 void __indirect_glVertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte * v
) |
| 8082 { |
| 8083 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8084 const GLuint cmdlen = 12 + __GLX_PAD((n * 4)); |
| 8085 if (n < 0) { |
| 8086 __glXSetError(gc, GL_INVALID_VALUE); |
| 8087 return; |
| 8088 } |
| 8089 if (__builtin_expect(n >= 0, 1)) { |
| 8090 emit_header(gc->pc, X_GLrop_VertexAttribs4ubvNV, cmdlen); |
| 8091 (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); |
| 8092 (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); |
| 8093 (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4)); |
| 8094 gc->pc += cmdlen; |
| 8095 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8096 } |
| 8097 } |
| 8098 |
| 8099 #define X_GLrop_PointParameteriNV 4221 |
| 8100 void __indirect_glPointParameteriNV(GLenum pname, GLint param) |
| 8101 { |
| 8102 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8103 const GLuint cmdlen = 12; |
| 8104 emit_header(gc->pc, X_GLrop_PointParameteriNV, cmdlen); |
| 8105 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); |
| 8106 (void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4); |
| 8107 gc->pc += cmdlen; |
| 8108 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8109 } |
| 8110 |
| 8111 #define X_GLrop_PointParameterivNV 4222 |
| 8112 void __indirect_glPointParameterivNV(GLenum pname, const GLint * params) |
| 8113 { |
| 8114 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8115 const GLuint compsize = __glPointParameterivNV_size(pname); |
| 8116 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4)); |
| 8117 emit_header(gc->pc, X_GLrop_PointParameterivNV, cmdlen); |
| 8118 (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); |
| 8119 (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4)); |
| 8120 gc->pc += cmdlen; |
| 8121 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8122 } |
| 8123 |
| 8124 #define X_GLrop_ActiveStencilFaceEXT 4220 |
| 8125 void __indirect_glActiveStencilFaceEXT(GLenum face) |
| 8126 { |
| 8127 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8128 const GLuint cmdlen = 8; |
| 8129 emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen); |
| 8130 (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4); |
| 8131 gc->pc += cmdlen; |
| 8132 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8133 } |
| 8134 |
| 8135 #define X_GLvop_GetProgramNamedParameterdvNV 1311 |
| 8136 void __indirect_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLu
byte * name, GLdouble * params) |
| 8137 { |
| 8138 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8139 Display * const dpy = gc->currentDpy; |
| 8140 const GLuint cmdlen = 8 + __GLX_PAD(len); |
| 8141 if (len < 0) { |
| 8142 __glXSetError(gc, GL_INVALID_VALUE); |
| 8143 return; |
| 8144 } |
| 8145 if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) { |
| 8146 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetProgramNamedParameterdvNV, cmdlen); |
| 8147 (void) memcpy((void *)(pc + 0), (void *)(&id), 4); |
| 8148 (void) memcpy((void *)(pc + 4), (void *)(&len), 4); |
| 8149 (void) memcpy((void *)(pc + 8), (void *)(name), len); |
| 8150 (void) __glXReadReply(dpy, 8, params, GL_TRUE); |
| 8151 UnlockDisplay(dpy); SyncHandle(); |
| 8152 } |
| 8153 return; |
| 8154 } |
| 8155 |
| 8156 #define X_GLvop_GetProgramNamedParameterfvNV 1310 |
| 8157 void __indirect_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLu
byte * name, GLfloat * params) |
| 8158 { |
| 8159 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8160 Display * const dpy = gc->currentDpy; |
| 8161 const GLuint cmdlen = 8 + __GLX_PAD(len); |
| 8162 if (len < 0) { |
| 8163 __glXSetError(gc, GL_INVALID_VALUE); |
| 8164 return; |
| 8165 } |
| 8166 if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) { |
| 8167 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetProgramNamedParameterfvNV, cmdlen); |
| 8168 (void) memcpy((void *)(pc + 0), (void *)(&id), 4); |
| 8169 (void) memcpy((void *)(pc + 4), (void *)(&len), 4); |
| 8170 (void) memcpy((void *)(pc + 8), (void *)(name), len); |
| 8171 (void) __glXReadReply(dpy, 4, params, GL_TRUE); |
| 8172 UnlockDisplay(dpy); SyncHandle(); |
| 8173 } |
| 8174 return; |
| 8175 } |
| 8176 |
| 8177 #define X_GLrop_ProgramNamedParameter4dvNV 4219 |
| 8178 void __indirect_glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyt
e * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w) |
| 8179 { |
| 8180 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8181 const GLuint cmdlen = 44 + __GLX_PAD(len); |
| 8182 if (len < 0) { |
| 8183 __glXSetError(gc, GL_INVALID_VALUE); |
| 8184 return; |
| 8185 } |
| 8186 if (__builtin_expect(len >= 0, 1)) { |
| 8187 emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen); |
| 8188 (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8); |
| 8189 (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8); |
| 8190 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8); |
| 8191 (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8); |
| 8192 (void) memcpy((void *)(gc->pc + 36), (void *)(&id), 4); |
| 8193 (void) memcpy((void *)(gc->pc + 40), (void *)(&len), 4); |
| 8194 (void) memcpy((void *)(gc->pc + 44), (void *)(name), len); |
| 8195 gc->pc += cmdlen; |
| 8196 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8197 } |
| 8198 } |
| 8199 |
| 8200 #define X_GLrop_ProgramNamedParameter4dvNV 4219 |
| 8201 void __indirect_glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLuby
te * name, const GLdouble * v) |
| 8202 { |
| 8203 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8204 const GLuint cmdlen = 44 + __GLX_PAD(len); |
| 8205 if (len < 0) { |
| 8206 __glXSetError(gc, GL_INVALID_VALUE); |
| 8207 return; |
| 8208 } |
| 8209 if (__builtin_expect(len >= 0, 1)) { |
| 8210 emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen); |
| 8211 (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32); |
| 8212 (void) memcpy((void *)(gc->pc + 36), (void *)(&id), 4); |
| 8213 (void) memcpy((void *)(gc->pc + 40), (void *)(&len), 4); |
| 8214 (void) memcpy((void *)(gc->pc + 44), (void *)(name), len); |
| 8215 gc->pc += cmdlen; |
| 8216 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8217 } |
| 8218 } |
| 8219 |
| 8220 #define X_GLrop_ProgramNamedParameter4fvNV 4218 |
| 8221 void __indirect_glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyt
e * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w) |
| 8222 { |
| 8223 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8224 const GLuint cmdlen = 28 + __GLX_PAD(len); |
| 8225 if (len < 0) { |
| 8226 __glXSetError(gc, GL_INVALID_VALUE); |
| 8227 return; |
| 8228 } |
| 8229 if (__builtin_expect(len >= 0, 1)) { |
| 8230 emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen); |
| 8231 (void) memcpy((void *)(gc->pc + 4), (void *)(&id), 4); |
| 8232 (void) memcpy((void *)(gc->pc + 8), (void *)(&len), 4); |
| 8233 (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4); |
| 8234 (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4); |
| 8235 (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4); |
| 8236 (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4); |
| 8237 (void) memcpy((void *)(gc->pc + 28), (void *)(name), len); |
| 8238 gc->pc += cmdlen; |
| 8239 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8240 } |
| 8241 } |
| 8242 |
| 8243 #define X_GLrop_ProgramNamedParameter4fvNV 4218 |
| 8244 void __indirect_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLuby
te * name, const GLfloat * v) |
| 8245 { |
| 8246 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8247 const GLuint cmdlen = 28 + __GLX_PAD(len); |
| 8248 if (len < 0) { |
| 8249 __glXSetError(gc, GL_INVALID_VALUE); |
| 8250 return; |
| 8251 } |
| 8252 if (__builtin_expect(len >= 0, 1)) { |
| 8253 emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen); |
| 8254 (void) memcpy((void *)(gc->pc + 4), (void *)(&id), 4); |
| 8255 (void) memcpy((void *)(gc->pc + 8), (void *)(&len), 4); |
| 8256 (void) memcpy((void *)(gc->pc + 12), (void *)(v), 16); |
| 8257 (void) memcpy((void *)(gc->pc + 28), (void *)(name), len); |
| 8258 gc->pc += cmdlen; |
| 8259 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8260 } |
| 8261 } |
| 8262 |
| 8263 #define X_GLrop_BlendEquationSeparateEXT 4228 |
| 8264 void __indirect_glBlendEquationSeparateEXT(GLenum modeRGB, GLenum modeA) |
| 8265 { |
| 8266 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8267 const GLuint cmdlen = 12; |
| 8268 emit_header(gc->pc, X_GLrop_BlendEquationSeparateEXT, cmdlen); |
| 8269 (void) memcpy((void *)(gc->pc + 4), (void *)(&modeRGB), 4); |
| 8270 (void) memcpy((void *)(gc->pc + 8), (void *)(&modeA), 4); |
| 8271 gc->pc += cmdlen; |
| 8272 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8273 } |
| 8274 |
| 8275 #define X_GLrop_BindFramebufferEXT 4319 |
| 8276 void __indirect_glBindFramebufferEXT(GLenum target, GLuint framebuffer) |
| 8277 { |
| 8278 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8279 const GLuint cmdlen = 12; |
| 8280 emit_header(gc->pc, X_GLrop_BindFramebufferEXT, cmdlen); |
| 8281 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 8282 (void) memcpy((void *)(gc->pc + 8), (void *)(&framebuffer), 4); |
| 8283 gc->pc += cmdlen; |
| 8284 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8285 } |
| 8286 |
| 8287 #define X_GLrop_BindRenderbufferEXT 4316 |
| 8288 void __indirect_glBindRenderbufferEXT(GLenum target, GLuint renderbuffer) |
| 8289 { |
| 8290 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8291 const GLuint cmdlen = 12; |
| 8292 emit_header(gc->pc, X_GLrop_BindRenderbufferEXT, cmdlen); |
| 8293 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 8294 (void) memcpy((void *)(gc->pc + 8), (void *)(&renderbuffer), 4); |
| 8295 gc->pc += cmdlen; |
| 8296 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8297 } |
| 8298 |
| 8299 #define X_GLvop_CheckFramebufferStatusEXT 1427 |
| 8300 GLenum __indirect_glCheckFramebufferStatusEXT(GLenum target) |
| 8301 { |
| 8302 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8303 Display * const dpy = gc->currentDpy; |
| 8304 GLenum retval = (GLenum) 0; |
| 8305 const GLuint cmdlen = 4; |
| 8306 if (__builtin_expect(dpy != NULL, 1)) { |
| 8307 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_CheckFramebufferStatusEXT, cmdlen); |
| 8308 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 8309 retval = (GLenum) __glXReadReply(dpy, 0, NULL, GL_FALSE); |
| 8310 UnlockDisplay(dpy); SyncHandle(); |
| 8311 } |
| 8312 return retval; |
| 8313 } |
| 8314 |
| 8315 #define X_GLrop_DeleteFramebuffersEXT 4320 |
| 8316 void __indirect_glDeleteFramebuffersEXT(GLsizei n, const GLuint * framebuffers) |
| 8317 { |
| 8318 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8319 const GLuint cmdlen = 8 + __GLX_PAD((n * 4)); |
| 8320 if (n < 0) { |
| 8321 __glXSetError(gc, GL_INVALID_VALUE); |
| 8322 return; |
| 8323 } |
| 8324 if (__builtin_expect(n >= 0, 1)) { |
| 8325 emit_header(gc->pc, X_GLrop_DeleteFramebuffersEXT, cmdlen); |
| 8326 (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4); |
| 8327 (void) memcpy((void *)(gc->pc + 8), (void *)(framebuffers), (n * 4)); |
| 8328 gc->pc += cmdlen; |
| 8329 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8330 } |
| 8331 } |
| 8332 |
| 8333 #define X_GLrop_DeleteRenderbuffersEXT 4317 |
| 8334 void __indirect_glDeleteRenderbuffersEXT(GLsizei n, const GLuint * renderbuffers
) |
| 8335 { |
| 8336 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8337 const GLuint cmdlen = 8 + __GLX_PAD((n * 4)); |
| 8338 if (n < 0) { |
| 8339 __glXSetError(gc, GL_INVALID_VALUE); |
| 8340 return; |
| 8341 } |
| 8342 if (__builtin_expect(n >= 0, 1)) { |
| 8343 emit_header(gc->pc, X_GLrop_DeleteRenderbuffersEXT, cmdlen); |
| 8344 (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4); |
| 8345 (void) memcpy((void *)(gc->pc + 8), (void *)(renderbuffers), (n * 4)); |
| 8346 gc->pc += cmdlen; |
| 8347 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8348 } |
| 8349 } |
| 8350 |
| 8351 #define X_GLrop_FramebufferRenderbufferEXT 4324 |
| 8352 void __indirect_glFramebufferRenderbufferEXT(GLenum target, GLenum attachment, G
Lenum renderbuffertarget, GLuint renderbuffer) |
| 8353 { |
| 8354 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8355 const GLuint cmdlen = 20; |
| 8356 emit_header(gc->pc, X_GLrop_FramebufferRenderbufferEXT, cmdlen); |
| 8357 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 8358 (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4); |
| 8359 (void) memcpy((void *)(gc->pc + 12), (void *)(&renderbuffertarget), 4); |
| 8360 (void) memcpy((void *)(gc->pc + 16), (void *)(&renderbuffer), 4); |
| 8361 gc->pc += cmdlen; |
| 8362 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8363 } |
| 8364 |
| 8365 #define X_GLrop_FramebufferTexture1DEXT 4321 |
| 8366 void __indirect_glFramebufferTexture1DEXT(GLenum target, GLenum attachment, GLen
um textarget, GLuint texture, GLint level) |
| 8367 { |
| 8368 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8369 const GLuint cmdlen = 24; |
| 8370 emit_header(gc->pc, X_GLrop_FramebufferTexture1DEXT, cmdlen); |
| 8371 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 8372 (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4); |
| 8373 (void) memcpy((void *)(gc->pc + 12), (void *)(&textarget), 4); |
| 8374 (void) memcpy((void *)(gc->pc + 16), (void *)(&texture), 4); |
| 8375 (void) memcpy((void *)(gc->pc + 20), (void *)(&level), 4); |
| 8376 gc->pc += cmdlen; |
| 8377 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8378 } |
| 8379 |
| 8380 #define X_GLrop_FramebufferTexture2DEXT 4322 |
| 8381 void __indirect_glFramebufferTexture2DEXT(GLenum target, GLenum attachment, GLen
um textarget, GLuint texture, GLint level) |
| 8382 { |
| 8383 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8384 const GLuint cmdlen = 24; |
| 8385 emit_header(gc->pc, X_GLrop_FramebufferTexture2DEXT, cmdlen); |
| 8386 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 8387 (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4); |
| 8388 (void) memcpy((void *)(gc->pc + 12), (void *)(&textarget), 4); |
| 8389 (void) memcpy((void *)(gc->pc + 16), (void *)(&texture), 4); |
| 8390 (void) memcpy((void *)(gc->pc + 20), (void *)(&level), 4); |
| 8391 gc->pc += cmdlen; |
| 8392 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8393 } |
| 8394 |
| 8395 #define X_GLrop_FramebufferTexture3DEXT 4323 |
| 8396 void __indirect_glFramebufferTexture3DEXT(GLenum target, GLenum attachment, GLen
um textarget, GLuint texture, GLint level, GLint zoffset) |
| 8397 { |
| 8398 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8399 const GLuint cmdlen = 28; |
| 8400 emit_header(gc->pc, X_GLrop_FramebufferTexture3DEXT, cmdlen); |
| 8401 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 8402 (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4); |
| 8403 (void) memcpy((void *)(gc->pc + 12), (void *)(&textarget), 4); |
| 8404 (void) memcpy((void *)(gc->pc + 16), (void *)(&texture), 4); |
| 8405 (void) memcpy((void *)(gc->pc + 20), (void *)(&level), 4); |
| 8406 (void) memcpy((void *)(gc->pc + 24), (void *)(&zoffset), 4); |
| 8407 gc->pc += cmdlen; |
| 8408 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8409 } |
| 8410 |
| 8411 #define X_GLvop_GenFramebuffersEXT 1426 |
| 8412 void __indirect_glGenFramebuffersEXT(GLsizei n, GLuint * framebuffers) |
| 8413 { |
| 8414 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8415 Display * const dpy = gc->currentDpy; |
| 8416 const GLuint cmdlen = 4; |
| 8417 if (n < 0) { |
| 8418 __glXSetError(gc, GL_INVALID_VALUE); |
| 8419 return; |
| 8420 } |
| 8421 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { |
| 8422 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GenFramebuffersEXT, cmdlen); |
| 8423 (void) memcpy((void *)(pc + 0), (void *)(&n), 4); |
| 8424 (void) __glXReadReply(dpy, 4, framebuffers, GL_TRUE); |
| 8425 UnlockDisplay(dpy); SyncHandle(); |
| 8426 } |
| 8427 return; |
| 8428 } |
| 8429 |
| 8430 #define X_GLvop_GenRenderbuffersEXT 1423 |
| 8431 void __indirect_glGenRenderbuffersEXT(GLsizei n, GLuint * renderbuffers) |
| 8432 { |
| 8433 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8434 Display * const dpy = gc->currentDpy; |
| 8435 const GLuint cmdlen = 4; |
| 8436 if (n < 0) { |
| 8437 __glXSetError(gc, GL_INVALID_VALUE); |
| 8438 return; |
| 8439 } |
| 8440 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { |
| 8441 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GenRenderbuffersEXT, cmdlen); |
| 8442 (void) memcpy((void *)(pc + 0), (void *)(&n), 4); |
| 8443 (void) __glXReadReply(dpy, 4, renderbuffers, GL_TRUE); |
| 8444 UnlockDisplay(dpy); SyncHandle(); |
| 8445 } |
| 8446 return; |
| 8447 } |
| 8448 |
| 8449 #define X_GLrop_GenerateMipmapEXT 4325 |
| 8450 void __indirect_glGenerateMipmapEXT(GLenum target) |
| 8451 { |
| 8452 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8453 const GLuint cmdlen = 8; |
| 8454 emit_header(gc->pc, X_GLrop_GenerateMipmapEXT, cmdlen); |
| 8455 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 8456 gc->pc += cmdlen; |
| 8457 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8458 } |
| 8459 |
| 8460 #define X_GLvop_GetFramebufferAttachmentParameterivEXT 1428 |
| 8461 void __indirect_glGetFramebufferAttachmentParameterivEXT(GLenum target, GLenum a
ttachment, GLenum pname, GLint * params) |
| 8462 { |
| 8463 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8464 Display * const dpy = gc->currentDpy; |
| 8465 const GLuint cmdlen = 12; |
| 8466 if (__builtin_expect(dpy != NULL, 1)) { |
| 8467 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetFramebufferAttachmentParameterivEXT, cmdlen); |
| 8468 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 8469 (void) memcpy((void *)(pc + 4), (void *)(&attachment), 4); |
| 8470 (void) memcpy((void *)(pc + 8), (void *)(&pname), 4); |
| 8471 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 8472 UnlockDisplay(dpy); SyncHandle(); |
| 8473 } |
| 8474 return; |
| 8475 } |
| 8476 |
| 8477 #define X_GLvop_GetRenderbufferParameterivEXT 1424 |
| 8478 void __indirect_glGetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLi
nt * params) |
| 8479 { |
| 8480 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8481 Display * const dpy = gc->currentDpy; |
| 8482 const GLuint cmdlen = 8; |
| 8483 if (__builtin_expect(dpy != NULL, 1)) { |
| 8484 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_GetRenderbufferParameterivEXT, cmdlen); |
| 8485 (void) memcpy((void *)(pc + 0), (void *)(&target), 4); |
| 8486 (void) memcpy((void *)(pc + 4), (void *)(&pname), 4); |
| 8487 (void) __glXReadReply(dpy, 4, params, GL_FALSE); |
| 8488 UnlockDisplay(dpy); SyncHandle(); |
| 8489 } |
| 8490 return; |
| 8491 } |
| 8492 |
| 8493 #define X_GLvop_IsFramebufferEXT 1425 |
| 8494 GLboolean __indirect_glIsFramebufferEXT(GLuint framebuffer) |
| 8495 { |
| 8496 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8497 Display * const dpy = gc->currentDpy; |
| 8498 GLboolean retval = (GLboolean) 0; |
| 8499 const GLuint cmdlen = 4; |
| 8500 if (__builtin_expect(dpy != NULL, 1)) { |
| 8501 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_IsFramebufferEXT, cmdlen); |
| 8502 (void) memcpy((void *)(pc + 0), (void *)(&framebuffer), 4); |
| 8503 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE); |
| 8504 UnlockDisplay(dpy); SyncHandle(); |
| 8505 } |
| 8506 return retval; |
| 8507 } |
| 8508 |
| 8509 #define X_GLvop_IsRenderbufferEXT 1422 |
| 8510 GLboolean __indirect_glIsRenderbufferEXT(GLuint renderbuffer) |
| 8511 { |
| 8512 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8513 Display * const dpy = gc->currentDpy; |
| 8514 GLboolean retval = (GLboolean) 0; |
| 8515 const GLuint cmdlen = 4; |
| 8516 if (__builtin_expect(dpy != NULL, 1)) { |
| 8517 GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithR
eply, X_GLvop_IsRenderbufferEXT, cmdlen); |
| 8518 (void) memcpy((void *)(pc + 0), (void *)(&renderbuffer), 4); |
| 8519 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE); |
| 8520 UnlockDisplay(dpy); SyncHandle(); |
| 8521 } |
| 8522 return retval; |
| 8523 } |
| 8524 |
| 8525 #define X_GLrop_RenderbufferStorageEXT 4318 |
| 8526 void __indirect_glRenderbufferStorageEXT(GLenum target, GLenum internalformat, G
Lsizei width, GLsizei height) |
| 8527 { |
| 8528 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8529 const GLuint cmdlen = 20; |
| 8530 emit_header(gc->pc, X_GLrop_RenderbufferStorageEXT, cmdlen); |
| 8531 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 8532 (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4); |
| 8533 (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4); |
| 8534 (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4); |
| 8535 gc->pc += cmdlen; |
| 8536 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8537 } |
| 8538 |
| 8539 #define X_GLrop_BlitFramebufferEXT 4330 |
| 8540 void __indirect_glBlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLin
t srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GL
enum filter) |
| 8541 { |
| 8542 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8543 const GLuint cmdlen = 44; |
| 8544 emit_header(gc->pc, X_GLrop_BlitFramebufferEXT, cmdlen); |
| 8545 (void) memcpy((void *)(gc->pc + 4), (void *)(&srcX0), 4); |
| 8546 (void) memcpy((void *)(gc->pc + 8), (void *)(&srcY0), 4); |
| 8547 (void) memcpy((void *)(gc->pc + 12), (void *)(&srcX1), 4); |
| 8548 (void) memcpy((void *)(gc->pc + 16), (void *)(&srcY1), 4); |
| 8549 (void) memcpy((void *)(gc->pc + 20), (void *)(&dstX0), 4); |
| 8550 (void) memcpy((void *)(gc->pc + 24), (void *)(&dstY0), 4); |
| 8551 (void) memcpy((void *)(gc->pc + 28), (void *)(&dstX1), 4); |
| 8552 (void) memcpy((void *)(gc->pc + 32), (void *)(&dstY1), 4); |
| 8553 (void) memcpy((void *)(gc->pc + 36), (void *)(&mask), 4); |
| 8554 (void) memcpy((void *)(gc->pc + 40), (void *)(&filter), 4); |
| 8555 gc->pc += cmdlen; |
| 8556 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8557 } |
| 8558 |
| 8559 #define X_GLrop_FramebufferTextureLayerEXT 237 |
| 8560 void __indirect_glFramebufferTextureLayerEXT(GLenum target, GLenum attachment, G
Luint texture, GLint level, GLint layer) |
| 8561 { |
| 8562 struct glx_context * const gc = __glXGetCurrentContext(); |
| 8563 const GLuint cmdlen = 24; |
| 8564 emit_header(gc->pc, X_GLrop_FramebufferTextureLayerEXT, cmdlen); |
| 8565 (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); |
| 8566 (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4); |
| 8567 (void) memcpy((void *)(gc->pc + 12), (void *)(&texture), 4); |
| 8568 (void) memcpy((void *)(gc->pc + 16), (void *)(&level), 4); |
| 8569 (void) memcpy((void *)(gc->pc + 20), (void *)(&layer), 4); |
| 8570 gc->pc += cmdlen; |
| 8571 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc,
gc->pc); } |
| 8572 } |
| 8573 |
| 8574 |
| 8575 #ifdef GLX_SHARED_GLAPI |
| 8576 |
| 8577 static const struct proc_pair |
| 8578 { |
| 8579 const char *name; |
| 8580 _glapi_proc proc; |
| 8581 } proc_pairs[20] = { |
| 8582 { "AreTexturesResidentEXT", (_glapi_proc) glAreTexturesResidentEXT }, |
| 8583 { "DeleteTexturesEXT", (_glapi_proc) glDeleteTexturesEXT }, |
| 8584 { "GenTexturesEXT", (_glapi_proc) glGenTexturesEXT }, |
| 8585 { "GetColorTableEXT", (_glapi_proc) glGetColorTableEXT }, |
| 8586 { "GetColorTableParameterfvEXT", (_glapi_proc) glGetColorTableParameterfvEXT
}, |
| 8587 { "GetColorTableParameterfvSGI", (_glapi_proc) glGetColorTableParameterfvEXT
}, |
| 8588 { "GetColorTableParameterivEXT", (_glapi_proc) glGetColorTableParameterivEXT
}, |
| 8589 { "GetColorTableParameterivSGI", (_glapi_proc) glGetColorTableParameterivEXT
}, |
| 8590 { "GetColorTableSGI", (_glapi_proc) glGetColorTableEXT }, |
| 8591 { "GetConvolutionFilterEXT", (_glapi_proc) gl_dispatch_stub_356 }, |
| 8592 { "GetConvolutionParameterfvEXT", (_glapi_proc) gl_dispatch_stub_357 }, |
| 8593 { "GetConvolutionParameterivEXT", (_glapi_proc) gl_dispatch_stub_358 }, |
| 8594 { "GetHistogramEXT", (_glapi_proc) gl_dispatch_stub_361 }, |
| 8595 { "GetHistogramParameterfvEXT", (_glapi_proc) gl_dispatch_stub_362 }, |
| 8596 { "GetHistogramParameterivEXT", (_glapi_proc) gl_dispatch_stub_363 }, |
| 8597 { "GetMinmaxEXT", (_glapi_proc) gl_dispatch_stub_364 }, |
| 8598 { "GetMinmaxParameterfvEXT", (_glapi_proc) gl_dispatch_stub_365 }, |
| 8599 { "GetMinmaxParameterivEXT", (_glapi_proc) gl_dispatch_stub_366 }, |
| 8600 { "GetSeparableFilterEXT", (_glapi_proc) gl_dispatch_stub_359 }, |
| 8601 { "IsTextureEXT", (_glapi_proc) glIsTextureEXT } |
| 8602 }; |
| 8603 |
| 8604 static int |
| 8605 __indirect_get_proc_compare(const void *key, const void *memb) |
| 8606 { |
| 8607 const struct proc_pair *pair = (const struct proc_pair *) memb; |
| 8608 return strcmp((const char *) key, pair->name); |
| 8609 } |
| 8610 |
| 8611 _glapi_proc |
| 8612 __indirect_get_proc_address(const char *name) |
| 8613 { |
| 8614 const struct proc_pair *pair; |
| 8615 |
| 8616 /* skip "gl" */ |
| 8617 name += 2; |
| 8618 |
| 8619 pair = (const struct proc_pair *) bsearch((const void *) name, |
| 8620 (const void *) proc_pairs, ARRAY_SIZE(proc_pairs), sizeof(proc_pairs[0]), |
| 8621 __indirect_get_proc_compare); |
| 8622 |
| 8623 return (pair) ? pair->proc : NULL; |
| 8624 } |
| 8625 |
| 8626 #endif /* GLX_SHARED_GLAPI */ |
| 8627 |
| 8628 |
| 8629 # undef FASTCALL |
| 8630 # undef NOINLINE |
OLD | NEW |