windows-server-2003/multimedia/opengl/server/inc/context.h

#ifndef __glcontext_h_
#define __glcontext_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.
**
** Graphics context structures.
*/
#include "os.h"
#include "attrib.h"
#include "feedback.h"
#include "select.h"
#include "buffers.h"
#include "pixel.h"
#include "dlist.h"
#include "xform.h"
#include "render.h"
#include "oleauto.h"
#include "parray.h"
#include "procs.h"
#include "gldrv.h"
#include "glarray.h"

// Disable long to float conversion warning.  see also gencx.h
#pragma warning (disable:4244)

/*
** Mode and limit information for a context.  This information is
** kept around in the context so that values can be used during
** command execution, and for returning information about the
** context to the application.
*/
struct __GLcontextModesRec {
    GLboolean rgbMode;
    GLboolean colorIndexMode;
    GLboolean doubleBufferMode;
    GLboolean stereoMode;
    GLboolean haveAccumBuffer;
    GLboolean haveDepthBuffer;
    GLboolean haveStencilBuffer;

    /* The number of bits present in various buffers */
    GLint accumBits;
    GLint *auxBits;
    GLint depthBits;
    GLint stencilBits;
    GLint indexBits;
    GLint indexFractionBits;
    GLint redBits, greenBits, blueBits, alphaBits;
    GLuint redMask, greenMask, blueMask, alphaMask;
#ifdef NT
    GLuint allMask;
    GLuint rgbMask;
#endif
    GLint maxAuxBuffers;

    /* False if running from inside the X server */
    GLboolean isDirect;

    /* frame buffer level */
    GLint level;
};

/*
** Various constants.  Most of these will never change through the life
** of the context.
*/
typedef struct __GLcontextConstantsRec {
    /* Specific size limits */
    GLint numberOfLights;
    GLint numberOfClipPlanes;
    GLint numberOfTextures;
    GLint numberOfTextureEnvs;
    GLint maxViewportWidth;
    GLint maxViewportHeight;

#ifdef GL_WIN_multiple_textures
    /* Maximum number of current textures */
    GLuint numberOfCurrentTextures;
    GLenum texCombineNaturalClamp;
#endif // GL_WIN_multiple_textures

    /*
    ** Viewport offsets: These numbers are added to the viewport center
    ** values to adjust the computed window coordinates into a
    ** numerically well behaved space (fixed point represented in a
    ** floating point number).
    */
    GLint viewportXAdjust;
    GLint viewportYAdjust;
    __GLfloat fviewportXAdjust;
    __GLfloat fviewportYAdjust;

    /*
    ** These values are computed from viewportXAdjust when the context
    ** is created.  It is assumed that x and y are forced into the same
    ** fixed point range by viewportXAdjust and viewportYAdjust.
    **
    ** viewportEpsilon is computed as the smallest possible value that can
    ** be represented in that fixed point space.
    **
    ** viewportAlmostHalf is equal to 0.5 - viewportEpsilon.
    */
    __GLfloat viewportEpsilon;
    __GLfloat viewportAlmostHalf;

    /* Scales that bring colors values from 0.0 to 1.0 into internal range */
    __GLfloat redScale, blueScale, greenScale, alphaScale;

    /*
    ** Geometry of the current window.
    */
    GLint width, height;

    /*
    ** Size of the alpha lookup table for alpha testing, and conversion
    ** value to convert from scaled alpha to alpha to be used for lookup table.
    */
    GLint alphaTestSize;
    __GLfloat alphaTableConv;

    /*
    ** Random getable constants
    */
    GLint maxTextureSize;
    GLint maxMipMapLevel;
    GLint subpixelBits;
    GLint maxListNesting;
    __GLfloat pointSizeMinimum;
    __GLfloat pointSizeMaximum;
    __GLfloat pointSizeGranularity;
    __GLfloat lineWidthMinimum;
    __GLfloat lineWidthMaximum;
    __GLfloat lineWidthGranularity;
    GLint maxEvalOrder;
    GLint maxPixelMapTable;
    GLint maxAttribStackDepth;
    GLint maxClientAttribStackDepth;
    GLint maxNameStackDepth;

    /*
    ** GDI's Y is inverted.  These two constants help out.
    */
    GLboolean yInverted;
    GLint ySign;
} __GLcontextConstants;

/************************************************************************/

typedef enum __GLbeginModeEnum {
    __GL_NOT_IN_BEGIN = 0,
    __GL_IN_BEGIN = 1,
    __GL_NEED_VALIDATE = 2
} __GLbeginMode;

#ifdef NT_SERVER_SHARE_LISTS
//
// Information for tracking dlist locks so we know what to unlock during
// cleanup
//
typedef struct _DlLockEntry
{
    __GLdlist *dlist;
} DlLockEntry;

typedef struct _DlLockArray
{
    GLsizei nAllocated;
    GLsizei nFilled;
    DlLockEntry *pdleEntries;
} DlLockArray;
#endif

// Signature stamp for gc's.  Must be non-zero.
// Currently spells 'GLGC' in byte order.
#define GC_SIGNATURE 0x43474c47

struct __GLcontextRec {

    /************************************************************************/

    /*
    ** Initialization and signature flag.  If this flag is set to the
    ** gc signature value then the gc is initialized.
    ** This could be a simple bit flag except that having the signature
    ** is convenient for identifying gc's in memory during debugging.
    */
    GLuint gcSig;

    /************************************************************************/

    /*
    ** Stackable state.  All of the current user controllable state
    ** is resident here.
    */
    __GLattribute state;

    /************************************************************************/

    /*
    ** Unstackable State
    */

    /*
    ** Current glBegin mode.  Legal values are 0 (not in begin mode), 1
    ** (in beginMode), or 2 (not in begin mode, some validation is
    ** needed).  Because all state changing routines have to fetch this
    ** value, we have overloaded state validation into it.  There is
    ** special code in the __glim_Begin (for software renderers) which
    ** deals with validation.
    */
    __GLbeginMode beginMode;

    /* Current rendering mode */
    GLenum renderMode;

    /*
    ** Most recent error code, or GL_NO_ERROR if no error has occurred
    ** since the last glGetError.
    */
    GLint error;

    /*
    ** Mode information that describes the kind of buffers and rendering
    ** modes that this context manages.
    */
    __GLcontextModes modes;

    /* Implementation dependent constants */
    __GLcontextConstants constants;

    /* Feedback and select state */
    __GLfeedbackMachine feedback;

    __GLselectMachine select;

    /* Display list state */
    __GLdlistMachine dlist;

#ifdef NT
    /* Saved client side dispatch tables.  Used by display list. */
    GLCLTPROCTABLE savedCltProcTable;
    GLEXTPROCTABLE savedExtProcTable;
#endif

    /************************************************************************/

    /*
    ** The remaining state is used primarily by the software renderer.
    */

    /*
    ** Mask word for validation state to help guide the gc validation
    ** code.  Only operations which are largely expensive are broken
    ** out here.  See the #define's below for the values being used.
    */
    GLuint validateMask;

    /*
    ** Mask word of dirty bits.  Most routines just set the GENERIC bit to
    ** dirty, others may set more specific bits.  The list of bits is
    ** listed below.
    */
    GLuint dirtyMask;

    /* Current draw buffer, set by glDrawBuffer */
    __GLcolorBuffer *drawBuffer;

    /* Current read buffer, set by glReadBuffer */
    __GLcolorBuffer *readBuffer;

    /* Function pointers that are mode dependent */
    __GLprocs procs;

    /* Attribute stack state */
    __GLattributeMachine attributes;

    /* Client attribute stack state */
    __GLclientAttributeMachine clientAttributes;

    /* Machine structures defining software rendering "machine" state */
    __GLvertexMachine vertex;
    __GLlightMachine light;
    __GLtextureMachine texture;
    __GLevaluatorMachine eval;
    __GLtransformMachine transform;
    __GLlineMachine line;
    __GLpolygonMachine polygon;
    __GLpixelMachine pixel;
    __GLbufferMachine buffers;

#ifdef NT
    __GLfloat redClampTable[4];
    __GLfloat greenClampTable[4];
    __GLfloat blueClampTable[4];
    __GLfloat alphaClampTable[4];
    __GLfloat oneOverRedVertexScale;
    __GLfloat oneOverGreenVertexScale;
    __GLfloat oneOverBlueVertexScale;
    __GLfloat oneOverAlphaVertexScale;
    __GLfloat redVertexScale;
    __GLfloat greenVertexScale;
    __GLfloat blueVertexScale;
    __GLfloat alphaVertexScale;
    GLboolean vertexToBufferIdentity;
    __GLfloat redVertexToBufferScale;
    __GLfloat blueVertexToBufferScale;
    __GLfloat greenVertexToBufferScale;
    __GLfloat alphaVertexToBufferScale;
    GLuint textureKey;
    GLubyte *alphaTestFuncTable;
#endif

    /* Buffers */
    __GLcolorBuffer *front;
    __GLcolorBuffer *back;
    __GLcolorBuffer frontBuffer;
    __GLcolorBuffer backBuffer;
    __GLcolorBuffer *auxBuffer;
    __GLstencilBuffer stencilBuffer;
    __GLdepthBuffer depthBuffer;
    __GLaccumBuffer accumBuffer;

#ifdef NT
    // Temporary buffers allocated by the gc.  The abnormal process exit
    // code will release these buffers.
    void * apvTempBuf[6];
#endif // NT

#ifdef NT_SERVER_SHARE_LISTS
    DlLockArray dla;
#endif

#ifdef NT
    // TEB polyarray pointer for this thread.  It allows fast access to the
    // polyarray structure in the TEB equivalent to the GLTEB_CLTPOLYARRAY
    // macro.  This field is kept current in MakeCurrent.
    POLYARRAY *paTeb;

    // Vertex array client states
    __GLvertexArray vertexArray;

    // Saved vertex array state for execution of display-listed
    // vertex array calls
    __GLvertexArray savedVertexArray;

    __GLmatrix *mInv;
#endif // NT
};

#ifdef NT
// Associate the temporary buffer with the gc for abnormal process cleanup.
#define GC_TEMP_BUFFER_ALLOC(gc, pv)                                    \
        {                                                               \
            int _i;                                                     \
            for (_i = 0; _i < sizeof(gc->apvTempBuf)/sizeof(void *); _i++)\
            {                                                           \
                if (!gc->apvTempBuf[_i])                                \
                {                                                       \
                    gc->apvTempBuf[_i] = pv;                            \
                    break;                                              \
                }                                                       \
            }                                                           \
            ASSERTOPENGL(_i < sizeof(gc->apvTempBuf)/sizeof(void *),    \
                "gc->apvTempBuf overflows\n");                          \
        }

// Unassociate the temporary buffer with the gc.
#define GC_TEMP_BUFFER_FREE(gc, pv)                                     \
        {                                                               \
            int _i;                                                     \
            for (_i = 0; _i < sizeof(gc->apvTempBuf)/sizeof(void *); _i++)\
            {                                                           \
                if (gc->apvTempBuf[_i] == pv)                           \
                {                                                       \
                    gc->apvTempBuf[_i] = (void *) NULL;                 \
                    break;                                              \
                }                                                       \
            }                                                           \
            ASSERTOPENGL(_i < sizeof(gc->apvTempBuf)/sizeof(void *),    \
                "gc->apvTempBuf entry not found\n");                    \
        }

// Cleanup any temporary buffer allocated in gc in abnormal process exit.
#define GC_TEMP_BUFFER_EXIT_CLEANUP(gc)                                 \
        {                                                               \
            int _i;                                                     \
            for (_i = 0; _i < sizeof(gc->apvTempBuf)/sizeof(void *); _i++)\
            {                                                           \
                if (gc->apvTempBuf[_i])                                 \
                {                                                       \
                    WARNING("Abnormal process exit: free allocated buffers\n");\
                    gcTempFree(gc, gc->apvTempBuf[_i]);              \
                    gc->apvTempBuf[_i] = (void *) NULL;                 \
                }                                                       \
            }                                                           \
        }
#endif // NT

/*
** Bit values for the validateMask word
*/
#define __GL_VALIDATE_ALPHA_FUNC	0x00000001
#define __GL_VALIDATE_STENCIL_FUNC	0x00000002
#define __GL_VALIDATE_STENCIL_OP	0x00000004

/*
** Bit values for dirtyMask word.
**
** These are all for delayed validation.  There are a few things that do
** not trigger delayed validation.  They are:
**
** Matrix operations -- matrices are validated immediately.
** Material changes -- they also validate immediately.
** Color Material change -- validated immediately.
** Color Material enable -- validated immediately.
** Pixel Map changes -- no validation.
*/

/*
** All things not listed elsewhere.
*/
#define __GL_DIRTY_GENERIC		0x00000001

/*
** Line stipple, line stipple enable, line width, line smooth enable,
** line smooth hint.
*/
#define __GL_DIRTY_LINE			0x00000002

/*
** Polygon stipple, polygon stipple enable, polygon smooth enable, face
** culling, front face orientation, polygon mode, point smooth hint.
*/
#define __GL_DIRTY_POLYGON		0x00000004

/*
** Point smooth, point smooth hint, point width.
*/
#define __GL_DIRTY_POINT		0x00000008

/*
** Pixel store, pixel zoom, pixel transfer, (pixel maps don't cause
** validation), read buffer.
*/
#define __GL_DIRTY_PIXEL		0x00000010

/*
** Light, Light Model, lighting enable, lightx enable, (color material
** validates immediately), (NOT shade model -- it is generic), (color material
** enable validates immediately)
*/
#define __GL_DIRTY_LIGHTING		0x00000020

/*
** Polygon stipple
*/
#define __GL_DIRTY_POLYGON_STIPPLE	0x00000040

/*
** the depth mode has changed.  Need to update depth function pointers.
*/
#define	__GL_DIRTY_DEPTH		0x00000080

/*
** Need to update texture and function pointers.
*/
#define	__GL_DIRTY_TEXTURE      0x00000100

#define __GL_DIRTY_ALL			0x000001ff

/*
** Bit values for changes to material colors
**
** These values are shared with MCDMATERIAL_
*/
#define __GL_MATERIAL_AMBIENT		0x00000001
#define __GL_MATERIAL_DIFFUSE		0x00000002
#define __GL_MATERIAL_SPECULAR		0x00000004
#define __GL_MATERIAL_EMISSIVE		0x00000008
#define __GL_MATERIAL_SHININESS		0x00000010
#define __GL_MATERIAL_COLORINDEXES	0x00000020
#define __GL_MATERIAL_ALL		0x0000003f

#define __GL_DELAY_VALIDATE(gc)		      \
    ASSERTOPENGL((gc)->beginMode != __GL_IN_BEGIN, "Dirty state in begin\n"); \
    (gc)->beginMode = __GL_NEED_VALIDATE;     \
    (gc)->dirtyMask |= __GL_DIRTY_GENERIC

#define __GL_DELAY_VALIDATE_MASK(gc, mask)	\
    ASSERTOPENGL((gc)->beginMode != __GL_IN_BEGIN, "Dirty state in begin\n"); \
    (gc)->beginMode = __GL_NEED_VALIDATE;     	\
    (gc)->dirtyMask |= (mask)

#define __GL_CLAMP_CI(target, gc, r)                            \
{                                                               \
    if ((r) > (GLfloat)(gc)->frontBuffer.redMax) {              \
        GLfloat fraction;                                       \
        GLint integer;                                          \
                                                                \
        integer = (GLint) (r);                                  \
        fraction = (r) - (GLfloat) integer;                     \
        integer = integer & (GLint)(gc)->frontBuffer.redMax;    \
        target = (GLfloat) integer + fraction;                  \
    } else if ((r) < 0) {                                       \
        GLfloat fraction;                                       \
        GLint integer;                                          \
                                                                \
        integer = (GLint) __GL_FLOORF(r);                       \
        fraction = (r) - (GLfloat) integer;                     \
        integer = integer & (GLint)(gc)->frontBuffer.redMax;    \
        target = (GLfloat) integer + fraction;                  \
    } else {                                                    \
        target = r;                                             \
    }\
}

#define __GL_CHECK_CLAMP_CI(target, gc, flags, r)               \
{                                                               \
    if (((r) > (GLfloat)(gc)->frontBuffer.redMax) ||            \
        ((r) < 0))                                              \
        flags |= POLYARRAY_CLAMP_COLOR;                         \
    (target) = (r);                                             \
}

#define __GL_COLOR_CLAMP_INDEX_R(value)                                 \
    (((ULONG)((CASTINT(value) & 0x80000000)) >> 30) |                   \
     ((ULONG)(((CASTINT(gc->redVertexScale) - CASTINT(value)) & 0x80000000)) >> 31))	\

#define __GL_COLOR_CLAMP_INDEX_G(value)                                 \
    (((ULONG)((CASTINT(value) & 0x80000000)) >> 30) |                   \
     ((ULONG)(((CASTINT(gc->greenVertexScale) - CASTINT(value)) & 0x80000000)) >> 31))	\

#define __GL_COLOR_CLAMP_INDEX_B(value)                                 \
    (((ULONG)((CASTINT(value) & 0x80000000)) >> 30) |                   \
     ((ULONG)(((CASTINT(gc->blueVertexScale) - CASTINT(value)) & 0x80000000)) >> 31))	\

#define __GL_COLOR_CLAMP_INDEX_A(value)                                 \
    (((ULONG)((CASTINT(value) & 0x80000000)) >> 30) |                   \
     ((ULONG)(((CASTINT(gc->alphaVertexScale) - CASTINT(value)) & 0x80000000)) >> 31))  \

#define __GL_SCALE_R(target, gc, r)                                         \
    (target) = (r) * (gc)->redVertexScale

#define __GL_SCALE_G(target, gc, g)                                         \
    (target) = (g) * (gc)->greenVertexScale

#define __GL_SCALE_B(target, gc, b)                                         \
    (target) = (b) * (gc)->blueVertexScale

#define __GL_SCALE_A(target, gc, a)                                         \
    (target) = (a) * (gc)->alphaVertexScale

#define __GL_COLOR_CHECK_CLAMP_R(value, flags)                                 \
    (flags) |=                                                                 \
    ((ULONG)(CASTINT(value) & 0x80000000) |                                    \
     (ULONG)((CASTINT(gc->redVertexScale) - CASTINT(value)) & 0x80000000))

#define __GL_COLOR_CHECK_CLAMP_G(value, flags)                                 \
    (flags) |=                                                                 \
    ((ULONG)(CASTINT(value) & 0x80000000) |                                    \
     (ULONG)((CASTINT(gc->greenVertexScale) - CASTINT(value)) & 0x80000000))

#define __GL_COLOR_CHECK_CLAMP_B(value, flags)                                 \
    (flags) |=                                                                 \
    ((ULONG)(CASTINT(value) & 0x80000000) |                                    \
     (ULONG)((CASTINT(gc->blueVertexScale) - CASTINT(value)) & 0x80000000))

#define __GL_COLOR_CHECK_CLAMP_A(value, flags)                                 \
    (flags) |=                                                                 \
    ((ULONG)(CASTINT(value) & 0x80000000) |                                    \
     (ULONG)((CASTINT(gc->alphaVertexScale) - CASTINT(value)) & 0x80000000))

#define __GL_COLOR_CHECK_CLAMP_RGB(gc, r, g, b)                              \
    ((CASTINT(r) | ((ULONG)(CASTINT(gc->redVertexScale) - CASTINT(r))) |     \
      CASTINT(g) | ((ULONG)(CASTINT(gc->greenVertexScale) - CASTINT(g))) |   \
      CASTINT(b) | ((ULONG)(CASTINT(gc->blueVertexScale) - CASTINT(b)))) &   \
     0x80000000)


#define __GL_SCALE_AND_CHECK_CLAMP_R(target, gc, flags, r)                  \
{                                                                           \
    __GL_SCALE_R(target, gc, r);                                            \
    __GL_COLOR_CHECK_CLAMP_R(target, flags);                                \
}

#define __GL_SCALE_AND_CHECK_CLAMP_G(target, gc, flags, g)                  \
{                                                                           \
    __GL_SCALE_G(target, gc, g);                                            \
    __GL_COLOR_CHECK_CLAMP_G(target, flags);                                \
}

#define __GL_SCALE_AND_CHECK_CLAMP_B(target, gc, flags, b)                  \
{                                                                           \
    __GL_SCALE_B(target, gc, b);                                            \
    __GL_COLOR_CHECK_CLAMP_B(target, flags);                                \
}

#define __GL_SCALE_AND_CHECK_CLAMP_A(target, gc, flags, a)                  \
{                                                                           \
    __GL_SCALE_A(target, gc, a);                                            \
    __GL_COLOR_CHECK_CLAMP_A(target, flags);                                \
}

#define __GL_CLAMP_R(target, gc, r)                                         \
{                                                                           \
    (gc)->redClampTable[0] = (r);                                           \
    target = (gc)->redClampTable[__GL_COLOR_CLAMP_INDEX_R((gc)->redClampTable[0])]; \
}

#define __GL_CLAMP_G(target, gc, g)                                         \
{                                                                           \
    (gc)->greenClampTable[0] = (g);                                         \
    target = (gc)->greenClampTable[__GL_COLOR_CLAMP_INDEX_G((gc)->greenClampTable[0])]; \
}

#define __GL_CLAMP_B(target, gc, b)                                         \
{                                                                           \
    (gc)->blueClampTable[0] = (b);                                          \
    target = (gc)->blueClampTable[__GL_COLOR_CLAMP_INDEX_B((gc)->blueClampTable[0])]; \
}

#define __GL_CLAMP_A(target, gc, a)                                         \
{                                                                           \
    (gc)->alphaClampTable[0] = (a);                                         \
    target = (gc)->alphaClampTable[__GL_COLOR_CLAMP_INDEX_A((gc)->alphaClampTable[0])]; \
}

/* Aggregate clamping routines. */


#ifdef _X86_

#define __GL_SCALE_RGB(rOut, gOut, bOut, gc, r, g, b)                   \
    __GL_SCALE_R(rOut, gc, r);                                    	\
    __GL_SCALE_G(gOut, gc, g);                                    	\
    __GL_SCALE_B(bOut, gc, b);

#define __GL_SCALE_RGBA(rOut, gOut, bOut, aOut, gc, r, g, b, a)         \
    __GL_SCALE_R(rOut, gc, r);                                    	\
    __GL_SCALE_G(gOut, gc, g);                                    	\
    __GL_SCALE_B(bOut, gc, b);                                    	\
    __GL_SCALE_A(aOut, gc, a);

#define __GL_CLAMP_RGB(rOut, gOut, bOut, gc, r, g, b)       		\
    __GL_CLAMP_R(rOut, gc, r);                                    	\
    __GL_CLAMP_G(gOut, gc, g);                                    	\
    __GL_CLAMP_B(bOut, gc, b);

#define __GL_CLAMP_RGBA(rOut, gOut, bOut, aOut, gc, r, g, b, a)         \
    __GL_CLAMP_R(rOut, gc, r);                                          \
    __GL_CLAMP_G(gOut, gc, g);                                    	\
    __GL_CLAMP_B(bOut, gc, b);                                    	\
    __GL_CLAMP_A(aOut, gc, a);

#define __GL_SCALE_AND_CHECK_CLAMP_RGB(rOut, gOut, bOut, gc, flags, r, g, b)\
    __GL_SCALE_AND_CHECK_CLAMP_R(rOut, gc, flags, r);         		\
    __GL_SCALE_AND_CHECK_CLAMP_G(gOut, gc, flags, g);         		\
    __GL_SCALE_AND_CHECK_CLAMP_B(bOut, gc, flags, b);

#define __GL_SCALE_AND_CHECK_CLAMP_RGBA(rOut, gOut, bOut, aOut, gc, flags,\
                                        r, g, b, a)                     \
    __GL_SCALE_AND_CHECK_CLAMP_R(rOut, gc, flags, r);                   \
    __GL_SCALE_AND_CHECK_CLAMP_G(gOut, gc, flags, g);                   \
    __GL_SCALE_AND_CHECK_CLAMP_B(bOut, gc, flags, b);                   \
    __GL_SCALE_AND_CHECK_CLAMP_A(aOut, gc, flags, a);

#else // NOT _X86_

/* The following code is written in a "load, compute, store" style.
** It is preferable for RISC CPU's with larger numbers of registers,
** such as DEC Alpha.  VC++ for Alpha does not do
** a good job expanding the __GL_CLAMP_R, __GL_CLAMP_G, __GL_CLAMP_B,
** __GL_CLAMP_A macros, due to all the pointer indirections and the
** basic blocks defined by {} brackets.
*/

#define __GL_SCALE_RGB(rOut, gOut, bOut, gc, r, g, b)               \
{                                                                   \
    __GLfloat rScale, gScale, bScale;                               \
    __GLfloat rs, gs, bs;                                           \
                                                                    \
    rScale = (gc)->redVertexScale;                                  \
    gScale = (gc)->greenVertexScale;                                \
    bScale = (gc)->blueVertexScale;                                 \
                                                                    \
    rs = (r) * rScale;                                              \
    gs = (g) * gScale;                                              \
    bs = (b) * bScale;                                              \
                                                                    \
    rOut = rs;                                                      \
    gOut = gs;                                                      \
    bOut = bs;                                                      \
}

#define __GL_SCALE_RGBA(rOut, gOut, bOut, aOut, gc, r, g, b, a)     \
{                                                                   \
    __GLfloat rScale, gScale, bScale, aScale;                       \
    __GLfloat rs, gs, bs, as;                                       \
                                                                    \
    rScale = (gc)->redVertexScale;                                  \
    gScale = (gc)->greenVertexScale;                                \
    bScale = (gc)->blueVertexScale;                                 \
    aScale = (gc)->alphaVertexScale;                                \
                                                                    \
    rs = (r) * rScale;                                              \
    gs = (g) * gScale;                                              \
    bs = (b) * bScale;                                              \
    as = (a) * aScale;                                              \
                                                                    \
    rOut = rs;                                                      \
    gOut = gs;                                                      \
    bOut = bs;                                                      \
    aOut = as;                                                      \
}

#define __GL_CLAMP_RGB(rOut, gOut, bOut, gc, r, g, b)               \
{                                                                   \
    __GLfloat dst_r, dst_g, dst_b;                                  \
    ULONG index_r, index_g, index_b;                                \
    LONG clamp_r, clamp_g, clamp_b;                                 \
    LONG i_rScale, i_gScale, i_bScale;                              \
    ULONG sign_mask = 0x80000000;                                   \
                                                                    \
    (gc)->redClampTable[0] = (r);                                   \
    (gc)->greenClampTable[0] = (g);                                 \
    (gc)->blueClampTable[0] = (b);                                  \
                                                                    \
    i_rScale = CASTINT((gc)->redVertexScale);                       \
    i_gScale = CASTINT((gc)->greenVertexScale);                     \
    i_bScale = CASTINT((gc)->blueVertexScale);                      \
                                                                    \
    clamp_r = CASTINT((gc)->redClampTable[0]);                      \
    clamp_g = CASTINT((gc)->greenClampTable[0]);                    \
    clamp_b = CASTINT((gc)->blueClampTable[0]);                     \
                                                                    \
    index_r =                                                       \
        (((ULONG)((clamp_r & sign_mask)) >> 30) |                   \
         ((ULONG)(((i_rScale - clamp_r) & sign_mask)) >> 31));      \
                                                                    \
    index_g =                                                       \
        (((ULONG)((clamp_g & sign_mask)) >> 30) |                   \
         ((ULONG)(((i_gScale - clamp_g) & sign_mask)) >> 31));      \
                                                                    \
    index_b =                                                       \
        (((ULONG)((clamp_b & sign_mask)) >> 30) |                   \
         ((ULONG)(((i_bScale - clamp_b) & sign_mask)) >> 31));      \
                                                                    \
    dst_r = (gc)->redClampTable[index_r];                           \
    dst_g = (gc)->greenClampTable[index_g];                         \
    dst_b = (gc)->blueClampTable[index_b];                          \
                                                                    \
    rOut = dst_r;                                                   \
    gOut = dst_g;                                                   \
    bOut = dst_b;                                                   \
}



#define __GL_CLAMP_RGBA(rOut, gOut, bOut, aOut, gc, r, g, b, a)     \
{                                                                   \
    __GLfloat dst_r, dst_g, dst_b, dst_a;                           \
    ULONG index_r, index_g, index_b, index_a;                       \
    LONG clamp_r, clamp_g, clamp_b, clamp_a;                        \
    LONG i_rScale, i_gScale, i_bScale, i_aScale;                    \
    ULONG sign_mask = 0x80000000;                                   \
                                                                    \
    (gc)->redClampTable[0] = (r);                                   \
    (gc)->greenClampTable[0] = (g);                                 \
    (gc)->blueClampTable[0] = (b);                                  \
    (gc)->alphaClampTable[0] = (a);                                 \
                                                                    \
    i_rScale = CASTINT((gc)->redVertexScale);                       \
    i_gScale = CASTINT((gc)->greenVertexScale);                     \
    i_bScale = CASTINT((gc)->blueVertexScale);                      \
    i_aScale = CASTINT((gc)->alphaVertexScale);                     \
                                                                    \
    clamp_r = CASTINT((gc)->redClampTable[0]);                      \
    clamp_g = CASTINT((gc)->greenClampTable[0]);                    \
    clamp_b = CASTINT((gc)->blueClampTable[0]);                     \
    clamp_a = CASTINT((gc)->alphaClampTable[0]);                    \
                                                                    \
    index_r =                                                       \
        (((ULONG)((clamp_r & sign_mask)) >> 30) |                   \
         ((ULONG)(((i_rScale - clamp_r) & sign_mask)) >> 31));      \
                                                                    \
    index_g =                                                       \
        (((ULONG)((clamp_g & sign_mask)) >> 30) |                   \
         ((ULONG)(((i_gScale - clamp_g) & sign_mask)) >> 31));      \
                                                                    \
    index_b =                                                       \
        (((ULONG)((clamp_b & sign_mask)) >> 30) |                   \
         ((ULONG)(((i_bScale - clamp_b) & sign_mask)) >> 31));      \
                                                                    \
    index_a =                                                       \
        (((ULONG)((clamp_a & sign_mask)) >> 30) |                   \
         ((ULONG)(((i_aScale - clamp_a) & sign_mask)) >> 31));      \
                                                                    \
    dst_r = (gc)->redClampTable[index_r];                           \
    dst_g = (gc)->greenClampTable[index_g];                         \
    dst_b = (gc)->blueClampTable[index_b];                          \
    dst_a = (gc)->alphaClampTable[index_a];                         \
                                                                    \
    rOut = dst_r;                                                   \
    gOut = dst_g;                                                   \
    bOut = dst_b;                                                   \
    aOut = dst_a;                                                   \
}


#define __GL_SCALE_AND_CHECK_CLAMP_RGB(rOut, gOut, bOut, gc, flags, r, g, b)\
{                                                                   \
    ULONG sign_mask = 0x80000000;                                   \
    __GLfloat rScale, gScale, bScale;                               \
    LONG i_rScale, i_gScale, i_bScale;                              \
    LONG i_r, i_g, i_b;                                             \
    __GLfloat fr, fg, fb;                                           \
    ULONG the_flags_copy, r_flags, g_flags, b_flags;                \
                                                                    \
    the_flags_copy = (flags);                                       \
                                                                    \
    rScale = (gc)->redVertexScale;                                  \
    gScale = (gc)->greenVertexScale;                                \
    bScale = (gc)->blueVertexScale;                                 \
                                                                    \
    i_rScale = CASTINT((gc)->redVertexScale);                       \
    i_gScale = CASTINT((gc)->greenVertexScale);                     \
    i_bScale = CASTINT((gc)->blueVertexScale);                      \
                                                                    \
    fr = (r) * rScale;                                              \
    fg = (g) * gScale;                                              \
    fb = (b) * bScale;                                              \
                                                                    \
    rOut = fr;                                                      \
    gOut = fg;                                                      \
    bOut = fb;                                                      \
                                                                    \
    i_r = CASTINT((rOut));  		                            \
    i_g = CASTINT((gOut));					    \
    i_b = CASTINT((bOut));	                                    \
                                                                    \
    r_flags =                                                       \
        ((ULONG)(i_r & sign_mask) |                                 \
         (ULONG)((i_rScale - i_r) & sign_mask));                    \
                                                                    \
    g_flags =                                                       \
        ((ULONG)(i_g & sign_mask) |                                 \
         (ULONG)((i_gScale - i_g) & sign_mask));                    \
                                                                    \
    b_flags =                                                       \
        ((ULONG)(i_b & sign_mask) |                                 \
         (ULONG)((i_bScale - i_b) & sign_mask));                    \
                                                                    \
    the_flags_copy |= r_flags | g_flags | b_flags;                  \
    (flags) = the_flags_copy;                                       \
}


#define __GL_SCALE_AND_CHECK_CLAMP_RGBA(rOut, gOut, bOut, aOut, gc, flags, \
                                        r, g, b, a)\
{                                                                   \
    ULONG sign_mask = 0x80000000;                                   \
    __GLfloat rScale, gScale, bScale, aScale;                       \
    LONG i_rScale, i_gScale, i_bScale, i_aScale;                    \
    LONG i_r, i_g, i_b, i_a;                                        \
    __GLfloat fr, fg, fb, fa;                                       \
    ULONG the_flags_copy, r_flags, g_flags, b_flags, a_flags;       \
                                                                    \
    the_flags_copy = (flags);                                       \
                                                                    \
    rScale = (gc)->redVertexScale;                                  \
    gScale = (gc)->greenVertexScale;                                \
    bScale = (gc)->blueVertexScale;                                 \
    aScale = (gc)->alphaVertexScale;                                \
                                                                    \
    i_rScale = CASTINT((gc)->redVertexScale);                       \
    i_gScale = CASTINT((gc)->greenVertexScale);                     \
    i_bScale = CASTINT((gc)->blueVertexScale);                      \
    i_aScale = CASTINT((gc)->alphaVertexScale);                     \
                                                                    \
    fr = (r) * rScale;                                              \
    fg = (g) * gScale;                                              \
    fb = (b) * bScale;                                              \
    fa = (a) * aScale;                                              \
                                                                    \
    rOut = fr;                                                      \
    gOut = fg;                                                      \
    bOut = fb;                                                      \
    aOut = fa;                                                      \
                                                                    \
    i_r = CASTINT((rOut));                                          \
    i_g = CASTINT((gOut));                                          \
    i_b = CASTINT((bOut));                                          \
    i_a = CASTINT((aOut));                                          \
                                                                    \
    r_flags =                                                       \
        ((ULONG)(i_r & sign_mask) |                                 \
         (ULONG)((i_rScale - i_r) & sign_mask));                    \
                                                                    \
    g_flags =                                                       \
        ((ULONG)(i_g & sign_mask) |                                 \
         (ULONG)((i_gScale - i_g) & sign_mask));                    \
                                                                    \
    b_flags =                                                       \
        ((ULONG)(i_b & sign_mask) |                                 \
         (ULONG)((i_bScale - i_b) & sign_mask));                    \
                                                                    \
    a_flags =                                                       \
        ((ULONG)(i_a & sign_mask) |                                 \
         (ULONG)((i_aScale - i_a) & sign_mask));                    \
                                                                    \
    the_flags_copy |= r_flags | g_flags | b_flags | a_flags;        \
    (flags) = the_flags_copy;                                       \
}

#endif // NOT _X86_


/************************************************************************/

/* Applies to current context */
extern void FASTCALL __glSetError(GLenum code);
#ifdef NT
/* Used when no RC is current */
extern void FASTCALL __glSetErrorEarly(__GLcontext *gc, GLenum code);
#endif // NT

extern void FASTCALL __glFreeEvaluatorState(__GLcontext *gc);
extern void FASTCALL __glFreeDlistState(__GLcontext *gc);
extern void FASTCALL __glFreeMachineState(__GLcontext *gc);
extern void FASTCALL __glFreePixelState(__GLcontext *gc);
extern void FASTCALL __glFreeTextureState(__GLcontext *gc);

extern void FASTCALL __glInitDlistState(__GLcontext *gc);
extern void FASTCALL __glInitEvaluatorState(__GLcontext *gc);
extern void FASTCALL __glInitPixelState(__GLcontext *gc);
extern void FASTCALL __glInitTextureState(__GLcontext *gc);
extern void FASTCALL __glInitTransformState(__GLcontext *gc);

void FASTCALL __glEarlyInitContext(__GLcontext *gc);
void FASTCALL __glContextSetColorScales(__GLcontext *gc);
void FASTCALL __glContextUnsetColorScales(__GLcontext *gc);
void FASTCALL __glSoftResetContext(__GLcontext *gc);
void FASTCALL __glDestroyContext(__GLcontext *gc);

#endif /* __glcontext_h_ */