DEADSOFTWARE

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