#ifndef TYPES_H
#define TYPES_H
#include "glheader.h"
#include <GL/internal/glcore.h>
#include "config.h"
#include "glapi/glapitable.h"
#include "glapi/glthread.h"
#include "math/m_matrix.h"
#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;
#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_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_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,
BUFFER_BACK_LEFT = 1,
BUFFER_FRONT_RIGHT = 2,
BUFFER_BACK_RIGHT = 3,
BUFFER_AUX0 = 4,
BUFFER_AUX1 = 5,
BUFFER_AUX2 = 6,
BUFFER_AUX3 = 7,
BUFFER_DEPTH = 8,
BUFFER_STENCIL = 9,
BUFFER_ACCUM = 10,
BUFFER_COLOR0 = 11,
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_COORD_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];
GLboolean Map2Color4;
GLboolean Map2Index;
GLboolean Map2Normal;
GLboolean Map2TextureCoord1;
GLboolean Map2TextureCoord2;
GLboolean Map2TextureCoord3;
GLboolean Map2TextureCoord4;
GLboolean Map2Vertex3;
GLboolean Map2Vertex4;
GLboolean Map2Attrib[16];
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;
GLboolean MultisampleEnabled;
GLboolean SampleAlphaToCoverage;
GLboolean SampleAlphaToOne;
GLboolean SampleCoverage;
GLboolean SampleCoverageInvert;
GLboolean RasterPositionUnclipped;
GLuint Texture[MAX_TEXTURE_IMAGE_UNITS];
GLuint TexGen[MAX_TEXTURE_COORD_UNITS];
GLboolean TextureColorTable[MAX_TEXTURE_IMAGE_UNITS];
GLboolean VertexProgram;
GLboolean VertexProgramPointSize;
GLboolean VertexProgramTwoSide;
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];
GLboolean Map2Color4;
GLboolean Map2Index;
GLboolean Map2Normal;
GLboolean Map2TextureCoord1;
GLboolean Map2TextureCoord2;
GLboolean Map2TextureCoord3;
GLboolean Map2TextureCoord4;
GLboolean Map2Vertex3;
GLboolean Map2Vertex4;
GLboolean Map2Attrib[16];
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;
GLfloat RedBias, RedScale;
GLfloat GreenBias, GreenScale;
GLfloat BlueBias, BlueScale;
GLfloat AlphaBias, AlphaScale;
GLfloat DepthBias, DepthScale;
GLint IndexShift, IndexOffset;
GLboolean MapColorFlag;
GLboolean MapStencilFlag;
GLboolean ColorTableEnabled[COLORTABLE_MAX];
GLfloat ColorTableScale[COLORTABLE_MAX][4];
GLfloat ColorTableBias[COLORTABLE_MAX][4];
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];
GLfloat PostColorMatrixScale[4];
GLfloat PostColorMatrixBias[4];
GLboolean HistogramEnabled;
GLboolean MinMaxEnabled;
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_COORD_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;
GLenum Function[2];
GLenum FailFunc[2];
GLenum ZPassFunc[2];
GLenum ZFailFunc[2];
GLint Ref[2];
GLuint ValueMask[2];
GLuint WriteMask[2];
GLuint Clear;
};
#define NUM_TEXTURE_TARGETS 7
#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)
#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
#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;
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 *Current1D;
struct gl_texture_object *Current2D;
struct gl_texture_object *Current3D;
struct gl_texture_object *CurrentCubeMap;
struct gl_texture_object *CurrentRect;
struct gl_texture_object *Current1DArray;
struct gl_texture_object *Current2DArray;
struct gl_texture_object *_Current;
struct gl_color_table ColorTable;
struct gl_color_table ProxyColorTable;
GLboolean ColorTableEnabled;
};
struct texenvprog_cache_item;
struct texenvprog_cache
{
struct texenvprog_cache_item **items;
GLuint size, n_items;
GLcontext *ctx;
};
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 texenvprog_cache env_fp_cache;
};
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 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;
};
struct gl_feedback
{
GLenum Type;
GLbitfield _Mask;
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 TexturesUsed[MAX_TEXTURE_IMAGE_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;
};
struct gl_program_state
{
GLint ErrorPos;
const char *ErrorString;
};
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];
GLenum TrackMatrix[MAX_PROGRAM_ENV_PARAMS / 4];
GLenum TrackMatrixTransform[MAX_PROGRAM_ENV_PARAMS / 4];
GLboolean _MaintainTnlProgram;
struct gl_vertex_program *_TnlProgram;
#if FEATURE_MESA_program_debug
GLprogramcallbackMESA Callback;
GLvoid *CallbackData;
GLboolean CallbackEnabled;
GLuint CurrentPosition;
#endif
};
struct gl_fragment_program_state
{
GLboolean Enabled;
GLboolean _Enabled;
GLboolean _Active;
struct gl_fragment_program *Current;
struct gl_fragment_program *_Current;
GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4];
GLboolean _MaintainTexEnvProgram;
GLboolean _UseTexEnvProgram;
struct gl_fragment_program *_TexEnvProgram;
#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
{
GLuint Id;
GLuint64EXT Result;
GLboolean Active;
GLboolean Ready;
};
struct gl_query_state
{
struct _mesa_HashTable *QueryObjects;
struct gl_query_object *CurrentOcclusionObject;
struct gl_query_object *CurrentTimerObject;
};
struct gl_shader
{
GLenum Type;
GLuint Name;
GLint RefCount;
GLboolean DeletePending;
const GLchar *Source;
GLboolean CompileStatus;
struct gl_program *Program;
GLchar *InfoLog;
GLboolean Main;
};
struct gl_shader_program
{
GLenum Type;
GLuint Name;
GLint RefCount;
GLboolean DeletePending;
GLuint NumShaders;
struct gl_shader **Shaders;
struct gl_program_parameter_list *Attributes;
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 *Default1D;
struct gl_texture_object *Default2D;
struct gl_texture_object *Default3D;
struct gl_texture_object *DefaultCubeMap;
struct gl_texture_object *DefaultRect;
struct gl_texture_object *Default1DArray;
struct gl_texture_object *Default2DArray;
_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;
struct gl_renderbuffer *Wrapped;
void (*Delete)(struct gl_renderbuffer *rb);
GLboolean (*AllocStorage)(GLcontext *ctx, struct gl_renderbuffer *rb,
GLenum internalFormat,
GLuint width, GLuint height);
void *(*GetPointer)(GLcontext *ctx, struct gl_renderbuffer *rb,
GLint x, GLint y);
void (*GetRow)(GLcontext *ctx, struct gl_renderbuffer *rb, GLuint count,
GLint x, GLint y, void *values);
void (*GetValues)(GLcontext *ctx, struct gl_renderbuffer *rb, GLuint count,
const GLint x[], const GLint y[], void *values);
void (*PutRow)(GLcontext *ctx, struct gl_renderbuffer *rb, GLuint count,
GLint x, GLint y, const void *values, const GLubyte *mask);
void (*PutRowRGB)(GLcontext *ctx, struct gl_renderbuffer *rb, GLuint count,
GLint x, GLint y, const void *values, const GLubyte *mask);
void (*PutMonoRow)(GLcontext *ctx, struct gl_renderbuffer *rb, GLuint count,
GLint x, GLint y, const void *value, const GLubyte *mask);
void (*PutValues)(GLcontext *ctx, struct gl_renderbuffer *rb, GLuint count,
const GLint x[], const GLint y[], const void *values,
const GLubyte *mask);
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;
struct gl_renderbuffer_attachment Attachment[BUFFER_COUNT];
GLenum ColorDrawBuffer[MAX_DRAW_BUFFERS];
GLenum ColorReadBuffer;
GLuint _NumColorDrawBuffers;
GLint _ColorDrawBufferIndexes[MAX_DRAW_BUFFERS];
GLint _ColorReadBufferIndex;
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
{
GLuint MaxInstructions;
GLuint MaxAluInstructions;
GLuint MaxTexInstructions;
GLuint MaxTexIndirections;
GLuint MaxAttribs;
GLuint MaxTemps;
GLuint MaxAddressRegs;
GLuint MaxParameters;
GLuint MaxLocalParams;
GLuint MaxEnvParams;
GLuint MaxNativeInstructions;
GLuint MaxNativeAluInstructions;
GLuint MaxNativeTexInstructions;
GLuint MaxNativeTexIndirections;
GLuint MaxNativeAttribs;
GLuint MaxNativeTemps;
GLuint MaxNativeAddressRegs;
GLuint MaxNativeParameters;
GLuint MaxUniformComponents;
};
struct gl_constants
{
GLint MaxTextureLevels;
GLint Max3DTextureLevels;
GLint MaxCubeTextureLevels;
GLint MaxArrayTextureLayers;
GLint MaxTextureRectSize;
GLuint MaxTextureCoordUnits;
GLuint MaxTextureImageUnits;
GLuint MaxTextureUnits;
GLfloat MaxTextureMaxAnisotropy;
GLfloat MaxTextureLodBias;
GLuint MaxArrayLockSize;
GLint SubPixelBits;
GLfloat MinPointSize, MaxPointSize;
GLfloat MinPointSizeAA, MaxPointSizeAA;
GLfloat PointSizeGranularity;
GLfloat MinLineWidth, MaxLineWidth;
GLfloat MinLineWidthAA, MaxLineWidthAA;
GLfloat LineWidthGranularity;
GLuint MaxColorTableSize;
GLuint MaxConvolutionWidth;
GLuint MaxConvolutionHeight;
GLuint MaxClipPlanes;
GLuint MaxLights;
GLfloat MaxShininess;
GLfloat MaxSpotExponent;
GLuint MaxViewportWidth, MaxViewportHeight;
struct gl_program_constants VertexProgram;
struct gl_program_constants FragmentProgram;
GLuint MaxProgramMatrices;
GLuint MaxProgramMatrixStackDepth;
GLboolean CheckArrayBounds;
GLuint MaxDrawBuffers;
GLenum ColorReadFormat;
GLenum ColorReadType;
GLuint MaxColorAttachments;
GLuint MaxRenderbufferSize;
GLuint MaxVertexTextureImageUnits;
GLuint MaxVarying;
};
struct gl_extensions
{
GLboolean dummy;
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;
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_depth_texture;
GLboolean SGIX_shadow;
GLboolean SGIX_shadow_ambient;
GLboolean TDFX_texture_compression_FXT1;
GLboolean S3_s3tc;
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
#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_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
#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
#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)
union node;
typedef union node Node;
#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;
};
#define MESA_DLIST_DANGLING_REFS 0x1
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_COORD_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;
GLuint TextureStateTimestamp;
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