context.c File Reference

#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "accum.h"
#include "alphabuf.h"
#include "clip.h"
#include "context.h"
#include "depth.h"
#include "eval.h"
#include "hash.h"
#include "light.h"
#include "lines.h"
#include "dlist.h"
#include "macros.h"
#include "mmath.h"
#include "pb.h"
#include "points.h"
#include "pointers.h"
#include "quads.h"
#include "stencil.h"
#include "triangle.h"
#include "teximage.h"
#include "texobj.h"
#include "texstate.h"
#include "types.h"
#include "vb.h"
#include "vbfill.h"
#include <wine/debug.h>

Include dependency graph for context.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (opengl32)
static struct gl_shared_state *	alloc_shared_state (void)
static void	free_shared_state (GLcontext *ctx, struct gl_shared_state *ss)
static void	init_light (struct gl_light *l, GLuint n)
static void	init_lightmodel (struct gl_lightmodel *lm)
static void	init_material (struct gl_material *m)
static void	initialize_context (GLcontext *ctx)
GLvisual *	gl_create_visual (GLboolean rgb_flag, GLboolean alpha_flag, GLboolean db_flag, GLint depth_bits, GLint stencil_bits, GLint accum_bits, GLint index_bits, GLfloat red_scale, GLfloat green_scale, GLfloat blue_scale, GLfloat alpha_scale, GLint red_bits, GLint green_bits, GLint blue_bits, GLint alpha_bits)
void	gl_destroy_visual (GLvisual *vis)
static GLboolean	alloc_proxy_textures (GLcontext *ctx)
GLcontext *	gl_create_context (GLvisual *visual, GLcontext *share_list, void *driver_ctx)
void	gl_destroy_context (GLcontext *ctx)
GLframebuffer *	gl_create_framebuffer (GLvisual *visual)
void	gl_destroy_framebuffer (GLframebuffer *buffer)
void	gl_make_current (GLcontext *ctx, GLframebuffer *buffer)
void	gl_copy_context (const GLcontext *src, GLcontext *dst, GLuint mask)
void	gl_set_api_table (GLcontext *ctx, const struct gl_api_table *api)
void	gl_problem (const GLcontext *ctx, const char *s)
void	gl_warning (const GLcontext *ctx, const char *s)
void	gl_error (GLcontext *ctx, GLenum error, const char *s)
GLenum	gl_GetError (GLcontext *ctx)
void	gl_ResizeBuffersMESA (GLcontext *ctx)
static void	update_pixel_logic (GLcontext *ctx)
static void	update_pixel_masking (GLcontext *ctx)
static void	update_rasterflags (GLcontext *ctx)
static void	update_clipmask (GLcontext *ctx)
void	gl_update_state (GLcontext *ctx)

Function Documentation

alloc_proxy_textures()

static GLboolean alloc_proxy_textures ( GLcontext *  ctx )

static

Definition at line 1041 of file context.c.

{
   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;
   }
 
   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();
      if (!ctx->Texture.Proxy1D->Image[i]
          || !ctx->Texture.Proxy2D->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]);
         }
      }
      gl_free_texture_object(NULL, ctx->Texture.Proxy1D);
      gl_free_texture_object(NULL, ctx->Texture.Proxy2D);
      return GL_FALSE;
   }
   else {
      return GL_TRUE;
   }
}

Referenced by gl_create_context().

alloc_shared_state()

static struct gl_shared_state * alloc_shared_state ( void  )

static

Definition at line 443 of file context.c.

{
   struct gl_shared_state *ss;
 
   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 */
   ss->Default1D = gl_alloc_texture_object(ss, 0, 1);
   ss->Default2D = gl_alloc_texture_object(ss, 0, 2);
 
   if (!ss->DisplayList || !ss->TexObjects
       || !ss->Default1D || !ss->Default2D) {
      /* Ran out of memory at some point.  Free everything and return NULL */
      if (!ss->DisplayList)
         DeleteHashTable(ss->DisplayList);
      if (!ss->TexObjects)
         DeleteHashTable(ss->TexObjects);
      if (!ss->Default1D)
         gl_free_texture_object(ss, ss->Default1D);
      if (!ss->Default2D)
         gl_free_texture_object(ss, ss->Default2D);
      free(ss);
      return NULL;
   }
   else {
      return ss;
   }
}

Referenced by gl_create_context().

free_shared_state()

static void free_shared_state ( GLcontext *  ctx, struct gl_shared_state *  ss  )

static

Definition at line 482 of file context.c.

{
   /* 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)
   {
      /* this function removes from linked list too! */
      gl_free_texture_object(ss, ss->TexObjectList);
   }
   DeleteHashTable(ss->TexObjects);
 
   free(ss);
}

Referenced by gl_create_context(), and gl_destroy_context().

gl_copy_context()

void gl_copy_context	(	const GLcontext *	src,
		GLcontext *	dst,
		GLuint	mask
	)

Definition at line 1293 of file context.c.

{
   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) );
   }
   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) );
   }
}

gl_create_context()

GLcontext * gl_create_context	(	GLvisual *	visual,
		GLcontext *	share_list,
		void *	driver_ctx
	)

Definition at line 1093 of file context.c.

{
   GLcontext *ctx;
 
   /* 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 */
   gl_init_math();
   gl_init_lists();
   gl_init_eval();
 
   ctx = (GLcontext *) calloc( 1, sizeof(GLcontext) );
   if (!ctx) {
      return NULL;
   }
 
   ctx->DriverCtx = driver_ctx;
   ctx->Visual = visual;
   ctx->Buffer = NULL;
 
   ctx->VB = gl_alloc_vb();
   if (!ctx->VB) {
      free( ctx );
      return NULL;
   }
 
   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 );
 
   if (visual->DBflag) {
      ctx->Color.DrawBuffer = GL_BACK;
      ctx->Pixel.ReadBuffer = GL_BACK;
   }
   else {
      ctx->Color.DrawBuffer = GL_FRONT;
      ctx->Pixel.ReadBuffer = GL_FRONT;
   }
 
#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;
}

Referenced by sw_CreateContext().

gl_create_framebuffer()

GLframebuffer * gl_create_framebuffer

(

GLvisual *

visual

)

Definition at line 1230 of file context.c.

{
   GLframebuffer *buffer;
 
   buffer = (GLframebuffer *) calloc( 1, sizeof(GLframebuffer) );
   if (!buffer) {
      return NULL;
   }
 
   buffer->Visual = visual;
 
   return buffer;
}

Referenced by sw_SetPixelFormat().

gl_create_visual()

GLvisual * gl_create_visual	(	GLboolean	rgb_flag,
		GLboolean	alpha_flag,
		GLboolean	db_flag,
		GLint	depth_bits,
		GLint	stencil_bits,
		GLint	accum_bits,
		GLint	index_bits,
		GLfloat	red_scale,
		GLfloat	green_scale,
		GLfloat	blue_scale,
		GLfloat	alpha_scale,
		GLint	red_bits,
		GLint	green_bits,
		GLint	blue_bits,
		GLint	alpha_bits
	)

Definition at line 936 of file context.c.

{
   GLvisual *vis;
 
   /* Can't do better than 8-bit/channel color at this time */
   assert( red_scale<=255.0 );
   assert( green_scale<=255.0 );
   assert( blue_scale<=255.0 );
   assert( alpha_scale<=255.0 );
 
   if (depth_bits > 8*sizeof(GLdepth)) {
      /* can't meet depth buffer requirements */
      return NULL;
   }
   if (stencil_bits > 8*sizeof(GLstencil)) {
      /* can't meet stencil buffer requirements */
      return NULL;
   }
   if (accum_bits > 8*sizeof(GLaccum)) {
      /* can't meet accum buffer requirements */
      return NULL;
   }
 
   vis = (GLvisual *) calloc( 1, sizeof(GLvisual) );
   if (!vis) {
      return NULL;
   }
 
   vis->RGBAflag      = rgb_flag;
   vis->DBflag        = db_flag;
   vis->RedScale      = red_scale;
   vis->GreenScale    = green_scale;
   vis->BlueScale     = blue_scale;
   vis->AlphaScale    = alpha_scale;
   if (red_scale) {
      vis->InvRedScale   = 1.0F / red_scale;
   }
   if (green_scale) {
      vis->InvGreenScale = 1.0F / green_scale;
   }
   if (blue_scale) {
      vis->InvBlueScale  = 1.0F / blue_scale;
   }
   if (alpha_scale) {
      vis->InvAlphaScale = 1.0F / alpha_scale;
   }
 
   vis->RedBits   = red_bits;
   vis->GreenBits = green_bits;
   vis->BlueBits  = blue_bits;
   vis->AlphaBits = alpha_flag ? 8*sizeof(GLubyte) : alpha_bits;
 
   vis->IndexBits   = index_bits;
   vis->DepthBits   = (depth_bits>0) ? 8*sizeof(GLdepth) : 0;
   vis->AccumBits   = (accum_bits>0) ? 8*sizeof(GLaccum) : 0;
   vis->StencilBits = (stencil_bits>0) ? 8*sizeof(GLstencil) : 0;
 
   if (red_scale==255.0F && green_scale==255.0F
       && blue_scale==255.0F && alpha_scale==255.0F) {
      vis->EightBitColor = GL_TRUE;
   }
   else {
      vis->EightBitColor = GL_FALSE;
   }
 
   /* software alpha buffers */
   if (alpha_flag) {
      vis->FrontAlphaEnabled = GL_TRUE;
      if (db_flag) {
         vis->BackAlphaEnabled = GL_TRUE;
      }
   }
 
   return vis;
}

Referenced by sw_SetPixelFormat().

gl_destroy_context()

void gl_destroy_context

(

GLcontext *

ctx

)

Definition at line 1186 of file context.c.

{
   if (ctx) {
 
#ifdef PROFILE
      if (getenv("MESA_PROFILE")) {
         print_timings( ctx );
      }
#endif
 
      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 );
      }
 
      /* Free proxy texture objects */
      gl_free_texture_object( NULL, ctx->Texture.Proxy1D );
      gl_free_texture_object( NULL, ctx->Texture.Proxy2D );
 
      free( (void *) ctx );
 
#ifndef THREADS
      if (ctx==CC) {
         CC = NULL;
      }
#endif
 
   }
}

Referenced by sw_DeleteContext().

gl_destroy_framebuffer()

void gl_destroy_framebuffer

(

GLframebuffer *

buffer

)

Definition at line 1249 of file context.c.

{
   if (buffer) {
      if (buffer->Depth) {
         free( buffer->Depth );
      }
      if (buffer->Accum) {
         free( buffer->Accum );
      }
      if (buffer->Stencil) {
         free( buffer->Stencil );
      }
      if (buffer->FrontAlpha) {
         free( buffer->FrontAlpha );
      }
      if (buffer->BackAlpha) {
         free( buffer->BackAlpha );
      }
      free(buffer);
   }
}

gl_destroy_visual()

void gl_destroy_visual

(

GLvisual *

vis

)

Definition at line 1029 of file context.c.

{
   free( vis );
}

Referenced by sw_SetPixelFormat().

gl_error()

void gl_error	(	GLcontext *	ctx,
		GLenum	error,
		const char *	s
	)

Definition at line 1421 of file context.c.

{
   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;
      }
      ERR("Mesa user error: %s in %s\n", wine_dbgstr_a(errstr), wine_dbgstr_a(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 );
   }
}

Referenced by alloc_instruction(), copy_depth_pixels(), copy_stencil_pixels(), draw_color_pixels(), draw_index_pixels(), draw_stencil_pixels(), drawpixels(), gl_Accum(), gl_alloc_accum_buffer(), gl_alloc_alpha_buffers(), gl_alloc_depth_buffer(), gl_alloc_stencil_buffer(), gl_AlphaFunc(), gl_AreTexturesResident(), gl_Begin(), gl_BindTexture(), gl_Bitmap(), gl_BlendFunc(), gl_Clear(), gl_ClearAccum(), gl_ClearColor(), gl_ClearDepth(), gl_ClearIndex(), gl_ClearStencil(), gl_client_state(), gl_ClipPlane(), gl_ColorMask(), gl_ColorMaterial(), gl_ColorPointer(), gl_ColorTable(), gl_CopyPixels(), gl_CopyTexImage1D(), gl_CopyTexImage2D(), gl_CopyTexSubImage1D(), gl_CopyTexSubImage2D(), gl_CullFace(), gl_DeleteLists(), gl_DeleteTextures(), gl_DepthFunc(), gl_DepthMask(), gl_DepthRange(), gl_DrawArrays(), gl_DrawBuffer(), gl_DrawElements(), gl_DrawPixels(), gl_EdgeFlagPointer(), gl_enable(), gl_End(), gl_EndList(), gl_EvalMesh1(), gl_EvalMesh2(), gl_FeedbackBuffer(), gl_Finish(), gl_Flush(), gl_Fogfv(), gl_free_control_points(), gl_FrontFace(), gl_Frustum(), gl_GenLists(), gl_GenTextures(), gl_GetBooleanv(), gl_GetClipPlane(), gl_GetColorTable(), gl_GetColorTableParameteriv(), gl_GetDoublev(), gl_GetError(), gl_GetFloatv(), gl_GetIntegerv(), gl_GetLightfv(), gl_GetLightiv(), gl_GetMapdv(), gl_GetMapfv(), gl_GetMapiv(), gl_GetMaterialfv(), gl_GetMaterialiv(), gl_GetPixelMapfv(), gl_GetPixelMapuiv(), gl_GetPixelMapusv(), gl_GetPointerv(), gl_GetString(), gl_GetTexEnvfv(), gl_GetTexEnviv(), gl_GetTexGendv(), gl_GetTexGenfv(), gl_GetTexGeniv(), gl_GetTexLevelParameteriv(), gl_GetTexParameterfv(), gl_GetTexParameteriv(), gl_Hint(), gl_IndexMask(), gl_IndexPointer(), gl_InitNames(), gl_InterleavedArrays(), gl_IsEnabled(), gl_IsTexture(), gl_Lightfv(), gl_LightModelfv(), gl_LineStipple(), gl_LineWidth(), gl_ListBase(), gl_LoadIdentity(), gl_LoadMatrixf(), gl_LoadName(), gl_LogicOp(), gl_logicop_ci_pixels(), gl_logicop_ci_span(), gl_Map1f(), gl_Map2f(), gl_MapGrid1f(), gl_MapGrid2f(), gl_Materialfv(), gl_MatrixMode(), gl_MultMatrixf(), gl_NewList(), gl_NormalPointer(), gl_PassThrough(), gl_PixelMapfv(), gl_PixelStorei(), gl_PixelTransferf(), gl_PixelZoom(), gl_PointSize(), gl_PolygonMode(), gl_PolygonOffset(), gl_PolygonStipple(), gl_PopAttrib(), gl_PopClientAttrib(), gl_PopMatrix(), gl_PopName(), gl_PrioritizeTextures(), gl_PushAttrib(), gl_PushClientAttrib(), gl_PushMatrix(), gl_PushName(), gl_ReadBuffer(), gl_ReadPixels(), gl_Rectf(), gl_RenderMode(), gl_save_DrawArrays(), gl_save_DrawElements(), gl_save_NewList(), gl_Scalef(), gl_Scissor(), gl_SelectBuffer(), gl_ShadeModel(), gl_StencilFunc(), gl_StencilMask(), gl_StencilOp(), gl_TexCoordPointer(), gl_TexEnvfv(), gl_TexGenfv(), gl_TexImage1D(), gl_TexImage2D(), gl_TexParameterfv(), gl_TexSubImage1D(), gl_TexSubImage2D(), gl_Translatef(), gl_unpack_pixels(), gl_vertex2f_nop(), gl_vertex3f_nop(), gl_vertex3fv_nop(), gl_vertex4f_nop(), gl_VertexPointer(), gl_Viewport(), read_color_pixels(), read_depth_pixels(), read_index_pixels(), read_stencil_pixels(), texture_1d_error_check(), and texture_2d_error_check().

gl_GetError()

GLenum gl_GetError

(

GLcontext *

ctx

)

Definition at line 1481 of file context.c.

{
   GLenum e;
 
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glGetError" );
      return GL_INVALID_OPERATION;
   }
 
   e = ctx->ErrorValue;
   ctx->ErrorValue = GL_NO_ERROR;
   return e;
}

Referenced by init_dlist_pointers(), and init_exec_pointers().

gl_make_current()

void gl_make_current	(	GLcontext *	ctx,
		GLframebuffer *	buffer
	)

Definition at line 1276 of file context.c.

{
   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 );
   }
}

Referenced by sw_ReleaseContext(), and sw_SetContext().

gl_problem()

void gl_problem	(	const GLcontext *	ctx,
		const char *	s
	)

Definition at line 1394 of file context.c.

{
   ERR("MESA ERROR : %s\n", wine_dbgstr_a(s));
}

Referenced by apply_stencil_op_to_pixels(), apply_stencil_op_to_span(), apply_texture(), check_pointers(), do_blend(), draw_color_pixels(), draw_depth_pixels(), execute_list(), get_1d_texel(), get_2d_texel(), gl_alpha_test(), gl_ArrayElement(), gl_BindTexture(), gl_ColorSubTable(), gl_depth_test_pixels_generic(), gl_depth_test_span_generic(), gl_fog_color_pixels(), gl_fog_color_vertices(), gl_fog_index_pixels(), gl_fog_index_vertices(), gl_GetColorTable(), gl_GetTexImage(), gl_LoadIdentity(), gl_LoadMatrixf(), gl_logicop_rgba_pixels(), gl_logicop_rgba_span(), gl_material_bitmask(), gl_MultMatrixf(), gl_PopAttrib(), gl_PopClientAttrib(), gl_PopMatrix(), gl_PushMatrix(), gl_render_vb(), gl_reset_vb(), gl_save_ArrayElement(), gl_Scalef(), gl_set_texture_sampler(), gl_stencil_pixels(), gl_stencil_span(), gl_test_texture_object_completeness(), gl_texgen(), gl_Translatef(), gl_unpack_image(), image_to_texture(), palette_sample(), project_and_cliptest(), sample_1d_nearest(), sample_2d_nearest(), sample_lambda_1d(), sample_lambda_2d(), transform_points3(), transform_points4(), and transform_texcoords().

gl_ResizeBuffersMESA()

void gl_ResizeBuffersMESA

(

GLcontext *

ctx

)

Definition at line 1497 of file context.c.

{
   GLint newsize;
   GLuint buf_width, buf_height;
   
   ctx->NewState |= NEW_ALL;   /* just to be safe */
 
   /* 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 */
   newsize = ctx->Buffer->Width!=buf_width || ctx->Buffer->Height!=buf_height;
 
   /* save buffer size */
   ctx->Buffer->Width = buf_width;
   ctx->Buffer->Height = buf_height;
 
   /* Reallocate other buffers if needed. */
   if (newsize && ctx->Visual->DepthBits>0) {
      /* reallocate depth buffer */
      (*ctx->Driver.AllocDepthBuffer)( ctx );
      /*** if scissoring enabled then clearing can cause a problem ***/
      /***(*ctx->Driver.ClearDepthBuffer)( ctx );***/
   }
   if (newsize && ctx->Visual->StencilBits>0) {
      /* reallocate stencil buffer */
      gl_alloc_stencil_buffer( ctx );
   }
   if (newsize && ctx->Visual->AccumBits>0) {
      /* reallocate accum buffer */
      gl_alloc_accum_buffer( ctx );
   }
   if (newsize
       && (ctx->Visual->FrontAlphaEnabled || ctx->Visual->BackAlphaEnabled)) {
      gl_alloc_alpha_buffers( ctx );
   }
}

Referenced by gl_Viewport(), sw_call_window_proc(), and sw_SetContext().

gl_set_api_table()

void gl_set_api_table	(	GLcontext *	ctx,
		const struct gl_api_table *	api
	)

Definition at line 1372 of file context.c.

{
   if (api) {
      MEMCPY( &ctx->API, api, sizeof(struct gl_api_table) );
   }
   else {
      MEMCPY( &ctx->API, &ctx->Exec, sizeof(struct gl_api_table) );
   }
}

gl_update_state()

void gl_update_state

(

GLcontext *

ctx

)

Definition at line 1749 of file context.c.

{
   if (ctx->NewState & NEW_RASTER_OPS) {
      update_pixel_logic(ctx);
      update_pixel_masking(ctx);
      update_rasterflags(ctx);
      if (ctx->Driver.Dither) {
         (*ctx->Driver.Dither)( ctx, ctx->Color.DitherFlag );
      }
   }
 
   if (ctx->NewState & (NEW_RASTER_OPS | NEW_LIGHTING)) {
      update_clipmask(ctx);
   }
 
   if (ctx->NewState & NEW_LIGHTING) {
      gl_update_lighting(ctx);
      gl_set_color_function(ctx);
   }
 
   if (ctx->NewState & NEW_TEXTURING) {
      gl_update_texture_state(ctx);
   }
 
   if (ctx->NewState & (NEW_LIGHTING | NEW_TEXTURING)) {
      /* Check if normal vectors are needed */
      GLboolean sphereGen = ctx->Texture.Enabled
         && ((ctx->Texture.GenModeS==GL_SPHERE_MAP
              && (ctx->Texture.TexGenEnabled & S_BIT))
             || (ctx->Texture.GenModeT==GL_SPHERE_MAP
                 && (ctx->Texture.TexGenEnabled & T_BIT)));
      if (ctx->Light.Enabled || sphereGen) {
         ctx->NeedNormals = GL_TRUE;
      }
      else {
         ctx->NeedNormals = GL_FALSE;
      }
   }
 
   if (ctx->NewState & NEW_RASTER_OPS) {
      /* 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;
      }
   }
 
   if (ctx->NewState & (NEW_RASTER_OPS | NEW_LIGHTING)) {
      /* Check if all pixels generated are likely to be the same color */
      if (ctx->Light.ShadeModel==GL_SMOOTH ||
          ctx->Light.Enabled ||
          ctx->Fog.Enabled ||
          ctx->Texture.Enabled ||
          ctx->Color.BlendEnabled ||
          ctx->Color.SWmasking ||
          ctx->Color.SWLogicOpEnabled) {
         ctx->MonoPixels = GL_FALSE;       /* pixels probably multicolored */
      }
      else {
         /* pixels will all be same color,
          * only glColor() can invalidate this.
          */
         ctx->MonoPixels = GL_TRUE;
      }
   }
 
   if (ctx->NewState & NEW_POLYGON) {
      /* Setup CullBits bitmask */
      ctx->Polygon.CullBits = 0;
      if (ctx->Polygon.CullFlag) {
         if (ctx->Polygon.CullFaceMode==GL_FRONT ||
             ctx->Polygon.CullFaceMode==GL_FRONT_AND_BACK) {
            ctx->Polygon.CullBits |= 1;
         }
         if (ctx->Polygon.CullFaceMode==GL_BACK ||
             ctx->Polygon.CullFaceMode==GL_FRONT_AND_BACK) {
            ctx->Polygon.CullBits |= 2;
         }
      }
      /* Any Polygon offsets enabled? */
      ctx->Polygon.OffsetAny = ctx->Polygon.OffsetPoint ||
                               ctx->Polygon.OffsetLine ||
                               ctx->Polygon.OffsetFill;
      /* reset Z offsets now */
      ctx->PointZoffset   = 0.0;
      ctx->LineZoffset    = 0.0;
      ctx->PolygonZoffset = 0.0;
   }
 
   if (ctx->NewState & (NEW_POLYGON | NEW_LIGHTING)) {
      /* Determine if we can directly call the triangle rasterizer */
      if (   ctx->Polygon.Unfilled
          || ctx->Polygon.OffsetAny
          || ctx->Polygon.CullFlag
          || ctx->Light.Model.TwoSide
          || ctx->RenderMode!=GL_RENDER) {
         ctx->DirectTriangles = GL_FALSE;
      }
      else {
         ctx->DirectTriangles = GL_TRUE;
      }
   }
 
   /* 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
    */
   if (ctx->NewState & NEW_RASTER_OPS) {
      ctx->Driver.AllocDepthBuffer = gl_alloc_depth_buffer;
      ctx->Driver.ClearDepthBuffer = gl_clear_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;
   }
 
   ctx->Driver.PointsFunc = NULL;
   ctx->Driver.LineFunc = NULL;
   ctx->Driver.TriangleFunc = NULL;
   ctx->Driver.QuadFunc = NULL;
   ctx->Driver.RectFunc = NULL;
 
   if (ctx->Driver.UpdateState) {
      (*ctx->Driver.UpdateState)(ctx);
   }
 
   gl_set_point_function(ctx);
   gl_set_line_function(ctx);
   gl_set_triangle_function(ctx);
   gl_set_quad_function(ctx);
 
   gl_set_vertex_function(ctx);
 
   ctx->NewState = 0;
}

Referenced by gl_Begin(), gl_Clear(), gl_CopyPixels(), gl_DrawPixels(), gl_make_current(), and gl_render_bitmap().

gl_warning()

void gl_warning	(	const GLcontext *	ctx,
		const char *	s
	)

Definition at line 1406 of file context.c.

{
   WARN("MESA WARNING: %s\n", wine_dbgstr_a(s));
}

Referenced by gl_Accum(), gl_enable(), and gl_RenderMode().

init_light()

static void init_light ( struct gl_light *  l, GLuint  n  )

static

Definition at line 514 of file context.c.

{
   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->Position, 0.0, 0.0, 1.0, 0.0 );
   ASSIGN_3V( l->Direction, 0.0, 0.0, -1.0 );
   l->SpotExponent = 0.0;
   gl_compute_spot_exp_table( l );
   l->SpotCutoff = 180.0;
   l->CosCutoff = -1.0;
   l->ConstantAttenuation = 1.0;
   l->LinearAttenuation = 0.0;
   l->QuadraticAttenuation = 0.0;
   l->Enabled = GL_FALSE;
}

Referenced by initialize_context().

init_lightmodel()

static void init_lightmodel ( struct gl_lightmodel *  lm )

static

Definition at line 539 of file context.c.

{
   ASSIGN_4V( lm->Ambient, 0.2f, 0.2f, 0.2f, 1.0f );
   lm->LocalViewer = GL_FALSE;
   lm->TwoSide = GL_FALSE;
}

Referenced by initialize_context().

init_material()

static void init_material ( struct gl_material *  m )

static

Definition at line 547 of file context.c.

{
   ASSIGN_4V( m->Ambient,  0.2f, 0.2f, 0.2f, 1.0f );
   ASSIGN_4V( m->Diffuse,  0.8f, 0.8f, 0.8f, 1.0f );
   ASSIGN_4V( m->Specular, 0.0f, 0.0f, 0.0f, 1.0f );
   ASSIGN_4V( m->Emission, 0.0f, 0.0f, 0.0f, 1.0f );
   m->Shininess = 0.0;
   m->AmbientIndex = 0;
   m->DiffuseIndex = 1;
   m->SpecularIndex = 1;
   gl_compute_material_shine_table( m );
}

Referenced by initialize_context().

initialize_context()

static void initialize_context ( GLcontext *  ctx )

static

Definition at line 565 of file context.c.

{
   static GLfloat identity[16] = {
    1.0, 0.0, 0.0, 0.0,
    0.0, 1.0, 0.0, 0.0,
    0.0, 0.0, 1.0, 0.0,
    0.0, 0.0, 0.0, 1.0
   };
   GLuint i;
 
   if (ctx) {
      /* Modelview matrix stuff */
      ctx->NewModelViewMatrix = GL_FALSE;
      ctx->ModelViewMatrixType = MATRIX_IDENTITY;
      MEMCPY( ctx->ModelViewMatrix, identity, 16*sizeof(GLfloat) );
      MEMCPY( ctx->ModelViewInv, identity, 16*sizeof(GLfloat) );
      ctx->ModelViewStackDepth = 0;
 
      /* Projection matrix stuff */
      ctx->NewProjectionMatrix = GL_FALSE;
      ctx->ProjectionMatrixType = MATRIX_IDENTITY;
      MEMCPY( ctx->ProjectionMatrix, identity, 16*sizeof(GLfloat) );
      ctx->ProjectionStackDepth = 0;
      ctx->NearFarStack[0][0] = 1.0; /* These values seem weird by make */
      ctx->NearFarStack[0][1] = 0.0; /* sense mathematically. */
 
      /* Texture matrix stuff */
      ctx->NewTextureMatrix = GL_FALSE;
      ctx->TextureMatrixType = MATRIX_IDENTITY;
      MEMCPY( ctx->TextureMatrix, identity, 16*sizeof(GLfloat) );
      ctx->TextureStackDepth = 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 = 0xf;
      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.0;
      ctx->Color.AlphaRefUbyte = 0;
      ctx->Color.BlendEnabled = GL_FALSE;
      ctx->Color.BlendSrc = GL_ONE;
      ctx->Color.BlendDst = GL_ZERO;
      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;
 
      /* Current group */
      ctx->Current.Index = 1;
      ASSIGN_3V( ctx->Current.Normal, 0.0, 0.0, 1.0 );
      ctx->Current.ByteColor[0] = (GLint) ctx->Visual->RedScale;
      ctx->Current.ByteColor[1] = (GLint) ctx->Visual->GreenScale;
      ctx->Current.ByteColor[2] = (GLint) ctx->Visual->BlueScale;
      ctx->Current.ByteColor[3] = (GLint) ctx->Visual->AlphaScale;
      ASSIGN_4V( ctx->Current.RasterPos, 0.0, 0.0, 0.0, 1.0 );
      ctx->Current.RasterPosValid = GL_TRUE;
      ctx->Current.RasterIndex = 1;
      ASSIGN_4V( ctx->Current.TexCoord, 0.0, 0.0, 0.0, 1.0 );
      ASSIGN_4V( ctx->Current.RasterColor, 1.0, 1.0, 1.0, 1.0 );
      ctx->Current.EdgeFlag = GL_TRUE;
 
      /* 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;
 
      /* 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;
 
      /* Lighting group */
      for (i=0;i<MAX_LIGHTS;i++) {
     init_light( &ctx->Light.Light[i], i );
      }
      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( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
 
      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.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.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;
 
      /* Polygon group */
      ctx->Polygon.CullFlag = GL_FALSE;
      ctx->Polygon.CullFaceMode = GL_BACK;
      ctx->Polygon.FrontFace = GL_CCW;
      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;
      ctx->Polygon.OffsetAny = 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.Enabled = 0;
      ctx->Texture.EnvMode = GL_MODULATE;
      ASSIGN_4V( ctx->Texture.EnvColor, 0.0, 0.0, 0.0, 0.0 );
      ctx->Texture.TexGenEnabled = 0;
      ctx->Texture.GenModeS = GL_EYE_LINEAR;
      ctx->Texture.GenModeT = GL_EYE_LINEAR;
      ctx->Texture.GenModeR = GL_EYE_LINEAR;
      ctx->Texture.GenModeQ = GL_EYE_LINEAR;
      ASSIGN_4V( ctx->Texture.ObjectPlaneS, 1.0, 0.0, 0.0, 0.0 );
      ASSIGN_4V( ctx->Texture.ObjectPlaneT, 0.0, 1.0, 0.0, 0.0 );
      ASSIGN_4V( ctx->Texture.ObjectPlaneR, 0.0, 0.0, 0.0, 0.0 );
      ASSIGN_4V( ctx->Texture.ObjectPlaneQ, 0.0, 0.0, 0.0, 0.0 );
      ASSIGN_4V( ctx->Texture.EyePlaneS, 1.0, 0.0, 0.0, 0.0 );
      ASSIGN_4V( ctx->Texture.EyePlaneT, 0.0, 1.0, 0.0, 0.0 );
      ASSIGN_4V( ctx->Texture.EyePlaneR, 0.0, 0.0, 0.0, 0.0 );
      ASSIGN_4V( ctx->Texture.EyePlaneQ, 0.0, 0.0, 0.0, 0.0 );
 
      ctx->Texture.Current1D = ctx->Shared->Default1D;
      ctx->Texture.Current2D = ctx->Shared->Default2D;
 
      ctx->Texture.AnyDirty = GL_FALSE;
 
      /* Transformation group */
      ctx->Transform.MatrixMode = GL_MODELVIEW;
      ctx->Transform.Normalize = GL_FALSE;
      for (i=0;i<MAX_CLIP_PLANES;i++) {
     ctx->Transform.ClipEnabled[i] = GL_FALSE;
         ASSIGN_4V( ctx->Transform.ClipEquation[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;
      ctx->Viewport.Sx = 0.0;  /* Sx, Tx, Sy, Ty are computed later */
      ctx->Viewport.Tx = 0.0;
      ctx->Viewport.Sy = 0.0;
      ctx->Viewport.Ty = 0.0;
      ctx->Viewport.Sz = 0.5 * DEPTH_SCALE;
      ctx->Viewport.Tz = 0.5 * DEPTH_SCALE;
 
      /* 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;
 
      /* Renderer and client attribute stacks */
      ctx->AttribStackDepth = 0;
      ctx->ClientAttribStackDepth = 0;
 
      /*** Miscellaneous ***/
      ctx->NewState = NEW_ALL;
      ctx->RenderMode = GL_RENDER;
      ctx->Primitive = GL_BITMAP;
 
      ctx->StippleCounter = 0;
      ctx->NeedNormals = GL_FALSE;
 
      if (   ctx->Visual->RedScale==255.0F
          && ctx->Visual->GreenScale==255.0F
          && ctx->Visual->BlueScale==255.0F
          && ctx->Visual->AlphaScale==255.0F) {
         ctx->Visual->EightBitColor = GL_TRUE;
      }
      else {
         ctx->Visual->EightBitColor = GL_FALSE;
      }
      ctx->FastDrawPixels = ctx->Visual->RGBAflag && ctx->Visual->EightBitColor;
 
#if JUNK
      ctx->PointsFunc = NULL;
      ctx->LineFunc = NULL;
      ctx->TriangleFunc = NULL;
#endif
 
      ctx->DirectContext = GL_TRUE;  /* XXXX temp */
 
      /* 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 = GL_NO_ERROR;
 
      /* 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) {
         TRACE("MESA_NO_DITHER set - dithering disabled\n");
         ctx->Color.DitherFlag = GL_FALSE;
      }
   }
}

Referenced by gl_create_context().

update_clipmask()

static void update_clipmask ( GLcontext *  ctx )

static

Definition at line 1699 of file context.c.

{
   /* Recompute ClipMask (what has to be interpolated when clipping) */
   ctx->ClipMask = 0;
   if (ctx->Texture.Enabled) {
      ctx->ClipMask |= CLIP_TEXTURE_BIT;
   }
   if (ctx->Light.ShadeModel==GL_SMOOTH) {
      if (ctx->Visual->RGBAflag) {
     ctx->ClipMask |= CLIP_FCOLOR_BIT;
     if (ctx->Light.Model.TwoSide) {
        ctx->ClipMask |= CLIP_BCOLOR_BIT;
     }
      }
      else {
     ctx->ClipMask |= CLIP_FINDEX_BIT;
     if (ctx->Light.Model.TwoSide) {
        ctx->ClipMask |= CLIP_BINDEX_BIT;
     }
      }
   }
 
   switch(ctx->ClipMask) {
      case CLIP_FCOLOR_BIT|CLIP_TEXTURE_BIT:
         if(ctx->VB->TexCoordSize==2)
            ctx->ClipInterpAuxFunc = interpolate_aux_color_tex2;
         else
            ctx->ClipInterpAuxFunc = interpolate_aux;
         break;
      case CLIP_TEXTURE_BIT:
         if(ctx->VB->TexCoordSize==2)
            ctx->ClipInterpAuxFunc = interpolate_aux_tex2;
         else
            ctx->ClipInterpAuxFunc = interpolate_aux;
         break;
      case CLIP_FCOLOR_BIT:
         ctx->ClipInterpAuxFunc = interpolate_aux_color;
         break;
      default:
         ctx->ClipInterpAuxFunc = interpolate_aux;
   }
}

Referenced by gl_update_state().

update_pixel_logic()

static void update_pixel_logic ( GLcontext *  ctx )

static

Definition at line 1548 of file context.c.

{
   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;
      }
   }
}

Referenced by gl_update_state().

update_pixel_masking()

static void update_pixel_masking ( GLcontext *  ctx )

static

Definition at line 1599 of file context.c.

{
   if (ctx->Visual->RGBAflag) {
      if (ctx->Color.ColorMask==0xf) {
         /* 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 & 8) ? GL_TRUE : GL_FALSE;
         GLboolean green = (ctx->Color.ColorMask & 4) ? GL_TRUE : GL_FALSE;
         GLboolean blue  = (ctx->Color.ColorMask & 2) ? GL_TRUE : GL_FALSE;
         GLboolean alpha = (ctx->Color.ColorMask & 1) ? 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;
         }
      }
   }
}

Referenced by gl_update_state().

update_rasterflags()

static void update_rasterflags ( GLcontext *  ctx )

static

Definition at line 1655 of file context.c.

{
   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->Fog.Enabled)        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->FrontAlphaEnabled)  ctx->RasterMask |= ALPHABUF_BIT;
   if (ctx->Visual->BackAlphaEnabled)   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;
   }
 
   /* check if drawing to front and back buffers */
   if (ctx->Color.DrawBuffer==GL_FRONT_AND_BACK) {
      ctx->RasterMask |= FRONT_AND_BACK_BIT;
   }
 
   /* check if writing to color buffer(s) is disabled */
   if (ctx->Color.DrawBuffer==GL_NONE) {
      ctx->RasterMask |= NO_DRAW_BIT;
   }
   else if (ctx->Visual->RGBAflag && ctx->Color.ColorMask==0) {
      ctx->RasterMask |= NO_DRAW_BIT;
   }
   else if (!ctx->Visual->RGBAflag && ctx->Color.IndexMask==0) {
      ctx->RasterMask |= NO_DRAW_BIT;
   }
}

Referenced by gl_update_state().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

opengl32

)