Initial revision

1 files changed, 2388 insertions, 0 deletions

diff --git a/src/mesa/main/context.c b/src/mesa/main/context.c
new file mode 100644
index 00000000000..55c74678213
--- /dev/null
+++ b/src/mesa/main/context.c
@@ -0,0 +1,2388 @@
+/* $Id: context.c,v 1.1 1999/08/19 00:55:41 jtg Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.1
+ *
+ * Copyright (C) 1999  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+/*
+ * If multi-threading is enabled (-DTHREADS) then each thread has it's
+ * own rendering context.  A thread obtains the pointer to its GLcontext
+ * with the gl_get_thread_context() function.  Otherwise, the global
+ * pointer, CC, points to the current context used by all threads in
+ * the address space.
+ */
+
+
+
+#ifdef PC_HEADER
+#include "all.h"
+#else
+#include <assert.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "accum.h"
+#include "alphabuf.h"
+#include "api.h"
+#include "clip.h"
+#include "context.h"
+#include "cva.h"
+#include "depth.h"
+#include "dlist.h"
+#include "eval.h"
+#include "enums.h"
+#include "fog.h"
+#include "hash.h"
+#include "light.h"
+#include "lines.h"
+#include "dlist.h"
+#include "macros.h"
+#include "matrix.h"
+#include "mmath.h"
+#include "pb.h"
+#include "pipeline.h"
+#include "points.h"
+#include "pointers.h"
+#include "quads.h"
+#include "shade.h"
+#include "simple_list.h"
+#include "stencil.h"
+#include "stages.h"
+#include "triangle.h"
+#include "translate.h"
+#include "teximage.h"
+#include "texobj.h"
+#include "texstate.h"
+#include "texture.h"
+#include "types.h"
+#include "varray.h"
+#include "vb.h"
+#include "vbcull.h"
+#include "vbfill.h"
+#include "vbrender.h"
+#include "vbxform.h"
+#include "xform.h"
+#ifdef XFree86Server
+#include "GL/xf86glx.h"
+#endif
+#endif
+
+
+
+/**********************************************************************/
+/*****                  Context and Thread management             *****/
+/**********************************************************************/
+
+
+#ifdef THREADS
+
+#include "mthreads.h" /* Mesa platform independent threads interface */
+
+static MesaTSD mesa_ctx_tsd;
+
+static void mesa_ctx_thread_init() {
+  MesaInitTSD(&mesa_ctx_tsd);
+}
+
+GLcontext *gl_get_thread_context( void ) {
+  return (GLcontext *) MesaGetTSD(&mesa_ctx_tsd);
+}
+
+static void set_thread_context( GLcontext *ctx ) {
+  MesaSetTSD(&mesa_ctx_tsd, ctx, mesa_ctx_thread_init);
+}
+
+
+#else
+
+/* One Current Context pointer for all threads in the address space */
+GLcontext *CC = NULL;
+struct immediate *CURRENT_INPUT = NULL;
+
+#endif /*THREADS*/
+
+
+
+
+/**********************************************************************/
+/*****                   Profiling functions                      *****/
+/**********************************************************************/
+
+#ifdef PROFILE
+
+#include <sys/times.h>
+#include <sys/param.h>
+
+
+/*
+ * Return system time in seconds.
+ * NOTE:  this implementation may not be very portable!
+ */
+GLdouble gl_time( void )
+{
+   static GLdouble prev_time = 0.0;
+   static GLdouble time;
+   struct tms tm;
+   clock_t clk;
+
+   clk = times(&tm);
+
+#ifdef CLK_TCK
+   time = (double)clk / (double)CLK_TCK;
+#else
+   time = (double)clk / (double)HZ;
+#endif
+
+   if (time>prev_time) {
+      prev_time = time;
+      return time;
+   }
+   else {
+      return prev_time;
+   }
+}
+
+/*
+ * Reset the timing/profiling counters
+ */
+static void init_timings( GLcontext *ctx )
+{
+   ctx->BeginEndCount = 0;
+   ctx->BeginEndTime = 0.0;
+   ctx->VertexCount = 0;
+   ctx->VertexTime = 0.0;
+   ctx->PointCount = 0;
+   ctx->PointTime = 0.0;
+   ctx->LineCount = 0;
+   ctx->LineTime = 0.0;
+   ctx->PolygonCount = 0;
+   ctx->PolygonTime = 0.0;
+   ctx->ClearCount = 0;
+   ctx->ClearTime = 0.0;
+   ctx->SwapCount = 0;
+   ctx->SwapTime = 0.0;
+}
+
+
+/*
+ * Print the accumulated timing/profiling data.
+ */
+static void print_timings( GLcontext *ctx )
+{
+   GLdouble beginendrate;
+   GLdouble vertexrate;
+   GLdouble pointrate;
+   GLdouble linerate;
+   GLdouble polygonrate;
+   GLdouble overhead;
+   GLdouble clearrate;
+   GLdouble swaprate;
+   GLdouble avgvertices;
+
+   if (ctx->BeginEndTime>0.0) {
+      beginendrate = ctx->BeginEndCount / ctx->BeginEndTime;
+   }
+   else {
+      beginendrate = 0.0;
+   }
+   if (ctx->VertexTime>0.0) {
+      vertexrate = ctx->VertexCount / ctx->VertexTime;
+   }
+   else {
+      vertexrate = 0.0;
+   }
+   if (ctx->PointTime>0.0) {
+      pointrate = ctx->PointCount / ctx->PointTime;
+   }
+   else {
+      pointrate = 0.0;
+   }
+   if (ctx->LineTime>0.0) {
+      linerate = ctx->LineCount / ctx->LineTime;
+   }
+   else {
+      linerate = 0.0;
+   }
+   if (ctx->PolygonTime>0.0) {
+      polygonrate = ctx->PolygonCount / ctx->PolygonTime;
+   }
+   else {
+      polygonrate = 0.0;
+   }
+   if (ctx->ClearTime>0.0) {
+      clearrate = ctx->ClearCount / ctx->ClearTime;
+   }
+   else {
+      clearrate = 0.0;
+   }
+   if (ctx->SwapTime>0.0) {
+      swaprate = ctx->SwapCount / ctx->SwapTime;
+   }
+   else {
+      swaprate = 0.0;
+   }
+
+   if (ctx->BeginEndCount>0) {
+      avgvertices = (GLdouble) ctx->VertexCount / (GLdouble) ctx->BeginEndCount;
+   }
+   else {
+      avgvertices = 0.0;
+   }
+
+   overhead = ctx->BeginEndTime - ctx->VertexTime - ctx->PointTime
+              - ctx->LineTime - ctx->PolygonTime;
+
+
+   printf("                          Count   Time (s)    Rate (/s) \n");
+   printf("--------------------------------------------------------\n");
+   printf("glBegin/glEnd           %7d  %8.3f   %10.3f\n",
+          ctx->BeginEndCount, ctx->BeginEndTime, beginendrate);
+   printf("  vertexes transformed  %7d  %8.3f   %10.3f\n",
+          ctx->VertexCount, ctx->VertexTime, vertexrate );
+   printf("  points rasterized     %7d  %8.3f   %10.3f\n",
+          ctx->PointCount, ctx->PointTime, pointrate );
+   printf("  lines rasterized      %7d  %8.3f   %10.3f\n",
+          ctx->LineCount, ctx->LineTime, linerate );
+   printf("  polygons rasterized   %7d  %8.3f   %10.3f\n",
+          ctx->PolygonCount, ctx->PolygonTime, polygonrate );
+   printf("  overhead                       %8.3f\n", overhead );
+   printf("glClear                 %7d  %8.3f   %10.3f\n",
+          ctx->ClearCount, ctx->ClearTime, clearrate );
+   printf("SwapBuffers             %7d  %8.3f   %10.3f\n",
+          ctx->SwapCount, ctx->SwapTime, swaprate );
+   printf("\n");
+
+   printf("Average number of vertices per begin/end: %8.3f\n", avgvertices );
+}
+#endif
+
+
+
+
+
+/**********************************************************************/
+/*****       Context allocation, initialization, destroying       *****/
+/**********************************************************************/
+
+
+/*
+ * This function just calls all the various one-time-init functions in Mesa.
+ */
+static void one_time_init( void )
+{
+   static GLboolean alreadyCalled = GL_FALSE;
+   if (!alreadyCalled) {
+      gl_init_clip();
+      gl_init_eval();
+      gl_init_fog();
+      gl_init_math();
+      gl_init_lists();
+      gl_init_shade();
+      gl_init_texture();
+      gl_init_transformation();
+      gl_init_translate();
+      gl_init_vbrender();
+      gl_init_vbxform();
+      alreadyCalled = GL_TRUE;
+   }
+#if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
+   fprintf(stderr, "Mesa DEBUG build %s %s\n", __DATE__, __TIME__);
+#endif
+}
+
+
+/*
+ * Allocate and initialize a shared context state structure.
+ */
+static struct gl_shared_state *alloc_shared_state( void )
+{
+   GLuint i;
+   struct gl_shared_state *ss;
+   GLboolean outOfMemory;
+
+   ss = (struct gl_shared_state*) calloc( 1, sizeof(struct gl_shared_state) );
+   if (!ss)
+      return NULL;
+
+   ss->DisplayList = NewHashTable();
+
+   ss->TexObjects = NewHashTable();
+
+   /* Default Texture objects */
+   outOfMemory = GL_FALSE;
+   for (i=0;i<MAX_TEXTURE_UNITS;i++) {
+      GLuint d;
+      for (d = 1 ; d <= 3 ; d++) {
+	 ss->DefaultD[d][i] = gl_alloc_texture_object(ss, 0, d);
+	 if (!ss->DefaultD[d][i]) {
+	    outOfMemory = GL_TRUE;
+	    break;
+	 }
+	 ss->DefaultD[d][i]->RefCount++; /* don't free if not in use */
+      }
+   }
+
+   if (!ss->DisplayList || !ss->TexObjects || outOfMemory) {
+      /* Ran out of memory at some point.  Free everything and return NULL */
+      if (ss->DisplayList)
+         DeleteHashTable(ss->DisplayList);
+      if (ss->TexObjects)
+         DeleteHashTable(ss->TexObjects);
+      for (i=0;i<MAX_TEXTURE_UNITS;i++) {
+         if (ss->DefaultD[1][i])
+            gl_free_texture_object(ss, ss->DefaultD[1][i]);
+         if (ss->DefaultD[2][i])
+            gl_free_texture_object(ss, ss->DefaultD[2][i]);
+         if (ss->DefaultD[3][i])
+            gl_free_texture_object(ss, ss->DefaultD[3][i]);
+      }
+      free(ss);
+      return NULL;
+   }
+   else {
+      return ss;
+   }
+}
+
+
+/*
+ * Deallocate a shared state context and all children structures.
+ */
+static void free_shared_state( GLcontext *ctx, struct gl_shared_state *ss )
+{
+   /* Free display lists */
+   while (1) {
+      GLuint list = HashFirstEntry(ss->DisplayList);
+      if (list) {
+         gl_destroy_list(ctx, list);
+      }
+      else {
+         break;
+      }
+   }
+   DeleteHashTable(ss->DisplayList);
+
+   /* Free texture objects */
+   while (ss->TexObjectList)
+   {
+      if (ctx->Driver.DeleteTexture)
+         (*ctx->Driver.DeleteTexture)( ctx, ss->TexObjectList );
+      /* this function removes from linked list too! */
+      gl_free_texture_object(ss, ss->TexObjectList);
+   }
+   DeleteHashTable(ss->TexObjects);
+
+   free(ss);
+}
+
+
+
+
+
+
+/*
+ * Initialize the nth light.  Note that the defaults for light 0 are
+ * different than the other lights.
+ */
+static void init_light( struct gl_light *l, GLuint n )
+{
+   make_empty_list( l );
+
+   ASSIGN_4V( l->Ambient, 0.0, 0.0, 0.0, 1.0 );
+   if (n==0) {
+      ASSIGN_4V( l->Diffuse, 1.0, 1.0, 1.0, 1.0 );
+      ASSIGN_4V( l->Specular, 1.0, 1.0, 1.0, 1.0 );
+   }
+   else {
+      ASSIGN_4V( l->Diffuse, 0.0, 0.0, 0.0, 1.0 );
+      ASSIGN_4V( l->Specular, 0.0, 0.0, 0.0, 1.0 );
+   }
+   ASSIGN_4V( l->EyePosition, 0.0, 0.0, 1.0, 0.0 );
+   ASSIGN_3V( l->EyeDirection, 0.0, 0.0, -1.0 );
+   l->SpotExponent = 0.0;
+   gl_compute_spot_exp_table( l );
+   l->SpotCutoff = 180.0;
+   l->CosCutoff = 0.0;		/* KW: -ve values not admitted */
+   l->ConstantAttenuation = 1.0;
+   l->LinearAttenuation = 0.0;
+   l->QuadraticAttenuation = 0.0;
+   l->Enabled = GL_FALSE;
+}
+
+
+
+static void init_lightmodel( struct gl_lightmodel *lm )
+{
+   ASSIGN_4V( lm->Ambient, 0.2, 0.2, 0.2, 1.0 );
+   lm->LocalViewer = GL_FALSE;
+   lm->TwoSide = GL_FALSE;
+   lm->ColorControl = GL_SINGLE_COLOR;
+}
+
+
+static void init_material( struct gl_material *m )
+{
+   ASSIGN_4V( m->Ambient,  0.2, 0.2, 0.2, 1.0 );
+   ASSIGN_4V( m->Diffuse,  0.8, 0.8, 0.8, 1.0 );
+   ASSIGN_4V( m->Specular, 0.0, 0.0, 0.0, 1.0 );
+   ASSIGN_4V( m->Emission, 0.0, 0.0, 0.0, 1.0 );
+   m->Shininess = 0.0;
+   m->AmbientIndex = 0;
+   m->DiffuseIndex = 1;
+   m->SpecularIndex = 1;
+}
+
+
+
+static void init_texture_unit( GLcontext *ctx, GLuint unit )
+{
+   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
+
+   texUnit->EnvMode = GL_MODULATE;
+   ASSIGN_4V( texUnit->EnvColor, 0.0, 0.0, 0.0, 0.0 );
+   texUnit->TexGenEnabled = 0;
+   texUnit->GenModeS = GL_EYE_LINEAR;
+   texUnit->GenModeT = GL_EYE_LINEAR;
+   texUnit->GenModeR = GL_EYE_LINEAR;
+   texUnit->GenModeQ = GL_EYE_LINEAR;
+   /* Yes, these plane coefficients are correct! */
+   ASSIGN_4V( texUnit->ObjectPlaneS, 1.0, 0.0, 0.0, 0.0 );
+   ASSIGN_4V( texUnit->ObjectPlaneT, 0.0, 1.0, 0.0, 0.0 );
+   ASSIGN_4V( texUnit->ObjectPlaneR, 0.0, 0.0, 0.0, 0.0 );
+   ASSIGN_4V( texUnit->ObjectPlaneQ, 0.0, 0.0, 0.0, 0.0 );
+   ASSIGN_4V( texUnit->EyePlaneS, 1.0, 0.0, 0.0, 0.0 );
+   ASSIGN_4V( texUnit->EyePlaneT, 0.0, 1.0, 0.0, 0.0 );
+   ASSIGN_4V( texUnit->EyePlaneR, 0.0, 0.0, 0.0, 0.0 );
+   ASSIGN_4V( texUnit->EyePlaneQ, 0.0, 0.0, 0.0, 0.0 );
+
+   texUnit->CurrentD[1] = ctx->Shared->DefaultD[1][unit];
+   texUnit->CurrentD[2] = ctx->Shared->DefaultD[2][unit];
+   texUnit->CurrentD[3] = ctx->Shared->DefaultD[3][unit];
+}
+
+
+static void init_fallback_arrays( GLcontext *ctx )
+{
+   struct gl_client_array *cl;
+   GLuint i;
+
+   cl = &ctx->Fallback.Normal;
+   cl->Size = 3;
+   cl->Type = GL_FLOAT;
+   cl->Stride = 0;
+   cl->StrideB = 0;
+   cl->Ptr = (void *) ctx->Current.Normal;
+   cl->Enabled = 1;
+
+   cl = &ctx->Fallback.Color;
+   cl->Size = 4;
+   cl->Type = GL_UNSIGNED_BYTE;
+   cl->Stride = 0;
+   cl->StrideB = 0;
+   cl->Ptr = (void *) ctx->Current.ByteColor;
+   cl->Enabled = 1;
+
+   cl = &ctx->Fallback.Index;
+   cl->Size = 1;
+   cl->Type = GL_UNSIGNED_INT;
+   cl->Stride = 0;
+   cl->StrideB = 0;
+   cl->Ptr = (void *) &ctx->Current.Index;
+   cl->Enabled = 1;
+
+   for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++) {
+      cl = &ctx->Fallback.TexCoord[i];
+      cl->Size = 4;
+      cl->Type = GL_FLOAT;
+      cl->Stride = 0;
+      cl->StrideB = 0;
+      cl->Ptr = (void *) ctx->Current.Texcoord[i];
+      cl->Enabled = 1;
+   }
+
+   cl = &ctx->Fallback.EdgeFlag;
+   cl->Size = 1;
+   cl->Type = GL_UNSIGNED_BYTE;
+   cl->Stride = 0;
+   cl->StrideB = 0;
+   cl->Ptr = (void *) &ctx->Current.EdgeFlag;
+   cl->Enabled = 1;
+}
+
+/* Initialize a 1-D evaluator map */
+static void init_1d_map( struct gl_1d_map *map, int n, const float *initial )
+{
+   map->Order = 1;
+   map->u1 = 0.0;
+   map->u2 = 1.0;
+   map->Points = (GLfloat *) malloc(n * sizeof(GLfloat));
+   if (map->Points) {
+      GLint i;
+      for (i=0;i<n;i++)
+         map->Points[i] = initial[i];
+   }
+   map->Retain = GL_FALSE;
+}
+
+
+/* Initialize a 2-D evaluator map */
+static void init_2d_map( struct gl_2d_map *map, int n, const float *initial )
+{
+   map->Uorder = 1;
+   map->Vorder = 1;
+   map->u1 = 0.0;
+   map->u2 = 1.0;
+   map->v1 = 0.0;
+   map->v2 = 1.0;
+   map->Points = (GLfloat *) malloc(n * sizeof(GLfloat));
+   if (map->Points) {
+      GLint i;
+      for (i=0;i<n;i++)
+         map->Points[i] = initial[i];
+   }
+   map->Retain = GL_FALSE;
+}
+
+
+
+/*
+ * Initialize a gl_context structure to default values.
+ */
+static void initialize_context( GLcontext *ctx )
+{
+   GLuint i, j;
+
+   if (ctx) {
+      /* Constants, may be overriden by device driver */
+      ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
+      ctx->Const.MaxTextureSize = 1 << (MAX_TEXTURE_LEVELS - 1);
+      ctx->Const.MaxTextureUnits = MAX_TEXTURE_UNITS;
+      ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
+
+
+      /* Modelview matrix */
+      gl_matrix_ctr( &ctx->ModelView );
+      gl_matrix_alloc_inv( &ctx->ModelView );
+
+      ctx->ModelViewStackDepth = 0;
+      for (i = 0 ; i < MAX_MODELVIEW_STACK_DEPTH ; i++) {
+	 gl_matrix_ctr( &ctx->ModelViewStack[i] );
+	 gl_matrix_alloc_inv( &ctx->ModelViewStack[i] );
+      }
+
+      /* Projection matrix - need inv for user clipping in clip space*/
+      gl_matrix_ctr( &ctx->ProjectionMatrix );
+      gl_matrix_alloc_inv( &ctx->ProjectionMatrix );
+
+      gl_matrix_ctr( &ctx->ModelProjectMatrix );
+      gl_matrix_ctr( &ctx->ModelProjectWinMatrix );
+      ctx->ModelProjectWinMatrixUptodate = GL_FALSE;
+
+      ctx->ProjectionStackDepth = 0;
+      ctx->NearFarStack[0][0] = 1.0; /* These values seem weird by make */
+      ctx->NearFarStack[0][1] = 0.0; /* sense mathematically. */
+
+      for (i = 0 ; i < MAX_PROJECTION_STACK_DEPTH ; i++) {
+	 gl_matrix_ctr( &ctx->ProjectionStack[i] );
+	 gl_matrix_alloc_inv( &ctx->ProjectionStack[i] );
+      }
+
+      /* Texture matrix */
+      for (i=0; i<MAX_TEXTURE_UNITS; i++) {
+	 gl_matrix_ctr( &ctx->TextureMatrix[i] );
+	 ctx->TextureStackDepth[i] = 0;
+	 for (j = 0 ; j < MAX_TEXTURE_STACK_DEPTH ; j++) {
+	    ctx->TextureStack[i][j].inv = 0;
+	 }
+      }
+
+      /* Accumulate buffer group */
+      ASSIGN_4V( ctx->Accum.ClearColor, 0.0, 0.0, 0.0, 0.0 );
+
+      /* Color buffer group */
+      ctx->Color.IndexMask = 0xffffffff;
+      ctx->Color.ColorMask[0] = 0xff;
+      ctx->Color.ColorMask[1] = 0xff;
+      ctx->Color.ColorMask[2] = 0xff;
+      ctx->Color.ColorMask[3] = 0xff;
+      ctx->Color.SWmasking = GL_FALSE;
+      ctx->Color.ClearIndex = 0;
+      ASSIGN_4V( ctx->Color.ClearColor, 0.0, 0.0, 0.0, 0.0 );
+      ctx->Color.DrawBuffer = GL_FRONT;
+      ctx->Color.AlphaEnabled = GL_FALSE;
+      ctx->Color.AlphaFunc = GL_ALWAYS;
+      ctx->Color.AlphaRef = 0;
+      ctx->Color.BlendEnabled = GL_FALSE;
+      ctx->Color.BlendSrcRGB = GL_ONE;
+      ctx->Color.BlendDstRGB = GL_ZERO;
+      ctx->Color.BlendSrcA = GL_ONE;
+      ctx->Color.BlendDstA = GL_ZERO;
+      ctx->Color.BlendEquation = GL_FUNC_ADD_EXT;
+      ctx->Color.BlendFunc = NULL;  /* this pointer set only when needed */
+      ASSIGN_4V( ctx->Color.BlendColor, 0.0, 0.0, 0.0, 0.0 );
+      ctx->Color.IndexLogicOpEnabled = GL_FALSE;
+      ctx->Color.ColorLogicOpEnabled = GL_FALSE;
+      ctx->Color.SWLogicOpEnabled = GL_FALSE;
+      ctx->Color.LogicOp = GL_COPY;
+      ctx->Color.DitherFlag = GL_TRUE;
+      ctx->Color.MultiDrawBuffer = GL_FALSE;
+
+      /* Current group */
+      ASSIGN_4V( ctx->Current.ByteColor, 255, 255, 255, 255);
+      ctx->Current.Index = 1;
+      for (i=0; i<MAX_TEXTURE_UNITS; i++)
+         ASSIGN_4V( ctx->Current.Texcoord[i], 0.0, 0.0, 0.0, 1.0 );
+      ASSIGN_4V( ctx->Current.RasterPos, 0.0, 0.0, 0.0, 1.0 );
+      ctx->Current.RasterDistance = 0.0;
+      ASSIGN_4V( ctx->Current.RasterColor, 1.0, 1.0, 1.0, 1.0 );
+      ctx->Current.RasterIndex = 1;
+      for (i=0; i<MAX_TEXTURE_UNITS; i++)
+         ASSIGN_4V( ctx->Current.RasterMultiTexCoord[i], 0.0, 0.0, 0.0, 1.0 );
+      ctx->Current.RasterTexCoord = ctx->Current.RasterMultiTexCoord[0];
+      ctx->Current.RasterPosValid = GL_TRUE;
+      ctx->Current.EdgeFlag = GL_TRUE;
+      ASSIGN_3V( ctx->Current.Normal, 0.0, 0.0, 1.0 );
+      ctx->Current.Primitive = (GLenum) (GL_POLYGON + 1);
+
+      ctx->Current.Flag = (VERT_NORM|VERT_INDEX|VERT_RGBA|VERT_EDGE|
+			   VERT_TEX0_1|VERT_TEX1_1|VERT_MATERIAL);
+
+      init_fallback_arrays( ctx );
+
+      /* Depth buffer group */
+      ctx->Depth.Test = GL_FALSE;
+      ctx->Depth.Clear = 1.0;
+      ctx->Depth.Func = GL_LESS;
+      ctx->Depth.Mask = GL_TRUE;
+
+      /* Evaluators group */
+      ctx->Eval.Map1Color4 = GL_FALSE;
+      ctx->Eval.Map1Index = GL_FALSE;
+      ctx->Eval.Map1Normal = GL_FALSE;
+      ctx->Eval.Map1TextureCoord1 = GL_FALSE;
+      ctx->Eval.Map1TextureCoord2 = GL_FALSE;
+      ctx->Eval.Map1TextureCoord3 = GL_FALSE;
+      ctx->Eval.Map1TextureCoord4 = GL_FALSE;
+      ctx->Eval.Map1Vertex3 = GL_FALSE;
+      ctx->Eval.Map1Vertex4 = GL_FALSE;
+      ctx->Eval.Map2Color4 = GL_FALSE;
+      ctx->Eval.Map2Index = GL_FALSE;
+      ctx->Eval.Map2Normal = GL_FALSE;
+      ctx->Eval.Map2TextureCoord1 = GL_FALSE;
+      ctx->Eval.Map2TextureCoord2 = GL_FALSE;
+      ctx->Eval.Map2TextureCoord3 = GL_FALSE;
+      ctx->Eval.Map2TextureCoord4 = GL_FALSE;
+      ctx->Eval.Map2Vertex3 = GL_FALSE;
+      ctx->Eval.Map2Vertex4 = GL_FALSE;
+      ctx->Eval.AutoNormal = GL_FALSE;
+      ctx->Eval.MapGrid1un = 1;
+      ctx->Eval.MapGrid1u1 = 0.0;
+      ctx->Eval.MapGrid1u2 = 1.0;
+      ctx->Eval.MapGrid2un = 1;
+      ctx->Eval.MapGrid2vn = 1;
+      ctx->Eval.MapGrid2u1 = 0.0;
+      ctx->Eval.MapGrid2u2 = 1.0;
+      ctx->Eval.MapGrid2v1 = 0.0;
+      ctx->Eval.MapGrid2v2 = 1.0;
+
+      /* Evaluator data */
+      {
+         static GLfloat vertex[4] = { 0.0, 0.0, 0.0, 1.0 };
+         static GLfloat normal[3] = { 0.0, 0.0, 1.0 };
+         static GLfloat index[1] = { 1.0 };
+         static GLfloat color[4] = { 1.0, 1.0, 1.0, 1.0 };
+         static GLfloat texcoord[4] = { 0.0, 0.0, 0.0, 1.0 };
+
+         init_1d_map( &ctx->EvalMap.Map1Vertex3, 3, vertex );
+         init_1d_map( &ctx->EvalMap.Map1Vertex4, 4, vertex );
+         init_1d_map( &ctx->EvalMap.Map1Index, 1, index );
+         init_1d_map( &ctx->EvalMap.Map1Color4, 4, color );
+         init_1d_map( &ctx->EvalMap.Map1Normal, 3, normal );
+         init_1d_map( &ctx->EvalMap.Map1Texture1, 1, texcoord );
+         init_1d_map( &ctx->EvalMap.Map1Texture2, 2, texcoord );
+         init_1d_map( &ctx->EvalMap.Map1Texture3, 3, texcoord );
+         init_1d_map( &ctx->EvalMap.Map1Texture4, 4, texcoord );
+
+         init_2d_map( &ctx->EvalMap.Map2Vertex3, 3, vertex );
+         init_2d_map( &ctx->EvalMap.Map2Vertex4, 4, vertex );
+         init_2d_map( &ctx->EvalMap.Map2Index, 1, index );
+         init_2d_map( &ctx->EvalMap.Map2Color4, 4, color );
+         init_2d_map( &ctx->EvalMap.Map2Normal, 3, normal );
+         init_2d_map( &ctx->EvalMap.Map2Texture1, 1, texcoord );
+         init_2d_map( &ctx->EvalMap.Map2Texture2, 2, texcoord );
+         init_2d_map( &ctx->EvalMap.Map2Texture3, 3, texcoord );
+         init_2d_map( &ctx->EvalMap.Map2Texture4, 4, texcoord );
+      }
+
+      /* Fog group */
+      ctx->Fog.Enabled = GL_FALSE;
+      ctx->Fog.Mode = GL_EXP;
+      ASSIGN_4V( ctx->Fog.Color, 0.0, 0.0, 0.0, 0.0 );
+      ctx->Fog.Index = 0.0;
+      ctx->Fog.Density = 1.0;
+      ctx->Fog.Start = 0.0;
+      ctx->Fog.End = 1.0;
+
+      /* Hint group */
+      ctx->Hint.PerspectiveCorrection = GL_DONT_CARE;
+      ctx->Hint.PointSmooth = GL_DONT_CARE;
+      ctx->Hint.LineSmooth = GL_DONT_CARE;
+      ctx->Hint.PolygonSmooth = GL_DONT_CARE;
+      ctx->Hint.Fog = GL_DONT_CARE;
+
+      ctx->Hint.AllowDrawWin = GL_TRUE;
+      ctx->Hint.AllowDrawSpn = GL_TRUE;
+      ctx->Hint.AllowDrawMem = GL_TRUE;
+      ctx->Hint.StrictLighting = GL_TRUE;
+
+      /* Pipeline */
+      gl_pipeline_init( ctx );
+      gl_cva_init( ctx );
+
+      /* Extensions */
+      gl_extensions_ctr( ctx );
+
+      ctx->AllowVertexCull = 0;
+
+      /* Lighting group */
+      for (i=0;i<MAX_LIGHTS;i++) {
+	 init_light( &ctx->Light.Light[i], i );
+      }
+      make_empty_list( &ctx->Light.EnabledList );
+
+      init_lightmodel( &ctx->Light.Model );
+      init_material( &ctx->Light.Material[0] );
+      init_material( &ctx->Light.Material[1] );
+      ctx->Light.ShadeModel = GL_SMOOTH;
+      ctx->Light.Enabled = GL_FALSE;
+      ctx->Light.ColorMaterialFace = GL_FRONT_AND_BACK;
+      ctx->Light.ColorMaterialMode = GL_AMBIENT_AND_DIFFUSE;
+      ctx->Light.ColorMaterialBitmask
+         = gl_material_bitmask( ctx,
+				GL_FRONT_AND_BACK,
+				GL_AMBIENT_AND_DIFFUSE, ~0, 0 );
+
+      ctx->Light.ColorMaterialEnabled = GL_FALSE;
+
+      /* Line group */
+      ctx->Line.SmoothFlag = GL_FALSE;
+      ctx->Line.StippleFlag = GL_FALSE;
+      ctx->Line.Width = 1.0;
+      ctx->Line.StipplePattern = 0xffff;
+      ctx->Line.StippleFactor = 1;
+
+      /* Display List group */
+      ctx->List.ListBase = 0;
+
+      /* Pixel group */
+      ctx->Pixel.RedBias = 0.0;
+      ctx->Pixel.RedScale = 1.0;
+      ctx->Pixel.GreenBias = 0.0;
+      ctx->Pixel.GreenScale = 1.0;
+      ctx->Pixel.BlueBias = 0.0;
+      ctx->Pixel.BlueScale = 1.0;
+      ctx->Pixel.AlphaBias = 0.0;
+      ctx->Pixel.AlphaScale = 1.0;
+      ctx->Pixel.ScaleOrBiasRGBA = GL_FALSE;
+      ctx->Pixel.DepthBias = 0.0;
+      ctx->Pixel.DepthScale = 1.0;
+      ctx->Pixel.IndexOffset = 0;
+      ctx->Pixel.IndexShift = 0;
+      ctx->Pixel.ZoomX = 1.0;
+      ctx->Pixel.ZoomY = 1.0;
+      ctx->Pixel.MapColorFlag = GL_FALSE;
+      ctx->Pixel.MapStencilFlag = GL_FALSE;
+      ctx->Pixel.MapStoSsize = 1;
+      ctx->Pixel.MapItoIsize = 1;
+      ctx->Pixel.MapItoRsize = 1;
+      ctx->Pixel.MapItoGsize = 1;
+      ctx->Pixel.MapItoBsize = 1;
+      ctx->Pixel.MapItoAsize = 1;
+      ctx->Pixel.MapRtoRsize = 1;
+      ctx->Pixel.MapGtoGsize = 1;
+      ctx->Pixel.MapBtoBsize = 1;
+      ctx->Pixel.MapAtoAsize = 1;
+      ctx->Pixel.MapStoS[0] = 0;
+      ctx->Pixel.MapItoI[0] = 0;
+      ctx->Pixel.MapItoR[0] = 0.0;
+      ctx->Pixel.MapItoG[0] = 0.0;
+      ctx->Pixel.MapItoB[0] = 0.0;
+      ctx->Pixel.MapItoA[0] = 0.0;
+      ctx->Pixel.MapItoR8[0] = 0;
+      ctx->Pixel.MapItoG8[0] = 0;
+      ctx->Pixel.MapItoB8[0] = 0;
+      ctx->Pixel.MapItoA8[0] = 0;
+      ctx->Pixel.MapRtoR[0] = 0.0;
+      ctx->Pixel.MapGtoG[0] = 0.0;
+      ctx->Pixel.MapBtoB[0] = 0.0;
+      ctx->Pixel.MapAtoA[0] = 0.0;
+
+      /* Point group */
+      ctx->Point.SmoothFlag = GL_FALSE;
+      ctx->Point.Size = 1.0;
+      ctx->Point.Params[0] = 1.0;
+      ctx->Point.Params[1] = 0.0;
+      ctx->Point.Params[2] = 0.0;
+      ctx->Point.Attenuated = GL_FALSE;
+      ctx->Point.MinSize = 0.0;
+      ctx->Point.MaxSize = (GLfloat) MAX_POINT_SIZE;
+      ctx->Point.Threshold = 1.0;
+
+      /* Polygon group */
+      ctx->Polygon.CullFlag = GL_FALSE;
+      ctx->Polygon.CullFaceMode = GL_BACK;
+      ctx->Polygon.FrontFace = GL_CCW;
+      ctx->Polygon.FrontBit = 0;
+      ctx->Polygon.FrontMode = GL_FILL;
+      ctx->Polygon.BackMode = GL_FILL;
+      ctx->Polygon.Unfilled = GL_FALSE;
+      ctx->Polygon.SmoothFlag = GL_FALSE;
+      ctx->Polygon.StippleFlag = GL_FALSE;
+      ctx->Polygon.OffsetFactor = 0.0F;
+      ctx->Polygon.OffsetUnits = 0.0F;
+      ctx->Polygon.OffsetPoint = GL_FALSE;
+      ctx->Polygon.OffsetLine = GL_FALSE;
+      ctx->Polygon.OffsetFill = GL_FALSE;
+
+      /* Polygon Stipple group */
+      MEMSET( ctx->PolygonStipple, 0xff, 32*sizeof(GLuint) );
+
+      /* Scissor group */
+      ctx->Scissor.Enabled = GL_FALSE;
+      ctx->Scissor.X = 0;
+      ctx->Scissor.Y = 0;
+      ctx->Scissor.Width = 0;
+      ctx->Scissor.Height = 0;
+
+      /* Stencil group */
+      ctx->Stencil.Enabled = GL_FALSE;
+      ctx->Stencil.Function = GL_ALWAYS;
+      ctx->Stencil.FailFunc = GL_KEEP;
+      ctx->Stencil.ZPassFunc = GL_KEEP;
+      ctx->Stencil.ZFailFunc = GL_KEEP;
+      ctx->Stencil.Ref = 0;
+      ctx->Stencil.ValueMask = 0xff;
+      ctx->Stencil.Clear = 0;
+      ctx->Stencil.WriteMask = 0xff;
+
+      /* Texture group */
+      ctx->Texture.CurrentUnit = 0;      /* multitexture */
+      ctx->Texture.CurrentTransformUnit = 0; /* multitexture */
+      ctx->Texture.Enabled = 0;
+
+      for (i=0; i<MAX_TEXTURE_UNITS; i++)
+         init_texture_unit( ctx, i );
+
+      ctx->Texture.SharedPalette = GL_FALSE;
+      ctx->Texture.Palette[0] = 255;
+      ctx->Texture.Palette[1] = 255;
+      ctx->Texture.Palette[2] = 255;
+      ctx->Texture.Palette[3] = 255;
+      ctx->Texture.PaletteSize = 1;
+      ctx->Texture.PaletteIntFormat = GL_RGBA;
+      ctx->Texture.PaletteFormat = GL_RGBA;
+
+      /* Transformation group */
+      ctx->Transform.MatrixMode = GL_MODELVIEW;
+      ctx->Transform.Normalize = GL_FALSE;
+      ctx->Transform.RescaleNormals = GL_FALSE;
+      for (i=0;i<MAX_CLIP_PLANES;i++) {
+	 ctx->Transform.ClipEnabled[i] = GL_FALSE;
+         ASSIGN_4V( ctx->Transform.EyeUserPlane[i], 0.0, 0.0, 0.0, 0.0 );
+      }
+      ctx->Transform.AnyClip = GL_FALSE;
+
+      /* Viewport group */
+      ctx->Viewport.X = 0;
+      ctx->Viewport.Y = 0;
+      ctx->Viewport.Width = 0;
+      ctx->Viewport.Height = 0;
+      ctx->Viewport.Near = 0.0;
+      ctx->Viewport.Far = 1.0;
+      gl_matrix_ctr(&ctx->Viewport.WindowMap);
+
+#define Sz 10
+#define Tz 14
+      ctx->Viewport.WindowMap.m[Sz] = 0.5 * DEPTH_SCALE;
+      ctx->Viewport.WindowMap.m[Tz] = 0.5 * DEPTH_SCALE;
+#undef Sz
+#undef Tz
+
+      ctx->Viewport.WindowMap.flags = MAT_FLAG_GENERAL_SCALE|MAT_FLAG_TRANSLATION;
+      ctx->Viewport.WindowMap.type = MATRIX_3D_NO_ROT;
+
+      /* Vertex arrays */
+      ctx->Array.Vertex.Size = 4;
+      ctx->Array.Vertex.Type = GL_FLOAT;
+      ctx->Array.Vertex.Stride = 0;
+      ctx->Array.Vertex.StrideB = 0;
+      ctx->Array.Vertex.Ptr = NULL;
+      ctx->Array.Vertex.Enabled = GL_FALSE;
+      ctx->Array.Normal.Type = GL_FLOAT;
+      ctx->Array.Normal.Stride = 0;
+      ctx->Array.Normal.StrideB = 0;
+      ctx->Array.Normal.Ptr = NULL;
+      ctx->Array.Normal.Enabled = GL_FALSE;
+      ctx->Array.Color.Size = 4;
+      ctx->Array.Color.Type = GL_FLOAT;
+      ctx->Array.Color.Stride = 0;
+      ctx->Array.Color.StrideB = 0;
+      ctx->Array.Color.Ptr = NULL;
+      ctx->Array.Color.Enabled = GL_FALSE;
+      ctx->Array.Index.Type = GL_FLOAT;
+      ctx->Array.Index.Stride = 0;
+      ctx->Array.Index.StrideB = 0;
+      ctx->Array.Index.Ptr = NULL;
+      ctx->Array.Index.Enabled = GL_FALSE;
+      for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
+         ctx->Array.TexCoord[i].Size = 4;
+         ctx->Array.TexCoord[i].Type = GL_FLOAT;
+         ctx->Array.TexCoord[i].Stride = 0;
+         ctx->Array.TexCoord[i].StrideB = 0;
+         ctx->Array.TexCoord[i].Ptr = NULL;
+         ctx->Array.TexCoord[i].Enabled = GL_FALSE;
+      }
+      ctx->Array.TexCoordInterleaveFactor = 1;
+      ctx->Array.EdgeFlag.Stride = 0;
+      ctx->Array.EdgeFlag.StrideB = 0;
+      ctx->Array.EdgeFlag.Ptr = NULL;
+      ctx->Array.EdgeFlag.Enabled = GL_FALSE;
+      ctx->Array.ActiveTexture = 0;   /* GL_ARB_multitexture */
+
+      /* Pixel transfer */
+      ctx->Pack.Alignment = 4;
+      ctx->Pack.RowLength = 0;
+      ctx->Pack.SkipPixels = 0;
+      ctx->Pack.SkipRows = 0;
+      ctx->Pack.SwapBytes = GL_FALSE;
+      ctx->Pack.LsbFirst = GL_FALSE;
+      ctx->Unpack.Alignment = 4;
+      ctx->Unpack.RowLength = 0;
+      ctx->Unpack.SkipPixels = 0;
+      ctx->Unpack.SkipRows = 0;
+      ctx->Unpack.SwapBytes = GL_FALSE;
+      ctx->Unpack.LsbFirst = GL_FALSE;
+
+      /* Feedback */
+      ctx->Feedback.Type = GL_2D;   /* TODO: verify */
+      ctx->Feedback.Buffer = NULL;
+      ctx->Feedback.BufferSize = 0;
+      ctx->Feedback.Count = 0;
+
+      /* Selection/picking */
+      ctx->Select.Buffer = NULL;
+      ctx->Select.BufferSize = 0;
+      ctx->Select.BufferCount = 0;
+      ctx->Select.Hits = 0;
+      ctx->Select.NameStackDepth = 0;
+
+      /* Optimized Accum buffer */
+      ctx->IntegerAccumMode = GL_TRUE;
+      ctx->IntegerAccumScaler = 0.0;
+
+      /* multitexture */
+      ctx->TexCoordUnit = 0;
+
+      /* Renderer and client attribute stacks */
+      ctx->AttribStackDepth = 0;
+      ctx->ClientAttribStackDepth = 0;
+
+      /*** Miscellaneous ***/
+      ctx->NewState = NEW_ALL;
+      ctx->RenderMode = GL_RENDER;
+      ctx->StippleCounter = 0;
+      ctx->NeedNormals = GL_FALSE;
+      ctx->DoViewportMapping = GL_TRUE;
+
+      ctx->NeedEyeCoords = GL_FALSE;
+      ctx->NeedEyeNormals = GL_FALSE;
+      ctx->vb_proj_matrix = &ctx->ModelProjectMatrix;
+
+      /* Display list */
+      ctx->CallDepth = 0;
+      ctx->ExecuteFlag = GL_TRUE;
+      ctx->CompileFlag = GL_FALSE;
+      ctx->CurrentListPtr = NULL;
+      ctx->CurrentBlock = NULL;
+      ctx->CurrentListNum = 0;
+      ctx->CurrentPos = 0;
+
+      ctx->ErrorValue = (GLenum) GL_NO_ERROR;
+
+      ctx->CatchSignals = GL_TRUE;
+
+      /* For debug/development only */
+      ctx->NoRaster = getenv("MESA_NO_RASTER") ? GL_TRUE : GL_FALSE;
+
+      /* Dither disable */
+      ctx->NoDither = getenv("MESA_NO_DITHER") ? GL_TRUE : GL_FALSE;
+      if (ctx->NoDither) {
+         if (getenv("MESA_DEBUG")) {
+            fprintf(stderr, "MESA_NO_DITHER set - dithering disabled\n");
+         }
+         ctx->Color.DitherFlag = GL_FALSE;
+      }
+   }
+}
+
+
+
+/*
+ * Allocate a new GLvisual object.
+ * Input:  rgbFlag - GL_TRUE=RGB(A) mode, GL_FALSE=Color Index mode
+ *         alphaFlag - alloc software alpha buffers?
+ *         dbFlag - double buffering?
+ *         stereoFlag - stereo buffer?
+ *         depthFits - requested minimum bits per depth buffer value
+ *         stencilFits - requested minimum bits per stencil buffer value
+ *         accumFits - requested minimum bits per accum buffer component
+ *         indexFits - number of bits per pixel if rgbFlag==GL_FALSE
+ *         red/green/blue/alphaFits - number of bits per color component
+ *                                     in frame buffer for RGB(A) mode.
+ * Return:  pointer to new GLvisual or NULL if requested parameters can't
+ *          be met.
+ */
+GLvisual *gl_create_visual( GLboolean rgbFlag,
+                            GLboolean alphaFlag,
+                            GLboolean dbFlag,
+                            GLboolean stereoFlag,
+                            GLint depthBits,
+                            GLint stencilBits,
+                            GLint accumBits,
+                            GLint indexBits,
+                            GLint redBits,
+                            GLint greenBits,
+                            GLint blueBits,
+                            GLint alphaBits )
+{
+   GLvisual *vis;
+
+   if (depthBits > (GLint) (8*sizeof(GLdepth))) {
+      /* can't meet depth buffer requirements */
+      return NULL;
+   }
+   if (stencilBits > (GLint) (8*sizeof(GLstencil))) {
+      /* can't meet stencil buffer requirements */
+      return NULL;
+   }
+   if (accumBits > (GLint) (8*sizeof(GLaccum))) {
+      /* can't meet accum buffer requirements */
+      return NULL;
+   }
+
+   vis = (GLvisual *) calloc( 1, sizeof(GLvisual) );
+   if (!vis) {
+      return NULL;
+   }
+
+   vis->RGBAflag   = rgbFlag;
+   vis->DBflag     = dbFlag;
+   vis->StereoFlag = stereoFlag;
+   vis->RedBits    = redBits;
+   vis->GreenBits  = greenBits;
+   vis->BlueBits   = blueBits;
+   vis->AlphaBits  = alphaFlag ? 8*sizeof(GLubyte) : alphaBits;
+
+   vis->IndexBits   = indexBits;
+   vis->DepthBits   = (depthBits>0) ? 8*sizeof(GLdepth) : 0;
+   vis->AccumBits   = (accumBits>0) ? 8*sizeof(GLaccum) : 0;
+   vis->StencilBits = (stencilBits>0) ? 8*sizeof(GLstencil) : 0;
+
+   vis->SoftwareAlpha = alphaFlag;
+
+   return vis;
+}
+
+
+
+void gl_destroy_visual( GLvisual *vis )
+{
+   free( vis );
+}
+
+
+
+/*
+ * Allocate the proxy textures.  If we run out of memory part way through
+ * the allocations clean up and return GL_FALSE.
+ * Return:  GL_TRUE=success, GL_FALSE=failure
+ */
+static GLboolean alloc_proxy_textures( GLcontext *ctx )
+{
+   GLboolean out_of_memory;
+   GLint i;
+
+   ctx->Texture.Proxy1D = gl_alloc_texture_object(NULL, 0, 1);
+   if (!ctx->Texture.Proxy1D) {
+      return GL_FALSE;
+   }
+
+   ctx->Texture.Proxy2D = gl_alloc_texture_object(NULL, 0, 2);
+   if (!ctx->Texture.Proxy2D) {
+      gl_free_texture_object(NULL, ctx->Texture.Proxy1D);
+      return GL_FALSE;
+   }
+
+   ctx->Texture.Proxy3D = gl_alloc_texture_object(NULL, 0, 3);
+   if (!ctx->Texture.Proxy3D) {
+      gl_free_texture_object(NULL, ctx->Texture.Proxy1D);
+      gl_free_texture_object(NULL, ctx->Texture.Proxy2D);
+      return GL_FALSE;
+   }
+
+   out_of_memory = GL_FALSE;
+   for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
+      ctx->Texture.Proxy1D->Image[i] = gl_alloc_texture_image();
+      ctx->Texture.Proxy2D->Image[i] = gl_alloc_texture_image();
+      ctx->Texture.Proxy3D->Image[i] = gl_alloc_texture_image();
+      if (!ctx->Texture.Proxy1D->Image[i]
+          || !ctx->Texture.Proxy2D->Image[i]
+          || !ctx->Texture.Proxy3D->Image[i]) {
+         out_of_memory = GL_TRUE;
+      }
+   }
+   if (out_of_memory) {
+      for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
+         if (ctx->Texture.Proxy1D->Image[i]) {
+            gl_free_texture_image(ctx->Texture.Proxy1D->Image[i]);
+         }
+         if (ctx->Texture.Proxy2D->Image[i]) {
+            gl_free_texture_image(ctx->Texture.Proxy2D->Image[i]);
+         }
+         if (ctx->Texture.Proxy3D->Image[i]) {
+            gl_free_texture_image(ctx->Texture.Proxy3D->Image[i]);
+         }
+      }
+      gl_free_texture_object(NULL, ctx->Texture.Proxy1D);
+      gl_free_texture_object(NULL, ctx->Texture.Proxy2D);
+      gl_free_texture_object(NULL, ctx->Texture.Proxy3D);
+      return GL_FALSE;
+   }
+   else {
+      return GL_TRUE;
+   }
+}
+
+
+
+#define MALLOC_STRUCT(T)  (struct T *) malloc( sizeof(struct T) )
+
+/*
+ * Allocate and initialize a GLcontext structure.
+ * Input:  visual - a GLvisual pointer
+ *         sharelist - another context to share display lists with or NULL
+ *         driver_ctx - pointer to device driver's context state struct
+ * Return:  pointer to a new gl_context struct or NULL if error.
+ */
+GLcontext *gl_create_context( GLvisual *visual,
+                              GLcontext *share_list,
+                              void *driver_ctx,
+                              GLboolean direct )
+{
+   GLcontext *ctx;
+   GLuint i;
+
+   (void) direct;  /* not used */
+
+   /* do some implementation tests */
+   assert( sizeof(GLbyte) == 1 );
+   assert( sizeof(GLshort) >= 2 );
+   assert( sizeof(GLint) >= 4 );
+   assert( sizeof(GLubyte) == 1 );
+   assert( sizeof(GLushort) >= 2 );
+   assert( sizeof(GLuint) >= 4 );
+
+   /* misc one-time initializations */
+   one_time_init();
+
+   ctx = (GLcontext *) calloc( 1, sizeof(GLcontext) );
+   if (!ctx) {
+      return NULL;
+   }
+
+   ctx->DriverCtx = driver_ctx;
+   ctx->Visual = visual;
+   ctx->Buffer = NULL;
+
+   ctx->VB = gl_vb_create_for_immediate( ctx );
+   if (!ctx->VB) {
+      free( ctx );
+      return NULL;
+   }
+   ctx->input = ctx->VB->IM;
+
+   ctx->PB = gl_alloc_pb();
+   if (!ctx->PB) {
+      free( ctx->VB );
+      free( ctx );
+      return NULL;
+   }
+
+   if (share_list) {
+      /* share the group of display lists of another context */
+      ctx->Shared = share_list->Shared;
+   }
+   else {
+      /* allocate new group of display lists */
+      ctx->Shared = alloc_shared_state();
+      if (!ctx->Shared) {
+         free(ctx->VB);
+         free(ctx->PB);
+         free(ctx);
+         return NULL;
+      }
+   }
+   ctx->Shared->RefCount++;
+
+   initialize_context( ctx );
+   gl_reset_vb( ctx->VB );
+   gl_reset_input( ctx );
+
+
+   ctx->ShineTabList = MALLOC_STRUCT( gl_shine_tab );
+   make_empty_list( ctx->ShineTabList );
+
+   for (i = 0 ; i < 10 ; i++) {
+      struct gl_shine_tab *s = MALLOC_STRUCT( gl_shine_tab );
+      s->shininess = -1;
+      s->refcount = 0;
+      insert_at_tail( ctx->ShineTabList, s );
+   }
+
+   for (i = 0 ; i < 4 ; i++) {
+      ctx->ShineTable[i] = ctx->ShineTabList->prev;
+      ctx->ShineTable[i]->refcount++;
+   }
+
+   if (visual->DBflag) {
+      ctx->Color.DrawBuffer = GL_BACK;
+      ctx->Color.DriverDrawBuffer = GL_BACK_LEFT;
+      ctx->Color.DrawDestMask = BACK_LEFT_BIT;
+      ctx->Pixel.ReadBuffer = GL_BACK;
+      ctx->Pixel.DriverReadBuffer = GL_BACK_LEFT;
+   }
+   else {
+      ctx->Color.DrawBuffer = GL_FRONT;
+      ctx->Color.DriverDrawBuffer = GL_FRONT_LEFT;
+      ctx->Color.DrawDestMask = FRONT_LEFT_BIT;
+      ctx->Pixel.ReadBuffer = GL_FRONT;
+      ctx->Pixel.DriverReadBuffer = GL_FRONT_LEFT;
+   }
+
+#ifdef PROFILE
+   init_timings( ctx );
+#endif
+
+#ifdef GL_VERSION_1_1
+   if (!alloc_proxy_textures(ctx)) {
+      free_shared_state(ctx, ctx->Shared);
+      free(ctx->VB);
+      free(ctx->PB);
+      free(ctx);
+      return NULL;
+   }
+#endif
+
+   gl_init_api_function_pointers( ctx );
+   ctx->API = ctx->Exec;   /* GL_EXECUTE is default */
+
+   return ctx;
+}
+
+/* Just reads the config files...
+ */
+void gl_context_initialize( GLcontext *ctx )
+{
+   gl_read_config_file( ctx );
+}
+
+
+
+
+/*
+ * Destroy a gl_context structure.
+ */
+void gl_destroy_context( GLcontext *ctx )
+{
+   if (ctx) {
+
+      GLuint i;
+      struct gl_shine_tab *s, *tmps;
+
+#ifdef PROFILE
+      if (getenv("MESA_PROFILE")) {
+         print_timings( ctx );
+      }
+#endif
+
+      gl_matrix_dtr( &ctx->ModelView );
+      for (i = 0 ; i < MAX_MODELVIEW_STACK_DEPTH ; i++) {
+	 gl_matrix_dtr( &ctx->ModelViewStack[i] );
+      }
+
+
+      free( ctx->PB );
+      free( ctx->VB );
+
+      ctx->Shared->RefCount--;
+      assert(ctx->Shared->RefCount>=0);
+      if (ctx->Shared->RefCount==0) {
+	 /* free shared state */
+	 free_shared_state( ctx, ctx->Shared );
+      }
+
+      foreach_s( s, tmps, ctx->ShineTabList ) {
+	 free( s );
+      }
+      free( ctx->ShineTabList );
+
+      /* Free proxy texture objects */
+      gl_free_texture_object( NULL, ctx->Texture.Proxy1D );
+      gl_free_texture_object( NULL, ctx->Texture.Proxy2D );
+      gl_free_texture_object( NULL, ctx->Texture.Proxy3D );
+
+      /* Free evaluator data */
+      if (ctx->EvalMap.Map1Vertex3.Points)
+         free( ctx->EvalMap.Map1Vertex3.Points );
+      if (ctx->EvalMap.Map1Vertex4.Points)
+         free( ctx->EvalMap.Map1Vertex4.Points );
+      if (ctx->EvalMap.Map1Index.Points)
+         free( ctx->EvalMap.Map1Index.Points );
+      if (ctx->EvalMap.Map1Color4.Points)
+         free( ctx->EvalMap.Map1Color4.Points );
+      if (ctx->EvalMap.Map1Normal.Points)
+         free( ctx->EvalMap.Map1Normal.Points );
+      if (ctx->EvalMap.Map1Texture1.Points)
+         free( ctx->EvalMap.Map1Texture1.Points );
+      if (ctx->EvalMap.Map1Texture2.Points)
+         free( ctx->EvalMap.Map1Texture2.Points );
+      if (ctx->EvalMap.Map1Texture3.Points)
+         free( ctx->EvalMap.Map1Texture3.Points );
+      if (ctx->EvalMap.Map1Texture4.Points)
+         free( ctx->EvalMap.Map1Texture4.Points );
+
+      if (ctx->EvalMap.Map2Vertex3.Points)
+         free( ctx->EvalMap.Map2Vertex3.Points );
+      if (ctx->EvalMap.Map2Vertex4.Points)
+         free( ctx->EvalMap.Map2Vertex4.Points );
+      if (ctx->EvalMap.Map2Index.Points)
+         free( ctx->EvalMap.Map2Index.Points );
+      if (ctx->EvalMap.Map2Color4.Points)
+         free( ctx->EvalMap.Map2Color4.Points );
+      if (ctx->EvalMap.Map2Normal.Points)
+         free( ctx->EvalMap.Map2Normal.Points );
+      if (ctx->EvalMap.Map2Texture1.Points)
+         free( ctx->EvalMap.Map2Texture1.Points );
+      if (ctx->EvalMap.Map2Texture2.Points)
+         free( ctx->EvalMap.Map2Texture2.Points );
+      if (ctx->EvalMap.Map2Texture3.Points)
+         free( ctx->EvalMap.Map2Texture3.Points );
+      if (ctx->EvalMap.Map2Texture4.Points)
+         free( ctx->EvalMap.Map2Texture4.Points );
+
+      free( (void *) ctx );
+
+#ifndef THREADS
+      if (ctx==CC) {
+         CC = NULL;
+	 CURRENT_INPUT = NULL;
+      }
+#endif
+
+   }
+}
+
+
+
+/*
+ * Create a new framebuffer.  A GLframebuffer is a struct which
+ * encapsulates the depth, stencil and accum buffers and related
+ * parameters.
+ * Input:  visual - a GLvisual pointer
+ * Return:  pointer to new GLframebuffer struct or NULL if error.
+ */
+GLframebuffer *gl_create_framebuffer( GLvisual *visual )
+{
+   GLframebuffer *buffer;
+
+   buffer = (GLframebuffer *) calloc( 1, sizeof(GLframebuffer) );
+   if (!buffer) {
+      return NULL;
+   }
+
+   buffer->Visual = visual;
+
+   return buffer;
+}
+
+
+
+/*
+ * Free a framebuffer struct and its buffers.
+ */
+void gl_destroy_framebuffer( GLframebuffer *buffer )
+{
+   if (buffer) {
+      if (buffer->Depth) {
+         free( buffer->Depth );
+      }
+      if (buffer->Accum) {
+         free( buffer->Accum );
+      }
+      if (buffer->Stencil) {
+         free( buffer->Stencil );
+      }
+      if (buffer->FrontLeftAlpha) {
+         free( buffer->FrontLeftAlpha );
+      }
+      if (buffer->BackLeftAlpha) {
+         free( buffer->BackLeftAlpha );
+      }
+      if (buffer->FrontRightAlpha) {
+         free( buffer->FrontRightAlpha );
+      }
+      if (buffer->BackRightAlpha) {
+         free( buffer->BackRightAlpha );
+      }
+      free(buffer);
+   }
+}
+
+
+
+/*
+ * Set the current context, binding the given frame buffer to the context.
+ */
+void gl_make_current( GLcontext *ctx, GLframebuffer *buffer )
+{
+   GET_CONTEXT;
+
+   /* Flush the old context
+    */
+   if (CC) {
+      ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(CC, "gl_make_current");
+   }
+
+#ifdef THREADS
+   /* TODO: unbind old buffer from context? */
+   set_thread_context( ctx );
+#else
+   if (CC && CC->Buffer) {
+      /* unbind frame buffer from context */
+      CC->Buffer = NULL;
+   }
+   CC = ctx;
+   if (ctx) {
+      SET_IMMEDIATE(ctx, ctx->input);
+   }
+#endif
+
+   if (MESA_VERBOSE) fprintf(stderr, "gl_make_current()\n");
+
+   if (ctx && buffer) {
+      /* TODO: check if ctx and buffer's visual match??? */
+      ctx->Buffer = buffer;      /* Bind the frame buffer to the context */
+      ctx->NewState = NEW_ALL;   /* just to be safe */
+      gl_update_state( ctx );
+   }
+}
+
+
+/*
+ * Return current context handle.
+ */
+GLcontext *gl_get_current_context( void )
+{
+#ifdef THREADS
+   return gl_get_thread_context();
+#else
+   return CC;
+#endif
+}
+
+
+
+/*
+ * Copy attribute groups from one context to another.
+ * Input:  src - source context
+ *         dst - destination context
+ *         mask - bitwise OR of GL_*_BIT flags
+ */
+void gl_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
+{
+   if (mask & GL_ACCUM_BUFFER_BIT) {
+      MEMCPY( &dst->Accum, &src->Accum, sizeof(struct gl_accum_attrib) );
+   }
+   if (mask & GL_COLOR_BUFFER_BIT) {
+      MEMCPY( &dst->Color, &src->Color, sizeof(struct gl_colorbuffer_attrib) );
+   }
+   if (mask & GL_CURRENT_BIT) {
+      MEMCPY( &dst->Current, &src->Current, sizeof(struct gl_current_attrib) );
+   }
+   if (mask & GL_DEPTH_BUFFER_BIT) {
+      MEMCPY( &dst->Depth, &src->Depth, sizeof(struct gl_depthbuffer_attrib) );
+   }
+   if (mask & GL_ENABLE_BIT) {
+      /* no op */
+   }
+   if (mask & GL_EVAL_BIT) {
+      MEMCPY( &dst->Eval, &src->Eval, sizeof(struct gl_eval_attrib) );
+   }
+   if (mask & GL_FOG_BIT) {
+      MEMCPY( &dst->Fog, &src->Fog, sizeof(struct gl_fog_attrib) );
+   }
+   if (mask & GL_HINT_BIT) {
+      MEMCPY( &dst->Hint, &src->Hint, sizeof(struct gl_hint_attrib) );
+   }
+   if (mask & GL_LIGHTING_BIT) {
+      MEMCPY( &dst->Light, &src->Light, sizeof(struct gl_light_attrib) );
+/*       gl_reinit_light_attrib( &dst->Light ); */
+   }
+   if (mask & GL_LINE_BIT) {
+      MEMCPY( &dst->Line, &src->Line, sizeof(struct gl_line_attrib) );
+   }
+   if (mask & GL_LIST_BIT) {
+      MEMCPY( &dst->List, &src->List, sizeof(struct gl_list_attrib) );
+   }
+   if (mask & GL_PIXEL_MODE_BIT) {
+      MEMCPY( &dst->Pixel, &src->Pixel, sizeof(struct gl_pixel_attrib) );
+   }
+   if (mask & GL_POINT_BIT) {
+      MEMCPY( &dst->Point, &src->Point, sizeof(struct gl_point_attrib) );
+   }
+   if (mask & GL_POLYGON_BIT) {
+      MEMCPY( &dst->Polygon, &src->Polygon, sizeof(struct gl_polygon_attrib) );
+   }
+   if (mask & GL_POLYGON_STIPPLE_BIT) {
+      /* Use loop instead of MEMCPY due to problem with Portland Group's
+       * C compiler.  Reported by John Stone.
+       */
+      int i;
+      for (i=0;i<32;i++) {
+         dst->PolygonStipple[i] = src->PolygonStipple[i];
+      }
+   }
+   if (mask & GL_SCISSOR_BIT) {
+      MEMCPY( &dst->Scissor, &src->Scissor, sizeof(struct gl_scissor_attrib) );
+   }
+   if (mask & GL_STENCIL_BUFFER_BIT) {
+      MEMCPY( &dst->Stencil, &src->Stencil, sizeof(struct gl_stencil_attrib) );
+   }
+   if (mask & GL_TEXTURE_BIT) {
+      MEMCPY( &dst->Texture, &src->Texture, sizeof(struct gl_texture_attrib) );
+   }
+   if (mask & GL_TRANSFORM_BIT) {
+      MEMCPY( &dst->Transform, &src->Transform, sizeof(struct gl_transform_attrib) );
+   }
+   if (mask & GL_VIEWPORT_BIT) {
+      MEMCPY( &dst->Viewport, &src->Viewport, sizeof(struct gl_viewport_attrib) );
+   }
+}
+
+
+
+/*
+ * Someday a GLS library or OpenGL-like debugger may call this function
+ * to register it's own set of API entry points.
+ * Input: ctx - the context to set API pointers for
+ *        api - if NULL, restore original API pointers
+ *              else, set API function table to this table.
+ */
+void gl_set_api_table( GLcontext *ctx, const struct gl_api_table *api )
+{
+   if (api) {
+      MEMCPY( &ctx->API, api, sizeof(struct gl_api_table) );
+   }
+   else {
+      MEMCPY( &ctx->API, &ctx->Exec, sizeof(struct gl_api_table) );
+   }
+}
+
+
+
+
+/**********************************************************************/
+/*****                Miscellaneous functions                     *****/
+/**********************************************************************/
+
+
+/*
+ * This function is called when the Mesa user has stumbled into a code
+ * path which may not be implemented fully or correctly.
+ */
+void gl_problem( const GLcontext *ctx, const char *s )
+{
+   fprintf( stderr, "Mesa implementation error: %s\n", s );
+   fprintf( stderr, "Report to [email protected]\n" );
+   (void) ctx;
+}
+
+
+
+/*
+ * This is called to inform the user that he or she has tried to do
+ * something illogical or if there's likely a bug in their program
+ * (like enabled depth testing without a depth buffer).
+ */
+void gl_warning( const GLcontext *ctx, const char *s )
+{
+   GLboolean debug;
+#ifdef DEBUG
+   debug = GL_TRUE;
+#else
+   if (getenv("MESA_DEBUG")) {
+      debug = GL_TRUE;
+   }
+   else {
+      debug = GL_FALSE;
+   }
+#endif
+   if (debug) {
+      fprintf( stderr, "Mesa warning: %s\n", s );
+   }
+   (void) ctx;
+}
+
+
+
+void gl_compile_error( GLcontext *ctx, GLenum error, const char *s )
+{
+   if (ctx->CompileFlag)
+      gl_save_error( ctx, error, s );
+
+   if (ctx->ExecuteFlag)
+      gl_error( ctx, error, s );
+}
+
+
+/*
+ * This is Mesa's error handler.  Normally, all that's done is the updating
+ * of the current error value.  If Mesa is compiled with -DDEBUG or if the
+ * environment variable "MESA_DEBUG" is defined then a real error message
+ * is printed to stderr.
+ * Input:  error - the error value
+ *         s - a diagnostic string
+ */
+void gl_error( GLcontext *ctx, GLenum error, const char *s )
+{
+   GLboolean debug;
+
+#ifdef DEBUG
+   debug = GL_TRUE;
+#else
+   if (getenv("MESA_DEBUG")) {
+      debug = GL_TRUE;
+   }
+   else {
+      debug = GL_FALSE;
+   }
+#endif
+
+   if (debug) {
+      char errstr[1000];
+
+      switch (error) {
+	 case GL_NO_ERROR:
+	    strcpy( errstr, "GL_NO_ERROR" );
+	    break;
+	 case GL_INVALID_VALUE:
+	    strcpy( errstr, "GL_INVALID_VALUE" );
+	    break;
+	 case GL_INVALID_ENUM:
+	    strcpy( errstr, "GL_INVALID_ENUM" );
+	    break;
+	 case GL_INVALID_OPERATION:
+	    strcpy( errstr, "GL_INVALID_OPERATION" );
+	    break;
+	 case GL_STACK_OVERFLOW:
+	    strcpy( errstr, "GL_STACK_OVERFLOW" );
+	    break;
+	 case GL_STACK_UNDERFLOW:
+	    strcpy( errstr, "GL_STACK_UNDERFLOW" );
+	    break;
+	 case GL_OUT_OF_MEMORY:
+	    strcpy( errstr, "GL_OUT_OF_MEMORY" );
+	    break;
+	 default:
+	    strcpy( errstr, "unknown" );
+	    break;
+      }
+      fprintf( stderr, "Mesa user error: %s in %s\n", errstr, s );
+   }
+
+   if (ctx->ErrorValue==GL_NO_ERROR) {
+      ctx->ErrorValue = error;
+   }
+
+   /* Call device driver's error handler, if any.  This is used on the Mac. */
+   if (ctx->Driver.Error) {
+      (*ctx->Driver.Error)( ctx );
+   }
+}
+
+
+
+/*
+ * Execute a glGetError command
+ */
+GLenum gl_GetError( GLcontext *ctx )
+{
+   GLenum e = ctx->ErrorValue;
+
+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL( ctx, "glGetError", 0);
+
+   if (MESA_VERBOSE & VERBOSE_API)
+      fprintf(stderr, "glGetError <-- %s\n", gl_lookup_enum_by_nr(e));
+
+   ctx->ErrorValue = (GLenum) GL_NO_ERROR;
+   return e;
+}
+
+
+
+void gl_ResizeBuffersMESA( GLcontext *ctx )
+{
+   GLuint buf_width, buf_height;
+
+   if (MESA_VERBOSE & VERBOSE_API)
+      fprintf(stderr, "glResizeBuffersMESA\n");
+
+   /* ask device driver for size of output buffer */
+   (*ctx->Driver.GetBufferSize)( ctx, &buf_width, &buf_height );
+
+   /* see if size of device driver's color buffer (window) has changed */
+   if (ctx->Buffer->Width == (GLint) buf_width &&
+       ctx->Buffer->Height == (GLint) buf_height)
+      return;
+
+   ctx->NewState |= NEW_RASTER_OPS;  /* to update scissor / window bounds */
+
+   /* save buffer size */
+   ctx->Buffer->Width = buf_width;
+   ctx->Buffer->Height = buf_height;
+
+   /* Reallocate other buffers if needed. */
+   if (ctx->Visual->DepthBits>0) {
+      /* reallocate depth buffer */
+      (*ctx->Driver.AllocDepthBuffer)( ctx );
+   }
+   if (ctx->Visual->StencilBits>0) {
+      /* reallocate stencil buffer */
+      gl_alloc_stencil_buffer( ctx );
+   }
+   if (ctx->Visual->AccumBits>0) {
+      /* reallocate accum buffer */
+      gl_alloc_accum_buffer( ctx );
+   }
+   if (ctx->Visual->SoftwareAlpha) {
+      gl_alloc_alpha_buffers( ctx );
+   }
+}
+
+
+
+
+/**********************************************************************/
+/*****                   State update logic                       *****/
+/**********************************************************************/
+
+
+/*
+ * Since the device driver may or may not support pixel logic ops we
+ * have to make some extensive tests to determine whether or not
+ * software-implemented logic operations have to be used.
+ */
+static void update_pixel_logic( GLcontext *ctx )
+{
+   if (ctx->Visual->RGBAflag) {
+      /* RGBA mode blending w/ Logic Op */
+      if (ctx->Color.ColorLogicOpEnabled) {
+	 if (ctx->Driver.LogicOp
+             && (*ctx->Driver.LogicOp)( ctx, ctx->Color.LogicOp )) {
+	    /* Device driver can do logic, don't have to do it in software */
+	    ctx->Color.SWLogicOpEnabled = GL_FALSE;
+	 }
+	 else {
+	    /* Device driver can't do logic op so we do it in software */
+	    ctx->Color.SWLogicOpEnabled = GL_TRUE;
+	 }
+      }
+      else {
+	 /* no logic op */
+	 if (ctx->Driver.LogicOp) {
+            (void) (*ctx->Driver.LogicOp)( ctx, GL_COPY );
+         }
+	 ctx->Color.SWLogicOpEnabled = GL_FALSE;
+      }
+   }
+   else {
+      /* CI mode Logic Op */
+      if (ctx->Color.IndexLogicOpEnabled) {
+	 if (ctx->Driver.LogicOp
+             && (*ctx->Driver.LogicOp)( ctx, ctx->Color.LogicOp )) {
+	    /* Device driver can do logic, don't have to do it in software */
+	    ctx->Color.SWLogicOpEnabled = GL_FALSE;
+	 }
+	 else {
+	    /* Device driver can't do logic op so we do it in software */
+	    ctx->Color.SWLogicOpEnabled = GL_TRUE;
+	 }
+      }
+      else {
+	 /* no logic op */
+	 if (ctx->Driver.LogicOp) {
+            (void) (*ctx->Driver.LogicOp)( ctx, GL_COPY );
+         }
+	 ctx->Color.SWLogicOpEnabled = GL_FALSE;
+      }
+   }
+}
+
+
+
+/*
+ * Check if software implemented RGBA or Color Index masking is needed.
+ */
+static void update_pixel_masking( GLcontext *ctx )
+{
+   if (ctx->Visual->RGBAflag) {
+      GLuint *colorMask = (GLuint *) ctx->Color.ColorMask;
+      if (*colorMask == 0xffffffff) {
+         /* disable masking */
+         if (ctx->Driver.ColorMask) {
+            (void) (*ctx->Driver.ColorMask)( ctx, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
+         }
+         ctx->Color.SWmasking = GL_FALSE;
+      }
+      else {
+         /* Ask driver to do color masking, if it can't then
+          * do it in software
+          */
+         GLboolean red   = ctx->Color.ColorMask[RCOMP] ? GL_TRUE : GL_FALSE;
+         GLboolean green = ctx->Color.ColorMask[GCOMP] ? GL_TRUE : GL_FALSE;
+         GLboolean blue  = ctx->Color.ColorMask[BCOMP] ? GL_TRUE : GL_FALSE;
+         GLboolean alpha = ctx->Color.ColorMask[ACOMP] ? GL_TRUE : GL_FALSE;
+         if (ctx->Driver.ColorMask
+             && (*ctx->Driver.ColorMask)( ctx, red, green, blue, alpha )) {
+            ctx->Color.SWmasking = GL_FALSE;
+         }
+         else {
+            ctx->Color.SWmasking = GL_TRUE;
+         }
+      }
+   }
+   else {
+      if (ctx->Color.IndexMask==0xffffffff) {
+         /* disable masking */
+         if (ctx->Driver.IndexMask) {
+            (void) (*ctx->Driver.IndexMask)( ctx, 0xffffffff );
+         }
+         ctx->Color.SWmasking = GL_FALSE;
+      }
+      else {
+         /* Ask driver to do index masking, if it can't then
+          * do it in software
+          */
+         if (ctx->Driver.IndexMask
+             && (*ctx->Driver.IndexMask)( ctx, ctx->Color.IndexMask )) {
+            ctx->Color.SWmasking = GL_FALSE;
+         }
+         else {
+            ctx->Color.SWmasking = GL_TRUE;
+         }
+      }
+   }
+}
+
+
+static void update_fog_mode( GLcontext *ctx )
+{
+   if (ctx->Fog.Enabled) {
+      if (ctx->Texture.Enabled)
+         ctx->FogMode = FOG_FRAGMENT;
+      else if (ctx->Hint.Fog == GL_NICEST)
+         ctx->FogMode = FOG_FRAGMENT;
+      else
+         ctx->FogMode = FOG_VERTEX;
+
+      if (ctx->Driver.GetParameteri)
+         if ((ctx->Driver.GetParameteri)( ctx, DD_HAVE_HARDWARE_FOG ))
+            ctx->FogMode = FOG_FRAGMENT;
+   }
+   else {
+      ctx->FogMode = FOG_NONE;
+   }
+}
+
+
+/*
+ * Recompute the value of ctx->RasterMask, etc. according to
+ * the current context.
+ */
+static void update_rasterflags( GLcontext *ctx )
+{
+   ctx->RasterMask = 0;
+
+   if (ctx->Color.AlphaEnabled)		ctx->RasterMask |= ALPHATEST_BIT;
+   if (ctx->Color.BlendEnabled)		ctx->RasterMask |= BLEND_BIT;
+   if (ctx->Depth.Test)			ctx->RasterMask |= DEPTH_BIT;
+   if (ctx->FogMode==FOG_FRAGMENT)	ctx->RasterMask |= FOG_BIT;
+   if (ctx->Color.SWLogicOpEnabled)	ctx->RasterMask |= LOGIC_OP_BIT;
+   if (ctx->Scissor.Enabled)		ctx->RasterMask |= SCISSOR_BIT;
+   if (ctx->Stencil.Enabled)		ctx->RasterMask |= STENCIL_BIT;
+   if (ctx->Color.SWmasking)		ctx->RasterMask |= MASKING_BIT;
+
+   if (ctx->Visual->SoftwareAlpha && ctx->Color.ColorMask[ACOMP]
+       && ctx->Color.DrawBuffer != GL_NONE)
+      ctx->RasterMask |= ALPHABUF_BIT;
+
+   if (   ctx->Viewport.X<0
+       || ctx->Viewport.X + ctx->Viewport.Width > ctx->Buffer->Width
+       || ctx->Viewport.Y<0
+       || ctx->Viewport.Y + ctx->Viewport.Height > ctx->Buffer->Height) {
+      ctx->RasterMask |= WINCLIP_BIT;
+   }
+
+   /* If we're not drawing to exactly one color buffer set the
+    * MULTI_DRAW_BIT flag.  Also set it if we're drawing to no
+    * buffers or the RGBA or CI mask disables all writes.
+    */
+
+   ctx->TriangleCaps &= ~DD_MULTIDRAW;
+
+   if (ctx->Color.MultiDrawBuffer) {
+      ctx->RasterMask |= MULTI_DRAW_BIT;
+      ctx->TriangleCaps |= DD_MULTIDRAW;
+   }
+   else if (ctx->Color.DrawBuffer==GL_NONE) {
+      ctx->RasterMask |= MULTI_DRAW_BIT;
+      ctx->TriangleCaps |= DD_MULTIDRAW;
+   }
+   else if (ctx->Visual->RGBAflag && ctx->Color.ColorMask==0) {
+      /* all RGBA channels disabled */
+      ctx->RasterMask |= MULTI_DRAW_BIT;
+      ctx->TriangleCaps |= DD_MULTIDRAW;
+      ctx->Color.DrawDestMask = 0;
+   }
+   else if (!ctx->Visual->RGBAflag && ctx->Color.IndexMask==0) {
+      /* all color index bits disabled */
+      ctx->RasterMask |= MULTI_DRAW_BIT;
+      ctx->TriangleCaps |= DD_MULTIDRAW;
+      ctx->Color.DrawDestMask = 0;
+   }
+}
+
+
+void gl_print_state( const char *msg, GLuint state )
+{
+   fprintf(stderr,
+	   "%s: (0x%x) %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
+	   msg,
+	   state,
+	   (state & NEW_LIGHTING)         ? "lighting, " : "",
+	   (state & NEW_RASTER_OPS)       ? "raster-ops, " : "",
+	   (state & NEW_TEXTURING)        ? "texturing, " : "",
+	   (state & NEW_POLYGON)          ? "polygon, " : "",
+	   (state & NEW_DRVSTATE0)        ? "driver-0, " : "",
+	   (state & NEW_DRVSTATE1)        ? "driver-1, " : "",
+	   (state & NEW_DRVSTATE2)        ? "driver-2, " : "",
+	   (state & NEW_DRVSTATE3)        ? "driver-3, " : "",
+	   (state & NEW_MODELVIEW)        ? "modelview, " : "",
+	   (state & NEW_PROJECTION)       ? "projection, " : "",
+	   (state & NEW_TEXTURE_MATRIX)   ? "texture-matrix, " : "",
+	   (state & NEW_USER_CLIP)        ? "user-clip, " : "",
+	   (state & NEW_TEXTURE_ENV)      ? "texture-env, " : "",
+	   (state & NEW_CLIENT_STATE)     ? "client-state, " : "",
+	   (state & NEW_FOG)              ? "fog, " : "",
+	   (state & NEW_NORMAL_TRANSFORM) ? "normal-transform, " : "",
+	   (state & NEW_VIEWPORT)         ? "viewport, " : "",
+	   (state & NEW_TEXTURE_ENABLE)   ? "texture-enable, " : "");
+}
+
+void gl_print_enable_flags( const char *msg, GLuint flags )
+{
+   fprintf(stderr,
+	   "%s: (0x%x) %s%s%s%s%s%s%s%s%s%s%s\n",
+	   msg,
+	   flags,
+	   (flags & ENABLE_TEX0)       ? "tex-0, " : "",
+	   (flags & ENABLE_TEX1)       ? "tex-1, " : "",
+	   (flags & ENABLE_LIGHT)      ? "light, " : "",
+	   (flags & ENABLE_FOG)        ? "fog, " : "",
+	   (flags & ENABLE_USERCLIP)   ? "userclip, " : "",
+	   (flags & ENABLE_TEXGEN0)    ? "tex-gen-0, " : "",
+	   (flags & ENABLE_TEXGEN1)    ? "tex-gen-1, " : "",
+	   (flags & ENABLE_TEXMAT0)    ? "tex-mat-0, " : "",
+	   (flags & ENABLE_TEXMAT1)    ? "tex-mat-1, " : "",
+	   (flags & ENABLE_NORMALIZE)  ? "normalize, " : "",
+	   (flags & ENABLE_RESCALE)    ? "rescale, " : "");
+}
+
+
+/*
+ * If ctx->NewState is non-zero then this function MUST be called before
+ * rendering any primitive.  Basically, function pointers and miscellaneous
+ * flags are updated to reflect the current state of the state machine.
+ */
+void gl_update_state( GLcontext *ctx )
+{
+   GLuint i;
+
+   if (MESA_VERBOSE & VERBOSE_STATE)
+      gl_print_state("", ctx->NewState);
+
+   if (ctx->NewState & NEW_CLIENT_STATE)
+      gl_update_client_state( ctx );
+
+   if ((ctx->NewState & NEW_TEXTURE_ENABLE) &&
+       (ctx->Enabled & ENABLE_TEX_ANY) != ctx->Texture.Enabled)
+      ctx->NewState |= NEW_TEXTURING | NEW_RASTER_OPS;
+
+   if (ctx->NewState & NEW_TEXTURE_ENV) {
+      if (ctx->Texture.Unit[0].EnvMode == ctx->Texture.Unit[0].LastEnvMode &&
+	  ctx->Texture.Unit[1].EnvMode == ctx->Texture.Unit[1].LastEnvMode)
+	 ctx->NewState &= ~NEW_TEXTURE_ENV;
+      ctx->Texture.Unit[0].LastEnvMode = ctx->Texture.Unit[0].EnvMode;
+      ctx->Texture.Unit[1].LastEnvMode = ctx->Texture.Unit[1].EnvMode;
+   }
+
+   if ((ctx->NewState & ~(NEW_CLIENT_STATE|NEW_TEXTURE_ENABLE)) == 0)
+      goto finished;
+
+   if (ctx->NewState & NEW_TEXTURE_MATRIX) {
+      ctx->Enabled &= ~(ENABLE_TEXMAT0|ENABLE_TEXMAT1);
+
+      for (i=0; i < MAX_TEXTURE_UNITS; i++) {
+	 if (ctx->TextureMatrix[i].flags & MAT_DIRTY_ALL_OVER)
+	 {
+	    gl_matrix_analyze( &ctx->TextureMatrix[i] );
+	    ctx->TextureMatrix[i].flags &= ~MAT_DIRTY_DEPENDENTS;
+
+	    if (ctx->Texture.Unit[i].Enabled &&
+		ctx->TextureMatrix[i].type != MATRIX_IDENTITY)
+	       ctx->Enabled |= ENABLE_TEXMAT0 << i;
+	 }
+      }
+   }
+
+   if (ctx->NewState & NEW_TEXTURING) {
+      ctx->Texture.NeedNormals = GL_FALSE;
+      gl_update_dirty_texobjs(ctx);
+      ctx->Enabled &= ~(ENABLE_TEXGEN0|ENABLE_TEXGEN1);
+      ctx->Texture.ReallyEnabled = 0;
+
+      for (i=0; i < MAX_TEXTURE_UNITS; i++) {
+	 if (ctx->Texture.Unit[i].Enabled) {
+	    gl_update_texture_unit( ctx, &ctx->Texture.Unit[i] );
+
+	    ctx->Texture.ReallyEnabled |=
+	       ctx->Texture.Unit[i].ReallyEnabled<<(i*4);
+
+	    if (ctx->Texture.Unit[i].GenFlags != 0) {
+	       ctx->Enabled |= ENABLE_TEXGEN0 << i;
+
+	       if (ctx->Texture.Unit[i].GenFlags & TEXGEN_NEED_NORMALS)
+	       {
+		  ctx->Texture.NeedNormals = GL_TRUE;
+		  ctx->Texture.NeedEyeCoords = GL_TRUE;
+	       }
+
+	       if (ctx->Texture.Unit[i].GenFlags & TEXGEN_NEED_EYE_COORD)
+	       {
+		  ctx->Texture.NeedEyeCoords = GL_TRUE;
+	       }
+	    }
+	 }
+      }
+
+      ctx->Texture.Enabled = ctx->Enabled & ENABLE_TEX_ANY;
+      ctx->NeedNormals = (ctx->Light.Enabled || ctx->Texture.NeedNormals);
+   }
+
+   if (ctx->NewState & (NEW_RASTER_OPS | NEW_LIGHTING)) {
+      if (ctx->NewState & NEW_RASTER_OPS) {
+	 update_pixel_logic(ctx);
+	 update_pixel_masking(ctx);
+	 update_fog_mode(ctx);
+	 update_rasterflags(ctx);
+	 if (ctx->Driver.Dither) {
+	    (*ctx->Driver.Dither)( ctx, ctx->Color.DitherFlag );
+	 }
+
+	 /* Check if incoming colors can be modified during rasterization */
+	 if (ctx->Fog.Enabled ||
+	     ctx->Texture.Enabled ||
+	     ctx->Color.BlendEnabled ||
+	     ctx->Color.SWmasking ||
+	     ctx->Color.SWLogicOpEnabled) {
+	    ctx->MutablePixels = GL_TRUE;
+	 }
+	 else {
+	    ctx->MutablePixels = GL_FALSE;
+	 }
+
+	 /* update scissor region */
+
+	 ctx->Buffer->Xmin = 0;
+	 ctx->Buffer->Ymin = 0;
+	 ctx->Buffer->Xmax = ctx->Buffer->Width-1;
+	 ctx->Buffer->Ymax = ctx->Buffer->Height-1;
+	 if (ctx->Scissor.Enabled) {
+	    if (ctx->Scissor.X > ctx->Buffer->Xmin) {
+	       ctx->Buffer->Xmin = ctx->Scissor.X;
+	    }
+	    if (ctx->Scissor.Y > ctx->Buffer->Ymin) {
+	       ctx->Buffer->Ymin = ctx->Scissor.Y;
+	    }
+	    if (ctx->Scissor.X + ctx->Scissor.Width - 1 < ctx->Buffer->Xmax) {
+	       ctx->Buffer->Xmax = ctx->Scissor.X + ctx->Scissor.Width - 1;
+	    }
+	    if (ctx->Scissor.Y + ctx->Scissor.Height - 1 < ctx->Buffer->Ymax) {
+	       ctx->Buffer->Ymax = ctx->Scissor.Y + ctx->Scissor.Height - 1;
+	    }
+	 }
+
+	 /*
+	  * Update Device Driver interface
+	  */
+	 ctx->Driver.AllocDepthBuffer = gl_alloc_depth_buffer;
+	 if (ctx->Depth.Mask) {
+	    switch (ctx->Depth.Func) {
+	    case GL_LESS:
+	       ctx->Driver.DepthTestSpan = gl_depth_test_span_less;
+	       ctx->Driver.DepthTestPixels = gl_depth_test_pixels_less;
+	       break;
+	    case GL_GREATER:
+	       ctx->Driver.DepthTestSpan = gl_depth_test_span_greater;
+	       ctx->Driver.DepthTestPixels = gl_depth_test_pixels_greater;
+	       break;
+	    default:
+	       ctx->Driver.DepthTestSpan = gl_depth_test_span_generic;
+	       ctx->Driver.DepthTestPixels = gl_depth_test_pixels_generic;
+	    }
+	 }
+	 else {
+	    ctx->Driver.DepthTestSpan = gl_depth_test_span_generic;
+	    ctx->Driver.DepthTestPixels = gl_depth_test_pixels_generic;
+	 }
+	 ctx->Driver.ReadDepthSpanFloat = gl_read_depth_span_float;
+	 ctx->Driver.ReadDepthSpanInt = gl_read_depth_span_int;
+      }
+
+      if (ctx->NewState & NEW_LIGHTING) {
+	 ctx->TriangleCaps &= ~(DD_TRI_LIGHT_TWOSIDE|DD_EARLY_CULL);
+	 if (ctx->Light.Enabled) {
+	    if (ctx->Light.Model.TwoSide)
+	       ctx->TriangleCaps |= (DD_TRI_LIGHT_TWOSIDE|DD_EARLY_CULL);
+	    gl_update_lighting(ctx);
+	 }
+      }
+   }
+
+   if (ctx->NewState & (NEW_POLYGON | NEW_LIGHTING)) {
+
+
+      if (ctx->NewState & NEW_POLYGON) {
+	 /* Setup CullBits bitmask */
+	 if (ctx->Polygon.CullFlag) {
+	    switch(ctx->Polygon.CullFaceMode) {
+	    case GL_FRONT:
+	       ctx->Polygon.CullBits = 2;
+	       break;
+	    case GL_BACK:
+	       ctx->Polygon.CullBits = 1;
+	       break;
+	    default:
+	    case GL_FRONT_AND_BACK:
+	       ctx->Polygon.CullBits = 3;
+	       break;
+	    }
+	 }
+	 else
+	    ctx->Polygon.CullBits = 3;
+
+	 /* Any Polygon offsets enabled? */
+	 ctx->TriangleCaps &= ~DD_TRI_OFFSET;
+
+	 if (ctx->Polygon.OffsetPoint ||
+	     ctx->Polygon.OffsetLine ||
+	     ctx->Polygon.OffsetFill)
+	    ctx->TriangleCaps |= DD_TRI_OFFSET;
+
+	 /* reset Z offsets now */
+	 ctx->PointZoffset   = 0.0;
+	 ctx->LineZoffset    = 0.0;
+	 ctx->PolygonZoffset = 0.0;
+      }
+   }
+
+   if (ctx->NewState & ~(NEW_CLIENT_STATE|NEW_TEXTURE_ENABLE|
+			 NEW_DRIVER_STATE|NEW_USER_CLIP|
+			 NEW_POLYGON))
+      gl_update_clipmask(ctx);
+
+   if (ctx->NewState & (NEW_LIGHTING|
+			NEW_RASTER_OPS|
+			NEW_TEXTURING|
+			NEW_TEXTURE_ENV|
+			NEW_POLYGON|
+			NEW_DRVSTATE0|
+			NEW_DRVSTATE1|
+			NEW_DRVSTATE2|
+			NEW_DRVSTATE3|
+			NEW_USER_CLIP))
+   {
+      ctx->IndirectTriangles = ctx->TriangleCaps & ~ctx->Driver.TriangleCaps;
+      ctx->IndirectTriangles |= DD_SW_RASTERIZE;
+
+      ctx->Driver.PointsFunc = NULL;
+      ctx->Driver.LineFunc = NULL;
+      ctx->Driver.TriangleFunc = NULL;
+      ctx->Driver.QuadFunc = NULL;
+      ctx->Driver.RectFunc = NULL;
+      ctx->Driver.RenderVBClippedTab = NULL;
+      ctx->Driver.RenderVBCulledTab = NULL;
+      ctx->Driver.RenderVBRawTab = NULL;
+
+      /*
+       * Here the driver sets up all the ctx->Driver function pointers to
+       * it's specific, private functions.
+       */
+      ctx->Driver.UpdateState(ctx);
+
+      /*
+       * In case the driver didn't hook in an optimized point, line or
+       * triangle function we'll now select "core/fallback" point, line
+       * and triangle functions.
+       */
+      if (ctx->IndirectTriangles & DD_SW_RASTERIZE) {
+	 gl_set_point_function(ctx);
+	 gl_set_line_function(ctx);
+	 gl_set_triangle_function(ctx);
+	 gl_set_quad_function(ctx);
+      }
+
+      gl_set_render_vb_function(ctx);
+   }
+
+   /* Should only be calc'd when !need_eye_coords and not culling.
+    */
+   if (ctx->NewState & (NEW_MODELVIEW|NEW_PROJECTION)) {
+      if (ctx->NewState & NEW_MODELVIEW) {
+	 gl_matrix_analyze( &ctx->ModelView );
+	 ctx->ProjectionMatrix.flags &= ~MAT_DIRTY_DEPENDENTS;
+      }
+
+      if (ctx->NewState & NEW_PROJECTION) {
+	 gl_matrix_analyze( &ctx->ProjectionMatrix );
+	 ctx->ProjectionMatrix.flags &= ~MAT_DIRTY_DEPENDENTS;
+
+	 if (ctx->Transform.AnyClip) {
+	    gl_update_userclip( ctx );
+	 }
+      }
+
+      gl_calculate_model_project_matrix( ctx );
+      ctx->ModelProjectWinMatrixUptodate = 0;
+   }
+
+   /* Figure out whether we can light in object space or not.  If we
+    * can, find the current positions of the lights in object space
+    */
+   if ((ctx->Enabled & (ENABLE_POINT_ATTEN | ENABLE_LIGHT | 
+			ENABLE_TEXGEN0 | ENABLE_TEXGEN1)) &&
+       (ctx->NewState & (NEW_LIGHTING | 
+			 NEW_MODELVIEW | 
+			 NEW_PROJECTION |
+			 NEW_TEXTURING |
+			 NEW_RASTER_OPS |
+			 NEW_USER_CLIP)))
+   {
+      GLboolean oldcoord, oldnorm;
+
+      oldcoord = ctx->NeedEyeCoords;
+      oldnorm = ctx->NeedEyeNormals;
+
+      ctx->NeedNormals = (ctx->Light.Enabled || ctx->Texture.NeedNormals);
+      ctx->NeedEyeCoords = ((ctx->Fog.Enabled && ctx->Hint.Fog != GL_NICEST) ||
+			    ctx->Point.Attenuated);
+      ctx->NeedEyeNormals = GL_FALSE;
+
+      if (ctx->Light.Enabled) {
+	 if (ctx->Light.Flags & LIGHT_POSITIONAL) {
+	    /* Need length for attenuation */
+	    if (!TEST_MAT_FLAGS( &ctx->ModelView, MAT_FLAGS_LENGTH_PRESERVING))
+	       ctx->NeedEyeCoords = GL_TRUE;
+	 } else if (ctx->Light.NeedVertices) {
+	    /* Need angle for spot calculations */
+	    if (!TEST_MAT_FLAGS( &ctx->ModelView, MAT_FLAGS_ANGLE_PRESERVING))
+	       ctx->NeedEyeCoords = GL_TRUE;
+	 }
+	 ctx->NeedEyeNormals = ctx->NeedEyeCoords;
+      }
+      if (ctx->Texture.Enabled || ctx->RenderMode==GL_FEEDBACK) {
+	 if (ctx->Texture.NeedEyeCoords) ctx->NeedEyeCoords = GL_TRUE;
+	 if (ctx->Texture.NeedNormals)
+	    ctx->NeedNormals = ctx->NeedEyeNormals = GL_TRUE;
+      }
+
+      ctx->vb_proj_matrix = &ctx->ModelProjectMatrix;
+
+      if (ctx->NeedEyeCoords)
+	 ctx->vb_proj_matrix = &ctx->ProjectionMatrix;
+
+      if (ctx->Light.Enabled) {
+	 gl_update_lighting_function(ctx);
+
+	 if ( (ctx->NewState & NEW_LIGHTING) ||
+	      ((ctx->NewState & (NEW_MODELVIEW| NEW_PROJECTION)) &&
+	       !ctx->NeedEyeCoords) ||
+	      oldcoord != ctx->NeedEyeCoords ||
+	      oldnorm != ctx->NeedEyeNormals) {
+	    gl_compute_light_positions(ctx);
+	 }
+
+	 ctx->rescale_factor = 1.0F;
+
+	 if (ctx->ModelView.flags & (MAT_FLAG_UNIFORM_SCALE |
+				     MAT_FLAG_GENERAL_SCALE |
+				     MAT_FLAG_GENERAL_3D |
+				     MAT_FLAG_GENERAL) )
+
+	 {
+	    GLfloat *m = ctx->ModelView.inv;
+	    GLfloat f = m[2]*m[2] + m[6]*m[6] + m[10]*m[10];
+	    if (f > 1e-12 && (f-1)*(f-1) > 1e-12)
+	       ctx->rescale_factor = 1.0/GL_SQRT(f);
+	 }
+      }
+
+      gl_update_normal_transform( ctx );
+   }
+
+ finished:
+   gl_update_pipelines(ctx);
+   ctx->NewState = 0;
+}