dlist.c File Reference

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "accum.h"
#include "alpha.h"
#include "attrib.h"
#include "bitmap.h"
#include "blend.h"
#include "clip.h"
#include "colortab.h"
#include "context.h"
#include "copypix.h"
#include "depth.h"
#include "drawpix.h"
#include "enable.h"
#include "eval.h"
#include "feedback.h"
#include "fog.h"
#include "hash.h"
#include "image.h"
#include "light.h"
#include "lines.h"
#include "dlist.h"
#include "logic.h"
#include "macros.h"
#include "masking.h"
#include "matrix.h"
#include "misc.h"
#include "pixel.h"
#include "points.h"
#include "polygon.h"
#include "rastpos.h"
#include "rect.h"
#include "scissor.h"
#include "stencil.h"
#include "texobj.h"
#include "teximage.h"
#include "texstate.h"
#include "types.h"
#include "vb.h"
#include "vbfill.h"

Include dependency graph for dlist.c:

Go to the source code of this file.

Classes
struct	node

Macros
#define	BLOCK_SIZE   500

Enumerations
enum	OpCode {   OPCODE_ACCUM, OPCODE_ALPHA_FUNC, OPCODE_BEGIN, OPCODE_BIND_TEXTURE,   OPCODE_BITMAP, OPCODE_BLEND_FUNC, OPCODE_CALL_LIST, OPCODE_CALL_LIST_OFFSET,   OPCODE_CLEAR, OPCODE_CLEAR_ACCUM, OPCODE_CLEAR_COLOR, OPCODE_CLEAR_DEPTH,   OPCODE_CLEAR_INDEX, OPCODE_CLEAR_STENCIL, OPCODE_CLIP_PLANE, OPCODE_COLOR_3F,   OPCODE_COLOR_4F, OPCODE_COLOR_4UB, OPCODE_COLOR_MASK, OPCODE_COLOR_MATERIAL,   OPCODE_COLOR_TABLE, OPCODE_COLOR_SUB_TABLE, OPCODE_COPY_PIXELS, OPCODE_COPY_TEX_IMAGE1D,   OPCODE_COPY_TEX_IMAGE2D, OPCODE_COPY_TEX_IMAGE3D, OPCODE_COPY_TEX_SUB_IMAGE1D, OPCODE_COPY_TEX_SUB_IMAGE2D,   OPCODE_CULL_FACE, OPCODE_DEPTH_FUNC, OPCODE_DEPTH_MASK, OPCODE_DEPTH_RANGE,   OPCODE_DISABLE, OPCODE_DRAW_BUFFER, OPCODE_DRAW_PIXELS, OPCODE_EDGE_FLAG,   OPCODE_ENABLE, OPCODE_END, OPCODE_EVALCOORD1, OPCODE_EVALCOORD2,   OPCODE_EVALMESH1, OPCODE_EVALMESH2, OPCODE_EVALPOINT1, OPCODE_EVALPOINT2,   OPCODE_FOG, OPCODE_FRONT_FACE, OPCODE_FRUSTUM, OPCODE_HINT,   OPCODE_INDEX, OPCODE_INDEX_MASK, OPCODE_INIT_NAMES, OPCODE_LIGHT,   OPCODE_LIGHT_MODEL, OPCODE_LINE_STIPPLE, OPCODE_LINE_WIDTH, OPCODE_LIST_BASE,   OPCODE_LOAD_IDENTITY, OPCODE_LOAD_MATRIX, OPCODE_LOAD_NAME, OPCODE_LOGIC_OP,   OPCODE_MAP1, OPCODE_MAP2, OPCODE_MAPGRID1, OPCODE_MAPGRID2,   OPCODE_MATERIAL, OPCODE_MATRIX_MODE, OPCODE_MULT_MATRIX, OPCODE_NORMAL,   OPCODE_ORTHO, OPCODE_PASSTHROUGH, OPCODE_PIXEL_MAP, OPCODE_PIXEL_TRANSFER,   OPCODE_PIXEL_ZOOM, OPCODE_POINT_SIZE, OPCODE_POLYGON_MODE, OPCODE_POLYGON_STIPPLE,   OPCODE_POLYGON_OFFSET, OPCODE_POP_ATTRIB, OPCODE_POP_MATRIX, OPCODE_POP_NAME,   OPCODE_PRIORITIZE_TEXTURE, OPCODE_PUSH_ATTRIB, OPCODE_PUSH_MATRIX, OPCODE_PUSH_NAME,   OPCODE_RASTER_POS, OPCODE_RECTF, OPCODE_READ_BUFFER, OPCODE_SCALE,   OPCODE_SCISSOR, OPCODE_SHADE_MODEL, OPCODE_STENCIL_FUNC, OPCODE_STENCIL_MASK,   OPCODE_STENCIL_OP, OPCODE_TEXCOORD2, OPCODE_TEXCOORD4, OPCODE_TEXENV,   OPCODE_TEXGEN, OPCODE_TEXPARAMETER, OPCODE_TEX_IMAGE1D, OPCODE_TEX_IMAGE2D,   OPCODE_TEX_SUB_IMAGE1D, OPCODE_TEX_SUB_IMAGE2D, OPCODE_TRANSLATE, OPCODE_VERTEX2,   OPCODE_VERTEX3, OPCODE_VERTEX4, OPCODE_VIEWPORT, OPCODE_CONTINUE,   OPCODE_END_OF_LIST }

Functions
static Node *	alloc_instruction (GLcontext *ctx, OpCode opcode, GLint argcount)
static Node *	make_empty_list (void)
void	gl_destroy_list (GLcontext *ctx, GLuint list)
static GLuint	translate_id (GLsizei n, GLenum type, const GLvoid *list)
void	gl_init_lists (void)
void	gl_save_Accum (GLcontext *ctx, GLenum op, GLfloat value)
void	gl_save_AlphaFunc (GLcontext *ctx, GLenum func, GLclampf ref)
void	gl_save_Begin (GLcontext *ctx, GLenum mode)
void	gl_save_BindTexture (GLcontext *ctx, GLenum target, GLuint texture)
void	gl_save_Bitmap (GLcontext *ctx, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const struct gl_image *bitmap)
void	gl_save_BlendFunc (GLcontext *ctx, GLenum sfactor, GLenum dfactor)
void	gl_save_CallList (GLcontext *ctx, GLuint list)
void	gl_save_CallLists (GLcontext *ctx, GLsizei n, GLenum type, const GLvoid *lists)
void	gl_save_Clear (GLcontext *ctx, GLbitfield mask)
void	gl_save_ClearAccum (GLcontext *ctx, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
void	gl_save_ClearColor (GLcontext *ctx, GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
void	gl_save_ClearDepth (GLcontext *ctx, GLclampd depth)
void	gl_save_ClearIndex (GLcontext *ctx, GLfloat c)
void	gl_save_ClearStencil (GLcontext *ctx, GLint s)
void	gl_save_ClipPlane (GLcontext *ctx, GLenum plane, const GLfloat *equ)
void	gl_save_Color3f (GLcontext *ctx, GLfloat r, GLfloat g, GLfloat b)
void	gl_save_Color3fv (GLcontext *ctx, const GLfloat *c)
void	gl_save_Color4f (GLcontext *ctx, GLfloat r, GLfloat g, GLfloat b, GLfloat a)
void	gl_save_Color4fv (GLcontext *ctx, const GLfloat *c)
void	gl_save_Color4ub (GLcontext *ctx, GLubyte r, GLubyte g, GLubyte b, GLubyte a)
void	gl_save_Color4ubv (GLcontext *ctx, const GLubyte *c)
void	gl_save_ColorMask (GLcontext *ctx, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
void	gl_save_ColorMaterial (GLcontext *ctx, GLenum face, GLenum mode)
void	gl_save_ColorTable (GLcontext *ctx, GLenum target, GLenum internalFormat, struct gl_image *table)
void	gl_save_ColorSubTable (GLcontext *ctx, GLenum target, GLsizei start, struct gl_image *data)
void	gl_save_CopyPixels (GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
void	gl_save_CopyTexImage1D (GLcontext *ctx, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
void	gl_save_CopyTexImage2D (GLcontext *ctx, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
void	gl_save_CopyTexSubImage1D (GLcontext *ctx, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
void	gl_save_CopyTexSubImage2D (GLcontext *ctx, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLint height)
void	gl_save_CullFace (GLcontext *ctx, GLenum mode)
void	gl_save_DepthFunc (GLcontext *ctx, GLenum func)
void	gl_save_DepthMask (GLcontext *ctx, GLboolean mask)
void	gl_save_DepthRange (GLcontext *ctx, GLclampd nearval, GLclampd farval)
void	gl_save_Disable (GLcontext *ctx, GLenum cap)
void	gl_save_DrawBuffer (GLcontext *ctx, GLenum mode)
void	gl_save_DrawPixels (GLcontext *ctx, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
void	gl_save_EdgeFlag (GLcontext *ctx, GLboolean flag)
void	gl_save_Enable (GLcontext *ctx, GLenum cap)
void	gl_save_End (GLcontext *ctx)
void	gl_save_EvalCoord1f (GLcontext *ctx, GLfloat u)
void	gl_save_EvalCoord2f (GLcontext *ctx, GLfloat u, GLfloat v)
void	gl_save_EvalMesh1 (GLcontext *ctx, GLenum mode, GLint i1, GLint i2)
void	gl_save_EvalMesh2 (GLcontext *ctx, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
void	gl_save_EvalPoint1 (GLcontext *ctx, GLint i)
void	gl_save_EvalPoint2 (GLcontext *ctx, GLint i, GLint j)
void	gl_save_Fogfv (GLcontext *ctx, GLenum pname, const GLfloat *params)
void	gl_save_FrontFace (GLcontext *ctx, GLenum mode)
void	gl_save_Frustum (GLcontext *ctx, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval)
void	gl_save_Hint (GLcontext *ctx, GLenum target, GLenum mode)
void	gl_save_Indexi (GLcontext *ctx, GLint index)
void	gl_save_Indexf (GLcontext *ctx, GLfloat index)
void	gl_save_IndexMask (GLcontext *ctx, GLuint mask)
void	gl_save_InitNames (GLcontext *ctx)
void	gl_save_Lightfv (GLcontext *ctx, GLenum light, GLenum pname, const GLfloat *params, GLint numparams)
void	gl_save_LightModelfv (GLcontext *ctx, GLenum pname, const GLfloat *params)
void	gl_save_LineStipple (GLcontext *ctx, GLint factor, GLushort pattern)
void	gl_save_LineWidth (GLcontext *ctx, GLfloat width)
void	gl_save_ListBase (GLcontext *ctx, GLuint base)
void	gl_save_LoadIdentity (GLcontext *ctx)
void	gl_save_LoadMatrixf (GLcontext *ctx, const GLfloat *m)
void	gl_save_LoadName (GLcontext *ctx, GLuint name)
void	gl_save_LogicOp (GLcontext *ctx, GLenum opcode)
void	gl_save_Map1f (GLcontext *ctx, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points, GLboolean retain)
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)
void	gl_save_MapGrid1f (GLcontext *ctx, GLint un, GLfloat u1, GLfloat u2)
void	gl_save_MapGrid2f (GLcontext *ctx, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
void	gl_save_Materialfv (GLcontext *ctx, GLenum face, GLenum pname, const GLfloat *params)
void	gl_save_MatrixMode (GLcontext *ctx, GLenum mode)
void	gl_save_MultMatrixf (GLcontext *ctx, const GLfloat *m)
void	gl_save_NewList (GLcontext *ctx, GLuint list, GLenum mode)
void	gl_save_Normal3fv (GLcontext *ctx, const GLfloat norm[3])
void	gl_save_Normal3f (GLcontext *ctx, GLfloat nx, GLfloat ny, GLfloat nz)
void	gl_save_Ortho (GLcontext *ctx, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval)
void	gl_save_PixelMapfv (GLcontext *ctx, GLenum map, GLint mapsize, const GLfloat *values)
void	gl_save_PixelTransferf (GLcontext *ctx, GLenum pname, GLfloat param)
void	gl_save_PixelZoom (GLcontext *ctx, GLfloat xfactor, GLfloat yfactor)
void	gl_save_PointSize (GLcontext *ctx, GLfloat size)
void	gl_save_PolygonMode (GLcontext *ctx, GLenum face, GLenum mode)
void	gl_save_PolygonStipple (GLcontext *ctx, const GLubyte *mask)
void	gl_save_PolygonOffset (GLcontext *ctx, GLfloat factor, GLfloat units)
void	gl_save_PopAttrib (GLcontext *ctx)
void	gl_save_PopMatrix (GLcontext *ctx)
void	gl_save_PopName (GLcontext *ctx)
void	gl_save_PrioritizeTextures (GLcontext *ctx, GLsizei num, const GLuint *textures, const GLclampf *priorities)
void	gl_save_PushAttrib (GLcontext *ctx, GLbitfield mask)
void	gl_save_PushMatrix (GLcontext *ctx)
void	gl_save_PushName (GLcontext *ctx, GLuint name)
void	gl_save_RasterPos4f (GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
void	gl_save_PassThrough (GLcontext *ctx, GLfloat token)
void	gl_save_ReadBuffer (GLcontext *ctx, GLenum mode)
void	gl_save_Rectf (GLcontext *ctx, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
void	gl_save_Rotatef (GLcontext *ctx, GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
void	gl_save_Scalef (GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z)
void	gl_save_Scissor (GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height)
void	gl_save_ShadeModel (GLcontext *ctx, GLenum mode)
void	gl_save_StencilFunc (GLcontext *ctx, GLenum func, GLint ref, GLuint mask)
void	gl_save_StencilMask (GLcontext *ctx, GLuint mask)
void	gl_save_StencilOp (GLcontext *ctx, GLenum fail, GLenum zfail, GLenum zpass)
void	gl_save_TexCoord2f (GLcontext *ctx, GLfloat s, GLfloat t)
void	gl_save_TexCoord4f (GLcontext *ctx, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
void	gl_save_TexEnvfv (GLcontext *ctx, GLenum target, GLenum pname, const GLfloat *params)
void	gl_save_TexGenfv (GLcontext *ctx, GLenum coord, GLenum pname, const GLfloat *params)
void	gl_save_TexParameterfv (GLcontext *ctx, GLenum target, GLenum pname, const GLfloat *params)
void	gl_save_TexImage1D (GLcontext *ctx, GLenum target, GLint level, GLint components, GLsizei width, GLint border, GLenum format, GLenum type, struct gl_image *teximage)
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)
void	gl_save_TexSubImage1D (GLcontext *ctx, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, struct gl_image *image)
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)
void	gl_save_Translatef (GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z)
void	gl_save_Vertex2f (GLcontext *ctx, GLfloat x, GLfloat y)
void	gl_save_Vertex3f (GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z)
void	gl_save_Vertex4f (GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
void	gl_save_Vertex3fv (GLcontext *ctx, const GLfloat v[3])
void	gl_save_Viewport (GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height)
static void	execute_list (GLcontext *ctx, GLuint list)
GLboolean	gl_IsList (GLcontext *ctx, GLuint list)
void	gl_DeleteLists (GLcontext *ctx, GLuint list, GLsizei range)
GLuint	gl_GenLists (GLcontext *ctx, GLsizei range)
void	gl_NewList (GLcontext *ctx, GLuint list, GLenum mode)
void	gl_EndList (GLcontext *ctx)
void	gl_CallList (GLcontext *ctx, GLuint list)
void	gl_CallLists (GLcontext *ctx, GLsizei n, GLenum type, const GLvoid *lists)
void	gl_ListBase (GLcontext *ctx, GLuint base)

Variables
static GLuint	InstSize [OPCODE_END_OF_LIST+1]

Macro Definition Documentation

BLOCK_SIZE

#define BLOCK_SIZE   500

Definition at line 220 of file dlist.c.

Enumeration Type Documentation

OpCode

enum OpCode

Enumerator
OPCODE_ACCUM
OPCODE_ALPHA_FUNC
OPCODE_BEGIN
OPCODE_BIND_TEXTURE
OPCODE_BITMAP
OPCODE_BLEND_FUNC
OPCODE_CALL_LIST
OPCODE_CALL_LIST_OFFSET
OPCODE_CLEAR
OPCODE_CLEAR_ACCUM
OPCODE_CLEAR_COLOR
OPCODE_CLEAR_DEPTH
OPCODE_CLEAR_INDEX
OPCODE_CLEAR_STENCIL
OPCODE_CLIP_PLANE
OPCODE_COLOR_3F
OPCODE_COLOR_4F
OPCODE_COLOR_4UB
OPCODE_COLOR_MASK
OPCODE_COLOR_MATERIAL
OPCODE_COLOR_TABLE
OPCODE_COLOR_SUB_TABLE
OPCODE_COPY_PIXELS
OPCODE_COPY_TEX_IMAGE1D
OPCODE_COPY_TEX_IMAGE2D
OPCODE_COPY_TEX_IMAGE3D
OPCODE_COPY_TEX_SUB_IMAGE1D
OPCODE_COPY_TEX_SUB_IMAGE2D
OPCODE_CULL_FACE
OPCODE_DEPTH_FUNC
OPCODE_DEPTH_MASK
OPCODE_DEPTH_RANGE
OPCODE_DISABLE
OPCODE_DRAW_BUFFER
OPCODE_DRAW_PIXELS
OPCODE_EDGE_FLAG
OPCODE_ENABLE
OPCODE_END
OPCODE_EVALCOORD1
OPCODE_EVALCOORD2
OPCODE_EVALMESH1
OPCODE_EVALMESH2
OPCODE_EVALPOINT1
OPCODE_EVALPOINT2
OPCODE_FOG
OPCODE_FRONT_FACE
OPCODE_FRUSTUM
OPCODE_HINT
OPCODE_INDEX
OPCODE_INDEX_MASK
OPCODE_INIT_NAMES
OPCODE_LIGHT
OPCODE_LIGHT_MODEL
OPCODE_LINE_STIPPLE
OPCODE_LINE_WIDTH
OPCODE_LIST_BASE
OPCODE_LOAD_IDENTITY
OPCODE_LOAD_MATRIX
OPCODE_LOAD_NAME
OPCODE_LOGIC_OP
OPCODE_MAP1
OPCODE_MAP2
OPCODE_MAPGRID1
OPCODE_MAPGRID2
OPCODE_MATERIAL
OPCODE_MATRIX_MODE
OPCODE_MULT_MATRIX
OPCODE_NORMAL
OPCODE_ORTHO
OPCODE_PASSTHROUGH
OPCODE_PIXEL_MAP
OPCODE_PIXEL_TRANSFER
OPCODE_PIXEL_ZOOM
OPCODE_POINT_SIZE
OPCODE_POLYGON_MODE
OPCODE_POLYGON_STIPPLE
OPCODE_POLYGON_OFFSET
OPCODE_POP_ATTRIB
OPCODE_POP_MATRIX
OPCODE_POP_NAME
OPCODE_PRIORITIZE_TEXTURE
OPCODE_PUSH_ATTRIB
OPCODE_PUSH_MATRIX
OPCODE_PUSH_NAME
OPCODE_RASTER_POS
OPCODE_RECTF
OPCODE_READ_BUFFER
OPCODE_SCALE
OPCODE_SCISSOR
OPCODE_SHADE_MODEL
OPCODE_STENCIL_FUNC
OPCODE_STENCIL_MASK
OPCODE_STENCIL_OP
OPCODE_TEXCOORD2
OPCODE_TEXCOORD4
OPCODE_TEXENV
OPCODE_TEXGEN
OPCODE_TEXPARAMETER
OPCODE_TEX_IMAGE1D
OPCODE_TEX_IMAGE2D
OPCODE_TEX_SUB_IMAGE1D
OPCODE_TEX_SUB_IMAGE2D
OPCODE_TRANSLATE
OPCODE_VERTEX2
OPCODE_VERTEX3
OPCODE_VERTEX4
OPCODE_VIEWPORT
OPCODE_CONTINUE
OPCODE_END_OF_LIST

Definition at line 229 of file dlist.c.

             {
    OPCODE_ACCUM,
    OPCODE_ALPHA_FUNC,
        OPCODE_BEGIN,
        OPCODE_BIND_TEXTURE,
    OPCODE_BITMAP,
    OPCODE_BLEND_FUNC,
        OPCODE_CALL_LIST,
        OPCODE_CALL_LIST_OFFSET,
    OPCODE_CLEAR,
    OPCODE_CLEAR_ACCUM,
    OPCODE_CLEAR_COLOR,
    OPCODE_CLEAR_DEPTH,
    OPCODE_CLEAR_INDEX,
    OPCODE_CLEAR_STENCIL,
        OPCODE_CLIP_PLANE,
    OPCODE_COLOR_3F,
    OPCODE_COLOR_4F,
    OPCODE_COLOR_4UB,
    OPCODE_COLOR_MASK,
    OPCODE_COLOR_MATERIAL,
    OPCODE_COLOR_TABLE,
    OPCODE_COLOR_SUB_TABLE,
    OPCODE_COPY_PIXELS,
        OPCODE_COPY_TEX_IMAGE1D,
        OPCODE_COPY_TEX_IMAGE2D,
        OPCODE_COPY_TEX_IMAGE3D,
        OPCODE_COPY_TEX_SUB_IMAGE1D,
        OPCODE_COPY_TEX_SUB_IMAGE2D,
    OPCODE_CULL_FACE,
    OPCODE_DEPTH_FUNC,
    OPCODE_DEPTH_MASK,
    OPCODE_DEPTH_RANGE,
    OPCODE_DISABLE,
    OPCODE_DRAW_BUFFER,
    OPCODE_DRAW_PIXELS,
        OPCODE_EDGE_FLAG,
    OPCODE_ENABLE,
        OPCODE_END,
    OPCODE_EVALCOORD1,
    OPCODE_EVALCOORD2,
    OPCODE_EVALMESH1,
    OPCODE_EVALMESH2,
    OPCODE_EVALPOINT1,
    OPCODE_EVALPOINT2,
    OPCODE_FOG,
    OPCODE_FRONT_FACE,
    OPCODE_FRUSTUM,
    OPCODE_HINT,
    OPCODE_INDEX,
    OPCODE_INDEX_MASK,
    OPCODE_INIT_NAMES,
    OPCODE_LIGHT,
    OPCODE_LIGHT_MODEL,
    OPCODE_LINE_STIPPLE,
    OPCODE_LINE_WIDTH,
    OPCODE_LIST_BASE,
    OPCODE_LOAD_IDENTITY,
    OPCODE_LOAD_MATRIX,
    OPCODE_LOAD_NAME,
    OPCODE_LOGIC_OP,
    OPCODE_MAP1,
    OPCODE_MAP2,
    OPCODE_MAPGRID1,
    OPCODE_MAPGRID2,
    OPCODE_MATERIAL,
    OPCODE_MATRIX_MODE,
    OPCODE_MULT_MATRIX,
        OPCODE_NORMAL,
    OPCODE_ORTHO,
    OPCODE_PASSTHROUGH,
    OPCODE_PIXEL_MAP,
    OPCODE_PIXEL_TRANSFER,
    OPCODE_PIXEL_ZOOM,
    OPCODE_POINT_SIZE,
    OPCODE_POLYGON_MODE,
        OPCODE_POLYGON_STIPPLE,
    OPCODE_POLYGON_OFFSET,
    OPCODE_POP_ATTRIB,
    OPCODE_POP_MATRIX,
    OPCODE_POP_NAME,
    OPCODE_PRIORITIZE_TEXTURE,
    OPCODE_PUSH_ATTRIB,
    OPCODE_PUSH_MATRIX,
    OPCODE_PUSH_NAME,
    OPCODE_RASTER_POS,
    OPCODE_RECTF,
    OPCODE_READ_BUFFER,
        OPCODE_SCALE,
    OPCODE_SCISSOR,
    OPCODE_SHADE_MODEL,
    OPCODE_STENCIL_FUNC,
    OPCODE_STENCIL_MASK,
    OPCODE_STENCIL_OP,
    OPCODE_TEXCOORD2,
    OPCODE_TEXCOORD4,
        OPCODE_TEXENV,
        OPCODE_TEXGEN,
        OPCODE_TEXPARAMETER,
    OPCODE_TEX_IMAGE1D,
    OPCODE_TEX_IMAGE2D,
    OPCODE_TEX_SUB_IMAGE1D,
    OPCODE_TEX_SUB_IMAGE2D,
        OPCODE_TRANSLATE,
        OPCODE_VERTEX2,
        OPCODE_VERTEX3,
        OPCODE_VERTEX4,
    OPCODE_VIEWPORT,
    /* The following two are meta instructions */
    OPCODE_CONTINUE,
    OPCODE_END_OF_LIST
} OpCode;

Function Documentation

alloc_instruction()

static Node* alloc_instruction ( GLcontext *  ctx, OpCode  opcode, GLint  argcount  )

static

Definition at line 381 of file dlist.c.

{
   Node *n, *newblock;
   GLuint count = InstSize[opcode];

   assert( count == argcount+1 );

   if (ctx->CurrentPos + count + 2 > BLOCK_SIZE) {
      /* This block is full.  Allocate a new block and chain to it */
      n = ctx->CurrentBlock + ctx->CurrentPos;
      n[0].opcode = OPCODE_CONTINUE;
      newblock = (Node *) malloc( sizeof(Node) * BLOCK_SIZE );
      if (!newblock) {
         gl_error( ctx, GL_OUT_OF_MEMORY, "Building display list" );
         return NULL;
      }
      n[1].next = (Node *) newblock;
      ctx->CurrentBlock = newblock;
      ctx->CurrentPos = 0;
   }

   n = ctx->CurrentBlock + ctx->CurrentPos;
   ctx->CurrentPos += count;

   n[0].opcode = opcode;

   return n;
}

Referenced by gl_EndList(), gl_save_Accum(), gl_save_AlphaFunc(), gl_save_Begin(), gl_save_BindTexture(), gl_save_Bitmap(), gl_save_BlendFunc(), gl_save_CallList(), gl_save_CallLists(), gl_save_Clear(), gl_save_ClearAccum(), gl_save_ClearColor(), gl_save_ClearDepth(), gl_save_ClearIndex(), gl_save_ClearStencil(), gl_save_ClipPlane(), gl_save_Color3f(), gl_save_Color3fv(), gl_save_Color4f(), gl_save_Color4fv(), gl_save_Color4ub(), gl_save_Color4ubv(), gl_save_ColorMask(), gl_save_ColorMaterial(), gl_save_ColorSubTable(), gl_save_ColorTable(), gl_save_CopyPixels(), gl_save_CopyTexImage1D(), gl_save_CopyTexImage2D(), gl_save_CopyTexSubImage1D(), gl_save_CopyTexSubImage2D(), gl_save_CullFace(), gl_save_DepthFunc(), gl_save_DepthMask(), gl_save_DepthRange(), gl_save_Disable(), gl_save_DrawBuffer(), gl_save_DrawPixels(), gl_save_EdgeFlag(), gl_save_Enable(), gl_save_End(), gl_save_EvalCoord1f(), gl_save_EvalCoord2f(), gl_save_EvalMesh1(), gl_save_EvalMesh2(), gl_save_EvalPoint1(), gl_save_EvalPoint2(), gl_save_Fogfv(), gl_save_FrontFace(), gl_save_Frustum(), gl_save_Hint(), gl_save_Indexf(), gl_save_Indexi(), gl_save_IndexMask(), gl_save_InitNames(), gl_save_Lightfv(), gl_save_LightModelfv(), gl_save_LineStipple(), gl_save_LineWidth(), gl_save_ListBase(), gl_save_LoadIdentity(), gl_save_LoadMatrixf(), gl_save_LoadName(), gl_save_LogicOp(), gl_save_Map1f(), gl_save_Map2f(), gl_save_MapGrid1f(), gl_save_MapGrid2f(), gl_save_Materialfv(), gl_save_MatrixMode(), gl_save_MultMatrixf(), gl_save_Normal3f(), gl_save_Normal3fv(), gl_save_Ortho(), gl_save_PassThrough(), gl_save_PixelMapfv(), gl_save_PixelTransferf(), gl_save_PixelZoom(), gl_save_PointSize(), gl_save_PolygonMode(), gl_save_PolygonOffset(), gl_save_PolygonStipple(), gl_save_PopAttrib(), gl_save_PopMatrix(), gl_save_PopName(), gl_save_PrioritizeTextures(), gl_save_PushAttrib(), gl_save_PushMatrix(), gl_save_PushName(), gl_save_RasterPos4f(), gl_save_ReadBuffer(), gl_save_Rectf(), gl_save_Scalef(), gl_save_Scissor(), gl_save_ShadeModel(), gl_save_StencilFunc(), gl_save_StencilMask(), gl_save_StencilOp(), gl_save_TexCoord2f(), gl_save_TexCoord4f(), gl_save_TexEnvfv(), gl_save_TexGenfv(), gl_save_TexImage1D(), gl_save_TexImage2D(), gl_save_TexParameterfv(), gl_save_TexSubImage1D(), gl_save_TexSubImage2D(), gl_save_Translatef(), gl_save_Vertex2f(), gl_save_Vertex3f(), gl_save_Vertex3fv(), gl_save_Vertex4f(), and gl_save_Viewport().

execute_list()

static void execute_list ( GLcontext *  ctx, GLuint  list  )

static

Definition at line 2397 of file dlist.c.

{
   Node *n;
   GLboolean done;
   OpCode opcode;

   if (!gl_IsList(ctx,list))
      return;

   ctx->CallDepth++;

   n = (Node *) HashLookup(ctx->Shared->DisplayList, list);

   done = GL_FALSE;
   while (!done) {
      opcode = n[0].opcode;

      switch (opcode) {
     /* Frequently called functions: */
         case OPCODE_VERTEX2:
            (*ctx->Exec.Vertex2f)( ctx, n[1].f, n[2].f );
            break;
         case OPCODE_VERTEX3:
            (*ctx->Exec.Vertex3f)( ctx, n[1].f, n[2].f, n[3].f );
            break;
         case OPCODE_VERTEX4:
            (*ctx->Exec.Vertex4f)( ctx, n[1].f, n[2].f, n[3].f, n[4].f );
            break;
         case OPCODE_NORMAL:
            ctx->Current.Normal[0] = n[1].f;
            ctx->Current.Normal[1] = n[2].f;
            ctx->Current.Normal[2] = n[3].f;
            ctx->VB->MonoNormal = GL_FALSE;
            break;
     case OPCODE_COLOR_4UB:
            (*ctx->Exec.Color4ub)( ctx, n[1].ub, n[2].ub, n[3].ub, n[4].ub );
        break;
     case OPCODE_COLOR_3F:
            (*ctx->Exec.Color3f)( ctx, n[1].f, n[2].f, n[3].f );
            break;
     case OPCODE_COLOR_4F:
            (*ctx->Exec.Color4f)( ctx, n[1].f, n[2].f, n[3].f, n[4].f );
            break;
         case OPCODE_INDEX:
            ctx->Current.Index = n[1].ui;
            ctx->VB->MonoColor = GL_FALSE;
            break;
         case OPCODE_BEGIN:
            gl_Begin( ctx, n[1].e );
            break;
         case OPCODE_END:
            gl_End( ctx );
            break;
     case OPCODE_TEXCOORD2:
        ctx->Current.TexCoord[0] = n[1].f;
        ctx->Current.TexCoord[1] = n[2].f;
            if (ctx->VB->TexCoordSize==4) {
               ctx->Current.TexCoord[2] = 0.0F;
               ctx->Current.TexCoord[3] = 1.0F;
            }
        break;
     case OPCODE_TEXCOORD4:
        ctx->Current.TexCoord[0] = n[1].f;
        ctx->Current.TexCoord[1] = n[2].f;
        ctx->Current.TexCoord[2] = n[3].f;
        ctx->Current.TexCoord[3] = n[4].f;
            if (ctx->VB->TexCoordSize==2) {
               /* Switch to 4-component texcoords */
               ctx->VB->TexCoordSize = 4;
               gl_set_vertex_function(ctx);
            }
        break;

     /* Everything Else: */
         case OPCODE_ACCUM:
        gl_Accum( ctx, n[1].e, n[2].f );
        break;
         case OPCODE_ALPHA_FUNC:
        gl_AlphaFunc( ctx, n[1].e, n[2].f );
        break;
         case OPCODE_BIND_TEXTURE:
            gl_BindTexture( ctx, n[1].e, n[2].ui );
            break;
     case OPCODE_BITMAP:
        gl_Bitmap( ctx, (GLsizei) n[1].i, (GLsizei) n[2].i,
               n[3].f, n[4].f,
               n[5].f, n[6].f,
               (struct gl_image *) n[7].data );
        break;
     case OPCODE_BLEND_FUNC:
        gl_BlendFunc( ctx, n[1].e, n[2].e );
        break;
         case OPCODE_CALL_LIST:
        /* Generated by glCallList(), don't add ListBase */
            if (ctx->CallDepth<MAX_LIST_NESTING) {
               execute_list( ctx, n[1].ui );
            }
            break;
         case OPCODE_CALL_LIST_OFFSET:
        /* Generated by glCallLists() so we must add ListBase */
            if (ctx->CallDepth<MAX_LIST_NESTING) {
               execute_list( ctx, ctx->List.ListBase + n[1].ui );
            }
            break;
     case OPCODE_CLEAR:
        gl_Clear( ctx, n[1].bf );
        break;
     case OPCODE_CLEAR_COLOR:
        gl_ClearColor( ctx, n[1].f, n[2].f, n[3].f, n[4].f );
        break;
     case OPCODE_CLEAR_ACCUM:
        gl_ClearAccum( ctx, n[1].f, n[2].f, n[3].f, n[4].f );
        break;
     case OPCODE_CLEAR_DEPTH:
        gl_ClearDepth( ctx, (GLclampd) n[1].f );
        break;
     case OPCODE_CLEAR_INDEX:
        gl_ClearIndex( ctx, n[1].ui );
        break;
     case OPCODE_CLEAR_STENCIL:
        gl_ClearStencil( ctx, n[1].i );
        break;
         case OPCODE_CLIP_PLANE:
            {
               GLfloat equ[4];
               equ[0] = n[2].f;
               equ[1] = n[3].f;
               equ[2] = n[4].f;
               equ[3] = n[5].f;
               gl_ClipPlane( ctx, n[1].e, equ );
            }
            break;
     case OPCODE_COLOR_MASK:
        gl_ColorMask( ctx, n[1].b, n[2].b, n[3].b, n[4].b );
        break;
     case OPCODE_COLOR_MATERIAL:
        gl_ColorMaterial( ctx, n[1].e, n[2].e );
        break;
         case OPCODE_COLOR_TABLE:
            gl_ColorTable( ctx, n[1].e, n[2].e, (struct gl_image *) n[3].data);
            break;
         case OPCODE_COLOR_SUB_TABLE:
            gl_ColorSubTable( ctx, n[1].e, n[2].i,
                              (struct gl_image *) n[3].data);
            break;
     case OPCODE_COPY_PIXELS:
        gl_CopyPixels( ctx, n[1].i, n[2].i,
               (GLsizei) n[3].i, (GLsizei) n[4].i, n[5].e );
        break;
         case OPCODE_COPY_TEX_IMAGE1D:
        gl_CopyTexImage1D( ctx, n[1].e, n[2].i, n[3].e, n[4].i,
                               n[5].i, n[6].i, n[7].i );
            break;
         case OPCODE_COPY_TEX_IMAGE2D:
        gl_CopyTexImage2D( ctx, n[1].e, n[2].i, n[3].e, n[4].i,
                               n[5].i, n[6].i, n[7].i, n[8].i );
            break;
         case OPCODE_COPY_TEX_SUB_IMAGE1D:
        gl_CopyTexSubImage1D( ctx, n[1].e, n[2].i, n[3].i, n[4].i,
                                  n[5].i, n[6].i );
            break;
         case OPCODE_COPY_TEX_SUB_IMAGE2D:
        gl_CopyTexSubImage2D( ctx, n[1].e, n[2].i, n[3].i, n[4].i,
                                  n[5].i, n[6].i, n[7].i, n[8].i );
            break;
     case OPCODE_CULL_FACE:
        gl_CullFace( ctx, n[1].e );
        break;
     case OPCODE_DEPTH_FUNC:
        gl_DepthFunc( ctx, n[1].e );
        break;
     case OPCODE_DEPTH_MASK:
        gl_DepthMask( ctx, n[1].b );
        break;
     case OPCODE_DEPTH_RANGE:
        gl_DepthRange( ctx, (GLclampd) n[1].f, (GLclampd) n[2].f );
        break;
     case OPCODE_DISABLE:
        gl_Disable( ctx, n[1].e );
        break;
     case OPCODE_DRAW_BUFFER:
        gl_DrawBuffer( ctx, n[1].e );
        break;
     case OPCODE_DRAW_PIXELS:
        gl_DrawPixels( ctx, (GLsizei) n[1].i, (GLsizei) n[2].i,
               n[3].e, n[4].e, n[5].data );
        break;
     case OPCODE_EDGE_FLAG:
            ctx->Current.EdgeFlag = n[1].b;
            break;
     case OPCODE_ENABLE:
        gl_Enable( ctx, n[1].e );
        break;
     case OPCODE_EVALCOORD1:
        gl_EvalCoord1f( ctx, n[1].f );
        break;
     case OPCODE_EVALCOORD2:
        gl_EvalCoord2f( ctx, n[1].f, n[2].f );
        break;
     case OPCODE_EVALMESH1:
        gl_EvalMesh1( ctx, n[1].e, n[2].i, n[3].i );
        break;
     case OPCODE_EVALMESH2:
        gl_EvalMesh2( ctx, n[1].e, n[2].i, n[3].i, n[4].i, n[5].i );
        break;
     case OPCODE_EVALPOINT1:
        gl_EvalPoint1( ctx, n[1].i );
        break;
     case OPCODE_EVALPOINT2:
        gl_EvalPoint2( ctx, n[1].i, n[2].i );
        break;
     case OPCODE_FOG:
        {
           GLfloat p[4];
           p[0] = n[2].f;
           p[1] = n[3].f;
           p[2] = n[4].f;
           p[3] = n[5].f;
           gl_Fogfv( ctx, n[1].e, p );
        }
        break;
     case OPCODE_FRONT_FACE:
        gl_FrontFace( ctx, n[1].e );
        break;
         case OPCODE_FRUSTUM:
            gl_Frustum( ctx, n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f );
            break;
     case OPCODE_HINT:
        gl_Hint( ctx, n[1].e, n[2].e );
        break;
     case OPCODE_INDEX_MASK:
        gl_IndexMask( ctx, n[1].ui );
        break;
     case OPCODE_INIT_NAMES:
        gl_InitNames( ctx );
        break;
         case OPCODE_LIGHT:
        {
           GLfloat p[4];
           p[0] = n[3].f;
           p[1] = n[4].f;
           p[2] = n[5].f;
           p[3] = n[6].f;
           gl_Lightfv( ctx, n[1].e, n[2].e, p, 4 );
        }
        break;
         case OPCODE_LIGHT_MODEL:
        {
           GLfloat p[4];
           p[0] = n[2].f;
           p[1] = n[3].f;
           p[2] = n[4].f;
           p[3] = n[5].f;
           gl_LightModelfv( ctx, n[1].e, p );
        }
        break;
     case OPCODE_LINE_STIPPLE:
        gl_LineStipple( ctx, n[1].i, n[2].us );
        break;
     case OPCODE_LINE_WIDTH:
        gl_LineWidth( ctx, n[1].f );
        break;
     case OPCODE_LIST_BASE:
        gl_ListBase( ctx, n[1].ui );
        break;
     case OPCODE_LOAD_IDENTITY:
            gl_LoadIdentity( ctx );
            break;
     case OPCODE_LOAD_MATRIX:
        if (sizeof(Node)==sizeof(GLfloat)) {
           gl_LoadMatrixf( ctx, &n[1].f );
        }
        else {
           GLfloat m[16];
           GLuint i;
           for (i=0;i<16;i++) {
          m[i] = n[1+i].f;
           }
           gl_LoadMatrixf( ctx, m );
        }
        break;
     case OPCODE_LOAD_NAME:
        gl_LoadName( ctx, n[1].ui );
        break;
     case OPCODE_LOGIC_OP:
        gl_LogicOp( ctx, n[1].e );
        break;
     case OPCODE_MAP1:
        gl_Map1f( ctx, n[1].e, n[2].f, n[3].f,
                      n[4].i, n[5].i, (GLfloat *) n[6].data, GL_TRUE );
        break;
     case OPCODE_MAP2:
        gl_Map2f( ctx, n[1].e,
                      n[2].f, n[3].f,  /* u1, u2 */
              n[6].i, n[8].i,  /* ustride, uorder */
              n[4].f, n[5].f,  /* v1, v2 */
              n[7].i, n[9].i,  /* vstride, vorder */
              (GLfloat *) n[10].data,
                      GL_TRUE);
        break;
     case OPCODE_MAPGRID1:
        gl_MapGrid1f( ctx, n[1].i, n[2].f, n[3].f );
        break;
     case OPCODE_MAPGRID2:
        gl_MapGrid2f( ctx, n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f);
        break;
     case OPCODE_MATERIAL:
        {
           GLfloat params[4];
           params[0] = n[3].f;
           params[1] = n[4].f;
           params[2] = n[5].f;
           params[3] = n[6].f;
           gl_Materialfv( ctx, n[1].e, n[2].e, params );
        }
        break;
         case OPCODE_MATRIX_MODE:
            gl_MatrixMode( ctx, n[1].e );
            break;
     case OPCODE_MULT_MATRIX:
        if (sizeof(Node)==sizeof(GLfloat)) {
           gl_MultMatrixf( ctx, &n[1].f );
        }
        else {
           GLfloat m[16];
           GLuint i;
           for (i=0;i<16;i++) {
          m[i] = n[1+i].f;
           }
           gl_MultMatrixf( ctx, m );
        }
        break;
         case OPCODE_ORTHO:
            gl_Ortho( ctx, n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f );
            break;
     case OPCODE_PASSTHROUGH:
        gl_PassThrough( ctx, n[1].f );
        break;
     case OPCODE_PIXEL_MAP:
        gl_PixelMapfv( ctx, n[1].e, n[2].i, (GLfloat *) n[3].data );
        break;
     case OPCODE_PIXEL_TRANSFER:
        gl_PixelTransferf( ctx, n[1].e, n[2].f );
        break;
     case OPCODE_PIXEL_ZOOM:
        gl_PixelZoom( ctx, n[1].f, n[2].f );
        break;
     case OPCODE_POINT_SIZE:
        gl_PointSize( ctx, n[1].f );
        break;
     case OPCODE_POLYGON_MODE:
        gl_PolygonMode( ctx, n[1].e, n[2].e );
        break;
     case OPCODE_POLYGON_STIPPLE:
        gl_PolygonStipple( ctx, (GLubyte *) n[1].data );
        break;
     case OPCODE_POLYGON_OFFSET:
        gl_PolygonOffset( ctx, n[1].f, n[2].f );
        break;
     case OPCODE_POP_ATTRIB:
        gl_PopAttrib( ctx );
        break;
     case OPCODE_POP_MATRIX:
        gl_PopMatrix( ctx );
        break;
     case OPCODE_POP_NAME:
        gl_PopName( ctx );
        break;
     case OPCODE_PRIORITIZE_TEXTURE:
            gl_PrioritizeTextures( ctx, 1, &n[1].ui, &n[2].f );
        break;
     case OPCODE_PUSH_ATTRIB:
        gl_PushAttrib( ctx, n[1].bf );
        break;
     case OPCODE_PUSH_MATRIX:
        gl_PushMatrix( ctx );
        break;
     case OPCODE_PUSH_NAME:
        gl_PushName( ctx, n[1].ui );
        break;
     case OPCODE_RASTER_POS:
            gl_RasterPos4f( ctx, n[1].f, n[2].f, n[3].f, n[4].f );
        break;
     case OPCODE_READ_BUFFER:
        gl_ReadBuffer( ctx, n[1].e );
        break;
         case OPCODE_RECTF:
            gl_Rectf( ctx, n[1].f, n[2].f, n[3].f, n[4].f );
            break;
         case OPCODE_SCALE:
            gl_Scalef( ctx, n[1].f, n[2].f, n[3].f );
            break;
     case OPCODE_SCISSOR:
        gl_Scissor( ctx, n[1].i, n[2].i, n[3].i, n[4].i );
        break;
     case OPCODE_SHADE_MODEL:
        gl_ShadeModel( ctx, n[1].e );
        break;
     case OPCODE_STENCIL_FUNC:
        gl_StencilFunc( ctx, n[1].e, n[2].i, n[3].ui );
        break;
     case OPCODE_STENCIL_MASK:
        gl_StencilMask( ctx, n[1].ui );
        break;
     case OPCODE_STENCIL_OP:
        gl_StencilOp( ctx, n[1].e, n[2].e, n[3].e );
        break;
         case OPCODE_TEXENV:
            {
               GLfloat params[4];
               params[0] = n[3].f;
               params[1] = n[4].f;
               params[2] = n[5].f;
               params[3] = n[6].f;
               gl_TexEnvfv( ctx, n[1].e, n[2].e, params );
            }
            break;
         case OPCODE_TEXGEN:
            {
               GLfloat params[4];
               params[0] = n[3].f;
               params[1] = n[4].f;
               params[2] = n[5].f;
               params[3] = n[6].f;
               gl_TexGenfv( ctx, n[1].e, n[2].e, params );
            }
            break;
         case OPCODE_TEXPARAMETER:
            {
               GLfloat params[4];
               params[0] = n[3].f;
               params[1] = n[4].f;
               params[2] = n[5].f;
               params[3] = n[6].f;
               gl_TexParameterfv( ctx, n[1].e, n[2].e, params );
            }
            break;
     case OPCODE_TEX_IMAGE1D:
        gl_TexImage1D( ctx,
                           n[1].e, /* target */
                           n[2].i, /* level */
                           n[3].i, /* components */
                           n[4].i, /* width */
                           n[5].e, /* border */
                           n[6].e, /* format */
                           n[7].e, /* type */
                           (struct gl_image *) n[8].data );
        break;
     case OPCODE_TEX_IMAGE2D:
        gl_TexImage2D( ctx,
                           n[1].e, /* target */
                           n[2].i, /* level */
                           n[3].i, /* components */
                           n[4].i, /* width */
                           n[5].i, /* height */
                           n[6].e, /* border */
                           n[7].e, /* format */
                           n[8].e, /* type */
                           (struct gl_image *) n[9].data );
        break;
         case OPCODE_TEX_SUB_IMAGE1D:
            gl_TexSubImage1D( ctx, n[1].e, n[2].i, n[3].i, n[4].i, n[5].e,
                              n[6].e, (struct gl_image *) n[7].data );
            break;
         case OPCODE_TEX_SUB_IMAGE2D:
            gl_TexSubImage2D( ctx, n[1].e, n[2].i, n[3].i, n[4].i, n[5].e,
                              n[6].i, n[7].e, n[8].e,
                              (struct gl_image *) n[9].data );
            break;
         case OPCODE_TRANSLATE:
            gl_Translatef( ctx, n[1].f, n[2].f, n[3].f );
            break;
     case OPCODE_VIEWPORT:
        gl_Viewport( ctx,
                         n[1].i, n[2].i, (GLsizei) n[3].i, (GLsizei) n[4].i );
        break;
     case OPCODE_CONTINUE:
        n = (Node *) n[1].next;
        break;
     case OPCODE_END_OF_LIST:
        done = GL_TRUE;
        break;
     default:
            {
               char msg[1000];
               sprintf(msg, "Error in execute_list: opcode=%d", (int) opcode);
               gl_problem( ctx, msg );
            }
            done = GL_TRUE;
      }

      /* increment n to point to next compiled command */
      if (opcode!=OPCODE_CONTINUE) {
     n += InstSize[opcode];
      }

   }
   ctx->CallDepth--;
}

Referenced by gl_CallList(), and gl_CallLists().

gl_CallList()

void gl_CallList	(	GLcontext *	ctx,
		GLuint	list
	)

Definition at line 3048 of file dlist.c.

{
   /* VERY IMPORTANT:  Save the CompileFlag status, turn it off, */
   /* execute the display list, and restore the CompileFlag. */
   GLboolean save_compile_flag;
   save_compile_flag = ctx->CompileFlag;
   ctx->CompileFlag = GL_FALSE;
   execute_list( ctx, list );
   ctx->CompileFlag = save_compile_flag;
}

Referenced by init_exec_pointers().

gl_CallLists()

void gl_CallLists	(	GLcontext *	ctx,
		GLsizei	n,
		GLenum	type,
		const GLvoid *	lists
	)

Definition at line 3064 of file dlist.c.

{
   GLuint i, list;
   GLboolean save_compile_flag;

   /* Save the CompileFlag status, turn it off, execute display list,
    * and restore the CompileFlag.
    */
   save_compile_flag = ctx->CompileFlag;
   ctx->CompileFlag = GL_FALSE;

   for (i=0;i<n;i++) {
      list = translate_id( i, type, lists );
      execute_list( ctx, ctx->List.ListBase + list );
   }

   ctx->CompileFlag = save_compile_flag;
}

Referenced by init_exec_pointers().

gl_DeleteLists()

void gl_DeleteLists	(	GLcontext *	ctx,
		GLuint	list,
		GLsizei	range
	)

Definition at line 2923 of file dlist.c.

{
   GLuint i;

   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glDeleteLists" );
      return;
   }
   if (range<0) {
      gl_error( ctx, GL_INVALID_VALUE, "glDeleteLists" );
      return;
   }
   for (i=list;i<list+range;i++) {
      gl_destroy_list( ctx, i );
   }
}

Referenced by init_dlist_pointers(), and init_exec_pointers().

gl_destroy_list()

void gl_destroy_list	(	GLcontext *	ctx,
		GLuint	list
	)

Definition at line 429 of file dlist.c.

{
   Node *n, *block;
   GLboolean done;

   block = (Node *) HashLookup(ctx->Shared->DisplayList, list);
   n = block;

   done = block ? GL_FALSE : GL_TRUE;
   while (!done) {
      switch (n[0].opcode) {
     /* special cases first */
     case OPCODE_MAP1:
        gl_free_control_points( ctx, n[1].e, (GLfloat *) n[6].data );
        n += InstSize[n[0].opcode];
        break;
     case OPCODE_MAP2:
        gl_free_control_points( ctx, n[1].e, (GLfloat *) n[10].data );
        n += InstSize[n[0].opcode];
        break;
     case OPCODE_DRAW_PIXELS:
        free( n[5].data );
        n += InstSize[n[0].opcode];
        break;
     case OPCODE_BITMAP:
        gl_free_image( (struct gl_image *) n[7].data );
        n += InstSize[n[0].opcode];
        break;
         case OPCODE_COLOR_TABLE:
            gl_free_image( (struct gl_image *) n[3].data );
            n += InstSize[n[0].opcode];
            break;
         case OPCODE_COLOR_SUB_TABLE:
            gl_free_image( (struct gl_image *) n[3].data );
            n += InstSize[n[0].opcode];
            break;
         case OPCODE_POLYGON_STIPPLE:
            free( n[1].data );
        n += InstSize[n[0].opcode];
            break;
     case OPCODE_TEX_IMAGE1D:
            gl_free_image( (struct gl_image *) n[8].data );
            n += InstSize[n[0].opcode];
        break;
     case OPCODE_TEX_IMAGE2D:
            gl_free_image( (struct gl_image *) n[9].data );
            n += InstSize[n[0].opcode];
        break;
         case OPCODE_TEX_SUB_IMAGE1D:
            {
               struct gl_image *image;
               image = (struct gl_image *) n[7].data;
               gl_free_image( image );
            }
            break;
         case OPCODE_TEX_SUB_IMAGE2D:
            {
               struct gl_image *image;
               image = (struct gl_image *) n[9].data;
               gl_free_image( image );
            }
            break;
     case OPCODE_CONTINUE:
        n = (Node *) n[1].next;
        free( block );
        block = n;
        break;
     case OPCODE_END_OF_LIST:
        free( block );
        done = GL_TRUE;
        break;
     default:
        /* Most frequent case */
        n += InstSize[n[0].opcode];
        break;
      }
   }

   HashRemove(ctx->Shared->DisplayList, list);
}

Referenced by free_shared_state(), gl_DeleteLists(), and gl_EndList().

gl_EndList()

void gl_EndList

(

GLcontext *

ctx

)

Definition at line 3020 of file dlist.c.

{
   Node *n;

   /* Check that a list is under construction */
   if (!ctx->CurrentListPtr) {
      gl_error( ctx, GL_INVALID_OPERATION, "glEndList" );
      return;
   }

   n = alloc_instruction( ctx, OPCODE_END_OF_LIST, 0 );
   (void)n;

   /* Destroy old list, if any */
   gl_destroy_list(ctx, ctx->CurrentListNum);
   /* Install the list */
   HashInsert(ctx->Shared->DisplayList, ctx->CurrentListNum, ctx->CurrentListPtr);

   ctx->CurrentListNum = 0;
   ctx->CurrentListPtr = NULL;
   ctx->ExecuteFlag = GL_TRUE;
   ctx->CompileFlag = GL_FALSE;

   ctx->API = ctx->Exec;   /* Switch the API function pointers */
}

Referenced by init_dlist_pointers(), and init_exec_pointers().

gl_GenLists()

GLuint gl_GenLists	(	GLcontext *	ctx,
		GLsizei	range
	)

Definition at line 2946 of file dlist.c.

{
   GLuint base;

   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glGenLists" );
      return 0;
   }
   if (range<0) {
      gl_error( ctx, GL_INVALID_VALUE, "glGenLists" );
      return 0;
   }
   if (range==0) {
      return 0;
   }

   base = HashFindFreeKeyBlock(ctx->Shared->DisplayList, range);
   if (base) {
      /* reserve the list IDs by with empty/dummy lists */
      GLuint i;
      for (i=0; i<range; i++) {
         HashInsert(ctx->Shared->DisplayList, base+i, make_empty_list());
      }
   }
   return base;
}

Referenced by init_dlist_pointers(), and init_exec_pointers().

gl_init_lists()

void gl_init_lists

(

void

)

Definition at line 573 of file dlist.c.

{
   static int init_flag = 0;

   if (init_flag==0) {
      InstSize[OPCODE_ACCUM] = 3;
      InstSize[OPCODE_ALPHA_FUNC] = 3;
      InstSize[OPCODE_BEGIN] = 2;
      InstSize[OPCODE_BIND_TEXTURE] = 3;
      InstSize[OPCODE_BITMAP] = 8;
      InstSize[OPCODE_BLEND_FUNC] = 3;
      InstSize[OPCODE_CALL_LIST] = 2;
      InstSize[OPCODE_CALL_LIST_OFFSET] = 2;
      InstSize[OPCODE_CLEAR] = 2;
      InstSize[OPCODE_CLEAR_ACCUM] = 5;
      InstSize[OPCODE_CLEAR_COLOR] = 5;
      InstSize[OPCODE_CLEAR_DEPTH] = 2;
      InstSize[OPCODE_CLEAR_INDEX] = 2;
      InstSize[OPCODE_CLEAR_STENCIL] = 2;
      InstSize[OPCODE_CLIP_PLANE] = 6;
      InstSize[OPCODE_COLOR_3F] = 4;
      InstSize[OPCODE_COLOR_4F] = 5;
      InstSize[OPCODE_COLOR_4UB] = 5;
      InstSize[OPCODE_COLOR_MASK] = 5;
      InstSize[OPCODE_COLOR_MATERIAL] = 3;
      InstSize[OPCODE_COLOR_TABLE] = 4;
      InstSize[OPCODE_COLOR_SUB_TABLE] = 4;
      InstSize[OPCODE_COPY_PIXELS] = 6;
      InstSize[OPCODE_COPY_TEX_IMAGE1D] = 8;
      InstSize[OPCODE_COPY_TEX_IMAGE2D] = 9;
      InstSize[OPCODE_COPY_TEX_SUB_IMAGE1D] = 7;
      InstSize[OPCODE_COPY_TEX_SUB_IMAGE2D] = 9;
      InstSize[OPCODE_CULL_FACE] = 2;
      InstSize[OPCODE_DEPTH_FUNC] = 2;
      InstSize[OPCODE_DEPTH_MASK] = 2;
      InstSize[OPCODE_DEPTH_RANGE] = 3;
      InstSize[OPCODE_DISABLE] = 2;
      InstSize[OPCODE_DRAW_BUFFER] = 2;
      InstSize[OPCODE_DRAW_PIXELS] = 6;
      InstSize[OPCODE_ENABLE] = 2;
      InstSize[OPCODE_EDGE_FLAG] = 2;
      InstSize[OPCODE_END] = 1;
      InstSize[OPCODE_EVALCOORD1] = 2;
      InstSize[OPCODE_EVALCOORD2] = 3;
      InstSize[OPCODE_EVALMESH1] = 4;
      InstSize[OPCODE_EVALMESH2] = 6;
      InstSize[OPCODE_EVALPOINT1] = 2;
      InstSize[OPCODE_EVALPOINT2] = 3;
      InstSize[OPCODE_FOG] = 6;
      InstSize[OPCODE_FRONT_FACE] = 2;
      InstSize[OPCODE_FRUSTUM] = 7;
      InstSize[OPCODE_HINT] = 3;
      InstSize[OPCODE_INDEX] = 2;
      InstSize[OPCODE_INDEX_MASK] = 2;
      InstSize[OPCODE_INIT_NAMES] = 1;
      InstSize[OPCODE_LIGHT] = 7;
      InstSize[OPCODE_LIGHT_MODEL] = 6;
      InstSize[OPCODE_LINE_STIPPLE] = 3;
      InstSize[OPCODE_LINE_WIDTH] = 2;
      InstSize[OPCODE_LIST_BASE] = 2;
      InstSize[OPCODE_LOAD_IDENTITY] = 1;
      InstSize[OPCODE_LOAD_MATRIX] = 17;
      InstSize[OPCODE_LOAD_NAME] = 2;
      InstSize[OPCODE_LOGIC_OP] = 2;
      InstSize[OPCODE_MAP1] = 7;
      InstSize[OPCODE_MAP2] = 11;
      InstSize[OPCODE_MAPGRID1] = 4;
      InstSize[OPCODE_MAPGRID2] = 7;
      InstSize[OPCODE_MATERIAL] = 7;
      InstSize[OPCODE_MATRIX_MODE] = 2;
      InstSize[OPCODE_MULT_MATRIX] = 17;
      InstSize[OPCODE_NORMAL] = 4;
      InstSize[OPCODE_ORTHO] = 7;
      InstSize[OPCODE_PASSTHROUGH] = 2;
      InstSize[OPCODE_PIXEL_MAP] = 4;
      InstSize[OPCODE_PIXEL_TRANSFER] = 3;
      InstSize[OPCODE_PIXEL_ZOOM] = 3;
      InstSize[OPCODE_POINT_SIZE] = 2;
      InstSize[OPCODE_POLYGON_MODE] = 3;
      InstSize[OPCODE_POLYGON_STIPPLE] = 2;
      InstSize[OPCODE_POLYGON_OFFSET] = 3;
      InstSize[OPCODE_POP_ATTRIB] = 1;
      InstSize[OPCODE_POP_MATRIX] = 1;
      InstSize[OPCODE_POP_NAME] = 1;
      InstSize[OPCODE_PRIORITIZE_TEXTURE] = 3;
      InstSize[OPCODE_PUSH_ATTRIB] = 2;
      InstSize[OPCODE_PUSH_MATRIX] = 1;
      InstSize[OPCODE_PUSH_NAME] = 2;
      InstSize[OPCODE_RASTER_POS] = 5;
      InstSize[OPCODE_RECTF] = 5;
      InstSize[OPCODE_READ_BUFFER] = 2;
      InstSize[OPCODE_SCALE] = 4;
      InstSize[OPCODE_SCISSOR] = 5;
      InstSize[OPCODE_STENCIL_FUNC] = 4;
      InstSize[OPCODE_STENCIL_MASK] = 2;
      InstSize[OPCODE_STENCIL_OP] = 4;
      InstSize[OPCODE_SHADE_MODEL] = 2;
      InstSize[OPCODE_TEXCOORD2] = 3;
      InstSize[OPCODE_TEXCOORD4] = 5;
      InstSize[OPCODE_TEXENV] = 7;
      InstSize[OPCODE_TEXGEN] = 7;
      InstSize[OPCODE_TEXPARAMETER] = 7;
      InstSize[OPCODE_TEX_IMAGE1D] = 9;
      InstSize[OPCODE_TEX_IMAGE2D] = 10;
      InstSize[OPCODE_TEX_SUB_IMAGE1D] = 8;
      InstSize[OPCODE_TEX_SUB_IMAGE2D] = 10;
      InstSize[OPCODE_TRANSLATE] = 4;
      InstSize[OPCODE_VERTEX2] = 3;
      InstSize[OPCODE_VERTEX3] = 4;
      InstSize[OPCODE_VERTEX4] = 5;
      InstSize[OPCODE_VIEWPORT] = 5;
      InstSize[OPCODE_CONTINUE] = 2;
      InstSize[OPCODE_END_OF_LIST] = 1;
   }
   init_flag = 1;
}

Referenced by gl_create_context().

gl_IsList()

GLboolean gl_IsList	(	GLcontext *	ctx,
		GLuint	list
	)

Definition at line 2908 of file dlist.c.

{
   if (list > 0 && HashLookup(ctx->Shared->DisplayList, list)) {
      return GL_TRUE;
   }
   else {
      return GL_FALSE;
   }
}

Referenced by execute_list(), init_dlist_pointers(), and init_exec_pointers().

gl_ListBase()

void gl_ListBase	(	GLcontext *	ctx,
		GLuint	base
	)

Definition at line 3089 of file dlist.c.

{
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glListBase" );
      return;
   }
   ctx->List.ListBase = base;
}

Referenced by execute_list(), and init_exec_pointers().

gl_NewList()

void gl_NewList	(	GLcontext *	ctx,
		GLuint	list,
		GLenum	mode
	)

Definition at line 2978 of file dlist.c.

{
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glNewList" );
      return;
   }
   if (list==0) {
      gl_error( ctx, GL_INVALID_VALUE, "glNewList" );
      return;
   }
   if (mode!=GL_COMPILE && mode!=GL_COMPILE_AND_EXECUTE) {
      gl_error( ctx, GL_INVALID_ENUM, "glNewList" );
      return;
   }
   if (ctx->CurrentListPtr) {
      /* already compiling a display list */
      gl_error( ctx, GL_INVALID_OPERATION, "glNewList" );
      return;
   }

   /* Allocate new display list */
   ctx->CurrentListNum = list;
   ctx->CurrentListPtr = ctx->CurrentBlock = (Node *) malloc( sizeof(Node) * BLOCK_SIZE );
   ctx->CurrentPos = 0;

   ctx->CompileFlag = GL_TRUE;
   if (mode==GL_COMPILE) {
      ctx->ExecuteFlag = GL_FALSE;
   }
   else {
      /* Compile and execute */
      ctx->ExecuteFlag = GL_TRUE;
   }

   ctx->API = ctx->Save;  /* Switch the API function pointers */
}

Referenced by init_exec_pointers().

gl_save_Accum()

void gl_save_Accum	(	GLcontext *	ctx,
		GLenum	op,
		GLfloat	value
	)

Definition at line 696 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_ACCUM, 2 );
   if (n) {
      n[1].e = op;
      n[2].f = value;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.Accum)( ctx, op, value );
   }
}

Referenced by init_dlist_pointers().

gl_save_AlphaFunc()

void gl_save_AlphaFunc	(	GLcontext *	ctx,
		GLenum	func,
		GLclampf	ref
	)

Definition at line 709 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_ALPHA_FUNC, 2 );
   if (n) {
      n[1].e = func;
      n[2].f = (GLfloat) ref;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.AlphaFunc)( ctx, func, ref );
   }
}

Referenced by init_dlist_pointers().

gl_save_Begin()

void gl_save_Begin	(	GLcontext *	ctx,
		GLenum	mode
	)

Definition at line 722 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_BEGIN, 1 );
   if (n) {
      n[1].e = mode;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.Begin)( ctx, mode );
   }
}

Referenced by gl_save_DrawArrays(), gl_save_DrawElements(), and init_dlist_pointers().

gl_save_BindTexture()

void gl_save_BindTexture	(	GLcontext *	ctx,
		GLenum	target,
		GLuint	texture
	)

Definition at line 734 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_BIND_TEXTURE, 2 );
   if (n) {
      n[1].e = target;
      n[2].ui = texture;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.BindTexture)( ctx, target, texture );
   }
}

Referenced by init_dlist_pointers().

gl_save_Bitmap()

void gl_save_Bitmap	(	GLcontext *	ctx,
		GLsizei	width,
		GLsizei	height,
		GLfloat	xorig,
		GLfloat	yorig,
		GLfloat	xmove,
		GLfloat	ymove,
		const struct gl_image *	bitmap
	)

Definition at line 747 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_BITMAP, 7 );
   if (n) {
      n[1].i = (GLint) width;
      n[2].i = (GLint) height;
      n[3].f = xorig;
      n[4].f = yorig;
      n[5].f = xmove;
      n[6].f = ymove;
      n[7].data = (void *) bitmap;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.Bitmap)( ctx, width, height,
                    xorig, yorig, xmove, ymove, bitmap );
   }
}

Referenced by init_dlist_pointers().

gl_save_BlendFunc()

void gl_save_BlendFunc	(	GLcontext *	ctx,
		GLenum	sfactor,
		GLenum	dfactor
	)

Definition at line 770 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_BLEND_FUNC, 2 );
   if (n) {
      n[1].e = sfactor;
      n[2].e = dfactor;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.BlendFunc)( ctx, sfactor, dfactor );
   }
}

Referenced by init_dlist_pointers().

gl_save_CallList()

void gl_save_CallList	(	GLcontext *	ctx,
		GLuint	list
	)

Definition at line 783 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_CALL_LIST, 1 );
   if (n) {
      n[1].ui = list;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.CallList)( ctx, list );
   }
}

Referenced by init_dlist_pointers().

gl_save_CallLists()

void gl_save_CallLists	(	GLcontext *	ctx,
		GLsizei	n,
		GLenum	type,
		const GLvoid *	lists
	)

Definition at line 795 of file dlist.c.

{
   GLuint i;

   for (i=0;i<n;i++) {
      GLuint list = translate_id( i, type, lists );
      Node *n = alloc_instruction( ctx, OPCODE_CALL_LIST_OFFSET, 1 );
      if (n) {
         n[1].ui = list;
      }
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.CallLists)( ctx, n, type, lists );
   }
}

Referenced by init_dlist_pointers().

gl_save_Clear()

void gl_save_Clear	(	GLcontext *	ctx,
		GLbitfield	mask
	)

Definition at line 813 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_CLEAR, 1 );
   if (n) {
      n[1].bf = mask;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.Clear)( ctx, mask );
   }
}

Referenced by init_dlist_pointers().

gl_save_ClearAccum()

void gl_save_ClearAccum	(	GLcontext *	ctx,
		GLfloat	red,
		GLfloat	green,
		GLfloat	blue,
		GLfloat	alpha
	)

Definition at line 825 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_CLEAR_ACCUM, 4 );
   if (n) {
      n[1].f = red;
      n[2].f = green;
      n[3].f = blue;
      n[4].f = alpha;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.ClearAccum)( ctx, red, green, blue, alpha );
   }
}

Referenced by init_dlist_pointers().

gl_save_ClearColor()

void gl_save_ClearColor	(	GLcontext *	ctx,
		GLclampf	red,
		GLclampf	green,
		GLclampf	blue,
		GLclampf	alpha
	)

Definition at line 841 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_CLEAR_COLOR, 4 );
   if (n) {
      n[1].f = red;
      n[2].f = green;
      n[3].f = blue;
      n[4].f = alpha;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.ClearColor)( ctx, red, green, blue, alpha );
   }
}

Referenced by init_dlist_pointers().

gl_save_ClearDepth()

void gl_save_ClearDepth	(	GLcontext *	ctx,
		GLclampd	depth
	)

Definition at line 857 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_CLEAR_DEPTH, 1 );
   if (n) {
      n[1].f = (GLfloat) depth;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.ClearDepth)( ctx, depth );
   }
}

Referenced by init_dlist_pointers().

gl_save_ClearIndex()

void gl_save_ClearIndex	(	GLcontext *	ctx,
		GLfloat	c
	)

Definition at line 869 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_CLEAR_INDEX, 1 );
   if (n) {
      n[1].f = c;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.ClearIndex)( ctx, c );
   }
}

Referenced by init_dlist_pointers().

gl_save_ClearStencil()

void gl_save_ClearStencil	(	GLcontext *	ctx,
		GLint	s
	)

Definition at line 881 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_CLEAR_STENCIL, 1 );
   if (n) {
      n[1].i = s;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.ClearStencil)( ctx, s );
   }
}

Referenced by init_dlist_pointers().

gl_save_ClipPlane()

void gl_save_ClipPlane	(	GLcontext *	ctx,
		GLenum	plane,
		const GLfloat *	equ
	)

Definition at line 893 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_CLIP_PLANE, 5 );
   if (n) {
      n[1].e = plane;
      n[2].f = equ[0];
      n[3].f = equ[1];
      n[4].f = equ[2];
      n[5].f = equ[3];
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.ClipPlane)( ctx, plane, equ );
   }
}

Referenced by init_dlist_pointers().

gl_save_Color3f()

void gl_save_Color3f	(	GLcontext *	ctx,
		GLfloat	r,
		GLfloat	g,
		GLfloat	b
	)

Definition at line 909 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_COLOR_3F, 3 );
   if (n) {
      n[1].f = r;
      n[2].f = g;
      n[3].f = b;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.Color3f)( ctx, r, g, b );
   }
}

Referenced by init_dlist_pointers().

gl_save_Color3fv()

void gl_save_Color3fv	(	GLcontext *	ctx,
		const GLfloat *	c
	)

Definition at line 923 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_COLOR_3F, 3 );
   if (n) {
      n[1].f = c[0];
      n[2].f = c[1];
      n[3].f = c[2];
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.Color3fv)( ctx, c );
   }
}

Referenced by init_dlist_pointers().

gl_save_Color4f()

void gl_save_Color4f	(	GLcontext *	ctx,
		GLfloat	r,
		GLfloat	g,
		GLfloat	b,
		GLfloat	a
	)

Definition at line 937 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_COLOR_4F, 4 );
   if (n) {
      n[1].f = r;
      n[2].f = g;
      n[3].f = b;
      n[4].f = a;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.Color4f)( ctx, r, g, b, a );
   }
}

Referenced by init_dlist_pointers().

gl_save_Color4fv()

void gl_save_Color4fv	(	GLcontext *	ctx,
		const GLfloat *	c
	)

Definition at line 953 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_COLOR_4F, 4 );
   if (n) {
      n[1].f = c[0];
      n[2].f = c[1];
      n[3].f = c[2];
      n[4].f = c[3];
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.Color4fv)( ctx, c );
   }
}

Referenced by init_dlist_pointers().

gl_save_Color4ub()

void gl_save_Color4ub	(	GLcontext *	ctx,
		GLubyte	r,
		GLubyte	g,
		GLubyte	b,
		GLubyte	a
	)

Definition at line 968 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_COLOR_4UB, 4 );
   if (n) {
      n[1].ub = r;
      n[2].ub = g;
      n[3].ub = b;
      n[4].ub = a;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.Color4ub)( ctx, r, g, b, a );
   }
}

Referenced by init_dlist_pointers().

gl_save_Color4ubv()

void gl_save_Color4ubv	(	GLcontext *	ctx,
		const GLubyte *	c
	)

Definition at line 984 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_COLOR_4UB, 4 );
   if (n) {
      n[1].ub = c[0];
      n[2].ub = c[1];
      n[3].ub = c[2];
      n[4].ub = c[3];
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.Color4ubv)( ctx, c );
   }
}

Referenced by init_dlist_pointers().

gl_save_ColorMask()

void gl_save_ColorMask	(	GLcontext *	ctx,
		GLboolean	red,
		GLboolean	green,
		GLboolean	blue,
		GLboolean	alpha
	)

Definition at line 999 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_COLOR_MASK, 4 );
   if (n) {
      n[1].b = red;
      n[2].b = green;
      n[3].b = blue;
      n[4].b = alpha;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.ColorMask)( ctx, red, green, blue, alpha );
   }
}

Referenced by init_dlist_pointers().

gl_save_ColorMaterial()

void gl_save_ColorMaterial	(	GLcontext *	ctx,
		GLenum	face,
		GLenum	mode
	)

Definition at line 1015 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_COLOR_MATERIAL, 2 );
   if (n) {
      n[1].e = face;
      n[2].e = mode;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.ColorMaterial)( ctx, face, mode );
   }
}

Referenced by init_dlist_pointers().

gl_save_ColorSubTable()

void gl_save_ColorSubTable	(	GLcontext *	ctx,
		GLenum	target,
		GLsizei	start,
		struct gl_image *	data
	)

Definition at line 1047 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_COLOR_SUB_TABLE, 3 );
   if (n) {
      n[1].e = target;
      n[2].i = start;
      n[3].data = (GLvoid *) data;
      if (data) {
         /* must retain this image */
         data->RefCount = 1;
      }
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.ColorSubTable)( ctx, target, start, data );
   }
}

Referenced by init_dlist_pointers().

gl_save_ColorTable()

void gl_save_ColorTable	(	GLcontext *	ctx,
		GLenum	target,
		GLenum	internalFormat,
		struct gl_image *	table
	)

Definition at line 1028 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_COLOR_TABLE, 3 );
   if (n) {
      n[1].e = target;
      n[2].e = internalFormat;
      n[3].data = (GLvoid *) table;
      if (table) {
         /* must retain this image */
         table->RefCount = 1;
      }
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.ColorTable)( ctx, target, internalFormat, table );
   }
}

Referenced by init_dlist_pointers().

gl_save_CopyPixels()

void gl_save_CopyPixels	(	GLcontext *	ctx,
		GLint	x,
		GLint	y,
		GLsizei	width,
		GLsizei	height,
		GLenum	type
	)

Definition at line 1067 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_COPY_PIXELS, 5 );
   if (n) {
      n[1].i = x;
      n[2].i = y;
      n[3].i = (GLint) width;
      n[4].i = (GLint) height;
      n[5].e = type;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.CopyPixels)( ctx, x, y, width, height, type );
   }
}

Referenced by init_dlist_pointers().

gl_save_CopyTexImage1D()

void gl_save_CopyTexImage1D	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		GLenum	internalformat,
		GLint	x,
		GLint	y,
		GLsizei	width,
		GLint	border
	)

Definition at line 1085 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_COPY_TEX_IMAGE1D, 7 );
   if (n) {
      n[1].e = target;
      n[2].i = level;
      n[3].e = internalformat;
      n[4].i = x;
      n[5].i = y;
      n[6].i = width;
      n[7].i = border;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.CopyTexImage1D)( ctx, target, level, internalformat,
                            x, y, width, border );
   }
}

Referenced by init_dlist_pointers().

gl_save_CopyTexImage2D()

void gl_save_CopyTexImage2D	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		GLenum	internalformat,
		GLint	x,
		GLint	y,
		GLsizei	width,
		GLsizei	height,
		GLint	border
	)

Definition at line 1108 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_COPY_TEX_IMAGE2D, 8 );
   if (n) {
      n[1].e = target;
      n[2].i = level;
      n[3].e = internalformat;
      n[4].i = x;
      n[5].i = y;
      n[6].i = width;
      n[7].i = height;
      n[8].i = border;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.CopyTexImage2D)( ctx, target, level, internalformat,
                            x, y, width, height, border );
   }
}

Referenced by init_dlist_pointers().

gl_save_CopyTexSubImage1D()

void gl_save_CopyTexSubImage1D	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		GLint	xoffset,
		GLint	x,
		GLint	y,
		GLsizei	width
	)

Definition at line 1133 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_COPY_TEX_SUB_IMAGE1D, 6 );
   if (n) {
      n[1].e = target;
      n[2].i = level;
      n[3].i = xoffset;
      n[4].i = x;
      n[5].i = y;
      n[6].i = width;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.CopyTexSubImage1D)( ctx, target, level, xoffset, x, y, width );
   }
}

Referenced by init_dlist_pointers().

gl_save_CopyTexSubImage2D()

void gl_save_CopyTexSubImage2D	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		GLint	xoffset,
		GLint	yoffset,
		GLint	x,
		GLint	y,
		GLsizei	width,
		GLint	height
	)

Definition at line 1153 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_COPY_TEX_SUB_IMAGE2D, 8 );
   if (n) {
      n[1].e = target;
      n[2].i = level;
      n[3].i = xoffset;
      n[4].i = yoffset;
      n[5].i = x;
      n[6].i = y;
      n[7].i = width;
      n[8].i = height;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.CopyTexSubImage2D)( ctx, target, level, xoffset, yoffset,
                               x, y, width, height );
   }
}

Referenced by init_dlist_pointers().

gl_save_CullFace()

void gl_save_CullFace	(	GLcontext *	ctx,
		GLenum	mode
	)

Definition at line 1176 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_CULL_FACE, 1 );
   if (n) {
      n[1].e = mode;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.CullFace)( ctx, mode );
   }
}

Referenced by init_dlist_pointers().

gl_save_DepthFunc()

void gl_save_DepthFunc	(	GLcontext *	ctx,
		GLenum	func
	)

Definition at line 1188 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_DEPTH_FUNC, 1 );
   if (n) {
      n[1].e = func;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.DepthFunc)( ctx, func );
   }
}

Referenced by init_dlist_pointers().

gl_save_DepthMask()

void gl_save_DepthMask	(	GLcontext *	ctx,
		GLboolean	mask
	)

Definition at line 1200 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_DEPTH_MASK, 1 );
   if (n) {
      n[1].b = mask;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.DepthMask)( ctx, mask );
   }
}

Referenced by init_dlist_pointers().

gl_save_DepthRange()

void gl_save_DepthRange	(	GLcontext *	ctx,
		GLclampd	nearval,
		GLclampd	farval
	)

Definition at line 1212 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_DEPTH_RANGE, 2 );
   if (n) {
      n[1].f = (GLfloat) nearval;
      n[2].f = (GLfloat) farval;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.DepthRange)( ctx, nearval, farval );
   }
}

Referenced by init_dlist_pointers().

gl_save_Disable()

void gl_save_Disable	(	GLcontext *	ctx,
		GLenum	cap
	)

Definition at line 1225 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_DISABLE, 1 );
   if (n) {
      n[1].e = cap;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.Disable)( ctx, cap );
   }
}

Referenced by init_dlist_pointers().

gl_save_DrawBuffer()

void gl_save_DrawBuffer	(	GLcontext *	ctx,
		GLenum	mode
	)

Definition at line 1237 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_DRAW_BUFFER, 1 );
   if (n) {
      n[1].e = mode;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.DrawBuffer)( ctx, mode );
   }
}

Referenced by init_dlist_pointers().

gl_save_DrawPixels()

void gl_save_DrawPixels	(	GLcontext *	ctx,
		GLsizei	width,
		GLsizei	height,
		GLenum	format,
		GLenum	type,
		const GLvoid *	pixels
	)

Definition at line 1249 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_DRAW_PIXELS, 5 );
   if (n) {
      n[1].i = (GLint) width;
      n[2].i = (GLint) height;
      n[3].e = format;
      n[4].e = type;
      n[5].data = (GLvoid *) pixels;
   }
/* Special case:  gl_DrawPixels takes care of GL_COMPILE_AND_EXECUTE case!
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.DrawPixels)( ctx, width, height, format, type, pixels );
   }
*/
}

Referenced by gl_DrawPixels().

gl_save_EdgeFlag()

void gl_save_EdgeFlag	(	GLcontext *	ctx,
		GLboolean	flag
	)

Definition at line 1268 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_EDGE_FLAG, 1 );
   if (n) {
      n[1].b = flag;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.EdgeFlag)( ctx, flag );
   }
}

Referenced by init_dlist_pointers().

gl_save_Enable()

void gl_save_Enable	(	GLcontext *	ctx,
		GLenum	cap
	)

Definition at line 1280 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_ENABLE, 1 );
   if (n) {
      n[1].e = cap;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.Enable)( ctx, cap );
   }
}

Referenced by init_dlist_pointers().

gl_save_End()

void gl_save_End

(

GLcontext *

ctx

)

Definition at line 1292 of file dlist.c.

{
   (void) alloc_instruction( ctx, OPCODE_END, 0 );
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.End)( ctx );
   }
}

Referenced by gl_save_DrawArrays(), gl_save_DrawElements(), and init_dlist_pointers().

gl_save_EvalCoord1f()

void gl_save_EvalCoord1f	(	GLcontext *	ctx,
		GLfloat	u
	)

Definition at line 1301 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_EVALCOORD1, 1 );
   if (n) {
      n[1].f = u;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.EvalCoord1f)( ctx, u );
   }
}

Referenced by init_dlist_pointers().

gl_save_EvalCoord2f()

void gl_save_EvalCoord2f	(	GLcontext *	ctx,
		GLfloat	u,
		GLfloat	v
	)

Definition at line 1313 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_EVALCOORD2, 2 );
   if (n) {
      n[1].f = u;
      n[2].f = v;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.EvalCoord2f)( ctx, u, v );
   }
}

Referenced by init_dlist_pointers().

gl_save_EvalMesh1()

void gl_save_EvalMesh1	(	GLcontext *	ctx,
		GLenum	mode,
		GLint	i1,
		GLint	i2
	)

Definition at line 1326 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_EVALMESH1, 3 );
   if (n) {
      n[1].e = mode;
      n[2].i = i1;
      n[3].i = i2;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.EvalMesh1)( ctx, mode, i1, i2 );
   }
}

Referenced by init_dlist_pointers().

gl_save_EvalMesh2()

void gl_save_EvalMesh2	(	GLcontext *	ctx,
		GLenum	mode,
		GLint	i1,
		GLint	i2,
		GLint	j1,
		GLint	j2
	)

Definition at line 1341 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_EVALMESH2, 5 );
   if (n) {
      n[1].e = mode;
      n[2].i = i1;
      n[3].i = i2;
      n[4].i = j1;
      n[5].i = j2;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.EvalMesh2)( ctx, mode, i1, i2, j1, j2 );
   }
}

Referenced by init_dlist_pointers().

gl_save_EvalPoint1()

void gl_save_EvalPoint1	(	GLcontext *	ctx,
		GLint	i
	)

Definition at line 1358 of file dlist.c.

{
   Node *n = alloc_instruction( ctx, OPCODE_EVALPOINT1, 1 );
   if (n) {
      n[1].i = i;
   }
   if (ctx->ExecuteFlag) {
      (*ctx->Exec.EvalPoint1)( ctx, i );
   }
}