state_client.c@ 78263

Last change on this file since 78263 was 78263, checked in by vboxsync, 6 years ago
Config.kmk,GuestHost\OpenGL,HostServices\SharedOpenGL: Fix a bunch of compiler warnings and enable them again
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 83.6 KB

Line
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	/*
8	* This file manages all the client-side state including:
9	* Pixel pack/unpack parameters
10	* Vertex arrays
11	*/
12
13
14	#include "cr_mem.h"
15	#include "state.h"
16	#include "state/cr_statetypes.h"
17	#include "state/cr_statefuncs.h"
18	#include "state_internals.h"
19
20	const CRPixelPackState crStateNativePixelPacking = {
21	0, /* rowLength */
22	0, /* skipRows */
23	0, /* skipPixels */
24	1, /* alignment */
25	0, /* imageHeight */
26	0, /* skipImages */
27	GL_FALSE, /* swapBytes */
28	GL_FALSE, /* psLSBFirst */
29	};
30
31
32	void crStateClientInitBits (CRClientBits *c)
33	{
34	int i;
35
36	/* XXX why GLCLIENT_BIT_ALLOC? */
37	c->v = (CRbitvalue ) crCalloc(GLCLIENT_BIT_ALLOCsizeof(CRbitvalue));
38	c->n = (CRbitvalue ) crCalloc(GLCLIENT_BIT_ALLOCsizeof(CRbitvalue));
39	c->c = (CRbitvalue ) crCalloc(GLCLIENT_BIT_ALLOCsizeof(CRbitvalue));
40	c->s = (CRbitvalue ) crCalloc(GLCLIENT_BIT_ALLOCsizeof(CRbitvalue));
41	c->i = (CRbitvalue ) crCalloc(GLCLIENT_BIT_ALLOCsizeof(CRbitvalue));
42	for ( i = 0; i < CR_MAX_TEXTURE_UNITS; i++ )
43	c->t[i] = (CRbitvalue ) crCalloc(GLCLIENT_BIT_ALLOCsizeof(CRbitvalue));
44	c->e = (CRbitvalue ) crCalloc(GLCLIENT_BIT_ALLOCsizeof(CRbitvalue));
45	c->f = (CRbitvalue ) crCalloc(GLCLIENT_BIT_ALLOCsizeof(CRbitvalue));
46
47	#ifdef CR_NV_vertex_program
48	for ( i = 0; i < CR_MAX_VERTEX_ATTRIBS; i++ )
49	c->a[i] = (CRbitvalue ) crCalloc(GLCLIENT_BIT_ALLOCsizeof(CRbitvalue));
50	#endif
51	}
52
53	void crStateClientDestroyBits (CRClientBits *c)
54	{
55	int i;
56
57	crFree(c->v);
58	crFree(c->n);
59	crFree(c->c);
60	crFree(c->s);
61	crFree(c->i);
62
63	for ( i = 0; i < CR_MAX_TEXTURE_UNITS; i++ )
64	crFree(c->t[i]);
65
66	crFree(c->e);
67	crFree(c->f);
68
69	#ifdef CR_NV_vertex_program
70	for ( i = 0; i < CR_MAX_VERTEX_ATTRIBS; i++ )
71	crFree(c->a[i]);
72	#endif
73	}
74
75	static void crStateUnlockClientPointer(CRClientPointer* cp, int fFreePointer)
76	{
77	if (cp->locked)
78	{
79	#ifndef IN_GUEST
80	if (cp->p && fFreePointer != 0)
81	{
82	if (cp->fRealPtr)
83	{
84	crFree(cp->p);
85	cp->fRealPtr = 0;
86	}
87	cp->p = NULL;
88	}
89	#else
90	RT_NOREF(fFreePointer);
91	#endif
92	cp->locked = GL_FALSE;
93	}
94	}
95
96	void crStateClientDestroy(CRContext *g)
97	{
98	CRClientState *c = &(g->client);
99	#ifdef CR_EXT_compiled_vertex_array
100	if (c->array.locked)
101	{
102	unsigned int i;
103
104	crStateUnlockClientPointer(&c->array.v, 1 /fFreePointer/);
105	crStateUnlockClientPointer(&c->array.c, 1 /fFreePointer/);
106	crStateUnlockClientPointer(&c->array.f, 1 /fFreePointer/);
107	crStateUnlockClientPointer(&c->array.s, 1 /fFreePointer/);
108	crStateUnlockClientPointer(&c->array.e, 1 /fFreePointer/);
109	crStateUnlockClientPointer(&c->array.i, 1 /fFreePointer/);
110	crStateUnlockClientPointer(&c->array.n, 1 /fFreePointer/);
111	for (i = 0 ; i < CR_MAX_TEXTURE_UNITS ; i++)
112	{
113	crStateUnlockClientPointer(&c->array.t[i], 1 /fFreePointer/);
114	}
115	for (i = 0; i < CR_MAX_VERTEX_ATTRIBS; i++)
116	{
117	crStateUnlockClientPointer(&c->array.a[i], 1 /fFreePointer/);
118	}
119	}
120	#endif
121	}
122
123	void crStateClientInit(CRContext *ctx)
124	{
125	CRClientState *c = &(ctx->client);
126	unsigned int i;
127
128	/* pixel pack/unpack */
129	c->unpack.rowLength = 0;
130	c->unpack.skipRows = 0;
131	c->unpack.skipPixels = 0;
132	c->unpack.skipImages = 0;
133	c->unpack.alignment = 4;
134	c->unpack.imageHeight = 0;
135	c->unpack.swapBytes = GL_FALSE;
136	c->unpack.psLSBFirst = GL_FALSE;
137	c->pack.rowLength = 0;
138	c->pack.skipRows = 0;
139	c->pack.skipPixels = 0;
140	c->pack.skipImages = 0;
141	c->pack.alignment = 4;
142	c->pack.imageHeight = 0;
143	c->pack.swapBytes = GL_FALSE;
144	c->pack.psLSBFirst = GL_FALSE;
145
146	/* ARB multitexture */
147	c->curClientTextureUnit = 0;
148
149	#ifdef CR_EXT_compiled_vertex_array
150	c->array.lockFirst = 0;
151	c->array.lockCount = 0;
152	c->array.locked = GL_FALSE;
153	# ifdef IN_GUEST
154	c->array.synced = GL_FALSE;
155	# endif
156	#endif
157
158	/* vertex array */
159	c->array.v.p = NULL;
160	c->array.v.size = 4;
161	c->array.v.type = GL_FLOAT;
162	c->array.v.stride = 0;
163	c->array.v.enabled = 0;
164	#ifndef IN_GUEST
165	c->array.v.fRealPtr = 0;
166	#endif
167	#ifdef CR_ARB_vertex_buffer_object
168	c->array.v.buffer = ctx->bufferobject.arrayBuffer;
169	if (c->array.v.buffer)
170	++c->array.v.buffer->refCount;
171	#endif
172	#ifdef CR_EXT_compiled_vertex_array
173	c->array.v.locked = GL_FALSE;
174	c->array.v.prevPtr = NULL;
175	c->array.v.prevStride = 0;
176	# ifndef IN_GUEST
177	c->array.v.fPrevRealPtr = 0;
178	# endif
179	#endif
180
181	/* color array */
182	c->array.c.p = NULL;
183	c->array.c.size = 4;
184	c->array.c.type = GL_FLOAT;
185	c->array.c.stride = 0;
186	c->array.c.enabled = 0;
187	#ifndef IN_GUEST
188	c->array.c.fRealPtr = 0;
189	#endif
190	#ifdef CR_ARB_vertex_buffer_object
191	c->array.c.buffer = ctx->bufferobject.arrayBuffer;
192	if (c->array.c.buffer)
193	++c->array.c.buffer->refCount;
194	#endif
195	#ifdef CR_EXT_compiled_vertex_array
196	c->array.c.locked = GL_FALSE;
197	c->array.c.prevPtr = NULL;
198	c->array.c.prevStride = 0;
199	# ifndef IN_GUEST
200	c->array.c.fPrevRealPtr = 0;
201	# endif
202	#endif
203
204	/* fog array */
205	c->array.f.p = NULL;
206	c->array.f.size = 0;
207	c->array.f.type = GL_FLOAT;
208	c->array.f.stride = 0;
209	c->array.f.enabled = 0;
210	#ifndef IN_GUEST
211	c->array.f.fRealPtr = 0;
212	#endif
213	#ifdef CR_ARB_vertex_buffer_object
214	c->array.f.buffer = ctx->bufferobject.arrayBuffer;
215	if (c->array.f.buffer)
216	++c->array.f.buffer->refCount;
217	#endif
218	#ifdef CR_EXT_compiled_vertex_array
219	c->array.f.locked = GL_FALSE;
220	c->array.f.prevPtr = NULL;
221	c->array.f.prevStride = 0;
222	# ifndef IN_GUEST
223	c->array.f.fPrevRealPtr = 0;
224	# endif
225	#endif
226
227	/* secondary color array */
228	c->array.s.p = NULL;
229	c->array.s.size = 3;
230	c->array.s.type = GL_FLOAT;
231	c->array.s.stride = 0;
232	c->array.s.enabled = 0;
233	#ifndef IN_GUEST
234	c->array.s.fRealPtr = 0;
235	#endif
236	#ifdef CR_ARB_vertex_buffer_object
237	c->array.s.buffer = ctx->bufferobject.arrayBuffer;
238	if (c->array.s.buffer)
239	++c->array.s.buffer->refCount;
240	#endif
241	#ifdef CR_EXT_compiled_vertex_array
242	c->array.s.locked = GL_FALSE;
243	c->array.s.prevPtr = NULL;
244	c->array.s.prevStride = 0;
245	# ifndef IN_GUEST
246	c->array.s.fPrevRealPtr = 0;
247	# endif
248	#endif
249
250	/* edge flag array */
251	c->array.e.p = NULL;
252	c->array.e.size = 0;
253	c->array.e.type = GL_FLOAT;
254	c->array.e.stride = 0;
255	c->array.e.enabled = 0;
256	#ifndef IN_GUEST
257	c->array.e.fRealPtr = 0;
258	#endif
259	#ifdef CR_ARB_vertex_buffer_object
260	c->array.e.buffer = ctx->bufferobject.arrayBuffer;
261	if (c->array.e.buffer)
262	++c->array.e.buffer->refCount;
263	#endif
264	#ifdef CR_EXT_compiled_vertex_array
265	c->array.e.locked = GL_FALSE;
266	c->array.e.prevPtr = NULL;
267	c->array.e.prevStride = 0;
268	# ifndef IN_GUEST
269	c->array.e.fPrevRealPtr = 0;
270	# endif
271	#endif
272
273	/* color index array */
274	c->array.i.p = NULL;
275	c->array.i.size = 0;
276	c->array.i.type = GL_FLOAT;
277	c->array.i.stride = 0;
278	c->array.i.enabled = 0;
279	#ifndef IN_GUEST
280	c->array.i.fRealPtr = 0;
281	#endif
282	#ifdef CR_ARB_vertex_buffer_object
283	c->array.i.buffer = ctx->bufferobject.arrayBuffer;
284	if (c->array.i.buffer)
285	++c->array.i.buffer->refCount;
286	#endif
287	#ifdef CR_EXT_compiled_vertex_array
288	c->array.i.locked = GL_FALSE;
289	c->array.i.prevPtr = NULL;
290	c->array.i.prevStride = 0;
291	# ifndef IN_GUEST
292	c->array.i.fPrevRealPtr = 0;
293	# endif
294	#endif
295
296	/* normal array */
297	c->array.n.p = NULL;
298	c->array.n.size = 4;
299	c->array.n.type = GL_FLOAT;
300	c->array.n.stride = 0;
301	c->array.n.enabled = 0;
302	#ifndef IN_GUEST
303	c->array.n.fRealPtr = 0;
304	#endif
305	#ifdef CR_ARB_vertex_buffer_object
306	c->array.n.buffer = ctx->bufferobject.arrayBuffer;
307	if (c->array.n.buffer)
308	++c->array.n.buffer->refCount;
309	#endif
310	#ifdef CR_EXT_compiled_vertex_array
311	c->array.n.locked = GL_FALSE;
312	c->array.n.prevPtr = NULL;
313	c->array.n.prevStride = 0;
314	# ifndef IN_GUEST
315	c->array.n.fPrevRealPtr = 0;
316	# endif
317	#endif
318
319	/* texcoord arrays */
320	for (i = 0 ; i < CR_MAX_TEXTURE_UNITS ; i++)
321	{
322	c->array.t[i].p = NULL;
323	c->array.t[i].size = 4;
324	c->array.t[i].type = GL_FLOAT;
325	c->array.t[i].stride = 0;
326	c->array.t[i].enabled = 0;
327	#ifndef IN_GUEST
328	c->array.t[i].fRealPtr = 0;
329	#endif
330	#ifdef CR_ARB_vertex_buffer_object
331	c->array.t[i].buffer = ctx->bufferobject.arrayBuffer;
332	if (c->array.t[i].buffer)
333	++c->array.t[i].buffer->refCount;
334	#endif
335	#ifdef CR_EXT_compiled_vertex_array
336	c->array.t[i].locked = GL_FALSE;
337	c->array.t[i].prevPtr = NULL;
338	c->array.t[i].prevStride = 0;
339	#endif
340	# ifndef IN_GUEST
341	c->array.t[i].fPrevRealPtr = 0;
342	# endif
343	}
344
345	/* generic vertex attributes */
346	#ifdef CR_NV_vertex_program
347	for (i = 0; i < CR_MAX_VERTEX_ATTRIBS; i++) {
348	c->array.a[i].enabled = GL_FALSE;
349	c->array.a[i].type = GL_FLOAT;
350	c->array.a[i].size = 4;
351	c->array.a[i].stride = 0;
352	# ifndef IN_GUEST
353	c->array.a[i].fRealPtr = 0;
354	# endif
355	#ifdef CR_ARB_vertex_buffer_object
356	c->array.a[i].buffer = ctx->bufferobject.arrayBuffer;
357	if (c->array.a[i].buffer)
358	++c->array.a[i].buffer->refCount;
359	#endif
360	#ifdef CR_EXT_compiled_vertex_array
361	c->array.a[i].locked = GL_FALSE;
362	c->array.a[i].prevPtr = NULL;
363	c->array.a[i].prevStride = 0;
364	# ifndef IN_GUEST
365	c->array.a[i].fPrevRealPtr = 0;
366	# endif
367	#endif
368	}
369	#endif
370	}
371
372
373	/*
374	* PixelStore functions are here, not in state_pixel.c because this
375	* is client-side state, like vertex arrays.
376	*/
377
378	void STATE_APIENTRY crStatePixelStoref (GLenum pname, GLfloat param)
379	{
380
381	/* The GL SPEC says I can do this on page 76. */
382	switch( pname )
383	{
384	case GL_PACK_SWAP_BYTES:
385	case GL_PACK_LSB_FIRST:
386	case GL_UNPACK_SWAP_BYTES:
387	case GL_UNPACK_LSB_FIRST:
388	crStatePixelStorei( pname, param == 0.0f ? 0: 1 );
389	break;
390	default:
391	crStatePixelStorei( pname, (GLint) param );
392	break;
393	}
394	}
395
396	void STATE_APIENTRY crStatePixelStorei (GLenum pname, GLint param)
397	{
398	CRContext *g = GetCurrentContext();
399	CRClientState *c = &(g->client);
400	CRStateBits *sb = GetCurrentBits();
401	CRClientBits *cb = &(sb->client);
402
403	if (g->current.inBeginEnd)
404	{
405	crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "PixelStore{if} called in Begin/End");
406	return;
407	}
408
409	FLUSH();
410
411	switch(pname) {
412	case GL_PACK_SWAP_BYTES:
413	c->pack.swapBytes = (GLboolean) param;
414	DIRTY(cb->pack, g->neg_bitid);
415	break;
416	case GL_PACK_LSB_FIRST:
417	c->pack.psLSBFirst = (GLboolean) param;
418	DIRTY(cb->pack, g->neg_bitid);
419	break;
420	case GL_PACK_ROW_LENGTH:
421	if (param < 0.0f)
422	{
423	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Negative Row Length: %f", param);
424	return;
425	}
426	c->pack.rowLength = param;
427	DIRTY(cb->pack, g->neg_bitid);
428	break;
429	#ifdef CR_OPENGL_VERSION_1_2
430	case GL_PACK_IMAGE_HEIGHT:
431	if (param < 0.0f)
432	{
433	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Negative Image Height: %f", param);
434	return;
435	}
436	c->pack.imageHeight = param;
437	DIRTY(cb->pack, g->neg_bitid);
438	break;
439	#endif
440	case GL_PACK_SKIP_IMAGES:
441	if (param < 0.0f)
442	{
443	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Negative Skip Images: %f", param);
444	return;
445	}
446	c->pack.skipImages = param;
447	DIRTY(cb->pack, g->neg_bitid);
448	break;
449	case GL_PACK_SKIP_PIXELS:
450	if (param < 0.0f)
451	{
452	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Negative Skip Pixels: %f", param);
453	return;
454	}
455	c->pack.skipPixels = param;
456	DIRTY(cb->pack, g->neg_bitid);
457	break;
458	case GL_PACK_SKIP_ROWS:
459	if (param < 0.0f)
460	{
461	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Negative Row Skip: %f", param);
462	return;
463	}
464	c->pack.skipRows = param;
465	DIRTY(cb->pack, g->neg_bitid);
466	break;
467	case GL_PACK_ALIGNMENT:
468	if (((GLint) param) != 1 &&
469	((GLint) param) != 2 &&
470	((GLint) param) != 4 &&
471	((GLint) param) != 8)
472	{
473	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Invalid Alignment: %f", param);
474	return;
475	}
476	c->pack.alignment = param;
477	DIRTY(cb->pack, g->neg_bitid);
478	break;
479
480	case GL_UNPACK_SWAP_BYTES:
481	c->unpack.swapBytes = (GLboolean) param;
482	DIRTY(cb->unpack, g->neg_bitid);
483	break;
484	case GL_UNPACK_LSB_FIRST:
485	c->unpack.psLSBFirst = (GLboolean) param;
486	DIRTY(cb->unpack, g->neg_bitid);
487	break;
488	case GL_UNPACK_ROW_LENGTH:
489	if (param < 0.0f)
490	{
491	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Negative Row Length: %f", param);
492	return;
493	}
494	c->unpack.rowLength = param;
495	DIRTY(cb->unpack, g->neg_bitid);
496	break;
497	#ifdef CR_OPENGL_VERSION_1_2
498	case GL_UNPACK_IMAGE_HEIGHT:
499	if (param < 0.0f)
500	{
501	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Negative Image Height: %f", param);
502	return;
503	}
504	c->unpack.imageHeight = param;
505	DIRTY(cb->unpack, g->neg_bitid);
506	break;
507	#endif
508	case GL_UNPACK_SKIP_IMAGES:
509	if (param < 0.0f)
510	{
511	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Negative Skip Images: %f", param);
512	return;
513	}
514	c->unpack.skipImages = param;
515	DIRTY(cb->unpack, g->neg_bitid);
516	break;
517	case GL_UNPACK_SKIP_PIXELS:
518	if (param < 0.0f)
519	{
520	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Negative Skip Pixels: %f", param);
521	return;
522	}
523	c->unpack.skipPixels = param;
524	DIRTY(cb->unpack, g->neg_bitid);
525	break;
526	case GL_UNPACK_SKIP_ROWS:
527	if (param < 0.0f)
528	{
529	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Negative Row Skip: %f", param);
530	return;
531	}
532	c->unpack.skipRows = param;
533	DIRTY(cb->unpack, g->neg_bitid);
534	break;
535	case GL_UNPACK_ALIGNMENT:
536	if (((GLint) param) != 1 &&
537	((GLint) param) != 2 &&
538	((GLint) param) != 4 &&
539	((GLint) param) != 8)
540	{
541	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Invalid Alignment: %f", param);
542	return;
543	}
544	c->unpack.alignment = param;
545	DIRTY(cb->unpack, g->neg_bitid);
546	break;
547	default:
548	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Unknown glPixelStore Pname: %d", pname);
549	return;
550	}
551	DIRTY(cb->dirty, g->neg_bitid);
552	}
553
554
555	static void setClientState(CRClientState c, CRClientBits cb,
556	CRbitvalue *neg_bitid, GLenum array, GLboolean state)
557	{
558	CRContext *g = GetCurrentContext();
559
560	switch (array)
561	{
562	#ifdef CR_NV_vertex_program
563	case GL_VERTEX_ATTRIB_ARRAY0_NV:
564	case GL_VERTEX_ATTRIB_ARRAY1_NV:
565	case GL_VERTEX_ATTRIB_ARRAY2_NV:
566	case GL_VERTEX_ATTRIB_ARRAY3_NV:
567	case GL_VERTEX_ATTRIB_ARRAY4_NV:
568	case GL_VERTEX_ATTRIB_ARRAY5_NV:
569	case GL_VERTEX_ATTRIB_ARRAY6_NV:
570	case GL_VERTEX_ATTRIB_ARRAY7_NV:
571	case GL_VERTEX_ATTRIB_ARRAY8_NV:
572	case GL_VERTEX_ATTRIB_ARRAY9_NV:
573	case GL_VERTEX_ATTRIB_ARRAY10_NV:
574	case GL_VERTEX_ATTRIB_ARRAY11_NV:
575	case GL_VERTEX_ATTRIB_ARRAY12_NV:
576	case GL_VERTEX_ATTRIB_ARRAY13_NV:
577	case GL_VERTEX_ATTRIB_ARRAY14_NV:
578	case GL_VERTEX_ATTRIB_ARRAY15_NV:
579	{
580	const GLuint i = array - GL_VERTEX_ATTRIB_ARRAY0_NV;
581	c->array.a[i].enabled = state;
582	}
583	break;
584	#endif
585	case GL_VERTEX_ARRAY:
586	c->array.v.enabled = state;
587	break;
588	case GL_COLOR_ARRAY:
589	c->array.c.enabled = state;
590	break;
591	case GL_NORMAL_ARRAY:
592	c->array.n.enabled = state;
593	break;
594	case GL_INDEX_ARRAY:
595	c->array.i.enabled = state;
596	break;
597	case GL_TEXTURE_COORD_ARRAY:
598	c->array.t[c->curClientTextureUnit].enabled = state;
599	break;
600	case GL_EDGE_FLAG_ARRAY:
601	c->array.e.enabled = state;
602	break;
603	#ifdef CR_EXT_fog_coord
604	case GL_FOG_COORDINATE_ARRAY_EXT:
605	c->array.f.enabled = state;
606	break;
607	#endif
608	#ifdef CR_EXT_secondary_color
609	case GL_SECONDARY_COLOR_ARRAY_EXT:
610	if( g->extensions.EXT_secondary_color ){
611	c->array.s.enabled = state;
612	}
613	else {
614	crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "Invalid Enum passed to Enable/Disable Client State: SECONDARY_COLOR_ARRAY_EXT - EXT_secondary_color is not enabled." );
615	return;
616	}
617	break;
618	#endif
619	default:
620	crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "Invalid Enum passed to Enable/Disable Client State: 0x%x", array );
621	return;
622	}
623	DIRTY(cb->dirty, neg_bitid);
624	DIRTY(cb->enableClientState, neg_bitid);
625	}
626
627	void STATE_APIENTRY crStateEnableClientState (GLenum array)
628	{
629	CRContext *g = GetCurrentContext();
630	CRClientState *c = &(g->client);
631	CRStateBits *sb = GetCurrentBits();
632	CRClientBits *cb = &(sb->client);
633
634	FLUSH();
635
636	setClientState(c, cb, g->neg_bitid, array, GL_TRUE);
637	}
638
639	void STATE_APIENTRY crStateDisableClientState (GLenum array)
640	{
641	CRContext *g = GetCurrentContext();
642	CRClientState *c = &(g->client);
643	CRStateBits *sb = GetCurrentBits();
644	CRClientBits *cb = &(sb->client);
645
646	FLUSH();
647
648	setClientState(c, cb, g->neg_bitid, array, GL_FALSE);
649	}
650
651	static void
652	crStateClientSetPointer(CRClientPointer *cp, GLint size, GLenum type, GLboolean normalized, GLsizei stride,
653	const GLvoid *pointer CRVBOX_HOST_ONLY_PARAM(int fRealPtr))
654	{
655	CRContext *g = GetCurrentContext();
656
657	#ifdef CR_EXT_compiled_vertex_array
658	crStateUnlockClientPointer(cp, 0 /fFreePointer/);
659	# ifndef IN_GUEST
660	if (cp->prevPtr && cp->fPrevRealPtr)
661	{
662	crFree(cp->prevPtr);
663	cp->fPrevRealPtr = 0;
664	}
665	# endif
666	cp->prevPtr = cp->p;
667	cp->prevStride = cp->stride;
668	# ifndef IN_GUEST
669	cp->fPrevRealPtr = cp->fRealPtr;
670	# endif
671	#endif
672
673	cp->p = (unsigned char *) pointer;
674	cp->size = size;
675	cp->type = type;
676	cp->normalized = normalized;
677	#ifndef IN_GUEST
678	cp->fRealPtr = fRealPtr;
679	#endif
680
681	/* Calculate the bytes per index for address calculation */
682	cp->bytesPerIndex = size;
683	switch (type)
684	{
685	case GL_BYTE:
686	case GL_UNSIGNED_BYTE:
687	break;
688	case GL_SHORT:
689	case GL_UNSIGNED_SHORT:
690	cp->bytesPerIndex *= sizeof(GLshort);
691	break;
692	case GL_INT:
693	case GL_UNSIGNED_INT:
694	cp->bytesPerIndex *= sizeof(GLint);
695	break;
696	case GL_FLOAT:
697	cp->bytesPerIndex *= sizeof(GLfloat);
698	break;
699	case GL_DOUBLE:
700	cp->bytesPerIndex *= sizeof(GLdouble);
701	break;
702	default:
703	crStateError( __LINE__, __FILE__, GL_INVALID_VALUE,
704	"Unknown type of vertex array: %d", type );
705	return;
706	}
707
708	/*
709	** Note: If stride==0 then we set the
710	** stride equal address offset
711	** therefore stride can never equal
712	** zero.
713	*/
714	if (stride)
715	cp->stride = stride;
716	else
717	cp->stride = cp->bytesPerIndex;
718
719	#ifdef CR_ARB_vertex_buffer_object
720	if (cp->buffer)
721	{
722	--cp->buffer->refCount;
723	CRASSERT(cp->buffer->refCount && cp->buffer->refCount < UINT32_MAX/2);
724	}
725	cp->buffer = g->bufferobject.arrayBuffer;
726	if (cp->buffer)
727	++cp->buffer->refCount;
728	#endif
729	}
730
731	void STATE_APIENTRY crStateVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *p CRVBOX_HOST_ONLY_PARAM(int fRealPtr))
732	{
733	CRContext *g = GetCurrentContext();
734	CRClientState *c = &(g->client);
735	CRStateBits *sb = GetCurrentBits();
736	CRClientBits *cb = &(sb->client);
737
738	FLUSH();
739
740	if (size != 2 && size != 3 && size != 4)
741	{
742	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glVertexPointer: invalid size: %d", size);
743	return;
744	}
745	if (type != GL_SHORT && type != GL_INT &&
746	type != GL_FLOAT && type != GL_DOUBLE)
747	{
748	crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glVertexPointer: invalid type: 0x%x", type);
749	return;
750	}
751	if (stride < 0)
752	{
753	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glVertexPointer: stride was negative: %d", stride);
754	return;
755	}
756
757	crStateClientSetPointer(&(c->array.v), size, type, GL_FALSE, stride, p CRVBOX_HOST_ONLY_PARAM(fRealPtr));
758	DIRTY(cb->dirty, g->neg_bitid);
759	DIRTY(cb->clientPointer, g->neg_bitid);
760	DIRTY(cb->v, g->neg_bitid);
761	}
762
763	void STATE_APIENTRY crStateColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *p CRVBOX_HOST_ONLY_PARAM(int fRealPtr))
764	{
765	CRContext *g = GetCurrentContext();
766	CRClientState *c = &(g->client);
767	CRStateBits *sb = GetCurrentBits();
768	CRClientBits *cb = &(sb->client);
769
770	FLUSH();
771
772	if (size != 3 && size != 4)
773	{
774	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glColorPointer: invalid size: %d", size);
775	return;
776	}
777	if (type != GL_BYTE && type != GL_UNSIGNED_BYTE &&
778	type != GL_SHORT && type != GL_UNSIGNED_SHORT &&
779	type != GL_INT && type != GL_UNSIGNED_INT &&
780	type != GL_FLOAT && type != GL_DOUBLE)
781	{
782	crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glColorPointer: invalid type: 0x%x", type);
783	return;
784	}
785	if (stride < 0)
786	{
787	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glColorPointer: stride was negative: %d", stride);
788	return;
789	}
790
791	crStateClientSetPointer(&(c->array.c), size, type, GL_TRUE, stride, p CRVBOX_HOST_ONLY_PARAM(fRealPtr));
792	DIRTY(cb->dirty, g->neg_bitid);
793	DIRTY(cb->clientPointer, g->neg_bitid);
794	DIRTY(cb->c, g->neg_bitid);
795	}
796
797	void STATE_APIENTRY crStateSecondaryColorPointerEXT(GLint size, GLenum type, GLsizei stride, const GLvoid *p CRVBOX_HOST_ONLY_PARAM(int fRealPtr))
798	{
799	CRContext *g = GetCurrentContext();
800	CRClientState *c = &(g->client);
801	CRStateBits *sb = GetCurrentBits();
802	CRClientBits *cb = &(sb->client);
803
804	FLUSH();
805
806	if ( !g->extensions.EXT_secondary_color )
807	{
808	crError( "glSecondaryColorPointerEXT called but EXT_secondary_color is disabled." );
809	return;
810	}
811
812	/*Note: According to opengl spec, only size==3 should be accepted here.
813	*But it turns out that most drivers accept size==4 here as well, and 4th value
814	*could even be accessed in shaders code.
815	*Having a strict check here, leads to difference between guest and host gpu states, which
816	*in turn could lead to crashes when using server side VBOs.
817	*@todo: add error reporting to state's VBO related functions and abort dispatching to
818	*real gpu on any failure to prevent other possible issues.
819	*/
820
821	if ((size != 3) && (size != 4))
822	{
823	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glSecondaryColorPointerEXT: invalid size: %d", size);
824	return;
825	}
826	if (type != GL_BYTE && type != GL_UNSIGNED_BYTE &&
827	type != GL_SHORT && type != GL_UNSIGNED_SHORT &&
828	type != GL_INT && type != GL_UNSIGNED_INT &&
829	type != GL_FLOAT && type != GL_DOUBLE)
830	{
831	crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glSecondaryColorPointerEXT: invalid type: 0x%x", type);
832	return;
833	}
834	if (stride < 0)
835	{
836	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glSecondaryColorPointerEXT: stride was negative: %d", stride);
837	return;
838	}
839
840	crStateClientSetPointer(&(c->array.s), size, type, GL_TRUE, stride, p CRVBOX_HOST_ONLY_PARAM(fRealPtr));
841	DIRTY(cb->dirty, g->neg_bitid);
842	DIRTY(cb->clientPointer, g->neg_bitid);
843	DIRTY(cb->s, g->neg_bitid);
844	}
845
846	void STATE_APIENTRY crStateIndexPointer(GLenum type, GLsizei stride, const GLvoid *p CRVBOX_HOST_ONLY_PARAM(int fRealPtr))
847	{
848	CRContext *g = GetCurrentContext();
849	CRClientState *c = &(g->client);
850	CRStateBits *sb = GetCurrentBits();
851	CRClientBits *cb = &(sb->client);
852
853	FLUSH();
854
855	if (type != GL_SHORT && type != GL_INT && type != GL_UNSIGNED_BYTE &&
856	type != GL_FLOAT && type != GL_DOUBLE)
857	{
858	crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glIndexPointer: invalid type: 0x%x", type);
859	return;
860	}
861	if (stride < 0)
862	{
863	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glIndexPointer: stride was negative: %d", stride);
864	return;
865	}
866
867	crStateClientSetPointer(&(c->array.i), 1, type, GL_TRUE, stride, p CRVBOX_HOST_ONLY_PARAM(fRealPtr));
868	DIRTY(cb->dirty, g->neg_bitid);
869	DIRTY(cb->clientPointer, g->neg_bitid);
870	DIRTY(cb->i, g->neg_bitid);
871	}
872
873	void STATE_APIENTRY crStateNormalPointer(GLenum type, GLsizei stride, const GLvoid *p CRVBOX_HOST_ONLY_PARAM(int fRealPtr))
874	{
875	CRContext *g = GetCurrentContext();
876	CRClientState *c = &(g->client);
877	CRStateBits *sb = GetCurrentBits();
878	CRClientBits *cb = &(sb->client);
879
880	FLUSH();
881
882	if (type != GL_BYTE && type != GL_SHORT &&
883	type != GL_INT && type != GL_FLOAT &&
884	type != GL_DOUBLE)
885	{
886	crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glNormalPointer: invalid type: 0x%x", type);
887	return;
888	}
889	if (stride < 0)
890	{
891	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glNormalPointer: stride was negative: %d", stride);
892	return;
893	}
894
895	crStateClientSetPointer(&(c->array.n), 3, type, GL_TRUE, stride, p CRVBOX_HOST_ONLY_PARAM(fRealPtr));
896	DIRTY(cb->dirty, g->neg_bitid);
897	DIRTY(cb->clientPointer, g->neg_bitid);
898	DIRTY(cb->n, g->neg_bitid);
899	}
900
901	void STATE_APIENTRY crStateTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *p CRVBOX_HOST_ONLY_PARAM(int fRealPtr))
902	{
903	CRContext *g = GetCurrentContext();
904	CRClientState *c = &(g->client);
905	CRStateBits *sb = GetCurrentBits();
906	CRClientBits *cb = &(sb->client);
907
908	FLUSH();
909
910	if (size != 1 && size != 2 && size != 3 && size != 4)
911	{
912	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glTexCoordPointer: invalid size: %d", size);
913	return;
914	}
915	if (type != GL_SHORT && type != GL_INT &&
916	type != GL_FLOAT && type != GL_DOUBLE)
917	{
918	crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glTexCoordPointer: invalid type: 0x%x", type);
919	return;
920	}
921	if (stride < 0)
922	{
923	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glTexCoordPointer: stride was negative: %d", stride);
924	return;
925	}
926
927	crStateClientSetPointer(&(c->array.t[c->curClientTextureUnit]), size, type, GL_FALSE, stride, p CRVBOX_HOST_ONLY_PARAM(fRealPtr));
928	DIRTY(cb->dirty, g->neg_bitid);
929	DIRTY(cb->clientPointer, g->neg_bitid);
930	DIRTY(cb->t[c->curClientTextureUnit], g->neg_bitid);
931	}
932
933	void STATE_APIENTRY crStateEdgeFlagPointer(GLsizei stride, const GLvoid *p CRVBOX_HOST_ONLY_PARAM(int fRealPtr))
934	{
935	CRContext *g = GetCurrentContext();
936	CRClientState *c = &(g->client);
937	CRStateBits *sb = GetCurrentBits();
938	CRClientBits *cb = &(sb->client);
939
940	FLUSH();
941
942	if (stride < 0)
943	{
944	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glTexCoordPointer: stride was negative: %d", stride);
945	return;
946	}
947
948	crStateClientSetPointer(&(c->array.e), 1, GL_UNSIGNED_BYTE, GL_FALSE, stride, p CRVBOX_HOST_ONLY_PARAM(fRealPtr));
949	DIRTY(cb->dirty, g->neg_bitid);
950	DIRTY(cb->clientPointer, g->neg_bitid);
951	DIRTY(cb->e, g->neg_bitid);
952	}
953
954	void STATE_APIENTRY crStateFogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid *p CRVBOX_HOST_ONLY_PARAM(int fRealPtr))
955	{
956	CRContext *g = GetCurrentContext();
957	CRClientState *c = &(g->client);
958	CRStateBits *sb = GetCurrentBits();
959	CRClientBits *cb = &(sb->client);
960
961	FLUSH();
962
963	if (type != GL_BYTE && type != GL_UNSIGNED_BYTE &&
964	type != GL_SHORT && type != GL_UNSIGNED_SHORT &&
965	type != GL_INT && type != GL_UNSIGNED_INT &&
966	type != GL_FLOAT && type != GL_DOUBLE)
967	{
968	crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glFogCoordPointerEXT: invalid type: 0x%x", type);
969	return;
970	}
971	if (stride < 0)
972	{
973	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glFogCoordPointerEXT: stride was negative: %d", stride);
974	return;
975	}
976
977	crStateClientSetPointer(&(c->array.f), 1, type, GL_FALSE, stride, p CRVBOX_HOST_ONLY_PARAM(fRealPtr));
978	DIRTY(cb->dirty, g->neg_bitid);
979	DIRTY(cb->clientPointer, g->neg_bitid);
980	DIRTY(cb->f, g->neg_bitid);
981	}
982
983
984	void STATE_APIENTRY crStateVertexAttribPointerNV(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *p CRVBOX_HOST_ONLY_PARAM(int fRealPtr))
985	{
986	GLboolean normalized = GL_FALSE;
987	/* Extra error checking for NV arrays */
988	if (type != GL_UNSIGNED_BYTE && type != GL_SHORT &&
989	type != GL_FLOAT && type != GL_DOUBLE) {
990	crStateError(__LINE__, __FILE__, GL_INVALID_ENUM,
991	"glVertexAttribPointerNV: invalid type: 0x%x", type);
992	return;
993	}
994	crStateVertexAttribPointerARB(index, size, type, normalized, stride, p CRVBOX_HOST_ONLY_PARAM(fRealPtr));
995	}
996
997
998	void STATE_APIENTRY crStateVertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized,
999	GLsizei stride, const GLvoid *p CRVBOX_HOST_ONLY_PARAM(int fRealPtr))
1000	{
1001	CRContext *g = GetCurrentContext();
1002	CRClientState *c = &(g->client);
1003	CRStateBits *sb = GetCurrentBits();
1004	CRClientBits *cb = &(sb->client);
1005
1006	FLUSH();
1007
1008	if (index >= CR_MAX_VERTEX_ATTRIBS)
1009	{
1010	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glVertexAttribPointerARB: invalid index: %d", (int) index);
1011	return;
1012	}
1013	if (size != 1 && size != 2 && size != 3 && size != 4)
1014	{
1015	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glVertexAttribPointerARB: invalid size: %d", size);
1016	return;
1017	}
1018	if (type != GL_BYTE && type != GL_UNSIGNED_BYTE &&
1019	type != GL_SHORT && type != GL_UNSIGNED_SHORT &&
1020	type != GL_INT && type != GL_UNSIGNED_INT &&
1021	type != GL_FLOAT && type != GL_DOUBLE)
1022	{
1023	crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glVertexAttribPointerARB: invalid type: 0x%x", type);
1024	return;
1025	}
1026	if (stride < 0)
1027	{
1028	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "glVertexAttribPointerARB: stride was negative: %d", stride);
1029	return;
1030	}
1031
1032	crStateClientSetPointer(&(c->array.a[index]), size, type, normalized, stride, p CRVBOX_HOST_ONLY_PARAM(fRealPtr));
1033	DIRTY(cb->dirty, g->neg_bitid);
1034	DIRTY(cb->clientPointer, g->neg_bitid);
1035	DIRTY(cb->a[index], g->neg_bitid);
1036	}
1037
1038
1039	void STATE_APIENTRY crStateGetVertexAttribPointervNV(GLuint index, GLenum pname, GLvoid **pointer)
1040	{
1041	CRContext *g = GetCurrentContext();
1042
1043	if (g->current.inBeginEnd) {
1044	crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,
1045	"glGetVertexAttribPointervNV called in Begin/End");
1046	return;
1047	}
1048
1049	if (index >= CR_MAX_VERTEX_ATTRIBS) {
1050	crStateError(__LINE__, __FILE__, GL_INVALID_VALUE,
1051	"glGetVertexAttribPointervNV(index)");
1052	return;
1053	}
1054
1055	if (pname != GL_ATTRIB_ARRAY_POINTER_NV) {
1056	crStateError(__LINE__, __FILE__, GL_INVALID_ENUM,
1057	"glGetVertexAttribPointervNV(pname)");
1058	return;
1059	}
1060
1061	*pointer = g->client.array.a[index].p;
1062	}
1063
1064
1065	void STATE_APIENTRY crStateGetVertexAttribPointervARB(GLuint index, GLenum pname, GLvoid **pointer)
1066	{
1067	crStateGetVertexAttribPointervNV(index, pname, pointer);
1068	}
1069
1070
1071
1072	/*
1073	** Currently I treat Interleaved Arrays as if the
1074	** user uses them as separate arrays.
1075	** Certainly not the most efficient method but it
1076	** lets me use the same glDrawArrays method.
1077	*/
1078	void STATE_APIENTRY crStateInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *p CRVBOX_HOST_ONLY_PARAM(int fRealPtr))
1079	{
1080	CRContext *g = GetCurrentContext();
1081	CRClientState *c = &(g->client);
1082	CRStateBits *sb = GetCurrentBits();
1083	CRClientBits *cb = &(sb->client);
1084	CRClientPointer *cp;
1085	unsigned char base = (unsigned char ) p;
1086
1087	#ifndef IN_GUEST
1088	RT_NOREF(fRealPtr);
1089	#endif
1090
1091	if (g->current.inBeginEnd)
1092	{
1093	crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glInterleavedArrays called in begin/end");
1094	return;
1095	}
1096
1097	FLUSH();
1098
1099	if (stride < 0)
1100	{
1101	crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glInterleavedArrays: stride < 0: %d", stride);
1102	return;
1103	}
1104
1105	switch (format)
1106	{
1107	case GL_T4F_C4F_N3F_V4F:
1108	case GL_T2F_C4F_N3F_V3F:
1109	case GL_C4F_N3F_V3F:
1110	case GL_T4F_V4F:
1111	case GL_T2F_C3F_V3F:
1112	case GL_T2F_N3F_V3F:
1113	case GL_C3F_V3F:
1114	case GL_N3F_V3F:
1115	case GL_T2F_C4UB_V3F:
1116	case GL_T2F_V3F:
1117	case GL_C4UB_V3F:
1118	case GL_V3F:
1119	case GL_C4UB_V2F:
1120	case GL_V2F:
1121	break;
1122	default:
1123	crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glInterleavedArrays: Unrecognized format: %d", format);
1124	return;
1125	}
1126
1127	DIRTY(cb->dirty, g->neg_bitid);
1128	DIRTY(cb->clientPointer, g->neg_bitid);
1129
1130	/* p, size, type, stride, enabled, bytesPerIndex */
1131	/*
1132	** VertexPointer
1133	*/
1134
1135	cp = &(c->array.v);
1136	cp->type = GL_FLOAT;
1137	cp->enabled = GL_TRUE;
1138
1139	#ifdef CR_EXT_compiled_vertex_array
1140	crStateUnlockClientPointer(cp, 1 /fFreePointer/);
1141	#endif
1142
1143	switch (format)
1144	{
1145	case GL_T4F_C4F_N3F_V4F:
1146	cp->p = base+4sizeof(GLfloat)+4sizeof(GLfloat)+3*sizeof(GLfloat);
1147	cp->size = 4;
1148	break;
1149	case GL_T2F_C4F_N3F_V3F:
1150	cp->p = base+2sizeof(GLfloat)+4sizeof(GLfloat)+3*sizeof(GLfloat);
1151	cp->size = 3;
1152	break;
1153	case GL_C4F_N3F_V3F:
1154	cp->p = base+4sizeof(GLfloat)+3sizeof(GLfloat);
1155	cp->size = 3;
1156	break;
1157	case GL_T4F_V4F:
1158	cp->p = base+4*sizeof(GLfloat);
1159	cp->size = 4;
1160	break;
1161	case GL_T2F_C3F_V3F:
1162	cp->p = base+2sizeof(GLfloat)+3sizeof(GLfloat);
1163	cp->size = 3;
1164	break;
1165	case GL_T2F_N3F_V3F:
1166	cp->p = base+2sizeof(GLfloat)+3sizeof(GLfloat);
1167	cp->size = 3;
1168	break;
1169	case GL_C3F_V3F:
1170	cp->p = base+3*sizeof(GLfloat);
1171	cp->size = 3;
1172	break;
1173	case GL_N3F_V3F:
1174	cp->p = base+3*sizeof(GLfloat);
1175	cp->size = 3;
1176	break;
1177	case GL_T2F_C4UB_V3F:
1178	cp->p = base+2sizeof(GLfloat)+4sizeof(GLubyte);
1179	cp->size = 3;
1180	break;
1181	case GL_T2F_V3F:
1182	cp->p = base+2*sizeof(GLfloat);
1183	cp->size = 3;
1184	break;
1185	case GL_C4UB_V3F:
1186	cp->p = base+4*sizeof(GLubyte);
1187	cp->size = 3;
1188	break;
1189	case GL_V3F:
1190	cp->p = base;
1191	cp->size = 3;
1192	break;
1193	case GL_C4UB_V2F:
1194	cp->p = base+4*sizeof(GLubyte);
1195	cp->size = 2;
1196	break;
1197	case GL_V2F:
1198	cp->p = base;
1199	cp->size = 2;
1200	break;
1201	default:
1202	crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glInterleavedArrays: Unrecognized format: %d", format);
1203	return;
1204	}
1205
1206	cp->bytesPerIndex = cp->size * sizeof (GLfloat);
1207
1208	if (stride==0)
1209	stride = cp->bytesPerIndex + (cp->p - base);
1210	cp->stride = stride;
1211
1212	/*
1213	** NormalPointer
1214	*/
1215
1216	cp = &(c->array.n);
1217	cp->enabled = GL_TRUE;
1218	cp->stride = stride;
1219	#ifdef CR_EXT_compiled_vertex_array
1220	crStateUnlockClientPointer(cp, 1 /fFreePointer/);
1221	#endif
1222
1223	switch (format)
1224	{
1225	case GL_T4F_C4F_N3F_V4F:
1226	cp->p = base+4sizeof(GLfloat)+4sizeof(GLfloat);
1227	break;
1228	case GL_T2F_C4F_N3F_V3F:
1229	cp->p = base+2sizeof(GLfloat)+4sizeof(GLfloat);
1230	break;
1231	case GL_C4F_N3F_V3F:
1232	cp->p = base+4*sizeof(GLfloat);
1233	break;
1234	case GL_T2F_N3F_V3F:
1235	cp->p = base+2*sizeof(GLfloat);
1236	break;
1237	case GL_N3F_V3F:
1238	cp->p = base;
1239	break;
1240	case GL_T4F_V4F:
1241	case GL_T2F_C3F_V3F:
1242	case GL_C3F_V3F:
1243	case GL_T2F_C4UB_V3F:
1244	case GL_T2F_V3F:
1245	case GL_C4UB_V3F:
1246	case GL_V3F:
1247	case GL_C4UB_V2F:
1248	case GL_V2F:
1249	cp->enabled = GL_FALSE;
1250	break;
1251	default:
1252	crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glInterleavedArrays: Unrecognized format: %d", format);
1253	return;
1254	}
1255
1256	if (cp->enabled)
1257	{
1258	cp->type = GL_FLOAT;
1259	cp->size = 3;
1260	cp->bytesPerIndex = cp->size * sizeof (GLfloat);
1261	}
1262
1263	/*
1264	** ColorPointer
1265	*/
1266
1267	cp = &(c->array.c);
1268	cp->enabled = GL_TRUE;
1269	cp->stride = stride;
1270	#ifdef CR_EXT_compiled_vertex_array
1271	crStateUnlockClientPointer(cp, 1 /fFreePointer/);
1272	#endif
1273
1274	switch (format)
1275	{
1276	case GL_T4F_C4F_N3F_V4F:
1277	cp->size = 4;
1278	cp->type = GL_FLOAT;
1279	cp->bytesPerIndex = cp->size * sizeof(GLfloat);
1280	cp->p = base+4*sizeof(GLfloat);
1281	break;
1282	case GL_T2F_C4F_N3F_V3F:
1283	cp->size = 4;
1284	cp->type = GL_FLOAT;
1285	cp->bytesPerIndex = cp->size * sizeof(GLfloat);
1286	cp->p = base+2*sizeof(GLfloat);
1287	break;
1288	case GL_C4F_N3F_V3F:
1289	cp->size = 4;
1290	cp->type = GL_FLOAT;
1291	cp->bytesPerIndex = cp->size * sizeof(GLfloat);
1292	cp->p = base;
1293	break;
1294	case GL_T2F_C3F_V3F:
1295	cp->size = 3;
1296	cp->type = GL_FLOAT;
1297	cp->bytesPerIndex = cp->size * sizeof(GLfloat);
1298	cp->p = base+2*sizeof(GLfloat);
1299	break;
1300	case GL_C3F_V3F:
1301	cp->size = 3;
1302	cp->type = GL_FLOAT;
1303	cp->bytesPerIndex = cp->size * sizeof(GLfloat);
1304	cp->p = base;
1305	break;
1306	case GL_T2F_C4UB_V3F:
1307	cp->size = 4;
1308	cp->type = GL_UNSIGNED_BYTE;
1309	cp->bytesPerIndex = cp->size * sizeof(GLubyte);
1310	cp->p = base+2*sizeof(GLfloat);
1311	break;
1312	case GL_C4UB_V3F:
1313	cp->size = 4;
1314	cp->type = GL_UNSIGNED_BYTE;
1315	cp->bytesPerIndex = cp->size * sizeof(GLubyte);
1316	cp->p = base;
1317	break;
1318	case GL_C4UB_V2F:
1319	cp->size = 4;
1320	cp->type = GL_UNSIGNED_BYTE;
1321	cp->bytesPerIndex = cp->size * sizeof(GLubyte);
1322	cp->p = base;
1323	break;
1324	case GL_T2F_N3F_V3F:
1325	case GL_N3F_V3F:
1326	case GL_T4F_V4F:
1327	case GL_T2F_V3F:
1328	case GL_V3F:
1329	case GL_V2F:
1330	cp->enabled = GL_FALSE;
1331	break;
1332	default:
1333	crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glInterleavedArrays: Unrecognized format: %d", format);
1334	return;
1335	}
1336
1337	/*
1338	** TexturePointer
1339	*/
1340
1341	cp = &(c->array.t[c->curClientTextureUnit]);
1342	cp->enabled = GL_TRUE;
1343	cp->stride = stride;
1344	#ifdef CR_EXT_compiled_vertex_array
1345	crStateUnlockClientPointer(cp, 1 /fFreePointer/);
1346	#endif
1347
1348	switch (format)
1349	{
1350	case GL_T4F_C4F_N3F_V4F:
1351	cp->size = 4;
1352	cp->p = base;
1353	break;
1354	case GL_T2F_C4F_N3F_V3F:
1355	cp->size = 3;
1356	cp->p = base;
1357	break;
1358	case GL_T2F_C3F_V3F:
1359	case GL_T2F_N3F_V3F:
1360	cp->size = 3;
1361	cp->p = base;
1362	break;
1363	case GL_T2F_C4UB_V3F:
1364	cp->size = 3;
1365	cp->p = base;
1366	break;
1367	case GL_T4F_V4F:
1368	cp->size = 4;
1369	cp->p = base;
1370	break;
1371	case GL_T2F_V3F:
1372	cp->size = 3;
1373	cp->p = base;
1374	break;
1375	case GL_C4UB_V3F:
1376	case GL_C4UB_V2F:
1377	case GL_C3F_V3F:
1378	case GL_C4F_N3F_V3F:
1379	case GL_N3F_V3F:
1380	case GL_V3F:
1381	case GL_V2F:
1382	cp->enabled = GL_FALSE;
1383	break;
1384	default:
1385	crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glInterleavedArrays: Unrecognized format: %d", format);
1386	return;
1387	}
1388
1389	if (cp->enabled)
1390	{
1391	cp->type = GL_FLOAT;
1392	cp->bytesPerIndex = cp->size * sizeof (GLfloat);
1393	}
1394	}
1395
1396	void STATE_APIENTRY crStateGetPointerv(GLenum pname, GLvoid * * params)
1397	{
1398	CRContext *g = GetCurrentContext();
1399	CRClientState *c = &(g->client);
1400
1401	if (g->current.inBeginEnd)
1402	{
1403	crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,
1404	"GetPointerv called in begin/end");
1405	return;
1406	}
1407
1408	switch (pname)
1409	{
1410	case GL_VERTEX_ARRAY_POINTER:
1411	params = (GLvoid ) c->array.v.p;
1412	break;
1413	case GL_COLOR_ARRAY_POINTER:
1414	params = (GLvoid ) c->array.c.p;
1415	break;
1416	case GL_NORMAL_ARRAY_POINTER:
1417	params = (GLvoid ) c->array.n.p;
1418	break;
1419	case GL_INDEX_ARRAY_POINTER:
1420	params = (GLvoid ) c->array.i.p;
1421	break;
1422	case GL_TEXTURE_COORD_ARRAY_POINTER:
1423	params = (GLvoid ) c->array.t[c->curClientTextureUnit].p;
1424	break;
1425	case GL_EDGE_FLAG_ARRAY_POINTER:
1426	params = (GLvoid ) c->array.e.p;
1427	break;
1428	#ifdef CR_EXT_fog_coord
1429	case GL_FOG_COORDINATE_ARRAY_POINTER_EXT:
1430	params = (GLvoid ) c->array.f.p;
1431	break;
1432	#endif
1433	#ifdef CR_EXT_secondary_color
1434	case GL_SECONDARY_COLOR_ARRAY_POINTER_EXT:
1435	if( g->extensions.EXT_secondary_color ){
1436	params = (GLvoid ) c->array.s.p;
1437	}
1438	else {
1439	crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "Invalid Enum passed to glGetPointerv: SECONDARY_COLOR_ARRAY_EXT - EXT_secondary_color is not enabled." );
1440	return;
1441	}
1442	break;
1443	#endif
1444	case GL_FEEDBACK_BUFFER_POINTER:
1445	case GL_SELECTION_BUFFER_POINTER:
1446	/* do nothing - API switching should pick this up */
1447	break;
1448	default:
1449	crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,
1450	"glGetPointerv: invalid pname: %d", pname);
1451	return;
1452	}
1453	}
1454
1455
1456	void STATE_APIENTRY crStatePushClientAttrib( GLbitfield mask )
1457	{
1458	CRContext *g = GetCurrentContext();
1459	CRClientState *c = &(g->client);
1460
1461	if (g->current.inBeginEnd) {
1462	crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,
1463	"glPushClientAttrib called in Begin/End");
1464	return;
1465	}
1466
1467	if (c->attribStackDepth == CR_MAX_CLIENT_ATTRIB_STACK_DEPTH - 1) {
1468	crStateError(__LINE__, __FILE__, GL_STACK_OVERFLOW,
1469	"glPushClientAttrib called with a full stack!" );
1470	return;
1471	}
1472
1473	FLUSH();
1474
1475	c->pushMaskStack[c->attribStackDepth++] = mask;
1476
1477	if (mask & GL_CLIENT_PIXEL_STORE_BIT) {
1478	c->pixelPackStoreStack[c->pixelStoreStackDepth] = c->pack;
1479	c->pixelUnpackStoreStack[c->pixelStoreStackDepth] = c->unpack;
1480	c->pixelStoreStackDepth++;
1481	}
1482	if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) {
1483	c->vertexArrayStack[c->vertexArrayStackDepth] = c->array;
1484	c->vertexArrayStackDepth++;
1485	}
1486
1487	/* dirty? - no, because we haven't really changed any state */
1488	}
1489
1490
1491	void STATE_APIENTRY crStatePopClientAttrib( void )
1492	{
1493	CRContext *g = GetCurrentContext();
1494	CRClientState *c = &(g->client);
1495	CRStateBits *sb = GetCurrentBits();
1496	CRClientBits *cb = &(sb->client);
1497	CRbitvalue mask;
1498
1499	if (g->current.inBeginEnd) {
1500	crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,
1501	"glPopClientAttrib called in Begin/End");
1502	return;
1503	}
1504
1505	if (c->attribStackDepth == 0) {
1506	crStateError(__LINE__, __FILE__, GL_STACK_UNDERFLOW,
1507	"glPopClientAttrib called with an empty stack!" );
1508	return;
1509	}
1510
1511	FLUSH();
1512
1513	mask = c->pushMaskStack[--c->attribStackDepth];
1514
1515	if (mask & GL_CLIENT_PIXEL_STORE_BIT) {
1516	if (c->pixelStoreStackDepth == 0) {
1517	crError("bug in glPopClientAttrib (pixel store) ");
1518	return;
1519	}
1520	c->pixelStoreStackDepth--;
1521	c->pack = c->pixelPackStoreStack[c->pixelStoreStackDepth];
1522	c->unpack = c->pixelUnpackStoreStack[c->pixelStoreStackDepth];
1523	DIRTY(cb->pack, g->neg_bitid);
1524	}
1525
1526	if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) {
1527	if (c->vertexArrayStackDepth == 0) {
1528	crError("bug in glPopClientAttrib (vertex array) ");
1529	return;
1530	}
1531	c->vertexArrayStackDepth--;
1532	c->array = c->vertexArrayStack[c->vertexArrayStackDepth];
1533	DIRTY(cb->clientPointer, g->neg_bitid);
1534	}
1535
1536	DIRTY(cb->dirty, g->neg_bitid);
1537	}
1538
1539	static void crStateLockClientPointer(CRClientPointer* cp)
1540	{
1541	crStateUnlockClientPointer(cp, 1 /fFreePointer/);
1542	if (cp->enabled)
1543	{
1544	cp->locked = GL_TRUE;
1545	}
1546	}
1547
1548	static GLboolean crStateCanLockClientPointer(CRClientPointer* cp)
1549	{
1550	return !(cp->enabled && cp->buffer && cp->buffer->id);
1551	}
1552
1553	void STATE_APIENTRY crStateLockArraysEXT(GLint first, GLint count)
1554	{
1555	CRContext *g = GetCurrentContext();
1556	CRClientState *c = &(g->client);
1557	int i;
1558
1559	for (i=0; i<CRSTATECLIENT_MAX_VERTEXARRAYS; ++i)
1560	{
1561	if (!crStateCanLockClientPointer(crStateGetClientPointerByIndex(i, &c->array)))
1562	{
1563	break;
1564	}
1565	}
1566	if (i<CRSTATECLIENT_MAX_VERTEXARRAYS)
1567	{
1568	crDebug("crStateLockArraysEXT ignored because array %i have a bound VBO", i);
1569	return;
1570	}
1571
1572	c->array.locked = GL_TRUE;
1573	c->array.lockFirst = first;
1574	c->array.lockCount = count;
1575	#ifdef IN_GUEST
1576	c->array.synced = GL_FALSE;
1577	#endif
1578
1579	for (i=0; i<CRSTATECLIENT_MAX_VERTEXARRAYS; ++i)
1580	{
1581	crStateLockClientPointer(crStateGetClientPointerByIndex(i, &c->array));
1582	}
1583	}
1584
1585	void STATE_APIENTRY crStateUnlockArraysEXT(void)
1586	{
1587	CRContext *g = GetCurrentContext();
1588	CRClientState *c = &(g->client);
1589	int i;
1590
1591	if (!c->array.locked)
1592	{
1593	crDebug("crStateUnlockArraysEXT ignored because arrays aren't locked");
1594	return;
1595	}
1596
1597	c->array.locked = GL_FALSE;
1598	#ifdef IN_GUEST
1599	c->array.synced = GL_FALSE;
1600	#endif
1601
1602	for (i=0; i<CRSTATECLIENT_MAX_VERTEXARRAYS; ++i)
1603	{
1604	crStateUnlockClientPointer(crStateGetClientPointerByIndex(i, &c->array), 1 /fFreePointer/);
1605	}
1606	}
1607
1608	void STATE_APIENTRY crStateVertexArrayRangeNV(GLsizei length, const GLvoid *pointer CRVBOX_HOST_ONLY_PARAM(int fRealPtr))
1609	{
1610	/* XXX todo */
1611	crWarning("crStateVertexArrayRangeNV not implemented");
1612	(void)length; (void)pointer CRVBOX_HOST_ONLY_PARAM((void)fRealPtr);
1613	}
1614
1615
1616	void STATE_APIENTRY crStateFlushVertexArrayRangeNV(void)
1617	{
1618	/* XXX todo */
1619	crWarning("crStateFlushVertexArrayRangeNV not implemented");
1620	}
1621
1622	/Returns if the given clientpointer could be used on server side directly/
1623	#define CRSTATE_IS_SERVER_CP(cp) (!(cp).enabled \|\| !(cp).p \|\| ((cp).buffer && (cp).buffer->id) \|\| ((cp).locked))
1624
1625	#if defined(DEBUG) && 0
1626	static void crStateDumpClientPointer(CRClientPointer cp, const char name, int i)
1627	{
1628	if (i<0 && cp->enabled)
1629	{
1630	crDebug("CP(%s): enabled:%d ptr:%p buffer:%p buffer.name:%i locked: %i %s",
1631	name, cp->enabled, cp->p, cp->buffer, cp->buffer ? cp->buffer->id : ~(GLuint)0, (int)cp->locked,
1632	CRSTATE_IS_SERVER_CP(*cp) ? "":"!FAIL!");
1633	}
1634	else if (0==i \|\| cp->enabled)
1635	{
1636	crDebug("CP(%s%i): enabled:%d ptr:%p buffer:%p buffer.name:%i locked: %i %s",
1637	name, i, cp->enabled, cp->p, cp->buffer, cp->buffer ? cp->buffer->id : ~(GLuint)0, (int)cp->locked,
1638	CRSTATE_IS_SERVER_CP(*cp) ? "":"!FAIL!");
1639	}
1640	}
1641	#endif
1642
1643	#ifdef DEBUG_misha
1644	/* debugging */
1645	/# define CR_NO_SERVER_ARRAYS/
1646	#endif
1647
1648	/*
1649	* Determine if the enabled arrays all live on the server
1650	* (via GL_ARB_vertex_buffer_object).
1651	*/
1652	GLboolean crStateUseServerArrays(void)
1653	{
1654	#if defined(CR_ARB_vertex_buffer_object) && !defined(CR_NO_SERVER_ARRAYS)
1655	CRContext *g = GetCurrentContext();
1656	CRClientState *c = &(g->client);
1657	int i;
1658	GLboolean res;
1659
1660	res = CRSTATE_IS_SERVER_CP(c->array.v)
1661	&& CRSTATE_IS_SERVER_CP(c->array.n)
1662	&& CRSTATE_IS_SERVER_CP(c->array.c)
1663	&& CRSTATE_IS_SERVER_CP(c->array.i)
1664	&& CRSTATE_IS_SERVER_CP(c->array.e)
1665	&& CRSTATE_IS_SERVER_CP(c->array.s)
1666	&& CRSTATE_IS_SERVER_CP(c->array.f);
1667
1668	if (res)
1669	{
1670	for (i = 0; (unsigned int)i < g->limits.maxTextureUnits; i++)
1671	if (!CRSTATE_IS_SERVER_CP(c->array.t[i]))
1672	{
1673	res = GL_FALSE;
1674	break;
1675	}
1676	}
1677
1678	if (res)
1679	{
1680	for (i = 0; (unsigned int)i < g->limits.maxVertexProgramAttribs; i++)
1681	if (!CRSTATE_IS_SERVER_CP(c->array.a[i]))
1682	{
1683	res = GL_FALSE;
1684	break;
1685	}
1686	}
1687
1688	#if defined(DEBUG) && 0
1689	if (!res)
1690	{
1691	crStateDumpClientPointer(&c->array.v, "v", -1);
1692	crStateDumpClientPointer(&c->array.n, "n", -1);
1693	crStateDumpClientPointer(&c->array.c, "c", -1);
1694	crStateDumpClientPointer(&c->array.i, "i", -1);
1695	crStateDumpClientPointer(&c->array.e, "e", -1);
1696	crStateDumpClientPointer(&c->array.s, "s", -1);
1697	crStateDumpClientPointer(&c->array.f, "f", -1);
1698	for (i = 0; (unsigned int)i < g->limits.maxTextureUnits; i++)
1699	crStateDumpClientPointer(&c->array.t[i], "tex", i);
1700	for (i = 0; (unsigned int)i < g->limits.maxVertexProgramAttribs; i++)
1701	crStateDumpClientPointer(&c->array.a[i], "attrib", i);
1702	crDebug("crStateUseServerArrays->%d", res);
1703	}
1704	#endif
1705
1706	return res;
1707	#else
1708	return GL_FALSE;
1709	#endif
1710	}
1711
1712	GLuint crStateNeedDummyZeroVertexArray(CRContext g, CRCurrentStatePointers current, GLfloat *pZva)
1713	{
1714	#if defined(CR_ARB_vertex_buffer_object)
1715	CRClientState *c = &(g->client);
1716	int i;
1717	GLuint zvMax = 0;
1718
1719	if (c->array.a[0].enabled)
1720	return 0;
1721
1722	for (i = 1; (unsigned int)i < g->limits.maxVertexProgramAttribs; i++)
1723	{
1724	if (c->array.a[i].enabled)
1725	{
1726	if (c->array.a[i].buffer && c->array.a[i].buffer->id)
1727	{
1728	GLuint cElements = c->array.a[i].buffer->size / c->array.a[i].stride;
1729	if (zvMax < cElements)
1730	zvMax = cElements;
1731	}
1732	else
1733	{
1734	zvMax = ~UINT32_C(0);
1735	break;
1736	}
1737	}
1738	}
1739
1740	if (zvMax)
1741	{
1742	Assert(!c->array.v.enabled);
1743
1744	crStateCurrentRecoverNew(g, current);
1745
1746	crMemcpy(pZva, &g->current.vertexAttrib[0][0], sizeof (pZva) 4);
1747	}
1748
1749	return zvMax;
1750	#else
1751	return GL_FALSE;
1752	#endif
1753	}
1754
1755
1756	/**
1757	* Determine if there's a server-side array element buffer.
1758	* Called by glDrawElements() in packing SPUs to determine if glDrawElements
1759	* should be evaluated (unrolled) locally or if glDrawElements should be
1760	* packed and sent to the server.
1761	*/
1762	GLboolean
1763	crStateUseServerArrayElements(void)
1764	{
1765	#ifdef CR_ARB_vertex_buffer_object
1766	CRContext *g = GetCurrentContext();
1767	if (g->bufferobject.elementsBuffer &&
1768	g->bufferobject.elementsBuffer->id > 0)
1769	return GL_TRUE;
1770	else
1771	return GL_FALSE;
1772	#else
1773	return GL_FALSE;
1774	#endif
1775	}
1776
1777	#define CR_BUFFER_HWID(_p) ((_p) ? (_p)->hwid : 0)
1778
1779	void
1780	crStateClientDiff(CRClientBits cb, CRbitvalue bitID,
1781	CRContext fromCtx, CRContext toCtx)
1782	{
1783	CRClientState *from = &(fromCtx->client);
1784	const CRClientState *to = &(toCtx->client);
1785	GLint curClientTextureUnit = from->curClientTextureUnit;
1786	int i;
1787	GLint idHwArrayBuffer = CR_BUFFER_HWID(toCtx->bufferobject.arrayBuffer);
1788	const GLint idHwInitialBuffer = idHwArrayBuffer;
1789
1790	#ifdef DEBUG_misha
1791	{
1792	GLint tstHwBuffer = -1;
1793	diff_api.GetIntegerv(GL_ARRAY_BUFFER_BINDING, &tstHwBuffer);
1794	CRASSERT(idHwInitialBuffer == tstHwBuffer);
1795	}
1796	#endif
1797
1798
1799	if (CHECKDIRTY(cb->clientPointer, bitID)) {
1800	/* one or more vertex pointers is dirty */
1801	if (CHECKDIRTY(cb->v, bitID)) {
1802	if (from->array.v.size != to->array.v.size \|\|
1803	from->array.v.type != to->array.v.type \|\|
1804	from->array.v.stride != to->array.v.stride \|\|
1805	from->array.v.p != to->array.v.p \|\|
1806	from->array.v.buffer != to->array.v.buffer) {
1807	GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.v.buffer);
1808	if (idHwArrayBufferUsed != idHwArrayBuffer)
1809	{
1810	diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed);
1811	idHwArrayBuffer = idHwArrayBufferUsed;
1812	}
1813	diff_api.VertexPointer(to->array.v.size, to->array.v.type, to->array.v.stride, to->array.v.p CRVBOX_HOST_ONLY_PARAM(to->array.v.fRealPtr));
1814	from->array.v.size = to->array.v.size;
1815	from->array.v.type = to->array.v.type;
1816	from->array.v.stride = to->array.v.stride;
1817	from->array.v.p = to->array.v.p;
1818	from->array.v.buffer = to->array.v.buffer;
1819	}
1820	CLEARDIRTY2(cb->v, bitID);
1821	}
1822	/* normal */
1823	if (CHECKDIRTY(cb->n, bitID)) {
1824	if (from->array.n.type != to->array.n.type \|\|
1825	from->array.n.stride != to->array.n.stride \|\|
1826	from->array.n.p != to->array.n.p \|\|
1827	from->array.n.buffer != to->array.n.buffer) {
1828	GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.n.buffer);
1829	if (idHwArrayBufferUsed != idHwArrayBuffer)
1830	{
1831	diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed);
1832	idHwArrayBuffer = idHwArrayBufferUsed;
1833	}
1834	diff_api.NormalPointer(to->array.n.type, to->array.n.stride, to->array.n.p CRVBOX_HOST_ONLY_PARAM(to->array.n.fRealPtr));
1835	from->array.n.type = to->array.n.type;
1836	from->array.n.stride = to->array.n.stride;
1837	from->array.n.p = to->array.n.p;
1838	from->array.n.buffer = to->array.n.buffer;
1839	}
1840	CLEARDIRTY2(cb->n, bitID);
1841	}
1842	/* color */
1843	if (CHECKDIRTY(cb->c, bitID)) {
1844	if (from->array.c.size != to->array.c.size \|\|
1845	from->array.c.type != to->array.c.type \|\|
1846	from->array.c.stride != to->array.c.stride \|\|
1847	from->array.c.p != to->array.c.p \|\|
1848	from->array.c.buffer != to->array.c.buffer) {
1849	GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.c.buffer);
1850	if (idHwArrayBufferUsed != idHwArrayBuffer)
1851	{
1852	diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed);
1853	idHwArrayBuffer = idHwArrayBufferUsed;
1854	}
1855	diff_api.ColorPointer(to->array.c.size, to->array.c.type, to->array.c.stride, to->array.c.p CRVBOX_HOST_ONLY_PARAM(to->array.c.fRealPtr));
1856	from->array.c.size = to->array.c.size;
1857	from->array.c.type = to->array.c.type;
1858	from->array.c.stride = to->array.c.stride;
1859	from->array.c.p = to->array.c.p;
1860	from->array.c.buffer = to->array.c.buffer;
1861	}
1862	CLEARDIRTY2(cb->c, bitID);
1863	}
1864	/* index */
1865	if (CHECKDIRTY(cb->i, bitID)) {
1866	if (from->array.i.type != to->array.i.type \|\|
1867	from->array.i.stride != to->array.i.stride \|\|
1868	from->array.i.p != to->array.i.p \|\|
1869	from->array.i.buffer != to->array.i.buffer) {
1870	GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.i.buffer);
1871	if (idHwArrayBufferUsed != idHwArrayBuffer)
1872	{
1873	diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed);
1874	idHwArrayBuffer = idHwArrayBufferUsed;
1875	}
1876	diff_api.IndexPointer(to->array.i.type, to->array.i.stride, to->array.i.p CRVBOX_HOST_ONLY_PARAM(to->array.i.fRealPtr));
1877	from->array.i.type = to->array.i.type;
1878	from->array.i.stride = to->array.i.stride;
1879	from->array.i.p = to->array.i.p;
1880	from->array.i.buffer = to->array.i.buffer;
1881	}
1882	CLEARDIRTY2(cb->i, bitID);
1883	}
1884	/* texcoords */
1885	for (i = 0; (unsigned int)i < toCtx->limits.maxTextureUnits; i++) {
1886	if (CHECKDIRTY(cb->t[i], bitID)) {
1887	if (from->array.t[i].size != to->array.t[i].size \|\|
1888	from->array.t[i].type != to->array.t[i].type \|\|
1889	from->array.t[i].stride != to->array.t[i].stride \|\|
1890	from->array.t[i].p != to->array.t[i].p \|\|
1891	from->array.t[i].buffer != to->array.t[i].buffer) {
1892	GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.t[i].buffer);
1893	if (idHwArrayBufferUsed != idHwArrayBuffer)
1894	{
1895	diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed);
1896	idHwArrayBuffer = idHwArrayBufferUsed;
1897	}
1898	diff_api.ClientActiveTextureARB(GL_TEXTURE0_ARB + i);
1899	curClientTextureUnit = i;
1900	diff_api.TexCoordPointer(to->array.t[i].size, to->array.t[i].type, to->array.t[i].stride, to->array.t[i].p CRVBOX_HOST_ONLY_PARAM(to->array.t[i].fRealPtr));
1901	from->array.t[i].size = to->array.t[i].size;
1902	from->array.t[i].type = to->array.t[i].type;
1903	from->array.t[i].stride = to->array.t[i].stride;
1904	from->array.t[i].p = to->array.t[i].p;
1905	from->array.t[i].buffer = to->array.t[i].buffer;
1906	}
1907	CLEARDIRTY2(cb->t[i], bitID);
1908	}
1909	}
1910	/* edge flag */
1911	if (CHECKDIRTY(cb->e, bitID)) {
1912	if (from->array.e.stride != to->array.e.stride \|\|
1913	from->array.e.p != to->array.e.p \|\|
1914	from->array.e.buffer != to->array.e.buffer) {
1915	GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.e.buffer);
1916	if (idHwArrayBufferUsed != idHwArrayBuffer)
1917	{
1918	diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed);
1919	idHwArrayBuffer = idHwArrayBufferUsed;
1920	}
1921	diff_api.EdgeFlagPointer(to->array.e.stride, to->array.e.p CRVBOX_HOST_ONLY_PARAM(to->array.e.fRealPtr));
1922	from->array.e.stride = to->array.e.stride;
1923	from->array.e.p = to->array.e.p;
1924	from->array.e.buffer = to->array.e.buffer;
1925	}
1926	CLEARDIRTY2(cb->e, bitID);
1927	}
1928	/* secondary color */
1929	if (CHECKDIRTY(cb->s, bitID)) {
1930	if (from->array.s.size != to->array.s.size \|\|
1931	from->array.s.type != to->array.s.type \|\|
1932	from->array.s.stride != to->array.s.stride \|\|
1933	from->array.s.p != to->array.s.p \|\|
1934	from->array.s.buffer != to->array.s.buffer) {
1935	GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.s.buffer);
1936	if (idHwArrayBufferUsed != idHwArrayBuffer)
1937	{
1938	diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed);
1939	idHwArrayBuffer = idHwArrayBufferUsed;
1940	}
1941	diff_api.SecondaryColorPointerEXT(to->array.s.size, to->array.s.type, to->array.s.stride, to->array.s.p CRVBOX_HOST_ONLY_PARAM(to->array.s.fRealPtr));
1942	from->array.s.size = to->array.s.size;
1943	from->array.s.type = to->array.s.type;
1944	from->array.s.stride = to->array.s.stride;
1945	from->array.s.p = to->array.s.p;
1946	from->array.s.buffer = to->array.s.buffer;
1947	}
1948	CLEARDIRTY2(cb->s, bitID);
1949	}
1950	/* fog coord */
1951	if (CHECKDIRTY(cb->f, bitID)) {
1952	if (from->array.f.type != to->array.f.type \|\|
1953	from->array.f.stride != to->array.f.stride \|\|
1954	from->array.f.p != to->array.f.p \|\|
1955	from->array.f.buffer != to->array.f.buffer) {
1956	GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.f.buffer);
1957	if (idHwArrayBufferUsed != idHwArrayBuffer)
1958	{
1959	diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed);
1960	idHwArrayBuffer = idHwArrayBufferUsed;
1961	}
1962	diff_api.FogCoordPointerEXT(to->array.f.type, to->array.f.stride, to->array.f.p CRVBOX_HOST_ONLY_PARAM(to->array.f.fRealPtr));
1963	from->array.f.type = to->array.f.type;
1964	from->array.f.stride = to->array.f.stride;
1965	from->array.f.p = to->array.f.p;
1966	from->array.f.buffer = to->array.f.buffer;
1967	}
1968	CLEARDIRTY2(cb->f, bitID);
1969	}
1970	#if defined(CR_NV_vertex_program) \|\| defined(CR_ARB_vertex_program)
1971	/* vertex attributes */
1972	for (i = 0; (unsigned int)i < toCtx->limits.maxVertexProgramAttribs; i++) {
1973	if (CHECKDIRTY(cb->a[i], bitID)) {
1974	if (from->array.a[i].size != to->array.a[i].size \|\|
1975	from->array.a[i].type != to->array.a[i].type \|\|
1976	from->array.a[i].stride != to->array.a[i].stride \|\|
1977	from->array.a[i].normalized != to->array.a[i].normalized \|\|
1978	from->array.a[i].p != to->array.a[i].p \|\|
1979	from->array.a[i].buffer != to->array.a[i].buffer) {
1980	GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.a[i].buffer);
1981	if (idHwArrayBufferUsed != idHwArrayBuffer)
1982	{
1983	diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed);
1984	idHwArrayBuffer = idHwArrayBufferUsed;
1985	}
1986	diff_api.VertexAttribPointerARB(i, to->array.a[i].size, to->array.a[i].type, to->array.a[i].normalized,
1987	to->array.a[i].stride, to->array.a[i].p CRVBOX_HOST_ONLY_PARAM(to->array.a[i].fRealPtr));
1988	from->array.a[i].size = to->array.a[i].size;
1989	from->array.a[i].type = to->array.a[i].type;
1990	from->array.a[i].stride = to->array.a[i].stride;
1991	from->array.a[i].normalized = to->array.a[i].normalized;
1992	from->array.a[i].p = to->array.a[i].p;
1993	from->array.a[i].buffer = to->array.a[i].buffer;
1994	}
1995	CLEARDIRTY2(cb->a[i], bitID);
1996	}
1997	}
1998	#endif
1999	}
2000
2001	if (idHwArrayBuffer != idHwInitialBuffer)
2002	{
2003	diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwInitialBuffer);
2004	}
2005
2006	if (CHECKDIRTY(cb->enableClientState, bitID)) {
2007	/* update vertex array enable/disable flags */
2008	glAble able[2];
2009	able[0] = diff_api.DisableClientState;
2010	able[1] = diff_api.EnableClientState;
2011	if (from->array.v.enabled != to->array.v.enabled) {
2012	able[to->array.v.enabled](GL_VERTEX_ARRAY);
2013	from->array.v.enabled = to->array.v.enabled;
2014	}
2015	if (from->array.n.enabled != to->array.n.enabled) {
2016	able[to->array.n.enabled](GL_NORMAL_ARRAY);
2017	from->array.n.enabled = to->array.n.enabled;
2018	}
2019	if (from->array.c.enabled != to->array.c.enabled) {
2020	able[to->array.c.enabled](GL_COLOR_ARRAY);
2021	from->array.c.enabled = to->array.c.enabled;
2022	}
2023	if (from->array.i.enabled != to->array.i.enabled) {
2024	able[to->array.i.enabled](GL_INDEX_ARRAY);
2025	from->array.i.enabled = to->array.i.enabled;
2026	}
2027	for (i = 0; (unsigned int)i < toCtx->limits.maxTextureUnits; i++) {
2028	if (from->array.t[i].enabled != to->array.t[i].enabled) {
2029	diff_api.ClientActiveTextureARB(GL_TEXTURE0_ARB + i);
2030	curClientTextureUnit = i;
2031	able[to->array.t[i].enabled](GL_TEXTURE_COORD_ARRAY);
2032	from->array.t[i].enabled = to->array.t[i].enabled;
2033	}
2034	}
2035	if (from->array.e.enabled != to->array.e.enabled) {
2036	able[to->array.e.enabled](GL_EDGE_FLAG_ARRAY);
2037	from->array.e.enabled = to->array.e.enabled;
2038	}
2039	if (from->array.s.enabled != to->array.s.enabled) {
2040	able[to->array.s.enabled](GL_SECONDARY_COLOR_ARRAY_EXT);
2041	from->array.s.enabled = to->array.s.enabled;
2042	}
2043	if (from->array.f.enabled != to->array.f.enabled) {
2044	able[to->array.f.enabled](GL_FOG_COORDINATE_ARRAY_EXT);
2045	from->array.f.enabled = to->array.f.enabled;
2046	}
2047	for (i = 0; (unsigned int)i < toCtx->limits.maxVertexProgramAttribs; i++) {
2048	if (from->array.a[i].enabled != to->array.a[i].enabled) {
2049	if (to->array.a[i].enabled)
2050	diff_api.EnableVertexAttribArrayARB(i);
2051	else
2052	diff_api.DisableVertexAttribArrayARB(i);
2053	from->array.a[i].enabled = to->array.a[i].enabled;
2054	}
2055	}
2056	CLEARDIRTY2(cb->enableClientState, bitID);
2057	}
2058
2059	if (to->curClientTextureUnit != curClientTextureUnit)
2060	{
2061	diff_api.ClientActiveTextureARB(GL_TEXTURE0_ARB + to->curClientTextureUnit);
2062	}
2063	}
2064
2065
2066	void
2067	crStateClientSwitch(CRClientBits cb, CRbitvalue bitID,
2068	CRContext fromCtx, CRContext toCtx)
2069	{
2070	const CRClientState *from = &(fromCtx->client);
2071	const CRClientState *to = &(toCtx->client);
2072	GLint curClientTextureUnit = from->curClientTextureUnit;
2073	int i;
2074	GLint idHwArrayBuffer = CR_BUFFER_HWID(toCtx->bufferobject.arrayBuffer);
2075	const GLint idHwInitialBuffer = idHwArrayBuffer;
2076
2077	#ifdef DEBUG_misha
2078	{
2079	GLint tstHwBuffer = -1;
2080	diff_api.GetIntegerv(GL_ARRAY_BUFFER_BINDING, &tstHwBuffer);
2081	CRASSERT(idHwInitialBuffer == tstHwBuffer);
2082	}
2083	#endif
2084
2085	if (CHECKDIRTY(cb->clientPointer, bitID)) {
2086	/* one or more vertex pointers is dirty */
2087	if (CHECKDIRTY(cb->v, bitID)) {
2088	if (from->array.v.size != to->array.v.size \|\|
2089	from->array.v.type != to->array.v.type \|\|
2090	from->array.v.stride != to->array.v.stride \|\|
2091	from->array.v.p != to->array.v.p \|\|
2092	from->array.v.buffer != to->array.v.buffer) {
2093	GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.v.buffer);
2094	if (idHwArrayBufferUsed != idHwArrayBuffer)
2095	{
2096	diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed);
2097	idHwArrayBuffer = idHwArrayBufferUsed;
2098	}
2099	diff_api.VertexPointer(to->array.v.size, to->array.v.type, to->array.v.stride, to->array.v.p CRVBOX_HOST_ONLY_PARAM(to->array.v.fRealPtr));
2100	FILLDIRTY(cb->v);
2101	FILLDIRTY(cb->clientPointer);
2102	FILLDIRTY(cb->dirty);
2103	}
2104	CLEARDIRTY2(cb->v, bitID);
2105	}
2106	/* normal */
2107	if (CHECKDIRTY(cb->n, bitID)) {
2108	if (from->array.n.type != to->array.n.type \|\|
2109	from->array.n.stride != to->array.n.stride \|\|
2110	from->array.n.p != to->array.n.p \|\|
2111	from->array.n.buffer != to->array.n.buffer) {
2112	GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.n.buffer);
2113	if (idHwArrayBufferUsed != idHwArrayBuffer)
2114	{
2115	diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed);
2116	idHwArrayBuffer = idHwArrayBufferUsed;
2117	}
2118	diff_api.NormalPointer(to->array.n.type, to->array.n.stride, to->array.n.p CRVBOX_HOST_ONLY_PARAM(to->array.n.fRealPtr));
2119	FILLDIRTY(cb->n);
2120	FILLDIRTY(cb->clientPointer);
2121	FILLDIRTY(cb->dirty);
2122	}
2123	CLEARDIRTY2(cb->n, bitID);
2124	}
2125	/* color */
2126	if (CHECKDIRTY(cb->c, bitID)) {
2127	if (from->array.c.size != to->array.c.size \|\|
2128	from->array.c.type != to->array.c.type \|\|
2129	from->array.c.stride != to->array.c.stride \|\|
2130	from->array.c.p != to->array.c.p \|\|
2131	from->array.c.buffer != to->array.c.buffer) {
2132	GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.c.buffer);
2133	if (idHwArrayBufferUsed != idHwArrayBuffer)
2134	{
2135	diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed);
2136	idHwArrayBuffer = idHwArrayBufferUsed;
2137	}
2138	diff_api.ColorPointer(to->array.c.size, to->array.c.type, to->array.c.stride, to->array.c.p CRVBOX_HOST_ONLY_PARAM(to->array.c.fRealPtr));
2139	FILLDIRTY(cb->c);
2140	FILLDIRTY(cb->clientPointer);
2141	FILLDIRTY(cb->dirty);
2142	}
2143	CLEARDIRTY2(cb->c, bitID);
2144	}
2145	/* index */
2146	if (CHECKDIRTY(cb->i, bitID)) {
2147	if (from->array.i.type != to->array.i.type \|\|
2148	from->array.i.stride != to->array.i.stride \|\|
2149	from->array.i.p != to->array.i.p \|\|
2150	from->array.i.buffer != to->array.i.buffer) {
2151	GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.i.buffer);
2152	if (idHwArrayBufferUsed != idHwArrayBuffer)
2153	{
2154	diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed);
2155	idHwArrayBuffer = idHwArrayBufferUsed;
2156	}
2157	diff_api.IndexPointer(to->array.i.type, to->array.i.stride, to->array.i.p CRVBOX_HOST_ONLY_PARAM(to->array.i.fRealPtr));
2158	FILLDIRTY(cb->i);
2159	FILLDIRTY(cb->dirty);
2160	FILLDIRTY(cb->clientPointer);
2161	}
2162	CLEARDIRTY2(cb->i, bitID);
2163	}
2164	/* texcoords */
2165	for (i = 0; (unsigned int)i < toCtx->limits.maxTextureUnits; i++) {
2166	if (CHECKDIRTY(cb->t[i], bitID)) {
2167	if (from->array.t[i].size != to->array.t[i].size \|\|
2168	from->array.t[i].type != to->array.t[i].type \|\|
2169	from->array.t[i].stride != to->array.t[i].stride \|\|
2170	from->array.t[i].p != to->array.t[i].p \|\|
2171	from->array.t[i].buffer != to->array.t[i].buffer) {
2172	GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.t[i].buffer);
2173	if (idHwArrayBufferUsed != idHwArrayBuffer)
2174	{
2175	diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed);
2176	idHwArrayBuffer = idHwArrayBufferUsed;
2177	}
2178	diff_api.ClientActiveTextureARB(GL_TEXTURE0_ARB + i);
2179	curClientTextureUnit = i;
2180	diff_api.TexCoordPointer(to->array.t[i].size, to->array.t[i].type, to->array.t[i].stride, to->array.t[i].p CRVBOX_HOST_ONLY_PARAM(to->array.t[i].fRealPtr));
2181	FILLDIRTY(cb->t[i]);
2182	FILLDIRTY(cb->clientPointer);
2183	FILLDIRTY(cb->dirty);
2184	}
2185	CLEARDIRTY2(cb->t[i], bitID);
2186	}
2187	}
2188	/* edge flag */
2189	if (CHECKDIRTY(cb->e, bitID)) {
2190	if (from->array.e.stride != to->array.e.stride \|\|
2191	from->array.e.p != to->array.e.p \|\|
2192	from->array.e.buffer != to->array.e.buffer) {
2193	GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.e.buffer);
2194	if (idHwArrayBufferUsed != idHwArrayBuffer)
2195	{
2196	diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed);
2197	idHwArrayBuffer = idHwArrayBufferUsed;
2198	}
2199	diff_api.EdgeFlagPointer(to->array.e.stride, to->array.e.p CRVBOX_HOST_ONLY_PARAM(to->array.e.fRealPtr));
2200	FILLDIRTY(cb->e);
2201	FILLDIRTY(cb->clientPointer);
2202	FILLDIRTY(cb->dirty);
2203	}
2204	CLEARDIRTY2(cb->e, bitID);
2205	}
2206	/* secondary color */
2207	if (CHECKDIRTY(cb->s, bitID)) {
2208	if (from->array.s.size != to->array.s.size \|\|
2209	from->array.s.type != to->array.s.type \|\|
2210	from->array.s.stride != to->array.s.stride \|\|
2211	from->array.s.p != to->array.s.p \|\|
2212	from->array.s.buffer != to->array.s.buffer) {
2213	GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.s.buffer);
2214	if (idHwArrayBufferUsed != idHwArrayBuffer)
2215	{
2216	diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed);
2217	idHwArrayBuffer = idHwArrayBufferUsed;
2218	}
2219	diff_api.SecondaryColorPointerEXT(to->array.s.size, to->array.s.type, to->array.s.stride, to->array.s.p CRVBOX_HOST_ONLY_PARAM(to->array.s.fRealPtr));
2220	FILLDIRTY(cb->s);
2221	FILLDIRTY(cb->clientPointer);
2222	FILLDIRTY(cb->dirty);
2223	}
2224	CLEARDIRTY2(cb->s, bitID);
2225	}
2226	/* fog coord */
2227	if (CHECKDIRTY(cb->f, bitID)) {
2228	if (from->array.f.type != to->array.f.type \|\|
2229	from->array.f.stride != to->array.f.stride \|\|
2230	from->array.f.p != to->array.f.p \|\|
2231	from->array.f.buffer != to->array.f.buffer) {
2232	GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.f.buffer);
2233	if (idHwArrayBufferUsed != idHwArrayBuffer)
2234	{
2235	diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed);
2236	idHwArrayBuffer = idHwArrayBufferUsed;
2237	}
2238	diff_api.FogCoordPointerEXT(to->array.f.type, to->array.f.stride, to->array.f.p CRVBOX_HOST_ONLY_PARAM(to->array.f.fRealPtr));
2239	FILLDIRTY(cb->f);
2240	FILLDIRTY(cb->clientPointer);
2241	FILLDIRTY(cb->dirty);
2242	}
2243	CLEARDIRTY2(cb->f, bitID);
2244	}
2245	#if defined(CR_NV_vertex_program) \|\| defined(CR_ARB_vertex_program)
2246	/* vertex attributes */
2247	for (i = 0; (unsigned int)i < toCtx->limits.maxVertexProgramAttribs; i++) {
2248	if (CHECKDIRTY(cb->a[i], bitID)) {
2249	if (from->array.a[i].size != to->array.a[i].size \|\|
2250	from->array.a[i].type != to->array.a[i].type \|\|
2251	from->array.a[i].stride != to->array.a[i].stride \|\|
2252	from->array.a[i].normalized != to->array.a[i].normalized \|\|
2253	from->array.a[i].p != to->array.a[i].p \|\|
2254	from->array.a[i].buffer != to->array.a[i].buffer) {
2255	GLint idHwArrayBufferUsed = CR_BUFFER_HWID(to->array.a[i].buffer);
2256	if (idHwArrayBufferUsed != idHwArrayBuffer)
2257	{
2258	diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwArrayBufferUsed);
2259	idHwArrayBuffer = idHwArrayBufferUsed;
2260	}
2261	diff_api.VertexAttribPointerARB(i, to->array.a[i].size, to->array.a[i].type, to->array.a[i].normalized,
2262	to->array.a[i].stride, to->array.a[i].p CRVBOX_HOST_ONLY_PARAM(to->array.a[i].fRealPtr));
2263	FILLDIRTY(cb->a[i]);
2264	FILLDIRTY(cb->clientPointer);
2265	FILLDIRTY(cb->dirty);
2266	}
2267	CLEARDIRTY2(cb->a[i], bitID);
2268	}
2269	}
2270	#endif
2271	}
2272
2273	if (idHwArrayBuffer != idHwInitialBuffer)
2274	{
2275	diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, idHwInitialBuffer);
2276	}
2277
2278	if (CHECKDIRTY(cb->enableClientState, bitID)) {
2279	/* update vertex array enable/disable flags */
2280	glAble able[2];
2281	able[0] = diff_api.DisableClientState;
2282	able[1] = diff_api.EnableClientState;
2283	if (from->array.v.enabled != to->array.v.enabled) {
2284	able[to->array.v.enabled](GL_VERTEX_ARRAY);
2285	FILLDIRTY(cb->enableClientState);
2286	FILLDIRTY(cb->dirty);
2287	}
2288	if (from->array.n.enabled != to->array.n.enabled) {
2289	able[to->array.n.enabled](GL_NORMAL_ARRAY);
2290	FILLDIRTY(cb->enableClientState);
2291	FILLDIRTY(cb->dirty);
2292	}
2293	if (from->array.c.enabled != to->array.c.enabled) {
2294	able[to->array.c.enabled](GL_COLOR_ARRAY);
2295	FILLDIRTY(cb->enableClientState);
2296	FILLDIRTY(cb->dirty);
2297	}
2298	if (from->array.i.enabled != to->array.i.enabled) {
2299	able[to->array.i.enabled](GL_INDEX_ARRAY);
2300	FILLDIRTY(cb->enableClientState);
2301	FILLDIRTY(cb->dirty);
2302	}
2303	for (i = 0; (unsigned int)i < toCtx->limits.maxTextureUnits; i++) {
2304	if (from->array.t[i].enabled != to->array.t[i].enabled) {
2305	diff_api.ClientActiveTextureARB(GL_TEXTURE0_ARB + i);
2306	curClientTextureUnit = i;
2307	able[to->array.t[i].enabled](GL_TEXTURE_COORD_ARRAY);
2308	FILLDIRTY(cb->enableClientState);
2309	FILLDIRTY(cb->dirty);
2310	}
2311	}
2312	if (from->array.e.enabled != to->array.e.enabled) {
2313	able[to->array.e.enabled](GL_EDGE_FLAG_ARRAY);
2314	FILLDIRTY(cb->enableClientState);
2315	FILLDIRTY(cb->dirty);
2316	}
2317	if (from->array.s.enabled != to->array.s.enabled) {
2318	able[to->array.s.enabled](GL_SECONDARY_COLOR_ARRAY_EXT);
2319	FILLDIRTY(cb->enableClientState);
2320	FILLDIRTY(cb->dirty);
2321	}
2322	if (from->array.f.enabled != to->array.f.enabled) {
2323	able[to->array.f.enabled](GL_FOG_COORDINATE_ARRAY_EXT);
2324	FILLDIRTY(cb->enableClientState);
2325	FILLDIRTY(cb->dirty);
2326	}
2327	for (i = 0; (unsigned int)i < toCtx->limits.maxVertexProgramAttribs; i++) {
2328	if (from->array.a[i].enabled != to->array.a[i].enabled) {
2329	if (to->array.a[i].enabled)
2330	diff_api.EnableVertexAttribArrayARB(i);
2331	else
2332	diff_api.DisableVertexAttribArrayARB(i);
2333	FILLDIRTY(cb->enableClientState);
2334	FILLDIRTY(cb->dirty);
2335	}
2336	}
2337	CLEARDIRTY2(cb->enableClientState, bitID);
2338	}
2339
2340	if (to->curClientTextureUnit != curClientTextureUnit)
2341	{
2342	diff_api.ClientActiveTextureARB(GL_TEXTURE0_ARB + to->curClientTextureUnit);
2343	}
2344
2345	if (CHECKDIRTY(cb->unpack, bitID))
2346	{
2347	if (from->unpack.rowLength != to->unpack.rowLength)
2348	{
2349	diff_api.PixelStorei(GL_UNPACK_ROW_LENGTH, to->unpack.rowLength);
2350	FILLDIRTY(cb->unpack);
2351	FILLDIRTY(cb->dirty);
2352	}
2353	if (from->unpack.skipRows != to->unpack.skipRows)
2354	{
2355	diff_api.PixelStorei(GL_UNPACK_SKIP_ROWS, to->unpack.skipRows);
2356	FILLDIRTY(cb->unpack);
2357	FILLDIRTY(cb->dirty);
2358	}
2359	if (from->unpack.skipPixels != to->unpack.skipPixels)
2360	{
2361	diff_api.PixelStorei(GL_UNPACK_SKIP_PIXELS, to->unpack.skipPixels);
2362	FILLDIRTY(cb->unpack);
2363	FILLDIRTY(cb->dirty);
2364	}
2365	if (from->unpack.alignment != to->unpack.alignment)
2366	{
2367	diff_api.PixelStorei(GL_UNPACK_ALIGNMENT, to->unpack.alignment);
2368	FILLDIRTY(cb->unpack);
2369	FILLDIRTY(cb->dirty);
2370	}
2371	if (from->unpack.imageHeight != to->unpack.imageHeight)
2372	{
2373	diff_api.PixelStorei(GL_UNPACK_IMAGE_HEIGHT, to->unpack.imageHeight);
2374	FILLDIRTY(cb->unpack);
2375	FILLDIRTY(cb->dirty);
2376	}
2377	if (from->unpack.skipImages != to->unpack.skipImages)
2378	{
2379	diff_api.PixelStorei(GL_UNPACK_SKIP_IMAGES, to->unpack.skipImages);
2380	FILLDIRTY(cb->unpack);
2381	FILLDIRTY(cb->dirty);
2382	}
2383	if (from->unpack.swapBytes != to->unpack.swapBytes)
2384	{
2385	diff_api.PixelStorei(GL_UNPACK_SWAP_BYTES, to->unpack.swapBytes);
2386	FILLDIRTY(cb->unpack);
2387	FILLDIRTY(cb->dirty);
2388	}
2389	if (from->unpack.psLSBFirst != to->unpack.psLSBFirst)
2390	{
2391	diff_api.PixelStorei(GL_UNPACK_LSB_FIRST, to->unpack.psLSBFirst);
2392	FILLDIRTY(cb->unpack);
2393	FILLDIRTY(cb->dirty);
2394	}
2395	CLEARDIRTY2(cb->unpack, bitID);
2396	}
2397
2398	if (CHECKDIRTY(cb->pack, bitID))
2399	{
2400	if (from->pack.rowLength != to->pack.rowLength)
2401	{
2402	diff_api.PixelStorei(GL_PACK_ROW_LENGTH, to->pack.rowLength);
2403	FILLDIRTY(cb->pack);
2404	FILLDIRTY(cb->dirty);
2405	}
2406	if (from->pack.skipRows != to->pack.skipRows)
2407	{
2408	diff_api.PixelStorei(GL_PACK_SKIP_ROWS, to->pack.skipRows);
2409	FILLDIRTY(cb->pack);
2410	FILLDIRTY(cb->dirty);
2411	}
2412	if (from->pack.skipPixels != to->pack.skipPixels)
2413	{
2414	diff_api.PixelStorei(GL_PACK_SKIP_PIXELS, to->pack.skipPixels);
2415	FILLDIRTY(cb->pack);
2416	FILLDIRTY(cb->dirty);
2417	}
2418	if (from->pack.alignment != to->pack.alignment)
2419	{
2420	diff_api.PixelStorei(GL_PACK_ALIGNMENT, to->pack.alignment);
2421	FILLDIRTY(cb->pack);
2422	FILLDIRTY(cb->dirty);
2423	}
2424	if (from->pack.imageHeight != to->pack.imageHeight)
2425	{
2426	diff_api.PixelStorei(GL_PACK_IMAGE_HEIGHT, to->pack.imageHeight);
2427	FILLDIRTY(cb->pack);
2428	FILLDIRTY(cb->dirty);
2429	}
2430	if (from->pack.skipImages != to->pack.skipImages)
2431	{
2432	diff_api.PixelStorei(GL_PACK_SKIP_IMAGES, to->pack.skipImages);
2433	FILLDIRTY(cb->pack);
2434	FILLDIRTY(cb->dirty);
2435	}
2436	if (from->pack.swapBytes != to->pack.swapBytes)
2437	{
2438	diff_api.PixelStorei(GL_PACK_SWAP_BYTES, to->pack.swapBytes);
2439	FILLDIRTY(cb->pack);
2440	FILLDIRTY(cb->dirty);
2441	}
2442	if (from->pack.psLSBFirst != to->pack.psLSBFirst)
2443	{
2444	diff_api.PixelStorei(GL_PACK_LSB_FIRST, to->pack.psLSBFirst);
2445	FILLDIRTY(cb->pack);
2446	FILLDIRTY(cb->dirty);
2447	}
2448	CLEARDIRTY2(cb->pack, bitID);
2449	}
2450
2451	CLEARDIRTY2(cb->dirty, bitID);
2452	}
2453
2454	CRClientPointer* crStateGetClientPointerByIndex(int index, CRVertexArrays *array)
2455	{
2456	CRASSERT(array && index>=0 && index<CRSTATECLIENT_MAX_VERTEXARRAYS);
2457
2458	if (array == NULL \|\| index < 0 \|\| index >= CRSTATECLIENT_MAX_VERTEXARRAYS)
2459	{
2460	return NULL;
2461	}
2462
2463	if (index < 7)
2464	{
2465	switch (index)
2466	{
2467	case 0: return &array->v;
2468	case 1: return &array->c;
2469	case 2: return &array->f;
2470	case 3: return &array->s;
2471	case 4: return &array->e;
2472	case 5: return &array->i;
2473	case 6: return &array->n;
2474	}
2475	}
2476	else if (index<(7+CR_MAX_TEXTURE_UNITS))
2477	{
2478	return &array->t[index-7];
2479	}
2480	else
2481	{
2482	return &array->a[index-7-CR_MAX_TEXTURE_UNITS];
2483	}
2484
2485	/silence the compiler warning/
2486	CRASSERT(false);
2487	return NULL;
2488	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_client.c@ 78263

Download in other formats: