-/* $Id: context.c,v 1.62 2000/05/04 13:53:55 brianp Exp $ */
+/* $Id: context.c,v 1.93 2000/10/20 19:54:49 brianp Exp $ */
/*
* Mesa 3-D graphics library
- * Version: 3.3
+ * Version: 3.5
*
* Copyright (C) 1999-2000 Brian Paul All Rights Reserved.
*
#include "all.h"
#else
#include "glheader.h"
-#include "accum.h"
-#include "alphabuf.h"
+#include "buffers.h"
#include "clip.h"
#include "colortab.h"
#include "context.h"
#include "cva.h"
-#include "depth.h"
#include "dlist.h"
#include "eval.h"
#include "enums.h"
#include "extensions.h"
#include "fog.h"
#include "get.h"
-#include "glapi.h"
#include "glapinoop.h"
#include "glthread.h"
#include "hash.h"
+#include "imports.h"
#include "light.h"
#include "macros.h"
#include "matrix.h"
#include "pipeline.h"
#include "shade.h"
#include "simple_list.h"
-#include "stencil.h"
#include "stages.h"
#include "state.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 "vbrender.h"
#include "vbxform.h"
#include "vertices.h"
#include "xform.h"
#endif
+#if defined(MESA_TRACE)
+#include "Trace/tr_context.h"
+#include "Trace/tr_wrapper.h"
+#endif
+
+
+
+/**********************************************************************/
+/***** OpenGL SI-style interface (new in Mesa 3.5) *****/
+/**********************************************************************/
+
+static GLboolean
+_mesa_DestroyContext(__GLcontext *gc)
+{
+ if (gc) {
+ _mesa_free_context_data(gc);
+ (*gc->imports.free)(gc, gc);
+ }
+ return GL_TRUE;
+}
+
+
+/* exported OpenGL SI interface */
+__GLcontext *
+__glCoreCreateContext(__GLimports *imports, __GLcontextModes *modes)
+{
+ GLcontext *ctx;
+
+ ctx = (GLcontext *) (*imports->calloc)(0, 1, sizeof(GLcontext));
+ if (ctx == NULL) {
+ return NULL;
+ }
+ ctx->imports = *imports;
+
+ _mesa_initialize_visual(&ctx->Visual,
+ modes->rgbMode,
+ modes->doubleBufferMode,
+ modes->stereoMode,
+ modes->redBits,
+ modes->greenBits,
+ modes->blueBits,
+ modes->alphaBits,
+ modes->indexBits,
+ modes->depthBits,
+ modes->stencilBits,
+ modes->accumRedBits,
+ modes->accumGreenBits,
+ modes->accumBlueBits,
+ modes->accumAlphaBits,
+ 0);
+
+ _mesa_initialize_context(ctx, &ctx->Visual, NULL, imports->wscx, GL_FALSE);
+
+ ctx->exports.destroyContext = _mesa_DestroyContext;
+
+ return ctx;
+}
+
+
+/* exported OpenGL SI interface */
+void
+__glCoreNopDispatch(void)
+{
+#if 0
+ /* SI */
+ __gl_dispatch = __glNopDispatchState;
+#else
+ /* Mesa */
+ _glapi_set_dispatch(NULL);
+#endif
+}
/**********************************************************************/
indexBits, depthBits, stencilBits,
accumRedBits, accumGreenBits,
accumBlueBits, accumAlphaBits,
- numSamples )) {
+ numSamples)) {
FREE(vis);
return NULL;
}
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.
+ * good values for DepthMax for Z vertex transformation purposes
+ * and for per-fragment fog computation.
*/
- vis->DepthMax = 1;
- vis->DepthMaxF = 1.0F;
+ vis->DepthMax = 1 << 16;
+ vis->DepthMaxF = (GLfloat) vis->DepthMax;
}
- else {
+ 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;
+ }
return GL_TRUE;
}
-/* 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 )
{
}
-/* obsolete */
-void
-gl_destroy_visual( GLvisual *vis )
-{
- _mesa_destroy_visual(vis);
-}
-
-
-
/**********************************************************************/
/***** GL Framebuffer allocation/destruction *****/
/**********************************************************************/
* Return: pointer to new GLframebuffer struct or NULL if error.
*/
GLframebuffer *
-gl_create_framebuffer( GLvisual *visual,
- GLboolean softwareDepth,
- GLboolean softwareStencil,
- GLboolean softwareAccum,
- GLboolean softwareAlpha )
+_mesa_create_framebuffer( GLvisual *visual,
+ GLboolean softwareDepth,
+ GLboolean softwareStencil,
+ GLboolean softwareAccum,
+ GLboolean softwareAlpha )
{
GLframebuffer *buffer = CALLOC_STRUCT(gl_frame_buffer);
assert(visual);
/*
* Initialize a GLframebuffer object.
- * Input: See gl_create_framebuffer() above.
+ * Input: See _mesa_create_framebuffer() above.
*/
void
_mesa_initialize_framebuffer( GLframebuffer *buffer,
* Free a framebuffer struct and its buffers.
*/
void
-gl_destroy_framebuffer( GLframebuffer *buffer )
+_mesa_destroy_framebuffer( GLframebuffer *buffer )
{
if (buffer) {
if (buffer->DepthBuffer) {
gl_init_translate();
gl_init_vbrender();
gl_init_vbxform();
- gl_init_vertices();
if (getenv("MESA_DEBUG")) {
_glapi_noop_enable_warnings(GL_TRUE);
if (!ss)
return NULL;
- ss->DisplayList = _mesa_NewHashTable();
+ _glthread_INIT_MUTEX(ss->Mutex);
+ ss->DisplayList = _mesa_NewHashTable();
ss->TexObjects = _mesa_NewHashTable();
/* Default Texture objects */
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;
}
struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
texUnit->EnvMode = GL_MODULATE;
+ texUnit->CombineModeRGB = GL_MODULATE;
+ texUnit->CombineModeA = GL_MODULATE;
+ texUnit->CombineSourceRGB[0] = GL_TEXTURE;
+ texUnit->CombineSourceRGB[1] = GL_PREVIOUS_EXT;
+ texUnit->CombineSourceRGB[2] = GL_CONSTANT_EXT;
+ texUnit->CombineSourceA[0] = GL_TEXTURE;
+ texUnit->CombineSourceA[1] = GL_PREVIOUS_EXT;
+ texUnit->CombineSourceA[2] = GL_CONSTANT_EXT;
+ texUnit->CombineOperandRGB[0] = GL_SRC_COLOR;
+ texUnit->CombineOperandRGB[1] = GL_SRC_COLOR;
+ texUnit->CombineOperandRGB[2] = GL_SRC_ALPHA;
+ texUnit->CombineOperandA[0] = GL_SRC_ALPHA;
+ texUnit->CombineOperandA[1] = GL_SRC_ALPHA;
+ texUnit->CombineOperandA[2] = GL_SRC_ALPHA;
+ texUnit->CombineScaleShiftRGB = 0;
+ texUnit->CombineScaleShiftA = 0;
+
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;
+ texUnit->GenBitS = TEXGEN_EYE_LINEAR;
+ texUnit->GenBitT = TEXGEN_EYE_LINEAR;
+ texUnit->GenBitR = TEXGEN_EYE_LINEAR;
+ texUnit->GenBitQ = TEXGEN_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 );
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;
}
/* Constants, may be overriden by device drivers */
ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
ctx->Const.MaxTextureSize = 1 << (MAX_TEXTURE_LEVELS - 1);
+ ctx->Const.MaxCubeTextureSize = ctx->Const.MaxTextureSize;
ctx->Const.MaxTextureUnits = MAX_TEXTURE_UNITS;
ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
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 );
}
/* Texture matrix */
- for (i=0; i<MAX_TEXTURE_UNITS; 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 - 1; j++) {
+ gl_matrix_ctr( &ctx->TextureStack[i][j] );
ctx->TextureStack[i][j].inv = 0;
}
}
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;
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;
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);
+ ctx->Current.Flag = (VERT_NORM |
+ VERT_INDEX |
+ VERT_RGBA |
+ VERT_EDGE |
+ VERT_TEX0_1 |
+ VERT_TEX1_1 |
+ VERT_TEX2_1 | /* XXX fix for MAX_TEXTURE_UNITS > 3 */
+ VERT_MATERIAL);
init_fallback_arrays( ctx );
ctx->Hint.LineSmooth = GL_DONT_CARE;
ctx->Hint.PolygonSmooth = GL_DONT_CARE;
ctx->Hint.Fog = GL_DONT_CARE;
-
ctx->Hint.AllowDrawWin = GL_TRUE;
ctx->Hint.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->MinMax.Min[BCOMP] = 1000; ctx->MinMax.Max[BCOMP] = -1000;
ctx->MinMax.Min[ACOMP] = 1000; ctx->MinMax.Max[ACOMP] = -1000;
-
-
/* Pipeline */
gl_pipeline_init( ctx );
gl_cva_init( ctx );
ctx->ShineTable[i]->refcount++;
}
+ gl_compute_shine_table( ctx, 0, ctx->Light.Material[0].Shininess );
+ gl_compute_shine_table( ctx, 2, ctx->Light.Material[0].Shininess * .5 );
+ gl_compute_shine_table( ctx, 1, ctx->Light.Material[1].Shininess );
+ gl_compute_shine_table( ctx, 3, ctx->Light.Material[1].Shininess * .5 );
+
/* Line group */
ctx->Line.SmoothFlag = GL_FALSE;
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.PixelTextureEnabled = GL_FALSE;
ctx->Pixel.FragmentRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
ctx->Pixel.FragmentAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
- ctx->Pixel.PostColorMatrixRedBias = 0.0;
- ctx->Pixel.PostColorMatrixRedScale = 1.0;
- ctx->Pixel.PostColorMatrixGreenBias = 0.0;
- ctx->Pixel.PostColorMatrixGreenScale = 1.0;
- ctx->Pixel.PostColorMatrixBlueBias = 0.0;
- ctx->Pixel.PostColorMatrixBlueScale = 1.0;
- ctx->Pixel.PostColorMatrixAlphaBias = 0.0;
- ctx->Pixel.PostColorMatrixAlphaScale = 1.0;
- ctx->Pixel.ColorTableScale[0] = 1.0F;
- ctx->Pixel.ColorTableScale[1] = 1.0F;
- ctx->Pixel.ColorTableScale[2] = 1.0F;
- ctx->Pixel.ColorTableScale[3] = 1.0F;
- ctx->Pixel.ColorTableBias[0] = 0.0F;
- ctx->Pixel.ColorTableBias[1] = 0.0F;
- ctx->Pixel.ColorTableBias[2] = 0.0F;
- ctx->Pixel.ColorTableBias[3] = 0.0F;
+ 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);
+ ASSIGN_4V(ctx->Pixel.PCCTscale, 1.0, 1.0, 1.0, 1.0);
+ ASSIGN_4V(ctx->Pixel.PCCTbias, 0.0, 0.0, 0.0, 0.0);
+ ASSIGN_4V(ctx->Pixel.PCMCTscale, 1.0, 1.0, 1.0, 1.0);
+ ASSIGN_4V(ctx->Pixel.PCMCTbias, 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->Point.UserSize = 1.0;
ctx->Point.Size = 1.0;
ctx->Point.Params[0] = 1.0;
ctx->Point.Params[1] = 0.0;
/* Texture group */
ctx->Texture.CurrentUnit = 0; /* multitexture */
ctx->Texture.CurrentTransformUnit = 0; /* multitexture */
- ctx->Texture.Enabled = 0;
+ ctx->Texture.ReallyEnabled = 0;
for (i=0; i<MAX_TEXTURE_UNITS; i++)
init_texture_unit( ctx, i );
+ ctx->Texture.SharedPalette = GL_FALSE;
_mesa_init_colortable(&ctx->Texture.Palette);
/* Transformation group */
#define Sz 10
#define Tz 14
- ctx->Viewport.WindowMap.m[Sz] = 0.5 * ctx->Visual->DepthMaxF;
- ctx->Viewport.WindowMap.m[Tz] = 0.5 * ctx->Visual->DepthMaxF;
+ 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->StippleCounter = 0;
ctx->NeedNormals = GL_FALSE;
ctx->DoViewportMapping = GL_TRUE;
+ ctx->ImageTransferState = UPDATE_IMAGE_TRANSFER_STATE;
ctx->NeedEyeCoords = GL_FALSE;
ctx->NeedEyeNormals = GL_FALSE;
}
-
/*
- * Initialize a GLcontext struct.
+ * Initialize a GLcontext struct. This includes allocating all the
+ * other structs and arrays which hang off of the context by pointers.
*/
GLboolean
_mesa_initialize_context( GLcontext *ctx,
void *driver_ctx,
GLboolean direct )
{
+ GLuint dispatchSize;
+
(void) direct; /* not used */
/* misc one-time initializations */
one_time_init();
+ /**
+ ** OpenGL SI stuff
+ **/
+ if (!ctx->imports.malloc) {
+ _mesa_InitDefaultImports(&ctx->imports, driver_ctx, NULL);
+ }
+ /* exports are setup by the device driver */
+
ctx->DriverCtx = driver_ctx;
- ctx->Visual = visual;
+ ctx->Visual = *visual;
ctx->DrawBuffer = NULL;
ctx->ReadBuffer = NULL;
ctx->VB = gl_vb_create_for_immediate( ctx );
if (!ctx->VB) {
- FREE( ctx );
return GL_FALSE;
}
ctx->input = ctx->VB->IM;
ctx->PB = gl_alloc_pb();
if (!ctx->PB) {
- FREE( ctx->VB );
- FREE( ctx );
+ ALIGN_FREE( ctx->VB );
return GL_FALSE;
}
/* allocate new group of display lists */
ctx->Shared = alloc_shared_state();
if (!ctx->Shared) {
- FREE(ctx->VB);
- FREE(ctx->PB);
- FREE(ctx);
+ ALIGN_FREE( ctx->VB );
+ FREE( ctx->PB );
return GL_FALSE;
}
}
if (!alloc_proxy_textures(ctx)) {
free_shared_state(ctx, ctx->Shared);
- FREE(ctx->VB);
- FREE(ctx->PB);
- FREE(ctx);
+ ALIGN_FREE( ctx->VB );
+ FREE( ctx->PB );
return GL_FALSE;
}
+ /* register the most recent extension functions with libGL */
+ _glapi_add_entrypoint("glTbufferMask3DFX", 553);
+ _glapi_add_entrypoint("glCompressedTexImage3DARB", 554);
+ _glapi_add_entrypoint("glCompressedTexImage2DARB", 555);
+ _glapi_add_entrypoint("glCompressedTexImage1DARB", 556);
+ _glapi_add_entrypoint("glCompressedTexSubImage3DARB", 557);
+ _glapi_add_entrypoint("glCompressedTexSubImage2DARB", 558);
+ _glapi_add_entrypoint("glCompressedTexSubImage1DARB", 559);
+ _glapi_add_entrypoint("glGetCompressedTexImageARB", 560);
+
+ /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
+ * In practice, this'll be the same for stand-alone Mesa. But for DRI
+ * Mesa we do this to accomodate different versions of libGL and various
+ * DRI drivers.
+ */
+ dispatchSize = MAX2(_glapi_get_dispatch_table_size(),
+ sizeof(struct _glapi_table) / sizeof(void *));
+
/* setup API dispatch tables */
- ctx->Exec = (struct _glapi_table *) CALLOC(_glapi_get_dispatch_table_size() * sizeof(void *));
- ctx->Save = (struct _glapi_table *) CALLOC(_glapi_get_dispatch_table_size() * sizeof(void *));
+ ctx->Exec = (struct _glapi_table *) CALLOC(dispatchSize * sizeof(void*));
+ ctx->Save = (struct _glapi_table *) CALLOC(dispatchSize * sizeof(void*));
if (!ctx->Exec || !ctx->Save) {
free_shared_state(ctx, ctx->Shared);
- FREE(ctx->VB);
- FREE(ctx->PB);
+ ALIGN_FREE( ctx->VB );
+ FREE( ctx->PB );
if (ctx->Exec)
- FREE(ctx->Exec);
- FREE(ctx);
+ FREE( ctx->Exec );
}
- _mesa_init_exec_table( ctx->Exec );
- _mesa_init_dlist_table( ctx->Save );
+ _mesa_init_exec_table(ctx->Exec, dispatchSize);
+ _mesa_init_dlist_table(ctx->Save, dispatchSize);
ctx->CurrentDispatch = ctx->Exec;
+#if defined(MESA_TRACE)
+ ctx->TraceCtx = CALLOC( sizeof(trace_context_t) );
+#if 0
+ /* Brian: do you want to have CreateContext fail here,
+ or should we just trap in NewTrace (currently done)? */
+ if (!(ctx->TraceCtx)) {
+ free_shared_state(ctx, ctx->Shared);
+ ALIGN_FREE( ctx->VB );
+ FREE( ctx->PB );
+ FREE( ctx->Exec );
+ FREE( ctx->Save );
+ return GL_FALSE;
+ }
+#endif
+ trInitContext(ctx->TraceCtx);
+
+ ctx->TraceDispatch = (struct _glapi_table *)
+ CALLOC(dispatchSize * sizeof(void*));
+#if 0
+ if (!(ctx->TraceCtx)) {
+ free_shared_state(ctx, ctx->Shared);
+ ALIGN_FREE( ctx->VB );
+ FREE( ctx->PB );
+ FREE( ctx->Exec );
+ FREE( ctx->Save );
+ FREE( ctx->TraceCtx );
+ return GL_FALSE;
+ }
+#endif
+ trInitDispatch(ctx->TraceDispatch);
+#endif
+
return GL_TRUE;
}
* 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.
+ * Return: pointer to a new __GLcontextRec or NULL if error.
*/
GLcontext *
-gl_create_context( GLvisual *visual,
- GLcontext *share_list,
- void *driver_ctx,
- GLboolean direct )
+_mesa_create_context( GLvisual *visual,
+ GLcontext *share_list,
+ void *driver_ctx,
+ GLboolean direct )
{
GLcontext *ctx = (GLcontext *) CALLOC( sizeof(GLcontext) );
if (!ctx) {
* But don't free() the GLcontext struct itself!
*/
void
-gl_free_context_data( GLcontext *ctx )
+_mesa_free_context_data( GLcontext *ctx )
{
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);
+ if (ctx == _mesa_get_current_context()) {
+ _mesa_make_current(NULL, NULL);
}
gl_matrix_dtr( &ctx->ModelView );
/* Free cache of immediate buffers. */
while (ctx->nr_im_queued-- > 0) {
struct immediate * next = ctx->freed_im_queue->next;
- FREE( ctx->freed_im_queue );
+ ALIGN_FREE( ctx->freed_im_queue );
ctx->freed_im_queue = next;
}
gl_extensions_dtr(ctx);
* Destroy a GLcontext structure.
*/
void
-gl_destroy_context( GLcontext *ctx )
+_mesa_destroy_context( GLcontext *ctx )
{
if (ctx) {
- gl_free_context_data(ctx);
+ _mesa_free_context_data(ctx);
FREE( (void *) ctx );
}
}
* initialized. Currently just reads the config file.
*/
void
-gl_context_initialize( GLcontext *ctx )
+_mesa_context_initialize( GLcontext *ctx )
{
gl_read_config_file( ctx );
}
* mask - bitwise OR of GL_*_BIT flags
*/
void
-gl_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
+_mesa_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) );
/*
* Set the current context, binding the given frame buffer to the context.
*/
-void gl_make_current( GLcontext *newCtx, GLframebuffer *buffer )
+void
+_mesa_make_current( GLcontext *newCtx, GLframebuffer *buffer )
{
- gl_make_current2( newCtx, buffer, buffer );
+ _mesa_make_current2( newCtx, buffer, buffer );
}
* Bind the given context to the given draw-buffer and read-buffer
* and make it the current context for this thread.
*/
-void gl_make_current2( GLcontext *newCtx, GLframebuffer *drawBuffer,
- GLframebuffer *readBuffer )
+void
+_mesa_make_current2( GLcontext *newCtx, GLframebuffer *drawBuffer,
+ GLframebuffer *readBuffer )
{
#if 0
GLcontext *oldCtx = gl_get_context();
/* Flush the old context
*/
if (oldCtx) {
- ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(oldCtx, "gl_make_current");
+ ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(oldCtx, "_mesa_make_current");
/* unbind frame buffers from context */
if (oldCtx->DrawBuffer) {
_glapi_check_multithread();
_glapi_set_context((void *) newCtx);
- ASSERT(gl_get_current_context() == newCtx);
+ ASSERT(_mesa_get_current_context() == newCtx);
if (newCtx) {
SET_IMMEDIATE(newCtx, newCtx->input);
_glapi_set_dispatch(newCtx->CurrentDispatch);
_glapi_set_dispatch(NULL); /* none current */
}
- if (MESA_VERBOSE) fprintf(stderr, "gl_make_current()\n");
+ if (MESA_VERBOSE) fprintf(stderr, "_mesa_make_current()\n");
if (newCtx && drawBuffer && readBuffer) {
/* TODO: check if newCtx and buffer's visual match??? */
* This isn't the fastest way to get the current context.
* If you need speed, see the GET_CURRENT_CONTEXT() macro in context.h
*/
-GLcontext *gl_get_current_context( void )
+GLcontext *
+_mesa_get_current_context( void )
{
return (GLcontext *) _glapi_get_context();
}
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;
}
* 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 )
+void
+_mesa_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;
+ (*ctx->imports.warning)((__GLcontext *) ctx, (char *) s);
}
/*
* Compile an error into current display list.
*/
-void gl_compile_error( GLcontext *ctx, GLenum error, const char *s )
+void
+_mesa_compile_error( GLcontext *ctx, GLenum error, const char *s )
{
if (ctx->CompileFlag)
gl_save_error( ctx, error, s );
* 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
+ * Input: ctx - the GL context
+ * error - the error value
+ * where - usually the name of function where error was detected
*/
-void gl_error( GLcontext *ctx, GLenum error, const char *s )
+void
+gl_error( GLcontext *ctx, GLenum error, const char *where )
{
+ const char *debugEnv = getenv("MESA_DEBUG");
GLboolean debug;
#ifdef DEBUG
- debug = GL_TRUE;
+ if (debugEnv && strstr(debugEnv, "silent"))
+ debug = GL_FALSE;
+ else
+ debug = GL_TRUE;
#else
- if (getenv("MESA_DEBUG")) {
+ if (debugEnv)
debug = GL_TRUE;
- }
- else {
+ else
debug = GL_FALSE;
- }
#endif
if (debug) {
- char errstr[1000];
-
+ const char *errstr;
switch (error) {
case GL_NO_ERROR:
- strcpy( errstr, "GL_NO_ERROR" );
+ errstr = "GL_NO_ERROR";
break;
case GL_INVALID_VALUE:
- strcpy( errstr, "GL_INVALID_VALUE" );
+ errstr = "GL_INVALID_VALUE";
break;
case GL_INVALID_ENUM:
- strcpy( errstr, "GL_INVALID_ENUM" );
+ errstr = "GL_INVALID_ENUM";
break;
case GL_INVALID_OPERATION:
- strcpy( errstr, "GL_INVALID_OPERATION" );
+ errstr = "GL_INVALID_OPERATION";
break;
case GL_STACK_OVERFLOW:
- strcpy( errstr, "GL_STACK_OVERFLOW" );
+ errstr = "GL_STACK_OVERFLOW";
break;
case GL_STACK_UNDERFLOW:
- strcpy( errstr, "GL_STACK_UNDERFLOW" );
+ errstr = "GL_STACK_UNDERFLOW";
break;
case GL_OUT_OF_MEMORY:
- strcpy( errstr, "GL_OUT_OF_MEMORY" );
+ errstr = "GL_OUT_OF_MEMORY";
break;
+ case GL_TABLE_TOO_LARGE:
+ errstr = "GL_TABLE_TOO_LARGE";
+ break;
default:
- strcpy( errstr, "unknown" );
+ errstr = "unknown";
break;
}
- fprintf( stderr, "Mesa user error: %s in %s\n", errstr, s );
+ fprintf(stderr, "Mesa user error: %s in %s\n", errstr, where);
}
- if (ctx->ErrorValue==GL_NO_ERROR) {
+ if (ctx->ErrorValue == GL_NO_ERROR) {
ctx->ErrorValue = error;
}
(*ctx->Driver.Flush)( ctx );
}
}
+
+
+
+const char *_mesa_prim_name[GL_POLYGON+2] = {
+ "GL_POINTS",
+ "GL_LINES",
+ "GL_LINE_LOOP",
+ "GL_LINE_STRIP",
+ "GL_TRIANGLES",
+ "GL_TRIANGLE_STRIP",
+ "GL_TRIANGLE_FAN",
+ "GL_QUADS",
+ "GL_QUAD_STRIP",
+ "GL_POLYGON",
+ "culled primitive"
+};
+
+
+GLenum gl_reduce_prim[GL_POLYGON+1] = {
+ GL_POINTS,
+ GL_LINES,
+ GL_LINES,
+ GL_LINES,
+ GL_TRIANGLES,
+ GL_TRIANGLES,
+ GL_TRIANGLES,
+ GL_TRIANGLES,
+ GL_TRIANGLES,
+ GL_TRIANGLES,
+};