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 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 "context.h" 35#include "depth.h" 36#include "enable.h" 37#include "enums.h" 38#include "fog.h" 39#include "hint.h" 40#include "light.h" 41#include "lines.h" 42#include "macros.h" 43#include "matrix.h" 44#include "multisample.h" 45#include "pixelstore.h" 46#include "points.h" 47#include "polygon.h" 48#include "shared.h" 49#include "scissor.h" 50#include "stencil.h" 51#include "texobj.h" 52#include "texparam.h" 53#include "texstate.h" 54#include "varray.h" 55#include "viewport.h" 56#include "mtypes.h" 57#include "state.h" 58#include "hash.h" 59#include <stdbool.h> 60#include "util/u_memory.h" 61#include "api_exec_decl.h" 62 63#include "state_tracker/st_cb_texture.h" 64#include "state_tracker/st_manager.h" 65#include "state_tracker/st_sampler_view.h" 66 67static inline bool 68copy_texture_attribs(struct gl_texture_object *dst, 69 const struct gl_texture_object *src, 70 gl_texture_index tex) 71{ 72 /* All pushed fields have no effect on texture buffers. */ 73 if (tex == TEXTURE_BUFFER_INDEX) 74 return false; 75 76 /* Sampler fields have no effect on MSAA textures. */ 77 if (tex != TEXTURE_2D_MULTISAMPLE_INDEX && 78 tex != TEXTURE_2D_MULTISAMPLE_ARRAY_INDEX) { 79 memcpy(&dst->Sampler.Attrib, &src->Sampler.Attrib, 80 sizeof(src->Sampler.Attrib)); 81 } 82 memcpy(&dst->Attrib, &src->Attrib, sizeof(src->Attrib)); 83 return true; 84} 85 86 87void GLAPIENTRY 88_mesa_PushAttrib(GLbitfield mask) 89{ 90 struct gl_attrib_node *head; 91 92 GET_CURRENT_CONTEXT(ctx); 93 94 if (MESA_VERBOSE & VERBOSE_API) 95 _mesa_debug(ctx, "glPushAttrib %x\n", (int) mask); 96 97 if (ctx->AttribStackDepth >= MAX_ATTRIB_STACK_DEPTH) { 98 _mesa_error(ctx, GL_STACK_OVERFLOW, "glPushAttrib"); 99 return; 100 } 101 102 head = ctx->AttribStack[ctx->AttribStackDepth]; 103 if (unlikely(!head)) { 104 head = CALLOC_STRUCT(gl_attrib_node); 105 if (unlikely(!head)) { 106 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushAttrib"); 107 return; 108 } 109 ctx->AttribStack[ctx->AttribStackDepth] = head; 110 } 111 112 head->Mask = mask; 113 head->OldPopAttribStateMask = ctx->PopAttribState; 114 115 if (mask & GL_ACCUM_BUFFER_BIT) 116 memcpy(&head->Accum, &ctx->Accum, sizeof(head->Accum)); 117 118 if (mask & GL_COLOR_BUFFER_BIT) { 119 memcpy(&head->Color, &ctx->Color, sizeof(struct gl_colorbuffer_attrib)); 120 /* push the Draw FBO's DrawBuffer[] state, not ctx->Color.DrawBuffer[] */ 121 for (unsigned i = 0; i < ctx->Const.MaxDrawBuffers; i ++) 122 head->Color.DrawBuffer[i] = ctx->DrawBuffer->ColorDrawBuffer[i]; 123 } 124 125 if (mask & GL_CURRENT_BIT) { 126 FLUSH_CURRENT(ctx, 0); 127 memcpy(&head->Current, &ctx->Current, sizeof(head->Current)); 128 } 129 130 if (mask & GL_DEPTH_BUFFER_BIT) 131 memcpy(&head->Depth, &ctx->Depth, sizeof(head->Depth)); 132 133 if (mask & GL_ENABLE_BIT) { 134 struct gl_enable_attrib_node *attr = &head->Enable; 135 GLuint i; 136 137 /* Copy enable flags from all other attributes into the enable struct. */ 138 attr->AlphaTest = ctx->Color.AlphaEnabled; 139 attr->AutoNormal = ctx->Eval.AutoNormal; 140 attr->Blend = ctx->Color.BlendEnabled; 141 attr->ClipPlanes = ctx->Transform.ClipPlanesEnabled; 142 attr->ColorMaterial = ctx->Light.ColorMaterialEnabled; 143 attr->CullFace = ctx->Polygon.CullFlag; 144 attr->DepthClampNear = ctx->Transform.DepthClampNear; 145 attr->DepthClampFar = ctx->Transform.DepthClampFar; 146 attr->DepthTest = ctx->Depth.Test; 147 attr->Dither = ctx->Color.DitherFlag; 148 attr->Fog = ctx->Fog.Enabled; 149 for (i = 0; i < ctx->Const.MaxLights; i++) { 150 attr->Light[i] = ctx->Light.Light[i].Enabled; 151 } 152 attr->Lighting = ctx->Light.Enabled; 153 attr->LineSmooth = ctx->Line.SmoothFlag; 154 attr->LineStipple = ctx->Line.StippleFlag; 155 attr->IndexLogicOp = ctx->Color.IndexLogicOpEnabled; 156 attr->ColorLogicOp = ctx->Color.ColorLogicOpEnabled; 157 attr->Map1Color4 = ctx->Eval.Map1Color4; 158 attr->Map1Index = ctx->Eval.Map1Index; 159 attr->Map1Normal = ctx->Eval.Map1Normal; 160 attr->Map1TextureCoord1 = ctx->Eval.Map1TextureCoord1; 161 attr->Map1TextureCoord2 = ctx->Eval.Map1TextureCoord2; 162 attr->Map1TextureCoord3 = ctx->Eval.Map1TextureCoord3; 163 attr->Map1TextureCoord4 = ctx->Eval.Map1TextureCoord4; 164 attr->Map1Vertex3 = ctx->Eval.Map1Vertex3; 165 attr->Map1Vertex4 = ctx->Eval.Map1Vertex4; 166 attr->Map2Color4 = ctx->Eval.Map2Color4; 167 attr->Map2Index = ctx->Eval.Map2Index; 168 attr->Map2Normal = ctx->Eval.Map2Normal; 169 attr->Map2TextureCoord1 = ctx->Eval.Map2TextureCoord1; 170 attr->Map2TextureCoord2 = ctx->Eval.Map2TextureCoord2; 171 attr->Map2TextureCoord3 = ctx->Eval.Map2TextureCoord3; 172 attr->Map2TextureCoord4 = ctx->Eval.Map2TextureCoord4; 173 attr->Map2Vertex3 = ctx->Eval.Map2Vertex3; 174 attr->Map2Vertex4 = ctx->Eval.Map2Vertex4; 175 attr->Normalize = ctx->Transform.Normalize; 176 attr->RasterPositionUnclipped = ctx->Transform.RasterPositionUnclipped; 177 attr->PointSmooth = ctx->Point.SmoothFlag; 178 attr->PointSprite = ctx->Point.PointSprite; 179 attr->PolygonOffsetPoint = ctx->Polygon.OffsetPoint; 180 attr->PolygonOffsetLine = ctx->Polygon.OffsetLine; 181 attr->PolygonOffsetFill = ctx->Polygon.OffsetFill; 182 attr->PolygonSmooth = ctx->Polygon.SmoothFlag; 183 attr->PolygonStipple = ctx->Polygon.StippleFlag; 184 attr->RescaleNormals = ctx->Transform.RescaleNormals; 185 attr->Scissor = ctx->Scissor.EnableFlags; 186 attr->Stencil = ctx->Stencil.Enabled; 187 attr->StencilTwoSide = ctx->Stencil.TestTwoSide; 188 attr->MultisampleEnabled = ctx->Multisample.Enabled; 189 attr->SampleAlphaToCoverage = ctx->Multisample.SampleAlphaToCoverage; 190 attr->SampleAlphaToOne = ctx->Multisample.SampleAlphaToOne; 191 attr->SampleCoverage = ctx->Multisample.SampleCoverage; 192 for (i = 0; i < ctx->Const.MaxTextureUnits; i++) { 193 attr->Texture[i] = ctx->Texture.FixedFuncUnit[i].Enabled; 194 attr->TexGen[i] = ctx->Texture.FixedFuncUnit[i].TexGenEnabled; 195 } 196 /* GL_ARB_vertex_program */ 197 attr->VertexProgram = ctx->VertexProgram.Enabled; 198 attr->VertexProgramPointSize = ctx->VertexProgram.PointSizeEnabled; 199 attr->VertexProgramTwoSide = ctx->VertexProgram.TwoSideEnabled; 200 201 /* GL_ARB_fragment_program */ 202 attr->FragmentProgram = ctx->FragmentProgram.Enabled; 203 204 /* GL_ARB_framebuffer_sRGB / GL_EXT_framebuffer_sRGB */ 205 attr->sRGBEnabled = ctx->Color.sRGBEnabled; 206 207 /* GL_NV_conservative_raster */ 208 attr->ConservativeRasterization = ctx->ConservativeRasterization; 209 } 210 211 if (mask & GL_EVAL_BIT) 212 memcpy(&head->Eval, &ctx->Eval, sizeof(head->Eval)); 213 214 if (mask & GL_FOG_BIT) 215 memcpy(&head->Fog, &ctx->Fog, sizeof(head->Fog)); 216 217 if (mask & GL_HINT_BIT) 218 memcpy(&head->Hint, &ctx->Hint, sizeof(head->Hint)); 219 220 if (mask & GL_LIGHTING_BIT) { 221 FLUSH_CURRENT(ctx, 0); /* flush material changes */ 222 memcpy(&head->Light, &ctx->Light, sizeof(head->Light)); 223 } 224 225 if (mask & GL_LINE_BIT) 226 memcpy(&head->Line, &ctx->Line, sizeof(head->Line)); 227 228 if (mask & GL_LIST_BIT) 229 memcpy(&head->List, &ctx->List, sizeof(head->List)); 230 231 if (mask & GL_PIXEL_MODE_BIT) { 232 memcpy(&head->Pixel, &ctx->Pixel, sizeof(struct gl_pixel_attrib)); 233 /* push the Read FBO's ReadBuffer state, not ctx->Pixel.ReadBuffer */ 234 head->Pixel.ReadBuffer = ctx->ReadBuffer->ColorReadBuffer; 235 } 236 237 if (mask & GL_POINT_BIT) 238 memcpy(&head->Point, &ctx->Point, sizeof(head->Point)); 239 240 if (mask & GL_POLYGON_BIT) 241 memcpy(&head->Polygon, &ctx->Polygon, sizeof(head->Polygon)); 242 243 if (mask & GL_POLYGON_STIPPLE_BIT) { 244 memcpy(&head->PolygonStipple, &ctx->PolygonStipple, 245 sizeof(head->PolygonStipple)); 246 } 247 248 if (mask & GL_SCISSOR_BIT) 249 memcpy(&head->Scissor, &ctx->Scissor, sizeof(head->Scissor)); 250 251 if (mask & GL_STENCIL_BUFFER_BIT) 252 memcpy(&head->Stencil, &ctx->Stencil, sizeof(head->Stencil)); 253 254 if (mask & GL_TEXTURE_BIT) { 255 GLuint u, tex; 256 257 _mesa_lock_context_textures(ctx); 258 259 /* copy/save the bulk of texture state here */ 260 head->Texture.CurrentUnit = ctx->Texture.CurrentUnit; 261 memcpy(&head->Texture.FixedFuncUnit, &ctx->Texture.FixedFuncUnit, 262 sizeof(ctx->Texture.FixedFuncUnit)); 263 264 /* Copy/save contents of default texture objects. They are almost 265 * always bound, so this can be done unconditionally. 266 * 267 * We save them separately, so that we don't have to save them in every 268 * texture unit where they are bound. This decreases CPU overhead. 269 */ 270 for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) { 271 struct gl_texture_object *dst = &head->Texture.SavedDefaultObj[tex]; 272 struct gl_texture_object *src = ctx->Shared->DefaultTex[tex]; 273 274 copy_texture_attribs(dst, src, tex); 275 } 276 277 /* copy state/contents of the currently bound texture objects */ 278 unsigned num_tex_used = ctx->Texture.NumCurrentTexUsed; 279 for (u = 0; u < num_tex_used; u++) { 280 head->Texture.LodBias[u] = ctx->Texture.Unit[u].LodBias; 281 head->Texture.LodBiasQuantized[u] = ctx->Texture.Unit[u].LodBiasQuantized; 282 283 for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) { 284 struct gl_texture_object *dst = &head->Texture.SavedObj[u][tex]; 285 struct gl_texture_object *src = ctx->Texture.Unit[u].CurrentTex[tex]; 286 287 dst->Name = src->Name; 288 289 /* Default texture targets are saved separately above. */ 290 if (src->Name != 0) 291 copy_texture_attribs(dst, src, tex); 292 } 293 } 294 head->Texture.NumTexSaved = num_tex_used; 295 _mesa_unlock_context_textures(ctx); 296 } 297 298 if (mask & GL_TRANSFORM_BIT) 299 memcpy(&head->Transform, &ctx->Transform, sizeof(head->Transform)); 300 301 if (mask & GL_VIEWPORT_BIT) { 302 memcpy(&head->Viewport.ViewportArray, &ctx->ViewportArray, 303 sizeof(struct gl_viewport_attrib)*ctx->Const.MaxViewports); 304 305 head->Viewport.SubpixelPrecisionBias[0] = ctx->SubpixelPrecisionBias[0]; 306 head->Viewport.SubpixelPrecisionBias[1] = ctx->SubpixelPrecisionBias[1]; 307 } 308 309 /* GL_ARB_multisample */ 310 if (mask & GL_MULTISAMPLE_BIT_ARB) 311 memcpy(&head->Multisample, &ctx->Multisample, sizeof(head->Multisample)); 312 313 ctx->AttribStackDepth++; 314 ctx->PopAttribState = 0; 315} 316 317 318#define TEST_AND_UPDATE(VALUE, NEWVALUE, ENUM) do { \ 319 if ((VALUE) != (NEWVALUE)) \ 320 _mesa_set_enable(ctx, ENUM, (NEWVALUE)); \ 321 } while (0) 322 323#define TEST_AND_UPDATE_BIT(VALUE, NEW_VALUE, BIT, ENUM) do { \ 324 if (((VALUE) & BITFIELD_BIT(BIT)) != ((NEW_VALUE) & BITFIELD_BIT(BIT))) \ 325 _mesa_set_enable(ctx, ENUM, ((NEW_VALUE) >> (BIT)) & 0x1); \ 326 } while (0) 327 328#define TEST_AND_UPDATE_INDEX(VALUE, NEW_VALUE, INDEX, ENUM) do { \ 329 if (((VALUE) & BITFIELD_BIT(INDEX)) != ((NEW_VALUE) & BITFIELD_BIT(INDEX))) \ 330 _mesa_set_enablei(ctx, ENUM, INDEX, ((NEW_VALUE) >> (INDEX)) & 0x1); \ 331 } while (0) 332 333 334static void 335pop_enable_group(struct gl_context *ctx, const struct gl_enable_attrib_node *enable) 336{ 337 GLuint i; 338 339 TEST_AND_UPDATE(ctx->Color.AlphaEnabled, enable->AlphaTest, GL_ALPHA_TEST); 340 if (ctx->Color.BlendEnabled != enable->Blend) { 341 if (ctx->Extensions.EXT_draw_buffers2) { 342 for (unsigned i = 0; i < ctx->Const.MaxDrawBuffers; i++) { 343 TEST_AND_UPDATE_INDEX(ctx->Color.BlendEnabled, enable->Blend, 344 i, GL_BLEND); 345 } 346 } else { 347 _mesa_set_enable(ctx, GL_BLEND, (enable->Blend & 1)); 348 } 349 } 350 351 if (ctx->Transform.ClipPlanesEnabled != enable->ClipPlanes) { 352 for (unsigned i = 0; i < ctx->Const.MaxClipPlanes; i++) { 353 TEST_AND_UPDATE_BIT(ctx->Transform.ClipPlanesEnabled, 354 enable->ClipPlanes, i, GL_CLIP_PLANE0 + i); 355 } 356 } 357 358 TEST_AND_UPDATE(ctx->Light.ColorMaterialEnabled, enable->ColorMaterial, 359 GL_COLOR_MATERIAL); 360 TEST_AND_UPDATE(ctx->Polygon.CullFlag, enable->CullFace, GL_CULL_FACE); 361 362 if (!ctx->Extensions.AMD_depth_clamp_separate) { 363 TEST_AND_UPDATE(ctx->Transform.DepthClampNear && ctx->Transform.DepthClampFar, 364 enable->DepthClampNear && enable->DepthClampFar, 365 GL_DEPTH_CLAMP); 366 } else { 367 TEST_AND_UPDATE(ctx->Transform.DepthClampNear, enable->DepthClampNear, 368 GL_DEPTH_CLAMP_NEAR_AMD); 369 TEST_AND_UPDATE(ctx->Transform.DepthClampFar, enable->DepthClampFar, 370 GL_DEPTH_CLAMP_FAR_AMD); 371 } 372 373 TEST_AND_UPDATE(ctx->Depth.Test, enable->DepthTest, GL_DEPTH_TEST); 374 TEST_AND_UPDATE(ctx->Color.DitherFlag, enable->Dither, GL_DITHER); 375 TEST_AND_UPDATE(ctx->Fog.Enabled, enable->Fog, GL_FOG); 376 TEST_AND_UPDATE(ctx->Light.Enabled, enable->Lighting, GL_LIGHTING); 377 TEST_AND_UPDATE(ctx->Line.SmoothFlag, enable->LineSmooth, GL_LINE_SMOOTH); 378 TEST_AND_UPDATE(ctx->Line.StippleFlag, enable->LineStipple, 379 GL_LINE_STIPPLE); 380 TEST_AND_UPDATE(ctx->Color.IndexLogicOpEnabled, enable->IndexLogicOp, 381 GL_INDEX_LOGIC_OP); 382 TEST_AND_UPDATE(ctx->Color.ColorLogicOpEnabled, enable->ColorLogicOp, 383 GL_COLOR_LOGIC_OP); 384 385 TEST_AND_UPDATE(ctx->Eval.Map1Color4, enable->Map1Color4, GL_MAP1_COLOR_4); 386 TEST_AND_UPDATE(ctx->Eval.Map1Index, enable->Map1Index, GL_MAP1_INDEX); 387 TEST_AND_UPDATE(ctx->Eval.Map1Normal, enable->Map1Normal, GL_MAP1_NORMAL); 388 TEST_AND_UPDATE(ctx->Eval.Map1TextureCoord1, enable->Map1TextureCoord1, 389 GL_MAP1_TEXTURE_COORD_1); 390 TEST_AND_UPDATE(ctx->Eval.Map1TextureCoord2, enable->Map1TextureCoord2, 391 GL_MAP1_TEXTURE_COORD_2); 392 TEST_AND_UPDATE(ctx->Eval.Map1TextureCoord3, enable->Map1TextureCoord3, 393 GL_MAP1_TEXTURE_COORD_3); 394 TEST_AND_UPDATE(ctx->Eval.Map1TextureCoord4, enable->Map1TextureCoord4, 395 GL_MAP1_TEXTURE_COORD_4); 396 TEST_AND_UPDATE(ctx->Eval.Map1Vertex3, enable->Map1Vertex3, 397 GL_MAP1_VERTEX_3); 398 TEST_AND_UPDATE(ctx->Eval.Map1Vertex4, enable->Map1Vertex4, 399 GL_MAP1_VERTEX_4); 400 401 TEST_AND_UPDATE(ctx->Eval.Map2Color4, enable->Map2Color4, GL_MAP2_COLOR_4); 402 TEST_AND_UPDATE(ctx->Eval.Map2Index, enable->Map2Index, GL_MAP2_INDEX); 403 TEST_AND_UPDATE(ctx->Eval.Map2Normal, enable->Map2Normal, GL_MAP2_NORMAL); 404 TEST_AND_UPDATE(ctx->Eval.Map2TextureCoord1, enable->Map2TextureCoord1, 405 GL_MAP2_TEXTURE_COORD_1); 406 TEST_AND_UPDATE(ctx->Eval.Map2TextureCoord2, enable->Map2TextureCoord2, 407 GL_MAP2_TEXTURE_COORD_2); 408 TEST_AND_UPDATE(ctx->Eval.Map2TextureCoord3, enable->Map2TextureCoord3, 409 GL_MAP2_TEXTURE_COORD_3); 410 TEST_AND_UPDATE(ctx->Eval.Map2TextureCoord4, enable->Map2TextureCoord4, 411 GL_MAP2_TEXTURE_COORD_4); 412 TEST_AND_UPDATE(ctx->Eval.Map2Vertex3, enable->Map2Vertex3, 413 GL_MAP2_VERTEX_3); 414 TEST_AND_UPDATE(ctx->Eval.Map2Vertex4, enable->Map2Vertex4, 415 GL_MAP2_VERTEX_4); 416 417 TEST_AND_UPDATE(ctx->Eval.AutoNormal, enable->AutoNormal, GL_AUTO_NORMAL); 418 TEST_AND_UPDATE(ctx->Transform.Normalize, enable->Normalize, GL_NORMALIZE); 419 TEST_AND_UPDATE(ctx->Transform.RescaleNormals, enable->RescaleNormals, 420 GL_RESCALE_NORMAL_EXT); 421 TEST_AND_UPDATE(ctx->Transform.RasterPositionUnclipped, 422 enable->RasterPositionUnclipped, 423 GL_RASTER_POSITION_UNCLIPPED_IBM); 424 TEST_AND_UPDATE(ctx->Point.SmoothFlag, enable->PointSmooth, 425 GL_POINT_SMOOTH); 426 if (ctx->Extensions.ARB_point_sprite) { 427 TEST_AND_UPDATE(ctx->Point.PointSprite, enable->PointSprite, 428 GL_POINT_SPRITE); 429 } 430 TEST_AND_UPDATE(ctx->Polygon.OffsetPoint, enable->PolygonOffsetPoint, 431 GL_POLYGON_OFFSET_POINT); 432 TEST_AND_UPDATE(ctx->Polygon.OffsetLine, enable->PolygonOffsetLine, 433 GL_POLYGON_OFFSET_LINE); 434 TEST_AND_UPDATE(ctx->Polygon.OffsetFill, enable->PolygonOffsetFill, 435 GL_POLYGON_OFFSET_FILL); 436 TEST_AND_UPDATE(ctx->Polygon.SmoothFlag, enable->PolygonSmooth, 437 GL_POLYGON_SMOOTH); 438 TEST_AND_UPDATE(ctx->Polygon.StippleFlag, enable->PolygonStipple, 439 GL_POLYGON_STIPPLE); 440 if (ctx->Scissor.EnableFlags != enable->Scissor) { 441 unsigned i; 442 443 for (i = 0; i < ctx->Const.MaxViewports; i++) { 444 TEST_AND_UPDATE_INDEX(ctx->Scissor.EnableFlags, enable->Scissor, 445 i, GL_SCISSOR_TEST); 446 } 447 } 448 TEST_AND_UPDATE(ctx->Stencil.Enabled, enable->Stencil, GL_STENCIL_TEST); 449 if (ctx->Extensions.EXT_stencil_two_side) { 450 TEST_AND_UPDATE(ctx->Stencil.TestTwoSide, enable->StencilTwoSide, 451 GL_STENCIL_TEST_TWO_SIDE_EXT); 452 } 453 TEST_AND_UPDATE(ctx->Multisample.Enabled, enable->MultisampleEnabled, 454 GL_MULTISAMPLE_ARB); 455 TEST_AND_UPDATE(ctx->Multisample.SampleAlphaToCoverage, 456 enable->SampleAlphaToCoverage, 457 GL_SAMPLE_ALPHA_TO_COVERAGE_ARB); 458 TEST_AND_UPDATE(ctx->Multisample.SampleAlphaToOne, 459 enable->SampleAlphaToOne, 460 GL_SAMPLE_ALPHA_TO_ONE_ARB); 461 TEST_AND_UPDATE(ctx->Multisample.SampleCoverage, 462 enable->SampleCoverage, 463 GL_SAMPLE_COVERAGE_ARB); 464 /* GL_ARB_vertex_program */ 465 TEST_AND_UPDATE(ctx->VertexProgram.Enabled, 466 enable->VertexProgram, 467 GL_VERTEX_PROGRAM_ARB); 468 TEST_AND_UPDATE(ctx->VertexProgram.PointSizeEnabled, 469 enable->VertexProgramPointSize, 470 GL_VERTEX_PROGRAM_POINT_SIZE_ARB); 471 TEST_AND_UPDATE(ctx->VertexProgram.TwoSideEnabled, 472 enable->VertexProgramTwoSide, 473 GL_VERTEX_PROGRAM_TWO_SIDE_ARB); 474 475 /* GL_ARB_fragment_program */ 476 TEST_AND_UPDATE(ctx->FragmentProgram.Enabled, 477 enable->FragmentProgram, 478 GL_FRAGMENT_PROGRAM_ARB); 479 480 /* GL_ARB_framebuffer_sRGB / GL_EXT_framebuffer_sRGB */ 481 TEST_AND_UPDATE(ctx->Color.sRGBEnabled, enable->sRGBEnabled, 482 GL_FRAMEBUFFER_SRGB); 483 484 /* GL_NV_conservative_raster */ 485 if (ctx->Extensions.NV_conservative_raster) { 486 TEST_AND_UPDATE(ctx->ConservativeRasterization, 487 enable->ConservativeRasterization, 488 GL_CONSERVATIVE_RASTERIZATION_NV); 489 } 490 491 const unsigned curTexUnitSave = ctx->Texture.CurrentUnit; 492 493 /* texture unit enables */ 494 for (i = 0; i < ctx->Const.MaxTextureUnits; i++) { 495 const GLbitfield enabled = enable->Texture[i]; 496 const GLbitfield gen_enabled = enable->TexGen[i]; 497 const struct gl_fixedfunc_texture_unit *unit = &ctx->Texture.FixedFuncUnit[i]; 498 const GLbitfield old_enabled = unit->Enabled; 499 const GLbitfield old_gen_enabled = unit->TexGenEnabled; 500 501 if (old_enabled == enabled && old_gen_enabled == gen_enabled) 502 continue; 503 504 ctx->Texture.CurrentUnit = i; 505 506 if (old_enabled != enabled) { 507 TEST_AND_UPDATE_BIT(old_enabled, enabled, TEXTURE_1D_INDEX, GL_TEXTURE_1D); 508 TEST_AND_UPDATE_BIT(old_enabled, enabled, TEXTURE_2D_INDEX, GL_TEXTURE_2D); 509 TEST_AND_UPDATE_BIT(old_enabled, enabled, TEXTURE_3D_INDEX, GL_TEXTURE_3D); 510 if (ctx->Extensions.NV_texture_rectangle) { 511 TEST_AND_UPDATE_BIT(old_enabled, enabled, TEXTURE_RECT_INDEX, 512 GL_TEXTURE_RECTANGLE); 513 } 514 TEST_AND_UPDATE_BIT(old_enabled, enabled, TEXTURE_CUBE_INDEX, 515 GL_TEXTURE_CUBE_MAP); 516 } 517 518 if (old_gen_enabled != gen_enabled) { 519 TEST_AND_UPDATE_BIT(old_gen_enabled, gen_enabled, 0, GL_TEXTURE_GEN_S); 520 TEST_AND_UPDATE_BIT(old_gen_enabled, gen_enabled, 1, GL_TEXTURE_GEN_T); 521 TEST_AND_UPDATE_BIT(old_gen_enabled, gen_enabled, 2, GL_TEXTURE_GEN_R); 522 TEST_AND_UPDATE_BIT(old_gen_enabled, gen_enabled, 3, GL_TEXTURE_GEN_Q); 523 } 524 } 525 526 ctx->Texture.CurrentUnit = curTexUnitSave; 527} 528 529 530/** 531 * Pop/restore texture attribute/group state. 532 */ 533static void 534pop_texture_group(struct gl_context *ctx, struct gl_texture_attrib_node *texstate) 535{ 536 GLuint u; 537 538 _mesa_lock_context_textures(ctx); 539 540 /* Restore fixed-function texture unit states. */ 541 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { 542 const struct gl_fixedfunc_texture_unit *unit = 543 &texstate->FixedFuncUnit[u]; 544 struct gl_fixedfunc_texture_unit *destUnit = 545 &ctx->Texture.FixedFuncUnit[u]; 546 547 ctx->Texture.CurrentUnit = u; 548 549 /* Fast path for other drivers. */ 550 memcpy(destUnit, unit, sizeof(*unit)); 551 destUnit->_CurrentCombine = NULL; 552 ctx->Texture.Unit[u].LodBias = texstate->LodBias[u]; 553 ctx->Texture.Unit[u].LodBiasQuantized = texstate->LodBiasQuantized[u]; 554 } 555 556 /* Restore saved textures. */ 557 unsigned num_tex_saved = texstate->NumTexSaved; 558 for (u = 0; u < num_tex_saved; u++) { 559 gl_texture_index tgt; 560 561 ctx->Texture.CurrentUnit = u; 562 563 /* Restore texture object state for each target */ 564 for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) { 565 const struct gl_texture_object *savedObj = &texstate->SavedObj[u][tgt]; 566 struct gl_texture_object *texObj = 567 _mesa_get_tex_unit(ctx, u)->CurrentTex[tgt]; 568 bool is_msaa = tgt == TEXTURE_2D_MULTISAMPLE_INDEX || 569 tgt == TEXTURE_2D_MULTISAMPLE_ARRAY_INDEX; 570 571 /* According to the OpenGL 4.6 Compatibility Profile specification, 572 * table 23.17, GL_TEXTURE_BINDING_2D_MULTISAMPLE and 573 * GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY do not belong in the 574 * texture attrib group. 575 */ 576 if (!is_msaa && texObj->Name != savedObj->Name) { 577 /* We don't need to check whether the texture target is supported, 578 * because we wouldn't get in this conditional block if it wasn't. 579 */ 580 _mesa_BindTexture_no_error(texObj->Target, savedObj->Name); 581 texObj = _mesa_get_tex_unit(ctx, u)->CurrentTex[tgt]; 582 } 583 584 /* Default texture object states are restored separately below. */ 585 if (texObj->Name == 0) 586 continue; 587 588 /* But in the MSAA case, where the currently-bound object is not the 589 * default state, we should still restore the saved default object's 590 * data when that's what was saved initially. 591 */ 592 if (savedObj->Name == 0) 593 savedObj = &texstate->SavedDefaultObj[tgt]; 594 595 if (!copy_texture_attribs(texObj, savedObj, tgt)) 596 continue; 597 598 st_texture_release_all_sampler_views(st_context(ctx), texObj); 599 } 600 } 601 602 /* Restore textures in units that were not used before glPushAttrib (thus 603 * they were not saved) but were used after glPushAttrib. Revert 604 * the bindings to Name = 0. 605 */ 606 unsigned num_tex_changed = ctx->Texture.NumCurrentTexUsed; 607 for (u = num_tex_saved; u < num_tex_changed; u++) { 608 ctx->Texture.CurrentUnit = u; 609 610 for (gl_texture_index tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) { 611 struct gl_texture_object *texObj = 612 _mesa_get_tex_unit(ctx, u)->CurrentTex[tgt]; 613 bool is_msaa = tgt == TEXTURE_2D_MULTISAMPLE_INDEX || 614 tgt == TEXTURE_2D_MULTISAMPLE_ARRAY_INDEX; 615 616 /* According to the OpenGL 4.6 Compatibility Profile specification, 617 * table 23.17, GL_TEXTURE_BINDING_2D_MULTISAMPLE and 618 * GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY do not belong in the 619 * texture attrib group. 620 */ 621 if (!is_msaa && texObj->Name != 0) { 622 /* We don't need to check whether the texture target is supported, 623 * because we wouldn't get in this conditional block if it wasn't. 624 */ 625 _mesa_BindTexture_no_error(texObj->Target, 0); 626 } 627 } 628 } 629 630 /* Restore default texture object states. */ 631 for (gl_texture_index tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) { 632 struct gl_texture_object *dst = ctx->Shared->DefaultTex[tex]; 633 const struct gl_texture_object *src = &texstate->SavedDefaultObj[tex]; 634 635 copy_texture_attribs(dst, src, tex); 636 } 637 638 _mesa_ActiveTexture(GL_TEXTURE0_ARB + texstate->CurrentUnit); 639 _mesa_unlock_context_textures(ctx); 640} 641 642 643#define TEST_AND_CALL1(FIELD, CALL) do { \ 644 if (ctx->FIELD != attr->FIELD) \ 645 _mesa_##CALL(attr->FIELD); \ 646 } while (0) 647 648#define TEST_AND_CALL1_SEL(FIELD, CALL, SEL) do { \ 649 if (ctx->FIELD != attr->FIELD) \ 650 _mesa_##CALL(SEL, attr->FIELD); \ 651 } while (0) 652 653#define TEST_AND_CALL2(FIELD1, FIELD2, CALL) do { \ 654 if (ctx->FIELD1 != attr->FIELD1 || ctx->FIELD2 != attr->FIELD2) \ 655 _mesa_##CALL(attr->FIELD1, attr->FIELD2); \ 656 } while (0) 657 658 659/* 660 * This function is kind of long just because we have to call a lot 661 * of device driver functions to update device driver state. 662 * 663 * XXX As it is now, most of the pop-code calls immediate-mode Mesa functions 664 * in order to restore GL state. This isn't terribly efficient but it 665 * ensures that dirty flags and any derived state gets updated correctly. 666 * We could at least check if the value to restore equals the current value 667 * and then skip the Mesa call. 668 */ 669void GLAPIENTRY 670_mesa_PopAttrib(void) 671{ 672 struct gl_attrib_node *attr; 673 GET_CURRENT_CONTEXT(ctx); 674 FLUSH_VERTICES(ctx, 0, 0); 675 676 if (ctx->AttribStackDepth == 0) { 677 _mesa_error(ctx, GL_STACK_UNDERFLOW, "glPopAttrib"); 678 return; 679 } 680 681 ctx->AttribStackDepth--; 682 attr = ctx->AttribStack[ctx->AttribStackDepth]; 683 684 unsigned mask = attr->Mask; 685 686 /* Flush current attribs. This must be done before PopAttribState is 687 * applied. 688 */ 689 if (mask & GL_CURRENT_BIT) 690 FLUSH_CURRENT(ctx, 0); 691 692 /* Only restore states that have been changed since glPushAttrib. */ 693 mask &= ctx->PopAttribState; 694 695 if (mask & GL_ACCUM_BUFFER_BIT) { 696 _mesa_ClearAccum(attr->Accum.ClearColor[0], 697 attr->Accum.ClearColor[1], 698 attr->Accum.ClearColor[2], 699 attr->Accum.ClearColor[3]); 700 } 701 702 if (mask & GL_COLOR_BUFFER_BIT) { 703 TEST_AND_CALL1(Color.ClearIndex, ClearIndex); 704 _mesa_ClearColor(attr->Color.ClearColor.f[0], 705 attr->Color.ClearColor.f[1], 706 attr->Color.ClearColor.f[2], 707 attr->Color.ClearColor.f[3]); 708 TEST_AND_CALL1(Color.IndexMask, IndexMask); 709 if (ctx->Color.ColorMask != attr->Color.ColorMask) { 710 if (!ctx->Extensions.EXT_draw_buffers2) { 711 _mesa_ColorMask(GET_COLORMASK_BIT(attr->Color.ColorMask, 0, 0), 712 GET_COLORMASK_BIT(attr->Color.ColorMask, 0, 1), 713 GET_COLORMASK_BIT(attr->Color.ColorMask, 0, 2), 714 GET_COLORMASK_BIT(attr->Color.ColorMask, 0, 3)); 715 } else { 716 for (unsigned i = 0; i < ctx->Const.MaxDrawBuffers; i++) { 717 _mesa_ColorMaski(i, 718 GET_COLORMASK_BIT(attr->Color.ColorMask, i, 0), 719 GET_COLORMASK_BIT(attr->Color.ColorMask, i, 1), 720 GET_COLORMASK_BIT(attr->Color.ColorMask, i, 2), 721 GET_COLORMASK_BIT(attr->Color.ColorMask, i, 3)); 722 } 723 } 724 } 725 if (memcmp(ctx->Color.DrawBuffer, attr->Color.DrawBuffer, 726 sizeof(attr->Color.DrawBuffer))) { 727 /* Need to determine if more than one color output is 728 * specified. If so, call glDrawBuffersARB, else call 729 * glDrawBuffer(). This is a subtle, but essential point 730 * since GL_FRONT (for example) is illegal for the former 731 * function, but legal for the later. 732 */ 733 GLboolean multipleBuffers = GL_FALSE; 734 GLuint i; 735 736 for (i = 1; i < ctx->Const.MaxDrawBuffers; i++) { 737 if (attr->Color.DrawBuffer[i] != GL_NONE) { 738 multipleBuffers = GL_TRUE; 739 break; 740 } 741 } 742 /* Call the API_level functions, not _mesa_drawbuffers() 743 * since we need to do error checking on the pop'd 744 * GL_DRAW_BUFFER. 745 * Ex: if GL_FRONT were pushed, but we're popping with a 746 * user FBO bound, GL_FRONT will be illegal and we'll need 747 * to record that error. Per OpenGL ARB decision. 748 */ 749 if (multipleBuffers) { 750 GLenum buffers[MAX_DRAW_BUFFERS]; 751 752 for (unsigned i = 0; i < ctx->Const.MaxDrawBuffers; i++) 753 buffers[i] = attr->Color.DrawBuffer[i]; 754 755 _mesa_DrawBuffers(ctx->Const.MaxDrawBuffers, buffers); 756 } else { 757 _mesa_DrawBuffer(attr->Color.DrawBuffer[0]); 758 } 759 } 760 TEST_AND_UPDATE(ctx->Color.AlphaEnabled, attr->Color.AlphaEnabled, 761 GL_ALPHA_TEST); 762 TEST_AND_CALL2(Color.AlphaFunc, Color.AlphaRefUnclamped, AlphaFunc); 763 if (ctx->Color.BlendEnabled != attr->Color.BlendEnabled) { 764 if (ctx->Extensions.EXT_draw_buffers2) { 765 for (unsigned i = 0; i < ctx->Const.MaxDrawBuffers; i++) { 766 TEST_AND_UPDATE_INDEX(ctx->Color.BlendEnabled, 767 attr->Color.BlendEnabled, i, GL_BLEND); 768 } 769 } 770 else { 771 TEST_AND_UPDATE(ctx->Color.BlendEnabled & 0x1, 772 attr->Color.BlendEnabled & 0x1, GL_BLEND); 773 } 774 } 775 if (ctx->Color._BlendFuncPerBuffer || 776 ctx->Color._BlendEquationPerBuffer) { 777 /* set blend per buffer */ 778 GLuint buf; 779 for (buf = 0; buf < ctx->Const.MaxDrawBuffers; buf++) { 780 _mesa_BlendFuncSeparateiARB(buf, attr->Color.Blend[buf].SrcRGB, 781 attr->Color.Blend[buf].DstRGB, 782 attr->Color.Blend[buf].SrcA, 783 attr->Color.Blend[buf].DstA); 784 _mesa_BlendEquationSeparateiARB(buf, 785 attr->Color.Blend[buf].EquationRGB, 786 attr->Color.Blend[buf].EquationA); 787 } 788 } 789 else { 790 /* set same blend modes for all buffers */ 791 _mesa_BlendFuncSeparate(attr->Color.Blend[0].SrcRGB, 792 attr->Color.Blend[0].DstRGB, 793 attr->Color.Blend[0].SrcA, 794 attr->Color.Blend[0].DstA); 795 /* This special case is because glBlendEquationSeparateEXT 796 * cannot take GL_LOGIC_OP as a parameter. 797 */ 798 if (attr->Color.Blend[0].EquationRGB == 799 attr->Color.Blend[0].EquationA) { 800 TEST_AND_CALL1(Color.Blend[0].EquationRGB, BlendEquation); 801 } 802 else { 803 TEST_AND_CALL2(Color.Blend[0].EquationRGB, 804 Color.Blend[0].EquationA, BlendEquationSeparate); 805 } 806 } 807 _mesa_BlendColor(attr->Color.BlendColorUnclamped[0], 808 attr->Color.BlendColorUnclamped[1], 809 attr->Color.BlendColorUnclamped[2], 810 attr->Color.BlendColorUnclamped[3]); 811 TEST_AND_CALL1(Color.LogicOp, LogicOp); 812 TEST_AND_UPDATE(ctx->Color.ColorLogicOpEnabled, 813 attr->Color.ColorLogicOpEnabled, GL_COLOR_LOGIC_OP); 814 TEST_AND_UPDATE(ctx->Color.IndexLogicOpEnabled, 815 attr->Color.IndexLogicOpEnabled, GL_INDEX_LOGIC_OP); 816 TEST_AND_UPDATE(ctx->Color.DitherFlag, attr->Color.DitherFlag, 817 GL_DITHER); 818 if (ctx->Extensions.ARB_color_buffer_float) { 819 TEST_AND_CALL1_SEL(Color.ClampFragmentColor, ClampColor, 820 GL_CLAMP_FRAGMENT_COLOR); 821 } 822 if (ctx->Extensions.ARB_color_buffer_float || ctx->Version >= 30) { 823 TEST_AND_CALL1_SEL(Color.ClampReadColor, ClampColor, 824 GL_CLAMP_READ_COLOR); 825 } 826 /* GL_ARB_framebuffer_sRGB / GL_EXT_framebuffer_sRGB */ 827 if (ctx->Extensions.EXT_framebuffer_sRGB) { 828 TEST_AND_UPDATE(ctx->Color.sRGBEnabled, attr->Color.sRGBEnabled, 829 GL_FRAMEBUFFER_SRGB); 830 } 831 } 832 833 if (mask & GL_CURRENT_BIT) { 834 memcpy(&ctx->Current, &attr->Current, 835 sizeof(struct gl_current_attrib)); 836 ctx->NewState |= _NEW_CURRENT_ATTRIB; 837 } 838 839 if (mask & GL_DEPTH_BUFFER_BIT) { 840 TEST_AND_CALL1(Depth.Func, DepthFunc); 841 TEST_AND_CALL1(Depth.Clear, ClearDepth); 842 TEST_AND_UPDATE(ctx->Depth.Test, attr->Depth.Test, GL_DEPTH_TEST); 843 TEST_AND_CALL1(Depth.Mask, DepthMask); 844 if (ctx->Extensions.EXT_depth_bounds_test) { 845 TEST_AND_UPDATE(ctx->Depth.BoundsTest, attr->Depth.BoundsTest, 846 GL_DEPTH_BOUNDS_TEST_EXT); 847 TEST_AND_CALL2(Depth.BoundsMin, Depth.BoundsMax, DepthBoundsEXT); 848 } 849 } 850 851 if (mask & GL_ENABLE_BIT) 852 pop_enable_group(ctx, &attr->Enable); 853 854 if (mask & GL_EVAL_BIT) { 855 memcpy(&ctx->Eval, &attr->Eval, sizeof(struct gl_eval_attrib)); 856 vbo_exec_update_eval_maps(ctx); 857 } 858 859 if (mask & GL_FOG_BIT) { 860 TEST_AND_UPDATE(ctx->Fog.Enabled, attr->Fog.Enabled, GL_FOG); 861 _mesa_Fogfv(GL_FOG_COLOR, attr->Fog.Color); 862 TEST_AND_CALL1_SEL(Fog.Density, Fogf, GL_FOG_DENSITY); 863 TEST_AND_CALL1_SEL(Fog.Start, Fogf, GL_FOG_START); 864 TEST_AND_CALL1_SEL(Fog.End, Fogf, GL_FOG_END); 865 TEST_AND_CALL1_SEL(Fog.Index, Fogf, GL_FOG_INDEX); 866 TEST_AND_CALL1_SEL(Fog.Mode, Fogi, GL_FOG_MODE); 867 } 868 869 if (mask & GL_HINT_BIT) { 870 TEST_AND_CALL1_SEL(Hint.PerspectiveCorrection, Hint, GL_PERSPECTIVE_CORRECTION_HINT); 871 TEST_AND_CALL1_SEL(Hint.PointSmooth, Hint, GL_POINT_SMOOTH_HINT); 872 TEST_AND_CALL1_SEL(Hint.LineSmooth, Hint, GL_LINE_SMOOTH_HINT); 873 TEST_AND_CALL1_SEL(Hint.PolygonSmooth, Hint, GL_POLYGON_SMOOTH_HINT); 874 TEST_AND_CALL1_SEL(Hint.Fog, Hint, GL_FOG_HINT); 875 TEST_AND_CALL1_SEL(Hint.TextureCompression, Hint, GL_TEXTURE_COMPRESSION_HINT_ARB); 876 } 877 878 if (mask & GL_LIGHTING_BIT) { 879 GLuint i; 880 /* lighting enable */ 881 TEST_AND_UPDATE(ctx->Light.Enabled, attr->Light.Enabled, GL_LIGHTING); 882 /* per-light state */ 883 if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top)) 884 _math_matrix_analyse(ctx->ModelviewMatrixStack.Top); 885 886 /* Fast path for other drivers. */ 887 ctx->NewState |= _NEW_LIGHT_CONSTANTS | _NEW_FF_VERT_PROGRAM; 888 889 memcpy(ctx->Light.LightSource, attr->Light.LightSource, 890 sizeof(attr->Light.LightSource)); 891 memcpy(&ctx->Light.Model, &attr->Light.Model, 892 sizeof(attr->Light.Model)); 893 894 for (i = 0; i < ctx->Const.MaxLights; i++) { 895 TEST_AND_UPDATE(ctx->Light.Light[i].Enabled, 896 attr->Light.Light[i].Enabled, 897 GL_LIGHT0 + i); 898 memcpy(&ctx->Light.Light[i], &attr->Light.Light[i], 899 sizeof(struct gl_light)); 900 } 901 /* shade model */ 902 TEST_AND_CALL1(Light.ShadeModel, ShadeModel); 903 /* color material */ 904 TEST_AND_CALL2(Light.ColorMaterialFace, Light.ColorMaterialMode, 905 ColorMaterial); 906 TEST_AND_UPDATE(ctx->Light.ColorMaterialEnabled, 907 attr->Light.ColorMaterialEnabled, GL_COLOR_MATERIAL); 908 /* Shininess material is used by the fixed-func vertex program. */ 909 ctx->NewState |= _NEW_MATERIAL | _NEW_FF_VERT_PROGRAM; 910 memcpy(&ctx->Light.Material, &attr->Light.Material, 911 sizeof(struct gl_material)); 912 if (ctx->Extensions.ARB_color_buffer_float) { 913 TEST_AND_CALL1_SEL(Light.ClampVertexColor, ClampColor, GL_CLAMP_VERTEX_COLOR_ARB); 914 } 915 } 916 917 if (mask & GL_LINE_BIT) { 918 TEST_AND_UPDATE(ctx->Line.SmoothFlag, attr->Line.SmoothFlag, GL_LINE_SMOOTH); 919 TEST_AND_UPDATE(ctx->Line.StippleFlag, attr->Line.StippleFlag, GL_LINE_STIPPLE); 920 TEST_AND_CALL2(Line.StippleFactor, Line.StipplePattern, LineStipple); 921 TEST_AND_CALL1(Line.Width, LineWidth); 922 } 923 924 if (mask & GL_LIST_BIT) 925 memcpy(&ctx->List, &attr->List, sizeof(struct gl_list_attrib)); 926 927 if (mask & GL_PIXEL_MODE_BIT) { 928 memcpy(&ctx->Pixel, &attr->Pixel, sizeof(struct gl_pixel_attrib)); 929 /* XXX what other pixel state needs to be set by function calls? */ 930 _mesa_ReadBuffer(ctx->Pixel.ReadBuffer); 931 ctx->NewState |= _NEW_PIXEL; 932 } 933 934 if (mask & GL_POINT_BIT) { 935 TEST_AND_CALL1(Point.Size, PointSize); 936 TEST_AND_UPDATE(ctx->Point.SmoothFlag, attr->Point.SmoothFlag, GL_POINT_SMOOTH); 937 _mesa_PointParameterfv(GL_DISTANCE_ATTENUATION_EXT, attr->Point.Params); 938 TEST_AND_CALL1_SEL(Point.MinSize, PointParameterf, GL_POINT_SIZE_MIN_EXT); 939 TEST_AND_CALL1_SEL(Point.MaxSize, PointParameterf, GL_POINT_SIZE_MAX_EXT); 940 TEST_AND_CALL1_SEL(Point.Threshold, PointParameterf, GL_POINT_FADE_THRESHOLD_SIZE_EXT); 941 942 if (ctx->Extensions.ARB_point_sprite) { 943 if (ctx->Point.CoordReplace != attr->Point.CoordReplace) { 944 ctx->NewState |= _NEW_POINT | _NEW_FF_VERT_PROGRAM; 945 ctx->Point.CoordReplace = attr->Point.CoordReplace; 946 } 947 TEST_AND_UPDATE(ctx->Point.PointSprite, attr->Point.PointSprite, 948 GL_POINT_SPRITE); 949 950 if ((ctx->API == API_OPENGL_COMPAT && ctx->Version >= 20) 951 || ctx->API == API_OPENGL_CORE) 952 TEST_AND_CALL1_SEL(Point.SpriteOrigin, PointParameterf, GL_POINT_SPRITE_COORD_ORIGIN); 953 } 954 } 955 956 if (mask & GL_POLYGON_BIT) { 957 TEST_AND_CALL1(Polygon.CullFaceMode, CullFace); 958 TEST_AND_CALL1(Polygon.FrontFace, FrontFace); 959 TEST_AND_CALL1_SEL(Polygon.FrontMode, PolygonMode, GL_FRONT); 960 TEST_AND_CALL1_SEL(Polygon.BackMode, PolygonMode, GL_BACK); 961 _mesa_polygon_offset_clamp(ctx, 962 attr->Polygon.OffsetFactor, 963 attr->Polygon.OffsetUnits, 964 attr->Polygon.OffsetClamp); 965 TEST_AND_UPDATE(ctx->Polygon.SmoothFlag, attr->Polygon.SmoothFlag, GL_POLYGON_SMOOTH); 966 TEST_AND_UPDATE(ctx->Polygon.StippleFlag, attr->Polygon.StippleFlag, GL_POLYGON_STIPPLE); 967 TEST_AND_UPDATE(ctx->Polygon.CullFlag, attr->Polygon.CullFlag, GL_CULL_FACE); 968 TEST_AND_UPDATE(ctx->Polygon.OffsetPoint, attr->Polygon.OffsetPoint, 969 GL_POLYGON_OFFSET_POINT); 970 TEST_AND_UPDATE(ctx->Polygon.OffsetLine, attr->Polygon.OffsetLine, 971 GL_POLYGON_OFFSET_LINE); 972 TEST_AND_UPDATE(ctx->Polygon.OffsetFill, attr->Polygon.OffsetFill, 973 GL_POLYGON_OFFSET_FILL); 974 } 975 976 if (mask & GL_POLYGON_STIPPLE_BIT) { 977 memcpy(ctx->PolygonStipple, attr->PolygonStipple, 32*sizeof(GLuint)); 978 979 ctx->NewDriverState |= ST_NEW_POLY_STIPPLE; 980 } 981 982 if (mask & GL_SCISSOR_BIT) { 983 unsigned i; 984 985 for (i = 0; i < ctx->Const.MaxViewports; i++) { 986 _mesa_set_scissor(ctx, i, 987 attr->Scissor.ScissorArray[i].X, 988 attr->Scissor.ScissorArray[i].Y, 989 attr->Scissor.ScissorArray[i].Width, 990 attr->Scissor.ScissorArray[i].Height); 991 TEST_AND_UPDATE_INDEX(ctx->Scissor.EnableFlags, 992 attr->Scissor.EnableFlags, i, GL_SCISSOR_TEST); 993 } 994 if (ctx->Extensions.EXT_window_rectangles) { 995 STATIC_ASSERT(sizeof(struct gl_scissor_rect) == 996 4 * sizeof(GLint)); 997 _mesa_WindowRectanglesEXT( 998 attr->Scissor.WindowRectMode, attr->Scissor.NumWindowRects, 999 (const GLint *)attr->Scissor.WindowRects); 1000 } 1001 } 1002 1003 if (mask & GL_STENCIL_BUFFER_BIT) { 1004 TEST_AND_UPDATE(ctx->Stencil.Enabled, attr->Stencil.Enabled, 1005 GL_STENCIL_TEST); 1006 TEST_AND_CALL1(Stencil.Clear, ClearStencil); 1007 if (ctx->Extensions.EXT_stencil_two_side) { 1008 TEST_AND_UPDATE(ctx->Stencil.TestTwoSide, attr->Stencil.TestTwoSide, 1009 GL_STENCIL_TEST_TWO_SIDE_EXT); 1010 _mesa_ActiveStencilFaceEXT(attr->Stencil.ActiveFace 1011 ? GL_BACK : GL_FRONT); 1012 } 1013 /* front state */ 1014 _mesa_StencilFuncSeparate(GL_FRONT, 1015 attr->Stencil.Function[0], 1016 attr->Stencil.Ref[0], 1017 attr->Stencil.ValueMask[0]); 1018 TEST_AND_CALL1_SEL(Stencil.WriteMask[0], StencilMaskSeparate, GL_FRONT); 1019 _mesa_StencilOpSeparate(GL_FRONT, attr->Stencil.FailFunc[0], 1020 attr->Stencil.ZFailFunc[0], 1021 attr->Stencil.ZPassFunc[0]); 1022 /* back state */ 1023 _mesa_StencilFuncSeparate(GL_BACK, 1024 attr->Stencil.Function[1], 1025 attr->Stencil.Ref[1], 1026 attr->Stencil.ValueMask[1]); 1027 TEST_AND_CALL1_SEL(Stencil.WriteMask[1], StencilMaskSeparate, GL_BACK); 1028 _mesa_StencilOpSeparate(GL_BACK, attr->Stencil.FailFunc[1], 1029 attr->Stencil.ZFailFunc[1], 1030 attr->Stencil.ZPassFunc[1]); 1031 } 1032 1033 if (mask & GL_TRANSFORM_BIT) { 1034 GLuint i; 1035 TEST_AND_CALL1(Transform.MatrixMode, MatrixMode); 1036 if (_math_matrix_is_dirty(ctx->ProjectionMatrixStack.Top)) 1037 _math_matrix_analyse(ctx->ProjectionMatrixStack.Top); 1038 1039 ctx->NewState |= _NEW_TRANSFORM; 1040 ctx->NewDriverState |= ST_NEW_CLIP_STATE; 1041 1042 /* restore clip planes */ 1043 for (i = 0; i < ctx->Const.MaxClipPlanes; i++) { 1044 const GLfloat *eyePlane = attr->Transform.EyeUserPlane[i]; 1045 COPY_4V(ctx->Transform.EyeUserPlane[i], eyePlane); 1046 TEST_AND_UPDATE_BIT(ctx->Transform.ClipPlanesEnabled, 1047 attr->Transform.ClipPlanesEnabled, i, 1048 GL_CLIP_PLANE0 + i); 1049 } 1050 1051 /* normalize/rescale */ 1052 TEST_AND_UPDATE(ctx->Transform.Normalize, attr->Transform.Normalize, 1053 GL_NORMALIZE); 1054 TEST_AND_UPDATE(ctx->Transform.RescaleNormals, 1055 attr->Transform.RescaleNormals, GL_RESCALE_NORMAL_EXT); 1056 1057 if (!ctx->Extensions.AMD_depth_clamp_separate) { 1058 TEST_AND_UPDATE(ctx->Transform.DepthClampNear && 1059 ctx->Transform.DepthClampFar, 1060 attr->Transform.DepthClampNear && 1061 attr->Transform.DepthClampFar, GL_DEPTH_CLAMP); 1062 } else { 1063 TEST_AND_UPDATE(ctx->Transform.DepthClampNear, 1064 attr->Transform.DepthClampNear, 1065 GL_DEPTH_CLAMP_NEAR_AMD); 1066 TEST_AND_UPDATE(ctx->Transform.DepthClampFar, 1067 attr->Transform.DepthClampFar, 1068 GL_DEPTH_CLAMP_FAR_AMD); 1069 } 1070 1071 if (ctx->Extensions.ARB_clip_control) { 1072 TEST_AND_CALL2(Transform.ClipOrigin, Transform.ClipDepthMode, 1073 ClipControl); 1074 } 1075 } 1076 1077 if (mask & GL_TEXTURE_BIT) { 1078 pop_texture_group(ctx, &attr->Texture); 1079 ctx->NewState |= _NEW_TEXTURE_OBJECT | _NEW_TEXTURE_STATE | 1080 _NEW_FF_VERT_PROGRAM | _NEW_FF_FRAG_PROGRAM; 1081 } 1082 1083 if (mask & GL_VIEWPORT_BIT) { 1084 unsigned i; 1085 1086 for (i = 0; i < ctx->Const.MaxViewports; i++) { 1087 const struct gl_viewport_attrib *vp = &attr->Viewport.ViewportArray[i]; 1088 1089 if (memcmp(&ctx->ViewportArray[i].X, &vp->X, sizeof(float) * 6)) { 1090 ctx->NewState |= _NEW_VIEWPORT; 1091 ctx->NewDriverState |= ST_NEW_VIEWPORT; 1092 1093 memcpy(&ctx->ViewportArray[i].X, &vp->X, sizeof(float) * 6); 1094 1095 if (ctx->invalidate_on_gl_viewport) 1096 st_manager_invalidate_drawables(ctx); 1097 } 1098 } 1099 1100 if (ctx->Extensions.NV_conservative_raster) { 1101 GLuint biasx = attr->Viewport.SubpixelPrecisionBias[0]; 1102 GLuint biasy = attr->Viewport.SubpixelPrecisionBias[1]; 1103 _mesa_SubpixelPrecisionBiasNV(biasx, biasy); 1104 } 1105 } 1106 1107 if (mask & GL_MULTISAMPLE_BIT_ARB) { 1108 TEST_AND_UPDATE(ctx->Multisample.Enabled, 1109 attr->Multisample.Enabled, 1110 GL_MULTISAMPLE); 1111 1112 TEST_AND_UPDATE(ctx->Multisample.SampleCoverage, 1113 attr->Multisample.SampleCoverage, 1114 GL_SAMPLE_COVERAGE); 1115 1116 TEST_AND_UPDATE(ctx->Multisample.SampleAlphaToCoverage, 1117 attr->Multisample.SampleAlphaToCoverage, 1118 GL_SAMPLE_ALPHA_TO_COVERAGE); 1119 1120 TEST_AND_UPDATE(ctx->Multisample.SampleAlphaToOne, 1121 attr->Multisample.SampleAlphaToOne, 1122 GL_SAMPLE_ALPHA_TO_ONE); 1123 1124 TEST_AND_CALL2(Multisample.SampleCoverageValue, 1125 Multisample.SampleCoverageInvert, SampleCoverage); 1126 1127 TEST_AND_CALL1(Multisample.SampleAlphaToCoverageDitherControl, 1128 AlphaToCoverageDitherControlNV); 1129 } 1130 1131 ctx->PopAttribState = attr->OldPopAttribStateMask; 1132} 1133 1134 1135/** 1136 * Copy gl_pixelstore_attrib from src to dst, updating buffer 1137 * object refcounts. 1138 */ 1139static void 1140copy_pixelstore(struct gl_context *ctx, 1141 struct gl_pixelstore_attrib *dst, 1142 const struct gl_pixelstore_attrib *src) 1143{ 1144 dst->Alignment = src->Alignment; 1145 dst->RowLength = src->RowLength; 1146 dst->SkipPixels = src->SkipPixels; 1147 dst->SkipRows = src->SkipRows; 1148 dst->ImageHeight = src->ImageHeight; 1149 dst->SkipImages = src->SkipImages; 1150 dst->SwapBytes = src->SwapBytes; 1151 dst->LsbFirst = src->LsbFirst; 1152 dst->Invert = src->Invert; 1153 _mesa_reference_buffer_object(ctx, &dst->BufferObj, src->BufferObj); 1154} 1155 1156 1157#define GL_CLIENT_PACK_BIT (1<<20) 1158#define GL_CLIENT_UNPACK_BIT (1<<21) 1159 1160static void 1161copy_vertex_attrib_array(struct gl_context *ctx, 1162 struct gl_array_attributes *dst, 1163 const struct gl_array_attributes *src) 1164{ 1165 dst->Ptr = src->Ptr; 1166 dst->RelativeOffset = src->RelativeOffset; 1167 dst->Format = src->Format; 1168 dst->Stride = src->Stride; 1169 dst->BufferBindingIndex = src->BufferBindingIndex; 1170 dst->_EffBufferBindingIndex = src->_EffBufferBindingIndex; 1171 dst->_EffRelativeOffset = src->_EffRelativeOffset; 1172} 1173 1174static void 1175copy_vertex_buffer_binding(struct gl_context *ctx, 1176 struct gl_vertex_buffer_binding *dst, 1177 const struct gl_vertex_buffer_binding *src) 1178{ 1179 dst->Offset = src->Offset; 1180 dst->Stride = src->Stride; 1181 dst->InstanceDivisor = src->InstanceDivisor; 1182 dst->_BoundArrays = src->_BoundArrays; 1183 dst->_EffBoundArrays = src->_EffBoundArrays; 1184 dst->_EffOffset = src->_EffOffset; 1185 1186 _mesa_reference_buffer_object(ctx, &dst->BufferObj, src->BufferObj); 1187} 1188 1189/** 1190 * Copy gl_vertex_array_object from src to dest. 1191 * 'dest' must be in an initialized state. 1192 */ 1193static void 1194copy_array_object(struct gl_context *ctx, 1195 struct gl_vertex_array_object *dest, 1196 struct gl_vertex_array_object *src, 1197 unsigned copy_attrib_mask) 1198{ 1199 /* skip Name */ 1200 /* skip RefCount */ 1201 1202 while (copy_attrib_mask) { 1203 unsigned i = u_bit_scan(©_attrib_mask); 1204 1205 copy_vertex_attrib_array(ctx, &dest->VertexAttrib[i], &src->VertexAttrib[i]); 1206 copy_vertex_buffer_binding(ctx, &dest->BufferBinding[i], &src->BufferBinding[i]); 1207 } 1208 1209 /* Enabled must be the same than on push */ 1210 dest->Enabled = src->Enabled; 1211 dest->_EnabledWithMapMode = src->_EnabledWithMapMode; 1212 dest->_EffEnabledVBO = src->_EffEnabledVBO; 1213 dest->_EffEnabledNonZeroDivisor = src->_EffEnabledNonZeroDivisor; 1214 /* The bitmask of bound VBOs needs to match the VertexBinding array */ 1215 dest->VertexAttribBufferMask = src->VertexAttribBufferMask; 1216 dest->NonZeroDivisorMask = src->NonZeroDivisorMask; 1217 dest->_AttributeMapMode = src->_AttributeMapMode; 1218 dest->NewVertexBuffers = src->NewVertexBuffers; 1219 dest->NewVertexElements = src->NewVertexElements; 1220 /* skip NumUpdates and IsDynamic because they can only increase, not decrease */ 1221} 1222 1223/** 1224 * Copy gl_array_attrib from src to dest. 1225 * 'dest' must be in an initialized state. 1226 */ 1227static void 1228copy_array_attrib(struct gl_context *ctx, 1229 struct gl_array_attrib *dest, 1230 struct gl_array_attrib *src, 1231 bool vbo_deleted, 1232 unsigned copy_attrib_mask) 1233{ 1234 /* skip ArrayObj */ 1235 /* skip DefaultArrayObj, Objects */ 1236 dest->ActiveTexture = src->ActiveTexture; 1237 dest->LockFirst = src->LockFirst; 1238 dest->LockCount = src->LockCount; 1239 dest->PrimitiveRestart = src->PrimitiveRestart; 1240 dest->PrimitiveRestartFixedIndex = src->PrimitiveRestartFixedIndex; 1241 dest->RestartIndex = src->RestartIndex; 1242 memcpy(dest->_PrimitiveRestart, src->_PrimitiveRestart, 1243 sizeof(src->_PrimitiveRestart)); 1244 memcpy(dest->_RestartIndex, src->_RestartIndex, sizeof(src->_RestartIndex)); 1245 /* skip NewState */ 1246 /* skip RebindArrays */ 1247 1248 if (!vbo_deleted) 1249 copy_array_object(ctx, dest->VAO, src->VAO, copy_attrib_mask); 1250 1251 /* skip ArrayBufferObj */ 1252 /* skip IndexBufferObj */ 1253} 1254 1255/** 1256 * Save the content of src to dest. 1257 */ 1258static void 1259save_array_attrib(struct gl_context *ctx, 1260 struct gl_array_attrib *dest, 1261 struct gl_array_attrib *src) 1262{ 1263 /* Set the Name, needed for restore, but do never overwrite. 1264 * Needs to match value in the object hash. */ 1265 dest->VAO->Name = src->VAO->Name; 1266 dest->VAO->NonDefaultStateMask = src->VAO->NonDefaultStateMask; 1267 /* And copy all of the rest. */ 1268 copy_array_attrib(ctx, dest, src, false, src->VAO->NonDefaultStateMask); 1269 1270 /* Just reference them here */ 1271 _mesa_reference_buffer_object(ctx, &dest->ArrayBufferObj, 1272 src->ArrayBufferObj); 1273 _mesa_reference_buffer_object(ctx, &dest->VAO->IndexBufferObj, 1274 src->VAO->IndexBufferObj); 1275} 1276 1277/** 1278 * Restore the content of src to dest. 1279 */ 1280static void 1281restore_array_attrib(struct gl_context *ctx, 1282 struct gl_array_attrib *dest, 1283 struct gl_array_attrib *src) 1284{ 1285 bool is_vao_name_zero = src->VAO->Name == 0; 1286 1287 /* The ARB_vertex_array_object spec says: 1288 * 1289 * "BindVertexArray fails and an INVALID_OPERATION error is generated 1290 * if array is not a name returned from a previous call to 1291 * GenVertexArrays, or if such a name has since been deleted with 1292 * DeleteVertexArrays." 1293 * 1294 * Therefore popping a deleted VAO cannot magically recreate it. 1295 */ 1296 if (!is_vao_name_zero && !_mesa_IsVertexArray(src->VAO->Name)) 1297 return; 1298 1299 _mesa_BindVertexArray(src->VAO->Name); 1300 1301 /* Restore or recreate the buffer objects by the names ... */ 1302 if (is_vao_name_zero || !src->ArrayBufferObj || 1303 _mesa_IsBuffer(src->ArrayBufferObj->Name)) { 1304 /* ... and restore its content */ 1305 dest->VAO->NonDefaultStateMask |= src->VAO->NonDefaultStateMask; 1306 copy_array_attrib(ctx, dest, src, false, 1307 dest->VAO->NonDefaultStateMask); 1308 1309 _mesa_BindBuffer(GL_ARRAY_BUFFER_ARB, 1310 src->ArrayBufferObj ? 1311 src->ArrayBufferObj->Name : 0); 1312 } else { 1313 copy_array_attrib(ctx, dest, src, true, 0); 1314 } 1315 1316 /* Invalidate array state. It will be updated during the next draw. */ 1317 _mesa_set_draw_vao(ctx, ctx->Array._EmptyVAO, 0); 1318 1319 if (is_vao_name_zero || !src->VAO->IndexBufferObj || 1320 _mesa_IsBuffer(src->VAO->IndexBufferObj->Name)) { 1321 _mesa_BindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 1322 src->VAO->IndexBufferObj ? 1323 src->VAO->IndexBufferObj->Name : 0); 1324 } 1325} 1326 1327 1328void GLAPIENTRY 1329_mesa_PushClientAttrib(GLbitfield mask) 1330{ 1331 struct gl_client_attrib_node *head; 1332 1333 GET_CURRENT_CONTEXT(ctx); 1334 1335 if (ctx->ClientAttribStackDepth >= MAX_CLIENT_ATTRIB_STACK_DEPTH) { 1336 _mesa_error(ctx, GL_STACK_OVERFLOW, "glPushClientAttrib"); 1337 return; 1338 } 1339 1340 head = &ctx->ClientAttribStack[ctx->ClientAttribStackDepth]; 1341 head->Mask = mask; 1342 1343 if (mask & GL_CLIENT_PIXEL_STORE_BIT) { 1344 copy_pixelstore(ctx, &head->Pack, &ctx->Pack); 1345 copy_pixelstore(ctx, &head->Unpack, &ctx->Unpack); 1346 } 1347 1348 if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) { 1349 _mesa_initialize_vao(ctx, &head->VAO, 0); 1350 /* Use the VAO declared within the node instead of allocating it. */ 1351 head->Array.VAO = &head->VAO; 1352 save_array_attrib(ctx, &head->Array, &ctx->Array); 1353 } 1354 1355 ctx->ClientAttribStackDepth++; 1356} 1357 1358 1359void GLAPIENTRY 1360_mesa_PopClientAttrib(void) 1361{ 1362 struct gl_client_attrib_node *head; 1363 1364 GET_CURRENT_CONTEXT(ctx); 1365 1366 if (ctx->ClientAttribStackDepth == 0) { 1367 _mesa_error(ctx, GL_STACK_UNDERFLOW, "glPopClientAttrib"); 1368 return; 1369 } 1370 1371 ctx->ClientAttribStackDepth--; 1372 head = &ctx->ClientAttribStack[ctx->ClientAttribStackDepth]; 1373 1374 if (head->Mask & GL_CLIENT_PIXEL_STORE_BIT) { 1375 copy_pixelstore(ctx, &ctx->Pack, &head->Pack); 1376 _mesa_reference_buffer_object(ctx, &head->Pack.BufferObj, NULL); 1377 1378 copy_pixelstore(ctx, &ctx->Unpack, &head->Unpack); 1379 _mesa_reference_buffer_object(ctx, &head->Unpack.BufferObj, NULL); 1380 } 1381 1382 if (head->Mask & GL_CLIENT_VERTEX_ARRAY_BIT) { 1383 restore_array_attrib(ctx, &ctx->Array, &head->Array); 1384 1385 /* _mesa_unbind_array_object_vbos can't use NonDefaultStateMask because 1386 * it's used by internal VAOs which don't always update the mask, so do 1387 * it manually here. 1388 */ 1389 GLbitfield mask = head->VAO.NonDefaultStateMask; 1390 while (mask) { 1391 unsigned i = u_bit_scan(&mask); 1392 _mesa_reference_buffer_object(ctx, &head->VAO.BufferBinding[i].BufferObj, NULL); 1393 } 1394 1395 _mesa_reference_buffer_object(ctx, &head->VAO.IndexBufferObj, NULL); 1396 _mesa_reference_buffer_object(ctx, &head->Array.ArrayBufferObj, NULL); 1397 } 1398} 1399 1400void GLAPIENTRY 1401_mesa_ClientAttribDefaultEXT( GLbitfield mask ) 1402{ 1403 if (mask & GL_CLIENT_PIXEL_STORE_BIT) { 1404 _mesa_PixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE); 1405 _mesa_PixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE); 1406 _mesa_PixelStorei(GL_UNPACK_IMAGE_HEIGHT, 0); 1407 _mesa_PixelStorei(GL_UNPACK_SKIP_IMAGES, 0); 1408 _mesa_PixelStorei(GL_UNPACK_ROW_LENGTH, 0); 1409 _mesa_PixelStorei(GL_UNPACK_SKIP_ROWS, 0); 1410 _mesa_PixelStorei(GL_UNPACK_SKIP_PIXELS, 0); 1411 _mesa_PixelStorei(GL_UNPACK_ALIGNMENT, 4); 1412 _mesa_PixelStorei(GL_PACK_SWAP_BYTES, GL_FALSE); 1413 _mesa_PixelStorei(GL_PACK_LSB_FIRST, GL_FALSE); 1414 _mesa_PixelStorei(GL_PACK_IMAGE_HEIGHT, 0); 1415 _mesa_PixelStorei(GL_PACK_SKIP_IMAGES, 0); 1416 _mesa_PixelStorei(GL_PACK_ROW_LENGTH, 0); 1417 _mesa_PixelStorei(GL_PACK_SKIP_ROWS, 0); 1418 _mesa_PixelStorei(GL_PACK_SKIP_PIXELS, 0); 1419 _mesa_PixelStorei(GL_PACK_ALIGNMENT, 4); 1420 1421 _mesa_BindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); 1422 _mesa_BindBuffer(GL_PIXEL_PACK_BUFFER, 0); 1423 } 1424 if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) { 1425 GET_CURRENT_CONTEXT(ctx); 1426 int i; 1427 1428 _mesa_BindBuffer(GL_ARRAY_BUFFER, 0); 1429 _mesa_BindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); 1430 1431 _mesa_DisableClientState(GL_EDGE_FLAG_ARRAY); 1432 _mesa_EdgeFlagPointer(0, 0); 1433 1434 _mesa_DisableClientState(GL_INDEX_ARRAY); 1435 _mesa_IndexPointer(GL_FLOAT, 0, 0); 1436 1437 _mesa_DisableClientState(GL_SECONDARY_COLOR_ARRAY); 1438 _mesa_SecondaryColorPointer(4, GL_FLOAT, 0, 0); 1439 1440 _mesa_DisableClientState(GL_FOG_COORD_ARRAY); 1441 _mesa_FogCoordPointer(GL_FLOAT, 0, 0); 1442 1443 for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) { 1444 _mesa_ClientActiveTexture(GL_TEXTURE0 + i); 1445 _mesa_DisableClientState(GL_TEXTURE_COORD_ARRAY); 1446 _mesa_TexCoordPointer(4, GL_FLOAT, 0, 0); 1447 } 1448 1449 _mesa_DisableClientState(GL_COLOR_ARRAY); 1450 _mesa_ColorPointer(4, GL_FLOAT, 0, 0); 1451 1452 _mesa_DisableClientState(GL_NORMAL_ARRAY); 1453 _mesa_NormalPointer(GL_FLOAT, 0, 0); 1454 1455 _mesa_DisableClientState(GL_VERTEX_ARRAY); 1456 _mesa_VertexPointer(4, GL_FLOAT, 0, 0); 1457 1458 for (i = 0; i < ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs; i++) { 1459 _mesa_DisableVertexAttribArray(i); 1460 _mesa_VertexAttribPointer(i, 4, GL_FLOAT, GL_FALSE, 0, 0); 1461 } 1462 1463 _mesa_ClientActiveTexture(GL_TEXTURE0); 1464 1465 _mesa_PrimitiveRestartIndex_no_error(0); 1466 if (ctx->Version >= 31) 1467 _mesa_Disable(GL_PRIMITIVE_RESTART); 1468 else if (_mesa_has_NV_primitive_restart(ctx)) 1469 _mesa_DisableClientState(GL_PRIMITIVE_RESTART_NV); 1470 1471 if (_mesa_has_ARB_ES3_compatibility(ctx)) 1472 _mesa_Disable(GL_PRIMITIVE_RESTART_FIXED_INDEX); 1473 } 1474} 1475 1476void GLAPIENTRY 1477_mesa_PushClientAttribDefaultEXT( GLbitfield mask ) 1478{ 1479 _mesa_PushClientAttrib(mask); 1480 _mesa_ClientAttribDefaultEXT(mask); 1481} 1482 1483 1484/** 1485 * Free any attribute state data that might be attached to the context. 1486 */ 1487void 1488_mesa_free_attrib_data(struct gl_context *ctx) 1489{ 1490 for (unsigned i = 0; i < ARRAY_SIZE(ctx->AttribStack); i++) 1491 FREE(ctx->AttribStack[i]); 1492} 1493 1494 1495void 1496_mesa_init_attrib(struct gl_context *ctx) 1497{ 1498 /* Renderer and client attribute stacks */ 1499 ctx->AttribStackDepth = 0; 1500 ctx->ClientAttribStackDepth = 0; 1501} 1502