DEADSOFTWARE

GIT / REPO / FRED-BOY
Projects / nanogl.git / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Add VBO support
[nanogl.git] / nanoWrap.cpp
1 /*
2 Copyright (C) 2007-2009 Olli Hinkka
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18
19 */
20 /*
21 #include <e32def.h>
22 #include <e32std.h>
23 */
24
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28
29 #include "gl.h"
30 #include "glesinterface.h"
31 #include "nanogl.h"
32
33 #define GL_TEXTURE0_ARB 0x84C0
34 #define GL_TEXTURE1_ARB 0x84C1
35
36 struct nanoState
37 {
38 GLboolean alpha_test;
39 GLboolean blend;
40 GLboolean clip_planei;
41 GLboolean color_logic_op;
42 GLboolean color_material;
43 GLboolean cull_face;
44 GLboolean depth_test;
45 GLboolean dither;
46 GLboolean fog;
47 GLboolean lighti;
48 GLboolean lighting;
49 GLboolean line_smooth;
50 GLboolean matrix_palette_oes;
51 GLboolean multisample;
52 GLboolean normalize;
53 GLboolean point_smooth;
54 GLboolean point_sprite_oes;
55 GLboolean polygon_offset_fill;
56 GLboolean rescale_normal;
57 GLboolean sample_alpha_to_coverage;
58 GLboolean sample_alpha_to_one;
59 GLboolean sample_coverage;
60 GLboolean scissor_test;
61 GLboolean stencil_test;
62 GLboolean depthmask;
63 GLboolean stupidglesbug;
64 GLclampf depth_range_near;
65 GLclampf depth_range_far;
66 GLenum depth_func;
67 GLenum cullface;
68 GLenum shademodel;
69 GLenum sfactor;
70 GLenum dfactor;
71 GLenum matrixmode;
72 };
73
74 static struct nanoState nanoglState;
75
76 static struct nanoState nanoglInitState =
77 {
78 GL_FALSE,
79 GL_FALSE,
80 GL_FALSE,
81 GL_FALSE,
82 GL_FALSE,
83 GL_FALSE,
84 GL_FALSE,
85 GL_TRUE,
86 GL_FALSE,
87 GL_FALSE,
88 GL_FALSE,
89 GL_FALSE,
90 GL_FALSE,
91 GL_TRUE,
92 GL_FALSE,
93 GL_FALSE,
94 GL_FALSE,
95 GL_FALSE,
96 GL_FALSE,
97 GL_FALSE,
98 GL_FALSE,
99 GL_FALSE,
100 GL_FALSE,
101 GL_FALSE,
102 GL_TRUE,
103 GL_FALSE,
104 0.0f,
105 1.0f,
106 GL_LESS,
107 GL_BACK,
108 GL_SMOOTH,
109 GL_ONE,
110 GL_ZERO,
111 GL_MODELVIEW,
112 };
113
114 struct booleanstate
115 {
116 GLboolean value;
117 GLboolean changed;
118 };
119
120 struct floatstate
121 {
122 GLfloat value;
123 GLboolean changed;
124 };
125
126 struct uintstate
127 {
128 GLuint value;
129 GLboolean changed;
130 };
131
132 struct ptrstate
133 {
134 GLint size;
135 GLenum type;
136 GLsizei stride;
137 GLvoid *ptr;
138 GLboolean changed;
139 GLboolean enabled;
140 };
141
142 struct nanotmuState
143 {
144 struct booleanstate texture_2d;
145 struct floatstate texture_env_mode;
146 struct uintstate boundtexture;
147 struct ptrstate vertex_array;
148 struct ptrstate color_array;
149 struct ptrstate texture_coord_array;
150 struct ptrstate normal_array;
151 };
152
153 static struct nanotmuState tmuState0;
154 static struct nanotmuState tmuState1;
155
156 static struct nanotmuState tmuInitState =
157 {
158 {GL_FALSE, GL_FALSE},
159 {GL_MODULATE, GL_FALSE},
160 {0x7fffffff, GL_FALSE},
161 {4, GL_FLOAT, 0, NULL, GL_FALSE, GL_FALSE},
162 {4, GL_FLOAT, 0, NULL, GL_FALSE, GL_FALSE},
163 {4, GL_FLOAT, 0, NULL, GL_FALSE, GL_FALSE},
164 {3, GL_FLOAT, 0, NULL, GL_FALSE, GL_FALSE},
165 };
166
167 static struct nanotmuState *activetmuState = &tmuState0;
168
169 extern "C++" GlESInterface *glEsImpl;
170
171 static GLenum wrapperPrimitiveMode = GL_QUADS;
172 GLboolean useTexCoordArray = GL_FALSE;
173 static GLenum activetmu = GL_TEXTURE0;
174 static GLenum clientactivetmu = GL_TEXTURE0;
175
176 #if defined( __MULTITEXTURE_SUPPORT__ )
177 GLboolean useMultiTexCoordArray = GL_FALSE;
178 #endif
179
180 #if !defined( __WINS__ )
181 //#define __FORCEINLINE __forceinline
182 #define __FORCEINLINE inline
183 #else
184 #define __FORCEINLINE
185 #endif
186
187 static GLboolean delayedttmuchange = GL_FALSE;
188 static GLenum delayedtmutarget = GL_TEXTURE0;
189
190 struct VertexAttrib
191 {
192 float x;
193 float y;
194 float z;
195 #if !defined( __MULTITEXTURE_SUPPORT__ )
196 float padding;
197 #endif
198 unsigned char red;
199 unsigned char green;
200 unsigned char blue;
201 unsigned char alpha;
202
203 float s;
204 float t;
205 #if defined( __MULTITEXTURE_SUPPORT__ )
206 float s_multi;
207 float t_multi;
208 #endif
209 };
210
211 static VertexAttrib vertexattribs[60000];
212
213 static GLushort indexArray[50000];
214
215 static GLuint vertexCount = 0;
216 static GLuint indexCount = 0;
217 static GLuint vertexMark = 0;
218 static int indexbase = 0;
219
220 static VertexAttrib *ptrVertexAttribArray = NULL;
221 static VertexAttrib *ptrVertexAttribArrayMark = NULL;
222
223 static VertexAttrib currentVertexAttrib;
224 #if defined( __MULTITEXTURE_SUPPORT__ )
225 static VertexAttrib currentVertexAttribInit = {0.0f, 0.0f, 0.0f, 255, 255, 255, 255, 0.0f, 0.0f, 0.0f, 0.0f};
226 #else
227 static VertexAttrib currentVertexAttribInit = {
228 0.0f, 0.0f, 0.0f, 0.0f, 255, 255, 255, 255, 0.0f, 0.0f,
229 };
230 #endif
231 static GLushort *ptrIndexArray = NULL;
232
233 static GLboolean arraysValid = GL_FALSE;
234
235 static GLboolean skipnanogl;
236
237 void InitGLStructs( )
238 {
239 ptrVertexAttribArray = vertexattribs;
240 ptrVertexAttribArrayMark = ptrVertexAttribArray;
241 ptrIndexArray = indexArray;
242
243 memcpy( &nanoglState, &nanoglInitState, sizeof( struct nanoState ) );
244 memcpy( &tmuState0, &tmuInitState, sizeof( struct nanotmuState ) );
245 memcpy( &tmuState1, &tmuInitState, sizeof( struct nanotmuState ) );
246 memcpy( &currentVertexAttrib, &currentVertexAttribInit, sizeof( struct VertexAttrib ) );
247
248 activetmuState = &tmuState0;
249 wrapperPrimitiveMode = GL_QUADS;
250 useTexCoordArray = GL_FALSE;
251 activetmu = GL_TEXTURE0;
252 clientactivetmu = GL_TEXTURE0;
253 delayedttmuchange = GL_FALSE;
254 delayedtmutarget = GL_TEXTURE0;
255 vertexCount = 0;
256 indexCount = 0;
257 vertexMark = 0;
258 indexbase = 0;
259 arraysValid = GL_FALSE;
260 }
261
262 void ResetNanoState( )
263 {
264
265 if ( tmuState0.color_array.enabled )
266 {
267 glEsImpl->glEnableClientState( GL_COLOR_ARRAY );
268 }
269 else
270 {
271 glEsImpl->glDisableClientState( GL_COLOR_ARRAY );
272 }
273
274 if ( tmuState0.vertex_array.enabled )
275 {
276 glEsImpl->glEnableClientState( GL_VERTEX_ARRAY );
277 }
278 else
279 {
280 glEsImpl->glDisableClientState( GL_VERTEX_ARRAY );
281 }
282
283 if ( tmuState0.texture_coord_array.enabled )
284 {
285 glEsImpl->glEnableClientState( GL_TEXTURE_COORD_ARRAY );
286 }
287 else
288 {
289 glEsImpl->glDisableClientState( GL_TEXTURE_COORD_ARRAY );
290 }
291
292 if ( tmuState0.normal_array.enabled )
293 {
294 glEsImpl->glEnableClientState( GL_NORMAL_ARRAY );
295 }
296 else
297 {
298 glEsImpl->glDisableClientState( GL_NORMAL_ARRAY );
299 }
300 glEsImpl->glVertexPointer( tmuState0.vertex_array.size,
301 tmuState0.vertex_array.type,
302 tmuState0.vertex_array.stride,
303 tmuState0.vertex_array.ptr );
304
305 glEsImpl->glTexCoordPointer( tmuState0.texture_coord_array.size,
306 tmuState0.texture_coord_array.type,
307 tmuState0.texture_coord_array.stride,
308 tmuState0.texture_coord_array.ptr );
309
310 glEsImpl->glColorPointer( tmuState0.color_array.size,
311 tmuState0.color_array.type,
312 tmuState0.color_array.stride,
313 tmuState0.color_array.ptr );
314
315 glEsImpl->glNormalPointer(
316 tmuState0.normal_array.type,
317 tmuState0.normal_array.stride,
318 tmuState0.normal_array.ptr );
319
320 glEsImpl->glMatrixMode( nanoglState.matrixmode );
321
322 glEsImpl->glColor4f( currentVertexAttrib.red/255.0f, currentVertexAttrib.green/255.0f,
323 currentVertexAttrib.blue/255.0f, currentVertexAttrib.alpha/255.0f );
324
325 glEsImpl->glBlendFunc( nanoglState.sfactor, nanoglState.dfactor );
326
327 //glEsImpl->glBindTexture(GL_TEXTURE_2D, stackTextureState);
328
329 glEsImpl->glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, activetmuState->texture_env_mode.value );
330
331 arraysValid = GL_FALSE;
332 skipnanogl = GL_FALSE;
333 }
334
335 void FlushOnStateChange( )
336 {
337 if( skipnanogl )
338 return;
339 if ( delayedttmuchange )
340 {
341 delayedttmuchange = GL_FALSE;
342 #ifndef USE_CORE_PROFILE
343 glEsImpl->glActiveTexture( delayedtmutarget );
344 #endif
345 }
346
347 if ( !vertexCount )
348 return;
349
350 if ( !arraysValid )
351 {
352 glEsImpl->glClientActiveTexture( GL_TEXTURE0 );
353 glEsImpl->glVertexPointer( 3, GL_FLOAT, sizeof( VertexAttrib ), &vertexattribs[0].x );
354 glEsImpl->glColorPointer( 4, GL_UNSIGNED_BYTE, sizeof( VertexAttrib ), &vertexattribs[0].red );
355 glEsImpl->glTexCoordPointer( 2, GL_FLOAT, sizeof( VertexAttrib ), &vertexattribs[0].s );
356 glEsImpl->glEnableClientState( GL_VERTEX_ARRAY );
357 glEsImpl->glEnableClientState( GL_TEXTURE_COORD_ARRAY );
358 glEsImpl->glEnableClientState( GL_COLOR_ARRAY );
359 #if defined( __MULTITEXTURE_SUPPORT__ )
360 glEsImpl->glClientActiveTexture( GL_TEXTURE1 );
361 glEsImpl->glTexCoordPointer( 2, GL_FLOAT, sizeof( VertexAttrib ), &vertexattribs[0].s_multi );
362 glEsImpl->glEnableClientState( GL_TEXTURE_COORD_ARRAY );
363 glEsImpl->glClientActiveTexture( GL_TEXTURE0 );
364 #endif
365 arraysValid = GL_TRUE;
366 }
367
368 glEsImpl->glDrawElements( GL_TRIANGLES, vertexCount, GL_UNSIGNED_SHORT, indexArray );
369
370 #if defined( __MULTITEXTURE_SUPPORT__ )
371 useMultiTexCoordArray = GL_FALSE;
372 #endif
373 vertexCount = 0;
374 indexCount = 0;
375 ptrVertexAttribArray = vertexattribs;
376 ptrVertexAttribArrayMark = ptrVertexAttribArray;
377 ptrIndexArray = indexArray;
378 useTexCoordArray = GL_FALSE;
379 }
380 void nanoGL_Flush( )
381 {
382 FlushOnStateChange( );
383 }
384 void nanoGL_Reset( )
385 {
386 ResetNanoState( );
387 }
388 void glBegin( GLenum mode )
389 {
390 wrapperPrimitiveMode = mode;
391 vertexMark = vertexCount;
392 ptrVertexAttribArrayMark = ptrVertexAttribArray;
393 indexbase = indexCount;
394 }
395
396 void glEnd( void )
397 {
398 vertexCount += ( (unsigned char *)ptrVertexAttribArray - (unsigned char *)ptrVertexAttribArrayMark ) / sizeof( VertexAttrib );
399 if ( vertexCount < 3 )
400 {
401 return;
402 }
403 switch ( wrapperPrimitiveMode )
404 {
405 case GL_QUADS:
406 {
407 *ptrIndexArray++ = indexCount;
408 *ptrIndexArray++ = indexCount + 1;
409 *ptrIndexArray++ = indexCount + 2;
410 *ptrIndexArray++ = indexCount;
411 *ptrIndexArray++ = indexCount + 2;
412 *ptrIndexArray++ = indexCount + 3;
413 indexCount += 4;
414 vertexCount += 2;
415 }
416 break;
417 case GL_TRIANGLES:
418 {
419 int vcount = ( vertexCount - vertexMark ) / 3;
420 for ( int count = 0; count < vcount; count++ )
421 {
422 *ptrIndexArray++ = indexCount;
423 *ptrIndexArray++ = indexCount + 1;
424 *ptrIndexArray++ = indexCount + 2;
425 indexCount += 3;
426 }
427 }
428 break;
429 case GL_TRIANGLE_STRIP:
430 {
431 *ptrIndexArray++ = indexCount;
432 *ptrIndexArray++ = indexCount + 1;
433 *ptrIndexArray++ = indexCount + 2;
434 indexCount += 3;
435 int vcount = ( ( vertexCount - vertexMark ) - 3 );
436 if ( vcount && ( (long)ptrIndexArray & 0x02 ) )
437 {
438 *ptrIndexArray++ = indexCount - 1; // 2
439 *ptrIndexArray++ = indexCount - 2; // 1
440 *ptrIndexArray++ = indexCount; // 3
441 indexCount++;
442 vcount -= 1;
443 int odd = vcount & 1;
444 vcount /= 2;
445 unsigned int *longptr = (unsigned int *)ptrIndexArray;
446
447 for ( int count = 0; count < vcount; count++ )
448 {
449 *( longptr++ ) = ( indexCount - 2 ) | ( ( indexCount - 1 ) << 16 );
450 *( longptr++ ) = ( indexCount ) | ( ( indexCount ) << 16 );
451 *( longptr++ ) = ( indexCount - 1 ) | ( ( indexCount + 1 ) << 16 );
452 indexCount += 2;
453 }
454 ptrIndexArray = (unsigned short *)( longptr );
455 if ( odd )
456 {
457 *ptrIndexArray++ = indexCount - 2; // 2
458 *ptrIndexArray++ = indexCount - 1; // 1
459 *ptrIndexArray++ = indexCount; // 3
460 indexCount++;
461 }
462 }
463 else
464 {
465 //already aligned
466 int odd = vcount & 1;
467 vcount /= 2;
468 unsigned int *longptr = (unsigned int *)ptrIndexArray;
469
470 for ( int count = 0; count < vcount; count++ )
471 {
472 *( longptr++ ) = ( indexCount - 1 ) | ( ( indexCount - 2 ) << 16 );
473 *( longptr++ ) = ( indexCount ) | ( ( indexCount - 1 ) << 16 );
474 *( longptr++ ) = ( indexCount ) | ( ( indexCount + 1 ) << 16 );
475 indexCount += 2;
476 }
477 ptrIndexArray = (unsigned short *)( longptr );
478 if ( odd )
479 {
480
481 *ptrIndexArray++ = indexCount - 1; // 2
482 *ptrIndexArray++ = indexCount - 2; // 1
483 *ptrIndexArray++ = indexCount; // 3
484 indexCount++;
485 }
486 }
487 vertexCount += ( vertexCount - vertexMark - 3 ) * 2;
488 }
489 break;
490 case GL_POLYGON:
491 case GL_TRIANGLE_FAN:
492 {
493 *ptrIndexArray++ = indexCount++;
494 *ptrIndexArray++ = indexCount++;
495 *ptrIndexArray++ = indexCount++;
496 int vcount = ( ( vertexCount - vertexMark ) - 3 );
497 for ( int count = 0; count < vcount; count++ )
498 {
499 *ptrIndexArray++ = indexbase;
500 *ptrIndexArray++ = indexCount - 1;
501 *ptrIndexArray++ = indexCount++;
502 vertexCount += 2;
503 }
504 }
505 break;
506
507 default:
508 break;
509 }
510 if ( ptrVertexAttribArray - vertexattribs > 20000 * sizeof( VertexAttrib ) ||
511 ptrIndexArray - indexArray > 15000 * sizeof( GLushort ) )
512 FlushOnStateChange( );
513 }
514
515 void glEnable( GLenum cap )
516 {
517 if( skipnanogl )
518 {
519 glEsImpl->glEnable( cap );
520 return;
521 }
522 GLboolean statechanged = GL_FALSE;
523 switch ( cap )
524 {
525 case GL_ALPHA_TEST:
526 {
527 if ( !nanoglState.alpha_test )
528 {
529 nanoglState.alpha_test = GL_TRUE;
530 statechanged = GL_TRUE;
531 }
532 break;
533 }
534 case GL_BLEND:
535 {
536 if ( !nanoglState.blend )
537 {
538 nanoglState.blend = GL_TRUE;
539 statechanged = GL_TRUE;
540 }
541 break;
542 }
543 //case GL_CLIP_PLANEi
544 case GL_COLOR_LOGIC_OP:
545 {
546 if ( !nanoglState.color_logic_op )
547 {
548 nanoglState.color_logic_op = GL_TRUE;
549 statechanged = GL_TRUE;
550 }
551 break;
552 }
553 case GL_COLOR_MATERIAL:
554 {
555 if ( !nanoglState.color_material )
556 {
557 nanoglState.color_material = GL_TRUE;
558 statechanged = GL_TRUE;
559 }
560 break;
561 }
562 case GL_CULL_FACE:
563 {
564 if ( !nanoglState.cull_face )
565 {
566 nanoglState.cull_face = GL_TRUE;
567 statechanged = GL_TRUE;
568 }
569 break;
570 }
571 case GL_DEPTH_TEST:
572 {
573 if ( !nanoglState.depth_test )
574 {
575 nanoglState.depth_test = GL_TRUE;
576 statechanged = GL_TRUE;
577 }
578 break;
579 }
580 case GL_DITHER:
581 {
582 if ( !nanoglState.dither )
583 {
584 nanoglState.dither = GL_TRUE;
585 statechanged = GL_TRUE;
586 }
587 break;
588 }
589 case GL_FOG:
590 //case GL_LIGHTi
591 {
592 if ( !nanoglState.fog )
593 {
594 nanoglState.fog = GL_TRUE;
595 statechanged = GL_TRUE;
596 }
597 break;
598 }
599 case GL_LIGHTING:
600 {
601 if ( !nanoglState.lighting )
602 {
603 nanoglState.lighting = GL_TRUE;
604 statechanged = GL_TRUE;
605 }
606 break;
607 }
608 case GL_LINE_SMOOTH:
609 {
610 if ( !nanoglState.line_smooth )
611 {
612 nanoglState.line_smooth = GL_TRUE;
613 statechanged = GL_TRUE;
614 }
615 break;
616 }
617 /* case GL_MATRIX_PALETTE_OES:
618 {
619 if (!nanoglState.matrix_palette_oes)
620 {
621 nanoglState.matrix_palette_oes = GL_TRUE;
622 statechanged = GL_TRUE;
623 }
624 break;
625 }*/
626 case GL_MULTISAMPLE:
627 {
628 if ( !nanoglState.multisample )
629 {
630 nanoglState.multisample = GL_TRUE;
631 statechanged = GL_TRUE;
632 }
633 break;
634 }
635 case GL_NORMALIZE:
636 {
637 if ( !nanoglState.normalize )
638 {
639 nanoglState.normalize = GL_TRUE;
640 statechanged = GL_TRUE;
641 }
642 break;
643 }
644 /* case GL_POINT_SPRITE_OES:
645 {
646 if (!nanoglState.point_sprite_oes)
647 {
648 nanoglState.point_sprite_oes = GL_TRUE;
649 statechanged = GL_TRUE;
650 }
651 break;
652 }*/
653 case GL_POLYGON_OFFSET_FILL:
654 {
655 if ( !nanoglState.polygon_offset_fill )
656 {
657 nanoglState.polygon_offset_fill = GL_TRUE;
658 statechanged = GL_TRUE;
659 }
660 break;
661 }
662 case GL_RESCALE_NORMAL:
663 {
664 if ( !nanoglState.rescale_normal )
665 {
666 nanoglState.rescale_normal = GL_TRUE;
667 statechanged = GL_TRUE;
668 }
669 break;
670 }
671 case GL_SAMPLE_ALPHA_TO_COVERAGE:
672 {
673 if ( !nanoglState.sample_alpha_to_coverage )
674 {
675 nanoglState.sample_alpha_to_coverage = GL_TRUE;
676 statechanged = GL_TRUE;
677 }
678 break;
679 }
680 case GL_SAMPLE_ALPHA_TO_ONE:
681 {
682 if ( !nanoglState.sample_alpha_to_one )
683 {
684 nanoglState.sample_alpha_to_one = GL_TRUE;
685 statechanged = GL_TRUE;
686 }
687 break;
688 }
689 case GL_SAMPLE_COVERAGE:
690 {
691 if ( !nanoglState.sample_coverage )
692 {
693 nanoglState.sample_coverage = GL_TRUE;
694 statechanged = GL_TRUE;
695 }
696 break;
697 }
698 case GL_SCISSOR_TEST:
699 {
700 if ( !nanoglState.scissor_test )
701 {
702 nanoglState.scissor_test = GL_TRUE;
703 statechanged = GL_TRUE;
704 }
705 break;
706 }
707 case GL_STENCIL_TEST:
708 {
709 return;
710 if (!nanoglState.stencil_test)
711 {
712 nanoglState.stencil_test = GL_TRUE;
713 statechanged = GL_TRUE;
714 }
715 break;
716 }
717 case GL_TEXTURE_2D:
718 {
719 if ( !activetmuState->texture_2d.value )
720 {
721 FlushOnStateChange( );
722 glEsImpl->glEnable( cap );
723 activetmuState->texture_2d.value = GL_TRUE;
724 return;
725 }
726 break;
727 }
728 #if 0 // todo: implement cubemap texgen
729 case GL_TEXTURE_GEN_S:
730 case GL_TEXTURE_GEN_T:
731 case GL_TEXTURE_GEN_R:
732 case GL_TEXTURE_GEN_Q:
733 {
734 FlushOnStateChange( );
735 nanoglState.texgen = true;
736 return;
737 }
738 #endif
739 default:
740 break;
741 }
742
743 if ( statechanged )
744 {
745 FlushOnStateChange( );
746 glEsImpl->glEnable( cap );
747 }
748 }
749
750 void glDisable( GLenum cap )
751 {
752 if( skipnanogl )
753 {
754 glEsImpl->glDisable( cap );
755 return;
756 }
757 GLboolean statechanged = GL_FALSE;
758 switch ( cap )
759 {
760 case GL_ALPHA_TEST:
761 {
762 if ( nanoglState.alpha_test )
763 {
764 nanoglState.alpha_test = GL_FALSE;
765 statechanged = GL_TRUE;
766 }
767 break;
768 }
769 case GL_BLEND:
770 {
771 if ( nanoglState.blend )
772 {
773 nanoglState.blend = GL_FALSE;
774 statechanged = GL_TRUE;
775 }
776 break;
777 }
778 //case GL_CLIP_PLANEi
779 case GL_COLOR_LOGIC_OP:
780 {
781 if ( nanoglState.color_logic_op )
782 {
783 nanoglState.color_logic_op = GL_FALSE;
784 statechanged = GL_TRUE;
785 }
786 break;
787 }
788 case GL_COLOR_MATERIAL:
789 {
790 if ( nanoglState.color_material )
791 {
792 nanoglState.color_material = GL_FALSE;
793 statechanged = GL_TRUE;
794 }
795 break;
796 }
797 case GL_CULL_FACE:
798 {
799 if ( nanoglState.cull_face )
800 {
801 nanoglState.cull_face = GL_FALSE;
802 statechanged = GL_TRUE;
803 }
804 break;
805 }
806 case GL_DEPTH_TEST:
807 {
808 if ( nanoglState.depth_test )
809 {
810 nanoglState.depth_test = GL_FALSE;
811 statechanged = GL_TRUE;
812 }
813 break;
814 }
815 case GL_DITHER:
816 {
817 if ( nanoglState.dither )
818 {
819 nanoglState.dither = GL_FALSE;
820 statechanged = GL_TRUE;
821 }
822 break;
823 }
824 case GL_FOG:
825 //case GL_LIGHTi
826 {
827 if ( nanoglState.fog )
828 {
829 nanoglState.fog = GL_FALSE;
830 statechanged = GL_TRUE;
831 }
832 break;
833 }
834 case GL_LIGHTING:
835 {
836 if ( nanoglState.lighting )
837 {
838 nanoglState.lighting = GL_FALSE;
839 statechanged = GL_TRUE;
840 }
841 break;
842 }
843 case GL_LINE_SMOOTH:
844 {
845 if ( nanoglState.line_smooth )
846 {
847 nanoglState.line_smooth = GL_FALSE;
848 statechanged = GL_TRUE;
849 }
850 break;
851 }
852 /* case GL_MATRIX_PALETTE_OES:
853 {
854 if (nanoglState.matrix_palette_oes)
855 {
856 nanoglState.matrix_palette_oes = GL_FALSE;
857 statechanged = GL_TRUE;
858 }
859 break;
860 }*/
861 case GL_MULTISAMPLE:
862 {
863 if ( nanoglState.multisample )
864 {
865 nanoglState.multisample = GL_FALSE;
866 statechanged = GL_TRUE;
867 }
868 break;
869 }
870 case GL_NORMALIZE:
871 {
872 if ( nanoglState.normalize )
873 {
874 nanoglState.normalize = GL_FALSE;
875 statechanged = GL_TRUE;
876 }
877 break;
878 }
879 /* case GL_POINT_SPRITE_OES:
880 {
881 if (nanoglState.point_sprite_oes)
882 {
883 nanoglState.point_sprite_oes = GL_FALSE;
884 statechanged = GL_TRUE;
885 }
886 break;
887 }*/
888 case GL_POLYGON_OFFSET_FILL:
889 {
890 if ( nanoglState.polygon_offset_fill )
891 {
892 nanoglState.polygon_offset_fill = GL_FALSE;
893 statechanged = GL_TRUE;
894 }
895 break;
896 }
897 case GL_RESCALE_NORMAL:
898 {
899 if ( nanoglState.rescale_normal )
900 {
901 nanoglState.rescale_normal = GL_FALSE;
902 statechanged = GL_TRUE;
903 }
904 break;
905 }
906 case GL_SAMPLE_ALPHA_TO_COVERAGE:
907 {
908 if ( nanoglState.sample_alpha_to_coverage )
909 {
910 nanoglState.sample_alpha_to_coverage = GL_FALSE;
911 statechanged = GL_TRUE;
912 }
913 break;
914 }
915 case GL_SAMPLE_ALPHA_TO_ONE:
916 {
917 if ( nanoglState.sample_alpha_to_one )
918 {
919 nanoglState.sample_alpha_to_one = GL_FALSE;
920 statechanged = GL_TRUE;
921 }
922 break;
923 }
924 case GL_SAMPLE_COVERAGE:
925 {
926 if ( nanoglState.sample_coverage )
927 {
928 nanoglState.sample_coverage = GL_FALSE;
929 statechanged = GL_TRUE;
930 }
931 break;
932 }
933 case GL_SCISSOR_TEST:
934 {
935 if ( nanoglState.scissor_test )
936 {
937 nanoglState.scissor_test = GL_FALSE;
938 statechanged = GL_TRUE;
939 }
940 break;
941 }
942 case GL_STENCIL_TEST:
943 {
944 return;
945 if (nanoglState.stencil_test)
946 {
947 nanoglState.stencil_test = GL_FALSE;
948 statechanged = GL_TRUE;
949 }
950 break;
951 }
952 case GL_TEXTURE_2D:
953 {
954 if ( activetmuState->texture_2d.value )
955 {
956 FlushOnStateChange( );
957 glEsImpl->glDisable( cap );
958 activetmuState->texture_2d.value = GL_FALSE;
959 return;
960 }
961 break;
962 }
963 #if 0
964 case GL_TEXTURE_GEN_S:
965 case GL_TEXTURE_GEN_T:
966 case GL_TEXTURE_GEN_R:
967 case GL_TEXTURE_GEN_Q:
968 {
969 FlushOnStateChange( );
970 nanoglState.texgen = false;
971 return;
972 }
973 #endif
974 default:
975 break;
976 }
977
978 if ( statechanged )
979 {
980 FlushOnStateChange( );
981 glEsImpl->glDisable( cap );
982 }
983 }
984
985 void glVertex2f( GLfloat x, GLfloat y )
986 {
987 glVertex3f( x, y, 0.0f );
988 }
989
990 __FORCEINLINE unsigned int ClampTo255( float value )
991 {
992 unsigned int retval = (unsigned int)( value );
993 if ( retval > 255 )
994 {
995 retval = 255;
996 }
997 return retval;
998 }
999
1000 void glColor3f( GLfloat red, GLfloat green, GLfloat blue )
1001 {
1002 currentVertexAttrib.red = (unsigned char)ClampTo255( red * 255.0f );
1003 currentVertexAttrib.green = (unsigned char)ClampTo255( green * 255.0f );
1004 currentVertexAttrib.blue = (unsigned char)ClampTo255( blue * 255.0f );
1005 currentVertexAttrib.alpha = 255;
1006 }
1007
1008 void glTexCoord2fv( const GLfloat *v )
1009 {
1010 memcpy( &currentVertexAttrib.s, v, 2 * sizeof( float ) );
1011 }
1012
1013 void glTexCoord2f( GLfloat s, GLfloat t )
1014 {
1015 currentVertexAttrib.s = s;
1016 currentVertexAttrib.t = t;
1017 }
1018
1019 void glViewport( GLint x, GLint y, GLsizei width, GLsizei height )
1020 {
1021 FlushOnStateChange( );
1022 glEsImpl->glViewport( x, y, width, height );
1023 }
1024
1025 void glLoadIdentity( void )
1026 {
1027 FlushOnStateChange( );
1028 glEsImpl->glLoadIdentity( );
1029 }
1030
1031 void glColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
1032 {
1033 if( nanoglState.stupidglesbug )
1034 {
1035 currentVertexAttrib.red = (unsigned char)ClampTo255( ( red * alpha ) * 255.0f );
1036 currentVertexAttrib.green = (unsigned char)ClampTo255( ( green * alpha ) * 255.0f );
1037 currentVertexAttrib.blue = (unsigned char)ClampTo255( ( blue * alpha ) * 255.0f );
1038 }
1039 else
1040 {
1041 currentVertexAttrib.red = (unsigned char)ClampTo255( red * 255.0f );
1042 currentVertexAttrib.green = (unsigned char)ClampTo255( green * 255.0f );
1043 currentVertexAttrib.blue = (unsigned char)ClampTo255( blue * 255.0f );
1044 }
1045 currentVertexAttrib.alpha = (unsigned char)ClampTo255( alpha * 255.0f );
1046 }
1047
1048 void glOrtho( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar )
1049 {
1050 FlushOnStateChange( );
1051 #ifdef USE_CORE_PROFILE
1052 glEsImpl->glOrtho( left, right, bottom, top, zNear, zFar );
1053 #else
1054 glEsImpl->glOrthof( left, right, bottom, top, zNear, zFar );
1055 #endif
1056 }
1057
1058 void glMatrixMode( GLenum mode )
1059 {
1060 if ( nanoglState.matrixmode == mode )
1061 {
1062 return;
1063 }
1064 nanoglState.matrixmode = mode;
1065 FlushOnStateChange( );
1066 glEsImpl->glMatrixMode( mode );
1067 }
1068
1069 void glTexParameterf( GLenum target, GLenum pname, GLfloat param )
1070 {
1071 if ( pname == GL_TEXTURE_BORDER_COLOR )
1072 {
1073 return; // not supported by opengl es
1074 }
1075 if ( ( pname == GL_TEXTURE_WRAP_S ||
1076 pname == GL_TEXTURE_WRAP_T ) &&
1077 param == GL_CLAMP )
1078 {
1079 param = 0x812F;
1080 }
1081
1082 FlushOnStateChange( );
1083 glEsImpl->glTexParameterf( target, pname, param );
1084 }
1085
1086 void glTexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
1087 {
1088 glTexParameterf( target, pname, params[0] );
1089 }
1090
1091 void glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels )
1092 {
1093 FlushOnStateChange( );
1094 internalformat = format;
1095 glEsImpl->glTexImage2D( target, level, internalformat, width, height, border, format, type, pixels );
1096 }
1097
1098 void glDrawBuffer( GLenum /*mode*/ )
1099 {
1100 }
1101
1102 void glTranslatef( GLfloat x, GLfloat y, GLfloat z )
1103 {
1104 FlushOnStateChange( );
1105 glEsImpl->glTranslatef( x, y, z );
1106 }
1107
1108 void glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
1109 {
1110 FlushOnStateChange( );
1111 glEsImpl->glRotatef( angle, x, y, z );
1112 }
1113
1114 void glScalef( GLfloat x, GLfloat y, GLfloat z )
1115 {
1116 FlushOnStateChange( );
1117 glEsImpl->glScalef( x, y, z );
1118 }
1119
1120 void glDepthRange( GLclampf zNear, GLclampf zFar )
1121 {
1122 if ( ( nanoglState.depth_range_near == zNear ) && ( nanoglState.depth_range_far == zFar ) )
1123 {
1124 return;
1125 }
1126 else
1127 {
1128 nanoglState.depth_range_near = zNear;
1129 nanoglState.depth_range_far = zFar;
1130 }
1131 FlushOnStateChange( );
1132 #ifdef USE_CORE_PROFILE
1133 glEsImpl->glDepthRange( zNear, zFar );
1134 #else
1135 glEsImpl->glDepthRangef( zNear, zFar );
1136 #endif
1137 }
1138
1139 void glDepthFunc( GLenum func )
1140 {
1141 if ( nanoglState.depth_func == func )
1142 {
1143 return;
1144 }
1145 else
1146 {
1147 nanoglState.depth_func = func;
1148 }
1149 FlushOnStateChange( );
1150 glEsImpl->glDepthFunc( func );
1151 }
1152
1153 void glFinish( void )
1154 {
1155 FlushOnStateChange( );
1156 glEsImpl->glFinish( );
1157 }
1158
1159 void glGetFloatv( GLenum pname, GLfloat *params )
1160 {
1161 FlushOnStateChange( );
1162 glEsImpl->glGetFloatv( pname, params );
1163 }
1164
1165 void glCullFace( GLenum mode )
1166 {
1167 if ( nanoglState.cullface == mode )
1168 {
1169 return;
1170 }
1171 else
1172 {
1173 nanoglState.cullface = mode;
1174 }
1175 FlushOnStateChange( );
1176 glEsImpl->glCullFace( mode );
1177 }
1178
1179 void glFrustum( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar )
1180 {
1181 FlushOnStateChange( );
1182 glEsImpl->glFrustumf( left, right, bottom, top, zNear, zFar );
1183 }
1184
1185 void glClear( GLbitfield mask )
1186 {
1187 FlushOnStateChange( );
1188 glEsImpl->glClear( mask );
1189 }
1190
1191 void glVertex3f( GLfloat x, GLfloat y, GLfloat z )
1192 {
1193 GLfloat *vert = (GLfloat *)ptrVertexAttribArray++;
1194 *vert++ = x;
1195 *vert++ = y;
1196 *vert++ = z;
1197 #if defined( __MULTITEXTURE_SUPPORT__ )
1198 memcpy( vert, &currentVertexAttrib.red, 5 * sizeof( GLfloat ) );
1199 #else
1200 memcpy( vert + 1, &currentVertexAttrib.red, 3 * sizeof( GLfloat ) );
1201 #endif
1202 }
1203
1204 void glColor4fv( const GLfloat *v )
1205 {
1206 if( nanoglState.stupidglesbug )
1207 {
1208 currentVertexAttrib.red = (unsigned char)ClampTo255( ( v[0] * v[3] ) * 255.0f );
1209 currentVertexAttrib.green = (unsigned char)ClampTo255( ( v[1] * v[3] ) * 255.0f );
1210 currentVertexAttrib.blue = (unsigned char)ClampTo255( ( v[2] * v[3] ) * 255.0f );
1211 }
1212 else
1213 {
1214 currentVertexAttrib.red = (unsigned char)ClampTo255( v[0] * 255.0f );
1215 currentVertexAttrib.green = (unsigned char)ClampTo255( v[1] * 255.0f );
1216 currentVertexAttrib.blue = (unsigned char)ClampTo255( v[2] * 255.0f );
1217 }
1218 currentVertexAttrib.alpha = (unsigned char)ClampTo255( v[3] * 255.0f );
1219 if( skipnanogl )
1220 glEsImpl->glColor4f( currentVertexAttrib.red/255.0f, currentVertexAttrib.green/255.0f,
1221 currentVertexAttrib.blue/255.0f, currentVertexAttrib.alpha/255.0f );
1222 }
1223
1224 void glColor3ubv( const GLubyte *v )
1225 {
1226 currentVertexAttrib.red = v[0];
1227 currentVertexAttrib.green = v[1];
1228 currentVertexAttrib.blue = v[2];
1229 currentVertexAttrib.alpha = 255;
1230 if( skipnanogl )
1231 glEsImpl->glColor4f( currentVertexAttrib.red/255.0f, currentVertexAttrib.green/255.0f,
1232 currentVertexAttrib.blue/255.0f, currentVertexAttrib.alpha/255.0f );
1233 }
1234
1235 void glColor4ubv( const GLubyte *v )
1236 {
1237 //*((unsigned int*)(&currentVertexAttrib.red)) = *((unsigned int*)(v));
1238 if( nanoglState.stupidglesbug )
1239 {
1240 currentVertexAttrib.red = (unsigned char)ClampTo255( v[0] * v[3] / 255.0f );
1241 currentVertexAttrib.green = (unsigned char)ClampTo255( v[1] * v[3] / 255.0f );
1242 currentVertexAttrib.blue = (unsigned char)ClampTo255( v[2] * v[3] / 255.0f );
1243 }
1244 else
1245 {
1246 currentVertexAttrib.red = v[0];
1247 currentVertexAttrib.green = v[1];
1248 currentVertexAttrib.blue = v[2];
1249 }
1250 currentVertexAttrib.alpha = v[3];
1251 if( skipnanogl )
1252 glEsImpl->glColor4f( currentVertexAttrib.red/255.0f, currentVertexAttrib.green/255.0f,
1253 currentVertexAttrib.blue/255.0f, currentVertexAttrib.alpha/255.0f );
1254 }
1255
1256 void glColor3fv( const GLfloat *v )
1257 {
1258 currentVertexAttrib.red = (unsigned char)ClampTo255( v[0] * 255.0f );
1259 currentVertexAttrib.green = (unsigned char)ClampTo255( v[1] * 255.0f );
1260 currentVertexAttrib.blue = (unsigned char)ClampTo255( v[2] * 255.0f );
1261 currentVertexAttrib.alpha = 255;
1262 if( skipnanogl )
1263 glEsImpl->glColor4f( currentVertexAttrib.red/255.0f, currentVertexAttrib.green/255.0f,
1264 currentVertexAttrib.blue/255.0f, currentVertexAttrib.alpha/255.0f );
1265 }
1266
1267 //-- nicknekit: xash3d funcs --
1268
1269 void glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
1270 {
1271 if( nanoglState.stupidglesbug )
1272 {
1273 currentVertexAttrib.red = (unsigned char)ClampTo255( red * alpha / 255.0f );
1274 currentVertexAttrib.green = (unsigned char)ClampTo255( green * alpha / 255.0f );
1275 currentVertexAttrib.blue = (unsigned char)ClampTo255( blue * alpha / 255.0f );
1276 }
1277 else
1278 {
1279 currentVertexAttrib.red = red;
1280 currentVertexAttrib.green = green;
1281 currentVertexAttrib.blue = blue;
1282 }
1283 currentVertexAttrib.alpha = alpha;
1284 if( skipnanogl )
1285 glEsImpl->glColor4f( currentVertexAttrib.red/255.0f, currentVertexAttrib.green/255.0f,
1286 currentVertexAttrib.blue/255.0f, currentVertexAttrib.alpha/255.0f );
1287 }
1288
1289 void glColor3ub( GLubyte red, GLubyte green, GLubyte blue )
1290 {
1291 currentVertexAttrib.red = red;
1292 currentVertexAttrib.green = green;
1293 currentVertexAttrib.blue = blue;
1294 currentVertexAttrib.alpha = 255;
1295 if( skipnanogl )
1296 glEsImpl->glColor4f( currentVertexAttrib.red/255.0f, currentVertexAttrib.green/255.0f,
1297 currentVertexAttrib.blue/255.0f, currentVertexAttrib.alpha/255.0f );
1298 }
1299
1300 void glNormal3fv( const GLfloat *v )
1301 {
1302 FlushOnStateChange( );
1303 glEsImpl->glNormal3f( v[0], v[1], v[2] );
1304 }
1305
1306 void glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
1307 {
1308 FlushOnStateChange( );
1309 glEsImpl->glCopyTexImage2D( target, level, internalformat, x, y, width, height, border );
1310 }
1311
1312 void glTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels )
1313 {
1314 glTexImage2D( GL_TEXTURE_2D, level, internalformat, width, 1, border, format, type, pixels );
1315 }
1316
1317 void glTexImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels )
1318 {
1319 glTexImage2D( GL_TEXTURE_2D, level, internalformat, width, height, border, format, type, pixels );
1320 }
1321
1322 void glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels )
1323 {
1324 glTexSubImage2D( target, level, xoffset, 0, width, 1, format, type, pixels );
1325 }
1326
1327 void glTexSubImage3D( GLenum target, GLint level,
1328 GLint xoffset, GLint yoffset,
1329 GLint zoffset, GLsizei width,
1330 GLsizei height, GLsizei depth,
1331 GLenum format,
1332 GLenum type, const GLvoid *pixels )
1333 {
1334 glTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels );
1335 }
1336
1337 GLboolean glIsTexture( GLuint texture )
1338 {
1339 FlushOnStateChange( );
1340 return glEsImpl->glIsTexture( texture );
1341 }
1342
1343 // TODO: add native normal/reflection map texgen support
1344
1345 void glTexGeni( GLenum coord, GLenum pname, GLint param )
1346 {
1347 FlushOnStateChange();
1348 //glEsImpl->glTexGeniOES( coord, pname, param );
1349 }
1350
1351 void glTexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
1352 {
1353 FlushOnStateChange();
1354 //glEsImpl->glTexGenfvOES( coord, pname, params );
1355 }
1356
1357 //-- --//
1358
1359 void glHint( GLenum target, GLenum mode )
1360 {
1361 FlushOnStateChange( );
1362 glEsImpl->glHint( target, mode );
1363 }
1364
1365 void glBlendFunc( GLenum sfactor, GLenum dfactor )
1366 {
1367 if( skipnanogl )
1368 {
1369 glEsImpl->glBlendFunc( sfactor, dfactor );
1370 return;
1371 }
1372 if ( ( nanoglState.sfactor == sfactor ) && ( nanoglState.dfactor == dfactor ) )
1373 {
1374 return;
1375 }
1376
1377 if( sfactor == GL_SRC_ALPHA && dfactor == GL_ONE )
1378 {
1379 sfactor = GL_ONE; // workaround gles bug
1380 nanoglState.stupidglesbug = GL_TRUE;
1381 }
1382 else
1383 nanoglState.stupidglesbug = GL_FALSE;
1384
1385 nanoglState.sfactor = sfactor;
1386 nanoglState.dfactor = dfactor;
1387 FlushOnStateChange( );
1388 glEsImpl->glBlendFunc( sfactor, dfactor );
1389 }
1390
1391 void glPopMatrix( void )
1392 {
1393 FlushOnStateChange( );
1394 glEsImpl->glPopMatrix( );
1395 }
1396
1397 void glShadeModel( GLenum mode )
1398 {
1399 if ( nanoglState.shademodel == mode )
1400 {
1401 return;
1402 }
1403 nanoglState.shademodel = mode;
1404 FlushOnStateChange( );
1405 glEsImpl->glShadeModel( mode );
1406 }
1407
1408 void glPushMatrix( void )
1409 {
1410 FlushOnStateChange( );
1411 glEsImpl->glPushMatrix( );
1412 }
1413
1414 void glTexEnvf( GLenum target, GLenum pname, GLfloat param )
1415 {
1416 if( skipnanogl )
1417 {
1418 glEsImpl->glTexEnvf( target, pname, param );
1419 return;
1420 }
1421 if ( target == GL_TEXTURE_ENV )
1422 {
1423 if ( pname == GL_TEXTURE_ENV_MODE )
1424 {
1425 if ( param == activetmuState->texture_env_mode.value )
1426 {
1427 return;
1428 }
1429 else
1430 {
1431 FlushOnStateChange( );
1432 glEsImpl->glTexEnvf( target, pname, param );
1433 activetmuState->texture_env_mode.value = param;
1434 return;
1435 }
1436 }
1437 }
1438 FlushOnStateChange( );
1439 glEsImpl->glTexEnvf( target, pname, param );
1440 }
1441
1442 void glVertex3fv( const GLfloat *v )
1443 {
1444 GLfloat *vert = (GLfloat *)ptrVertexAttribArray++;
1445 memcpy( vert, v, 3 * sizeof( GLfloat ) );
1446 #if defined( __MULTITEXTURE_SUPPORT__ )
1447 memcpy( vert + 3, &currentVertexAttrib.red, 5 * sizeof( GLfloat ) );
1448 #else
1449 memcpy( vert + 4, &currentVertexAttrib.red, 3 * sizeof( GLfloat ) );
1450 #endif
1451 }
1452
1453 void glDepthMask( GLboolean flag )
1454 {
1455 if( !skipnanogl )
1456 {
1457 if ( nanoglState.depthmask == flag )
1458 {
1459 return;
1460 }
1461 nanoglState.depthmask = flag;
1462 FlushOnStateChange( );
1463 }
1464 glEsImpl->glDepthMask( flag );
1465 }
1466
1467 void glBindTexture( GLenum target, GLuint texture )
1468 {
1469 if( skipnanogl )
1470 {
1471 glEsImpl->glBindTexture( target,texture );
1472 return;
1473 }
1474 if ( activetmuState->boundtexture.value == texture )
1475 {
1476 return;
1477 }
1478 FlushOnStateChange( );
1479 activetmuState->boundtexture.value = texture;
1480 glEsImpl->glBindTexture( target, texture );
1481 }
1482
1483 void glGetIntegerv( GLenum pname, GLint *params )
1484 {
1485 FlushOnStateChange( );
1486 glEsImpl->glGetIntegerv( pname, params );
1487 }
1488
1489 GLubyte nano_extensions_string[4096];
1490 const GLubyte *glGetString( GLenum name )
1491 {
1492
1493 if ( name == GL_EXTENSIONS )
1494 {
1495 #if defined( __MULTITEXTURE_SUPPORT__ )
1496 sprintf( (char *)nano_extensions_string, "%s %s", glEsImpl->glGetString( name ), "GL_ARB_multitexture EXT_texture_env_add" );
1497 #else
1498 sprintf( (char *)nano_extensions_string, "%s %s", glEsImpl->glGetString( name ), "EXT_texture_env_add" );
1499 #endif
1500 return nano_extensions_string;
1501 }
1502 return glEsImpl->glGetString( name );
1503 }
1504
1505 void glAlphaFunc( GLenum func, GLclampf ref )
1506 {
1507 FlushOnStateChange( );
1508 glEsImpl->glAlphaFunc( func, ref );
1509 }
1510
1511 void glFlush( void )
1512 {
1513 FlushOnStateChange( );
1514 glEsImpl->glFlush( );
1515 }
1516
1517 void glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels )
1518 {
1519 if ( format == GL_DEPTH_COMPONENT )
1520 {
1521 // OpenglEs 1.1 does not support reading depth buffer without an extension
1522 memset( pixels, 0xff, 4 );
1523 return;
1524 }
1525 FlushOnStateChange( );
1526 glEsImpl->glReadPixels( x, y, width, height, format, type, pixels );
1527 }
1528
1529 void glReadBuffer( GLenum /*mode*/ )
1530 {
1531 }
1532
1533 void glLoadMatrixf( const GLfloat *m )
1534 {
1535 FlushOnStateChange( );
1536 glEsImpl->glLoadMatrixf( m );
1537 }
1538
1539 void glTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels )
1540 {
1541 FlushOnStateChange( );
1542 glEsImpl->glTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels );
1543 }
1544
1545 void glClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
1546 {
1547 FlushOnStateChange( );
1548 glEsImpl->glClearColor( red, green, blue, alpha );
1549 }
1550
1551 GLenum glGetError( void )
1552 {
1553 //FlushOnStateChange();
1554 return GL_NO_ERROR; //glEsImpl->glGetError();
1555 }
1556
1557 void glActiveTexture( GLenum texture )
1558 {
1559 if( skipnanogl )
1560 {
1561 glEsImpl->glActiveTexture( texture );
1562 return;
1563 }
1564 if ( activetmu == texture )
1565 {
1566 return;
1567 }
1568 if ( delayedttmuchange )
1569 {
1570 delayedttmuchange = GL_FALSE;
1571 }
1572 else
1573 {
1574 delayedttmuchange = GL_TRUE;
1575 delayedtmutarget = texture;
1576 }
1577 if ( texture == GL_TEXTURE0 )
1578 {
1579 activetmuState = &tmuState0;
1580 }
1581 else
1582 {
1583 activetmuState = &tmuState1;
1584 }
1585 activetmu = texture;
1586 }
1587
1588 void glClientActiveTexture( GLenum texture )
1589 {
1590 if( skipnanogl )
1591 {
1592 glEsImpl->glClientActiveTexture( texture );
1593 return;
1594 }
1595 clientactivetmu = texture;
1596 }
1597
1598 void glPolygonMode( GLenum face, GLenum mode )
1599 {
1600 }
1601
1602 void glDeleteTextures( GLsizei n, const GLuint *textures )
1603 {
1604 FlushOnStateChange( );
1605 glEsImpl->glDeleteTextures( n, textures );
1606 }
1607
1608 void glClearDepth( GLclampf depth )
1609 {
1610 FlushOnStateChange( );
1611 glEsImpl->glClearDepthf( depth );
1612 }
1613
1614 void glClipPlane( GLenum plane, const GLdouble *equation )
1615 {
1616 FlushOnStateChange( );
1617 float array[4];
1618 array[0] = ( GLfloat )( equation[0] );
1619 array[1] = ( GLfloat )( equation[1] );
1620 array[2] = ( GLfloat )( equation[2] );
1621 array[3] = ( GLfloat )( equation[3] );
1622 glEsImpl->glClipPlanef( plane, array );
1623 }
1624
1625 void glScissor( GLint x, GLint y, GLsizei width, GLsizei height )
1626 {
1627 FlushOnStateChange( );
1628 glEsImpl->glScissor( x, y, width, height );
1629 }
1630
1631 void glPointSize( GLfloat size )
1632 {
1633 FlushOnStateChange( );
1634 glEsImpl->glPointSize( size );
1635 }
1636
1637 void glArrayElement( GLint i )
1638 {
1639 }
1640 void glLineWidth( GLfloat width )
1641 {
1642 }
1643 void glCallList( GLuint list )
1644 {
1645 }
1646 void glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )
1647 {
1648 }
1649 void glStencilFunc( GLenum func, GLint ref, GLuint mask )
1650 {
1651 }
1652 void glStencilOp( GLenum fail, GLenum zfail, GLenum zpass )
1653 {
1654 }
1655
1656 struct ptrstate vertex_array;
1657 struct ptrstate color_array;
1658 struct ptrstate texture_coord_array;
1659
1660 void glDrawElements( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices )
1661 {
1662 if( skipnanogl )
1663 {
1664 glEsImpl->glDrawElements( mode, count, type, indices );
1665 return;
1666 }
1667 // ensure that all primitives specified between glBegin/glEnd pairs
1668 // are rendered first, and that we have correct tmu in use..
1669 FlushOnStateChange( );
1670 // setup correct vertex/color/texcoord pointers
1671 if ( arraysValid ||
1672 tmuState0.vertex_array.changed ||
1673 tmuState0.color_array.changed ||
1674 tmuState0.texture_coord_array.changed || tmuState0.normal_array.changed )
1675 {
1676 glEsImpl->glClientActiveTexture( GL_TEXTURE0 );
1677 }
1678 if ( arraysValid || tmuState0.vertex_array.changed )
1679 {
1680 if ( tmuState0.vertex_array.enabled )
1681 {
1682 glEsImpl->glEnableClientState( GL_VERTEX_ARRAY );
1683 }
1684 else
1685 {
1686 glEsImpl->glDisableClientState( GL_VERTEX_ARRAY );
1687 }
1688 glEsImpl->glVertexPointer( tmuState0.vertex_array.size,
1689 tmuState0.vertex_array.type,
1690 tmuState0.vertex_array.stride,
1691 tmuState0.vertex_array.ptr );
1692 tmuState0.vertex_array.changed = GL_FALSE;
1693 }
1694 if ( arraysValid || tmuState0.color_array.changed )
1695 {
1696 if ( tmuState0.color_array.enabled )
1697 {
1698 glEsImpl->glEnableClientState( GL_COLOR_ARRAY );
1699 }
1700 else
1701 {
1702 glEsImpl->glDisableClientState( GL_COLOR_ARRAY );
1703 }
1704 glEsImpl->glColorPointer( tmuState0.color_array.size,
1705 tmuState0.color_array.type,
1706 tmuState0.color_array.stride,
1707 tmuState0.color_array.ptr );
1708 tmuState0.color_array.changed = GL_FALSE;
1709 }
1710 if ( arraysValid || tmuState0.normal_array.changed )
1711 {
1712 if ( tmuState0.normal_array.enabled )
1713 {
1714 glEsImpl->glEnableClientState( GL_NORMAL_ARRAY );
1715 }
1716 else
1717 {
1718 glEsImpl->glDisableClientState( GL_NORMAL_ARRAY );
1719 }
1720 glEsImpl->glNormalPointer( tmuState0.normal_array.type,
1721 tmuState0.normal_array.stride,
1722 tmuState0.normal_array.ptr );
1723 tmuState0.normal_array.changed = GL_FALSE;
1724 }
1725 if ( arraysValid || tmuState0.texture_coord_array.changed )
1726 {
1727 tmuState0.texture_coord_array.changed = GL_FALSE;
1728 if ( tmuState0.texture_coord_array.enabled )
1729 {
1730 glEsImpl->glEnableClientState( GL_TEXTURE_COORD_ARRAY );
1731 }
1732 else
1733 {
1734 glEsImpl->glDisableClientState( GL_TEXTURE_COORD_ARRAY );
1735 }
1736 glEsImpl->glTexCoordPointer( tmuState0.texture_coord_array.size,
1737 tmuState0.texture_coord_array.type,
1738 tmuState0.texture_coord_array.stride,
1739 tmuState0.texture_coord_array.ptr );
1740 }
1741
1742 if ( arraysValid || tmuState1.texture_coord_array.changed )
1743 {
1744 tmuState1.texture_coord_array.changed = GL_FALSE;
1745 glEsImpl->glClientActiveTexture( GL_TEXTURE1 );
1746 if ( tmuState1.texture_coord_array.enabled )
1747 {
1748 glEsImpl->glEnableClientState( GL_TEXTURE_COORD_ARRAY );
1749 }
1750 else
1751 {
1752 glEsImpl->glDisableClientState( GL_TEXTURE_COORD_ARRAY );
1753 }
1754 glEsImpl->glTexCoordPointer( tmuState1.texture_coord_array.size,
1755 tmuState1.texture_coord_array.type,
1756 tmuState1.texture_coord_array.stride,
1757 tmuState1.texture_coord_array.ptr );
1758 }
1759
1760 arraysValid = GL_FALSE;
1761 glEsImpl->glDrawElements( mode, count, type, indices );
1762 }
1763
1764 bool vboarray;
1765
1766 void glEnableClientState( GLenum array )
1767 {
1768 if( skipnanogl )
1769 {
1770 glEsImpl->glEnableClientState( array );
1771 if( array == GL_VERTEX_ARRAY )
1772 vboarray = true;
1773 return;
1774 }
1775 struct nanotmuState *clientstate = NULL;
1776 if ( clientactivetmu == GL_TEXTURE0 )
1777 {
1778 clientstate = &tmuState0;
1779 }
1780 else if ( clientactivetmu == GL_TEXTURE1 )
1781 {
1782 clientstate = &tmuState1;
1783 }
1784 else
1785 {
1786 return;
1787 }
1788 switch ( array )
1789 {
1790 case GL_VERTEX_ARRAY:
1791 if ( clientstate->vertex_array.enabled )
1792 {
1793 return;
1794 }
1795 clientstate->vertex_array.enabled = GL_TRUE;
1796 clientstate->vertex_array.changed = GL_TRUE;
1797 break;
1798 case GL_COLOR_ARRAY:
1799 if ( clientstate->color_array.enabled )
1800 {
1801 return;
1802 }
1803 clientstate->color_array.enabled = GL_TRUE;
1804 clientstate->color_array.changed = GL_TRUE;
1805
1806 break;
1807 case GL_NORMAL_ARRAY:
1808 if ( clientstate->normal_array.enabled )
1809 {
1810 return;
1811 }
1812 clientstate->normal_array.enabled = GL_TRUE;
1813 clientstate->normal_array.changed = GL_TRUE;
1814
1815 break;
1816 case GL_TEXTURE_COORD_ARRAY:
1817 if ( clientstate->texture_coord_array.enabled )
1818 {
1819 return;
1820 }
1821 clientstate->texture_coord_array.enabled = GL_TRUE;
1822 clientstate->texture_coord_array.changed = GL_TRUE;
1823 break;
1824 default:
1825 break;
1826 }
1827 }
1828 void glDisableClientState( GLenum array )
1829 {
1830 if( skipnanogl )
1831 {
1832 glEsImpl->glDisableClientState( array );
1833 if( array == GL_VERTEX_ARRAY )
1834 vboarray = false;
1835 return;
1836 }
1837 struct nanotmuState *clientstate = NULL;
1838 if ( clientactivetmu == GL_TEXTURE0 )
1839 {
1840 clientstate = &tmuState0;
1841 }
1842 else if ( clientactivetmu == GL_TEXTURE1 )
1843 {
1844 clientstate = &tmuState1;
1845 }
1846 else
1847 {
1848 return;
1849 }
1850 switch ( array )
1851 {
1852 case GL_VERTEX_ARRAY:
1853 if ( !clientstate->vertex_array.enabled )
1854 {
1855 return;
1856 }
1857 clientstate->vertex_array.enabled = GL_FALSE;
1858 clientstate->vertex_array.changed = GL_TRUE;
1859 break;
1860 case GL_COLOR_ARRAY:
1861 if ( !clientstate->color_array.enabled )
1862 {
1863 return;
1864 }
1865 clientstate->color_array.enabled = GL_FALSE;
1866 clientstate->color_array.changed = GL_TRUE;
1867
1868 break;
1869 case GL_NORMAL_ARRAY:
1870 if ( !clientstate->normal_array.enabled )
1871 {
1872 return;
1873 }
1874 clientstate->normal_array.enabled = GL_FALSE;
1875 clientstate->normal_array.changed = GL_TRUE;
1876
1877 break;
1878 case GL_TEXTURE_COORD_ARRAY:
1879 if ( !clientstate->texture_coord_array.enabled )
1880 {
1881 return;
1882 }
1883 clientstate->texture_coord_array.enabled = GL_FALSE;
1884 clientstate->texture_coord_array.changed = GL_TRUE;
1885 break;
1886 default:
1887 break;
1888 }
1889 }
1890 void glVertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
1891 {
1892
1893 if( skipnanogl )
1894 {
1895 glEsImpl->glVertexPointer( size, type, stride, pointer );
1896 return;
1897 }
1898 if ( tmuState0.vertex_array.size == size &&
1899 tmuState0.vertex_array.stride == stride &&
1900 tmuState0.vertex_array.type == type &&
1901 tmuState0.vertex_array.ptr == pointer )
1902 {
1903 return;
1904 }
1905 tmuState0.vertex_array.size = size;
1906 tmuState0.vertex_array.stride = stride;
1907 tmuState0.vertex_array.type = type;
1908 tmuState0.vertex_array.ptr = (GLvoid *)pointer;
1909 tmuState0.vertex_array.changed = GL_TRUE;
1910 }
1911 void glTexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
1912 {
1913 if( skipnanogl )
1914 {
1915 glEsImpl->glTexCoordPointer( size, type, stride, pointer );
1916 return;
1917 }
1918 struct nanotmuState *clientstate = NULL;
1919 if ( clientactivetmu == GL_TEXTURE0 )
1920 {
1921 clientstate = &tmuState0;
1922 }
1923 else if ( clientactivetmu == GL_TEXTURE1 )
1924 {
1925 clientstate = &tmuState1;
1926 }
1927 if ( clientstate->texture_coord_array.size == size &&
1928 clientstate->texture_coord_array.stride == stride &&
1929 clientstate->texture_coord_array.type == type &&
1930 clientstate->texture_coord_array.ptr == pointer )
1931 {
1932 return;
1933 }
1934 clientstate->texture_coord_array.size = size;
1935 clientstate->texture_coord_array.stride = stride;
1936 clientstate->texture_coord_array.type = type;
1937 clientstate->texture_coord_array.ptr = (GLvoid *)pointer;
1938 clientstate->texture_coord_array.changed = GL_TRUE;
1939 }
1940 void glColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
1941 {
1942 if ( tmuState0.color_array.size == size &&
1943 tmuState0.color_array.stride == stride &&
1944 tmuState0.color_array.type == type &&
1945 tmuState0.color_array.ptr == pointer )
1946 {
1947 return;
1948 }
1949 tmuState0.color_array.size = size;
1950 tmuState0.color_array.stride = stride;
1951 tmuState0.color_array.type = type;
1952 tmuState0.color_array.ptr = (GLvoid *)pointer;
1953 tmuState0.color_array.changed = GL_TRUE;
1954 }
1955
1956 void glNormalPointer( GLenum type, GLsizei stride, const GLvoid *pointer )
1957 {
1958 int size = 0;
1959 if ( tmuState0.normal_array.size == size &&
1960 tmuState0.normal_array.stride == stride &&
1961 tmuState0.normal_array.type == type &&
1962 tmuState0.normal_array.ptr == pointer )
1963 {
1964 return;
1965 }
1966 tmuState0.normal_array.size = size;
1967 tmuState0.normal_array.stride = stride;
1968 tmuState0.normal_array.type = type;
1969 tmuState0.normal_array.ptr = (GLvoid *)pointer;
1970 tmuState0.normal_array.changed = GL_TRUE;
1971 }
1972 void glPolygonOffset( GLfloat factor, GLfloat units )
1973 {
1974 FlushOnStateChange( );
1975 glEsImpl->glPolygonOffset( factor, units );
1976 }
1977 void glStencilMask( GLuint mask )
1978 {
1979 }
1980 void glClearStencil( GLint s )
1981 {
1982 }
1983
1984 #if defined( __MULTITEXTURE_SUPPORT__ )
1985
1986 extern "C" void glMultiTexCoord2fARB( GLenum target, GLfloat s, GLfloat t );
1987
1988 void glMultiTexCoord2fARB( GLenum target, GLfloat s, GLfloat t )
1989 {
1990 if ( target == GL_TEXTURE0 )
1991 {
1992 glTexCoord2f( s, t );
1993 }
1994 else
1995 {
1996 currentVertexAttrib.s_multi = s;
1997 currentVertexAttrib.t_multi = t;
1998 }
1999 }
2000 #endif
2001
2002 /* Vladimir */
2003 /*void glDrawArrays( GLenum mode, int first, int count)
2004 {
2005 FlushOnStateChange();
2006 glEsImpl->glDrawArrays(mode, first , count);
2007 }*/
2008 void glMultMatrixf( const GLfloat *m )
2009 {
2010 FlushOnStateChange( );
2011 glEsImpl->glMultMatrixf( m );
2012 }
2013
2014 void glPixelStorei( GLenum pname, GLint param )
2015 {
2016 FlushOnStateChange( );
2017 glEsImpl->glPixelStorei( pname, param );
2018 }
2019
2020 void glFogf( GLenum pname, GLfloat param )
2021 {
2022 FlushOnStateChange( );
2023 glEsImpl->glFogf( pname, param );
2024 }
2025
2026 void glFogfv( GLenum pname, const GLfloat *params )
2027 {
2028 FlushOnStateChange( );
2029 glEsImpl->glFogfv( pname, params );
2030 }
2031
2032 void glGetTexParameteriv( GLenum target, GLenum pname, GLint *params )
2033 {
2034 FlushOnStateChange( );
2035 glEsImpl->glGetTexParameteriv( target, pname, params );
2036 }
2037
2038 // This gives: called unimplemented OpenGL ES API (Android)
2039 void glTexParameteri( GLenum target, GLenum pname, GLint param )
2040 {
2041 if ( pname == GL_TEXTURE_BORDER_COLOR )
2042 {
2043 return; // not supported by opengl es
2044 }
2045 if ( ( pname == GL_TEXTURE_WRAP_S ||
2046 pname == GL_TEXTURE_WRAP_T ) &&
2047 param == GL_CLAMP )
2048 {
2049 param = 0x812F;
2050 }
2051
2052 FlushOnStateChange( );
2053 glEsImpl->glTexParameteri( target, pname, param );
2054 }
2055
2056 void glTexParameterx( GLenum target, GLenum pname, GLfixed param )
2057 {
2058 if ( pname == GL_TEXTURE_BORDER_COLOR )
2059 {
2060 return; // not supported by opengl es
2061 }
2062 if ( ( pname == GL_TEXTURE_WRAP_S ||
2063 pname == GL_TEXTURE_WRAP_T ) &&
2064 param == GL_CLAMP )
2065 {
2066 param = 0x812F;
2067 }
2068 FlushOnStateChange( );
2069 glEsImpl->glTexParameterx( target, pname, param );
2070 }
2071
2072 void glGenTextures( GLsizei n, GLuint *textures )
2073 {
2074 FlushOnStateChange( );
2075 glEsImpl->glGenTextures( n, textures );
2076 }
2077
2078 void glFrontFace( GLenum mode )
2079 {
2080 FlushOnStateChange( );
2081 glEsImpl->glFrontFace( mode );
2082 }
2083 // End Vladimir
2084
2085 void glTexEnvi( GLenum target, GLenum pname, GLint param )
2086 {
2087 if( skipnanogl )
2088 {
2089 glEsImpl->glTexEnvi( target, pname, param );
2090 return;
2091 }
2092 if ( target == GL_TEXTURE_ENV )
2093 {
2094 if ( pname == GL_TEXTURE_ENV_MODE )
2095 {
2096 if ( param == activetmuState->texture_env_mode.value )
2097 {
2098 return;
2099 }
2100 else
2101 {
2102 FlushOnStateChange( );
2103 glEsImpl->glTexEnvi( target, pname, param );
2104 activetmuState->texture_env_mode.value = param;
2105 return;
2106 }
2107 }
2108 }
2109 FlushOnStateChange( );
2110 glEsImpl->glTexEnvi( target, pname, param );
2111 }
2112
2113 #ifdef __MULTITEXTURE_SUPPORT__
2114 void glMultiTexCoord3fARB( GLenum a, GLfloat b, GLfloat c, GLfloat )
2115 {
2116 return glMultiTexCoord2fARB( a, b, c );
2117 }
2118
2119 void glMultiTexCoord2f( GLenum a, GLfloat b, GLfloat c )
2120 {
2121 glMultiTexCoord2fARB(a,b,c);
2122 }
2123 #endif
2124 void glDrawArrays( GLenum mode, GLint first, GLsizei count )
2125 {
2126 if( skipnanogl )
2127 {
2128 glEsImpl->glDrawArrays( mode, first, count );
2129 return;
2130 }
2131 // ensure that all primitives specified between glBegin/glEnd pairs
2132 // are rendered first, and that we have correct tmu in use..
2133 if ( mode == GL_QUADS )
2134 mode = GL_TRIANGLE_FAN;
2135 FlushOnStateChange( );
2136 // setup correct vertex/color/texcoord pointers
2137 if ( arraysValid ||
2138 tmuState0.vertex_array.changed ||
2139 tmuState0.color_array.changed ||
2140 tmuState0.texture_coord_array.changed || tmuState0.normal_array.changed )
2141 {
2142 glEsImpl->glClientActiveTexture( GL_TEXTURE0 );
2143 }
2144 if ( arraysValid || tmuState0.vertex_array.changed )
2145 {
2146 if ( tmuState0.vertex_array.enabled )
2147 {
2148 glEsImpl->glEnableClientState( GL_VERTEX_ARRAY );
2149 }
2150 else
2151 {
2152 glEsImpl->glDisableClientState( GL_VERTEX_ARRAY );
2153 }
2154 glEsImpl->glVertexPointer( tmuState0.vertex_array.size,
2155 tmuState0.vertex_array.type,
2156 tmuState0.vertex_array.stride,
2157 tmuState0.vertex_array.ptr );
2158 tmuState0.vertex_array.changed = GL_FALSE;
2159 }
2160 if ( arraysValid || tmuState0.color_array.changed )
2161 {
2162 if ( tmuState0.color_array.enabled )
2163 {
2164 glEsImpl->glEnableClientState( GL_COLOR_ARRAY );
2165 }
2166 else
2167 {
2168 glEsImpl->glDisableClientState( GL_COLOR_ARRAY );
2169 }
2170 glEsImpl->glColorPointer( tmuState0.color_array.size,
2171 tmuState0.color_array.type,
2172 tmuState0.color_array.stride,
2173 tmuState0.color_array.ptr );
2174 tmuState0.color_array.changed = GL_FALSE;
2175 }
2176 if ( arraysValid || tmuState0.normal_array.changed )
2177 {
2178 if ( tmuState0.normal_array.enabled )
2179 {
2180 glEsImpl->glEnableClientState( GL_NORMAL_ARRAY );
2181 }
2182 else
2183 {
2184 glEsImpl->glDisableClientState( GL_NORMAL_ARRAY );
2185 }
2186 glEsImpl->glNormalPointer( tmuState0.normal_array.type,
2187 tmuState0.normal_array.stride,
2188 tmuState0.normal_array.ptr );
2189 tmuState0.normal_array.changed = GL_FALSE;
2190 }
2191 if ( arraysValid || tmuState0.texture_coord_array.changed )
2192 {
2193 tmuState0.texture_coord_array.changed = GL_FALSE;
2194 if ( tmuState0.texture_coord_array.enabled )
2195 {
2196 glEsImpl->glEnableClientState( GL_TEXTURE_COORD_ARRAY );
2197 }
2198 else
2199 {
2200 glEsImpl->glDisableClientState( GL_TEXTURE_COORD_ARRAY );
2201 }
2202 glEsImpl->glTexCoordPointer( tmuState0.texture_coord_array.size,
2203 tmuState0.texture_coord_array.type,
2204 tmuState0.texture_coord_array.stride,
2205 tmuState0.texture_coord_array.ptr );
2206 }
2207
2208 if ( arraysValid || tmuState1.texture_coord_array.changed )
2209 {
2210 tmuState1.texture_coord_array.changed = GL_FALSE;
2211 glEsImpl->glClientActiveTexture( GL_TEXTURE1 );
2212 if ( tmuState1.texture_coord_array.enabled )
2213 {
2214 glEsImpl->glEnableClientState( GL_TEXTURE_COORD_ARRAY );
2215 }
2216 else
2217 {
2218 glEsImpl->glDisableClientState( GL_TEXTURE_COORD_ARRAY );
2219 }
2220 glEsImpl->glTexCoordPointer( tmuState1.texture_coord_array.size,
2221 tmuState1.texture_coord_array.type,
2222 tmuState1.texture_coord_array.stride,
2223 tmuState1.texture_coord_array.ptr );
2224 }
2225
2226 arraysValid = GL_FALSE;
2227 glEsImpl->glDrawArrays( mode, first, count );
2228 }
2229 /*void glNormalPointer(GLenum type, GLsizei stride, const void *ptr)
2230 {
2231 glEsImpl->glNormalPointer( type, stride, ptr );
2232 }*/
2233
2234 void glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
2235 {
2236 FlushOnStateChange( );
2237 glEsImpl->glCopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height );
2238 }
2239
2240 void glGenFramebuffers( GLsizei n, GLuint *framebuffers )
2241 {
2242 FlushOnStateChange( );
2243 glEsImpl->glGenFramebuffers( n, framebuffers );
2244 }
2245
2246 void glGenRenderbuffers( GLsizei n, GLuint *renderbuffers )
2247 {
2248 FlushOnStateChange( );
2249 glEsImpl->glGenRenderbuffers( n, renderbuffers );
2250 }
2251
2252 void glBindRenderbuffer( GLenum target, GLuint renderbuffer )
2253 {
2254 FlushOnStateChange( );
2255 glEsImpl->glBindRenderbuffer( target, renderbuffer );
2256 }
2257
2258 void glBindFramebuffer( GLenum target, GLuint framebuffer )
2259 {
2260 FlushOnStateChange( );
2261 glEsImpl->glBindFramebuffer( target, framebuffer );
2262 }
2263
2264 void glFramebufferRenderbuffer( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer )
2265 {
2266 FlushOnStateChange( );
2267 glEsImpl->glFramebufferRenderbuffer( target, attachment, renderbuffertarget, renderbuffer );
2268 }
2269
2270 void glDeleteFramebuffers( GLsizei n, const GLuint *framebuffers )
2271 {
2272 FlushOnStateChange( );
2273 glEsImpl->glDeleteFramebuffers( n, framebuffers );
2274 }
2275
2276 void glDeleteRenderbuffers( GLsizei n, const GLuint *renderbuffers )
2277 {
2278 FlushOnStateChange( );
2279 glEsImpl->glDeleteRenderbuffers( n, renderbuffers );
2280 }
2281 void glFramebufferTexture2D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
2282 {
2283 FlushOnStateChange( );
2284 glEsImpl->glFramebufferTexture2D( target, attachment, textarget, texture, level );
2285 }
2286
2287 void glRenderbufferStorage( GLenum target, GLenum internalformat, GLsizei width, GLsizei height )
2288 {
2289 FlushOnStateChange( );
2290 glEsImpl->glRenderbufferStorage( target, internalformat, width, height );
2291 }
2292
2293 void glBindBufferARB( GLuint target, GLuint index )
2294 {
2295 static int sindex;
2296
2297 if( index && !sindex && !skipnanogl )
2298 FlushOnStateChange();
2299 glEsImpl->glDisableClientState( GL_COLOR_ARRAY );
2300 glEsImpl->glColor4f( currentVertexAttrib.red/255.0f, currentVertexAttrib.green/255.0f,
2301 currentVertexAttrib.blue/255.0f, currentVertexAttrib.alpha/255.0f );
2302
2303 skipnanogl = (!!index) || vboarray;
2304 glEsImpl->glBindBuffer( target, index );
2305 if( sindex && !index )
2306 {
2307 arraysValid = GL_FALSE;
2308 }
2309 sindex = index;
2310 }
2311
2312 void glGenBuffersARB( GLuint count, GLuint *indexes )
2313 {
2314 glEsImpl->glGenBuffers( count, indexes );
2315 }
2316
2317 void glDeleteBuffersARB( GLuint count, GLuint *indexes )
2318 {
2319 glEsImpl->glDeleteBuffers( count, indexes );
2320 }
2321
2322 void glBufferDataARB( GLuint target, GLuint size, void *buffer, GLuint type )
2323 {
2324 glEsImpl->glBufferData( target, size, buffer, type );
2325 }
2326
2327 void glBufferSubDataARB( GLuint target, GLsizei offset, GLsizei size, void *buffer )
2328 {
2329 glEsImpl->glBufferSubData( target, offset, size, buffer );
2330 }
[FORK] nanogl for android version of Doom2D:Forever
[25/02/2024 19:55:35]
DEADSOFTWARE 2012-2024