/**
* Leave meta state. This is like a light-weight version of glPopAttrib().
*/
void
_mesa_meta_end(struct gl_context *ctx)
{
struct save_state *save = &ctx->Meta->Save[--ctx->Meta->SaveStackDepth];
const GLbitfield state = save->SavedState;
if (state & MESA_META_ALPHA_TEST) {
if (ctx->Color.AlphaEnabled != save->AlphaEnabled)
_mesa_set_enable(ctx, GL_ALPHA_TEST, save->AlphaEnabled);
_mesa_AlphaFunc(save->AlphaFunc, save->AlphaRef);
}
if (state & MESA_META_BLEND) {
if (ctx->Color.BlendEnabled != save->BlendEnabled) {
_mesa_set_enable(ctx, GL_BLEND, (save->BlendEnabled & 1));
}
if (ctx->Color.ColorLogicOpEnabled != save->ColorLogicOpEnabled)
_mesa_set_enable(ctx, GL_COLOR_LOGIC_OP, save->ColorLogicOpEnabled);
}
if (state & MESA_META_COLOR_MASK) {
if (!TEST_EQ_4V(ctx->Color.ColorMask, save->ColorMask)) {
_mesa_ColorMask(save->ColorMask[0], save->ColorMask[1],
save->ColorMask[2], save->ColorMask[3]);
}
}
if (state & MESA_META_DEPTH_TEST) {
if (ctx->Depth.Test != save->Depth.Test)
_mesa_set_enable(ctx, GL_DEPTH_TEST, save->Depth.Test);
_mesa_DepthFunc(save->Depth.Func);
_mesa_DepthMask(save->Depth.Mask);
}
if (state & MESA_META_FOG) {
_mesa_set_enable(ctx, GL_FOG, save->Fog);
}
if (state & MESA_META_PIXEL_STORE) {
ctx->Pack = save->Pack;
ctx->Unpack = save->Unpack;
}
if (state & MESA_META_PIXEL_TRANSFER) {
ctx->Pixel.RedScale = save->RedScale;
ctx->Pixel.RedBias = save->RedBias;
ctx->Pixel.GreenScale = save->GreenScale;
ctx->Pixel.GreenBias = save->GreenBias;
ctx->Pixel.BlueScale = save->BlueScale;
ctx->Pixel.BlueBias = save->BlueBias;
ctx->Pixel.AlphaScale = save->AlphaScale;
ctx->Pixel.AlphaBias = save->AlphaBias;
ctx->Pixel.MapColorFlag = save->MapColorFlag;
/* XXX more state */
ctx->NewState |=_NEW_PIXEL;
}
if (state & MESA_META_RASTERIZATION) {
_mesa_PolygonMode(GL_FRONT, save->FrontPolygonMode);
_mesa_PolygonMode(GL_BACK, save->BackPolygonMode);
_mesa_set_enable(ctx, GL_POLYGON_STIPPLE, save->PolygonStipple);
_mesa_set_enable(ctx, GL_POLYGON_OFFSET_FILL, save->PolygonOffset);
_mesa_set_enable(ctx, GL_POLYGON_SMOOTH, save->PolygonSmooth);
_mesa_set_enable(ctx, GL_CULL_FACE, save->PolygonCull);
}
if (state & MESA_META_SCISSOR) {
_mesa_set_enable(ctx, GL_SCISSOR_TEST, save->Scissor.Enabled);
_mesa_Scissor(save->Scissor.X, save->Scissor.Y,
save->Scissor.Width, save->Scissor.Height);
}
if (state & MESA_META_STENCIL_TEST) {
const struct gl_stencil_attrib *stencil = &save->Stencil;
_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);
}
if (state & MESA_META_TEXTURE) {
GLuint tgt;
/* restore texenv for unit[0] */
_mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, save->EnvMode);
/* restore texture objects for unit[0] only */
for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
if (ctx->Texture.Unit.CurrentTex[tgt] != save->CurrentTexture[tgt]) {
FLUSH_VERTICES(ctx, _NEW_TEXTURE);
_mesa_reference_texobj(&ctx->Texture.Unit.CurrentTex[tgt],
save->CurrentTexture[tgt]);
}
_mesa_reference_texobj(&save->CurrentTexture[tgt], NULL);
}
/* Restore fixed function texture enables, texgen */
if (ctx->Texture.Unit.Enabled != save->TexEnabled) {
FLUSH_VERTICES(ctx, _NEW_TEXTURE);
ctx->Texture.Unit.Enabled = save->TexEnabled;
}
if (ctx->Texture.Unit.TexGenEnabled != save->TexGenEnabled) {
FLUSH_VERTICES(ctx, _NEW_TEXTURE);
ctx->Texture.Unit.TexGenEnabled = save->TexGenEnabled;
}
}
if (state & MESA_META_TRANSFORM) {
_mesa_MatrixMode(GL_TEXTURE);
_mesa_LoadMatrixf(save->TextureMatrix);
_mesa_MatrixMode(GL_MODELVIEW);
_mesa_LoadMatrixf(save->ModelviewMatrix);
_mesa_MatrixMode(GL_PROJECTION);
_mesa_LoadMatrixf(save->ProjectionMatrix);
_mesa_MatrixMode(save->MatrixMode);
}
if (state & MESA_META_CLIP) {
if (save->ClipPlanesEnabled) {
GLuint i;
for (i = 0; i < ctx->Const.MaxClipPlanes; i++) {
if (save->ClipPlanesEnabled & (1 << i)) {
_mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_TRUE);
}
}
}
}
if (state & MESA_META_VIEWPORT) {
if (save->ViewportX != ctx->Viewport.X ||
save->ViewportY != ctx->Viewport.Y ||
save->ViewportW != ctx->Viewport.Width ||
save->ViewportH != ctx->Viewport.Height) {
_mesa_set_viewport(ctx, save->ViewportX, save->ViewportY,
save->ViewportW, save->ViewportH);
}
_mesa_DepthRange(save->DepthNear, save->DepthFar);
}
/* misc */
if (save->Lighting) {
_mesa_set_enable(ctx, GL_LIGHTING, GL_TRUE);
}
if (save->RasterDiscard) {
_mesa_set_enable(ctx, GL_RASTERIZER_DISCARD, GL_TRUE);
}
}
/*
* This function is kind of long just because we have to call a lot
* of device driver functions to update device driver state.
*
* XXX As it is now, most of the pop-code calls immediate-mode Mesa functions
* in order to restore GL state. This isn't terribly efficient but it
* ensures that dirty flags and any derived state gets updated correctly.
* We could at least check if the value to restore equals the current value
* and then skip the Mesa call.
*/
void
_mesa_PopAttrib(void)
{
struct gl_attrib_node *attr, *next;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
if (ctx->AttribStackDepth == 0) {
_mesa_error( ctx, GL_STACK_UNDERFLOW, "glPopAttrib" );
return;
}
ctx->AttribStackDepth--;
attr = ctx->AttribStack[ctx->AttribStackDepth];
while (attr) {
if (MESA_VERBOSE&VERBOSE_API) {
fprintf(stderr, "glPopAttrib %s\n",
_mesa_lookup_enum_by_nr(attr->kind));
}
switch (attr->kind) {
case GL_ACCUM_BUFFER_BIT:
{
const struct gl_accum_attrib *accum;
accum = (const struct gl_accum_attrib *) attr->data;
_mesa_ClearAccum(accum->ClearColor[0],
accum->ClearColor[1],
accum->ClearColor[2],
accum->ClearColor[3]);
}
break;
case GL_COLOR_BUFFER_BIT:
{
const struct gl_colorbuffer_attrib *color;
color = (const struct gl_colorbuffer_attrib *) attr->data;
_mesa_ClearIndex((GLfloat) 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_IndexMask(color->IndexMask);
_mesa_ColorMask((GLboolean) (color->ColorMask[0] != 0),
(GLboolean) (color->ColorMask[1] != 0),
(GLboolean) (color->ColorMask[2] != 0),
(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_set_enable(ctx, GL_BLEND, color->BlendEnabled);
_mesa_BlendFuncSeparateEXT(color->BlendSrcRGB,
color->BlendDstRGB,
color->BlendSrcA,
color->BlendDstA);
_mesa_BlendEquation(color->BlendEquation);
_mesa_BlendColor(color->BlendColor[0],
color->BlendColor[1],
color->BlendColor[2],
color->BlendColor[3]);
_mesa_LogicOp(color->LogicOp);
_mesa_set_enable(ctx, GL_COLOR_LOGIC_OP,
color->ColorLogicOpEnabled);
_mesa_set_enable(ctx, GL_INDEX_LOGIC_OP,
color->IndexLogicOpEnabled);
_mesa_set_enable(ctx, GL_DITHER, color->DitherFlag);
}
break;
case GL_CURRENT_BIT:
FLUSH_CURRENT( ctx, 0 );
MEMCPY( &ctx->Current, attr->data,
sizeof(struct gl_current_attrib) );
break;
case GL_DEPTH_BUFFER_BIT:
{
const struct gl_depthbuffer_attrib *depth;
depth = (const struct gl_depthbuffer_attrib *) attr->data;
_mesa_DepthFunc(depth->Func);
_mesa_ClearDepth(depth->Clear);
_mesa_set_enable(ctx, GL_DEPTH_TEST, depth->Test);
_mesa_DepthMask(depth->Mask);
if (ctx->Extensions.HP_occlusion_test)
_mesa_set_enable(ctx, GL_OCCLUSION_TEST_HP,
depth->OcclusionTest);
}
break;
case GL_ENABLE_BIT:
{
const struct gl_enable_attrib *enable;
enable = (const struct gl_enable_attrib *) attr->data;
pop_enable_group(ctx, enable);
ctx->NewState |= _NEW_ALL;
}
break;
case GL_EVAL_BIT:
MEMCPY( &ctx->Eval, attr->data, sizeof(struct gl_eval_attrib) );
ctx->NewState |= _NEW_EVAL;
break;
case GL_FOG_BIT:
{
const struct gl_fog_attrib *fog;
fog = (const struct gl_fog_attrib *) attr->data;
_mesa_set_enable(ctx, GL_FOG, fog->Enabled);
_mesa_Fogfv(GL_FOG_COLOR, fog->Color);
_mesa_Fogf(GL_FOG_DENSITY, fog->Density);
_mesa_Fogf(GL_FOG_START, fog->Start);
_mesa_Fogf(GL_FOG_END, fog->End);
_mesa_Fogf(GL_FOG_INDEX, fog->Index);
_mesa_Fogi(GL_FOG_MODE, fog->Mode);
}
break;
case GL_HINT_BIT:
{
const struct gl_hint_attrib *hint;
hint = (const struct gl_hint_attrib *) attr->data;
_mesa_Hint(GL_PERSPECTIVE_CORRECTION_HINT,
hint->PerspectiveCorrection );
_mesa_Hint(GL_POINT_SMOOTH_HINT, hint->PointSmooth);
_mesa_Hint(GL_LINE_SMOOTH_HINT, hint->LineSmooth);
_mesa_Hint(GL_POLYGON_SMOOTH_HINT, hint->PolygonSmooth);
_mesa_Hint(GL_FOG_HINT, hint->Fog);
_mesa_Hint(GL_CLIP_VOLUME_CLIPPING_HINT_EXT,
hint->ClipVolumeClipping);
if (ctx->Extensions.ARB_texture_compression)
_mesa_Hint(GL_TEXTURE_COMPRESSION_HINT_ARB,
hint->TextureCompression);
}
break;
case GL_LIGHTING_BIT:
{
GLuint i;
const struct gl_light_attrib *light;
light = (const struct gl_light_attrib *) attr->data;
/* lighting enable */
_mesa_set_enable(ctx, GL_LIGHTING, light->Enabled);
/* per-light state */
if (ctx->ModelView.flags & MAT_DIRTY_INVERSE)
_math_matrix_analyse( &ctx->ModelView );
for (i = 0; i < MAX_LIGHTS; i++) {
GLenum lgt = (GLenum) (GL_LIGHT0 + i);
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->ModelView.inv, l->EyePosition );
_mesa_Lightfv( lgt, GL_POSITION, tmp );
TRANSFORM_POINT( tmp, ctx->ModelView.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,
light->Model.Ambient);
_mesa_LightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER,
(GLfloat) light->Model.LocalViewer);
_mesa_LightModelf(GL_LIGHT_MODEL_TWO_SIDE,
(GLfloat) light->Model.TwoSide);
_mesa_LightModelf(GL_LIGHT_MODEL_COLOR_CONTROL,
(GLfloat) light->Model.ColorControl);
/* materials */
MEMCPY(ctx->Light.Material, light->Material,
2 * sizeof(struct gl_material));
/* shade model */
_mesa_ShadeModel(light->ShadeModel);
/* color material */
_mesa_ColorMaterial(light->ColorMaterialFace,
light->ColorMaterialMode);
_mesa_set_enable(ctx, GL_COLOR_MATERIAL,
light->ColorMaterialEnabled);
}
break;
case GL_LINE_BIT:
{
const struct gl_line_attrib *line;
line = (const struct gl_line_attrib *) attr->data;
_mesa_set_enable(ctx, GL_LINE_SMOOTH, line->SmoothFlag);
_mesa_set_enable(ctx, GL_LINE_STIPPLE, line->StippleFlag);
_mesa_LineStipple(line->StippleFactor, line->StipplePattern);
_mesa_LineWidth(line->Width);
}
break;
case GL_LIST_BIT:
MEMCPY( &ctx->List, attr->data, sizeof(struct gl_list_attrib) );
break;
case GL_PIXEL_MODE_BIT:
MEMCPY( &ctx->Pixel, attr->data, sizeof(struct gl_pixel_attrib) );
ctx->NewState |= _NEW_PIXEL;
break;
case GL_POINT_BIT:
{
const struct gl_point_attrib *point;
point = (const struct gl_point_attrib *) attr->data;
_mesa_PointSize(point->Size);
_mesa_set_enable(ctx, GL_POINT_SMOOTH, point->SmoothFlag);
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);
}
}
break;
case GL_POLYGON_BIT:
{
const struct gl_polygon_attrib *polygon;
polygon = (const struct gl_polygon_attrib *) attr->data;
_mesa_CullFace(polygon->CullFaceMode);
_mesa_FrontFace(polygon->FrontFace);
_mesa_PolygonMode(GL_FRONT, polygon->FrontMode);
_mesa_PolygonMode(GL_BACK, polygon->BackMode);
_mesa_PolygonOffset(polygon->OffsetFactor,
polygon->OffsetUnits);
_mesa_set_enable(ctx, GL_POLYGON_SMOOTH, polygon->SmoothFlag);
_mesa_set_enable(ctx, GL_POLYGON_STIPPLE, polygon->StippleFlag);
_mesa_set_enable(ctx, GL_CULL_FACE, polygon->CullFlag);
_mesa_set_enable(ctx, GL_POLYGON_OFFSET_POINT,
polygon->OffsetPoint);
_mesa_set_enable(ctx, GL_POLYGON_OFFSET_LINE,
polygon->OffsetLine);
_mesa_set_enable(ctx, GL_POLYGON_OFFSET_FILL,
polygon->OffsetFill);
}
break;
case GL_POLYGON_STIPPLE_BIT:
MEMCPY( ctx->PolygonStipple, attr->data, 32*sizeof(GLuint) );
ctx->NewState |= _NEW_POLYGONSTIPPLE;
if (ctx->Driver.PolygonStipple)
ctx->Driver.PolygonStipple( ctx, (const GLubyte *) attr->data );
break;
case GL_SCISSOR_BIT:
{
const struct gl_scissor_attrib *scissor;
scissor = (const struct gl_scissor_attrib *) attr->data;
_mesa_Scissor(scissor->X, scissor->Y,
scissor->Width, scissor->Height);
_mesa_set_enable(ctx, GL_SCISSOR_TEST, scissor->Enabled);
}
break;
case GL_STENCIL_BUFFER_BIT:
{
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);
}
break;
case GL_TRANSFORM_BIT:
{
GLuint i;
const struct gl_transform_attrib *xform;
xform = (const struct gl_transform_attrib *) attr->data;
_mesa_MatrixMode(xform->MatrixMode);
if (ctx->ProjectionMatrix.flags & MAT_DIRTY)
_math_matrix_analyse( &ctx->ProjectionMatrix );
/* restore clip planes */
for (i = 0; i < MAX_CLIP_PLANES; i++) {
const GLfloat *eyePlane = xform->EyeUserPlane[i];
COPY_4V(ctx->Transform.EyeUserPlane[i], eyePlane);
if (xform->ClipEnabled[i]) {
_mesa_transform_vector( ctx->Transform._ClipUserPlane[i],
eyePlane,
ctx->ProjectionMatrix.inv );
_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);
}
break;
case GL_TEXTURE_BIT:
/* Take care of texture object reference counters */
{
const struct gl_texture_attrib *texture;
texture = (const struct gl_texture_attrib *) attr->data;
pop_texture_group(ctx, texture);
ctx->NewState |= _NEW_TEXTURE;
}
break;
case GL_VIEWPORT_BIT:
{
const struct gl_viewport_attrib *vp;
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;
}
next = attr->next;
FREE( attr->data );
FREE( attr );
attr = next;
}
}
