Merge trunk into bsd-1-0-1-branch.bsd-1-0-1-20000613bsd-1-0-1-branch

1 files changed, 375 insertions, 297 deletions

diff --git a/xc/extras/Mesa/src/context.c b/xc/extras/Mesa/src/context.c
index 48e92df60..0138ae6b3 100644
--- a/xc/extras/Mesa/src/context.c
+++ b/xc/extras/Mesa/src/context.c
@@ -31,6 +31,7 @@
 #include "accum.h"
 #include "alphabuf.h"
 #include "clip.h"
+#include "colortab.h"
 #include "context.h"
 #include "cva.h"
 #include "depth.h"
@@ -85,215 +86,110 @@ struct immediate *_mesa_CurrentInput = NULL;
 #endif
 
 
-
-
 /**********************************************************************/
-/*****                   Profiling functions                      *****/
+/***** GL Visual allocation/destruction                           *****/
 /**********************************************************************/
 
-#ifdef PROFILE
-
-#include <sys/times.h>
-#include <sys/param.h>
-
 
 /*
- * Return system time in seconds.
- * NOTE:  this implementation may not be very portable!
+ * Allocate a new GLvisual object.
+ * Input:  rgbFlag - GL_TRUE=RGB(A) mode, GL_FALSE=Color Index mode
+ *         dbFlag - double buffering?
+ *         stereoFlag - stereo buffer?
+ *         depthBits - requested bits per depth buffer value
+ *                     Any value in [0, 32] is acceptable but the actual
+ *                     depth type will be GLushort or GLuint as needed.
+ *         stencilBits - requested minimum bits per stencil buffer value
+ *         accumBits - requested minimum bits per accum buffer component
+ *         indexBits - number of bits per pixel if rgbFlag==GL_FALSE
+ *         red/green/blue/alphaBits - number of bits per color component
+ *                                    in frame buffer for RGB(A) mode.
+ *                                    We always use 8 in core Mesa though.
+ * Return:  pointer to new GLvisual or NULL if requested parameters can't
+ *          be met.
  */
-GLdouble gl_time( void )
+GLvisual *
+_mesa_create_visual( GLboolean rgbFlag,
+                     GLboolean dbFlag,
+                     GLboolean stereoFlag,
+                     GLint redBits,
+                     GLint greenBits,
+                     GLint blueBits,
+                     GLint alphaBits,
+                     GLint indexBits,
+                     GLint depthBits,
+                     GLint stencilBits,
+                     GLint accumRedBits,
+                     GLint accumGreenBits,
+                     GLint accumBlueBits,
+                     GLint accumAlphaBits,
+                     GLint numSamples )
 {
-   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;
+   GLvisual *vis = (GLvisual *) CALLOC( sizeof(GLvisual) );
+   if (vis) {
+      if (!_mesa_initialize_visual(vis, rgbFlag, dbFlag, stereoFlag,
+                                   redBits, greenBits, blueBits, alphaBits,
+                                   indexBits, depthBits, stencilBits,
+                                   accumRedBits, accumGreenBits,
+                                   accumBlueBits, accumAlphaBits,
+                                   numSamples )) {
+         FREE(vis);
+         return NULL;
+      }
    }
+   return vis;
 }
 
+
 /*
- * Reset the timing/profiling counters
+ * Initialize the fields of the given GLvisual.
+ * Input:  see _mesa_create_visual() above.
+ * Return: GL_TRUE = success
+ *         GL_FALSE = failure.
  */
-static void init_timings( GLcontext *ctx )
+GLboolean
+_mesa_initialize_visual( GLvisual *vis,
+                         GLboolean rgbFlag,
+                         GLboolean dbFlag,
+                         GLboolean stereoFlag,
+                         GLint redBits,
+                         GLint greenBits,
+                         GLint blueBits,
+                         GLint alphaBits,
+                         GLint indexBits,
+                         GLint depthBits,
+                         GLint stencilBits,
+                         GLint accumRedBits,
+                         GLint accumGreenBits,
+                         GLint accumBlueBits,
+                         GLint accumAlphaBits,
+                         GLint numSamples )
 {
-   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;
-}
+   assert(vis);
 
+   /* This is to catch bad values from device drivers not updated for
+    * Mesa 3.3.  Some device drivers just passed 1.  That's a REALLY
+    * bad value now (a 1-bit depth buffer!?!).
+    */
+   assert(depthBits == 0 || depthBits > 1);
 
-/*
- * 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 (depthBits < 0 || depthBits > 32) {
+      return GL_FALSE;
    }
-
-   if (ctx->BeginEndCount>0) {
-      avgvertices = (GLdouble) ctx->VertexCount / (GLdouble) ctx->BeginEndCount;
+   if (stencilBits < 0 || stencilBits > (GLint) (8 * sizeof(GLstencil))) {
+      return GL_FALSE;
    }
-   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
-
-
-
-
-
-/**********************************************************************/
-/***** GL Visual allocation/destruction                           *****/
-/**********************************************************************/
-
-
-/*
- * 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 (accumRedBits < 0 || accumRedBits > (GLint) (8 * sizeof(GLaccum))) {
+      return GL_FALSE;
    }
-   if (stencilBits > (GLint) (8*sizeof(GLstencil))) {
-      /* can't meet stencil buffer requirements */
-      return NULL;
+   if (accumGreenBits < 0 || accumGreenBits > (GLint) (8 * sizeof(GLaccum))) {
+      return GL_FALSE;
    }
-   if (accumBits > (GLint) (8*sizeof(GLaccum))) {
-      /* can't meet accum buffer requirements */
-      return NULL;
+   if (accumBlueBits < 0 || accumBlueBits > (GLint) (8 * sizeof(GLaccum))) {
+      return GL_FALSE;
    }
-
-   vis = (GLvisual *) CALLOC( sizeof(GLvisual) );
-   if (!vis) {
-      return NULL;
+   if (accumAlphaBits < 0 || accumAlphaBits > (GLint) (8 * sizeof(GLaccum))) {
+      return GL_FALSE;
    }
 
    vis->RGBAflag   = rgbFlag;
@@ -302,23 +198,75 @@ GLvisual *gl_create_visual( GLboolean rgbFlag,
    vis->RedBits    = redBits;
    vis->GreenBits  = greenBits;
    vis->BlueBits   = blueBits;
-   vis->AlphaBits  = alphaFlag ? 8*sizeof(GLubyte) : alphaBits;
+   vis->AlphaBits  = alphaBits;
+
+   vis->IndexBits      = indexBits;
+   vis->DepthBits      = depthBits;
+   vis->AccumRedBits   = (accumRedBits > 0) ? (8 * sizeof(GLaccum)) : 0;
+   vis->AccumGreenBits = (accumGreenBits > 0) ? (8 * sizeof(GLaccum)) : 0;
+   vis->AccumBlueBits  = (accumBlueBits > 0) ? (8 * sizeof(GLaccum)) : 0;
+   vis->AccumAlphaBits = (accumAlphaBits > 0) ? (8 * sizeof(GLaccum)) : 0;
+   vis->StencilBits    = (stencilBits > 0) ? (8 * sizeof(GLstencil)) : 0;
+
+   if (depthBits == 0) {
+      /* Special case.  Even if we don't have a depth buffer we need
+       * good values for DepthMax for Z vertex transformation purposes.
+       */
+      vis->DepthMax = 1;
+      vis->DepthMaxF = 1.0F;
+   }
+   else if (depthBits < 32) {
+      vis->DepthMax = (1 << depthBits) - 1;
+      vis->DepthMaxF = (GLfloat) vis->DepthMax;
+   }
+   else {
+      /* Special case since shift values greater than or equal to the
+       * number of bits in the left hand expression's type are
+       * undefined.
+       */
+      vis->DepthMax = 0xffffffff;
+      vis->DepthMaxF = (GLfloat) vis->DepthMax;
+   }
 
-   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;
+   return GL_TRUE;
+}
 
-   vis->SoftwareAlpha = alphaFlag;
 
-   return vis;
+/* This function should no longer be used. Use _mesa_create_visual() instead */
+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 )
+{
+   (void) alphaFlag;
+   return _mesa_create_visual(rgbFlag, dbFlag, stereoFlag,
+                              redBits, greenBits, blueBits, alphaBits,
+                              indexBits, depthBits, stencilBits,
+                              accumBits, accumBits, accumBits, accumBits, 0);
 }
 
 
+void
+_mesa_destroy_visual( GLvisual *vis )
+{
+   FREE(vis);
+}
 
-void gl_destroy_visual( GLvisual *vis )
+
+/* obsolete */
+void
+gl_destroy_visual( GLvisual *vis )
 {
-   FREE( vis );
+   _mesa_destroy_visual(vis);
 }
 
 
@@ -340,18 +288,38 @@ void gl_destroy_visual( GLvisual *vis )
 
  * Return:  pointer to new GLframebuffer struct or NULL if error.
  */
-GLframebuffer *gl_create_framebuffer( GLvisual *visual,
-                                      GLboolean softwareDepth,
-                                      GLboolean softwareStencil,
-                                      GLboolean softwareAccum,
-                                      GLboolean softwareAlpha )
+GLframebuffer *
+gl_create_framebuffer( GLvisual *visual,
+                       GLboolean softwareDepth,
+                       GLboolean softwareStencil,
+                       GLboolean softwareAccum,
+                       GLboolean softwareAlpha )
 {
-   GLframebuffer *buffer;
-
-   buffer = CALLOC_STRUCT(gl_frame_buffer);
-   if (!buffer) {
-      return NULL;
+   GLframebuffer *buffer = CALLOC_STRUCT(gl_frame_buffer);
+   assert(visual);
+   if (buffer) {
+      _mesa_initialize_framebuffer(buffer, visual,
+                                   softwareDepth, softwareStencil,
+                                   softwareAccum, softwareAlpha );
    }
+   return buffer;
+}
+
+
+/*
+ * Initialize a GLframebuffer object.
+ * Input:  See gl_create_framebuffer() above.
+ */
+void
+_mesa_initialize_framebuffer( GLframebuffer *buffer,
+                              GLvisual *visual,
+                              GLboolean softwareDepth,
+                              GLboolean softwareStencil,
+                              GLboolean softwareAccum,
+                              GLboolean softwareAlpha )
+{
+   assert(buffer);
+   assert(visual);
 
    /* sanity checks */
    if (softwareDepth ) {
@@ -362,7 +330,9 @@ GLframebuffer *gl_create_framebuffer( GLvisual *visual,
    }
    if (softwareAccum) {
       assert(visual->RGBAflag);
-      assert(visual->AccumBits > 0);
+      assert(visual->AccumRedBits > 0);
+      assert(visual->AccumGreenBits > 0);
+      assert(visual->AccumBlueBits > 0);
    }
    if (softwareAlpha) {
       assert(visual->RGBAflag);
@@ -374,20 +344,18 @@ GLframebuffer *gl_create_framebuffer( GLvisual *visual,
    buffer->UseSoftwareStencilBuffer = softwareStencil;
    buffer->UseSoftwareAccumBuffer = softwareAccum;
    buffer->UseSoftwareAlphaBuffers = softwareAlpha;
-
-   return buffer;
 }
 
 
-
 /*
  * Free a framebuffer struct and its buffers.
  */
-void gl_destroy_framebuffer( GLframebuffer *buffer )
+void
+gl_destroy_framebuffer( GLframebuffer *buffer )
 {
    if (buffer) {
-      if (buffer->Depth) {
-         FREE( buffer->Depth );
+      if (buffer->DepthBuffer) {
+         FREE( buffer->DepthBuffer );
       }
       if (buffer->Accum) {
          FREE( buffer->Accum );
@@ -424,7 +392,8 @@ _glthread_DECLARE_STATIC_MUTEX(OneTimeLock);
 /*
  * This function just calls all the various one-time-init functions in Mesa.
  */
-static void one_time_init( void )
+static void
+one_time_init( void )
 {
    static GLboolean alreadyCalled = GL_FALSE;
    _glthread_LOCK_MUTEX(OneTimeLock);
@@ -440,7 +409,7 @@ static void one_time_init( void )
       gl_init_clip();
       gl_init_eval();
       _mesa_init_fog();
-      gl_init_math();
+      _mesa_init_math();
       gl_init_lists();
       gl_init_shade();
       gl_init_texture();
@@ -471,7 +440,8 @@ static void one_time_init( void )
 /*
  * Allocate and initialize a shared context state structure.
  */
-static struct gl_shared_state *alloc_shared_state( void )
+static struct gl_shared_state *
+alloc_shared_state( void )
 {
    GLuint d;
    struct gl_shared_state *ss;
@@ -496,6 +466,14 @@ static struct gl_shared_state *alloc_shared_state( void )
       ss->DefaultD[d]->RefCount++; /* don't free if not in use */
    }
 
+   ss->DefaultCubeMap = gl_alloc_texture_object(ss, 0, 6);
+   if (!ss->DefaultCubeMap) {
+      outOfMemory = GL_TRUE;
+   }
+   else {
+      ss->DefaultCubeMap->RefCount++;
+   }
+
    if (!ss->DisplayList || !ss->TexObjects || outOfMemory) {
       /* Ran out of memory at some point.  Free everything and return NULL */
       if (ss->DisplayList)
@@ -508,6 +486,8 @@ static struct gl_shared_state *alloc_shared_state( void )
          gl_free_texture_object(ss, ss->DefaultD[2]);
       if (ss->DefaultD[3])
          gl_free_texture_object(ss, ss->DefaultD[3]);
+      if (ss->DefaultCubeMap)
+         gl_free_texture_object(ss, ss->DefaultCubeMap);
       FREE(ss);
       return NULL;
    }
@@ -520,7 +500,8 @@ static struct gl_shared_state *alloc_shared_state( void )
 /*
  * Deallocate a shared state context and all children structures.
  */
-static void free_shared_state( GLcontext *ctx, struct gl_shared_state *ss )
+static void
+free_shared_state( GLcontext *ctx, struct gl_shared_state *ss )
 {
    /* Free display lists */
    while (1) {
@@ -553,7 +534,8 @@ static void free_shared_state( GLcontext *ctx, struct gl_shared_state *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 )
+static void
+init_light( struct gl_light *l, GLuint n )
 {
    make_empty_list( l );
 
@@ -580,7 +562,8 @@ static void init_light( struct gl_light *l, GLuint n )
 
 
 
-static void init_lightmodel( struct gl_lightmodel *lm )
+static void
+init_lightmodel( struct gl_lightmodel *lm )
 {
    ASSIGN_4V( lm->Ambient, 0.2, 0.2, 0.2, 1.0 );
    lm->LocalViewer = GL_FALSE;
@@ -589,7 +572,8 @@ static void init_lightmodel( struct gl_lightmodel *lm )
 }
 
 
-static void init_material( struct gl_material *m )
+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 );
@@ -603,7 +587,8 @@ static void init_material( struct gl_material *m )
 
 
 
-static void init_texture_unit( GLcontext *ctx, GLuint unit )
+static void
+init_texture_unit( GLcontext *ctx, GLuint unit )
 {
    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 
@@ -627,10 +612,12 @@ static void init_texture_unit( GLcontext *ctx, GLuint unit )
    texUnit->CurrentD[1] = ctx->Shared->DefaultD[1];
    texUnit->CurrentD[2] = ctx->Shared->DefaultD[2];
    texUnit->CurrentD[3] = ctx->Shared->DefaultD[3];
+   texUnit->CurrentCubeMap = ctx->Shared->DefaultCubeMap;
 }
 
 
-static void init_fallback_arrays( GLcontext *ctx )
+static void
+init_fallback_arrays( GLcontext *ctx )
 {
    struct gl_client_array *cl;
    GLuint i;
@@ -680,7 +667,8 @@ static void init_fallback_arrays( GLcontext *ctx )
 
 
 /* Initialize a 1-D evaluator map */
-static void init_1d_map( struct gl_1d_map *map, int n, const float *initial )
+static void
+init_1d_map( struct gl_1d_map *map, int n, const float *initial )
 {
    map->Order = 1;
    map->u1 = 0.0;
@@ -695,7 +683,8 @@ static void init_1d_map( struct gl_1d_map *map, int n, const float *initial )
 
 
 /* Initialize a 2-D evaluator map */
-static void init_2d_map( struct gl_2d_map *map, int n, const float *initial )
+static void
+init_2d_map( struct gl_2d_map *map, int n, const float *initial )
 {
    map->Uorder = 1;
    map->Vorder = 1;
@@ -712,22 +701,11 @@ static void init_2d_map( struct gl_2d_map *map, int n, const float *initial )
 }
 
 
-static void init_color_table( struct gl_color_table *p )
-{
-   p->Table[0] = 255;
-   p->Table[1] = 255;
-   p->Table[2] = 255;
-   p->Table[3] = 255;
-   p->Size = 1;
-   p->IntFormat = GL_RGBA;
-   p->Format = GL_RGBA;
-}
-
-
 /*
  * Initialize the attribute groups in a GLcontext.
  */
-static void init_attrib_groups( GLcontext *ctx )
+static void
+init_attrib_groups( GLcontext *ctx )
 {
    GLuint i, j;
 
@@ -736,6 +714,7 @@ static void init_attrib_groups( GLcontext *ctx )
    /* Constants, may be overriden by device drivers */
    ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
    ctx->Const.MaxTextureSize = 1 << (MAX_TEXTURE_LEVELS - 1);
+   ctx->Const.MaxCubeTextureSize = ctx->Const.MaxTextureSize;
    ctx->Const.MaxTextureUnits = MAX_TEXTURE_UNITS;
    ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
    ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
@@ -750,13 +729,17 @@ static void init_attrib_groups( GLcontext *ctx )
    ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
    ctx->Const.LineWidthGranularity = LINE_WIDTH_GRANULARITY;
    ctx->Const.NumAuxBuffers = NUM_AUX_BUFFERS;
+   ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
+   ctx->Const.MaxConvolutionWidth = MAX_CONVOLUTION_WIDTH;
+   ctx->Const.MaxConvolutionHeight = MAX_CONVOLUTION_HEIGHT;
+   ctx->Const.NumCompressedTextureFormats = 0;
 
    /* 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++) {
+   for (i = 0; i < MAX_MODELVIEW_STACK_DEPTH - 1; i++) {
       gl_matrix_ctr( &ctx->ModelViewStack[i] );
       gl_matrix_alloc_inv( &ctx->ModelViewStack[i] );
    }
@@ -773,7 +756,7 @@ static void init_attrib_groups( GLcontext *ctx )
    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++) {
+   for (i = 0; i < MAX_PROJECTION_STACK_DEPTH - 1; i++) {
       gl_matrix_ctr( &ctx->ProjectionStack[i] );
       gl_matrix_alloc_inv( &ctx->ProjectionStack[i] );
    }
@@ -782,11 +765,18 @@ static void init_attrib_groups( GLcontext *ctx )
    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++) {
+      for (j = 0; j < MAX_TEXTURE_STACK_DEPTH - 1; j++) {
          ctx->TextureStack[i][j].inv = 0;
       }
    }
 
+   /* Color matrix */
+   gl_matrix_ctr(&ctx->ColorMatrix);
+   ctx->ColorStackDepth = 0;
+   for (j = 0; j < MAX_COLOR_STACK_DEPTH - 1; j++) {
+      gl_matrix_ctr(&ctx->ColorStack[j]);
+   }
+
    /* Accumulate buffer group */
    ASSIGN_4V( ctx->Accum.ClearColor, 0.0, 0.0, 0.0, 0.0 );
 
@@ -845,6 +835,7 @@ static void init_attrib_groups( GLcontext *ctx )
    ctx->Depth.Clear = 1.0;
    ctx->Depth.Func = GL_LESS;
    ctx->Depth.Mask = GL_TRUE;
+   ctx->Depth.OcclusionTest = GL_FALSE;
 
    /* Evaluators group */
    ctx->Eval.Map1Color4 = GL_FALSE;
@@ -920,11 +911,38 @@ static void init_attrib_groups( GLcontext *ctx )
    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.AllowDrawFrg = GL_TRUE;
    ctx->Hint.AllowDrawMem = GL_TRUE;
    ctx->Hint.StrictLighting = GL_TRUE;
+   ctx->Hint.ClipVolumeClipping = GL_DONT_CARE;
+   ctx->Hint.TextureCompression = GL_DONT_CARE;
+
+   /* Histogram group */
+   ctx->Histogram.Width = 0;
+   ctx->Histogram.Format = GL_RGBA;
+   ctx->Histogram.Sink = GL_FALSE;
+   ctx->Histogram.RedSize       = 0xffffffff;
+   ctx->Histogram.GreenSize     = 0xffffffff;
+   ctx->Histogram.BlueSize      = 0xffffffff;
+   ctx->Histogram.AlphaSize     = 0xffffffff;
+   ctx->Histogram.LuminanceSize = 0xffffffff;
+   for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) {
+      ctx->Histogram.Count[i][0] = 0;
+      ctx->Histogram.Count[i][1] = 0;
+      ctx->Histogram.Count[i][2] = 0;
+      ctx->Histogram.Count[i][3] = 0;
+   }
+
+   /* Min/Max group */
+   ctx->MinMax.Format = GL_RGBA;
+   ctx->MinMax.Sink = GL_FALSE;
+   ctx->MinMax.Min[RCOMP] = 1000;    ctx->MinMax.Max[RCOMP] = -1000;
+   ctx->MinMax.Min[GCOMP] = 1000;    ctx->MinMax.Max[GCOMP] = -1000;
+   ctx->MinMax.Min[BCOMP] = 1000;    ctx->MinMax.Max[BCOMP] = -1000;
+   ctx->MinMax.Min[ACOMP] = 1000;    ctx->MinMax.Max[ACOMP] = -1000;
+
+
 
    /* Pipeline */
    gl_pipeline_init( ctx );
@@ -1022,6 +1040,29 @@ static void init_attrib_groups( GLcontext *ctx )
    ctx->Pixel.MapGtoG[0] = 0.0;
    ctx->Pixel.MapBtoB[0] = 0.0;
    ctx->Pixel.MapAtoA[0] = 0.0;
+   ctx->Pixel.HistogramEnabled = GL_FALSE;
+   ctx->Pixel.MinMaxEnabled = GL_FALSE;
+   ctx->Pixel.PixelTextureEnabled = GL_FALSE;
+   ctx->Pixel.FragmentRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
+   ctx->Pixel.FragmentAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
+   ASSIGN_4V(ctx->Pixel.PostColorMatrixScale, 1.0, 1.0, 1.0, 1.0);
+   ASSIGN_4V(ctx->Pixel.PostColorMatrixBias, 0.0, 0.0, 0.0, 0.0);
+   ASSIGN_4V(ctx->Pixel.ColorTableScale, 1.0, 1.0, 1.0, 1.0);
+   ASSIGN_4V(ctx->Pixel.ColorTableBias, 0.0, 0.0, 0.0, 0.0);
+   ctx->Pixel.ColorTableEnabled = GL_FALSE;
+   ctx->Pixel.PostConvolutionColorTableEnabled = GL_FALSE;
+   ctx->Pixel.PostColorMatrixColorTableEnabled = GL_FALSE;
+   ctx->Pixel.Convolution1DEnabled = GL_FALSE;
+   ctx->Pixel.Convolution2DEnabled = GL_FALSE;
+   ctx->Pixel.Separable2DEnabled = GL_FALSE;
+   for (i = 0; i < 3; i++) {
+      ASSIGN_4V(ctx->Pixel.ConvolutionBorderColor[i], 0.0, 0.0, 0.0, 0.0);
+      ctx->Pixel.ConvolutionBorderMode[i] = GL_REDUCE;
+      ASSIGN_4V(ctx->Pixel.ConvolutionFilterScale[i], 1.0, 1.0, 1.0, 1.0);
+      ASSIGN_4V(ctx->Pixel.ConvolutionFilterBias[i], 0.0, 0.0, 0.0, 0.0);
+   }
+   ASSIGN_4V(ctx->Pixel.PostConvolutionScale, 1.0, 1.0, 1.0, 1.0);
+   ASSIGN_4V(ctx->Pixel.PostConvolutionBias, 0.0, 0.0, 0.0, 0.0);
 
    /* Point group */
    ctx->Point.SmoothFlag = GL_FALSE;
@@ -1077,7 +1118,7 @@ static void init_attrib_groups( GLcontext *ctx )
    ctx->Texture.Enabled = 0;
    for (i=0; i<MAX_TEXTURE_UNITS; i++)
       init_texture_unit( ctx, i );
-   init_color_table(&ctx->Texture.Palette);
+   _mesa_init_colortable(&ctx->Texture.Palette);
 
    /* Transformation group */
    ctx->Transform.MatrixMode = GL_MODELVIEW;
@@ -1100,8 +1141,8 @@ static void init_attrib_groups( GLcontext *ctx )
 
 #define Sz 10
 #define Tz 14
-   ctx->Viewport.WindowMap.m[Sz] = 0.5 * DEPTH_SCALE;
-   ctx->Viewport.WindowMap.m[Tz] = 0.5 * DEPTH_SCALE;
+   ctx->Viewport.WindowMap.m[Sz] = 0.5 * ctx->Visual->DepthMaxF;
+   ctx->Viewport.WindowMap.m[Tz] = 0.5 * ctx->Visual->DepthMaxF;
 #undef Sz
 #undef Tz
 
@@ -1185,6 +1226,23 @@ static void init_attrib_groups( GLcontext *ctx )
    ctx->AttribStackDepth = 0;
    ctx->ClientAttribStackDepth = 0;
 
+   /* 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;
+
+   /* Color tables */
+   _mesa_init_colortable(&ctx->ColorTable);
+   _mesa_init_colortable(&ctx->ProxyColorTable);
+   _mesa_init_colortable(&ctx->PostConvolutionColorTable);
+   _mesa_init_colortable(&ctx->ProxyPostConvolutionColorTable);
+   _mesa_init_colortable(&ctx->PostColorMatrixColorTable);
+   _mesa_init_colortable(&ctx->ProxyPostColorMatrixColorTable);
+
    /* Miscellaneous */
    ctx->NewState = NEW_ALL;
    ctx->RenderMode = GL_RENDER;
@@ -1196,18 +1254,11 @@ static void init_attrib_groups( GLcontext *ctx )
    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;
+   ctx->OcclusionResult = GL_FALSE;
+   ctx->OcclusionResultSaved = GL_FALSE;
 
    /* For debug/development only */
    ctx->NoRaster = getenv("MESA_NO_RASTER") ? GL_TRUE : GL_FALSE;
@@ -1231,7 +1282,8 @@ static void init_attrib_groups( GLcontext *ctx )
  * the allocations clean up and return GL_FALSE.
  * Return:  GL_TRUE=success, GL_FALSE=failure
  */
-static GLboolean alloc_proxy_textures( GLcontext *ctx )
+static GLboolean
+alloc_proxy_textures( GLcontext *ctx )
 {
    GLboolean out_of_memory;
    GLint i;
@@ -1256,9 +1308,9 @@ static GLboolean alloc_proxy_textures( GLcontext *ctx )
 
    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();
+      ctx->Texture.Proxy1D->Image[i] = _mesa_alloc_texture_image();
+      ctx->Texture.Proxy2D->Image[i] = _mesa_alloc_texture_image();
+      ctx->Texture.Proxy3D->Image[i] = _mesa_alloc_texture_image();
       if (!ctx->Texture.Proxy1D->Image[i]
           || !ctx->Texture.Proxy2D->Image[i]
           || !ctx->Texture.Proxy3D->Image[i]) {
@@ -1268,13 +1320,13 @@ static GLboolean alloc_proxy_textures( GLcontext *ctx )
    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]);
+            _mesa_free_texture_image(ctx->Texture.Proxy1D->Image[i]);
          }
          if (ctx->Texture.Proxy2D->Image[i]) {
-            gl_free_texture_image(ctx->Texture.Proxy2D->Image[i]);
+            _mesa_free_texture_image(ctx->Texture.Proxy2D->Image[i]);
          }
          if (ctx->Texture.Proxy3D->Image[i]) {
-            gl_free_texture_image(ctx->Texture.Proxy3D->Image[i]);
+            _mesa_free_texture_image(ctx->Texture.Proxy3D->Image[i]);
          }
       }
       gl_free_texture_object(NULL, ctx->Texture.Proxy1D);
@@ -1292,12 +1344,15 @@ static GLboolean alloc_proxy_textures( GLcontext *ctx )
 /*
  * Initialize a GLcontext struct.
  */
-GLboolean gl_initialize_context_data( GLcontext *ctx,
-                                      GLvisual *visual,
-                                      GLcontext *share_list,
-                                      void *driver_ctx,
-                                      GLboolean direct )
+GLboolean
+_mesa_initialize_context( GLcontext *ctx,
+                          GLvisual *visual,
+                          GLcontext *share_list,
+                          void *driver_ctx,
+                          GLboolean direct )
 {
+   GLuint dispatchSize;
+
    (void) direct;  /* not used */
 
    /* misc one-time initializations */
@@ -1360,10 +1415,6 @@ GLboolean gl_initialize_context_data( GLcontext *ctx,
       ctx->Pixel.DriverReadBuffer = GL_FRONT_LEFT;
    }
 
-#ifdef PROFILE
-   init_timings( ctx );
-#endif
-
    if (!alloc_proxy_textures(ctx)) {
       free_shared_state(ctx, ctx->Shared);
       FREE(ctx->VB);
@@ -1372,9 +1423,27 @@ GLboolean gl_initialize_context_data( GLcontext *ctx,
       return GL_FALSE;
    }
 
+   /* register the most recent extension functions with libGL */
+   _glapi_add_entrypoint("glTbufferMask3DFX", 553);
+   _glapi_add_entrypoint("glCompressedTexImage3DARB", 554);
+   _glapi_add_entrypoint("glCompressedTexImage2DARB", 555);
+   _glapi_add_entrypoint("glCompressedTexImage1DARB", 556);
+   _glapi_add_entrypoint("glCompressedTexSubImage3DARB", 557);
+   _glapi_add_entrypoint("glCompressedTexSubImage2DARB", 558);
+   _glapi_add_entrypoint("glCompressedTexSubImage1DARB", 559);
+   _glapi_add_entrypoint("glGetCompressedTexImageARB", 560);
+
+   /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
+    * In practice, this'll be the same for stand-alone Mesa.  But for DRI
+    * Mesa we do this to accomodate different versions of libGL and various
+    * DRI drivers.
+    */
+   dispatchSize = MAX2(_glapi_get_dispatch_table_size(),
+                       sizeof(struct _glapi_table) / sizeof(void *));
+
    /* setup API dispatch tables */
-   ctx->Exec = CALLOC(_glapi_get_dispatch_table_size() * sizeof(void *));
-   ctx->Save = CALLOC(_glapi_get_dispatch_table_size() * sizeof(void *));
+   ctx->Exec = (struct _glapi_table *) CALLOC(dispatchSize * sizeof(void*));
+   ctx->Save = (struct _glapi_table *) CALLOC(dispatchSize * sizeof(void*));
    if (!ctx->Exec || !ctx->Save) {
       free_shared_state(ctx, ctx->Shared);
       FREE(ctx->VB);
@@ -1383,8 +1452,8 @@ GLboolean gl_initialize_context_data( GLcontext *ctx,
          FREE(ctx->Exec);
       FREE(ctx);
    }
-   _mesa_init_exec_table( ctx->Exec );
-   _mesa_init_dlist_table( ctx->Save );
+   _mesa_init_exec_table(ctx->Exec, dispatchSize);
+   _mesa_init_dlist_table(ctx->Save, dispatchSize);
    ctx->CurrentDispatch = ctx->Exec;
 
    return GL_TRUE;
@@ -1399,18 +1468,18 @@ GLboolean gl_initialize_context_data( GLcontext *ctx,
  *         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 *
+gl_create_context( GLvisual *visual,
+                   GLcontext *share_list,
+                   void *driver_ctx,
+                   GLboolean direct )
 {
    GLcontext *ctx = (GLcontext *) CALLOC( sizeof(GLcontext) );
    if (!ctx) {
       return NULL;
    }
 
-   if (gl_initialize_context_data(ctx, visual, share_list,
-                                  driver_ctx, direct)) {
+   if (_mesa_initialize_context(ctx, visual, share_list, driver_ctx, direct)) {
       return ctx;
    }
    else {
@@ -1425,34 +1494,35 @@ GLcontext *gl_create_context( GLvisual *visual,
  * Free the data associated with the given context.
  * But don't free() the GLcontext struct itself!
  */
-void gl_free_context_data( GLcontext *ctx )
+void
+gl_free_context_data( GLcontext *ctx )
 {
-   GLuint i;
    struct gl_shine_tab *s, *tmps;
+   GLuint i, j;
 
    /* if we're destroying the current context, unbind it first */
    if (ctx == gl_get_current_context()) {
       gl_make_current(NULL, NULL);
    }
 
-#ifdef PROFILE
-   if (getenv("MESA_PROFILE")) {
-      print_timings( ctx );
-   }
-#endif
-
    gl_matrix_dtr( &ctx->ModelView );
-   for (i = 0 ; i < MAX_MODELVIEW_STACK_DEPTH ; i++) {
+   for (i = 0; i < MAX_MODELVIEW_STACK_DEPTH - 1; i++) {
       gl_matrix_dtr( &ctx->ModelViewStack[i] );
    }
    gl_matrix_dtr( &ctx->ProjectionMatrix );
-   for (i = 0 ; i < MAX_PROJECTION_STACK_DEPTH ; i++) {
+   for (i = 0; i < MAX_PROJECTION_STACK_DEPTH - 1; i++) {
       gl_matrix_dtr( &ctx->ProjectionStack[i] );
    }
+   for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
+      gl_matrix_dtr( &ctx->TextureMatrix[i] );
+      for (j = 0; j < MAX_TEXTURE_STACK_DEPTH - 1; j++) {
+         gl_matrix_dtr( &ctx->TextureStack[i][j] );
+      }
+   }
 
    FREE( ctx->PB );
 
-   if(ctx->input != ctx->VB->IM)
+   if (ctx->input != ctx->VB->IM)
       gl_immediate_free( ctx->input );
 
    gl_vb_free( ctx->VB );
@@ -1515,6 +1585,11 @@ void gl_free_context_data( GLcontext *ctx )
    if (ctx->EvalMap.Map2Texture4.Points)
       FREE( ctx->EvalMap.Map2Texture4.Points );
 
+   _mesa_free_colortable_data( &ctx->ColorTable );
+   _mesa_free_colortable_data( &ctx->PostConvolutionColorTable );
+   _mesa_free_colortable_data( &ctx->PostColorMatrixColorTable );
+   _mesa_free_colortable_data( &ctx->Texture.Palette );
+
    /* Free cache of immediate buffers. */
    while (ctx->nr_im_queued-- > 0) {
       struct immediate * next = ctx->freed_im_queue->next;
@@ -1532,7 +1607,8 @@ void gl_free_context_data( GLcontext *ctx )
 /*
  * Destroy a GLcontext structure.
  */
-void gl_destroy_context( GLcontext *ctx )
+void
+gl_destroy_context( GLcontext *ctx )
 {
    if (ctx) {
       gl_free_context_data(ctx);
@@ -1546,7 +1622,8 @@ void gl_destroy_context( GLcontext *ctx )
  * Called by the driver after both the context and driver are fully
  * initialized.  Currently just reads the config file.
  */
-void gl_context_initialize( GLcontext *ctx )
+void
+gl_context_initialize( GLcontext *ctx )
 {
    gl_read_config_file( ctx );
 }
@@ -1559,7 +1636,8 @@ void gl_context_initialize( GLcontext *ctx )
  *         dst - destination context
  *         mask - bitwise OR of GL_*_BIT flags
  */
-void gl_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
+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) );
@@ -1767,7 +1845,7 @@ _mesa_get_dispatch(GLcontext *ctx)
 void gl_problem( const GLcontext *ctx, const char *s )
 {
    fprintf( stderr, "Mesa implementation error: %s\n", s );
-   fprintf( stderr, "Report to mesa-bugs@mesa3d.org\n" );
+   fprintf( stderr, "Report to Mesa bug database at www.mesa3d.org\n" );
    (void) ctx;
 }