ReactOS 0.4.15-dev-7681-g776c3a3
dlist.c
Go to the documentation of this file.
1/* $Id: dlist.c,v 1.37 1997/12/06 18:06:50 brianp Exp $ */
2
3/*
4 * Mesa 3-D graphics library
5 * Version: 2.6
6 * Copyright (C) 1995-1997 Brian Paul
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Library General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Library General Public License for more details.
17 *
18 * You should have received a copy of the GNU Library General Public
19 * License along with this library; if not, write to the Free
20 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23
24/*
25 * $Log: dlist.c,v $
26 * Revision 1.37 1997/12/06 18:06:50 brianp
27 * moved several static display list vars into GLcontext
28 *
29 * Revision 1.36 1997/11/25 03:20:09 brianp
30 * simple clean-ups for multi-threading (John Stone)
31 *
32 * Revision 1.35 1997/10/29 01:29:09 brianp
33 * added GL_EXT_point_parameters extension from Daniel Barrero
34 *
35 * Revision 1.34 1997/10/02 00:48:29 brianp
36 * removed the EXEC() macro stuff, it caused bugs in gl_save_Color*()
37 *
38 * Revision 1.33 1997/09/27 00:13:44 brianp
39 * added GL_EXT_paletted_texture extension
40 *
41 * Revision 1.32 1997/09/23 00:57:52 brianp
42 * removed list>MAX_DISPLAYLISTS test
43 *
44 * Revision 1.31 1997/09/22 02:33:58 brianp
45 * display lists now implemented with hash table
46 *
47 * Revision 1.30 1997/07/24 01:25:01 brianp
48 * changed precompiled header symbol from PCH to PC_HEADER
49 *
50 * Revision 1.29 1997/07/09 01:26:12 brianp
51 * fixed glDrawPixels() GL_COMPILE_AND_EXECUTE infinite loop (Renaud Cazoulat)
52 *
53 * Revision 1.28 1997/06/24 01:13:26 brianp
54 * initialize image RefCount to 1 for gl_save_TexSubImage[123]D()
55 *
56 * Revision 1.27 1997/06/20 01:57:57 brianp
57 * added gl_save_Color4ubv()
58 *
59 * Revision 1.26 1997/06/06 02:59:19 brianp
60 * renamed destroy_list() to gl_destroy_list()
61 *
62 * Revision 1.25 1997/05/28 03:24:22 brianp
63 * added precompiled header (PCH) support
64 *
65 * Revision 1.24 1997/05/27 03:13:41 brianp
66 * removed some debugging code
67 *
68 * Revision 1.23 1997/04/30 21:36:22 brianp
69 * added casts to gl_TexImage[123]D() calls
70 *
71 * Revision 1.22 1997/04/28 23:40:47 brianp
72 * added #include "rect.h"
73 *
74 * Revision 1.21 1997/04/24 01:50:53 brianp
75 * optimized glColor3f, glColor3fv, glColor4fv
76 *
77 * Revision 1.20 1997/04/24 00:30:17 brianp
78 * optimized glTexCoord2() code
79 *
80 * Revision 1.19 1997/04/21 01:21:33 brianp
81 * added gl_save_Rectf()
82 *
83 * Revision 1.18 1997/04/20 16:18:15 brianp
84 * added glOrtho and glFrustum API pointers
85 *
86 * Revision 1.17 1997/04/16 23:55:33 brianp
87 * added optimized glTexCoord2f code
88 *
89 * Revision 1.16 1997/04/14 22:18:23 brianp
90 * added optimized glVertex3fv code
91 *
92 * Revision 1.15 1997/04/14 02:00:39 brianp
93 * #include "texstate.h" instead of "texture.h"
94 *
95 * Revision 1.14 1997/04/07 02:58:49 brianp
96 * added gl_save_Vertex[23]f() and related code
97 *
98 * Revision 1.13 1997/04/01 04:26:02 brianp
99 * added code for glLoadIdentity(), changed #include's
100 *
101 * Revision 1.12 1997/02/27 19:58:08 brianp
102 * call gl_problem() instead of gl_warning()
103 *
104 * Revision 1.11 1997/02/09 18:50:18 brianp
105 * added GL_EXT_texture3D support
106 *
107 * Revision 1.10 1997/01/29 18:51:30 brianp
108 * small MEMCPY call change for Acorn compiler, per Graham Jones
109 *
110 * Revision 1.9 1997/01/09 21:25:28 brianp
111 * set reference count to one for texture images in display lists
112 *
113 * Revision 1.8 1996/12/11 20:19:11 brianp
114 * abort display list execution if invalid opcode found
115 *
116 * Revision 1.7 1996/12/09 21:39:23 brianp
117 * compare list to MAX_DISPLAYLISTS in gl_IsList()
118 *
119 * Revision 1.6 1996/12/04 22:14:27 brianp
120 * improved the mesa_print_display_list() debug function
121 *
122 * Revision 1.5 1996/11/07 04:12:45 brianp
123 * texture images are now gl_image structs, not gl_texture_image structs
124 *
125 * Revision 1.4 1996/10/16 00:59:12 brianp
126 * fixed bug in gl_save_Lightfv()
127 * execution of OPCODE_EDGE_FLAG used enum value instead of boolean
128 *
129 * Revision 1.3 1996/09/27 01:26:08 brianp
130 * removed unused variables
131 *
132 * Revision 1.2 1996/09/19 00:54:43 brianp
133 * fixed bug in gl_save_Rotatef() when in GL_COMPILE_AND_EXECUTE mode
134 *
135 * Revision 1.1 1996/09/13 01:38:16 brianp
136 * Initial revision
137 *
138 */
139
140
141#ifdef PC_HEADER
142#include "all.h"
143#else
144#include <assert.h>
145#include <stdio.h>
146#include <stdlib.h>
147#include <string.h>
148#include "accum.h"
149#include "alpha.h"
150#include "attrib.h"
151#include "bitmap.h"
152#include "blend.h"
153#include "clip.h"
154#include "colortab.h"
155#include "context.h"
156#include "copypix.h"
157#include "depth.h"
158#include "drawpix.h"
159#include "enable.h"
160#include "eval.h"
161#include "feedback.h"
162#include "fog.h"
163#include "hash.h"
164#include "image.h"
165#include "light.h"
166#include "lines.h"
167#include "dlist.h"
168#include "logic.h"
169#include "macros.h"
170#include "masking.h"
171#include "matrix.h"
172#include "misc.h"
173#include "pixel.h"
174#include "points.h"
175#include "polygon.h"
176#include "rastpos.h"
177#include "rect.h"
178#include "scissor.h"
179#include "stencil.h"
180#include "texobj.h"
181#include "teximage.h"
182#include "texstate.h"
183#include "types.h"
184#include "vb.h"
185#include "vbfill.h"
186#endif
187
188
189
190/*
191Functions which aren't compiled but executed immediately:
192 glIsList
193 glGenLists
194 glDeleteLists
195 glEndList
196 glFeedbackBuffer
197 glSelectBuffer
198 glRenderMode
199 glReadPixels
200 glPixelStore
201 glFlush
202 glFinish
203 glIsEnabled
204 glGet*
205
206Functions which cause errors if called while compiling a display list:
207 glNewList
208*/
209
210
211
212/*
213 * Display list instructions are stored as sequences of "nodes". Nodes
214 * are allocated in blocks. Each block has BLOCK_SIZE nodes. Blocks
215 * are linked together with a pointer.
216 */
217
218
219/* How many nodes to allocate at a time: */
220#define BLOCK_SIZE 500
221
222
223/*
224 * Display list opcodes.
225 *
226 * The fact that these identifiers are assigned consecutive
227 * integer values starting at 0 is very important, see InstSize array usage)
228 */
229typedef enum {
337 /* The following two are meta instructions */
341
342
343/*
344 * Each instruction in the display list is stored as a sequence of
345 * contiguous nodes in memory.
346 * Each node is the union of a variety of datatypes.
347 */
348union node {
360 void *next; /* If prev node's opcode==OPCODE_CONTINUE */
361};
362
363
364
365/* Number of nodes of storage needed for each instruction: */
367
368
369
370/**********************************************************************/
371/***** Private *****/
372/**********************************************************************/
373
374
375/*
376 * Allocate space for a display list instruction.
377 * Input: opcode - type of instruction
378 * argcount - number of arguments following the instruction
379 * Return: pointer to first node in the instruction
380 */
381static Node *alloc_instruction( GLcontext *ctx, OpCode opcode, GLint argcount )
382{
383 Node *n, *newblock;
384 GLuint count = InstSize[opcode];
385
386 assert( count == argcount+1 );
387
388 if (ctx->CurrentPos + count + 2 > BLOCK_SIZE) {
389 /* This block is full. Allocate a new block and chain to it */
390 n = ctx->CurrentBlock + ctx->CurrentPos;
391 n[0].opcode = OPCODE_CONTINUE;
392 newblock = (Node *) malloc( sizeof(Node) * BLOCK_SIZE );
393 if (!newblock) {
394 gl_error( ctx, GL_OUT_OF_MEMORY, "Building display list" );
395 return NULL;
396 }
397 n[1].next = (Node *) newblock;
398 ctx->CurrentBlock = newblock;
399 ctx->CurrentPos = 0;
400 }
401
402 n = ctx->CurrentBlock + ctx->CurrentPos;
403 ctx->CurrentPos += count;
404
405 n[0].opcode = opcode;
406
407 return n;
408}
409
410
411
412/*
413 * Make an empty display list. This is used by glGenLists() to
414 * reserver display list IDs.
415 */
416static Node *make_empty_list( void )
417{
418 Node *n = (Node *) malloc( sizeof(Node) );
419 n[0].opcode = OPCODE_END_OF_LIST;
420 return n;
421}
422
423
424
425/*
426 * Destroy all nodes in a display list.
427 * Input: list - display list number
428 */
430{
431 Node *n, *block;
432 GLboolean done;
433
434 block = (Node *) HashLookup(ctx->Shared->DisplayList, list);
435 n = block;
436
437 done = block ? GL_FALSE : GL_TRUE;
438 while (!done) {
439 switch (n[0].opcode) {
440 /* special cases first */
441 case OPCODE_MAP1:
442 gl_free_control_points( ctx, n[1].e, (GLfloat *) n[6].data );
443 n += InstSize[n[0].opcode];
444 break;
445 case OPCODE_MAP2:
446 gl_free_control_points( ctx, n[1].e, (GLfloat *) n[10].data );
447 n += InstSize[n[0].opcode];
448 break;
450 free( n[5].data );
451 n += InstSize[n[0].opcode];
452 break;
453 case OPCODE_BITMAP:
454 gl_free_image( (struct gl_image *) n[7].data );
455 n += InstSize[n[0].opcode];
456 break;
458 gl_free_image( (struct gl_image *) n[3].data );
459 n += InstSize[n[0].opcode];
460 break;
462 gl_free_image( (struct gl_image *) n[3].data );
463 n += InstSize[n[0].opcode];
464 break;
466 free( n[1].data );
467 n += InstSize[n[0].opcode];
468 break;
470 gl_free_image( (struct gl_image *) n[8].data );
471 n += InstSize[n[0].opcode];
472 break;
474 gl_free_image( (struct gl_image *) n[9].data );
475 n += InstSize[n[0].opcode];
476 break;
478 {
479 struct gl_image *image;
480 image = (struct gl_image *) n[7].data;
482 }
483 break;
485 {
486 struct gl_image *image;
487 image = (struct gl_image *) n[9].data;
489 }
490 break;
491 case OPCODE_CONTINUE:
492 n = (Node *) n[1].next;
493 free( block );
494 block = n;
495 break;
497 free( block );
498 done = GL_TRUE;
499 break;
500 default:
501 /* Most frequent case */
502 n += InstSize[n[0].opcode];
503 break;
504 }
505 }
506
507 HashRemove(ctx->Shared->DisplayList, list);
508}
509
510
511
512/*
513 * Translate the nth element of list from type to GLuint.
514 */
516{
517 GLbyte *bptr;
518 GLubyte *ubptr;
519 GLshort *sptr;
520 GLushort *usptr;
521 GLint *iptr;
522 GLuint *uiptr;
523 GLfloat *fptr;
524
525 switch (type) {
526 case GL_BYTE:
527 bptr = (GLbyte *) list;
528 return (GLuint) *(bptr+n);
529 case GL_UNSIGNED_BYTE:
530 ubptr = (GLubyte *) list;
531 return (GLuint) *(ubptr+n);
532 case GL_SHORT:
533 sptr = (GLshort *) list;
534 return (GLuint) *(sptr+n);
536 usptr = (GLushort *) list;
537 return (GLuint) *(usptr+n);
538 case GL_INT:
539 iptr = (GLint *) list;
540 return (GLuint) *(iptr+n);
541 case GL_UNSIGNED_INT:
542 uiptr = (GLuint *) list;
543 return (GLuint) *(uiptr+n);
544 case GL_FLOAT:
545 fptr = (GLfloat *) list;
546 return (GLuint) *(fptr+n);
547 case GL_2_BYTES:
548 ubptr = ((GLubyte *) list) + 2*n;
549 return (GLuint) *ubptr * 256 + (GLuint) *(ubptr+1);
550 case GL_3_BYTES:
551 ubptr = ((GLubyte *) list) + 3*n;
552 return (GLuint) *ubptr * 65536
553 + (GLuint) *(ubptr+1) * 256
554 + (GLuint) *(ubptr+2);
555 case GL_4_BYTES:
556 ubptr = ((GLubyte *) list) + 4*n;
557 return (GLuint) *ubptr * 16777216
558 + (GLuint) *(ubptr+1) * 65536
559 + (GLuint) *(ubptr+2) * 256
560 + (GLuint) *(ubptr+3);
561 default:
562 return 0;
563 }
564}
565
566
567
568
569/**********************************************************************/
570/***** Public *****/
571/**********************************************************************/
572
573void gl_init_lists( void )
574{
575 static int init_flag = 0;
576
577 if (init_flag==0) {
614 InstSize[OPCODE_END] = 1;
621 InstSize[OPCODE_FOG] = 6;
638 InstSize[OPCODE_MAP2] = 11;
686 }
687 init_flag = 1;
688}
689
690
691/*
692 * Display List compilation functions
693 */
694
695
697{
699 if (n) {
700 n[1].e = op;
701 n[2].f = value;
702 }
703 if (ctx->ExecuteFlag) {
704 (*ctx->Exec.Accum)( ctx, op, value );
705 }
706}
707
708
710{
712 if (n) {
713 n[1].e = func;
714 n[2].f = (GLfloat) ref;
715 }
716 if (ctx->ExecuteFlag) {
717 (*ctx->Exec.AlphaFunc)( ctx, func, ref );
718 }
719}
720
721
723{
725 if (n) {
726 n[1].e = mode;
727 }
728 if (ctx->ExecuteFlag) {
729 (*ctx->Exec.Begin)( ctx, mode );
730 }
731}
732
733
735{
737 if (n) {
738 n[1].e = target;
739 n[2].ui = texture;
740 }
741 if (ctx->ExecuteFlag) {
742 (*ctx->Exec.BindTexture)( ctx, target, texture );
743 }
744}
745
746
749 GLfloat xorig, GLfloat yorig,
750 GLfloat xmove, GLfloat ymove,
751 const struct gl_image *bitmap )
752{
754 if (n) {
755 n[1].i = (GLint) width;
756 n[2].i = (GLint) height;
757 n[3].f = xorig;
758 n[4].f = yorig;
759 n[5].f = xmove;
760 n[6].f = ymove;
761 n[7].data = (void *) bitmap;
762 }
763 if (ctx->ExecuteFlag) {
764 (*ctx->Exec.Bitmap)( ctx, width, height,
765 xorig, yorig, xmove, ymove, bitmap );
766 }
767}
768
769
771{
773 if (n) {
774 n[1].e = sfactor;
775 n[2].e = dfactor;
776 }
777 if (ctx->ExecuteFlag) {
778 (*ctx->Exec.BlendFunc)( ctx, sfactor, dfactor );
779 }
780}
781
782
784{
786 if (n) {
787 n[1].ui = list;
788 }
789 if (ctx->ExecuteFlag) {
790 (*ctx->Exec.CallList)( ctx, list );
791 }
792}
793
794
796 GLsizei n, GLenum type, const GLvoid *lists )
797{
798 GLuint i;
799
800 for (i=0;i<n;i++) {
803 if (n) {
804 n[1].ui = list;
805 }
806 }
807 if (ctx->ExecuteFlag) {
808 (*ctx->Exec.CallLists)( ctx, n, type, lists );
809 }
810}
811
812
814{
816 if (n) {
817 n[1].bf = mask;
818 }
819 if (ctx->ExecuteFlag) {
820 (*ctx->Exec.Clear)( ctx, mask );
821 }
822}
823
824
827{
829 if (n) {
830 n[1].f = red;
831 n[2].f = green;
832 n[3].f = blue;
833 n[4].f = alpha;
834 }
835 if (ctx->ExecuteFlag) {
836 (*ctx->Exec.ClearAccum)( ctx, red, green, blue, alpha );
837 }
838}
839
840
843{
845 if (n) {
846 n[1].f = red;
847 n[2].f = green;
848 n[3].f = blue;
849 n[4].f = alpha;
850 }
851 if (ctx->ExecuteFlag) {
852 (*ctx->Exec.ClearColor)( ctx, red, green, blue, alpha );
853 }
854}
855
856
858{
860 if (n) {
861 n[1].f = (GLfloat) depth;
862 }
863 if (ctx->ExecuteFlag) {
864 (*ctx->Exec.ClearDepth)( ctx, depth );
865 }
866}
867
868
870{
872 if (n) {
873 n[1].f = c;
874 }
875 if (ctx->ExecuteFlag) {
876 (*ctx->Exec.ClearIndex)( ctx, c );
877 }
878}
879
880
882{
884 if (n) {
885 n[1].i = s;
886 }
887 if (ctx->ExecuteFlag) {
888 (*ctx->Exec.ClearStencil)( ctx, s );
889 }
890}
891
892
894{
896 if (n) {
897 n[1].e = plane;
898 n[2].f = equ[0];
899 n[3].f = equ[1];
900 n[4].f = equ[2];
901 n[5].f = equ[3];
902 }
903 if (ctx->ExecuteFlag) {
904 (*ctx->Exec.ClipPlane)( ctx, plane, equ );
905 }
906}
907
908
910{
912 if (n) {
913 n[1].f = r;
914 n[2].f = g;
915 n[3].f = b;
916 }
917 if (ctx->ExecuteFlag) {
918 (*ctx->Exec.Color3f)( ctx, r, g, b );
919 }
920}
921
922
924{
926 if (n) {
927 n[1].f = c[0];
928 n[2].f = c[1];
929 n[3].f = c[2];
930 }
931 if (ctx->ExecuteFlag) {
932 (*ctx->Exec.Color3fv)( ctx, c );
933 }
934}
935
936
938 GLfloat b, GLfloat a )
939{
941 if (n) {
942 n[1].f = r;
943 n[2].f = g;
944 n[3].f = b;
945 n[4].f = a;
946 }
947 if (ctx->ExecuteFlag) {
948 (*ctx->Exec.Color4f)( ctx, r, g, b, a );
949 }
950}
951
952
954{
956 if (n) {
957 n[1].f = c[0];
958 n[2].f = c[1];
959 n[3].f = c[2];
960 n[4].f = c[3];
961 }
962 if (ctx->ExecuteFlag) {
963 (*ctx->Exec.Color4fv)( ctx, c );
964 }
965}
966
967
969 GLubyte b, GLubyte a )
970{
972 if (n) {
973 n[1].ub = r;
974 n[2].ub = g;
975 n[3].ub = b;
976 n[4].ub = a;
977 }
978 if (ctx->ExecuteFlag) {
979 (*ctx->Exec.Color4ub)( ctx, r, g, b, a );
980 }
981}
982
983
985{
987 if (n) {
988 n[1].ub = c[0];
989 n[2].ub = c[1];
990 n[3].ub = c[2];
991 n[4].ub = c[3];
992 }
993 if (ctx->ExecuteFlag) {
994 (*ctx->Exec.Color4ubv)( ctx, c );
995 }
996}
997
998
1001{
1003 if (n) {
1004 n[1].b = red;
1005 n[2].b = green;
1006 n[3].b = blue;
1007 n[4].b = alpha;
1008 }
1009 if (ctx->ExecuteFlag) {
1010 (*ctx->Exec.ColorMask)( ctx, red, green, blue, alpha );
1011 }
1012}
1013
1014
1016{
1018 if (n) {
1019 n[1].e = face;
1020 n[2].e = mode;
1021 }
1022 if (ctx->ExecuteFlag) {
1023 (*ctx->Exec.ColorMaterial)( ctx, face, mode );
1024 }
1025}
1026
1027
1029 struct gl_image *table )
1030{
1032 if (n) {
1033 n[1].e = target;
1034 n[2].e = internalFormat;
1035 n[3].data = (GLvoid *) table;
1036 if (table) {
1037 /* must retain this image */
1038 table->RefCount = 1;
1039 }
1040 }
1041 if (ctx->ExecuteFlag) {
1042 (*ctx->Exec.ColorTable)( ctx, target, internalFormat, table );
1043 }
1044}
1045
1046
1048 GLsizei start, struct gl_image *data )
1049{
1051 if (n) {
1052 n[1].e = target;
1053 n[2].i = start;
1054 n[3].data = (GLvoid *) data;
1055 if (data) {
1056 /* must retain this image */
1057 data->RefCount = 1;
1058 }
1059 }
1060 if (ctx->ExecuteFlag) {
1061 (*ctx->Exec.ColorSubTable)( ctx, target, start, data );
1062 }
1063}
1064
1065
1066
1069{
1071 if (n) {
1072 n[1].i = x;
1073 n[2].i = y;
1074 n[3].i = (GLint) width;
1075 n[4].i = (GLint) height;
1076 n[5].e = type;
1077 }
1078 if (ctx->ExecuteFlag) {
1079 (*ctx->Exec.CopyPixels)( ctx, x, y, width, height, type );
1080 }
1081}
1082
1083
1084
1089 GLint border )
1090{
1092 if (n) {
1093 n[1].e = target;
1094 n[2].i = level;
1095 n[3].e = internalformat;
1096 n[4].i = x;
1097 n[5].i = y;
1098 n[6].i = width;
1099 n[7].i = border;
1100 }
1101 if (ctx->ExecuteFlag) {
1102 (*ctx->Exec.CopyTexImage1D)( ctx, target, level, internalformat,
1103 x, y, width, border );
1104 }
1105}
1106
1107
1113{
1115 if (n) {
1116 n[1].e = target;
1117 n[2].i = level;
1118 n[3].e = internalformat;
1119 n[4].i = x;
1120 n[5].i = y;
1121 n[6].i = width;
1122 n[7].i = height;
1123 n[8].i = border;
1124 }
1125 if (ctx->ExecuteFlag) {
1126 (*ctx->Exec.CopyTexImage2D)( ctx, target, level, internalformat,
1127 x, y, width, height, border );
1128 }
1129}
1130
1131
1132
1136 GLsizei width )
1137{
1139 if (n) {
1140 n[1].e = target;
1141 n[2].i = level;
1142 n[3].i = xoffset;
1143 n[4].i = x;
1144 n[5].i = y;
1145 n[6].i = width;
1146 }
1147 if (ctx->ExecuteFlag) {
1148 (*ctx->Exec.CopyTexSubImage1D)( ctx, target, level, xoffset, x, y, width );
1149 }
1150}
1151
1152
1156 GLint x, GLint y,
1158{
1160 if (n) {
1161 n[1].e = target;
1162 n[2].i = level;
1163 n[3].i = xoffset;
1164 n[4].i = yoffset;
1165 n[5].i = x;
1166 n[6].i = y;
1167 n[7].i = width;
1168 n[8].i = height;
1169 }
1170 if (ctx->ExecuteFlag) {
1171 (*ctx->Exec.CopyTexSubImage2D)( ctx, target, level, xoffset, yoffset,
1172 x, y, width, height );
1173 }
1174}
1175
1177{
1179 if (n) {
1180 n[1].e = mode;
1181 }
1182 if (ctx->ExecuteFlag) {
1183 (*ctx->Exec.CullFace)( ctx, mode );
1184 }
1185}
1186
1187
1189{
1191 if (n) {
1192 n[1].e = func;
1193 }
1194 if (ctx->ExecuteFlag) {
1195 (*ctx->Exec.DepthFunc)( ctx, func );
1196 }
1197}
1198
1199
1201{
1203 if (n) {
1204 n[1].b = mask;
1205 }
1206 if (ctx->ExecuteFlag) {
1207 (*ctx->Exec.DepthMask)( ctx, mask );
1208 }
1209}
1210
1211
1213{
1215 if (n) {
1216 n[1].f = (GLfloat) nearval;
1217 n[2].f = (GLfloat) farval;
1218 }
1219 if (ctx->ExecuteFlag) {
1220 (*ctx->Exec.DepthRange)( ctx, nearval, farval );
1221 }
1222}
1223
1224
1226{
1228 if (n) {
1229 n[1].e = cap;
1230 }
1231 if (ctx->ExecuteFlag) {
1232 (*ctx->Exec.Disable)( ctx, cap );
1233 }
1234}
1235
1236
1238{
1240 if (n) {
1241 n[1].e = mode;
1242 }
1243 if (ctx->ExecuteFlag) {
1244 (*ctx->Exec.DrawBuffer)( ctx, mode );
1245 }
1246}
1247
1248
1251{
1253 if (n) {
1254 n[1].i = (GLint) width;
1255 n[2].i = (GLint) height;
1256 n[3].e = format;
1257 n[4].e = type;
1258 n[5].data = (GLvoid *) pixels;
1259 }
1260/* Special case: gl_DrawPixels takes care of GL_COMPILE_AND_EXECUTE case!
1261 if (ctx->ExecuteFlag) {
1262 (*ctx->Exec.DrawPixels)( ctx, width, height, format, type, pixels );
1263 }
1264*/
1265}
1266
1267
1269{
1271 if (n) {
1272 n[1].b = flag;
1273 }
1274 if (ctx->ExecuteFlag) {
1275 (*ctx->Exec.EdgeFlag)( ctx, flag );
1276 }
1277}
1278
1279
1281{
1283 if (n) {
1284 n[1].e = cap;
1285 }
1286 if (ctx->ExecuteFlag) {
1287 (*ctx->Exec.Enable)( ctx, cap );
1288 }
1289}
1290
1291
1293{
1295 if (ctx->ExecuteFlag) {
1296 (*ctx->Exec.End)( ctx );
1297 }
1298}
1299
1300
1302{
1304 if (n) {
1305 n[1].f = u;
1306 }
1307 if (ctx->ExecuteFlag) {
1308 (*ctx->Exec.EvalCoord1f)( ctx, u );
1309 }
1310}
1311
1312
1314{
1316 if (n) {
1317 n[1].f = u;
1318 n[2].f = v;
1319 }
1320 if (ctx->ExecuteFlag) {
1321 (*ctx->Exec.EvalCoord2f)( ctx, u, v );
1322 }
1323}
1324
1325
1327 GLenum mode, GLint i1, GLint i2 )
1328{
1330 if (n) {
1331 n[1].e = mode;
1332 n[2].i = i1;
1333 n[3].i = i2;
1334 }
1335 if (ctx->ExecuteFlag) {
1336 (*ctx->Exec.EvalMesh1)( ctx, mode, i1, i2 );
1337 }
1338}
1339
1340
1342 GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
1343{
1345 if (n) {
1346 n[1].e = mode;
1347 n[2].i = i1;
1348 n[3].i = i2;
1349 n[4].i = j1;
1350 n[5].i = j2;
1351 }
1352 if (ctx->ExecuteFlag) {
1353 (*ctx->Exec.EvalMesh2)( ctx, mode, i1, i2, j1, j2 );
1354 }
1355}
1356
1357
1359{
1361 if (n) {
1362 n[1].i = i;
1363 }
1364 if (ctx->ExecuteFlag) {
1365 (*ctx->Exec.EvalPoint1)( ctx, i );
1366 }
1367}
1368
1369
1371{
1373 if (n) {
1374 n[1].i = i;
1375 n[2].i = j;
1376 }
1377 if (ctx->ExecuteFlag) {
1378 (*ctx->Exec.EvalPoint2)( ctx, i, j );
1379 }
1380}
1381
1382
1384{
1386 if (n) {
1387 n[1].e = pname;
1388 n[2].f = params[0];
1389 n[3].f = params[1];
1390 n[4].f = params[2];
1391 n[5].f = params[3];
1392 }
1393 if (ctx->ExecuteFlag) {
1394 (*ctx->Exec.Fogfv)( ctx, pname, params );
1395 }
1396}
1397
1398
1400{
1402 if (n) {
1403 n[1].e = mode;
1404 }
1405 if (ctx->ExecuteFlag) {
1406 (*ctx->Exec.FrontFace)( ctx, mode );
1407 }
1408}
1409
1410
1413 GLdouble nearval, GLdouble farval )
1414{
1416 if (n) {
1417 n[1].f = left;
1418 n[2].f = right;
1419 n[3].f = bottom;
1420 n[4].f = top;
1421 n[5].f = nearval;
1422 n[6].f = farval;
1423 }
1424 if (ctx->ExecuteFlag) {
1425 (*ctx->Exec.Frustum)( ctx, left, right, bottom, top, nearval, farval );
1426 }
1427}
1428
1429
1431{
1433 if (n) {
1434 n[1].e = target;
1435 n[2].e = mode;
1436 }
1437 if (ctx->ExecuteFlag) {
1438 (*ctx->Exec.Hint)( ctx, target, mode );
1439 }
1440}
1441
1442
1444{
1446 if (n) {
1447 n[1].i = index;
1448 }
1449 if (ctx->ExecuteFlag) {
1450 (*ctx->Exec.Indexi)( ctx, index );
1451 }
1452}
1453
1454
1456{
1458 if (n) {
1459 n[1].i = (GLint) index;
1460 }
1461 if (ctx->ExecuteFlag) {
1462 (*ctx->Exec.Indexf)( ctx,index );
1463 }
1464}
1465
1466
1468{
1470 if (n) {
1471 n[1].ui = mask;
1472 }
1473 if (ctx->ExecuteFlag) {
1474 (*ctx->Exec.IndexMask)( ctx, mask );
1475 }
1476}
1477
1478
1480{
1482 if (ctx->ExecuteFlag) {
1483 (*ctx->Exec.InitNames)( ctx );
1484 }
1485}
1486
1487
1489 const GLfloat *params, GLint numparams )
1490{
1492 if (OPCODE_LIGHT) {
1493 GLint i;
1494 n[1].e = light;
1495 n[2].e = pname;
1496 for (i=0;i<numparams;i++) {
1497 n[3+i].f = params[i];
1498 }
1499 }
1500 if (ctx->ExecuteFlag) {
1501 (*ctx->Exec.Lightfv)( ctx, light, pname, params, numparams );
1502 }
1503}
1504
1505
1507 GLenum pname, const GLfloat *params )
1508{
1510 if (n) {
1511 n[1].e = pname;
1512 n[2].f = params[0];
1513 n[3].f = params[1];
1514 n[4].f = params[2];
1515 n[5].f = params[3];
1516 }
1517 if (ctx->ExecuteFlag) {
1518 (*ctx->Exec.LightModelfv)( ctx, pname, params );
1519 }
1520}
1521
1522
1524{
1526 if (n) {
1527 n[1].i = factor;
1528 n[2].us = pattern;
1529 }
1530 if (ctx->ExecuteFlag) {
1531 (*ctx->Exec.LineStipple)( ctx, factor, pattern );
1532 }
1533}
1534
1535
1537{
1539 if (n) {
1540 n[1].f = width;
1541 }
1542 if (ctx->ExecuteFlag) {
1543 (*ctx->Exec.LineWidth)( ctx, width );
1544 }
1545}
1546
1547
1549{
1551 if (n) {
1552 n[1].ui = base;
1553 }
1554 if (ctx->ExecuteFlag) {
1555 (*ctx->Exec.ListBase)( ctx, base );
1556 }
1557}
1558
1559
1561{
1563 if (ctx->ExecuteFlag) {
1564 (*ctx->Exec.LoadIdentity)( ctx );
1565 }
1566}
1567
1568
1570{
1572 if (n) {
1573 GLuint i;
1574 for (i=0;i<16;i++) {
1575 n[1+i].f = m[i];
1576 }
1577 }
1578 if (ctx->ExecuteFlag) {
1579 (*ctx->Exec.LoadMatrixf)( ctx, m );
1580 }
1581}
1582
1583
1585{
1587 if (n) {
1588 n[1].ui = name;
1589 }
1590 if (ctx->ExecuteFlag) {
1591 (*ctx->Exec.LoadName)( ctx, name );
1592 }
1593}
1594
1595
1597{
1599 if (n) {
1600 n[1].e = opcode;
1601 }
1602 if (ctx->ExecuteFlag) {
1603 (*ctx->Exec.LogicOp)( ctx, opcode );
1604 }
1605}
1606
1607
1610 GLint order, const GLfloat *points, GLboolean retain )
1611{
1613 if (n) {
1614 n[1].e = target;
1615 n[2].f = u1;
1616 n[3].f = u2;
1617 n[4].i = stride;
1618 n[5].i = order;
1619 n[6].data = (void *) points;
1620 }
1621 if (ctx->ExecuteFlag) {
1622 (*ctx->Exec.Map1f)( ctx, target, u1, u2, stride, order, points, GL_TRUE );
1623 }
1624}
1625
1626
1630 const GLfloat *points, GLboolean retain )
1631{
1633 if (n) {
1634 n[1].e = target;
1635 n[2].f = u1;
1636 n[3].f = u2;
1637 n[4].f = v1;
1638 n[5].f = v2;
1639 n[6].i = ustride;
1640 n[7].i = vstride;
1641 n[8].i = uorder;
1642 n[9].i = vorder;
1643 n[10].data = (void *) points;
1644 }
1645 if (ctx->ExecuteFlag) {
1646 (*ctx->Exec.Map2f)( ctx, target,
1647 u1, u2, ustride, uorder,
1649 }
1650}
1651
1652
1654{
1656 if (n) {
1657 n[1].i = un;
1658 n[2].f = u1;
1659 n[3].f = u2;
1660 }
1661 if (ctx->ExecuteFlag) {
1662 (*ctx->Exec.MapGrid1f)( ctx, un, u1, u2 );
1663 }
1664}
1665
1666
1670{
1672 if (n) {
1673 n[1].i = un;
1674 n[2].f = u1;
1675 n[3].f = u2;
1676 n[4].i = vn;
1677 n[5].f = v1;
1678 n[6].f = v2;
1679 }
1680 if (ctx->ExecuteFlag) {
1681 (*ctx->Exec.MapGrid2f)( ctx, un, u1, u2, vn, v1, v2 );
1682 }
1683}
1684
1685
1688{
1690 if (n) {
1691 n[1].e = face;
1692 n[2].e = pname;
1693 n[3].f = params[0];
1694 n[4].f = params[1];
1695 n[5].f = params[2];
1696 n[6].f = params[3];
1697 }
1698 if (ctx->ExecuteFlag) {
1699 (*ctx->Exec.Materialfv)( ctx, face, pname, params );
1700 }
1701}
1702
1703
1705{
1707 if (n) {
1708 n[1].e = mode;
1709 }
1710 if (ctx->ExecuteFlag) {
1711 (*ctx->Exec.MatrixMode)( ctx, mode );
1712 }
1713}
1714
1715
1717{
1719 if (n) {
1720 GLuint i;
1721 for (i=0;i<16;i++) {
1722 n[1+i].f = m[i];
1723 }
1724 }
1725 if (ctx->ExecuteFlag) {
1726 (*ctx->Exec.MultMatrixf)( ctx, m );
1727 }
1728}
1729
1730
1732{
1733 /* It's an error to call this function while building a display list */
1734 gl_error( ctx, GL_INVALID_OPERATION, "glNewList" );
1735}
1736
1737
1739{
1741 if (n) {
1742 n[1].f = norm[0];
1743 n[2].f = norm[1];
1744 n[3].f = norm[2];
1745 }
1746 if (ctx->ExecuteFlag) {
1747 (*ctx->Exec.Normal3fv)( ctx, norm );
1748 }
1749}
1750
1751
1753{
1755 if (n) {
1756 n[1].f = nx;
1757 n[2].f = ny;
1758 n[3].f = nz;
1759 }
1760 if (ctx->ExecuteFlag) {
1761 (*ctx->Exec.Normal3f)( ctx, nx, ny, nz );
1762 }
1763}
1764
1765
1768 GLdouble nearval, GLdouble farval )
1769{
1771 if (n) {
1772 n[1].f = left;
1773 n[2].f = right;
1774 n[3].f = bottom;
1775 n[4].f = top;
1776 n[5].f = nearval;
1777 n[6].f = farval;
1778 }
1779 if (ctx->ExecuteFlag) {
1780 (*ctx->Exec.Ortho)( ctx, left, right, bottom, top, nearval, farval );
1781 }
1782}
1783
1784
1787{
1789 if (n) {
1790 n[1].e = map;
1791 n[2].i = mapsize;
1792 n[3].data = (void *) malloc( mapsize * sizeof(GLfloat) );
1793 MEMCPY( n[3].data, (void *) values, mapsize * sizeof(GLfloat) );
1794 }
1795 if (ctx->ExecuteFlag) {
1796 (*ctx->Exec.PixelMapfv)( ctx, map, mapsize, values );
1797 }
1798}
1799
1800
1802{
1804 if (n) {
1805 n[1].e = pname;
1806 n[2].f = param;
1807 }
1808 if (ctx->ExecuteFlag) {
1809 (*ctx->Exec.PixelTransferf)( ctx, pname, param );
1810 }
1811}
1812
1813
1815{
1817 if (n) {
1818 n[1].f = xfactor;
1819 n[2].f = yfactor;
1820 }
1821 if (ctx->ExecuteFlag) {
1822 (*ctx->Exec.PixelZoom)( ctx, xfactor, yfactor );
1823 }
1824}
1825
1826
1828{
1830 if (n) {
1831 n[1].f = size;
1832 }
1833 if (ctx->ExecuteFlag) {
1834 (*ctx->Exec.PointSize)( ctx, size );
1835 }
1836}
1837
1838
1840{
1842 if (n) {
1843 n[1].e = face;
1844 n[2].e = mode;
1845 }
1846 if (ctx->ExecuteFlag) {
1847 (*ctx->Exec.PolygonMode)( ctx, face, mode );
1848 }
1849}
1850
1851
1853{
1855 if (n) {
1856 void *data;
1857 n[1].data = malloc( 32 * 4 );
1858 data = n[1].data; /* This needed for Acorn compiler */
1859 MEMCPY( data, mask, 32 * 4 );
1860 }
1861 if (ctx->ExecuteFlag) {
1862 (*ctx->Exec.PolygonStipple)( ctx, mask );
1863 }
1864}
1865
1866
1868{
1870 if (n) {
1871 n[1].f = factor;
1872 n[2].f = units;
1873 }
1874 if (ctx->ExecuteFlag) {
1875 (*ctx->Exec.PolygonOffset)( ctx, factor, units );
1876 }
1877}
1878
1879
1881{
1883 if (ctx->ExecuteFlag) {
1884 (*ctx->Exec.PopAttrib)( ctx );
1885 }
1886}
1887
1888
1890{
1892 if (ctx->ExecuteFlag) {
1893 (*ctx->Exec.PopMatrix)( ctx );
1894 }
1895}
1896
1897
1899{
1901 if (ctx->ExecuteFlag) {
1902 (*ctx->Exec.PopName)( ctx );
1903 }
1904}
1905
1906
1908 GLsizei num, const GLuint *textures,
1909 const GLclampf *priorities )
1910{
1911 GLint i;
1912
1913 for (i=0;i<num;i++) {
1915 if (n) {
1916 n[1].ui = textures[i];
1917 n[2].f = priorities[i];
1918 }
1919 }
1920 if (ctx->ExecuteFlag) {
1921 (*ctx->Exec.PrioritizeTextures)( ctx, num, textures, priorities );
1922 }
1923}
1924
1925
1927{
1929 if (n) {
1930 n[1].bf = mask;
1931 }
1932 if (ctx->ExecuteFlag) {
1933 (*ctx->Exec.PushAttrib)( ctx, mask );
1934 }
1935}
1936
1937
1939{
1941 if (ctx->ExecuteFlag) {
1942 (*ctx->Exec.PushMatrix)( ctx );
1943 }
1944}
1945
1946
1948{
1950 if (n) {
1951 n[1].ui = name;
1952 }
1953 if (ctx->ExecuteFlag) {
1954 (*ctx->Exec.PushName)( ctx, name );
1955 }
1956}
1957
1958
1961{
1963 if (n) {
1964 n[1].f = x;
1965 n[2].f = y;
1966 n[3].f = z;
1967 n[4].f = w;
1968 }
1969 if (ctx->ExecuteFlag) {
1970 (*ctx->Exec.RasterPos4f)( ctx, x, y, z, w );
1971 }
1972}
1973
1974
1976{
1978 if (n) {
1979 n[1].f = token;
1980 }
1981 if (ctx->ExecuteFlag) {
1982 (*ctx->Exec.PassThrough)( ctx, token );
1983 }
1984}
1985
1986
1988{
1990 if (n) {
1991 n[1].e = mode;
1992 }
1993 if (ctx->ExecuteFlag) {
1994 (*ctx->Exec.ReadBuffer)( ctx, mode );
1995 }
1996}
1997
1998
2001{
2003 if (n) {
2004 n[1].f = x1;
2005 n[2].f = y1;
2006 n[3].f = x2;
2007 n[4].f = y2;
2008 }
2009 if (ctx->ExecuteFlag) {
2010 (*ctx->Exec.Rectf)( ctx, x1, y1, x2, y2 );
2011 }
2012}
2013
2014
2017{
2018 GLfloat m[16];
2019 gl_rotation_matrix( angle, x, y, z, m );
2020 gl_save_MultMatrixf( ctx, m ); /* save and maybe execute */
2021}
2022
2023
2025{
2027 if (n) {
2028 n[1].f = x;
2029 n[2].f = y;
2030 n[3].f = z;
2031 }
2032 if (ctx->ExecuteFlag) {
2033 (*ctx->Exec.Scalef)( ctx, x, y, z );
2034 }
2035}
2036
2037
2040{
2042 if (n) {
2043 n[1].i = x;
2044 n[2].i = y;
2045 n[3].i = width;
2046 n[4].i = height;
2047 }
2048 if (ctx->ExecuteFlag) {
2049 (*ctx->Exec.Scissor)( ctx, x, y, width, height );
2050 }
2051}
2052
2053
2055{
2057 if (n) {
2058 n[1].e = mode;
2059 }
2060 if (ctx->ExecuteFlag) {
2061 (*ctx->Exec.ShadeModel)( ctx, mode );
2062 }
2063}
2064
2065
2067{
2069 if (n) {
2070 n[1].e = func;
2071 n[2].i = ref;
2072 n[3].ui = mask;
2073 }
2074 if (ctx->ExecuteFlag) {
2075 (*ctx->Exec.StencilFunc)( ctx, func, ref, mask );
2076 }
2077}
2078
2079
2081{
2083 if (n) {
2084 n[1].ui = mask;
2085 }
2086 if (ctx->ExecuteFlag) {
2087 (*ctx->Exec.StencilMask)( ctx, mask );
2088 }
2089}
2090
2091
2093 GLenum fail, GLenum zfail, GLenum zpass )
2094{
2096 if (n) {
2097 n[1].e = fail;
2098 n[2].e = zfail;
2099 n[3].e = zpass;
2100 }
2101 if (ctx->ExecuteFlag) {
2102 (*ctx->Exec.StencilOp)( ctx, fail, zfail, zpass );
2103 }
2104}
2105
2106
2108{
2110 if (n) {
2111 n[1].f = s;
2112 n[2].f = t;
2113 }
2114 if (ctx->ExecuteFlag) {
2115 (*ctx->Exec.TexCoord2f)( ctx, s, t );
2116 }
2117}
2118
2119
2121 GLfloat r, GLfloat q )
2122{
2124 if (n) {
2125 n[1].f = s;
2126 n[2].f = t;
2127 n[3].f = r;
2128 n[4].f = q;
2129 }
2130 if (ctx->ExecuteFlag) {
2131 (*ctx->Exec.TexCoord4f)( ctx, s, t, r, q );
2132 }
2133}
2134
2135
2138{
2140 if (n) {
2141 n[1].e = target;
2142 n[2].e = pname;
2143 n[3].f = params[0];
2144 n[4].f = params[1];
2145 n[5].f = params[2];
2146 n[6].f = params[3];
2147 }
2148 if (ctx->ExecuteFlag) {
2149 (*ctx->Exec.TexEnvfv)( ctx, target, pname, params );
2150 }
2151}
2152
2153
2156{
2158 if (n) {
2159 n[1].e = coord;
2160 n[2].e = pname;
2161 n[3].f = params[0];
2162 n[4].f = params[1];
2163 n[5].f = params[2];
2164 n[6].f = params[3];
2165 }
2166 if (ctx->ExecuteFlag) {
2167 (*ctx->Exec.TexGenfv)( ctx, coord, pname, params );
2168 }
2169}
2170
2171
2173 GLenum pname, const GLfloat *params )
2174{
2176 if (n) {
2177 n[1].e = target;
2178 n[2].e = pname;
2179 n[3].f = params[0];
2180 n[4].f = params[1];
2181 n[5].f = params[2];
2182 n[6].f = params[3];
2183 }
2184 if (ctx->ExecuteFlag) {
2185 (*ctx->Exec.TexParameterfv)( ctx, target, pname, params );
2186 }
2187}
2188
2189
2194 struct gl_image *teximage )
2195{
2197 if (n) {
2198 n[1].e = target;
2199 n[2].i = level;
2200 n[3].i = components;
2201 n[4].i = (GLint) width;
2202 n[5].i = border;
2203 n[6].e = format;
2204 n[7].e = type;
2205 n[8].data = teximage;
2206 if (teximage) {
2207 /* this prevents gl_TexImage2D() from freeing the image */
2208 teximage->RefCount = 1;
2209 }
2210 }
2211 if (ctx->ExecuteFlag) {
2212 (*ctx->Exec.TexImage1D)( ctx, target, level, components, width,
2213 border, format, type, teximage );
2214 }
2215}
2216
2217
2222 struct gl_image *teximage )
2223{
2225 if (n) {
2226 n[1].e = target;
2227 n[2].i = level;
2228 n[3].i = components;
2229 n[4].i = (GLint) width;
2230 n[5].i = (GLint) height;
2231 n[6].i = border;
2232 n[7].e = format;
2233 n[8].e = type;
2234 n[9].data = teximage;
2235 if (teximage) {
2236 /* this prevents gl_TexImage2D() from freeing the image */
2237 teximage->RefCount = 1;
2238 }
2239 }
2240 if (ctx->ExecuteFlag) {
2241 (*ctx->Exec.TexImage2D)( ctx, target, level, components, width,
2242 height, border, format, type, teximage );
2243 }
2244}
2245
2246
2250 struct gl_image *image )
2251{
2253 if (n) {
2254 n[1].e = target;
2255 n[2].i = level;
2256 n[3].i = xoffset;
2257 n[4].i = (GLint) width;
2258 n[5].e = format;
2259 n[6].e = type;
2260 n[7].data = image;
2261 if (image)
2262 image->RefCount = 1;
2263 }
2264 if (ctx->ExecuteFlag) {
2265 (*ctx->Exec.TexSubImage1D)( ctx, target, level, xoffset, width,
2266 format, type, image );
2267 }
2268}
2269
2270
2276 struct gl_image *image )
2277{
2279 if (n) {
2280 n[1].e = target;
2281 n[2].i = level;
2282 n[3].i = xoffset;
2283 n[4].i = yoffset;
2284 n[5].i = (GLint) width;
2285 n[6].i = (GLint) height;
2286 n[7].e = format;
2287 n[8].e = type;
2288 n[9].data = image;
2289 if (image)
2290 image->RefCount = 1;
2291 }
2292 if (ctx->ExecuteFlag) {
2293 (*ctx->Exec.TexSubImage2D)( ctx, target, level, xoffset, yoffset,
2295 }
2296}
2297
2298
2300{
2302 if (n) {
2303 n[1].f = x;
2304 n[2].f = y;
2305 n[3].f = z;
2306 }
2307 if (ctx->ExecuteFlag) {
2308 (*ctx->Exec.Translatef)( ctx, x, y, z );
2309 }
2310}
2311
2312
2314{
2316 if (n) {
2317 n[1].f = x;
2318 n[2].f = y;
2319 }
2320 if (ctx->ExecuteFlag) {
2321 (*ctx->Exec.Vertex2f)( ctx, x, y );
2322 }
2323}
2324
2325
2327{
2329 if (n) {
2330 n[1].f = x;
2331 n[2].f = y;
2332 n[3].f = z;
2333 }
2334 if (ctx->ExecuteFlag) {
2335 (*ctx->Exec.Vertex3f)( ctx, x, y, z );
2336 }
2337}
2338
2339
2342{
2344 if (n) {
2345 n[1].f = x;
2346 n[2].f = y;
2347 n[3].f = z;
2348 n[4].f = w;
2349 }
2350 if (ctx->ExecuteFlag) {
2351 (*ctx->Exec.Vertex4f)( ctx, x, y, z, w );
2352 }
2353}
2354
2355
2357{
2359 if (n) {
2360 n[1].f = v[0];
2361 n[2].f = v[1];
2362 n[3].f = v[2];
2363 }
2364 if (ctx->ExecuteFlag) {
2365 (*ctx->Exec.Vertex3fv)( ctx, v );
2366 }
2367}
2368
2369
2372{
2374 if (n) {
2375 n[1].i = x;
2376 n[2].i = y;
2377 n[3].i = (GLint) width;
2378 n[4].i = (GLint) height;
2379 }
2380 if (ctx->ExecuteFlag) {
2381 (*ctx->Exec.Viewport)( ctx, x, y, width, height );
2382 }
2383}
2384
2385
2386/**********************************************************************/
2387/* Display list execution */
2388/**********************************************************************/
2389
2390
2391/*
2392 * Execute a display list. Note that the ListBase offset must have already
2393 * been added before calling this function. I.e. the list argument is
2394 * the absolute list number, not relative to ListBase.
2395 * Input: list - display list number
2396 */
2398{
2399 Node *n;
2400 GLboolean done;
2401 OpCode opcode;
2402
2403 if (!gl_IsList(ctx,list))
2404 return;
2405
2406 ctx->CallDepth++;
2407
2408 n = (Node *) HashLookup(ctx->Shared->DisplayList, list);
2409
2410 done = GL_FALSE;
2411 while (!done) {
2412 opcode = n[0].opcode;
2413
2414 switch (opcode) {
2415 /* Frequently called functions: */
2416 case OPCODE_VERTEX2:
2417 (*ctx->Exec.Vertex2f)( ctx, n[1].f, n[2].f );
2418 break;
2419 case OPCODE_VERTEX3:
2420 (*ctx->Exec.Vertex3f)( ctx, n[1].f, n[2].f, n[3].f );
2421 break;
2422 case OPCODE_VERTEX4:
2423 (*ctx->Exec.Vertex4f)( ctx, n[1].f, n[2].f, n[3].f, n[4].f );
2424 break;
2425 case OPCODE_NORMAL:
2426 ctx->Current.Normal[0] = n[1].f;
2427 ctx->Current.Normal[1] = n[2].f;
2428 ctx->Current.Normal[2] = n[3].f;
2429 ctx->VB->MonoNormal = GL_FALSE;
2430 break;
2431 case OPCODE_COLOR_4UB:
2432 (*ctx->Exec.Color4ub)( ctx, n[1].ub, n[2].ub, n[3].ub, n[4].ub );
2433 break;
2434 case OPCODE_COLOR_3F:
2435 (*ctx->Exec.Color3f)( ctx, n[1].f, n[2].f, n[3].f );
2436 break;
2437 case OPCODE_COLOR_4F:
2438 (*ctx->Exec.Color4f)( ctx, n[1].f, n[2].f, n[3].f, n[4].f );
2439 break;
2440 case OPCODE_INDEX:
2441 ctx->Current.Index = n[1].ui;
2442 ctx->VB->MonoColor = GL_FALSE;
2443 break;
2444 case OPCODE_BEGIN:
2445 gl_Begin( ctx, n[1].e );
2446 break;
2447 case OPCODE_END:
2448 gl_End( ctx );
2449 break;
2450 case OPCODE_TEXCOORD2:
2451 ctx->Current.TexCoord[0] = n[1].f;
2452 ctx->Current.TexCoord[1] = n[2].f;
2453 if (ctx->VB->TexCoordSize==4) {
2454 ctx->Current.TexCoord[2] = 0.0F;
2455 ctx->Current.TexCoord[3] = 1.0F;
2456 }
2457 break;
2458 case OPCODE_TEXCOORD4:
2459 ctx->Current.TexCoord[0] = n[1].f;
2460 ctx->Current.TexCoord[1] = n[2].f;
2461 ctx->Current.TexCoord[2] = n[3].f;
2462 ctx->Current.TexCoord[3] = n[4].f;
2463 if (ctx->VB->TexCoordSize==2) {
2464 /* Switch to 4-component texcoords */
2465 ctx->VB->TexCoordSize = 4;
2467 }
2468 break;
2469
2470 /* Everything Else: */
2471 case OPCODE_ACCUM:
2472 gl_Accum( ctx, n[1].e, n[2].f );
2473 break;
2474 case OPCODE_ALPHA_FUNC:
2475 gl_AlphaFunc( ctx, n[1].e, n[2].f );
2476 break;
2478 gl_BindTexture( ctx, n[1].e, n[2].ui );
2479 break;
2480 case OPCODE_BITMAP:
2481 gl_Bitmap( ctx, (GLsizei) n[1].i, (GLsizei) n[2].i,
2482 n[3].f, n[4].f,
2483 n[5].f, n[6].f,
2484 (struct gl_image *) n[7].data );
2485 break;
2486 case OPCODE_BLEND_FUNC:
2487 gl_BlendFunc( ctx, n[1].e, n[2].e );
2488 break;
2489 case OPCODE_CALL_LIST:
2490 /* Generated by glCallList(), don't add ListBase */
2491 if (ctx->CallDepth<MAX_LIST_NESTING) {
2492 execute_list( ctx, n[1].ui );
2493 }
2494 break;
2496 /* Generated by glCallLists() so we must add ListBase */
2497 if (ctx->CallDepth<MAX_LIST_NESTING) {
2498 execute_list( ctx, ctx->List.ListBase + n[1].ui );
2499 }
2500 break;
2501 case OPCODE_CLEAR:
2502 gl_Clear( ctx, n[1].bf );
2503 break;
2504 case OPCODE_CLEAR_COLOR:
2505 gl_ClearColor( ctx, n[1].f, n[2].f, n[3].f, n[4].f );
2506 break;
2507 case OPCODE_CLEAR_ACCUM:
2508 gl_ClearAccum( ctx, n[1].f, n[2].f, n[3].f, n[4].f );
2509 break;
2510 case OPCODE_CLEAR_DEPTH:
2511 gl_ClearDepth( ctx, (GLclampd) n[1].f );
2512 break;
2513 case OPCODE_CLEAR_INDEX:
2514 gl_ClearIndex( ctx, n[1].ui );
2515 break;
2517 gl_ClearStencil( ctx, n[1].i );
2518 break;
2519 case OPCODE_CLIP_PLANE:
2520 {
2521 GLfloat equ[4];
2522 equ[0] = n[2].f;
2523 equ[1] = n[3].f;
2524 equ[2] = n[4].f;
2525 equ[3] = n[5].f;
2526 gl_ClipPlane( ctx, n[1].e, equ );
2527 }
2528 break;
2529 case OPCODE_COLOR_MASK:
2530 gl_ColorMask( ctx, n[1].b, n[2].b, n[3].b, n[4].b );
2531 break;
2533 gl_ColorMaterial( ctx, n[1].e, n[2].e );
2534 break;
2535 case OPCODE_COLOR_TABLE:
2536 gl_ColorTable( ctx, n[1].e, n[2].e, (struct gl_image *) n[3].data);
2537 break;
2539 gl_ColorSubTable( ctx, n[1].e, n[2].i,
2540 (struct gl_image *) n[3].data);
2541 break;
2542 case OPCODE_COPY_PIXELS:
2543 gl_CopyPixels( ctx, n[1].i, n[2].i,
2544 (GLsizei) n[3].i, (GLsizei) n[4].i, n[5].e );
2545 break;
2547 gl_CopyTexImage1D( ctx, n[1].e, n[2].i, n[3].e, n[4].i,
2548 n[5].i, n[6].i, n[7].i );
2549 break;
2551 gl_CopyTexImage2D( ctx, n[1].e, n[2].i, n[3].e, n[4].i,
2552 n[5].i, n[6].i, n[7].i, n[8].i );
2553 break;
2555 gl_CopyTexSubImage1D( ctx, n[1].e, n[2].i, n[3].i, n[4].i,
2556 n[5].i, n[6].i );
2557 break;
2559 gl_CopyTexSubImage2D( ctx, n[1].e, n[2].i, n[3].i, n[4].i,
2560 n[5].i, n[6].i, n[7].i, n[8].i );
2561 break;
2562 case OPCODE_CULL_FACE:
2563 gl_CullFace( ctx, n[1].e );
2564 break;
2565 case OPCODE_DEPTH_FUNC:
2566 gl_DepthFunc( ctx, n[1].e );
2567 break;
2568 case OPCODE_DEPTH_MASK:
2569 gl_DepthMask( ctx, n[1].b );
2570 break;
2571 case OPCODE_DEPTH_RANGE:
2572 gl_DepthRange( ctx, (GLclampd) n[1].f, (GLclampd) n[2].f );
2573 break;
2574 case OPCODE_DISABLE:
2575 gl_Disable( ctx, n[1].e );
2576 break;
2577 case OPCODE_DRAW_BUFFER:
2578 gl_DrawBuffer( ctx, n[1].e );
2579 break;
2580 case OPCODE_DRAW_PIXELS:
2581 gl_DrawPixels( ctx, (GLsizei) n[1].i, (GLsizei) n[2].i,
2582 n[3].e, n[4].e, n[5].data );
2583 break;
2584 case OPCODE_EDGE_FLAG:
2585 ctx->Current.EdgeFlag = n[1].b;
2586 break;
2587 case OPCODE_ENABLE:
2588 gl_Enable( ctx, n[1].e );
2589 break;
2590 case OPCODE_EVALCOORD1:
2591 gl_EvalCoord1f( ctx, n[1].f );
2592 break;
2593 case OPCODE_EVALCOORD2:
2594 gl_EvalCoord2f( ctx, n[1].f, n[2].f );
2595 break;
2596 case OPCODE_EVALMESH1:
2597 gl_EvalMesh1( ctx, n[1].e, n[2].i, n[3].i );
2598 break;
2599 case OPCODE_EVALMESH2:
2600 gl_EvalMesh2( ctx, n[1].e, n[2].i, n[3].i, n[4].i, n[5].i );
2601 break;
2602 case OPCODE_EVALPOINT1:
2603 gl_EvalPoint1( ctx, n[1].i );
2604 break;
2605 case OPCODE_EVALPOINT2:
2606 gl_EvalPoint2( ctx, n[1].i, n[2].i );
2607 break;
2608 case OPCODE_FOG:
2609 {
2610 GLfloat p[4];
2611 p[0] = n[2].f;
2612 p[1] = n[3].f;
2613 p[2] = n[4].f;
2614 p[3] = n[5].f;
2615 gl_Fogfv( ctx, n[1].e, p );
2616 }
2617 break;
2618 case OPCODE_FRONT_FACE:
2619 gl_FrontFace( ctx, n[1].e );
2620 break;
2621 case OPCODE_FRUSTUM:
2622 gl_Frustum( ctx, n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f );
2623 break;
2624 case OPCODE_HINT:
2625 gl_Hint( ctx, n[1].e, n[2].e );
2626 break;
2627 case OPCODE_INDEX_MASK:
2628 gl_IndexMask( ctx, n[1].ui );
2629 break;
2630 case OPCODE_INIT_NAMES:
2631 gl_InitNames( ctx );
2632 break;
2633 case OPCODE_LIGHT:
2634 {
2635 GLfloat p[4];
2636 p[0] = n[3].f;
2637 p[1] = n[4].f;
2638 p[2] = n[5].f;
2639 p[3] = n[6].f;
2640 gl_Lightfv( ctx, n[1].e, n[2].e, p, 4 );
2641 }
2642 break;
2643 case OPCODE_LIGHT_MODEL:
2644 {
2645 GLfloat p[4];
2646 p[0] = n[2].f;
2647 p[1] = n[3].f;
2648 p[2] = n[4].f;
2649 p[3] = n[5].f;
2650 gl_LightModelfv( ctx, n[1].e, p );
2651 }
2652 break;
2654 gl_LineStipple( ctx, n[1].i, n[2].us );
2655 break;
2656 case OPCODE_LINE_WIDTH:
2657 gl_LineWidth( ctx, n[1].f );
2658 break;
2659 case OPCODE_LIST_BASE:
2660 gl_ListBase( ctx, n[1].ui );
2661 break;
2664 break;
2665 case OPCODE_LOAD_MATRIX:
2666 if (sizeof(Node)==sizeof(GLfloat)) {
2667 gl_LoadMatrixf( ctx, &n[1].f );
2668 }
2669 else {
2670 GLfloat m[16];
2671 GLuint i;
2672 for (i=0;i<16;i++) {
2673 m[i] = n[1+i].f;
2674 }
2675 gl_LoadMatrixf( ctx, m );
2676 }
2677 break;
2678 case OPCODE_LOAD_NAME:
2679 gl_LoadName( ctx, n[1].ui );
2680 break;
2681 case OPCODE_LOGIC_OP:
2682 gl_LogicOp( ctx, n[1].e );
2683 break;
2684 case OPCODE_MAP1:
2685 gl_Map1f( ctx, n[1].e, n[2].f, n[3].f,
2686 n[4].i, n[5].i, (GLfloat *) n[6].data, GL_TRUE );
2687 break;
2688 case OPCODE_MAP2:
2689 gl_Map2f( ctx, n[1].e,
2690 n[2].f, n[3].f, /* u1, u2 */
2691 n[6].i, n[8].i, /* ustride, uorder */
2692 n[4].f, n[5].f, /* v1, v2 */
2693 n[7].i, n[9].i, /* vstride, vorder */
2694 (GLfloat *) n[10].data,
2695 GL_TRUE);
2696 break;
2697 case OPCODE_MAPGRID1:
2698 gl_MapGrid1f( ctx, n[1].i, n[2].f, n[3].f );
2699 break;
2700 case OPCODE_MAPGRID2:
2701 gl_MapGrid2f( ctx, n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f);
2702 break;
2703 case OPCODE_MATERIAL:
2704 {
2705 GLfloat params[4];
2706 params[0] = n[3].f;
2707 params[1] = n[4].f;
2708 params[2] = n[5].f;
2709 params[3] = n[6].f;
2710 gl_Materialfv( ctx, n[1].e, n[2].e, params );
2711 }
2712 break;
2713 case OPCODE_MATRIX_MODE:
2714 gl_MatrixMode( ctx, n[1].e );
2715 break;
2716 case OPCODE_MULT_MATRIX:
2717 if (sizeof(Node)==sizeof(GLfloat)) {
2718 gl_MultMatrixf( ctx, &n[1].f );
2719 }
2720 else {
2721 GLfloat m[16];
2722 GLuint i;
2723 for (i=0;i<16;i++) {
2724 m[i] = n[1+i].f;
2725 }
2726 gl_MultMatrixf( ctx, m );
2727 }
2728 break;
2729 case OPCODE_ORTHO:
2730 gl_Ortho( ctx, n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f );
2731 break;
2732 case OPCODE_PASSTHROUGH:
2733 gl_PassThrough( ctx, n[1].f );
2734 break;
2735 case OPCODE_PIXEL_MAP:
2736 gl_PixelMapfv( ctx, n[1].e, n[2].i, (GLfloat *) n[3].data );
2737 break;
2739 gl_PixelTransferf( ctx, n[1].e, n[2].f );
2740 break;
2741 case OPCODE_PIXEL_ZOOM:
2742 gl_PixelZoom( ctx, n[1].f, n[2].f );
2743 break;
2744 case OPCODE_POINT_SIZE:
2745 gl_PointSize( ctx, n[1].f );
2746 break;
2748 gl_PolygonMode( ctx, n[1].e, n[2].e );
2749 break;
2751 gl_PolygonStipple( ctx, (GLubyte *) n[1].data );
2752 break;
2754 gl_PolygonOffset( ctx, n[1].f, n[2].f );
2755 break;
2756 case OPCODE_POP_ATTRIB:
2757 gl_PopAttrib( ctx );
2758 break;
2759 case OPCODE_POP_MATRIX:
2760 gl_PopMatrix( ctx );
2761 break;
2762 case OPCODE_POP_NAME:
2763 gl_PopName( ctx );
2764 break;
2766 gl_PrioritizeTextures( ctx, 1, &n[1].ui, &n[2].f );
2767 break;
2768 case OPCODE_PUSH_ATTRIB:
2769 gl_PushAttrib( ctx, n[1].bf );
2770 break;
2771 case OPCODE_PUSH_MATRIX:
2772 gl_PushMatrix( ctx );
2773 break;
2774 case OPCODE_PUSH_NAME:
2775 gl_PushName( ctx, n[1].ui );
2776 break;
2777 case OPCODE_RASTER_POS:
2778 gl_RasterPos4f( ctx, n[1].f, n[2].f, n[3].f, n[4].f );
2779 break;
2780 case OPCODE_READ_BUFFER:
2781 gl_ReadBuffer( ctx, n[1].e );
2782 break;
2783 case OPCODE_RECTF:
2784 gl_Rectf( ctx, n[1].f, n[2].f, n[3].f, n[4].f );
2785 break;
2786 case OPCODE_SCALE:
2787 gl_Scalef( ctx, n[1].f, n[2].f, n[3].f );
2788 break;
2789 case OPCODE_SCISSOR:
2790 gl_Scissor( ctx, n[1].i, n[2].i, n[3].i, n[4].i );
2791 break;
2792 case OPCODE_SHADE_MODEL:
2793 gl_ShadeModel( ctx, n[1].e );
2794 break;
2796 gl_StencilFunc( ctx, n[1].e, n[2].i, n[3].ui );
2797 break;
2799 gl_StencilMask( ctx, n[1].ui );
2800 break;
2801 case OPCODE_STENCIL_OP:
2802 gl_StencilOp( ctx, n[1].e, n[2].e, n[3].e );
2803 break;
2804 case OPCODE_TEXENV:
2805 {
2806 GLfloat params[4];
2807 params[0] = n[3].f;
2808 params[1] = n[4].f;
2809 params[2] = n[5].f;
2810 params[3] = n[6].f;
2811 gl_TexEnvfv( ctx, n[1].e, n[2].e, params );
2812 }
2813 break;
2814 case OPCODE_TEXGEN:
2815 {
2816 GLfloat params[4];
2817 params[0] = n[3].f;
2818 params[1] = n[4].f;
2819 params[2] = n[5].f;
2820 params[3] = n[6].f;
2821 gl_TexGenfv( ctx, n[1].e, n[2].e, params );
2822 }
2823 break;
2825 {
2826 GLfloat params[4];
2827 params[0] = n[3].f;
2828 params[1] = n[4].f;
2829 params[2] = n[5].f;
2830 params[3] = n[6].f;
2831 gl_TexParameterfv( ctx, n[1].e, n[2].e, params );
2832 }
2833 break;
2834 case OPCODE_TEX_IMAGE1D:
2836 n[1].e, /* target */
2837 n[2].i, /* level */
2838 n[3].i, /* components */
2839 n[4].i, /* width */
2840 n[5].e, /* border */
2841 n[6].e, /* format */
2842 n[7].e, /* type */
2843 (struct gl_image *) n[8].data );
2844 break;
2845 case OPCODE_TEX_IMAGE2D:
2847 n[1].e, /* target */
2848 n[2].i, /* level */
2849 n[3].i, /* components */
2850 n[4].i, /* width */
2851 n[5].i, /* height */
2852 n[6].e, /* border */
2853 n[7].e, /* format */
2854 n[8].e, /* type */
2855 (struct gl_image *) n[9].data );
2856 break;
2858 gl_TexSubImage1D( ctx, n[1].e, n[2].i, n[3].i, n[4].i, n[5].e,
2859 n[6].e, (struct gl_image *) n[7].data );
2860 break;
2862 gl_TexSubImage2D( ctx, n[1].e, n[2].i, n[3].i, n[4].i, n[5].e,
2863 n[6].i, n[7].e, n[8].e,
2864 (struct gl_image *) n[9].data );
2865 break;
2866 case OPCODE_TRANSLATE:
2867 gl_Translatef( ctx, n[1].f, n[2].f, n[3].f );
2868 break;
2869 case OPCODE_VIEWPORT:
2871 n[1].i, n[2].i, (GLsizei) n[3].i, (GLsizei) n[4].i );
2872 break;
2873 case OPCODE_CONTINUE:
2874 n = (Node *) n[1].next;
2875 break;
2876 case OPCODE_END_OF_LIST:
2877 done = GL_TRUE;
2878 break;
2879 default:
2880 {
2881 char msg[1000];
2882 sprintf(msg, "Error in execute_list: opcode=%d", (int) opcode);
2883 gl_problem( ctx, msg );
2884 }
2885 done = GL_TRUE;
2886 }
2887
2888 /* increment n to point to next compiled command */
2889 if (opcode!=OPCODE_CONTINUE) {
2890 n += InstSize[opcode];
2891 }
2892
2893 }
2894 ctx->CallDepth--;
2895}
2896
2897
2898
2899/**********************************************************************/
2900/* GL functions */
2901/**********************************************************************/
2902
2903
2904
2905/*
2906 * Test if a display list number is valid.
2907 */
2909{
2910 if (list > 0 && HashLookup(ctx->Shared->DisplayList, list)) {
2911 return GL_TRUE;
2912 }
2913 else {
2914 return GL_FALSE;
2915 }
2916}
2917
2918
2919
2920/*
2921 * Delete a sequence of consecutive display lists.
2922 */
2924{
2925 GLuint i;
2926
2927 if (INSIDE_BEGIN_END(ctx)) {
2928 gl_error( ctx, GL_INVALID_OPERATION, "glDeleteLists" );
2929 return;
2930 }
2931 if (range<0) {
2932 gl_error( ctx, GL_INVALID_VALUE, "glDeleteLists" );
2933 return;
2934 }
2935 for (i=list;i<list+range;i++) {
2936 gl_destroy_list( ctx, i );
2937 }
2938}
2939
2940
2941
2942/*
2943 * Return a display list number, n, such that lists n through n+range-1
2944 * are free.
2945 */
2947{
2948 GLuint base;
2949
2950 if (INSIDE_BEGIN_END(ctx)) {
2951 gl_error( ctx, GL_INVALID_OPERATION, "glGenLists" );
2952 return 0;
2953 }
2954 if (range<0) {
2955 gl_error( ctx, GL_INVALID_VALUE, "glGenLists" );
2956 return 0;
2957 }
2958 if (range==0) {
2959 return 0;
2960 }
2961
2962 base = HashFindFreeKeyBlock(ctx->Shared->DisplayList, range);
2963 if (base) {
2964 /* reserve the list IDs by with empty/dummy lists */
2965 GLuint i;
2966 for (i=0; i<range; i++) {
2967 HashInsert(ctx->Shared->DisplayList, base+i, make_empty_list());
2968 }
2969 }
2970 return base;
2971}
2972
2973
2974
2975/*
2976 * Begin a new display list.
2977 */
2979{
2980 if (INSIDE_BEGIN_END(ctx)) {
2981 gl_error( ctx, GL_INVALID_OPERATION, "glNewList" );
2982 return;
2983 }
2984 if (list==0) {
2985 gl_error( ctx, GL_INVALID_VALUE, "glNewList" );
2986 return;
2987 }
2989 gl_error( ctx, GL_INVALID_ENUM, "glNewList" );
2990 return;
2991 }
2992 if (ctx->CurrentListPtr) {
2993 /* already compiling a display list */
2994 gl_error( ctx, GL_INVALID_OPERATION, "glNewList" );
2995 return;
2996 }
2997
2998 /* Allocate new display list */
2999 ctx->CurrentListNum = list;
3000 ctx->CurrentListPtr = ctx->CurrentBlock = (Node *) malloc( sizeof(Node) * BLOCK_SIZE );
3001 ctx->CurrentPos = 0;
3002
3003 ctx->CompileFlag = GL_TRUE;
3004 if (mode==GL_COMPILE) {
3005 ctx->ExecuteFlag = GL_FALSE;
3006 }
3007 else {
3008 /* Compile and execute */
3009 ctx->ExecuteFlag = GL_TRUE;
3010 }
3011
3012 ctx->API = ctx->Save; /* Switch the API function pointers */
3013}
3014
3015
3016
3017/*
3018 * End definition of current display list.
3019 */
3021{
3022 Node *n;
3023
3024 /* Check that a list is under construction */
3025 if (!ctx->CurrentListPtr) {
3026 gl_error( ctx, GL_INVALID_OPERATION, "glEndList" );
3027 return;
3028 }
3029
3031 (void)n;
3032
3033 /* Destroy old list, if any */
3034 gl_destroy_list(ctx, ctx->CurrentListNum);
3035 /* Install the list */
3036 HashInsert(ctx->Shared->DisplayList, ctx->CurrentListNum, ctx->CurrentListPtr);
3037
3038 ctx->CurrentListNum = 0;
3039 ctx->CurrentListPtr = NULL;
3040 ctx->ExecuteFlag = GL_TRUE;
3041 ctx->CompileFlag = GL_FALSE;
3042
3043 ctx->API = ctx->Exec; /* Switch the API function pointers */
3044}
3045
3046
3047
3049{
3050 /* VERY IMPORTANT: Save the CompileFlag status, turn it off, */
3051 /* execute the display list, and restore the CompileFlag. */
3052 GLboolean save_compile_flag;
3053 save_compile_flag = ctx->CompileFlag;
3054 ctx->CompileFlag = GL_FALSE;
3055 execute_list( ctx, list );
3056 ctx->CompileFlag = save_compile_flag;
3057}
3058
3059
3060
3061/*
3062 * Execute glCallLists: call multiple display lists.
3063 */
3065 GLsizei n, GLenum type, const GLvoid *lists )
3066{
3067 GLuint i, list;
3068 GLboolean save_compile_flag;
3069
3070 /* Save the CompileFlag status, turn it off, execute display list,
3071 * and restore the CompileFlag.
3072 */
3073 save_compile_flag = ctx->CompileFlag;
3074 ctx->CompileFlag = GL_FALSE;
3075
3076 for (i=0;i<n;i++) {
3077 list = translate_id( i, type, lists );
3078 execute_list( ctx, ctx->List.ListBase + list );
3079 }
3080
3081 ctx->CompileFlag = save_compile_flag;
3082}
3083
3084
3085
3086/*
3087 * Set the offset added to list numbers in glCallLists.
3088 */
3090{
3091 if (INSIDE_BEGIN_END(ctx)) {
3092 gl_error( ctx, GL_INVALID_OPERATION, "glListBase" );
3093 return;
3094 }
3095 ctx->List.ListBase = base;
3096}
_Tp _STLP_CALL norm(const complex< _Tp > &__z)
Definition: _complex.h:741
void gl_ClearAccum(GLcontext *ctx, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
Definition: accum.c:79
void gl_Accum(GLcontext *ctx, GLenum op, GLfloat value)
Definition: accum.c:95
void gl_AlphaFunc(GLcontext *ctx, GLenum func, GLclampf ref)
Definition: alpha.c:56
#define msg(x)
Definition: auth_time.c:54
#define index(s, c)
Definition: various.h:29
#define nz(x)
void gl_BlendFunc(GLcontext *ctx, GLenum sfactor, GLenum dfactor)
Definition: blend.c:76
Definition: list.h:37
Definition: _map.h:48
void gl_ColorTable(GLcontext *ctx, GLenum target, GLenum internalFormat, struct gl_image *table)
Definition: colortab.c:129
void gl_ColorSubTable(GLcontext *ctx, GLenum target, GLsizei start, struct gl_image *data)
Definition: colortab.c:187
void gl_CopyPixels(GLcontext *ctx, GLint srcx, GLint srcy, GLsizei width, GLsizei height, GLenum type)
Definition: copypix.c:454
#define free
Definition: debug_ros.c:5
#define malloc
Definition: debug_ros.c:4
void gl_DepthFunc(GLcontext *ctx, GLenum func)
Definition: depth.c:98
void gl_DepthMask(GLcontext *ctx, GLboolean flag)
Definition: depth.c:124
void gl_ClearDepth(GLcontext *ctx, GLclampd depth)
Definition: depth.c:87
void gl_DepthRange(GLcontext *ctx, GLclampd nearval, GLclampd farval)
Definition: depth.c:141
void gl_save_NewList(GLcontext *ctx, GLuint list, GLenum mode)
Definition: dlist.c:1731
void gl_save_BlendFunc(GLcontext *ctx, GLenum sfactor, GLenum dfactor)
Definition: dlist.c:770
void gl_save_PrioritizeTextures(GLcontext *ctx, GLsizei num, const GLuint *textures, const GLclampf *priorities)
Definition: dlist.c:1907
void gl_save_FrontFace(GLcontext *ctx, GLenum mode)
Definition: dlist.c:1399
void gl_save_Begin(GLcontext *ctx, GLenum mode)
Definition: dlist.c:722
void gl_save_DepthFunc(GLcontext *ctx, GLenum func)
Definition: dlist.c:1188
void gl_save_Scissor(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height)
Definition: dlist.c:2038
void gl_save_MatrixMode(GLcontext *ctx, GLenum mode)
Definition: dlist.c:1704
void gl_save_PushMatrix(GLcontext *ctx)
Definition: dlist.c:1938
void gl_save_Hint(GLcontext *ctx, GLenum target, GLenum mode)
Definition: dlist.c:1430
void gl_save_EvalMesh1(GLcontext *ctx, GLenum mode, GLint i1, GLint i2)
Definition: dlist.c:1326
void gl_save_PassThrough(GLcontext *ctx, GLfloat token)
Definition: dlist.c:1975
void gl_save_PixelZoom(GLcontext *ctx, GLfloat xfactor, GLfloat yfactor)
Definition: dlist.c:1814
void gl_NewList(GLcontext *ctx, GLuint list, GLenum mode)
Definition: dlist.c:2978
void gl_save_BindTexture(GLcontext *ctx, GLenum target, GLuint texture)
Definition: dlist.c:734
void gl_save_ClearColor(GLcontext *ctx, GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
Definition: dlist.c:841
void gl_save_Vertex3f(GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z)
Definition: dlist.c:2326
void gl_save_PopName(GLcontext *ctx)
Definition: dlist.c:1898
void gl_save_Accum(GLcontext *ctx, GLenum op, GLfloat value)
Definition: dlist.c:696
void gl_save_PushName(GLcontext *ctx, GLuint name)
Definition: dlist.c:1947
void gl_save_Vertex2f(GLcontext *ctx, GLfloat x, GLfloat y)
Definition: dlist.c:2313
static GLuint InstSize[OPCODE_END_OF_LIST+1]
Definition: dlist.c:366
void gl_save_Rotatef(GLcontext *ctx, GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
Definition: dlist.c:2015
void gl_save_Color4f(GLcontext *ctx, GLfloat r, GLfloat g, GLfloat b, GLfloat a)
Definition: dlist.c:937
void gl_save_TexImage2D(GLcontext *ctx, GLenum target, GLint level, GLint components, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, struct gl_image *teximage)
Definition: dlist.c:2218
void gl_save_ColorSubTable(GLcontext *ctx, GLenum target, GLsizei start, struct gl_image *data)
Definition: dlist.c:1047
void gl_save_ReadBuffer(GLcontext *ctx, GLenum mode)
Definition: dlist.c:1987
void gl_save_IndexMask(GLcontext *ctx, GLuint mask)
Definition: dlist.c:1467
void gl_save_EvalMesh2(GLcontext *ctx, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
Definition: dlist.c:1341
void gl_save_PixelTransferf(GLcontext *ctx, GLenum pname, GLfloat param)
Definition: dlist.c:1801
void gl_save_PolygonOffset(GLcontext *ctx, GLfloat factor, GLfloat units)
Definition: dlist.c:1867
void gl_CallList(GLcontext *ctx, GLuint list)
Definition: dlist.c:3048
void gl_save_Viewport(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height)
Definition: dlist.c:2370
void gl_save_EvalCoord1f(GLcontext *ctx, GLfloat u)
Definition: dlist.c:1301
static Node * alloc_instruction(GLcontext *ctx, OpCode opcode, GLint argcount)
Definition: dlist.c:381
void gl_destroy_list(GLcontext *ctx, GLuint list)
Definition: dlist.c:429
void gl_save_ClipPlane(GLcontext *ctx, GLenum plane, const GLfloat *equ)
Definition: dlist.c:893
void gl_save_DepthMask(GLcontext *ctx, GLboolean mask)
Definition: dlist.c:1200
void gl_save_PushAttrib(GLcontext *ctx, GLbitfield mask)
Definition: dlist.c:1926
void gl_save_Frustum(GLcontext *ctx, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval)
Definition: dlist.c:1411
void gl_save_CallList(GLcontext *ctx, GLuint list)
Definition: dlist.c:783
void gl_save_ColorMask(GLcontext *ctx, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
Definition: dlist.c:999
void gl_save_PolygonStipple(GLcontext *ctx, const GLubyte *mask)
Definition: dlist.c:1852
void gl_ListBase(GLcontext *ctx, GLuint base)
Definition: dlist.c:3089
void gl_save_LineStipple(GLcontext *ctx, GLint factor, GLushort pattern)
Definition: dlist.c:1523
void gl_DeleteLists(GLcontext *ctx, GLuint list, GLsizei range)
Definition: dlist.c:2923
void gl_save_MapGrid2f(GLcontext *ctx, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
Definition: dlist.c:1667
void gl_save_ColorMaterial(GLcontext *ctx, GLenum face, GLenum mode)
Definition: dlist.c:1015
void gl_save_ColorTable(GLcontext *ctx, GLenum target, GLenum internalFormat, struct gl_image *table)
Definition: dlist.c:1028
void gl_save_TexSubImage1D(GLcontext *ctx, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, struct gl_image *image)
Definition: dlist.c:2247
void gl_save_Vertex3fv(GLcontext *ctx, const GLfloat v[3])
Definition: dlist.c:2356
void gl_save_StencilOp(GLcontext *ctx, GLenum fail, GLenum zfail, GLenum zpass)
Definition: dlist.c:2092
void gl_save_ClearAccum(GLcontext *ctx, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
Definition: dlist.c:825
void gl_save_Scalef(GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z)
Definition: dlist.c:2024
void gl_save_LineWidth(GLcontext *ctx, GLfloat width)
Definition: dlist.c:1536
void gl_save_CopyTexImage2D(GLcontext *ctx, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
Definition: dlist.c:1108
void gl_save_TexParameterfv(GLcontext *ctx, GLenum target, GLenum pname, const GLfloat *params)
Definition: dlist.c:2172
void gl_save_TexGenfv(GLcontext *ctx, GLenum coord, GLenum pname, const GLfloat *params)
Definition: dlist.c:2154
void gl_save_Color4ubv(GLcontext *ctx, const GLubyte *c)
Definition: dlist.c:984
void gl_save_Fogfv(GLcontext *ctx, GLenum pname, const GLfloat *params)
Definition: dlist.c:1383
void gl_save_Color4fv(GLcontext *ctx, const GLfloat *c)
Definition: dlist.c:953
void gl_save_Bitmap(GLcontext *ctx, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const struct gl_image *bitmap)
Definition: dlist.c:747
void gl_save_TexCoord2f(GLcontext *ctx, GLfloat s, GLfloat t)
Definition: dlist.c:2107
void gl_save_EvalPoint2(GLcontext *ctx, GLint i, GLint j)
Definition: dlist.c:1370
void gl_save_MultMatrixf(GLcontext *ctx, const GLfloat *m)
Definition: dlist.c:1716
GLboolean gl_IsList(GLcontext *ctx, GLuint list)
Definition: dlist.c:2908
void gl_save_TexSubImage2D(GLcontext *ctx, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, struct gl_image *image)
Definition: dlist.c:2271
void gl_save_LoadName(GLcontext *ctx, GLuint name)
Definition: dlist.c:1584
void gl_save_CopyTexSubImage1D(GLcontext *ctx, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
Definition: dlist.c:1133
void gl_save_Normal3fv(GLcontext *ctx, const GLfloat norm[3])
Definition: dlist.c:1738
void gl_save_CopyTexSubImage2D(GLcontext *ctx, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLint height)
Definition: dlist.c:1153
void gl_save_DrawBuffer(GLcontext *ctx, GLenum mode)
Definition: dlist.c:1237
void gl_save_PixelMapfv(GLcontext *ctx, GLenum map, GLint mapsize, const GLfloat *values)
Definition: dlist.c:1785
GLuint gl_GenLists(GLcontext *ctx, GLsizei range)
Definition: dlist.c:2946
void gl_save_TexEnvfv(GLcontext *ctx, GLenum target, GLenum pname, const GLfloat *params)
Definition: dlist.c:2136
void gl_save_TexCoord4f(GLcontext *ctx, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
Definition: dlist.c:2120
void gl_save_Lightfv(GLcontext *ctx, GLenum light, GLenum pname, const GLfloat *params, GLint numparams)
Definition: dlist.c:1488
void gl_save_EdgeFlag(GLcontext *ctx, GLboolean flag)
Definition: dlist.c:1268
void gl_save_CopyTexImage1D(GLcontext *ctx, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
Definition: dlist.c:1085
void gl_save_PopMatrix(GLcontext *ctx)
Definition: dlist.c:1889
void gl_save_LogicOp(GLcontext *ctx, GLenum opcode)
Definition: dlist.c:1596
void gl_save_CullFace(GLcontext *ctx, GLenum mode)
Definition: dlist.c:1176
void gl_save_CallLists(GLcontext *ctx, GLsizei n, GLenum type, const GLvoid *lists)
Definition: dlist.c:795
void gl_save_Rectf(GLcontext *ctx, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
Definition: dlist.c:1999
void gl_save_Translatef(GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z)
Definition: dlist.c:2299
void gl_save_DepthRange(GLcontext *ctx, GLclampd nearval, GLclampd farval)
Definition: dlist.c:1212
void gl_save_EvalCoord2f(GLcontext *ctx, GLfloat u, GLfloat v)
Definition: dlist.c:1313
void gl_init_lists(void)
Definition: dlist.c:573
void gl_save_AlphaFunc(GLcontext *ctx, GLenum func, GLclampf ref)
Definition: dlist.c:709
void gl_save_InitNames(GLcontext *ctx)
Definition: dlist.c:1479
void gl_save_ClearIndex(GLcontext *ctx, GLfloat c)
Definition: dlist.c:869
void gl_save_LightModelfv(GLcontext *ctx, GLenum pname, const GLfloat *params)
Definition: dlist.c:1506
void gl_EndList(GLcontext *ctx)
Definition: dlist.c:3020
void gl_save_TexImage1D(GLcontext *ctx, GLenum target, GLint level, GLint components, GLsizei width, GLint border, GLenum format, GLenum type, struct gl_image *teximage)
Definition: dlist.c:2190
void gl_save_Enable(GLcontext *ctx, GLenum cap)
Definition: dlist.c:1280
OpCode
Definition: dlist.c:229
@ OPCODE_LIGHT
Definition: dlist.c:281
@ OPCODE_BITMAP
Definition: dlist.c:234
@ OPCODE_CALL_LIST_OFFSET
Definition: dlist.c:237
@ OPCODE_INDEX_MASK
Definition: dlist.c:279
@ OPCODE_DEPTH_RANGE
Definition: dlist.c:261
@ OPCODE_TEX_IMAGE2D
Definition: dlist.c:329
@ OPCODE_COPY_TEX_IMAGE3D
Definition: dlist.c:255
@ OPCODE_DRAW_BUFFER
Definition: dlist.c:263
@ OPCODE_FRONT_FACE
Definition: dlist.c:275
@ OPCODE_CLEAR_ACCUM
Definition: dlist.c:239
@ OPCODE_TRANSLATE
Definition: dlist.c:332
@ OPCODE_MAPGRID2
Definition: dlist.c:293
@ OPCODE_LOAD_IDENTITY
Definition: dlist.c:286
@ OPCODE_POP_ATTRIB
Definition: dlist.c:307
@ OPCODE_FOG
Definition: dlist.c:274
@ OPCODE_TEXPARAMETER
Definition: dlist.c:327
@ OPCODE_ENABLE
Definition: dlist.c:266
@ OPCODE_TEXCOORD2
Definition: dlist.c:323
@ OPCODE_POP_MATRIX
Definition: dlist.c:308
@ OPCODE_BLEND_FUNC
Definition: dlist.c:235
@ OPCODE_HINT
Definition: dlist.c:277
@ OPCODE_MAPGRID1
Definition: dlist.c:292
@ OPCODE_STENCIL_MASK
Definition: dlist.c:321
@ OPCODE_EDGE_FLAG
Definition: dlist.c:265
@ OPCODE_BEGIN
Definition: dlist.c:232
@ OPCODE_PUSH_ATTRIB
Definition: dlist.c:311
@ OPCODE_MAP2
Definition: dlist.c:291
@ OPCODE_COLOR_SUB_TABLE
Definition: dlist.c:251
@ OPCODE_RECTF
Definition: dlist.c:315
@ OPCODE_ORTHO
Definition: dlist.c:298
@ OPCODE_CALL_LIST
Definition: dlist.c:236
@ OPCODE_BIND_TEXTURE
Definition: dlist.c:233
@ OPCODE_CLEAR_DEPTH
Definition: dlist.c:241
@ OPCODE_END
Definition: dlist.c:267
@ OPCODE_COLOR_MASK
Definition: dlist.c:248
@ OPCODE_COPY_TEX_IMAGE1D
Definition: dlist.c:253
@ OPCODE_NORMAL
Definition: dlist.c:297
@ OPCODE_ALPHA_FUNC
Definition: dlist.c:231
@ OPCODE_MAP1
Definition: dlist.c:290
@ OPCODE_POP_NAME
Definition: dlist.c:309
@ OPCODE_COLOR_4F
Definition: dlist.c:246
@ OPCODE_DISABLE
Definition: dlist.c:262
@ OPCODE_EVALMESH2
Definition: dlist.c:271
@ OPCODE_CLEAR_INDEX
Definition: dlist.c:242
@ OPCODE_TEXCOORD4
Definition: dlist.c:324
@ OPCODE_PASSTHROUGH
Definition: dlist.c:299
@ OPCODE_READ_BUFFER
Definition: dlist.c:316
@ OPCODE_VIEWPORT
Definition: dlist.c:336
@ OPCODE_EVALPOINT1
Definition: dlist.c:272
@ OPCODE_CONTINUE
Definition: dlist.c:338
@ OPCODE_COPY_TEX_SUB_IMAGE1D
Definition: dlist.c:256
@ OPCODE_POINT_SIZE
Definition: dlist.c:303
@ OPCODE_COLOR_4UB
Definition: dlist.c:247
@ OPCODE_COLOR_3F
Definition: dlist.c:245
@ OPCODE_CLEAR
Definition: dlist.c:238
@ OPCODE_TEX_SUB_IMAGE1D
Definition: dlist.c:330
@ OPCODE_DEPTH_MASK
Definition: dlist.c:260
@ OPCODE_LINE_WIDTH
Definition: dlist.c:284
@ OPCODE_COPY_PIXELS
Definition: dlist.c:252
@ OPCODE_CLEAR_COLOR
Definition: dlist.c:240
@ OPCODE_PUSH_NAME
Definition: dlist.c:313
@ OPCODE_ACCUM
Definition: dlist.c:230
@ OPCODE_COPY_TEX_IMAGE2D
Definition: dlist.c:254
@ OPCODE_LIGHT_MODEL
Definition: dlist.c:282
@ OPCODE_COPY_TEX_SUB_IMAGE2D
Definition: dlist.c:257
@ OPCODE_FRUSTUM
Definition: dlist.c:276
@ OPCODE_MULT_MATRIX
Definition: dlist.c:296
@ OPCODE_PUSH_MATRIX
Definition: dlist.c:312
@ OPCODE_POLYGON_OFFSET
Definition: dlist.c:306
@ OPCODE_LOAD_NAME
Definition: dlist.c:288
@ OPCODE_CLIP_PLANE
Definition: dlist.c:244
@ OPCODE_LOAD_MATRIX
Definition: dlist.c:287
@ OPCODE_LIST_BASE
Definition: dlist.c:285
@ OPCODE_DRAW_PIXELS
Definition: dlist.c:264
@ OPCODE_TEXENV
Definition: dlist.c:325
@ OPCODE_EVALCOORD1
Definition: dlist.c:268
@ OPCODE_VERTEX3
Definition: dlist.c:334
@ OPCODE_POLYGON_STIPPLE
Definition: dlist.c:305
@ OPCODE_EVALMESH1
Definition: dlist.c:270
@ OPCODE_EVALCOORD2
Definition: dlist.c:269
@ OPCODE_STENCIL_OP
Definition: dlist.c:322
@ OPCODE_PIXEL_TRANSFER
Definition: dlist.c:301
@ OPCODE_END_OF_LIST
Definition: dlist.c:339
@ OPCODE_PIXEL_ZOOM
Definition: dlist.c:302
@ OPCODE_TEXGEN
Definition: dlist.c:326
@ OPCODE_POLYGON_MODE
Definition: dlist.c:304
@ OPCODE_COLOR_MATERIAL
Definition: dlist.c:249
@ OPCODE_EVALPOINT2
Definition: dlist.c:273
@ OPCODE_PIXEL_MAP
Definition: dlist.c:300
@ OPCODE_MATRIX_MODE
Definition: dlist.c:295
@ OPCODE_PRIORITIZE_TEXTURE
Definition: dlist.c:310
@ OPCODE_INIT_NAMES
Definition: dlist.c:280
@ OPCODE_VERTEX2
Definition: dlist.c:333
@ OPCODE_COLOR_TABLE
Definition: dlist.c:250
@ OPCODE_VERTEX4
Definition: dlist.c:335
@ OPCODE_MATERIAL
Definition: dlist.c:294
@ OPCODE_SCALE
Definition: dlist.c:317
@ OPCODE_LOGIC_OP
Definition: dlist.c:289
@ OPCODE_RASTER_POS
Definition: dlist.c:314
@ OPCODE_TEX_SUB_IMAGE2D
Definition: dlist.c:331
@ OPCODE_STENCIL_FUNC
Definition: dlist.c:320
@ OPCODE_INDEX
Definition: dlist.c:278
@ OPCODE_SHADE_MODEL
Definition: dlist.c:319
@ OPCODE_DEPTH_FUNC
Definition: dlist.c:259
@ OPCODE_TEX_IMAGE1D
Definition: dlist.c:328
@ OPCODE_LINE_STIPPLE
Definition: dlist.c:283
@ OPCODE_SCISSOR
Definition: dlist.c:318
@ OPCODE_CLEAR_STENCIL
Definition: dlist.c:243
@ OPCODE_CULL_FACE
Definition: dlist.c:258
void gl_save_DrawPixels(GLcontext *ctx, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
Definition: dlist.c:1249
void gl_save_Color3fv(GLcontext *ctx, const GLfloat *c)
Definition: dlist.c:923
void gl_save_PointSize(GLcontext *ctx, GLfloat size)
Definition: dlist.c:1827
void gl_save_Ortho(GLcontext *ctx, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval)
Definition: dlist.c:1766
void gl_save_Indexi(GLcontext *ctx, GLint index)
Definition: dlist.c:1443
void gl_save_RasterPos4f(GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Definition: dlist.c:1959
void gl_save_CopyPixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
Definition: dlist.c:1067
void gl_save_LoadMatrixf(GLcontext *ctx, const GLfloat *m)
Definition: dlist.c:1569
void gl_save_LoadIdentity(GLcontext *ctx)
Definition: dlist.c:1560
void gl_save_Color4ub(GLcontext *ctx, GLubyte r, GLubyte g, GLubyte b, GLubyte a)
Definition: dlist.c:968
void gl_save_StencilFunc(GLcontext *ctx, GLenum func, GLint ref, GLuint mask)
Definition: dlist.c:2066
void gl_save_ShadeModel(GLcontext *ctx, GLenum mode)
Definition: dlist.c:2054
void gl_save_Vertex4f(GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Definition: dlist.c:2340
void gl_save_Indexf(GLcontext *ctx, GLfloat index)
Definition: dlist.c:1455
void gl_save_StencilMask(GLcontext *ctx, GLuint mask)
Definition: dlist.c:2080
#define BLOCK_SIZE
Definition: dlist.c:220
void gl_save_Normal3f(GLcontext *ctx, GLfloat nx, GLfloat ny, GLfloat nz)
Definition: dlist.c:1752
static void execute_list(GLcontext *ctx, GLuint list)
Definition: dlist.c:2397
static GLuint translate_id(GLsizei n, GLenum type, const GLvoid *list)
Definition: dlist.c:515
void gl_save_MapGrid1f(GLcontext *ctx, GLint un, GLfloat u1, GLfloat u2)
Definition: dlist.c:1653
void gl_save_Disable(GLcontext *ctx, GLenum cap)
Definition: dlist.c:1225
void gl_save_Materialfv(GLcontext *ctx, GLenum face, GLenum pname, const GLfloat *params)
Definition: dlist.c:1686
void gl_save_End(GLcontext *ctx)
Definition: dlist.c:1292
void gl_save_Color3f(GLcontext *ctx, GLfloat r, GLfloat g, GLfloat b)
Definition: dlist.c:909
void gl_CallLists(GLcontext *ctx, GLsizei n, GLenum type, const GLvoid *lists)
Definition: dlist.c:3064
void gl_save_Map1f(GLcontext *ctx, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points, GLboolean retain)
Definition: dlist.c:1608
static Node * make_empty_list(void)
Definition: dlist.c:416
void gl_save_Clear(GLcontext *ctx, GLbitfield mask)
Definition: dlist.c:813
void gl_save_ListBase(GLcontext *ctx, GLuint base)
Definition: dlist.c:1548
void gl_save_EvalPoint1(GLcontext *ctx, GLint i)
Definition: dlist.c:1358
void gl_save_PopAttrib(GLcontext *ctx)
Definition: dlist.c:1880
void gl_save_Map2f(GLcontext *ctx, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points, GLboolean retain)
Definition: dlist.c:1627
void gl_save_ClearStencil(GLcontext *ctx, GLint s)
Definition: dlist.c:881
void gl_save_PolygonMode(GLcontext *ctx, GLenum face, GLenum mode)
Definition: dlist.c:1839
void gl_save_ClearDepth(GLcontext *ctx, GLclampd depth)
Definition: dlist.c:857
#define NULL
Definition: types.h:112
UINT op
Definition: effect.c:236
WORD face[3]
Definition: mesh.c:4747
void gl_PopAttrib(GLcontext *ctx)
Definition: attrib.c:364
void gl_PushAttrib(GLcontext *ctx, GLbitfield mask)
Definition: attrib.c:87
void gl_Bitmap(GLcontext *ctx, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const struct gl_image *bitmap)
Definition: bitmap.c:161
void gl_ClipPlane(GLcontext *ctx, GLenum plane, const GLfloat *equation)
Definition: clip.c:204
#define MAX_LIST_NESTING
Definition: config.h:81
void gl_problem(const GLcontext *ctx, const char *s)
Definition: context.c:1394
void gl_error(GLcontext *ctx, GLenum error, const char *s)
Definition: context.c:1421
void gl_Enable(GLcontext *ctx, GLenum cap)
Definition: enable.c:462
void gl_Disable(GLcontext *ctx, GLenum cap)
Definition: enable.c:469
void gl_EvalMesh1(GLcontext *ctx, GLenum mode, GLint i1, GLint i2)
Definition: eval.c:2330
void gl_MapGrid1f(GLcontext *ctx, GLint un, GLfloat u1, GLfloat u2)
Definition: eval.c:2236
void gl_free_control_points(GLcontext *ctx, GLenum target, GLfloat *data)
Definition: eval.c:732
void gl_Map1f(GLcontext *ctx, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points, GLboolean retain)
Definition: eval.c:836
void gl_MapGrid2f(GLcontext *ctx, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
Definition: eval.c:2252
void gl_EvalMesh2(GLcontext *ctx, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
Definition: eval.c:2374
void gl_EvalPoint1(GLcontext *ctx, GLint i)
Definition: eval.c:2276
void gl_EvalPoint2(GLcontext *ctx, GLint i, GLint j)
Definition: eval.c:2296
void gl_EvalCoord1f(GLcontext *ctx, GLfloat u)
Definition: eval.c:1978
void gl_Map2f(GLcontext *ctx, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points, GLboolean retain)
Definition: eval.c:988
void gl_EvalCoord2f(GLcontext *ctx, GLfloat u, GLfloat v)
Definition: eval.c:2084
void HashRemove(struct HashTable *table, GLuint key)
Definition: hash.c:176
void * HashLookup(const struct HashTable *table, GLuint key)
Definition: hash.c:110
GLuint HashFindFreeKeyBlock(const struct HashTable *table, GLuint numKeys)
Definition: hash.c:248
void HashInsert(struct HashTable *table, GLuint key, void *data)
Definition: hash.c:138
void gl_free_image(struct gl_image *image)
Definition: image.c:661
void gl_LineStipple(GLcontext *ctx, GLint factor, GLushort pattern)
Definition: lines.c:120
void gl_LineWidth(GLcontext *ctx, GLfloat width)
Definition: lines.c:104
void gl_Scalef(GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z)
Definition: matrix.c:940
void gl_rotation_matrix(GLfloat angle, GLfloat x, GLfloat y, GLfloat z, GLfloat m[])
Definition: matrix.c:814
void gl_LoadIdentity(GLcontext *ctx)
Definition: matrix.c:709
void gl_Viewport(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height)
Definition: matrix.c:1014
void gl_Translatef(GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z)
Definition: matrix.c:976
void gl_PopMatrix(GLcontext *ctx)
Definition: matrix.c:653
void gl_MultMatrixf(GLcontext *ctx, const GLfloat *m)
Definition: matrix.c:785
void gl_PushMatrix(GLcontext *ctx)
Definition: matrix.c:603
void gl_Ortho(GLcontext *ctx, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval)
Definition: matrix.c:553
void gl_Frustum(GLcontext *ctx, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval)
Definition: matrix.c:511
void gl_LoadMatrixf(GLcontext *ctx, const GLfloat *m)
Definition: matrix.c:738
void gl_MatrixMode(GLcontext *ctx, GLenum mode)
Definition: matrix.c:584
void gl_Hint(GLcontext *ctx, GLenum target, GLenum mode)
Definition: misc.c:374
void gl_ReadBuffer(GLcontext *ctx, GLenum mode)
Definition: misc.c:455
void gl_ClearIndex(GLcontext *ctx, GLfloat c)
Definition: misc.c:117
void gl_Clear(GLcontext *ctx, GLbitfield mask)
Definition: misc.c:260
void gl_DrawBuffer(GLcontext *ctx, GLenum mode)
Definition: misc.c:408
void gl_ClearColor(GLcontext *ctx, GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
Definition: misc.c:132
void gl_Rectf(GLcontext *ctx, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
Definition: rect.c:58
#define assert(x)
Definition: debug.h:53
void gl_DrawPixels(GLcontext *ctx, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
Definition: drawpix.c:1145
void gl_PopName(GLcontext *ctx)
Definition: feedback.c:327
void gl_LoadName(GLcontext *ctx, GLuint name)
Definition: feedback.c:280
void gl_PushName(GLcontext *ctx, GLuint name)
Definition: feedback.c:305
void gl_PassThrough(GLcontext *ctx, GLfloat token)
Definition: feedback.c:143
void gl_InitNames(GLcontext *ctx)
Definition: feedback.c:219
void gl_Fogfv(GLcontext *ctx, GLenum pname, const GLfloat *params)
Definition: fog.c:70
GLint GLint GLsizei GLsizei GLsizei GLint border
Definition: gl.h:1546
unsigned char GLubyte
Definition: gl.h:157
#define GL_TRUE
Definition: gl.h:174
#define GL_INVALID_VALUE
Definition: gl.h:695
signed char GLbyte
Definition: gl.h:154
GLuint start
Definition: gl.h:1545
#define GL_INT
Definition: gl.h:181
GLint GLint GLsizei GLsizei GLsizei depth
Definition: gl.h:1546
GLint level
Definition: gl.h:1546
short GLshort
Definition: gl.h:155
float GLfloat
Definition: gl.h:161
GLclampf green
Definition: gl.h:1740
GLint GLint xoffset
Definition: gl.h:1547
#define GL_UNSIGNED_SHORT
Definition: gl.h:180
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
const GLdouble * v
Definition: gl.h:2040
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: gl.h:1546
GLeglImageOES image
Definition: gl.h:2204
double GLdouble
Definition: gl.h:163
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define GL_INVALID_OPERATION
Definition: gl.h:696
GLclampf GLclampf GLclampf alpha
Definition: gl.h:1740
unsigned int GLenum
Definition: gl.h:150
GLdouble s
Definition: gl.h:2039
#define GL_2_BYTES
Definition: gl.h:184
#define GL_BYTE
Definition: gl.h:177
unsigned int GLuint
Definition: gl.h:159
#define GL_UNSIGNED_INT
Definition: gl.h:182
#define GL_FLOAT
Definition: gl.h:183
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
#define GL_SHORT
Definition: gl.h:179
#define GL_UNSIGNED_BYTE
Definition: gl.h:178
#define GL_3_BYTES
Definition: gl.h:185
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLint GLint internalformat
Definition: gl.h:1546
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
#define GL_COMPILE
Definition: gl.h:286
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
#define GL_FALSE
Definition: gl.h:173
double GLclampd
Definition: gl.h:164
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLclampf GLclampf blue
Definition: gl.h:1740
unsigned int GLbitfield
Definition: gl.h:152
int GLsizei
Definition: gl.h:160
unsigned short GLushort
Definition: gl.h:158
GLdouble GLdouble t
Definition: gl.h:2047
int GLint
Definition: gl.h:156
#define GL_OUT_OF_MEMORY
Definition: gl.h:699
GLint GLint GLsizei width
Definition: gl.h:1546
float GLclampf
Definition: gl.h:162
GLint GLint GLint yoffset
Definition: gl.h:1547
#define GL_4_BYTES
Definition: gl.h:186
unsigned char GLboolean
Definition: gl.h:151
#define GL_INVALID_ENUM
Definition: gl.h:694
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
#define GL_COMPILE_AND_EXECUTE
Definition: gl.h:287
GLsizeiptr size
Definition: glext.h:5919
GLenum func
Definition: glext.h:6028
GLdouble n
Definition: glext.h:7729
GLdouble GLdouble GLint ustride
Definition: glext.h:8308
GLenum GLuint texture
Definition: glext.h:6295
GLsizei stride
Definition: glext.h:5848
GLfloat GLfloat nz
Definition: glext.h:8896
GLenum GLenum GLuint components
Definition: glext.h:9620
const GLuint * textures
Definition: glext.h:8098
GLuint coord
Definition: glext.h:9511
const GLubyte * c
Definition: glext.h:8905
GLuint index
Definition: glext.h:6031
GLenum GLint GLuint mask
Definition: glext.h:6028
GLfloat ny
Definition: glext.h:8896
GLdouble GLdouble GLdouble GLdouble top
Definition: glext.h:10859
GLenum pname
Definition: glext.h:5645
GLdouble GLdouble right
Definition: glext.h:10859
GLdouble GLdouble GLint GLint uorder
Definition: glext.h:8308
GLubyte * pattern
Definition: glext.h:7787
GLenum GLuint GLint GLenum face
Definition: glext.h:7025
GLfloat f
Definition: glext.h:7540
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLenum GLint * range
Definition: glext.h:7539
GLfloat GLfloat GLfloat GLfloat nx
Definition: glext.h:8898
GLenum mode
Definition: glext.h:6217
GLenum const GLfloat * params
Definition: glext.h:5645
GLfloat units
Definition: glext.h:11727
GLint left
Definition: glext.h:7726
GLboolean GLenum GLenum GLvoid * values
Definition: glext.h:5666
GLint GLint bottom
Definition: glext.h:7726
GLboolean GLboolean g
Definition: glext.h:6204
GLfloat angle
Definition: glext.h:10853
GLdouble GLdouble u2
Definition: glext.h:8308
GLdouble GLdouble GLint GLint GLdouble GLdouble GLint GLint vorder
Definition: glext.h:8308
GLfloat GLfloat p
Definition: glext.h:8902
GLuint GLuint num
Definition: glext.h:9618
const GLuint const GLclampf * priorities
Definition: glext.h:8103
GLfloat param
Definition: glext.h:5796
GLuint GLdouble GLdouble GLint GLint order
Definition: glext.h:11194
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
GLfloat GLfloat v1
Definition: glext.h:6062
GLfloat GLfloat GLfloat v2
Definition: glext.h:6063
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
GLdouble u1
Definition: glext.h:8308
GLenum cap
Definition: glext.h:9639
GLsizei const GLfloat * points
Definition: glext.h:8112
GLdouble GLdouble z
Definition: glext.h:5874
GLdouble GLdouble GLint GLint GLdouble GLdouble GLint vstride
Definition: glext.h:8308
GLenum internalFormat
Definition: glext.h:8404
const GLfloat * m
Definition: glext.h:10848
GLenum target
Definition: glext.h:7315
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint factor
Definition: glfuncs.h:178
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean flag
Definition: glfuncs.h:52
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLby