-/* $Id: context.c,v 1.41 2000/02/03 15:33:29 brianp Exp $ */
+/* $Id: context.c,v 1.70 2000/05/26 14:44:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
#include "accum.h"
#include "alphabuf.h"
#include "clip.h"
+#include "colortab.h"
#include "context.h"
#include "cva.h"
#include "depth.h"
#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;
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);
}
* 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 ) {
}
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);
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 );
/*
* 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);
gl_init_clip();
gl_init_eval();
_mesa_init_fog();
- gl_init_math();
+ _mesa_init_math();
gl_init_lists();
gl_init_shade();
gl_init_texture();
/*
* 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;
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)
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;
}
/*
* 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) {
* 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 );
-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;
}
-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 );
-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];
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;
/* 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;
/* 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;
}
-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;
assert(ctx);
- /* Constants, may be overriden by device driver */
+ /* 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 = 4;
+ ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
+ ctx->Const.MinPointSize = MIN_POINT_SIZE;
+ ctx->Const.MaxPointSize = MAX_POINT_SIZE;
+ ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
+ ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
+ ctx->Const.PointSizeGranularity = POINT_SIZE_GRANULARITY;
+ ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
+ ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
+ ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
+ 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] );
}
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] );
}
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 );
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;
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 );
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;
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;
#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
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;
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;
* 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;
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]) {
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);
/*
* 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 */
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);
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 */
- _mesa_init_exec_table( &ctx->Exec );
- _mesa_init_dlist_table( &ctx->Save );
- ctx->CurrentDispatch = &ctx->Exec;
+ 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);
+ FREE(ctx->PB);
+ if (ctx->Exec)
+ FREE(ctx->Exec);
+ FREE(ctx);
+ }
+ _mesa_init_exec_table(ctx->Exec, dispatchSize);
+ _mesa_init_dlist_table(ctx->Save, dispatchSize);
+ ctx->CurrentDispatch = ctx->Exec;
return GL_TRUE;
}
* 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 {
* 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 );
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;
ctx->freed_im_queue = next;
}
gl_extensions_dtr(ctx);
+
+ FREE(ctx->Exec);
+ FREE(ctx->Save);
}
/*
* Destroy a GLcontext structure.
*/
-void gl_destroy_context( GLcontext *ctx )
+void
+gl_destroy_context( GLcontext *ctx )
{
if (ctx) {
gl_free_context_data(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 );
}
* 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) );
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;
}
projects / mesa.git / blobdiff