DEADSOFTWARE

GIT / REPO / FRED-BOY
Projects / nanogl.git / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Implement stencil funcs
[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 GLclampd depth_range_near;
71 GLclampd 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 if (!nanoglState.stencil_test)
793 {
794 nanoglState.stencil_test = GL_TRUE;
795 statechanged = GL_TRUE;
796 }
797 break;
798 }
799 case GL_TEXTURE_2D:
800 {
801 if ( !activetmuState->texture_2d.value )
802 {
803 FlushOnStateChange( );
804 glEsImpl->glEnable( cap );
805 activetmuState->texture_2d.value = GL_TRUE;
806 return;
807 }
808 break;
809 }
810 #if 0 // todo: implement cubemap texgen
811 case GL_TEXTURE_GEN_S:
812 case GL_TEXTURE_GEN_T:
813 case GL_TEXTURE_GEN_R:
814 case GL_TEXTURE_GEN_Q:
815 {
816 FlushOnStateChange( );
817 nanoglState.texgen = true;
818 return;
819 }
820 #endif
821 default:
822 break;
823 }
824
825 if ( statechanged )
826 {
827 FlushOnStateChange( );
828 glEsImpl->glEnable( cap );
829 }
830 }
831
832 void glDisable( GLenum cap )
833 {
834 if( skipnanogl )
835 {
836 glEsImpl->glDisable( cap );
837 return;
838 }
839 GLboolean statechanged = GL_FALSE;
840 switch ( cap )
841 {
842 case GL_ALPHA_TEST:
843 {
844 if ( nanoglState.alpha_test )
845 {
846 nanoglState.alpha_test = GL_FALSE;
847 statechanged = GL_TRUE;
848 }
849 break;
850 }
851 case GL_BLEND:
852 {
853 if ( nanoglState.blend )
854 {
855 nanoglState.blend = GL_FALSE;
856 statechanged = GL_TRUE;
857 }
858 break;
859 }
860 //case GL_CLIP_PLANEi
861 case GL_COLOR_LOGIC_OP:
862 {
863 if ( nanoglState.color_logic_op )
864 {
865 nanoglState.color_logic_op = GL_FALSE;
866 statechanged = GL_TRUE;
867 }
868 break;
869 }
870 case GL_COLOR_MATERIAL:
871 {
872 if ( nanoglState.color_material )
873 {
874 nanoglState.color_material = GL_FALSE;
875 statechanged = GL_TRUE;
876 }
877 break;
878 }
879 case GL_CULL_FACE:
880 {
881 if ( nanoglState.cull_face )
882 {
883 nanoglState.cull_face = GL_FALSE;
884 statechanged = GL_TRUE;
885 }
886 break;
887 }
888 case GL_DEPTH_TEST:
889 {
890 if ( nanoglState.depth_test )
891 {
892 nanoglState.depth_test = GL_FALSE;
893 statechanged = GL_TRUE;
894 }
895 break;
896 }
897 case GL_DITHER:
898 {
899 if ( nanoglState.dither )
900 {
901 nanoglState.dither = GL_FALSE;
902 statechanged = GL_TRUE;
903 }
904 break;
905 }
906 case GL_FOG:
907 {
908 if ( nanoglState.fog )
909 {
910 nanoglState.fog = GL_FALSE;
911 statechanged = GL_TRUE;
912 }
913 break;
914 }
915 case GL_LIGHT0:
916 {
917 if ( !nanoglState.light0 )
918 {
919 nanoglState.light0 = GL_FALSE;
920 statechanged = GL_TRUE;
921 }
922 break;
923 }
924 case GL_LIGHT1:
925 {
926 if ( !nanoglState.light1 )
927 {
928 nanoglState.light1 = GL_FALSE;
929 statechanged = GL_TRUE;
930 }
931 break;
932 }
933 case GL_LIGHT2:
934 {
935 if ( !nanoglState.light2 )
936 {
937 nanoglState.light2 = GL_FALSE;
938 statechanged = GL_TRUE;
939 }
940 break;
941 }
942 case GL_LIGHT3:
943 {
944 if ( !nanoglState.light3 )
945 {
946 nanoglState.light3 = GL_FALSE;
947 statechanged = GL_TRUE;
948 }
949 break;
950 }
951 case GL_LIGHT4:
952 {
953 if ( !nanoglState.light4 )
954 {
955 nanoglState.light4 = GL_FALSE;
956 statechanged = GL_TRUE;
957 }
958 break;
959 }
960 case GL_LIGHT5:
961 {
962 if ( !nanoglState.light5 )
963 {
964 nanoglState.light5 = GL_FALSE;
965 statechanged = GL_TRUE;
966 }
967 break;
968 }
969 case GL_LIGHT6:
970 {
971 if ( !nanoglState.light6 )
972 {
973 nanoglState.light6 = GL_FALSE;
974 statechanged = GL_TRUE;
975 }
976 break;
977 }
978 case GL_LIGHT7:
979 {
980 if ( !nanoglState.light7 )
981 {
982 nanoglState.light7 = GL_FALSE;
983 statechanged = GL_TRUE;
984 }
985 break;
986 }
987 case GL_LIGHTING:
988 {
989 if ( nanoglState.lighting )
990 {
991 nanoglState.lighting = GL_FALSE;
992 statechanged = GL_TRUE;
993 }
994 break;
995 }
996 case GL_LINE_SMOOTH:
997 {
998 if ( nanoglState.line_smooth )
999 {
1000 nanoglState.line_smooth = GL_FALSE;
1001 statechanged = GL_TRUE;
1002 }
1003 break;
1004 }
1005 /* case GL_MATRIX_PALETTE_OES:
1006 {
1007 if (nanoglState.matrix_palette_oes)
1008 {
1009 nanoglState.matrix_palette_oes = GL_FALSE;
1010 statechanged = GL_TRUE;
1011 }
1012 break;
1013 }*/
1014 case GL_MULTISAMPLE:
1015 {
1016 if ( nanoglState.multisample )
1017 {
1018 nanoglState.multisample = GL_FALSE;
1019 statechanged = GL_TRUE;
1020 }
1021 break;
1022 }
1023 case GL_NORMALIZE:
1024 {
1025 if ( nanoglState.normalize )
1026 {
1027 nanoglState.normalize = GL_FALSE;
1028 statechanged = GL_TRUE;
1029 }
1030 break;
1031 }
1032 /* case GL_POINT_SPRITE_OES:
1033 {
1034 if (nanoglState.point_sprite_oes)
1035 {
1036 nanoglState.point_sprite_oes = GL_FALSE;
1037 statechanged = GL_TRUE;
1038 }
1039 break;
1040 }*/
1041 case GL_POLYGON_OFFSET_FILL:
1042 {
1043 if ( nanoglState.polygon_offset_fill )
1044 {
1045 nanoglState.polygon_offset_fill = GL_FALSE;
1046 statechanged = GL_TRUE;
1047 }
1048 break;
1049 }
1050 case GL_RESCALE_NORMAL:
1051 {
1052 if ( nanoglState.rescale_normal )
1053 {
1054 nanoglState.rescale_normal = GL_FALSE;
1055 statechanged = GL_TRUE;
1056 }
1057 break;
1058 }
1059 case GL_SAMPLE_ALPHA_TO_COVERAGE:
1060 {
1061 if ( nanoglState.sample_alpha_to_coverage )
1062 {
1063 nanoglState.sample_alpha_to_coverage = GL_FALSE;
1064 statechanged = GL_TRUE;
1065 }
1066 break;
1067 }
1068 case GL_SAMPLE_ALPHA_TO_ONE:
1069 {
1070 if ( nanoglState.sample_alpha_to_one )
1071 {
1072 nanoglState.sample_alpha_to_one = GL_FALSE;
1073 statechanged = GL_TRUE;
1074 }
1075 break;
1076 }
1077 case GL_SAMPLE_COVERAGE:
1078 {
1079 if ( nanoglState.sample_coverage )
1080 {
1081 nanoglState.sample_coverage = GL_FALSE;
1082 statechanged = GL_TRUE;
1083 }
1084 break;
1085 }
1086 case GL_SCISSOR_TEST:
1087 {
1088 if ( nanoglState.scissor_test )
1089 {
1090 nanoglState.scissor_test = GL_FALSE;
1091 statechanged = GL_TRUE;
1092 }
1093 break;
1094 }
1095 case GL_STENCIL_TEST:
1096 {
1097 if (nanoglState.stencil_test)
1098 {
1099 nanoglState.stencil_test = GL_FALSE;
1100 statechanged = GL_TRUE;
1101 }
1102 break;
1103 }
1104 case GL_TEXTURE_2D:
1105 {
1106 if ( activetmuState->texture_2d.value )
1107 {
1108 FlushOnStateChange( );
1109 glEsImpl->glDisable( cap );
1110 activetmuState->texture_2d.value = GL_FALSE;
1111 return;
1112 }
1113 break;
1114 }
1115 #if 0
1116 case GL_TEXTURE_GEN_S:
1117 case GL_TEXTURE_GEN_T:
1118 case GL_TEXTURE_GEN_R:
1119 case GL_TEXTURE_GEN_Q:
1120 {
1121 FlushOnStateChange( );
1122 nanoglState.texgen = false;
1123 return;
1124 }
1125 #endif
1126 default:
1127 break;
1128 }
1129
1130 if ( statechanged )
1131 {
1132 FlushOnStateChange( );
1133 glEsImpl->glDisable( cap );
1134 }
1135 }
1136
1137 void glVertex2f( GLfloat x, GLfloat y )
1138 {
1139 glVertex3f( x, y, 0.0f );
1140 }
1141
1142 __FORCEINLINE unsigned int ClampTo255( float value )
1143 {
1144 unsigned int retval = (unsigned int)( value );
1145 if ( retval > 255 )
1146 {
1147 retval = 255;
1148 }
1149 return retval;
1150 }
1151
1152 void glColor3f( GLfloat red, GLfloat green, GLfloat blue )
1153 {
1154 currentVertexAttrib.red = (unsigned char)ClampTo255( red * 255.0f );
1155 currentVertexAttrib.green = (unsigned char)ClampTo255( green * 255.0f );
1156 currentVertexAttrib.blue = (unsigned char)ClampTo255( blue * 255.0f );
1157 currentVertexAttrib.alpha = 255;
1158 }
1159
1160 void glTexCoord2fv( const GLfloat *v )
1161 {
1162 memcpy( &currentVertexAttrib.s, v, 2 * sizeof( float ) );
1163 }
1164
1165 void glTexCoord2f( GLfloat s, GLfloat t )
1166 {
1167 currentVertexAttrib.s = s;
1168 currentVertexAttrib.t = t;
1169 }
1170
1171 void glViewport( GLint x, GLint y, GLsizei width, GLsizei height )
1172 {
1173 FlushOnStateChange( );
1174 glEsImpl->glViewport( x, y, width, height );
1175 }
1176
1177 void glLoadIdentity( void )
1178 {
1179 FlushOnStateChange( );
1180 glEsImpl->glLoadIdentity( );
1181 }
1182
1183 void glColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
1184 {
1185 currentVertexAttrib.red = (unsigned char)ClampTo255( red * 255.0f );
1186 currentVertexAttrib.green = (unsigned char)ClampTo255( green * 255.0f );
1187 currentVertexAttrib.blue = (unsigned char)ClampTo255( blue * 255.0f );
1188 currentVertexAttrib.alpha = (unsigned char)ClampTo255( alpha * 255.0f );
1189 }
1190
1191 void glOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar )
1192 {
1193 FlushOnStateChange( );
1194 #ifdef USE_CORE_PROFILE
1195 glEsImpl->glOrtho( left, right, bottom, top, zNear, zFar );
1196 #else
1197 glEsImpl->glOrthof( left, right, bottom, top, zNear, zFar );
1198 #endif
1199 }
1200
1201 // Rikku2000: Light
1202 void glLightf( GLenum light, GLenum pname, GLfloat param )
1203 {
1204 FlushOnStateChange( );
1205
1206 glEsImpl->glLightf( light, pname, param );
1207 }
1208 void glLightfv( GLenum light, GLenum pname, const GLfloat *params )
1209 {
1210 FlushOnStateChange( );
1211
1212 glEsImpl->glLightfv( light, pname, params );
1213 }
1214 void glLightModelf( GLenum pname, GLfloat param )
1215 {
1216 FlushOnStateChange( );
1217
1218 glEsImpl->glLightModelf( pname, param );
1219 }
1220 void glLightModelfv( GLenum pname, const GLfloat *params )
1221 {
1222 FlushOnStateChange( );
1223
1224 glEsImpl->glLightModelfv( pname, params );
1225 }
1226 void glMaterialf( GLenum face, GLenum pname, GLfloat param )
1227 {
1228 FlushOnStateChange( );
1229
1230 glEsImpl->glMaterialf( face, pname, param );
1231 }
1232 void glMaterialfv( GLenum face, GLenum pname, const GLfloat *params )
1233 {
1234 FlushOnStateChange( );
1235
1236 glEsImpl->glMaterialfv( face, pname, params );
1237 }
1238 void glColorMaterial( GLenum face, GLenum mode )
1239 {
1240 FlushOnStateChange( );
1241
1242 glEsImpl->glColorMaterial( face, mode );
1243 }
1244
1245 void glMatrixMode( GLenum mode )
1246 {
1247 if ( nanoglState.matrixmode == mode )
1248 {
1249 return;
1250 }
1251 nanoglState.matrixmode = mode;
1252 FlushOnStateChange( );
1253 glEsImpl->glMatrixMode( mode );
1254 }
1255
1256 void glTexParameterf( GLenum target, GLenum pname, GLfloat param )
1257 {
1258 if ( pname == GL_TEXTURE_BORDER_COLOR )
1259 {
1260 return; // not supported by opengl es
1261 }
1262 if ( ( pname == GL_TEXTURE_WRAP_S ||
1263 pname == GL_TEXTURE_WRAP_T ) &&
1264 param == GL_CLAMP )
1265 {
1266 param = 0x812F;
1267 }
1268
1269 FlushOnStateChange( );
1270 glEsImpl->glTexParameterf( target, pname, param );
1271 }
1272
1273 void glTexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
1274 {
1275 glTexParameterf( target, pname, params[0] );
1276 }
1277
1278 void glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels )
1279 {
1280 unsigned char *data = (unsigned char*)pixels;
1281
1282 if( pixels && internalformat == GL_RGB && format == GL_RGBA ) // strip alpha from texture
1283 {
1284 unsigned char *in = data, *out;
1285 int i = 0, size = width * height * 4;
1286
1287 data = out = (unsigned char*)malloc( size );
1288
1289 for( i = 0; i < size; i += 4, in += 4, out += 4 )
1290 {
1291 memcpy( out, in, 3 );
1292 out[3] = 255;
1293 }
1294 }
1295
1296 internalformat = format;
1297 glEsImpl->glTexImage2D( target, level, internalformat, width, height, border, format, type, data );
1298
1299 if( data != pixels )
1300 free(data);
1301 }
1302
1303 void glDrawBuffer( GLenum /*mode*/ )
1304 {
1305 }
1306
1307 void glTranslatef( GLfloat x, GLfloat y, GLfloat z )
1308 {
1309 FlushOnStateChange( );
1310 glEsImpl->glTranslatef( x, y, z );
1311 }
1312
1313 void glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
1314 {
1315 FlushOnStateChange( );
1316 glEsImpl->glRotatef( angle, x, y, z );
1317 }
1318
1319 void glScalef( GLfloat x, GLfloat y, GLfloat z )
1320 {
1321 FlushOnStateChange( );
1322 glEsImpl->glScalef( x, y, z );
1323 }
1324
1325 void glDepthRange( GLclampd zNear, GLclampd zFar )
1326 {
1327 if ( ( nanoglState.depth_range_near == zNear ) && ( nanoglState.depth_range_far == zFar ) )
1328 {
1329 return;
1330 }
1331 else
1332 {
1333 nanoglState.depth_range_near = zNear;
1334 nanoglState.depth_range_far = zFar;
1335 }
1336 FlushOnStateChange( );
1337 #ifdef USE_CORE_PROFILE
1338 glEsImpl->glDepthRange( zNear, zFar );
1339 #else
1340 glEsImpl->glDepthRangef( zNear, zFar );
1341 #endif
1342 }
1343
1344 void glDepthFunc( GLenum func )
1345 {
1346 if ( nanoglState.depth_func == func )
1347 {
1348 return;
1349 }
1350 else
1351 {
1352 nanoglState.depth_func = func;
1353 }
1354 FlushOnStateChange( );
1355 glEsImpl->glDepthFunc( func );
1356 }
1357
1358 void glFinish( void )
1359 {
1360 FlushOnStateChange( );
1361 glEsImpl->glFinish( );
1362 }
1363
1364 void glGetFloatv( GLenum pname, GLfloat *params )
1365 {
1366 FlushOnStateChange( );
1367 glEsImpl->glGetFloatv( pname, params );
1368 }
1369
1370 void glCullFace( GLenum mode )
1371 {
1372 if ( nanoglState.cullface == mode )
1373 {
1374 return;
1375 }
1376 else
1377 {
1378 nanoglState.cullface = mode;
1379 }
1380 FlushOnStateChange( );
1381 glEsImpl->glCullFace( mode );
1382 }
1383
1384 void glFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar )
1385 {
1386 FlushOnStateChange( );
1387 glEsImpl->glFrustumf( left, right, bottom, top, zNear, zFar );
1388 }
1389
1390 void glClear( GLbitfield mask )
1391 {
1392 FlushOnStateChange( );
1393 glEsImpl->glClear( mask );
1394 }
1395
1396 void glVertex3f( GLfloat x, GLfloat y, GLfloat z )
1397 {
1398 GLfloat *vert = (GLfloat *)ptrVertexAttribArray++;
1399 *vert++ = x;
1400 *vert++ = y;
1401 *vert++ = z;
1402 #if defined( __MULTITEXTURE_SUPPORT__ )
1403 memcpy( vert, &currentVertexAttrib.red, 5 * sizeof( GLfloat ) );
1404 #else
1405 memcpy( vert + 1, &currentVertexAttrib.red, 3 * sizeof( GLfloat ) );
1406 #endif
1407 }
1408
1409 void glColor4fv( const GLfloat *v )
1410 {
1411 currentVertexAttrib.red = (unsigned char)ClampTo255( v[0] * 255.0f );
1412 currentVertexAttrib.green = (unsigned char)ClampTo255( v[1] * 255.0f );
1413 currentVertexAttrib.blue = (unsigned char)ClampTo255( v[2] * 255.0f );
1414 currentVertexAttrib.alpha = (unsigned char)ClampTo255( v[3] * 255.0f );
1415 if( skipnanogl )
1416 glEsImpl->glColor4f( currentVertexAttrib.red/255.0f, currentVertexAttrib.green/255.0f,
1417 currentVertexAttrib.blue/255.0f, currentVertexAttrib.alpha/255.0f );
1418 }
1419
1420 void glColor3ubv( const GLubyte *v )
1421 {
1422 currentVertexAttrib.red = v[0];
1423 currentVertexAttrib.green = v[1];
1424 currentVertexAttrib.blue = v[2];
1425 currentVertexAttrib.alpha = 255;
1426 if( skipnanogl )
1427 glEsImpl->glColor4f( currentVertexAttrib.red/255.0f, currentVertexAttrib.green/255.0f,
1428 currentVertexAttrib.blue/255.0f, currentVertexAttrib.alpha/255.0f );
1429 }
1430
1431 void glColor4ubv( const GLubyte *v )
1432 {
1433 //*((unsigned int*)(&currentVertexAttrib.red)) = *((unsigned int*)(v));
1434 currentVertexAttrib.red = v[0];
1435 currentVertexAttrib.green = v[1];
1436 currentVertexAttrib.blue = v[2];
1437 currentVertexAttrib.alpha = v[3];
1438 if( skipnanogl )
1439 glEsImpl->glColor4f( currentVertexAttrib.red/255.0f, currentVertexAttrib.green/255.0f,
1440 currentVertexAttrib.blue/255.0f, currentVertexAttrib.alpha/255.0f );
1441 }
1442
1443 void glColor3fv( const GLfloat *v )
1444 {
1445 currentVertexAttrib.red = (unsigned char)ClampTo255( v[0] * 255.0f );
1446 currentVertexAttrib.green = (unsigned char)ClampTo255( v[1] * 255.0f );
1447 currentVertexAttrib.blue = (unsigned char)ClampTo255( v[2] * 255.0f );
1448 currentVertexAttrib.alpha = 255;
1449 if( skipnanogl )
1450 glEsImpl->glColor4f( currentVertexAttrib.red/255.0f, currentVertexAttrib.green/255.0f,
1451 currentVertexAttrib.blue/255.0f, currentVertexAttrib.alpha/255.0f );
1452 }
1453
1454 //-- nicknekit: xash3d funcs --
1455
1456 void glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
1457 {
1458 currentVertexAttrib.red = red;
1459 currentVertexAttrib.green = green;
1460 currentVertexAttrib.blue = blue;
1461 currentVertexAttrib.alpha = alpha;
1462 if( skipnanogl )
1463 glEsImpl->glColor4f( currentVertexAttrib.red/255.0f, currentVertexAttrib.green/255.0f,
1464 currentVertexAttrib.blue/255.0f, currentVertexAttrib.alpha/255.0f );
1465 }
1466
1467 void glColor3ub( GLubyte red, GLubyte green, GLubyte blue )
1468 {
1469 currentVertexAttrib.red = red;
1470 currentVertexAttrib.green = green;
1471 currentVertexAttrib.blue = blue;
1472 currentVertexAttrib.alpha = 255;
1473 if( skipnanogl )
1474 glEsImpl->glColor4f( currentVertexAttrib.red/255.0f, currentVertexAttrib.green/255.0f,
1475 currentVertexAttrib.blue/255.0f, currentVertexAttrib.alpha/255.0f );
1476 }
1477
1478 void glNormal3fv( const GLfloat *v )
1479 {
1480 FlushOnStateChange( );
1481 glEsImpl->glNormal3f( v[0], v[1], v[2] );
1482 }
1483
1484 void glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
1485 {
1486 FlushOnStateChange( );
1487 glEsImpl->glCopyTexImage2D( target, level, internalformat, x, y, width, height, border );
1488 }
1489
1490 void glTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels )
1491 {
1492 glTexImage2D( GL_TEXTURE_2D, level, internalformat, width, 1, border, format, type, pixels );
1493 }
1494
1495 void glTexImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels )
1496 {
1497 glTexImage2D( GL_TEXTURE_2D, level, internalformat, width, height, border, format, type, pixels );
1498 }
1499
1500 void glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels )
1501 {
1502 glTexSubImage2D( target, level, xoffset, 0, width, 1, format, type, pixels );
1503 }
1504
1505 void glTexSubImage3D( GLenum target, GLint level,
1506 GLint xoffset, GLint yoffset,
1507 GLint zoffset, GLsizei width,
1508 GLsizei height, GLsizei depth,
1509 GLenum format,
1510 GLenum type, const GLvoid *pixels )
1511 {
1512 glTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels );
1513 }
1514
1515 GLboolean glIsTexture( GLuint texture )
1516 {
1517 FlushOnStateChange( );
1518 return glEsImpl->glIsTexture( texture );
1519 }
1520
1521 // TODO: add native normal/reflection map texgen support
1522
1523 void glTexGeni( GLenum coord, GLenum pname, GLint param )
1524 {
1525 FlushOnStateChange();
1526 //glEsImpl->glTexGeniOES( coord, pname, param );
1527 }
1528
1529 void glTexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
1530 {
1531 FlushOnStateChange();
1532 //glEsImpl->glTexGenfvOES( coord, pname, params );
1533 }
1534
1535 //-- --//
1536
1537 void glHint( GLenum target, GLenum mode )
1538 {
1539 FlushOnStateChange( );
1540 glEsImpl->glHint( target, mode );
1541 }
1542
1543 void glBlendFunc( GLenum sfactor, GLenum dfactor )
1544 {
1545 if( skipnanogl )
1546 {
1547 glEsImpl->glBlendFunc( sfactor, dfactor );
1548 return;
1549 }
1550 if ( ( nanoglState.sfactor == sfactor ) && ( nanoglState.dfactor == dfactor ) )
1551 {
1552 return;
1553 }
1554
1555 nanoglState.sfactor = sfactor;
1556 nanoglState.dfactor = dfactor;
1557 FlushOnStateChange( );
1558 glEsImpl->glBlendFunc( sfactor, dfactor );
1559 }
1560
1561 void glPopMatrix( void )
1562 {
1563 FlushOnStateChange( );
1564 glEsImpl->glPopMatrix( );
1565 }
1566
1567 void glShadeModel( GLenum mode )
1568 {
1569 if ( nanoglState.shademodel == mode )
1570 {
1571 return;
1572 }
1573 nanoglState.shademodel = mode;
1574 FlushOnStateChange( );
1575 glEsImpl->glShadeModel( mode );
1576 }
1577
1578 void glPushMatrix( void )
1579 {
1580 FlushOnStateChange( );
1581 glEsImpl->glPushMatrix( );
1582 }
1583
1584 void glTexEnvf( GLenum target, GLenum pname, GLfloat param )
1585 {
1586 if( skipnanogl )
1587 {
1588 glEsImpl->glTexEnvf( target, pname, param );
1589 return;
1590 }
1591 if ( target == GL_TEXTURE_ENV )
1592 {
1593 if ( pname == GL_TEXTURE_ENV_MODE )
1594 {
1595 if ( param == activetmuState->texture_env_mode.value )
1596 {
1597 return;
1598 }
1599 else
1600 {
1601 FlushOnStateChange( );
1602 glEsImpl->glTexEnvf( target, pname, param );
1603 activetmuState->texture_env_mode.value = param;
1604 return;
1605 }
1606 }
1607 }
1608 FlushOnStateChange( );
1609 glEsImpl->glTexEnvf( target, pname, param );
1610 }
1611
1612 void glVertex3fv( const GLfloat *v )
1613 {
1614 GLfloat *vert = (GLfloat *)ptrVertexAttribArray++;
1615 memcpy( vert, v, 3 * sizeof( GLfloat ) );
1616 #if defined( __MULTITEXTURE_SUPPORT__ )
1617 memcpy( vert + 3, &currentVertexAttrib.red, 5 * sizeof( GLfloat ) );
1618 #else
1619 memcpy( vert + 4, &currentVertexAttrib.red, 3 * sizeof( GLfloat ) );
1620 #endif
1621 }
1622
1623 void glDepthMask( GLboolean flag )
1624 {
1625 if( !skipnanogl )
1626 {
1627 if ( nanoglState.depthmask == flag )
1628 {
1629 return;
1630 }
1631 nanoglState.depthmask = flag;
1632 FlushOnStateChange( );
1633 }
1634 glEsImpl->glDepthMask( flag );
1635 }
1636
1637 void glBindTexture( GLenum target, GLuint texture )
1638 {
1639 if( skipnanogl )
1640 {
1641 glEsImpl->glBindTexture( target,texture );
1642 return;
1643 }
1644 if ( activetmuState->boundtexture.value == texture )
1645 {
1646 return;
1647 }
1648 FlushOnStateChange( );
1649 activetmuState->boundtexture.value = texture;
1650 glEsImpl->glBindTexture( target, texture );
1651 }
1652
1653 void glGetIntegerv( GLenum pname, GLint *params )
1654 {
1655 FlushOnStateChange( );
1656 glEsImpl->glGetIntegerv( pname, params );
1657 }
1658
1659 GLubyte nano_extensions_string[4096];
1660 const GLubyte *glGetString( GLenum name )
1661 {
1662
1663 if ( name == GL_EXTENSIONS )
1664 {
1665 #if defined( __MULTITEXTURE_SUPPORT__ )
1666 sprintf( (char *)nano_extensions_string, "%s %s", glEsImpl->glGetString( name ), "GL_ARB_multitexture EXT_texture_env_add" );
1667 #else
1668 sprintf( (char *)nano_extensions_string, "%s %s", glEsImpl->glGetString( name ), "EXT_texture_env_add" );
1669 #endif
1670 return nano_extensions_string;
1671 }
1672 return glEsImpl->glGetString( name );
1673 }
1674
1675 void glAlphaFunc( GLenum func, GLclampf ref )
1676 {
1677 FlushOnStateChange( );
1678 glEsImpl->glAlphaFunc( func, ref );
1679 }
1680
1681 void glFlush( void )
1682 {
1683 FlushOnStateChange( );
1684 glEsImpl->glFlush( );
1685 }
1686
1687 void glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels )
1688 {
1689 if ( format == GL_DEPTH_COMPONENT )
1690 {
1691 // OpenglEs 1.1 does not support reading depth buffer without an extension
1692 memset( pixels, 0xff, 4 );
1693 return;
1694 }
1695 FlushOnStateChange( );
1696 glEsImpl->glReadPixels( x, y, width, height, format, type, pixels );
1697 }
1698
1699 void glReadBuffer( GLenum /*mode*/ )
1700 {
1701 }
1702
1703 void glLoadMatrixf( const GLfloat *m )
1704 {
1705 FlushOnStateChange( );
1706 glEsImpl->glLoadMatrixf( m );
1707 }
1708
1709 void glTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels )
1710 {
1711 FlushOnStateChange( );
1712 glEsImpl->glTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels );
1713 }
1714
1715 void glClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
1716 {
1717 FlushOnStateChange( );
1718 glEsImpl->glClearColor( red, green, blue, alpha );
1719 }
1720
1721 GLenum glGetError( void )
1722 {
1723 //FlushOnStateChange();
1724 return GL_NO_ERROR; //glEsImpl->glGetError();
1725 }
1726
1727 void glActiveTexture( GLenum texture )
1728 {
1729 if( skipnanogl )
1730 {
1731 glEsImpl->glActiveTexture( texture );
1732 return;
1733 }
1734 if ( activetmu == texture )
1735 {
1736 return;
1737 }
1738 if ( delayedttmuchange )
1739 {
1740 delayedttmuchange = GL_FALSE;
1741 }
1742 else
1743 {
1744 delayedttmuchange = GL_TRUE;
1745 delayedtmutarget = texture;
1746 }
1747 if ( texture == GL_TEXTURE0 )
1748 {
1749 activetmuState = &tmuState0;
1750 }
1751 else
1752 {
1753 activetmuState = &tmuState1;
1754 }
1755 activetmu = texture;
1756 }
1757
1758 void glActiveTextureARB( GLenum texture )
1759 {
1760 if( skipnanogl )
1761 {
1762 glEsImpl->glActiveTexture( texture );
1763 return;
1764 }
1765 if ( activetmu == texture )
1766 {
1767 return;
1768 }
1769 if ( delayedttmuchange )
1770 {
1771 delayedttmuchange = GL_FALSE;
1772 }
1773 else
1774 {
1775 delayedttmuchange = GL_TRUE;
1776 delayedtmutarget = texture;
1777 }
1778 if ( texture == GL_TEXTURE0 )
1779 {
1780 activetmuState = &tmuState0;
1781 }
1782 else
1783 {
1784 activetmuState = &tmuState1;
1785 }
1786 activetmu = texture;
1787 }
1788
1789 void glClientActiveTexture( GLenum texture )
1790 {
1791 if( skipnanogl )
1792 {
1793 glEsImpl->glClientActiveTexture( texture );
1794 return;
1795 }
1796 clientactivetmu = texture;
1797 }
1798 void glClientActiveTextureARB( GLenum texture )
1799 {
1800 if( skipnanogl )
1801 {
1802 glEsImpl->glClientActiveTexture( texture );
1803 return;
1804 }
1805 clientactivetmu = texture;
1806 }
1807
1808
1809 void glPolygonMode( GLenum face, GLenum mode )
1810 {
1811 }
1812
1813 void glDeleteTextures( GLsizei n, const GLuint *textures )
1814 {
1815 FlushOnStateChange( );
1816 glEsImpl->glDeleteTextures( n, textures );
1817 }
1818
1819 void glClearDepth( GLclampd depth )
1820 {
1821 FlushOnStateChange( );
1822 glEsImpl->glClearDepthf( depth );
1823 }
1824
1825 void glClipPlane( GLenum plane, const GLdouble *equation )
1826 {
1827 FlushOnStateChange( );
1828 float array[4];
1829 array[0] = ( GLfloat )( equation[0] );
1830 array[1] = ( GLfloat )( equation[1] );
1831 array[2] = ( GLfloat )( equation[2] );
1832 array[3] = ( GLfloat )( equation[3] );
1833 glEsImpl->glClipPlanef( plane, array );
1834 }
1835
1836 void glScissor( GLint x, GLint y, GLsizei width, GLsizei height )
1837 {
1838 FlushOnStateChange( );
1839 glEsImpl->glScissor( x, y, width, height );
1840 }
1841
1842 void glPointSize( GLfloat size )
1843 {
1844 FlushOnStateChange( );
1845 glEsImpl->glPointSize( size );
1846 }
1847
1848 void glArrayElement( GLint i )
1849 {
1850 }
1851 void glLineWidth( GLfloat width )
1852 {
1853 }
1854 void glCallList( GLuint list )
1855 {
1856 }
1857 void glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )
1858 {
1859 FlushOnStateChange( );
1860 glEsImpl->glColorMask( red, green, blue, alpha );
1861 }
1862 void glStencilFunc( GLenum func, GLint ref, GLuint mask )
1863 {
1864 FlushOnStateChange( );
1865 glEsImpl->glStencilFunc( func, ref, mask );
1866 }
1867 void glStencilOp( GLenum fail, GLenum zfail, GLenum zpass )
1868 {
1869 FlushOnStateChange( );
1870 glEsImpl->glStencilOp( fail, zfail, zpass );
1871 }
1872
1873 struct ptrstate vertex_array;
1874 struct ptrstate color_array;
1875 struct ptrstate texture_coord_array;
1876
1877 void glDrawElements( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices )
1878 {
1879 if( skipnanogl )
1880 {
1881 glEsImpl->glDrawElements( mode, count, type, indices );
1882 return;
1883 }
1884 // ensure that all primitives specified between glBegin/glEnd pairs
1885 // are rendered first, and that we have correct tmu in use..
1886 FlushOnStateChange( );
1887 // setup correct vertex/color/texcoord pointers
1888 if ( arraysValid ||
1889 tmuState0.vertex_array.changed ||
1890 tmuState0.color_array.changed ||
1891 tmuState0.texture_coord_array.changed || tmuState0.normal_array.changed )
1892 {
1893 glEsImpl->glClientActiveTexture( GL_TEXTURE0 );
1894 }
1895 if ( arraysValid || tmuState0.vertex_array.changed )
1896 {
1897 if ( tmuState0.vertex_array.enabled )
1898 {
1899 glEsImpl->glEnableClientState( GL_VERTEX_ARRAY );
1900 }
1901 else
1902 {
1903 glEsImpl->glDisableClientState( GL_VERTEX_ARRAY );
1904 }
1905 glEsImpl->glVertexPointer( tmuState0.vertex_array.size,
1906 tmuState0.vertex_array.type,
1907 tmuState0.vertex_array.stride,
1908 tmuState0.vertex_array.ptr );
1909 tmuState0.vertex_array.changed = GL_FALSE;
1910 }
1911 if ( arraysValid || tmuState0.color_array.changed )
1912 {
1913 if ( tmuState0.color_array.enabled )
1914 {
1915 glEsImpl->glEnableClientState( GL_COLOR_ARRAY );
1916 }
1917 else
1918 {
1919 glEsImpl->glDisableClientState( GL_COLOR_ARRAY );
1920 glEsImpl->glColor4f( currentVertexAttrib.red/255.0f, currentVertexAttrib.green/255.0f,
1921 currentVertexAttrib.blue/255.0f, currentVertexAttrib.alpha/255.0f );
1922
1923 }
1924 glEsImpl->glColorPointer( tmuState0.color_array.size,
1925 tmuState0.color_array.type,
1926 tmuState0.color_array.stride,
1927 tmuState0.color_array.ptr );
1928 tmuState0.color_array.changed = GL_FALSE;
1929 }
1930 if ( arraysValid || tmuState0.normal_array.changed )
1931 {
1932 if ( tmuState0.normal_array.enabled )
1933 {
1934 glEsImpl->glEnableClientState( GL_NORMAL_ARRAY );
1935 }
1936 else
1937 {
1938 glEsImpl->glDisableClientState( GL_NORMAL_ARRAY );
1939 }
1940 glEsImpl->glNormalPointer( tmuState0.normal_array.type,
1941 tmuState0.normal_array.stride,
1942 tmuState0.normal_array.ptr );
1943 tmuState0.normal_array.changed = GL_FALSE;
1944 }
1945 if ( arraysValid || tmuState0.texture_coord_array.changed )
1946 {
1947 tmuState0.texture_coord_array.changed = GL_FALSE;
1948 if ( tmuState0.texture_coord_array.enabled )
1949 {
1950 glEsImpl->glEnableClientState( GL_TEXTURE_COORD_ARRAY );
1951 }
1952 else
1953 {
1954 glEsImpl->glDisableClientState( GL_TEXTURE_COORD_ARRAY );
1955 }
1956 glEsImpl->glTexCoordPointer( tmuState0.texture_coord_array.size,
1957 tmuState0.texture_coord_array.type,
1958 tmuState0.texture_coord_array.stride,
1959 tmuState0.texture_coord_array.ptr );
1960 }
1961
1962 if ( arraysValid || tmuState1.texture_coord_array.changed )
1963 {
1964 tmuState1.texture_coord_array.changed = GL_FALSE;
1965 glEsImpl->glClientActiveTexture( GL_TEXTURE1 );
1966 if ( tmuState1.texture_coord_array.enabled )
1967 {
1968 glEsImpl->glEnableClientState( GL_TEXTURE_COORD_ARRAY );
1969 }
1970 else
1971 {
1972 glEsImpl->glDisableClientState( GL_TEXTURE_COORD_ARRAY );
1973 }
1974 glEsImpl->glTexCoordPointer( tmuState1.texture_coord_array.size,
1975 tmuState1.texture_coord_array.type,
1976 tmuState1.texture_coord_array.stride,
1977 tmuState1.texture_coord_array.ptr );
1978 }
1979
1980 arraysValid = GL_FALSE;
1981 glEsImpl->glDrawElements( mode, count, type, indices );
1982 }
1983
1984 bool vboarray;
1985
1986 void glEnableClientState( GLenum array )
1987 {
1988 if( skipnanogl )
1989 {
1990 glEsImpl->glEnableClientState( array );
1991 if( array == GL_VERTEX_ARRAY )
1992 vboarray = true;
1993 return;
1994 }
1995 struct nanotmuState *clientstate = NULL;
1996 if ( clientactivetmu == GL_TEXTURE0 )
1997 {
1998 clientstate = &tmuState0;
1999 }
2000 else if ( clientactivetmu == GL_TEXTURE1 )
2001 {
2002 clientstate = &tmuState1;
2003 }
2004 else
2005 {
2006 return;
2007 }
2008 switch ( array )
2009 {
2010 case GL_VERTEX_ARRAY:
2011 if ( clientstate->vertex_array.enabled )
2012 {
2013 return;
2014 }
2015 clientstate->vertex_array.enabled = GL_TRUE;
2016 clientstate->vertex_array.changed = GL_TRUE;
2017 break;
2018 case GL_COLOR_ARRAY:
2019 if ( clientstate->color_array.enabled )
2020 {
2021 return;
2022 }
2023 clientstate->color_array.enabled = GL_TRUE;
2024 clientstate->color_array.changed = GL_TRUE;
2025
2026 break;
2027 case GL_NORMAL_ARRAY:
2028 if ( clientstate->normal_array.enabled )
2029 {
2030 return;
2031 }
2032 clientstate->normal_array.enabled = GL_TRUE;
2033 clientstate->normal_array.changed = GL_TRUE;
2034
2035 break;
2036 case GL_TEXTURE_COORD_ARRAY:
2037 if ( clientstate->texture_coord_array.enabled )
2038 {
2039 return;
2040 }
2041 clientstate->texture_coord_array.enabled = GL_TRUE;
2042 clientstate->texture_coord_array.changed = GL_TRUE;
2043 break;
2044 default:
2045 break;
2046 }
2047 }
2048 void glDisableClientState( GLenum array )
2049 {
2050 if( skipnanogl )
2051 {
2052 glEsImpl->glDisableClientState( array );
2053 if( array == GL_VERTEX_ARRAY )
2054 vboarray = false;
2055 return;
2056 }
2057 struct nanotmuState *clientstate = NULL;
2058 if ( clientactivetmu == GL_TEXTURE0 )
2059 {
2060 clientstate = &tmuState0;
2061 }
2062 else if ( clientactivetmu == GL_TEXTURE1 )
2063 {
2064 clientstate = &tmuState1;
2065 }
2066 else
2067 {
2068 return;
2069 }
2070 switch ( array )
2071 {
2072 case GL_VERTEX_ARRAY:
2073 if ( !clientstate->vertex_array.enabled )
2074 {
2075 return;
2076 }
2077 clientstate->vertex_array.enabled = GL_FALSE;
2078 clientstate->vertex_array.changed = GL_TRUE;
2079 break;
2080 case GL_COLOR_ARRAY:
2081 if ( !clientstate->color_array.enabled )
2082 {
2083 return;
2084 }
2085 clientstate->color_array.enabled = GL_FALSE;
2086 clientstate->color_array.changed = GL_TRUE;
2087
2088 break;
2089 case GL_NORMAL_ARRAY:
2090 if ( !clientstate->normal_array.enabled )
2091 {
2092 return;
2093 }
2094 clientstate->normal_array.enabled = GL_FALSE;
2095 clientstate->normal_array.changed = GL_TRUE;
2096
2097 break;
2098 case GL_TEXTURE_COORD_ARRAY:
2099 if ( !clientstate->texture_coord_array.enabled )
2100 {
2101 return;
2102 }
2103 clientstate->texture_coord_array.enabled = GL_FALSE;
2104 clientstate->texture_coord_array.changed = GL_TRUE;
2105 break;
2106 default:
2107 break;
2108 }
2109 }
2110 void glVertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
2111 {
2112
2113 if( skipnanogl )
2114 {
2115 glEsImpl->glVertexPointer( size, type, stride, pointer );
2116 return;
2117 }
2118 if ( tmuState0.vertex_array.size == size &&
2119 tmuState0.vertex_array.stride == stride &&
2120 tmuState0.vertex_array.type == type &&
2121 tmuState0.vertex_array.ptr == pointer )
2122 {
2123 return;
2124 }
2125 tmuState0.vertex_array.size = size;
2126 tmuState0.vertex_array.stride = stride;
2127 tmuState0.vertex_array.type = type;
2128 tmuState0.vertex_array.ptr = (GLvoid *)pointer;
2129 tmuState0.vertex_array.changed = GL_TRUE;
2130 }
2131 void glTexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
2132 {
2133 if( skipnanogl )
2134 {
2135 glEsImpl->glTexCoordPointer( size, type, stride, pointer );
2136 return;
2137 }
2138 struct nanotmuState *clientstate = NULL;
2139 if ( clientactivetmu == GL_TEXTURE0 )
2140 {
2141 clientstate = &tmuState0;
2142 }
2143 else if ( clientactivetmu == GL_TEXTURE1 )
2144 {
2145 clientstate = &tmuState1;
2146 }
2147 if ( clientstate->texture_coord_array.size == size &&
2148 clientstate->texture_coord_array.stride == stride &&
2149 clientstate->texture_coord_array.type == type &&
2150 clientstate->texture_coord_array.ptr == pointer )
2151 {
2152 return;
2153 }
2154 clientstate->texture_coord_array.size = size;
2155 clientstate->texture_coord_array.stride = stride;
2156 clientstate->texture_coord_array.type = type;
2157 clientstate->texture_coord_array.ptr = (GLvoid *)pointer;
2158 clientstate->texture_coord_array.changed = GL_TRUE;
2159 }
2160 void glColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
2161 {
2162 if ( tmuState0.color_array.size == size &&
2163 tmuState0.color_array.stride == stride &&
2164 tmuState0.color_array.type == type &&
2165 tmuState0.color_array.ptr == pointer )
2166 {
2167 return;
2168 }
2169 tmuState0.color_array.size = size;
2170 tmuState0.color_array.stride = stride;
2171 tmuState0.color_array.type = type;
2172 tmuState0.color_array.ptr = (GLvoid *)pointer;
2173 tmuState0.color_array.changed = GL_TRUE;
2174 }
2175
2176 void glNormalPointer( GLenum type, GLsizei stride, const GLvoid *pointer )
2177 {
2178 int size = 0;
2179 if ( tmuState0.normal_array.size == size &&
2180 tmuState0.normal_array.stride == stride &&
2181 tmuState0.normal_array.type == type &&
2182 tmuState0.normal_array.ptr == pointer )
2183 {
2184 return;
2185 }
2186 tmuState0.normal_array.size = size;
2187 tmuState0.normal_array.stride = stride;
2188 tmuState0.normal_array.type = type;
2189 tmuState0.normal_array.ptr = (GLvoid *)pointer;
2190 tmuState0.normal_array.changed = GL_TRUE;
2191 }
2192 void glPolygonOffset( GLfloat factor, GLfloat units )
2193 {
2194 FlushOnStateChange( );
2195 glEsImpl->glPolygonOffset( factor, units );
2196 }
2197 void glStencilMask( GLuint mask )
2198 {
2199 FlushOnStateChange( );
2200 glEsImpl->glStencilMask( mask );
2201 }
2202 void glClearStencil( GLint s )
2203 {
2204 FlushOnStateChange( );
2205 glEsImpl->glClearStencil( s );
2206 }
2207
2208 #if defined( __MULTITEXTURE_SUPPORT__ )
2209
2210 extern "C" void glMultiTexCoord2fARB( GLenum target, GLfloat s, GLfloat t );
2211
2212 void glMultiTexCoord2fARB( GLenum target, GLfloat s, GLfloat t )
2213 {
2214 if ( target == GL_TEXTURE0 )
2215 {
2216 glTexCoord2f( s, t );
2217 }
2218 else
2219 {
2220 currentVertexAttrib.s_multi = s;
2221 currentVertexAttrib.t_multi = t;
2222 }
2223 }
2224 #endif
2225
2226 /* Vladimir */
2227 /*void glDrawArrays( GLenum mode, int first, int count)
2228 {
2229 FlushOnStateChange();
2230 glEsImpl->glDrawArrays(mode, first , count);
2231 }*/
2232 void glMultMatrixf( const GLfloat *m )
2233 {
2234 FlushOnStateChange( );
2235 glEsImpl->glMultMatrixf( m );
2236 }
2237
2238 void glPixelStorei( GLenum pname, GLint param )
2239 {
2240 FlushOnStateChange( );
2241 glEsImpl->glPixelStorei( pname, param );
2242 }
2243
2244 void glFogi( GLenum pname, GLint param )
2245 {
2246 FlushOnStateChange( );
2247 glEsImpl->glFogf( pname, param );
2248 }
2249
2250 void glFogf( GLenum pname, GLfloat param )
2251 {
2252 FlushOnStateChange( );
2253 glEsImpl->glFogf( pname, param );
2254 }
2255
2256 void glFogfv( GLenum pname, const GLfloat *params )
2257 {
2258 FlushOnStateChange( );
2259 glEsImpl->glFogfv( pname, params );
2260 }
2261
2262 void glGetTexParameteriv( GLenum target, GLenum pname, GLint *params )
2263 {
2264 FlushOnStateChange( );
2265 glEsImpl->glGetTexParameteriv( target, pname, params );
2266 }
2267
2268 // This gives: called unimplemented OpenGL ES API (Android)
2269 void glTexParameteri( GLenum target, GLenum pname, GLint param )
2270 {
2271 if ( pname == GL_TEXTURE_BORDER_COLOR )
2272 {
2273 return; // not supported by opengl es
2274 }
2275 if ( ( pname == GL_TEXTURE_WRAP_S ||
2276 pname == GL_TEXTURE_WRAP_T ) &&
2277 param == GL_CLAMP )
2278 {
2279 param = 0x812F;
2280 }
2281
2282 FlushOnStateChange( );
2283 glEsImpl->glTexParameteri( target, pname, param );
2284 }
2285
2286 void glTexParameterx( GLenum target, GLenum pname, GLfixed param )
2287 {
2288 if ( pname == GL_TEXTURE_BORDER_COLOR )
2289 {
2290 return; // not supported by opengl es
2291 }
2292 if ( ( pname == GL_TEXTURE_WRAP_S ||
2293 pname == GL_TEXTURE_WRAP_T ) &&
2294 param == GL_CLAMP )
2295 {
2296 param = 0x812F;
2297 }
2298 FlushOnStateChange( );
2299 glEsImpl->glTexParameterx( target, pname, param );
2300 }
2301
2302 void glGenTextures( GLsizei n, GLuint *textures )
2303 {
2304 FlushOnStateChange( );
2305 glEsImpl->glGenTextures( n, textures );
2306 }
2307
2308 void glFrontFace( GLenum mode )
2309 {
2310 FlushOnStateChange( );
2311 glEsImpl->glFrontFace( mode );
2312 }
2313 // End Vladimir
2314
2315 void glTexEnvi( GLenum target, GLenum pname, GLint param )
2316 {
2317 if( skipnanogl )
2318 {
2319 glEsImpl->glTexEnvi( target, pname, param );
2320 return;
2321 }
2322 if ( target == GL_TEXTURE_ENV )
2323 {
2324 if ( pname == GL_TEXTURE_ENV_MODE )
2325 {
2326 if ( param == activetmuState->texture_env_mode.value )
2327 {
2328 return;
2329 }
2330 else
2331 {
2332 FlushOnStateChange( );
2333 glEsImpl->glTexEnvi( target, pname, param );
2334 activetmuState->texture_env_mode.value = param;
2335 return;
2336 }
2337 }
2338 }
2339 FlushOnStateChange( );
2340 glEsImpl->glTexEnvi( target, pname, param );
2341 }
2342
2343 #ifdef __MULTITEXTURE_SUPPORT__
2344 void glMultiTexCoord3fARB( GLenum a, GLfloat b, GLfloat c, GLfloat )
2345 {
2346 return glMultiTexCoord2fARB( a, b, c );
2347 }
2348
2349 void glMultiTexCoord2f( GLenum a, GLfloat b, GLfloat c )
2350 {
2351 glMultiTexCoord2fARB(a,b,c);
2352 }
2353 #endif
2354 void glDrawArrays( GLenum mode, GLint first, GLsizei count )
2355 {
2356 if( skipnanogl )
2357 {
2358 glEsImpl->glDrawArrays( mode, first, count );
2359 return;
2360 }
2361 // ensure that all primitives specified between glBegin/glEnd pairs
2362 // are rendered first, and that we have correct tmu in use..
2363 if ( mode == GL_QUADS )
2364 mode = GL_TRIANGLE_FAN;
2365 FlushOnStateChange( );
2366 // setup correct vertex/color/texcoord pointers
2367 if ( arraysValid ||
2368 tmuState0.vertex_array.changed ||
2369 tmuState0.color_array.changed ||
2370 tmuState0.texture_coord_array.changed || tmuState0.normal_array.changed )
2371 {
2372 glEsImpl->glClientActiveTexture( GL_TEXTURE0 );
2373 }
2374 if ( arraysValid || tmuState0.vertex_array.changed )
2375 {
2376 if ( tmuState0.vertex_array.enabled )
2377 {
2378 glEsImpl->glEnableClientState( GL_VERTEX_ARRAY );
2379 }
2380 else
2381 {
2382 glEsImpl->glDisableClientState( GL_VERTEX_ARRAY );
2383 }
2384 glEsImpl->glVertexPointer( tmuState0.vertex_array.size,
2385 tmuState0.vertex_array.type,
2386 tmuState0.vertex_array.stride,
2387 tmuState0.vertex_array.ptr );
2388 tmuState0.vertex_array.changed = GL_FALSE;
2389 }
2390 if ( arraysValid || tmuState0.color_array.changed )
2391 {
2392 if ( tmuState0.color_array.enabled )
2393 {
2394 glEsImpl->glEnableClientState( GL_COLOR_ARRAY );
2395 }
2396 else
2397 {
2398 glEsImpl->glDisableClientState( GL_COLOR_ARRAY );
2399 glEsImpl->glColor4f( currentVertexAttrib.red/255.0f, currentVertexAttrib.green/255.0f,
2400 currentVertexAttrib.blue/255.0f, currentVertexAttrib.alpha/255.0f );
2401
2402 }
2403 glEsImpl->glColorPointer( tmuState0.color_array.size,
2404 tmuState0.color_array.type,
2405 tmuState0.color_array.stride,
2406 tmuState0.color_array.ptr );
2407 tmuState0.color_array.changed = GL_FALSE;
2408 }
2409 if ( arraysValid || tmuState0.normal_array.changed )
2410 {
2411 if ( tmuState0.normal_array.enabled )
2412 {
2413 glEsImpl->glEnableClientState( GL_NORMAL_ARRAY );
2414 }
2415 else
2416 {
2417 glEsImpl->glDisableClientState( GL_NORMAL_ARRAY );
2418 }
2419 glEsImpl->glNormalPointer( tmuState0.normal_array.type,
2420 tmuState0.normal_array.stride,
2421 tmuState0.normal_array.ptr );
2422 tmuState0.normal_array.changed = GL_FALSE;
2423 }
2424 if ( arraysValid || tmuState0.texture_coord_array.changed )
2425 {
2426 tmuState0.texture_coord_array.changed = GL_FALSE;
2427 if ( tmuState0.texture_coord_array.enabled )
2428 {
2429 glEsImpl->glEnableClientState( GL_TEXTURE_COORD_ARRAY );
2430 }
2431 else
2432 {
2433 glEsImpl->glDisableClientState( GL_TEXTURE_COORD_ARRAY );
2434 }
2435 glEsImpl->glTexCoordPointer( tmuState0.texture_coord_array.size,
2436 tmuState0.texture_coord_array.type,
2437 tmuState0.texture_coord_array.stride,
2438 tmuState0.texture_coord_array.ptr );
2439 }
2440
2441 if ( arraysValid || tmuState1.texture_coord_array.changed )
2442 {
2443 tmuState1.texture_coord_array.changed = GL_FALSE;
2444 glEsImpl->glClientActiveTexture( GL_TEXTURE1 );
2445 if ( tmuState1.texture_coord_array.enabled )
2446 {
2447 glEsImpl->glEnableClientState( GL_TEXTURE_COORD_ARRAY );
2448 }
2449 else
2450 {
2451 glEsImpl->glDisableClientState( GL_TEXTURE_COORD_ARRAY );
2452 }
2453 glEsImpl->glTexCoordPointer( tmuState1.texture_coord_array.size,
2454 tmuState1.texture_coord_array.type,
2455 tmuState1.texture_coord_array.stride,
2456 tmuState1.texture_coord_array.ptr );
2457 }
2458
2459 arraysValid = GL_FALSE;
2460 glEsImpl->glDrawArrays( mode, first, count );
2461 }
2462 /*void glNormalPointer(GLenum type, GLsizei stride, const void *ptr)
2463 {
2464 glEsImpl->glNormalPointer( type, stride, ptr );
2465 }*/
2466
2467 void glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
2468 {
2469 FlushOnStateChange( );
2470 glEsImpl->glCopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height );
2471 }
2472
2473 void glGenFramebuffers( GLsizei n, GLuint *framebuffers )
2474 {
2475 FlushOnStateChange( );
2476 glEsImpl->glGenFramebuffers( n, framebuffers );
2477 }
2478
2479 void glGenRenderbuffers( GLsizei n, GLuint *renderbuffers )
2480 {
2481 FlushOnStateChange( );
2482 glEsImpl->glGenRenderbuffers( n, renderbuffers );
2483 }
2484
2485 void glBindRenderbuffer( GLenum target, GLuint renderbuffer )
2486 {
2487 FlushOnStateChange( );
2488 glEsImpl->glBindRenderbuffer( target, renderbuffer );
2489 }
2490
2491 void glBindFramebuffer( GLenum target, GLuint framebuffer )
2492 {
2493 FlushOnStateChange( );
2494 glEsImpl->glBindFramebuffer( target, framebuffer );
2495 }
2496
2497 void glFramebufferRenderbuffer( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer )
2498 {
2499 FlushOnStateChange( );
2500 glEsImpl->glFramebufferRenderbuffer( target, attachment, renderbuffertarget, renderbuffer );
2501 }
2502
2503 void glDeleteFramebuffers( GLsizei n, const GLuint *framebuffers )
2504 {
2505 FlushOnStateChange( );
2506 glEsImpl->glDeleteFramebuffers( n, framebuffers );
2507 }
2508
2509 void glDeleteRenderbuffers( GLsizei n, const GLuint *renderbuffers )
2510 {
2511 FlushOnStateChange( );
2512 glEsImpl->glDeleteRenderbuffers( n, renderbuffers );
2513 }
2514 void glFramebufferTexture2D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
2515 {
2516 FlushOnStateChange( );
2517 glEsImpl->glFramebufferTexture2D( target, attachment, textarget, texture, level );
2518 }
2519
2520 void glRenderbufferStorage( GLenum target, GLenum internalformat, GLsizei width, GLsizei height )
2521 {
2522 FlushOnStateChange( );
2523 glEsImpl->glRenderbufferStorage( target, internalformat, width, height );
2524 }
2525
2526 void glBindBufferARB( GLuint target, GLuint index )
2527 {
2528 static int sindex;
2529
2530 if( index && !sindex && !skipnanogl )
2531 FlushOnStateChange();
2532 glEsImpl->glDisableClientState( GL_COLOR_ARRAY );
2533 glEsImpl->glColor4f( currentVertexAttrib.red/255.0f, currentVertexAttrib.green/255.0f,
2534 currentVertexAttrib.blue/255.0f, currentVertexAttrib.alpha/255.0f );
2535
2536 skipnanogl = (!!index) || vboarray;
2537 glEsImpl->glBindBuffer( target, index );
2538 if( sindex && !index )
2539 {
2540 arraysValid = GL_FALSE;
2541 }
2542 sindex = index;
2543 }
2544
2545 void glGenBuffersARB( GLuint count, GLuint *indexes )
2546 {
2547 glEsImpl->glGenBuffers( count, indexes );
2548 }
2549
2550 void glDeleteBuffersARB( GLuint count, GLuint *indexes )
2551 {
2552 glEsImpl->glDeleteBuffers( count, indexes );
2553 }
2554
2555 void glBufferDataARB( GLuint target, GLuint size, void *buffer, GLuint type )
2556 {
2557 glEsImpl->glBufferData( target, size, buffer, type );
2558 }
2559
2560 void glBufferSubDataARB( GLuint target, GLsizei offset, GLsizei size, void *buffer )
2561 {
2562 glEsImpl->glBufferSubData( target, offset, size, buffer );
2563 }
[FORK] nanogl for android version of Doom2D:Forever
[25/02/2024 19:55:35]
DEADSOFTWARE 2012-2024