X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Fattrib.c;h=c34b80a60d0dfe0cb08ab6eea599a6316debb4ee;hb=a7c52c61e5bb5dc1f1781453b757bdb9904f6a1e;hp=00394a7970d1681458707e95f1aa47e2696c5406;hpb=08836341788a9f9d638d9dc8328510ccd18ddeb5;p=mesa.git diff --git a/src/mesa/main/attrib.c b/src/mesa/main/attrib.c index 00394a7970d..c34b80a60d0 100644 --- a/src/mesa/main/attrib.c +++ b/src/mesa/main/attrib.c @@ -1,10 +1,10 @@ -/* $Id: attrib.c,v 1.45 2001/03/03 20:33:27 brianp Exp $ */ +/* $Id: attrib.c,v 1.76 2003/01/22 17:58:52 brianp Exp $ */ /* * Mesa 3-D graphics library - * Version: 3.5 + * Version: 5.1 * - * Copyright (C) 1999-2001 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2003 Brian Paul All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), @@ -24,18 +24,14 @@ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ - -#ifdef PC_HEADER -#include "all.h" -#else #include "glheader.h" +#include "imports.h" #include "accum.h" -#include "alpha.h" #include "attrib.h" #include "blend.h" #include "buffers.h" -#include "clip.h" #include "colormac.h" +#include "colortab.h" #include "context.h" #include "depth.h" #include "enable.h" @@ -44,20 +40,15 @@ #include "hint.h" #include "light.h" #include "lines.h" -#include "logic.h" -#include "masking.h" #include "matrix.h" -#include "mem.h" #include "points.h" #include "polygon.h" -#include "scissor.h" #include "simple_list.h" #include "stencil.h" +#include "texobj.h" #include "texstate.h" #include "mtypes.h" -#endif - - +#include "math/m_xform.h" /* @@ -75,43 +66,6 @@ new_attrib_node( GLbitfield kind ) } - -/* - * Copy texture object state from one texture object to another. - */ -static void -copy_texobj_state( struct gl_texture_object *dest, - const struct gl_texture_object *src ) -{ - /* - dest->Name = src->Name; - dest->Dimensions = src->Dimensions; - */ - dest->Priority = src->Priority; - dest->BorderColor[0] = src->BorderColor[0]; - dest->BorderColor[1] = src->BorderColor[1]; - dest->BorderColor[2] = src->BorderColor[2]; - dest->BorderColor[3] = src->BorderColor[3]; - dest->WrapS = src->WrapS; - dest->WrapT = src->WrapT; - dest->WrapR = src->WrapR; - dest->MinFilter = src->MinFilter; - dest->MagFilter = src->MagFilter; - dest->MinLod = src->MinLod; - dest->MaxLod = src->MaxLod; - dest->BaseLevel = src->BaseLevel; - dest->MaxLevel = src->MaxLevel; - dest->CompareFlag = src->CompareFlag; - dest->CompareOperator = src->CompareOperator; - dest->ShadowAmbient = src->ShadowAmbient; - dest->_MaxLevel = src->_MaxLevel; - dest->_MaxLambda = src->_MaxLambda; - dest->Palette = src->Palette; - dest->Complete = src->Complete; -} - - - void _mesa_PushAttrib(GLbitfield mask) { @@ -121,8 +75,8 @@ _mesa_PushAttrib(GLbitfield mask) GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); - if (MESA_VERBOSE&VERBOSE_API) - fprintf(stderr, "glPushAttrib %x\n", (int)mask); + if (MESA_VERBOSE & VERBOSE_API) + _mesa_debug(ctx, "glPushAttrib %x\n", (int) mask); if (ctx->AttribStackDepth >= MAX_ATTRIB_STACK_DEPTH) { _mesa_error( ctx, GL_STACK_OVERFLOW, "glPushAttrib" ); @@ -182,10 +136,11 @@ _mesa_PushAttrib(GLbitfield mask) attr->AlphaTest = ctx->Color.AlphaEnabled; attr->AutoNormal = ctx->Eval.AutoNormal; attr->Blend = ctx->Color.BlendEnabled; - for (i=0;iClipPlane[i] = ctx->Transform.ClipEnabled[i]; - } + attr->ClipPlanes = ctx->Transform.ClipPlanesEnabled; attr->ColorMaterial = ctx->Light.ColorMaterialEnabled; + attr->ColorTable = ctx->Pixel.ColorTableEnabled; + attr->PostColorMatrixColorTable = ctx->Pixel.PostColorMatrixColorTableEnabled; + attr->PostConvolutionColorTable = ctx->Pixel.PostConvolutionColorTableEnabled; attr->Convolution1D = ctx->Pixel.Convolution1DEnabled; attr->Convolution2D = ctx->Pixel.Convolution2DEnabled; attr->Separable2D = ctx->Pixel.Separable2DEnabled; @@ -212,6 +167,7 @@ _mesa_PushAttrib(GLbitfield mask) attr->Map1TextureCoord4 = ctx->Eval.Map1TextureCoord4; attr->Map1Vertex3 = ctx->Eval.Map1Vertex3; attr->Map1Vertex4 = ctx->Eval.Map1Vertex4; + MEMCPY(attr->Map1Attrib, ctx->Eval.Map1Attrib, sizeof(ctx->Eval.Map1Attrib)); attr->Map2Color4 = ctx->Eval.Map2Color4; attr->Map2Index = ctx->Eval.Map2Index; attr->Map2Normal = ctx->Eval.Map2Normal; @@ -221,9 +177,12 @@ _mesa_PushAttrib(GLbitfield mask) attr->Map2TextureCoord4 = ctx->Eval.Map2TextureCoord4; attr->Map2Vertex3 = ctx->Eval.Map2Vertex3; attr->Map2Vertex4 = ctx->Eval.Map2Vertex4; + MEMCPY(attr->Map2Attrib, ctx->Eval.Map2Attrib, sizeof(ctx->Eval.Map2Attrib)); attr->Normalize = ctx->Transform.Normalize; + attr->RasterPositionUnclipped = ctx->Transform.RasterPositionUnclipped; attr->PixelTexture = ctx->Pixel.PixelTextureEnabled; attr->PointSmooth = ctx->Point.SmoothFlag; + attr->PointSprite = ctx->Point.PointSprite; attr->PolygonOffsetPoint = ctx->Polygon.OffsetPoint; attr->PolygonOffsetLine = ctx->Polygon.OffsetLine; attr->PolygonOffsetFill = ctx->Polygon.OffsetFill; @@ -232,10 +191,20 @@ _mesa_PushAttrib(GLbitfield mask) attr->RescaleNormals = ctx->Transform.RescaleNormals; attr->Scissor = ctx->Scissor.Enabled; attr->Stencil = ctx->Stencil.Enabled; + attr->MultisampleEnabled = ctx->Multisample.Enabled; + attr->SampleAlphaToCoverage = ctx->Multisample.SampleAlphaToCoverage; + attr->SampleAlphaToOne = ctx->Multisample.SampleAlphaToOne; + attr->SampleCoverage = ctx->Multisample.SampleCoverage; + attr->SampleCoverageInvert = ctx->Multisample.SampleCoverageInvert; for (i=0; iTexture[i] = ctx->Texture.Unit[i].Enabled; attr->TexGen[i] = ctx->Texture.Unit[i].TexGenEnabled; } + attr->TextureColorTable = ctx->Texture.ColorTableEnabled; + /* GL_NV_vertex_program */ + attr->VertexProgram = ctx->VertexProgram.Enabled; + attr->VertexProgramPointSize = ctx->VertexProgram.PointSizeEnabled; + attr->VertexProgramTwoSide = ctx->VertexProgram.TwoSideEnabled; newnode = new_attrib_node( GL_ENABLE_BIT ); newnode->data = attr; newnode->next = head; @@ -366,21 +335,30 @@ _mesa_PushAttrib(GLbitfield mask) if (mask & GL_TEXTURE_BIT) { struct gl_texture_attrib *attr; GLuint u; - /* Take care of texture object reference counters */ + /* Bump the texture object reference counts so that they don't + * inadvertantly get deleted. + */ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { ctx->Texture.Unit[u].Current1D->RefCount++; ctx->Texture.Unit[u].Current2D->RefCount++; ctx->Texture.Unit[u].Current3D->RefCount++; ctx->Texture.Unit[u].CurrentCubeMap->RefCount++; + ctx->Texture.Unit[u].CurrentRect->RefCount++; } attr = MALLOC_STRUCT( gl_texture_attrib ); MEMCPY( attr, &ctx->Texture, sizeof(struct gl_texture_attrib) ); /* copy state of the currently bound texture objects */ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - copy_texobj_state(&attr->Unit[u].Saved1D, attr->Unit[u].Current1D); - copy_texobj_state(&attr->Unit[u].Saved2D, attr->Unit[u].Current2D); - copy_texobj_state(&attr->Unit[u].Saved3D, attr->Unit[u].Current3D); - copy_texobj_state(&attr->Unit[u].SavedCubeMap, attr->Unit[u].CurrentCubeMap); + _mesa_copy_texture_object(&attr->Unit[u].Saved1D, + attr->Unit[u].Current1D); + _mesa_copy_texture_object(&attr->Unit[u].Saved2D, + attr->Unit[u].Current2D); + _mesa_copy_texture_object(&attr->Unit[u].Saved3D, + attr->Unit[u].Current3D); + _mesa_copy_texture_object(&attr->Unit[u].SavedCubeMap, + attr->Unit[u].CurrentCubeMap); + _mesa_copy_texture_object(&attr->Unit[u].SavedRect, + attr->Unit[u].CurrentRect); } newnode = new_attrib_node( GL_TEXTURE_BIT ); newnode->data = attr; @@ -408,6 +386,17 @@ _mesa_PushAttrib(GLbitfield mask) head = newnode; } + /* GL_ARB_multisample */ + if (mask & GL_MULTISAMPLE_BIT_ARB) { + struct gl_multisample_attrib *attr; + attr = MALLOC_STRUCT( gl_multisample_attrib ); + MEMCPY( attr, &ctx->Multisample, sizeof(struct gl_multisample_attrib) ); + newnode = new_attrib_node( GL_MULTISAMPLE_BIT_ARB ); + newnode->data = attr; + newnode->next = head; + head = newnode; + } + ctx->AttribStack[ctx->AttribStackDepth] = head; ctx->AttribStackDepth++; } @@ -425,17 +414,25 @@ pop_enable_group(GLcontext *ctx, const struct gl_enable_attrib *enable) } TEST_AND_UPDATE(ctx->Color.AlphaEnabled, enable->AlphaTest, GL_ALPHA_TEST); - TEST_AND_UPDATE(ctx->Transform.Normalize, enable->AutoNormal, GL_NORMALIZE); TEST_AND_UPDATE(ctx->Color.BlendEnabled, enable->Blend, GL_BLEND); for (i=0;iTransform.ClipEnabled[i] != enable->ClipPlane[i]) - _mesa_set_enable(ctx, (GLenum) (GL_CLIP_PLANE0 + i), - enable->ClipPlane[i]); + const GLuint mask = 1 << i; + if ((ctx->Transform.ClipPlanesEnabled & mask) != (enable->ClipPlanes & mask)) + _mesa_set_enable(ctx, (GLenum) (GL_CLIP_PLANE0 + i), + (GLboolean) ((enable->ClipPlanes & mask) ? GL_TRUE : GL_FALSE)); } TEST_AND_UPDATE(ctx->Light.ColorMaterialEnabled, enable->ColorMaterial, GL_COLOR_MATERIAL); + TEST_AND_UPDATE(ctx->Pixel.ColorTableEnabled, enable->ColorTable, + GL_COLOR_TABLE); + TEST_AND_UPDATE(ctx->Pixel.PostColorMatrixColorTableEnabled, + enable->PostColorMatrixColorTable, + GL_POST_COLOR_MATRIX_COLOR_TABLE); + TEST_AND_UPDATE(ctx->Pixel.PostConvolutionColorTableEnabled, + enable->PostConvolutionColorTable, + GL_POST_CONVOLUTION_COLOR_TABLE); TEST_AND_UPDATE(ctx->Polygon.CullFlag, enable->CullFace, GL_CULL_FACE); TEST_AND_UPDATE(ctx->Depth.Test, enable->DepthTest, GL_DEPTH_TEST); TEST_AND_UPDATE(ctx->Color.DitherFlag, enable->Dither, GL_DITHER); @@ -454,6 +451,7 @@ pop_enable_group(GLcontext *ctx, const struct gl_enable_attrib *enable) GL_INDEX_LOGIC_OP); TEST_AND_UPDATE(ctx->Color.ColorLogicOpEnabled, enable->ColorLogicOp, GL_COLOR_LOGIC_OP); + TEST_AND_UPDATE(ctx->Eval.Map1Color4, enable->Map1Color4, GL_MAP1_COLOR_4); TEST_AND_UPDATE(ctx->Eval.Map1Index, enable->Map1Index, GL_MAP1_INDEX); TEST_AND_UPDATE(ctx->Eval.Map1Normal, enable->Map1Normal, GL_MAP1_NORMAL); @@ -469,6 +467,11 @@ pop_enable_group(GLcontext *ctx, const struct gl_enable_attrib *enable) GL_MAP1_VERTEX_3); TEST_AND_UPDATE(ctx->Eval.Map1Vertex4, enable->Map1Vertex4, GL_MAP1_VERTEX_4); + for (i = 0; i < 16; i++) { + TEST_AND_UPDATE(ctx->Eval.Map1Attrib[i], enable->Map1Attrib[i], + GL_MAP1_VERTEX_ATTRIB0_4_NV + i); + } + TEST_AND_UPDATE(ctx->Eval.Map2Color4, enable->Map2Color4, GL_MAP2_COLOR_4); TEST_AND_UPDATE(ctx->Eval.Map2Index, enable->Map2Index, GL_MAP2_INDEX); TEST_AND_UPDATE(ctx->Eval.Map2Normal, enable->Map2Normal, GL_MAP2_NORMAL); @@ -484,13 +487,26 @@ pop_enable_group(GLcontext *ctx, const struct gl_enable_attrib *enable) GL_MAP2_VERTEX_3); TEST_AND_UPDATE(ctx->Eval.Map2Vertex4, enable->Map2Vertex4, GL_MAP2_VERTEX_4); + for (i = 0; i < 16; i++) { + TEST_AND_UPDATE(ctx->Eval.Map2Attrib[i], enable->Map2Attrib[i], + GL_MAP2_VERTEX_ATTRIB0_4_NV + i); + } + + TEST_AND_UPDATE(ctx->Eval.AutoNormal, enable->AutoNormal, GL_AUTO_NORMAL); TEST_AND_UPDATE(ctx->Transform.Normalize, enable->Normalize, GL_NORMALIZE); TEST_AND_UPDATE(ctx->Transform.RescaleNormals, enable->RescaleNormals, GL_RESCALE_NORMAL_EXT); + TEST_AND_UPDATE(ctx->Transform.RasterPositionUnclipped, + enable->RasterPositionUnclipped, + GL_RASTER_POSITION_UNCLIPPED_IBM); TEST_AND_UPDATE(ctx->Pixel.PixelTextureEnabled, enable->PixelTexture, GL_POINT_SMOOTH); TEST_AND_UPDATE(ctx->Point.SmoothFlag, enable->PointSmooth, GL_POINT_SMOOTH); + if (ctx->Extensions.NV_point_sprite) { + TEST_AND_UPDATE(ctx->Point.PointSprite, enable->PointSprite, + GL_POINT_SPRITE_NV); + } TEST_AND_UPDATE(ctx->Polygon.OffsetPoint, enable->PolygonOffsetPoint, GL_POLYGON_OFFSET_POINT); TEST_AND_UPDATE(ctx->Polygon.OffsetLine, enable->PolygonOffsetLine, @@ -503,6 +519,34 @@ pop_enable_group(GLcontext *ctx, const struct gl_enable_attrib *enable) GL_POLYGON_STIPPLE); TEST_AND_UPDATE(ctx->Scissor.Enabled, enable->Scissor, GL_SCISSOR_TEST); TEST_AND_UPDATE(ctx->Stencil.Enabled, enable->Stencil, GL_STENCIL_TEST); + /* XXX two-sided stencil */ + TEST_AND_UPDATE(ctx->Multisample.Enabled, enable->MultisampleEnabled, + GL_MULTISAMPLE_ARB); + TEST_AND_UPDATE(ctx->Multisample.SampleAlphaToCoverage, + enable->SampleAlphaToCoverage, + GL_SAMPLE_ALPHA_TO_COVERAGE_ARB); + TEST_AND_UPDATE(ctx->Multisample.SampleAlphaToOne, + enable->SampleAlphaToOne, + GL_SAMPLE_ALPHA_TO_ONE_ARB); + TEST_AND_UPDATE(ctx->Multisample.SampleCoverage, + enable->SampleCoverage, + GL_SAMPLE_COVERAGE_ARB); + TEST_AND_UPDATE(ctx->Multisample.SampleCoverageInvert, + enable->SampleCoverageInvert, + GL_SAMPLE_COVERAGE_INVERT_ARB); + TEST_AND_UPDATE(ctx->Texture.ColorTableEnabled, enable->TextureColorTable, + GL_TEXTURE_COLOR_TABLE_SGI); + /* GL_NV_vertex_program */ + TEST_AND_UPDATE(ctx->VertexProgram.Enabled, + enable->VertexProgram, + GL_VERTEX_PROGRAM_NV); + TEST_AND_UPDATE(ctx->VertexProgram.PointSizeEnabled, + enable->VertexProgramPointSize, + GL_VERTEX_PROGRAM_POINT_SIZE_NV); + TEST_AND_UPDATE(ctx->VertexProgram.TwoSideEnabled, + enable->VertexProgramTwoSide, + GL_VERTEX_PROGRAM_TWO_SIDE_NV); + #undef TEST_AND_UPDATE /* texture unit enables */ @@ -514,11 +558,17 @@ pop_enable_group(GLcontext *ctx, const struct gl_enable_attrib *enable) (*ctx->Driver.ActiveTexture)(ctx, i); } (*ctx->Driver.Enable)( ctx, GL_TEXTURE_1D, - (GLboolean) (enable->Texture[i] & TEXTURE0_1D) ); + (GLboolean) (enable->Texture[i] & TEXTURE_1D_BIT) ); (*ctx->Driver.Enable)( ctx, GL_TEXTURE_2D, - (GLboolean) (enable->Texture[i] & TEXTURE0_2D) ); + (GLboolean) (enable->Texture[i] & TEXTURE_2D_BIT) ); (*ctx->Driver.Enable)( ctx, GL_TEXTURE_3D, - (GLboolean) (enable->Texture[i] & TEXTURE0_3D) ); + (GLboolean) (enable->Texture[i] & TEXTURE_3D_BIT) ); + if (ctx->Extensions.ARB_texture_cube_map) + (*ctx->Driver.Enable)( ctx, GL_TEXTURE_CUBE_MAP_ARB, + (GLboolean) (enable->Texture[i] & TEXTURE_CUBE_BIT) ); + if (ctx->Extensions.NV_texture_rectangle) + (*ctx->Driver.Enable)( ctx, GL_TEXTURE_RECTANGLE_NV, + (GLboolean) (enable->Texture[i] & TEXTURE_RECT_BIT) ); } } @@ -554,6 +604,180 @@ pop_enable_group(GLcontext *ctx, const struct gl_enable_attrib *enable) } +static void +pop_texture_group(GLcontext *ctx, const struct gl_texture_attrib *texAttrib) +{ + GLuint u; + + for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { + const struct gl_texture_unit *unit = &texAttrib->Unit[u]; + GLuint i; + + _mesa_ActiveTextureARB(GL_TEXTURE0_ARB + u); + _mesa_set_enable(ctx, GL_TEXTURE_1D, + (GLboolean) (unit->Enabled & TEXTURE_1D_BIT ? GL_TRUE : GL_FALSE)); + _mesa_set_enable(ctx, GL_TEXTURE_2D, + (GLboolean) (unit->Enabled & TEXTURE_2D_BIT ? GL_TRUE : GL_FALSE)); + _mesa_set_enable(ctx, GL_TEXTURE_3D, + (GLboolean) (unit->Enabled & TEXTURE_3D_BIT ? GL_TRUE : GL_FALSE)); + if (ctx->Extensions.ARB_texture_cube_map) { + _mesa_set_enable(ctx, GL_TEXTURE_CUBE_MAP_ARB, + (GLboolean) (unit->Enabled & TEXTURE_CUBE_BIT ? GL_TRUE : GL_FALSE)); + } + if (ctx->Extensions.NV_texture_rectangle) { + _mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE_NV, + (GLboolean) (unit->Enabled & TEXTURE_RECT_BIT ? GL_TRUE : GL_FALSE)); + } + if (ctx->Extensions.SGI_texture_color_table) { + _mesa_set_enable(ctx, GL_TEXTURE_COLOR_TABLE_SGI, + texAttrib->ColorTableEnabled); + _mesa_ColorTableParameterfv(GL_TEXTURE_COLOR_TABLE_SGI, + GL_COLOR_TABLE_SCALE_SGI, + texAttrib->ColorTableScale); + _mesa_ColorTableParameterfv(GL_TEXTURE_COLOR_TABLE_SGI, + GL_COLOR_TABLE_BIAS_SGI, + texAttrib->ColorTableBias); + } + _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->EnvMode); + _mesa_TexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, unit->EnvColor); + _mesa_TexGeni(GL_S, GL_TEXTURE_GEN_MODE, unit->GenModeS); + _mesa_TexGeni(GL_T, GL_TEXTURE_GEN_MODE, unit->GenModeT); + _mesa_TexGeni(GL_R, GL_TEXTURE_GEN_MODE, unit->GenModeR); + _mesa_TexGeni(GL_Q, GL_TEXTURE_GEN_MODE, unit->GenModeQ); + _mesa_TexGenfv(GL_S, GL_OBJECT_PLANE, unit->ObjectPlaneS); + _mesa_TexGenfv(GL_T, GL_OBJECT_PLANE, unit->ObjectPlaneT); + _mesa_TexGenfv(GL_R, GL_OBJECT_PLANE, unit->ObjectPlaneR); + _mesa_TexGenfv(GL_Q, GL_OBJECT_PLANE, unit->ObjectPlaneQ); + _mesa_TexGenfv(GL_S, GL_EYE_PLANE, unit->EyePlaneS); + _mesa_TexGenfv(GL_T, GL_EYE_PLANE, unit->EyePlaneT); + _mesa_TexGenfv(GL_R, GL_EYE_PLANE, unit->EyePlaneR); + _mesa_TexGenfv(GL_Q, GL_EYE_PLANE, unit->EyePlaneQ); + if (ctx->Extensions.EXT_texture_lod_bias) { + _mesa_TexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT, + GL_TEXTURE_LOD_BIAS_EXT, unit->LodBias); + } + if (ctx->Extensions.EXT_texture_env_combine || + ctx->Extensions.ARB_texture_env_combine) { + _mesa_TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, + unit->CombineModeRGB); + _mesa_TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, + unit->CombineModeA); + _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, + unit->CombineSourceRGB[0]); + _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, + unit->CombineSourceRGB[1]); + _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT, + unit->CombineSourceRGB[2]); + _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, + unit->CombineSourceA[0]); + _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, + unit->CombineSourceA[1]); + _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_EXT, + unit->CombineSourceA[2]); + _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, + unit->CombineOperandRGB[0]); + _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, + unit->CombineOperandRGB[1]); + _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, + unit->CombineOperandRGB[2]); + _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT, + unit->CombineOperandA[0]); + _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT, + unit->CombineOperandA[1]); + _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_EXT, + unit->CombineOperandA[2]); + _mesa_TexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, + 1 << unit->CombineScaleShiftRGB); + _mesa_TexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE, + 1 << unit->CombineScaleShiftA); + } + + /* Restore texture object state */ + for (i = 0; i < NUM_TEXTURE_TARGETS; i++) { + GLenum target = 0; + const struct gl_texture_object *obj = NULL; + GLfloat bordColor[4]; + + switch (i) { + case 0: + target = GL_TEXTURE_1D; + obj = &unit->Saved1D; + break; + case 1: + target = GL_TEXTURE_2D; + obj = &unit->Saved2D; + break; + case 2: + target = GL_TEXTURE_3D; + obj = &unit->Saved3D; + break; + case 3: + if (!ctx->Extensions.ARB_texture_cube_map) + continue; + target = GL_TEXTURE_CUBE_MAP_ARB; + obj = &unit->SavedCubeMap; + break; + case 4: + if (!ctx->Extensions.NV_texture_rectangle) + continue; + target = GL_TEXTURE_RECTANGLE_NV; + obj = &unit->SavedRect; + break; + default: + ; /* silence warnings */ + } + + _mesa_BindTexture(target, obj->Name); + + bordColor[0] = CHAN_TO_FLOAT(obj->BorderColor[0]); + bordColor[1] = CHAN_TO_FLOAT(obj->BorderColor[1]); + bordColor[2] = CHAN_TO_FLOAT(obj->BorderColor[2]); + bordColor[3] = CHAN_TO_FLOAT(obj->BorderColor[3]); + + _mesa_TexParameterf(target, GL_TEXTURE_PRIORITY, obj->Priority); + _mesa_TexParameterfv(target, GL_TEXTURE_BORDER_COLOR, bordColor); + _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, obj->WrapS); + _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, obj->WrapT); + _mesa_TexParameteri(target, GL_TEXTURE_WRAP_R, obj->WrapR); + _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, obj->MinFilter); + _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, obj->MagFilter); + _mesa_TexParameterf(target, GL_TEXTURE_MIN_LOD, obj->MinLod); + _mesa_TexParameterf(target, GL_TEXTURE_MAX_LOD, obj->MaxLod); + _mesa_TexParameteri(target, GL_TEXTURE_BASE_LEVEL, obj->BaseLevel); + _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, obj->MaxLevel); + if (ctx->Extensions.EXT_texture_filter_anisotropic) { + _mesa_TexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, + obj->MaxAnisotropy); + } + if (ctx->Extensions.SGIX_shadow) { + _mesa_TexParameteri(target, GL_TEXTURE_COMPARE_SGIX, + obj->CompareFlag); + _mesa_TexParameteri(target, GL_TEXTURE_COMPARE_OPERATOR_SGIX, + obj->CompareOperator); + } + if (ctx->Extensions.SGIX_shadow_ambient) { + _mesa_TexParameterf(target, GL_SHADOW_AMBIENT_SGIX, + obj->ShadowAmbient); + } + + } + } + _mesa_ActiveTextureARB(GL_TEXTURE0_ARB + + texAttrib->CurrentUnit); + + /* "un-bump" the texture object reference counts. We did that so they + * wouldn't inadvertantly get deleted while they were still referenced + * inside the attribute state stack. + */ + for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { + ctx->Texture.Unit[u].Current1D->RefCount--; + ctx->Texture.Unit[u].Current2D->RefCount--; + ctx->Texture.Unit[u].Current3D->RefCount--; + ctx->Texture.Unit[u].CurrentCubeMap->RefCount--; + ctx->Texture.Unit[u].CurrentRect->RefCount--; + } +} + /* * This function is kind of long just because we have to call a lot @@ -582,8 +806,10 @@ _mesa_PopAttrib(void) while (attr) { - if (MESA_VERBOSE&VERBOSE_API) - fprintf(stderr, "glPopAttrib %s\n", _mesa_lookup_enum_by_nr(attr->kind)); + if (MESA_VERBOSE & VERBOSE_API) { + _mesa_debug(ctx, "glPopAttrib %s\n", + _mesa_lookup_enum_by_nr(attr->kind)); + } switch (attr->kind) { case GL_ACCUM_BUFFER_BIT: @@ -600,11 +826,11 @@ _mesa_PopAttrib(void) { const struct gl_colorbuffer_attrib *color; color = (const struct gl_colorbuffer_attrib *) attr->data; - _mesa_ClearIndex(color->ClearIndex); - _mesa_ClearColor(CHAN_TO_FLOAT(color->ClearColor[0]), - CHAN_TO_FLOAT(color->ClearColor[1]), - CHAN_TO_FLOAT(color->ClearColor[2]), - CHAN_TO_FLOAT(color->ClearColor[3])); + _mesa_ClearIndex((GLfloat) color->ClearIndex); + _mesa_ClearColor(color->ClearColor[0], + color->ClearColor[1], + color->ClearColor[2], + color->ClearColor[3]); _mesa_IndexMask(color->IndexMask); _mesa_ColorMask((GLboolean) (color->ColorMask[0] != 0), (GLboolean) (color->ColorMask[1] != 0), @@ -612,8 +838,7 @@ _mesa_PopAttrib(void) (GLboolean) (color->ColorMask[3] != 0)); _mesa_DrawBuffer(color->DrawBuffer); _mesa_set_enable(ctx, GL_ALPHA_TEST, color->AlphaEnabled); - _mesa_AlphaFunc(color->AlphaFunc, - CHAN_TO_FLOAT(color->AlphaRef)); + _mesa_AlphaFunc(color->AlphaFunc, color->AlphaRef); _mesa_set_enable(ctx, GL_BLEND, color->BlendEnabled); _mesa_BlendFuncSeparateEXT(color->BlendSrcRGB, color->BlendDstRGB, @@ -679,8 +904,6 @@ _mesa_PopAttrib(void) { const struct gl_hint_attrib *hint; hint = (const struct gl_hint_attrib *) attr->data; - /* XXX this memcpy is temporary: */ - MEMCPY(&ctx->Hint, hint, sizeof(struct gl_hint_attrib)); _mesa_Hint(GL_PERSPECTIVE_CORRECTION_HINT, hint->PerspectiveCorrection ); _mesa_Hint(GL_POINT_SMOOTH_HINT, hint->PointSmooth); @@ -702,11 +925,30 @@ _mesa_PopAttrib(void) /* lighting enable */ _mesa_set_enable(ctx, GL_LIGHTING, light->Enabled); /* per-light state */ + + if (ctx->ModelviewMatrixStack.Top->flags & MAT_DIRTY_INVERSE) + _math_matrix_analyse( ctx->ModelviewMatrixStack.Top ); + for (i = 0; i < MAX_LIGHTS; i++) { GLenum lgt = (GLenum) (GL_LIGHT0 + i); - _mesa_set_enable(ctx, lgt, light->Light[i].Enabled); - MEMCPY(&ctx->Light.Light[i], &light->Light[i], - sizeof(struct gl_light)); + const struct gl_light *l = &light->Light[i]; + GLfloat tmp[4]; + _mesa_set_enable(ctx, lgt, l->Enabled); + _mesa_Lightfv( lgt, GL_AMBIENT, l->Ambient ); + _mesa_Lightfv( lgt, GL_DIFFUSE, l->Diffuse ); + _mesa_Lightfv( lgt, GL_SPECULAR, l->Specular ); + TRANSFORM_POINT( tmp, ctx->ModelviewMatrixStack.Top->inv, l->EyePosition ); + _mesa_Lightfv( lgt, GL_POSITION, tmp ); + TRANSFORM_POINT( tmp, ctx->ModelviewMatrixStack.Top->m, l->EyeDirection ); + _mesa_Lightfv( lgt, GL_SPOT_DIRECTION, tmp ); + _mesa_Lightfv( lgt, GL_SPOT_EXPONENT, &l->SpotExponent ); + _mesa_Lightfv( lgt, GL_SPOT_CUTOFF, &l->SpotCutoff ); + _mesa_Lightfv( lgt, GL_CONSTANT_ATTENUATION, + &l->ConstantAttenuation ); + _mesa_Lightfv( lgt, GL_LINEAR_ATTENUATION, + &l->LinearAttenuation ); + _mesa_Lightfv( lgt, GL_QUADRATIC_ATTENUATION, + &l->QuadraticAttenuation ); } /* light model */ _mesa_LightModelfv(GL_LIGHT_MODEL_AMBIENT, @@ -752,12 +994,26 @@ _mesa_PopAttrib(void) point = (const struct gl_point_attrib *) attr->data; _mesa_PointSize(point->Size); _mesa_set_enable(ctx, GL_POINT_SMOOTH, point->SmoothFlag); - _mesa_PointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, - point->Params); - _mesa_PointParameterfEXT(GL_POINT_SIZE_MIN_EXT, point->MinSize); - _mesa_PointParameterfEXT(GL_POINT_SIZE_MAX_EXT, point->MaxSize); - _mesa_PointParameterfEXT(GL_POINT_FADE_THRESHOLD_SIZE_EXT, - point->Threshold); + if (ctx->Extensions.EXT_point_parameters) { + _mesa_PointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, + point->Params); + _mesa_PointParameterfEXT(GL_POINT_SIZE_MIN_EXT, + point->MinSize); + _mesa_PointParameterfEXT(GL_POINT_SIZE_MAX_EXT, + point->MaxSize); + _mesa_PointParameterfEXT(GL_POINT_FADE_THRESHOLD_SIZE_EXT, + point->Threshold); + } + if (ctx->Extensions.NV_point_sprite) { + GLuint u; + for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { + _mesa_TexEnvi(GL_POINT_SPRITE_NV, GL_COORD_REPLACE_NV, + (GLint) point->CoordReplace[u]); + } + _mesa_set_enable(ctx, GL_POINT_SPRITE_NV,point->PointSprite); + _mesa_PointParameteriNV(GL_POINT_SPRITE_R_MODE_NV, + ctx->Point.SpriteRMode); + } } break; case GL_POLYGON_BIT: @@ -798,15 +1054,17 @@ _mesa_PopAttrib(void) break; case GL_STENCIL_BUFFER_BIT: { + const GLint face = 0; /* XXX stencil two side */ const struct gl_stencil_attrib *stencil; stencil = (const struct gl_stencil_attrib *) attr->data; _mesa_set_enable(ctx, GL_STENCIL_TEST, stencil->Enabled); _mesa_ClearStencil(stencil->Clear); - _mesa_StencilFunc(stencil->Function, stencil->Ref, - stencil->ValueMask); - _mesa_StencilMask(stencil->WriteMask); - _mesa_StencilOp(stencil->FailFunc, stencil->ZFailFunc, - stencil->ZPassFunc); + _mesa_StencilFunc(stencil->Function[face], stencil->Ref[face], + stencil->ValueMask[face]); + _mesa_StencilMask(stencil->WriteMask[face]); + _mesa_StencilOp(stencil->FailFunc[face], + stencil->ZFailFunc[face], + stencil->ZPassFunc[face]); } break; case GL_TRANSFORM_BIT: @@ -815,61 +1073,59 @@ _mesa_PopAttrib(void) const struct gl_transform_attrib *xform; xform = (const struct gl_transform_attrib *) attr->data; _mesa_MatrixMode(xform->MatrixMode); - /* clip planes */ - MEMCPY(ctx->Transform.EyeUserPlane, xform->EyeUserPlane, - sizeof(xform->EyeUserPlane)); - MEMCPY(ctx->Transform._ClipUserPlane, xform->_ClipUserPlane, - sizeof(xform->EyeUserPlane)); - /* clip plane enable flags */ + + if (ctx->ProjectionMatrixStack.Top->flags & MAT_DIRTY) + _math_matrix_analyse( ctx->ProjectionMatrixStack.Top ); + + /* restore clip planes */ for (i = 0; i < MAX_CLIP_PLANES; i++) { - _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, - xform->ClipEnabled[i]); + const GLuint mask = 1 << 1; + const GLfloat *eyePlane = xform->EyeUserPlane[i]; + COPY_4V(ctx->Transform.EyeUserPlane[i], eyePlane); + if (xform->ClipPlanesEnabled & mask) { + _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_TRUE); + } + else { + _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_FALSE); + } + if (ctx->Driver.ClipPlane) + ctx->Driver.ClipPlane( ctx, GL_CLIP_PLANE0 + i, eyePlane ); } + /* normalize/rescale */ - _mesa_set_enable(ctx, GL_NORMALIZE, ctx->Transform.Normalize); - _mesa_set_enable(ctx, GL_RESCALE_NORMAL_EXT, - ctx->Transform.RescaleNormals); + if (xform->Normalize != ctx->Transform.Normalize) + _mesa_set_enable(ctx, GL_NORMALIZE,ctx->Transform.Normalize); + if (xform->RescaleNormals != ctx->Transform.RescaleNormals) + _mesa_set_enable(ctx, GL_RESCALE_NORMAL_EXT, + ctx->Transform.RescaleNormals); } break; case GL_TEXTURE_BIT: /* Take care of texture object reference counters */ { - GLuint u; - for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - ctx->Texture.Unit[u].Current1D->RefCount--; - ctx->Texture.Unit[u].Current2D->RefCount--; - ctx->Texture.Unit[u].Current3D->RefCount--; - ctx->Texture.Unit[u].CurrentCubeMap->RefCount--; - } - MEMCPY( &ctx->Texture, attr->data, - sizeof(struct gl_texture_attrib) ); + const struct gl_texture_attrib *texture; + texture = (const struct gl_texture_attrib *) attr->data; + pop_texture_group(ctx, texture); ctx->NewState |= _NEW_TEXTURE; - /* restore state of the currently bound texture objects */ - for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - copy_texobj_state( ctx->Texture.Unit[u].Current1D, - &(ctx->Texture.Unit[u].Saved1D) ); - copy_texobj_state( ctx->Texture.Unit[u].Current2D, - &(ctx->Texture.Unit[u].Saved2D) ); - copy_texobj_state( ctx->Texture.Unit[u].Current3D, - &(ctx->Texture.Unit[u].Saved3D) ); - copy_texobj_state( ctx->Texture.Unit[u].CurrentCubeMap, - &(ctx->Texture.Unit[u].SavedCubeMap) ); - - ctx->Texture.Unit[u].Current1D->Complete = GL_FALSE; - ctx->Texture.Unit[u].Current2D->Complete = GL_FALSE; - ctx->Texture.Unit[u].Current3D->Complete = GL_FALSE; - ctx->Texture.Unit[u].CurrentCubeMap->Complete = GL_FALSE; - } } break; case GL_VIEWPORT_BIT: { const struct gl_viewport_attrib *vp; - vp = (const struct gl_viewport_attrib *)attr->data; + vp = (const struct gl_viewport_attrib *) attr->data; _mesa_Viewport(vp->X, vp->Y, vp->Width, vp->Height); _mesa_DepthRange(vp->Near, vp->Far); } break; + case GL_MULTISAMPLE_BIT_ARB: + { + const struct gl_multisample_attrib *ms; + ms = (const struct gl_multisample_attrib *) attr->data; + _mesa_SampleCoverageARB(ms->SampleCoverageValue, + ms->SampleCoverageInvert); + } + break; + default: _mesa_problem( ctx, "Bad attrib flag in PopAttrib"); break; @@ -960,17 +1216,17 @@ _mesa_PopClientAttrib(void) case GL_CLIENT_PACK_BIT: MEMCPY( &ctx->Pack, attr->data, sizeof(struct gl_pixelstore_attrib) ); - ctx->NewState = _NEW_PACKUNPACK; + ctx->NewState |= _NEW_PACKUNPACK; break; case GL_CLIENT_UNPACK_BIT: MEMCPY( &ctx->Unpack, attr->data, sizeof(struct gl_pixelstore_attrib) ); - ctx->NewState = _NEW_PACKUNPACK; + ctx->NewState |= _NEW_PACKUNPACK; break; case GL_CLIENT_VERTEX_ARRAY_BIT: MEMCPY( &ctx->Array, attr->data, sizeof(struct gl_array_attrib) ); - ctx->NewState = _NEW_ARRAY; + ctx->NewState |= _NEW_ARRAY; break; default: _mesa_problem( ctx, "Bad attrib flag in PopClientAttrib"); @@ -983,6 +1239,3 @@ _mesa_PopClientAttrib(void) attr = next; } } - - -