aboutsummaryrefslogtreecommitdiffstats
path: root/src/mesa/main/context.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/mesa/main/context.c')
-rw-r--r--src/mesa/main/context.c2388
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;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-01 23:03:10 +0000