1 /**
2 * \file enable.c
3 * Enable/disable/query GL capabilities.
4 */
5
6 /*
7 * Mesa 3-D graphics library
8 *
9 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
10 *
11 * Permission is hereby granted, free of charge, to any person obtaining a
12 * copy of this software and associated documentation files (the "Software"),
13 * to deal in the Software without restriction, including without limitation
14 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
15 * and/or sell copies of the Software, and to permit persons to whom the
16 * Software is furnished to do so, subject to the following conditions:
17 *
18 * The above copyright notice and this permission notice shall be included
19 * in all copies or substantial portions of the Software.
20 *
21 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
22 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
24 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
25 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
26 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
27 * OTHER DEALINGS IN THE SOFTWARE.
28 */
29
30
31 #include "glheader.h"
32 #include "arrayobj.h"
33 #include "blend.h"
34 #include "clip.h"
35 #include "context.h"
36 #include "debug_output.h"
37 #include "draw_validate.h"
38 #include "enable.h"
39 #include "errors.h"
40 #include "light.h"
41 #include "mtypes.h"
42 #include "enums.h"
43 #include "state.h"
44 #include "texstate.h"
45 #include "varray.h"
46 #include "api_exec_decl.h"
47
48 #include "state_tracker/st_cb_bitmap.h"
49 #include "state_tracker/st_context.h"
50
51 void
_mesa_update_derived_primitive_restart_state(struct gl_context * ctx)52 _mesa_update_derived_primitive_restart_state(struct gl_context *ctx)
53 {
54 if (ctx->Array.PrimitiveRestart ||
55 ctx->Array.PrimitiveRestartFixedIndex) {
56 unsigned restart_index[3] = {
57 _mesa_primitive_restart_index(ctx, 1),
58 _mesa_primitive_restart_index(ctx, 2),
59 _mesa_primitive_restart_index(ctx, 4),
60 };
61
62 ctx->Array._RestartIndex[0] = restart_index[0];
63 ctx->Array._RestartIndex[1] = restart_index[1];
64 ctx->Array._RestartIndex[2] = restart_index[2];
65
66 /* Enable primitive restart only when the restart index can have an
67 * effect. This is required for correctness in AMD GFX8 support.
68 * Other hardware may also benefit from taking a faster, non-restart path
69 * when possible.
70 */
71 ctx->Array._PrimitiveRestart[0] = true && restart_index[0] <= UINT8_MAX;
72 ctx->Array._PrimitiveRestart[1] = true && restart_index[1] <= UINT16_MAX;
73 ctx->Array._PrimitiveRestart[2] = true;
74 } else {
75 ctx->Array._PrimitiveRestart[0] = false;
76 ctx->Array._PrimitiveRestart[1] = false;
77 ctx->Array._PrimitiveRestart[2] = false;
78 }
79 }
80
81
82 /**
83 * Helper to enable/disable VAO client-side state.
84 */
85 static void
vao_state(struct gl_context * ctx,struct gl_vertex_array_object * vao,gl_vert_attrib attr,GLboolean state)86 vao_state(struct gl_context *ctx, struct gl_vertex_array_object* vao,
87 gl_vert_attrib attr, GLboolean state)
88 {
89 if (state)
90 _mesa_enable_vertex_array_attrib(ctx, vao, attr);
91 else
92 _mesa_disable_vertex_array_attrib(ctx, vao, attr);
93 }
94
95
96 /**
97 * Helper to enable/disable client-side state.
98 */
99 static void
client_state(struct gl_context * ctx,struct gl_vertex_array_object * vao,GLenum cap,GLboolean state)100 client_state(struct gl_context *ctx, struct gl_vertex_array_object* vao,
101 GLenum cap, GLboolean state)
102 {
103 switch (cap) {
104 case GL_VERTEX_ARRAY:
105 vao_state(ctx, vao, VERT_ATTRIB_POS, state);
106 break;
107 case GL_NORMAL_ARRAY:
108 vao_state(ctx, vao, VERT_ATTRIB_NORMAL, state);
109 break;
110 case GL_COLOR_ARRAY:
111 vao_state(ctx, vao, VERT_ATTRIB_COLOR0, state);
112 break;
113 case GL_INDEX_ARRAY:
114 vao_state(ctx, vao, VERT_ATTRIB_COLOR_INDEX, state);
115 break;
116 case GL_TEXTURE_COORD_ARRAY:
117 vao_state(ctx, vao, VERT_ATTRIB_TEX(ctx->Array.ActiveTexture), state);
118 break;
119 case GL_EDGE_FLAG_ARRAY:
120 vao_state(ctx, vao, VERT_ATTRIB_EDGEFLAG, state);
121 break;
122 case GL_FOG_COORDINATE_ARRAY_EXT:
123 vao_state(ctx, vao, VERT_ATTRIB_FOG, state);
124 break;
125 case GL_SECONDARY_COLOR_ARRAY_EXT:
126 vao_state(ctx, vao, VERT_ATTRIB_COLOR1, state);
127 break;
128
129 case GL_POINT_SIZE_ARRAY_OES:
130 if (ctx->VertexProgram.PointSizeEnabled != state) {
131 FLUSH_VERTICES(ctx, _NEW_PROGRAM, 0);
132 ctx->VertexProgram.PointSizeEnabled = state;
133 }
134 vao_state(ctx, vao, VERT_ATTRIB_POINT_SIZE, state);
135 break;
136
137 /* GL_NV_primitive_restart */
138 case GL_PRIMITIVE_RESTART_NV:
139 if (!_mesa_has_NV_primitive_restart(ctx))
140 goto invalid_enum_error;
141 if (ctx->Array.PrimitiveRestart == state)
142 return;
143
144 ctx->Array.PrimitiveRestart = state;
145 _mesa_update_derived_primitive_restart_state(ctx);
146 return;
147
148 default:
149 goto invalid_enum_error;
150 }
151 return;
152
153 invalid_enum_error:
154 _mesa_error(ctx, GL_INVALID_ENUM, "gl%sClientState(%s)",
155 state ? "Enable" : "Disable", _mesa_enum_to_string(cap));
156 }
157
158
159 /* Helper for GL_EXT_direct_state_access following functions:
160 * - EnableClientStateIndexedEXT
161 * - EnableClientStateiEXT
162 * - DisableClientStateIndexedEXT
163 * - DisableClientStateiEXT
164 */
165 static void
client_state_i(struct gl_context * ctx,struct gl_vertex_array_object * vao,GLenum cap,GLuint index,GLboolean state)166 client_state_i(struct gl_context *ctx, struct gl_vertex_array_object* vao,
167 GLenum cap, GLuint index, GLboolean state)
168 {
169 int saved_active;
170
171 if (cap != GL_TEXTURE_COORD_ARRAY) {
172 _mesa_error(ctx, GL_INVALID_ENUM, "gl%sClientStateiEXT(cap=%s)",
173 state ? "Enable" : "Disable",
174 _mesa_enum_to_string(cap));
175 return;
176 }
177
178 if (index >= ctx->Const.MaxTextureCoordUnits) {
179 _mesa_error(ctx, GL_INVALID_VALUE, "gl%sClientStateiEXT(index=%d)",
180 state ? "Enable" : "Disable",
181 index);
182 return;
183 }
184
185 saved_active = ctx->Array.ActiveTexture;
186 _mesa_ClientActiveTexture(GL_TEXTURE0 + index);
187 client_state(ctx, vao, cap, state);
188 _mesa_ClientActiveTexture(GL_TEXTURE0 + saved_active);
189 }
190
191
192 /**
193 * Enable GL capability.
194 * \param cap state to enable/disable.
195 *
196 * Get's the current context, assures that we're outside glBegin()/glEnd() and
197 * calls client_state().
198 */
199 void GLAPIENTRY
_mesa_EnableClientState(GLenum cap)200 _mesa_EnableClientState( GLenum cap )
201 {
202 GET_CURRENT_CONTEXT(ctx);
203 client_state( ctx, ctx->Array.VAO, cap, GL_TRUE );
204 }
205
206
207 void GLAPIENTRY
_mesa_EnableVertexArrayEXT(GLuint vaobj,GLenum cap)208 _mesa_EnableVertexArrayEXT( GLuint vaobj, GLenum cap )
209 {
210 GET_CURRENT_CONTEXT(ctx);
211 struct gl_vertex_array_object* vao = _mesa_lookup_vao_err(ctx, vaobj,
212 true,
213 "glEnableVertexArrayEXT");
214 if (!vao)
215 return;
216
217 /* The EXT_direct_state_access spec says:
218 * "Additionally EnableVertexArrayEXT and DisableVertexArrayEXT accept
219 * the tokens TEXTURE0 through TEXTUREn where n is less than the
220 * implementation-dependent limit of MAX_TEXTURE_COORDS. For these
221 * GL_TEXTUREi tokens, EnableVertexArrayEXT and DisableVertexArrayEXT
222 * act identically to EnableVertexArrayEXT(vaobj, TEXTURE_COORD_ARRAY)
223 * or DisableVertexArrayEXT(vaobj, TEXTURE_COORD_ARRAY) respectively
224 * as if the active client texture is set to texture coordinate set i
225 * based on the token TEXTUREi indicated by array."
226 */
227 if (GL_TEXTURE0 <= cap && cap < GL_TEXTURE0 + ctx->Const.MaxTextureCoordUnits) {
228 GLuint saved_active = ctx->Array.ActiveTexture;
229 _mesa_ClientActiveTexture(cap);
230 client_state(ctx, vao, GL_TEXTURE_COORD_ARRAY, GL_TRUE);
231 _mesa_ClientActiveTexture(GL_TEXTURE0 + saved_active);
232 } else {
233 client_state(ctx, vao, cap, GL_TRUE);
234 }
235 }
236
237
238 void GLAPIENTRY
_mesa_EnableClientStateiEXT(GLenum cap,GLuint index)239 _mesa_EnableClientStateiEXT( GLenum cap, GLuint index )
240 {
241 GET_CURRENT_CONTEXT(ctx);
242 client_state_i(ctx, ctx->Array.VAO, cap, index, GL_TRUE);
243 }
244
245
246 /**
247 * Disable GL capability.
248 * \param cap state to enable/disable.
249 *
250 * Get's the current context, assures that we're outside glBegin()/glEnd() and
251 * calls client_state().
252 */
253 void GLAPIENTRY
_mesa_DisableClientState(GLenum cap)254 _mesa_DisableClientState( GLenum cap )
255 {
256 GET_CURRENT_CONTEXT(ctx);
257 client_state( ctx, ctx->Array.VAO, cap, GL_FALSE );
258 }
259
260 void GLAPIENTRY
_mesa_DisableVertexArrayEXT(GLuint vaobj,GLenum cap)261 _mesa_DisableVertexArrayEXT( GLuint vaobj, GLenum cap )
262 {
263 GET_CURRENT_CONTEXT(ctx);
264 struct gl_vertex_array_object* vao = _mesa_lookup_vao_err(ctx, vaobj,
265 true,
266 "glDisableVertexArrayEXT");
267 if (!vao)
268 return;
269
270 /* The EXT_direct_state_access spec says:
271 * "Additionally EnableVertexArrayEXT and DisableVertexArrayEXT accept
272 * the tokens TEXTURE0 through TEXTUREn where n is less than the
273 * implementation-dependent limit of MAX_TEXTURE_COORDS. For these
274 * GL_TEXTUREi tokens, EnableVertexArrayEXT and DisableVertexArrayEXT
275 * act identically to EnableVertexArrayEXT(vaobj, TEXTURE_COORD_ARRAY)
276 * or DisableVertexArrayEXT(vaobj, TEXTURE_COORD_ARRAY) respectively
277 * as if the active client texture is set to texture coordinate set i
278 * based on the token TEXTUREi indicated by array."
279 */
280 if (GL_TEXTURE0 <= cap && cap < GL_TEXTURE0 + ctx->Const.MaxTextureCoordUnits) {
281 GLuint saved_active = ctx->Array.ActiveTexture;
282 _mesa_ClientActiveTexture(cap);
283 client_state(ctx, vao, GL_TEXTURE_COORD_ARRAY, GL_FALSE);
284 _mesa_ClientActiveTexture(GL_TEXTURE0 + saved_active);
285 } else {
286 client_state(ctx, vao, cap, GL_FALSE);
287 }
288 }
289
290 void GLAPIENTRY
_mesa_DisableClientStateiEXT(GLenum cap,GLuint index)291 _mesa_DisableClientStateiEXT( GLenum cap, GLuint index )
292 {
293 GET_CURRENT_CONTEXT(ctx);
294 client_state_i(ctx, ctx->Array.VAO, cap, index, GL_FALSE);
295 }
296
297 /**
298 * Return pointer to current texture unit for setting/getting coordinate
299 * state.
300 * Note that we'll set GL_INVALID_OPERATION and return NULL if the active
301 * texture unit is higher than the number of supported coordinate units.
302 */
303 static struct gl_fixedfunc_texture_unit *
get_texcoord_unit(struct gl_context * ctx)304 get_texcoord_unit(struct gl_context *ctx)
305 {
306 if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
307 _mesa_error(ctx, GL_INVALID_OPERATION, "glEnable/Disable(texcoord unit)");
308 return NULL;
309 }
310 else {
311 return &ctx->Texture.FixedFuncUnit[ctx->Texture.CurrentUnit];
312 }
313 }
314
315
316 /**
317 * Helper function to enable or disable a texture target.
318 * \param bit one of the TEXTURE_x_BIT values
319 * \return GL_TRUE if state is changing or GL_FALSE if no change
320 */
321 static GLboolean
enable_texture(struct gl_context * ctx,GLboolean state,GLbitfield texBit)322 enable_texture(struct gl_context *ctx, GLboolean state, GLbitfield texBit)
323 {
324 struct gl_fixedfunc_texture_unit *texUnit =
325 _mesa_get_fixedfunc_tex_unit(ctx, ctx->Texture.CurrentUnit);
326 if (!texUnit)
327 return GL_FALSE;
328
329 const GLbitfield newenabled = state
330 ? (texUnit->Enabled | texBit) : (texUnit->Enabled & ~texBit);
331
332 if (texUnit->Enabled == newenabled)
333 return GL_FALSE;
334
335 FLUSH_VERTICES(ctx, _NEW_TEXTURE_STATE, GL_TEXTURE_BIT | GL_ENABLE_BIT);
336 texUnit->Enabled = newenabled;
337 return GL_TRUE;
338 }
339
340
341 /**
342 * Helper function to enable or disable GL_MULTISAMPLE, skipping the check for
343 * whether the API supports it (GLES doesn't).
344 */
345 void
_mesa_set_multisample(struct gl_context * ctx,GLboolean state)346 _mesa_set_multisample(struct gl_context *ctx, GLboolean state)
347 {
348 if (ctx->Multisample.Enabled == state)
349 return;
350
351 /* GL compatibility needs Multisample.Enable to determine program state
352 * constants.
353 */
354 if (ctx->API == API_OPENGL_COMPAT || ctx->API == API_OPENGLES) {
355 FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE, GL_MULTISAMPLE_BIT | GL_ENABLE_BIT);
356 } else {
357 FLUSH_VERTICES(ctx, 0, GL_MULTISAMPLE_BIT | GL_ENABLE_BIT);
358 }
359
360 ctx->NewDriverState |= ctx->DriverFlags.NewMultisampleEnable;
361 ctx->Multisample.Enabled = state;
362 }
363
364 /**
365 * Helper function to enable or disable GL_FRAMEBUFFER_SRGB, skipping the
366 * check for whether the API supports it (GLES doesn't).
367 */
368 void
_mesa_set_framebuffer_srgb(struct gl_context * ctx,GLboolean state)369 _mesa_set_framebuffer_srgb(struct gl_context *ctx, GLboolean state)
370 {
371 if (ctx->Color.sRGBEnabled == state)
372 return;
373
374 /* TODO: Switch i965 to the new flag and remove the conditional */
375 FLUSH_VERTICES(ctx, 0,
376 GL_COLOR_BUFFER_BIT | GL_ENABLE_BIT);
377 ctx->NewDriverState |= ST_NEW_FB_STATE;
378 ctx->Color.sRGBEnabled = state;
379 }
380
381 /**
382 * Helper function to enable or disable state.
383 *
384 * \param ctx GL context.
385 * \param cap the state to enable/disable
386 * \param state whether to enable or disable the specified capability.
387 *
388 * Updates the current context and flushes the vertices as needed. For
389 * capabilities associated with extensions it verifies that those extensions
390 * are effectivly present before updating. Notifies the driver via
391 * dd_function_table::Enable.
392 */
393 void
_mesa_set_enable(struct gl_context * ctx,GLenum cap,GLboolean state)394 _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state)
395 {
396 if (MESA_VERBOSE & VERBOSE_API)
397 _mesa_debug(ctx, "%s %s (newstate is %x)\n",
398 state ? "glEnable" : "glDisable",
399 _mesa_enum_to_string(cap),
400 ctx->NewState);
401
402 switch (cap) {
403 case GL_ALPHA_TEST:
404 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
405 goto invalid_enum_error;
406 if (ctx->Color.AlphaEnabled == state)
407 return;
408 /* AlphaEnabled is used by the fixed-func fragment program */
409 FLUSH_VERTICES(ctx, _NEW_COLOR | _NEW_FF_FRAG_PROGRAM,
410 GL_COLOR_BUFFER_BIT | GL_ENABLE_BIT);
411 ctx->NewDriverState |= ctx->DriverFlags.NewAlphaTest;
412 ctx->Color.AlphaEnabled = state;
413 break;
414 case GL_AUTO_NORMAL:
415 if (ctx->API != API_OPENGL_COMPAT)
416 goto invalid_enum_error;
417 if (ctx->Eval.AutoNormal == state)
418 return;
419 FLUSH_VERTICES(ctx, 0, GL_EVAL_BIT | GL_ENABLE_BIT);
420 vbo_exec_update_eval_maps(ctx);
421 ctx->Eval.AutoNormal = state;
422 break;
423 case GL_BLEND:
424 {
425 GLbitfield newEnabled =
426 state * ((1 << ctx->Const.MaxDrawBuffers) - 1);
427 if (newEnabled != ctx->Color.BlendEnabled) {
428 _mesa_flush_vertices_for_blend_adv(ctx, newEnabled,
429 ctx->Color._AdvancedBlendMode);
430 ctx->PopAttribState |= GL_ENABLE_BIT;
431 ctx->Color.BlendEnabled = newEnabled;
432 _mesa_update_allow_draw_out_of_order(ctx);
433 _mesa_update_valid_to_render_state(ctx);
434 }
435 }
436 break;
437 case GL_CLIP_DISTANCE0: /* aka GL_CLIP_PLANE0 */
438 case GL_CLIP_DISTANCE1:
439 case GL_CLIP_DISTANCE2:
440 case GL_CLIP_DISTANCE3:
441 case GL_CLIP_DISTANCE4:
442 case GL_CLIP_DISTANCE5:
443 case GL_CLIP_DISTANCE6:
444 case GL_CLIP_DISTANCE7:
445 {
446 const GLuint p = cap - GL_CLIP_DISTANCE0;
447
448 if (p >= ctx->Const.MaxClipPlanes)
449 goto invalid_enum_error;
450
451 if ((ctx->Transform.ClipPlanesEnabled & (1 << p))
452 == ((GLuint) state << p))
453 return;
454
455 /* The compatibility profile needs _NEW_TRANSFORM to transform
456 * clip planes according to the projection matrix.
457 */
458 if (ctx->API == API_OPENGL_COMPAT || ctx->API == API_OPENGLES) {
459 FLUSH_VERTICES(ctx, _NEW_TRANSFORM,
460 GL_TRANSFORM_BIT | GL_ENABLE_BIT);
461 } else {
462 FLUSH_VERTICES(ctx, 0, GL_TRANSFORM_BIT | GL_ENABLE_BIT);
463 }
464 ctx->NewDriverState |= ctx->DriverFlags.NewClipPlaneEnable;
465
466 if (state) {
467 ctx->Transform.ClipPlanesEnabled |= (1 << p);
468
469 /* The projection matrix transforms the clip plane. */
470 /* TODO: glEnable might not be the best place to do it. */
471 if (ctx->API == API_OPENGL_COMPAT || ctx->API == API_OPENGLES) {
472 _mesa_update_clip_plane(ctx, p);
473 ctx->NewDriverState |= ST_NEW_CLIP_STATE;
474 }
475 }
476 else {
477 ctx->Transform.ClipPlanesEnabled &= ~(1 << p);
478 }
479 }
480 break;
481 case GL_COLOR_MATERIAL:
482 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
483 goto invalid_enum_error;
484 if (ctx->Light.ColorMaterialEnabled == state)
485 return;
486 FLUSH_VERTICES(ctx, _NEW_LIGHT_CONSTANTS | _NEW_FF_VERT_PROGRAM,
487 GL_LIGHTING_BIT | GL_ENABLE_BIT);
488 FLUSH_CURRENT(ctx, 0);
489 ctx->Light.ColorMaterialEnabled = state;
490 if (state) {
491 _mesa_update_color_material( ctx,
492 ctx->Current.Attrib[VERT_ATTRIB_COLOR0] );
493 }
494 break;
495 case GL_CULL_FACE:
496 if (ctx->Polygon.CullFlag == state)
497 return;
498 FLUSH_VERTICES(ctx, 0,
499 GL_POLYGON_BIT | GL_ENABLE_BIT);
500 ctx->NewDriverState |= ST_NEW_RASTERIZER;
501 ctx->Polygon.CullFlag = state;
502 break;
503 case GL_DEPTH_TEST:
504 if (ctx->Depth.Test == state)
505 return;
506 FLUSH_VERTICES(ctx, 0,
507 GL_DEPTH_BUFFER_BIT | GL_ENABLE_BIT);
508 ctx->NewDriverState |= ST_NEW_DSA;
509 ctx->Depth.Test = state;
510 _mesa_update_allow_draw_out_of_order(ctx);
511 break;
512 case GL_DEBUG_OUTPUT:
513 case GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB:
514 _mesa_set_debug_state_int(ctx, cap, state);
515 _mesa_update_debug_callback(ctx);
516 break;
517 case GL_DITHER:
518 if (ctx->Color.DitherFlag == state)
519 return;
520 FLUSH_VERTICES(ctx, 0,
521 GL_COLOR_BUFFER_BIT | GL_ENABLE_BIT);
522 ctx->NewDriverState |= ST_NEW_BLEND;
523 ctx->Color.DitherFlag = state;
524 break;
525 case GL_FOG:
526 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
527 goto invalid_enum_error;
528 if (ctx->Fog.Enabled == state)
529 return;
530 FLUSH_VERTICES(ctx, _NEW_FOG | _NEW_FF_FRAG_PROGRAM,
531 GL_FOG_BIT | GL_ENABLE_BIT);
532 ctx->Fog.Enabled = state;
533 ctx->Fog._PackedEnabledMode = state ? ctx->Fog._PackedMode : FOG_NONE;
534 break;
535 case GL_LIGHT0:
536 case GL_LIGHT1:
537 case GL_LIGHT2:
538 case GL_LIGHT3:
539 case GL_LIGHT4:
540 case GL_LIGHT5:
541 case GL_LIGHT6:
542 case GL_LIGHT7:
543 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
544 goto invalid_enum_error;
545 if (ctx->Light.Light[cap-GL_LIGHT0].Enabled == state)
546 return;
547 FLUSH_VERTICES(ctx, _NEW_LIGHT_CONSTANTS | _NEW_FF_VERT_PROGRAM,
548 GL_LIGHTING_BIT | GL_ENABLE_BIT);
549 ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
550 if (state) {
551 ctx->Light._EnabledLights |= 1u << (cap - GL_LIGHT0);
552 }
553 else {
554 ctx->Light._EnabledLights &= ~(1u << (cap - GL_LIGHT0));
555 }
556 break;
557 case GL_LIGHTING:
558 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
559 goto invalid_enum_error;
560 if (ctx->Light.Enabled == state)
561 return;
562 FLUSH_VERTICES(ctx, _NEW_LIGHT_CONSTANTS | _NEW_FF_VERT_PROGRAM |
563 _NEW_FF_FRAG_PROGRAM | _NEW_LIGHT_STATE,
564 GL_LIGHTING_BIT | GL_ENABLE_BIT);
565 ctx->Light.Enabled = state;
566 break;
567 case GL_LINE_SMOOTH:
568 if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES)
569 goto invalid_enum_error;
570 if (ctx->Line.SmoothFlag == state)
571 return;
572 FLUSH_VERTICES(ctx, 0,
573 GL_LINE_BIT | GL_ENABLE_BIT);
574 ctx->NewDriverState |= ST_NEW_RASTERIZER;
575 ctx->Line.SmoothFlag = state;
576 break;
577 case GL_LINE_STIPPLE:
578 if (ctx->API != API_OPENGL_COMPAT)
579 goto invalid_enum_error;
580 if (ctx->Line.StippleFlag == state)
581 return;
582 FLUSH_VERTICES(ctx, 0,
583 GL_LINE_BIT | GL_ENABLE_BIT);
584 ctx->NewDriverState |= ST_NEW_RASTERIZER;
585 ctx->Line.StippleFlag = state;
586 break;
587 case GL_INDEX_LOGIC_OP:
588 if (ctx->API != API_OPENGL_COMPAT)
589 goto invalid_enum_error;
590 if (ctx->Color.IndexLogicOpEnabled == state)
591 return;
592 FLUSH_VERTICES(ctx, 0,
593 GL_COLOR_BUFFER_BIT | GL_ENABLE_BIT);
594 ctx->NewDriverState |= ST_NEW_BLEND;
595 ctx->Color.IndexLogicOpEnabled = state;
596 break;
597 case GL_CONSERVATIVE_RASTERIZATION_INTEL:
598 if (!_mesa_has_INTEL_conservative_rasterization(ctx))
599 goto invalid_enum_error;
600 if (ctx->IntelConservativeRasterization == state)
601 return;
602 FLUSH_VERTICES(ctx, 0, 0);
603 ctx->NewDriverState |= ST_NEW_RASTERIZER;
604 ctx->IntelConservativeRasterization = state;
605 _mesa_update_valid_to_render_state(ctx);
606 break;
607 case GL_CONSERVATIVE_RASTERIZATION_NV:
608 if (!_mesa_has_NV_conservative_raster(ctx))
609 goto invalid_enum_error;
610 if (ctx->ConservativeRasterization == state)
611 return;
612 FLUSH_VERTICES(ctx, 0, GL_ENABLE_BIT);
613 ctx->NewDriverState |= ST_NEW_RASTERIZER;
614 ctx->ConservativeRasterization = state;
615 break;
616 case GL_COLOR_LOGIC_OP:
617 if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES)
618 goto invalid_enum_error;
619 if (ctx->Color.ColorLogicOpEnabled == state)
620 return;
621 FLUSH_VERTICES(ctx, 0,
622 GL_COLOR_BUFFER_BIT | GL_ENABLE_BIT);
623 ctx->NewDriverState |= ST_NEW_BLEND;
624 ctx->Color.ColorLogicOpEnabled = state;
625 _mesa_update_allow_draw_out_of_order(ctx);
626 break;
627 case GL_MAP1_COLOR_4:
628 if (ctx->API != API_OPENGL_COMPAT)
629 goto invalid_enum_error;
630 if (ctx->Eval.Map1Color4 == state)
631 return;
632 FLUSH_VERTICES(ctx, 0, GL_EVAL_BIT | GL_ENABLE_BIT);
633 vbo_exec_update_eval_maps(ctx);
634 ctx->Eval.Map1Color4 = state;
635 break;
636 case GL_MAP1_INDEX:
637 if (ctx->API != API_OPENGL_COMPAT)
638 goto invalid_enum_error;
639 if (ctx->Eval.Map1Index == state)
640 return;
641 FLUSH_VERTICES(ctx, 0, GL_EVAL_BIT | GL_ENABLE_BIT);
642 vbo_exec_update_eval_maps(ctx);
643 ctx->Eval.Map1Index = state;
644 break;
645 case GL_MAP1_NORMAL:
646 if (ctx->API != API_OPENGL_COMPAT)
647 goto invalid_enum_error;
648 if (ctx->Eval.Map1Normal == state)
649 return;
650 FLUSH_VERTICES(ctx, 0, GL_EVAL_BIT | GL_ENABLE_BIT);
651 vbo_exec_update_eval_maps(ctx);
652 ctx->Eval.Map1Normal = state;
653 break;
654 case GL_MAP1_TEXTURE_COORD_1:
655 if (ctx->API != API_OPENGL_COMPAT)
656 goto invalid_enum_error;
657 if (ctx->Eval.Map1TextureCoord1 == state)
658 return;
659 FLUSH_VERTICES(ctx, 0, GL_EVAL_BIT | GL_ENABLE_BIT);
660 vbo_exec_update_eval_maps(ctx);
661 ctx->Eval.Map1TextureCoord1 = state;
662 break;
663 case GL_MAP1_TEXTURE_COORD_2:
664 if (ctx->API != API_OPENGL_COMPAT)
665 goto invalid_enum_error;
666 if (ctx->Eval.Map1TextureCoord2 == state)
667 return;
668 FLUSH_VERTICES(ctx, 0, GL_EVAL_BIT | GL_ENABLE_BIT);
669 vbo_exec_update_eval_maps(ctx);
670 ctx->Eval.Map1TextureCoord2 = state;
671 break;
672 case GL_MAP1_TEXTURE_COORD_3:
673 if (ctx->API != API_OPENGL_COMPAT)
674 goto invalid_enum_error;
675 if (ctx->Eval.Map1TextureCoord3 == state)
676 return;
677 FLUSH_VERTICES(ctx, 0, GL_EVAL_BIT | GL_ENABLE_BIT);
678 vbo_exec_update_eval_maps(ctx);
679 ctx->Eval.Map1TextureCoord3 = state;
680 break;
681 case GL_MAP1_TEXTURE_COORD_4:
682 if (ctx->API != API_OPENGL_COMPAT)
683 goto invalid_enum_error;
684 if (ctx->Eval.Map1TextureCoord4 == state)
685 return;
686 FLUSH_VERTICES(ctx, 0, GL_EVAL_BIT | GL_ENABLE_BIT);
687 vbo_exec_update_eval_maps(ctx);
688 ctx->Eval.Map1TextureCoord4 = state;
689 break;
690 case GL_MAP1_VERTEX_3:
691 if (ctx->API != API_OPENGL_COMPAT)
692 goto invalid_enum_error;
693 if (ctx->Eval.Map1Vertex3 == state)
694 return;
695 FLUSH_VERTICES(ctx, 0, GL_EVAL_BIT | GL_ENABLE_BIT);
696 vbo_exec_update_eval_maps(ctx);
697 ctx->Eval.Map1Vertex3 = state;
698 break;
699 case GL_MAP1_VERTEX_4:
700 if (ctx->API != API_OPENGL_COMPAT)
701 goto invalid_enum_error;
702 if (ctx->Eval.Map1Vertex4 == state)
703 return;
704 FLUSH_VERTICES(ctx, 0, GL_EVAL_BIT | GL_ENABLE_BIT);
705 vbo_exec_update_eval_maps(ctx);
706 ctx->Eval.Map1Vertex4 = state;
707 break;
708 case GL_MAP2_COLOR_4:
709 if (ctx->API != API_OPENGL_COMPAT)
710 goto invalid_enum_error;
711 if (ctx->Eval.Map2Color4 == state)
712 return;
713 FLUSH_VERTICES(ctx, 0, GL_EVAL_BIT | GL_ENABLE_BIT);
714 vbo_exec_update_eval_maps(ctx);
715 ctx->Eval.Map2Color4 = state;
716 break;
717 case GL_MAP2_INDEX:
718 if (ctx->API != API_OPENGL_COMPAT)
719 goto invalid_enum_error;
720 if (ctx->Eval.Map2Index == state)
721 return;
722 FLUSH_VERTICES(ctx, 0, GL_EVAL_BIT | GL_ENABLE_BIT);
723 vbo_exec_update_eval_maps(ctx);
724 ctx->Eval.Map2Index = state;
725 break;
726 case GL_MAP2_NORMAL:
727 if (ctx->API != API_OPENGL_COMPAT)
728 goto invalid_enum_error;
729 if (ctx->Eval.Map2Normal == state)
730 return;
731 FLUSH_VERTICES(ctx, 0, GL_EVAL_BIT | GL_ENABLE_BIT);
732 vbo_exec_update_eval_maps(ctx);
733 ctx->Eval.Map2Normal = state;
734 break;
735 case GL_MAP2_TEXTURE_COORD_1:
736 if (ctx->API != API_OPENGL_COMPAT)
737 goto invalid_enum_error;
738 if (ctx->Eval.Map2TextureCoord1 == state)
739 return;
740 FLUSH_VERTICES(ctx, 0, GL_EVAL_BIT | GL_ENABLE_BIT);
741 vbo_exec_update_eval_maps(ctx);
742 ctx->Eval.Map2TextureCoord1 = state;
743 break;
744 case GL_MAP2_TEXTURE_COORD_2:
745 if (ctx->API != API_OPENGL_COMPAT)
746 goto invalid_enum_error;
747 if (ctx->Eval.Map2TextureCoord2 == state)
748 return;
749 FLUSH_VERTICES(ctx, 0, GL_EVAL_BIT | GL_ENABLE_BIT);
750 vbo_exec_update_eval_maps(ctx);
751 ctx->Eval.Map2TextureCoord2 = state;
752 break;
753 case GL_MAP2_TEXTURE_COORD_3:
754 if (ctx->API != API_OPENGL_COMPAT)
755 goto invalid_enum_error;
756 if (ctx->Eval.Map2TextureCoord3 == state)
757 return;
758 FLUSH_VERTICES(ctx, 0, GL_EVAL_BIT | GL_ENABLE_BIT);
759 vbo_exec_update_eval_maps(ctx);
760 ctx->Eval.Map2TextureCoord3 = state;
761 break;
762 case GL_MAP2_TEXTURE_COORD_4:
763 if (ctx->API != API_OPENGL_COMPAT)
764 goto invalid_enum_error;
765 if (ctx->Eval.Map2TextureCoord4 == state)
766 return;
767 FLUSH_VERTICES(ctx, 0, GL_EVAL_BIT | GL_ENABLE_BIT);
768 vbo_exec_update_eval_maps(ctx);
769 ctx->Eval.Map2TextureCoord4 = state;
770 break;
771 case GL_MAP2_VERTEX_3:
772 if (ctx->API != API_OPENGL_COMPAT)
773 goto invalid_enum_error;
774 if (ctx->Eval.Map2Vertex3 == state)
775 return;
776 FLUSH_VERTICES(ctx, 0, GL_EVAL_BIT | GL_ENABLE_BIT);
777 vbo_exec_update_eval_maps(ctx);
778 ctx->Eval.Map2Vertex3 = state;
779 break;
780 case GL_MAP2_VERTEX_4:
781 if (ctx->API != API_OPENGL_COMPAT)
782 goto invalid_enum_error;
783 if (ctx->Eval.Map2Vertex4 == state)
784 return;
785 FLUSH_VERTICES(ctx, 0, GL_EVAL_BIT | GL_ENABLE_BIT);
786 vbo_exec_update_eval_maps(ctx);
787 ctx->Eval.Map2Vertex4 = state;
788 break;
789 case GL_NORMALIZE:
790 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
791 goto invalid_enum_error;
792 if (ctx->Transform.Normalize == state)
793 return;
794 FLUSH_VERTICES(ctx, _NEW_TRANSFORM | _NEW_FF_VERT_PROGRAM,
795 GL_TRANSFORM_BIT | GL_ENABLE_BIT);
796 ctx->Transform.Normalize = state;
797 break;
798 case GL_POINT_SMOOTH:
799 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
800 goto invalid_enum_error;
801 if (ctx->Point.SmoothFlag == state)
802 return;
803 FLUSH_VERTICES(ctx, _NEW_POINT, GL_POINT_BIT | GL_ENABLE_BIT);
804 ctx->Point.SmoothFlag = state;
805 break;
806 case GL_POLYGON_SMOOTH:
807 if (!_mesa_is_desktop_gl(ctx))
808 goto invalid_enum_error;
809 if (ctx->Polygon.SmoothFlag == state)
810 return;
811 FLUSH_VERTICES(ctx, 0,
812 GL_POLYGON_BIT | GL_ENABLE_BIT);
813 ctx->NewDriverState |= ST_NEW_RASTERIZER;
814 ctx->Polygon.SmoothFlag = state;
815 break;
816 case GL_POLYGON_STIPPLE:
817 if (ctx->API != API_OPENGL_COMPAT)
818 goto invalid_enum_error;
819 if (ctx->Polygon.StippleFlag == state)
820 return;
821 FLUSH_VERTICES(ctx, 0,
822 GL_POLYGON_BIT | GL_ENABLE_BIT);
823 ctx->NewDriverState |= ST_NEW_RASTERIZER;
824 ctx->Polygon.StippleFlag = state;
825 break;
826 case GL_POLYGON_OFFSET_POINT:
827 if (!_mesa_is_desktop_gl(ctx))
828 goto invalid_enum_error;
829 if (ctx->Polygon.OffsetPoint == state)
830 return;
831 FLUSH_VERTICES(ctx, 0,
832 GL_POLYGON_BIT | GL_ENABLE_BIT);
833 ctx->NewDriverState |= ST_NEW_RASTERIZER;
834 ctx->Polygon.OffsetPoint = state;
835 break;
836 case GL_POLYGON_OFFSET_LINE:
837 if (!_mesa_is_desktop_gl(ctx))
838 goto invalid_enum_error;
839 if (ctx->Polygon.OffsetLine == state)
840 return;
841 FLUSH_VERTICES(ctx, 0,
842 GL_POLYGON_BIT | GL_ENABLE_BIT);
843 ctx->NewDriverState |= ST_NEW_RASTERIZER;
844 ctx->Polygon.OffsetLine = state;
845 break;
846 case GL_POLYGON_OFFSET_FILL:
847 if (ctx->Polygon.OffsetFill == state)
848 return;
849 FLUSH_VERTICES(ctx, 0,
850 GL_POLYGON_BIT | GL_ENABLE_BIT);
851 ctx->NewDriverState |= ST_NEW_RASTERIZER;
852 ctx->Polygon.OffsetFill = state;
853 break;
854 case GL_RESCALE_NORMAL_EXT:
855 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
856 goto invalid_enum_error;
857 if (ctx->Transform.RescaleNormals == state)
858 return;
859 FLUSH_VERTICES(ctx, _NEW_TRANSFORM | _NEW_FF_VERT_PROGRAM,
860 GL_TRANSFORM_BIT | GL_ENABLE_BIT);
861 ctx->Transform.RescaleNormals = state;
862 break;
863 case GL_SCISSOR_TEST:
864 {
865 /* Must expand glEnable to all scissors */
866 GLbitfield newEnabled =
867 state * ((1 << ctx->Const.MaxViewports) - 1);
868 if (newEnabled != ctx->Scissor.EnableFlags) {
869 st_flush_bitmap_cache(st_context(ctx));
870
871 FLUSH_VERTICES(ctx, 0,
872 GL_SCISSOR_BIT | GL_ENABLE_BIT);
873 ctx->NewDriverState |= ST_NEW_SCISSOR | ST_NEW_RASTERIZER;
874 ctx->Scissor.EnableFlags = newEnabled;
875 }
876 }
877 break;
878 case GL_STENCIL_TEST:
879 if (ctx->Stencil.Enabled == state)
880 return;
881 FLUSH_VERTICES(ctx, 0,
882 GL_STENCIL_BUFFER_BIT | GL_ENABLE_BIT);
883 ctx->NewDriverState |= ST_NEW_DSA;
884 ctx->Stencil.Enabled = state;
885 _mesa_update_allow_draw_out_of_order(ctx);
886 break;
887 case GL_TEXTURE_1D:
888 if (ctx->API != API_OPENGL_COMPAT)
889 goto invalid_enum_error;
890 if (!enable_texture(ctx, state, TEXTURE_1D_BIT)) {
891 return;
892 }
893 break;
894 case GL_TEXTURE_2D:
895 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
896 goto invalid_enum_error;
897 if (!enable_texture(ctx, state, TEXTURE_2D_BIT)) {
898 return;
899 }
900 break;
901 case GL_TEXTURE_3D:
902 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
903 goto invalid_enum_error;
904 if (!enable_texture(ctx, state, TEXTURE_3D_BIT)) {
905 return;
906 }
907 break;
908 case GL_TEXTURE_GEN_S:
909 case GL_TEXTURE_GEN_T:
910 case GL_TEXTURE_GEN_R:
911 case GL_TEXTURE_GEN_Q:
912 {
913 struct gl_fixedfunc_texture_unit *texUnit = get_texcoord_unit(ctx);
914
915 if (ctx->API != API_OPENGL_COMPAT)
916 goto invalid_enum_error;
917
918 if (texUnit) {
919 GLbitfield coordBit = S_BIT << (cap - GL_TEXTURE_GEN_S);
920 GLbitfield newenabled = texUnit->TexGenEnabled & ~coordBit;
921 if (state)
922 newenabled |= coordBit;
923 if (texUnit->TexGenEnabled == newenabled)
924 return;
925 FLUSH_VERTICES(ctx, _NEW_TEXTURE_STATE | _NEW_FF_VERT_PROGRAM |
926 _NEW_FF_FRAG_PROGRAM,
927 GL_TEXTURE_BIT | GL_ENABLE_BIT);
928 texUnit->TexGenEnabled = newenabled;
929 }
930 }
931 break;
932
933 case GL_TEXTURE_GEN_STR_OES:
934 /* disable S, T, and R at the same time */
935 {
936 struct gl_fixedfunc_texture_unit *texUnit = get_texcoord_unit(ctx);
937
938 if (ctx->API != API_OPENGLES)
939 goto invalid_enum_error;
940
941 if (texUnit) {
942 GLuint newenabled =
943 texUnit->TexGenEnabled & ~STR_BITS;
944 if (state)
945 newenabled |= STR_BITS;
946 if (texUnit->TexGenEnabled == newenabled)
947 return;
948 FLUSH_VERTICES(ctx, _NEW_TEXTURE_STATE | _NEW_FF_VERT_PROGRAM |
949 _NEW_FF_FRAG_PROGRAM, 0);
950 texUnit->TexGenEnabled = newenabled;
951 }
952 }
953 break;
954
955 /* client-side state */
956 case GL_VERTEX_ARRAY:
957 case GL_NORMAL_ARRAY:
958 case GL_COLOR_ARRAY:
959 case GL_TEXTURE_COORD_ARRAY:
960 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
961 goto invalid_enum_error;
962 client_state( ctx, ctx->Array.VAO, cap, state );
963 return;
964 case GL_INDEX_ARRAY:
965 case GL_EDGE_FLAG_ARRAY:
966 case GL_FOG_COORDINATE_ARRAY_EXT:
967 case GL_SECONDARY_COLOR_ARRAY_EXT:
968 if (ctx->API != API_OPENGL_COMPAT)
969 goto invalid_enum_error;
970 client_state( ctx, ctx->Array.VAO, cap, state );
971 return;
972 case GL_POINT_SIZE_ARRAY_OES:
973 if (ctx->API != API_OPENGLES)
974 goto invalid_enum_error;
975 client_state( ctx, ctx->Array.VAO, cap, state );
976 return;
977
978 /* GL_ARB_texture_cube_map */
979 case GL_TEXTURE_CUBE_MAP:
980 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
981 goto invalid_enum_error;
982 if (!enable_texture(ctx, state, TEXTURE_CUBE_BIT)) {
983 return;
984 }
985 break;
986
987 /* GL_EXT_secondary_color */
988 case GL_COLOR_SUM_EXT:
989 if (ctx->API != API_OPENGL_COMPAT)
990 goto invalid_enum_error;
991 if (ctx->Fog.ColorSumEnabled == state)
992 return;
993 FLUSH_VERTICES(ctx, _NEW_FOG | _NEW_FF_FRAG_PROGRAM,
994 GL_FOG_BIT | GL_ENABLE_BIT);
995 ctx->Fog.ColorSumEnabled = state;
996 break;
997
998 /* GL_ARB_multisample */
999 case GL_MULTISAMPLE_ARB:
1000 if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES)
1001 goto invalid_enum_error;
1002 _mesa_set_multisample(ctx, state);
1003 return;
1004 case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
1005 if (ctx->Multisample.SampleAlphaToCoverage == state)
1006 return;
1007 FLUSH_VERTICES(ctx, 0,
1008 GL_MULTISAMPLE_BIT | GL_ENABLE_BIT);
1009 ctx->NewDriverState |= ST_NEW_BLEND;
1010 ctx->Multisample.SampleAlphaToCoverage = state;
1011 break;
1012 case GL_SAMPLE_ALPHA_TO_ONE_ARB:
1013 if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES)
1014 goto invalid_enum_error;
1015 if (ctx->Multisample.SampleAlphaToOne == state)
1016 return;
1017 FLUSH_VERTICES(ctx, 0,
1018 GL_MULTISAMPLE_BIT | GL_ENABLE_BIT);
1019 ctx->NewDriverState |= ST_NEW_BLEND;
1020 ctx->Multisample.SampleAlphaToOne = state;
1021 break;
1022 case GL_SAMPLE_COVERAGE_ARB:
1023 if (ctx->Multisample.SampleCoverage == state)
1024 return;
1025 FLUSH_VERTICES(ctx, 0,
1026 GL_MULTISAMPLE_BIT | GL_ENABLE_BIT);
1027 ctx->NewDriverState |= ST_NEW_SAMPLE_STATE;
1028 ctx->Multisample.SampleCoverage = state;
1029 break;
1030 case GL_SAMPLE_COVERAGE_INVERT_ARB:
1031 if (!_mesa_is_desktop_gl(ctx))
1032 goto invalid_enum_error;
1033 if (ctx->Multisample.SampleCoverageInvert == state)
1034 return;
1035 FLUSH_VERTICES(ctx, 0, GL_MULTISAMPLE_BIT);
1036 ctx->NewDriverState |= ST_NEW_SAMPLE_STATE;
1037 ctx->Multisample.SampleCoverageInvert = state;
1038 break;
1039
1040 /* GL_ARB_sample_shading */
1041 case GL_SAMPLE_SHADING:
1042 if (!_mesa_has_ARB_sample_shading(ctx) && !_mesa_is_gles3(ctx))
1043 goto invalid_enum_error;
1044 if (ctx->Multisample.SampleShading == state)
1045 return;
1046 FLUSH_VERTICES(ctx, 0,
1047 GL_MULTISAMPLE_BIT | GL_ENABLE_BIT);
1048 ctx->NewDriverState |= ctx->DriverFlags.NewSampleShading;
1049 ctx->Multisample.SampleShading = state;
1050 break;
1051
1052 /* GL_IBM_rasterpos_clip */
1053 case GL_RASTER_POSITION_UNCLIPPED_IBM:
1054 if (ctx->API != API_OPENGL_COMPAT)
1055 goto invalid_enum_error;
1056 if (ctx->Transform.RasterPositionUnclipped == state)
1057 return;
1058 FLUSH_VERTICES(ctx, 0, GL_TRANSFORM_BIT | GL_ENABLE_BIT);
1059 ctx->Transform.RasterPositionUnclipped = state;
1060 break;
1061
1062 /* GL_ARB_point_sprite */
1063 case GL_POINT_SPRITE:
1064 if (!(ctx->API == API_OPENGL_COMPAT &&
1065 _mesa_has_ARB_point_sprite(ctx)) &&
1066 !_mesa_has_OES_point_sprite(ctx))
1067 goto invalid_enum_error;
1068 if (ctx->Point.PointSprite == state)
1069 return;
1070 FLUSH_VERTICES(ctx, _NEW_POINT | _NEW_FF_VERT_PROGRAM |
1071 _NEW_FF_FRAG_PROGRAM, GL_POINT_BIT | GL_ENABLE_BIT);
1072 ctx->Point.PointSprite = state;
1073 break;
1074
1075 case GL_VERTEX_PROGRAM_ARB:
1076 if (!_mesa_has_ARB_vertex_program(ctx))
1077 goto invalid_enum_error;
1078 if (ctx->VertexProgram.Enabled == state)
1079 return;
1080 FLUSH_VERTICES(ctx, _NEW_PROGRAM, GL_ENABLE_BIT);
1081 ctx->VertexProgram.Enabled = state;
1082 _mesa_update_vertex_processing_mode(ctx);
1083 _mesa_update_valid_to_render_state(ctx);
1084 break;
1085 case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
1086 /* This was added with ARB_vertex_program, but it is also used with
1087 * GLSL vertex shaders on desktop.
1088 */
1089 if (!_mesa_has_ARB_vertex_program(ctx) &&
1090 ctx->API != API_OPENGL_CORE)
1091 goto invalid_enum_error;
1092 if (ctx->VertexProgram.PointSizeEnabled == state)
1093 return;
1094 FLUSH_VERTICES(ctx, _NEW_PROGRAM, GL_ENABLE_BIT);
1095 ctx->VertexProgram.PointSizeEnabled = state;
1096 break;
1097 case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
1098 if (!_mesa_has_ARB_vertex_program(ctx))
1099 goto invalid_enum_error;
1100 if (ctx->VertexProgram.TwoSideEnabled == state)
1101 return;
1102 FLUSH_VERTICES(ctx, _NEW_PROGRAM, GL_ENABLE_BIT);
1103 ctx->VertexProgram.TwoSideEnabled = state;
1104 break;
1105
1106 /* GL_NV_texture_rectangle */
1107 case GL_TEXTURE_RECTANGLE_NV:
1108 if (!_mesa_has_NV_texture_rectangle(ctx))
1109 goto invalid_enum_error;
1110 if (!enable_texture(ctx, state, TEXTURE_RECT_BIT)) {
1111 return;
1112 }
1113 break;
1114
1115 /* GL_EXT_stencil_two_side */
1116 case GL_STENCIL_TEST_TWO_SIDE_EXT:
1117 if (!_mesa_has_EXT_stencil_two_side(ctx))
1118 goto invalid_enum_error;
1119 if (ctx->Stencil.TestTwoSide == state)
1120 return;
1121 FLUSH_VERTICES(ctx, 0,
1122 GL_STENCIL_BUFFER_BIT | GL_ENABLE_BIT);
1123 ctx->NewDriverState |= ST_NEW_DSA;
1124 ctx->Stencil.TestTwoSide = state;
1125 if (state) {
1126 ctx->Stencil._BackFace = 2;
1127 } else {
1128 ctx->Stencil._BackFace = 1;
1129 }
1130 break;
1131
1132 case GL_FRAGMENT_PROGRAM_ARB:
1133 if (!_mesa_has_ARB_fragment_program(ctx))
1134 goto invalid_enum_error;
1135 if (ctx->FragmentProgram.Enabled == state)
1136 return;
1137 FLUSH_VERTICES(ctx, _NEW_PROGRAM, GL_ENABLE_BIT);
1138 ctx->FragmentProgram.Enabled = state;
1139 _mesa_update_valid_to_render_state(ctx);
1140 break;
1141
1142 /* GL_EXT_depth_bounds_test */
1143 case GL_DEPTH_BOUNDS_TEST_EXT:
1144 if (!_mesa_has_EXT_depth_bounds_test(ctx))
1145 goto invalid_enum_error;
1146 if (ctx->Depth.BoundsTest == state)
1147 return;
1148 FLUSH_VERTICES(ctx, 0, GL_DEPTH_BUFFER_BIT | GL_ENABLE_BIT);
1149 ctx->NewDriverState |= ST_NEW_DSA;
1150 ctx->Depth.BoundsTest = state;
1151 break;
1152
1153 case GL_DEPTH_CLAMP:
1154 if (!_mesa_has_ARB_depth_clamp(ctx) &&
1155 !_mesa_has_EXT_depth_clamp(ctx))
1156 goto invalid_enum_error;
1157 if (ctx->Transform.DepthClampNear == state &&
1158 ctx->Transform.DepthClampFar == state)
1159 return;
1160 FLUSH_VERTICES(ctx, 0,
1161 GL_TRANSFORM_BIT | GL_ENABLE_BIT);
1162 ctx->NewDriverState |= ST_NEW_RASTERIZER;
1163 ctx->Transform.DepthClampNear = state;
1164 ctx->Transform.DepthClampFar = state;
1165 break;
1166
1167 case GL_DEPTH_CLAMP_NEAR_AMD:
1168 if (!_mesa_has_AMD_depth_clamp_separate(ctx))
1169 goto invalid_enum_error;
1170 if (ctx->Transform.DepthClampNear == state)
1171 return;
1172 FLUSH_VERTICES(ctx, 0,
1173 GL_TRANSFORM_BIT | GL_ENABLE_BIT);
1174 ctx->NewDriverState |= ST_NEW_RASTERIZER;
1175 ctx->Transform.DepthClampNear = state;
1176 break;
1177
1178 case GL_DEPTH_CLAMP_FAR_AMD:
1179 if (!_mesa_has_AMD_depth_clamp_separate(ctx))
1180 goto invalid_enum_error;
1181 if (ctx->Transform.DepthClampFar == state)
1182 return;
1183 FLUSH_VERTICES(ctx, 0,
1184 GL_TRANSFORM_BIT | GL_ENABLE_BIT);
1185 ctx->NewDriverState |= ST_NEW_RASTERIZER;
1186 ctx->Transform.DepthClampFar = state;
1187 break;
1188
1189 case GL_FRAGMENT_SHADER_ATI:
1190 if (!_mesa_has_ATI_fragment_shader(ctx))
1191 goto invalid_enum_error;
1192 if (ctx->ATIFragmentShader.Enabled == state)
1193 return;
1194 FLUSH_VERTICES(ctx, _NEW_PROGRAM, GL_ENABLE_BIT);
1195 ctx->ATIFragmentShader.Enabled = state;
1196 break;
1197
1198 case GL_TEXTURE_CUBE_MAP_SEAMLESS:
1199 if (!_mesa_has_ARB_seamless_cube_map(ctx))
1200 goto invalid_enum_error;
1201 if (ctx->Texture.CubeMapSeamless != state) {
1202 FLUSH_VERTICES(ctx, _NEW_TEXTURE_OBJECT, 0);
1203 ctx->Texture.CubeMapSeamless = state;
1204 }
1205 break;
1206
1207 case GL_RASTERIZER_DISCARD:
1208 if (!(_mesa_has_EXT_transform_feedback(ctx) || _mesa_is_gles3(ctx)))
1209 goto invalid_enum_error;
1210 if (ctx->RasterDiscard != state) {
1211 FLUSH_VERTICES(ctx, 0, 0);
1212 ctx->NewDriverState |= ST_NEW_RASTERIZER;
1213 ctx->RasterDiscard = state;
1214 }
1215 break;
1216
1217 case GL_TILE_RASTER_ORDER_FIXED_MESA:
1218 if (!_mesa_has_MESA_tile_raster_order(ctx))
1219 goto invalid_enum_error;
1220 if (ctx->TileRasterOrderFixed != state) {
1221 FLUSH_VERTICES(ctx, 0, GL_ENABLE_BIT);
1222 ctx->NewDriverState |= ST_NEW_RASTERIZER;
1223 ctx->TileRasterOrderFixed = state;
1224 }
1225 break;
1226
1227 case GL_TILE_RASTER_ORDER_INCREASING_X_MESA:
1228 if (!_mesa_has_MESA_tile_raster_order(ctx))
1229 goto invalid_enum_error;
1230 if (ctx->TileRasterOrderIncreasingX != state) {
1231 FLUSH_VERTICES(ctx, 0, GL_ENABLE_BIT);
1232 ctx->NewDriverState |= ST_NEW_RASTERIZER;
1233 ctx->TileRasterOrderIncreasingX = state;
1234 }
1235 break;
1236
1237 case GL_TILE_RASTER_ORDER_INCREASING_Y_MESA:
1238 if (!_mesa_has_MESA_tile_raster_order(ctx))
1239 goto invalid_enum_error;
1240 if (ctx->TileRasterOrderIncreasingY != state) {
1241 FLUSH_VERTICES(ctx, 0, GL_ENABLE_BIT);
1242 ctx->NewDriverState |= ST_NEW_RASTERIZER;
1243 ctx->TileRasterOrderIncreasingY = state;
1244 }
1245 break;
1246
1247 /* GL 3.1 primitive restart. Note: this enum is different from
1248 * GL_PRIMITIVE_RESTART_NV (which is client state).
1249 */
1250 case GL_PRIMITIVE_RESTART:
1251 if (!_mesa_is_desktop_gl(ctx) || ctx->Version < 31) {
1252 goto invalid_enum_error;
1253 }
1254 if (ctx->Array.PrimitiveRestart != state) {
1255 ctx->Array.PrimitiveRestart = state;
1256 _mesa_update_derived_primitive_restart_state(ctx);
1257 }
1258 break;
1259
1260 case GL_PRIMITIVE_RESTART_FIXED_INDEX:
1261 if (!_mesa_is_gles3(ctx) && !_mesa_has_ARB_ES3_compatibility(ctx))
1262 goto invalid_enum_error;
1263 if (ctx->Array.PrimitiveRestartFixedIndex != state) {
1264 ctx->Array.PrimitiveRestartFixedIndex = state;
1265 _mesa_update_derived_primitive_restart_state(ctx);
1266 }
1267 break;
1268
1269 /* GL3.0 - GL_framebuffer_sRGB */
1270 case GL_FRAMEBUFFER_SRGB_EXT:
1271 if (!_mesa_has_EXT_framebuffer_sRGB(ctx) &&
1272 !_mesa_has_EXT_sRGB_write_control(ctx))
1273 goto invalid_enum_error;
1274 _mesa_set_framebuffer_srgb(ctx, state);
1275 return;
1276
1277 /* GL_OES_EGL_image_external */
1278 case GL_TEXTURE_EXTERNAL_OES:
1279 if (!_mesa_has_OES_EGL_image_external(ctx))
1280 goto invalid_enum_error;
1281 if (!enable_texture(ctx, state, TEXTURE_EXTERNAL_BIT)) {
1282 return;
1283 }
1284 break;
1285
1286 /* ARB_texture_multisample */
1287 case GL_SAMPLE_MASK:
1288 if (!_mesa_has_ARB_texture_multisample(ctx) && !_mesa_is_gles31(ctx))
1289 goto invalid_enum_error;
1290 if (ctx->Multisample.SampleMask == state)
1291 return;
1292 FLUSH_VERTICES(ctx, 0, 0);
1293 ctx->NewDriverState |= ST_NEW_SAMPLE_STATE;
1294 ctx->Multisample.SampleMask = state;
1295 break;
1296
1297 case GL_BLEND_ADVANCED_COHERENT_KHR:
1298 if (!_mesa_has_KHR_blend_equation_advanced_coherent(ctx))
1299 goto invalid_enum_error;
1300 if (ctx->Color.BlendCoherent == state)
1301 return;
1302 FLUSH_VERTICES(ctx, 0, GL_COLOR_BUFFER_BIT);
1303 ctx->NewDriverState |= ST_NEW_BLEND;
1304 ctx->Color.BlendCoherent = state;
1305 break;
1306
1307 case GL_BLACKHOLE_RENDER_INTEL:
1308 if (!_mesa_has_INTEL_blackhole_render(ctx))
1309 goto invalid_enum_error;
1310 if (ctx->IntelBlackholeRender == state)
1311 return;
1312 FLUSH_VERTICES(ctx, 0, 0);
1313 ctx->IntelBlackholeRender = state;
1314 ctx->pipe->set_frontend_noop(ctx->pipe, state);
1315 break;
1316
1317 default:
1318 goto invalid_enum_error;
1319 }
1320 return;
1321
1322 invalid_enum_error:
1323 _mesa_error(ctx, GL_INVALID_ENUM, "gl%s(%s)",
1324 state ? "Enable" : "Disable", _mesa_enum_to_string(cap));
1325 }
1326
1327
1328 /**
1329 * Enable GL capability. Called by glEnable()
1330 * \param cap state to enable.
1331 */
1332 void GLAPIENTRY
_mesa_Enable(GLenum cap)1333 _mesa_Enable( GLenum cap )
1334 {
1335 GET_CURRENT_CONTEXT(ctx);
1336
1337 _mesa_set_enable( ctx, cap, GL_TRUE );
1338 }
1339
1340
1341 /**
1342 * Disable GL capability. Called by glDisable()
1343 * \param cap state to disable.
1344 */
1345 void GLAPIENTRY
_mesa_Disable(GLenum cap)1346 _mesa_Disable( GLenum cap )
1347 {
1348 GET_CURRENT_CONTEXT(ctx);
1349
1350 _mesa_set_enable( ctx, cap, GL_FALSE );
1351 }
1352
1353
1354
1355 /**
1356 * Enable/disable an indexed state var.
1357 */
1358 void
_mesa_set_enablei(struct gl_context * ctx,GLenum cap,GLuint index,GLboolean state)1359 _mesa_set_enablei(struct gl_context *ctx, GLenum cap,
1360 GLuint index, GLboolean state)
1361 {
1362 assert(state == 0 || state == 1);
1363 switch (cap) {
1364 case GL_BLEND:
1365 if (!ctx->Extensions.EXT_draw_buffers2) {
1366 goto invalid_enum_error;
1367 }
1368 if (index >= ctx->Const.MaxDrawBuffers) {
1369 _mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%u)",
1370 state ? "glEnableIndexed" : "glDisableIndexed", index);
1371 return;
1372 }
1373 if (((ctx->Color.BlendEnabled >> index) & 1) != state) {
1374 GLbitfield enabled = ctx->Color.BlendEnabled;
1375
1376 if (state)
1377 enabled |= (1 << index);
1378 else
1379 enabled &= ~(1 << index);
1380
1381 _mesa_flush_vertices_for_blend_adv(ctx, enabled,
1382 ctx->Color._AdvancedBlendMode);
1383 ctx->PopAttribState |= GL_ENABLE_BIT;
1384 ctx->Color.BlendEnabled = enabled;
1385 _mesa_update_allow_draw_out_of_order(ctx);
1386 _mesa_update_valid_to_render_state(ctx);
1387 }
1388 break;
1389 case GL_SCISSOR_TEST:
1390 if (index >= ctx->Const.MaxViewports) {
1391 _mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%u)",
1392 state ? "glEnablei" : "glDisablei", index);
1393 return;
1394 }
1395 if (((ctx->Scissor.EnableFlags >> index) & 1) != state) {
1396 st_flush_bitmap_cache(st_context(ctx));
1397
1398 FLUSH_VERTICES(ctx, 0,
1399 GL_SCISSOR_BIT | GL_ENABLE_BIT);
1400 ctx->NewDriverState |= ST_NEW_SCISSOR | ST_NEW_RASTERIZER;
1401 if (state)
1402 ctx->Scissor.EnableFlags |= (1 << index);
1403 else
1404 ctx->Scissor.EnableFlags &= ~(1 << index);
1405 }
1406 break;
1407 /* EXT_direct_state_access */
1408 case GL_TEXTURE_1D:
1409 case GL_TEXTURE_2D:
1410 case GL_TEXTURE_3D:
1411 case GL_TEXTURE_CUBE_MAP:
1412 case GL_TEXTURE_GEN_S:
1413 case GL_TEXTURE_GEN_T:
1414 case GL_TEXTURE_GEN_R:
1415 case GL_TEXTURE_GEN_Q:
1416 case GL_TEXTURE_RECTANGLE_ARB: {
1417 const GLuint curTexUnitSave = ctx->Texture.CurrentUnit;
1418 if (index >= MAX2(ctx->Const.MaxCombinedTextureImageUnits,
1419 ctx->Const.MaxTextureCoordUnits)) {
1420 _mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%u)",
1421 state ? "glEnablei" : "glDisablei", index);
1422 return;
1423 }
1424 _mesa_ActiveTexture(GL_TEXTURE0 + index);
1425 _mesa_set_enable( ctx, cap, state );
1426 _mesa_ActiveTexture(GL_TEXTURE0 + curTexUnitSave);
1427 break;
1428 }
1429 default:
1430 goto invalid_enum_error;
1431 }
1432 return;
1433
1434 invalid_enum_error:
1435 _mesa_error(ctx, GL_INVALID_ENUM, "%s(cap=%s)",
1436 state ? "glEnablei" : "glDisablei",
1437 _mesa_enum_to_string(cap));
1438 }
1439
1440
1441 void GLAPIENTRY
_mesa_Disablei(GLenum cap,GLuint index)1442 _mesa_Disablei( GLenum cap, GLuint index )
1443 {
1444 GET_CURRENT_CONTEXT(ctx);
1445 _mesa_set_enablei(ctx, cap, index, GL_FALSE);
1446 }
1447
1448
1449 void GLAPIENTRY
_mesa_Enablei(GLenum cap,GLuint index)1450 _mesa_Enablei( GLenum cap, GLuint index )
1451 {
1452 GET_CURRENT_CONTEXT(ctx);
1453 _mesa_set_enablei(ctx, cap, index, GL_TRUE);
1454 }
1455
1456
1457 GLboolean GLAPIENTRY
_mesa_IsEnabledi(GLenum cap,GLuint index)1458 _mesa_IsEnabledi( GLenum cap, GLuint index )
1459 {
1460 GET_CURRENT_CONTEXT(ctx);
1461 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
1462 switch (cap) {
1463 case GL_BLEND:
1464 if (index >= ctx->Const.MaxDrawBuffers) {
1465 _mesa_error(ctx, GL_INVALID_VALUE, "glIsEnabledIndexed(index=%u)",
1466 index);
1467 return GL_FALSE;
1468 }
1469 return (ctx->Color.BlendEnabled >> index) & 1;
1470 case GL_SCISSOR_TEST:
1471 if (index >= ctx->Const.MaxViewports) {
1472 _mesa_error(ctx, GL_INVALID_VALUE, "glIsEnabledIndexed(index=%u)",
1473 index);
1474 return GL_FALSE;
1475 }
1476 return (ctx->Scissor.EnableFlags >> index) & 1;
1477 /* EXT_direct_state_access */
1478 case GL_TEXTURE_1D:
1479 case GL_TEXTURE_2D:
1480 case GL_TEXTURE_3D:
1481 case GL_TEXTURE_CUBE_MAP:
1482 case GL_TEXTURE_GEN_S:
1483 case GL_TEXTURE_GEN_T:
1484 case GL_TEXTURE_GEN_R:
1485 case GL_TEXTURE_GEN_Q:
1486 case GL_TEXTURE_RECTANGLE_ARB: {
1487 GLboolean state;
1488 const GLuint curTexUnitSave = ctx->Texture.CurrentUnit;
1489 if (index >= MAX2(ctx->Const.MaxCombinedTextureImageUnits,
1490 ctx->Const.MaxTextureCoordUnits)) {
1491 _mesa_error(ctx, GL_INVALID_VALUE, "glIsEnabledIndexed(index=%u)",
1492 index);
1493 return GL_FALSE;
1494 }
1495 _mesa_ActiveTexture(GL_TEXTURE0 + index);
1496 state = _mesa_IsEnabled(cap);
1497 _mesa_ActiveTexture(GL_TEXTURE0 + curTexUnitSave);
1498 return state;
1499 }
1500 default:
1501 _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabledIndexed(cap=%s)",
1502 _mesa_enum_to_string(cap));
1503 return GL_FALSE;
1504 }
1505 }
1506
1507
1508
1509 /**
1510 * Helper function to determine whether a texture target is enabled.
1511 */
1512 static GLboolean
is_texture_enabled(struct gl_context * ctx,GLbitfield bit)1513 is_texture_enabled(struct gl_context *ctx, GLbitfield bit)
1514 {
1515 const struct gl_fixedfunc_texture_unit *const texUnit =
1516 _mesa_get_fixedfunc_tex_unit(ctx, ctx->Texture.CurrentUnit);
1517
1518 if (!texUnit)
1519 return GL_FALSE;
1520
1521 return (texUnit->Enabled & bit) ? GL_TRUE : GL_FALSE;
1522 }
1523
1524
1525 /**
1526 * Return simple enable/disable state.
1527 *
1528 * \param cap state variable to query.
1529 *
1530 * Returns the state of the specified capability from the current GL context.
1531 * For the capabilities associated with extensions verifies that those
1532 * extensions are effectively present before reporting.
1533 */
1534 GLboolean GLAPIENTRY
_mesa_IsEnabled(GLenum cap)1535 _mesa_IsEnabled( GLenum cap )
1536 {
1537 GET_CURRENT_CONTEXT(ctx);
1538 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
1539
1540 switch (cap) {
1541 case GL_ALPHA_TEST:
1542 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1543 goto invalid_enum_error;
1544 return ctx->Color.AlphaEnabled;
1545 case GL_AUTO_NORMAL:
1546 if (ctx->API != API_OPENGL_COMPAT)
1547 goto invalid_enum_error;
1548 return ctx->Eval.AutoNormal;
1549 case GL_BLEND:
1550 return ctx->Color.BlendEnabled & 1; /* return state for buffer[0] */
1551 case GL_CLIP_DISTANCE0: /* aka GL_CLIP_PLANE0 */
1552 case GL_CLIP_DISTANCE1:
1553 case GL_CLIP_DISTANCE2:
1554 case GL_CLIP_DISTANCE3:
1555 case GL_CLIP_DISTANCE4:
1556 case GL_CLIP_DISTANCE5:
1557 case GL_CLIP_DISTANCE6:
1558 case GL_CLIP_DISTANCE7: {
1559 const GLuint p = cap - GL_CLIP_DISTANCE0;
1560
1561 if (p >= ctx->Const.MaxClipPlanes)
1562 goto invalid_enum_error;
1563
1564 return (ctx->Transform.ClipPlanesEnabled >> p) & 1;
1565 }
1566 case GL_COLOR_MATERIAL:
1567 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1568 goto invalid_enum_error;
1569 return ctx->Light.ColorMaterialEnabled;
1570 case GL_CULL_FACE:
1571 return ctx->Polygon.CullFlag;
1572 case GL_DEBUG_OUTPUT:
1573 case GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB:
1574 return (GLboolean) _mesa_get_debug_state_int(ctx, cap);
1575 case GL_DEPTH_TEST:
1576 return ctx->Depth.Test;
1577 case GL_DITHER:
1578 return ctx->Color.DitherFlag;
1579 case GL_FOG:
1580 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1581 goto invalid_enum_error;
1582 return ctx->Fog.Enabled;
1583 case GL_LIGHTING:
1584 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1585 goto invalid_enum_error;
1586 return ctx->Light.Enabled;
1587 case GL_LIGHT0:
1588 case GL_LIGHT1:
1589 case GL_LIGHT2:
1590 case GL_LIGHT3:
1591 case GL_LIGHT4:
1592 case GL_LIGHT5:
1593 case GL_LIGHT6:
1594 case GL_LIGHT7:
1595 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1596 goto invalid_enum_error;
1597 return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
1598 case GL_LINE_SMOOTH:
1599 if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES)
1600 goto invalid_enum_error;
1601 return ctx->Line.SmoothFlag;
1602 case GL_LINE_STIPPLE:
1603 if (ctx->API != API_OPENGL_COMPAT)
1604 goto invalid_enum_error;
1605 return ctx->Line.StippleFlag;
1606 case GL_INDEX_LOGIC_OP:
1607 if (ctx->API != API_OPENGL_COMPAT)
1608 goto invalid_enum_error;
1609 return ctx->Color.IndexLogicOpEnabled;
1610 case GL_COLOR_LOGIC_OP:
1611 if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES)
1612 goto invalid_enum_error;
1613 return ctx->Color.ColorLogicOpEnabled;
1614 case GL_MAP1_COLOR_4:
1615 if (ctx->API != API_OPENGL_COMPAT)
1616 goto invalid_enum_error;
1617 return ctx->Eval.Map1Color4;
1618 case GL_MAP1_INDEX:
1619 if (ctx->API != API_OPENGL_COMPAT)
1620 goto invalid_enum_error;
1621 return ctx->Eval.Map1Index;
1622 case GL_MAP1_NORMAL:
1623 if (ctx->API != API_OPENGL_COMPAT)
1624 goto invalid_enum_error;
1625 return ctx->Eval.Map1Normal;
1626 case GL_MAP1_TEXTURE_COORD_1:
1627 if (ctx->API != API_OPENGL_COMPAT)
1628 goto invalid_enum_error;
1629 return ctx->Eval.Map1TextureCoord1;
1630 case GL_MAP1_TEXTURE_COORD_2:
1631 if (ctx->API != API_OPENGL_COMPAT)
1632 goto invalid_enum_error;
1633 return ctx->Eval.Map1TextureCoord2;
1634 case GL_MAP1_TEXTURE_COORD_3:
1635 if (ctx->API != API_OPENGL_COMPAT)
1636 goto invalid_enum_error;
1637 return ctx->Eval.Map1TextureCoord3;
1638 case GL_MAP1_TEXTURE_COORD_4:
1639 if (ctx->API != API_OPENGL_COMPAT)
1640 goto invalid_enum_error;
1641 return ctx->Eval.Map1TextureCoord4;
1642 case GL_MAP1_VERTEX_3:
1643 if (ctx->API != API_OPENGL_COMPAT)
1644 goto invalid_enum_error;
1645 return ctx->Eval.Map1Vertex3;
1646 case GL_MAP1_VERTEX_4:
1647 if (ctx->API != API_OPENGL_COMPAT)
1648 goto invalid_enum_error;
1649 return ctx->Eval.Map1Vertex4;
1650 case GL_MAP2_COLOR_4:
1651 if (ctx->API != API_OPENGL_COMPAT)
1652 goto invalid_enum_error;
1653 return ctx->Eval.Map2Color4;
1654 case GL_MAP2_INDEX:
1655 if (ctx->API != API_OPENGL_COMPAT)
1656 goto invalid_enum_error;
1657 return ctx->Eval.Map2Index;
1658 case GL_MAP2_NORMAL:
1659 if (ctx->API != API_OPENGL_COMPAT)
1660 goto invalid_enum_error;
1661 return ctx->Eval.Map2Normal;
1662 case GL_MAP2_TEXTURE_COORD_1:
1663 if (ctx->API != API_OPENGL_COMPAT)
1664 goto invalid_enum_error;
1665 return ctx->Eval.Map2TextureCoord1;
1666 case GL_MAP2_TEXTURE_COORD_2:
1667 if (ctx->API != API_OPENGL_COMPAT)
1668 goto invalid_enum_error;
1669 return ctx->Eval.Map2TextureCoord2;
1670 case GL_MAP2_TEXTURE_COORD_3:
1671 if (ctx->API != API_OPENGL_COMPAT)
1672 goto invalid_enum_error;
1673 return ctx->Eval.Map2TextureCoord3;
1674 case GL_MAP2_TEXTURE_COORD_4:
1675 if (ctx->API != API_OPENGL_COMPAT)
1676 goto invalid_enum_error;
1677 return ctx->Eval.Map2TextureCoord4;
1678 case GL_MAP2_VERTEX_3:
1679 if (ctx->API != API_OPENGL_COMPAT)
1680 goto invalid_enum_error;
1681 return ctx->Eval.Map2Vertex3;
1682 case GL_MAP2_VERTEX_4:
1683 if (ctx->API != API_OPENGL_COMPAT)
1684 goto invalid_enum_error;
1685 return ctx->Eval.Map2Vertex4;
1686 case GL_NORMALIZE:
1687 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1688 goto invalid_enum_error;
1689 return ctx->Transform.Normalize;
1690 case GL_POINT_SMOOTH:
1691 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1692 goto invalid_enum_error;
1693 return ctx->Point.SmoothFlag;
1694 case GL_POLYGON_SMOOTH:
1695 if (!_mesa_is_desktop_gl(ctx))
1696 goto invalid_enum_error;
1697 return ctx->Polygon.SmoothFlag;
1698 case GL_POLYGON_STIPPLE:
1699 if (ctx->API != API_OPENGL_COMPAT)
1700 goto invalid_enum_error;
1701 return ctx->Polygon.StippleFlag;
1702 case GL_POLYGON_OFFSET_POINT:
1703 if (!_mesa_is_desktop_gl(ctx))
1704 goto invalid_enum_error;
1705 return ctx->Polygon.OffsetPoint;
1706 case GL_POLYGON_OFFSET_LINE:
1707 if (!_mesa_is_desktop_gl(ctx))
1708 goto invalid_enum_error;
1709 return ctx->Polygon.OffsetLine;
1710 case GL_POLYGON_OFFSET_FILL:
1711 return ctx->Polygon.OffsetFill;
1712 case GL_RESCALE_NORMAL_EXT:
1713 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1714 goto invalid_enum_error;
1715 return ctx->Transform.RescaleNormals;
1716 case GL_SCISSOR_TEST:
1717 return ctx->Scissor.EnableFlags & 1; /* return state for index 0 */
1718 case GL_STENCIL_TEST:
1719 return ctx->Stencil.Enabled;
1720 case GL_TEXTURE_1D:
1721 if (ctx->API != API_OPENGL_COMPAT)
1722 goto invalid_enum_error;
1723 return is_texture_enabled(ctx, TEXTURE_1D_BIT);
1724 case GL_TEXTURE_2D:
1725 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1726 goto invalid_enum_error;
1727 return is_texture_enabled(ctx, TEXTURE_2D_BIT);
1728 case GL_TEXTURE_3D:
1729 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1730 goto invalid_enum_error;
1731 return is_texture_enabled(ctx, TEXTURE_3D_BIT);
1732 case GL_TEXTURE_GEN_S:
1733 case GL_TEXTURE_GEN_T:
1734 case GL_TEXTURE_GEN_R:
1735 case GL_TEXTURE_GEN_Q:
1736 {
1737 const struct gl_fixedfunc_texture_unit *texUnit =
1738 get_texcoord_unit(ctx);
1739
1740 if (ctx->API != API_OPENGL_COMPAT)
1741 goto invalid_enum_error;
1742
1743 if (texUnit) {
1744 GLbitfield coordBit = S_BIT << (cap - GL_TEXTURE_GEN_S);
1745 return (texUnit->TexGenEnabled & coordBit) ? GL_TRUE : GL_FALSE;
1746 }
1747 }
1748 return GL_FALSE;
1749 case GL_TEXTURE_GEN_STR_OES:
1750 {
1751 const struct gl_fixedfunc_texture_unit *texUnit =
1752 get_texcoord_unit(ctx);
1753
1754 if (ctx->API != API_OPENGLES)
1755 goto invalid_enum_error;
1756
1757 if (texUnit) {
1758 return (texUnit->TexGenEnabled & STR_BITS) == STR_BITS
1759 ? GL_TRUE : GL_FALSE;
1760 }
1761
1762 return GL_FALSE;
1763 }
1764
1765 /* client-side state */
1766 case GL_VERTEX_ARRAY:
1767 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1768 goto invalid_enum_error;
1769 return !!(ctx->Array.VAO->Enabled & VERT_BIT_POS);
1770 case GL_NORMAL_ARRAY:
1771 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1772 goto invalid_enum_error;
1773 return !!(ctx->Array.VAO->Enabled & VERT_BIT_NORMAL);
1774 case GL_COLOR_ARRAY:
1775 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1776 goto invalid_enum_error;
1777 return !!(ctx->Array.VAO->Enabled & VERT_BIT_COLOR0);
1778 case GL_INDEX_ARRAY:
1779 if (ctx->API != API_OPENGL_COMPAT)
1780 goto invalid_enum_error;
1781 return !!(ctx->Array.VAO->Enabled & VERT_BIT_COLOR_INDEX);
1782 case GL_TEXTURE_COORD_ARRAY:
1783 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1784 goto invalid_enum_error;
1785 return !!(ctx->Array.VAO->Enabled &
1786 VERT_BIT_TEX(ctx->Array.ActiveTexture));
1787 case GL_EDGE_FLAG_ARRAY:
1788 if (ctx->API != API_OPENGL_COMPAT)
1789 goto invalid_enum_error;
1790 return !!(ctx->Array.VAO->Enabled & VERT_BIT_EDGEFLAG);
1791 case GL_FOG_COORDINATE_ARRAY_EXT:
1792 if (ctx->API != API_OPENGL_COMPAT)
1793 goto invalid_enum_error;
1794 return !!(ctx->Array.VAO->Enabled & VERT_BIT_FOG);
1795 case GL_SECONDARY_COLOR_ARRAY_EXT:
1796 if (ctx->API != API_OPENGL_COMPAT)
1797 goto invalid_enum_error;
1798 return !!(ctx->Array.VAO->Enabled & VERT_BIT_COLOR1);
1799 case GL_POINT_SIZE_ARRAY_OES:
1800 if (ctx->API != API_OPENGLES)
1801 goto invalid_enum_error;
1802 return !!(ctx->Array.VAO->Enabled & VERT_BIT_POINT_SIZE);
1803
1804 /* GL_ARB_texture_cube_map */
1805 case GL_TEXTURE_CUBE_MAP:
1806 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1807 goto invalid_enum_error;
1808 return is_texture_enabled(ctx, TEXTURE_CUBE_BIT);
1809
1810 /* GL_EXT_secondary_color */
1811 case GL_COLOR_SUM_EXT:
1812 if (ctx->API != API_OPENGL_COMPAT)
1813 goto invalid_enum_error;
1814 return ctx->Fog.ColorSumEnabled;
1815
1816 /* GL_ARB_multisample */
1817 case GL_MULTISAMPLE_ARB:
1818 if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES)
1819 goto invalid_enum_error;
1820 return ctx->Multisample.Enabled;
1821 case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
1822 return ctx->Multisample.SampleAlphaToCoverage;
1823 case GL_SAMPLE_ALPHA_TO_ONE_ARB:
1824 if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES)
1825 goto invalid_enum_error;
1826 return ctx->Multisample.SampleAlphaToOne;
1827 case GL_SAMPLE_COVERAGE_ARB:
1828 return ctx->Multisample.SampleCoverage;
1829 case GL_SAMPLE_COVERAGE_INVERT_ARB:
1830 if (!_mesa_is_desktop_gl(ctx))
1831 goto invalid_enum_error;
1832 return ctx->Multisample.SampleCoverageInvert;
1833
1834 /* GL_IBM_rasterpos_clip */
1835 case GL_RASTER_POSITION_UNCLIPPED_IBM:
1836 if (ctx->API != API_OPENGL_COMPAT)
1837 goto invalid_enum_error;
1838 return ctx->Transform.RasterPositionUnclipped;
1839
1840 /* GL_ARB_point_sprite */
1841 case GL_POINT_SPRITE:
1842 if (!(ctx->API == API_OPENGL_COMPAT &&
1843 _mesa_has_ARB_point_sprite(ctx)) &&
1844 !_mesa_has_OES_point_sprite(ctx))
1845 goto invalid_enum_error;
1846 return ctx->Point.PointSprite;
1847
1848 case GL_VERTEX_PROGRAM_ARB:
1849 if (!_mesa_has_ARB_vertex_program(ctx))
1850 goto invalid_enum_error;
1851 return ctx->VertexProgram.Enabled;
1852 case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
1853 /* This was added with ARB_vertex_program, but it is also used with
1854 * GLSL vertex shaders on desktop.
1855 */
1856 if (!_mesa_has_ARB_vertex_program(ctx) &&
1857 ctx->API != API_OPENGL_CORE)
1858 goto invalid_enum_error;
1859 return ctx->VertexProgram.PointSizeEnabled;
1860 case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
1861 if (!_mesa_has_ARB_vertex_program(ctx))
1862 goto invalid_enum_error;
1863 return ctx->VertexProgram.TwoSideEnabled;
1864
1865 /* GL_NV_texture_rectangle */
1866 case GL_TEXTURE_RECTANGLE_NV:
1867 if (!_mesa_has_NV_texture_rectangle(ctx))
1868 goto invalid_enum_error;
1869 return is_texture_enabled(ctx, TEXTURE_RECT_BIT);
1870
1871 /* GL_EXT_stencil_two_side */
1872 case GL_STENCIL_TEST_TWO_SIDE_EXT:
1873 if (!_mesa_has_EXT_stencil_two_side(ctx))
1874 goto invalid_enum_error;
1875 return ctx->Stencil.TestTwoSide;
1876
1877 case GL_FRAGMENT_PROGRAM_ARB:
1878 if (!_mesa_has_ARB_fragment_program(ctx))
1879 goto invalid_enum_error;
1880 return ctx->FragmentProgram.Enabled;
1881
1882 /* GL_EXT_depth_bounds_test */
1883 case GL_DEPTH_BOUNDS_TEST_EXT:
1884 if (!_mesa_has_EXT_depth_bounds_test(ctx))
1885 goto invalid_enum_error;
1886 return ctx->Depth.BoundsTest;
1887
1888 /* GL_ARB_depth_clamp */
1889 case GL_DEPTH_CLAMP:
1890 if (!_mesa_has_ARB_depth_clamp(ctx) &&
1891 !_mesa_has_EXT_depth_clamp(ctx))
1892 goto invalid_enum_error;
1893 return ctx->Transform.DepthClampNear ||
1894 ctx->Transform.DepthClampFar;
1895
1896 case GL_DEPTH_CLAMP_NEAR_AMD:
1897 if (!_mesa_has_AMD_depth_clamp_separate(ctx))
1898 goto invalid_enum_error;
1899 return ctx->Transform.DepthClampNear;
1900
1901 case GL_DEPTH_CLAMP_FAR_AMD:
1902 if (!_mesa_has_AMD_depth_clamp_separate(ctx))
1903 goto invalid_enum_error;
1904 return ctx->Transform.DepthClampFar;
1905
1906 case GL_FRAGMENT_SHADER_ATI:
1907 if (!_mesa_has_ATI_fragment_shader(ctx))
1908 goto invalid_enum_error;
1909 return ctx->ATIFragmentShader.Enabled;
1910
1911 case GL_TEXTURE_CUBE_MAP_SEAMLESS:
1912 if (!_mesa_has_ARB_seamless_cube_map(ctx))
1913 goto invalid_enum_error;
1914 return ctx->Texture.CubeMapSeamless;
1915
1916 case GL_RASTERIZER_DISCARD:
1917 if (!(_mesa_has_EXT_transform_feedback(ctx) || _mesa_is_gles3(ctx)))
1918 goto invalid_enum_error;
1919 return ctx->RasterDiscard;
1920
1921 /* GL_NV_primitive_restart */
1922 case GL_PRIMITIVE_RESTART_NV:
1923 if (!_mesa_has_NV_primitive_restart(ctx))
1924 goto invalid_enum_error;
1925 return ctx->Array.PrimitiveRestart;
1926
1927 /* GL 3.1 primitive restart */
1928 case GL_PRIMITIVE_RESTART:
1929 if (!_mesa_is_desktop_gl(ctx) || ctx->Version < 31) {
1930 goto invalid_enum_error;
1931 }
1932 return ctx->Array.PrimitiveRestart;
1933
1934 case GL_PRIMITIVE_RESTART_FIXED_INDEX:
1935 if (!_mesa_is_gles3(ctx) && !_mesa_has_ARB_ES3_compatibility(ctx))
1936 goto invalid_enum_error;
1937 return ctx->Array.PrimitiveRestartFixedIndex;
1938
1939 /* GL3.0 - GL_framebuffer_sRGB */
1940 case GL_FRAMEBUFFER_SRGB_EXT:
1941 if (!_mesa_has_EXT_framebuffer_sRGB(ctx) &&
1942 !_mesa_has_EXT_sRGB_write_control(ctx))
1943 goto invalid_enum_error;
1944 return ctx->Color.sRGBEnabled;
1945
1946 /* GL_OES_EGL_image_external */
1947 case GL_TEXTURE_EXTERNAL_OES:
1948 if (!_mesa_has_OES_EGL_image_external(ctx))
1949 goto invalid_enum_error;
1950 return is_texture_enabled(ctx, TEXTURE_EXTERNAL_BIT);
1951
1952 /* ARB_texture_multisample */
1953 case GL_SAMPLE_MASK:
1954 if (!_mesa_has_ARB_texture_multisample(ctx) && !_mesa_is_gles31(ctx))
1955 goto invalid_enum_error;
1956 return ctx->Multisample.SampleMask;
1957
1958 /* ARB_sample_shading */
1959 case GL_SAMPLE_SHADING:
1960 if (!_mesa_has_ARB_sample_shading(ctx) && !_mesa_is_gles3(ctx))
1961 goto invalid_enum_error;
1962 return ctx->Multisample.SampleShading;
1963
1964 case GL_BLEND_ADVANCED_COHERENT_KHR:
1965 if (!_mesa_has_KHR_blend_equation_advanced_coherent(ctx))
1966 goto invalid_enum_error;
1967 return ctx->Color.BlendCoherent;
1968
1969 case GL_CONSERVATIVE_RASTERIZATION_INTEL:
1970 if (!_mesa_has_INTEL_conservative_rasterization(ctx))
1971 goto invalid_enum_error;
1972 return ctx->IntelConservativeRasterization;
1973
1974 case GL_CONSERVATIVE_RASTERIZATION_NV:
1975 if (!_mesa_has_NV_conservative_raster(ctx))
1976 goto invalid_enum_error;
1977 return ctx->ConservativeRasterization;
1978
1979 case GL_TILE_RASTER_ORDER_FIXED_MESA:
1980 if (!_mesa_has_MESA_tile_raster_order(ctx))
1981 goto invalid_enum_error;
1982 return ctx->TileRasterOrderFixed;
1983
1984 case GL_TILE_RASTER_ORDER_INCREASING_X_MESA:
1985 if (!_mesa_has_MESA_tile_raster_order(ctx))
1986 goto invalid_enum_error;
1987 return ctx->TileRasterOrderIncreasingX;
1988
1989 case GL_TILE_RASTER_ORDER_INCREASING_Y_MESA:
1990 if (!_mesa_has_MESA_tile_raster_order(ctx))
1991 goto invalid_enum_error;
1992 return ctx->TileRasterOrderIncreasingY;
1993
1994 case GL_BLACKHOLE_RENDER_INTEL:
1995 if (!_mesa_has_INTEL_blackhole_render(ctx))
1996 goto invalid_enum_error;
1997 return ctx->IntelBlackholeRender;
1998
1999 default:
2000 goto invalid_enum_error;
2001 }
2002
2003 return GL_FALSE;
2004
2005 invalid_enum_error:
2006 _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled(%s)",
2007 _mesa_enum_to_string(cap));
2008 return GL_FALSE;
2009 }
2010