#ifndef __glattrib_h_ #define __glattrib_h_ /* ** Copyright 1991, Silicon Graphics, Inc. ** All Rights Reserved. ** ** This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.; ** the contents of this file may not be disclosed to third parties, copied or ** duplicated in any form, in whole or in part, without the prior written ** permission of Silicon Graphics, Inc. ** ** RESTRICTED RIGHTS LEGEND: ** Use, duplication or disclosure by the Government is subject to restrictions ** as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data ** and Computer Software clause at DFARS 252.227-7013, and/or in similar or ** successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished - ** rights reserved under the Copyright Laws of the United States. ** ** $Revision: 1.14 $ ** $Date: 1993/10/07 18:34:31 $ */ #include "lighting.h" #include "pixel.h" #include "texture.h" #include "eval.h" #include "vertex.h" #include "glarray.h" typedef struct __GLcurrentStateRec { __GLvertex rasterPos; /* ** Raster pos valid bit. */ GLboolean validRasterPos; /* ** Edge tag state. */ GLboolean edgeTag; /* ** Current color and colorIndex. These variables are also used for ** the current rasterPos color and colorIndex as set by the user. */ __GLcolor userColor; __GLfloat userColorIndex; __GLcoord normal; __GLcoord texture; } __GLcurrentState; /************************************************************************/ typedef struct __GLpointStateRec { __GLfloat requestedSize; __GLfloat smoothSize; GLint aliasedSize; } __GLpointState; /************************************************************************/ /* ** Line state. Contains all the client controllable line state. */ typedef struct { __GLfloat requestedWidth; __GLfloat smoothWidth; GLint aliasedWidth; GLushort stipple; GLshort stippleRepeat; } __GLlineState; /************************************************************************/ /* ** Polygon state. Contains all the user controllable polygon state ** except for the stipple state. */ typedef struct __GLpolygonStateRec { GLenum frontMode; GLenum backMode; /* ** Culling state. Culling can be enabled/disabled and set to cull ** front or back faces. The FrontFace call determines whether clockwise ** or counter-clockwise oriented vertices are front facing. */ GLenum cull; GLenum frontFaceDirection; /* ** Polygon offset state */ __GLfloat factor; __GLfloat units; } __GLpolygonState; /************************************************************************/ /* ** Polygon stipple state. */ typedef struct __GLpolygonStippleStateRec { GLubyte stipple[4*32]; } __GLpolygonStippleState; /************************************************************************/ typedef struct __GLfogStateRec { GLenum mode; #ifdef NT GLuint flags; #endif __GLcolor color; #ifdef NT __GLfloat density2neg; #endif __GLfloat density, start, end; __GLfloat oneOverEMinusS; __GLfloat index; } __GLfogState; // fog flags // __GL_FOG_GRAY_RGB is set when the clamped and scaled fog color contains // identical R, G, and B values #define __GL_FOG_GRAY_RGB 0x0001 /************************************************************************/ /* ** Depth state. Contains all the user settable depth state. */ typedef struct __GLdepthStateRec __GLdepthState; struct __GLdepthStateRec { /* ** Depth buffer test function. The z value is compared using zFunction ** against the current value in the zbuffer. If the comparison ** succeeds the new z value is written into the z buffer masked ** by the z write mask. */ GLenum testFunc; /* ** Writemask enable. When GL_TRUE writing to the depth buffer is ** allowed. */ GLboolean writeEnable; /* ** Value used to clear the z buffer when glClear is called. */ GLdouble clear; }; /************************************************************************/ typedef struct __GLaccumStateRec { __GLcolor clear; } __GLaccumState; /************************************************************************/ /* ** Stencil state. Contains all the user settable stencil state. */ typedef struct __GLstencilStateRec { /* ** Stencil test function. When the stencil is enabled this ** function is applied to the reference value and the stored stencil ** value as follows: ** result = ref comparision (mask & stencilBuffer[x][y]) ** If the test fails then the fail op is applied and rendering of ** the pixel stops. */ GLenum testFunc; /* ** Stencil clear value. Used by glClear. */ GLshort clear; /* ** Reference stencil value. */ GLshort reference; /* ** Stencil mask. This is anded against the contents of the stencil ** buffer during comparisons. */ GLshort mask; /* ** Stencil write mask */ GLshort writeMask; /* ** When the stencil comparison fails this operation is applied to ** the stencil buffer. */ GLenum fail; /* ** When the stencil comparison passes and the depth test ** fails this operation is applied to the stencil buffer. */ GLenum depthFail; /* ** When both the stencil comparison passes and the depth test ** passes this operation is applied to the stencil buffer. */ GLenum depthPass; } __GLstencilState; /************************************************************************/ typedef struct __GLviewportRec { /* ** Viewport parameters from user, as integers. */ GLint x, y; GLsizei width, height; /* ** Depthrange parameters from user. */ GLdouble zNear, zFar; /*XXX move me */ /* ** Internal form of viewport and depth range used to compute ** window coordinates from clip coordinates. */ __GLfloat xScale, xCenter; __GLfloat yScale, yCenter; __GLfloat zScale, zCenter; } __GLviewport; /************************************************************************/ typedef struct __GLtransformStateRec { /* ** Current mode of the matrix stack. This determines what effect ** the various matrix operations (load, mult, scale) apply to. */ GLenum matrixMode; /* ** User clipping planes in eye space. These are the user clip planes ** projected into eye space. */ /* XXX BUG! stacking of eyeClipPlanes is busted! */ __GLcoord *eyeClipPlanes; __GLcoord *eyeClipPlanesSet; } __GLtransformState; /************************************************************************/ /* ** Enable structures. Anything that can be glEnable'd or glDisable'd is ** contained in this structure. The enables are kept as single bits ** in a couple of bitfields. */ /* Bits in "general" enable word */ #define __GL_ALPHA_TEST_ENABLE (1 << 0) #define __GL_BLEND_ENABLE (1 << 1) #define __GL_INDEX_LOGIC_OP_ENABLE (1 << 2) #define __GL_DITHER_ENABLE (1 << 3) #define __GL_DEPTH_TEST_ENABLE (1 << 4) #define __GL_FOG_ENABLE (1 << 5) #define __GL_LIGHTING_ENABLE (1 << 6) #define __GL_COLOR_MATERIAL_ENABLE (1 << 7) #define __GL_LINE_STIPPLE_ENABLE (1 << 8) #define __GL_LINE_SMOOTH_ENABLE (1 << 9) #define __GL_POINT_SMOOTH_ENABLE (1 << 10) #define __GL_POLYGON_SMOOTH_ENABLE (1 << 11) #define __GL_CULL_FACE_ENABLE (1 << 12) #define __GL_POLYGON_STIPPLE_ENABLE (1 << 13) #define __GL_SCISSOR_TEST_ENABLE (1 << 14) #define __GL_STENCIL_TEST_ENABLE (1 << 15) #define __GL_TEXTURE_1D_ENABLE (1 << 16) #define __GL_TEXTURE_2D_ENABLE (1 << 17) #define __GL_TEXTURE_GEN_S_ENABLE (1 << 18) #define __GL_TEXTURE_GEN_T_ENABLE (1 << 19) #define __GL_TEXTURE_GEN_R_ENABLE (1 << 20) #define __GL_TEXTURE_GEN_Q_ENABLE (1 << 21) #define __GL_NORMALIZE_ENABLE (1 << 22) #define __GL_AUTO_NORMAL_ENABLE (1 << 23) #define __GL_POLYGON_OFFSET_POINT_ENABLE (1 << 24) #define __GL_POLYGON_OFFSET_LINE_ENABLE (1 << 25) #define __GL_POLYGON_OFFSET_FILL_ENABLE (1 << 26) #define __GL_COLOR_LOGIC_OP_ENABLE (1 << 27) #ifdef GL_EXT_flat_paletted_lighting // NOTE: Not currently enabled, can be reused if necessary #define __GL_PALETTED_LIGHTING_ENABLE (1 << 28) #endif // GL_EXT_flat_paletted_lighting #ifdef GL_WIN_specular_fog #define __GL_FOG_SPEC_TEX_ENABLE (1 << 29) #endif //GL_WIN_specular_fog #ifdef GL_WIN_multiple_textures #define __GL_TEXCOMBINE_CLAMP_ENABLE (1 << 30) #endif // GL_WIN_multiple_textures /* ** Composities of the above bits for each glPushAttrib group that has ** multiple enables, except for those defined below */ #define __GL_COLOR_BUFFER_ENABLES \ (__GL_ALPHA_TEST_ENABLE | __GL_BLEND_ENABLE | __GL_INDEX_LOGIC_OP_ENABLE \ | __GL_DITHER_ENABLE | __GL_COLOR_LOGIC_OP_ENABLE) #define __GL_LIGHTING_ENABLES \ (__GL_LIGHTING_ENABLE | __GL_COLOR_MATERIAL_ENABLE) #define __GL_LINE_ENABLES \ (__GL_LINE_STIPPLE_ENABLE | __GL_LINE_SMOOTH_ENABLE) #define __GL_POLYGON_ENABLES \ (__GL_POLYGON_SMOOTH_ENABLE | __GL_CULL_FACE_ENABLE \ | __GL_POLYGON_STIPPLE_ENABLE | __GL_POLYGON_OFFSET_POINT_ENABLE \ | __GL_POLYGON_OFFSET_LINE_ENABLE | __GL_POLYGON_OFFSET_FILL_ENABLE) #define __GL_TEXTURE_ENABLES \ (__GL_TEXTURE_1D_ENABLE | __GL_TEXTURE_2D_ENABLE \ | __GL_TEXTURE_GEN_S_ENABLE | __GL_TEXTURE_GEN_T_ENABLE \ | __GL_TEXTURE_GEN_R_ENABLE | __GL_TEXTURE_GEN_Q_ENABLE) /* Bits in "eval1" enable word */ #define __GL_MAP1_VERTEX_3_ENABLE (1 << __GL_V3) #define __GL_MAP1_VERTEX_4_ENABLE (1 << __GL_V4) #define __GL_MAP1_COLOR_4_ENABLE (1 << __GL_C4) #define __GL_MAP1_INDEX_ENABLE (1 << __GL_I) #define __GL_MAP1_NORMAL_ENABLE (1 << __GL_N3) #define __GL_MAP1_TEXTURE_COORD_1_ENABLE (1 << __GL_T1) #define __GL_MAP1_TEXTURE_COORD_2_ENABLE (1 << __GL_T2) #define __GL_MAP1_TEXTURE_COORD_3_ENABLE (1 << __GL_T3) #define __GL_MAP1_TEXTURE_COORD_4_ENABLE (1 << __GL_T4) /* Bits in "eval2" enable word */ #define __GL_MAP2_VERTEX_3_ENABLE (1 << __GL_V3) #define __GL_MAP2_VERTEX_4_ENABLE (1 << __GL_V4) #define __GL_MAP2_COLOR_4_ENABLE (1 << __GL_C4) #define __GL_MAP2_INDEX_ENABLE (1 << __GL_I) #define __GL_MAP2_NORMAL_ENABLE (1 << __GL_N3) #define __GL_MAP2_TEXTURE_COORD_1_ENABLE (1 << __GL_T1) #define __GL_MAP2_TEXTURE_COORD_2_ENABLE (1 << __GL_T2) #define __GL_MAP2_TEXTURE_COORD_3_ENABLE (1 << __GL_T3) #define __GL_MAP2_TEXTURE_COORD_4_ENABLE (1 << __GL_T4) /* Bits in "clipPlanes" enable word */ #define __GL_CLIP_PLANE0_ENABLE (1 << 0) #define __GL_CLIP_PLANE1_ENABLE (1 << 1) #define __GL_CLIP_PLANE2_ENABLE (1 << 2) #define __GL_CLIP_PLANE3_ENABLE (1 << 3) #define __GL_CLIP_PLANE4_ENABLE (1 << 4) #define __GL_CLIP_PLANE5_ENABLE (1 << 5) /* Bits in "lights" enable word */ #define __GL_LIGHT0_ENABLE (1 << 0) #define __GL_LIGHT1_ENABLE (1 << 1) #define __GL_LIGHT2_ENABLE (1 << 2) #define __GL_LIGHT3_ENABLE (1 << 3) #define __GL_LIGHT4_ENABLE (1 << 4) #define __GL_LIGHT5_ENABLE (1 << 5) #define __GL_LIGHT6_ENABLE (1 << 6) #define __GL_LIGHT7_ENABLE (1 << 7) typedef struct __GLenableStateRec __GLenableState; struct __GLenableStateRec { GLuint general; GLuint lights; GLuint clipPlanes; GLushort eval1, eval2; }; /************************************************************************/ typedef struct __GLrasterStateRec __GLrasterState; struct __GLrasterStateRec { /* ** Alpha function. The alpha function is applied to the alpha color ** value and the reference value. If it fails then the pixel is ** not rendered. */ GLenum alphaFunction; __GLfloat alphaReference; /* ** Alpha blending source and destination factors. */ GLenum blendSrc; GLenum blendDst; /* ** Logic op. Logic op is only used during color index mode. */ GLenum logicOp; /* ** Color to fill the color portion of the framebuffer when clear ** is called. */ __GLcolor clear; __GLfloat clearIndex; /* ** Color index write mask. The color values are masked with this ** value when writing to the frame buffer so that only the bits set ** in the mask are changed in the frame buffer. */ GLint writeMask; /* ** RGB write masks. These booleans enable or disable writing of ** the r, g, b, and a components. */ GLboolean rMask, gMask, bMask, aMask; /* ** This state variable tracks which buffer(s) is being drawn into. */ GLenum drawBuffer; /* ** Draw buffer specified by user. May be different from drawBuffer ** above. If the user specifies GL_FRONT_LEFT, for example, then ** drawBuffer is set to GL_FRONT, and drawBufferReturn to ** GL_FRONT_LEFT. */ GLenum drawBufferReturn; }; /************************************************************************/ /* ** Hint state. Contains all the user controllable hint state. */ typedef struct { GLenum perspectiveCorrection; GLenum pointSmooth; GLenum lineSmooth; GLenum polygonSmooth; GLenum fog; #ifdef GL_WIN_phong_shading GLenum phong; #endif } __GLhintState; /************************************************************************/ /* ** All stackable list state. */ typedef struct __GLdlistStateRec { GLuint listBase; } __GLdlistState; /************************************************************************/ /* ** Scissor state from user. */ typedef struct __GLscissorRec { GLint scissorX, scissorY, scissorWidth, scissorHeight; } __GLscissor; /************************************************************************/ struct __GLattributeRec { /* ** Mask of which fields in this structure are valid. */ GLuint mask; __GLcurrentState current; __GLpointState point; __GLlineState line; __GLpolygonState polygon; __GLpolygonStippleState polygonStipple; __GLpixelState pixel; __GLlightState light; __GLfogState fog; __GLdepthState depth; __GLaccumState accum; __GLstencilState stencil; __GLviewport viewport; __GLtransformState transform; __GLenableState enables; __GLrasterState raster; __GLhintState hints; __GLevaluatorState evaluator; __GLdlistState list; __GLtextureState texture; __GLscissor scissor; }; /************************************************************************/ /* ** Attribution machine state. This manages the stack of attributes. */ typedef struct { /* ** Attribute stack. The attribute stack keeps track of the ** attributes that have been pushed. */ __GLattribute **stack; /* ** Attribute stack pointer. */ __GLattribute **stackPointer; } __GLattributeMachine; extern void FASTCALL __glFreeAttributeState(__GLcontext *gc); extern GLboolean FASTCALL __glCopyContext(__GLcontext *dst, const __GLcontext *src, GLuint mask); extern GLenum __glErrorCheckMaterial(GLenum face, GLenum p, GLfloat pv0); /************************************************************************/ // Client attribute states. typedef struct __GLclientAttributeRec { // Mask of which fields in this structure are valid. GLbitfield mask; __GLpixelPackMode pixelPackModes; __GLpixelUnpackMode pixelUnpackModes; __GLvertexArray vertexArray; } __GLclientAttribute; /* ** Client attribution machine state. This manages the stack of client ** attributes. */ typedef struct { /* ** Client attribute stack. The client attribute stack keeps track of the ** client attributes that have been pushed. */ __GLclientAttribute **stack; /* ** Client attribute stack pointer. */ __GLclientAttribute **stackPointer; } __GLclientAttributeMachine; extern void FASTCALL __glFreeClientAttributeState(__GLcontext *gc); extern GLuint FASTCALL __glInternalPopAttrib(__GLcontext *, GLboolean); extern GLuint FASTCALL __glInternalPopClientAttrib(__GLcontext *, GLboolean, GLboolean); #endif /* __glattrib_h_ */