src/mesa/main/attrib.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
   5  * Copyright (C) 2009  VMware, Inc.   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  21  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  22  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  23  * OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26 #include "glheader.h"
  27 #include "imports.h"
  28 #include "accum.h"
  29 #include "arrayobj.h"
  30 #include "attrib.h"
  31 #include "blend.h"
  32 #include "buffers.h"
  33 #include "bufferobj.h"
  34 #include "clear.h"
  35 #include "colormac.h"
  36 #include "context.h"
  37 #include "depth.h"
  38 #include "enable.h"
  39 #include "enums.h"
  40 #include "fog.h"
  41 #include "hint.h"
  42 #include "light.h"
  43 #include "lines.h"
  44 #include "macros.h"
  45 #include "matrix.h"
  46 #include "multisample.h"
  47 #include "points.h"
  48 #include "polygon.h"
  49 #include "shared.h"
  50 #include "scissor.h"
  51 #include "stencil.h"
  52 #include "texenv.h"
  53 #include "texgen.h"
  54 #include "texobj.h"
  55 #include "texparam.h"
  56 #include "texstate.h"
  57 #include "varray.h"
  58 #include "viewport.h"
  59 #include "mtypes.h"
  60 #include "main/dispatch.h"
  61 #include "hash.h"
  62 #include <stdbool.h>
  63
  64
  65 /**
  66  * glEnable()/glDisable() attribute group (GL_ENABLE_BIT).
  67  */
  68 struct gl_enable_attrib
  69 {
  70    GLboolean AlphaTest;
  71    GLboolean AutoNormal;
  72    GLboolean Blend;
  73    GLbitfield ClipPlanes;
  74    GLboolean ColorMaterial;
  75    GLboolean CullFace;
  76    GLboolean DepthClamp;
  77    GLboolean DepthTest;
  78    GLboolean Dither;
  79    GLboolean Fog;
  80    GLboolean Light[MAX_LIGHTS];
  81    GLboolean Lighting;
  82    GLboolean LineSmooth;
  83    GLboolean LineStipple;
  84    GLboolean IndexLogicOp;
  85    GLboolean ColorLogicOp;
  86
  87    GLboolean Map1Color4;
  88    GLboolean Map1Index;
  89    GLboolean Map1Normal;
  90    GLboolean Map1TextureCoord1;
  91    GLboolean Map1TextureCoord2;
  92    GLboolean Map1TextureCoord3;
  93    GLboolean Map1TextureCoord4;
  94    GLboolean Map1Vertex3;
  95    GLboolean Map1Vertex4;
  96    GLboolean Map2Color4;
  97    GLboolean Map2Index;
  98    GLboolean Map2Normal;
  99    GLboolean Map2TextureCoord1;
 100    GLboolean Map2TextureCoord2;
 101    GLboolean Map2TextureCoord3;
 102    GLboolean Map2TextureCoord4;
 103    GLboolean Map2Vertex3;
 104    GLboolean Map2Vertex4;
 105
 106    GLboolean Normalize;
 107    GLboolean PixelTexture;
 108    GLboolean PointSmooth;
 109    GLboolean PolygonOffsetPoint;
 110    GLboolean PolygonOffsetLine;
 111    GLboolean PolygonOffsetFill;
 112    GLboolean PolygonSmooth;
 113    GLboolean PolygonStipple;
 114    GLboolean RescaleNormals;
 115    GLbitfield Scissor;
 116    GLboolean Stencil;
 117    GLboolean StencilTwoSide;          /* GL_EXT_stencil_two_side */
 118    GLboolean MultisampleEnabled;      /* GL_ARB_multisample */
 119    GLboolean SampleAlphaToCoverage;   /* GL_ARB_multisample */
 120    GLboolean SampleAlphaToOne;        /* GL_ARB_multisample */
 121    GLboolean SampleCoverage;          /* GL_ARB_multisample */
 122    GLboolean RasterPositionUnclipped; /* GL_IBM_rasterpos_clip */
 123
 124    GLbitfield Texture[MAX_TEXTURE_UNITS];
 125    GLbitfield TexGen[MAX_TEXTURE_UNITS];
 126
 127    /* GL_ARB_vertex_program */
 128    GLboolean VertexProgram;
 129    GLboolean VertexProgramPointSize;
 130    GLboolean VertexProgramTwoSide;
 131
 132    /* GL_ARB_fragment_program */
 133    GLboolean FragmentProgram;
 134
 135    /* GL_ARB_point_sprite / GL_NV_point_sprite */
 136    GLboolean PointSprite;
 137    GLboolean FragmentShaderATI;
 138
 139    /* GL_ARB_framebuffer_sRGB / GL_EXT_framebuffer_sRGB */
 140    GLboolean sRGBEnabled;
 141 };
 142
 143
 144 /**
 145  * Node for the attribute stack.
 146  */
 147 struct gl_attrib_node
 148 {
 149    GLbitfield kind;
 150    void *data;
 151    struct gl_attrib_node *next;
 152 };
 153
 154
 155
 156 /**
 157  * Special struct for saving/restoring texture state (GL_TEXTURE_BIT)
 158  */
 159 struct texture_state
 160 {
 161    struct gl_texture_attrib Texture;  /**< The usual context state */
 162
 163    /** to save per texture object state (wrap modes, filters, etc): */
 164    struct gl_texture_object SavedObj[MAX_TEXTURE_UNITS][NUM_TEXTURE_TARGETS];
 165
 166    /**
 167     * To save references to texture objects (so they don't get accidentally
 168     * deleted while saved in the attribute stack).
 169     */
 170    struct gl_texture_object *SavedTexRef[MAX_TEXTURE_UNITS][NUM_TEXTURE_TARGETS];
 171
 172    /* We need to keep a reference to the shared state.  That's where the
 173     * default texture objects are kept.  We don't want that state to be
 174     * freed while the attribute stack contains pointers to any default
 175     * texture objects.
 176     */
 177    struct gl_shared_state *SharedRef;
 178 };
 179
 180
 181 /**
 182  * Allocate new attribute node of given type/kind.  Attach payload data.
 183  * Insert it into the linked list named by 'head'.
 184  */
 185 static bool
 186 save_attrib_data(struct gl_attrib_node **head,
 187                  GLbitfield kind, void *payload)
 188 {
 189    struct gl_attrib_node *n = MALLOC_STRUCT(gl_attrib_node);
 190    if (n) {
 191       n->kind = kind;
 192       n->data = payload;
 193       /* insert at head */
 194       n->next = *head;
 195       *head = n;
 196    }
 197    else {
 198       /* out of memory! */
 199       return false;
 200    }
 201    return true;
 202 }
 203
 204
 205 /**
 206  * Helper function for_mesa_PushAttrib for simple attributes.
 207  * Allocates memory for attribute data and copies the given attribute data.
 208  * \param head  head of linked list to insert attribute data into
 209  * \param attr_bit  one of the GL_<attrib>_BIT flags
 210  * \param attr_size  number of bytes to allocate for attribute data
 211  * \param attr_data  the attribute data to copy
 212  * \return true for success, false for out of memory
 213  */
 214 static bool
 215 push_attrib(struct gl_context *ctx, struct gl_attrib_node **head,
 216             GLbitfield attr_bit, GLuint attr_size, const void *attr_data)
 217 {
 218    void *attribute;
 219
 220    attribute = MALLOC(attr_size);
 221    if (attribute == NULL) {
 222       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushAttrib");
 223       return false;
 224    }
 225
 226    if (save_attrib_data(head, attr_bit, attribute)) {
 227       memcpy(attribute, attr_data, attr_size);
 228    }
 229    else {
 230       FREE(attribute);
 231       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushAttrib");
 232       return false;
 233    }
 234    return true;
 235 }
 236
 237
 238 void GLAPIENTRY
 239 _mesa_PushAttrib(GLbitfield mask)
 240 {
 241    struct gl_attrib_node *head;
 242
 243    GET_CURRENT_CONTEXT(ctx);
 244
 245    if (MESA_VERBOSE & VERBOSE_API)
 246       _mesa_debug(ctx, "glPushAttrib %x\n", (int) mask);
 247
 248    if (ctx->AttribStackDepth >= MAX_ATTRIB_STACK_DEPTH) {
 249       _mesa_error( ctx, GL_STACK_OVERFLOW, "glPushAttrib" );
 250       return;
 251    }
 252
 253    /* Build linked list of attribute nodes which save all attribute */
 254    /* groups specified by the mask. */
 255    head = NULL;
 256
 257    if (mask & GL_ACCUM_BUFFER_BIT) {
 258       if (!push_attrib(ctx, &head, GL_ACCUM_BUFFER_BIT,
 259                        sizeof(struct gl_accum_attrib),
 260                        (void*)&ctx->Accum))
 261          goto end;
 262    }
 263
 264    if (mask & GL_COLOR_BUFFER_BIT) {
 265       GLuint i;
 266       struct gl_colorbuffer_attrib *attr;
 267       attr = MALLOC_STRUCT( gl_colorbuffer_attrib );
 268       if (attr == NULL) {
 269          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushAttrib");
 270          goto end;
 271       }
 272
 273     if (save_attrib_data(&head, GL_COLOR_BUFFER_BIT, attr)) {
 274          memcpy(attr, &ctx->Color, sizeof(struct gl_colorbuffer_attrib));
 275          /* push the Draw FBO's DrawBuffer[] state, not ctx->Color.DrawBuffer[] */
 276          for (i = 0; i < ctx->Const.MaxDrawBuffers; i ++)
 277             attr->DrawBuffer[i] = ctx->DrawBuffer->ColorDrawBuffer[i];
 278       }
 279       else {
 280          FREE(attr);
 281          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushAttrib");
 282          goto end;
 283       }
 284    }
 285
 286    if (mask & GL_CURRENT_BIT) {
 287       FLUSH_CURRENT(ctx, 0);
 288       if (!push_attrib(ctx, &head, GL_CURRENT_BIT,
 289                        sizeof(struct gl_current_attrib),
 290                        (void*)&ctx->Current))
 291          goto end;
 292    }
 293
 294    if (mask & GL_DEPTH_BUFFER_BIT) {
 295       if (!push_attrib(ctx, &head, GL_DEPTH_BUFFER_BIT,
 296                        sizeof(struct gl_depthbuffer_attrib),
 297                        (void*)&ctx->Depth))
 298          goto end;
 299    }
 300
 301    if (mask & GL_ENABLE_BIT) {
 302       struct gl_enable_attrib *attr;
 303       GLuint i;
 304       attr = MALLOC_STRUCT( gl_enable_attrib );
 305       if (attr == NULL) {
 306          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushAttrib");
 307          goto end;
 308       }
 309
 310       /* Copy enable flags from all other attributes into the enable struct. */
 311       attr->AlphaTest = ctx->Color.AlphaEnabled;
 312       attr->AutoNormal = ctx->Eval.AutoNormal;
 313       attr->Blend = ctx->Color.BlendEnabled;
 314       attr->ClipPlanes = ctx->Transform.ClipPlanesEnabled;
 315       attr->ColorMaterial = ctx->Light.ColorMaterialEnabled;
 316       attr->CullFace = ctx->Polygon.CullFlag;
 317       attr->DepthClamp = ctx->Transform.DepthClamp;
 318       attr->DepthTest = ctx->Depth.Test;
 319       attr->Dither = ctx->Color.DitherFlag;
 320       attr->Fog = ctx->Fog.Enabled;
 321       for (i = 0; i < ctx->Const.MaxLights; i++) {
 322          attr->Light[i] = ctx->Light.Light[i].Enabled;
 323       }
 324       attr->Lighting = ctx->Light.Enabled;
 325       attr->LineSmooth = ctx->Line.SmoothFlag;
 326       attr->LineStipple = ctx->Line.StippleFlag;
 327       attr->IndexLogicOp = ctx->Color.IndexLogicOpEnabled;
 328       attr->ColorLogicOp = ctx->Color.ColorLogicOpEnabled;
 329       attr->Map1Color4 = ctx->Eval.Map1Color4;
 330       attr->Map1Index = ctx->Eval.Map1Index;
 331       attr->Map1Normal = ctx->Eval.Map1Normal;
 332       attr->Map1TextureCoord1 = ctx->Eval.Map1TextureCoord1;
 333       attr->Map1TextureCoord2 = ctx->Eval.Map1TextureCoord2;
 334       attr->Map1TextureCoord3 = ctx->Eval.Map1TextureCoord3;
 335       attr->Map1TextureCoord4 = ctx->Eval.Map1TextureCoord4;
 336       attr->Map1Vertex3 = ctx->Eval.Map1Vertex3;
 337       attr->Map1Vertex4 = ctx->Eval.Map1Vertex4;
 338       attr->Map2Color4 = ctx->Eval.Map2Color4;
 339       attr->Map2Index = ctx->Eval.Map2Index;
 340       attr->Map2Normal = ctx->Eval.Map2Normal;
 341       attr->Map2TextureCoord1 = ctx->Eval.Map2TextureCoord1;
 342       attr->Map2TextureCoord2 = ctx->Eval.Map2TextureCoord2;
 343       attr->Map2TextureCoord3 = ctx->Eval.Map2TextureCoord3;
 344       attr->Map2TextureCoord4 = ctx->Eval.Map2TextureCoord4;
 345       attr->Map2Vertex3 = ctx->Eval.Map2Vertex3;
 346       attr->Map2Vertex4 = ctx->Eval.Map2Vertex4;
 347       attr->Normalize = ctx->Transform.Normalize;
 348       attr->RasterPositionUnclipped = ctx->Transform.RasterPositionUnclipped;
 349       attr->PointSmooth = ctx->Point.SmoothFlag;
 350       attr->PointSprite = ctx->Point.PointSprite;
 351       attr->PolygonOffsetPoint = ctx->Polygon.OffsetPoint;
 352       attr->PolygonOffsetLine = ctx->Polygon.OffsetLine;
 353       attr->PolygonOffsetFill = ctx->Polygon.OffsetFill;
 354       attr->PolygonSmooth = ctx->Polygon.SmoothFlag;
 355       attr->PolygonStipple = ctx->Polygon.StippleFlag;
 356       attr->RescaleNormals = ctx->Transform.RescaleNormals;
 357       attr->Scissor = ctx->Scissor.EnableFlags;
 358       attr->Stencil = ctx->Stencil.Enabled;
 359       attr->StencilTwoSide = ctx->Stencil.TestTwoSide;
 360       attr->MultisampleEnabled = ctx->Multisample.Enabled;
 361       attr->SampleAlphaToCoverage = ctx->Multisample.SampleAlphaToCoverage;
 362       attr->SampleAlphaToOne = ctx->Multisample.SampleAlphaToOne;
 363       attr->SampleCoverage = ctx->Multisample.SampleCoverage;
 364       for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
 365          attr->Texture[i] = ctx->Texture.Unit[i].Enabled;
 366          attr->TexGen[i] = ctx->Texture.Unit[i].TexGenEnabled;
 367       }
 368       /* GL_ARB_vertex_program */
 369       attr->VertexProgram = ctx->VertexProgram.Enabled;
 370       attr->VertexProgramPointSize = ctx->VertexProgram.PointSizeEnabled;
 371       attr->VertexProgramTwoSide = ctx->VertexProgram.TwoSideEnabled;
 372
 373       /* GL_ARB_fragment_program */
 374       attr->FragmentProgram = ctx->FragmentProgram.Enabled;
 375
 376       if (!save_attrib_data(&head, GL_ENABLE_BIT, attr)) {
 377          FREE(attr);
 378          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushAttrib");
 379          goto end;
 380       }
 381
 382       /* GL_ARB_framebuffer_sRGB / GL_EXT_framebuffer_sRGB */
 383       attr->sRGBEnabled = ctx->Color.sRGBEnabled;
 384    }
 385
 386    if (mask & GL_EVAL_BIT) {
 387       if (!push_attrib(ctx, &head, GL_EVAL_BIT,
 388                        sizeof(struct gl_eval_attrib),
 389                        (void*)&ctx->Eval))
 390          goto end;
 391    }
 392
 393    if (mask & GL_FOG_BIT) {
 394       if (!push_attrib(ctx, &head, GL_FOG_BIT,
 395                        sizeof(struct gl_fog_attrib),
 396                        (void*)&ctx->Fog))
 397          goto end;
 398    }
 399
 400    if (mask & GL_HINT_BIT) {
 401       if (!push_attrib(ctx, &head, GL_HINT_BIT,
 402                        sizeof(struct gl_hint_attrib),
 403                        (void*)&ctx->Hint))
 404          goto end;
 405    }
 406
 407    if (mask & GL_LIGHTING_BIT) {
 408       FLUSH_CURRENT(ctx, 0);   /* flush material changes */
 409       if (!push_attrib(ctx, &head, GL_LIGHTING_BIT,
 410                        sizeof(struct gl_light_attrib),
 411                        (void*)&ctx->Light))
 412          goto end;
 413    }
 414
 415    if (mask & GL_LINE_BIT) {
 416       if (!push_attrib(ctx, &head, GL_LINE_BIT,
 417                        sizeof(struct gl_line_attrib),
 418                        (void*)&ctx->Line))
 419          goto end;
 420    }
 421
 422    if (mask & GL_LIST_BIT) {
 423       if (!push_attrib(ctx, &head, GL_LIST_BIT,
 424                        sizeof(struct gl_list_attrib),
 425                        (void*)&ctx->List))
 426          goto end;
 427    }
 428
 429    if (mask & GL_PIXEL_MODE_BIT) {
 430       struct gl_pixel_attrib *attr;
 431       attr = MALLOC_STRUCT( gl_pixel_attrib );
 432       if (attr == NULL) {
 433          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushAttrib");
 434          goto end;
 435       }
 436
 437       if (save_attrib_data(&head, GL_PIXEL_MODE_BIT, attr)) {
 438          memcpy(attr, &ctx->Pixel, sizeof(struct gl_pixel_attrib));
 439          /* push the Read FBO's ReadBuffer state, not ctx->Pixel.ReadBuffer */
 440          attr->ReadBuffer = ctx->ReadBuffer->ColorReadBuffer;
 441       }
 442       else {
 443          FREE(attr);
 444          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushAttrib");
 445          goto end;
 446       }
 447    }
 448
 449    if (mask & GL_POINT_BIT) {
 450       if (!push_attrib(ctx, &head, GL_POINT_BIT,
 451                        sizeof(struct gl_point_attrib),
 452                        (void*)&ctx->Point))
 453          goto end;
 454    }
 455
 456    if (mask & GL_POLYGON_BIT) {
 457       if (!push_attrib(ctx, &head, GL_POLYGON_BIT,
 458                        sizeof(struct gl_polygon_attrib),
 459                        (void*)&ctx->Polygon))
 460          goto end;
 461    }
 462
 463    if (mask & GL_POLYGON_STIPPLE_BIT) {
 464       if (!push_attrib(ctx, &head, GL_POLYGON_STIPPLE_BIT,
 465                        sizeof(ctx->PolygonStipple),
 466                        (void*)&ctx->PolygonStipple))
 467          goto end;
 468    }
 469
 470    if (mask & GL_SCISSOR_BIT) {
 471       if (!push_attrib(ctx, &head, GL_SCISSOR_BIT,
 472                        sizeof(struct gl_scissor_attrib),
 473                        (void*)&ctx->Scissor))
 474          goto end;
 475    }
 476
 477    if (mask & GL_STENCIL_BUFFER_BIT) {
 478       if (!push_attrib(ctx, &head, GL_STENCIL_BUFFER_BIT,
 479                        sizeof(struct gl_stencil_attrib),
 480                        (void*)&ctx->Stencil))
 481          goto end;
 482    }
 483
 484    if (mask & GL_TEXTURE_BIT) {
 485       struct texture_state *texstate = CALLOC_STRUCT(texture_state);
 486       GLuint u, tex;
 487
 488       if (!texstate) {
 489          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushAttrib(GL_TEXTURE_BIT)");
 490          goto end;
 491       }
 492
 493       if (!save_attrib_data(&head, GL_TEXTURE_BIT, texstate)) {
 494          FREE(texstate);
 495          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushAttrib(GL_TEXTURE_BIT)");
 496          goto end;
 497       }
 498
 499       _mesa_lock_context_textures(ctx);
 500
 501       /* copy/save the bulk of texture state here */
 502       memcpy(&texstate->Texture, &ctx->Texture, sizeof(ctx->Texture));
 503
 504       /* Save references to the currently bound texture objects so they don't
 505        * accidentally get deleted while referenced in the attribute stack.
 506        */
 507       for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
 508          for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
 509             _mesa_reference_texobj(&texstate->SavedTexRef[u][tex],
 510                                    ctx->Texture.Unit[u].CurrentTex[tex]);
 511          }
 512       }
 513
 514       /* copy state/contents of the currently bound texture objects */
 515       for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
 516          for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
 517             _mesa_copy_texture_object(&texstate->SavedObj[u][tex],
 518                                       ctx->Texture.Unit[u].CurrentTex[tex]);
 519          }
 520       }
 521
 522       _mesa_reference_shared_state(ctx, &texstate->SharedRef, ctx->Shared);
 523
 524       _mesa_unlock_context_textures(ctx);
 525    }
 526
 527    if (mask & GL_TRANSFORM_BIT) {
 528       if (!push_attrib(ctx, &head, GL_TRANSFORM_BIT,
 529                        sizeof(struct gl_transform_attrib),
 530                        (void*)&ctx->Transform))
 531          goto end;
 532    }
 533
 534    if (mask & GL_VIEWPORT_BIT) {
 535       if (!push_attrib(ctx, &head, GL_VIEWPORT_BIT,
 536                        sizeof(struct gl_viewport_attrib),
 537                        (void*)&ctx->Viewport))
 538          goto end;
 539    }
 540
 541    /* GL_ARB_multisample */
 542    if (mask & GL_MULTISAMPLE_BIT_ARB) {
 543       if (!push_attrib(ctx, &head, GL_MULTISAMPLE_BIT_ARB,
 544                        sizeof(struct gl_multisample_attrib),
 545                        (void*)&ctx->Multisample))
 546          goto end;
 547    }
 548
 549 end:
 550    if (head != NULL) {
 551        ctx->AttribStack[ctx->AttribStackDepth] = head;
 552        ctx->AttribStackDepth++;
 553    }
 554 }
 555
 556
 557
 558 static void
 559 pop_enable_group(struct gl_context *ctx, const struct gl_enable_attrib *enable)
 560 {
 561    const GLuint curTexUnitSave = ctx->Texture.CurrentUnit;
 562    GLuint i;
 563
 564 #define TEST_AND_UPDATE(VALUE, NEWVALUE, ENUM)          \
 565         if ((VALUE) != (NEWVALUE)) {                    \
 566            _mesa_set_enable( ctx, ENUM, (NEWVALUE) );   \
 567         }
 568
 569    TEST_AND_UPDATE(ctx->Color.AlphaEnabled, enable->AlphaTest, GL_ALPHA_TEST);
 570    if (ctx->Color.BlendEnabled != enable->Blend) {
 571       if (ctx->Extensions.EXT_draw_buffers2) {
 572          GLuint i;
 573          for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
 574             _mesa_set_enablei(ctx, GL_BLEND, i, (enable->Blend >> i) & 1);
 575          }
 576       }
 577       else {
 578          _mesa_set_enable(ctx, GL_BLEND, (enable->Blend & 1));
 579       }
 580    }
 581
 582    for (i=0;i<ctx->Const.MaxClipPlanes;i++) {
 583       const GLuint mask = 1 << i;
 584       if ((ctx->Transform.ClipPlanesEnabled & mask) != (enable->ClipPlanes & mask))
 585           _mesa_set_enable(ctx, (GLenum) (GL_CLIP_PLANE0 + i),
 586                            !!(enable->ClipPlanes & mask));
 587    }
 588
 589    TEST_AND_UPDATE(ctx->Light.ColorMaterialEnabled, enable->ColorMaterial,
 590                    GL_COLOR_MATERIAL);
 591    TEST_AND_UPDATE(ctx->Polygon.CullFlag, enable->CullFace, GL_CULL_FACE);
 592    TEST_AND_UPDATE(ctx->Transform.DepthClamp, enable->DepthClamp,
 593                    GL_DEPTH_CLAMP);
 594    TEST_AND_UPDATE(ctx->Depth.Test, enable->DepthTest, GL_DEPTH_TEST);
 595    TEST_AND_UPDATE(ctx->Color.DitherFlag, enable->Dither, GL_DITHER);
 596    TEST_AND_UPDATE(ctx->Fog.Enabled, enable->Fog, GL_FOG);
 597    TEST_AND_UPDATE(ctx->Light.Enabled, enable->Lighting, GL_LIGHTING);
 598    TEST_AND_UPDATE(ctx->Line.SmoothFlag, enable->LineSmooth, GL_LINE_SMOOTH);
 599    TEST_AND_UPDATE(ctx->Line.StippleFlag, enable->LineStipple,
 600                    GL_LINE_STIPPLE);
 601    TEST_AND_UPDATE(ctx->Color.IndexLogicOpEnabled, enable->IndexLogicOp,
 602                    GL_INDEX_LOGIC_OP);
 603    TEST_AND_UPDATE(ctx->Color.ColorLogicOpEnabled, enable->ColorLogicOp,
 604                    GL_COLOR_LOGIC_OP);
 605
 606    TEST_AND_UPDATE(ctx->Eval.Map1Color4, enable->Map1Color4, GL_MAP1_COLOR_4);
 607    TEST_AND_UPDATE(ctx->Eval.Map1Index, enable->Map1Index, GL_MAP1_INDEX);
 608    TEST_AND_UPDATE(ctx->Eval.Map1Normal, enable->Map1Normal, GL_MAP1_NORMAL);
 609    TEST_AND_UPDATE(ctx->Eval.Map1TextureCoord1, enable->Map1TextureCoord1,
 610                    GL_MAP1_TEXTURE_COORD_1);
 611    TEST_AND_UPDATE(ctx->Eval.Map1TextureCoord2, enable->Map1TextureCoord2,
 612                    GL_MAP1_TEXTURE_COORD_2);
 613    TEST_AND_UPDATE(ctx->Eval.Map1TextureCoord3, enable->Map1TextureCoord3,
 614                    GL_MAP1_TEXTURE_COORD_3);
 615    TEST_AND_UPDATE(ctx->Eval.Map1TextureCoord4, enable->Map1TextureCoord4,
 616                    GL_MAP1_TEXTURE_COORD_4);
 617    TEST_AND_UPDATE(ctx->Eval.Map1Vertex3, enable->Map1Vertex3,
 618                    GL_MAP1_VERTEX_3);
 619    TEST_AND_UPDATE(ctx->Eval.Map1Vertex4, enable->Map1Vertex4,
 620                    GL_MAP1_VERTEX_4);
 621
 622    TEST_AND_UPDATE(ctx->Eval.Map2Color4, enable->Map2Color4, GL_MAP2_COLOR_4);
 623    TEST_AND_UPDATE(ctx->Eval.Map2Index, enable->Map2Index, GL_MAP2_INDEX);
 624    TEST_AND_UPDATE(ctx->Eval.Map2Normal, enable->Map2Normal, GL_MAP2_NORMAL);
 625    TEST_AND_UPDATE(ctx->Eval.Map2TextureCoord1, enable->Map2TextureCoord1,
 626                    GL_MAP2_TEXTURE_COORD_1);
 627    TEST_AND_UPDATE(ctx->Eval.Map2TextureCoord2, enable->Map2TextureCoord2,
 628                    GL_MAP2_TEXTURE_COORD_2);
 629    TEST_AND_UPDATE(ctx->Eval.Map2TextureCoord3, enable->Map2TextureCoord3,
 630                    GL_MAP2_TEXTURE_COORD_3);
 631    TEST_AND_UPDATE(ctx->Eval.Map2TextureCoord4, enable->Map2TextureCoord4,
 632                    GL_MAP2_TEXTURE_COORD_4);
 633    TEST_AND_UPDATE(ctx->Eval.Map2Vertex3, enable->Map2Vertex3,
 634                    GL_MAP2_VERTEX_3);
 635    TEST_AND_UPDATE(ctx->Eval.Map2Vertex4, enable->Map2Vertex4,
 636                    GL_MAP2_VERTEX_4);
 637
 638    TEST_AND_UPDATE(ctx->Eval.AutoNormal, enable->AutoNormal, GL_AUTO_NORMAL);
 639    TEST_AND_UPDATE(ctx->Transform.Normalize, enable->Normalize, GL_NORMALIZE);
 640    TEST_AND_UPDATE(ctx->Transform.RescaleNormals, enable->RescaleNormals,
 641                    GL_RESCALE_NORMAL_EXT);
 642    TEST_AND_UPDATE(ctx->Transform.RasterPositionUnclipped,
 643                    enable->RasterPositionUnclipped,
 644                    GL_RASTER_POSITION_UNCLIPPED_IBM);
 645    TEST_AND_UPDATE(ctx->Point.SmoothFlag, enable->PointSmooth,
 646                    GL_POINT_SMOOTH);
 647    if (ctx->Extensions.NV_point_sprite || ctx->Extensions.ARB_point_sprite) {
 648       TEST_AND_UPDATE(ctx->Point.PointSprite, enable->PointSprite,
 649                       GL_POINT_SPRITE_NV);
 650    }
 651    TEST_AND_UPDATE(ctx->Polygon.OffsetPoint, enable->PolygonOffsetPoint,
 652                    GL_POLYGON_OFFSET_POINT);
 653    TEST_AND_UPDATE(ctx->Polygon.OffsetLine, enable->PolygonOffsetLine,
 654                    GL_POLYGON_OFFSET_LINE);
 655    TEST_AND_UPDATE(ctx->Polygon.OffsetFill, enable->PolygonOffsetFill,
 656                    GL_POLYGON_OFFSET_FILL);
 657    TEST_AND_UPDATE(ctx->Polygon.SmoothFlag, enable->PolygonSmooth,
 658                    GL_POLYGON_SMOOTH);
 659    TEST_AND_UPDATE(ctx->Polygon.StippleFlag, enable->PolygonStipple,
 660                    GL_POLYGON_STIPPLE);
 661    if (ctx->Scissor.EnableFlags != enable->Scissor) {
 662       unsigned i;
 663
 664       for (i = 0; i < ctx->Const.MaxViewports; i++) {
 665          _mesa_set_enablei(ctx, GL_SCISSOR_TEST, i, (enable->Scissor >> i) & 1);
 666       }
 667    }
 668    TEST_AND_UPDATE(ctx->Stencil.Enabled, enable->Stencil, GL_STENCIL_TEST);
 669    if (ctx->Extensions.EXT_stencil_two_side) {
 670       TEST_AND_UPDATE(ctx->Stencil.TestTwoSide, enable->StencilTwoSide, GL_STENCIL_TEST_TWO_SIDE_EXT);
 671    }
 672    TEST_AND_UPDATE(ctx->Multisample.Enabled, enable->MultisampleEnabled,
 673                    GL_MULTISAMPLE_ARB);
 674    TEST_AND_UPDATE(ctx->Multisample.SampleAlphaToCoverage,
 675                    enable->SampleAlphaToCoverage,
 676                    GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
 677    TEST_AND_UPDATE(ctx->Multisample.SampleAlphaToOne,
 678                    enable->SampleAlphaToOne,
 679                    GL_SAMPLE_ALPHA_TO_ONE_ARB);
 680    TEST_AND_UPDATE(ctx->Multisample.SampleCoverage,
 681                    enable->SampleCoverage,
 682                    GL_SAMPLE_COVERAGE_ARB);
 683    /* GL_ARB_vertex_program */
 684    TEST_AND_UPDATE(ctx->VertexProgram.Enabled,
 685                    enable->VertexProgram,
 686                    GL_VERTEX_PROGRAM_ARB);
 687    TEST_AND_UPDATE(ctx->VertexProgram.PointSizeEnabled,
 688                    enable->VertexProgramPointSize,
 689                    GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
 690    TEST_AND_UPDATE(ctx->VertexProgram.TwoSideEnabled,
 691                    enable->VertexProgramTwoSide,
 692                    GL_VERTEX_PROGRAM_TWO_SIDE_ARB);
 693
 694    /* GL_ARB_fragment_program */
 695    TEST_AND_UPDATE(ctx->FragmentProgram.Enabled,
 696                    enable->FragmentProgram,
 697                    GL_FRAGMENT_PROGRAM_ARB);
 698
 699    /* GL_ARB_framebuffer_sRGB / GL_EXT_framebuffer_sRGB */
 700    TEST_AND_UPDATE(ctx->Color.sRGBEnabled, enable->sRGBEnabled,
 701                    GL_FRAMEBUFFER_SRGB);
 702
 703    /* texture unit enables */
 704    for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
 705       const GLbitfield enabled = enable->Texture[i];
 706       const GLbitfield genEnabled = enable->TexGen[i];
 707
 708       if (ctx->Texture.Unit[i].Enabled != enabled) {
 709          _mesa_ActiveTexture(GL_TEXTURE0 + i);
 710
 711          _mesa_set_enable(ctx, GL_TEXTURE_1D, !!(enabled & TEXTURE_1D_BIT));
 712          _mesa_set_enable(ctx, GL_TEXTURE_2D, !!(enabled & TEXTURE_2D_BIT));
 713          _mesa_set_enable(ctx, GL_TEXTURE_3D, !!(enabled & TEXTURE_3D_BIT));
 714          if (ctx->Extensions.NV_texture_rectangle) {
 715             _mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE_ARB,
 716                              !!(enabled & TEXTURE_RECT_BIT));
 717          }
 718          if (ctx->Extensions.ARB_texture_cube_map) {
 719             _mesa_set_enable(ctx, GL_TEXTURE_CUBE_MAP,
 720                              !!(enabled & TEXTURE_CUBE_BIT));
 721          }
 722       }
 723
 724       if (ctx->Texture.Unit[i].TexGenEnabled != genEnabled) {
 725          _mesa_ActiveTexture(GL_TEXTURE0 + i);
 726          _mesa_set_enable(ctx, GL_TEXTURE_GEN_S, !!(genEnabled & S_BIT));
 727          _mesa_set_enable(ctx, GL_TEXTURE_GEN_T, !!(genEnabled & T_BIT));
 728          _mesa_set_enable(ctx, GL_TEXTURE_GEN_R, !!(genEnabled & R_BIT));
 729          _mesa_set_enable(ctx, GL_TEXTURE_GEN_Q, !!(genEnabled & Q_BIT));
 730       }
 731    }
 732
 733    _mesa_ActiveTexture(GL_TEXTURE0 + curTexUnitSave);
 734 }
 735
 736
 737 /**
 738  * Pop/restore texture attribute/group state.
 739  */
 740 static void
 741 pop_texture_group(struct gl_context *ctx, struct texture_state *texstate)
 742 {
 743    GLuint u;
 744
 745    _mesa_lock_context_textures(ctx);
 746
 747    for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
 748       const struct gl_texture_unit *unit = &texstate->Texture.Unit[u];
 749       GLuint tgt;
 750
 751       _mesa_ActiveTexture(GL_TEXTURE0_ARB + u);
 752       _mesa_set_enable(ctx, GL_TEXTURE_1D, !!(unit->Enabled & TEXTURE_1D_BIT));
 753       _mesa_set_enable(ctx, GL_TEXTURE_2D, !!(unit->Enabled & TEXTURE_2D_BIT));
 754       _mesa_set_enable(ctx, GL_TEXTURE_3D, !!(unit->Enabled & TEXTURE_3D_BIT));
 755       if (ctx->Extensions.ARB_texture_cube_map) {
 756          _mesa_set_enable(ctx, GL_TEXTURE_CUBE_MAP_ARB,
 757                           !!(unit->Enabled & TEXTURE_CUBE_BIT));
 758       }
 759       if (ctx->Extensions.NV_texture_rectangle) {
 760          _mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE_NV,
 761                           !!(unit->Enabled & TEXTURE_RECT_BIT));
 762       }
 763       _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->EnvMode);
 764       _mesa_TexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, unit->EnvColor);
 765       _mesa_TexGeni(GL_S, GL_TEXTURE_GEN_MODE, unit->GenS.Mode);
 766       _mesa_TexGeni(GL_T, GL_TEXTURE_GEN_MODE, unit->GenT.Mode);
 767       _mesa_TexGeni(GL_R, GL_TEXTURE_GEN_MODE, unit->GenR.Mode);
 768       _mesa_TexGeni(GL_Q, GL_TEXTURE_GEN_MODE, unit->GenQ.Mode);
 769       _mesa_TexGenfv(GL_S, GL_OBJECT_PLANE, unit->GenS.ObjectPlane);
 770       _mesa_TexGenfv(GL_T, GL_OBJECT_PLANE, unit->GenT.ObjectPlane);
 771       _mesa_TexGenfv(GL_R, GL_OBJECT_PLANE, unit->GenR.ObjectPlane);
 772       _mesa_TexGenfv(GL_Q, GL_OBJECT_PLANE, unit->GenQ.ObjectPlane);
 773       /* Eye plane done differently to avoid re-transformation */
 774       {
 775          struct gl_texture_unit *destUnit = &ctx->Texture.Unit[u];
 776          COPY_4FV(destUnit->GenS.EyePlane, unit->GenS.EyePlane);
 777          COPY_4FV(destUnit->GenT.EyePlane, unit->GenT.EyePlane);
 778          COPY_4FV(destUnit->GenR.EyePlane, unit->GenR.EyePlane);
 779          COPY_4FV(destUnit->GenQ.EyePlane, unit->GenQ.EyePlane);
 780          if (ctx->Driver.TexGen) {
 781             ctx->Driver.TexGen(ctx, GL_S, GL_EYE_PLANE, unit->GenS.EyePlane);
 782             ctx->Driver.TexGen(ctx, GL_T, GL_EYE_PLANE, unit->GenT.EyePlane);
 783             ctx->Driver.TexGen(ctx, GL_R, GL_EYE_PLANE, unit->GenR.EyePlane);
 784             ctx->Driver.TexGen(ctx, GL_Q, GL_EYE_PLANE, unit->GenQ.EyePlane);
 785          }
 786       }
 787       _mesa_set_enable(ctx, GL_TEXTURE_GEN_S, !!(unit->TexGenEnabled & S_BIT));
 788       _mesa_set_enable(ctx, GL_TEXTURE_GEN_T, !!(unit->TexGenEnabled & T_BIT));
 789       _mesa_set_enable(ctx, GL_TEXTURE_GEN_R, !!(unit->TexGenEnabled & R_BIT));
 790       _mesa_set_enable(ctx, GL_TEXTURE_GEN_Q, !!(unit->TexGenEnabled & Q_BIT));
 791       _mesa_TexEnvf(GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS,
 792                     unit->LodBias);
 793       _mesa_TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,
 794                     unit->Combine.ModeRGB);
 795       _mesa_TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA,
 796                     unit->Combine.ModeA);
 797       {
 798          const GLuint n = ctx->Extensions.NV_texture_env_combine4 ? 4 : 3;
 799          GLuint i;
 800          for (i = 0; i < n; i++) {
 801             _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB + i,
 802                           unit->Combine.SourceRGB[i]);
 803             _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA + i,
 804                           unit->Combine.SourceA[i]);
 805             _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB + i,
 806                           unit->Combine.OperandRGB[i]);
 807             _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA + i,
 808                           unit->Combine.OperandA[i]);
 809          }
 810       }
 811       _mesa_TexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE,
 812                     1 << unit->Combine.ScaleShiftRGB);
 813       _mesa_TexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE,
 814                     1 << unit->Combine.ScaleShiftA);
 815
 816       /* Restore texture object state for each target */
 817       for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
 818          const struct gl_texture_object *obj = NULL;
 819          const struct gl_sampler_object *samp;
 820          GLenum target;
 821
 822          obj = &texstate->SavedObj[u][tgt];
 823
 824          /* don't restore state for unsupported targets to prevent
 825           * raising GL errors.
 826           */
 827          if (obj->Target == GL_TEXTURE_CUBE_MAP_ARB &&
 828              !ctx->Extensions.ARB_texture_cube_map) {
 829             continue;
 830          }
 831          else if (obj->Target == GL_TEXTURE_RECTANGLE_NV &&
 832                   !ctx->Extensions.NV_texture_rectangle) {
 833             continue;
 834          }
 835          else if ((obj->Target == GL_TEXTURE_1D_ARRAY_EXT ||
 836                    obj->Target == GL_TEXTURE_2D_ARRAY_EXT) &&
 837                   !ctx->Extensions.EXT_texture_array) {
 838             continue;
 839          }
 840          else if (obj->Target == GL_TEXTURE_CUBE_MAP_ARRAY &&
 841              !ctx->Extensions.ARB_texture_cube_map_array) {
 842             continue;
 843          } else if (obj->Target == GL_TEXTURE_BUFFER)
 844             continue;
 845          else if (obj->Target == GL_TEXTURE_EXTERNAL_OES)
 846             continue;
 847          else if (obj->Target == GL_TEXTURE_2D_MULTISAMPLE ||
 848                   obj->Target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
 849             continue;
 850
 851          target = obj->Target;
 852
 853          _mesa_BindTexture(target, obj->Name);
 854
 855          samp = &obj->Sampler;
 856
 857          _mesa_TexParameterfv(target, GL_TEXTURE_BORDER_COLOR, samp->BorderColor.f);
 858          _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, samp->WrapS);
 859          _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, samp->WrapT);
 860          _mesa_TexParameteri(target, GL_TEXTURE_WRAP_R, samp->WrapR);
 861          _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, samp->MinFilter);
 862          _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, samp->MagFilter);
 863          _mesa_TexParameterf(target, GL_TEXTURE_MIN_LOD, samp->MinLod);
 864          _mesa_TexParameterf(target, GL_TEXTURE_MAX_LOD, samp->MaxLod);
 865          _mesa_TexParameterf(target, GL_TEXTURE_LOD_BIAS, samp->LodBias);
 866          _mesa_TexParameterf(target, GL_TEXTURE_PRIORITY, obj->Priority);
 867          _mesa_TexParameteri(target, GL_TEXTURE_BASE_LEVEL, obj->BaseLevel);
 868          if (target != GL_TEXTURE_RECTANGLE_ARB)
 869             _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, obj->MaxLevel);
 870          if (ctx->Extensions.EXT_texture_filter_anisotropic) {
 871             _mesa_TexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT,
 872                                 samp->MaxAnisotropy);
 873          }
 874          if (ctx->Extensions.ARB_shadow) {
 875             _mesa_TexParameteri(target, GL_TEXTURE_COMPARE_MODE,
 876                                 samp->CompareMode);
 877             _mesa_TexParameteri(target, GL_TEXTURE_COMPARE_FUNC,
 878                                 samp->CompareFunc);
 879          }
 880          if (ctx->Extensions.ARB_depth_texture)
 881             _mesa_TexParameteri(target, GL_DEPTH_TEXTURE_MODE, obj->DepthMode);
 882       }
 883
 884       /* remove saved references to the texture objects */
 885       for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
 886          _mesa_reference_texobj(&texstate->SavedTexRef[u][tgt], NULL);
 887       }
 888    }
 889
 890    _mesa_ActiveTexture(GL_TEXTURE0_ARB + texstate->Texture.CurrentUnit);
 891
 892    _mesa_reference_shared_state(ctx, &texstate->SharedRef, NULL);
 893
 894    _mesa_unlock_context_textures(ctx);
 895 }
 896
 897
 898 /*
 899  * This function is kind of long just because we have to call a lot
 900  * of device driver functions to update device driver state.
 901  *
 902  * XXX As it is now, most of the pop-code calls immediate-mode Mesa functions
 903  * in order to restore GL state.  This isn't terribly efficient but it
 904  * ensures that dirty flags and any derived state gets updated correctly.
 905  * We could at least check if the value to restore equals the current value
 906  * and then skip the Mesa call.
 907  */
 908 void GLAPIENTRY
 909 _mesa_PopAttrib(void)
 910 {
 911    struct gl_attrib_node *attr, *next;
 912    GET_CURRENT_CONTEXT(ctx);
 913    FLUSH_VERTICES(ctx, 0);
 914
 915    if (ctx->AttribStackDepth == 0) {
 916       _mesa_error( ctx, GL_STACK_UNDERFLOW, "glPopAttrib" );
 917       return;
 918    }
 919
 920    ctx->AttribStackDepth--;
 921    attr = ctx->AttribStack[ctx->AttribStackDepth];
 922
 923    while (attr) {
 924
 925       if (MESA_VERBOSE & VERBOSE_API) {
 926          _mesa_debug(ctx, "glPopAttrib %s\n",
 927                      _mesa_lookup_enum_by_nr(attr->kind));
 928       }
 929
 930       switch (attr->kind) {
 931          case GL_ACCUM_BUFFER_BIT:
 932             {
 933                const struct gl_accum_attrib *accum;
 934                accum = (const struct gl_accum_attrib *) attr->data;
 935                _mesa_ClearAccum(accum->ClearColor[0],
 936                                 accum->ClearColor[1],
 937                                 accum->ClearColor[2],
 938                                 accum->ClearColor[3]);
 939             }
 940             break;
 941          case GL_COLOR_BUFFER_BIT:
 942             {
 943                const struct gl_colorbuffer_attrib *color;
 944
 945                color = (const struct gl_colorbuffer_attrib *) attr->data;
 946                _mesa_ClearIndex((GLfloat) color->ClearIndex);
 947                _mesa_ClearColor(color->ClearColor.f[0],
 948                                 color->ClearColor.f[1],
 949                                 color->ClearColor.f[2],
 950                                 color->ClearColor.f[3]);
 951                _mesa_IndexMask(color->IndexMask);
 952                if (!ctx->Extensions.EXT_draw_buffers2) {
 953                   _mesa_ColorMask((GLboolean) (color->ColorMask[0][0] != 0),
 954                                   (GLboolean) (color->ColorMask[0][1] != 0),
 955                                   (GLboolean) (color->ColorMask[0][2] != 0),
 956                                   (GLboolean) (color->ColorMask[0][3] != 0));
 957                }
 958                else {
 959                   GLuint i;
 960                   for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
 961                      _mesa_ColorMaski(i,
 962                                   (GLboolean) (color->ColorMask[i][0] != 0),
 963                                   (GLboolean) (color->ColorMask[i][1] != 0),
 964                                   (GLboolean) (color->ColorMask[i][2] != 0),
 965                                   (GLboolean) (color->ColorMask[i][3] != 0));
 966                   }
 967                }
 968                {
 969                   /* Need to determine if more than one color output is
 970                    * specified.  If so, call glDrawBuffersARB, else call
 971                    * glDrawBuffer().  This is a subtle, but essential point
 972                    * since GL_FRONT (for example) is illegal for the former
 973                    * function, but legal for the later.
 974                    */
 975                   GLboolean multipleBuffers = GL_FALSE;
 976                   GLuint i;
 977
 978                   for (i = 1; i < ctx->Const.MaxDrawBuffers; i++) {
 979                      if (color->DrawBuffer[i] != GL_NONE) {
 980                         multipleBuffers = GL_TRUE;
 981                         break;
 982                      }
 983                   }
 984                   /* Call the API_level functions, not _mesa_drawbuffers()
 985                    * since we need to do error checking on the pop'd
 986                    * GL_DRAW_BUFFER.
 987                    * Ex: if GL_FRONT were pushed, but we're popping with a
 988                    * user FBO bound, GL_FRONT will be illegal and we'll need
 989                    * to record that error.  Per OpenGL ARB decision.
 990                    */
 991                   if (multipleBuffers)
 992                      _mesa_DrawBuffers(ctx->Const.MaxDrawBuffers,
 993                                           color->DrawBuffer);
 994                   else
 995                      _mesa_DrawBuffer(color->DrawBuffer[0]);
 996                }
 997                _mesa_set_enable(ctx, GL_ALPHA_TEST, color->AlphaEnabled);
 998                _mesa_AlphaFunc(color->AlphaFunc, color->AlphaRefUnclamped);
 999                if (ctx->Color.BlendEnabled != color->BlendEnabled) {
1000                   if (ctx->Extensions.EXT_draw_buffers2) {
1001                      GLuint i;
1002                      for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
1003                         _mesa_set_enablei(ctx, GL_BLEND, i,
1004                                           (color->BlendEnabled >> i) & 1);
1005                      }
1006                   }
1007                   else {
1008                      _mesa_set_enable(ctx, GL_BLEND, (color->BlendEnabled & 1));
1009                   }
1010                }
1011                if (ctx->Color._BlendFuncPerBuffer ||
1012                    ctx->Color._BlendEquationPerBuffer) {
1013                   /* set blend per buffer */
1014                   GLuint buf;
1015                   for (buf = 0; buf < ctx->Const.MaxDrawBuffers; buf++) {
1016                      _mesa_BlendFuncSeparateiARB(buf, color->Blend[buf].SrcRGB,
1017                                               color->Blend[buf].DstRGB,
1018                                               color->Blend[buf].SrcA,
1019                                               color->Blend[buf].DstA);
1020                      _mesa_BlendEquationSeparateiARB(buf,
1021                                                   color->Blend[buf].EquationRGB,
1022                                                   color->Blend[buf].EquationA);
1023                   }
1024                }
1025                else {
1026                   /* set same blend modes for all buffers */
1027                   _mesa_BlendFuncSeparate(color->Blend[0].SrcRGB,
1028                                              color->Blend[0].DstRGB,
1029                                              color->Blend[0].SrcA,
1030                                              color->Blend[0].DstA);
1031                   /* This special case is because glBlendEquationSeparateEXT
1032                    * cannot take GL_LOGIC_OP as a parameter.
1033                    */
1034                   if (color->Blend[0].EquationRGB ==
1035                       color->Blend[0].EquationA) {
1036                      _mesa_BlendEquation(color->Blend[0].EquationRGB);
1037                   }
1038                   else {
1039                      _mesa_BlendEquationSeparate(
1040                                                  color->Blend[0].EquationRGB,
1041                                                  color->Blend[0].EquationA);
1042                   }
1043                }
1044                _mesa_BlendColor(color->BlendColorUnclamped[0],
1045                                 color->BlendColorUnclamped[1],
1046                                 color->BlendColorUnclamped[2],
1047                                 color->BlendColorUnclamped[3]);
1048                _mesa_LogicOp(color->LogicOp);
1049                _mesa_set_enable(ctx, GL_COLOR_LOGIC_OP,
1050                                 color->ColorLogicOpEnabled);
1051                _mesa_set_enable(ctx, GL_INDEX_LOGIC_OP,
1052                                 color->IndexLogicOpEnabled);
1053                _mesa_set_enable(ctx, GL_DITHER, color->DitherFlag);
1054                if (ctx->Extensions.ARB_color_buffer_float)
1055                   _mesa_ClampColor(GL_CLAMP_FRAGMENT_COLOR_ARB,
1056                                    color->ClampFragmentColor);
1057                _mesa_ClampColor(GL_CLAMP_READ_COLOR_ARB, color->ClampReadColor);
1058
1059                /* GL_ARB_framebuffer_sRGB / GL_EXT_framebuffer_sRGB */
1060                if (ctx->Extensions.EXT_framebuffer_sRGB)
1061                   _mesa_set_enable(ctx, GL_FRAMEBUFFER_SRGB, color->sRGBEnabled);
1062             }
1063             break;
1064          case GL_CURRENT_BIT:
1065             FLUSH_CURRENT( ctx, 0 );
1066             memcpy( &ctx->Current, attr->data,
1067                     sizeof(struct gl_current_attrib) );
1068             break;
1069          case GL_DEPTH_BUFFER_BIT:
1070             {
1071                const struct gl_depthbuffer_attrib *depth;
1072                depth = (const struct gl_depthbuffer_attrib *) attr->data;
1073                _mesa_DepthFunc(depth->Func);
1074                _mesa_ClearDepth(depth->Clear);
1075                _mesa_set_enable(ctx, GL_DEPTH_TEST, depth->Test);
1076                _mesa_DepthMask(depth->Mask);
1077             }
1078             break;
1079          case GL_ENABLE_BIT:
1080             {
1081                const struct gl_enable_attrib *enable;
1082                enable = (const struct gl_enable_attrib *) attr->data;
1083                pop_enable_group(ctx, enable);
1084                ctx->NewState |= _NEW_ALL;
1085             }
1086             break;
1087          case GL_EVAL_BIT:
1088             memcpy( &ctx->Eval, attr->data, sizeof(struct gl_eval_attrib) );
1089             ctx->NewState |= _NEW_EVAL;
1090             break;
1091          case GL_FOG_BIT:
1092             {
1093                const struct gl_fog_attrib *fog;
1094                fog = (const struct gl_fog_attrib *) attr->data;
1095                _mesa_set_enable(ctx, GL_FOG, fog->Enabled);
1096                _mesa_Fogfv(GL_FOG_COLOR, fog->Color);
1097                _mesa_Fogf(GL_FOG_DENSITY, fog->Density);
1098                _mesa_Fogf(GL_FOG_START, fog->Start);
1099                _mesa_Fogf(GL_FOG_END, fog->End);
1100                _mesa_Fogf(GL_FOG_INDEX, fog->Index);
1101                _mesa_Fogi(GL_FOG_MODE, fog->Mode);
1102             }
1103             break;
1104          case GL_HINT_BIT:
1105             {
1106                const struct gl_hint_attrib *hint;
1107                hint = (const struct gl_hint_attrib *) attr->data;
1108                _mesa_Hint(GL_PERSPECTIVE_CORRECTION_HINT,
1109                           hint->PerspectiveCorrection );
1110                _mesa_Hint(GL_POINT_SMOOTH_HINT, hint->PointSmooth);
1111                _mesa_Hint(GL_LINE_SMOOTH_HINT, hint->LineSmooth);
1112                _mesa_Hint(GL_POLYGON_SMOOTH_HINT, hint->PolygonSmooth);
1113                _mesa_Hint(GL_FOG_HINT, hint->Fog);
1114                _mesa_Hint(GL_TEXTURE_COMPRESSION_HINT_ARB,
1115                           hint->TextureCompression);
1116             }
1117             break;
1118          case GL_LIGHTING_BIT:
1119             {
1120                GLuint i;
1121                const struct gl_light_attrib *light;
1122                light = (const struct gl_light_attrib *) attr->data;
1123                /* lighting enable */
1124                _mesa_set_enable(ctx, GL_LIGHTING, light->Enabled);
1125                /* per-light state */
1126                if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top))
1127                   _math_matrix_analyse( ctx->ModelviewMatrixStack.Top );
1128
1129                for (i = 0; i < ctx->Const.MaxLights; i++) {
1130                   const struct gl_light *l = &light->Light[i];
1131                   _mesa_set_enable(ctx, GL_LIGHT0 + i, l->Enabled);
1132                   _mesa_light(ctx, i, GL_AMBIENT, l->Ambient);
1133                   _mesa_light(ctx, i, GL_DIFFUSE, l->Diffuse);
1134                   _mesa_light(ctx, i, GL_SPECULAR, l->Specular );
1135                   _mesa_light(ctx, i, GL_POSITION, l->EyePosition);
1136                   _mesa_light(ctx, i, GL_SPOT_DIRECTION, l->SpotDirection);
1137                   {
1138                      GLfloat p[4] = { 0 };
1139                      p[0] = l->SpotExponent;
1140                      _mesa_light(ctx, i, GL_SPOT_EXPONENT, p);
1141                   }
1142                   {
1143                      GLfloat p[4] = { 0 };
1144                      p[0] = l->SpotCutoff;
1145                      _mesa_light(ctx, i, GL_SPOT_CUTOFF, p);
1146                   }
1147                   {
1148                      GLfloat p[4] = { 0 };
1149                      p[0] = l->ConstantAttenuation;
1150                      _mesa_light(ctx, i, GL_CONSTANT_ATTENUATION, p);
1151                   }
1152                   {
1153                      GLfloat p[4] = { 0 };
1154                      p[0] = l->LinearAttenuation;
1155                      _mesa_light(ctx, i, GL_LINEAR_ATTENUATION, p);
1156                   }
1157                   {
1158                      GLfloat p[4] = { 0 };
1159                      p[0] = l->QuadraticAttenuation;
1160                      _mesa_light(ctx, i, GL_QUADRATIC_ATTENUATION, p);
1161                   }
1162                }
1163                /* light model */
1164                _mesa_LightModelfv(GL_LIGHT_MODEL_AMBIENT,
1165                                   light->Model.Ambient);
1166                _mesa_LightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER,
1167                                  (GLfloat) light->Model.LocalViewer);
1168                _mesa_LightModelf(GL_LIGHT_MODEL_TWO_SIDE,
1169                                  (GLfloat) light->Model.TwoSide);
1170                _mesa_LightModelf(GL_LIGHT_MODEL_COLOR_CONTROL,
1171                                  (GLfloat) light->Model.ColorControl);
1172                /* shade model */
1173                _mesa_ShadeModel(light->ShadeModel);
1174                /* color material */
1175                _mesa_ColorMaterial(light->ColorMaterialFace,
1176                                    light->ColorMaterialMode);
1177                _mesa_set_enable(ctx, GL_COLOR_MATERIAL,
1178                                 light->ColorMaterialEnabled);
1179                /* materials */
1180                memcpy(&ctx->Light.Material, &light->Material,
1181                       sizeof(struct gl_material));
1182                if (ctx->Extensions.ARB_color_buffer_float) {
1183                   _mesa_ClampColor(GL_CLAMP_VERTEX_COLOR_ARB,
1184                                    light->ClampVertexColor);
1185                }
1186             }
1187             break;
1188          case GL_LINE_BIT:
1189             {
1190                const struct gl_line_attrib *line;
1191                line = (const struct gl_line_attrib *) attr->data;
1192                _mesa_set_enable(ctx, GL_LINE_SMOOTH, line->SmoothFlag);
1193                _mesa_set_enable(ctx, GL_LINE_STIPPLE, line->StippleFlag);
1194                _mesa_LineStipple(line->StippleFactor, line->StipplePattern);
1195                _mesa_LineWidth(line->Width);
1196             }
1197             break;
1198          case GL_LIST_BIT:
1199             memcpy( &ctx->List, attr->data, sizeof(struct gl_list_attrib) );
1200             break;
1201          case GL_PIXEL_MODE_BIT:
1202             memcpy( &ctx->Pixel, attr->data, sizeof(struct gl_pixel_attrib) );
1203             /* XXX what other pixel state needs to be set by function calls? */
1204             _mesa_ReadBuffer(ctx->Pixel.ReadBuffer);
1205             ctx->NewState |= _NEW_PIXEL;
1206             break;
1207          case GL_POINT_BIT:
1208             {
1209                const struct gl_point_attrib *point;
1210                point = (const struct gl_point_attrib *) attr->data;
1211                _mesa_PointSize(point->Size);
1212                _mesa_set_enable(ctx, GL_POINT_SMOOTH, point->SmoothFlag);
1213                if (ctx->Extensions.EXT_point_parameters) {
1214                   _mesa_PointParameterfv(GL_DISTANCE_ATTENUATION_EXT,
1215                                          point->Params);
1216                   _mesa_PointParameterf(GL_POINT_SIZE_MIN_EXT,
1217                                         point->MinSize);
1218                   _mesa_PointParameterf(GL_POINT_SIZE_MAX_EXT,
1219                                         point->MaxSize);
1220                   _mesa_PointParameterf(GL_POINT_FADE_THRESHOLD_SIZE_EXT,
1221                                         point->Threshold);
1222                }
1223                if (ctx->Extensions.NV_point_sprite
1224                    || ctx->Extensions.ARB_point_sprite) {
1225                   GLuint u;
1226                   for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
1227                      _mesa_TexEnvi(GL_POINT_SPRITE_NV, GL_COORD_REPLACE_NV,
1228                                    (GLint) point->CoordReplace[u]);
1229                   }
1230                   _mesa_set_enable(ctx, GL_POINT_SPRITE_NV,point->PointSprite);
1231                   if (ctx->Extensions.NV_point_sprite)
1232                      _mesa_PointParameteri(GL_POINT_SPRITE_R_MODE_NV,
1233                                            ctx->Point.SpriteRMode);
1234
1235                   if ((ctx->API == API_OPENGL_COMPAT && ctx->Version >= 20)
1236                       || ctx->API == API_OPENGL_CORE)
1237                      _mesa_PointParameterf(GL_POINT_SPRITE_COORD_ORIGIN,
1238                                            (GLfloat)ctx->Point.SpriteOrigin);
1239                }
1240             }
1241             break;
1242          case GL_POLYGON_BIT:
1243             {
1244                const struct gl_polygon_attrib *polygon;
1245                polygon = (const struct gl_polygon_attrib *) attr->data;
1246                _mesa_CullFace(polygon->CullFaceMode);
1247                _mesa_FrontFace(polygon->FrontFace);
1248                _mesa_PolygonMode(GL_FRONT, polygon->FrontMode);
1249                _mesa_PolygonMode(GL_BACK, polygon->BackMode);
1250                _mesa_PolygonOffset(polygon->OffsetFactor,
1251                                    polygon->OffsetUnits);
1252                _mesa_set_enable(ctx, GL_POLYGON_SMOOTH, polygon->SmoothFlag);
1253                _mesa_set_enable(ctx, GL_POLYGON_STIPPLE, polygon->StippleFlag);
1254                _mesa_set_enable(ctx, GL_CULL_FACE, polygon->CullFlag);
1255                _mesa_set_enable(ctx, GL_POLYGON_OFFSET_POINT,
1256                                 polygon->OffsetPoint);
1257                _mesa_set_enable(ctx, GL_POLYGON_OFFSET_LINE,
1258                                 polygon->OffsetLine);
1259                _mesa_set_enable(ctx, GL_POLYGON_OFFSET_FILL,
1260                                 polygon->OffsetFill);
1261             }
1262             break;
1263          case GL_POLYGON_STIPPLE_BIT:
1264             memcpy( ctx->PolygonStipple, attr->data, 32*sizeof(GLuint) );
1265             ctx->NewState |= _NEW_POLYGONSTIPPLE;
1266             if (ctx->Driver.PolygonStipple)
1267                ctx->Driver.PolygonStipple( ctx, (const GLubyte *) attr->data );
1268             break;
1269          case GL_SCISSOR_BIT:
1270             {
1271                const struct gl_scissor_attrib *scissor;
1272                scissor = (const struct gl_scissor_attrib *) attr->data;
1273                _mesa_set_scissor(ctx,
1274                                  scissor->ScissorArray[0].X,
1275                                  scissor->ScissorArray[0].Y,
1276                                  scissor->ScissorArray[0].Width,
1277                                  scissor->ScissorArray[0].Height);
1278                _mesa_set_enable(ctx, GL_SCISSOR_TEST, scissor->EnableFlags & 1);
1279
1280             }
1281             break;
1282          case GL_STENCIL_BUFFER_BIT:
1283             {
1284                const struct gl_stencil_attrib *stencil;
1285                stencil = (const struct gl_stencil_attrib *) attr->data;
1286                _mesa_set_enable(ctx, GL_STENCIL_TEST, stencil->Enabled);
1287                _mesa_ClearStencil(stencil->Clear);
1288                if (ctx->Extensions.EXT_stencil_two_side) {
1289                   _mesa_set_enable(ctx, GL_STENCIL_TEST_TWO_SIDE_EXT,
1290                                    stencil->TestTwoSide);
1291                   _mesa_ActiveStencilFaceEXT(stencil->ActiveFace
1292                                              ? GL_BACK : GL_FRONT);
1293                }
1294                /* front state */
1295                _mesa_StencilFuncSeparate(GL_FRONT,
1296                                          stencil->Function[0],
1297                                          stencil->Ref[0],
1298                                          stencil->ValueMask[0]);
1299                _mesa_StencilMaskSeparate(GL_FRONT, stencil->WriteMask[0]);
1300                _mesa_StencilOpSeparate(GL_FRONT, stencil->FailFunc[0],
1301                                        stencil->ZFailFunc[0],
1302                                        stencil->ZPassFunc[0]);
1303                /* back state */
1304                _mesa_StencilFuncSeparate(GL_BACK,
1305                                          stencil->Function[1],
1306                                          stencil->Ref[1],
1307                                          stencil->ValueMask[1]);
1308                _mesa_StencilMaskSeparate(GL_BACK, stencil->WriteMask[1]);
1309                _mesa_StencilOpSeparate(GL_BACK, stencil->FailFunc[1],
1310                                        stencil->ZFailFunc[1],
1311                                        stencil->ZPassFunc[1]);
1312             }
1313             break;
1314          case GL_TRANSFORM_BIT:
1315             {
1316                GLuint i;
1317                const struct gl_transform_attrib *xform;
1318                xform = (const struct gl_transform_attrib *) attr->data;
1319                _mesa_MatrixMode(xform->MatrixMode);
1320                if (_math_matrix_is_dirty(ctx->ProjectionMatrixStack.Top))
1321                   _math_matrix_analyse( ctx->ProjectionMatrixStack.Top );
1322
1323                /* restore clip planes */
1324                for (i = 0; i < ctx->Const.MaxClipPlanes; i++) {
1325                   const GLuint mask = 1 << i;
1326                   const GLfloat *eyePlane = xform->EyeUserPlane[i];
1327                   COPY_4V(ctx->Transform.EyeUserPlane[i], eyePlane);
1328                   _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i,
1329                                    !!(xform->ClipPlanesEnabled & mask));
1330                   if (ctx->Driver.ClipPlane)
1331                      ctx->Driver.ClipPlane( ctx, GL_CLIP_PLANE0 + i, eyePlane );
1332                }
1333
1334                /* normalize/rescale */
1335                if (xform->Normalize != ctx->Transform.Normalize)
1336                   _mesa_set_enable(ctx, GL_NORMALIZE,ctx->Transform.Normalize);
1337                if (xform->RescaleNormals != ctx->Transform.RescaleNormals)
1338                   _mesa_set_enable(ctx, GL_RESCALE_NORMAL_EXT,
1339                                    ctx->Transform.RescaleNormals);
1340                if (xform->DepthClamp != ctx->Transform.DepthClamp)
1341                   _mesa_set_enable(ctx, GL_DEPTH_CLAMP,
1342                                    ctx->Transform.DepthClamp);
1343             }
1344             break;
1345          case GL_TEXTURE_BIT:
1346             {
1347                struct texture_state *texstate
1348                   = (struct texture_state *) attr->data;
1349                pop_texture_group(ctx, texstate);
1350                ctx->NewState |= _NEW_TEXTURE;
1351             }
1352             break;
1353          case GL_VIEWPORT_BIT:
1354             {
1355                const struct gl_viewport_attrib *vp;
1356                vp = (const struct gl_viewport_attrib *) attr->data;
1357                _mesa_Viewport(vp->X, vp->Y, vp->Width, vp->Height);
1358                _mesa_DepthRange(vp->Near, vp->Far);
1359             }
1360             break;
1361          case GL_MULTISAMPLE_BIT_ARB:
1362             {
1363                const struct gl_multisample_attrib *ms;
1364                ms = (const struct gl_multisample_attrib *) attr->data;
1365
1366                TEST_AND_UPDATE(ctx->Multisample.Enabled,
1367                                ms->Enabled,
1368                                GL_MULTISAMPLE);
1369
1370                TEST_AND_UPDATE(ctx->Multisample.SampleCoverage,
1371                                ms->SampleCoverage,
1372                                GL_SAMPLE_COVERAGE);
1373
1374                TEST_AND_UPDATE(ctx->Multisample.SampleAlphaToCoverage,
1375                                ms->SampleAlphaToCoverage,
1376                                GL_SAMPLE_ALPHA_TO_COVERAGE);
1377
1378                TEST_AND_UPDATE(ctx->Multisample.SampleAlphaToOne,
1379                                ms->SampleAlphaToOne,
1380                                GL_SAMPLE_ALPHA_TO_ONE);
1381
1382                _mesa_SampleCoverage(ms->SampleCoverageValue,
1383                                        ms->SampleCoverageInvert);
1384             }
1385             break;
1386
1387          default:
1388             _mesa_problem( ctx, "Bad attrib flag in PopAttrib");
1389             break;
1390       }
1391
1392       next = attr->next;
1393       free(attr->data);
1394       free(attr);
1395       attr = next;
1396    }
1397 }
1398
1399
1400 /**
1401  * Copy gl_pixelstore_attrib from src to dst, updating buffer
1402  * object refcounts.
1403  */
1404 static void
1405 copy_pixelstore(struct gl_context *ctx,
1406                 struct gl_pixelstore_attrib *dst,
1407                 const struct gl_pixelstore_attrib *src)
1408 {
1409    dst->Alignment = src->Alignment;
1410    dst->RowLength = src->RowLength;
1411    dst->SkipPixels = src->SkipPixels;
1412    dst->SkipRows = src->SkipRows;
1413    dst->ImageHeight = src->ImageHeight;
1414    dst->SkipImages = src->SkipImages;
1415    dst->SwapBytes = src->SwapBytes;
1416    dst->LsbFirst = src->LsbFirst;
1417    dst->Invert = src->Invert;
1418    _mesa_reference_buffer_object(ctx, &dst->BufferObj, src->BufferObj);
1419 }
1420
1421
1422 #define GL_CLIENT_PACK_BIT (1<<20)
1423 #define GL_CLIENT_UNPACK_BIT (1<<21)
1424
1425 /**
1426  * Copy gl_array_object from src to dest.
1427  * 'dest' must be in an initialized state.
1428  */
1429 static void
1430 copy_array_object(struct gl_context *ctx,
1431                   struct gl_array_object *dest,
1432                   struct gl_array_object *src)
1433 {
1434    GLuint i;
1435
1436    /* skip Name */
1437    /* skip RefCount */
1438
1439    /* In theory must be the same anyway, but on recreate make sure it matches */
1440    dest->ARBsemantics = src->ARBsemantics;
1441
1442    for (i = 0; i < Elements(src->_VertexAttrib); i++) {
1443       _mesa_copy_client_array(ctx, &dest->_VertexAttrib[i], &src->_VertexAttrib[i]);
1444       _mesa_copy_vertex_attrib_array(ctx, &dest->VertexAttrib[i], &src->VertexAttrib[i]);
1445       _mesa_copy_vertex_buffer_binding(ctx, &dest->VertexBinding[i], &src->VertexBinding[i]);
1446    }
1447
1448    /* _Enabled must be the same than on push */
1449    dest->_Enabled = src->_Enabled;
1450    dest->_MaxElement = src->_MaxElement;
1451 }
1452
1453 /**
1454  * Copy gl_array_attrib from src to dest.
1455  * 'dest' must be in an initialized state.
1456  */
1457 static void
1458 copy_array_attrib(struct gl_context *ctx,
1459                   struct gl_array_attrib *dest,
1460                   struct gl_array_attrib *src,
1461                   bool vbo_deleted)
1462 {
1463    /* skip ArrayObj */
1464    /* skip DefaultArrayObj, Objects */
1465    dest->ActiveTexture = src->ActiveTexture;
1466    dest->LockFirst = src->LockFirst;
1467    dest->LockCount = src->LockCount;
1468    dest->PrimitiveRestart = src->PrimitiveRestart;
1469    dest->PrimitiveRestartFixedIndex = src->PrimitiveRestartFixedIndex;
1470    dest->_PrimitiveRestart = src->_PrimitiveRestart;
1471    dest->RestartIndex = src->RestartIndex;
1472    /* skip NewState */
1473    /* skip RebindArrays */
1474
1475    if (!vbo_deleted)
1476       copy_array_object(ctx, dest->ArrayObj, src->ArrayObj);
1477
1478    /* skip ArrayBufferObj */
1479    /* skip ElementArrayBufferObj */
1480 }
1481
1482 /**
1483  * Save the content of src to dest.
1484  */
1485 static void
1486 save_array_attrib(struct gl_context *ctx,
1487                   struct gl_array_attrib *dest,
1488                   struct gl_array_attrib *src)
1489 {
1490    /* Set the Name, needed for restore, but do never overwrite.
1491     * Needs to match value in the object hash. */
1492    dest->ArrayObj->Name = src->ArrayObj->Name;
1493    /* And copy all of the rest. */
1494    copy_array_attrib(ctx, dest, src, false);
1495
1496    /* Just reference them here */
1497    _mesa_reference_buffer_object(ctx, &dest->ArrayBufferObj,
1498                                  src->ArrayBufferObj);
1499    _mesa_reference_buffer_object(ctx, &dest->ArrayObj->ElementArrayBufferObj,
1500                                  src->ArrayObj->ElementArrayBufferObj);
1501 }
1502
1503 /**
1504  * Restore the content of src to dest.
1505  */
1506 static void
1507 restore_array_attrib(struct gl_context *ctx,
1508                      struct gl_array_attrib *dest,
1509                      struct gl_array_attrib *src)
1510 {
1511    /* The ARB_vertex_array_object spec says:
1512     *
1513     *     "BindVertexArray fails and an INVALID_OPERATION error is generated
1514     *     if array is not a name returned from a previous call to
1515     *     GenVertexArrays, or if such a name has since been deleted with
1516     *     DeleteVertexArrays."
1517     *
1518     * Therefore popping a deleted VAO cannot magically recreate it.
1519     *
1520     * The semantics of objects created using APPLE_vertex_array_objects behave
1521     * differently.  These objects expect to be recreated by pop.  Alas.
1522     */
1523    const bool arb_vao = (src->ArrayObj->Name != 0
1524                          && src->ArrayObj->ARBsemantics);
1525
1526    if (arb_vao && !_mesa_IsVertexArray(src->ArrayObj->Name))
1527       return;
1528
1529    _mesa_BindVertexArrayAPPLE(src->ArrayObj->Name);
1530
1531    /* Restore or recreate the buffer objects by the names ... */
1532    if (!arb_vao
1533        || src->ArrayBufferObj->Name == 0
1534        || _mesa_IsBuffer(src->ArrayBufferObj->Name)) {
1535       /* ... and restore its content */
1536       copy_array_attrib(ctx, dest, src, false);
1537
1538       _mesa_BindBuffer(GL_ARRAY_BUFFER_ARB,
1539                           src->ArrayBufferObj->Name);
1540    } else {
1541       copy_array_attrib(ctx, dest, src, true);
1542    }
1543
1544    if (!arb_vao
1545        || src->ArrayObj->ElementArrayBufferObj->Name == 0
1546        || _mesa_IsBuffer(src->ArrayObj->ElementArrayBufferObj->Name))
1547       _mesa_BindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB,
1548                           src->ArrayObj->ElementArrayBufferObj->Name);
1549 }
1550
1551 /**
1552  * init/alloc the fields of 'attrib'.
1553  * Needs to the init part matching free_array_attrib_data below.
1554  */
1555 static bool
1556 init_array_attrib_data(struct gl_context *ctx,
1557                        struct gl_array_attrib *attrib)
1558 {
1559    /* Get a non driver gl_array_object. */
1560    attrib->ArrayObj = CALLOC_STRUCT( gl_array_object );
1561
1562    if (attrib->ArrayObj == NULL) {
1563       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushClientAttrib");
1564       return false;
1565    }
1566
1567    _mesa_initialize_array_object(ctx, attrib->ArrayObj, 0);
1568    return true;
1569 }
1570
1571 /**
1572  * Free/unreference the fields of 'attrib' but don't delete it (that's
1573  * done later in the calling code).
1574  * Needs to the cleanup part matching init_array_attrib_data above.
1575  */
1576 static void
1577 free_array_attrib_data(struct gl_context *ctx,
1578                        struct gl_array_attrib *attrib)
1579 {
1580    /* We use a non driver array object, so don't just unref since we would
1581     * end up using the drivers DeleteArrayObject function for deletion. */
1582    _mesa_delete_array_object(ctx, attrib->ArrayObj);
1583    attrib->ArrayObj = 0;
1584    _mesa_reference_buffer_object(ctx, &attrib->ArrayBufferObj, NULL);
1585 }
1586
1587
1588 void GLAPIENTRY
1589 _mesa_PushClientAttrib(GLbitfield mask)
1590 {
1591    struct gl_attrib_node *head;
1592
1593    GET_CURRENT_CONTEXT(ctx);
1594
1595    if (ctx->ClientAttribStackDepth >= MAX_CLIENT_ATTRIB_STACK_DEPTH) {
1596       _mesa_error( ctx, GL_STACK_OVERFLOW, "glPushClientAttrib" );
1597       return;
1598    }
1599
1600    /* Build linked list of attribute nodes which save all attribute
1601     * groups specified by the mask.
1602     */
1603    head = NULL;
1604
1605    if (mask & GL_CLIENT_PIXEL_STORE_BIT) {
1606       struct gl_pixelstore_attrib *attr;
1607       /* packing attribs */
1608       attr = CALLOC_STRUCT( gl_pixelstore_attrib );
1609       if (attr == NULL) {
1610          _mesa_error( ctx, GL_OUT_OF_MEMORY, "glPushClientAttrib" );
1611          goto end;
1612       }
1613       if (save_attrib_data(&head, GL_CLIENT_PACK_BIT, attr)) {
1614          copy_pixelstore(ctx, attr, &ctx->Pack);
1615       }
1616       else {
1617          _mesa_error( ctx, GL_OUT_OF_MEMORY, "glPushClientAttrib" );
1618          FREE(attr);
1619          goto end;
1620       }
1621
1622       /* unpacking attribs */
1623       attr = CALLOC_STRUCT( gl_pixelstore_attrib );
1624       if (attr == NULL) {
1625          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushClientAttrib");
1626          goto end;
1627       }
1628
1629       if (save_attrib_data(&head, GL_CLIENT_UNPACK_BIT, attr)) {
1630          copy_pixelstore(ctx, attr, &ctx->Unpack);
1631       }
1632       else {
1633          _mesa_error( ctx, GL_OUT_OF_MEMORY, "glPushClientAttrib" );
1634          FREE(attr);
1635          goto end;
1636        }
1637    }
1638
1639    if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) {
1640       struct gl_array_attrib *attr;
1641       attr = CALLOC_STRUCT( gl_array_attrib );
1642       if (attr == NULL) {
1643          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushClientAttrib");
1644          goto end;
1645       }
1646
1647       if (!init_array_attrib_data(ctx, attr)) {
1648          FREE(attr);
1649          goto end;
1650       }
1651
1652       if (save_attrib_data(&head, GL_CLIENT_VERTEX_ARRAY_BIT, attr)) {
1653          save_array_attrib(ctx, attr, &ctx->Array);
1654       }
1655       else {
1656          free_array_attrib_data(ctx, attr);
1657          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushClientAttrib");
1658          FREE(attr);
1659          /* goto to keep safe from possible later changes */
1660          goto end;
1661       }
1662    }
1663 end:
1664    if (head != NULL) {
1665        ctx->ClientAttribStack[ctx->ClientAttribStackDepth] = head;
1666        ctx->ClientAttribStackDepth++;
1667    }
1668 }
1669
1670
1671
1672
1673 void GLAPIENTRY
1674 _mesa_PopClientAttrib(void)
1675 {
1676    struct gl_attrib_node *node, *next;
1677
1678    GET_CURRENT_CONTEXT(ctx);
1679    FLUSH_VERTICES(ctx, 0);
1680
1681    if (ctx->ClientAttribStackDepth == 0) {
1682       _mesa_error( ctx, GL_STACK_UNDERFLOW, "glPopClientAttrib" );
1683       return;
1684    }
1685
1686    ctx->ClientAttribStackDepth--;
1687    node = ctx->ClientAttribStack[ctx->ClientAttribStackDepth];
1688
1689    while (node) {
1690       switch (node->kind) {
1691          case GL_CLIENT_PACK_BIT:
1692             {
1693                struct gl_pixelstore_attrib *store =
1694                   (struct gl_pixelstore_attrib *) node->data;
1695                copy_pixelstore(ctx, &ctx->Pack, store);
1696                _mesa_reference_buffer_object(ctx, &store->BufferObj, NULL);
1697             }
1698             break;
1699          case GL_CLIENT_UNPACK_BIT:
1700             {
1701                struct gl_pixelstore_attrib *store =
1702                   (struct gl_pixelstore_attrib *) node->data;
1703                copy_pixelstore(ctx, &ctx->Unpack, store);
1704                _mesa_reference_buffer_object(ctx, &store->BufferObj, NULL);
1705             }
1706             break;
1707          case GL_CLIENT_VERTEX_ARRAY_BIT: {
1708             struct gl_array_attrib * attr =
1709               (struct gl_array_attrib *) node->data;
1710             restore_array_attrib(ctx, &ctx->Array, attr);
1711             free_array_attrib_data(ctx, attr);
1712             ctx->NewState |= _NEW_ARRAY;
1713             break;
1714          }
1715          default:
1716             _mesa_problem( ctx, "Bad attrib flag in PopClientAttrib");
1717             break;
1718       }
1719
1720       next = node->next;
1721       free(node->data);
1722       free(node);
1723       node = next;
1724    }
1725 }
1726
1727
1728 /**
1729  * Free any attribute state data that might be attached to the context.
1730  */
1731 void
1732 _mesa_free_attrib_data(struct gl_context *ctx)
1733 {
1734    while (ctx->AttribStackDepth > 0) {
1735       struct gl_attrib_node *attr, *next;
1736
1737       ctx->AttribStackDepth--;
1738       attr = ctx->AttribStack[ctx->AttribStackDepth];
1739
1740       while (attr) {
1741          if (attr->kind == GL_TEXTURE_BIT) {
1742             struct texture_state *texstate = (struct texture_state*)attr->data;
1743             GLuint u, tgt;
1744             /* clear references to the saved texture objects */
1745             for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
1746                for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
1747                   _mesa_reference_texobj(&texstate->SavedTexRef[u][tgt], NULL);
1748                }
1749             }
1750             _mesa_reference_shared_state(ctx, &texstate->SharedRef, NULL);
1751          }
1752          else {
1753             /* any other chunks of state that requires special handling? */
1754          }
1755
1756          next = attr->next;
1757          free(attr->data);
1758          free(attr);
1759          attr = next;
1760       }
1761    }
1762 }
1763
1764
1765 void _mesa_init_attrib( struct gl_context *ctx )
1766 {
1767    /* Renderer and client attribute stacks */
1768    ctx->AttribStackDepth = 0;
1769    ctx->ClientAttribStackDepth = 0;
1770 }