mtypes.h

Go to the documentation of this file.

/*
 * Mesa 3-D graphics library
 * Version:  7.3
 *
 * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
 * Copyright (C) 1999-2008  VMware, Inc.  All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#ifndef TYPES_H
#define TYPES_H


#include "glheader.h"
#include <GL/internal/glcore.h> /* __GLcontextModes (GLvisual) */
#include "config.h"     /* Hardwired parameters */
#include "glapi/glapi.h"
#include "math/m_matrix.h"  /* GLmatrix */
#include "bitset.h"


#define GL_SHADER_PROGRAM_MESA 0x9999


#if CHAN_BITS == 8
   typedef GLubyte GLchan;
#define CHAN_MAX 255
#define CHAN_MAXF 255.0F
#define CHAN_TYPE GL_UNSIGNED_BYTE
#elif CHAN_BITS == 16
   typedef GLushort GLchan;
#define CHAN_MAX 65535
#define CHAN_MAXF 65535.0F
#define CHAN_TYPE GL_UNSIGNED_SHORT
#elif CHAN_BITS == 32
   typedef GLfloat GLchan;
#define CHAN_MAX 1.0
#define CHAN_MAXF 1.0F
#define CHAN_TYPE GL_FLOAT
#else
#error "illegal number of color channel bits"
#endif


#if STENCIL_BITS==8
   typedef GLubyte GLstencil;
#elif STENCIL_BITS==16
   typedef GLushort GLstencil;
#else
#  error "illegal number of stencil bits"
#endif


typedef int GLfixed;
/*
 * Fixed point arithmetic macros
 */
#ifndef FIXED_FRAC_BITS
#define FIXED_FRAC_BITS 11
#endif

#define FIXED_SHIFT     FIXED_FRAC_BITS
#define FIXED_ONE       (1 << FIXED_SHIFT)
#define FIXED_HALF      (1 << (FIXED_SHIFT-1))
#define FIXED_FRAC_MASK (FIXED_ONE - 1)
#define FIXED_INT_MASK  (~FIXED_FRAC_MASK)
#define FIXED_EPSILON   1
#define FIXED_SCALE     ((float) FIXED_ONE)
#define FIXED_DBL_SCALE ((double) FIXED_ONE)
#define FloatToFixed(X) (IROUND((X) * FIXED_SCALE))
#define FixedToDouble(X) ((X) * (1.0 / FIXED_DBL_SCALE))
#define IntToFixed(I)   ((I) << FIXED_SHIFT)
#define FixedToInt(X)   ((X) >> FIXED_SHIFT)
#define FixedToUns(X)   (((unsigned int)(X)) >> FIXED_SHIFT)
#define FixedCeil(X)    (((X) + FIXED_ONE - FIXED_EPSILON) & FIXED_INT_MASK)
#define FixedFloor(X)   ((X) & FIXED_INT_MASK)
#define FixedToFloat(X) ((X) * (1.0F / FIXED_SCALE))
#define PosFloatToFixed(X)      FloatToFixed(X)
#define SignedFloatToFixed(X)   FloatToFixed(X)



struct _mesa_HashTable;
struct gl_pixelstore_attrib;
struct gl_program_cache;
struct gl_texture_format;
struct gl_texture_image;
struct gl_texture_object;
typedef struct __GLcontextRec GLcontext;
typedef struct __GLcontextModesRec GLvisual;
typedef struct gl_framebuffer GLframebuffer;
enum
{
   VERT_ATTRIB_POS = 0,
   VERT_ATTRIB_WEIGHT = 1,
   VERT_ATTRIB_NORMAL = 2,
   VERT_ATTRIB_COLOR0 = 3,
   VERT_ATTRIB_COLOR1 = 4,
   VERT_ATTRIB_FOG = 5,
   VERT_ATTRIB_COLOR_INDEX = 6,
   VERT_ATTRIB_POINT_SIZE = 6,  /*alias*/
   VERT_ATTRIB_EDGEFLAG = 7,
   VERT_ATTRIB_TEX0 = 8,
   VERT_ATTRIB_TEX1 = 9,
   VERT_ATTRIB_TEX2 = 10,
   VERT_ATTRIB_TEX3 = 11,
   VERT_ATTRIB_TEX4 = 12,
   VERT_ATTRIB_TEX5 = 13,
   VERT_ATTRIB_TEX6 = 14,
   VERT_ATTRIB_TEX7 = 15,
   VERT_ATTRIB_GENERIC0 = 16,
   VERT_ATTRIB_GENERIC1 = 17,
   VERT_ATTRIB_GENERIC2 = 18,
   VERT_ATTRIB_GENERIC3 = 19,
   VERT_ATTRIB_GENERIC4 = 20,
   VERT_ATTRIB_GENERIC5 = 21,
   VERT_ATTRIB_GENERIC6 = 22,
   VERT_ATTRIB_GENERIC7 = 23,
   VERT_ATTRIB_GENERIC8 = 24,
   VERT_ATTRIB_GENERIC9 = 25,
   VERT_ATTRIB_GENERIC10 = 26,
   VERT_ATTRIB_GENERIC11 = 27,
   VERT_ATTRIB_GENERIC12 = 28,
   VERT_ATTRIB_GENERIC13 = 29,
   VERT_ATTRIB_GENERIC14 = 30,
   VERT_ATTRIB_GENERIC15 = 31,
   VERT_ATTRIB_MAX = 32
};

#define VERT_BIT_POS         (1 << VERT_ATTRIB_POS)
#define VERT_BIT_WEIGHT      (1 << VERT_ATTRIB_WEIGHT)
#define VERT_BIT_NORMAL      (1 << VERT_ATTRIB_NORMAL)
#define VERT_BIT_COLOR0      (1 << VERT_ATTRIB_COLOR0)
#define VERT_BIT_COLOR1      (1 << VERT_ATTRIB_COLOR1)
#define VERT_BIT_FOG         (1 << VERT_ATTRIB_FOG)
#define VERT_BIT_COLOR_INDEX (1 << VERT_ATTRIB_COLOR_INDEX)
#define VERT_BIT_EDGEFLAG    (1 << VERT_ATTRIB_EDGEFLAG)
#define VERT_BIT_TEX0        (1 << VERT_ATTRIB_TEX0)
#define VERT_BIT_TEX1        (1 << VERT_ATTRIB_TEX1)
#define VERT_BIT_TEX2        (1 << VERT_ATTRIB_TEX2)
#define VERT_BIT_TEX3        (1 << VERT_ATTRIB_TEX3)
#define VERT_BIT_TEX4        (1 << VERT_ATTRIB_TEX4)
#define VERT_BIT_TEX5        (1 << VERT_ATTRIB_TEX5)
#define VERT_BIT_TEX6        (1 << VERT_ATTRIB_TEX6)
#define VERT_BIT_TEX7        (1 << VERT_ATTRIB_TEX7)
#define VERT_BIT_GENERIC0    (1 << VERT_ATTRIB_GENERIC0)
#define VERT_BIT_GENERIC1    (1 << VERT_ATTRIB_GENERIC1)
#define VERT_BIT_GENERIC2    (1 << VERT_ATTRIB_GENERIC2)
#define VERT_BIT_GENERIC3    (1 << VERT_ATTRIB_GENERIC3)
#define VERT_BIT_GENERIC4    (1 << VERT_ATTRIB_GENERIC4)
#define VERT_BIT_GENERIC5    (1 << VERT_ATTRIB_GENERIC5)
#define VERT_BIT_GENERIC6    (1 << VERT_ATTRIB_GENERIC6)
#define VERT_BIT_GENERIC7    (1 << VERT_ATTRIB_GENERIC7)
#define VERT_BIT_GENERIC8    (1 << VERT_ATTRIB_GENERIC8)
#define VERT_BIT_GENERIC9    (1 << VERT_ATTRIB_GENERIC9)
#define VERT_BIT_GENERIC10   (1 << VERT_ATTRIB_GENERIC10)
#define VERT_BIT_GENERIC11   (1 << VERT_ATTRIB_GENERIC11)
#define VERT_BIT_GENERIC12   (1 << VERT_ATTRIB_GENERIC12)
#define VERT_BIT_GENERIC13   (1 << VERT_ATTRIB_GENERIC13)
#define VERT_BIT_GENERIC14   (1 << VERT_ATTRIB_GENERIC14)
#define VERT_BIT_GENERIC15   (1 << VERT_ATTRIB_GENERIC15)

#define VERT_BIT_TEX(u)  (1 << (VERT_ATTRIB_TEX0 + (u)))
#define VERT_BIT_GENERIC(g)  (1 << (VERT_ATTRIB_GENERIC0 + (g)))

#define VERT_RESULT_HPOS 0
#define VERT_RESULT_COL0 1
#define VERT_RESULT_COL1 2
#define VERT_RESULT_FOGC 3
#define VERT_RESULT_TEX0 4
#define VERT_RESULT_TEX1 5
#define VERT_RESULT_TEX2 6
#define VERT_RESULT_TEX3 7
#define VERT_RESULT_TEX4 8
#define VERT_RESULT_TEX5 9
#define VERT_RESULT_TEX6 10
#define VERT_RESULT_TEX7 11
#define VERT_RESULT_PSIZ 12
#define VERT_RESULT_BFC0 13
#define VERT_RESULT_BFC1 14
#define VERT_RESULT_EDGE 15
#define VERT_RESULT_VAR0 16  
#define VERT_RESULT_MAX  (VERT_RESULT_VAR0 + MAX_VARYING)

enum
{
   FRAG_ATTRIB_WPOS = 0,
   FRAG_ATTRIB_COL0 = 1,
   FRAG_ATTRIB_COL1 = 2,
   FRAG_ATTRIB_FOGC = 3,
   FRAG_ATTRIB_TEX0 = 4,
   FRAG_ATTRIB_TEX1 = 5,
   FRAG_ATTRIB_TEX2 = 6,
   FRAG_ATTRIB_TEX3 = 7,
   FRAG_ATTRIB_TEX4 = 8,
   FRAG_ATTRIB_TEX5 = 9,
   FRAG_ATTRIB_TEX6 = 10,
   FRAG_ATTRIB_TEX7 = 11,
   FRAG_ATTRIB_VAR0 = 12,  
   FRAG_ATTRIB_MAX = (FRAG_ATTRIB_VAR0 + MAX_VARYING)
};

#define FRAG_BIT_WPOS  (1 << FRAG_ATTRIB_WPOS)
#define FRAG_BIT_COL0  (1 << FRAG_ATTRIB_COL0)
#define FRAG_BIT_COL1  (1 << FRAG_ATTRIB_COL1)
#define FRAG_BIT_FOGC  (1 << FRAG_ATTRIB_FOGC)
#define FRAG_BIT_TEX0  (1 << FRAG_ATTRIB_TEX0)
#define FRAG_BIT_TEX1  (1 << FRAG_ATTRIB_TEX1)
#define FRAG_BIT_TEX2  (1 << FRAG_ATTRIB_TEX2)
#define FRAG_BIT_TEX3  (1 << FRAG_ATTRIB_TEX3)
#define FRAG_BIT_TEX4  (1 << FRAG_ATTRIB_TEX4)
#define FRAG_BIT_TEX5  (1 << FRAG_ATTRIB_TEX5)
#define FRAG_BIT_TEX6  (1 << FRAG_ATTRIB_TEX6)
#define FRAG_BIT_TEX7  (1 << FRAG_ATTRIB_TEX7)
#define FRAG_BIT_VAR0  (1 << FRAG_ATTRIB_VAR0)

#define FRAG_BIT_TEX(U)  (FRAG_BIT_TEX0 << (U))
#define FRAG_BIT_VAR(V)  (FRAG_BIT_VAR0 << (V))

#define FRAG_BITS_TEX_ANY (FRAG_BIT_TEX0|   \
               FRAG_BIT_TEX1|   \
               FRAG_BIT_TEX2|   \
               FRAG_BIT_TEX3|   \
               FRAG_BIT_TEX4|   \
               FRAG_BIT_TEX5|   \
               FRAG_BIT_TEX6|   \
               FRAG_BIT_TEX7)

enum
{
   FRAG_RESULT_COLR = 0,
   FRAG_RESULT_COLH = 1,
   FRAG_RESULT_DEPR = 2,
   FRAG_RESULT_DATA0 = 3,
   FRAG_RESULT_MAX = (FRAG_RESULT_DATA0 + MAX_DRAW_BUFFERS)
};


enum {
   BUFFER_FRONT_LEFT  = 0,  /* the four standard color buffers */
   BUFFER_BACK_LEFT   = 1,
   BUFFER_FRONT_RIGHT = 2,
   BUFFER_BACK_RIGHT  = 3,
   BUFFER_AUX0        = 4,  /* optional aux buffer */
   BUFFER_AUX1        = 5,
   BUFFER_AUX2        = 6,
   BUFFER_AUX3        = 7,
   BUFFER_DEPTH       = 8,
   BUFFER_STENCIL     = 9,
   BUFFER_ACCUM       = 10,
   BUFFER_COLOR0      = 11, /* generic renderbuffers */
   BUFFER_COLOR1      = 12,
   BUFFER_COLOR2      = 13,
   BUFFER_COLOR3      = 14,
   BUFFER_COLOR4      = 15,
   BUFFER_COLOR5      = 16,
   BUFFER_COLOR6      = 17,
   BUFFER_COLOR7      = 18,
   BUFFER_COUNT       = 19
};

#define BUFFER_BIT_FRONT_LEFT   (1 << BUFFER_FRONT_LEFT)
#define BUFFER_BIT_BACK_LEFT    (1 << BUFFER_BACK_LEFT)
#define BUFFER_BIT_FRONT_RIGHT  (1 << BUFFER_FRONT_RIGHT)
#define BUFFER_BIT_BACK_RIGHT   (1 << BUFFER_BACK_RIGHT)
#define BUFFER_BIT_AUX0         (1 << BUFFER_AUX0)
#define BUFFER_BIT_AUX1         (1 << BUFFER_AUX1)
#define BUFFER_BIT_AUX2         (1 << BUFFER_AUX2)
#define BUFFER_BIT_AUX3         (1 << BUFFER_AUX3)
#define BUFFER_BIT_DEPTH        (1 << BUFFER_DEPTH)
#define BUFFER_BIT_STENCIL      (1 << BUFFER_STENCIL)
#define BUFFER_BIT_ACCUM        (1 << BUFFER_ACCUM)
#define BUFFER_BIT_COLOR0       (1 << BUFFER_COLOR0)
#define BUFFER_BIT_COLOR1       (1 << BUFFER_COLOR1)
#define BUFFER_BIT_COLOR2       (1 << BUFFER_COLOR2)
#define BUFFER_BIT_COLOR3       (1 << BUFFER_COLOR3)
#define BUFFER_BIT_COLOR4       (1 << BUFFER_COLOR4)
#define BUFFER_BIT_COLOR5       (1 << BUFFER_COLOR5)
#define BUFFER_BIT_COLOR6       (1 << BUFFER_COLOR6)
#define BUFFER_BIT_COLOR7       (1 << BUFFER_COLOR7)

#define BUFFER_BITS_COLOR  (BUFFER_BIT_FRONT_LEFT | \
                            BUFFER_BIT_BACK_LEFT | \
                            BUFFER_BIT_FRONT_RIGHT | \
                            BUFFER_BIT_BACK_RIGHT | \
                            BUFFER_BIT_AUX0 | \
                            BUFFER_BIT_AUX1 | \
                            BUFFER_BIT_AUX2 | \
                            BUFFER_BIT_AUX3 | \
                            BUFFER_BIT_COLOR0 | \
                            BUFFER_BIT_COLOR1 | \
                            BUFFER_BIT_COLOR2 | \
                            BUFFER_BIT_COLOR3 | \
                            BUFFER_BIT_COLOR4 | \
                            BUFFER_BIT_COLOR5 | \
                            BUFFER_BIT_COLOR6 | \
                            BUFFER_BIT_COLOR7)


#define COLORTABLE_PRECONVOLUTION  0
#define COLORTABLE_POSTCONVOLUTION 1
#define COLORTABLE_POSTCOLORMATRIX 2
#define COLORTABLE_MAX 3

struct gl_color_table
{
   GLenum InternalFormat;      
   GLenum _BaseFormat;         
   GLuint Size;                
   GLfloat *TableF;            
   GLubyte *TableUB;           
   GLubyte RedSize;
   GLubyte GreenSize;
   GLubyte BlueSize;
   GLubyte AlphaSize;
   GLubyte LuminanceSize;
   GLubyte IntensitySize;
};


#define MAT_ATTRIB_FRONT_AMBIENT           0 
#define MAT_ATTRIB_BACK_AMBIENT            1
#define MAT_ATTRIB_FRONT_DIFFUSE           2 
#define MAT_ATTRIB_BACK_DIFFUSE            3
#define MAT_ATTRIB_FRONT_SPECULAR          4 
#define MAT_ATTRIB_BACK_SPECULAR           5
#define MAT_ATTRIB_FRONT_EMISSION          6
#define MAT_ATTRIB_BACK_EMISSION           7
#define MAT_ATTRIB_FRONT_SHININESS         8
#define MAT_ATTRIB_BACK_SHININESS          9
#define MAT_ATTRIB_FRONT_INDEXES           10
#define MAT_ATTRIB_BACK_INDEXES            11
#define MAT_ATTRIB_MAX                     12

#define MAT_ATTRIB_AMBIENT(f)  (MAT_ATTRIB_FRONT_AMBIENT+(f))  
#define MAT_ATTRIB_DIFFUSE(f)  (MAT_ATTRIB_FRONT_DIFFUSE+(f))  
#define MAT_ATTRIB_SPECULAR(f) (MAT_ATTRIB_FRONT_SPECULAR+(f)) 
#define MAT_ATTRIB_EMISSION(f) (MAT_ATTRIB_FRONT_EMISSION+(f)) 
#define MAT_ATTRIB_SHININESS(f)(MAT_ATTRIB_FRONT_SHININESS+(f))
#define MAT_ATTRIB_INDEXES(f)  (MAT_ATTRIB_FRONT_INDEXES+(f))  

#define MAT_INDEX_AMBIENT  0
#define MAT_INDEX_DIFFUSE  1
#define MAT_INDEX_SPECULAR 2

#define MAT_BIT_FRONT_AMBIENT         (1<<MAT_ATTRIB_FRONT_AMBIENT)
#define MAT_BIT_BACK_AMBIENT          (1<<MAT_ATTRIB_BACK_AMBIENT)
#define MAT_BIT_FRONT_DIFFUSE         (1<<MAT_ATTRIB_FRONT_DIFFUSE)
#define MAT_BIT_BACK_DIFFUSE          (1<<MAT_ATTRIB_BACK_DIFFUSE)
#define MAT_BIT_FRONT_SPECULAR        (1<<MAT_ATTRIB_FRONT_SPECULAR)
#define MAT_BIT_BACK_SPECULAR         (1<<MAT_ATTRIB_BACK_SPECULAR)
#define MAT_BIT_FRONT_EMISSION        (1<<MAT_ATTRIB_FRONT_EMISSION)
#define MAT_BIT_BACK_EMISSION         (1<<MAT_ATTRIB_BACK_EMISSION)
#define MAT_BIT_FRONT_SHININESS       (1<<MAT_ATTRIB_FRONT_SHININESS)
#define MAT_BIT_BACK_SHININESS        (1<<MAT_ATTRIB_BACK_SHININESS)
#define MAT_BIT_FRONT_INDEXES         (1<<MAT_ATTRIB_FRONT_INDEXES)
#define MAT_BIT_BACK_INDEXES          (1<<MAT_ATTRIB_BACK_INDEXES)


#define FRONT_MATERIAL_BITS (MAT_BIT_FRONT_EMISSION |   \
                 MAT_BIT_FRONT_AMBIENT |    \
                 MAT_BIT_FRONT_DIFFUSE |    \
                 MAT_BIT_FRONT_SPECULAR |   \
                 MAT_BIT_FRONT_SHININESS |  \
                 MAT_BIT_FRONT_INDEXES)

#define BACK_MATERIAL_BITS  (MAT_BIT_BACK_EMISSION |    \
                 MAT_BIT_BACK_AMBIENT |     \
                 MAT_BIT_BACK_DIFFUSE |     \
                 MAT_BIT_BACK_SPECULAR |    \
                 MAT_BIT_BACK_SHININESS |   \
                 MAT_BIT_BACK_INDEXES)

#define ALL_MATERIAL_BITS   (FRONT_MATERIAL_BITS | BACK_MATERIAL_BITS)

#define EXP_TABLE_SIZE 512  
#define SHINE_TABLE_SIZE 256    
struct gl_shine_tab
{
   struct gl_shine_tab *next, *prev;
   GLfloat tab[SHINE_TABLE_SIZE+1];
   GLfloat shininess;
   GLuint refcount;
};


struct gl_light
{
   struct gl_light *next;   
   struct gl_light *prev;

   GLfloat Ambient[4];      
   GLfloat Diffuse[4];      
   GLfloat Specular[4];     
   GLfloat EyePosition[4];  
   GLfloat EyeDirection[4]; 
   GLfloat SpotExponent;
   GLfloat SpotCutoff;      
   GLfloat _CosCutoffNeg;   
   GLfloat _CosCutoff;      
   GLfloat ConstantAttenuation;
   GLfloat LinearAttenuation;
   GLfloat QuadraticAttenuation;
   GLboolean Enabled;       
   GLbitfield _Flags;       
   GLfloat _Position[4];    
   GLfloat _VP_inf_norm[3]; 
   GLfloat _h_inf_norm[3];  
   GLfloat _NormDirection[4];   
   GLfloat _VP_inf_spot_attenuation;

   GLfloat _SpotExpTable[EXP_TABLE_SIZE][2];  
   GLfloat _MatAmbient[2][3];   
   GLfloat _MatDiffuse[2][3];   
   GLfloat _MatSpecular[2][3];  
   GLfloat _dli;        
   GLfloat _sli;        
};


struct gl_lightmodel
{
   GLfloat Ambient[4];      
   GLboolean LocalViewer;   
   GLboolean TwoSide;       
   GLenum ColorControl;     
};


struct gl_material
{
   GLfloat Attrib[MAT_ATTRIB_MAX][4];
};


struct gl_accum_attrib
{
   GLfloat ClearColor[4];   
};


struct gl_colorbuffer_attrib
{
   GLuint ClearIndex;           
   GLclampf ClearColor[4];      
   GLuint IndexMask;            
   GLubyte ColorMask[4];        
   GLenum DrawBuffer[MAX_DRAW_BUFFERS]; 
   GLboolean AlphaEnabled;      
   GLenum AlphaFunc;            
   GLclampf AlphaRef;           

   GLboolean BlendEnabled;      
   GLenum BlendSrcRGB;          
   GLenum BlendDstRGB;          
   GLenum BlendSrcA;            
   GLenum BlendDstA;            
   GLenum BlendEquationRGB;     
   GLenum BlendEquationA;       
   GLfloat BlendColor[4];       

   GLenum LogicOp;          
   GLboolean IndexLogicOpEnabled;   
   GLboolean ColorLogicOpEnabled;   
   GLboolean _LogicOpEnabled;       

   GLboolean DitherFlag;        
   GLenum ClampFragmentColor; 
   GLenum ClampReadColor;     
};


struct gl_current_attrib
{
   GLfloat Attrib[VERT_ATTRIB_MAX][4];  

   GLfloat RasterPos[4];
   GLfloat RasterDistance;
   GLfloat RasterColor[4];
   GLfloat RasterSecondaryColor[4];
   GLfloat RasterIndex;
   GLfloat RasterTexCoords[MAX_TEXTURE_UNITS][4];
   GLboolean RasterPosValid;
};


struct gl_depthbuffer_attrib
{
   GLenum Func;         
   GLclampd Clear;      
   GLboolean Test;      
   GLboolean Mask;      
   GLboolean BoundsTest;        
   GLfloat BoundsMin, BoundsMax;
};


struct gl_enable_attrib
{
   GLboolean AlphaTest;
   GLboolean AutoNormal;
   GLboolean Blend;
   GLbitfield ClipPlanes;
   GLboolean ColorMaterial;
   GLboolean ColorTable[COLORTABLE_MAX];
   GLboolean Convolution1D;
   GLboolean Convolution2D;
   GLboolean Separable2D;
   GLboolean CullFace;
   GLboolean DepthTest;
   GLboolean Dither;
   GLboolean Fog;
   GLboolean Histogram;
   GLboolean Light[MAX_LIGHTS];
   GLboolean Lighting;
   GLboolean LineSmooth;
   GLboolean LineStipple;
   GLboolean IndexLogicOp;
   GLboolean ColorLogicOp;
   GLboolean Map1Color4;
   GLboolean Map1Index;
   GLboolean Map1Normal;
   GLboolean Map1TextureCoord1;
   GLboolean Map1TextureCoord2;
   GLboolean Map1TextureCoord3;
   GLboolean Map1TextureCoord4;
   GLboolean Map1Vertex3;
   GLboolean Map1Vertex4;
   GLboolean Map1Attrib[16];  /* GL_NV_vertex_program */
   GLboolean Map2Color4;
   GLboolean Map2Index;
   GLboolean Map2Normal;
   GLboolean Map2TextureCoord1;
   GLboolean Map2TextureCoord2;
   GLboolean Map2TextureCoord3;
   GLboolean Map2TextureCoord4;
   GLboolean Map2Vertex3;
   GLboolean Map2Vertex4;
   GLboolean Map2Attrib[16];  /* GL_NV_vertex_program */
   GLboolean MinMax;
   GLboolean Normalize;
   GLboolean PixelTexture;
   GLboolean PointSmooth;
   GLboolean PolygonOffsetPoint;
   GLboolean PolygonOffsetLine;
   GLboolean PolygonOffsetFill;
   GLboolean PolygonSmooth;
   GLboolean PolygonStipple;
   GLboolean RescaleNormals;
   GLboolean Scissor;
   GLboolean Stencil;
   GLboolean StencilTwoSide;          /* GL_EXT_stencil_two_side */
   GLboolean MultisampleEnabled;      /* GL_ARB_multisample */
   GLboolean SampleAlphaToCoverage;   /* GL_ARB_multisample */
   GLboolean SampleAlphaToOne;        /* GL_ARB_multisample */
   GLboolean SampleCoverage;          /* GL_ARB_multisample */
   GLboolean SampleCoverageInvert;    /* GL_ARB_multisample */
   GLboolean RasterPositionUnclipped; /* GL_IBM_rasterpos_clip */
   GLuint Texture[MAX_TEXTURE_UNITS];
   GLuint TexGen[MAX_TEXTURE_UNITS];
   /* SGI_texture_color_table */
   GLboolean TextureColorTable[MAX_TEXTURE_UNITS];
   /* GL_ARB_vertex_program / GL_NV_vertex_program */
   GLboolean VertexProgram;
   GLboolean VertexProgramPointSize;
   GLboolean VertexProgramTwoSide;
   /* GL_ARB_point_sprite / GL_NV_point_sprite */
   GLboolean PointSprite;
   GLboolean FragmentShaderATI;
};


struct gl_eval_attrib
{
   GLboolean Map1Color4;
   GLboolean Map1Index;
   GLboolean Map1Normal;
   GLboolean Map1TextureCoord1;
   GLboolean Map1TextureCoord2;
   GLboolean Map1TextureCoord3;
   GLboolean Map1TextureCoord4;
   GLboolean Map1Vertex3;
   GLboolean Map1Vertex4;
   GLboolean Map1Attrib[16];  /* GL_NV_vertex_program */
   GLboolean Map2Color4;
   GLboolean Map2Index;
   GLboolean Map2Normal;
   GLboolean Map2TextureCoord1;
   GLboolean Map2TextureCoord2;
   GLboolean Map2TextureCoord3;
   GLboolean Map2TextureCoord4;
   GLboolean Map2Vertex3;
   GLboolean Map2Vertex4;
   GLboolean Map2Attrib[16];  /* GL_NV_vertex_program */
   GLboolean AutoNormal;
   GLint MapGrid1un;
   GLfloat MapGrid1u1, MapGrid1u2, MapGrid1du;
   GLint MapGrid2un, MapGrid2vn;
   GLfloat MapGrid2u1, MapGrid2u2, MapGrid2du;
   GLfloat MapGrid2v1, MapGrid2v2, MapGrid2dv;
};


struct gl_fog_attrib
{
   GLboolean Enabled;       
   GLfloat Color[4];        
   GLfloat Density;     
   GLfloat Start;       
   GLfloat End;         
   GLfloat Index;       
   GLenum Mode;         
   GLboolean ColorSumEnabled;
   GLenum FogCoordinateSource;  
   GLfloat _Scale;      
};


struct gl_hint_attrib
{
   GLenum PerspectiveCorrection;
   GLenum PointSmooth;
   GLenum LineSmooth;
   GLenum PolygonSmooth;
   GLenum Fog;
   GLenum ClipVolumeClipping;   
   GLenum TextureCompression;   
   GLenum GenerateMipmap;       
   GLenum FragmentShaderDerivative; 
};


struct gl_histogram_attrib
{
   GLuint Width;                
   GLint Format;                
   GLuint Count[HISTOGRAM_TABLE_SIZE][4];   
   GLboolean Sink;              
   GLubyte RedSize;             
   GLubyte GreenSize;
   GLubyte BlueSize;
   GLubyte AlphaSize;
   GLubyte LuminanceSize;
};


struct gl_minmax_attrib
{
   GLenum Format;
   GLboolean Sink;
   GLfloat Min[4], Max[4];   
};


struct gl_convolution_attrib
{
   GLenum Format;
   GLenum InternalFormat;
   GLuint Width;
   GLuint Height;
   GLfloat Filter[MAX_CONVOLUTION_WIDTH * MAX_CONVOLUTION_HEIGHT * 4];
};


#define LIGHT_SPOT         0x1
#define LIGHT_LOCAL_VIEWER 0x2
#define LIGHT_POSITIONAL   0x4
#define LIGHT_NEED_VERTICES (LIGHT_POSITIONAL|LIGHT_LOCAL_VIEWER)

struct gl_light_attrib
{
   struct gl_light Light[MAX_LIGHTS];   
   struct gl_lightmodel Model;      
   struct gl_material Material;     

   GLboolean Enabled;           
   GLenum ShadeModel;           
   GLenum ColorMaterialFace;        
   GLenum ColorMaterialMode;        
   GLbitfield ColorMaterialBitmask; 
   GLboolean ColorMaterialEnabled;
   GLenum ClampVertexColor;

   struct gl_light EnabledList;         
   GLboolean _NeedEyeCoords;        
   GLboolean _NeedVertices;     
   GLbitfield  _Flags;              
   GLfloat _BaseColor[2][3];
};


struct gl_line_attrib
{
   GLboolean SmoothFlag;    
   GLboolean StippleFlag;   
   GLushort StipplePattern; 
   GLint StippleFactor;     
   GLfloat Width;       
};


struct gl_list_attrib
{
   GLuint ListBase;
};


struct gl_list_instruction
{
   GLuint Size;
   void (*Execute)( GLcontext *ctx, void *data );
   void (*Destroy)( GLcontext *ctx, void *data );
   void (*Print)( GLcontext *ctx, void *data );
};

#define MAX_DLIST_EXT_OPCODES 16

struct gl_list_extensions
{
   struct gl_list_instruction Opcode[MAX_DLIST_EXT_OPCODES];
   GLuint NumOpcodes;
};


struct gl_multisample_attrib
{
   GLboolean Enabled;
   GLboolean _Enabled;   
   GLboolean SampleAlphaToCoverage;
   GLboolean SampleAlphaToOne;
   GLboolean SampleCoverage;
   GLfloat SampleCoverageValue;
   GLboolean SampleCoverageInvert;
};


struct gl_pixelmap
{
   GLint Size;
   GLfloat Map[MAX_PIXEL_MAP_TABLE];
   GLubyte Map8[MAX_PIXEL_MAP_TABLE];  
};


struct gl_pixelmaps
{
   struct gl_pixelmap RtoR;  
   struct gl_pixelmap GtoG;
   struct gl_pixelmap BtoB;
   struct gl_pixelmap AtoA;
   struct gl_pixelmap ItoR;
   struct gl_pixelmap ItoG;
   struct gl_pixelmap ItoB;
   struct gl_pixelmap ItoA;
   struct gl_pixelmap ItoI;
   struct gl_pixelmap StoS;
};


struct gl_pixel_attrib
{
   GLenum ReadBuffer;       
   /*--- Begin Pixel Transfer State ---*/
   /* Fields are in the order in which they're applied... */

   /* Scale & Bias (index shift, offset) */
   GLfloat RedBias, RedScale;
   GLfloat GreenBias, GreenScale;
   GLfloat BlueBias, BlueScale;
   GLfloat AlphaBias, AlphaScale;
   GLfloat DepthBias, DepthScale;
   GLint IndexShift, IndexOffset;

   /* Pixel Maps */
   /* Note: actual pixel maps are not part of this attrib group */
   GLboolean MapColorFlag;
   GLboolean MapStencilFlag;

   /* There are multiple color table stages: */
   GLboolean ColorTableEnabled[COLORTABLE_MAX];
   GLfloat ColorTableScale[COLORTABLE_MAX][4];  
   GLfloat ColorTableBias[COLORTABLE_MAX][4];   
   /* Convolution (GL_EXT_convolution) */
   GLboolean Convolution1DEnabled;
   GLboolean Convolution2DEnabled;
   GLboolean Separable2DEnabled;
   GLfloat ConvolutionBorderColor[3][4];
   GLenum ConvolutionBorderMode[3];
   GLfloat ConvolutionFilterScale[3][4];  
   GLfloat ConvolutionFilterBias[3][4];   
   GLfloat PostConvolutionScale[4];  
   GLfloat PostConvolutionBias[4];   
   /* Color matrix (GL_SGI_color_matrix) */
   /* Note: the color matrix is not part of this attrib group */
   GLfloat PostColorMatrixScale[4];  
   GLfloat PostColorMatrixBias[4];   
   /* Histogram & minmax (GL_EXT_histogram) */
   /* Note: histogram and minmax data are not part of this attrib group */
   GLboolean HistogramEnabled;
   GLboolean MinMaxEnabled;

   /*--- End Pixel Transfer State ---*/

   /* Pixel Zoom */
   GLfloat ZoomX, ZoomY;

   GLfloat TextureColorTableScale[4];
   GLfloat TextureColorTableBias[4];
};


struct gl_point_attrib
{
   GLboolean SmoothFlag;    
   GLfloat Size;        
   GLfloat Params[3];       
   GLfloat MinSize, MaxSize;    
   GLfloat Threshold;       
   GLboolean _Attenuated;   
   GLboolean PointSprite;   
   GLboolean CoordReplace[MAX_TEXTURE_UNITS]; 
   GLenum SpriteRMode;      
   GLenum SpriteOrigin;     
};


struct gl_polygon_attrib
{
   GLenum FrontFace;        
   GLenum FrontMode;        
   GLenum BackMode;     
   GLboolean _FrontBit;     
   GLboolean CullFlag;      
   GLboolean SmoothFlag;    
   GLboolean StippleFlag;   
   GLenum CullFaceMode;     
   GLfloat OffsetFactor;    
   GLfloat OffsetUnits;     
   GLboolean OffsetPoint;   
   GLboolean OffsetLine;    
   GLboolean OffsetFill;    
};


struct gl_scissor_attrib
{
   GLboolean Enabled;       
   GLint X, Y;          
   GLsizei Width, Height;   
};


struct gl_stencil_attrib
{
   GLboolean Enabled;       
   GLboolean TestTwoSide;   
   GLubyte ActiveFace;      
   GLboolean _TestTwoSide;
   GLubyte _BackFace;           
   GLenum Function[3];      
   GLenum FailFunc[3];      
   GLenum ZPassFunc[3];     
   GLenum ZFailFunc[3];     
   GLint Ref[3];        
   GLuint ValueMask[3];     
   GLuint WriteMask[3];     
   GLuint Clear;        
};


#define NUM_TEXTURE_TARGETS 7   /* 1D, 2D, 3D, CUBE, RECT, 1D_STACK, and 2D_STACK */

#define TEXTURE_1D_INDEX       0
#define TEXTURE_2D_INDEX       1
#define TEXTURE_3D_INDEX       2
#define TEXTURE_CUBE_INDEX     3
#define TEXTURE_RECT_INDEX     4
#define TEXTURE_1D_ARRAY_INDEX 5
#define TEXTURE_2D_ARRAY_INDEX 6

#define TEXTURE_1D_BIT       (1 << TEXTURE_1D_INDEX)
#define TEXTURE_2D_BIT       (1 << TEXTURE_2D_INDEX)
#define TEXTURE_3D_BIT       (1 << TEXTURE_3D_INDEX)
#define TEXTURE_CUBE_BIT     (1 << TEXTURE_CUBE_INDEX)
#define TEXTURE_RECT_BIT     (1 << TEXTURE_RECT_INDEX)
#define TEXTURE_1D_ARRAY_BIT (1 << TEXTURE_1D_ARRAY_INDEX)
#define TEXTURE_2D_ARRAY_BIT (1 << TEXTURE_2D_ARRAY_INDEX)

#define S_BIT 1
#define T_BIT 2
#define R_BIT 4
#define Q_BIT 8

#define TEXGEN_SPHERE_MAP        0x1
#define TEXGEN_OBJ_LINEAR        0x2
#define TEXGEN_EYE_LINEAR        0x4
#define TEXGEN_REFLECTION_MAP_NV 0x8
#define TEXGEN_NORMAL_MAP_NV     0x10

#define TEXGEN_NEED_NORMALS      (TEXGEN_SPHERE_MAP        | \
                  TEXGEN_REFLECTION_MAP_NV | \
                  TEXGEN_NORMAL_MAP_NV)
#define TEXGEN_NEED_EYE_COORD    (TEXGEN_SPHERE_MAP        | \
                  TEXGEN_REFLECTION_MAP_NV | \
                  TEXGEN_NORMAL_MAP_NV     | \
                  TEXGEN_EYE_LINEAR)

/* A selection of state flags to make driver and module's lives easier. */
#define ENABLE_TEXGEN0        0x1
#define ENABLE_TEXGEN1        0x2
#define ENABLE_TEXGEN2        0x4
#define ENABLE_TEXGEN3        0x8
#define ENABLE_TEXGEN4        0x10
#define ENABLE_TEXGEN5        0x20
#define ENABLE_TEXGEN6        0x40
#define ENABLE_TEXGEN7        0x80

#define ENABLE_TEXMAT0        0x1   /* Ie. not the identity matrix */
#define ENABLE_TEXMAT1        0x2
#define ENABLE_TEXMAT2        0x4
#define ENABLE_TEXMAT3        0x8
#define ENABLE_TEXMAT4        0x10
#define ENABLE_TEXMAT5        0x20
#define ENABLE_TEXMAT6        0x40
#define ENABLE_TEXMAT7        0x80

#define ENABLE_TEXGEN(i) (ENABLE_TEXGEN0 << (i))
#define ENABLE_TEXMAT(i) (ENABLE_TEXMAT0 << (i))


typedef void (*FetchTexelFuncC)( const struct gl_texture_image *texImage,
                                 GLint col, GLint row, GLint img,
                                 GLchan *texelOut );

typedef void (*FetchTexelFuncF)( const struct gl_texture_image *texImage,
                                 GLint col, GLint row, GLint img,
                                 GLfloat *texelOut );


typedef void (*StoreTexelFunc)(struct gl_texture_image *texImage,
                               GLint col, GLint row, GLint img,
                               const void *texel);


#define TEXSTORE_PARAMS \
    GLcontext *ctx, GLuint dims, \
    GLenum baseInternalFormat, \
    const struct gl_texture_format *dstFormat, \
    GLvoid *dstAddr, \
    GLint dstXoffset, GLint dstYoffset, GLint dstZoffset, \
    GLint dstRowStride, const GLuint *dstImageOffsets, \
    GLint srcWidth, GLint srcHeight, GLint srcDepth, \
    GLenum srcFormat, GLenum srcType, \
    const GLvoid *srcAddr, \
    const struct gl_pixelstore_attrib *srcPacking



typedef GLboolean (*StoreTexImageFunc)(TEXSTORE_PARAMS);


struct gl_texture_format
{
   GLint MesaFormat;        
   GLenum BaseFormat;       
   GLenum DataType;     
   GLubyte RedBits;
   GLubyte GreenBits;
   GLubyte BlueBits;
   GLubyte AlphaBits;
   GLubyte LuminanceBits;
   GLubyte IntensityBits;
   GLubyte IndexBits;
   GLubyte DepthBits;
   GLubyte StencilBits;     

   GLuint TexelBytes;       
   StoreTexImageFunc StoreImage;

   FetchTexelFuncC FetchTexel1D;
   FetchTexelFuncC FetchTexel2D;
   FetchTexelFuncC FetchTexel3D;
   FetchTexelFuncF FetchTexel1Df;
   FetchTexelFuncF FetchTexel2Df;
   FetchTexelFuncF FetchTexel3Df;
   StoreTexelFunc StoreTexel;
};


struct gl_texture_image
{
   GLenum _BaseFormat;      
   GLint InternalFormat;    
   GLuint Border;       
   GLuint Width;        
   GLuint Height;       
   GLuint Depth;        
   GLuint Width2;       
   GLuint Height2;      
   GLuint Depth2;       
   GLuint WidthLog2;        
   GLuint HeightLog2;       
   GLuint DepthLog2;        
   GLuint MaxLog2;      
   GLfloat WidthScale;      
   GLfloat HeightScale;     
   GLfloat DepthScale;      
   GLboolean IsClientData;  
   GLboolean _IsPowerOfTwo; 
   const struct gl_texture_format *TexFormat;

   struct gl_texture_object *TexObject;  
   FetchTexelFuncC FetchTexelc; 
   FetchTexelFuncF FetchTexelf; 
   GLboolean IsCompressed;  
   GLuint CompressedSize;   
   GLuint RowStride;        
   GLuint *ImageOffsets;        
   GLvoid *Data;        
   void *DriverData;        
};


#define FACE_POS_X   0
#define FACE_NEG_X   1
#define FACE_POS_Y   2
#define FACE_NEG_Y   3
#define FACE_POS_Z   4
#define FACE_NEG_Z   5
#define MAX_FACES    6

struct gl_texture_object
{
   _glthread_Mutex Mutex;   
   GLint RefCount;      
   GLuint Name;         
   GLenum Target;               
   GLfloat Priority;        
   GLfloat BorderColor[4];  
   GLchan _BorderChan[4];   
   GLenum WrapS;        
   GLenum WrapT;        
   GLenum WrapR;        
   GLenum MinFilter;        
   GLenum MagFilter;        
   GLfloat MinLod;      
   GLfloat MaxLod;      
   GLfloat LodBias;     
   GLint BaseLevel;     
   GLint MaxLevel;      
   GLfloat MaxAnisotropy;   
   GLboolean CompareFlag;   
   GLenum CompareOperator;  
   GLfloat ShadowAmbient;       
   GLenum CompareMode;      
   GLenum CompareFunc;      
   GLenum _Function;        
   GLenum DepthMode;        
   GLint _MaxLevel;     
   GLfloat _MaxLambda;      
   GLint CropRect[4];           
   GLboolean GenerateMipmap;    
   GLboolean _Complete;     
   struct gl_texture_image *Image[MAX_FACES][MAX_TEXTURE_LEVELS];

   struct gl_color_table Palette;

   void *DriverData;    
};


struct gl_tex_env_combine_state
{
   GLenum ModeRGB;       
   GLenum ModeA;         
   GLenum SourceRGB[3];  
   GLenum SourceA[3];    
   GLenum OperandRGB[3]; 
   GLenum OperandA[3];   
   GLuint ScaleShiftRGB; 
   GLuint ScaleShiftA;   
   GLuint _NumArgsRGB;   
   GLuint _NumArgsA;     
};


struct gl_texture_unit
{
   GLbitfield Enabled;          
   GLbitfield _ReallyEnabled;   
   GLenum EnvMode;              
   GLfloat EnvColor[4];
   GLbitfield TexGenEnabled;    
   GLenum GenModeS;     
   GLenum GenModeT;
   GLenum GenModeR;
   GLenum GenModeQ;
   GLbitfield _GenBitS;
   GLbitfield _GenBitT;
   GLbitfield _GenBitR;
   GLbitfield _GenBitQ;
   GLbitfield _GenFlags;    
   GLfloat ObjectPlaneS[4];
   GLfloat ObjectPlaneT[4];
   GLfloat ObjectPlaneR[4];
   GLfloat ObjectPlaneQ[4];
   GLfloat EyePlaneS[4];
   GLfloat EyePlaneT[4];
   GLfloat EyePlaneR[4];
   GLfloat EyePlaneQ[4];
   GLfloat LodBias;     
   struct gl_tex_env_combine_state Combine;

   struct gl_tex_env_combine_state _EnvMode;

   struct gl_tex_env_combine_state *_CurrentCombine;

   struct gl_texture_object *CurrentTex[NUM_TEXTURE_TARGETS];

   struct gl_texture_object *_Current;

   struct gl_color_table ColorTable;
   struct gl_color_table ProxyColorTable;
   GLboolean ColorTableEnabled;
};



struct gl_texture_attrib
{
   GLuint CurrentUnit;   
   GLbitfield _EnabledUnits;  
   GLbitfield _EnabledCoordUnits;   
   GLbitfield _GenFlags;            
   GLbitfield _TexGenEnabled;
   GLbitfield _TexMatEnabled;
   struct gl_texture_unit Unit[MAX_TEXTURE_UNITS];

   struct gl_texture_object *ProxyTex[NUM_TEXTURE_TARGETS];

   GLboolean SharedPalette;
   struct gl_color_table Palette;
};


struct gl_transform_attrib
{
   GLenum MatrixMode;               
   GLfloat EyeUserPlane[MAX_CLIP_PLANES][4];    
   GLfloat _ClipUserPlane[MAX_CLIP_PLANES][4];  
   GLbitfield ClipPlanesEnabled;                
   GLboolean Normalize;             
   GLboolean RescaleNormals;            
   GLboolean RasterPositionUnclipped;           
   GLboolean CullVertexFlag;    
   GLfloat CullEyePos[4];
   GLfloat CullObjPos[4];
};


struct gl_viewport_attrib
{
   GLint X, Y;          
   GLsizei Width, Height;   
   GLfloat Near, Far;       
   GLmatrix _WindowMap;     
};


struct gl_attrib_node
{
   GLbitfield kind;
   void *data;
   struct gl_attrib_node *next;
};


struct gl_buffer_object
{
   GLint RefCount;
   GLuint Name;
   GLenum Usage;
   GLenum Access;
   GLvoid *Pointer;          
   GLsizeiptrARB Size;       
   GLubyte *Data;            
   GLboolean OnCard;         
};



struct gl_pixelstore_attrib
{
   GLint Alignment;
   GLint RowLength;
   GLint SkipPixels;
   GLint SkipRows;
   GLint ImageHeight;     
   GLint SkipImages;      
   GLboolean SwapBytes;
   GLboolean LsbFirst;
   GLboolean ClientStorage; 
   GLboolean Invert;        
   struct gl_buffer_object *BufferObj; 
};



struct gl_client_array
{
   GLint Size;                  
   GLenum Type;                 
   GLsizei Stride;      
   GLsizei StrideB;     
   const GLubyte *Ptr;          
   GLboolean Enabled;       
   GLboolean Normalized;        
   struct gl_buffer_object *BufferObj;
   GLuint _MaxElement;
};


struct gl_array_object
{
   GLuint Name;

   struct gl_client_array Vertex;
   struct gl_client_array Normal;
   struct gl_client_array Color;
   struct gl_client_array SecondaryColor;
   struct gl_client_array FogCoord;
   struct gl_client_array Index;
   struct gl_client_array EdgeFlag;
   struct gl_client_array TexCoord[MAX_TEXTURE_COORD_UNITS];
   struct gl_client_array PointSize;
   struct gl_client_array VertexAttrib[VERT_ATTRIB_MAX];

   GLbitfield _Enabled;
};


struct gl_array_attrib
{
   struct gl_array_object *ArrayObj;
   struct gl_array_object *DefaultArrayObj;

   GLint ActiveTexture;     
   GLuint LockFirst;            
   GLuint LockCount;            
   GLbitfield NewState;     
#if FEATURE_ARB_vertex_buffer_object
   struct gl_buffer_object *NullBufferObj;
   struct gl_buffer_object *ArrayBufferObj;
   struct gl_buffer_object *ElementArrayBufferObj;
#endif
   GLuint _MaxElement;          /* Min of all enabled array's maxes */
};


struct gl_feedback
{
   GLenum Type;
   GLbitfield _Mask;        /* FB_* bits */
   GLfloat *Buffer;
   GLuint BufferSize;
   GLuint Count;
};


struct gl_selection
{
   GLuint *Buffer;  
   GLuint BufferSize;   
   GLuint BufferCount;  
   GLuint Hits;     
   GLuint NameStackDepth; 
   GLuint NameStack[MAX_NAME_STACK_DEPTH]; 
   GLboolean HitFlag;   
   GLfloat HitMinZ; 
   GLfloat HitMaxZ; 
};


struct gl_1d_map
{
   GLuint Order;    
   GLfloat u1, u2, du;  
   GLfloat *Points; 
};


struct gl_2d_map
{
   GLuint Uorder;       
   GLuint Vorder;       
   GLfloat u1, u2, du;
   GLfloat v1, v2, dv;
   GLfloat *Points;     
};


struct gl_evaluators
{
   struct gl_1d_map Map1Vertex3;
   struct gl_1d_map Map1Vertex4;
   struct gl_1d_map Map1Index;
   struct gl_1d_map Map1Color4;
   struct gl_1d_map Map1Normal;
   struct gl_1d_map Map1Texture1;
   struct gl_1d_map Map1Texture2;
   struct gl_1d_map Map1Texture3;
   struct gl_1d_map Map1Texture4;
   struct gl_1d_map Map1Attrib[16];  

   struct gl_2d_map Map2Vertex3;
   struct gl_2d_map Map2Vertex4;
   struct gl_2d_map Map2Index;
   struct gl_2d_map Map2Color4;
   struct gl_2d_map Map2Normal;
   struct gl_2d_map Map2Texture1;
   struct gl_2d_map Map2Texture2;
   struct gl_2d_map Map2Texture3;
   struct gl_2d_map Map2Texture4;
   struct gl_2d_map Map2Attrib[16];  
};


enum register_file
{
   PROGRAM_TEMPORARY = 0,   
   PROGRAM_LOCAL_PARAM = 1, 
   PROGRAM_ENV_PARAM = 2,   
   PROGRAM_STATE_VAR = 3,   
   PROGRAM_INPUT = 4,       
   PROGRAM_OUTPUT = 5,      
   PROGRAM_NAMED_PARAM = 6, 
   PROGRAM_CONSTANT = 7,    
   PROGRAM_UNIFORM = 8,     
   PROGRAM_VARYING = 9,     
   PROGRAM_WRITE_ONLY = 10, 
   PROGRAM_ADDRESS = 11,    
   PROGRAM_SAMPLER = 12,    
   PROGRAM_UNDEFINED = 13,  
   PROGRAM_FILE_MAX
};


struct prog_instruction;
struct gl_program_parameter_list;
struct gl_uniform_list;


struct gl_program
{
   GLuint Id;
   GLubyte *String;  
   GLint RefCount;
   GLenum Target;    
   GLenum Format;    
   GLboolean Resident;

   struct prog_instruction *Instructions;

   GLbitfield InputsRead;     
   GLbitfield OutputsWritten; 
   GLbitfield InputFlags[MAX_PROGRAM_INPUTS];   
   GLbitfield OutputFlags[MAX_PROGRAM_OUTPUTS]; 
   GLbitfield TexturesUsed[MAX_TEXTURE_UNITS];  
   GLbitfield SamplersUsed;   
   GLbitfield ShadowSamplers; 
   struct gl_program_parameter_list *Parameters;
   GLfloat LocalParams[MAX_PROGRAM_LOCAL_PARAMS][4];

   struct gl_program_parameter_list *Varying;
   struct gl_program_parameter_list *Attributes;

   GLubyte SamplerUnits[MAX_SAMPLERS];
   GLubyte SamplerTargets[MAX_SAMPLERS];

   GLuint NumInstructions;
   GLuint NumTemporaries;
   GLuint NumParameters;
   GLuint NumAttributes;
   GLuint NumAddressRegs;
   GLuint NumAluInstructions;
   GLuint NumTexInstructions;
   GLuint NumTexIndirections;
   GLuint NumNativeInstructions;
   GLuint NumNativeTemporaries;
   GLuint NumNativeParameters;
   GLuint NumNativeAttributes;
   GLuint NumNativeAddressRegs;
   GLuint NumNativeAluInstructions;
   GLuint NumNativeTexInstructions;
   GLuint NumNativeTexIndirections;
};


struct gl_vertex_program
{
   struct gl_program Base;   
   GLboolean IsNVProgram;    
   GLboolean IsPositionInvariant;
   void *TnlData;       
};


struct gl_fragment_program
{
   struct gl_program Base;   
   GLenum FogOption;
   GLboolean UsesKill;          
   GLboolean UsesPointCoord;    
   GLboolean UsesFrontFacing;   
   GLboolean UsesFogFragCoord;  
};


struct gl_program_state
{
   GLint ErrorPos;                       /* GL_PROGRAM_ERROR_POSITION_ARB/NV */
   const char *ErrorString;              /* GL_PROGRAM_ERROR_STRING_ARB/NV */
};


struct gl_vertex_program_state
{
   GLboolean Enabled;               
   GLboolean _Enabled;              
   GLboolean PointSizeEnabled;      
   GLboolean TwoSideEnabled;        
   struct gl_vertex_program *Current;  
   struct gl_vertex_program *_Current;

   GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; 
   /* For GL_NV_vertex_program only: */
   GLenum TrackMatrix[MAX_PROGRAM_ENV_PARAMS / 4];
   GLenum TrackMatrixTransform[MAX_PROGRAM_ENV_PARAMS / 4];

   GLboolean _MaintainTnlProgram;

   struct gl_vertex_program *_TnlProgram;

   struct gl_program_cache *Cache;

#if FEATURE_MESA_program_debug
   GLprogramcallbackMESA Callback;
   GLvoid *CallbackData;
   GLboolean CallbackEnabled;
   GLuint CurrentPosition;
#endif
};


struct gl_fragment_program_state
{
   GLboolean Enabled;     
   GLboolean _Enabled;    
   struct gl_fragment_program *Current;  
   struct gl_fragment_program *_Current;

   GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; 
   GLboolean _MaintainTexEnvProgram;

   struct gl_fragment_program *_TexEnvProgram;

   struct gl_program_cache *Cache;

#if FEATURE_MESA_program_debug
   GLprogramcallbackMESA Callback;
   GLvoid *CallbackData;
   GLboolean CallbackEnabled;
   GLuint CurrentPosition;
#endif
};


#define ATI_FS_INPUT_PRIMARY 0
#define ATI_FS_INPUT_SECONDARY 1

struct atifs_instruction;
struct atifs_setupinst;

struct ati_fragment_shader
{
   GLuint Id;
   GLint RefCount;
   struct atifs_instruction *Instructions[2];
   struct atifs_setupinst *SetupInst[2];
   GLfloat Constants[8][4];
   GLbitfield LocalConstDef;  
   GLubyte numArithInstr[2];
   GLubyte regsAssigned[2];
   GLubyte NumPasses;         
   GLubyte cur_pass;
   GLubyte last_optype;
   GLboolean interpinp1;
   GLboolean isValid;
   GLuint swizzlerq;
};

struct gl_ati_fragment_shader_state
{
   GLboolean Enabled;
   GLboolean _Enabled;                      
   GLboolean Compiling;
   GLfloat GlobalConstants[8][4];
   struct ati_fragment_shader *Current;
};


struct gl_query_object
{
   GLenum Target;      
   GLuint Id;          
   GLuint64EXT Result; 
   GLboolean Active;   
   GLboolean Ready;    
};


struct gl_query_state
{
   struct _mesa_HashTable *QueryObjects;
   struct gl_query_object *CurrentOcclusionObject; /* GL_ARB_occlusion_query */
   struct gl_query_object *CurrentTimerObject;     /* GL_EXT_timer_query */
};


struct gl_sl_pragmas
{
   GLboolean Optimize;  
   GLboolean Debug;     
};


struct gl_shader
{
   GLenum Type;  
   GLuint Name;  
   GLint RefCount;  
   GLboolean DeletePending;
   GLboolean CompileStatus;
   GLboolean Main;  
   const GLchar *Source;  
   struct gl_program *Program;  
   GLchar *InfoLog;
   struct gl_sl_pragmas Pragmas;
};


struct gl_shader_program
{
   GLenum Type;  
   GLuint Name;  
   GLint RefCount;  
   GLboolean DeletePending;

   GLuint NumShaders;          
   struct gl_shader **Shaders; 
   struct gl_program_parameter_list *Attributes;

   /* post-link info: */
   struct gl_vertex_program *VertexProgram;     
   struct gl_fragment_program *FragmentProgram; 
   struct gl_uniform_list *Uniforms;
   struct gl_program_parameter_list *Varying;
   GLboolean LinkStatus;   
   GLboolean Validated;
   GLchar *InfoLog;
};   


struct gl_shader_state
{
   struct gl_shader_program *CurrentProgram; 
   GLboolean EmitHighLevelInstructions; 
   GLboolean EmitCondCodes;             
   GLboolean EmitComments;              
   void *MemPool;
};


struct gl_shared_state
{
   _glthread_Mutex Mutex;          
   GLint RefCount;             
   struct _mesa_HashTable *DisplayList;    
   struct _mesa_HashTable *TexObjects;     
   struct gl_texture_object *DefaultTex[NUM_TEXTURE_TARGETS];

   _glthread_Mutex TexMutex;        
   GLuint TextureStateStamp;            


   struct _mesa_HashTable *Programs; 
#if FEATURE_ARB_vertex_program
   struct gl_vertex_program *DefaultVertexProgram;
#endif
#if FEATURE_ARB_fragment_program
   struct gl_fragment_program *DefaultFragmentProgram;
#endif

#if FEATURE_ATI_fragment_shader
   struct _mesa_HashTable *ATIShaders;
   struct ati_fragment_shader *DefaultFragmentShader;
#endif

#if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
   struct _mesa_HashTable *BufferObjects;
#endif

#if FEATURE_ARB_shader_objects

   struct _mesa_HashTable *ShaderObjects;
#endif

#if FEATURE_EXT_framebuffer_object
   struct _mesa_HashTable *RenderBuffers;
   struct _mesa_HashTable *FrameBuffers;
#endif

   struct _mesa_HashTable *ArrayObjects;

   void *DriverData;  
};




struct gl_renderbuffer
{
#define RB_MAGIC 0xaabbccdd
   int Magic; 
   _glthread_Mutex Mutex;          
   GLuint ClassID;        
   GLuint Name;
   GLint RefCount;
   GLuint Width, Height;
   GLenum InternalFormat; 
   GLenum _ActualFormat;  
   GLenum _BaseFormat;    
   GLenum DataType;      
   GLubyte RedBits;      
   GLubyte GreenBits;
   GLubyte BlueBits;
   GLubyte AlphaBits;
   GLubyte IndexBits;
   GLubyte DepthBits;
   GLubyte StencilBits;
   GLvoid *Data;        
   /* Used to wrap one renderbuffer around another: */
   struct gl_renderbuffer *Wrapped;

   /* Delete this renderbuffer */
   void (*Delete)(struct gl_renderbuffer *rb);

   /* Allocate new storage for this renderbuffer */
   GLboolean (*AllocStorage)(GLcontext *ctx, struct gl_renderbuffer *rb,
                             GLenum internalFormat,
                             GLuint width, GLuint height);

   /* Lock/Unlock are called before/after calling the Get/Put functions.
    * Not sure this is the right place for these yet.
   void (*Lock)(GLcontext *ctx, struct gl_renderbuffer *rb);
   void (*Unlock)(GLcontext *ctx, struct gl_renderbuffer *rb);
    */

   /* Return a pointer to the element/pixel at (x,y).
    * Should return NULL if the buffer memory can't be directly addressed.
    */
   void *(*GetPointer)(GLcontext *ctx, struct gl_renderbuffer *rb,
                       GLint x, GLint y);

   /* Get/Read a row of values.
    * The values will be of format _BaseFormat and type DataType.
    */
   void (*GetRow)(GLcontext *ctx, struct gl_renderbuffer *rb, GLuint count,
                  GLint x, GLint y, void *values);

   /* Get/Read values at arbitrary locations.
    * The values will be of format _BaseFormat and type DataType.
    */
   void (*GetValues)(GLcontext *ctx, struct gl_renderbuffer *rb, GLuint count,
                     const GLint x[], const GLint y[], void *values);

   /* Put/Write a row of values.
    * The values will be of format _BaseFormat and type DataType.
    */
   void (*PutRow)(GLcontext *ctx, struct gl_renderbuffer *rb, GLuint count,
                  GLint x, GLint y, const void *values, const GLubyte *mask);

   /* Put/Write a row of RGB values.  This is a special-case routine that's
    * only used for RGBA renderbuffers when the source data is GL_RGB. That's
    * a common case for glDrawPixels and some triangle routines.
    * The values will be of format GL_RGB and type DataType.
    */
   void (*PutRowRGB)(GLcontext *ctx, struct gl_renderbuffer *rb, GLuint count,
                    GLint x, GLint y, const void *values, const GLubyte *mask);


   /* Put/Write a row of identical values.
    * The values will be of format _BaseFormat and type DataType.
    */
   void (*PutMonoRow)(GLcontext *ctx, struct gl_renderbuffer *rb, GLuint count,
                     GLint x, GLint y, const void *value, const GLubyte *mask);

   /* Put/Write values at arbitrary locations.
    * The values will be of format _BaseFormat and type DataType.
    */
   void (*PutValues)(GLcontext *ctx, struct gl_renderbuffer *rb, GLuint count,
                     const GLint x[], const GLint y[], const void *values,
                     const GLubyte *mask);
   /* Put/Write identical values at arbitrary locations.
    * The values will be of format _BaseFormat and type DataType.
    */
   void (*PutMonoValues)(GLcontext *ctx, struct gl_renderbuffer *rb,
                         GLuint count, const GLint x[], const GLint y[],
                         const void *value, const GLubyte *mask);
};


struct gl_renderbuffer_attachment
{
   GLenum Type;  
   GLboolean Complete;

   struct gl_renderbuffer *Renderbuffer;

   struct gl_texture_object *Texture;
   GLuint TextureLevel; 
   GLuint CubeMapFace;  
   GLuint Zoffset;      
};


struct gl_framebuffer
{
   _glthread_Mutex Mutex;  
   GLuint Name;

   GLint RefCount;
   GLboolean DeletePending;

   GLvisual Visual; 
   GLboolean Initialized;

   GLuint Width, Height;    
   GLint _Xmin, _Xmax;  
   GLint _Ymin, _Ymax;  

   GLuint _DepthMax;    
   GLfloat _DepthMaxF;  
   GLfloat _MRD;    

   GLenum _Status; /* One of the GL_FRAMEBUFFER_(IN)COMPLETE_* tokens */

   /* Array of all renderbuffer attachments, indexed by BUFFER_* tokens. */
   struct gl_renderbuffer_attachment Attachment[BUFFER_COUNT];

   /* In unextended OpenGL these vars are part of the GL_COLOR_BUFFER
    * attribute group and GL_PIXEL attribute group, respectively.
    */
   GLenum ColorDrawBuffer[MAX_DRAW_BUFFERS];
   GLenum ColorReadBuffer;

   GLuint _NumColorDrawBuffers;
   GLint _ColorDrawBufferIndexes[MAX_DRAW_BUFFERS]; 
   GLint _ColorReadBufferIndex; /* -1 = None */
   struct gl_renderbuffer *_ColorDrawBuffers[MAX_DRAW_BUFFERS];
   struct gl_renderbuffer *_ColorReadBuffer;

   struct gl_renderbuffer *_DepthBuffer;
   struct gl_renderbuffer *_StencilBuffer;

   void (*Delete)(struct gl_framebuffer *fb);
};


struct gl_program_constants
{
   /* logical limits */
   GLuint MaxInstructions;
   GLuint MaxAluInstructions; /* fragment programs only, for now */
   GLuint MaxTexInstructions; /* fragment programs only, for now */
   GLuint MaxTexIndirections; /* fragment programs only, for now */
   GLuint MaxAttribs;
   GLuint MaxTemps;
   GLuint MaxAddressRegs; /* vertex program only, for now */
   GLuint MaxParameters;
   GLuint MaxLocalParams;
   GLuint MaxEnvParams;
   /* native/hardware limits */
   GLuint MaxNativeInstructions;
   GLuint MaxNativeAluInstructions; /* fragment programs only, for now */
   GLuint MaxNativeTexInstructions; /* fragment programs only, for now */
   GLuint MaxNativeTexIndirections; /* fragment programs only, for now */
   GLuint MaxNativeAttribs;
   GLuint MaxNativeTemps;
   GLuint MaxNativeAddressRegs; /* vertex program only, for now */
   GLuint MaxNativeParameters;
   /* For shaders */
   GLuint MaxUniformComponents;
};


struct gl_constants
{
   GLint MaxTextureLevels;      
   GLint Max3DTextureLevels;        
   GLint MaxCubeTextureLevels;          
   GLint MaxArrayTextureLayers;         
   GLint MaxTextureRectSize;            /* GL_NV_texture_rectangle */
   GLuint MaxTextureCoordUnits;
   GLuint MaxTextureImageUnits;
   GLuint MaxTextureUnits;              
   GLfloat MaxTextureMaxAnisotropy;     
   GLfloat MaxTextureLodBias;           
   GLuint MaxArrayLockSize;
   GLint SubPixelBits;
   GLfloat MinPointSize, MaxPointSize;      /* aliased */
   GLfloat MinPointSizeAA, MaxPointSizeAA;  /* antialiased */
   GLfloat PointSizeGranularity;
   GLfloat MinLineWidth, MaxLineWidth;      /* aliased */
   GLfloat MinLineWidthAA, MaxLineWidthAA;  /* antialiased */
   GLfloat LineWidthGranularity;
   GLuint MaxColorTableSize;
   GLuint MaxConvolutionWidth;
   GLuint MaxConvolutionHeight;
   GLuint MaxClipPlanes;
   GLuint MaxLights;
   GLfloat MaxShininess;            /* GL_NV_light_max_exponent */
   GLfloat MaxSpotExponent;         /* GL_NV_light_max_exponent */
   GLuint MaxViewportWidth, MaxViewportHeight;
   struct gl_program_constants VertexProgram;    /* GL_ARB_vertex_program */
   struct gl_program_constants FragmentProgram;  /* GL_ARB_fragment_program */
   /* shared by vertex and fragment program: */
   GLuint MaxProgramMatrices;
   GLuint MaxProgramMatrixStackDepth;
   /* vertex array / buffer object bounds checking */
   GLboolean CheckArrayBounds;
   /* GL_ARB_draw_buffers */
   GLuint MaxDrawBuffers;
   /* GL_OES_read_format */
   GLenum ColorReadFormat;
   GLenum ColorReadType;
   /* GL_EXT_framebuffer_object */
   GLuint MaxColorAttachments;
   GLuint MaxRenderbufferSize;
   /* GL_ARB_vertex_shader */
   GLuint MaxVertexTextureImageUnits;
   GLuint MaxVarying;  
};


struct gl_extensions
{
   GLboolean dummy;  /* don't remove this! */
   GLboolean ARB_depth_texture;
   GLboolean ARB_draw_buffers;
   GLboolean ARB_fragment_program;
   GLboolean ARB_fragment_program_shadow;
   GLboolean ARB_fragment_shader;
   GLboolean ARB_half_float_pixel;
   GLboolean ARB_imaging;
   GLboolean ARB_multisample;
   GLboolean ARB_multitexture;
   GLboolean ARB_occlusion_query;
   GLboolean ARB_point_sprite;
   GLboolean ARB_shader_objects;
   GLboolean ARB_shading_language_100;
   GLboolean ARB_shading_language_120;
   GLboolean ARB_shadow;
   GLboolean ARB_texture_border_clamp;
   GLboolean ARB_texture_compression;
   GLboolean ARB_texture_cube_map;
   GLboolean ARB_texture_env_combine;
   GLboolean ARB_texture_env_crossbar;
   GLboolean ARB_texture_env_dot3;
   GLboolean ARB_texture_float;
   GLboolean ARB_texture_mirrored_repeat;
   GLboolean ARB_texture_non_power_of_two;
   GLboolean ARB_transpose_matrix;
   GLboolean ARB_vertex_buffer_object;
   GLboolean ARB_vertex_program;
   GLboolean ARB_vertex_shader;
   GLboolean ARB_window_pos;
   GLboolean EXT_abgr;
   GLboolean EXT_bgra;
   GLboolean EXT_blend_color;
   GLboolean EXT_blend_equation_separate;
   GLboolean EXT_blend_func_separate;
   GLboolean EXT_blend_logic_op;
   GLboolean EXT_blend_minmax;
   GLboolean EXT_blend_subtract;
   GLboolean EXT_clip_volume_hint;
   GLboolean EXT_cull_vertex;
   GLboolean EXT_convolution;
   GLboolean EXT_compiled_vertex_array;
   GLboolean EXT_copy_texture;
   GLboolean EXT_depth_bounds_test;
   GLboolean EXT_draw_range_elements;
   GLboolean EXT_framebuffer_object;
   GLboolean EXT_fog_coord;
   GLboolean EXT_framebuffer_blit;
   GLboolean EXT_gpu_program_parameters;
   GLboolean EXT_histogram;
   GLboolean EXT_multi_draw_arrays;
   GLboolean EXT_paletted_texture;
   GLboolean EXT_packed_depth_stencil;
   GLboolean EXT_packed_pixels;
   GLboolean EXT_pixel_buffer_object;
   GLboolean EXT_point_parameters;
   GLboolean EXT_polygon_offset;
   GLboolean EXT_rescale_normal;
   GLboolean EXT_shadow_funcs;
   GLboolean EXT_secondary_color;
   GLboolean EXT_separate_specular_color;
   GLboolean EXT_shared_texture_palette;
   GLboolean EXT_stencil_wrap;
   GLboolean EXT_stencil_two_side;
   GLboolean EXT_subtexture;
   GLboolean EXT_texture;
   GLboolean EXT_texture_object;
   GLboolean EXT_texture3D;
   GLboolean EXT_texture_compression_s3tc;
   GLboolean EXT_texture_env_add;
   GLboolean EXT_texture_env_combine;
   GLboolean EXT_texture_env_dot3;
   GLboolean EXT_texture_filter_anisotropic;
   GLboolean EXT_texture_lod_bias;
   GLboolean EXT_texture_mirror_clamp;
   GLboolean EXT_texture_sRGB;
   GLboolean EXT_timer_query;
   GLboolean EXT_vertex_array;
   GLboolean EXT_vertex_array_set;
   /* vendor extensions */
   GLboolean APPLE_client_storage;
   GLboolean APPLE_packed_pixels;
   GLboolean APPLE_vertex_array_object;
   GLboolean ATI_texture_mirror_once;
   GLboolean ATI_texture_env_combine3;
   GLboolean ATI_fragment_shader;
   GLboolean ATI_separate_stencil;
   GLboolean IBM_rasterpos_clip;
   GLboolean IBM_multimode_draw_arrays;
   GLboolean MESA_pack_invert;
   GLboolean MESA_packed_depth_stencil;
   GLboolean MESA_program_debug;
   GLboolean MESA_resize_buffers;
   GLboolean MESA_ycbcr_texture;
   GLboolean MESA_texture_array;
   GLboolean NV_blend_square;
   GLboolean NV_fragment_program;
   GLboolean NV_light_max_exponent;
   GLboolean NV_point_sprite;
   GLboolean NV_texgen_reflection;
   GLboolean NV_texture_rectangle;
   GLboolean NV_vertex_program;
   GLboolean NV_vertex_program1_1;
   GLboolean OES_read_format;
   GLboolean SGI_color_matrix;
   GLboolean SGI_color_table;
   GLboolean SGI_texture_color_table;
   GLboolean SGIS_generate_mipmap;
   GLboolean SGIS_texture_edge_clamp;
   GLboolean SGIS_texture_lod;
   GLboolean SGIX_shadow;
   GLboolean SGIX_shadow_ambient; /* or GL_ARB_shadow_ambient */
   GLboolean TDFX_texture_compression_FXT1;
   GLboolean S3_s3tc;
   /* The extension string */
   const GLubyte *String;
};


struct gl_matrix_stack
{
   GLmatrix *Top;      
   GLmatrix *Stack;    
   GLuint Depth;       
   GLuint MaxDepth;    
   GLuint DirtyFlag;   
};


#define IMAGE_SCALE_BIAS_BIT                      0x1
#define IMAGE_SHIFT_OFFSET_BIT                    0x2
#define IMAGE_MAP_COLOR_BIT                       0x4
#define IMAGE_COLOR_TABLE_BIT                     0x8
#define IMAGE_CONVOLUTION_BIT                     0x10
#define IMAGE_POST_CONVOLUTION_SCALE_BIAS         0x20
#define IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT    0x40
#define IMAGE_COLOR_MATRIX_BIT                    0x80
#define IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT   0x100
#define IMAGE_HISTOGRAM_BIT                       0x200
#define IMAGE_MIN_MAX_BIT                         0x400
#define IMAGE_CLAMP_BIT                           0x800 /* extra */


#define IMAGE_PRE_CONVOLUTION_BITS (IMAGE_SCALE_BIAS_BIT |     \
                                    IMAGE_SHIFT_OFFSET_BIT |   \
                                    IMAGE_MAP_COLOR_BIT |      \
                                    IMAGE_COLOR_TABLE_BIT)

#define IMAGE_POST_CONVOLUTION_BITS (IMAGE_POST_CONVOLUTION_SCALE_BIAS |      \
                                     IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT | \
                                     IMAGE_COLOR_MATRIX_BIT |                 \
                                     IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT |\
                                     IMAGE_HISTOGRAM_BIT |                    \
                                     IMAGE_MIN_MAX_BIT)

#define _NEW_MODELVIEW      0x1        
#define _NEW_PROJECTION     0x2        
#define _NEW_TEXTURE_MATRIX 0x4        
#define _NEW_COLOR_MATRIX   0x8        
#define _NEW_ACCUM      0x10       
#define _NEW_COLOR      0x20       
#define _NEW_DEPTH      0x40       
#define _NEW_EVAL       0x80       
#define _NEW_FOG        0x100      
#define _NEW_HINT       0x200      
#define _NEW_LIGHT      0x400      
#define _NEW_LINE       0x800      
#define _NEW_PIXEL      0x1000     
#define _NEW_POINT      0x2000     
#define _NEW_POLYGON        0x4000     
#define _NEW_POLYGONSTIPPLE 0x8000     
#define _NEW_SCISSOR        0x10000    
#define _NEW_STENCIL        0x20000    
#define _NEW_TEXTURE        0x40000    
#define _NEW_TRANSFORM      0x80000    
#define _NEW_VIEWPORT       0x100000   
#define _NEW_PACKUNPACK     0x200000   
#define _NEW_ARRAY          0x400000   
#define _NEW_RENDERMODE     0x800000   
#define _NEW_BUFFERS            0x1000000  
#define _NEW_MULTISAMPLE        0x2000000  
#define _NEW_TRACK_MATRIX       0x4000000  
#define _NEW_PROGRAM            0x8000000  
#define _NEW_ALL ~0

#define _NEW_ARRAY_VERTEX           VERT_BIT_POS
#define _NEW_ARRAY_WEIGHT           VERT_BIT_WEIGHT
#define _NEW_ARRAY_NORMAL           VERT_BIT_NORMAL
#define _NEW_ARRAY_COLOR0           VERT_BIT_COLOR0
#define _NEW_ARRAY_COLOR1           VERT_BIT_COLOR1
#define _NEW_ARRAY_FOGCOORD         VERT_BIT_FOG
#define _NEW_ARRAY_INDEX            VERT_BIT_COLOR_INDEX
#define _NEW_ARRAY_EDGEFLAG         VERT_BIT_EDGEFLAG
#define _NEW_ARRAY_POINT_SIZE       VERT_BIT_COLOR_INDEX  /* aliased */
#define _NEW_ARRAY_TEXCOORD_0       VERT_BIT_TEX0
#define _NEW_ARRAY_TEXCOORD_1       VERT_BIT_TEX1
#define _NEW_ARRAY_TEXCOORD_2       VERT_BIT_TEX2
#define _NEW_ARRAY_TEXCOORD_3       VERT_BIT_TEX3
#define _NEW_ARRAY_TEXCOORD_4       VERT_BIT_TEX4
#define _NEW_ARRAY_TEXCOORD_5       VERT_BIT_TEX5
#define _NEW_ARRAY_TEXCOORD_6       VERT_BIT_TEX6
#define _NEW_ARRAY_TEXCOORD_7       VERT_BIT_TEX7
#define _NEW_ARRAY_ATTRIB_0         VERT_BIT_GENERIC0  /* start at bit 16 */
#define _NEW_ARRAY_ALL              0xffffffff


#define _NEW_ARRAY_TEXCOORD(i) (_NEW_ARRAY_TEXCOORD_0 << (i))
#define _NEW_ARRAY_ATTRIB(i) (_NEW_ARRAY_ATTRIB_0 << (i))

#define DD_FLATSHADE                0x1
#define DD_SEPARATE_SPECULAR        0x2
#define DD_TRI_CULL_FRONT_BACK      0x4 /* special case on some hw */
#define DD_TRI_LIGHT_TWOSIDE        0x8
#define DD_TRI_UNFILLED             0x10
#define DD_TRI_SMOOTH               0x20
#define DD_TRI_STIPPLE              0x40
#define DD_TRI_OFFSET               0x80
#define DD_LINE_SMOOTH              0x100
#define DD_LINE_STIPPLE             0x200
#define DD_LINE_WIDTH               0x400
#define DD_POINT_SMOOTH             0x800
#define DD_POINT_SIZE               0x1000
#define DD_POINT_ATTEN              0x2000
#define DD_TRI_TWOSTENCIL           0x4000

#define _DD_NEW_FLATSHADE                _NEW_LIGHT
#define _DD_NEW_SEPARATE_SPECULAR        (_NEW_LIGHT | _NEW_FOG | _NEW_PROGRAM)
#define _DD_NEW_TRI_CULL_FRONT_BACK      _NEW_POLYGON
#define _DD_NEW_TRI_LIGHT_TWOSIDE        _NEW_LIGHT
#define _DD_NEW_TRI_UNFILLED             _NEW_POLYGON
#define _DD_NEW_TRI_SMOOTH               _NEW_POLYGON
#define _DD_NEW_TRI_STIPPLE              _NEW_POLYGON
#define _DD_NEW_TRI_OFFSET               _NEW_POLYGON
#define _DD_NEW_LINE_SMOOTH              _NEW_LINE
#define _DD_NEW_LINE_STIPPLE             _NEW_LINE
#define _DD_NEW_LINE_WIDTH               _NEW_LINE
#define _DD_NEW_POINT_SMOOTH             _NEW_POINT
#define _DD_NEW_POINT_SIZE               _NEW_POINT
#define _DD_NEW_POINT_ATTEN              _NEW_POINT

#define _MESA_NEW_NEED_EYE_COORDS         (_NEW_LIGHT |     \
                                           _NEW_TEXTURE |   \
                                           _NEW_POINT |     \
                                           _NEW_PROGRAM |   \
                                           _NEW_MODELVIEW)

#define _MESA_NEW_NEED_NORMALS            (_NEW_LIGHT |     \
                                           _NEW_TEXTURE)

#define _IMAGE_NEW_TRANSFER_STATE         (_NEW_PIXEL | _NEW_COLOR_MATRIX)




/*
 * Forward declaration of display list data types:
 */
union node;
typedef union node Node;


/* This has to be included here. */
#include "dd.h"


#define NUM_VERTEX_FORMAT_ENTRIES (sizeof(GLvertexformat) / sizeof(void *))

struct gl_tnl_module
{
   const GLvertexformat *Current;

   struct {
       _glapi_proc * location;
       _glapi_proc function;
   } Swapped[NUM_VERTEX_FORMAT_ENTRIES];
   GLuint SwapCount;
};

/* Strictly this is a tnl/ private concept, but it doesn't seem
 * worthwhile adding a tnl private structure just to hold this one bit
 * of information:
 */
#define MESA_DLIST_DANGLING_REFS     0x1 

/* Provide a location where information about a display list can be
 * collected.  Could be extended with driverPrivate structures,
 * etc. in the future.
 */
struct mesa_display_list
{
   Node *node;
   GLuint id;
   GLbitfield flags;
};


struct gl_dlist_state
{
   GLuint CallDepth;        
   struct mesa_display_list *CurrentList;
   Node *CurrentListPtr;    
   GLuint CurrentListNum;   
   Node *CurrentBlock;      
   GLuint CurrentPos;       
   GLvertexformat ListVtxfmt;

   GLubyte ActiveAttribSize[VERT_ATTRIB_MAX];
   GLfloat CurrentAttrib[VERT_ATTRIB_MAX][4];
   
   GLubyte ActiveMaterialSize[MAT_ATTRIB_MAX];
   GLfloat CurrentMaterial[MAT_ATTRIB_MAX][4];

   GLubyte ActiveIndex;
   GLfloat CurrentIndex;
   
   GLubyte ActiveEdgeFlag;
   GLboolean CurrentEdgeFlag;
};


struct __GLcontextRec
{
   struct gl_shared_state *Shared;

   struct _glapi_table *Save;   
   struct _glapi_table *Exec;   
   struct _glapi_table *CurrentDispatch;  

   GLvisual Visual;
   GLframebuffer *DrawBuffer;   
   GLframebuffer *ReadBuffer;   
   GLframebuffer *WinSysDrawBuffer;  
   GLframebuffer *WinSysReadBuffer;  
   struct dd_function_table Driver;

   void *DriverCtx; 
   struct gl_constants Const;

   struct gl_matrix_stack ModelviewMatrixStack;
   struct gl_matrix_stack ProjectionMatrixStack;
   struct gl_matrix_stack ColorMatrixStack;
   struct gl_matrix_stack TextureMatrixStack[MAX_TEXTURE_UNITS];
   struct gl_matrix_stack ProgramMatrixStack[MAX_PROGRAM_MATRICES];
   struct gl_matrix_stack *CurrentStack; 

   GLmatrix _ModelProjectMatrix;

   struct gl_dlist_state ListState;

   GLboolean ExecuteFlag;   
   GLboolean CompileFlag;   
   struct gl_extensions Extensions;

   GLuint AttribStackDepth;
   struct gl_attrib_node *AttribStack[MAX_ATTRIB_STACK_DEPTH];
   struct gl_accum_attrib   Accum;      
   struct gl_colorbuffer_attrib Color;      
   struct gl_current_attrib Current;    
   struct gl_depthbuffer_attrib Depth;      
   struct gl_eval_attrib    Eval;       
   struct gl_fog_attrib     Fog;        
   struct gl_hint_attrib    Hint;       
   struct gl_light_attrib   Light;      
   struct gl_line_attrib    Line;       
   struct gl_list_attrib    List;       
   struct gl_multisample_attrib Multisample;
   struct gl_pixel_attrib   Pixel;      
   struct gl_point_attrib   Point;      
   struct gl_polygon_attrib Polygon;    
   GLuint PolygonStipple[32];           
   struct gl_scissor_attrib Scissor;    
   struct gl_stencil_attrib Stencil;    
   struct gl_texture_attrib Texture;    
   struct gl_transform_attrib   Transform;  
   struct gl_viewport_attrib    Viewport;   

   GLuint ClientAttribStackDepth;
   struct gl_attrib_node *ClientAttribStack[MAX_CLIENT_ATTRIB_STACK_DEPTH];
   struct gl_array_attrib   Array;  
   struct gl_pixelstore_attrib  Pack;   
   struct gl_pixelstore_attrib  Unpack; 
   struct gl_pixelstore_attrib  DefaultPacking; 

   struct gl_pixelmaps          PixelMaps;
   struct gl_histogram_attrib   Histogram;
   struct gl_minmax_attrib  MinMax;
   struct gl_convolution_attrib Convolution1D;
   struct gl_convolution_attrib Convolution2D;
   struct gl_convolution_attrib Separable2D;

   struct gl_evaluators EvalMap;   
   struct gl_feedback   Feedback;  
   struct gl_selection  Select;    
   struct gl_color_table ColorTable[COLORTABLE_MAX];
   struct gl_color_table ProxyColorTable[COLORTABLE_MAX];
#if 0
   struct gl_color_table PostConvolutionColorTable;
   struct gl_color_table ProxyPostConvolutionColorTable;
   struct gl_color_table PostColorMatrixColorTable;
   struct gl_color_table ProxyPostColorMatrixColorTable;
#endif

   struct gl_program_state Program;        
   struct gl_vertex_program_state VertexProgram;   
   struct gl_fragment_program_state FragmentProgram;  
   struct gl_ati_fragment_shader_state ATIFragmentShader;  
   struct gl_query_state Query;  
   struct gl_shader_state Shader; 

#if FEATURE_EXT_framebuffer_object
   struct gl_renderbuffer *CurrentRenderbuffer;
#endif

   GLenum ErrorValue;        
   GLenum RenderMode;        
   GLbitfield NewState;      
   GLbitfield _TriangleCaps;
   GLbitfield _ImageTransferState;
   GLfloat _EyeZDir[3];
   GLfloat _ModelViewInvScale;
   GLboolean _NeedEyeCoords;
   GLboolean _ForceEyeCoords; 
   GLenum _CurrentProgram;    /* currently executing program */

   GLuint TextureStateTimestamp; /* detect changes to shared state */

   struct gl_shine_tab *_ShineTable[2]; 
   struct gl_shine_tab *_ShineTabList;  
   struct gl_list_extensions ListExt; 
   GLboolean FirstTimeCurrent;
   GLboolean NoDither;

   GLboolean Mesa_DXTn;

   struct gl_tnl_module TnlModule;

   void *swrast_context;
   void *swsetup_context;
   void *swtnl_context;
   void *swtnl_im;
   void *acache_context;
   void *aelt_context;
};


extern const char *_mesa_prim_name[GL_POLYGON+4];


#ifdef DEBUG
extern int MESA_VERBOSE;
extern int MESA_DEBUG_FLAGS;
# define MESA_FUNCTION __FUNCTION__
#else
# define MESA_VERBOSE 0
# define MESA_DEBUG_FLAGS 0
# define MESA_FUNCTION "a function"
# ifndef NDEBUG
#  define NDEBUG
# endif
#endif


enum _verbose
{
   VERBOSE_VARRAY       = 0x0001,
   VERBOSE_TEXTURE      = 0x0002,
   VERBOSE_IMMEDIATE        = 0x0004,
   VERBOSE_PIPELINE     = 0x0008,
   VERBOSE_DRIVER       = 0x0010,
   VERBOSE_STATE        = 0x0020,
   VERBOSE_API          = 0x0040,
   VERBOSE_DISPLAY_LIST     = 0x0100,
   VERBOSE_LIGHTING     = 0x0200,
   VERBOSE_PRIMS        = 0x0400,
   VERBOSE_VERTS        = 0x0800,
   VERBOSE_DISASSEM     = 0x1000,
   VERBOSE_GLSL         = 0x2000,
   VERBOSE_GLSL_DUMP        = 0x4000
};


enum _debug
{
   DEBUG_ALWAYS_FLUSH       = 0x1
};



#define Elements(x) sizeof(x)/sizeof(*(x))


#endif /* TYPES_H */