state_enable.c@ 80272

最後變更在這個檔案從80272是 78375,由 vboxsync 提交於 6 年前
Additions/common/crOpengl,GuestHost/OpenGL,HostServices/SharedOpenGL: Eliminate all global variables from the state tracker library (state_tracker) in preparation of the SPU DLL merging, bugref:9435
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Id Revision`
檔案大小: 16.6 KB

行
1	/* Copyright (c) 2001, Stanford University
2	* All rights reserved
3	*
4	* See the file LICENSE.txt for information on redistributing this software.
5	*/
6
7	#include <stdio.h>
8	#include "state.h"
9	#include "state/cr_statetypes.h"
10	#include "state_internals.h"
11
12	static void __enableSet (CRContext g, CRStateBits sb, CRbitvalue *neg_bitid,
13	GLenum cap, GLboolean val)
14	{
15	PCRStateTracker pState = g->pStateTracker;
16	unsigned int i;
17	i = cap - GL_CLIP_PLANE0;
18	if (i < g->limits.maxClipPlanes) {
19	g->transform.clip[i] = val;
20	DIRTY(sb->transform.enable, neg_bitid);
21	DIRTY(sb->transform.dirty, neg_bitid);
22	return;
23	}
24	i = cap - GL_LIGHT0;
25	if (i < g->limits.maxLights) {
26	g->lighting.light[i].enable = val;
27	DIRTY(sb->lighting.light[i].dirty, neg_bitid);
28	DIRTY(sb->lighting.light[i].enable, neg_bitid);
29	DIRTY(sb->lighting.dirty, neg_bitid);
30	return;
31	}
32
33	switch (cap) {
34	case GL_AUTO_NORMAL:
35	g->eval.autoNormal = val;
36	DIRTY(sb->eval.enable, neg_bitid);
37	DIRTY(sb->eval.dirty, neg_bitid);
38	break;
39	case GL_ALPHA_TEST:
40	g->buffer.alphaTest = val;
41	DIRTY(sb->buffer.enable, neg_bitid);
42	DIRTY(sb->buffer.dirty, neg_bitid);
43	break;
44	case GL_BLEND:
45	g->buffer.blend = val;
46	DIRTY(sb->buffer.enable, neg_bitid);
47	DIRTY(sb->buffer.dirty, neg_bitid);
48	break;
49	case GL_COLOR_MATERIAL :
50	if (!val)
51	{
52	/* We're TURNING OFF color material. In this case,
53	* we should make sure that the very very latest
54	* color that was specified gets copied into the
55	* material parameters, since this might be our
56	* last chance (see frame 1 of progs/kirchner
57	* for an example of why). */
58
59	crStateCurrentRecover(pState);
60	crStateColorMaterialRecover(pState);
61	}
62	g->lighting.colorMaterial = val;
63	DIRTY(sb->lighting.enable, neg_bitid);
64	DIRTY(sb->lighting.dirty, neg_bitid);
65	break;
66	#ifdef CR_EXT_secondary_color
67	case GL_COLOR_SUM_EXT :
68	if (g->extensions.EXT_secondary_color) { /* XXX does EXT_separate_specular color support this enable, too? */
69	g->lighting.colorSumEXT = val;
70	DIRTY(sb->lighting.enable, neg_bitid);
71	DIRTY(sb->lighting.dirty, neg_bitid);
72	}
73	else {
74	crStateError(pState, __LINE__, __FILE__, GL_INVALID_ENUM, "glEnable/glDisable(GL_COLOR_SUM_EXT) - No support for secondary color!");
75	return;
76	}
77	break;
78	#endif
79	case GL_CULL_FACE :
80	g->polygon.cullFace = val;
81	DIRTY(sb->polygon.enable, neg_bitid);
82	DIRTY(sb->polygon.dirty, neg_bitid);
83	break;
84	case GL_DEPTH_TEST :
85	g->buffer.depthTest = val;
86	DIRTY(sb->buffer.enable, neg_bitid);
87	DIRTY(sb->buffer.dirty, neg_bitid);
88	break;
89	case GL_DITHER :
90	g->buffer.dither = val;
91	DIRTY(sb->buffer.enable, neg_bitid);
92	DIRTY(sb->buffer.dirty, neg_bitid);
93	break;
94	case GL_FOG :
95	g->fog.enable = val;
96	DIRTY(sb->fog.enable, neg_bitid);
97	DIRTY(sb->fog.dirty, neg_bitid);
98	break;
99	case GL_LIGHTING :
100	g->lighting.lighting = val;
101	DIRTY(sb->lighting.enable, neg_bitid);
102	DIRTY(sb->lighting.dirty, neg_bitid);
103	break;
104	case GL_LINE_SMOOTH :
105	g->line.lineSmooth = val;
106	DIRTY(sb->line.enable, neg_bitid);
107	DIRTY(sb->line.dirty, neg_bitid);
108	break;
109	case GL_LINE_STIPPLE :
110	g->line.lineStipple = val;
111	DIRTY(sb->line.enable, neg_bitid);
112	DIRTY(sb->line.dirty, neg_bitid);
113	break;
114	case GL_COLOR_LOGIC_OP :
115	g->buffer.logicOp = val;
116	DIRTY(sb->buffer.enable, neg_bitid);
117	DIRTY(sb->buffer.dirty, neg_bitid);
118	break;
119	case GL_INDEX_LOGIC_OP :
120	g->buffer.indexLogicOp = val;
121	DIRTY(sb->buffer.enable, neg_bitid);
122	DIRTY(sb->buffer.dirty, neg_bitid);
123	break;
124	case GL_NORMALIZE :
125	g->transform.normalize = val;
126	DIRTY(sb->transform.enable, neg_bitid);
127	DIRTY(sb->transform.dirty, neg_bitid);
128	break;
129	case GL_POINT_SMOOTH :
130	g->point.pointSmooth = val;
131	DIRTY(sb->point.enableSmooth, neg_bitid);
132	DIRTY(sb->point.dirty, neg_bitid);
133	break;
134	case GL_POLYGON_OFFSET_FILL:
135	g->polygon.polygonOffsetFill = val;
136	DIRTY(sb->polygon.enable, neg_bitid);
137	DIRTY(sb->polygon.dirty, neg_bitid);
138	break;
139	case GL_POLYGON_OFFSET_LINE:
140	g->polygon.polygonOffsetLine = val;
141	DIRTY(sb->polygon.enable, neg_bitid);
142	DIRTY(sb->polygon.dirty, neg_bitid);
143	break;
144	case GL_POLYGON_OFFSET_POINT:
145	g->polygon.polygonOffsetPoint = val;
146	DIRTY(sb->polygon.enable, neg_bitid);
147	DIRTY(sb->polygon.dirty, neg_bitid);
148	break;
149	case GL_POLYGON_SMOOTH :
150	g->polygon.polygonSmooth = val;
151	DIRTY(sb->polygon.enable, neg_bitid);
152	DIRTY(sb->polygon.dirty, neg_bitid);
153	break;
154	case GL_POLYGON_STIPPLE :
155	g->polygon.polygonStipple = val;
156	DIRTY(sb->polygon.enable, neg_bitid);
157	DIRTY(sb->polygon.dirty, neg_bitid);
158	break;
159	#ifdef CR_NV_register_combiners
160	case GL_REGISTER_COMBINERS_NV :
161	if (g->extensions.NV_register_combiners) {
162	g->regcombiner.enabledRegCombiners = val;
163	DIRTY(sb->regcombiner.enable, neg_bitid);
164	DIRTY(sb->regcombiner.dirty, neg_bitid);
165	}
166	else {
167	crStateError(pState, __LINE__, __FILE__, GL_INVALID_ENUM, "glEnable/glDisable(GL_REGISTER_COMBINERS_NV) - No support for NV_register_combiners");
168	return;
169	}
170	break;
171	#endif
172	#ifdef CR_NV_register_combiners2
173	case GL_PER_STAGE_CONSTANTS_NV :
174	if (g->extensions.NV_register_combiners2) {
175	g->regcombiner.enabledPerStageConstants = val;
176	DIRTY(sb->regcombiner.enable, neg_bitid);
177	DIRTY(sb->regcombiner.dirty, neg_bitid);
178	}
179	else {
180	crStateError(pState, __LINE__, __FILE__, GL_INVALID_ENUM, "glEnable/glDisable(GL_PER_STAGE_CONSTANTS_NV) - No support for NV_register_combiners2");
181	return;
182	}
183	break;
184	#endif
185	#ifdef CR_NV_texture_rectangle
186	case GL_TEXTURE_RECTANGLE_NV:
187	if (g->extensions.NV_texture_rectangle) {
188	g->texture.unit[g->texture.curTextureUnit].enabledRect = val;
189	DIRTY(sb->texture.enable[g->texture.curTextureUnit], neg_bitid);
190	DIRTY(sb->texture.dirty, neg_bitid);
191	}
192	else {
193	crStateError(pState, __LINE__, __FILE__, GL_INVALID_ENUM, "glEnable/glDisable(0x%x)", cap);
194	return;
195	}
196	break;
197	#endif /* CR_NV_texture_rectangle */
198	#ifdef CR_OPENGL_VERSION_1_2
199	case GL_RESCALE_NORMAL :
200	g->transform.rescaleNormals = val;
201	DIRTY(sb->transform.enable, neg_bitid);
202	DIRTY(sb->transform.dirty, neg_bitid);
203	break;
204	#endif
205	case GL_SCISSOR_TEST :
206	g->viewport.scissorTest = val;
207	DIRTY(sb->viewport.enable, neg_bitid);
208	DIRTY(sb->viewport.dirty, neg_bitid);
209	break;
210	case GL_STENCIL_TEST :
211	g->stencil.stencilTest= val;
212	DIRTY(sb->stencil.enable, neg_bitid);
213	DIRTY(sb->stencil.dirty, neg_bitid);
214	break;
215	case GL_TEXTURE_1D :
216	g->texture.unit[g->texture.curTextureUnit].enabled1D = val;
217	DIRTY(sb->texture.enable[g->texture.curTextureUnit], neg_bitid);
218	DIRTY(sb->texture.dirty, neg_bitid);
219	break;
220	case GL_TEXTURE_2D :
221	g->texture.unit[g->texture.curTextureUnit].enabled2D = val;
222	DIRTY(sb->texture.enable[g->texture.curTextureUnit], neg_bitid);
223	DIRTY(sb->texture.dirty, neg_bitid);
224	break;
225	#ifdef CR_OPENGL_VERSION_1_2
226	case GL_TEXTURE_3D :
227	g->texture.unit[g->texture.curTextureUnit].enabled3D = val;
228	DIRTY(sb->texture.enable[g->texture.curTextureUnit], neg_bitid);
229	DIRTY(sb->texture.dirty, neg_bitid);
230	break;
231	#endif
232	#ifdef CR_ARB_texture_cube_map
233	case GL_TEXTURE_CUBE_MAP_ARB:
234	if (g->extensions.ARB_texture_cube_map) {
235	g->texture.unit[g->texture.curTextureUnit].enabledCubeMap = val;
236	DIRTY(sb->texture.enable[g->texture.curTextureUnit], neg_bitid);
237	DIRTY(sb->texture.dirty, neg_bitid);
238	}
239	else {
240	crStateError(pState, __LINE__, __FILE__, GL_INVALID_ENUM, "glEnable/glDisable(0x%x)", cap);
241	return;
242	}
243	break;
244	#endif /* CR_ARB_texture_cube_map */
245	case GL_TEXTURE_GEN_Q :
246	g->texture.unit[g->texture.curTextureUnit].textureGen.q = val;
247	DIRTY(sb->texture.enable[g->texture.curTextureUnit], neg_bitid);
248	DIRTY(sb->texture.dirty, neg_bitid);
249	break;
250	case GL_TEXTURE_GEN_R :
251	g->texture.unit[g->texture.curTextureUnit].textureGen.r = val;
252	DIRTY(sb->texture.enable[g->texture.curTextureUnit], neg_bitid);
253	DIRTY(sb->texture.dirty, neg_bitid);
254	break;
255	case GL_TEXTURE_GEN_S :
256	g->texture.unit[g->texture.curTextureUnit].textureGen.s = val;
257	DIRTY(sb->texture.enable[g->texture.curTextureUnit], neg_bitid);
258	DIRTY(sb->texture.dirty, neg_bitid);
259	break;
260	case GL_TEXTURE_GEN_T :
261	g->texture.unit[g->texture.curTextureUnit].textureGen.t = val;
262	DIRTY(sb->texture.enable[g->texture.curTextureUnit], neg_bitid);
263	DIRTY(sb->texture.dirty, neg_bitid);
264	break;
265	case GL_MAP1_COLOR_4 :
266	case GL_MAP1_INDEX :
267	case GL_MAP1_NORMAL :
268	case GL_MAP1_TEXTURE_COORD_1 :
269	case GL_MAP1_TEXTURE_COORD_2 :
270	case GL_MAP1_TEXTURE_COORD_3 :
271	case GL_MAP1_TEXTURE_COORD_4 :
272	case GL_MAP1_VERTEX_3 :
273	case GL_MAP1_VERTEX_4 :
274	if (g->texture.curTextureUnit != 0)
275	{
276	crStateError(pState, __LINE__, __FILE__, GL_INVALID_OPERATION, "Map stuff was enabled while the current texture unit was not GL_TEXTURE0_ARB!" );
277	return;
278	}
279	g->eval.enable1D[cap - GL_MAP1_COLOR_4] = val;
280	DIRTY(sb->eval.enable1D[cap - GL_MAP1_COLOR_4], neg_bitid);
281	DIRTY(sb->eval.dirty, neg_bitid);
282	break;
283	case GL_MAP2_COLOR_4 :
284	case GL_MAP2_INDEX :
285	case GL_MAP2_NORMAL :
286	case GL_MAP2_TEXTURE_COORD_1 :
287	case GL_MAP2_TEXTURE_COORD_2 :
288	case GL_MAP2_TEXTURE_COORD_3 :
289	case GL_MAP2_TEXTURE_COORD_4 :
290	case GL_MAP2_VERTEX_3 :
291	case GL_MAP2_VERTEX_4 :
292	#if 0
293	if (g->texture.curTextureUnit != 0)
294	{
295	crStateError( __LINE__, __FILE__, GL_INVALID_OPERATION, "Map stuff was enabled while the current texture unit was not GL_TEXTURE0_ARB!" );
296	return;
297	}
298	#endif
299	g->eval.enable2D[cap - GL_MAP2_COLOR_4] = val;
300	DIRTY(sb->eval.enable2D[cap - GL_MAP2_COLOR_4], neg_bitid);
301	DIRTY(sb->eval.dirty, neg_bitid);
302	break;
303	#ifdef CR_ARB_multisample
304	case GL_MULTISAMPLE_ARB:
305	g->multisample.enabled = val;
306	DIRTY(sb->multisample.enable, neg_bitid);
307	DIRTY(sb->multisample.dirty, neg_bitid);
308	break;
309	case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
310	g->multisample.sampleAlphaToCoverage = val;
311	DIRTY(sb->multisample.sampleAlphaToCoverage, neg_bitid);
312	DIRTY(sb->multisample.dirty, neg_bitid);
313	break;
314	case GL_SAMPLE_ALPHA_TO_ONE_ARB:
315	g->multisample.sampleAlphaToOne = val;
316	DIRTY(sb->multisample.sampleAlphaToOne, neg_bitid);
317	DIRTY(sb->multisample.dirty, neg_bitid);
318	break;
319	case GL_SAMPLE_COVERAGE_ARB:
320	g->multisample.sampleCoverage = val;
321	DIRTY(sb->multisample.sampleCoverage, neg_bitid);
322	DIRTY(sb->multisample.dirty, neg_bitid);
323	break;
324	#endif
325	#ifdef CR_NV_vertex_program
326	case GL_VERTEX_PROGRAM_NV:
327	if (g->extensions.NV_vertex_program) {
328	g->program.vpEnabled = val;
329	DIRTY(sb->program.vpEnable, neg_bitid);
330	DIRTY(sb->program.dirty, neg_bitid);
331	}
332	else if (g->extensions.ARB_vertex_program) {
333	g->program.vpEnabled = val;
334	DIRTY(sb->program.vpEnable, neg_bitid);
335	DIRTY(sb->program.dirty, neg_bitid);
336	}
337	else {
338	crStateError(pState, __LINE__, __FILE__, GL_INVALID_ENUM, "glEnable/glDisable(0x%x)", cap);
339	return;
340	}
341	break;
342	case GL_VERTEX_PROGRAM_POINT_SIZE_NV:
343	if (g->extensions.NV_vertex_program) {
344	g->program.vpPointSize = val;
345	DIRTY(sb->program.vpEnable, neg_bitid);
346	DIRTY(sb->program.dirty, neg_bitid);
347	}
348	else if (g->extensions.ARB_vertex_program) {
349	g->program.vpPointSize = val;
350	DIRTY(sb->program.vpEnable, neg_bitid);
351	DIRTY(sb->program.dirty, neg_bitid);
352	}
353	else {
354	crStateError(pState, __LINE__, __FILE__, GL_INVALID_ENUM, "glEnable/glDisable(0x%x)", cap);
355	return;
356	}
357	break;
358	case GL_VERTEX_PROGRAM_TWO_SIDE_NV:
359	if (g->extensions.NV_vertex_program) {
360	g->program.vpTwoSide = val;
361	DIRTY(sb->program.vpEnable, neg_bitid);
362	DIRTY(sb->program.dirty, neg_bitid);
363	}
364	else if (g->extensions.ARB_vertex_program) {
365	g->program.vpTwoSide = val;
366	DIRTY(sb->program.vpEnable, neg_bitid);
367	DIRTY(sb->program.dirty, neg_bitid);
368	}
369	else {
370	crStateError(pState, __LINE__, __FILE__, GL_INVALID_ENUM, "glEnable/glDisable(0x%x)", cap);
371	return;
372	}
373	break;
374
375	case GL_MAP1_VERTEX_ATTRIB0_4_NV:
376	case GL_MAP1_VERTEX_ATTRIB1_4_NV:
377	case GL_MAP1_VERTEX_ATTRIB2_4_NV:
378	case GL_MAP1_VERTEX_ATTRIB3_4_NV:
379	case GL_MAP1_VERTEX_ATTRIB4_4_NV:
380	case GL_MAP1_VERTEX_ATTRIB5_4_NV:
381	case GL_MAP1_VERTEX_ATTRIB6_4_NV:
382	case GL_MAP1_VERTEX_ATTRIB7_4_NV:
383	case GL_MAP1_VERTEX_ATTRIB8_4_NV:
384	case GL_MAP1_VERTEX_ATTRIB9_4_NV:
385	case GL_MAP1_VERTEX_ATTRIB10_4_NV:
386	case GL_MAP1_VERTEX_ATTRIB11_4_NV:
387	case GL_MAP1_VERTEX_ATTRIB12_4_NV:
388	case GL_MAP1_VERTEX_ATTRIB13_4_NV:
389	case GL_MAP1_VERTEX_ATTRIB14_4_NV:
390	case GL_MAP1_VERTEX_ATTRIB15_4_NV:
391	{
392	const GLint idx = cap - GL_MAP1_VERTEX_ATTRIB0_4_NV;
393	g->eval.enableAttrib1D[idx] = val;
394	DIRTY(sb->program.map1AttribArrayEnable[idx], neg_bitid);
395	DIRTY(sb->program.dirty, neg_bitid);
396	}
397	break;
398	case GL_MAP2_VERTEX_ATTRIB0_4_NV:
399	case GL_MAP2_VERTEX_ATTRIB1_4_NV:
400	case GL_MAP2_VERTEX_ATTRIB2_4_NV:
401	case GL_MAP2_VERTEX_ATTRIB3_4_NV:
402	case GL_MAP2_VERTEX_ATTRIB4_4_NV:
403	case GL_MAP2_VERTEX_ATTRIB5_4_NV:
404	case GL_MAP2_VERTEX_ATTRIB6_4_NV:
405	case GL_MAP2_VERTEX_ATTRIB7_4_NV:
406	case GL_MAP2_VERTEX_ATTRIB8_4_NV:
407	case GL_MAP2_VERTEX_ATTRIB9_4_NV:
408	case GL_MAP2_VERTEX_ATTRIB10_4_NV:
409	case GL_MAP2_VERTEX_ATTRIB11_4_NV:
410	case GL_MAP2_VERTEX_ATTRIB12_4_NV:
411	case GL_MAP2_VERTEX_ATTRIB13_4_NV:
412	case GL_MAP2_VERTEX_ATTRIB14_4_NV:
413	case GL_MAP2_VERTEX_ATTRIB15_4_NV:
414	{
415	const GLint idx = cap - GL_MAP2_VERTEX_ATTRIB0_4_NV;
416	g->eval.enableAttrib2D[idx] = val;
417	DIRTY(sb->program.map2AttribArrayEnable[idx], neg_bitid);
418	DIRTY(sb->program.dirty, neg_bitid);
419	}
420	break;
421	#endif
422	#ifdef CR_NV_fragment_program
423	case GL_FRAGMENT_PROGRAM_NV:
424	if (g->extensions.NV_fragment_program) {
425	g->program.fpEnabled = val;
426	DIRTY(sb->program.fpEnable, neg_bitid);
427	DIRTY(sb->program.dirty, neg_bitid);
428	}
429	else {
430	crStateError(pState, __LINE__, __FILE__, GL_INVALID_ENUM, "glEnable/glDisable(0x%x)", cap);
431	return;
432	}
433	break;
434	#endif
435	#ifdef CR_ARB_fragment_program
436	case GL_FRAGMENT_PROGRAM_ARB:
437	if (g->extensions.ARB_fragment_program) {
438	g->program.fpEnabledARB = val;
439	DIRTY(sb->program.fpEnable, neg_bitid);
440	DIRTY(sb->program.dirty, neg_bitid);
441	}
442	else {
443	crStateError(pState, __LINE__, __FILE__, GL_INVALID_ENUM, "glEnable/glDisable(0x%x)", cap);
444	return;
445	}
446	break;
447	#endif
448	#ifdef CR_IBM_rasterpos_clip
449	case GL_RASTER_POSITION_UNCLIPPED_IBM:
450	g->transform.rasterPositionUnclipped = val;
451	DIRTY(sb->transform.enable, neg_bitid);
452	DIRTY(sb->transform.dirty, neg_bitid);
453	break;
454	#endif
455
456	#ifdef CR_ARB_point_sprite
457	case GL_POINT_SPRITE_ARB:
458	g->point.pointSprite = val;
459	DIRTY(sb->point.enableSprite, neg_bitid);
460	DIRTY(sb->point.dirty, neg_bitid);
461	break;
462	#endif
463
464	/* Client-side enables */
465	case GL_VERTEX_ARRAY:
466	case GL_COLOR_ARRAY:
467	case GL_NORMAL_ARRAY:
468	case GL_INDEX_ARRAY:
469	case GL_TEXTURE_COORD_ARRAY:
470	case GL_EDGE_FLAG_ARRAY:
471	#ifdef CR_EXT_fog_coord
472	case GL_FOG_COORDINATE_ARRAY_POINTER_EXT:
473	#endif
474	#ifdef CR_EXT_secondary_color
475	case GL_SECONDARY_COLOR_ARRAY_EXT:
476	#endif
477	#ifdef CR_NV_vertex_program
478	case GL_VERTEX_ATTRIB_ARRAY0_NV:
479	case GL_VERTEX_ATTRIB_ARRAY1_NV:
480	case GL_VERTEX_ATTRIB_ARRAY2_NV:
481	case GL_VERTEX_ATTRIB_ARRAY3_NV:
482	case GL_VERTEX_ATTRIB_ARRAY4_NV:
483	case GL_VERTEX_ATTRIB_ARRAY5_NV:
484	case GL_VERTEX_ATTRIB_ARRAY6_NV:
485	case GL_VERTEX_ATTRIB_ARRAY7_NV:
486	case GL_VERTEX_ATTRIB_ARRAY8_NV:
487	case GL_VERTEX_ATTRIB_ARRAY9_NV:
488	case GL_VERTEX_ATTRIB_ARRAY10_NV:
489	case GL_VERTEX_ATTRIB_ARRAY11_NV:
490	case GL_VERTEX_ATTRIB_ARRAY12_NV:
491	case GL_VERTEX_ATTRIB_ARRAY13_NV:
492	case GL_VERTEX_ATTRIB_ARRAY14_NV:
493	case GL_VERTEX_ATTRIB_ARRAY15_NV:
494	#endif
495	if (val)
496	crStateEnableClientState(pState, cap);
497	else
498	crStateDisableClientState(pState, cap);
499	break;
500	#ifdef CR_EXT_stencil_two_side
501	case GL_STENCIL_TEST_TWO_SIDE_EXT:
502	g->stencil.stencilTwoSideEXT= val;
503	DIRTY(sb->stencil.enableTwoSideEXT, neg_bitid);
504	DIRTY(sb->stencil.dirty, neg_bitid);
505	break;
506	#endif
507	default:
508	crStateError(pState, __LINE__, __FILE__, GL_INVALID_ENUM, "glEnable/glDisable called with bogus cap: 0x%x", cap);
509	return;
510	}
511	}
512
513
514	void STATE_APIENTRY crStateEnable (PCRStateTracker pState, GLenum cap)
515	{
516	CRContext *g = GetCurrentContext(pState);
517	CRStateBits *sb = GetCurrentBits(pState);
518
519	if (g->current.inBeginEnd)
520	{
521	crStateError(pState, __LINE__, __FILE__, GL_INVALID_OPERATION, "glEnable called in begin/end");
522	return;
523	}
524
525	FLUSH();
526
527	__enableSet(g, sb, g->neg_bitid, cap, GL_TRUE);
528	}
529
530
531	void STATE_APIENTRY crStateDisable (PCRStateTracker pState, GLenum cap)
532	{
533	CRContext *g = GetCurrentContext(pState);
534	CRStateBits *sb = GetCurrentBits(pState);
535
536	if (g->current.inBeginEnd)
537	{
538	crStateError(pState, __LINE__, __FILE__, GL_INVALID_OPERATION, "glDisable called in begin/end");
539	return;
540	}
541
542	FLUSH();
543
544	__enableSet(g, sb, g->neg_bitid, cap, GL_FALSE);
545	}

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_enable.c@ 80272

以其他格式下載: