fa3829e35aefd1c22e42c13e43a1db9fdcbfae00
1 /*
2 Copyright (C) 2007-2009 Olli Hinkka
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.
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.
13 See the GNU General Public License for more details.
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.
19 */
20 /*
21 #include <e32def.h>
22 #include <e32std.h>
23 */
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
33 #define GL_TEXTURE0_ARB 0x84C0
34 #define GL_TEXTURE1_ARB 0x84C1
36 struct nanoState
37 {
38 GLboolean alpha_test;
39 GLboolean blend;
40 GLboolean clip_planei;
41 GLboolean color_logic_op;
42 GLboolean color_material;
43 GLboolean cull_face;
44 GLboolean depth_test;
45 GLboolean dither;
46 GLboolean fog;
47 GLboolean lighti;
48 GLboolean lighting;
49 GLboolean line_smooth;
50 GLboolean matrix_palette_oes;
51 GLboolean multisample;
52 GLboolean normalize;
53 GLboolean point_smooth;
54 GLboolean point_sprite_oes;
55 GLboolean polygon_offset_fill;
56 GLboolean rescale_normal;
57 GLboolean sample_alpha_to_coverage;
58 GLboolean sample_alpha_to_one;
59 GLboolean sample_coverage;
60 GLboolean scissor_test;
61 GLboolean stencil_test;
62 GLboolean depthmask;
63 GLclampf depth_range_near;
64 GLclampf depth_range_far;
65 GLenum depth_func;
66 GLenum cullface;
67 GLenum shademodel;
68 GLenum sfactor;
69 GLenum dfactor;
70 GLenum matrixmode;
71 };
76 {
77 GL_FALSE,
78 GL_FALSE,
79 GL_FALSE,
80 GL_FALSE,
81 GL_FALSE,
82 GL_FALSE,
83 GL_FALSE,
84 GL_TRUE,
85 GL_FALSE,
86 GL_FALSE,
87 GL_FALSE,
88 GL_FALSE,
89 GL_FALSE,
90 GL_TRUE,
91 GL_FALSE,
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_TRUE,
104 GL_LESS,
105 GL_BACK,
106 GL_SMOOTH,
107 GL_ONE,
108 GL_ZERO,
109 GL_MODELVIEW,
110 };
112 struct booleanstate
113 {
114 GLboolean value;
115 GLboolean changed;
116 };
118 struct floatstate
119 {
120 GLfloat value;
121 GLboolean changed;
122 };
124 struct uintstate
125 {
126 GLuint value;
127 GLboolean changed;
128 };
130 struct ptrstate
131 {
132 GLint size;
133 GLenum type;
134 GLsizei stride;
136 GLboolean changed;
137 GLboolean enabled;
138 };
141 struct nanotmuState
142 {
151 };
157 {
165 };
176 #if defined(__MULTITEXTURE_SUPPORT__)
178 #endif
181 #if !defined (__WINS__)
182 //#define __FORCEINLINE __forceinline
183 #define __FORCEINLINE inline
184 #else
185 #define __FORCEINLINE
186 #endif
191 struct VertexAttrib
192 {
196 #if !defined(__MULTITEXTURE_SUPPORT__)
198 #endif
206 #if defined(__MULTITEXTURE_SUPPORT__)
209 #endif
210 };
225 #if defined(__MULTITEXTURE_SUPPORT__)
230 };
231 #else
235 };
236 #endif
242 {
264 }
267 {
270 {
272 }
273 else
274 {
276 }
279 {
281 }
282 else
283 {
285 }
288 {
290 }
291 else
292 {
294 }
297 {
299 }
300 else
301 {
303 }
328 glEsImpl->glColor4f (currentVertexAttrib.red, currentVertexAttrib.green, currentVertexAttrib.blue, currentVertexAttrib.alpha);
332 //glEsImpl->glBindTexture(GL_TEXTURE_2D, stackTextureState);
334 glEsImpl->glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, activetmuState->texture_env_mode.value);
337 }
340 {
342 {
344 #ifndef USE_CORE_PROFILE
346 #endif
347 }
353 {
361 #if defined(__MULTITEXTURE_SUPPORT__)
366 #endif
368 }
373 #if defined(__MULTITEXTURE_SUPPORT__)
375 #endif
382 }
384 {
386 }
388 {
390 }
392 {
397 }
400 {
401 vertexCount+=((unsigned char*)ptrVertexAttribArray-(unsigned char*)ptrVertexAttribArrayMark)/sizeof(VertexAttrib);
403 {
405 }
407 {
409 {
418 }
421 {
424 {
429 }
430 }
433 {
440 {
444 indexCount++;
451 {
456 }
459 {
463 indexCount++;
464 }
465 }
466 else
467 {
468 //already aligned
474 {
480 }
483 {
488 indexCount++;
489 }
490 }
492 }
496 {
502 {
507 }
508 }
513 }
514 }
517 {
520 {
522 {
524 {
527 }
529 }
531 {
533 {
536 }
538 }
539 //case GL_CLIP_PLANEi
541 {
543 {
546 }
548 }
550 {
552 {
555 }
557 }
559 {
561 {
564 }
566 }
568 {
570 {
573 }
575 }
577 {
579 {
582 }
584 }
586 //case GL_LIGHTi
587 {
589 {
592 }
594 }
596 {
598 {
601 }
603 }
605 {
607 {
610 }
612 }
613 /* case GL_MATRIX_PALETTE_OES:
614 {
615 if (!nanoglState.matrix_palette_oes)
616 {
617 nanoglState.matrix_palette_oes = GL_TRUE;
618 statechanged = GL_TRUE;
619 }
620 break;
621 }*/
623 {
625 {
628 }
630 }
632 {
634 {
637 }
639 }
640 /* case GL_POINT_SPRITE_OES:
641 {
642 if (!nanoglState.point_sprite_oes)
643 {
644 nanoglState.point_sprite_oes = GL_TRUE;
645 statechanged = GL_TRUE;
646 }
647 break;
648 }*/
650 {
652 {
655 }
657 }
659 {
661 {
664 }
666 }
668 {
670 {
673 }
675 }
677 {
679 {
682 }
684 }
686 {
688 {
691 }
693 }
695 {
697 {
700 }
702 }
704 {
706 /* if (!nanoglState.stencil_test)
707 {
708 nanoglState.stencil_test = GL_TRUE;
709 statechanged = GL_TRUE;
710 }*/
712 }
714 {
716 {
721 }
723 }
726 }
729 {
732 }
733 }
736 {
739 {
741 {
743 {
746 }
748 }
750 {
752 {
755 }
757 }
758 //case GL_CLIP_PLANEi
760 {
762 {
765 }
767 }
769 {
771 {
774 }
776 }
778 {
780 {
783 }
785 }
787 {
789 {
792 }
794 }
796 {
798 {
801 }
803 }
805 //case GL_LIGHTi
806 {
808 {
811 }
813 }
815 {
817 {
820 }
822 }
824 {
826 {
829 }
831 }
832 /* case GL_MATRIX_PALETTE_OES:
833 {
834 if (nanoglState.matrix_palette_oes)
835 {
836 nanoglState.matrix_palette_oes = GL_FALSE;
837 statechanged = GL_TRUE;
838 }
839 break;
840 }*/
842 {
844 {
847 }
849 }
851 {
853 {
856 }
858 }
859 /* case GL_POINT_SPRITE_OES:
860 {
861 if (nanoglState.point_sprite_oes)
862 {
863 nanoglState.point_sprite_oes = GL_FALSE;
864 statechanged = GL_TRUE;
865 }
866 break;
867 }*/
869 {
871 {
874 }
876 }
878 {
880 {
883 }
885 }
887 {
889 {
892 }
894 }
896 {
898 {
901 }
903 }
905 {
907 {
910 }
912 }
914 {
916 {
919 }
921 }
923 {
925 /* if (nanoglState.stencil_test)
926 {
927 nanoglState.stencil_test = GL_FALSE;
928 statechanged = GL_TRUE;
929 }*/
931 }
933 {
935 {
942 }
944 }
947 }
950 {
953 }
954 }
957 {
959 }
963 {
966 {
968 }
970 }
973 {
978 }
982 {
984 }
988 {
991 }
994 {
997 }
1000 {
1003 }
1006 {
1011 }
1013 void glOrtho (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
1014 {
1016 #ifdef USE_CORE_PROFILE
1018 #else
1020 #endif
1021 }
1024 {
1026 {
1028 }
1032 }
1035 {
1037 {
1039 }
1043 {
1045 }
1049 }
1052 {
1054 }
1056 void glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
1057 {
1060 glEsImpl->glTexImage2D(target, level, internalformat, width, height,border,format,type,pixels);
1061 }
1064 {
1065 }
1068 {
1071 }
1074 {
1077 }
1080 {
1083 }
1086 {
1088 {
1090 }
1091 else
1092 {
1095 }
1097 #ifdef USE_CORE_PROFILE
1099 #else
1101 #endif
1102 }
1105 {
1107 {
1109 }
1110 else
1111 {
1113 }
1116 }
1119 {
1122 }
1125 {
1128 }
1131 {
1133 {
1135 }
1136 else
1137 {
1139 }
1142 }
1144 void glFrustum (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
1145 {
1148 }
1151 {
1154 }
1158 {
1163 #if defined(__MULTITEXTURE_SUPPORT__)
1165 #else
1167 #endif
1169 }
1172 {
1177 }
1180 {
1185 }
1188 {
1189 //*((unsigned int*)(¤tVertexAttrib.red)) = *((unsigned int*)(v));
1194 }
1197 {
1202 }
1204 //-- nicknekit: xash3d funcs --
1207 {
1212 }
1215 {
1220 }
1223 {
1226 }
1228 void glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
1229 {
1232 }
1234 void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
1235 {
1237 }
1239 void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
1240 {
1241 glTexImage2D(GL_TEXTURE_2D, level, internalformat, width, height, border, format, type, pixels);
1242 }
1244 void glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels )
1245 {
1247 }
1253 GLenum format,
1255 {
1257 }
1262 {
1265 }
1269 {
1270 //for mirrors? not needed for original hl?
1271 }
1274 {
1275 //for mirrors? not needed for original hl?
1276 }
1278 //-- --//
1281 {
1284 }
1287 {
1289 {
1291 }
1296 }
1299 {
1302 }
1305 {
1307 {
1309 }
1313 }
1316 {
1319 }
1322 {
1324 {
1326 {
1328 {
1330 }
1331 else
1332 {
1337 }
1338 }
1339 }
1342 }
1345 {
1348 #if defined(__MULTITEXTURE_SUPPORT__)
1350 #else
1352 #endif
1353 }
1357 {
1359 {
1361 }
1365 }
1368 {
1370 {
1372 }
1376 }
1380 {
1383 }
1387 {
1390 {
1391 #if defined(__MULTITEXTURE_SUPPORT__)
1392 sprintf((char*)nano_extensions_string,"%s %s",glEsImpl->glGetString(name),"GL_ARB_multitexture EXT_texture_env_add");
1393 #else
1394 sprintf((char*)nano_extensions_string,"%s %s",glEsImpl->glGetString(name),"EXT_texture_env_add");
1395 #endif
1397 }
1399 }
1402 {
1405 }
1408 {
1411 }
1413 void glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
1414 {
1416 {
1417 // OpenglEs 1.1 does not support reading depth buffer without an extension
1420 }
1423 }
1426 {
1428 }
1431 {
1434 }
1436 void glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
1437 {
1440 }
1443 {
1446 }
1449 {
1450 //FlushOnStateChange();
1452 }
1455 {
1457 {
1459 }
1461 {
1463 }
1464 else
1465 {
1468 }
1470 {
1472 }
1473 else
1474 {
1476 }
1478 }
1481 {
1483 }
1486 {
1487 }
1490 {
1493 }
1496 {
1499 }
1502 {
1510 }
1513 {
1516 }
1519 {
1522 }
1536 {
1537 // ensure that all primitives specified between glBegin/glEnd pairs
1538 // are rendered first, and that we have correct tmu in use..
1540 // setup correct vertex/color/texcoord pointers
1545 {
1547 }
1549 {
1551 {
1553 }
1554 else
1555 {
1557 }
1563 }
1565 {
1567 {
1569 }
1570 else
1571 {
1573 }
1579 }
1581 {
1583 {
1585 }
1586 else
1587 {
1589 }
1595 }
1597 {
1600 {
1602 }
1603 else
1604 {
1606 }
1611 }
1614 {
1618 {
1620 }
1621 else
1622 {
1624 }
1629 }
1633 }
1636 {
1639 {
1641 }
1643 {
1645 }
1646 else
1647 {
1649 }
1651 {
1654 {
1656 }
1662 {
1664 }
1671 {
1673 }
1680 {
1682 }
1688 }
1689 }
1691 {
1694 {
1696 }
1698 {
1700 }
1701 else
1702 {
1704 }
1706 {
1709 {
1711 }
1717 {
1719 }
1726 {
1728 }
1735 {
1737 }
1743 }
1744 }
1746 {
1751 {
1753 }
1759 }
1761 {
1764 {
1766 }
1768 {
1770 }
1775 {
1777 }
1783 }
1785 {
1790 {
1792 }
1798 }
1801 {
1807 {
1809 }
1815 }
1817 {
1820 }
1824 #if defined(__MULTITEXTURE_SUPPORT__)
1829 {
1831 {
1833 }
1834 else
1835 {
1838 }
1839 }
1840 #endif
1842 /* Vladimir */
1844 {
1847 }
1849 {
1852 }
1855 {
1858 }
1862 {
1865 }
1868 {
1871 }
1874 {
1877 }
1880 // This gives: called unimplemented OpenGL ES API (Android)
1882 {
1885 }
1890 }
1894 }
1897 {
1900 }
1905 }
1908 }
1911 {
1914 }
1917 {
1920 }
1921 // End Vladimir
1924 {
1926 {
1928 {
1930 {
1932 }
1933 else
1934 {
1939 }
1940 }
1941 }
1944 }
1947 {
1949 }
1952 {
1954 }
1956 /*void glNormalPointer(GLenum type, GLsizei stride, const void *ptr)
1957 {
1958 glEsImpl->glNormalPointer( type, stride, ptr );
1959 }*/
1961 void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
1962 {
1965 }
1968 {
1971 }
1975 {
1978 }
1981 {
1984 }
1987 {
1990 }
1992 void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
1993 {
1996 }
1999 {
2002 }
2005 {
2008 }
2009 void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
2010 {
2013 }
2015 void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
2016 {
2019 }