1 /* $Id: enable.c,v 1.23 1997/10/29 02:23:54 brianp Exp $ */
2
3 /*
4 * Mesa 3-D graphics library
5 * Version: 2.5
6 * Copyright (C) 1995-1997 Brian Paul
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Library General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Library General Public License for more details.
17 *
18 * You should have received a copy of the GNU Library General Public
19 * License along with this library; if not, write to the Free
20 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23
24 /*
25 * $Log: enable.c,v $
26 * Revision 1.23 1997/10/29 02:23:54 brianp
27 * added UseGlobalTexturePalette() dd function (David Bucciarelli v20 3dfx)
28 *
29 * Revision 1.22 1997/10/16 01:59:08 brianp
30 * added GL_EXT_shared_texture_palette extension
31 *
32 * Revision 1.21 1997/07/24 01:25:01 brianp
33 * changed precompiled header symbol from PCH to PC_HEADER
34 *
35 * Revision 1.20 1997/06/20 02:20:32 brianp
36 * replaced Current.IntColor with Current.ByteColor
37 *
38 * Revision 1.19 1997/05/31 16:57:14 brianp
39 * added MESA_NO_RASTER env var support
40 *
41 * Revision 1.18 1997/05/28 03:24:22 brianp
42 * added precompiled header (PCH) support
43 *
44 * Revision 1.17 1997/04/24 01:49:30 brianp
45 * call gl_set_color_function() instead of directly setting pointers
46 *
47 * Revision 1.16 1997/04/12 16:54:05 brianp
48 * new NEW_POLYGON state flag
49 *
50 * Revision 1.15 1997/04/12 16:20:27 brianp
51 * removed call to Driver.Dither()
52 *
53 * Revision 1.14 1997/04/02 03:10:36 brianp
54 * changed some #include's
55 *
56 * Revision 1.13 1997/02/27 19:59:08 brianp
57 * issue a warning if enable depth or stencil test without such a buffer
58 *
59 * Revision 1.12 1997/02/09 19:53:43 brianp
60 * now use TEXTURE_xD enable constants
61 *
62 * Revision 1.11 1997/02/09 18:49:37 brianp
63 * added GL_EXT_texture3D support
64 *
65 * Revision 1.10 1997/01/28 22:13:42 brianp
66 * now there's separate state for CI and RGBA logic op enabled
67 *
68 * Revision 1.9 1996/12/18 20:00:57 brianp
69 * gl_set_material() now takes a bitmask instead of face and pname
70 *
71 * Revision 1.8 1996/12/11 20:16:49 brianp
72 * more work on the GL_COLOR_MATERIAL bug
73 *
74 * Revision 1.7 1996/12/09 22:51:51 brianp
75 * update API Color4f and Color4ub pointers for GL_COLOR_MATERIAL
76 *
77 * Revision 1.6 1996/12/07 10:21:07 brianp
78 * call gl_set_material() instead of gl_Materialfv()
79 *
80 * Revision 1.5 1996/11/09 03:11:18 brianp
81 * added missing GL_EXT_vertex_array caps to gl_enable()
82 *
83 * Revision 1.4 1996/10/11 03:44:09 brianp
84 * added comments for GL_POLYGON_OFFSET_EXT symbol
85 *
86 * Revision 1.3 1996/09/27 01:26:40 brianp
87 * removed unused variables
88 *
89 * Revision 1.2 1996/09/15 14:17:30 brianp
90 * now use GLframebuffer and GLvisual
91 *
92 * Revision 1.1 1996/09/13 01:38:16 brianp
93 * Initial revision
94 *
95 */
96
97
98 #ifdef PC_HEADER
99 #include "all.h"
100 #else
101 #include <string.h>
102 #include "context.h"
103 #include "depth.h"
104 #include "enable.h"
105 #include "light.h"
106 #include "dlist.h"
107 #include "macros.h"
108 #include "stencil.h"
109 #include "types.h"
110 #include "vbfill.h"
111 #endif
112
113
114
115 /*
116 * Perform glEnable and glDisable calls.
117 */
gl_enable(GLcontext * ctx,GLenum cap,GLboolean state)118 static void gl_enable( GLcontext* ctx, GLenum cap, GLboolean state )
119 {
120 GLuint p;
121
122 if (INSIDE_BEGIN_END(ctx)) {
123 if (state) {
124 gl_error( ctx, GL_INVALID_OPERATION, "glEnable" );
125 }
126 else {
127 gl_error( ctx, GL_INVALID_OPERATION, "glDisable" );
128 }
129 return;
130 }
131
132 switch (cap) {
133 case GL_ALPHA_TEST:
134 if (ctx->Color.AlphaEnabled!=state) {
135 ctx->Color.AlphaEnabled = state;
136 ctx->NewState |= NEW_RASTER_OPS;
137 }
138 break;
139 case GL_AUTO_NORMAL:
140 ctx->Eval.AutoNormal = state;
141 break;
142 case GL_BLEND:
143 if (ctx->Color.BlendEnabled!=state) {
144 ctx->Color.BlendEnabled = state;
145 /* The following needed to accomodate 1.0 RGB logic op blending */
146 ctx->Color.ColorLogicOpEnabled = GL_FALSE;
147 ctx->NewState |= NEW_RASTER_OPS;
148 }
149 break;
150 case GL_CLIP_PLANE0:
151 case GL_CLIP_PLANE1:
152 case GL_CLIP_PLANE2:
153 case GL_CLIP_PLANE3:
154 case GL_CLIP_PLANE4:
155 case GL_CLIP_PLANE5:
156 ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0] = state;
157 /* Check if any clip planes enabled */
158 ctx->Transform.AnyClip = GL_FALSE;
159 for (p=0;p<MAX_CLIP_PLANES;p++) {
160 if (ctx->Transform.ClipEnabled[p]) {
161 ctx->Transform.AnyClip = GL_TRUE;
162 break;
163 }
164 }
165 break;
166 case GL_COLOR_MATERIAL:
167 if (ctx->Light.ColorMaterialEnabled!=state) {
168 ctx->Light.ColorMaterialEnabled = state;
169 if (state) {
170 GLfloat color[4];
171 color[0] = ctx->Current.ByteColor[0] * ctx->Visual->InvRedScale;
172 color[1] = ctx->Current.ByteColor[1] * ctx->Visual->InvGreenScale;
173 color[2] = ctx->Current.ByteColor[2] * ctx->Visual->InvBlueScale;
174 color[3] = ctx->Current.ByteColor[3] * ctx->Visual->InvAlphaScale;
175 /* update material with current color */
176 gl_set_material( ctx, ctx->Light.ColorMaterialBitmask, color );
177 }
178 gl_set_color_function(ctx);
179 ctx->NewState |= NEW_LIGHTING;
180 }
181 break;
182 case GL_CULL_FACE:
183 if (ctx->Polygon.CullFlag!=state) {
184 ctx->Polygon.CullFlag = state;
185 ctx->NewState |= NEW_POLYGON;
186 }
187 break;
188 case GL_DEPTH_TEST:
189 if (state && ctx->Visual->DepthBits==0) {
190 gl_warning(ctx,"glEnable(GL_DEPTH_TEST) but no depth buffer");
191 return;
192 }
193 if (ctx->Depth.Test!=state) {
194 ctx->Depth.Test = state;
195 ctx->NewState |= NEW_RASTER_OPS;
196 }
197 break;
198 case GL_DITHER:
199 if (ctx->NoDither) {
200 /* MESA_NO_DITHER env var */
201 state = GL_FALSE;
202 }
203 if (ctx->Color.DitherFlag!=state) {
204 ctx->Color.DitherFlag = state;
205 ctx->NewState |= NEW_RASTER_OPS;
206 }
207 break;
208 case GL_FOG:
209 if (ctx->Fog.Enabled!=state) {
210 ctx->Fog.Enabled = state;
211 ctx->NewState |= NEW_RASTER_OPS;
212 }
213 break;
214 case GL_LIGHT0:
215 case GL_LIGHT1:
216 case GL_LIGHT2:
217 case GL_LIGHT3:
218 case GL_LIGHT4:
219 case GL_LIGHT5:
220 case GL_LIGHT6:
221 case GL_LIGHT7:
222 ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
223 ctx->NewState |= NEW_LIGHTING;
224 break;
225 case GL_LIGHTING:
226 if (ctx->Light.Enabled!=state) {
227 ctx->Light.Enabled = state;
228 ctx->NewState |= NEW_LIGHTING;
229 }
230 break;
231 case GL_LINE_SMOOTH:
232 if (ctx->Line.SmoothFlag!=state) {
233 ctx->Line.SmoothFlag = state;
234 ctx->NewState |= NEW_RASTER_OPS;
235 }
236 break;
237 case GL_LINE_STIPPLE:
238 if (ctx->Line.StippleFlag!=state) {
239 ctx->Line.StippleFlag = state;
240 ctx->NewState |= NEW_RASTER_OPS;
241 }
242 break;
243 case GL_INDEX_LOGIC_OP:
244 if (ctx->Color.IndexLogicOpEnabled!=state) {
245 ctx->NewState |= NEW_RASTER_OPS;
246 }
247 ctx->Color.IndexLogicOpEnabled = state;
248 break;
249 case GL_COLOR_LOGIC_OP:
250 if (ctx->Color.ColorLogicOpEnabled!=state) {
251 ctx->NewState |= NEW_RASTER_OPS;
252 }
253 ctx->Color.ColorLogicOpEnabled = state;
254 break;
255 case GL_MAP1_COLOR_4:
256 ctx->Eval.Map1Color4 = state;
257 break;
258 case GL_MAP1_INDEX:
259 ctx->Eval.Map1Index = state;
260 break;
261 case GL_MAP1_NORMAL:
262 ctx->Eval.Map1Normal = state;
263 break;
264 case GL_MAP1_TEXTURE_COORD_1:
265 ctx->Eval.Map1TextureCoord1 = state;
266 break;
267 case GL_MAP1_TEXTURE_COORD_2:
268 ctx->Eval.Map1TextureCoord2 = state;
269 break;
270 case GL_MAP1_TEXTURE_COORD_3:
271 ctx->Eval.Map1TextureCoord3 = state;
272 break;
273 case GL_MAP1_TEXTURE_COORD_4:
274 ctx->Eval.Map1TextureCoord4 = state;
275 break;
276 case GL_MAP1_VERTEX_3:
277 ctx->Eval.Map1Vertex3 = state;
278 break;
279 case GL_MAP1_VERTEX_4:
280 ctx->Eval.Map1Vertex4 = state;
281 break;
282 case GL_MAP2_COLOR_4:
283 ctx->Eval.Map2Color4 = state;
284 break;
285 case GL_MAP2_INDEX:
286 ctx->Eval.Map2Index = state;
287 break;
288 case GL_MAP2_NORMAL:
289 ctx->Eval.Map2Normal = state;
290 break;
291 case GL_MAP2_TEXTURE_COORD_1:
292 ctx->Eval.Map2TextureCoord1 = state;
293 break;
294 case GL_MAP2_TEXTURE_COORD_2:
295 ctx->Eval.Map2TextureCoord2 = state;
296 break;
297 case GL_MAP2_TEXTURE_COORD_3:
298 ctx->Eval.Map2TextureCoord3 = state;
299 break;
300 case GL_MAP2_TEXTURE_COORD_4:
301 ctx->Eval.Map2TextureCoord4 = state;
302 break;
303 case GL_MAP2_VERTEX_3:
304 ctx->Eval.Map2Vertex3 = state;
305 break;
306 case GL_MAP2_VERTEX_4:
307 ctx->Eval.Map2Vertex4 = state;
308 break;
309 case GL_NORMALIZE:
310 ctx->Transform.Normalize = state;
311 break;
312 case GL_POINT_SMOOTH:
313 if (ctx->Point.SmoothFlag!=state) {
314 ctx->Point.SmoothFlag = state;
315 ctx->NewState |= NEW_RASTER_OPS;
316 }
317 break;
318 case GL_POLYGON_SMOOTH:
319 if (ctx->Polygon.SmoothFlag!=state) {
320 ctx->Polygon.SmoothFlag = state;
321 ctx->NewState |= NEW_RASTER_OPS;
322 }
323 break;
324 case GL_POLYGON_STIPPLE:
325 if (ctx->Polygon.StippleFlag!=state) {
326 ctx->Polygon.StippleFlag = state;
327 ctx->NewState |= NEW_RASTER_OPS;
328 }
329 break;
330 case GL_POLYGON_OFFSET_POINT:
331 if (ctx->Polygon.OffsetPoint!=state) {
332 ctx->Polygon.OffsetPoint = state;
333 ctx->NewState |= NEW_POLYGON;
334 }
335 break;
336 case GL_POLYGON_OFFSET_LINE:
337 if (ctx->Polygon.OffsetLine!=state) {
338 ctx->Polygon.OffsetLine = state;
339 ctx->NewState |= NEW_POLYGON;
340 }
341 break;
342 case GL_POLYGON_OFFSET_FILL:
343 /*case GL_POLYGON_OFFSET_EXT:*/
344 if (ctx->Polygon.OffsetFill!=state) {
345 ctx->Polygon.OffsetFill = state;
346 ctx->NewState |= NEW_POLYGON;
347 }
348 break;
349 case GL_SCISSOR_TEST:
350 if (ctx->Scissor.Enabled!=state) {
351 ctx->Scissor.Enabled = state;
352 ctx->NewState |= NEW_RASTER_OPS;
353 }
354 break;
355 case GL_STENCIL_TEST:
356 if (state && ctx->Visual->StencilBits==0) {
357 gl_warning(ctx, "glEnable(GL_STENCIL_TEST) but no stencil buffer");
358 return;
359 }
360 if (ctx->Stencil.Enabled!=state) {
361 ctx->Stencil.Enabled = state;
362 ctx->NewState |= NEW_RASTER_OPS;
363 }
364 break;
365 case GL_TEXTURE_1D:
366 if (ctx->Visual->RGBAflag) {
367 /* texturing only works in RGB mode */
368 if (state) {
369 ctx->Texture.Enabled |= TEXTURE_1D;
370 }
371 else {
372 ctx->Texture.Enabled &= (~TEXTURE_1D);
373 }
374 ctx->NewState |= (NEW_RASTER_OPS | NEW_TEXTURING);
375 }
376 break;
377 case GL_TEXTURE_2D:
378 if (ctx->Visual->RGBAflag) {
379 /* texturing only works in RGB mode */
380 if (state) {
381 ctx->Texture.Enabled |= TEXTURE_2D;
382 }
383 else {
384 ctx->Texture.Enabled &= (~TEXTURE_2D);
385 }
386 ctx->NewState |= (NEW_RASTER_OPS | NEW_TEXTURING);
387 }
388 break;
389 case GL_TEXTURE_GEN_Q:
390 if (state) {
391 ctx->Texture.TexGenEnabled |= Q_BIT;
392 }
393 else {
394 ctx->Texture.TexGenEnabled &= ~Q_BIT;
395 }
396 ctx->NewState |= NEW_TEXTURING;
397 break;
398 case GL_TEXTURE_GEN_R:
399 if (state) {
400 ctx->Texture.TexGenEnabled |= R_BIT;
401 }
402 else {
403 ctx->Texture.TexGenEnabled &= ~R_BIT;
404 }
405 ctx->NewState |= NEW_TEXTURING;
406 break;
407 case GL_TEXTURE_GEN_S:
408 if (state) {
409 ctx->Texture.TexGenEnabled |= S_BIT;
410 }
411 else {
412 ctx->Texture.TexGenEnabled &= ~S_BIT;
413 }
414 ctx->NewState |= NEW_TEXTURING;
415 break;
416 case GL_TEXTURE_GEN_T:
417 if (state) {
418 ctx->Texture.TexGenEnabled |= T_BIT;
419 }
420 else {
421 ctx->Texture.TexGenEnabled &= ~T_BIT;
422 }
423 ctx->NewState |= NEW_TEXTURING;
424 break;
425
426 /*
427 * CLIENT STATE!!!
428 */
429 case GL_VERTEX_ARRAY:
430 ctx->Array.VertexEnabled = state;
431 break;
432 case GL_NORMAL_ARRAY:
433 ctx->Array.NormalEnabled = state;
434 break;
435 case GL_COLOR_ARRAY:
436 ctx->Array.ColorEnabled = state;
437 break;
438 case GL_INDEX_ARRAY:
439 ctx->Array.IndexEnabled = state;
440 break;
441 case GL_TEXTURE_COORD_ARRAY:
442 ctx->Array.TexCoordEnabled = state;
443 break;
444 case GL_EDGE_FLAG_ARRAY:
445 ctx->Array.EdgeFlagEnabled = state;
446 break;
447
448 default:
449 if (state) {
450 gl_error( ctx, GL_INVALID_ENUM, "glEnable" );
451 }
452 else {
453 gl_error( ctx, GL_INVALID_ENUM, "glDisable" );
454 }
455 break;
456 }
457 }
458
459
460
461
gl_Enable(GLcontext * ctx,GLenum cap)462 void gl_Enable( GLcontext* ctx, GLenum cap )
463 {
464 gl_enable( ctx, cap, GL_TRUE );
465 }
466
467
468
gl_Disable(GLcontext * ctx,GLenum cap)469 void gl_Disable( GLcontext* ctx, GLenum cap )
470 {
471 gl_enable( ctx, cap, GL_FALSE );
472 }
473
474
475
gl_IsEnabled(GLcontext * ctx,GLenum cap)476 GLboolean gl_IsEnabled( GLcontext* ctx, GLenum cap )
477 {
478 switch (cap) {
479 case GL_ALPHA_TEST:
480 return ctx->Color.AlphaEnabled;
481 case GL_AUTO_NORMAL:
482 return ctx->Eval.AutoNormal;
483 case GL_BLEND:
484 return ctx->Color.BlendEnabled;
485 case GL_CLIP_PLANE0:
486 case GL_CLIP_PLANE1:
487 case GL_CLIP_PLANE2:
488 case GL_CLIP_PLANE3:
489 case GL_CLIP_PLANE4:
490 case GL_CLIP_PLANE5:
491 return ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0];
492 case GL_COLOR_MATERIAL:
493 return ctx->Light.ColorMaterialEnabled;
494 case GL_CULL_FACE:
495 return ctx->Polygon.CullFlag;
496 case GL_DEPTH_TEST:
497 return ctx->Depth.Test;
498 case GL_DITHER:
499 return ctx->Color.DitherFlag;
500 case GL_FOG:
501 return ctx->Fog.Enabled;
502 case GL_LIGHTING:
503 return ctx->Light.Enabled;
504 case GL_LIGHT0:
505 case GL_LIGHT1:
506 case GL_LIGHT2:
507 case GL_LIGHT3:
508 case GL_LIGHT4:
509 case GL_LIGHT5:
510 case GL_LIGHT6:
511 case GL_LIGHT7:
512 return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
513 case GL_LINE_SMOOTH:
514 return ctx->Line.SmoothFlag;
515 case GL_LINE_STIPPLE:
516 return ctx->Line.StippleFlag;
517 case GL_INDEX_LOGIC_OP:
518 return ctx->Color.IndexLogicOpEnabled;
519 case GL_COLOR_LOGIC_OP:
520 return ctx->Color.ColorLogicOpEnabled;
521 case GL_MAP1_COLOR_4:
522 return ctx->Eval.Map1Color4;
523 case GL_MAP1_INDEX:
524 return ctx->Eval.Map1Index;
525 case GL_MAP1_NORMAL:
526 return ctx->Eval.Map1Normal;
527 case GL_MAP1_TEXTURE_COORD_1:
528 return ctx->Eval.Map1TextureCoord1;
529 case GL_MAP1_TEXTURE_COORD_2:
530 return ctx->Eval.Map1TextureCoord2;
531 case GL_MAP1_TEXTURE_COORD_3:
532 return ctx->Eval.Map1TextureCoord3;
533 case GL_MAP1_TEXTURE_COORD_4:
534 return ctx->Eval.Map1TextureCoord4;
535 case GL_MAP1_VERTEX_3:
536 return ctx->Eval.Map1Vertex3;
537 case GL_MAP1_VERTEX_4:
538 return ctx->Eval.Map1Vertex4;
539 case GL_MAP2_COLOR_4:
540 return ctx->Eval.Map2Color4;
541 case GL_MAP2_INDEX:
542 return ctx->Eval.Map2Index;
543 case GL_MAP2_NORMAL:
544 return ctx->Eval.Map2Normal;
545 case GL_MAP2_TEXTURE_COORD_1:
546 return ctx->Eval.Map2TextureCoord1;
547 case GL_MAP2_TEXTURE_COORD_2:
548 return ctx->Eval.Map2TextureCoord2;
549 case GL_MAP2_TEXTURE_COORD_3:
550 return ctx->Eval.Map2TextureCoord3;
551 case GL_MAP2_TEXTURE_COORD_4:
552 return ctx->Eval.Map2TextureCoord4;
553 case GL_MAP2_VERTEX_3:
554 return ctx->Eval.Map2Vertex3;
555 case GL_MAP2_VERTEX_4:
556 return ctx->Eval.Map2Vertex4;
557 case GL_NORMALIZE:
558 return ctx->Transform.Normalize;
559 case GL_POINT_SMOOTH:
560 return ctx->Point.SmoothFlag;
561 case GL_POLYGON_SMOOTH:
562 return ctx->Polygon.SmoothFlag;
563 case GL_POLYGON_STIPPLE:
564 return ctx->Polygon.StippleFlag;
565 case GL_POLYGON_OFFSET_POINT:
566 return ctx->Polygon.OffsetPoint;
567 case GL_POLYGON_OFFSET_LINE:
568 return ctx->Polygon.OffsetLine;
569 case GL_POLYGON_OFFSET_FILL:
570 /*case GL_POLYGON_OFFSET_EXT:*/
571 return ctx->Polygon.OffsetFill;
572 case GL_SCISSOR_TEST:
573 return ctx->Scissor.Enabled;
574 case GL_STENCIL_TEST:
575 return ctx->Stencil.Enabled;
576 case GL_TEXTURE_1D:
577 return (ctx->Texture.Enabled & TEXTURE_1D) ? GL_TRUE : GL_FALSE;
578 case GL_TEXTURE_2D:
579 return (ctx->Texture.Enabled & TEXTURE_2D) ? GL_TRUE : GL_FALSE;
580 case GL_TEXTURE_GEN_Q:
581 return (ctx->Texture.TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
582 case GL_TEXTURE_GEN_R:
583 return (ctx->Texture.TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
584 case GL_TEXTURE_GEN_S:
585 return (ctx->Texture.TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
586 case GL_TEXTURE_GEN_T:
587 return (ctx->Texture.TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
588
589 /*
590 * CLIENT STATE!!!
591 */
592 case GL_VERTEX_ARRAY:
593 return ctx->Array.VertexEnabled;
594 case GL_NORMAL_ARRAY:
595 return ctx->Array.NormalEnabled;
596 case GL_COLOR_ARRAY:
597 return ctx->Array.ColorEnabled;
598 case GL_INDEX_ARRAY:
599 return ctx->Array.IndexEnabled;
600 case GL_TEXTURE_COORD_ARRAY:
601 return ctx->Array.TexCoordEnabled;
602 case GL_EDGE_FLAG_ARRAY:
603 return ctx->Array.EdgeFlagEnabled;
604 default:
605 gl_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
606 return GL_FALSE;
607 }
608 }
609
610
611
612
gl_client_state(GLcontext * ctx,GLenum cap,GLboolean state)613 void gl_client_state( GLcontext *ctx, GLenum cap, GLboolean state )
614 {
615 switch (cap) {
616 case GL_VERTEX_ARRAY:
617 ctx->Array.VertexEnabled = state;
618 break;
619 case GL_NORMAL_ARRAY:
620 ctx->Array.NormalEnabled = state;
621 break;
622 case GL_COLOR_ARRAY:
623 ctx->Array.ColorEnabled = state;
624 break;
625 case GL_INDEX_ARRAY:
626 ctx->Array.IndexEnabled = state;
627 break;
628 case GL_TEXTURE_COORD_ARRAY:
629 ctx->Array.TexCoordEnabled = state;
630 break;
631 case GL_EDGE_FLAG_ARRAY:
632 ctx->Array.EdgeFlagEnabled = state;
633 break;
634 default:
635 gl_error( ctx, GL_INVALID_ENUM, "glEnable/DisableClientState" );
636 }
637 }
638
639
640
gl_EnableClientState(GLcontext * ctx,GLenum cap)641 void gl_EnableClientState( GLcontext *ctx, GLenum cap )
642 {
643 gl_client_state( ctx, cap, GL_TRUE );
644 }
645
646
647
gl_DisableClientState(GLcontext * ctx,GLenum cap)648 void gl_DisableClientState( GLcontext *ctx, GLenum cap )
649 {
650 gl_client_state( ctx, cap, GL_FALSE );
651 }
652
653