projects / mesa.git / blob
? search:


a706ea5d3d7a0a829bc476072b6836dc91ac7b92
[mesa.git] / src / mesa / main / enable.c
1 /* $Id: enable.c,v 1.26 2000/10/21 01:29:12 brianp Exp $ */
2
3 /*
4 * Mesa 3-D graphics library
5 * Version: 3.5
6 *
7 * Copyright (C) 1999-2000 Brian Paul All Rights Reserved.
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 */
26
27
28 #ifdef PC_HEADER
29 #include "all.h"
30 #else
31 #include "glheader.h"
32 #include "context.h"
33 #include "enable.h"
34 #include "light.h"
35 #include "macros.h"
36 #include "matrix.h"
37 #include "mmath.h"
38 #include "simple_list.h"
39 #include "types.h"
40 #include "vbfill.h"
41 #include "xform.h"
42 #include "enums.h"
43 #endif
44
45
46
47 /*
48 * Perform glEnable and glDisable calls.
49 */
50 void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
51 {
52 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, "gl_enable/disable" );
53
54 if (MESA_VERBOSE & VERBOSE_API)
55 fprintf(stderr, "%s %s (newstate is %x)\n",
56 state ? "glEnable" : "glDisable",
57 gl_lookup_enum_by_nr(cap),
58 ctx->NewState);
59
60 switch (cap) {
61 case GL_ALPHA_TEST:
62 if (ctx->Color.AlphaEnabled!=state) {
63 ctx->Color.AlphaEnabled = state;
64 ctx->NewState |= NEW_RASTER_OPS;
65 }
66 break;
67 case GL_AUTO_NORMAL:
68 ctx->Eval.AutoNormal = state;
69 break;
70 case GL_BLEND:
71 if (ctx->Color.BlendEnabled!=state) {
72 ctx->Color.BlendEnabled = state;
73 /* The following needed to accomodate 1.0 RGB logic op blending */
74 if (ctx->Color.BlendEquation==GL_LOGIC_OP && state) {
75 ctx->Color.ColorLogicOpEnabled = GL_TRUE;
76 }
77 else {
78 ctx->Color.ColorLogicOpEnabled = GL_FALSE;
79 }
80 ctx->NewState |= NEW_RASTER_OPS;
81 }
82 break;
83 case GL_CLIP_PLANE0:
84 case GL_CLIP_PLANE1:
85 case GL_CLIP_PLANE2:
86 case GL_CLIP_PLANE3:
87 case GL_CLIP_PLANE4:
88 case GL_CLIP_PLANE5:
89 if (cap >= GL_CLIP_PLANE0 &&
90 cap <= GL_CLIP_PLANE5 &&
91 ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0] != state)
92 {
93 GLuint p = cap-GL_CLIP_PLANE0;
94
95 ctx->Transform.ClipEnabled[p] = state;
96 ctx->NewState |= NEW_USER_CLIP;
97
98 if (state) {
99 ctx->Enabled |= ENABLE_USERCLIP;
100 ctx->Transform.AnyClip++;
101
102 if (ctx->ProjectionMatrix.flags & MAT_DIRTY_ALL_OVER) {
103 gl_matrix_analyze( &ctx->ProjectionMatrix );
104 }
105
106 gl_transform_vector( ctx->Transform.ClipUserPlane[p],
107 ctx->Transform.EyeUserPlane[p],
108 ctx->ProjectionMatrix.inv );
109 } else {
110 if (--ctx->Transform.AnyClip == 0)
111 ctx->Enabled &= ~ENABLE_USERCLIP;
112 }
113 }
114 break;
115 case GL_COLOR_MATERIAL:
116 if (ctx->Light.ColorMaterialEnabled!=state) {
117 ctx->Light.ColorMaterialEnabled = state;
118 ctx->NewState |= NEW_LIGHTING;
119 if (state)
120 gl_update_color_material( ctx, ctx->Current.ByteColor );
121 }
122 break;
123 case GL_CULL_FACE:
124 if (ctx->Polygon.CullFlag!=state) {
125 ctx->Polygon.CullFlag = state;
126 ctx->TriangleCaps ^= DD_TRI_CULL;
127 ctx->NewState |= NEW_POLYGON;
128 }
129 break;
130 case GL_DEPTH_TEST:
131 if (state && ctx->Visual.DepthBits==0) {
132 _mesa_warning(ctx,"glEnable(GL_DEPTH_TEST) but no depth buffer");
133 return;
134 }
135 if (ctx->Depth.Test!=state) {
136 ctx->Depth.Test = state;
137 ctx->NewState |= NEW_RASTER_OPS;
138 }
139 break;
140 case GL_DITHER:
141 if (ctx->NoDither) {
142 /* MESA_NO_DITHER env var */
143 state = GL_FALSE;
144 }
145 if (ctx->Color.DitherFlag!=state) {
146 ctx->Color.DitherFlag = state;
147 ctx->NewState |= NEW_RASTER_OPS;
148 }
149 break;
150 case GL_FOG:
151 if (ctx->Fog.Enabled!=state) {
152 ctx->Fog.Enabled = state;
153 ctx->Enabled ^= ENABLE_FOG;
154 ctx->NewState |= NEW_FOG|NEW_RASTER_OPS;
155 }
156 break;
157 case GL_HISTOGRAM:
158 if (ctx->Extensions.HaveHistogram) {
159 ctx->Pixel.HistogramEnabled = state;
160 }
161 else {
162 gl_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
163 return;
164 }
165 break;
166 case GL_LIGHT0:
167 case GL_LIGHT1:
168 case GL_LIGHT2:
169 case GL_LIGHT3:
170 case GL_LIGHT4:
171 case GL_LIGHT5:
172 case GL_LIGHT6:
173 case GL_LIGHT7:
174 if (ctx->Light.Light[cap-GL_LIGHT0].Enabled != state) {
175 ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
176
177 if (state) {
178 insert_at_tail(&ctx->Light.EnabledList,
179 &ctx->Light.Light[cap-GL_LIGHT0]);
180 if (ctx->Light.Enabled)
181 ctx->Enabled |= ENABLE_LIGHT;
182 } else {
183 remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]);
184 if (is_empty_list(&ctx->Light.EnabledList))
185 ctx->Enabled &= ~ENABLE_LIGHT;
186 }
187
188 ctx->NewState |= NEW_LIGHTING;
189 }
190 break;
191 case GL_LIGHTING:
192 if (ctx->Light.Enabled!=state) {
193 ctx->Light.Enabled = state;
194 ctx->Enabled &= ~ENABLE_LIGHT;
195 if (state)
196 ctx->Enabled |= ENABLE_LIGHT;
197 ctx->NewState |= NEW_LIGHTING;
198 }
199 break;
200 case GL_LINE_SMOOTH:
201 if (ctx->Line.SmoothFlag!=state) {
202 ctx->Line.SmoothFlag = state;
203 ctx->TriangleCaps ^= DD_LINE_SMOOTH;
204 ctx->NewState |= NEW_RASTER_OPS;
205 }
206 break;
207 case GL_LINE_STIPPLE:
208 if (ctx->Line.StippleFlag!=state) {
209 ctx->Line.StippleFlag = state;
210 ctx->TriangleCaps ^= DD_LINE_STIPPLE;
211 ctx->NewState |= NEW_RASTER_OPS;
212 }
213 break;
214 case GL_INDEX_LOGIC_OP:
215 if (ctx->Color.IndexLogicOpEnabled!=state) {
216 ctx->Color.IndexLogicOpEnabled = state;
217 ctx->NewState |= NEW_RASTER_OPS;
218 }
219 break;
220 case GL_COLOR_LOGIC_OP:
221 if (ctx->Color.ColorLogicOpEnabled!=state) {
222 ctx->Color.ColorLogicOpEnabled = state;
223 ctx->NewState |= NEW_RASTER_OPS;
224 }
225 break;
226 case GL_MAP1_COLOR_4:
227 ctx->Eval.Map1Color4 = state;
228 break;
229 case GL_MAP1_INDEX:
230 ctx->Eval.Map1Index = state;
231 break;
232 case GL_MAP1_NORMAL:
233 ctx->Eval.Map1Normal = state;
234 break;
235 case GL_MAP1_TEXTURE_COORD_1:
236 ctx->Eval.Map1TextureCoord1 = state;
237 break;
238 case GL_MAP1_TEXTURE_COORD_2:
239 ctx->Eval.Map1TextureCoord2 = state;
240 break;
241 case GL_MAP1_TEXTURE_COORD_3:
242 ctx->Eval.Map1TextureCoord3 = state;
243 break;
244 case GL_MAP1_TEXTURE_COORD_4:
245 ctx->Eval.Map1TextureCoord4 = state;
246 break;
247 case GL_MAP1_VERTEX_3:
248 ctx->Eval.Map1Vertex3 = state;
249 break;
250 case GL_MAP1_VERTEX_4:
251 ctx->Eval.Map1Vertex4 = state;
252 break;
253 case GL_MAP2_COLOR_4:
254 ctx->Eval.Map2Color4 = state;
255 break;
256 case GL_MAP2_INDEX:
257 ctx->Eval.Map2Index = state;
258 break;
259 case GL_MAP2_NORMAL:
260 ctx->Eval.Map2Normal = state;
261 break;
262 case GL_MAP2_TEXTURE_COORD_1:
263 ctx->Eval.Map2TextureCoord1 = state;
264 break;
265 case GL_MAP2_TEXTURE_COORD_2:
266 ctx->Eval.Map2TextureCoord2 = state;
267 break;
268 case GL_MAP2_TEXTURE_COORD_3:
269 ctx->Eval.Map2TextureCoord3 = state;
270 break;
271 case GL_MAP2_TEXTURE_COORD_4:
272 ctx->Eval.Map2TextureCoord4 = state;
273 break;
274 case GL_MAP2_VERTEX_3:
275 ctx->Eval.Map2Vertex3 = state;
276 break;
277 case GL_MAP2_VERTEX_4:
278 ctx->Eval.Map2Vertex4 = state;
279 break;
280 case GL_MINMAX:
281 ctx->Pixel.MinMaxEnabled = state;
282 break;
283 case GL_NORMALIZE:
284 if (ctx->Transform.Normalize != state) {
285 ctx->Transform.Normalize = state;
286 ctx->NewState |= NEW_NORMAL_TRANSFORM|NEW_LIGHTING;
287 ctx->Enabled ^= ENABLE_NORMALIZE;
288 }
289 break;
290 case GL_POINT_SMOOTH:
291 if (ctx->Point.SmoothFlag!=state) {
292 ctx->Point.SmoothFlag = state;
293 ctx->TriangleCaps ^= DD_POINT_SMOOTH;
294 ctx->NewState |= NEW_RASTER_OPS;
295 }
296 break;
297 case GL_POLYGON_SMOOTH:
298 if (ctx->Polygon.SmoothFlag!=state) {
299 ctx->Polygon.SmoothFlag = state;
300 ctx->TriangleCaps ^= DD_TRI_SMOOTH;
301 ctx->NewState |= NEW_RASTER_OPS;
302 }
303 break;
304 case GL_POLYGON_STIPPLE:
305 if (ctx->Polygon.StippleFlag!=state) {
306 ctx->Polygon.StippleFlag = state;
307 ctx->TriangleCaps ^= DD_TRI_STIPPLE;
308 ctx->NewState |= NEW_RASTER_OPS;
309 }
310 break;
311 case GL_POLYGON_OFFSET_POINT:
312 if (ctx->Polygon.OffsetPoint!=state) {
313 ctx->Polygon.OffsetPoint = state;
314 ctx->NewState |= NEW_POLYGON;
315 }
316 break;
317 case GL_POLYGON_OFFSET_LINE:
318 if (ctx->Polygon.OffsetLine!=state) {
319 ctx->Polygon.OffsetLine = state;
320 ctx->NewState |= NEW_POLYGON;
321 }
322 break;
323 case GL_POLYGON_OFFSET_FILL:
324 /*case GL_POLYGON_OFFSET_EXT:*/
325 if (ctx->Polygon.OffsetFill!=state) {
326 ctx->Polygon.OffsetFill = state;
327 ctx->NewState |= NEW_POLYGON;
328 }
329 break;
330 case GL_RESCALE_NORMAL_EXT:
331 if (ctx->Transform.RescaleNormals != state) {
332 ctx->Transform.RescaleNormals = state;
333 ctx->NewState |= NEW_NORMAL_TRANSFORM|NEW_LIGHTING;
334 ctx->Enabled ^= ENABLE_RESCALE;
335 }
336 break;
337 case GL_SCISSOR_TEST:
338 if (ctx->Scissor.Enabled!=state) {
339 ctx->Scissor.Enabled = state;
340 ctx->NewState |= NEW_RASTER_OPS;
341 }
342 break;
343 case GL_SHARED_TEXTURE_PALETTE_EXT:
344 ctx->Texture.SharedPalette = state;
345 break;
346 case GL_STENCIL_TEST:
347 if (state && ctx->Visual.StencilBits==0) {
348 _mesa_warning(ctx, "glEnable(GL_STENCIL_TEST) but no stencil buffer");
349 return;
350 }
351 if (ctx->Stencil.Enabled!=state) {
352 ctx->Stencil.Enabled = state;
353 ctx->NewState |= NEW_RASTER_OPS;
354 ctx->TriangleCaps ^= DD_STENCIL;
355 }
356 break;
357 case GL_TEXTURE_1D:
358 if (ctx->Visual.RGBAflag) {
359 const GLuint curr = ctx->Texture.CurrentUnit;
360 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
361 ctx->NewState |= NEW_TEXTURE_ENABLE;
362 if (state) {
363 texUnit->Enabled |= TEXTURE0_1D;
364 }
365 else {
366 texUnit->Enabled &= ~TEXTURE0_1D;
367 }
368 }
369 break;
370 case GL_TEXTURE_2D:
371 if (ctx->Visual.RGBAflag) {
372 const GLuint curr = ctx->Texture.CurrentUnit;
373 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
374 ctx->NewState |= NEW_TEXTURE_ENABLE;
375 if (state) {
376 texUnit->Enabled |= TEXTURE0_2D;
377 }
378 else {
379 texUnit->Enabled &= ~TEXTURE0_2D;
380 }
381 }
382 break;
383 case GL_TEXTURE_3D:
384 if (ctx->Visual.RGBAflag) {
385 const GLuint curr = ctx->Texture.CurrentUnit;
386 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
387 ctx->NewState |= NEW_TEXTURE_ENABLE;
388 if (state) {
389 texUnit->Enabled |= TEXTURE0_3D;
390 }
391 else {
392 texUnit->Enabled &= ~TEXTURE0_3D;
393 }
394 }
395 break;
396 case GL_TEXTURE_GEN_Q:
397 {
398 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
399 if (state)
400 texUnit->TexGenEnabled |= Q_BIT;
401 else
402 texUnit->TexGenEnabled &= ~Q_BIT;
403 ctx->NewState |= NEW_TEXTURING;
404 }
405 break;
406 case GL_TEXTURE_GEN_R:
407 {
408 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
409 if (state)
410 texUnit->TexGenEnabled |= R_BIT;
411 else
412 texUnit->TexGenEnabled &= ~R_BIT;
413 ctx->NewState |= NEW_TEXTURING;
414 }
415 break;
416 case GL_TEXTURE_GEN_S:
417 {
418 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
419 if (state)
420 texUnit->TexGenEnabled |= S_BIT;
421 else
422 texUnit->TexGenEnabled &= ~S_BIT;
423 ctx->NewState |= NEW_TEXTURING;
424 }
425 break;
426 case GL_TEXTURE_GEN_T:
427 {
428 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
429 if (state)
430 texUnit->TexGenEnabled |= T_BIT;
431 else
432 texUnit->TexGenEnabled &= ~T_BIT;
433 ctx->NewState |= NEW_TEXTURING;
434 }
435 break;
436
437 /*
438 * CLIENT STATE!!!
439 */
440 case GL_VERTEX_ARRAY:
441 ctx->Array.Vertex.Enabled = state;
442 break;
443 case GL_NORMAL_ARRAY:
444 ctx->Array.Normal.Enabled = state;
445 break;
446 case GL_COLOR_ARRAY:
447 ctx->Array.Color.Enabled = state;
448 break;
449 case GL_INDEX_ARRAY:
450 ctx->Array.Index.Enabled = state;
451 break;
452 case GL_TEXTURE_COORD_ARRAY:
453 ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled = state;
454 break;
455 case GL_EDGE_FLAG_ARRAY:
456 ctx->Array.EdgeFlag.Enabled = state;
457 break;
458
459 /* GL_HP_occlusion_test */
460 case GL_OCCLUSION_TEST_HP:
461 if (ctx->Extensions.HaveHpOcclusionTest) {
462 ctx->Depth.OcclusionTest = state;
463 if (state)
464 ctx->OcclusionResult = ctx->OcclusionResultSaved;
465 else
466 ctx->OcclusionResultSaved = ctx->OcclusionResult;
467 ctx->NewState |= NEW_RASTER_OPS;
468 }
469 else {
470 gl_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
471 return;
472 }
473 break;
474
475 /* GL_SGIS_pixel_texture */
476 case GL_PIXEL_TEXTURE_SGIS:
477 /* XXX check for extension */
478 ctx->Pixel.PixelTextureEnabled = state;
479 break;
480
481 /* GL_SGIX_pixel_texture */
482 case GL_PIXEL_TEX_GEN_SGIX:
483 /* XXX check for extension */
484 ctx->Pixel.PixelTextureEnabled = state;
485 break;
486
487 /* GL_SGI_color_table */
488 case GL_COLOR_TABLE_SGI:
489 /* XXX check for extension */
490 ctx->Pixel.ColorTableEnabled = state;
491 ctx->ImageTransferState = UPDATE_IMAGE_TRANSFER_STATE;
492 break;
493 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
494 ctx->Pixel.PostConvolutionColorTableEnabled = state;
495 ctx->ImageTransferState = UPDATE_IMAGE_TRANSFER_STATE;
496 break;
497 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
498 ctx->Pixel.PostColorMatrixColorTableEnabled = state;
499 ctx->ImageTransferState = UPDATE_IMAGE_TRANSFER_STATE;
500 break;
501
502 /* GL_EXT_convolution */
503 case GL_CONVOLUTION_1D:
504 /* XXX check for extension */
505 ctx->Pixel.Convolution1DEnabled = state;
506 ctx->ImageTransferState = UPDATE_IMAGE_TRANSFER_STATE;
507 break;
508 case GL_CONVOLUTION_2D:
509 ctx->Pixel.Convolution2DEnabled = state;
510 ctx->ImageTransferState = UPDATE_IMAGE_TRANSFER_STATE;
511 break;
512 case GL_SEPARABLE_2D:
513 ctx->Pixel.Separable2DEnabled = state;
514 ctx->ImageTransferState = UPDATE_IMAGE_TRANSFER_STATE;
515 break;
516
517 /* GL_ARB_texture_cube_map */
518 case GL_TEXTURE_CUBE_MAP_ARB:
519 if (ctx->Extensions.HaveTextureCubeMap) {
520 if (ctx->Visual.RGBAflag) {
521 const GLuint curr = ctx->Texture.CurrentUnit;
522 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
523 ctx->NewState |= NEW_TEXTURE_ENABLE;
524 if (state) {
525 texUnit->Enabled |= TEXTURE0_CUBE;
526 }
527 else {
528 texUnit->Enabled &= ~TEXTURE0_CUBE;
529 }
530 }
531 }
532 else {
533 gl_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
534 return;
535 }
536 break;
537
538 default:
539 gl_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
540 return;
541 }
542
543 if (ctx->Driver.Enable) {
544 (*ctx->Driver.Enable)( ctx, cap, state );
545 }
546 }
547
548
549
550
551 void
552 _mesa_Enable( GLenum cap )
553 {
554 GET_CURRENT_CONTEXT(ctx);
555 _mesa_set_enable( ctx, cap, GL_TRUE );
556 }
557
558
559
560 void
561 _mesa_Disable( GLenum cap )
562 {
563 GET_CURRENT_CONTEXT(ctx);
564 _mesa_set_enable( ctx, cap, GL_FALSE );
565 }
566
567
568
569 GLboolean
570 _mesa_IsEnabled( GLenum cap )
571 {
572 GET_CURRENT_CONTEXT(ctx);
573 switch (cap) {
574 case GL_ALPHA_TEST:
575 return ctx->Color.AlphaEnabled;
576 case GL_AUTO_NORMAL:
577 return ctx->Eval.AutoNormal;
578 case GL_BLEND:
579 return ctx->Color.BlendEnabled;
580 case GL_CLIP_PLANE0:
581 case GL_CLIP_PLANE1:
582 case GL_CLIP_PLANE2:
583 case GL_CLIP_PLANE3:
584 case GL_CLIP_PLANE4:
585 case GL_CLIP_PLANE5:
586 return ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0];
587 case GL_COLOR_MATERIAL:
588 return ctx->Light.ColorMaterialEnabled;
589 case GL_CULL_FACE:
590 return ctx->Polygon.CullFlag;
591 case GL_DEPTH_TEST:
592 return ctx->Depth.Test;
593 case GL_DITHER:
594 return ctx->Color.DitherFlag;
595 case GL_FOG:
596 return ctx->Fog.Enabled;
597 case GL_HISTOGRAM:
598 if (ctx->Extensions.HaveHistogram) {
599 return ctx->Pixel.HistogramEnabled;
600 }
601 else {
602 gl_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
603 return GL_FALSE;
604 }
605 case GL_LIGHTING:
606 return ctx->Light.Enabled;
607 case GL_LIGHT0:
608 case GL_LIGHT1:
609 case GL_LIGHT2:
610 case GL_LIGHT3:
611 case GL_LIGHT4:
612 case GL_LIGHT5:
613 case GL_LIGHT6:
614 case GL_LIGHT7:
615 return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
616 case GL_LINE_SMOOTH:
617 return ctx->Line.SmoothFlag;
618 case GL_LINE_STIPPLE:
619 return ctx->Line.StippleFlag;
620 case GL_INDEX_LOGIC_OP:
621 return ctx->Color.IndexLogicOpEnabled;
622 case GL_COLOR_LOGIC_OP:
623 return ctx->Color.ColorLogicOpEnabled;
624 case GL_MAP1_COLOR_4:
625 return ctx->Eval.Map1Color4;
626 case GL_MAP1_INDEX:
627 return ctx->Eval.Map1Index;
628 case GL_MAP1_NORMAL:
629 return ctx->Eval.Map1Normal;
630 case GL_MAP1_TEXTURE_COORD_1:
631 return ctx->Eval.Map1TextureCoord1;
632 case GL_MAP1_TEXTURE_COORD_2:
633 return ctx->Eval.Map1TextureCoord2;
634 case GL_MAP1_TEXTURE_COORD_3:
635 return ctx->Eval.Map1TextureCoord3;
636 case GL_MAP1_TEXTURE_COORD_4:
637 return ctx->Eval.Map1TextureCoord4;
638 case GL_MAP1_VERTEX_3:
639 return ctx->Eval.Map1Vertex3;
640 case GL_MAP1_VERTEX_4:
641 return ctx->Eval.Map1Vertex4;
642 case GL_MAP2_COLOR_4:
643 return ctx->Eval.Map2Color4;
644 case GL_MAP2_INDEX:
645 return ctx->Eval.Map2Index;
646 case GL_MAP2_NORMAL:
647 return ctx->Eval.Map2Normal;
648 case GL_MAP2_TEXTURE_COORD_1:
649 return ctx->Eval.Map2TextureCoord1;
650 case GL_MAP2_TEXTURE_COORD_2:
651 return ctx->Eval.Map2TextureCoord2;
652 case GL_MAP2_TEXTURE_COORD_3:
653 return ctx->Eval.Map2TextureCoord3;
654 case GL_MAP2_TEXTURE_COORD_4:
655 return ctx->Eval.Map2TextureCoord4;
656 case GL_MAP2_VERTEX_3:
657 return ctx->Eval.Map2Vertex3;
658 case GL_MAP2_VERTEX_4:
659 return ctx->Eval.Map2Vertex4;
660 case GL_MINMAX:
661 return ctx->Pixel.MinMaxEnabled;
662 case GL_NORMALIZE:
663 return ctx->Transform.Normalize;
664 case GL_POINT_SMOOTH:
665 return ctx->Point.SmoothFlag;
666 case GL_POLYGON_SMOOTH:
667 return ctx->Polygon.SmoothFlag;
668 case GL_POLYGON_STIPPLE:
669 return ctx->Polygon.StippleFlag;
670 case GL_POLYGON_OFFSET_POINT:
671 return ctx->Polygon.OffsetPoint;
672 case GL_POLYGON_OFFSET_LINE:
673 return ctx->Polygon.OffsetLine;
674 case GL_POLYGON_OFFSET_FILL:
675 /*case GL_POLYGON_OFFSET_EXT:*/
676 return ctx->Polygon.OffsetFill;
677 case GL_RESCALE_NORMAL_EXT:
678 return ctx->Transform.RescaleNormals;
679 case GL_SCISSOR_TEST:
680 return ctx->Scissor.Enabled;
681 case GL_SHARED_TEXTURE_PALETTE_EXT:
682 return ctx->Texture.SharedPalette;
683 case GL_STENCIL_TEST:
684 return ctx->Stencil.Enabled;
685 case GL_TEXTURE_1D:
686 {
687 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
688 return (texUnit->Enabled & TEXTURE0_1D) ? GL_TRUE : GL_FALSE;
689 }
690 case GL_TEXTURE_2D:
691 {
692 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
693 return (texUnit->Enabled & TEXTURE0_2D) ? GL_TRUE : GL_FALSE;
694 }
695 case GL_TEXTURE_3D:
696 {
697 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
698 return (texUnit->Enabled & TEXTURE0_3D) ? GL_TRUE : GL_FALSE;
699 }
700 case GL_TEXTURE_GEN_Q:
701 {
702 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
703 return (texUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
704 }
705 case GL_TEXTURE_GEN_R:
706 {
707 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
708 return (texUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
709 }
710 case GL_TEXTURE_GEN_S:
711 {
712 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
713 return (texUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
714 }
715 case GL_TEXTURE_GEN_T:
716 {
717 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
718 return (texUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
719 }
720
721 /*
722 * CLIENT STATE!!!
723 */
724 case GL_VERTEX_ARRAY:
725 return ctx->Array.Vertex.Enabled;
726 case GL_NORMAL_ARRAY:
727 return ctx->Array.Normal.Enabled;
728 case GL_COLOR_ARRAY:
729 return ctx->Array.Color.Enabled;
730 case GL_INDEX_ARRAY:
731 return ctx->Array.Index.Enabled;
732 case GL_TEXTURE_COORD_ARRAY:
733 return ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled;
734 case GL_EDGE_FLAG_ARRAY:
735 return ctx->Array.EdgeFlag.Enabled;
736
737 /* GL_HP_occlusion_test */
738 case GL_OCCLUSION_TEST_HP:
739 if (ctx->Extensions.HaveHpOcclusionTest) {
740 return ctx->Depth.OcclusionTest;
741 }
742 else {
743 gl_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
744 return GL_FALSE;
745 }
746
747 /* GL_SGIS_pixel_texture */
748 case GL_PIXEL_TEXTURE_SGIS:
749 return ctx->Pixel.PixelTextureEnabled;
750
751 /* GL_SGIX_pixel_texture */
752 case GL_PIXEL_TEX_GEN_SGIX:
753 return ctx->Pixel.PixelTextureEnabled;
754
755 /* GL_SGI_color_table */
756 case GL_COLOR_TABLE_SGI:
757 return ctx->Pixel.ColorTableEnabled;
758 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
759 return ctx->Pixel.PostConvolutionColorTableEnabled;
760 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
761 return ctx->Pixel.PostColorMatrixColorTableEnabled;
762
763 /* GL_EXT_convolution */
764 case GL_CONVOLUTION_1D:
765 return ctx->Pixel.Convolution1DEnabled;
766 case GL_CONVOLUTION_2D:
767 return ctx->Pixel.Convolution2DEnabled;
768 case GL_SEPARABLE_2D:
769 return ctx->Pixel.Separable2DEnabled;
770
771 /* GL_ARB_texture_cube_map */
772 case GL_TEXTURE_CUBE_MAP_ARB:
773 if (ctx->Extensions.HaveTextureCubeMap) {
774 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
775 return (texUnit->Enabled & TEXTURE0_CUBE) ? GL_TRUE : GL_FALSE;
776 }
777 else {
778 gl_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
779 return GL_FALSE;
780 }
781
782 default:
783 gl_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
784 return GL_FALSE;
785 }
786 }
787
788
789
790
791 static void
792 client_state( GLcontext *ctx, GLenum cap, GLboolean state )
793 {
794 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx,
795 (state
796 ? "glEnableClientState"
797 : "glDisableClientState") );
798
799 switch (cap) {
800 case GL_VERTEX_ARRAY:
801 ctx->Array.Vertex.Enabled = state;
802 break;
803 case GL_NORMAL_ARRAY:
804 ctx->Array.Normal.Enabled = state;
805 break;
806 case GL_COLOR_ARRAY:
807 ctx->Array.Color.Enabled = state;
808 break;
809 case GL_INDEX_ARRAY:
810 ctx->Array.Index.Enabled = state;
811 break;
812 case GL_TEXTURE_COORD_ARRAY:
813 ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled = state;
814 break;
815 case GL_EDGE_FLAG_ARRAY:
816 ctx->Array.EdgeFlag.Enabled = state;
817 break;
818 default:
819 gl_error( ctx, GL_INVALID_ENUM, "glEnable/DisableClientState" );
820 }
821
822 ctx->NewState |= NEW_CLIENT_STATE;
823 }
824
825
826
827 void
828 _mesa_EnableClientState( GLenum cap )
829 {
830 GET_CURRENT_CONTEXT(ctx);
831 client_state( ctx, cap, GL_TRUE );
832 }
833
834
835
836 void
837 _mesa_DisableClientState( GLenum cap )
838 {
839 GET_CURRENT_CONTEXT(ctx);
840 client_state( ctx, cap, GL_FALSE );
841 }
842