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