VirtualBox

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

最後變更 在這個檔案從24684是 23123,由 vboxsync 提交於 16 年 前

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

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette