dlist.c revision 3c63452e64df7e10aa073c6c3b9492b1d7dabbb8
1/* $Id: dlist.c,v 1.99 2002/10/24 23:57:20 brianp Exp $ */ 2 3/* 4 * Mesa 3-D graphics library 5 * Version: 4.1 6 * 7 * Copyright (C) 1999-2002 Brian Paul All Rights Reserved. 8 * 9 * Permission is hereby granted, free of charge, to any person obtaining a 10 * copy of this software and associated documentation files (the "Software"), 11 * to deal in the Software without restriction, including without limitation 12 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 13 * and/or sell copies of the Software, and to permit persons to whom the 14 * Software is furnished to do so, subject to the following conditions: 15 * 16 * The above copyright notice and this permission notice shall be included 17 * in all copies or substantial portions of the Software. 18 * 19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 22 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 23 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 */ 26 27#include "glheader.h" 28#include "imports.h" 29#include "api_loopback.h" 30#include "attrib.h" 31#include "blend.h" 32#include "buffers.h" 33#include "clip.h" 34#include "colormac.h" 35#include "colortab.h" 36#include "context.h" 37#include "convolve.h" 38#include "depth.h" 39#include "dlist.h" 40#include "enable.h" 41#include "enums.h" 42#include "eval.h" 43#include "extensions.h" 44#include "feedback.h" 45#include "get.h" 46#include "glapi.h" 47#include "hash.h" 48#include "histogram.h" 49#include "image.h" 50#include "light.h" 51#include "lines.h" 52#include "dlist.h" 53#include "macros.h" 54#include "matrix.h" 55#include "pixel.h" 56#include "points.h" 57#include "polygon.h" 58#include "state.h" 59#include "texobj.h" 60#include "teximage.h" 61#include "texstate.h" 62#include "mtypes.h" 63#include "varray.h" 64#if FEATURE_NV_vertex_program 65#include "vpstate.h" 66#endif 67 68#include "math/m_matrix.h" 69#include "math/m_xform.h" 70 71 72 73/* 74Functions which aren't compiled but executed immediately: 75 glIsList 76 glGenLists 77 glDeleteLists 78 glEndList --- BUT: call ctx->Driver.EndList at end of list execution? 79 glFeedbackBuffer 80 glSelectBuffer 81 glRenderMode 82 glReadPixels 83 glPixelStore 84 glFlush 85 glFinish 86 glIsEnabled 87 glGet* 88 89Functions which cause errors if called while compiling a display list: 90 glNewList 91*/ 92 93 94 95/* 96 * Display list instructions are stored as sequences of "nodes". Nodes 97 * are allocated in blocks. Each block has BLOCK_SIZE nodes. Blocks 98 * are linked together with a pointer. 99 */ 100 101 102/* How many nodes to allocate at a time: 103 * - reduced now that we hold vertices etc. elsewhere. 104 */ 105#define BLOCK_SIZE 256 106 107 108/* 109 * Display list opcodes. 110 * 111 * The fact that these identifiers are assigned consecutive 112 * integer values starting at 0 is very important, see InstSize array usage) 113 * 114 */ 115typedef enum { 116 OPCODE_ACCUM, 117 OPCODE_ALPHA_FUNC, 118 OPCODE_BIND_TEXTURE, 119 OPCODE_BITMAP, 120 OPCODE_BLEND_COLOR, 121 OPCODE_BLEND_EQUATION, 122 OPCODE_BLEND_FUNC, 123 OPCODE_BLEND_FUNC_SEPARATE, 124 OPCODE_CALL_LIST, 125 OPCODE_CALL_LIST_OFFSET, 126 OPCODE_CLEAR, 127 OPCODE_CLEAR_ACCUM, 128 OPCODE_CLEAR_COLOR, 129 OPCODE_CLEAR_DEPTH, 130 OPCODE_CLEAR_INDEX, 131 OPCODE_CLEAR_STENCIL, 132 OPCODE_CLIP_PLANE, 133 OPCODE_COLOR_MASK, 134 OPCODE_COLOR_MATERIAL, 135 OPCODE_COLOR_TABLE, 136 OPCODE_COLOR_TABLE_PARAMETER_FV, 137 OPCODE_COLOR_TABLE_PARAMETER_IV, 138 OPCODE_COLOR_SUB_TABLE, 139 OPCODE_CONVOLUTION_FILTER_1D, 140 OPCODE_CONVOLUTION_FILTER_2D, 141 OPCODE_CONVOLUTION_PARAMETER_I, 142 OPCODE_CONVOLUTION_PARAMETER_IV, 143 OPCODE_CONVOLUTION_PARAMETER_F, 144 OPCODE_CONVOLUTION_PARAMETER_FV, 145 OPCODE_COPY_COLOR_SUB_TABLE, 146 OPCODE_COPY_COLOR_TABLE, 147 OPCODE_COPY_PIXELS, 148 OPCODE_COPY_TEX_IMAGE1D, 149 OPCODE_COPY_TEX_IMAGE2D, 150 OPCODE_COPY_TEX_SUB_IMAGE1D, 151 OPCODE_COPY_TEX_SUB_IMAGE2D, 152 OPCODE_COPY_TEX_SUB_IMAGE3D, 153 OPCODE_CULL_FACE, 154 OPCODE_DEPTH_FUNC, 155 OPCODE_DEPTH_MASK, 156 OPCODE_DEPTH_RANGE, 157 OPCODE_DISABLE, 158 OPCODE_DRAW_BUFFER, 159 OPCODE_DRAW_PIXELS, 160 OPCODE_ENABLE, 161 OPCODE_EVALMESH1, 162 OPCODE_EVALMESH2, 163 OPCODE_FOG, 164 OPCODE_FRONT_FACE, 165 OPCODE_FRUSTUM, 166 OPCODE_HINT, 167 OPCODE_HISTOGRAM, 168 OPCODE_INDEX_MASK, 169 OPCODE_INIT_NAMES, 170 OPCODE_LIGHT, 171 OPCODE_LIGHT_MODEL, 172 OPCODE_LINE_STIPPLE, 173 OPCODE_LINE_WIDTH, 174 OPCODE_LIST_BASE, 175 OPCODE_LOAD_IDENTITY, 176 OPCODE_LOAD_MATRIX, 177 OPCODE_LOAD_NAME, 178 OPCODE_LOGIC_OP, 179 OPCODE_MAP1, 180 OPCODE_MAP2, 181 OPCODE_MAPGRID1, 182 OPCODE_MAPGRID2, 183 OPCODE_MATRIX_MODE, 184 OPCODE_MIN_MAX, 185 OPCODE_MULT_MATRIX, 186 OPCODE_ORTHO, 187 OPCODE_PASSTHROUGH, 188 OPCODE_PIXEL_MAP, 189 OPCODE_PIXEL_TRANSFER, 190 OPCODE_PIXEL_ZOOM, 191 OPCODE_POINT_SIZE, 192 OPCODE_POINT_PARAMETERS, 193 OPCODE_POLYGON_MODE, 194 OPCODE_POLYGON_STIPPLE, 195 OPCODE_POLYGON_OFFSET, 196 OPCODE_POP_ATTRIB, 197 OPCODE_POP_MATRIX, 198 OPCODE_POP_NAME, 199 OPCODE_PRIORITIZE_TEXTURE, 200 OPCODE_PUSH_ATTRIB, 201 OPCODE_PUSH_MATRIX, 202 OPCODE_PUSH_NAME, 203 OPCODE_RASTER_POS, 204 OPCODE_READ_BUFFER, 205 OPCODE_RESET_HISTOGRAM, 206 OPCODE_RESET_MIN_MAX, 207 OPCODE_ROTATE, 208 OPCODE_SCALE, 209 OPCODE_SCISSOR, 210 OPCODE_SELECT_TEXTURE_SGIS, 211 OPCODE_SELECT_TEXTURE_COORD_SET, 212 OPCODE_SHADE_MODEL, 213 OPCODE_STENCIL_FUNC, 214 OPCODE_STENCIL_MASK, 215 OPCODE_STENCIL_OP, 216 OPCODE_TEXENV, 217 OPCODE_TEXGEN, 218 OPCODE_TEXPARAMETER, 219 OPCODE_TEX_IMAGE1D, 220 OPCODE_TEX_IMAGE2D, 221 OPCODE_TEX_IMAGE3D, 222 OPCODE_TEX_SUB_IMAGE1D, 223 OPCODE_TEX_SUB_IMAGE2D, 224 OPCODE_TEX_SUB_IMAGE3D, 225 OPCODE_TRANSLATE, 226 OPCODE_VIEWPORT, 227 OPCODE_WINDOW_POS, 228 /* GL_ARB_multitexture */ 229 OPCODE_ACTIVE_TEXTURE, 230 /* GL_SGIX/SGIS_pixel_texture */ 231 OPCODE_PIXEL_TEXGEN_SGIX, 232 OPCODE_PIXEL_TEXGEN_PARAMETER_SGIS, 233 /* GL_ARB_texture_compression */ 234 OPCODE_COMPRESSED_TEX_IMAGE_1D, 235 OPCODE_COMPRESSED_TEX_IMAGE_2D, 236 OPCODE_COMPRESSED_TEX_IMAGE_3D, 237 OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D, 238 OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D, 239 OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D, 240 /* GL_ARB_multisample */ 241 OPCODE_SAMPLE_COVERAGE, 242 /* GL_ARB_window_pos */ 243 OPCODE_WINDOW_POS_ARB, 244 /* GL_NV_vertex_program */ 245 OPCODE_BIND_PROGRAM_NV, 246 OPCODE_EXECUTE_PROGRAM_NV, 247 OPCODE_REQUEST_PROGRAMS_RESIDENT_NV, 248 OPCODE_LOAD_PROGRAM_NV, 249 OPCODE_PROGRAM_PARAMETER4F_NV, 250 OPCODE_TRACK_MATRIX_NV, 251 /* GL_EXT_stencil_two_side */ 252 OPCODE_ACTIVE_STENCIL_FACE_EXT, 253 /* The following three are meta instructions */ 254 OPCODE_ERROR, /* raise compiled-in error */ 255 OPCODE_CONTINUE, 256 OPCODE_END_OF_LIST, 257 OPCODE_DRV_0 258} OpCode; 259 260 261/* 262 * Each instruction in the display list is stored as a sequence of 263 * contiguous nodes in memory. 264 * Each node is the union of a variety of datatypes. 265 */ 266union node { 267 OpCode opcode; 268 GLboolean b; 269 GLbitfield bf; 270 GLubyte ub; 271 GLshort s; 272 GLushort us; 273 GLint i; 274 GLuint ui; 275 GLenum e; 276 GLfloat f; 277 GLvoid *data; 278 void *next; /* If prev node's opcode==OPCODE_CONTINUE */ 279}; 280 281 282 283/* Number of nodes of storage needed for each instruction. Sizes for 284 * dynamically allocated opcodes are stored in the context struct. 285 */ 286static GLuint InstSize[ OPCODE_END_OF_LIST+1 ]; 287 288void mesa_print_display_list( GLuint list ); 289 290 291/**********************************************************************/ 292/***** Private *****/ 293/**********************************************************************/ 294 295 296 297 298 299/* 300 * Make an empty display list. This is used by glGenLists() to 301 * reserver display list IDs. 302 */ 303static Node *make_empty_list( void ) 304{ 305 Node *n = (Node *) MALLOC( sizeof(Node) ); 306 n[0].opcode = OPCODE_END_OF_LIST; 307 return n; 308} 309 310 311 312/* 313 * Destroy all nodes in a display list. 314 * Input: list - display list number 315 */ 316void _mesa_destroy_list( GLcontext *ctx, GLuint list ) 317{ 318 Node *n, *block; 319 GLboolean done; 320 321 if (list==0) 322 return; 323 324 block = (Node *) _mesa_HashLookup(ctx->Shared->DisplayList, list); 325 n = block; 326 327 done = block ? GL_FALSE : GL_TRUE; 328 while (!done) { 329 330 /* check for extension opcodes first */ 331 332 GLint i = (GLint) n[0].opcode - (GLint) OPCODE_DRV_0; 333 if (i >= 0 && i < (GLint) ctx->listext.nr_opcodes) { 334 ctx->listext.opcode[i].destroy(ctx, &n[1]); 335 n += ctx->listext.opcode[i].size; 336 } 337 else { 338 switch (n[0].opcode) { 339 case OPCODE_MAP1: 340 FREE(n[6].data); 341 n += InstSize[n[0].opcode]; 342 break; 343 case OPCODE_MAP2: 344 FREE(n[10].data); 345 n += InstSize[n[0].opcode]; 346 break; 347 case OPCODE_DRAW_PIXELS: 348 FREE( n[5].data ); 349 n += InstSize[n[0].opcode]; 350 break; 351 case OPCODE_BITMAP: 352 FREE( n[7].data ); 353 n += InstSize[n[0].opcode]; 354 break; 355 case OPCODE_COLOR_TABLE: 356 FREE( n[6].data ); 357 n += InstSize[n[0].opcode]; 358 break; 359 case OPCODE_COLOR_SUB_TABLE: 360 FREE( n[6].data ); 361 n += InstSize[n[0].opcode]; 362 break; 363 case OPCODE_CONVOLUTION_FILTER_1D: 364 FREE( n[6].data ); 365 n += InstSize[n[0].opcode]; 366 break; 367 case OPCODE_CONVOLUTION_FILTER_2D: 368 FREE( n[7].data ); 369 n += InstSize[n[0].opcode]; 370 break; 371 case OPCODE_POLYGON_STIPPLE: 372 FREE( n[1].data ); 373 n += InstSize[n[0].opcode]; 374 break; 375 case OPCODE_TEX_IMAGE1D: 376 FREE(n[8].data); 377 n += InstSize[n[0].opcode]; 378 break; 379 case OPCODE_TEX_IMAGE2D: 380 FREE( n[9]. data ); 381 n += InstSize[n[0].opcode]; 382 break; 383 case OPCODE_TEX_IMAGE3D: 384 FREE( n[10]. data ); 385 n += InstSize[n[0].opcode]; 386 break; 387 case OPCODE_TEX_SUB_IMAGE1D: 388 FREE(n[7].data); 389 n += InstSize[n[0].opcode]; 390 break; 391 case OPCODE_TEX_SUB_IMAGE2D: 392 FREE(n[9].data); 393 n += InstSize[n[0].opcode]; 394 break; 395 case OPCODE_TEX_SUB_IMAGE3D: 396 FREE(n[11].data); 397 n += InstSize[n[0].opcode]; 398 break; 399 case OPCODE_COMPRESSED_TEX_IMAGE_1D: 400 FREE(n[7].data); 401 n += InstSize[n[0].opcode]; 402 break; 403 case OPCODE_COMPRESSED_TEX_IMAGE_2D: 404 FREE(n[8].data); 405 n += InstSize[n[0].opcode]; 406 break; 407 case OPCODE_COMPRESSED_TEX_IMAGE_3D: 408 FREE(n[9].data); 409 n += InstSize[n[0].opcode]; 410 break; 411 case OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D: 412 FREE(n[7].data); 413 n += InstSize[n[0].opcode]; 414 break; 415 case OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D: 416 FREE(n[9].data); 417 n += InstSize[n[0].opcode]; 418 break; 419 case OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D: 420 FREE(n[11].data); 421 n += InstSize[n[0].opcode]; 422 break; 423 case OPCODE_CONTINUE: 424 n = (Node *) n[1].next; 425 FREE( block ); 426 block = n; 427 break; 428 case OPCODE_END_OF_LIST: 429 FREE( block ); 430 done = GL_TRUE; 431 break; 432 default: 433 /* Most frequent case */ 434 n += InstSize[n[0].opcode]; 435 break; 436 } 437 } 438 } 439 440 _mesa_HashRemove(ctx->Shared->DisplayList, list); 441} 442 443 444 445/* 446 * Translate the nth element of list from type to GLuint. 447 */ 448static GLuint translate_id( GLsizei n, GLenum type, const GLvoid *list ) 449{ 450 GLbyte *bptr; 451 GLubyte *ubptr; 452 GLshort *sptr; 453 GLushort *usptr; 454 GLint *iptr; 455 GLuint *uiptr; 456 GLfloat *fptr; 457 458 switch (type) { 459 case GL_BYTE: 460 bptr = (GLbyte *) list; 461 return (GLuint) *(bptr+n); 462 case GL_UNSIGNED_BYTE: 463 ubptr = (GLubyte *) list; 464 return (GLuint) *(ubptr+n); 465 case GL_SHORT: 466 sptr = (GLshort *) list; 467 return (GLuint) *(sptr+n); 468 case GL_UNSIGNED_SHORT: 469 usptr = (GLushort *) list; 470 return (GLuint) *(usptr+n); 471 case GL_INT: 472 iptr = (GLint *) list; 473 return (GLuint) *(iptr+n); 474 case GL_UNSIGNED_INT: 475 uiptr = (GLuint *) list; 476 return (GLuint) *(uiptr+n); 477 case GL_FLOAT: 478 fptr = (GLfloat *) list; 479 return (GLuint) *(fptr+n); 480 case GL_2_BYTES: 481 ubptr = ((GLubyte *) list) + 2*n; 482 return (GLuint) *ubptr * 256 + (GLuint) *(ubptr+1); 483 case GL_3_BYTES: 484 ubptr = ((GLubyte *) list) + 3*n; 485 return (GLuint) *ubptr * 65536 486 + (GLuint) *(ubptr+1) * 256 487 + (GLuint) *(ubptr+2); 488 case GL_4_BYTES: 489 ubptr = ((GLubyte *) list) + 4*n; 490 return (GLuint) *ubptr * 16777216 491 + (GLuint) *(ubptr+1) * 65536 492 + (GLuint) *(ubptr+2) * 256 493 + (GLuint) *(ubptr+3); 494 default: 495 return 0; 496 } 497} 498 499 500 501 502/**********************************************************************/ 503/***** Public *****/ 504/**********************************************************************/ 505 506void _mesa_init_lists( void ) 507{ 508 static int init_flag = 0; 509 510 if (init_flag==0) { 511 InstSize[OPCODE_ACCUM] = 3; 512 InstSize[OPCODE_ALPHA_FUNC] = 3; 513 InstSize[OPCODE_BIND_TEXTURE] = 3; 514 InstSize[OPCODE_BITMAP] = 8; 515 InstSize[OPCODE_BLEND_COLOR] = 5; 516 InstSize[OPCODE_BLEND_EQUATION] = 2; 517 InstSize[OPCODE_BLEND_FUNC] = 3; 518 InstSize[OPCODE_BLEND_FUNC_SEPARATE] = 5; 519 InstSize[OPCODE_CALL_LIST] = 2; 520 InstSize[OPCODE_CALL_LIST_OFFSET] = 3; 521 InstSize[OPCODE_CLEAR] = 2; 522 InstSize[OPCODE_CLEAR_ACCUM] = 5; 523 InstSize[OPCODE_CLEAR_COLOR] = 5; 524 InstSize[OPCODE_CLEAR_DEPTH] = 2; 525 InstSize[OPCODE_CLEAR_INDEX] = 2; 526 InstSize[OPCODE_CLEAR_STENCIL] = 2; 527 InstSize[OPCODE_CLIP_PLANE] = 6; 528 InstSize[OPCODE_COLOR_MASK] = 5; 529 InstSize[OPCODE_COLOR_MATERIAL] = 3; 530 InstSize[OPCODE_COLOR_TABLE] = 7; 531 InstSize[OPCODE_COLOR_TABLE_PARAMETER_FV] = 7; 532 InstSize[OPCODE_COLOR_TABLE_PARAMETER_IV] = 7; 533 InstSize[OPCODE_COLOR_SUB_TABLE] = 7; 534 InstSize[OPCODE_CONVOLUTION_FILTER_1D] = 7; 535 InstSize[OPCODE_CONVOLUTION_FILTER_2D] = 8; 536 InstSize[OPCODE_CONVOLUTION_PARAMETER_I] = 4; 537 InstSize[OPCODE_CONVOLUTION_PARAMETER_IV] = 7; 538 InstSize[OPCODE_CONVOLUTION_PARAMETER_F] = 4; 539 InstSize[OPCODE_CONVOLUTION_PARAMETER_FV] = 7; 540 InstSize[OPCODE_COPY_PIXELS] = 6; 541 InstSize[OPCODE_COPY_COLOR_SUB_TABLE] = 6; 542 InstSize[OPCODE_COPY_COLOR_TABLE] = 6; 543 InstSize[OPCODE_COPY_TEX_IMAGE1D] = 8; 544 InstSize[OPCODE_COPY_TEX_IMAGE2D] = 9; 545 InstSize[OPCODE_COPY_TEX_SUB_IMAGE1D] = 7; 546 InstSize[OPCODE_COPY_TEX_SUB_IMAGE2D] = 9; 547 InstSize[OPCODE_COPY_TEX_SUB_IMAGE3D] = 10; 548 InstSize[OPCODE_CULL_FACE] = 2; 549 InstSize[OPCODE_DEPTH_FUNC] = 2; 550 InstSize[OPCODE_DEPTH_MASK] = 2; 551 InstSize[OPCODE_DEPTH_RANGE] = 3; 552 InstSize[OPCODE_DISABLE] = 2; 553 InstSize[OPCODE_DRAW_BUFFER] = 2; 554 InstSize[OPCODE_DRAW_PIXELS] = 6; 555 InstSize[OPCODE_ENABLE] = 2; 556 InstSize[OPCODE_EVALMESH1] = 4; 557 InstSize[OPCODE_EVALMESH2] = 6; 558 InstSize[OPCODE_FOG] = 6; 559 InstSize[OPCODE_FRONT_FACE] = 2; 560 InstSize[OPCODE_FRUSTUM] = 7; 561 InstSize[OPCODE_HINT] = 3; 562 InstSize[OPCODE_HISTOGRAM] = 5; 563 InstSize[OPCODE_INDEX_MASK] = 2; 564 InstSize[OPCODE_INIT_NAMES] = 1; 565 InstSize[OPCODE_LIGHT] = 7; 566 InstSize[OPCODE_LIGHT_MODEL] = 6; 567 InstSize[OPCODE_LINE_STIPPLE] = 3; 568 InstSize[OPCODE_LINE_WIDTH] = 2; 569 InstSize[OPCODE_LIST_BASE] = 2; 570 InstSize[OPCODE_LOAD_IDENTITY] = 1; 571 InstSize[OPCODE_LOAD_MATRIX] = 17; 572 InstSize[OPCODE_LOAD_NAME] = 2; 573 InstSize[OPCODE_LOGIC_OP] = 2; 574 InstSize[OPCODE_MAP1] = 7; 575 InstSize[OPCODE_MAP2] = 11; 576 InstSize[OPCODE_MAPGRID1] = 4; 577 InstSize[OPCODE_MAPGRID2] = 7; 578 InstSize[OPCODE_MATRIX_MODE] = 2; 579 InstSize[OPCODE_MIN_MAX] = 4; 580 InstSize[OPCODE_MULT_MATRIX] = 17; 581 InstSize[OPCODE_ORTHO] = 7; 582 InstSize[OPCODE_PASSTHROUGH] = 2; 583 InstSize[OPCODE_PIXEL_MAP] = 4; 584 InstSize[OPCODE_PIXEL_TRANSFER] = 3; 585 InstSize[OPCODE_PIXEL_ZOOM] = 3; 586 InstSize[OPCODE_POINT_SIZE] = 2; 587 InstSize[OPCODE_POINT_PARAMETERS] = 5; 588 InstSize[OPCODE_POLYGON_MODE] = 3; 589 InstSize[OPCODE_POLYGON_STIPPLE] = 2; 590 InstSize[OPCODE_POLYGON_OFFSET] = 3; 591 InstSize[OPCODE_POP_ATTRIB] = 1; 592 InstSize[OPCODE_POP_MATRIX] = 1; 593 InstSize[OPCODE_POP_NAME] = 1; 594 InstSize[OPCODE_PRIORITIZE_TEXTURE] = 3; 595 InstSize[OPCODE_PUSH_ATTRIB] = 2; 596 InstSize[OPCODE_PUSH_MATRIX] = 1; 597 InstSize[OPCODE_PUSH_NAME] = 2; 598 InstSize[OPCODE_RASTER_POS] = 5; 599 InstSize[OPCODE_READ_BUFFER] = 2; 600 InstSize[OPCODE_RESET_HISTOGRAM] = 2; 601 InstSize[OPCODE_RESET_MIN_MAX] = 2; 602 InstSize[OPCODE_ROTATE] = 5; 603 InstSize[OPCODE_SCALE] = 4; 604 InstSize[OPCODE_SCISSOR] = 5; 605 InstSize[OPCODE_STENCIL_FUNC] = 4; 606 InstSize[OPCODE_STENCIL_MASK] = 2; 607 InstSize[OPCODE_STENCIL_OP] = 4; 608 InstSize[OPCODE_SHADE_MODEL] = 2; 609 InstSize[OPCODE_TEXENV] = 7; 610 InstSize[OPCODE_TEXGEN] = 7; 611 InstSize[OPCODE_TEXPARAMETER] = 7; 612 InstSize[OPCODE_TEX_IMAGE1D] = 9; 613 InstSize[OPCODE_TEX_IMAGE2D] = 10; 614 InstSize[OPCODE_TEX_IMAGE3D] = 11; 615 InstSize[OPCODE_TEX_SUB_IMAGE1D] = 8; 616 InstSize[OPCODE_TEX_SUB_IMAGE2D] = 10; 617 InstSize[OPCODE_TEX_SUB_IMAGE3D] = 12; 618 InstSize[OPCODE_TRANSLATE] = 4; 619 InstSize[OPCODE_VIEWPORT] = 5; 620 InstSize[OPCODE_WINDOW_POS] = 5; 621 InstSize[OPCODE_CONTINUE] = 2; 622 InstSize[OPCODE_ERROR] = 3; 623 InstSize[OPCODE_END_OF_LIST] = 1; 624 /* GL_SGIX/SGIS_pixel_texture */ 625 InstSize[OPCODE_PIXEL_TEXGEN_SGIX] = 2; 626 InstSize[OPCODE_PIXEL_TEXGEN_PARAMETER_SGIS] = 3; 627 /* GL_ARB_texture_compression */ 628 InstSize[OPCODE_COMPRESSED_TEX_IMAGE_1D] = 8; 629 InstSize[OPCODE_COMPRESSED_TEX_IMAGE_2D] = 9; 630 InstSize[OPCODE_COMPRESSED_TEX_IMAGE_3D] = 10; 631 InstSize[OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D] = 8; 632 InstSize[OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D] = 10; 633 InstSize[OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D] = 12; 634 /* GL_ARB_multisample */ 635 InstSize[OPCODE_SAMPLE_COVERAGE] = 3; 636 /* GL_ARB_multitexture */ 637 InstSize[OPCODE_ACTIVE_TEXTURE] = 2; 638 /* GL_ARB_window_pos */ 639 InstSize[OPCODE_WINDOW_POS_ARB] = 4; 640 /* GL_NV_vertex_program */ 641 InstSize[OPCODE_BIND_PROGRAM_NV] = 3; 642 InstSize[OPCODE_EXECUTE_PROGRAM_NV] = 7; 643 InstSize[OPCODE_REQUEST_PROGRAMS_RESIDENT_NV] = 2; 644 InstSize[OPCODE_LOAD_PROGRAM_NV] = 4; 645 InstSize[OPCODE_PROGRAM_PARAMETER4F_NV] = 7; 646 InstSize[OPCODE_TRACK_MATRIX_NV] = 5; 647 /* GL_EXT_stencil_two_side */ 648 InstSize[OPCODE_ACTIVE_STENCIL_FACE_EXT] = 2; 649 } 650 init_flag = 1; 651} 652 653 654/* 655 * Allocate space for a display list instruction. 656 * Input: opcode - type of instruction 657 * argcount - size in bytes of data required. 658 * Return: pointer to the usable data area (not including the internal 659 * opcode). 660 */ 661void * 662_mesa_alloc_instruction( GLcontext *ctx, int opcode, GLint sz ) 663{ 664 Node *n, *newblock; 665 GLuint count = 1 + (sz + sizeof(Node) - 1) / sizeof(Node); 666 667#ifdef DEBUG 668 if (opcode < (int) OPCODE_DRV_0) { 669 assert( count == InstSize[opcode] ); 670 } 671#endif 672 673 if (ctx->CurrentPos + count + 2 > BLOCK_SIZE) { 674 /* This block is full. Allocate a new block and chain to it */ 675 n = ctx->CurrentBlock + ctx->CurrentPos; 676 n[0].opcode = OPCODE_CONTINUE; 677 newblock = (Node *) MALLOC( sizeof(Node) * BLOCK_SIZE ); 678 if (!newblock) { 679 _mesa_error( ctx, GL_OUT_OF_MEMORY, "Building display list" ); 680 return NULL; 681 } 682 n[1].next = (Node *) newblock; 683 ctx->CurrentBlock = newblock; 684 ctx->CurrentPos = 0; 685 } 686 687 n = ctx->CurrentBlock + ctx->CurrentPos; 688 ctx->CurrentPos += count; 689 690 n[0].opcode = (OpCode) opcode; 691 692 return (void *)&n[1]; 693} 694 695 696/* Allow modules and drivers to get their own opcodes. 697 */ 698int 699_mesa_alloc_opcode( GLcontext *ctx, 700 GLuint sz, 701 void (*execute)( GLcontext *, void * ), 702 void (*destroy)( GLcontext *, void * ), 703 void (*print)( GLcontext *, void * ) ) 704{ 705 if (ctx->listext.nr_opcodes < GL_MAX_EXT_OPCODES) { 706 GLuint i = ctx->listext.nr_opcodes++; 707 ctx->listext.opcode[i].size = 1 + (sz + sizeof(Node) - 1)/sizeof(Node); 708 ctx->listext.opcode[i].execute = execute; 709 ctx->listext.opcode[i].destroy = destroy; 710 ctx->listext.opcode[i].print = print; 711 return i + OPCODE_DRV_0; 712 } 713 return -1; 714} 715 716 717 718/* Mimic the old behaviour of alloc_instruction: 719 * - sz is in units of sizeof(Node) 720 * - return value a pointer to sizeof(Node) before the actual 721 * usable data area. 722 */ 723#define ALLOC_INSTRUCTION(ctx, opcode, sz) \ 724 ((Node *)_mesa_alloc_instruction(ctx, opcode, sz*sizeof(Node)) - 1) 725 726 727 728/* 729 * Display List compilation functions 730 */ 731static void save_Accum( GLenum op, GLfloat value ) 732{ 733 GET_CURRENT_CONTEXT(ctx); 734 Node *n; 735 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 736 n = ALLOC_INSTRUCTION( ctx, OPCODE_ACCUM, 2 ); 737 if (n) { 738 n[1].e = op; 739 n[2].f = value; 740 } 741 if (ctx->ExecuteFlag) { 742 (*ctx->Exec->Accum)( op, value ); 743 } 744} 745 746 747static void save_AlphaFunc( GLenum func, GLclampf ref ) 748{ 749 GET_CURRENT_CONTEXT(ctx); 750 Node *n; 751 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 752 n = ALLOC_INSTRUCTION( ctx, OPCODE_ALPHA_FUNC, 2 ); 753 if (n) { 754 n[1].e = func; 755 n[2].f = (GLfloat) ref; 756 } 757 if (ctx->ExecuteFlag) { 758 (*ctx->Exec->AlphaFunc)( func, ref ); 759 } 760} 761 762 763static void save_BindTexture( GLenum target, GLuint texture ) 764{ 765 GET_CURRENT_CONTEXT(ctx); 766 Node *n; 767 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 768 n = ALLOC_INSTRUCTION( ctx, OPCODE_BIND_TEXTURE, 2 ); 769 if (n) { 770 n[1].e = target; 771 n[2].ui = texture; 772 } 773 if (ctx->ExecuteFlag) { 774 (*ctx->Exec->BindTexture)( target, texture ); 775 } 776} 777 778 779static void save_Bitmap( GLsizei width, GLsizei height, 780 GLfloat xorig, GLfloat yorig, 781 GLfloat xmove, GLfloat ymove, 782 const GLubyte *pixels ) 783{ 784 GET_CURRENT_CONTEXT(ctx); 785 GLvoid *image = _mesa_unpack_bitmap( width, height, pixels, &ctx->Unpack ); 786 Node *n; 787 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 788 n = ALLOC_INSTRUCTION( ctx, OPCODE_BITMAP, 7 ); 789 if (n) { 790 n[1].i = (GLint) width; 791 n[2].i = (GLint) height; 792 n[3].f = xorig; 793 n[4].f = yorig; 794 n[5].f = xmove; 795 n[6].f = ymove; 796 n[7].data = image; 797 } 798 else if (image) { 799 FREE(image); 800 } 801 if (ctx->ExecuteFlag) { 802 (*ctx->Exec->Bitmap)( width, height, 803 xorig, yorig, xmove, ymove, pixels ); 804 } 805} 806 807 808static void save_BlendEquation( GLenum mode ) 809{ 810 GET_CURRENT_CONTEXT(ctx); 811 Node *n; 812 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 813 n = ALLOC_INSTRUCTION( ctx, OPCODE_BLEND_EQUATION, 1 ); 814 if (n) { 815 n[1].e = mode; 816 } 817 if (ctx->ExecuteFlag) { 818 (*ctx->Exec->BlendEquation)( mode ); 819 } 820} 821 822 823static void save_BlendFunc( GLenum sfactor, GLenum dfactor ) 824{ 825 GET_CURRENT_CONTEXT(ctx); 826 Node *n; 827 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 828 n = ALLOC_INSTRUCTION( ctx, OPCODE_BLEND_FUNC, 2 ); 829 if (n) { 830 n[1].e = sfactor; 831 n[2].e = dfactor; 832 } 833 if (ctx->ExecuteFlag) { 834 (*ctx->Exec->BlendFunc)( sfactor, dfactor ); 835 } 836} 837 838 839static void save_BlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, 840 GLenum sfactorA, GLenum dfactorA) 841{ 842 GET_CURRENT_CONTEXT(ctx); 843 Node *n; 844 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 845 n = ALLOC_INSTRUCTION( ctx, OPCODE_BLEND_FUNC_SEPARATE, 4 ); 846 if (n) { 847 n[1].e = sfactorRGB; 848 n[2].e = dfactorRGB; 849 n[3].e = sfactorA; 850 n[4].e = dfactorA; 851 } 852 if (ctx->ExecuteFlag) { 853 (*ctx->Exec->BlendFuncSeparateEXT)( sfactorRGB, dfactorRGB, 854 sfactorA, dfactorA); 855 } 856} 857 858 859static void save_BlendColor( GLfloat red, GLfloat green, 860 GLfloat blue, GLfloat alpha ) 861{ 862 GET_CURRENT_CONTEXT(ctx); 863 Node *n; 864 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 865 n = ALLOC_INSTRUCTION( ctx, OPCODE_BLEND_COLOR, 4 ); 866 if (n) { 867 n[1].f = red; 868 n[2].f = green; 869 n[3].f = blue; 870 n[4].f = alpha; 871 } 872 if (ctx->ExecuteFlag) { 873 (*ctx->Exec->BlendColor)( red, green, blue, alpha ); 874 } 875} 876 877 878void _mesa_save_CallList( GLuint list ) 879{ 880 GET_CURRENT_CONTEXT(ctx); 881 Node *n; 882 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 883 FLUSH_CURRENT(ctx, 0); 884 885 n = ALLOC_INSTRUCTION( ctx, OPCODE_CALL_LIST, 1 ); 886 if (n) { 887 n[1].ui = list; 888 } 889 if (ctx->ExecuteFlag) { 890 (*ctx->Exec->CallList)( list ); 891 } 892} 893 894 895void _mesa_save_CallLists( GLsizei n, GLenum type, const GLvoid *lists ) 896{ 897 GET_CURRENT_CONTEXT(ctx); 898 GLint i; 899 GLboolean typeErrorFlag; 900 901 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 902 FLUSH_CURRENT(ctx, 0); 903 904 switch (type) { 905 case GL_BYTE: 906 case GL_UNSIGNED_BYTE: 907 case GL_SHORT: 908 case GL_UNSIGNED_SHORT: 909 case GL_INT: 910 case GL_UNSIGNED_INT: 911 case GL_FLOAT: 912 case GL_2_BYTES: 913 case GL_3_BYTES: 914 case GL_4_BYTES: 915 typeErrorFlag = GL_FALSE; 916 break; 917 default: 918 typeErrorFlag = GL_TRUE; 919 } 920 921 for (i=0;i<n;i++) { 922 GLuint list = translate_id( i, type, lists ); 923 Node *n = ALLOC_INSTRUCTION( ctx, OPCODE_CALL_LIST_OFFSET, 2 ); 924 if (n) { 925 n[1].ui = list; 926 n[2].b = typeErrorFlag; 927 } 928 } 929 if (ctx->ExecuteFlag) { 930 (*ctx->Exec->CallLists)( n, type, lists ); 931 } 932} 933 934 935static void save_Clear( GLbitfield mask ) 936{ 937 GET_CURRENT_CONTEXT(ctx); 938 Node *n; 939 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 940 n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR, 1 ); 941 if (n) { 942 n[1].bf = mask; 943 } 944 if (ctx->ExecuteFlag) { 945 (*ctx->Exec->Clear)( mask ); 946 } 947} 948 949 950static void save_ClearAccum( GLfloat red, GLfloat green, 951 GLfloat blue, GLfloat alpha ) 952{ 953 GET_CURRENT_CONTEXT(ctx); 954 Node *n; 955 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 956 n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR_ACCUM, 4 ); 957 if (n) { 958 n[1].f = red; 959 n[2].f = green; 960 n[3].f = blue; 961 n[4].f = alpha; 962 } 963 if (ctx->ExecuteFlag) { 964 (*ctx->Exec->ClearAccum)( red, green, blue, alpha ); 965 } 966} 967 968 969static void save_ClearColor( GLclampf red, GLclampf green, 970 GLclampf blue, GLclampf alpha ) 971{ 972 GET_CURRENT_CONTEXT(ctx); 973 Node *n; 974 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 975 n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR_COLOR, 4 ); 976 if (n) { 977 n[1].f = red; 978 n[2].f = green; 979 n[3].f = blue; 980 n[4].f = alpha; 981 } 982 if (ctx->ExecuteFlag) { 983 (*ctx->Exec->ClearColor)( red, green, blue, alpha ); 984 } 985} 986 987 988static void save_ClearDepth( GLclampd depth ) 989{ 990 GET_CURRENT_CONTEXT(ctx); 991 Node *n; 992 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 993 n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR_DEPTH, 1 ); 994 if (n) { 995 n[1].f = (GLfloat) depth; 996 } 997 if (ctx->ExecuteFlag) { 998 (*ctx->Exec->ClearDepth)( depth ); 999 } 1000} 1001 1002 1003static void save_ClearIndex( GLfloat c ) 1004{ 1005 GET_CURRENT_CONTEXT(ctx); 1006 Node *n; 1007 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1008 n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR_INDEX, 1 ); 1009 if (n) { 1010 n[1].f = c; 1011 } 1012 if (ctx->ExecuteFlag) { 1013 (*ctx->Exec->ClearIndex)( c ); 1014 } 1015} 1016 1017 1018static void save_ClearStencil( GLint s ) 1019{ 1020 GET_CURRENT_CONTEXT(ctx); 1021 Node *n; 1022 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1023 n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR_STENCIL, 1 ); 1024 if (n) { 1025 n[1].i = s; 1026 } 1027 if (ctx->ExecuteFlag) { 1028 (*ctx->Exec->ClearStencil)( s ); 1029 } 1030} 1031 1032 1033static void save_ClipPlane( GLenum plane, const GLdouble *equ ) 1034{ 1035 GET_CURRENT_CONTEXT(ctx); 1036 Node *n; 1037 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1038 n = ALLOC_INSTRUCTION( ctx, OPCODE_CLIP_PLANE, 5 ); 1039 if (n) { 1040 n[1].e = plane; 1041 n[2].f = (GLfloat) equ[0]; 1042 n[3].f = (GLfloat) equ[1]; 1043 n[4].f = (GLfloat) equ[2]; 1044 n[5].f = (GLfloat) equ[3]; 1045 } 1046 if (ctx->ExecuteFlag) { 1047 (*ctx->Exec->ClipPlane)( plane, equ ); 1048 } 1049} 1050 1051 1052 1053static void save_ColorMask( GLboolean red, GLboolean green, 1054 GLboolean blue, GLboolean alpha ) 1055{ 1056 GET_CURRENT_CONTEXT(ctx); 1057 Node *n; 1058 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1059 n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_MASK, 4 ); 1060 if (n) { 1061 n[1].b = red; 1062 n[2].b = green; 1063 n[3].b = blue; 1064 n[4].b = alpha; 1065 } 1066 if (ctx->ExecuteFlag) { 1067 (*ctx->Exec->ColorMask)( red, green, blue, alpha ); 1068 } 1069} 1070 1071 1072static void save_ColorMaterial( GLenum face, GLenum mode ) 1073{ 1074 GET_CURRENT_CONTEXT(ctx); 1075 Node *n; 1076 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1077 FLUSH_CURRENT(ctx, 0); 1078 1079 n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_MATERIAL, 2 ); 1080 if (n) { 1081 n[1].e = face; 1082 n[2].e = mode; 1083 } 1084 if (ctx->ExecuteFlag) { 1085 (*ctx->Exec->ColorMaterial)( face, mode ); 1086 } 1087} 1088 1089 1090static void save_ColorTable( GLenum target, GLenum internalFormat, 1091 GLsizei width, GLenum format, GLenum type, 1092 const GLvoid *table ) 1093{ 1094 GET_CURRENT_CONTEXT(ctx); 1095 if (target == GL_PROXY_TEXTURE_1D || 1096 target == GL_PROXY_TEXTURE_2D || 1097 target == GL_PROXY_TEXTURE_3D || 1098 target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) { 1099 /* execute immediately */ 1100 (*ctx->Exec->ColorTable)( target, internalFormat, width, 1101 format, type, table ); 1102 } 1103 else { 1104 GLvoid *image = _mesa_unpack_image(width, 1, 1, format, type, table, 1105 &ctx->Unpack); 1106 Node *n; 1107 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1108 n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_TABLE, 6 ); 1109 if (n) { 1110 n[1].e = target; 1111 n[2].e = internalFormat; 1112 n[3].i = width; 1113 n[4].e = format; 1114 n[5].e = type; 1115 n[6].data = image; 1116 } 1117 else if (image) { 1118 FREE(image); 1119 } 1120 if (ctx->ExecuteFlag) { 1121 (*ctx->Exec->ColorTable)( target, internalFormat, width, 1122 format, type, table ); 1123 } 1124 } 1125} 1126 1127 1128 1129static void 1130save_ColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params) 1131{ 1132 GET_CURRENT_CONTEXT(ctx); 1133 Node *n; 1134 1135 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1136 1137 n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_TABLE_PARAMETER_FV, 6 ); 1138 if (n) { 1139 n[1].e = target; 1140 n[2].e = pname; 1141 n[3].f = params[0]; 1142 if (pname == GL_COLOR_TABLE_SGI || 1143 pname == GL_POST_CONVOLUTION_COLOR_TABLE_SGI || 1144 pname == GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI) { 1145 n[4].f = params[1]; 1146 n[5].f = params[2]; 1147 n[6].f = params[3]; 1148 } 1149 } 1150 1151 if (ctx->ExecuteFlag) { 1152 (*ctx->Exec->ColorTableParameterfv)( target, pname, params ); 1153 } 1154} 1155 1156 1157static void 1158save_ColorTableParameteriv(GLenum target, GLenum pname, const GLint *params) 1159{ 1160 GET_CURRENT_CONTEXT(ctx); 1161 Node *n; 1162 1163 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1164 1165 n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_TABLE_PARAMETER_IV, 6 ); 1166 if (n) { 1167 n[1].e = target; 1168 n[2].e = pname; 1169 n[3].i = params[0]; 1170 if (pname == GL_COLOR_TABLE_SGI || 1171 pname == GL_POST_CONVOLUTION_COLOR_TABLE_SGI || 1172 pname == GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI) { 1173 n[4].i = params[1]; 1174 n[5].i = params[2]; 1175 n[6].i = params[3]; 1176 } 1177 } 1178 1179 if (ctx->ExecuteFlag) { 1180 (*ctx->Exec->ColorTableParameteriv)( target, pname, params ); 1181 } 1182} 1183 1184 1185 1186static void save_ColorSubTable( GLenum target, GLsizei start, GLsizei count, 1187 GLenum format, GLenum type, 1188 const GLvoid *table) 1189{ 1190 GET_CURRENT_CONTEXT(ctx); 1191 GLvoid *image = _mesa_unpack_image(count, 1, 1, format, type, table, 1192 &ctx->Unpack); 1193 Node *n; 1194 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1195 n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_SUB_TABLE, 6 ); 1196 if (n) { 1197 n[1].e = target; 1198 n[2].i = start; 1199 n[3].i = count; 1200 n[4].e = format; 1201 n[5].e = type; 1202 n[6].data = image; 1203 } 1204 else if (image) { 1205 FREE(image); 1206 } 1207 if (ctx->ExecuteFlag) { 1208 (*ctx->Exec->ColorSubTable)(target, start, count, format, type, table); 1209 } 1210} 1211 1212 1213static void 1214save_CopyColorSubTable(GLenum target, GLsizei start, 1215 GLint x, GLint y, GLsizei width) 1216{ 1217 GET_CURRENT_CONTEXT(ctx); 1218 Node *n; 1219 1220 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1221 n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_COLOR_SUB_TABLE, 5 ); 1222 if (n) { 1223 n[1].e = target; 1224 n[2].i = start; 1225 n[3].i = x; 1226 n[4].i = y; 1227 n[5].i = width; 1228 } 1229 if (ctx->ExecuteFlag) { 1230 (*ctx->Exec->CopyColorSubTable)(target, start, x, y, width); 1231 } 1232} 1233 1234 1235static void 1236save_CopyColorTable(GLenum target, GLenum internalformat, 1237 GLint x, GLint y, GLsizei width) 1238{ 1239 GET_CURRENT_CONTEXT(ctx); 1240 Node *n; 1241 1242 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1243 n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_COLOR_TABLE, 5 ); 1244 if (n) { 1245 n[1].e = target; 1246 n[2].e = internalformat; 1247 n[3].i = x; 1248 n[4].i = y; 1249 n[5].i = width; 1250 } 1251 if (ctx->ExecuteFlag) { 1252 (*ctx->Exec->CopyColorTable)(target, internalformat, x, y, width); 1253 } 1254} 1255 1256 1257static void 1258save_ConvolutionFilter1D(GLenum target, GLenum internalFormat, GLsizei width, 1259 GLenum format, GLenum type, const GLvoid *filter) 1260{ 1261 GET_CURRENT_CONTEXT(ctx); 1262 GLvoid *image = _mesa_unpack_image(width, 1, 1, format, type, filter, 1263 &ctx->Unpack); 1264 Node *n; 1265 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1266 n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_FILTER_1D, 6 ); 1267 if (n) { 1268 n[1].e = target; 1269 n[2].e = internalFormat; 1270 n[3].i = width; 1271 n[4].e = format; 1272 n[5].e = type; 1273 n[6].data = image; 1274 } 1275 else if (image) { 1276 FREE(image); 1277 } 1278 if (ctx->ExecuteFlag) { 1279 (*ctx->Exec->ConvolutionFilter1D)( target, internalFormat, width, 1280 format, type, filter ); 1281 } 1282} 1283 1284 1285static void 1286save_ConvolutionFilter2D(GLenum target, GLenum internalFormat, 1287 GLsizei width, GLsizei height, GLenum format, 1288 GLenum type, const GLvoid *filter) 1289{ 1290 GET_CURRENT_CONTEXT(ctx); 1291 GLvoid *image = _mesa_unpack_image(width, height, 1, format, type, filter, 1292 &ctx->Unpack); 1293 Node *n; 1294 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1295 n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_FILTER_2D, 7 ); 1296 if (n) { 1297 n[1].e = target; 1298 n[2].e = internalFormat; 1299 n[3].i = width; 1300 n[4].i = height; 1301 n[5].e = format; 1302 n[6].e = type; 1303 n[7].data = image; 1304 } 1305 else if (image) { 1306 FREE(image); 1307 } 1308 if (ctx->ExecuteFlag) { 1309 (*ctx->Exec->ConvolutionFilter2D)( target, internalFormat, width, height, 1310 format, type, filter ); 1311 } 1312} 1313 1314 1315static void 1316save_ConvolutionParameteri(GLenum target, GLenum pname, GLint param) 1317{ 1318 GET_CURRENT_CONTEXT(ctx); 1319 Node *n; 1320 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1321 n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_PARAMETER_I, 3 ); 1322 if (n) { 1323 n[1].e = target; 1324 n[2].e = pname; 1325 n[3].i = param; 1326 } 1327 if (ctx->ExecuteFlag) { 1328 (*ctx->Exec->ConvolutionParameteri)( target, pname, param ); 1329 } 1330} 1331 1332 1333static void 1334save_ConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params) 1335{ 1336 GET_CURRENT_CONTEXT(ctx); 1337 Node *n; 1338 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1339 n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_PARAMETER_IV, 6 ); 1340 if (n) { 1341 n[1].e = target; 1342 n[2].e = pname; 1343 n[3].i = params[0]; 1344 if (pname == GL_CONVOLUTION_BORDER_COLOR || 1345 pname == GL_CONVOLUTION_FILTER_SCALE || 1346 pname == GL_CONVOLUTION_FILTER_BIAS) { 1347 n[4].i = params[1]; 1348 n[5].i = params[2]; 1349 n[6].i = params[3]; 1350 } 1351 else { 1352 n[4].i = n[5].i = n[6].i = 0; 1353 } 1354 } 1355 if (ctx->ExecuteFlag) { 1356 (*ctx->Exec->ConvolutionParameteriv)( target, pname, params ); 1357 } 1358} 1359 1360 1361static void 1362save_ConvolutionParameterf(GLenum target, GLenum pname, GLfloat param) 1363{ 1364 GET_CURRENT_CONTEXT(ctx); 1365 Node *n; 1366 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1367 n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_PARAMETER_F, 3 ); 1368 if (n) { 1369 n[1].e = target; 1370 n[2].e = pname; 1371 n[3].f = param; 1372 } 1373 if (ctx->ExecuteFlag) { 1374 (*ctx->Exec->ConvolutionParameterf)( target, pname, param ); 1375 } 1376} 1377 1378 1379static void 1380save_ConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params) 1381{ 1382 GET_CURRENT_CONTEXT(ctx); 1383 Node *n; 1384 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1385 n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_PARAMETER_FV, 6 ); 1386 if (n) { 1387 n[1].e = target; 1388 n[2].e = pname; 1389 n[3].f = params[0]; 1390 if (pname == GL_CONVOLUTION_BORDER_COLOR || 1391 pname == GL_CONVOLUTION_FILTER_SCALE || 1392 pname == GL_CONVOLUTION_FILTER_BIAS) { 1393 n[4].f = params[1]; 1394 n[5].f = params[2]; 1395 n[6].f = params[3]; 1396 } 1397 else { 1398 n[4].f = n[5].f = n[6].f = 0.0F; 1399 } 1400 } 1401 if (ctx->ExecuteFlag) { 1402 (*ctx->Exec->ConvolutionParameterfv)( target, pname, params ); 1403 } 1404} 1405 1406 1407static void 1408save_CopyPixels( GLint x, GLint y, 1409 GLsizei width, GLsizei height, GLenum type ) 1410{ 1411 GET_CURRENT_CONTEXT(ctx); 1412 Node *n; 1413 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1414 n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_PIXELS, 5 ); 1415 if (n) { 1416 n[1].i = x; 1417 n[2].i = y; 1418 n[3].i = (GLint) width; 1419 n[4].i = (GLint) height; 1420 n[5].e = type; 1421 } 1422 if (ctx->ExecuteFlag) { 1423 (*ctx->Exec->CopyPixels)( x, y, width, height, type ); 1424 } 1425} 1426 1427 1428 1429static void 1430save_CopyTexImage1D( GLenum target, GLint level, GLenum internalformat, 1431 GLint x, GLint y, GLsizei width, GLint border ) 1432{ 1433 GET_CURRENT_CONTEXT(ctx); 1434 Node *n; 1435 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1436 n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_TEX_IMAGE1D, 7 ); 1437 if (n) { 1438 n[1].e = target; 1439 n[2].i = level; 1440 n[3].e = internalformat; 1441 n[4].i = x; 1442 n[5].i = y; 1443 n[6].i = width; 1444 n[7].i = border; 1445 } 1446 if (ctx->ExecuteFlag) { 1447 (*ctx->Exec->CopyTexImage1D)( target, level, internalformat, 1448 x, y, width, border ); 1449 } 1450} 1451 1452 1453static void 1454save_CopyTexImage2D( GLenum target, GLint level, 1455 GLenum internalformat, 1456 GLint x, GLint y, GLsizei width, 1457 GLsizei height, GLint border ) 1458{ 1459 GET_CURRENT_CONTEXT(ctx); 1460 Node *n; 1461 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1462 n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_TEX_IMAGE2D, 8 ); 1463 if (n) { 1464 n[1].e = target; 1465 n[2].i = level; 1466 n[3].e = internalformat; 1467 n[4].i = x; 1468 n[5].i = y; 1469 n[6].i = width; 1470 n[7].i = height; 1471 n[8].i = border; 1472 } 1473 if (ctx->ExecuteFlag) { 1474 (*ctx->Exec->CopyTexImage2D)( target, level, internalformat, 1475 x, y, width, height, border ); 1476 } 1477} 1478 1479 1480 1481static void 1482save_CopyTexSubImage1D( GLenum target, GLint level, 1483 GLint xoffset, GLint x, GLint y, 1484 GLsizei width ) 1485{ 1486 GET_CURRENT_CONTEXT(ctx); 1487 Node *n; 1488 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1489 n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_TEX_SUB_IMAGE1D, 6 ); 1490 if (n) { 1491 n[1].e = target; 1492 n[2].i = level; 1493 n[3].i = xoffset; 1494 n[4].i = x; 1495 n[5].i = y; 1496 n[6].i = width; 1497 } 1498 if (ctx->ExecuteFlag) { 1499 (*ctx->Exec->CopyTexSubImage1D)( target, level, xoffset, x, y, width ); 1500 } 1501} 1502 1503 1504static void 1505save_CopyTexSubImage2D( GLenum target, GLint level, 1506 GLint xoffset, GLint yoffset, 1507 GLint x, GLint y, 1508 GLsizei width, GLint height ) 1509{ 1510 GET_CURRENT_CONTEXT(ctx); 1511 Node *n; 1512 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1513 n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_TEX_SUB_IMAGE2D, 8 ); 1514 if (n) { 1515 n[1].e = target; 1516 n[2].i = level; 1517 n[3].i = xoffset; 1518 n[4].i = yoffset; 1519 n[5].i = x; 1520 n[6].i = y; 1521 n[7].i = width; 1522 n[8].i = height; 1523 } 1524 if (ctx->ExecuteFlag) { 1525 (*ctx->Exec->CopyTexSubImage2D)( target, level, xoffset, yoffset, 1526 x, y, width, height ); 1527 } 1528} 1529 1530 1531static void 1532save_CopyTexSubImage3D( GLenum target, GLint level, 1533 GLint xoffset, GLint yoffset, GLint zoffset, 1534 GLint x, GLint y, 1535 GLsizei width, GLint height ) 1536{ 1537 GET_CURRENT_CONTEXT(ctx); 1538 Node *n; 1539 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1540 n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_TEX_SUB_IMAGE3D, 9 ); 1541 if (n) { 1542 n[1].e = target; 1543 n[2].i = level; 1544 n[3].i = xoffset; 1545 n[4].i = yoffset; 1546 n[5].i = zoffset; 1547 n[6].i = x; 1548 n[7].i = y; 1549 n[8].i = width; 1550 n[9].i = height; 1551 } 1552 if (ctx->ExecuteFlag) { 1553 (*ctx->Exec->CopyTexSubImage3D)( target, level, 1554 xoffset, yoffset, zoffset, 1555 x, y, width, height ); 1556 } 1557} 1558 1559 1560static void save_CullFace( GLenum mode ) 1561{ 1562 GET_CURRENT_CONTEXT(ctx); 1563 Node *n; 1564 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1565 n = ALLOC_INSTRUCTION( ctx, OPCODE_CULL_FACE, 1 ); 1566 if (n) { 1567 n[1].e = mode; 1568 } 1569 if (ctx->ExecuteFlag) { 1570 (*ctx->Exec->CullFace)( mode ); 1571 } 1572} 1573 1574 1575static void save_DepthFunc( GLenum func ) 1576{ 1577 GET_CURRENT_CONTEXT(ctx); 1578 Node *n; 1579 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1580 n = ALLOC_INSTRUCTION( ctx, OPCODE_DEPTH_FUNC, 1 ); 1581 if (n) { 1582 n[1].e = func; 1583 } 1584 if (ctx->ExecuteFlag) { 1585 (*ctx->Exec->DepthFunc)( func ); 1586 } 1587} 1588 1589 1590static void save_DepthMask( GLboolean mask ) 1591{ 1592 GET_CURRENT_CONTEXT(ctx); 1593 Node *n; 1594 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1595 n = ALLOC_INSTRUCTION( ctx, OPCODE_DEPTH_MASK, 1 ); 1596 if (n) { 1597 n[1].b = mask; 1598 } 1599 if (ctx->ExecuteFlag) { 1600 (*ctx->Exec->DepthMask)( mask ); 1601 } 1602} 1603 1604 1605static void save_DepthRange( GLclampd nearval, GLclampd farval ) 1606{ 1607 GET_CURRENT_CONTEXT(ctx); 1608 Node *n; 1609 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1610 n = ALLOC_INSTRUCTION( ctx, OPCODE_DEPTH_RANGE, 2 ); 1611 if (n) { 1612 n[1].f = (GLfloat) nearval; 1613 n[2].f = (GLfloat) farval; 1614 } 1615 if (ctx->ExecuteFlag) { 1616 (*ctx->Exec->DepthRange)( nearval, farval ); 1617 } 1618} 1619 1620 1621static void save_Disable( GLenum cap ) 1622{ 1623 GET_CURRENT_CONTEXT(ctx); 1624 Node *n; 1625 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1626 n = ALLOC_INSTRUCTION( ctx, OPCODE_DISABLE, 1 ); 1627 if (n) { 1628 n[1].e = cap; 1629 } 1630 if (ctx->ExecuteFlag) { 1631 (*ctx->Exec->Disable)( cap ); 1632 } 1633} 1634 1635 1636static void save_DrawBuffer( GLenum mode ) 1637{ 1638 GET_CURRENT_CONTEXT(ctx); 1639 Node *n; 1640 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1641 n = ALLOC_INSTRUCTION( ctx, OPCODE_DRAW_BUFFER, 1 ); 1642 if (n) { 1643 n[1].e = mode; 1644 } 1645 if (ctx->ExecuteFlag) { 1646 (*ctx->Exec->DrawBuffer)( mode ); 1647 } 1648} 1649 1650 1651static void save_DrawPixels( GLsizei width, GLsizei height, 1652 GLenum format, GLenum type, 1653 const GLvoid *pixels ) 1654{ 1655 GET_CURRENT_CONTEXT(ctx); 1656 GLvoid *image = _mesa_unpack_image(width, height, 1, format, type, 1657 pixels, &ctx->Unpack); 1658 Node *n; 1659 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1660 n = ALLOC_INSTRUCTION( ctx, OPCODE_DRAW_PIXELS, 5 ); 1661 if (n) { 1662 n[1].i = width; 1663 n[2].i = height; 1664 n[3].e = format; 1665 n[4].e = type; 1666 n[5].data = image; 1667 } 1668 else if (image) { 1669 FREE(image); 1670 } 1671 if (ctx->ExecuteFlag) { 1672 (*ctx->Exec->DrawPixels)( width, height, format, type, pixels ); 1673 } 1674} 1675 1676 1677 1678static void save_Enable( GLenum cap ) 1679{ 1680 GET_CURRENT_CONTEXT(ctx); 1681 Node *n; 1682 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1683 n = ALLOC_INSTRUCTION( ctx, OPCODE_ENABLE, 1 ); 1684 if (n) { 1685 n[1].e = cap; 1686 } 1687 if (ctx->ExecuteFlag) { 1688 (*ctx->Exec->Enable)( cap ); 1689 } 1690} 1691 1692 1693 1694void _mesa_save_EvalMesh1( GLenum mode, GLint i1, GLint i2 ) 1695{ 1696 GET_CURRENT_CONTEXT(ctx); 1697 Node *n; 1698 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1699 n = ALLOC_INSTRUCTION( ctx, OPCODE_EVALMESH1, 3 ); 1700 if (n) { 1701 n[1].e = mode; 1702 n[2].i = i1; 1703 n[3].i = i2; 1704 } 1705 if (ctx->ExecuteFlag) { 1706 (*ctx->Exec->EvalMesh1)( mode, i1, i2 ); 1707 } 1708} 1709 1710 1711void _mesa_save_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 ) 1712{ 1713 GET_CURRENT_CONTEXT(ctx); 1714 Node *n; 1715 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1716 n = ALLOC_INSTRUCTION( ctx, OPCODE_EVALMESH2, 5 ); 1717 if (n) { 1718 n[1].e = mode; 1719 n[2].i = i1; 1720 n[3].i = i2; 1721 n[4].i = j1; 1722 n[5].i = j2; 1723 } 1724 if (ctx->ExecuteFlag) { 1725 (*ctx->Exec->EvalMesh2)( mode, i1, i2, j1, j2 ); 1726 } 1727} 1728 1729 1730 1731 1732static void save_Fogfv( GLenum pname, const GLfloat *params ) 1733{ 1734 GET_CURRENT_CONTEXT(ctx); 1735 Node *n; 1736 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1737 n = ALLOC_INSTRUCTION( ctx, OPCODE_FOG, 5 ); 1738 if (n) { 1739 n[1].e = pname; 1740 n[2].f = params[0]; 1741 n[3].f = params[1]; 1742 n[4].f = params[2]; 1743 n[5].f = params[3]; 1744 } 1745 if (ctx->ExecuteFlag) { 1746 (*ctx->Exec->Fogfv)( pname, params ); 1747 } 1748} 1749 1750 1751static void save_Fogf( GLenum pname, GLfloat param ) 1752{ 1753 save_Fogfv(pname, ¶m); 1754} 1755 1756 1757static void save_Fogiv(GLenum pname, const GLint *params ) 1758{ 1759 GLfloat p[4]; 1760 switch (pname) { 1761 case GL_FOG_MODE: 1762 case GL_FOG_DENSITY: 1763 case GL_FOG_START: 1764 case GL_FOG_END: 1765 case GL_FOG_INDEX: 1766 p[0] = (GLfloat) *params; 1767 break; 1768 case GL_FOG_COLOR: 1769 p[0] = INT_TO_FLOAT( params[0] ); 1770 p[1] = INT_TO_FLOAT( params[1] ); 1771 p[2] = INT_TO_FLOAT( params[2] ); 1772 p[3] = INT_TO_FLOAT( params[3] ); 1773 break; 1774 default: 1775 /* Error will be caught later in gl_Fogfv */ 1776 ; 1777 } 1778 save_Fogfv(pname, p); 1779} 1780 1781 1782static void save_Fogi(GLenum pname, GLint param ) 1783{ 1784 save_Fogiv(pname, ¶m); 1785} 1786 1787 1788static void save_FrontFace( GLenum mode ) 1789{ 1790 GET_CURRENT_CONTEXT(ctx); 1791 Node *n; 1792 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1793 n = ALLOC_INSTRUCTION( ctx, OPCODE_FRONT_FACE, 1 ); 1794 if (n) { 1795 n[1].e = mode; 1796 } 1797 if (ctx->ExecuteFlag) { 1798 (*ctx->Exec->FrontFace)( mode ); 1799 } 1800} 1801 1802 1803static void save_Frustum( GLdouble left, GLdouble right, 1804 GLdouble bottom, GLdouble top, 1805 GLdouble nearval, GLdouble farval ) 1806{ 1807 GET_CURRENT_CONTEXT(ctx); 1808 Node *n; 1809 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1810 n = ALLOC_INSTRUCTION( ctx, OPCODE_FRUSTUM, 6 ); 1811 if (n) { 1812 n[1].f = (GLfloat) left; 1813 n[2].f = (GLfloat) right; 1814 n[3].f = (GLfloat) bottom; 1815 n[4].f = (GLfloat) top; 1816 n[5].f = (GLfloat) nearval; 1817 n[6].f = (GLfloat) farval; 1818 } 1819 if (ctx->ExecuteFlag) { 1820 (*ctx->Exec->Frustum)( left, right, bottom, top, nearval, farval ); 1821 } 1822} 1823 1824 1825static void save_Hint( GLenum target, GLenum mode ) 1826{ 1827 GET_CURRENT_CONTEXT(ctx); 1828 Node *n; 1829 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1830 n = ALLOC_INSTRUCTION( ctx, OPCODE_HINT, 2 ); 1831 if (n) { 1832 n[1].e = target; 1833 n[2].e = mode; 1834 } 1835 if (ctx->ExecuteFlag) { 1836 (*ctx->Exec->Hint)( target, mode ); 1837 } 1838} 1839 1840 1841static void 1842save_Histogram(GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink) 1843{ 1844 GET_CURRENT_CONTEXT(ctx); 1845 Node *n; 1846 1847 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1848 n = ALLOC_INSTRUCTION( ctx, OPCODE_HISTOGRAM, 4 ); 1849 if (n) { 1850 n[1].e = target; 1851 n[2].i = width; 1852 n[3].e = internalFormat; 1853 n[4].b = sink; 1854 } 1855 if (ctx->ExecuteFlag) { 1856 (*ctx->Exec->Histogram)( target, width, internalFormat, sink ); 1857 } 1858} 1859 1860 1861static void save_IndexMask( GLuint mask ) 1862{ 1863 GET_CURRENT_CONTEXT(ctx); 1864 Node *n; 1865 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1866 n = ALLOC_INSTRUCTION( ctx, OPCODE_INDEX_MASK, 1 ); 1867 if (n) { 1868 n[1].ui = mask; 1869 } 1870 if (ctx->ExecuteFlag) { 1871 (*ctx->Exec->IndexMask)( mask ); 1872 } 1873} 1874 1875 1876static void save_InitNames( void ) 1877{ 1878 GET_CURRENT_CONTEXT(ctx); 1879 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1880 (void) ALLOC_INSTRUCTION( ctx, OPCODE_INIT_NAMES, 0 ); 1881 if (ctx->ExecuteFlag) { 1882 (*ctx->Exec->InitNames)(); 1883 } 1884} 1885 1886 1887static void save_Lightfv( GLenum light, GLenum pname, const GLfloat *params ) 1888{ 1889 GET_CURRENT_CONTEXT(ctx); 1890 Node *n; 1891 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1892 n = ALLOC_INSTRUCTION( ctx, OPCODE_LIGHT, 6 ); 1893 if (OPCODE_LIGHT) { 1894 GLint i, nParams; 1895 n[1].e = light; 1896 n[2].e = pname; 1897 switch (pname) { 1898 case GL_AMBIENT: 1899 nParams = 4; 1900 break; 1901 case GL_DIFFUSE: 1902 nParams = 4; 1903 break; 1904 case GL_SPECULAR: 1905 nParams = 4; 1906 break; 1907 case GL_POSITION: 1908 nParams = 4; 1909 break; 1910 case GL_SPOT_DIRECTION: 1911 nParams = 3; 1912 break; 1913 case GL_SPOT_EXPONENT: 1914 nParams = 1; 1915 break; 1916 case GL_SPOT_CUTOFF: 1917 nParams = 1; 1918 break; 1919 case GL_CONSTANT_ATTENUATION: 1920 nParams = 1; 1921 break; 1922 case GL_LINEAR_ATTENUATION: 1923 nParams = 1; 1924 break; 1925 case GL_QUADRATIC_ATTENUATION: 1926 nParams = 1; 1927 break; 1928 default: 1929 nParams = 0; 1930 } 1931 for (i = 0; i < nParams; i++) { 1932 n[3+i].f = params[i]; 1933 } 1934 } 1935 if (ctx->ExecuteFlag) { 1936 (*ctx->Exec->Lightfv)( light, pname, params ); 1937 } 1938} 1939 1940 1941static void save_Lightf( GLenum light, GLenum pname, GLfloat params ) 1942{ 1943 save_Lightfv(light, pname, ¶ms); 1944} 1945 1946 1947static void save_Lightiv( GLenum light, GLenum pname, const GLint *params ) 1948{ 1949 GLfloat fparam[4]; 1950 switch (pname) { 1951 case GL_AMBIENT: 1952 case GL_DIFFUSE: 1953 case GL_SPECULAR: 1954 fparam[0] = INT_TO_FLOAT( params[0] ); 1955 fparam[1] = INT_TO_FLOAT( params[1] ); 1956 fparam[2] = INT_TO_FLOAT( params[2] ); 1957 fparam[3] = INT_TO_FLOAT( params[3] ); 1958 break; 1959 case GL_POSITION: 1960 fparam[0] = (GLfloat) params[0]; 1961 fparam[1] = (GLfloat) params[1]; 1962 fparam[2] = (GLfloat) params[2]; 1963 fparam[3] = (GLfloat) params[3]; 1964 break; 1965 case GL_SPOT_DIRECTION: 1966 fparam[0] = (GLfloat) params[0]; 1967 fparam[1] = (GLfloat) params[1]; 1968 fparam[2] = (GLfloat) params[2]; 1969 break; 1970 case GL_SPOT_EXPONENT: 1971 case GL_SPOT_CUTOFF: 1972 case GL_CONSTANT_ATTENUATION: 1973 case GL_LINEAR_ATTENUATION: 1974 case GL_QUADRATIC_ATTENUATION: 1975 fparam[0] = (GLfloat) params[0]; 1976 break; 1977 default: 1978 /* error will be caught later in gl_Lightfv */ 1979 ; 1980 } 1981 save_Lightfv( light, pname, fparam ); 1982} 1983 1984 1985static void save_Lighti( GLenum light, GLenum pname, GLint param ) 1986{ 1987 save_Lightiv( light, pname, ¶m ); 1988} 1989 1990 1991static void save_LightModelfv( GLenum pname, const GLfloat *params ) 1992{ 1993 GET_CURRENT_CONTEXT(ctx); 1994 Node *n; 1995 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 1996 n = ALLOC_INSTRUCTION( ctx, OPCODE_LIGHT_MODEL, 5 ); 1997 if (n) { 1998 n[1].e = pname; 1999 n[2].f = params[0]; 2000 n[3].f = params[1]; 2001 n[4].f = params[2]; 2002 n[5].f = params[3]; 2003 } 2004 if (ctx->ExecuteFlag) { 2005 (*ctx->Exec->LightModelfv)( pname, params ); 2006 } 2007} 2008 2009 2010static void save_LightModelf( GLenum pname, GLfloat param ) 2011{ 2012 save_LightModelfv(pname, ¶m); 2013} 2014 2015 2016static void save_LightModeliv( GLenum pname, const GLint *params ) 2017{ 2018 GLfloat fparam[4]; 2019 switch (pname) { 2020 case GL_LIGHT_MODEL_AMBIENT: 2021 fparam[0] = INT_TO_FLOAT( params[0] ); 2022 fparam[1] = INT_TO_FLOAT( params[1] ); 2023 fparam[2] = INT_TO_FLOAT( params[2] ); 2024 fparam[3] = INT_TO_FLOAT( params[3] ); 2025 break; 2026 case GL_LIGHT_MODEL_LOCAL_VIEWER: 2027 case GL_LIGHT_MODEL_TWO_SIDE: 2028 case GL_LIGHT_MODEL_COLOR_CONTROL: 2029 fparam[0] = (GLfloat) params[0]; 2030 break; 2031 default: 2032 /* Error will be caught later in gl_LightModelfv */ 2033 ; 2034 } 2035 save_LightModelfv(pname, fparam); 2036} 2037 2038 2039static void save_LightModeli( GLenum pname, GLint param ) 2040{ 2041 save_LightModeliv(pname, ¶m); 2042} 2043 2044 2045static void save_LineStipple( GLint factor, GLushort pattern ) 2046{ 2047 GET_CURRENT_CONTEXT(ctx); 2048 Node *n; 2049 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2050 n = ALLOC_INSTRUCTION( ctx, OPCODE_LINE_STIPPLE, 2 ); 2051 if (n) { 2052 n[1].i = factor; 2053 n[2].us = pattern; 2054 } 2055 if (ctx->ExecuteFlag) { 2056 (*ctx->Exec->LineStipple)( factor, pattern ); 2057 } 2058} 2059 2060 2061static void save_LineWidth( GLfloat width ) 2062{ 2063 GET_CURRENT_CONTEXT(ctx); 2064 Node *n; 2065 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2066 n = ALLOC_INSTRUCTION( ctx, OPCODE_LINE_WIDTH, 1 ); 2067 if (n) { 2068 n[1].f = width; 2069 } 2070 if (ctx->ExecuteFlag) { 2071 (*ctx->Exec->LineWidth)( width ); 2072 } 2073} 2074 2075 2076static void save_ListBase( GLuint base ) 2077{ 2078 GET_CURRENT_CONTEXT(ctx); 2079 Node *n; 2080 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2081 n = ALLOC_INSTRUCTION( ctx, OPCODE_LIST_BASE, 1 ); 2082 if (n) { 2083 n[1].ui = base; 2084 } 2085 if (ctx->ExecuteFlag) { 2086 (*ctx->Exec->ListBase)( base ); 2087 } 2088} 2089 2090 2091static void save_LoadIdentity( void ) 2092{ 2093 GET_CURRENT_CONTEXT(ctx); 2094 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2095 (void) ALLOC_INSTRUCTION( ctx, OPCODE_LOAD_IDENTITY, 0 ); 2096 if (ctx->ExecuteFlag) { 2097 (*ctx->Exec->LoadIdentity)(); 2098 } 2099} 2100 2101 2102static void save_LoadMatrixf( const GLfloat *m ) 2103{ 2104 GET_CURRENT_CONTEXT(ctx); 2105 Node *n; 2106 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2107 n = ALLOC_INSTRUCTION( ctx, OPCODE_LOAD_MATRIX, 16 ); 2108 if (n) { 2109 GLuint i; 2110 for (i=0;i<16;i++) { 2111 n[1+i].f = m[i]; 2112 } 2113 } 2114 if (ctx->ExecuteFlag) { 2115 (*ctx->Exec->LoadMatrixf)( m ); 2116 } 2117} 2118 2119 2120static void save_LoadMatrixd( const GLdouble *m ) 2121{ 2122 GLfloat f[16]; 2123 GLint i; 2124 for (i = 0; i < 16; i++) { 2125 f[i] = (GLfloat) m[i]; 2126 } 2127 save_LoadMatrixf(f); 2128} 2129 2130 2131static void save_LoadName( GLuint name ) 2132{ 2133 GET_CURRENT_CONTEXT(ctx); 2134 Node *n; 2135 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2136 n = ALLOC_INSTRUCTION( ctx, OPCODE_LOAD_NAME, 1 ); 2137 if (n) { 2138 n[1].ui = name; 2139 } 2140 if (ctx->ExecuteFlag) { 2141 (*ctx->Exec->LoadName)( name ); 2142 } 2143} 2144 2145 2146static void save_LogicOp( GLenum opcode ) 2147{ 2148 GET_CURRENT_CONTEXT(ctx); 2149 Node *n; 2150 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2151 n = ALLOC_INSTRUCTION( ctx, OPCODE_LOGIC_OP, 1 ); 2152 if (n) { 2153 n[1].e = opcode; 2154 } 2155 if (ctx->ExecuteFlag) { 2156 (*ctx->Exec->LogicOp)( opcode ); 2157 } 2158} 2159 2160 2161static void save_Map1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, 2162 GLint order, const GLdouble *points) 2163{ 2164 GET_CURRENT_CONTEXT(ctx); 2165 Node *n; 2166 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2167 n = ALLOC_INSTRUCTION( ctx, OPCODE_MAP1, 6 ); 2168 if (n) { 2169 GLfloat *pnts = _mesa_copy_map_points1d( target, stride, order, points ); 2170 n[1].e = target; 2171 n[2].f = (GLfloat) u1; 2172 n[3].f = (GLfloat) u2; 2173 n[4].i = _mesa_evaluator_components(target); /* stride */ 2174 n[5].i = order; 2175 n[6].data = (void *) pnts; 2176 } 2177 if (ctx->ExecuteFlag) { 2178 (*ctx->Exec->Map1d)( target, u1, u2, stride, order, points ); 2179 } 2180} 2181 2182static void save_Map1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, 2183 GLint order, const GLfloat *points) 2184{ 2185 GET_CURRENT_CONTEXT(ctx); 2186 Node *n; 2187 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2188 n = ALLOC_INSTRUCTION( ctx, OPCODE_MAP1, 6 ); 2189 if (n) { 2190 GLfloat *pnts = _mesa_copy_map_points1f( target, stride, order, points ); 2191 n[1].e = target; 2192 n[2].f = u1; 2193 n[3].f = u2; 2194 n[4].i = _mesa_evaluator_components(target); /* stride */ 2195 n[5].i = order; 2196 n[6].data = (void *) pnts; 2197 } 2198 if (ctx->ExecuteFlag) { 2199 (*ctx->Exec->Map1f)( target, u1, u2, stride, order, points ); 2200 } 2201} 2202 2203 2204static void save_Map2d( GLenum target, 2205 GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, 2206 GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, 2207 const GLdouble *points ) 2208{ 2209 GET_CURRENT_CONTEXT(ctx); 2210 Node *n; 2211 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2212 n = ALLOC_INSTRUCTION( ctx, OPCODE_MAP2, 10 ); 2213 if (n) { 2214 GLfloat *pnts = _mesa_copy_map_points2d( target, ustride, uorder, 2215 vstride, vorder, points ); 2216 n[1].e = target; 2217 n[2].f = (GLfloat) u1; 2218 n[3].f = (GLfloat) u2; 2219 n[4].f = (GLfloat) v1; 2220 n[5].f = (GLfloat) v2; 2221 /* XXX verify these strides are correct */ 2222 n[6].i = _mesa_evaluator_components(target) * vorder; /*ustride*/ 2223 n[7].i = _mesa_evaluator_components(target); /*vstride*/ 2224 n[8].i = uorder; 2225 n[9].i = vorder; 2226 n[10].data = (void *) pnts; 2227 } 2228 if (ctx->ExecuteFlag) { 2229 (*ctx->Exec->Map2d)( target, 2230 u1, u2, ustride, uorder, 2231 v1, v2, vstride, vorder, points ); 2232 } 2233} 2234 2235 2236static void save_Map2f( GLenum target, 2237 GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, 2238 GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, 2239 const GLfloat *points ) 2240{ 2241 GET_CURRENT_CONTEXT(ctx); 2242 Node *n; 2243 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2244 n = ALLOC_INSTRUCTION( ctx, OPCODE_MAP2, 10 ); 2245 if (n) { 2246 GLfloat *pnts = _mesa_copy_map_points2f( target, ustride, uorder, 2247 vstride, vorder, points ); 2248 n[1].e = target; 2249 n[2].f = u1; 2250 n[3].f = u2; 2251 n[4].f = v1; 2252 n[5].f = v2; 2253 /* XXX verify these strides are correct */ 2254 n[6].i = _mesa_evaluator_components(target) * vorder; /*ustride*/ 2255 n[7].i = _mesa_evaluator_components(target); /*vstride*/ 2256 n[8].i = uorder; 2257 n[9].i = vorder; 2258 n[10].data = (void *) pnts; 2259 } 2260 if (ctx->ExecuteFlag) { 2261 (*ctx->Exec->Map2f)( target, u1, u2, ustride, uorder, 2262 v1, v2, vstride, vorder, points ); 2263 } 2264} 2265 2266 2267static void save_MapGrid1f( GLint un, GLfloat u1, GLfloat u2 ) 2268{ 2269 GET_CURRENT_CONTEXT(ctx); 2270 Node *n; 2271 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2272 n = ALLOC_INSTRUCTION( ctx, OPCODE_MAPGRID1, 3 ); 2273 if (n) { 2274 n[1].i = un; 2275 n[2].f = u1; 2276 n[3].f = u2; 2277 } 2278 if (ctx->ExecuteFlag) { 2279 (*ctx->Exec->MapGrid1f)( un, u1, u2 ); 2280 } 2281} 2282 2283 2284static void save_MapGrid1d( GLint un, GLdouble u1, GLdouble u2 ) 2285{ 2286 save_MapGrid1f(un, (GLfloat) u1, (GLfloat) u2); 2287} 2288 2289 2290static void save_MapGrid2f( GLint un, GLfloat u1, GLfloat u2, 2291 GLint vn, GLfloat v1, GLfloat v2 ) 2292{ 2293 GET_CURRENT_CONTEXT(ctx); 2294 Node *n; 2295 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2296 n = ALLOC_INSTRUCTION( ctx, OPCODE_MAPGRID2, 6 ); 2297 if (n) { 2298 n[1].i = un; 2299 n[2].f = u1; 2300 n[3].f = u2; 2301 n[4].i = vn; 2302 n[5].f = v1; 2303 n[6].f = v2; 2304 } 2305 if (ctx->ExecuteFlag) { 2306 (*ctx->Exec->MapGrid2f)( un, u1, u2, vn, v1, v2 ); 2307 } 2308} 2309 2310 2311 2312static void save_MapGrid2d( GLint un, GLdouble u1, GLdouble u2, 2313 GLint vn, GLdouble v1, GLdouble v2 ) 2314{ 2315 save_MapGrid2f(un, (GLfloat) u1, (GLfloat) u2, 2316 vn, (GLfloat) v1, (GLfloat) v2); 2317} 2318 2319 2320static void save_MatrixMode( GLenum mode ) 2321{ 2322 GET_CURRENT_CONTEXT(ctx); 2323 Node *n; 2324 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2325 n = ALLOC_INSTRUCTION( ctx, OPCODE_MATRIX_MODE, 1 ); 2326 if (n) { 2327 n[1].e = mode; 2328 } 2329 if (ctx->ExecuteFlag) { 2330 (*ctx->Exec->MatrixMode)( mode ); 2331 } 2332} 2333 2334 2335static void 2336save_Minmax(GLenum target, GLenum internalFormat, GLboolean sink) 2337{ 2338 GET_CURRENT_CONTEXT(ctx); 2339 Node *n; 2340 2341 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2342 n = ALLOC_INSTRUCTION( ctx, OPCODE_MIN_MAX, 3 ); 2343 if (n) { 2344 n[1].e = target; 2345 n[2].e = internalFormat; 2346 n[3].b = sink; 2347 } 2348 if (ctx->ExecuteFlag) { 2349 (*ctx->Exec->Minmax)( target, internalFormat, sink ); 2350 } 2351} 2352 2353 2354static void save_MultMatrixf( const GLfloat *m ) 2355{ 2356 GET_CURRENT_CONTEXT(ctx); 2357 Node *n; 2358 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2359 n = ALLOC_INSTRUCTION( ctx, OPCODE_MULT_MATRIX, 16 ); 2360 if (n) { 2361 GLuint i; 2362 for (i=0;i<16;i++) { 2363 n[1+i].f = m[i]; 2364 } 2365 } 2366 if (ctx->ExecuteFlag) { 2367 (*ctx->Exec->MultMatrixf)( m ); 2368 } 2369} 2370 2371 2372static void save_MultMatrixd( const GLdouble *m ) 2373{ 2374 GLfloat f[16]; 2375 GLint i; 2376 for (i = 0; i < 16; i++) { 2377 f[i] = (GLfloat) m[i]; 2378 } 2379 save_MultMatrixf(f); 2380} 2381 2382 2383static void save_NewList( GLuint list, GLenum mode ) 2384{ 2385 GET_CURRENT_CONTEXT(ctx); 2386 /* It's an error to call this function while building a display list */ 2387 _mesa_error( ctx, GL_INVALID_OPERATION, "glNewList" ); 2388 (void) list; 2389 (void) mode; 2390} 2391 2392 2393 2394static void save_Ortho( GLdouble left, GLdouble right, 2395 GLdouble bottom, GLdouble top, 2396 GLdouble nearval, GLdouble farval ) 2397{ 2398 GET_CURRENT_CONTEXT(ctx); 2399 Node *n; 2400 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2401 n = ALLOC_INSTRUCTION( ctx, OPCODE_ORTHO, 6 ); 2402 if (n) { 2403 n[1].f = (GLfloat) left; 2404 n[2].f = (GLfloat) right; 2405 n[3].f = (GLfloat) bottom; 2406 n[4].f = (GLfloat) top; 2407 n[5].f = (GLfloat) nearval; 2408 n[6].f = (GLfloat) farval; 2409 } 2410 if (ctx->ExecuteFlag) { 2411 (*ctx->Exec->Ortho)( left, right, bottom, top, nearval, farval ); 2412 } 2413} 2414 2415 2416static void 2417save_PixelMapfv( GLenum map, GLint mapsize, const GLfloat *values ) 2418{ 2419 GET_CURRENT_CONTEXT(ctx); 2420 Node *n; 2421 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2422 n = ALLOC_INSTRUCTION( ctx, OPCODE_PIXEL_MAP, 3 ); 2423 if (n) { 2424 n[1].e = map; 2425 n[2].i = mapsize; 2426 n[3].data = (void *) MALLOC( mapsize * sizeof(GLfloat) ); 2427 MEMCPY( n[3].data, (void *) values, mapsize * sizeof(GLfloat) ); 2428 } 2429 if (ctx->ExecuteFlag) { 2430 (*ctx->Exec->PixelMapfv)( map, mapsize, values ); 2431 } 2432} 2433 2434 2435static void 2436save_PixelMapuiv(GLenum map, GLint mapsize, const GLuint *values ) 2437{ 2438 GLfloat fvalues[MAX_PIXEL_MAP_TABLE]; 2439 GLint i; 2440 if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) { 2441 for (i=0;i<mapsize;i++) { 2442 fvalues[i] = (GLfloat) values[i]; 2443 } 2444 } 2445 else { 2446 for (i=0;i<mapsize;i++) { 2447 fvalues[i] = UINT_TO_FLOAT( values[i] ); 2448 } 2449 } 2450 save_PixelMapfv(map, mapsize, fvalues); 2451} 2452 2453 2454static void 2455save_PixelMapusv(GLenum map, GLint mapsize, const GLushort *values) 2456{ 2457 GLfloat fvalues[MAX_PIXEL_MAP_TABLE]; 2458 GLint i; 2459 if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) { 2460 for (i=0;i<mapsize;i++) { 2461 fvalues[i] = (GLfloat) values[i]; 2462 } 2463 } 2464 else { 2465 for (i=0;i<mapsize;i++) { 2466 fvalues[i] = USHORT_TO_FLOAT( values[i] ); 2467 } 2468 } 2469 save_PixelMapfv(map, mapsize, fvalues); 2470} 2471 2472 2473static void 2474save_PixelTransferf( GLenum pname, GLfloat param ) 2475{ 2476 GET_CURRENT_CONTEXT(ctx); 2477 Node *n; 2478 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2479 n = ALLOC_INSTRUCTION( ctx, OPCODE_PIXEL_TRANSFER, 2 ); 2480 if (n) { 2481 n[1].e = pname; 2482 n[2].f = param; 2483 } 2484 if (ctx->ExecuteFlag) { 2485 (*ctx->Exec->PixelTransferf)( pname, param ); 2486 } 2487} 2488 2489 2490static void 2491save_PixelTransferi( GLenum pname, GLint param ) 2492{ 2493 save_PixelTransferf( pname, (GLfloat) param ); 2494} 2495 2496 2497static void 2498save_PixelZoom( GLfloat xfactor, GLfloat yfactor ) 2499{ 2500 GET_CURRENT_CONTEXT(ctx); 2501 Node *n; 2502 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2503 n = ALLOC_INSTRUCTION( ctx, OPCODE_PIXEL_ZOOM, 2 ); 2504 if (n) { 2505 n[1].f = xfactor; 2506 n[2].f = yfactor; 2507 } 2508 if (ctx->ExecuteFlag) { 2509 (*ctx->Exec->PixelZoom)( xfactor, yfactor ); 2510 } 2511} 2512 2513 2514static void 2515save_PointParameterfvEXT( GLenum pname, const GLfloat *params ) 2516{ 2517 GET_CURRENT_CONTEXT(ctx); 2518 Node *n; 2519 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2520 n = ALLOC_INSTRUCTION( ctx, OPCODE_POINT_PARAMETERS, 4 ); 2521 if (n) { 2522 n[1].e = pname; 2523 n[2].f = params[0]; 2524 n[3].f = params[1]; 2525 n[4].f = params[2]; 2526 } 2527 if (ctx->ExecuteFlag) { 2528 (*ctx->Exec->PointParameterfvEXT)( pname, params ); 2529 } 2530} 2531 2532 2533static void save_PointParameterfEXT( GLenum pname, GLfloat param ) 2534{ 2535 save_PointParameterfvEXT(pname, ¶m); 2536} 2537 2538static void save_PointParameteriNV( GLenum pname, GLint param ) 2539{ 2540 GLfloat p = (GLfloat) param; 2541 save_PointParameterfvEXT(pname, &p); 2542} 2543 2544static void save_PointParameterivNV( GLenum pname, const GLint *param ) 2545{ 2546 GLfloat p = (GLfloat) param[0]; 2547 save_PointParameterfvEXT(pname, &p); 2548} 2549 2550 2551static void save_PointSize( GLfloat size ) 2552{ 2553 GET_CURRENT_CONTEXT(ctx); 2554 Node *n; 2555 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2556 n = ALLOC_INSTRUCTION( ctx, OPCODE_POINT_SIZE, 1 ); 2557 if (n) { 2558 n[1].f = size; 2559 } 2560 if (ctx->ExecuteFlag) { 2561 (*ctx->Exec->PointSize)( size ); 2562 } 2563} 2564 2565 2566static void save_PolygonMode( GLenum face, GLenum mode ) 2567{ 2568 GET_CURRENT_CONTEXT(ctx); 2569 Node *n; 2570 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2571 n = ALLOC_INSTRUCTION( ctx, OPCODE_POLYGON_MODE, 2 ); 2572 if (n) { 2573 n[1].e = face; 2574 n[2].e = mode; 2575 } 2576 if (ctx->ExecuteFlag) { 2577 (*ctx->Exec->PolygonMode)( face, mode ); 2578 } 2579} 2580 2581 2582/* 2583 * Polygon stipple must have been upacked already! 2584 */ 2585static void save_PolygonStipple( const GLubyte *pattern ) 2586{ 2587 GET_CURRENT_CONTEXT(ctx); 2588 Node *n; 2589 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2590 n = ALLOC_INSTRUCTION( ctx, OPCODE_POLYGON_STIPPLE, 1 ); 2591 if (n) { 2592 void *data; 2593 n[1].data = MALLOC( 32 * 4 ); 2594 data = n[1].data; /* This needed for Acorn compiler */ 2595 MEMCPY( data, pattern, 32 * 4 ); 2596 } 2597 if (ctx->ExecuteFlag) { 2598 (*ctx->Exec->PolygonStipple)( (GLubyte*) pattern ); 2599 } 2600} 2601 2602 2603static void save_PolygonOffset( GLfloat factor, GLfloat units ) 2604{ 2605 GET_CURRENT_CONTEXT(ctx); 2606 Node *n; 2607 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2608 n = ALLOC_INSTRUCTION( ctx, OPCODE_POLYGON_OFFSET, 2 ); 2609 if (n) { 2610 n[1].f = factor; 2611 n[2].f = units; 2612 } 2613 if (ctx->ExecuteFlag) { 2614 (*ctx->Exec->PolygonOffset)( factor, units ); 2615 } 2616} 2617 2618 2619static void save_PolygonOffsetEXT( GLfloat factor, GLfloat bias ) 2620{ 2621 GET_CURRENT_CONTEXT(ctx); 2622 save_PolygonOffset(factor, ctx->DepthMaxF * bias); 2623} 2624 2625 2626static void save_PopAttrib( void ) 2627{ 2628 GET_CURRENT_CONTEXT(ctx); 2629 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2630 (void) ALLOC_INSTRUCTION( ctx, OPCODE_POP_ATTRIB, 0 ); 2631 if (ctx->ExecuteFlag) { 2632 (*ctx->Exec->PopAttrib)(); 2633 } 2634} 2635 2636 2637static void save_PopMatrix( void ) 2638{ 2639 GET_CURRENT_CONTEXT(ctx); 2640 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2641 FLUSH_CURRENT(ctx, 0); 2642 (void) ALLOC_INSTRUCTION( ctx, OPCODE_POP_MATRIX, 0 ); 2643 if (ctx->ExecuteFlag) { 2644 (*ctx->Exec->PopMatrix)(); 2645 } 2646} 2647 2648 2649static void save_PopName( void ) 2650{ 2651 GET_CURRENT_CONTEXT(ctx); 2652 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2653 (void) ALLOC_INSTRUCTION( ctx, OPCODE_POP_NAME, 0 ); 2654 if (ctx->ExecuteFlag) { 2655 (*ctx->Exec->PopName)(); 2656 } 2657} 2658 2659 2660static void save_PrioritizeTextures( GLsizei num, const GLuint *textures, 2661 const GLclampf *priorities ) 2662{ 2663 GET_CURRENT_CONTEXT(ctx); 2664 GLint i; 2665 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2666 2667 for (i=0;i<num;i++) { 2668 Node *n; 2669 n = ALLOC_INSTRUCTION( ctx, OPCODE_PRIORITIZE_TEXTURE, 2 ); 2670 if (n) { 2671 n[1].ui = textures[i]; 2672 n[2].f = priorities[i]; 2673 } 2674 } 2675 if (ctx->ExecuteFlag) { 2676 (*ctx->Exec->PrioritizeTextures)( num, textures, priorities ); 2677 } 2678} 2679 2680 2681static void save_PushAttrib( GLbitfield mask ) 2682{ 2683 GET_CURRENT_CONTEXT(ctx); 2684 Node *n; 2685 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2686 FLUSH_CURRENT(ctx, 0); 2687 n = ALLOC_INSTRUCTION( ctx, OPCODE_PUSH_ATTRIB, 1 ); 2688 if (n) { 2689 n[1].bf = mask; 2690 } 2691 if (ctx->ExecuteFlag) { 2692 (*ctx->Exec->PushAttrib)( mask ); 2693 } 2694} 2695 2696 2697static void save_PushMatrix( void ) 2698{ 2699 GET_CURRENT_CONTEXT(ctx); 2700 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2701 (void) ALLOC_INSTRUCTION( ctx, OPCODE_PUSH_MATRIX, 0 ); 2702 if (ctx->ExecuteFlag) { 2703 (*ctx->Exec->PushMatrix)(); 2704 } 2705} 2706 2707 2708static void save_PushName( GLuint name ) 2709{ 2710 GET_CURRENT_CONTEXT(ctx); 2711 Node *n; 2712 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2713 n = ALLOC_INSTRUCTION( ctx, OPCODE_PUSH_NAME, 1 ); 2714 if (n) { 2715 n[1].ui = name; 2716 } 2717 if (ctx->ExecuteFlag) { 2718 (*ctx->Exec->PushName)( name ); 2719 } 2720} 2721 2722 2723static void save_RasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) 2724{ 2725 GET_CURRENT_CONTEXT(ctx); 2726 Node *n; 2727 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2728 FLUSH_CURRENT(ctx, 0); 2729 n = ALLOC_INSTRUCTION( ctx, OPCODE_RASTER_POS, 4 ); 2730 if (n) { 2731 n[1].f = x; 2732 n[2].f = y; 2733 n[3].f = z; 2734 n[4].f = w; 2735 } 2736 if (ctx->ExecuteFlag) { 2737 (*ctx->Exec->RasterPos4f)( x, y, z, w ); 2738 } 2739} 2740 2741static void save_RasterPos2d(GLdouble x, GLdouble y) 2742{ 2743 save_RasterPos4f((GLfloat) x, (GLfloat) y, 0.0F, 1.0F); 2744} 2745 2746static void save_RasterPos2f(GLfloat x, GLfloat y) 2747{ 2748 save_RasterPos4f(x, y, 0.0F, 1.0F); 2749} 2750 2751static void save_RasterPos2i(GLint x, GLint y) 2752{ 2753 save_RasterPos4f((GLfloat) x, (GLfloat) y, 0.0F, 1.0F); 2754} 2755 2756static void save_RasterPos2s(GLshort x, GLshort y) 2757{ 2758 save_RasterPos4f(x, y, 0.0F, 1.0F); 2759} 2760 2761static void save_RasterPos3d(GLdouble x, GLdouble y, GLdouble z) 2762{ 2763 save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F); 2764} 2765 2766static void save_RasterPos3f(GLfloat x, GLfloat y, GLfloat z) 2767{ 2768 save_RasterPos4f(x, y, z, 1.0F); 2769} 2770 2771static void save_RasterPos3i(GLint x, GLint y, GLint z) 2772{ 2773 save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F); 2774} 2775 2776static void save_RasterPos3s(GLshort x, GLshort y, GLshort z) 2777{ 2778 save_RasterPos4f(x, y, z, 1.0F); 2779} 2780 2781static void save_RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) 2782{ 2783 save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w); 2784} 2785 2786static void save_RasterPos4i(GLint x, GLint y, GLint z, GLint w) 2787{ 2788 save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w); 2789} 2790 2791static void save_RasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w) 2792{ 2793 save_RasterPos4f(x, y, z, w); 2794} 2795 2796static void save_RasterPos2dv(const GLdouble *v) 2797{ 2798 save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F); 2799} 2800 2801static void save_RasterPos2fv(const GLfloat *v) 2802{ 2803 save_RasterPos4f(v[0], v[1], 0.0F, 1.0F); 2804} 2805 2806static void save_RasterPos2iv(const GLint *v) 2807{ 2808 save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F); 2809} 2810 2811static void save_RasterPos2sv(const GLshort *v) 2812{ 2813 save_RasterPos4f(v[0], v[1], 0.0F, 1.0F); 2814} 2815 2816static void save_RasterPos3dv(const GLdouble *v) 2817{ 2818 save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F); 2819} 2820 2821static void save_RasterPos3fv(const GLfloat *v) 2822{ 2823 save_RasterPos4f(v[0], v[1], v[2], 1.0F); 2824} 2825 2826static void save_RasterPos3iv(const GLint *v) 2827{ 2828 save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F); 2829} 2830 2831static void save_RasterPos3sv(const GLshort *v) 2832{ 2833 save_RasterPos4f(v[0], v[1], v[2], 1.0F); 2834} 2835 2836static void save_RasterPos4dv(const GLdouble *v) 2837{ 2838 save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 2839 (GLfloat) v[2], (GLfloat) v[3]); 2840} 2841 2842static void save_RasterPos4fv(const GLfloat *v) 2843{ 2844 save_RasterPos4f(v[0], v[1], v[2], v[3]); 2845} 2846 2847static void save_RasterPos4iv(const GLint *v) 2848{ 2849 save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 2850 (GLfloat) v[2], (GLfloat) v[3]); 2851} 2852 2853static void save_RasterPos4sv(const GLshort *v) 2854{ 2855 save_RasterPos4f(v[0], v[1], v[2], v[3]); 2856} 2857 2858 2859static void save_PassThrough( GLfloat token ) 2860{ 2861 GET_CURRENT_CONTEXT(ctx); 2862 Node *n; 2863 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2864 n = ALLOC_INSTRUCTION( ctx, OPCODE_PASSTHROUGH, 1 ); 2865 if (n) { 2866 n[1].f = token; 2867 } 2868 if (ctx->ExecuteFlag) { 2869 (*ctx->Exec->PassThrough)( token ); 2870 } 2871} 2872 2873 2874static void save_ReadBuffer( GLenum mode ) 2875{ 2876 GET_CURRENT_CONTEXT(ctx); 2877 Node *n; 2878 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2879 n = ALLOC_INSTRUCTION( ctx, OPCODE_READ_BUFFER, 1 ); 2880 if (n) { 2881 n[1].e = mode; 2882 } 2883 if (ctx->ExecuteFlag) { 2884 (*ctx->Exec->ReadBuffer)( mode ); 2885 } 2886} 2887 2888 2889static void 2890save_ResetHistogram(GLenum target) 2891{ 2892 GET_CURRENT_CONTEXT(ctx); 2893 Node *n; 2894 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2895 n = ALLOC_INSTRUCTION( ctx, OPCODE_RESET_HISTOGRAM, 1 ); 2896 if (n) { 2897 n[1].e = target; 2898 } 2899 if (ctx->ExecuteFlag) { 2900 (*ctx->Exec->ResetHistogram)( target ); 2901 } 2902} 2903 2904 2905static void 2906save_ResetMinmax(GLenum target) 2907{ 2908 GET_CURRENT_CONTEXT(ctx); 2909 Node *n; 2910 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2911 n = ALLOC_INSTRUCTION( ctx, OPCODE_RESET_MIN_MAX, 1 ); 2912 if (n) { 2913 n[1].e = target; 2914 } 2915 if (ctx->ExecuteFlag) { 2916 (*ctx->Exec->ResetMinmax)( target ); 2917 } 2918} 2919 2920 2921static void save_Rotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z ) 2922{ 2923 GET_CURRENT_CONTEXT(ctx); 2924 Node *n; 2925 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2926 n = ALLOC_INSTRUCTION( ctx, OPCODE_ROTATE, 4 ); 2927 if (n) { 2928 n[1].f = angle; 2929 n[2].f = x; 2930 n[3].f = y; 2931 n[4].f = z; 2932 } 2933 if (ctx->ExecuteFlag) { 2934 (*ctx->Exec->Rotatef)( angle, x, y, z ); 2935 } 2936} 2937 2938 2939static void save_Rotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z ) 2940{ 2941 save_Rotatef((GLfloat) angle, (GLfloat) x, (GLfloat) y, (GLfloat) z); 2942} 2943 2944 2945static void save_Scalef( GLfloat x, GLfloat y, GLfloat z ) 2946{ 2947 GET_CURRENT_CONTEXT(ctx); 2948 Node *n; 2949 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2950 n = ALLOC_INSTRUCTION( ctx, OPCODE_SCALE, 3 ); 2951 if (n) { 2952 n[1].f = x; 2953 n[2].f = y; 2954 n[3].f = z; 2955 } 2956 if (ctx->ExecuteFlag) { 2957 (*ctx->Exec->Scalef)( x, y, z ); 2958 } 2959} 2960 2961 2962static void save_Scaled( GLdouble x, GLdouble y, GLdouble z ) 2963{ 2964 save_Scalef((GLfloat) x, (GLfloat) y, (GLfloat) z); 2965} 2966 2967 2968static void save_Scissor( GLint x, GLint y, GLsizei width, GLsizei height ) 2969{ 2970 GET_CURRENT_CONTEXT(ctx); 2971 Node *n; 2972 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2973 n = ALLOC_INSTRUCTION( ctx, OPCODE_SCISSOR, 4 ); 2974 if (n) { 2975 n[1].i = x; 2976 n[2].i = y; 2977 n[3].i = width; 2978 n[4].i = height; 2979 } 2980 if (ctx->ExecuteFlag) { 2981 (*ctx->Exec->Scissor)( x, y, width, height ); 2982 } 2983} 2984 2985 2986static void save_ShadeModel( GLenum mode ) 2987{ 2988 GET_CURRENT_CONTEXT(ctx); 2989 Node *n; 2990 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 2991 n = ALLOC_INSTRUCTION( ctx, OPCODE_SHADE_MODEL, 1 ); 2992 if (n) { 2993 n[1].e = mode; 2994 } 2995 if (ctx->ExecuteFlag) { 2996 (*ctx->Exec->ShadeModel)( mode ); 2997 } 2998} 2999 3000 3001static void save_StencilFunc( GLenum func, GLint ref, GLuint mask ) 3002{ 3003 GET_CURRENT_CONTEXT(ctx); 3004 Node *n; 3005 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3006 n = ALLOC_INSTRUCTION( ctx, OPCODE_STENCIL_FUNC, 3 ); 3007 if (n) { 3008 n[1].e = func; 3009 n[2].i = ref; 3010 n[3].ui = mask; 3011 } 3012 if (ctx->ExecuteFlag) { 3013 (*ctx->Exec->StencilFunc)( func, ref, mask ); 3014 } 3015} 3016 3017 3018static void save_StencilMask( GLuint mask ) 3019{ 3020 GET_CURRENT_CONTEXT(ctx); 3021 Node *n; 3022 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3023 n = ALLOC_INSTRUCTION( ctx, OPCODE_STENCIL_MASK, 1 ); 3024 if (n) { 3025 n[1].ui = mask; 3026 } 3027 if (ctx->ExecuteFlag) { 3028 (*ctx->Exec->StencilMask)( mask ); 3029 } 3030} 3031 3032 3033static void save_StencilOp( GLenum fail, GLenum zfail, GLenum zpass ) 3034{ 3035 GET_CURRENT_CONTEXT(ctx); 3036 Node *n; 3037 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3038 n = ALLOC_INSTRUCTION( ctx, OPCODE_STENCIL_OP, 3 ); 3039 if (n) { 3040 n[1].e = fail; 3041 n[2].e = zfail; 3042 n[3].e = zpass; 3043 } 3044 if (ctx->ExecuteFlag) { 3045 (*ctx->Exec->StencilOp)( fail, zfail, zpass ); 3046 } 3047} 3048 3049 3050static void save_TexEnvfv( GLenum target, GLenum pname, const GLfloat *params ) 3051{ 3052 GET_CURRENT_CONTEXT(ctx); 3053 Node *n; 3054 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3055 n = ALLOC_INSTRUCTION( ctx, OPCODE_TEXENV, 6 ); 3056 if (n) { 3057 n[1].e = target; 3058 n[2].e = pname; 3059 n[3].f = params[0]; 3060 n[4].f = params[1]; 3061 n[5].f = params[2]; 3062 n[6].f = params[3]; 3063 } 3064 if (ctx->ExecuteFlag) { 3065 (*ctx->Exec->TexEnvfv)( target, pname, params ); 3066 } 3067} 3068 3069 3070static void save_TexEnvf( GLenum target, GLenum pname, GLfloat param ) 3071{ 3072 save_TexEnvfv( target, pname, ¶m ); 3073} 3074 3075 3076static void save_TexEnvi( GLenum target, GLenum pname, GLint param ) 3077{ 3078 GLfloat p[4]; 3079 p[0] = (GLfloat) param; 3080 p[1] = p[2] = p[3] = 0.0; 3081 save_TexEnvfv( target, pname, p ); 3082} 3083 3084 3085static void save_TexEnviv( GLenum target, GLenum pname, const GLint *param ) 3086{ 3087 GLfloat p[4]; 3088 p[0] = INT_TO_FLOAT( param[0] ); 3089 p[1] = INT_TO_FLOAT( param[1] ); 3090 p[2] = INT_TO_FLOAT( param[2] ); 3091 p[3] = INT_TO_FLOAT( param[3] ); 3092 save_TexEnvfv( target, pname, p ); 3093} 3094 3095 3096static void save_TexGenfv( GLenum coord, GLenum pname, const GLfloat *params ) 3097{ 3098 GET_CURRENT_CONTEXT(ctx); 3099 Node *n; 3100 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3101 n = ALLOC_INSTRUCTION( ctx, OPCODE_TEXGEN, 6 ); 3102 if (n) { 3103 n[1].e = coord; 3104 n[2].e = pname; 3105 n[3].f = params[0]; 3106 n[4].f = params[1]; 3107 n[5].f = params[2]; 3108 n[6].f = params[3]; 3109 } 3110 if (ctx->ExecuteFlag) { 3111 (*ctx->Exec->TexGenfv)( coord, pname, params ); 3112 } 3113} 3114 3115 3116static void save_TexGeniv(GLenum coord, GLenum pname, const GLint *params ) 3117{ 3118 GLfloat p[4]; 3119 p[0] = (GLfloat) params[0]; 3120 p[1] = (GLfloat) params[1]; 3121 p[2] = (GLfloat) params[2]; 3122 p[3] = (GLfloat) params[3]; 3123 save_TexGenfv(coord, pname, p); 3124} 3125 3126 3127static void save_TexGend(GLenum coord, GLenum pname, GLdouble param ) 3128{ 3129 GLfloat p = (GLfloat) param; 3130 save_TexGenfv( coord, pname, &p ); 3131} 3132 3133 3134static void save_TexGendv(GLenum coord, GLenum pname, const GLdouble *params ) 3135{ 3136 GLfloat p[4]; 3137 p[0] = (GLfloat) params[0]; 3138 p[1] = (GLfloat) params[1]; 3139 p[2] = (GLfloat) params[2]; 3140 p[3] = (GLfloat) params[3]; 3141 save_TexGenfv( coord, pname, p ); 3142} 3143 3144 3145static void save_TexGenf( GLenum coord, GLenum pname, GLfloat param ) 3146{ 3147 save_TexGenfv(coord, pname, ¶m); 3148} 3149 3150 3151static void save_TexGeni( GLenum coord, GLenum pname, GLint param ) 3152{ 3153 save_TexGeniv( coord, pname, ¶m ); 3154} 3155 3156 3157static void save_TexParameterfv( GLenum target, 3158 GLenum pname, const GLfloat *params ) 3159{ 3160 GET_CURRENT_CONTEXT(ctx); 3161 Node *n; 3162 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3163 n = ALLOC_INSTRUCTION( ctx, OPCODE_TEXPARAMETER, 6 ); 3164 if (n) { 3165 n[1].e = target; 3166 n[2].e = pname; 3167 n[3].f = params[0]; 3168 n[4].f = params[1]; 3169 n[5].f = params[2]; 3170 n[6].f = params[3]; 3171 } 3172 if (ctx->ExecuteFlag) { 3173 (*ctx->Exec->TexParameterfv)( target, pname, params ); 3174 } 3175} 3176 3177 3178static void save_TexParameterf( GLenum target, GLenum pname, GLfloat param ) 3179{ 3180 save_TexParameterfv(target, pname, ¶m); 3181} 3182 3183 3184static void save_TexParameteri( GLenum target, GLenum pname, GLint param ) 3185{ 3186 GLfloat fparam[4]; 3187 fparam[0] = (GLfloat) param; 3188 fparam[1] = fparam[2] = fparam[3] = 0.0; 3189 save_TexParameterfv(target, pname, fparam); 3190} 3191 3192 3193static void save_TexParameteriv( GLenum target, GLenum pname, const GLint *params ) 3194{ 3195 GLfloat fparam[4]; 3196 fparam[0] = (GLfloat) params[0]; 3197 fparam[1] = fparam[2] = fparam[3] = 0.0; 3198 save_TexParameterfv(target, pname, fparam); 3199} 3200 3201 3202static void save_TexImage1D( GLenum target, 3203 GLint level, GLint components, 3204 GLsizei width, GLint border, 3205 GLenum format, GLenum type, 3206 const GLvoid *pixels ) 3207{ 3208 GET_CURRENT_CONTEXT(ctx); 3209 if (target == GL_PROXY_TEXTURE_1D) { 3210 /* don't compile, execute immediately */ 3211 (*ctx->Exec->TexImage1D)( target, level, components, width, 3212 border, format, type, pixels ); 3213 } 3214 else { 3215 GLvoid *image = _mesa_unpack_image(width, 1, 1, format, type, 3216 pixels, &ctx->Unpack); 3217 Node *n; 3218 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3219 n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_IMAGE1D, 8 ); 3220 if (n) { 3221 n[1].e = target; 3222 n[2].i = level; 3223 n[3].i = components; 3224 n[4].i = (GLint) width; 3225 n[5].i = border; 3226 n[6].e = format; 3227 n[7].e = type; 3228 n[8].data = image; 3229 } 3230 else if (image) { 3231 FREE(image); 3232 } 3233 if (ctx->ExecuteFlag) { 3234 (*ctx->Exec->TexImage1D)( target, level, components, width, 3235 border, format, type, pixels ); 3236 } 3237 } 3238} 3239 3240 3241static void save_TexImage2D( GLenum target, 3242 GLint level, GLint components, 3243 GLsizei width, GLsizei height, GLint border, 3244 GLenum format, GLenum type, 3245 const GLvoid *pixels) 3246{ 3247 GET_CURRENT_CONTEXT(ctx); 3248 if (target == GL_PROXY_TEXTURE_2D) { 3249 /* don't compile, execute immediately */ 3250 (*ctx->Exec->TexImage2D)( target, level, components, width, 3251 height, border, format, type, pixels ); 3252 } 3253 else { 3254 GLvoid *image = _mesa_unpack_image(width, height, 1, format, type, 3255 pixels, &ctx->Unpack); 3256 Node *n; 3257 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3258 n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_IMAGE2D, 9 ); 3259 if (n) { 3260 n[1].e = target; 3261 n[2].i = level; 3262 n[3].i = components; 3263 n[4].i = (GLint) width; 3264 n[5].i = (GLint) height; 3265 n[6].i = border; 3266 n[7].e = format; 3267 n[8].e = type; 3268 n[9].data = image; 3269 } 3270 else if (image) { 3271 FREE(image); 3272 } 3273 if (ctx->ExecuteFlag) { 3274 (*ctx->Exec->TexImage2D)( target, level, components, width, 3275 height, border, format, type, pixels ); 3276 } 3277 } 3278} 3279 3280 3281static void save_TexImage3D( GLenum target, 3282 GLint level, GLint internalFormat, 3283 GLsizei width, GLsizei height, GLsizei depth, 3284 GLint border, 3285 GLenum format, GLenum type, 3286 const GLvoid *pixels ) 3287{ 3288 GET_CURRENT_CONTEXT(ctx); 3289 if (target == GL_PROXY_TEXTURE_3D) { 3290 /* don't compile, execute immediately */ 3291 (*ctx->Exec->TexImage3D)( target, level, internalFormat, width, 3292 height, depth, border, format, type, pixels ); 3293 } 3294 else { 3295 Node *n; 3296 GLvoid *image = _mesa_unpack_image(width, height, depth, format, type, 3297 pixels, &ctx->Unpack); 3298 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3299 n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_IMAGE3D, 10 ); 3300 if (n) { 3301 n[1].e = target; 3302 n[2].i = level; 3303 n[3].i = (GLint) internalFormat; 3304 n[4].i = (GLint) width; 3305 n[5].i = (GLint) height; 3306 n[6].i = (GLint) depth; 3307 n[7].i = border; 3308 n[8].e = format; 3309 n[9].e = type; 3310 n[10].data = image; 3311 } 3312 else if (image) { 3313 FREE(image); 3314 } 3315 if (ctx->ExecuteFlag) { 3316 (*ctx->Exec->TexImage3D)( target, level, internalFormat, width, 3317 height, depth, border, format, type, pixels ); 3318 } 3319 } 3320} 3321 3322 3323static void save_TexSubImage1D( GLenum target, GLint level, GLint xoffset, 3324 GLsizei width, GLenum format, GLenum type, 3325 const GLvoid *pixels ) 3326{ 3327 GET_CURRENT_CONTEXT(ctx); 3328 Node *n; 3329 GLvoid *image = _mesa_unpack_image(width, 1, 1, format, type, 3330 pixels, &ctx->Unpack); 3331 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3332 n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_SUB_IMAGE1D, 7 ); 3333 if (n) { 3334 n[1].e = target; 3335 n[2].i = level; 3336 n[3].i = xoffset; 3337 n[4].i = (GLint) width; 3338 n[5].e = format; 3339 n[6].e = type; 3340 n[7].data = image; 3341 } 3342 else if (image) { 3343 FREE(image); 3344 } 3345 if (ctx->ExecuteFlag) { 3346 (*ctx->Exec->TexSubImage1D)( target, level, xoffset, width, 3347 format, type, pixels ); 3348 } 3349} 3350 3351 3352static void save_TexSubImage2D( GLenum target, GLint level, 3353 GLint xoffset, GLint yoffset, 3354 GLsizei width, GLsizei height, 3355 GLenum format, GLenum type, 3356 const GLvoid *pixels ) 3357{ 3358 GET_CURRENT_CONTEXT(ctx); 3359 Node *n; 3360 GLvoid *image = _mesa_unpack_image(width, height, 1, format, type, 3361 pixels, &ctx->Unpack); 3362 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3363 n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_SUB_IMAGE2D, 9 ); 3364 if (n) { 3365 n[1].e = target; 3366 n[2].i = level; 3367 n[3].i = xoffset; 3368 n[4].i = yoffset; 3369 n[5].i = (GLint) width; 3370 n[6].i = (GLint) height; 3371 n[7].e = format; 3372 n[8].e = type; 3373 n[9].data = image; 3374 } 3375 else if (image) { 3376 FREE(image); 3377 } 3378 if (ctx->ExecuteFlag) { 3379 (*ctx->Exec->TexSubImage2D)( target, level, xoffset, yoffset, 3380 width, height, format, type, pixels ); 3381 } 3382} 3383 3384 3385static void save_TexSubImage3D( GLenum target, GLint level, 3386 GLint xoffset, GLint yoffset,GLint zoffset, 3387 GLsizei width, GLsizei height, GLsizei depth, 3388 GLenum format, GLenum type, 3389 const GLvoid *pixels ) 3390{ 3391 GET_CURRENT_CONTEXT(ctx); 3392 Node *n; 3393 GLvoid *image = _mesa_unpack_image(width, height, depth, format, type, 3394 pixels, &ctx->Unpack); 3395 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3396 n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_SUB_IMAGE3D, 11 ); 3397 if (n) { 3398 n[1].e = target; 3399 n[2].i = level; 3400 n[3].i = xoffset; 3401 n[4].i = yoffset; 3402 n[5].i = zoffset; 3403 n[6].i = (GLint) width; 3404 n[7].i = (GLint) height; 3405 n[8].i = (GLint) depth; 3406 n[9].e = format; 3407 n[10].e = type; 3408 n[11].data = image; 3409 } 3410 else if (image) { 3411 FREE(image); 3412 } 3413 if (ctx->ExecuteFlag) { 3414 (*ctx->Exec->TexSubImage3D)( target, level, 3415 xoffset, yoffset, zoffset, 3416 width, height, depth, format, type, pixels ); 3417 } 3418} 3419 3420 3421static void save_Translatef( GLfloat x, GLfloat y, GLfloat z ) 3422{ 3423 GET_CURRENT_CONTEXT(ctx); 3424 Node *n; 3425 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3426 n = ALLOC_INSTRUCTION( ctx, OPCODE_TRANSLATE, 3 ); 3427 if (n) { 3428 n[1].f = x; 3429 n[2].f = y; 3430 n[3].f = z; 3431 } 3432 if (ctx->ExecuteFlag) { 3433 (*ctx->Exec->Translatef)( x, y, z ); 3434 } 3435} 3436 3437 3438static void save_Translated( GLdouble x, GLdouble y, GLdouble z ) 3439{ 3440 save_Translatef((GLfloat) x, (GLfloat) y, (GLfloat) z); 3441} 3442 3443 3444 3445static void save_Viewport( GLint x, GLint y, GLsizei width, GLsizei height ) 3446{ 3447 GET_CURRENT_CONTEXT(ctx); 3448 Node *n; 3449 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3450 n = ALLOC_INSTRUCTION( ctx, OPCODE_VIEWPORT, 4 ); 3451 if (n) { 3452 n[1].i = x; 3453 n[2].i = y; 3454 n[3].i = (GLint) width; 3455 n[4].i = (GLint) height; 3456 } 3457 if (ctx->ExecuteFlag) { 3458 (*ctx->Exec->Viewport)( x, y, width, height ); 3459 } 3460} 3461 3462 3463static void save_WindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) 3464{ 3465 GET_CURRENT_CONTEXT(ctx); 3466 Node *n; 3467 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3468 FLUSH_CURRENT(ctx, 0); 3469 n = ALLOC_INSTRUCTION( ctx, OPCODE_WINDOW_POS, 4 ); 3470 if (n) { 3471 n[1].f = x; 3472 n[2].f = y; 3473 n[3].f = z; 3474 n[4].f = w; 3475 } 3476 if (ctx->ExecuteFlag) { 3477 (*ctx->Exec->WindowPos4fMESA)( x, y, z, w ); 3478 } 3479} 3480 3481static void save_WindowPos2dMESA(GLdouble x, GLdouble y) 3482{ 3483 save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, 0.0F, 1.0F); 3484} 3485 3486static void save_WindowPos2fMESA(GLfloat x, GLfloat y) 3487{ 3488 save_WindowPos4fMESA(x, y, 0.0F, 1.0F); 3489} 3490 3491static void save_WindowPos2iMESA(GLint x, GLint y) 3492{ 3493 save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, 0.0F, 1.0F); 3494} 3495 3496static void save_WindowPos2sMESA(GLshort x, GLshort y) 3497{ 3498 save_WindowPos4fMESA(x, y, 0.0F, 1.0F); 3499} 3500 3501static void save_WindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z) 3502{ 3503 save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F); 3504} 3505 3506static void save_WindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z) 3507{ 3508 save_WindowPos4fMESA(x, y, z, 1.0F); 3509} 3510 3511static void save_WindowPos3iMESA(GLint x, GLint y, GLint z) 3512{ 3513 save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F); 3514} 3515 3516static void save_WindowPos3sMESA(GLshort x, GLshort y, GLshort z) 3517{ 3518 save_WindowPos4fMESA(x, y, z, 1.0F); 3519} 3520 3521static void save_WindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w) 3522{ 3523 save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w); 3524} 3525 3526static void save_WindowPos4iMESA(GLint x, GLint y, GLint z, GLint w) 3527{ 3528 save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w); 3529} 3530 3531static void save_WindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w) 3532{ 3533 save_WindowPos4fMESA(x, y, z, w); 3534} 3535 3536static void save_WindowPos2dvMESA(const GLdouble *v) 3537{ 3538 save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F); 3539} 3540 3541static void save_WindowPos2fvMESA(const GLfloat *v) 3542{ 3543 save_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F); 3544} 3545 3546static void save_WindowPos2ivMESA(const GLint *v) 3547{ 3548 save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F); 3549} 3550 3551static void save_WindowPos2svMESA(const GLshort *v) 3552{ 3553 save_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F); 3554} 3555 3556static void save_WindowPos3dvMESA(const GLdouble *v) 3557{ 3558 save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F); 3559} 3560 3561static void save_WindowPos3fvMESA(const GLfloat *v) 3562{ 3563 save_WindowPos4fMESA(v[0], v[1], v[2], 1.0F); 3564} 3565 3566static void save_WindowPos3ivMESA(const GLint *v) 3567{ 3568 save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F); 3569} 3570 3571static void save_WindowPos3svMESA(const GLshort *v) 3572{ 3573 save_WindowPos4fMESA(v[0], v[1], v[2], 1.0F); 3574} 3575 3576static void save_WindowPos4dvMESA(const GLdouble *v) 3577{ 3578 save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 3579 (GLfloat) v[2], (GLfloat) v[3]); 3580} 3581 3582static void save_WindowPos4fvMESA(const GLfloat *v) 3583{ 3584 save_WindowPos4fMESA(v[0], v[1], v[2], v[3]); 3585} 3586 3587static void save_WindowPos4ivMESA(const GLint *v) 3588{ 3589 save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 3590 (GLfloat) v[2], (GLfloat) v[3]); 3591} 3592 3593static void save_WindowPos4svMESA(const GLshort *v) 3594{ 3595 save_WindowPos4fMESA(v[0], v[1], v[2], v[3]); 3596} 3597 3598 3599 3600/* GL_ARB_multitexture */ 3601static void save_ActiveTextureARB( GLenum target ) 3602{ 3603 GET_CURRENT_CONTEXT(ctx); 3604 Node *n; 3605 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3606 n = ALLOC_INSTRUCTION( ctx, OPCODE_ACTIVE_TEXTURE, 1 ); 3607 if (n) { 3608 n[1].e = target; 3609 } 3610 if (ctx->ExecuteFlag) { 3611 (*ctx->Exec->ActiveTextureARB)( target ); 3612 } 3613} 3614 3615 3616/* GL_ARB_transpose_matrix */ 3617 3618static void save_LoadTransposeMatrixdARB( const GLdouble m[16] ) 3619{ 3620 GLfloat tm[16]; 3621 _math_transposefd(tm, m); 3622 save_LoadMatrixf(tm); 3623} 3624 3625 3626static void save_LoadTransposeMatrixfARB( const GLfloat m[16] ) 3627{ 3628 GLfloat tm[16]; 3629 _math_transposef(tm, m); 3630 save_LoadMatrixf(tm); 3631} 3632 3633 3634static void 3635save_MultTransposeMatrixdARB( const GLdouble m[16] ) 3636{ 3637 GLfloat tm[16]; 3638 _math_transposefd(tm, m); 3639 save_MultMatrixf(tm); 3640} 3641 3642 3643static void 3644save_MultTransposeMatrixfARB( const GLfloat m[16] ) 3645{ 3646 GLfloat tm[16]; 3647 _math_transposef(tm, m); 3648 save_MultMatrixf(tm); 3649} 3650 3651 3652static void 3653save_PixelTexGenSGIX(GLenum mode) 3654{ 3655 GET_CURRENT_CONTEXT(ctx); 3656 Node *n; 3657 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3658 n = ALLOC_INSTRUCTION( ctx, OPCODE_PIXEL_TEXGEN_SGIX, 1 ); 3659 if (n) { 3660 n[1].e = mode; 3661 } 3662 if (ctx->ExecuteFlag) { 3663 (*ctx->Exec->PixelTexGenSGIX)( mode ); 3664 } 3665} 3666 3667 3668/* GL_ARB_texture_compression */ 3669static void 3670save_CompressedTexImage1DARB(GLenum target, GLint level, 3671 GLenum internalFormat, GLsizei width, 3672 GLint border, GLsizei imageSize, 3673 const GLvoid *data) 3674{ 3675 GET_CURRENT_CONTEXT(ctx); 3676 if (target == GL_PROXY_TEXTURE_1D) { 3677 /* don't compile, execute immediately */ 3678 (*ctx->Exec->CompressedTexImage1DARB)(target, level, internalFormat, 3679 width, border, imageSize, data); 3680 } 3681 else { 3682 Node *n; 3683 GLvoid *image; 3684 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3685 /* make copy of image */ 3686 image = MALLOC(imageSize); 3687 if (!image) { 3688 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage1DARB"); 3689 return; 3690 } 3691 MEMCPY(image, data, imageSize); 3692 n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_IMAGE_1D, 7 ); 3693 if (n) { 3694 n[1].e = target; 3695 n[2].i = level; 3696 n[3].e = internalFormat; 3697 n[4].i = (GLint) width; 3698 n[5].i = border; 3699 n[6].i = imageSize; 3700 n[7].data = image; 3701 } 3702 else if (image) { 3703 FREE(image); 3704 } 3705 if (ctx->ExecuteFlag) { 3706 (*ctx->Exec->CompressedTexImage1DARB)(target, level, internalFormat, 3707 width, border, imageSize, data); 3708 } 3709 } 3710} 3711 3712 3713static void 3714save_CompressedTexImage2DARB(GLenum target, GLint level, 3715 GLenum internalFormat, GLsizei width, 3716 GLsizei height, GLint border, GLsizei imageSize, 3717 const GLvoid *data) 3718{ 3719 GET_CURRENT_CONTEXT(ctx); 3720 if (target == GL_PROXY_TEXTURE_2D) { 3721 /* don't compile, execute immediately */ 3722 (*ctx->Exec->CompressedTexImage2DARB)(target, level, internalFormat, 3723 width, height, border, imageSize, data); 3724 } 3725 else { 3726 Node *n; 3727 GLvoid *image; 3728 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3729 /* make copy of image */ 3730 image = MALLOC(imageSize); 3731 if (!image) { 3732 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2DARB"); 3733 return; 3734 } 3735 MEMCPY(image, data, imageSize); 3736 n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_IMAGE_2D, 8 ); 3737 if (n) { 3738 n[1].e = target; 3739 n[2].i = level; 3740 n[3].e = internalFormat; 3741 n[4].i = (GLint) width; 3742 n[5].i = (GLint) height; 3743 n[6].i = border; 3744 n[7].i = imageSize; 3745 n[8].data = image; 3746 } 3747 else if (image) { 3748 FREE(image); 3749 } 3750 if (ctx->ExecuteFlag) { 3751 (*ctx->Exec->CompressedTexImage2DARB)(target, level, internalFormat, 3752 width, height, border, imageSize, data); 3753 } 3754 } 3755} 3756 3757 3758static void 3759save_CompressedTexImage3DARB(GLenum target, GLint level, 3760 GLenum internalFormat, GLsizei width, 3761 GLsizei height, GLsizei depth, GLint border, 3762 GLsizei imageSize, const GLvoid *data) 3763{ 3764 GET_CURRENT_CONTEXT(ctx); 3765 if (target == GL_PROXY_TEXTURE_3D) { 3766 /* don't compile, execute immediately */ 3767 (*ctx->Exec->CompressedTexImage3DARB)(target, level, internalFormat, 3768 width, height, depth, border, imageSize, data); 3769 } 3770 else { 3771 Node *n; 3772 GLvoid *image; 3773 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3774 /* make copy of image */ 3775 image = MALLOC(imageSize); 3776 if (!image) { 3777 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage3DARB"); 3778 return; 3779 } 3780 MEMCPY(image, data, imageSize); 3781 n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_IMAGE_3D, 9 ); 3782 if (n) { 3783 n[1].e = target; 3784 n[2].i = level; 3785 n[3].e = internalFormat; 3786 n[4].i = (GLint) width; 3787 n[5].i = (GLint) height; 3788 n[6].i = (GLint) depth; 3789 n[7].i = border; 3790 n[8].i = imageSize; 3791 n[9].data = image; 3792 } 3793 else if (image) { 3794 FREE(image); 3795 } 3796 if (ctx->ExecuteFlag) { 3797 (*ctx->Exec->CompressedTexImage3DARB)(target, level, internalFormat, 3798 width, height, depth, border, imageSize, data); 3799 } 3800 } 3801} 3802 3803 3804static void 3805save_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset, 3806 GLsizei width, GLenum format, 3807 GLsizei imageSize, const GLvoid *data) 3808{ 3809 Node *n; 3810 GLvoid *image; 3811 3812 GET_CURRENT_CONTEXT(ctx); 3813 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3814 3815 /* make copy of image */ 3816 image = MALLOC(imageSize); 3817 if (!image) { 3818 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage1DARB"); 3819 return; 3820 } 3821 MEMCPY(image, data, imageSize); 3822 n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D, 7 ); 3823 if (n) { 3824 n[1].e = target; 3825 n[2].i = level; 3826 n[3].i = xoffset; 3827 n[4].i = (GLint) width; 3828 n[5].e = format; 3829 n[6].i = imageSize; 3830 n[7].data = image; 3831 } 3832 else if (image) { 3833 FREE(image); 3834 } 3835 if (ctx->ExecuteFlag) { 3836 (*ctx->Exec->CompressedTexSubImage1DARB)(target, level, xoffset, 3837 width, format, imageSize, data); 3838 } 3839} 3840 3841 3842static void 3843save_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset, 3844 GLint yoffset, GLsizei width, GLsizei height, 3845 GLenum format, GLsizei imageSize, 3846 const GLvoid *data) 3847{ 3848 Node *n; 3849 GLvoid *image; 3850 3851 GET_CURRENT_CONTEXT(ctx); 3852 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3853 3854 /* make copy of image */ 3855 image = MALLOC(imageSize); 3856 if (!image) { 3857 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage2DARB"); 3858 return; 3859 } 3860 MEMCPY(image, data, imageSize); 3861 n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D, 9 ); 3862 if (n) { 3863 n[1].e = target; 3864 n[2].i = level; 3865 n[3].i = xoffset; 3866 n[4].i = yoffset; 3867 n[5].i = (GLint) width; 3868 n[6].i = (GLint) height; 3869 n[7].e = format; 3870 n[8].i = imageSize; 3871 n[9].data = image; 3872 } 3873 else if (image) { 3874 FREE(image); 3875 } 3876 if (ctx->ExecuteFlag) { 3877 (*ctx->Exec->CompressedTexSubImage2DARB)(target, level, xoffset, yoffset, 3878 width, height, format, imageSize, data); 3879 } 3880} 3881 3882 3883static void 3884save_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, 3885 GLint yoffset, GLint zoffset, GLsizei width, 3886 GLsizei height, GLsizei depth, GLenum format, 3887 GLsizei imageSize, const GLvoid *data) 3888{ 3889 Node *n; 3890 GLvoid *image; 3891 3892 GET_CURRENT_CONTEXT(ctx); 3893 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3894 3895 /* make copy of image */ 3896 image = MALLOC(imageSize); 3897 if (!image) { 3898 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage3DARB"); 3899 return; 3900 } 3901 MEMCPY(image, data, imageSize); 3902 n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D, 11 ); 3903 if (n) { 3904 n[1].e = target; 3905 n[2].i = level; 3906 n[3].i = xoffset; 3907 n[4].i = yoffset; 3908 n[5].i = zoffset; 3909 n[6].i = (GLint) width; 3910 n[7].i = (GLint) height; 3911 n[8].i = (GLint) depth; 3912 n[9].e = format; 3913 n[10].i = imageSize; 3914 n[11].data = image; 3915 } 3916 else if (image) { 3917 FREE(image); 3918 } 3919 if (ctx->ExecuteFlag) { 3920 (*ctx->Exec->CompressedTexSubImage3DARB)(target, level, xoffset, yoffset, 3921 zoffset, width, height, depth, format, imageSize, data); 3922 } 3923} 3924 3925 3926/* GL_ARB_multisample */ 3927static void 3928save_SampleCoverageARB(GLclampf value, GLboolean invert) 3929{ 3930 GET_CURRENT_CONTEXT(ctx); 3931 Node *n; 3932 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3933 n = ALLOC_INSTRUCTION( ctx, OPCODE_SAMPLE_COVERAGE, 2 ); 3934 if (n) { 3935 n[1].f = value; 3936 n[2].b = invert; 3937 } 3938 if (ctx->ExecuteFlag) { 3939 (*ctx->Exec->SampleCoverageARB)( value, invert ); 3940 } 3941} 3942 3943 3944/* GL_SGIS_pixel_texture */ 3945 3946static void 3947save_PixelTexGenParameteriSGIS(GLenum target, GLint value) 3948{ 3949 GET_CURRENT_CONTEXT(ctx); 3950 Node *n; 3951 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3952 n = ALLOC_INSTRUCTION( ctx, OPCODE_PIXEL_TEXGEN_PARAMETER_SGIS, 2 ); 3953 if (n) { 3954 n[1].e = target; 3955 n[2].i = value; 3956 } 3957 if (ctx->ExecuteFlag) { 3958 (*ctx->Exec->PixelTexGenParameteriSGIS)( target, value ); 3959 } 3960} 3961 3962 3963static void 3964save_PixelTexGenParameterfSGIS(GLenum target, GLfloat value) 3965{ 3966 save_PixelTexGenParameteriSGIS(target, (GLint) value); 3967} 3968 3969 3970static void 3971save_PixelTexGenParameterivSGIS(GLenum target, const GLint *value) 3972{ 3973 save_PixelTexGenParameteriSGIS(target, *value); 3974} 3975 3976 3977static void 3978save_PixelTexGenParameterfvSGIS(GLenum target, const GLfloat *value) 3979{ 3980 save_PixelTexGenParameteriSGIS(target, (GLint) *value); 3981} 3982 3983 3984/* 3985 * GL_NV_vertex_program 3986 */ 3987#if FEATURE_NV_vertex_program 3988static void 3989save_BindProgramNV(GLenum target, GLuint id) 3990{ 3991 GET_CURRENT_CONTEXT(ctx); 3992 Node *n; 3993 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 3994 n = ALLOC_INSTRUCTION( ctx, OPCODE_BIND_PROGRAM_NV, 2 ); 3995 if (n) { 3996 n[1].e = target; 3997 n[2].ui = id; 3998 } 3999 if (ctx->ExecuteFlag) { 4000 (*ctx->Exec->BindProgramNV)( target, id ); 4001 } 4002} 4003 4004static void 4005save_ExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params) 4006{ 4007 GET_CURRENT_CONTEXT(ctx); 4008 Node *n; 4009 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 4010 n = ALLOC_INSTRUCTION( ctx, OPCODE_EXECUTE_PROGRAM_NV, 6 ); 4011 if (n) { 4012 n[1].e = target; 4013 n[2].ui = id; 4014 n[3].f = params[0]; 4015 n[4].f = params[1]; 4016 n[5].f = params[2]; 4017 n[6].f = params[3]; 4018 } 4019 if (ctx->ExecuteFlag) { 4020 (*ctx->Exec->ExecuteProgramNV)(target, id, params); 4021 } 4022} 4023 4024 4025static void 4026save_ProgramParameter4fNV(GLenum target, GLuint index, 4027 GLfloat x, GLfloat y, 4028 GLfloat z, GLfloat w) 4029{ 4030 GET_CURRENT_CONTEXT(ctx); 4031 Node *n; 4032 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 4033 n = ALLOC_INSTRUCTION( ctx, OPCODE_PROGRAM_PARAMETER4F_NV, 6 ); 4034 if (n) { 4035 n[1].e = target; 4036 n[2].ui = index; 4037 n[3].f = x; 4038 n[4].f = y; 4039 n[5].f = z; 4040 n[6].f = w; 4041 } 4042 if (ctx->ExecuteFlag) { 4043 (*ctx->Exec->ProgramParameter4fNV)(target, index, x, y, z, w); 4044 } 4045} 4046 4047 4048static void 4049save_ProgramParameter4fvNV(GLenum target, GLuint index, const GLfloat *params) 4050{ 4051 save_ProgramParameter4fNV(target, index, params[0], params[1], 4052 params[2], params[3]); 4053} 4054 4055 4056static void 4057save_ProgramParameter4dNV(GLenum target, GLuint index, 4058 GLdouble x, GLdouble y, 4059 GLdouble z, GLdouble w) 4060{ 4061 save_ProgramParameter4fNV(target, index, (GLfloat) x, (GLfloat) y, 4062 (GLfloat) z, (GLfloat) w); 4063} 4064 4065 4066static void 4067save_ProgramParameter4dvNV(GLenum target, GLuint index, 4068 const GLdouble *params) 4069{ 4070 save_ProgramParameter4fNV(target, index, (GLfloat) params[0], 4071 (GLfloat) params[1], (GLfloat) params[2], 4072 (GLfloat) params[3]); 4073} 4074 4075 4076static void 4077save_ProgramParameters4dvNV(GLenum target, GLuint index, 4078 GLuint num, const GLdouble *params) 4079{ 4080 GLuint i; 4081 for (i = 0; i < num; i++) { 4082 save_ProgramParameter4dvNV(target, index + i, params + 4 * i); 4083 } 4084} 4085 4086 4087static void 4088save_ProgramParameters4fvNV(GLenum target, GLuint index, 4089 GLuint num, const GLfloat *params) 4090{ 4091 GLuint i; 4092 for (i = 0; i < num; i++) { 4093 save_ProgramParameter4fvNV(target, index + i, params + 4 * i); 4094 } 4095} 4096 4097 4098 4099static void 4100save_TrackMatrixNV(GLenum target, GLuint address, 4101 GLenum matrix, GLenum transform) 4102{ 4103 GET_CURRENT_CONTEXT(ctx); 4104 Node *n; 4105 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 4106 n = ALLOC_INSTRUCTION( ctx, OPCODE_TRACK_MATRIX_NV, 4 ); 4107 if (n) { 4108 n[1].e = target; 4109 n[2].ui = address; 4110 n[3].e = matrix; 4111 n[4].e = transform; 4112 } 4113 if (ctx->ExecuteFlag) { 4114 (*ctx->Exec->TrackMatrixNV)(target, address, matrix, transform); 4115 } 4116} 4117#endif /* FEATURE_NV_vertex_program */ 4118 4119 4120/* GL_EXT_stencil_two_side */ 4121static void save_ActiveStencilFaceEXT( GLenum face ) 4122{ 4123 GET_CURRENT_CONTEXT(ctx); 4124 Node *n; 4125 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); 4126 n = ALLOC_INSTRUCTION( ctx, OPCODE_ACTIVE_STENCIL_FACE_EXT, 1 ); 4127 if (n) { 4128 n[1].e = face; 4129 } 4130 if (ctx->ExecuteFlag) { 4131 (*ctx->Exec->ActiveStencilFaceEXT)( face ); 4132 } 4133} 4134 4135 4136 4137/* KW: Compile commands 4138 * 4139 * Will appear in the list before the vertex buffer containing the 4140 * command that provoked the error. I don't see this as a problem. 4141 */ 4142void 4143_mesa_save_error( GLcontext *ctx, GLenum error, const char *s ) 4144{ 4145 Node *n; 4146 n = ALLOC_INSTRUCTION( ctx, OPCODE_ERROR, 2 ); 4147 if (n) { 4148 n[1].e = error; 4149 n[2].data = (void *) s; 4150 } 4151 /* execute already done */ 4152} 4153 4154 4155/* 4156 * Compile an error into current display list. 4157 */ 4158void 4159_mesa_compile_error( GLcontext *ctx, GLenum error, const char *s ) 4160{ 4161 if (ctx->CompileFlag) 4162 _mesa_save_error( ctx, error, s ); 4163 4164 if (ctx->ExecuteFlag) 4165 _mesa_error( ctx, error, s ); 4166} 4167 4168 4169 4170static GLboolean 4171islist(GLcontext *ctx, GLuint list) 4172{ 4173 if (list > 0 && _mesa_HashLookup(ctx->Shared->DisplayList, list)) { 4174 return GL_TRUE; 4175 } 4176 else { 4177 return GL_FALSE; 4178 } 4179} 4180 4181 4182 4183/**********************************************************************/ 4184/* Display list execution */ 4185/**********************************************************************/ 4186 4187 4188/* 4189 * Execute a display list. Note that the ListBase offset must have already 4190 * been added before calling this function. I.e. the list argument is 4191 * the absolute list number, not relative to ListBase. 4192 * Input: list - display list number 4193 */ 4194static void 4195execute_list( GLcontext *ctx, GLuint list ) 4196{ 4197 Node *n; 4198 GLboolean done; 4199 4200 if (!islist(ctx,list)) 4201 return; 4202 4203 if (ctx->Driver.BeginCallList) 4204 ctx->Driver.BeginCallList( ctx, list ); 4205 4206 ctx->CallDepth++; 4207 4208 n = (Node *) _mesa_HashLookup(ctx->Shared->DisplayList, list); 4209 4210 done = GL_FALSE; 4211 while (!done) { 4212 OpCode opcode = n[0].opcode; 4213 int i = (int)n[0].opcode - (int)OPCODE_DRV_0; 4214 4215 if (i >= 0 && i < (GLint) ctx->listext.nr_opcodes) { 4216 ctx->listext.opcode[i].execute(ctx, &n[1]); 4217 n += ctx->listext.opcode[i].size; 4218 } 4219 else { 4220 switch (opcode) { 4221 case OPCODE_ERROR: 4222 _mesa_error( ctx, n[1].e, (const char *) n[2].data ); 4223 break; 4224 case OPCODE_ACCUM: 4225 (*ctx->Exec->Accum)( n[1].e, n[2].f ); 4226 break; 4227 case OPCODE_ALPHA_FUNC: 4228 (*ctx->Exec->AlphaFunc)( n[1].e, n[2].f ); 4229 break; 4230 case OPCODE_BIND_TEXTURE: 4231 (*ctx->Exec->BindTexture)( n[1].e, n[2].ui ); 4232 break; 4233 case OPCODE_BITMAP: 4234 { 4235 struct gl_pixelstore_attrib save = ctx->Unpack; 4236 ctx->Unpack = _mesa_native_packing; 4237 (*ctx->Exec->Bitmap)( (GLsizei) n[1].i, (GLsizei) n[2].i, 4238 n[3].f, n[4].f, n[5].f, n[6].f, (const GLubyte *) n[7].data ); 4239 ctx->Unpack = save; /* restore */ 4240 } 4241 break; 4242 case OPCODE_BLEND_COLOR: 4243 (*ctx->Exec->BlendColor)( n[1].f, n[2].f, n[3].f, n[4].f ); 4244 break; 4245 case OPCODE_BLEND_EQUATION: 4246 (*ctx->Exec->BlendEquation)( n[1].e ); 4247 break; 4248 case OPCODE_BLEND_FUNC: 4249 (*ctx->Exec->BlendFunc)( n[1].e, n[2].e ); 4250 break; 4251 case OPCODE_BLEND_FUNC_SEPARATE: 4252 (*ctx->Exec->BlendFuncSeparateEXT)(n[1].e, n[2].e, n[3].e, n[4].e); 4253 break; 4254 case OPCODE_CALL_LIST: 4255 /* Generated by glCallList(), don't add ListBase */ 4256 if (ctx->CallDepth<MAX_LIST_NESTING) { 4257 execute_list( ctx, n[1].ui ); 4258 } 4259 break; 4260 case OPCODE_CALL_LIST_OFFSET: 4261 /* Generated by glCallLists() so we must add ListBase */ 4262 if (n[2].b) { 4263 /* user specified a bad datatype at compile time */ 4264 _mesa_error(ctx, GL_INVALID_ENUM, "glCallLists(type)"); 4265 } 4266 else if (ctx->CallDepth < MAX_LIST_NESTING) { 4267 execute_list( ctx, ctx->List.ListBase + n[1].ui ); 4268 } 4269 break; 4270 case OPCODE_CLEAR: 4271 (*ctx->Exec->Clear)( n[1].bf ); 4272 break; 4273 case OPCODE_CLEAR_COLOR: 4274 (*ctx->Exec->ClearColor)( n[1].f, n[2].f, n[3].f, n[4].f ); 4275 break; 4276 case OPCODE_CLEAR_ACCUM: 4277 (*ctx->Exec->ClearAccum)( n[1].f, n[2].f, n[3].f, n[4].f ); 4278 break; 4279 case OPCODE_CLEAR_DEPTH: 4280 (*ctx->Exec->ClearDepth)( (GLclampd) n[1].f ); 4281 break; 4282 case OPCODE_CLEAR_INDEX: 4283 (*ctx->Exec->ClearIndex)( (GLfloat) n[1].ui ); 4284 break; 4285 case OPCODE_CLEAR_STENCIL: 4286 (*ctx->Exec->ClearStencil)( n[1].i ); 4287 break; 4288 case OPCODE_CLIP_PLANE: 4289 { 4290 GLdouble eq[4]; 4291 eq[0] = n[2].f; 4292 eq[1] = n[3].f; 4293 eq[2] = n[4].f; 4294 eq[3] = n[5].f; 4295 (*ctx->Exec->ClipPlane)( n[1].e, eq ); 4296 } 4297 break; 4298 case OPCODE_COLOR_MASK: 4299 (*ctx->Exec->ColorMask)( n[1].b, n[2].b, n[3].b, n[4].b ); 4300 break; 4301 case OPCODE_COLOR_MATERIAL: 4302 (*ctx->Exec->ColorMaterial)( n[1].e, n[2].e ); 4303 break; 4304 case OPCODE_COLOR_TABLE: 4305 { 4306 struct gl_pixelstore_attrib save = ctx->Unpack; 4307 ctx->Unpack = _mesa_native_packing; 4308 (*ctx->Exec->ColorTable)( n[1].e, n[2].e, n[3].i, n[4].e, 4309 n[5].e, n[6].data ); 4310 ctx->Unpack = save; /* restore */ 4311 } 4312 break; 4313 case OPCODE_COLOR_TABLE_PARAMETER_FV: 4314 { 4315 GLfloat params[4]; 4316 params[0] = n[3].f; 4317 params[1] = n[4].f; 4318 params[2] = n[5].f; 4319 params[3] = n[6].f; 4320 (*ctx->Exec->ColorTableParameterfv)( n[1].e, n[2].e, params ); 4321 } 4322 break; 4323 case OPCODE_COLOR_TABLE_PARAMETER_IV: 4324 { 4325 GLint params[4]; 4326 params[0] = n[3].i; 4327 params[1] = n[4].i; 4328 params[2] = n[5].i; 4329 params[3] = n[6].i; 4330 (*ctx->Exec->ColorTableParameteriv)( n[1].e, n[2].e, params ); 4331 } 4332 break; 4333 case OPCODE_COLOR_SUB_TABLE: 4334 { 4335 struct gl_pixelstore_attrib save = ctx->Unpack; 4336 ctx->Unpack = _mesa_native_packing; 4337 (*ctx->Exec->ColorSubTable)( n[1].e, n[2].i, n[3].i, 4338 n[4].e, n[5].e, n[6].data ); 4339 ctx->Unpack = save; /* restore */ 4340 } 4341 break; 4342 case OPCODE_CONVOLUTION_FILTER_1D: 4343 { 4344 struct gl_pixelstore_attrib save = ctx->Unpack; 4345 ctx->Unpack = _mesa_native_packing; 4346 (*ctx->Exec->ConvolutionFilter1D)( n[1].e, n[2].i, n[3].i, 4347 n[4].e, n[5].e, n[6].data ); 4348 ctx->Unpack = save; /* restore */ 4349 } 4350 break; 4351 case OPCODE_CONVOLUTION_FILTER_2D: 4352 { 4353 struct gl_pixelstore_attrib save = ctx->Unpack; 4354 ctx->Unpack = _mesa_native_packing; 4355 (*ctx->Exec->ConvolutionFilter2D)( n[1].e, n[2].i, n[3].i, 4356 n[4].i, n[5].e, n[6].e, n[7].data ); 4357 ctx->Unpack = save; /* restore */ 4358 } 4359 break; 4360 case OPCODE_CONVOLUTION_PARAMETER_I: 4361 (*ctx->Exec->ConvolutionParameteri)( n[1].e, n[2].e, n[3].i ); 4362 break; 4363 case OPCODE_CONVOLUTION_PARAMETER_IV: 4364 { 4365 GLint params[4]; 4366 params[0] = n[3].i; 4367 params[1] = n[4].i; 4368 params[2] = n[5].i; 4369 params[3] = n[6].i; 4370 (*ctx->Exec->ConvolutionParameteriv)( n[1].e, n[2].e, params ); 4371 } 4372 break; 4373 case OPCODE_CONVOLUTION_PARAMETER_F: 4374 (*ctx->Exec->ConvolutionParameterf)( n[1].e, n[2].e, n[3].f ); 4375 break; 4376 case OPCODE_CONVOLUTION_PARAMETER_FV: 4377 { 4378 GLfloat params[4]; 4379 params[0] = n[3].f; 4380 params[1] = n[4].f; 4381 params[2] = n[5].f; 4382 params[3] = n[6].f; 4383 (*ctx->Exec->ConvolutionParameterfv)( n[1].e, n[2].e, params ); 4384 } 4385 break; 4386 case OPCODE_COPY_COLOR_SUB_TABLE: 4387 (*ctx->Exec->CopyColorSubTable)( n[1].e, n[2].i, 4388 n[3].i, n[4].i, n[5].i ); 4389 break; 4390 case OPCODE_COPY_COLOR_TABLE: 4391 (*ctx->Exec->CopyColorSubTable)( n[1].e, n[2].i, 4392 n[3].i, n[4].i, n[5].i ); 4393 break; 4394 case OPCODE_COPY_PIXELS: 4395 (*ctx->Exec->CopyPixels)( n[1].i, n[2].i, 4396 (GLsizei) n[3].i, (GLsizei) n[4].i, n[5].e ); 4397 break; 4398 case OPCODE_COPY_TEX_IMAGE1D: 4399 (*ctx->Exec->CopyTexImage1D)( n[1].e, n[2].i, n[3].e, n[4].i, 4400 n[5].i, n[6].i, n[7].i ); 4401 break; 4402 case OPCODE_COPY_TEX_IMAGE2D: 4403 (*ctx->Exec->CopyTexImage2D)( n[1].e, n[2].i, n[3].e, n[4].i, 4404 n[5].i, n[6].i, n[7].i, n[8].i ); 4405 break; 4406 case OPCODE_COPY_TEX_SUB_IMAGE1D: 4407 (*ctx->Exec->CopyTexSubImage1D)( n[1].e, n[2].i, n[3].i, 4408 n[4].i, n[5].i, n[6].i ); 4409 break; 4410 case OPCODE_COPY_TEX_SUB_IMAGE2D: 4411 (*ctx->Exec->CopyTexSubImage2D)( n[1].e, n[2].i, n[3].i, 4412 n[4].i, n[5].i, n[6].i, n[7].i, n[8].i ); 4413 break; 4414 case OPCODE_COPY_TEX_SUB_IMAGE3D: 4415 (*ctx->Exec->CopyTexSubImage3D)( n[1].e, n[2].i, n[3].i, 4416 n[4].i, n[5].i, n[6].i, n[7].i, n[8].i , n[9].i); 4417 break; 4418 case OPCODE_CULL_FACE: 4419 (*ctx->Exec->CullFace)( n[1].e ); 4420 break; 4421 case OPCODE_DEPTH_FUNC: 4422 (*ctx->Exec->DepthFunc)( n[1].e ); 4423 break; 4424 case OPCODE_DEPTH_MASK: 4425 (*ctx->Exec->DepthMask)( n[1].b ); 4426 break; 4427 case OPCODE_DEPTH_RANGE: 4428 (*ctx->Exec->DepthRange)( (GLclampd) n[1].f, (GLclampd) n[2].f ); 4429 break; 4430 case OPCODE_DISABLE: 4431 (*ctx->Exec->Disable)( n[1].e ); 4432 break; 4433 case OPCODE_DRAW_BUFFER: 4434 (*ctx->Exec->DrawBuffer)( n[1].e ); 4435 break; 4436 case OPCODE_DRAW_PIXELS: 4437 { 4438 struct gl_pixelstore_attrib save = ctx->Unpack; 4439 ctx->Unpack = _mesa_native_packing; 4440 (*ctx->Exec->DrawPixels)( n[1].i, n[2].i, n[3].e, n[4].e, 4441 n[5].data ); 4442 ctx->Unpack = save; /* restore */ 4443 } 4444 break; 4445 case OPCODE_ENABLE: 4446 (*ctx->Exec->Enable)( n[1].e ); 4447 break; 4448 case OPCODE_EVALMESH1: 4449 (*ctx->Exec->EvalMesh1)( n[1].e, n[2].i, n[3].i ); 4450 break; 4451 case OPCODE_EVALMESH2: 4452 (*ctx->Exec->EvalMesh2)( n[1].e, n[2].i, n[3].i, n[4].i, n[5].i ); 4453 break; 4454 case OPCODE_FOG: 4455 { 4456 GLfloat p[4]; 4457 p[0] = n[2].f; 4458 p[1] = n[3].f; 4459 p[2] = n[4].f; 4460 p[3] = n[5].f; 4461 (*ctx->Exec->Fogfv)( n[1].e, p ); 4462 } 4463 break; 4464 case OPCODE_FRONT_FACE: 4465 (*ctx->Exec->FrontFace)( n[1].e ); 4466 break; 4467 case OPCODE_FRUSTUM: 4468 (*ctx->Exec->Frustum)( n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f ); 4469 break; 4470 case OPCODE_HINT: 4471 (*ctx->Exec->Hint)( n[1].e, n[2].e ); 4472 break; 4473 case OPCODE_HISTOGRAM: 4474 (*ctx->Exec->Histogram)( n[1].e, n[2].i, n[3].e, n[4].b ); 4475 break; 4476 case OPCODE_INDEX_MASK: 4477 (*ctx->Exec->IndexMask)( n[1].ui ); 4478 break; 4479 case OPCODE_INIT_NAMES: 4480 (*ctx->Exec->InitNames)(); 4481 break; 4482 case OPCODE_LIGHT: 4483 { 4484 GLfloat p[4]; 4485 p[0] = n[3].f; 4486 p[1] = n[4].f; 4487 p[2] = n[5].f; 4488 p[3] = n[6].f; 4489 (*ctx->Exec->Lightfv)( n[1].e, n[2].e, p ); 4490 } 4491 break; 4492 case OPCODE_LIGHT_MODEL: 4493 { 4494 GLfloat p[4]; 4495 p[0] = n[2].f; 4496 p[1] = n[3].f; 4497 p[2] = n[4].f; 4498 p[3] = n[5].f; 4499 (*ctx->Exec->LightModelfv)( n[1].e, p ); 4500 } 4501 break; 4502 case OPCODE_LINE_STIPPLE: 4503 (*ctx->Exec->LineStipple)( n[1].i, n[2].us ); 4504 break; 4505 case OPCODE_LINE_WIDTH: 4506 (*ctx->Exec->LineWidth)( n[1].f ); 4507 break; 4508 case OPCODE_LIST_BASE: 4509 (*ctx->Exec->ListBase)( n[1].ui ); 4510 break; 4511 case OPCODE_LOAD_IDENTITY: 4512 (*ctx->Exec->LoadIdentity)(); 4513 break; 4514 case OPCODE_LOAD_MATRIX: 4515 if (sizeof(Node)==sizeof(GLfloat)) { 4516 (*ctx->Exec->LoadMatrixf)( &n[1].f ); 4517 } 4518 else { 4519 GLfloat m[16]; 4520 GLuint i; 4521 for (i=0;i<16;i++) { 4522 m[i] = n[1+i].f; 4523 } 4524 (*ctx->Exec->LoadMatrixf)( m ); 4525 } 4526 break; 4527 case OPCODE_LOAD_NAME: 4528 (*ctx->Exec->LoadName)( n[1].ui ); 4529 break; 4530 case OPCODE_LOGIC_OP: 4531 (*ctx->Exec->LogicOp)( n[1].e ); 4532 break; 4533 case OPCODE_MAP1: 4534 { 4535 GLenum target = n[1].e; 4536 GLint ustride = _mesa_evaluator_components(target); 4537 GLint uorder = n[5].i; 4538 GLfloat u1 = n[2].f; 4539 GLfloat u2 = n[3].f; 4540 (*ctx->Exec->Map1f)( target, u1, u2, ustride, uorder, 4541 (GLfloat *) n[6].data ); 4542 } 4543 break; 4544 case OPCODE_MAP2: 4545 { 4546 GLenum target = n[1].e; 4547 GLfloat u1 = n[2].f; 4548 GLfloat u2 = n[3].f; 4549 GLfloat v1 = n[4].f; 4550 GLfloat v2 = n[5].f; 4551 GLint ustride = n[6].i; 4552 GLint vstride = n[7].i; 4553 GLint uorder = n[8].i; 4554 GLint vorder = n[9].i; 4555 (*ctx->Exec->Map2f)( target, u1, u2, ustride, uorder, 4556 v1, v2, vstride, vorder, 4557 (GLfloat *) n[10].data ); 4558 } 4559 break; 4560 case OPCODE_MAPGRID1: 4561 (*ctx->Exec->MapGrid1f)( n[1].i, n[2].f, n[3].f ); 4562 break; 4563 case OPCODE_MAPGRID2: 4564 (*ctx->Exec->MapGrid2f)( n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f); 4565 break; 4566 case OPCODE_MATRIX_MODE: 4567 (*ctx->Exec->MatrixMode)( n[1].e ); 4568 break; 4569 case OPCODE_MIN_MAX: 4570 (*ctx->Exec->Minmax)(n[1].e, n[2].e, n[3].b); 4571 break; 4572 case OPCODE_MULT_MATRIX: 4573 if (sizeof(Node)==sizeof(GLfloat)) { 4574 (*ctx->Exec->MultMatrixf)( &n[1].f ); 4575 } 4576 else { 4577 GLfloat m[16]; 4578 GLuint i; 4579 for (i=0;i<16;i++) { 4580 m[i] = n[1+i].f; 4581 } 4582 (*ctx->Exec->MultMatrixf)( m ); 4583 } 4584 break; 4585 case OPCODE_ORTHO: 4586 (*ctx->Exec->Ortho)( n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f ); 4587 break; 4588 case OPCODE_PASSTHROUGH: 4589 (*ctx->Exec->PassThrough)( n[1].f ); 4590 break; 4591 case OPCODE_PIXEL_MAP: 4592 (*ctx->Exec->PixelMapfv)( n[1].e, n[2].i, (GLfloat *) n[3].data ); 4593 break; 4594 case OPCODE_PIXEL_TRANSFER: 4595 (*ctx->Exec->PixelTransferf)( n[1].e, n[2].f ); 4596 break; 4597 case OPCODE_PIXEL_ZOOM: 4598 (*ctx->Exec->PixelZoom)( n[1].f, n[2].f ); 4599 break; 4600 case OPCODE_POINT_SIZE: 4601 (*ctx->Exec->PointSize)( n[1].f ); 4602 break; 4603 case OPCODE_POINT_PARAMETERS: 4604 { 4605 GLfloat params[3]; 4606 params[0] = n[2].f; 4607 params[1] = n[3].f; 4608 params[2] = n[4].f; 4609 (*ctx->Exec->PointParameterfvEXT)( n[1].e, params ); 4610 } 4611 break; 4612 case OPCODE_POLYGON_MODE: 4613 (*ctx->Exec->PolygonMode)( n[1].e, n[2].e ); 4614 break; 4615 case OPCODE_POLYGON_STIPPLE: 4616 (*ctx->Exec->PolygonStipple)( (GLubyte *) n[1].data ); 4617 break; 4618 case OPCODE_POLYGON_OFFSET: 4619 (*ctx->Exec->PolygonOffset)( n[1].f, n[2].f ); 4620 break; 4621 case OPCODE_POP_ATTRIB: 4622 (*ctx->Exec->PopAttrib)(); 4623 break; 4624 case OPCODE_POP_MATRIX: 4625 (*ctx->Exec->PopMatrix)(); 4626 break; 4627 case OPCODE_POP_NAME: 4628 (*ctx->Exec->PopName)(); 4629 break; 4630 case OPCODE_PRIORITIZE_TEXTURE: 4631 (*ctx->Exec->PrioritizeTextures)( 1, &n[1].ui, &n[2].f ); 4632 break; 4633 case OPCODE_PUSH_ATTRIB: 4634 (*ctx->Exec->PushAttrib)( n[1].bf ); 4635 break; 4636 case OPCODE_PUSH_MATRIX: 4637 (*ctx->Exec->PushMatrix)(); 4638 break; 4639 case OPCODE_PUSH_NAME: 4640 (*ctx->Exec->PushName)( n[1].ui ); 4641 break; 4642 case OPCODE_RASTER_POS: 4643 (*ctx->Exec->RasterPos4f)( n[1].f, n[2].f, n[3].f, n[4].f ); 4644 break; 4645 case OPCODE_READ_BUFFER: 4646 (*ctx->Exec->ReadBuffer)( n[1].e ); 4647 break; 4648 case OPCODE_RESET_HISTOGRAM: 4649 (*ctx->Exec->ResetHistogram)( n[1].e ); 4650 break; 4651 case OPCODE_RESET_MIN_MAX: 4652 (*ctx->Exec->ResetMinmax)( n[1].e ); 4653 break; 4654 case OPCODE_ROTATE: 4655 (*ctx->Exec->Rotatef)( n[1].f, n[2].f, n[3].f, n[4].f ); 4656 break; 4657 case OPCODE_SCALE: 4658 (*ctx->Exec->Scalef)( n[1].f, n[2].f, n[3].f ); 4659 break; 4660 case OPCODE_SCISSOR: 4661 (*ctx->Exec->Scissor)( n[1].i, n[2].i, n[3].i, n[4].i ); 4662 break; 4663 case OPCODE_SHADE_MODEL: 4664 (*ctx->Exec->ShadeModel)( n[1].e ); 4665 break; 4666 case OPCODE_STENCIL_FUNC: 4667 (*ctx->Exec->StencilFunc)( n[1].e, n[2].i, n[3].ui ); 4668 break; 4669 case OPCODE_STENCIL_MASK: 4670 (*ctx->Exec->StencilMask)( n[1].ui ); 4671 break; 4672 case OPCODE_STENCIL_OP: 4673 (*ctx->Exec->StencilOp)( n[1].e, n[2].e, n[3].e ); 4674 break; 4675 case OPCODE_TEXENV: 4676 { 4677 GLfloat params[4]; 4678 params[0] = n[3].f; 4679 params[1] = n[4].f; 4680 params[2] = n[5].f; 4681 params[3] = n[6].f; 4682 (*ctx->Exec->TexEnvfv)( n[1].e, n[2].e, params ); 4683 } 4684 break; 4685 case OPCODE_TEXGEN: 4686 { 4687 GLfloat params[4]; 4688 params[0] = n[3].f; 4689 params[1] = n[4].f; 4690 params[2] = n[5].f; 4691 params[3] = n[6].f; 4692 (*ctx->Exec->TexGenfv)( n[1].e, n[2].e, params ); 4693 } 4694 break; 4695 case OPCODE_TEXPARAMETER: 4696 { 4697 GLfloat params[4]; 4698 params[0] = n[3].f; 4699 params[1] = n[4].f; 4700 params[2] = n[5].f; 4701 params[3] = n[6].f; 4702 (*ctx->Exec->TexParameterfv)( n[1].e, n[2].e, params ); 4703 } 4704 break; 4705 case OPCODE_TEX_IMAGE1D: 4706 { 4707 struct gl_pixelstore_attrib save = ctx->Unpack; 4708 ctx->Unpack = _mesa_native_packing; 4709 (*ctx->Exec->TexImage1D)( 4710 n[1].e, /* target */ 4711 n[2].i, /* level */ 4712 n[3].i, /* components */ 4713 n[4].i, /* width */ 4714 n[5].e, /* border */ 4715 n[6].e, /* format */ 4716 n[7].e, /* type */ 4717 n[8].data ); 4718 ctx->Unpack = save; /* restore */ 4719 } 4720 break; 4721 case OPCODE_TEX_IMAGE2D: 4722 { 4723 struct gl_pixelstore_attrib save = ctx->Unpack; 4724 ctx->Unpack = _mesa_native_packing; 4725 (*ctx->Exec->TexImage2D)( 4726 n[1].e, /* target */ 4727 n[2].i, /* level */ 4728 n[3].i, /* components */ 4729 n[4].i, /* width */ 4730 n[5].i, /* height */ 4731 n[6].e, /* border */ 4732 n[7].e, /* format */ 4733 n[8].e, /* type */ 4734 n[9].data ); 4735 ctx->Unpack = save; /* restore */ 4736 } 4737 break; 4738 case OPCODE_TEX_IMAGE3D: 4739 { 4740 struct gl_pixelstore_attrib save = ctx->Unpack; 4741 ctx->Unpack = _mesa_native_packing; 4742 (*ctx->Exec->TexImage3D)( 4743 n[1].e, /* target */ 4744 n[2].i, /* level */ 4745 n[3].i, /* components */ 4746 n[4].i, /* width */ 4747 n[5].i, /* height */ 4748 n[6].i, /* depth */ 4749 n[7].e, /* border */ 4750 n[8].e, /* format */ 4751 n[9].e, /* type */ 4752 n[10].data ); 4753 ctx->Unpack = save; /* restore */ 4754 } 4755 break; 4756 case OPCODE_TEX_SUB_IMAGE1D: 4757 { 4758 struct gl_pixelstore_attrib save = ctx->Unpack; 4759 ctx->Unpack = _mesa_native_packing; 4760 (*ctx->Exec->TexSubImage1D)( n[1].e, n[2].i, n[3].i, 4761 n[4].i, n[5].e, 4762 n[6].e, n[7].data ); 4763 ctx->Unpack = save; /* restore */ 4764 } 4765 break; 4766 case OPCODE_TEX_SUB_IMAGE2D: 4767 { 4768 struct gl_pixelstore_attrib save = ctx->Unpack; 4769 ctx->Unpack = _mesa_native_packing; 4770 (*ctx->Exec->TexSubImage2D)( n[1].e, n[2].i, n[3].i, 4771 n[4].i, n[5].e, 4772 n[6].i, n[7].e, n[8].e, n[9].data ); 4773 ctx->Unpack = save; /* restore */ 4774 } 4775 break; 4776 case OPCODE_TEX_SUB_IMAGE3D: 4777 { 4778 struct gl_pixelstore_attrib save = ctx->Unpack; 4779 ctx->Unpack = _mesa_native_packing; 4780 (*ctx->Exec->TexSubImage3D)( n[1].e, n[2].i, n[3].i, 4781 n[4].i, n[5].i, n[6].i, n[7].i, 4782 n[8].i, n[9].e, n[10].e, 4783 n[11].data ); 4784 ctx->Unpack = save; /* restore */ 4785 } 4786 break; 4787 case OPCODE_TRANSLATE: 4788 (*ctx->Exec->Translatef)( n[1].f, n[2].f, n[3].f ); 4789 break; 4790 case OPCODE_VIEWPORT: 4791 (*ctx->Exec->Viewport)(n[1].i, n[2].i, 4792 (GLsizei) n[3].i, (GLsizei) n[4].i); 4793 break; 4794 case OPCODE_WINDOW_POS: 4795 (*ctx->Exec->WindowPos4fMESA)( n[1].f, n[2].f, n[3].f, n[4].f ); 4796 break; 4797 case OPCODE_ACTIVE_TEXTURE: /* GL_ARB_multitexture */ 4798 (*ctx->Exec->ActiveTextureARB)( n[1].e ); 4799 break; 4800 case OPCODE_PIXEL_TEXGEN_SGIX: /* GL_SGIX_pixel_texture */ 4801 (*ctx->Exec->PixelTexGenSGIX)( n[1].e ); 4802 break; 4803 case OPCODE_PIXEL_TEXGEN_PARAMETER_SGIS: /* GL_SGIS_pixel_texture */ 4804 (*ctx->Exec->PixelTexGenParameteriSGIS)( n[1].e, n[2].i ); 4805 break; 4806 case OPCODE_COMPRESSED_TEX_IMAGE_1D: /* GL_ARB_texture_compression */ 4807 (*ctx->Exec->CompressedTexImage1DARB)(n[1].e, n[2].i, n[3].e, 4808 n[4].i, n[5].i, n[6].i, n[7].data); 4809 break; 4810 case OPCODE_COMPRESSED_TEX_IMAGE_2D: /* GL_ARB_texture_compression */ 4811 (*ctx->Exec->CompressedTexImage2DARB)(n[1].e, n[2].i, n[3].e, 4812 n[4].i, n[5].i, n[6].i, n[7].i, n[8].data); 4813 break; 4814 case OPCODE_COMPRESSED_TEX_IMAGE_3D: /* GL_ARB_texture_compression */ 4815 (*ctx->Exec->CompressedTexImage3DARB)(n[1].e, n[2].i, n[3].e, 4816 n[4].i, n[5].i, n[6].i, n[7].i, n[8].i, n[9].data); 4817 break; 4818 case OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D: /* GL_ARB_texture_compress */ 4819 (*ctx->Exec->CompressedTexSubImage1DARB)(n[1].e, n[2].i, n[3].i, 4820 n[4].i, n[5].e, n[6].i, n[7].data); 4821 break; 4822 case OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D: /* GL_ARB_texture_compress */ 4823 (*ctx->Exec->CompressedTexSubImage2DARB)(n[1].e, n[2].i, n[3].i, 4824 n[4].i, n[5].i, n[6].i, n[7].e, n[8].i, n[9].data); 4825 break; 4826 case OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D: /* GL_ARB_texture_compress */ 4827 (*ctx->Exec->CompressedTexSubImage3DARB)(n[1].e, n[2].i, n[3].i, 4828 n[4].i, n[5].i, n[6].i, n[7].i, n[8].i, 4829 n[9].e, n[10].i, n[11].data); 4830 break; 4831 case OPCODE_SAMPLE_COVERAGE: /* GL_ARB_multisample */ 4832 (*ctx->Exec->SampleCoverageARB)(n[1].f, n[2].b); 4833 break; 4834 case OPCODE_WINDOW_POS_ARB: /* GL_ARB_window_pos */ 4835 (*ctx->Exec->WindowPos3fMESA)( n[1].f, n[2].f, n[3].f ); 4836 break; 4837 case OPCODE_BIND_PROGRAM_NV: /* GL_NV_vertex_program */ 4838 (*ctx->Exec->BindProgramNV)( n[1].e, n[2].ui ); 4839 break; 4840 case OPCODE_EXECUTE_PROGRAM_NV: 4841 { 4842 GLfloat v[4]; 4843 v[0] = n[3].f; 4844 v[1] = n[4].f; 4845 v[2] = n[5].f; 4846 v[3] = n[6].f; 4847 (*ctx->Exec->ExecuteProgramNV)(n[1].e, n[2].ui, v); 4848 } 4849 break; 4850 case OPCODE_REQUEST_PROGRAMS_RESIDENT_NV: 4851 /* 4852 (*ctx->Exec->RequestResidentProgramsNV)(); 4853 */ 4854 break; 4855 case OPCODE_LOAD_PROGRAM_NV: 4856 /* 4857 (*ctx->Exec->LoadProgramNV)(); 4858 */ 4859 break; 4860 case OPCODE_PROGRAM_PARAMETER4F_NV: 4861 (*ctx->Exec->ProgramParameter4fNV)(n[1].e, n[2].ui, n[3].f, 4862 n[4].f, n[5].f, n[6].f); 4863 break; 4864 case OPCODE_TRACK_MATRIX_NV: 4865 (*ctx->Exec->TrackMatrixNV)(n[1].e, n[2].ui, n[3].e, n[4].e); 4866 break; 4867 4868 case OPCODE_CONTINUE: 4869 n = (Node *) n[1].next; 4870 break; 4871 case OPCODE_END_OF_LIST: 4872 done = GL_TRUE; 4873 break; 4874 default: 4875 { 4876 char msg[1000]; 4877 _mesa_sprintf(msg, "Error in execute_list: opcode=%d", (int) opcode); 4878 _mesa_problem(ctx, msg); 4879 } 4880 done = GL_TRUE; 4881 } 4882 4883 /* increment n to point to next compiled command */ 4884 if (opcode!=OPCODE_CONTINUE) { 4885 n += InstSize[opcode]; 4886 } 4887 } 4888 } 4889 ctx->CallDepth--; 4890 4891 if (ctx->Driver.EndCallList) 4892 ctx->Driver.EndCallList( ctx ); 4893} 4894 4895 4896 4897 4898 4899/**********************************************************************/ 4900/* GL functions */ 4901/**********************************************************************/ 4902 4903 4904 4905 4906/* 4907 * Test if a display list number is valid. 4908 */ 4909GLboolean 4910_mesa_IsList( GLuint list ) 4911{ 4912 GET_CURRENT_CONTEXT(ctx); 4913 FLUSH_VERTICES(ctx, 0); /* must be called before assert */ 4914 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE); 4915 return islist(ctx, list); 4916} 4917 4918 4919/* 4920 * Delete a sequence of consecutive display lists. 4921 */ 4922void 4923_mesa_DeleteLists( GLuint list, GLsizei range ) 4924{ 4925 GET_CURRENT_CONTEXT(ctx); 4926 GLuint i; 4927 FLUSH_VERTICES(ctx, 0); /* must be called before assert */ 4928 ASSERT_OUTSIDE_BEGIN_END(ctx); 4929 4930 if (range<0) { 4931 _mesa_error( ctx, GL_INVALID_VALUE, "glDeleteLists" ); 4932 return; 4933 } 4934 for (i=list;i<list+range;i++) { 4935 _mesa_destroy_list( ctx, i ); 4936 } 4937} 4938 4939 4940 4941/* 4942 * Return a display list number, n, such that lists n through n+range-1 4943 * are free. 4944 */ 4945GLuint 4946_mesa_GenLists(GLsizei range ) 4947{ 4948 GET_CURRENT_CONTEXT(ctx); 4949 GLuint base; 4950 FLUSH_VERTICES(ctx, 0); /* must be called before assert */ 4951 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0); 4952 4953 if (range<0) { 4954 _mesa_error( ctx, GL_INVALID_VALUE, "glGenLists" ); 4955 return 0; 4956 } 4957 if (range==0) { 4958 return 0; 4959 } 4960 4961 /* 4962 * Make this an atomic operation 4963 */ 4964 _glthread_LOCK_MUTEX(ctx->Shared->Mutex); 4965 4966 base = _mesa_HashFindFreeKeyBlock(ctx->Shared->DisplayList, range); 4967 if (base) { 4968 /* reserve the list IDs by with empty/dummy lists */ 4969 GLint i; 4970 for (i=0; i<range; i++) { 4971 _mesa_HashInsert(ctx->Shared->DisplayList, base+i, make_empty_list()); 4972 } 4973 } 4974 4975 _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex); 4976 4977 return base; 4978} 4979 4980 4981 4982/* 4983 * Begin a new display list. 4984 */ 4985void 4986_mesa_NewList( GLuint list, GLenum mode ) 4987{ 4988 GET_CURRENT_CONTEXT(ctx); 4989 FLUSH_CURRENT(ctx, 0); /* must be called before assert */ 4990 ASSERT_OUTSIDE_BEGIN_END(ctx); 4991 4992 if (MESA_VERBOSE&VERBOSE_API) 4993 _mesa_debug(ctx, "glNewList %u %s\n", list, 4994 _mesa_lookup_enum_by_nr(mode)); 4995 4996 if (list==0) { 4997 _mesa_error( ctx, GL_INVALID_VALUE, "glNewList" ); 4998 return; 4999 } 5000 5001 if (mode!=GL_COMPILE && mode!=GL_COMPILE_AND_EXECUTE) { 5002 _mesa_error( ctx, GL_INVALID_ENUM, "glNewList" ); 5003 return; 5004 } 5005 5006 if (ctx->CurrentListPtr) { 5007 /* already compiling a display list */ 5008 _mesa_error( ctx, GL_INVALID_OPERATION, "glNewList" ); 5009 return; 5010 } 5011 5012 /* Allocate new display list */ 5013 ctx->CurrentListNum = list; 5014 ctx->CurrentBlock = (Node *) MALLOC( sizeof(Node) * BLOCK_SIZE ); 5015 ctx->CurrentListPtr = ctx->CurrentBlock; 5016 ctx->CurrentPos = 0; 5017 ctx->CompileFlag = GL_TRUE; 5018 ctx->ExecuteFlag = (mode == GL_COMPILE_AND_EXECUTE); 5019 5020 ctx->Driver.NewList( ctx, list, mode ); 5021 5022 ctx->CurrentDispatch = ctx->Save; 5023 _glapi_set_dispatch( ctx->CurrentDispatch ); 5024} 5025 5026 5027 5028/* 5029 * End definition of current display list. Is the current 5030 * ASSERT_OUTSIDE_BEGIN_END strong enough to really guarentee that 5031 * we are outside begin/end calls? 5032 */ 5033void 5034_mesa_EndList( void ) 5035{ 5036 GET_CURRENT_CONTEXT(ctx); 5037 FLUSH_CURRENT(ctx, 0); /* must be called before assert */ 5038 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 5039 5040 if (MESA_VERBOSE&VERBOSE_API) 5041 _mesa_debug(ctx, "glEndList\n"); 5042 5043 /* Check that a list is under construction */ 5044 if (!ctx->CurrentListPtr) { 5045 _mesa_error( ctx, GL_INVALID_OPERATION, "glEndList" ); 5046 return; 5047 } 5048 5049 (void) ALLOC_INSTRUCTION( ctx, OPCODE_END_OF_LIST, 0 ); 5050 5051 /* Destroy old list, if any */ 5052 _mesa_destroy_list(ctx, ctx->CurrentListNum); 5053 /* Install the list */ 5054 _mesa_HashInsert(ctx->Shared->DisplayList, ctx->CurrentListNum, ctx->CurrentListPtr); 5055 5056 5057 if (MESA_VERBOSE & VERBOSE_DISPLAY_LIST) 5058 mesa_print_display_list(ctx->CurrentListNum); 5059 5060 ctx->CurrentListNum = 0; 5061 ctx->CurrentListPtr = NULL; 5062 ctx->ExecuteFlag = GL_TRUE; 5063 ctx->CompileFlag = GL_FALSE; 5064 5065 ctx->Driver.EndList( ctx ); 5066 5067 ctx->CurrentDispatch = ctx->Exec; 5068 _glapi_set_dispatch( ctx->CurrentDispatch ); 5069} 5070 5071 5072 5073void 5074_mesa_CallList( GLuint list ) 5075{ 5076 GLboolean save_compile_flag; 5077 GET_CURRENT_CONTEXT(ctx); 5078 FLUSH_CURRENT(ctx, 0); 5079 /* VERY IMPORTANT: Save the CompileFlag status, turn it off, */ 5080 /* execute the display list, and restore the CompileFlag. */ 5081 5082 5083 if (MESA_VERBOSE & VERBOSE_API) 5084 _mesa_debug(ctx, "_mesa_CallList %d\n", list); 5085 5086/* mesa_print_display_list( list ); */ 5087 5088 save_compile_flag = ctx->CompileFlag; 5089 if (save_compile_flag) { 5090 ctx->CompileFlag = GL_FALSE; 5091 } 5092 5093 execute_list( ctx, list ); 5094 ctx->CompileFlag = save_compile_flag; 5095 5096 /* also restore API function pointers to point to "save" versions */ 5097 if (save_compile_flag) { 5098 ctx->CurrentDispatch = ctx->Save; 5099 _glapi_set_dispatch( ctx->CurrentDispatch ); 5100 } 5101} 5102 5103 5104 5105/* 5106 * Execute glCallLists: call multiple display lists. 5107 */ 5108void 5109_mesa_CallLists( GLsizei n, GLenum type, const GLvoid *lists ) 5110{ 5111 GET_CURRENT_CONTEXT(ctx); 5112 GLuint list; 5113 GLint i; 5114 GLboolean save_compile_flag; 5115 5116 if (MESA_VERBOSE & VERBOSE_API) 5117 _mesa_debug(ctx, "_mesa_CallLists %d\n", n); 5118 5119 switch (type) { 5120 case GL_BYTE: 5121 case GL_UNSIGNED_BYTE: 5122 case GL_SHORT: 5123 case GL_UNSIGNED_SHORT: 5124 case GL_INT: 5125 case GL_UNSIGNED_INT: 5126 case GL_FLOAT: 5127 case GL_2_BYTES: 5128 case GL_3_BYTES: 5129 case GL_4_BYTES: 5130 /* OK */ 5131 break; 5132 default: 5133 _mesa_error(ctx, GL_INVALID_ENUM, "glCallLists(type)"); 5134 return; 5135 } 5136 5137 /* Save the CompileFlag status, turn it off, execute display list, 5138 * and restore the CompileFlag. 5139 */ 5140 save_compile_flag = ctx->CompileFlag; 5141 ctx->CompileFlag = GL_FALSE; 5142 5143 for (i=0;i<n;i++) { 5144 list = translate_id( i, type, lists ); 5145 execute_list( ctx, ctx->List.ListBase + list ); 5146 } 5147 5148 ctx->CompileFlag = save_compile_flag; 5149 5150 /* also restore API function pointers to point to "save" versions */ 5151 if (save_compile_flag) { 5152 ctx->CurrentDispatch = ctx->Save; 5153 _glapi_set_dispatch( ctx->CurrentDispatch ); 5154 } 5155} 5156 5157 5158 5159/* 5160 * Set the offset added to list numbers in glCallLists. 5161 */ 5162void 5163_mesa_ListBase( GLuint base ) 5164{ 5165 GET_CURRENT_CONTEXT(ctx); 5166 FLUSH_VERTICES(ctx, 0); /* must be called before assert */ 5167 ASSERT_OUTSIDE_BEGIN_END(ctx); 5168 ctx->List.ListBase = base; 5169} 5170 5171 5172/* Can no longer assume ctx->Exec->Func is equal to _mesa_Func. 5173 */ 5174static void exec_Finish( void ) 5175{ 5176 GET_CURRENT_CONTEXT(ctx); 5177 FLUSH_VERTICES(ctx, 0); 5178 ctx->Exec->Finish(); 5179} 5180 5181static void exec_Flush( void ) 5182{ 5183 GET_CURRENT_CONTEXT(ctx); 5184 FLUSH_VERTICES(ctx, 0); 5185 ctx->Exec->Flush( ); 5186} 5187 5188static void exec_GetBooleanv( GLenum pname, GLboolean *params ) 5189{ 5190 GET_CURRENT_CONTEXT(ctx); 5191 FLUSH_VERTICES(ctx, 0); 5192 ctx->Exec->GetBooleanv( pname, params ); 5193} 5194 5195static void exec_GetClipPlane( GLenum plane, GLdouble *equation ) 5196{ 5197 GET_CURRENT_CONTEXT(ctx); 5198 FLUSH_VERTICES(ctx, 0); 5199 ctx->Exec->GetClipPlane( plane, equation ); 5200} 5201 5202static void exec_GetDoublev( GLenum pname, GLdouble *params ) 5203{ 5204 GET_CURRENT_CONTEXT(ctx); 5205 FLUSH_VERTICES(ctx, 0); 5206 ctx->Exec->GetDoublev( pname, params ); 5207} 5208 5209static GLenum exec_GetError( void ) 5210{ 5211 GET_CURRENT_CONTEXT(ctx); 5212 FLUSH_VERTICES(ctx, 0); 5213 return ctx->Exec->GetError( ); 5214} 5215 5216static void exec_GetFloatv( GLenum pname, GLfloat *params ) 5217{ 5218 GET_CURRENT_CONTEXT(ctx); 5219 FLUSH_VERTICES(ctx, 0); 5220 ctx->Exec->GetFloatv( pname, params ); 5221} 5222 5223static void exec_GetIntegerv( GLenum pname, GLint *params ) 5224{ 5225 GET_CURRENT_CONTEXT(ctx); 5226 FLUSH_VERTICES(ctx, 0); 5227 ctx->Exec->GetIntegerv( pname, params ); 5228} 5229 5230static void exec_GetLightfv( GLenum light, GLenum pname, GLfloat *params ) 5231{ 5232 GET_CURRENT_CONTEXT(ctx); 5233 FLUSH_VERTICES(ctx, 0); 5234 ctx->Exec->GetLightfv( light, pname, params ); 5235} 5236 5237static void exec_GetLightiv( GLenum light, GLenum pname, GLint *params ) 5238{ 5239 GET_CURRENT_CONTEXT(ctx); 5240 FLUSH_VERTICES(ctx, 0); 5241 ctx->Exec->GetLightiv( light, pname, params ); 5242} 5243 5244static void exec_GetMapdv( GLenum target, GLenum query, GLdouble *v ) 5245{ 5246 GET_CURRENT_CONTEXT(ctx); 5247 FLUSH_VERTICES(ctx, 0); 5248 ctx->Exec->GetMapdv( target, query, v ); 5249} 5250 5251static void exec_GetMapfv( GLenum target, GLenum query, GLfloat *v ) 5252{ 5253 GET_CURRENT_CONTEXT(ctx); 5254 FLUSH_VERTICES(ctx, 0); 5255 ctx->Exec->GetMapfv( target, query, v ); 5256} 5257 5258static void exec_GetMapiv( GLenum target, GLenum query, GLint *v ) 5259{ 5260 GET_CURRENT_CONTEXT(ctx); 5261 FLUSH_VERTICES(ctx, 0); 5262 ctx->Exec->GetMapiv( target, query, v ); 5263} 5264 5265static void exec_GetMaterialfv( GLenum face, GLenum pname, GLfloat *params ) 5266{ 5267 GET_CURRENT_CONTEXT(ctx); 5268 FLUSH_VERTICES(ctx, 0); 5269 ctx->Exec->GetMaterialfv( face, pname, params ); 5270} 5271 5272static void exec_GetMaterialiv( GLenum face, GLenum pname, GLint *params ) 5273{ 5274 GET_CURRENT_CONTEXT(ctx); 5275 FLUSH_VERTICES(ctx, 0); 5276 ctx->Exec->GetMaterialiv( face, pname, params ); 5277} 5278 5279static void exec_GetPixelMapfv( GLenum map, GLfloat *values ) 5280{ 5281 GET_CURRENT_CONTEXT(ctx); 5282 FLUSH_VERTICES(ctx, 0); 5283 ctx->Exec->GetPixelMapfv( map, values ); 5284} 5285 5286static void exec_GetPixelMapuiv( GLenum map, GLuint *values ) 5287{ 5288 GET_CURRENT_CONTEXT(ctx); 5289 FLUSH_VERTICES(ctx, 0); 5290 ctx->Exec->GetPixelMapuiv( map, values ); 5291} 5292 5293static void exec_GetPixelMapusv( GLenum map, GLushort *values ) 5294{ 5295 GET_CURRENT_CONTEXT(ctx); 5296 FLUSH_VERTICES(ctx, 0); 5297 ctx->Exec->GetPixelMapusv( map, values ); 5298} 5299 5300static void exec_GetPolygonStipple( GLubyte *dest ) 5301{ 5302 GET_CURRENT_CONTEXT(ctx); 5303 FLUSH_VERTICES(ctx, 0); 5304 ctx->Exec->GetPolygonStipple( dest ); 5305} 5306 5307static const GLubyte *exec_GetString( GLenum name ) 5308{ 5309 GET_CURRENT_CONTEXT(ctx); 5310 FLUSH_VERTICES(ctx, 0); 5311 return ctx->Exec->GetString( name ); 5312} 5313 5314static void exec_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params ) 5315{ 5316 GET_CURRENT_CONTEXT(ctx); 5317 FLUSH_VERTICES(ctx, 0); 5318 ctx->Exec->GetTexEnvfv( target, pname, params ); 5319} 5320 5321static void exec_GetTexEnviv( GLenum target, GLenum pname, GLint *params ) 5322{ 5323 GET_CURRENT_CONTEXT(ctx); 5324 FLUSH_VERTICES(ctx, 0); 5325 ctx->Exec->GetTexEnviv( target, pname, params ); 5326} 5327 5328static void exec_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params ) 5329{ 5330 GET_CURRENT_CONTEXT(ctx); 5331 FLUSH_VERTICES(ctx, 0); 5332 ctx->Exec->GetTexGendv( coord, pname, params ); 5333} 5334 5335static void exec_GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params ) 5336{ 5337 GET_CURRENT_CONTEXT(ctx); 5338 FLUSH_VERTICES(ctx, 0); 5339 ctx->Exec->GetTexGenfv( coord, pname, params ); 5340} 5341 5342static void exec_GetTexGeniv( GLenum coord, GLenum pname, GLint *params ) 5343{ 5344 GET_CURRENT_CONTEXT(ctx); 5345 FLUSH_VERTICES(ctx, 0); 5346 ctx->Exec->GetTexGeniv( coord, pname, params ); 5347} 5348 5349static void exec_GetTexImage( GLenum target, GLint level, GLenum format, 5350 GLenum type, GLvoid *pixels ) 5351{ 5352 GET_CURRENT_CONTEXT(ctx); 5353 FLUSH_VERTICES(ctx, 0); 5354 ctx->Exec->GetTexImage( target, level, format, type, pixels ); 5355} 5356 5357static void exec_GetTexLevelParameterfv( GLenum target, GLint level, 5358 GLenum pname, GLfloat *params ) 5359{ 5360 GET_CURRENT_CONTEXT(ctx); 5361 FLUSH_VERTICES(ctx, 0); 5362 ctx->Exec->GetTexLevelParameterfv( target, level, pname, params ); 5363} 5364 5365static void exec_GetTexLevelParameteriv( GLenum target, GLint level, 5366 GLenum pname, GLint *params ) 5367{ 5368 GET_CURRENT_CONTEXT(ctx); 5369 FLUSH_VERTICES(ctx, 0); 5370 ctx->Exec->GetTexLevelParameteriv( target, level, pname, params ); 5371} 5372 5373static void exec_GetTexParameterfv( GLenum target, GLenum pname, 5374 GLfloat *params ) 5375{ 5376 GET_CURRENT_CONTEXT(ctx); 5377 FLUSH_VERTICES(ctx, 0); 5378 ctx->Exec->GetTexParameterfv( target, pname, params ); 5379} 5380 5381static void exec_GetTexParameteriv( GLenum target, GLenum pname, GLint *params ) 5382{ 5383 GET_CURRENT_CONTEXT(ctx); 5384 FLUSH_VERTICES(ctx, 0); 5385 ctx->Exec->GetTexParameteriv( target, pname, params ); 5386} 5387 5388static GLboolean exec_IsEnabled( GLenum cap ) 5389{ 5390 GET_CURRENT_CONTEXT(ctx); 5391 FLUSH_VERTICES(ctx, 0); 5392 return ctx->Exec->IsEnabled( cap ); 5393} 5394 5395static void exec_PixelStoref( GLenum pname, GLfloat param ) 5396{ 5397 GET_CURRENT_CONTEXT(ctx); 5398 FLUSH_VERTICES(ctx, 0); 5399 ctx->Exec->PixelStoref( pname, param ); 5400} 5401 5402static void exec_PixelStorei( GLenum pname, GLint param ) 5403{ 5404 GET_CURRENT_CONTEXT(ctx); 5405 FLUSH_VERTICES(ctx, 0); 5406 ctx->Exec->PixelStorei( pname, param ); 5407} 5408 5409static void exec_ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, 5410 GLenum format, GLenum type, GLvoid *pixels ) 5411{ 5412 GET_CURRENT_CONTEXT(ctx); 5413 FLUSH_VERTICES(ctx, 0); 5414 ctx->Exec->ReadPixels( x, y, width, height, format, type, pixels ); 5415} 5416 5417static GLint exec_RenderMode( GLenum mode ) 5418{ 5419 GET_CURRENT_CONTEXT(ctx); 5420 FLUSH_VERTICES(ctx, 0); 5421 return ctx->Exec->RenderMode( mode ); 5422} 5423 5424static void exec_FeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer ) 5425{ 5426 GET_CURRENT_CONTEXT(ctx); 5427 FLUSH_VERTICES(ctx, 0); 5428 ctx->Exec->FeedbackBuffer( size, type, buffer ); 5429} 5430 5431static void exec_SelectBuffer( GLsizei size, GLuint *buffer ) 5432{ 5433 GET_CURRENT_CONTEXT(ctx); 5434 FLUSH_VERTICES(ctx, 0); 5435 ctx->Exec->SelectBuffer( size, buffer ); 5436} 5437 5438static GLboolean exec_AreTexturesResident(GLsizei n, const GLuint *texName, 5439 GLboolean *residences) 5440{ 5441 GET_CURRENT_CONTEXT(ctx); 5442 FLUSH_VERTICES(ctx, 0); 5443 return ctx->Exec->AreTexturesResident( n, texName, residences); 5444} 5445 5446static void exec_ColorPointer(GLint size, GLenum type, GLsizei stride, 5447 const GLvoid *ptr) 5448{ 5449 GET_CURRENT_CONTEXT(ctx); 5450 FLUSH_VERTICES(ctx, 0); 5451 ctx->Exec->ColorPointer( size, type, stride, ptr); 5452} 5453 5454static void exec_DeleteTextures( GLsizei n, const GLuint *texName) 5455{ 5456 GET_CURRENT_CONTEXT(ctx); 5457 FLUSH_VERTICES(ctx, 0); 5458 ctx->Exec->DeleteTextures( n, texName); 5459} 5460 5461static void exec_DisableClientState( GLenum cap ) 5462{ 5463 GET_CURRENT_CONTEXT(ctx); 5464 FLUSH_VERTICES(ctx, 0); 5465 ctx->Exec->DisableClientState( cap ); 5466} 5467 5468static void exec_EdgeFlagPointer(GLsizei stride, const void *vptr) 5469{ 5470 GET_CURRENT_CONTEXT(ctx); 5471 FLUSH_VERTICES(ctx, 0); 5472 ctx->Exec->EdgeFlagPointer( stride, vptr); 5473} 5474 5475static void exec_EnableClientState( GLenum cap ) 5476{ 5477 GET_CURRENT_CONTEXT(ctx); 5478 FLUSH_VERTICES(ctx, 0); 5479 ctx->Exec->EnableClientState( cap ); 5480} 5481 5482static void exec_GenTextures( GLsizei n, GLuint *texName ) 5483{ 5484 GET_CURRENT_CONTEXT(ctx); 5485 FLUSH_VERTICES(ctx, 0); 5486 ctx->Exec->GenTextures( n, texName ); 5487} 5488 5489static void exec_GetPointerv( GLenum pname, GLvoid **params ) 5490{ 5491 GET_CURRENT_CONTEXT(ctx); 5492 FLUSH_VERTICES(ctx, 0); 5493 ctx->Exec->GetPointerv( pname, params ); 5494} 5495 5496static void exec_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr) 5497{ 5498 GET_CURRENT_CONTEXT(ctx); 5499 FLUSH_VERTICES(ctx, 0); 5500 ctx->Exec->IndexPointer( type, stride, ptr); 5501} 5502 5503static void exec_InterleavedArrays(GLenum format, GLsizei stride, 5504 const GLvoid *pointer) 5505{ 5506 GET_CURRENT_CONTEXT(ctx); 5507 FLUSH_VERTICES(ctx, 0); 5508 ctx->Exec->InterleavedArrays( format, stride, pointer); 5509} 5510 5511static GLboolean exec_IsTexture( GLuint texture ) 5512{ 5513 GET_CURRENT_CONTEXT(ctx); 5514 FLUSH_VERTICES(ctx, 0); 5515 return ctx->Exec->IsTexture( texture ); 5516} 5517 5518static void exec_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr ) 5519{ 5520 GET_CURRENT_CONTEXT(ctx); 5521 FLUSH_VERTICES(ctx, 0); 5522 ctx->Exec->NormalPointer( type, stride, ptr ); 5523} 5524 5525static void exec_PopClientAttrib(void) 5526{ 5527 GET_CURRENT_CONTEXT(ctx); 5528 FLUSH_VERTICES(ctx, 0); 5529 ctx->Exec->PopClientAttrib(); 5530} 5531 5532static void exec_PushClientAttrib(GLbitfield mask) 5533{ 5534 GET_CURRENT_CONTEXT(ctx); 5535 FLUSH_VERTICES(ctx, 0); 5536 ctx->Exec->PushClientAttrib( mask); 5537} 5538 5539static void exec_TexCoordPointer(GLint size, GLenum type, GLsizei stride, 5540 const GLvoid *ptr) 5541{ 5542 GET_CURRENT_CONTEXT(ctx); 5543 FLUSH_VERTICES(ctx, 0); 5544 ctx->Exec->TexCoordPointer( size, type, stride, ptr); 5545} 5546 5547static void exec_GetCompressedTexImageARB(GLenum target, GLint level, 5548 GLvoid *img) 5549{ 5550 GET_CURRENT_CONTEXT(ctx); 5551 FLUSH_VERTICES(ctx, 0); 5552 ctx->Exec->GetCompressedTexImageARB( target, level, img); 5553} 5554 5555static void exec_VertexPointer(GLint size, GLenum type, GLsizei stride, 5556 const GLvoid *ptr) 5557{ 5558 GET_CURRENT_CONTEXT(ctx); 5559 FLUSH_VERTICES(ctx, 0); 5560 ctx->Exec->VertexPointer( size, type, stride, ptr); 5561} 5562 5563static void exec_CopyConvolutionFilter1D(GLenum target, GLenum internalFormat, 5564 GLint x, GLint y, GLsizei width) 5565{ 5566 GET_CURRENT_CONTEXT(ctx); 5567 FLUSH_VERTICES(ctx, 0); 5568 ctx->Exec->CopyConvolutionFilter1D( target, internalFormat, x, y, width); 5569} 5570 5571static void exec_CopyConvolutionFilter2D(GLenum target, GLenum internalFormat, 5572 GLint x, GLint y, GLsizei width, 5573 GLsizei height) 5574{ 5575 GET_CURRENT_CONTEXT(ctx); 5576 FLUSH_VERTICES(ctx, 0); 5577 ctx->Exec->CopyConvolutionFilter2D( target, internalFormat, x, y, width, 5578 height); 5579} 5580 5581static void exec_GetColorTable( GLenum target, GLenum format, 5582 GLenum type, GLvoid *data ) 5583{ 5584 GET_CURRENT_CONTEXT(ctx); 5585 FLUSH_VERTICES(ctx, 0); 5586 ctx->Exec->GetColorTable( target, format, type, data ); 5587} 5588 5589static void exec_GetColorTableParameterfv( GLenum target, GLenum pname, 5590 GLfloat *params ) 5591{ 5592 GET_CURRENT_CONTEXT(ctx); 5593 FLUSH_VERTICES(ctx, 0); 5594 ctx->Exec->GetColorTableParameterfv( target, pname, params ); 5595} 5596 5597static void exec_GetColorTableParameteriv( GLenum target, GLenum pname, 5598 GLint *params ) 5599{ 5600 GET_CURRENT_CONTEXT(ctx); 5601 FLUSH_VERTICES(ctx, 0); 5602 ctx->Exec->GetColorTableParameteriv( target, pname, params ); 5603} 5604 5605static void exec_GetConvolutionFilter(GLenum target, GLenum format, GLenum type, 5606 GLvoid *image) 5607{ 5608 GET_CURRENT_CONTEXT(ctx); 5609 FLUSH_VERTICES(ctx, 0); 5610 ctx->Exec->GetConvolutionFilter( target, format, type, image); 5611} 5612 5613static void exec_GetConvolutionParameterfv(GLenum target, GLenum pname, 5614 GLfloat *params) 5615{ 5616 GET_CURRENT_CONTEXT(ctx); 5617 FLUSH_VERTICES(ctx, 0); 5618 ctx->Exec->GetConvolutionParameterfv( target, pname, params); 5619} 5620 5621static void exec_GetConvolutionParameteriv(GLenum target, GLenum pname, 5622 GLint *params) 5623{ 5624 GET_CURRENT_CONTEXT(ctx); 5625 FLUSH_VERTICES(ctx, 0); 5626 ctx->Exec->GetConvolutionParameteriv( target, pname, params); 5627} 5628 5629static void exec_GetHistogram(GLenum target, GLboolean reset, GLenum format, 5630 GLenum type, GLvoid *values) 5631{ 5632 GET_CURRENT_CONTEXT(ctx); 5633 FLUSH_VERTICES(ctx, 0); 5634 ctx->Exec->GetHistogram( target, reset, format, type, values); 5635} 5636 5637static void exec_GetHistogramParameterfv(GLenum target, GLenum pname, 5638 GLfloat *params) 5639{ 5640 GET_CURRENT_CONTEXT(ctx); 5641 FLUSH_VERTICES(ctx, 0); 5642 ctx->Exec->GetHistogramParameterfv( target, pname, params); 5643} 5644 5645static void exec_GetHistogramParameteriv(GLenum target, GLenum pname, 5646 GLint *params) 5647{ 5648 GET_CURRENT_CONTEXT(ctx); 5649 FLUSH_VERTICES(ctx, 0); 5650 ctx->Exec->GetHistogramParameteriv( target, pname, params); 5651} 5652 5653static void exec_GetMinmax(GLenum target, GLboolean reset, GLenum format, 5654 GLenum type, GLvoid *values) 5655{ 5656 GET_CURRENT_CONTEXT(ctx); 5657 FLUSH_VERTICES(ctx, 0); 5658 ctx->Exec->GetMinmax( target, reset, format, type, values); 5659} 5660 5661static void exec_GetMinmaxParameterfv(GLenum target, GLenum pname, 5662 GLfloat *params) 5663{ 5664 GET_CURRENT_CONTEXT(ctx); 5665 FLUSH_VERTICES(ctx, 0); 5666 ctx->Exec->GetMinmaxParameterfv( target, pname, params); 5667} 5668 5669static void exec_GetMinmaxParameteriv(GLenum target, GLenum pname, 5670 GLint *params) 5671{ 5672 GET_CURRENT_CONTEXT(ctx); 5673 FLUSH_VERTICES(ctx, 0); 5674 ctx->Exec->GetMinmaxParameteriv( target, pname, params); 5675} 5676 5677static void exec_GetSeparableFilter(GLenum target, GLenum format, GLenum type, 5678 GLvoid *row, GLvoid *column, GLvoid *span) 5679{ 5680 GET_CURRENT_CONTEXT(ctx); 5681 FLUSH_VERTICES(ctx, 0); 5682 ctx->Exec->GetSeparableFilter( target, format, type, row, column, span); 5683} 5684 5685static void exec_SeparableFilter2D(GLenum target, GLenum internalFormat, 5686 GLsizei width, GLsizei height, GLenum format, 5687 GLenum type, const GLvoid *row, 5688 const GLvoid *column) 5689{ 5690 GET_CURRENT_CONTEXT(ctx); 5691 FLUSH_VERTICES(ctx, 0); 5692 ctx->Exec->SeparableFilter2D( target, internalFormat, width, height, format, 5693 type, row, column); 5694} 5695 5696static void exec_GetPixelTexGenParameterivSGIS(GLenum target, GLint *value) 5697{ 5698 GET_CURRENT_CONTEXT(ctx); 5699 FLUSH_VERTICES(ctx, 0); 5700 ctx->Exec->GetPixelTexGenParameterivSGIS( target, value); 5701} 5702 5703static void exec_GetPixelTexGenParameterfvSGIS(GLenum target, GLfloat *value) 5704{ 5705 GET_CURRENT_CONTEXT(ctx); 5706 FLUSH_VERTICES(ctx, 0); 5707 ctx->Exec->GetPixelTexGenParameterfvSGIS( target, value); 5708} 5709 5710static void exec_ColorPointerEXT(GLint size, GLenum type, GLsizei stride, 5711 GLsizei count, const GLvoid *ptr) 5712{ 5713 GET_CURRENT_CONTEXT(ctx); 5714 FLUSH_VERTICES(ctx, 0); 5715 ctx->Exec->ColorPointerEXT( size, type, stride, count, ptr); 5716} 5717 5718static void exec_EdgeFlagPointerEXT(GLsizei stride, GLsizei count, 5719 const GLboolean *ptr) 5720{ 5721 GET_CURRENT_CONTEXT(ctx); 5722 FLUSH_VERTICES(ctx, 0); 5723 ctx->Exec->EdgeFlagPointerEXT( stride, count, ptr); 5724} 5725 5726static void exec_IndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, 5727 const GLvoid *ptr) 5728{ 5729 GET_CURRENT_CONTEXT(ctx); 5730 FLUSH_VERTICES(ctx, 0); 5731 ctx->Exec->IndexPointerEXT( type, stride, count, ptr); 5732} 5733 5734static void exec_NormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, 5735 const GLvoid *ptr) 5736{ 5737 GET_CURRENT_CONTEXT(ctx); 5738 FLUSH_VERTICES(ctx, 0); 5739 ctx->Exec->NormalPointerEXT( type, stride, count, ptr); 5740} 5741 5742static void exec_TexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, 5743 GLsizei count, const GLvoid *ptr) 5744{ 5745 GET_CURRENT_CONTEXT(ctx); 5746 FLUSH_VERTICES(ctx, 0); 5747 ctx->Exec->TexCoordPointerEXT( size, type, stride, count, ptr); 5748} 5749 5750static void exec_VertexPointerEXT(GLint size, GLenum type, GLsizei stride, 5751 GLsizei count, const GLvoid *ptr) 5752{ 5753 GET_CURRENT_CONTEXT(ctx); 5754 FLUSH_VERTICES(ctx, 0); 5755 ctx->Exec->VertexPointerEXT( size, type, stride, count, ptr); 5756} 5757 5758static void exec_LockArraysEXT(GLint first, GLsizei count) 5759{ 5760 GET_CURRENT_CONTEXT(ctx); 5761 FLUSH_VERTICES(ctx, 0); 5762 ctx->Exec->LockArraysEXT( first, count); 5763} 5764 5765static void exec_UnlockArraysEXT( void ) 5766{ 5767 GET_CURRENT_CONTEXT(ctx); 5768 FLUSH_VERTICES(ctx, 0); 5769 ctx->Exec->UnlockArraysEXT( ); 5770} 5771 5772static void exec_ResizeBuffersMESA( void ) 5773{ 5774 GET_CURRENT_CONTEXT(ctx); 5775 FLUSH_VERTICES(ctx, 0); 5776 ctx->Exec->ResizeBuffersMESA( ); 5777} 5778 5779 5780static void exec_ClientActiveTextureARB( GLenum target ) 5781{ 5782 GET_CURRENT_CONTEXT(ctx); 5783 FLUSH_VERTICES(ctx, 0); 5784 ctx->Exec->ClientActiveTextureARB(target); 5785} 5786 5787static void exec_SecondaryColorPointerEXT(GLint size, GLenum type, 5788 GLsizei stride, const GLvoid *ptr) 5789{ 5790 GET_CURRENT_CONTEXT(ctx); 5791 FLUSH_VERTICES(ctx, 0); 5792 ctx->Exec->SecondaryColorPointerEXT( size, type, stride, ptr); 5793} 5794 5795static void exec_FogCoordPointerEXT(GLenum type, GLsizei stride, 5796 const GLvoid *ptr) 5797{ 5798 GET_CURRENT_CONTEXT(ctx); 5799 FLUSH_VERTICES(ctx, 0); 5800 ctx->Exec->FogCoordPointerEXT( type, stride, ptr); 5801} 5802 5803/* GL_EXT_multi_draw_arrays */ 5804static void exec_MultiDrawArraysEXT(GLenum mode, GLint *first, 5805 GLsizei *count, GLsizei primcount) 5806{ 5807 GET_CURRENT_CONTEXT(ctx); 5808 FLUSH_VERTICES(ctx, 0); 5809 ctx->Exec->MultiDrawArraysEXT( mode, first, count, primcount ); 5810} 5811 5812/* GL_EXT_multi_draw_arrays */ 5813static void exec_MultiDrawElementsEXT(GLenum mode, const GLsizei *count, 5814 GLenum type, const GLvoid **indices, 5815 GLsizei primcount) 5816{ 5817 GET_CURRENT_CONTEXT(ctx); 5818 FLUSH_VERTICES(ctx, 0); 5819 ctx->Exec->MultiDrawElementsEXT(mode, count, type, indices, primcount); 5820} 5821 5822 5823 5824/* 5825 * Assign all the pointers in <table> to point to Mesa's display list 5826 * building functions. 5827 * 5828 * This does not include any of the tnl functions - they are 5829 * initialized from _mesa_init_api_defaults and from the active vtxfmt 5830 * struct. 5831 */ 5832void 5833_mesa_init_dlist_table( struct _glapi_table *table, GLuint tableSize ) 5834{ 5835 _mesa_init_no_op_table(table, tableSize); 5836 5837 _mesa_loopback_init_api_table( table, GL_TRUE ); 5838 5839 /* GL 1.0 */ 5840 table->Accum = save_Accum; 5841 table->AlphaFunc = save_AlphaFunc; 5842 table->Bitmap = save_Bitmap; 5843 table->BlendFunc = save_BlendFunc; 5844 table->CallList = _mesa_save_CallList; 5845 table->CallLists = _mesa_save_CallLists; 5846 table->Clear = save_Clear; 5847 table->ClearAccum = save_ClearAccum; 5848 table->ClearColor = save_ClearColor; 5849 table->ClearDepth = save_ClearDepth; 5850 table->ClearIndex = save_ClearIndex; 5851 table->ClearStencil = save_ClearStencil; 5852 table->ClipPlane = save_ClipPlane; 5853 table->ColorMask = save_ColorMask; 5854 table->ColorMaterial = save_ColorMaterial; 5855 table->CopyPixels = save_CopyPixels; 5856 table->CullFace = save_CullFace; 5857 table->DeleteLists = _mesa_DeleteLists; 5858 table->DepthFunc = save_DepthFunc; 5859 table->DepthMask = save_DepthMask; 5860 table->DepthRange = save_DepthRange; 5861 table->Disable = save_Disable; 5862 table->DrawBuffer = save_DrawBuffer; 5863 table->DrawPixels = save_DrawPixels; 5864 table->Enable = save_Enable; 5865 table->EndList = _mesa_EndList; 5866 table->EvalMesh1 = _mesa_save_EvalMesh1; 5867 table->EvalMesh2 = _mesa_save_EvalMesh2; 5868 table->Finish = exec_Finish; 5869 table->Flush = exec_Flush; 5870 table->Fogf = save_Fogf; 5871 table->Fogfv = save_Fogfv; 5872 table->Fogi = save_Fogi; 5873 table->Fogiv = save_Fogiv; 5874 table->FrontFace = save_FrontFace; 5875 table->Frustum = save_Frustum; 5876 table->GenLists = _mesa_GenLists; 5877 table->GetBooleanv = exec_GetBooleanv; 5878 table->GetClipPlane = exec_GetClipPlane; 5879 table->GetDoublev = exec_GetDoublev; 5880 table->GetError = exec_GetError; 5881 table->GetFloatv = exec_GetFloatv; 5882 table->GetIntegerv = exec_GetIntegerv; 5883 table->GetLightfv = exec_GetLightfv; 5884 table->GetLightiv = exec_GetLightiv; 5885 table->GetMapdv = exec_GetMapdv; 5886 table->GetMapfv = exec_GetMapfv; 5887 table->GetMapiv = exec_GetMapiv; 5888 table->GetMaterialfv = exec_GetMaterialfv; 5889 table->GetMaterialiv = exec_GetMaterialiv; 5890 table->GetPixelMapfv = exec_GetPixelMapfv; 5891 table->GetPixelMapuiv = exec_GetPixelMapuiv; 5892 table->GetPixelMapusv = exec_GetPixelMapusv; 5893 table->GetPolygonStipple = exec_GetPolygonStipple; 5894 table->GetString = exec_GetString; 5895 table->GetTexEnvfv = exec_GetTexEnvfv; 5896 table->GetTexEnviv = exec_GetTexEnviv; 5897 table->GetTexGendv = exec_GetTexGendv; 5898 table->GetTexGenfv = exec_GetTexGenfv; 5899 table->GetTexGeniv = exec_GetTexGeniv; 5900 table->GetTexImage = exec_GetTexImage; 5901 table->GetTexLevelParameterfv = exec_GetTexLevelParameterfv; 5902 table->GetTexLevelParameteriv = exec_GetTexLevelParameteriv; 5903 table->GetTexParameterfv = exec_GetTexParameterfv; 5904 table->GetTexParameteriv = exec_GetTexParameteriv; 5905 table->Hint = save_Hint; 5906 table->IndexMask = save_IndexMask; 5907 table->InitNames = save_InitNames; 5908 table->IsEnabled = exec_IsEnabled; 5909 table->IsList = _mesa_IsList; 5910 table->LightModelf = save_LightModelf; 5911 table->LightModelfv = save_LightModelfv; 5912 table->LightModeli = save_LightModeli; 5913 table->LightModeliv = save_LightModeliv; 5914 table->Lightf = save_Lightf; 5915 table->Lightfv = save_Lightfv; 5916 table->Lighti = save_Lighti; 5917 table->Lightiv = save_Lightiv; 5918 table->LineStipple = save_LineStipple; 5919 table->LineWidth = save_LineWidth; 5920 table->ListBase = save_ListBase; 5921 table->LoadIdentity = save_LoadIdentity; 5922 table->LoadMatrixd = save_LoadMatrixd; 5923 table->LoadMatrixf = save_LoadMatrixf; 5924 table->LoadName = save_LoadName; 5925 table->LogicOp = save_LogicOp; 5926 table->Map1d = save_Map1d; 5927 table->Map1f = save_Map1f; 5928 table->Map2d = save_Map2d; 5929 table->Map2f = save_Map2f; 5930 table->MapGrid1d = save_MapGrid1d; 5931 table->MapGrid1f = save_MapGrid1f; 5932 table->MapGrid2d = save_MapGrid2d; 5933 table->MapGrid2f = save_MapGrid2f; 5934 table->MatrixMode = save_MatrixMode; 5935 table->MultMatrixd = save_MultMatrixd; 5936 table->MultMatrixf = save_MultMatrixf; 5937 table->NewList = save_NewList; 5938 table->Ortho = save_Ortho; 5939 table->PassThrough = save_PassThrough; 5940 table->PixelMapfv = save_PixelMapfv; 5941 table->PixelMapuiv = save_PixelMapuiv; 5942 table->PixelMapusv = save_PixelMapusv; 5943 table->PixelStoref = exec_PixelStoref; 5944 table->PixelStorei = exec_PixelStorei; 5945 table->PixelTransferf = save_PixelTransferf; 5946 table->PixelTransferi = save_PixelTransferi; 5947 table->PixelZoom = save_PixelZoom; 5948 table->PointSize = save_PointSize; 5949 table->PolygonMode = save_PolygonMode; 5950 table->PolygonOffset = save_PolygonOffset; 5951 table->PolygonStipple = save_PolygonStipple; 5952 table->PopAttrib = save_PopAttrib; 5953 table->PopMatrix = save_PopMatrix; 5954 table->PopName = save_PopName; 5955 table->PushAttrib = save_PushAttrib; 5956 table->PushMatrix = save_PushMatrix; 5957 table->PushName = save_PushName; 5958 table->RasterPos2d = save_RasterPos2d; 5959 table->RasterPos2dv = save_RasterPos2dv; 5960 table->RasterPos2f = save_RasterPos2f; 5961 table->RasterPos2fv = save_RasterPos2fv; 5962 table->RasterPos2i = save_RasterPos2i; 5963 table->RasterPos2iv = save_RasterPos2iv; 5964 table->RasterPos2s = save_RasterPos2s; 5965 table->RasterPos2sv = save_RasterPos2sv; 5966 table->RasterPos3d = save_RasterPos3d; 5967 table->RasterPos3dv = save_RasterPos3dv; 5968 table->RasterPos3f = save_RasterPos3f; 5969 table->RasterPos3fv = save_RasterPos3fv; 5970 table->RasterPos3i = save_RasterPos3i; 5971 table->RasterPos3iv = save_RasterPos3iv; 5972 table->RasterPos3s = save_RasterPos3s; 5973 table->RasterPos3sv = save_RasterPos3sv; 5974 table->RasterPos4d = save_RasterPos4d; 5975 table->RasterPos4dv = save_RasterPos4dv; 5976 table->RasterPos4f = save_RasterPos4f; 5977 table->RasterPos4fv = save_RasterPos4fv; 5978 table->RasterPos4i = save_RasterPos4i; 5979 table->RasterPos4iv = save_RasterPos4iv; 5980 table->RasterPos4s = save_RasterPos4s; 5981 table->RasterPos4sv = save_RasterPos4sv; 5982 table->ReadBuffer = save_ReadBuffer; 5983 table->ReadPixels = exec_ReadPixels; 5984 table->RenderMode = exec_RenderMode; 5985 table->Rotated = save_Rotated; 5986 table->Rotatef = save_Rotatef; 5987 table->Scaled = save_Scaled; 5988 table->Scalef = save_Scalef; 5989 table->Scissor = save_Scissor; 5990 table->FeedbackBuffer = exec_FeedbackBuffer; 5991 table->SelectBuffer = exec_SelectBuffer; 5992 table->ShadeModel = save_ShadeModel; 5993 table->StencilFunc = save_StencilFunc; 5994 table->StencilMask = save_StencilMask; 5995 table->StencilOp = save_StencilOp; 5996 table->TexEnvf = save_TexEnvf; 5997 table->TexEnvfv = save_TexEnvfv; 5998 table->TexEnvi = save_TexEnvi; 5999 table->TexEnviv = save_TexEnviv; 6000 table->TexGend = save_TexGend; 6001 table->TexGendv = save_TexGendv; 6002 table->TexGenf = save_TexGenf; 6003 table->TexGenfv = save_TexGenfv; 6004 table->TexGeni = save_TexGeni; 6005 table->TexGeniv = save_TexGeniv; 6006 table->TexImage1D = save_TexImage1D; 6007 table->TexImage2D = save_TexImage2D; 6008 table->TexParameterf = save_TexParameterf; 6009 table->TexParameterfv = save_TexParameterfv; 6010 table->TexParameteri = save_TexParameteri; 6011 table->TexParameteriv = save_TexParameteriv; 6012 table->Translated = save_Translated; 6013 table->Translatef = save_Translatef; 6014 table->Viewport = save_Viewport; 6015 6016 /* GL 1.1 */ 6017 table->AreTexturesResident = exec_AreTexturesResident; 6018 table->BindTexture = save_BindTexture; 6019 table->ColorPointer = exec_ColorPointer; 6020 table->CopyTexImage1D = save_CopyTexImage1D; 6021 table->CopyTexImage2D = save_CopyTexImage2D; 6022 table->CopyTexSubImage1D = save_CopyTexSubImage1D; 6023 table->CopyTexSubImage2D = save_CopyTexSubImage2D; 6024 table->DeleteTextures = exec_DeleteTextures; 6025 table->DisableClientState = exec_DisableClientState; 6026 table->EdgeFlagPointer = exec_EdgeFlagPointer; 6027 table->EnableClientState = exec_EnableClientState; 6028 table->GenTextures = exec_GenTextures; 6029 table->GetPointerv = exec_GetPointerv; 6030 table->IndexPointer = exec_IndexPointer; 6031 table->InterleavedArrays = exec_InterleavedArrays; 6032 table->IsTexture = exec_IsTexture; 6033 table->NormalPointer = exec_NormalPointer; 6034 table->PopClientAttrib = exec_PopClientAttrib; 6035 table->PrioritizeTextures = save_PrioritizeTextures; 6036 table->PushClientAttrib = exec_PushClientAttrib; 6037 table->TexCoordPointer = exec_TexCoordPointer; 6038 table->TexSubImage1D = save_TexSubImage1D; 6039 table->TexSubImage2D = save_TexSubImage2D; 6040 table->VertexPointer = exec_VertexPointer; 6041 6042 /* GL 1.2 */ 6043 table->CopyTexSubImage3D = save_CopyTexSubImage3D; 6044 table->TexImage3D = save_TexImage3D; 6045 table->TexSubImage3D = save_TexSubImage3D; 6046 6047 /* GL_ARB_imaging */ 6048 /* Not all are supported */ 6049 table->BlendColor = save_BlendColor; 6050 table->BlendEquation = save_BlendEquation; 6051 table->ColorSubTable = save_ColorSubTable; 6052 table->ColorTable = save_ColorTable; 6053 table->ColorTableParameterfv = save_ColorTableParameterfv; 6054 table->ColorTableParameteriv = save_ColorTableParameteriv; 6055 table->ConvolutionFilter1D = save_ConvolutionFilter1D; 6056 table->ConvolutionFilter2D = save_ConvolutionFilter2D; 6057 table->ConvolutionParameterf = save_ConvolutionParameterf; 6058 table->ConvolutionParameterfv = save_ConvolutionParameterfv; 6059 table->ConvolutionParameteri = save_ConvolutionParameteri; 6060 table->ConvolutionParameteriv = save_ConvolutionParameteriv; 6061 table->CopyColorSubTable = save_CopyColorSubTable; 6062 table->CopyColorTable = save_CopyColorTable; 6063 table->CopyConvolutionFilter1D = exec_CopyConvolutionFilter1D; 6064 table->CopyConvolutionFilter2D = exec_CopyConvolutionFilter2D; 6065 table->GetColorTable = exec_GetColorTable; 6066 table->GetColorTableParameterfv = exec_GetColorTableParameterfv; 6067 table->GetColorTableParameteriv = exec_GetColorTableParameteriv; 6068 table->GetConvolutionFilter = exec_GetConvolutionFilter; 6069 table->GetConvolutionParameterfv = exec_GetConvolutionParameterfv; 6070 table->GetConvolutionParameteriv = exec_GetConvolutionParameteriv; 6071 table->GetHistogram = exec_GetHistogram; 6072 table->GetHistogramParameterfv = exec_GetHistogramParameterfv; 6073 table->GetHistogramParameteriv = exec_GetHistogramParameteriv; 6074 table->GetMinmax = exec_GetMinmax; 6075 table->GetMinmaxParameterfv = exec_GetMinmaxParameterfv; 6076 table->GetMinmaxParameteriv = exec_GetMinmaxParameteriv; 6077 table->GetSeparableFilter = exec_GetSeparableFilter; 6078 table->Histogram = save_Histogram; 6079 table->Minmax = save_Minmax; 6080 table->ResetHistogram = save_ResetHistogram; 6081 table->ResetMinmax = save_ResetMinmax; 6082 table->SeparableFilter2D = exec_SeparableFilter2D; 6083 6084 /* 2. GL_EXT_blend_color */ 6085#if 0 6086 table->BlendColorEXT = save_BlendColorEXT; 6087#endif 6088 6089 /* 3. GL_EXT_polygon_offset */ 6090 table->PolygonOffsetEXT = save_PolygonOffsetEXT; 6091 6092 /* 6. GL_EXT_texture3d */ 6093#if 0 6094 table->CopyTexSubImage3DEXT = save_CopyTexSubImage3D; 6095 table->TexImage3DEXT = save_TexImage3DEXT; 6096 table->TexSubImage3DEXT = save_TexSubImage3D; 6097#endif 6098 6099 /* 15. GL_SGIX_pixel_texture */ 6100 table->PixelTexGenSGIX = save_PixelTexGenSGIX; 6101 6102 /* 15. GL_SGIS_pixel_texture */ 6103 table->PixelTexGenParameteriSGIS = save_PixelTexGenParameteriSGIS; 6104 table->PixelTexGenParameterfSGIS = save_PixelTexGenParameterfSGIS; 6105 table->PixelTexGenParameterivSGIS = save_PixelTexGenParameterivSGIS; 6106 table->PixelTexGenParameterfvSGIS = save_PixelTexGenParameterfvSGIS; 6107 table->GetPixelTexGenParameterivSGIS = exec_GetPixelTexGenParameterivSGIS; 6108 table->GetPixelTexGenParameterfvSGIS = exec_GetPixelTexGenParameterfvSGIS; 6109 6110 /* 30. GL_EXT_vertex_array */ 6111 table->ColorPointerEXT = exec_ColorPointerEXT; 6112 table->EdgeFlagPointerEXT = exec_EdgeFlagPointerEXT; 6113 table->IndexPointerEXT = exec_IndexPointerEXT; 6114 table->NormalPointerEXT = exec_NormalPointerEXT; 6115 table->TexCoordPointerEXT = exec_TexCoordPointerEXT; 6116 table->VertexPointerEXT = exec_VertexPointerEXT; 6117 6118 /* 37. GL_EXT_blend_minmax */ 6119#if 0 6120 table->BlendEquationEXT = save_BlendEquationEXT; 6121#endif 6122 6123 /* 54. GL_EXT_point_parameters */ 6124 table->PointParameterfEXT = save_PointParameterfEXT; 6125 table->PointParameterfvEXT = save_PointParameterfvEXT; 6126 6127 /* 78. GL_EXT_paletted_texture */ 6128#if 0 6129 table->ColorTableEXT = save_ColorTable; 6130 table->ColorSubTableEXT = save_ColorSubTable; 6131#endif 6132 table->GetColorTableEXT = exec_GetColorTable; 6133 table->GetColorTableParameterfvEXT = exec_GetColorTableParameterfv; 6134 table->GetColorTableParameterivEXT = exec_GetColorTableParameteriv; 6135 6136 /* 97. GL_EXT_compiled_vertex_array */ 6137 table->LockArraysEXT = exec_LockArraysEXT; 6138 table->UnlockArraysEXT = exec_UnlockArraysEXT; 6139 6140 /* 145. GL_EXT_secondary_color */ 6141 table->SecondaryColorPointerEXT = exec_SecondaryColorPointerEXT; 6142 6143 /* 148. GL_EXT_multi_draw_arrays */ 6144 table->MultiDrawArraysEXT = exec_MultiDrawArraysEXT; 6145 table->MultiDrawElementsEXT = exec_MultiDrawElementsEXT; 6146 6147 /* 149. GL_EXT_fog_coord */ 6148 table->FogCoordPointerEXT = exec_FogCoordPointerEXT; 6149 6150 /* 173. GL_EXT_blend_func_separate */ 6151 table->BlendFuncSeparateEXT = save_BlendFuncSeparateEXT; 6152 6153 /* 196. GL_MESA_resize_buffers */ 6154 table->ResizeBuffersMESA = exec_ResizeBuffersMESA; 6155 6156 /* 197. GL_MESA_window_pos */ 6157 table->WindowPos2dMESA = save_WindowPos2dMESA; 6158 table->WindowPos2dvMESA = save_WindowPos2dvMESA; 6159 table->WindowPos2fMESA = save_WindowPos2fMESA; 6160 table->WindowPos2fvMESA = save_WindowPos2fvMESA; 6161 table->WindowPos2iMESA = save_WindowPos2iMESA; 6162 table->WindowPos2ivMESA = save_WindowPos2ivMESA; 6163 table->WindowPos2sMESA = save_WindowPos2sMESA; 6164 table->WindowPos2svMESA = save_WindowPos2svMESA; 6165 table->WindowPos3dMESA = save_WindowPos3dMESA; 6166 table->WindowPos3dvMESA = save_WindowPos3dvMESA; 6167 table->WindowPos3fMESA = save_WindowPos3fMESA; 6168 table->WindowPos3fvMESA = save_WindowPos3fvMESA; 6169 table->WindowPos3iMESA = save_WindowPos3iMESA; 6170 table->WindowPos3ivMESA = save_WindowPos3ivMESA; 6171 table->WindowPos3sMESA = save_WindowPos3sMESA; 6172 table->WindowPos3svMESA = save_WindowPos3svMESA; 6173 table->WindowPos4dMESA = save_WindowPos4dMESA; 6174 table->WindowPos4dvMESA = save_WindowPos4dvMESA; 6175 table->WindowPos4fMESA = save_WindowPos4fMESA; 6176 table->WindowPos4fvMESA = save_WindowPos4fvMESA; 6177 table->WindowPos4iMESA = save_WindowPos4iMESA; 6178 table->WindowPos4ivMESA = save_WindowPos4ivMESA; 6179 table->WindowPos4sMESA = save_WindowPos4sMESA; 6180 table->WindowPos4svMESA = save_WindowPos4svMESA; 6181 6182#if FEATURE_NV_vertex_program 6183 /* 233. GL_NV_vertex_program */ 6184 /* The following commands DO NOT go into display lists: 6185 * AreProgramsResidentNV, IsProgramNV, GenProgramsNV, DeleteProgramsNV, 6186 * VertexAttribPointerNV, GetProgram*, GetVertexAttrib* 6187 */ 6188 table->BindProgramNV = save_BindProgramNV; 6189 table->DeleteProgramsNV = _mesa_DeleteProgramsNV; 6190 table->ExecuteProgramNV = save_ExecuteProgramNV; 6191 table->GenProgramsNV = _mesa_GenProgramsNV; 6192 table->AreProgramsResidentNV = _mesa_AreProgramsResidentNV; 6193 table->RequestResidentProgramsNV = _mesa_RequestResidentProgramsNV; 6194 table->GetProgramParameterfvNV = _mesa_GetProgramParameterfvNV; 6195 table->GetProgramParameterdvNV = _mesa_GetProgramParameterdvNV; 6196 table->GetProgramivNV = _mesa_GetProgramivNV; 6197 table->GetProgramStringNV = _mesa_GetProgramStringNV; 6198 table->GetTrackMatrixivNV = _mesa_GetTrackMatrixivNV; 6199 table->GetVertexAttribdvNV = _mesa_GetVertexAttribdvNV; 6200 table->GetVertexAttribfvNV = _mesa_GetVertexAttribfvNV; 6201 table->GetVertexAttribivNV = _mesa_GetVertexAttribivNV; 6202 table->GetVertexAttribPointervNV = _mesa_GetVertexAttribPointervNV; 6203 table->IsProgramNV = _mesa_IsProgramNV; 6204 table->LoadProgramNV = _mesa_LoadProgramNV; 6205 table->ProgramParameter4dNV = save_ProgramParameter4dNV; 6206 table->ProgramParameter4dvNV = save_ProgramParameter4dvNV; 6207 table->ProgramParameter4fNV = save_ProgramParameter4fNV; 6208 table->ProgramParameter4fvNV = save_ProgramParameter4fvNV; 6209 table->ProgramParameters4dvNV = save_ProgramParameters4dvNV; 6210 table->ProgramParameters4fvNV = save_ProgramParameters4fvNV; 6211 table->TrackMatrixNV = save_TrackMatrixNV; 6212 table->VertexAttribPointerNV = _mesa_VertexAttribPointerNV; 6213#endif 6214 6215 /* 262. GL_NV_point_sprite */ 6216 table->PointParameteriNV = save_PointParameteriNV; 6217 table->PointParameterivNV = save_PointParameterivNV; 6218 6219 /* 268. GL_EXT_stencil_two_side */ 6220 table->ActiveStencilFaceEXT = save_ActiveStencilFaceEXT; 6221 6222 /* ARB 1. GL_ARB_multitexture */ 6223 table->ActiveTextureARB = save_ActiveTextureARB; 6224 table->ClientActiveTextureARB = exec_ClientActiveTextureARB; 6225 6226 /* ARB 3. GL_ARB_transpose_matrix */ 6227 table->LoadTransposeMatrixdARB = save_LoadTransposeMatrixdARB; 6228 table->LoadTransposeMatrixfARB = save_LoadTransposeMatrixfARB; 6229 table->MultTransposeMatrixdARB = save_MultTransposeMatrixdARB; 6230 table->MultTransposeMatrixfARB = save_MultTransposeMatrixfARB; 6231 6232 /* ARB 5. GL_ARB_multisample */ 6233 table->SampleCoverageARB = save_SampleCoverageARB; 6234 6235 /* ARB 12. GL_ARB_texture_compression */ 6236 table->CompressedTexImage3DARB = save_CompressedTexImage3DARB; 6237 table->CompressedTexImage2DARB = save_CompressedTexImage2DARB; 6238 table->CompressedTexImage1DARB = save_CompressedTexImage1DARB; 6239 table->CompressedTexSubImage3DARB = save_CompressedTexSubImage3DARB; 6240 table->CompressedTexSubImage2DARB = save_CompressedTexSubImage2DARB; 6241 table->CompressedTexSubImage1DARB = save_CompressedTexSubImage1DARB; 6242 table->GetCompressedTexImageARB = exec_GetCompressedTexImageARB; 6243 6244 /* ARB 14. GL_ARB_point_parameters */ 6245 /* re-use EXT_point_parameters functions */ 6246 6247 /* ARB 25. GL_ARB_window_pos */ 6248 /* re-use MESA_window_pos functions */ 6249} 6250 6251 6252 6253/*** 6254 *** Debugging code 6255 ***/ 6256static const char *enum_string( GLenum k ) 6257{ 6258 return _mesa_lookup_enum_by_nr( k ); 6259} 6260 6261 6262/* 6263 * Print the commands in a display list. For debugging only. 6264 * TODO: many commands aren't handled yet. 6265 */ 6266static void print_list( GLcontext *ctx, GLuint list ) 6267{ 6268 Node *n; 6269 GLboolean done; 6270 6271 if (!glIsList(list)) { 6272 _mesa_printf("%u is not a display list ID\n", list); 6273 return; 6274 } 6275 6276 n = (Node *) _mesa_HashLookup(ctx->Shared->DisplayList, list); 6277 6278 _mesa_printf("START-LIST %u, address %p\n", list, (void*)n ); 6279 6280 done = n ? GL_FALSE : GL_TRUE; 6281 while (!done) { 6282 OpCode opcode = n[0].opcode; 6283 GLint i = (GLint) n[0].opcode - (GLint) OPCODE_DRV_0; 6284 6285 if (i >= 0 && i < (GLint) ctx->listext.nr_opcodes) { 6286 ctx->listext.opcode[i].print(ctx, &n[1]); 6287 n += ctx->listext.opcode[i].size; 6288 } 6289 else { 6290 switch (opcode) { 6291 case OPCODE_ACCUM: 6292 _mesa_printf("accum %s %g\n", enum_string(n[1].e), n[2].f ); 6293 break; 6294 case OPCODE_BITMAP: 6295 _mesa_printf("Bitmap %d %d %g %g %g %g %p\n", n[1].i, n[2].i, 6296 n[3].f, n[4].f, n[5].f, n[6].f, (void *) n[7].data ); 6297 break; 6298 case OPCODE_CALL_LIST: 6299 _mesa_printf("CallList %d\n", (int) n[1].ui ); 6300 break; 6301 case OPCODE_CALL_LIST_OFFSET: 6302 _mesa_printf("CallList %d + offset %u = %u\n", (int) n[1].ui, 6303 ctx->List.ListBase, ctx->List.ListBase + n[1].ui ); 6304 break; 6305 case OPCODE_COLOR_TABLE_PARAMETER_FV: 6306 _mesa_printf("ColorTableParameterfv %s %s %f %f %f %f\n", 6307 enum_string(n[1].e), enum_string(n[2].e), 6308 n[3].f, n[4].f, n[5].f, n[6].f); 6309 break; 6310 case OPCODE_COLOR_TABLE_PARAMETER_IV: 6311 _mesa_printf("ColorTableParameteriv %s %s %d %d %d %d\n", 6312 enum_string(n[1].e), enum_string(n[2].e), 6313 n[3].i, n[4].i, n[5].i, n[6].i); 6314 break; 6315 case OPCODE_DISABLE: 6316 _mesa_printf("Disable %s\n", enum_string(n[1].e)); 6317 break; 6318 case OPCODE_ENABLE: 6319 _mesa_printf("Enable %s\n", enum_string(n[1].e)); 6320 break; 6321 case OPCODE_FRUSTUM: 6322 _mesa_printf("Frustum %g %g %g %g %g %g\n", 6323 n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f ); 6324 break; 6325 case OPCODE_LINE_STIPPLE: 6326 _mesa_printf("LineStipple %d %x\n", n[1].i, (int) n[2].us ); 6327 break; 6328 case OPCODE_LOAD_IDENTITY: 6329 _mesa_printf("LoadIdentity\n"); 6330 break; 6331 case OPCODE_LOAD_MATRIX: 6332 _mesa_printf("LoadMatrix\n"); 6333 _mesa_printf(" %8f %8f %8f %8f\n", 6334 n[1].f, n[5].f, n[9].f, n[13].f); 6335 _mesa_printf(" %8f %8f %8f %8f\n", 6336 n[2].f, n[6].f, n[10].f, n[14].f); 6337 _mesa_printf(" %8f %8f %8f %8f\n", 6338 n[3].f, n[7].f, n[11].f, n[15].f); 6339 _mesa_printf(" %8f %8f %8f %8f\n", 6340 n[4].f, n[8].f, n[12].f, n[16].f); 6341 break; 6342 case OPCODE_MULT_MATRIX: 6343 _mesa_printf("MultMatrix (or Rotate)\n"); 6344 _mesa_printf(" %8f %8f %8f %8f\n", 6345 n[1].f, n[5].f, n[9].f, n[13].f); 6346 _mesa_printf(" %8f %8f %8f %8f\n", 6347 n[2].f, n[6].f, n[10].f, n[14].f); 6348 _mesa_printf(" %8f %8f %8f %8f\n", 6349 n[3].f, n[7].f, n[11].f, n[15].f); 6350 _mesa_printf(" %8f %8f %8f %8f\n", 6351 n[4].f, n[8].f, n[12].f, n[16].f); 6352 break; 6353 case OPCODE_ORTHO: 6354 _mesa_printf("Ortho %g %g %g %g %g %g\n", 6355 n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f ); 6356 break; 6357 case OPCODE_POP_ATTRIB: 6358 _mesa_printf("PopAttrib\n"); 6359 break; 6360 case OPCODE_POP_MATRIX: 6361 _mesa_printf("PopMatrix\n"); 6362 break; 6363 case OPCODE_POP_NAME: 6364 _mesa_printf("PopName\n"); 6365 break; 6366 case OPCODE_PUSH_ATTRIB: 6367 _mesa_printf("PushAttrib %x\n", n[1].bf ); 6368 break; 6369 case OPCODE_PUSH_MATRIX: 6370 _mesa_printf("PushMatrix\n"); 6371 break; 6372 case OPCODE_PUSH_NAME: 6373 _mesa_printf("PushName %d\n", (int) n[1].ui ); 6374 break; 6375 case OPCODE_RASTER_POS: 6376 _mesa_printf("RasterPos %g %g %g %g\n", 6377 n[1].f, n[2].f,n[3].f,n[4].f); 6378 break; 6379 case OPCODE_ROTATE: 6380 _mesa_printf("Rotate %g %g %g %g\n", 6381 n[1].f, n[2].f, n[3].f, n[4].f ); 6382 break; 6383 case OPCODE_SCALE: 6384 _mesa_printf("Scale %g %g %g\n", n[1].f, n[2].f, n[3].f ); 6385 break; 6386 case OPCODE_TRANSLATE: 6387 _mesa_printf("Translate %g %g %g\n", n[1].f, n[2].f, n[3].f ); 6388 break; 6389 case OPCODE_BIND_TEXTURE: 6390 _mesa_printf("BindTexture %s %d\n", 6391 _mesa_lookup_enum_by_nr(n[1].ui), n[2].ui); 6392 break; 6393 case OPCODE_SHADE_MODEL: 6394 _mesa_printf("ShadeModel %s\n", 6395 _mesa_lookup_enum_by_nr(n[1].ui)); 6396 break; 6397 case OPCODE_MAP1: 6398 _mesa_printf("Map1 %s %.3f %.3f %d %d\n", 6399 _mesa_lookup_enum_by_nr(n[1].ui), 6400 n[2].f, n[3].f, n[4].i, n[5].i); 6401 break; 6402 case OPCODE_MAP2: 6403 _mesa_printf("Map2 %s %.3f %.3f %.3f %.3f %d %d %d %d\n", 6404 _mesa_lookup_enum_by_nr(n[1].ui), 6405 n[2].f, n[3].f, n[4].f, n[5].f, 6406 n[6].i, n[7].i, n[8].i, n[9].i); 6407 break; 6408 case OPCODE_MAPGRID1: 6409 _mesa_printf("MapGrid1 %d %.3f %.3f\n", 6410 n[1].i, n[2].f, n[3].f); 6411 break; 6412 case OPCODE_MAPGRID2: 6413 _mesa_printf("MapGrid2 %d %.3f %.3f, %d %.3f %.3f\n", 6414 n[1].i, n[2].f, n[3].f, 6415 n[4].i, n[5].f, n[6].f); 6416 break; 6417 case OPCODE_EVALMESH1: 6418 _mesa_printf("EvalMesh1 %d %d\n", n[1].i, n[2].i); 6419 break; 6420 case OPCODE_EVALMESH2: 6421 _mesa_printf("EvalMesh2 %d %d %d %d\n", 6422 n[1].i, n[2].i, n[3].i, n[4].i); 6423 break; 6424 6425 /* 6426 * meta opcodes/commands 6427 */ 6428 case OPCODE_ERROR: 6429 _mesa_printf("Error: %s %s\n", 6430 enum_string(n[1].e), (const char *)n[2].data ); 6431 break; 6432 case OPCODE_CONTINUE: 6433 _mesa_printf("DISPLAY-LIST-CONTINUE\n"); 6434 n = (Node *) n[1].next; 6435 break; 6436 case OPCODE_END_OF_LIST: 6437 _mesa_printf("END-LIST %u\n", list); 6438 done = GL_TRUE; 6439 break; 6440 default: 6441 if (opcode < 0 || opcode > OPCODE_END_OF_LIST) { 6442 _mesa_printf("ERROR IN DISPLAY LIST: opcode = %d, address = %p\n", 6443 opcode, (void*) n); 6444 return; 6445 } 6446 else { 6447 _mesa_printf("command %d, %u operands\n", opcode, InstSize[opcode]); 6448 } 6449 } 6450 /* increment n to point to next compiled command */ 6451 if (opcode!=OPCODE_CONTINUE) { 6452 n += InstSize[opcode]; 6453 } 6454 } 6455 } 6456} 6457 6458 6459 6460/* 6461 * Clients may call this function to help debug display list problems. 6462 * This function is _ONLY_FOR_DEBUGGING_PURPOSES_. It may be removed, 6463 * changed, or break in the future without notice. 6464 */ 6465void mesa_print_display_list( GLuint list ) 6466{ 6467 GET_CURRENT_CONTEXT(ctx); 6468 print_list( ctx, list ); 6469} 6470