source: trunk/src/opengl/mesa/enable.c@ 3204

Last change on this file since 3204 was 2962, checked in by jeroen, 26 years ago

* empty log message *
File size: 20.6 KB
Line 
1/* $Id: enable.c,v 1.2 2000-03-01 18:49:27 jeroen Exp $ */
2
3/*
4 * Mesa 3-D graphics library
5 * Version: 3.1
6 *
7 * Copyright (C) 1999 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/* $XFree86: xc/lib/GL/mesa/src/enable.c,v 1.3 1999/04/04 00:20:23 dawes Exp $ */
29
30#ifdef PC_HEADER
31#include "all.h"
32#else
33#ifndef XFree86Server
34#include <stdio.h>
35#include <string.h>
36#else
37#include "GL/xf86glx.h"
38#endif
39#include "types.h"
40#include "context.h"
41#include "enable.h"
42#include "light.h"
43#include "macros.h"
44#include "matrix.h"
45#include "mmath.h"
46#include "simple_list.h"
47#include "vbfill.h"
48#include "xform.h"
49#include "enums.h"
50#endif
51
52
53
54/*
55 * Perform glEnable and glDisable calls.
56 */
57void gl_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
58{
59 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, "gl_enable/disable" );
60
61 if (MESA_VERBOSE & VERBOSE_API)
62 fprintf(stderr, "%s %s (newstate is %x)\n",
63 state ? "glEnable" : "glDisable",
64 gl_lookup_enum_by_nr(cap),
65 ctx->NewState);
66
67 switch (cap) {
68 case GL_ALPHA_TEST:
69 if (ctx->Color.AlphaEnabled!=state) {
70 ctx->Color.AlphaEnabled = state;
71 ctx->NewState |= NEW_RASTER_OPS;
72 }
73 break;
74 case GL_AUTO_NORMAL:
75 ctx->Eval.AutoNormal = state;
76 break;
77 case GL_BLEND:
78 if (ctx->Color.BlendEnabled!=state) {
79 ctx->Color.BlendEnabled = state;
80 /* The following needed to accomodate 1.0 RGB logic op blending */
81 if (ctx->Color.BlendEquation==GL_LOGIC_OP && state) {
82 ctx->Color.ColorLogicOpEnabled = GL_TRUE;
83 }
84 else {
85 ctx->Color.ColorLogicOpEnabled = GL_FALSE;
86 }
87 ctx->NewState |= NEW_RASTER_OPS;
88 }
89 break;
90 case GL_CLIP_PLANE0:
91 case GL_CLIP_PLANE1:
92 case GL_CLIP_PLANE2:
93 case GL_CLIP_PLANE3:
94 case GL_CLIP_PLANE4:
95 case GL_CLIP_PLANE5:
96 if (cap >= GL_CLIP_PLANE0 &&
97 cap <= GL_CLIP_PLANE5 &&
98 ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0] != state)
99 {
100 GLuint p = cap-GL_CLIP_PLANE0;
101
102 ctx->Transform.ClipEnabled[p] = state;
103 ctx->NewState |= NEW_USER_CLIP;
104
105 if (state) {
106 ctx->Enabled |= ENABLE_USERCLIP;
107 ctx->Transform.AnyClip++;
108
109 if (ctx->ProjectionMatrix.flags & MAT_DIRTY_ALL_OVER) {
110 gl_matrix_analyze( &ctx->ProjectionMatrix );
111 }
112
113 gl_transform_vector( ctx->Transform.ClipUserPlane[p],
114 ctx->Transform.EyeUserPlane[p],
115 ctx->ProjectionMatrix.inv );
116 } else {
117 if (--ctx->Transform.AnyClip == 0)
118 ctx->Enabled &= ~ENABLE_USERCLIP;
119 }
120 }
121 break;
122 case GL_COLOR_MATERIAL:
123 if (ctx->Light.ColorMaterialEnabled!=state) {
124 ctx->Light.ColorMaterialEnabled = state;
125 ctx->NewState |= NEW_LIGHTING;
126 if (state)
127 gl_update_color_material( ctx, ctx->Current.ByteColor );
128 }
129 break;
130 case GL_CULL_FACE:
131 if (ctx->Polygon.CullFlag!=state) {
132 ctx->Polygon.CullFlag = state;
133 ctx->TriangleCaps ^= DD_TRI_CULL;
134 ctx->NewState |= NEW_POLYGON;
135 }
136 break;
137 case GL_DEPTH_TEST:
138 if (state && ctx->Visual->DepthBits==0) {
139 gl_warning(ctx,"glEnable(GL_DEPTH_TEST) but no depth buffer");
140 return;
141 }
142 if (ctx->Depth.Test!=state) {
143 ctx->Depth.Test = state;
144 ctx->NewState |= NEW_RASTER_OPS;
145 }
146 break;
147 case GL_DITHER:
148 if (ctx->NoDither) {
149 /* MESA_NO_DITHER env var */
150 state = GL_FALSE;
151 }
152 if (ctx->Color.DitherFlag!=state) {
153 ctx->Color.DitherFlag = state;
154 ctx->NewState |= NEW_RASTER_OPS;
155 }
156 break;
157 case GL_FOG:
158 if (ctx->Fog.Enabled!=state) {
159 ctx->Fog.Enabled = state;
160 ctx->Enabled ^= ENABLE_FOG;
161 ctx->NewState |= NEW_FOG|NEW_RASTER_OPS;
162 }
163 break;
164 case GL_LIGHT0:
165 case GL_LIGHT1:
166 case GL_LIGHT2:
167 case GL_LIGHT3:
168 case GL_LIGHT4:
169 case GL_LIGHT5:
170 case GL_LIGHT6:
171 case GL_LIGHT7:
172 if (ctx->Light.Light[cap-GL_LIGHT0].Enabled != state)
173 {
174 ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
175
176 if (state) {
177 insert_at_tail(&ctx->Light.EnabledList,
178 &ctx->Light.Light[cap-GL_LIGHT0]);
179 if (ctx->Light.Enabled)
180 ctx->Enabled |= ENABLE_LIGHT;
181 } else {
182 remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]);
183 if (is_empty_list(&ctx->Light.EnabledList))
184 ctx->Enabled &= ~ENABLE_LIGHT;
185 }
186
187 ctx->NewState |= NEW_LIGHTING;
188 }
189 break;
190 case GL_LIGHTING:
191 if (ctx->Light.Enabled!=state) {
192 ctx->Light.Enabled = state;
193 ctx->Enabled &= ~ENABLE_LIGHT;
194 if (state)
195 ctx->Enabled |= ENABLE_LIGHT;
196 ctx->NewState |= NEW_LIGHTING;
197 }
198 break;
199 case GL_LINE_SMOOTH:
200 if (ctx->Line.SmoothFlag!=state) {
201 ctx->Line.SmoothFlag = state;
202 ctx->NewState |= NEW_RASTER_OPS;
203 }
204 break;
205 case GL_LINE_STIPPLE:
206 if (ctx->Line.StippleFlag!=state) {
207 ctx->Line.StippleFlag = state;
208 ctx->TriangleCaps ^= DD_LINE_STIPPLE;
209 ctx->NewState |= NEW_RASTER_OPS;
210 }
211 break;
212 case GL_INDEX_LOGIC_OP:
213 if (ctx->Color.IndexLogicOpEnabled!=state) {
214 ctx->Color.IndexLogicOpEnabled = state;
215 ctx->NewState |= NEW_RASTER_OPS;
216 }
217 break;
218 case GL_COLOR_LOGIC_OP:
219 if (ctx->Color.ColorLogicOpEnabled!=state) {
220 ctx->Color.ColorLogicOpEnabled = state;
221 ctx->NewState |= NEW_RASTER_OPS;
222 }
223 break;
224 case GL_MAP1_COLOR_4:
225 ctx->Eval.Map1Color4 = state;
226 break;
227 case GL_MAP1_INDEX:
228 ctx->Eval.Map1Index = state;
229 break;
230 case GL_MAP1_NORMAL:
231 ctx->Eval.Map1Normal = state;
232 break;
233 case GL_MAP1_TEXTURE_COORD_1:
234 ctx->Eval.Map1TextureCoord1 = state;
235 break;
236 case GL_MAP1_TEXTURE_COORD_2:
237 ctx->Eval.Map1TextureCoord2 = state;
238 break;
239 case GL_MAP1_TEXTURE_COORD_3:
240 ctx->Eval.Map1TextureCoord3 = state;
241 break;
242 case GL_MAP1_TEXTURE_COORD_4:
243 ctx->Eval.Map1TextureCoord4 = state;
244 break;
245 case GL_MAP1_VERTEX_3:
246 ctx->Eval.Map1Vertex3 = state;
247 break;
248 case GL_MAP1_VERTEX_4:
249 ctx->Eval.Map1Vertex4 = state;
250 break;
251 case GL_MAP2_COLOR_4:
252 ctx->Eval.Map2Color4 = state;
253 break;
254 case GL_MAP2_INDEX:
255 ctx->Eval.Map2Index = state;
256 break;
257 case GL_MAP2_NORMAL:
258 ctx->Eval.Map2Normal = state;
259 break;
260 case GL_MAP2_TEXTURE_COORD_1:
261 ctx->Eval.Map2TextureCoord1 = state;
262 break;
263 case GL_MAP2_TEXTURE_COORD_2:
264 ctx->Eval.Map2TextureCoord2 = state;
265 break;
266 case GL_MAP2_TEXTURE_COORD_3:
267 ctx->Eval.Map2TextureCoord3 = state;
268 break;
269 case GL_MAP2_TEXTURE_COORD_4:
270 ctx->Eval.Map2TextureCoord4 = state;
271 break;
272 case GL_MAP2_VERTEX_3:
273 ctx->Eval.Map2Vertex3 = state;
274 break;
275 case GL_MAP2_VERTEX_4:
276 ctx->Eval.Map2Vertex4 = state;
277 break;
278 case GL_NORMALIZE:
279 if (ctx->Transform.Normalize != state) {
280 ctx->Transform.Normalize = state;
281 ctx->NewState |= NEW_NORMAL_TRANSFORM|NEW_LIGHTING;
282 ctx->Enabled ^= ENABLE_NORMALIZE;
283 }
284 break;
285 case GL_POINT_SMOOTH:
286 if (ctx->Point.SmoothFlag!=state) {
287 ctx->Point.SmoothFlag = state;
288 ctx->NewState |= NEW_RASTER_OPS;
289 }
290 break;
291 case GL_POLYGON_SMOOTH:
292 if (ctx->Polygon.SmoothFlag!=state) {
293 ctx->Polygon.SmoothFlag = state;
294 ctx->NewState |= NEW_RASTER_OPS;
295 }
296 break;
297 case GL_POLYGON_STIPPLE:
298 if (ctx->Polygon.StippleFlag!=state) {
299 ctx->Polygon.StippleFlag = state;
300 ctx->TriangleCaps ^= DD_TRI_STIPPLE;
301 ctx->NewState |= NEW_RASTER_OPS;
302 }
303 break;
304 case GL_POLYGON_OFFSET_POINT:
305 if (ctx->Polygon.OffsetPoint!=state) {
306 ctx->Polygon.OffsetPoint = state;
307 ctx->NewState |= NEW_POLYGON;
308 }
309 break;
310 case GL_POLYGON_OFFSET_LINE:
311 if (ctx->Polygon.OffsetLine!=state) {
312 ctx->Polygon.OffsetLine = state;
313 ctx->NewState |= NEW_POLYGON;
314 }
315 break;
316 case GL_POLYGON_OFFSET_FILL:
317 /*case GL_POLYGON_OFFSET_EXT:*/
318 if (ctx->Polygon.OffsetFill!=state) {
319 ctx->Polygon.OffsetFill = state;
320 ctx->NewState |= NEW_POLYGON;
321 }
322 break;
323 case GL_RESCALE_NORMAL_EXT:
324 if (ctx->Transform.RescaleNormals != state) {
325 ctx->Transform.RescaleNormals = state;
326 ctx->NewState |= NEW_NORMAL_TRANSFORM|NEW_LIGHTING;
327 ctx->Enabled ^= ENABLE_RESCALE;
328 }
329 break;
330 case GL_SCISSOR_TEST:
331 if (ctx->Scissor.Enabled!=state) {
332 ctx->Scissor.Enabled = state;
333 ctx->NewState |= NEW_RASTER_OPS;
334 }
335 break;
336 case GL_SHARED_TEXTURE_PALETTE_EXT:
337 ctx->Texture.SharedPalette = state;
338 if (ctx->Driver.UseGlobalTexturePalette)
339 (*ctx->Driver.UseGlobalTexturePalette)( ctx, state );
340 break;
341 case GL_STENCIL_TEST:
342 if (state && ctx->Visual->StencilBits==0) {
343 gl_warning(ctx, "glEnable(GL_STENCIL_TEST) but no stencil buffer");
344 return;
345 }
346 if (ctx->Stencil.Enabled!=state) {
347 ctx->Stencil.Enabled = state;
348 ctx->NewState |= NEW_RASTER_OPS;
349 ctx->TriangleCaps ^= DD_STENCIL;
350 }
351 break;
352 case GL_TEXTURE_1D:
353 if (ctx->Visual->RGBAflag) {
354 const GLuint curr = ctx->Texture.CurrentUnit;
355 const GLuint flag = TEXTURE0_1D << (curr * 4);
356 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
357 ctx->NewState |= NEW_TEXTURE_ENABLE;
358 if (state) {
359 texUnit->Enabled |= TEXTURE0_1D;
360 ctx->Enabled |= flag;
361 }
362 else {
363 texUnit->Enabled &= ~TEXTURE0_1D;
364 ctx->Enabled &= ~flag;
365 }
366 }
367 break;
368 case GL_TEXTURE_2D:
369 if (ctx->Visual->RGBAflag) {
370 const GLuint curr = ctx->Texture.CurrentUnit;
371 const GLuint flag = TEXTURE0_2D << (curr * 4);
372 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
373 ctx->NewState |= NEW_TEXTURE_ENABLE;
374 if (state) {
375 texUnit->Enabled |= TEXTURE0_2D;
376 ctx->Enabled |= flag;
377 }
378 else {
379 texUnit->Enabled &= ~TEXTURE0_2D;
380 ctx->Enabled &= ~flag;
381 }
382 }
383 break;
384 case GL_TEXTURE_3D:
385 if (ctx->Visual->RGBAflag) {
386 const GLuint curr = ctx->Texture.CurrentUnit;
387 const GLuint flag = TEXTURE0_3D << (curr * 4);
388 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
389 ctx->NewState |= NEW_TEXTURE_ENABLE;
390 if (state) {
391 texUnit->Enabled |= TEXTURE0_3D;
392 ctx->Enabled |= flag;
393 }
394 else {
395 texUnit->Enabled &= ~TEXTURE0_3D;
396 ctx->Enabled &= ~flag;
397 }
398 }
399 break;
400 case GL_TEXTURE_GEN_Q:
401 {
402 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
403 if (state)
404 texUnit->TexGenEnabled |= Q_BIT;
405 else
406 texUnit->TexGenEnabled &= ~Q_BIT;
407 ctx->NewState |= NEW_TEXTURING;
408 }
409 break;
410 case GL_TEXTURE_GEN_R:
411 {
412 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
413 if (state)
414 texUnit->TexGenEnabled |= R_BIT;
415 else
416 texUnit->TexGenEnabled &= ~R_BIT;
417 ctx->NewState |= NEW_TEXTURING;
418 }
419 break;
420 case GL_TEXTURE_GEN_S:
421 {
422 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
423 if (state)
424 texUnit->TexGenEnabled |= S_BIT;
425 else
426 texUnit->TexGenEnabled &= ~S_BIT;
427 ctx->NewState |= NEW_TEXTURING;
428 }
429 break;
430 case GL_TEXTURE_GEN_T:
431 {
432 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
433 if (state)
434 texUnit->TexGenEnabled |= T_BIT;
435 else
436 texUnit->TexGenEnabled &= ~T_BIT;
437 ctx->NewState |= NEW_TEXTURING;
438 }
439 break;
440
441 /*
442 * CLIENT STATE!!!
443 */
444 case GL_VERTEX_ARRAY:
445 ctx->Array.Vertex.Enabled = state;
446 break;
447 case GL_NORMAL_ARRAY:
448 ctx->Array.Normal.Enabled = state;
449 break;
450 case GL_COLOR_ARRAY:
451 ctx->Array.Color.Enabled = state;
452 break;
453 case GL_INDEX_ARRAY:
454 ctx->Array.Index.Enabled = state;
455 break;
456 case GL_TEXTURE_COORD_ARRAY:
457 ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled = state;
458 break;
459 case GL_EDGE_FLAG_ARRAY:
460 ctx->Array.EdgeFlag.Enabled = state;
461 break;
462
463 default:
464 if (state) {
465 gl_error( ctx, GL_INVALID_ENUM, "glEnable" );
466 }
467 else {
468 gl_error( ctx, GL_INVALID_ENUM, "glDisable" );
469 }
470 return;
471 }
472
473 if (ctx->Driver.Enable) {
474 (*ctx->Driver.Enable)( ctx, cap, state );
475 }
476}
477
478
479
480
481void gl_Enable( GLcontext* ctx, GLenum cap )
482{
483 gl_set_enable( ctx, cap, GL_TRUE );
484}
485
486
487
488void gl_Disable( GLcontext* ctx, GLenum cap )
489{
490 gl_set_enable( ctx, cap, GL_FALSE );
491}
492
493
494
495GLboolean gl_IsEnabled( GLcontext* ctx, GLenum cap )
496{
497 switch (cap) {
498 case GL_ALPHA_TEST:
499 return ctx->Color.AlphaEnabled;
500 case GL_AUTO_NORMAL:
501 return ctx->Eval.AutoNormal;
502 case GL_BLEND:
503 return ctx->Color.BlendEnabled;
504 case GL_CLIP_PLANE0:
505 case GL_CLIP_PLANE1:
506 case GL_CLIP_PLANE2:
507 case GL_CLIP_PLANE3:
508 case GL_CLIP_PLANE4:
509 case GL_CLIP_PLANE5:
510 return ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0];
511 case GL_COLOR_MATERIAL:
512 return ctx->Light.ColorMaterialEnabled;
513 case GL_CULL_FACE:
514 return ctx->Polygon.CullFlag;
515 case GL_DEPTH_TEST:
516 return ctx->Depth.Test;
517 case GL_DITHER:
518 return ctx->Color.DitherFlag;
519 case GL_FOG:
520 return ctx->Fog.Enabled;
521 case GL_LIGHTING:
522 return ctx->Light.Enabled;
523 case GL_LIGHT0:
524 case GL_LIGHT1:
525 case GL_LIGHT2:
526 case GL_LIGHT3:
527 case GL_LIGHT4:
528 case GL_LIGHT5:
529 case GL_LIGHT6:
530 case GL_LIGHT7:
531 return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
532 case GL_LINE_SMOOTH:
533 return ctx->Line.SmoothFlag;
534 case GL_LINE_STIPPLE:
535 return ctx->Line.StippleFlag;
536 case GL_INDEX_LOGIC_OP:
537 return ctx->Color.IndexLogicOpEnabled;
538 case GL_COLOR_LOGIC_OP:
539 return ctx->Color.ColorLogicOpEnabled;
540 case GL_MAP1_COLOR_4:
541 return ctx->Eval.Map1Color4;
542 case GL_MAP1_INDEX:
543 return ctx->Eval.Map1Index;
544 case GL_MAP1_NORMAL:
545 return ctx->Eval.Map1Normal;
546 case GL_MAP1_TEXTURE_COORD_1:
547 return ctx->Eval.Map1TextureCoord1;
548 case GL_MAP1_TEXTURE_COORD_2:
549 return ctx->Eval.Map1TextureCoord2;
550 case GL_MAP1_TEXTURE_COORD_3:
551 return ctx->Eval.Map1TextureCoord3;
552 case GL_MAP1_TEXTURE_COORD_4:
553 return ctx->Eval.Map1TextureCoord4;
554 case GL_MAP1_VERTEX_3:
555 return ctx->Eval.Map1Vertex3;
556 case GL_MAP1_VERTEX_4:
557 return ctx->Eval.Map1Vertex4;
558 case GL_MAP2_COLOR_4:
559 return ctx->Eval.Map2Color4;
560 case GL_MAP2_INDEX:
561 return ctx->Eval.Map2Index;
562 case GL_MAP2_NORMAL:
563 return ctx->Eval.Map2Normal;
564 case GL_MAP2_TEXTURE_COORD_1:
565 return ctx->Eval.Map2TextureCoord1;
566 case GL_MAP2_TEXTURE_COORD_2:
567 return ctx->Eval.Map2TextureCoord2;
568 case GL_MAP2_TEXTURE_COORD_3:
569 return ctx->Eval.Map2TextureCoord3;
570 case GL_MAP2_TEXTURE_COORD_4:
571 return ctx->Eval.Map2TextureCoord4;
572 case GL_MAP2_VERTEX_3:
573 return ctx->Eval.Map2Vertex3;
574 case GL_MAP2_VERTEX_4:
575 return ctx->Eval.Map2Vertex4;
576 case GL_NORMALIZE:
577 return ctx->Transform.Normalize;
578 case GL_POINT_SMOOTH:
579 return ctx->Point.SmoothFlag;
580 case GL_POLYGON_SMOOTH:
581 return ctx->Polygon.SmoothFlag;
582 case GL_POLYGON_STIPPLE:
583 return ctx->Polygon.StippleFlag;
584 case GL_POLYGON_OFFSET_POINT:
585 return ctx->Polygon.OffsetPoint;
586 case GL_POLYGON_OFFSET_LINE:
587 return ctx->Polygon.OffsetLine;
588 case GL_POLYGON_OFFSET_FILL:
589 /*case GL_POLYGON_OFFSET_EXT:*/
590 return ctx->Polygon.OffsetFill;
591 case GL_RESCALE_NORMAL_EXT:
592 return ctx->Transform.RescaleNormals;
593 case GL_SCISSOR_TEST:
594 return ctx->Scissor.Enabled;
595 case GL_SHARED_TEXTURE_PALETTE_EXT:
596 return ctx->Texture.SharedPalette;
597 case GL_STENCIL_TEST:
598 return ctx->Stencil.Enabled;
599 case GL_TEXTURE_1D:
600 {
601 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
602 return (texUnit->Enabled & TEXTURE0_1D) ? GL_TRUE : GL_FALSE;
603 }
604 case GL_TEXTURE_2D:
605 {
606 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
607 return (texUnit->Enabled & TEXTURE0_2D) ? GL_TRUE : GL_FALSE;
608 }
609 case GL_TEXTURE_3D:
610 {
611 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
612 return (texUnit->Enabled & TEXTURE0_3D) ? GL_TRUE : GL_FALSE;
613 }
614 case GL_TEXTURE_GEN_Q:
615 {
616 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
617 return (texUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
618 }
619 case GL_TEXTURE_GEN_R:
620 {
621 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
622 return (texUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
623 }
624 case GL_TEXTURE_GEN_S:
625 {
626 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
627 return (texUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
628 }
629 case GL_TEXTURE_GEN_T:
630 {
631 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
632 return (texUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
633 }
634
635 /*
636 * CLIENT STATE!!!
637 */
638 case GL_VERTEX_ARRAY:
639 return ctx->Array.Vertex.Enabled;
640 case GL_NORMAL_ARRAY:
641 return ctx->Array.Normal.Enabled;
642 case GL_COLOR_ARRAY:
643 return ctx->Array.Color.Enabled;
644 case GL_INDEX_ARRAY:
645 return ctx->Array.Index.Enabled;
646 case GL_TEXTURE_COORD_ARRAY:
647 return ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled;
648 case GL_EDGE_FLAG_ARRAY:
649 return ctx->Array.EdgeFlag.Enabled;
650 default:
651 gl_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
652 return GL_FALSE;
653 }
654}
655
656
657
658
659static void gl_client_state( GLcontext *ctx, GLenum cap, GLboolean state )
660{
661 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx,
662 (state
663 ? "glEnableClientState"
664 : "glDisableClientState") );
665
666 switch (cap) {
667 case GL_VERTEX_ARRAY:
668 ctx->Array.Vertex.Enabled = state;
669 break;
670 case GL_NORMAL_ARRAY:
671 ctx->Array.Normal.Enabled = state;
672 break;
673 case GL_COLOR_ARRAY:
674 ctx->Array.Color.Enabled = state;
675 break;
676 case GL_INDEX_ARRAY:
677 ctx->Array.Index.Enabled = state;
678 break;
679 case GL_TEXTURE_COORD_ARRAY:
680 ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled = state;
681 break;
682 case GL_EDGE_FLAG_ARRAY:
683 ctx->Array.EdgeFlag.Enabled = state;
684 break;
685 default:
686 gl_error( ctx, GL_INVALID_ENUM, "glEnable/DisableClientState" );
687 }
688
689 ctx->NewState |= NEW_CLIENT_STATE;
690}
691
692
693
694void gl_EnableClientState( GLcontext *ctx, GLenum cap )
695{
696 gl_client_state( ctx, cap, GL_TRUE );
697}
698
699
700
701void gl_DisableClientState( GLcontext *ctx, GLenum cap )
702{
703 gl_client_state( ctx, cap, GL_FALSE );
704}
705
Note: See TracBrowser for help on using the repository browser.