DEADSOFTWARE

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