windows-server-2003/multimedia/opengl/server/soft/so_conte.c

/*
** Copyright 1991-1993, 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.
*/
#include "precomp.h"
#pragma hdrstop

#include <stdio.h>
#include <fixed.h>

static GLfloat DefaultAmbient[4] = { 0.2f, 0.2f, 0.2f, 1.0 };
static GLfloat DefaultDiffuse[4] = { 0.8f, 0.8f, 0.8f, 1.0 };
static GLfloat DefaultBlack[4] = { 0.0, 0.0, 0.0, 1.0 };
static GLfloat DefaultWhite[4] = { 1.0, 1.0, 1.0, 1.0 };

#ifdef NT
#define UB2F(ub)  ((GLfloat) ((ub) / 255.0))
#define B2F(b)    ((GLfloat) ((2 * (b) + 1) / 255.0))

GLfloat __glUByteToFloat[256] = {
    UB2F(  0), UB2F(  1), UB2F(  2), UB2F(  3),
    UB2F(  4), UB2F(  5), UB2F(  6), UB2F(  7),
    UB2F(  8), UB2F(  9), UB2F( 10), UB2F( 11),
    UB2F( 12), UB2F( 13), UB2F( 14), UB2F( 15),
    UB2F( 16), UB2F( 17), UB2F( 18), UB2F( 19),
    UB2F( 20), UB2F( 21), UB2F( 22), UB2F( 23),
    UB2F( 24), UB2F( 25), UB2F( 26), UB2F( 27),
    UB2F( 28), UB2F( 29), UB2F( 30), UB2F( 31),
    UB2F( 32), UB2F( 33), UB2F( 34), UB2F( 35),
    UB2F( 36), UB2F( 37), UB2F( 38), UB2F( 39),
    UB2F( 40), UB2F( 41), UB2F( 42), UB2F( 43),
    UB2F( 44), UB2F( 45), UB2F( 46), UB2F( 47),
    UB2F( 48), UB2F( 49), UB2F( 50), UB2F( 51),
    UB2F( 52), UB2F( 53), UB2F( 54), UB2F( 55),
    UB2F( 56), UB2F( 57), UB2F( 58), UB2F( 59),
    UB2F( 60), UB2F( 61), UB2F( 62), UB2F( 63),
    UB2F( 64), UB2F( 65), UB2F( 66), UB2F( 67),
    UB2F( 68), UB2F( 69), UB2F( 70), UB2F( 71),
    UB2F( 72), UB2F( 73), UB2F( 74), UB2F( 75),
    UB2F( 76), UB2F( 77), UB2F( 78), UB2F( 79),
    UB2F( 80), UB2F( 81), UB2F( 82), UB2F( 83),
    UB2F( 84), UB2F( 85), UB2F( 86), UB2F( 87),
    UB2F( 88), UB2F( 89), UB2F( 90), UB2F( 91),
    UB2F( 92), UB2F( 93), UB2F( 94), UB2F( 95),
    UB2F( 96), UB2F( 97), UB2F( 98), UB2F( 99),
    UB2F(100), UB2F(101), UB2F(102), UB2F(103),
    UB2F(104), UB2F(105), UB2F(106), UB2F(107),
    UB2F(108), UB2F(109), UB2F(110), UB2F(111),
    UB2F(112), UB2F(113), UB2F(114), UB2F(115),
    UB2F(116), UB2F(117), UB2F(118), UB2F(119),
    UB2F(120), UB2F(121), UB2F(122), UB2F(123),
    UB2F(124), UB2F(125), UB2F(126), UB2F(127),
    UB2F(128), UB2F(129), UB2F(130), UB2F(131),
    UB2F(132), UB2F(133), UB2F(134), UB2F(135),
    UB2F(136), UB2F(137), UB2F(138), UB2F(139),
    UB2F(140), UB2F(141), UB2F(142), UB2F(143),
    UB2F(144), UB2F(145), UB2F(146), UB2F(147),
    UB2F(148), UB2F(149), UB2F(150), UB2F(151),
    UB2F(152), UB2F(153), UB2F(154), UB2F(155),
    UB2F(156), UB2F(157), UB2F(158), UB2F(159),
    UB2F(160), UB2F(161), UB2F(162), UB2F(163),
    UB2F(164), UB2F(165), UB2F(166), UB2F(167),
    UB2F(168), UB2F(169), UB2F(170), UB2F(171),
    UB2F(172), UB2F(173), UB2F(174), UB2F(175),
    UB2F(176), UB2F(177), UB2F(178), UB2F(179),
    UB2F(180), UB2F(181), UB2F(182), UB2F(183),
    UB2F(184), UB2F(185), UB2F(186), UB2F(187),
    UB2F(188), UB2F(189), UB2F(190), UB2F(191),
    UB2F(192), UB2F(193), UB2F(194), UB2F(195),
    UB2F(196), UB2F(197), UB2F(198), UB2F(199),
    UB2F(200), UB2F(201), UB2F(202), UB2F(203),
    UB2F(204), UB2F(205), UB2F(206), UB2F(207),
    UB2F(208), UB2F(209), UB2F(210), UB2F(211),
    UB2F(212), UB2F(213), UB2F(214), UB2F(215),
    UB2F(216), UB2F(217), UB2F(218), UB2F(219),
    UB2F(220), UB2F(221), UB2F(222), UB2F(223),
    UB2F(224), UB2F(225), UB2F(226), UB2F(227),
    UB2F(228), UB2F(229), UB2F(230), UB2F(231),
    UB2F(232), UB2F(233), UB2F(234), UB2F(235),
    UB2F(236), UB2F(237), UB2F(238), UB2F(239),
    UB2F(240), UB2F(241), UB2F(242), UB2F(243),
    UB2F(244), UB2F(245), UB2F(246), UB2F(247),
    UB2F(248), UB2F(249), UB2F(250), UB2F(251),
    UB2F(252), UB2F(253), UB2F(254), UB2F(255),
};

GLfloat __glByteToFloat[256] = {
    B2F(   0), B2F(   1), B2F(   2), B2F(   3),
    B2F(   4), B2F(   5), B2F(   6), B2F(   7),
    B2F(   8), B2F(   9), B2F(  10), B2F(  11),
    B2F(  12), B2F(  13), B2F(  14), B2F(  15),
    B2F(  16), B2F(  17), B2F(  18), B2F(  19),
    B2F(  20), B2F(  21), B2F(  22), B2F(  23),
    B2F(  24), B2F(  25), B2F(  26), B2F(  27),
    B2F(  28), B2F(  29), B2F(  30), B2F(  31),
    B2F(  32), B2F(  33), B2F(  34), B2F(  35),
    B2F(  36), B2F(  37), B2F(  38), B2F(  39),
    B2F(  40), B2F(  41), B2F(  42), B2F(  43),
    B2F(  44), B2F(  45), B2F(  46), B2F(  47),
    B2F(  48), B2F(  49), B2F(  50), B2F(  51),
    B2F(  52), B2F(  53), B2F(  54), B2F(  55),
    B2F(  56), B2F(  57), B2F(  58), B2F(  59),
    B2F(  60), B2F(  61), B2F(  62), B2F(  63),
    B2F(  64), B2F(  65), B2F(  66), B2F(  67),
    B2F(  68), B2F(  69), B2F(  70), B2F(  71),
    B2F(  72), B2F(  73), B2F(  74), B2F(  75),
    B2F(  76), B2F(  77), B2F(  78), B2F(  79),
    B2F(  80), B2F(  81), B2F(  82), B2F(  83),
    B2F(  84), B2F(  85), B2F(  86), B2F(  87),
    B2F(  88), B2F(  89), B2F(  90), B2F(  91),
    B2F(  92), B2F(  93), B2F(  94), B2F(  95),
    B2F(  96), B2F(  97), B2F(  98), B2F(  99),
    B2F( 100), B2F( 101), B2F( 102), B2F( 103),
    B2F( 104), B2F( 105), B2F( 106), B2F( 107),
    B2F( 108), B2F( 109), B2F( 110), B2F( 111),
    B2F( 112), B2F( 113), B2F( 114), B2F( 115),
    B2F( 116), B2F( 117), B2F( 118), B2F( 119),
    B2F( 120), B2F( 121), B2F( 122), B2F( 123),
    B2F( 124), B2F( 125), B2F( 126), B2F( 127),
    B2F(-128), B2F(-127), B2F(-126), B2F(-125),
    B2F(-124), B2F(-123), B2F(-122), B2F(-121),
    B2F(-120), B2F(-119), B2F(-118), B2F(-117),
    B2F(-116), B2F(-115), B2F(-114), B2F(-113),
    B2F(-112), B2F(-111), B2F(-110), B2F(-109),
    B2F(-108), B2F(-107), B2F(-106), B2F(-105),
    B2F(-104), B2F(-103), B2F(-102), B2F(-101),
    B2F(-100), B2F( -99), B2F( -98), B2F( -97),
    B2F( -96), B2F( -95), B2F( -94), B2F( -93),
    B2F( -92), B2F( -91), B2F( -90), B2F( -89),
    B2F( -88), B2F( -87), B2F( -86), B2F( -85),
    B2F( -84), B2F( -83), B2F( -82), B2F( -81),
    B2F( -80), B2F( -79), B2F( -78), B2F( -77),
    B2F( -76), B2F( -75), B2F( -74), B2F( -73),
    B2F( -72), B2F( -71), B2F( -70), B2F( -69),
    B2F( -68), B2F( -67), B2F( -66), B2F( -65),
    B2F( -64), B2F( -63), B2F( -62), B2F( -61),
    B2F( -60), B2F( -59), B2F( -58), B2F( -57),
    B2F( -56), B2F( -55), B2F( -54), B2F( -53),
    B2F( -52), B2F( -51), B2F( -50), B2F( -49),
    B2F( -48), B2F( -47), B2F( -46), B2F( -45),
    B2F( -44), B2F( -43), B2F( -42), B2F( -41),
    B2F( -40), B2F( -39), B2F( -38), B2F( -37),
    B2F( -36), B2F( -35), B2F( -34), B2F( -33),
    B2F( -32), B2F( -31), B2F( -30), B2F( -29),
    B2F( -28), B2F( -27), B2F( -26), B2F( -25),
    B2F( -24), B2F( -23), B2F( -22), B2F( -21),
    B2F( -20), B2F( -19), B2F( -18), B2F( -17),
    B2F( -16), B2F( -15), B2F( -14), B2F( -13),
    B2F( -12), B2F( -11), B2F( -10), B2F(  -9),
    B2F(  -8), B2F(  -7), B2F(  -6), B2F(  -5),
    B2F(  -4), B2F(  -3), B2F(  -2), B2F(  -1),
};
#endif // NT

/*
** Early initialization of context.  Very little is done here, just enough
** to make a context viable.
*/

void FASTCALL __glEarlyInitContext(__GLcontext *gc)
{
    GLint numLights, attribDepth;
    GLint i;

    ASSERTOPENGL(__GL_MAX_MAX_VIEWPORT == __GL_MAX_WINDOW_WIDTH &&
		 __GL_MAX_MAX_VIEWPORT == __GL_MAX_WINDOW_HEIGHT,
		 "__GL_MAX_MAX_VIEWPORT mismatch\n");

    gc->constants.fviewportXAdjust = (__GLfloat) gc->constants.viewportXAdjust;
    gc->constants.fviewportYAdjust = (__GLfloat) gc->constants.viewportYAdjust;
    gc->procs.pickColorMaterialProcs = __glNopGC;
    gc->procs.applyColor = __glNopGC;

    /* Allocate memory to hold variable sized things */
    numLights = gc->constants.numberOfLights;
    gc->state.light.source = (__GLlightSourceState*)
	GCALLOCZ(gc, numLights*sizeof(__GLlightSourceState));
    gc->light.lutCache = NULL;
    gc->light.source = (__GLlightSourceMachine*)
	GCALLOCZ(gc, numLights*sizeof(__GLlightSourceMachine));
    attribDepth = gc->constants.maxAttribStackDepth;
    gc->attributes.stack = (__GLattribute**)
	GCALLOCZ(gc, attribDepth*sizeof(__GLattribute*));
    attribDepth = gc->constants.maxClientAttribStackDepth;
    gc->clientAttributes.stack = (__GLclientAttribute**)
	GCALLOCZ(gc, attribDepth*sizeof(__GLclientAttribute*));
    // now lazy allocate in RenderMode
    gc->select.stack = (GLuint*) NULL;

#ifdef NT
    // Allocate (n-1) vertices.  The last one is reserved by polyarray code.
    (void) PolyArrayAllocBuffer(gc, POLYDATA_BUFFER_SIZE + 1);
#ifndef NEW_PARTIAL_PRIM
    for (i = 0; i < sizeof(gc->vertex.pdSaved)/sizeof(gc->vertex.pdSaved[0]); i++)
	gc->vertex.pdSaved[i].color = &gc->vertex.pdSaved[i].colors[__GL_FRONTFACE];
#endif // NEW_PARTIAL_PRIM
#endif

#ifdef _X86_

    initClipCodesTable();
    initInvSqrtTable();

#endif // _X86_

    __glEarlyInitTextureState(gc);

#if __GL_NUMBER_OF_AUX_BUFFERS > 0
    /*
    ** Allocate any aux color buffer records
    ** Note: Does not allocate the actual buffer memory, this is done elsewhere.
    */
    if (gc->modes.maxAuxBuffers > 0) {
	gc->auxBuffer = (__GLcolorBuffer *)
	    GCALLOCZ(gc, gc->modes.maxAuxBuffers*sizeof(__GLcolorBuffer));
    }
#endif

    __glInitDlistState(gc);
}

void FASTCALL __glContextSetColorScales(__GLcontext *gc)
{
    __GLfloat one = __glOne;
    __GLattribute **spp;
    __GLattribute *sp;
    GLuint mask;
    GLint i;

    gc->frontBuffer.oneOverRedScale = one / gc->frontBuffer.redScale;
    gc->frontBuffer.oneOverGreenScale = one / gc->frontBuffer.greenScale;
    gc->frontBuffer.oneOverBlueScale = one / gc->frontBuffer.blueScale;
    gc->frontBuffer.oneOverAlphaScale = one / gc->frontBuffer.alphaScale;

    gc->vertexToBufferIdentity = GL_TRUE;
    
    if (__GL_FLOAT_NEZ(gc->redVertexScale))
    {
        gc->oneOverRedVertexScale = one / gc->redVertexScale;
    }
    else
    {
        gc->oneOverRedVertexScale = __glZero;
    }
    
    if (__GL_FLOAT_NE(gc->redVertexScale, gc->frontBuffer.redScale))
    {
        gc->redVertexToBufferScale =
            gc->frontBuffer.redScale * gc->oneOverRedVertexScale;
        gc->vertexToBufferIdentity = GL_FALSE;
    }
    else
    {
        gc->redVertexToBufferScale = __glOne;
    }

    if (__GL_FLOAT_NEZ(gc->greenVertexScale))
    {
        gc->oneOverGreenVertexScale = one / gc->greenVertexScale;
    }
    else
    {
        gc->oneOverGreenVertexScale = __glZero;
    }

    if (__GL_FLOAT_NE(gc->greenVertexScale, gc->frontBuffer.greenScale))
    {
        gc->greenVertexToBufferScale =
            gc->frontBuffer.greenScale * gc->oneOverGreenVertexScale;
        gc->vertexToBufferIdentity = GL_FALSE;
    }
    else
    {
        gc->greenVertexToBufferScale = __glOne;
    }

    if (__GL_FLOAT_NEZ(gc->blueVertexScale))
    {
        gc->oneOverBlueVertexScale = one / gc->blueVertexScale;
    }
    else
    {
        gc->oneOverBlueVertexScale = __glZero;
    }
    
    if (__GL_FLOAT_NE(gc->blueVertexScale, gc->frontBuffer.blueScale))
    {
        gc->blueVertexToBufferScale =
            gc->frontBuffer.blueScale * gc->oneOverBlueVertexScale;
        gc->vertexToBufferIdentity = GL_FALSE;
    }
    else
    {
        gc->blueVertexToBufferScale = __glOne;
    }

    if (__GL_FLOAT_NEZ(gc->alphaVertexScale))
    {
        gc->oneOverAlphaVertexScale = one / gc->alphaVertexScale;
    }
    else
    {
        gc->oneOverAlphaVertexScale = __glZero;
    }
    
    if (__GL_FLOAT_NE(gc->alphaVertexScale, gc->frontBuffer.alphaScale))
    {
        gc->alphaVertexToBufferScale =
            gc->frontBuffer.alphaScale * gc->oneOverAlphaVertexScale;
        gc->vertexToBufferIdentity = GL_FALSE;
    }
    else
    {
        gc->alphaVertexToBufferScale = __glOne;
    }

    for (spp = &gc->attributes.stack[0]; spp < gc->attributes.stackPointer; 
	    spp++) {
	sp = *spp;
	mask = sp->mask;

	if (mask & GL_CURRENT_BIT) {
	    if (gc->modes.rgbMode) {
		__glScaleColorf(gc,
		    &sp->current.rasterPos.colors[__GL_FRONTFACE],
		    &sp->current.rasterPos.colors[__GL_FRONTFACE].r);
	    }
	}
	if (mask & GL_LIGHTING_BIT) {
	    __glScaleColorf(gc,
		&sp->light.model.ambient,
		&sp->light.model.ambient.r);
	    for (i=0; i<gc->constants.numberOfLights; i++) {
		__glScaleColorf(gc,
		    &sp->light.source[i].ambient,
		    &sp->light.source[i].ambient.r);
		__glScaleColorf(gc,
		    &sp->light.source[i].diffuse,
		    &sp->light.source[i].diffuse.r);
		__glScaleColorf(gc,
		    &sp->light.source[i].specular,
		    &sp->light.source[i].specular.r);
	    }
	    __glScaleColorf(gc,
		&sp->light.front.emissive,
		&sp->light.front.emissive.r);
	    __glScaleColorf(gc,
		&sp->light.back.emissive,
		&sp->light.back.emissive.r);
	}
#ifdef NT
        if (mask & GL_FOG_BIT)
        {
            __glScaleColorf(gc, &sp->fog.color, &sp->fog.color.r);
	    if (sp->fog.color.r == sp->fog.color.g
	     && sp->fog.color.r == sp->fog.color.b)
		sp->fog.flags |= __GL_FOG_GRAY_RGB;
	    else
		sp->fog.flags &= ~__GL_FOG_GRAY_RGB;
        }

#ifdef _MCD_
        MCD_STATE_DIRTY(gc, FOG);
#endif
#endif
    }

    if (gc->modes.rgbMode) {
	__glScaleColorf(gc, 
	        &gc->state.current.rasterPos.colors[__GL_FRONTFACE], 
		&gc->state.current.rasterPos.colors[__GL_FRONTFACE].r);
    } 

    __glScaleColorf(gc, 
	    &gc->state.light.model.ambient,
	    &gc->state.light.model.ambient.r);
    for (i=0; i<gc->constants.numberOfLights; i++) {
	__glScaleColorf(gc,
		&gc->state.light.source[i].ambient,
		&gc->state.light.source[i].ambient.r);
	__glScaleColorf(gc,
		&gc->state.light.source[i].diffuse,
		&gc->state.light.source[i].diffuse.r);
	__glScaleColorf(gc,
		&gc->state.light.source[i].specular,
		&gc->state.light.source[i].specular.r);
    }
    __glScaleColorf(gc,
   	    &gc->state.light.front.emissive, 
   	    &gc->state.light.front.emissive.r);
    __glScaleColorf(gc,
   	    &gc->state.light.back.emissive, 
   	    &gc->state.light.back.emissive.r);
#ifdef NT
    __glScaleColorf(gc, &gc->state.fog.color, &gc->state.fog.color.r);
    if (gc->state.fog.color.r == gc->state.fog.color.g
     && gc->state.fog.color.r == gc->state.fog.color.b)
	gc->state.fog.flags |= __GL_FOG_GRAY_RGB;
    else
        gc->state.fog.flags &= ~__GL_FOG_GRAY_RGB;

#ifdef _MCD_
        MCD_STATE_DIRTY(gc, FOG);
#endif
#endif

    __glPixelSetColorScales(gc);
}

void FASTCALL __glContextUnsetColorScales(__GLcontext *gc)
{
    GLint i;
    __GLattribute **spp;
    __GLattribute *sp;
    GLuint mask;

    for (spp = &gc->attributes.stack[0]; spp < gc->attributes.stackPointer; 
	    spp++) {
	sp = *spp;
	mask = sp->mask;

	if (mask & GL_CURRENT_BIT) {
	    if (gc->modes.rgbMode) {
		__glUnScaleColorf(gc,
		    &sp->current.rasterPos.colors[__GL_FRONTFACE].r,
		    &sp->current.rasterPos.colors[__GL_FRONTFACE]);
	    }
	}
	if (mask & GL_LIGHTING_BIT) {
	    __glUnScaleColorf(gc,
		&sp->light.model.ambient.r,
		&sp->light.model.ambient);
	    for (i=0; i<gc->constants.numberOfLights; i++) {
		__glUnScaleColorf(gc,
		    &sp->light.source[i].ambient.r,
		    &sp->light.source[i].ambient);
		__glUnScaleColorf(gc,
		    &sp->light.source[i].diffuse.r,
		    &sp->light.source[i].diffuse);
		__glUnScaleColorf(gc,
		    &sp->light.source[i].specular.r,
		    &sp->light.source[i].specular);
	    }
	    __glUnScaleColorf(gc,
		&sp->light.front.emissive.r,
		&sp->light.front.emissive);
	    __glUnScaleColorf(gc,
		&sp->light.back.emissive.r,
		&sp->light.back.emissive);
	}
#ifdef NT
        if (mask & GL_FOG_BIT)
        {
            __glUnScaleColorf(gc, &sp->fog.color.r, &sp->fog.color);
#ifdef _MCD_
            MCD_STATE_DIRTY(gc, FOG);
#endif
        }
#endif
    }

    if (gc->modes.rgbMode) {
	__glUnScaleColorf(gc,
	        &gc->state.current.rasterPos.colors[__GL_FRONTFACE].r,
		&gc->state.current.rasterPos.colors[__GL_FRONTFACE]);
    }
    __glUnScaleColorf(gc, 
	    &gc->state.light.model.ambient.r,
	    &gc->state.light.model.ambient);
    for (i=0; i<gc->constants.numberOfLights; i++) {
	__glUnScaleColorf(gc,
		&gc->state.light.source[i].ambient.r,
		&gc->state.light.source[i].ambient);
	__glUnScaleColorf(gc,
		&gc->state.light.source[i].diffuse.r,
		&gc->state.light.source[i].diffuse);
	__glUnScaleColorf(gc,
		&gc->state.light.source[i].specular.r,
		&gc->state.light.source[i].specular);
    }
    __glUnScaleColorf(gc,
   	    &gc->state.light.front.emissive.r,
   	    &gc->state.light.front.emissive);
    __glUnScaleColorf(gc,
   	    &gc->state.light.back.emissive.r,
   	    &gc->state.light.back.emissive);
#ifdef NT
    __glUnScaleColorf(gc, &gc->state.fog.color.r, &gc->state.fog.color);
#ifdef _MCD_
    MCD_STATE_DIRTY(gc, FOG);
#endif
#endif
}

/*
** Initialize all user controllable state, plus any computed state that
** is only set by user commands.  For example, light source position
** is converted immediately into eye coordinates.
**
** Any state that would be initialized to zero is not done here because
** the memory assigned to the context has already been block zeroed.
**
** NOTE: Since this function may need memory allocation, caller must
** check that gengc->errorcode is not set indicating memory allocation
** error.  If error is set, context is in an unknown state and data
** structure integrity is not guaranteed.
*/
void FASTCALL __glSoftResetContext(__GLcontext *gc)
{
    __GLlightSourceState *lss;
    __GLlightSourceMachine *lsm;
    __GLvertex *vx;
    GLint i, numLights;
    __GLfloat one = __glOne;

    /*
    ** Initialize constant values first so that they will
    ** be valid if needed by subsequent initialization steps.
    */

    if (gc->constants.alphaTestSize == 0) {
	gc->constants.alphaTestSize = 256;	/* A default */
    }
    gc->constants.alphaTableConv = (gc->constants.alphaTestSize - 1) / 
	    gc->frontBuffer.alphaScale;

    // viewportEpsilon is the smallest representable value in window
    // coordinates.  The number of fractional bits in a window
    // coordinate is known and fixed, so compute epsilon directly
    gc->constants.viewportEpsilon = 1.0f/(1 << __GL_VERTEX_FRAC_BITS);
    gc->constants.viewportAlmostHalf =
        __glHalf - gc->constants.viewportEpsilon;

    /* Allocate memory to hold variable sized things */
    numLights = gc->constants.numberOfLights;

    /* Misc machine state */
    gc->beginMode = __GL_NEED_VALIDATE;
    gc->dirtyMask = __GL_DIRTY_ALL;
    gc->validateMask = (GLuint) ~0;
    gc->attributes.stackPointer = &gc->attributes.stack[0];
    gc->clientAttributes.stackPointer = &gc->clientAttributes.stack[0];
#ifndef NT
// NT vertex allocation is done in __glEarlyInitContext.
    gc->vertex.v0 = &gc->vertex.vbuf[0];

    vx = &gc->vertex.vbuf[0];
    for (i = 0; i < __GL_NVBUF; i++, vx++) {
	vx->color = &vx->colors[__GL_FRONTFACE];
    }
#endif

    /* We need to initialize the matrix stuff early (before we handle */
    /* lighting) since we cache the modelview matrix with the light   */

    __glInitTransformState(gc);
#ifdef NT
    /* __glInitTransformState does memory allocation (incl. modelView */
    /* matrix which is needed later in this function.  If error code  */
    /* is set, we must exit.                                          */
    if (((__GLGENcontext *) gc)->errorcode)
        return;
#endif

    /* GL_LIGHTING_BIT state */
    gc->state.light.model.ambient.r = DefaultAmbient[0];
    gc->state.light.model.ambient.g = DefaultAmbient[1];
    gc->state.light.model.ambient.b = DefaultAmbient[2];
    gc->state.light.model.ambient.a = DefaultAmbient[3];
    gc->state.light.front.ambient.r = DefaultAmbient[0];
    gc->state.light.front.ambient.g = DefaultAmbient[1];
    gc->state.light.front.ambient.b = DefaultAmbient[2];
    gc->state.light.front.ambient.a = DefaultAmbient[3];
    gc->state.light.front.diffuse.r = DefaultDiffuse[0];
    gc->state.light.front.diffuse.g = DefaultDiffuse[1];
    gc->state.light.front.diffuse.b = DefaultDiffuse[2];
    gc->state.light.front.diffuse.a = DefaultDiffuse[3];
    gc->state.light.front.specular.r = DefaultBlack[0];
    gc->state.light.front.specular.g = DefaultBlack[1];
    gc->state.light.front.specular.b = DefaultBlack[2];
    gc->state.light.front.specular.a = DefaultBlack[3];
    gc->state.light.front.emissive.r = DefaultBlack[0];
    gc->state.light.front.emissive.g = DefaultBlack[1];
    gc->state.light.front.emissive.b = DefaultBlack[2];
    gc->state.light.front.emissive.a = DefaultBlack[3];
    gc->state.light.front.cmapa = 0;
    gc->state.light.front.cmapd = 1;
    gc->state.light.front.cmaps = 1;
    gc->state.light.back = gc->state.light.front;

    gc->light.front.specularExponent = -1;
    gc->light.front.specTable = NULL;
    gc->light.front.cache = NULL;
    gc->light.back.specularExponent = -1;
    gc->light.back.specTable = NULL;
    gc->light.back.cache = NULL;

    /* Initialize the individual lights */
    gc->state.light.dirtyLights = (1 << gc->constants.numberOfLights)-1;
    lss = &gc->state.light.source[0];
    lsm = &gc->light.source[0];
    for (i = 0; i < numLights; i++, lss++, lsm++) {
	lss->ambient.r = DefaultBlack[0];
	lss->ambient.g = DefaultBlack[1];
	lss->ambient.b = DefaultBlack[2];
	lss->ambient.a = DefaultBlack[3];
	if (i == 0) {
	    lss->diffuse.r = DefaultWhite[0];
	    lss->diffuse.g = DefaultWhite[1];
	    lss->diffuse.b = DefaultWhite[2];
	    lss->diffuse.a = DefaultWhite[3];
	} else {
	    lss->diffuse.r = DefaultBlack[0];
	    lss->diffuse.g = DefaultBlack[1];
	    lss->diffuse.b = DefaultBlack[2];
	    lss->diffuse.a = DefaultBlack[3];
	}
        lss->lightMatrix = gc->transform.modelView->matrix;
	lss->specular = lss->diffuse;
	lss->position.z = __glOne;
	lss->positionEye.z = __glOne;
	lsm->position.z = __glOne;
        lss->direction.z = __glMinusOne;
	lss->directionEye.z = __glMinusOne;
        lss->directionEyeNorm.z = __glMinusOne;
	lsm->direction.z = __glMinusOne;
	lss->spotLightCutOffAngle = 180;
	lss->constantAttenuation = __glOne;
	lsm->spotTable = NULL;
	lsm->spotLightExponent = -1;
	lsm->cache = NULL;
    }
    gc->state.light.colorMaterialFace = GL_FRONT_AND_BACK;
    gc->state.light.colorMaterialParam = GL_AMBIENT_AND_DIFFUSE;
    gc->state.light.shadingModel = GL_SMOOTH;

    /* GL_HINT_BIT state */
    gc->state.hints.perspectiveCorrection = GL_DONT_CARE;
    gc->state.hints.pointSmooth = GL_DONT_CARE;
    gc->state.hints.lineSmooth = GL_DONT_CARE;
    gc->state.hints.polygonSmooth = GL_DONT_CARE;
    gc->state.hints.fog = GL_DONT_CARE;
#ifdef GL_WIN_phong_shading
    gc->state.hints.phong = GL_DONT_CARE;
#endif //GL_WIN_phong_shading

    /* GL_CURRENT_BIT state */
    gc->state.current.rasterPos.window.x = gc->constants.fviewportXAdjust;
    gc->state.current.rasterPos.window.y = gc->constants.fviewportYAdjust;
    gc->state.current.rasterPos.clip.w = __glOne;
    gc->state.current.rasterPos.texture.w = __glOne;
    gc->state.current.rasterPos.color
	= &gc->state.current.rasterPos.colors[__GL_FRONTFACE];
    if (gc->modes.rgbMode) {
	gc->state.current.rasterPos.colors[__GL_FRONTFACE].r = DefaultWhite[0];
	gc->state.current.rasterPos.colors[__GL_FRONTFACE].g = DefaultWhite[1];
	gc->state.current.rasterPos.colors[__GL_FRONTFACE].b = DefaultWhite[2];
	gc->state.current.rasterPos.colors[__GL_FRONTFACE].a = DefaultWhite[3];
    } else {
	gc->state.current.rasterPos.colors[__GL_FRONTFACE].r = __glOne;
    }
    gc->state.current.validRasterPos = GL_TRUE;
    gc->state.current.edgeTag = GL_TRUE;

    /* GL_FOG_BIT state */
    gc->state.fog.mode = GL_EXP;
    gc->state.fog.density = __glOne;
#ifdef NT
    gc->state.fog.density2neg = -(__glOne);
#endif
    gc->state.fog.end = (__GLfloat) 1.0;
    gc->state.fog.flags = __GL_FOG_GRAY_RGB; // default fog color is 0,0,0,0

    /* GL_POINT_BIT state */
    gc->state.point.requestedSize = (__GLfloat) 1.0;
    gc->state.point.smoothSize = (__GLfloat) 1.0;
    gc->state.point.aliasedSize = 1;

    /* GL_LINE_BIT state */
    gc->state.line.requestedWidth = (__GLfloat) 1.0;
    gc->state.line.smoothWidth = (__GLfloat) 1.0;
    gc->state.line.aliasedWidth = 1;
    gc->state.line.stipple = 0xFFFF;
    gc->state.line.stippleRepeat = 1;

    /* GL_POLYGON_BIT state */
    gc->state.polygon.frontMode = GL_FILL;
    gc->state.polygon.backMode = GL_FILL;
    gc->state.polygon.cull = GL_BACK;
    gc->state.polygon.frontFaceDirection = GL_CCW;

    /* GL_POLYGON_STIPPLE_BIT state */
    for (i = 0; i < 4*32; i++) {
	gc->state.polygonStipple.stipple[i] = 0xFF;
    }
    for (i = 0; i < 32; i++) {
	gc->polygon.stipple[i] = 0xFFFFFFFF;
    }

    /* GL_ACCUM_BUFFER_BIT state */

    /* GL_STENCIL_BUFFER_BIT state */
    gc->state.stencil.testFunc = GL_ALWAYS;
    gc->state.stencil.mask = __GL_MAX_STENCIL_VALUE;
    gc->state.stencil.fail = GL_KEEP;
    gc->state.stencil.depthFail = GL_KEEP;
    gc->state.stencil.depthPass = GL_KEEP;
    gc->state.stencil.writeMask = __GL_MAX_STENCIL_VALUE;

    /* GL_DEPTH_BUFFER_BIT state */
    gc->state.depth.writeEnable = GL_TRUE;
    gc->state.depth.testFunc = GL_LESS;
    gc->state.depth.clear = __glOne;

    /* GL_COLOR_BUFFER_BIT state */
    gc->renderMode = GL_RENDER;
    gc->state.raster.alphaFunction = GL_ALWAYS;
    gc->state.raster.blendSrc = GL_ONE;
    gc->state.raster.blendDst = GL_ZERO;
    gc->state.raster.logicOp = GL_COPY;
    gc->state.raster.rMask = GL_TRUE;
    gc->state.raster.gMask = GL_TRUE;
    gc->state.raster.bMask = GL_TRUE;
    gc->state.raster.aMask = GL_TRUE;
    if (gc->modes.doubleBufferMode) {
	gc->state.raster.drawBuffer = GL_BACK;
    } else {
	gc->state.raster.drawBuffer = GL_FRONT;
    }
    gc->state.raster.drawBufferReturn = gc->state.raster.drawBuffer;
    gc->state.current.userColor.r = (__GLfloat) 1.0;
    gc->state.current.userColor.g = (__GLfloat) 1.0;
    gc->state.current.userColor.b = (__GLfloat) 1.0;
    gc->state.current.userColor.a = (__GLfloat) 1.0;
    gc->state.current.userColorIndex = (__GLfloat) 1.0;
    if (gc->modes.colorIndexMode) {
	gc->state.raster.writeMask = (gc)->frontBuffer.redMax;
    }
    gc->state.enables.general |= __GL_DITHER_ENABLE;

    gc->select.hit = GL_FALSE;
    gc->select.sp = gc->select.stack;

    /*
    ** Initialize larger subsystems by calling their init codes.
    */
    __glInitEvaluatorState(gc);
    __glInitTextureState(gc);
    __glInitPixelState(gc);
    __glInitLUTCache(gc);
#ifdef NT
    __glInitVertexArray(gc);
#endif
#ifdef _MCD_
    MCD_STATE_DIRTY(gc, ALL);
#endif
}

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

/*
** Free any attribute state left on the stack.  Stop at the first
** zero in the array.
*/
void FASTCALL __glFreeAttributeState(__GLcontext *gc)
{
    __GLattribute *sp, **spp;

    for (spp = &gc->attributes.stack[0];
	 spp < &gc->attributes.stack[gc->constants.maxAttribStackDepth];
	 spp++) {
	if (sp = *spp) {
	    GCFREE(gc, sp);
	} else
	    break;
    }
    GCFREE(gc, gc->attributes.stack);
}

void FASTCALL __glFreeClientAttributeState(__GLcontext *gc)
{
    __GLclientAttribute *sp, **spp;

    for (spp = &gc->clientAttributes.stack[0];
	 spp < &gc->clientAttributes.stack[gc->constants.maxClientAttribStackDepth];
	 spp++) {
	if (sp = *spp) {
	    GCFREE(gc, sp);
	} else
	    break;
    }
    GCFREE(gc, gc->clientAttributes.stack);
}

/*
** Destroy a context.  If it's the current context then the
** current context is set to GL_NULL.
*/
void FASTCALL __glDestroyContext(__GLcontext *gc)
{
    __GLcontext *oldgc;

    oldgc = (__GLcontext *)GLTEB_SRVCONTEXT();

#ifndef NT
    /* Set the global context to the one we are destroying. */
    __gl_context = gc;
#else
    // Set paTeb to NULL for now.  If we ever need to reference pa in this
    // function, then set it up appropriately.
    gc->paTeb = NULL;
    GLTEB_SET_SRVCONTEXT(gc);

    /*
    ** Need to pop all pushed attributes to free storage.
    ** Then it will be safe to delete stack entries.
    */
    if (gc->attributes.stack) {
        while (gc->attributes.stackPointer > &gc->attributes.stack[0]) {
            (void) __glInternalPopAttrib(gc, GL_TRUE);
        }
    }
    if (gc->clientAttributes.stack) {
        while (gc->clientAttributes.stackPointer > &gc->clientAttributes.stack[0]) {
            (void) __glInternalPopClientAttrib(gc, GL_FALSE, GL_TRUE);
        }
    }
#endif

    GCFREE(gc, gc->state.light.source);
    GCFREE(gc, gc->light.source);
#ifdef NT
    // now lazy allocated
    if (gc->select.stack)
#endif
	GCFREE(gc, gc->select.stack);

    GCFREE(gc, gc->state.transform.eyeClipPlanes);
    GCFREE(gc, gc->transform.modelViewStack);
    GCFREE(gc, gc->transform.projectionStack);
    GCFREE(gc, gc->transform.textureStack);
    GCFREE(gc, gc->transform.clipTemp);

    GCFREE(gc, gc->alphaTestFuncTable);
#ifdef NT
    // they are one memory allocation.
    GCFREE(gc, gc->stencilBuffer.testFuncTable);
#else
    GCFREE(gc, gc->stencilBuffer.testFuncTable);
    GCFREE(gc, gc->stencilBuffer.failOpTable);
    GCFREE(gc, gc->stencilBuffer.depthFailOpTable);
    GCFREE(gc, gc->stencilBuffer.depthPassOpTable);
#endif

    /*
    ** Free other malloc'd data associated with the context
    */
    __glFreeEvaluatorState(gc);
    __glFreePixelState(gc);
    __glFreeDlistState(gc);
    if (gc->attributes.stack)   __glFreeAttributeState(gc);
    if (gc->clientAttributes.stack)   __glFreeClientAttributeState(gc);
    if (gc->texture.texture)  __glFreeTextureState(gc);
    if (gc->light.lutCache)   __glFreeLUTCache(gc);

#ifdef NT
    // Free the vertex buffer.
    PolyArrayFreeBuffer(gc);
#endif

#if __GL_NUMBER_OF_AUX_BUFFERS > 0
    /*
    ** Free any aux color buffer records
    ** Note: Does not free the actual buffer memory, this is done elsewhere.
    */
    if (gc->auxBuffer) GCFREE(gc, gc->auxBuffer);
#endif

    /*
    ** Note: We do not free the software buffers here.  They are attached
    ** to the drawable, and is the glx extension's responsibility to free
    ** them when the drawable is destroyed.
    */

    FREE(gc);

    if (gc == oldgc) oldgc = NULL;
#ifndef NT
    __gl_context = oldgc;
#else
    GLTEB_SET_SRVCONTEXT(oldgc);
#endif
}

#ifdef NT
// See also __glSetError
void FASTCALL __glSetErrorEarly(__GLcontext *gc, GLenum code)
{
    if (gc == (__GLcontext *) NULL)
        return;

    if (!gc->error)
	gc->error = code;

    ASSERTOPENGL(gc->error == 0
        || (gc->error >= GL_INVALID_ENUM && gc->error <= GL_OUT_OF_MEMORY),
        "Bad error code in gc\n");

    DBGLEVEL2(LEVEL_INFO, "__glSetError error: %ld (0x%lX)\n", code, code);

#if 0
    try
    {
	DebugBreak();
    }
    finally
    {
    }
#endif
}
#endif // NT

void FASTCALL __glSetError(GLenum code)
{
    __GL_SETUP();

    __glSetErrorEarly(gc, code);
}

GLint APIPRIVATE __glim_RenderMode(GLenum mode)
{
    GLint rv;
    __GL_SETUP_NOT_IN_BEGIN2();

    switch (mode) {
      case GL_RENDER:
      case GL_FEEDBACK:
      case GL_SELECT:
	break;
      default:
	__glSetError(GL_INVALID_ENUM);
	return 0;
    }

    /* Switch out of old render mode.  Get return value. */
    switch (gc->renderMode) {
      case GL_RENDER:
	rv = 0;
	break;
      case GL_FEEDBACK:
	rv = gc->feedback.overFlowed ? -1 :
	    (GLint)((ULONG_PTR)(gc->feedback.result - gc->feedback.resultBase));
	break;
      case GL_SELECT:
	rv = gc->select.overFlowed ? -1 : gc->select.hits;
	break;
    }

    switch (mode) {
      case GL_FEEDBACK:
	if (!gc->feedback.resultBase) {
	    __glSetError(GL_INVALID_OPERATION);
	    return rv;
	}
	gc->feedback.result = gc->feedback.resultBase;
	gc->feedback.overFlowed = GL_FALSE;
	break;
      case GL_SELECT:
	if (!gc->select.stack)
	{
	    gc->select.stack = (GLuint*) GCALLOCZ
		(gc, gc->constants.maxNameStackDepth*sizeof(GLuint));
	    if (!gc->select.stack)
	    {
		__glSetError(GL_OUT_OF_MEMORY);
		return rv;
	    }
	}
	if (!gc->select.resultBase) {
	    __glSetError(GL_INVALID_OPERATION);
	    return rv;
	}
	gc->select.result = gc->select.resultBase;
	gc->select.overFlowed = GL_FALSE;
	gc->select.sp = gc->select.stack;
	gc->select.hit = GL_FALSE;
	gc->select.hits = 0;
	gc->select.z = 0;
	break;
    }
    /* Switch to new render mode - do this last! */
    if (gc->renderMode == mode) return rv;
    gc->renderMode = mode;
    __GL_DELAY_VALIDATE(gc);
    return rv;
}