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
  32 #define GL_TEXTURE0_ARB                     0x84C0
  33 #define GL_TEXTURE1_ARB                     0x84C1
  34
  35 struct nanoState
  36     {
  37     GLboolean alpha_test;
  38     GLboolean blend;
  39     GLboolean clip_planei;
  40     GLboolean color_logic_op;
  41     GLboolean color_material;
  42     GLboolean cull_face;
  43     GLboolean depth_test;
  44     GLboolean dither;
  45     GLboolean fog;
  46     GLboolean lighti;
  47     GLboolean lighting;
  48     GLboolean line_smooth;
  49     GLboolean matrix_palette_oes;
  50     GLboolean multisample;
  51     GLboolean normalize;
  52     GLboolean point_smooth;
  53     GLboolean point_sprite_oes;
  54     GLboolean polygon_offset_fill;
  55     GLboolean rescale_normal;
  56     GLboolean sample_alpha_to_coverage;
  57     GLboolean sample_alpha_to_one;
  58     GLboolean sample_coverage;
  59     GLboolean scissor_test;
  60     GLboolean stencil_test;
  61     GLboolean depthmask;
  62     GLclampf depth_range_near;
  63     GLclampf depth_range_far;
  64     GLenum depth_func;
  65     GLenum cullface;
  66     GLenum shademodel;
  67     GLenum sfactor;
  68     GLenum dfactor;
  69     GLenum matrixmode;
  70     };
  71
  72 static struct nanoState nanoglState;
  73
  74 static struct nanoState nanoglInitState =
  75     {
  76     GL_FALSE,
  77     GL_FALSE,
  78     GL_FALSE,
  79     GL_FALSE,
  80     GL_FALSE,
  81     GL_FALSE,
  82     GL_FALSE,
  83     GL_TRUE,
  84     GL_FALSE,
  85     GL_FALSE,
  86     GL_FALSE,
  87     GL_FALSE,
  88     GL_FALSE,
  89     GL_TRUE,
  90     GL_FALSE,
  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_TRUE,
 101     0.0f,
 102     1.0f,
 103     GL_LESS,
 104     GL_BACK,
 105     GL_SMOOTH,
 106     GL_ONE,
 107     GL_ZERO,
 108     GL_MODELVIEW,
 109     };
 110
 111 struct booleanstate
 112     {
 113     GLboolean value;
 114     GLboolean changed;
 115     };
 116
 117 struct floatstate
 118     {
 119     GLfloat value;
 120     GLboolean changed;
 121     };
 122
 123 struct uintstate
 124     {
 125     GLuint value;
 126     GLboolean changed;
 127     };
 128
 129 struct ptrstate
 130     {
 131     GLint size;
 132     GLenum type;
 133     GLsizei stride;
 134     GLvoid* ptr;
 135     GLboolean changed;
 136     GLboolean enabled;
 137     };
 138
 139
 140 struct nanotmuState
 141     {
 142     struct booleanstate texture_2d;
 143     struct floatstate texture_env_mode;
 144     struct uintstate boundtexture;
 145     struct ptrstate vertex_array;
 146     struct ptrstate color_array;
 147     struct ptrstate texture_coord_array;
 148     };
 149
 150 static struct nanotmuState tmuState0;
 151 static struct nanotmuState tmuState1;
 152
 153 static struct nanotmuState tmuInitState =
 154     {
 155     {GL_FALSE, GL_FALSE},
 156     {GL_MODULATE,GL_FALSE},
 157     {0x7fffffff,GL_FALSE},
 158     {4,GL_FLOAT,0, NULL, GL_FALSE, GL_FALSE},
 159     {4,GL_FLOAT,0, NULL, GL_FALSE, GL_FALSE},
 160     {4,GL_FLOAT,0, NULL, GL_FALSE, GL_FALSE},
 161     };
 162
 163 static struct nanotmuState* activetmuState = &tmuState0;
 164
 165 extern "C++" GlESInterface* glEsImpl;
 166
 167 static GLenum wrapperPrimitiveMode = GL_QUADS;
 168 GLboolean useTexCoordArray = GL_FALSE;
 169 static GLenum activetmu = GL_TEXTURE0;
 170 static GLenum clientactivetmu = GL_TEXTURE0;
 171
 172 #if defined(__MULTITEXTURE_SUPPORT__)
 173 GLboolean useMultiTexCoordArray = GL_FALSE;
 174 #endif
 175
 176
 177 #if !defined (__WINS__)
 178 //#define __FORCEINLINE __forceinline
 179 #define __FORCEINLINE inline
 180 #else
 181 #define __FORCEINLINE
 182 #endif
 183
 184 static GLboolean delayedttmuchange = GL_FALSE;
 185 static GLenum delayedtmutarget = GL_TEXTURE0;
 186
 187 struct VertexAttrib
 188     {
 189     float x;
 190     float y;
 191     float z;
 192 #if !defined(__MULTITEXTURE_SUPPORT__)
 193     float padding;
 194 #endif
 195     unsigned char red;
 196     unsigned char green;
 197     unsigned char blue;
 198     unsigned char alpha;
 199
 200     float s;
 201     float t;
 202 #if defined(__MULTITEXTURE_SUPPORT__)
 203     float s_multi;
 204     float t_multi;
 205 #endif
 206     };
 207
 208 static VertexAttrib vertexattribs[8000];
 209
 210 static GLushort indexArray[30000];
 211
 212 static GLuint vertexCount = 0;
 213 static GLuint indexCount = 0;
 214 static GLuint vertexMark = 0;
 215 static int indexbase = 0;
 216
 217 static VertexAttrib* ptrVertexAttribArray = NULL;
 218 static VertexAttrib* ptrVertexAttribArrayMark = NULL;
 219
 220 static VertexAttrib currentVertexAttrib;
 221 #if defined(__MULTITEXTURE_SUPPORT__)
 222 static VertexAttrib currentVertexAttribInit = {0.0f,0.0f,0.0f,
 223                                     255,255,255,255,
 224                                     0.0f,0.0f,
 225                                     0.0f,0.0f
 226                                     };
 227 #else
 228 static VertexAttrib currentVertexAttribInit = {0.0f,0.0f,0.0f,0.0f,
 229                                     255,255,255,255,
 230                                     0.0f,0.0f,
 231                                     };
 232 #endif
 233 static GLushort* ptrIndexArray = NULL;
 234
 235 static GLboolean arraysValid = GL_FALSE;
 236
 237 void InitGLStructs()
 238     {
 239     ptrVertexAttribArray = vertexattribs;
 240     ptrVertexAttribArrayMark = ptrVertexAttribArray;
 241     ptrIndexArray = indexArray;
 242
 243     memcpy(&nanoglState, &nanoglInitState, sizeof(struct nanoState));
 244     memcpy(&tmuState0,&tmuInitState,sizeof(struct nanotmuState));
 245     memcpy(&tmuState1,&tmuInitState,sizeof(struct nanotmuState));
 246     memcpy(&currentVertexAttrib,&currentVertexAttribInit,sizeof(struct VertexAttrib));
 247
 248     activetmuState = &tmuState0;
 249     wrapperPrimitiveMode = GL_QUADS;
 250     useTexCoordArray = GL_FALSE;
 251     activetmu = GL_TEXTURE0;
 252     clientactivetmu = GL_TEXTURE0;
 253     delayedttmuchange = GL_FALSE;
 254     delayedtmutarget = GL_TEXTURE0;
 255     vertexCount = 0;
 256     indexCount = 0;
 257     vertexMark = 0;
 258     indexbase = 0;
 259     arraysValid = GL_FALSE;
 260     }
 261
 262
 263 void FlushOnStateChange()
 264     {
 265     if (delayedttmuchange)
 266         {
 267         delayedttmuchange = GL_FALSE;
 268         glEsImpl->glActiveTexture(delayedtmutarget);
 269         }
 270
 271     if (!vertexCount)
 272         return;
 273
 274     if (!arraysValid)
 275         {
 276         glEsImpl->glClientActiveTexture(GL_TEXTURE0);
 277         glEsImpl->glVertexPointer(3, GL_FLOAT, sizeof(VertexAttrib), &vertexattribs[0].x);
 278         glEsImpl->glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(VertexAttrib), &vertexattribs[0].red);
 279         glEsImpl->glTexCoordPointer(2, GL_FLOAT, sizeof(VertexAttrib), &vertexattribs[0].s);
 280         glEsImpl->glEnableClientState(GL_VERTEX_ARRAY);
 281         glEsImpl->glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 282         glEsImpl->glEnableClientState(GL_COLOR_ARRAY);
 283 #if defined(__MULTITEXTURE_SUPPORT__)
 284         glEsImpl->glClientActiveTexture(GL_TEXTURE1);
 285         glEsImpl->glTexCoordPointer(2, GL_FLOAT, sizeof(VertexAttrib), &vertexattribs[0].s_multi);
 286         glEsImpl->glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 287         glEsImpl->glClientActiveTexture(GL_TEXTURE0);
 288 #endif
 289         arraysValid = GL_TRUE;
 290         }
 291
 292     glEsImpl->glDrawElements( GL_TRIANGLES,vertexCount,GL_UNSIGNED_SHORT, indexArray );
 293
 294
 295 #if defined(__MULTITEXTURE_SUPPORT__)
 296     useMultiTexCoordArray = GL_FALSE;
 297 #endif
 298     vertexCount = 0;
 299     indexCount = 0;
 300     ptrVertexAttribArray = vertexattribs;
 301     ptrVertexAttribArrayMark = ptrVertexAttribArray;
 302     ptrIndexArray = indexArray;
 303     useTexCoordArray = GL_FALSE;
 304     }
 305
 306 void glBegin(GLenum mode)
 307     {
 308     wrapperPrimitiveMode = mode;
 309     vertexMark = vertexCount;
 310     ptrVertexAttribArrayMark = ptrVertexAttribArray;
 311     indexbase = indexCount;
 312     }
 313
 314 void glEnd(void)
 315     {
 316     vertexCount+=((unsigned char*)ptrVertexAttribArray-(unsigned char*)ptrVertexAttribArrayMark)/sizeof(VertexAttrib);
 317     if (vertexCount < 3)
 318         {
 319         return;
 320         }
 321     switch (wrapperPrimitiveMode)
 322         {
 323         case GL_QUADS:
 324             {
 325             *ptrIndexArray++ = indexCount;
 326             *ptrIndexArray++ = indexCount+1;
 327             *ptrIndexArray++ = indexCount+2;
 328             *ptrIndexArray++ = indexCount;
 329             *ptrIndexArray++ = indexCount+2;
 330             *ptrIndexArray++ = indexCount+3;
 331             indexCount+=4;
 332             vertexCount+=2;
 333             }
 334             break;
 335         case GL_TRIANGLES:
 336             {
 337             int  vcount = (vertexCount-vertexMark)/3;
 338             for (int count = 0; count < vcount; count++)
 339                 {
 340                 *ptrIndexArray++ = indexCount;
 341                 *ptrIndexArray++ = indexCount+1;
 342                 *ptrIndexArray++ = indexCount+2;
 343                 indexCount+=3;
 344                 }
 345             }
 346             break;
 347         case GL_TRIANGLE_STRIP:
 348             {
 349             *ptrIndexArray++ = indexCount;
 350             *ptrIndexArray++ = indexCount+1;
 351             *ptrIndexArray++ = indexCount+2;
 352             indexCount+=3;
 353             int vcount = ((vertexCount-vertexMark)-3);
 354             if (vcount && ((long)ptrIndexArray & 0x02))
 355                 {
 356                 *ptrIndexArray++ = indexCount-1; // 2
 357                 *ptrIndexArray++ = indexCount-2; // 1
 358                 *ptrIndexArray++ = indexCount;   // 3
 359                 indexCount++;
 360                 vcount-=1;
 361                 int odd = vcount&1;
 362                 vcount/=2;
 363                 unsigned int* longptr = (unsigned int*) ptrIndexArray;
 364
 365                 for (int count = 0; count < vcount; count++)
 366                     {
 367                     *(longptr++) = (indexCount-2) | ((indexCount-1)<<16);
 368                     *(longptr++) = (indexCount) | ((indexCount)<<16);
 369                     *(longptr++) = (indexCount-1) | ((indexCount+1)<<16);
 370                     indexCount+=2;
 371                     }
 372                 ptrIndexArray = (unsigned short*)(longptr);
 373                 if (odd)
 374                     {
 375                     *ptrIndexArray++ = indexCount-2; // 2
 376                     *ptrIndexArray++ = indexCount-1; // 1
 377                     *ptrIndexArray++ = indexCount;   // 3
 378                     indexCount++;
 379                     }
 380                 }
 381            else
 382                 {
 383                 //already aligned
 384                 int odd = vcount&1;
 385                 vcount/=2;
 386                 unsigned int* longptr = (unsigned int*) ptrIndexArray;
 387
 388                 for (int count = 0; count < vcount; count++)
 389                     {
 390                     *(longptr++) = (indexCount-1) | ((indexCount-2)<<16);
 391                     *(longptr++) = (indexCount) | ((indexCount-1)<<16);
 392                     *(longptr++) = (indexCount) | ((indexCount+1)<<16);
 393                     indexCount+=2;
 394
 395                     }
 396                 ptrIndexArray = (unsigned short*)(longptr);
 397                 if (odd)
 398                     {
 399
 400                     *ptrIndexArray++ = indexCount-1; // 2
 401                     *ptrIndexArray++ = indexCount-2; // 1
 402                     *ptrIndexArray++ = indexCount;   // 3
 403                     indexCount++;
 404                     }
 405                 }
 406             vertexCount+=(vertexCount-vertexMark-3)*2;
 407             }
 408             break;
 409         case GL_POLYGON:
 410         case GL_TRIANGLE_FAN:
 411             {
 412             *ptrIndexArray++ = indexCount++;
 413             *ptrIndexArray++ = indexCount++;
 414             *ptrIndexArray++ = indexCount++;
 415             int vcount = ((vertexCount-vertexMark)-3);
 416             for (int count = 0; count < vcount; count++)
 417                 {
 418                 *ptrIndexArray++ = indexbase;
 419                 *ptrIndexArray++ = indexCount-1;
 420                 *ptrIndexArray++ = indexCount++;
 421                 vertexCount+=2;
 422                 }
 423              }
 424             break;
 425
 426         default:
 427             break;
 428         }
 429     }
 430
 431 void glEnable (GLenum cap)
 432     {
 433     GLboolean statechanged = GL_FALSE;
 434     switch(cap)
 435         {
 436         case GL_ALPHA_TEST:
 437             {
 438             if (!nanoglState.alpha_test)
 439                 {
 440                 nanoglState.alpha_test = GL_TRUE;
 441                 statechanged = GL_TRUE;
 442                 }
 443             break;
 444             }
 445         case GL_BLEND:
 446             {
 447             if (!nanoglState.blend)
 448                 {
 449                 nanoglState.blend = GL_TRUE;
 450                 statechanged = GL_TRUE;
 451                 }
 452             break;
 453             }
 454         //case GL_CLIP_PLANEi
 455         case GL_COLOR_LOGIC_OP:
 456             {
 457             if (!nanoglState.color_logic_op)
 458                 {
 459                 nanoglState.color_logic_op = GL_TRUE;
 460                 statechanged = GL_TRUE;
 461                 }
 462             break;
 463             }
 464         case GL_COLOR_MATERIAL:
 465             {
 466             if (!nanoglState.color_material)
 467                 {
 468                 nanoglState.color_material = GL_TRUE;
 469                 statechanged = GL_TRUE;
 470                 }
 471             break;
 472             }
 473         case GL_CULL_FACE:
 474             {
 475             if (!nanoglState.cull_face)
 476                 {
 477                 nanoglState.cull_face = GL_TRUE;
 478                 statechanged = GL_TRUE;
 479                 }
 480             break;
 481             }
 482         case GL_DEPTH_TEST:
 483             {
 484             if (!nanoglState.depth_test)
 485                 {
 486                 nanoglState.depth_test = GL_TRUE;
 487                 statechanged = GL_TRUE;
 488                 }
 489             break;
 490             }
 491         case GL_DITHER:
 492             {
 493             if (!nanoglState.dither)
 494                 {
 495                 nanoglState.dither = GL_TRUE;
 496                 statechanged = GL_TRUE;
 497                 }
 498             break;
 499             }
 500         case GL_FOG:
 501         //case GL_LIGHTi
 502             {
 503             if (!nanoglState.fog)
 504                 {
 505                 nanoglState.fog = GL_TRUE;
 506                 statechanged = GL_TRUE;
 507                 }
 508             break;
 509             }
 510         case GL_LIGHTING:
 511             {
 512             if (!nanoglState.lighting)
 513                 {
 514                 nanoglState.lighting = GL_TRUE;
 515                 statechanged = GL_TRUE;
 516                 }
 517             break;
 518             }
 519         case GL_LINE_SMOOTH:
 520             {
 521             if (!nanoglState.line_smooth)
 522                 {
 523                 nanoglState.line_smooth = GL_TRUE;
 524                 statechanged = GL_TRUE;
 525                 }
 526             break;
 527             }
 528 /*        case GL_MATRIX_PALETTE_OES:
 529             {
 530             if (!nanoglState.matrix_palette_oes)
 531                 {
 532                 nanoglState.matrix_palette_oes = GL_TRUE;
 533                 statechanged = GL_TRUE;
 534                 }
 535             break;
 536             }*/
 537         case GL_MULTISAMPLE:
 538             {
 539             if (!nanoglState.multisample)
 540                 {
 541                 nanoglState.multisample = GL_TRUE;
 542                 statechanged = GL_TRUE;
 543                 }
 544             break;
 545             }
 546         case GL_NORMALIZE:
 547             {
 548             if (!nanoglState.normalize)
 549                 {
 550                 nanoglState.normalize = GL_TRUE;
 551                 statechanged = GL_TRUE;
 552                 }
 553             break;
 554             }
 555 /*        case GL_POINT_SPRITE_OES:
 556             {
 557             if (!nanoglState.point_sprite_oes)
 558                 {
 559                 nanoglState.point_sprite_oes = GL_TRUE;
 560                 statechanged = GL_TRUE;
 561                 }
 562             break;
 563             }*/
 564         case GL_POLYGON_OFFSET_FILL:
 565             {
 566             if (!nanoglState.polygon_offset_fill)
 567                 {
 568                 nanoglState.polygon_offset_fill = GL_TRUE;
 569                 statechanged = GL_TRUE;
 570                 }
 571             break;
 572             }
 573         case GL_RESCALE_NORMAL:
 574             {
 575             if (!nanoglState.rescale_normal)
 576                 {
 577                 nanoglState.rescale_normal = GL_TRUE;
 578                 statechanged = GL_TRUE;
 579                 }
 580             break;
 581             }
 582         case GL_SAMPLE_ALPHA_TO_COVERAGE:
 583             {
 584             if (!nanoglState.sample_alpha_to_coverage)
 585                 {
 586                 nanoglState.sample_alpha_to_coverage = GL_TRUE;
 587                 statechanged = GL_TRUE;
 588                 }
 589             break;
 590             }
 591         case GL_SAMPLE_ALPHA_TO_ONE:
 592             {
 593             if (!nanoglState.sample_alpha_to_one)
 594                 {
 595                 nanoglState.sample_alpha_to_one = GL_TRUE;
 596                 statechanged = GL_TRUE;
 597                 }
 598             break;
 599             }
 600         case GL_SAMPLE_COVERAGE:
 601             {
 602             if (!nanoglState.sample_coverage)
 603                 {
 604                 nanoglState.sample_coverage = GL_TRUE;
 605                 statechanged = GL_TRUE;
 606                 }
 607             break;
 608             }
 609         case GL_SCISSOR_TEST:
 610             {
 611             if (!nanoglState.scissor_test)
 612                 {
 613                 nanoglState.scissor_test = GL_TRUE;
 614                 statechanged = GL_TRUE;
 615                 }
 616             break;
 617             }
 618         case GL_STENCIL_TEST:
 619             {
 620             return;
 621 /*            if (!nanoglState.stencil_test)
 622                 {
 623                 nanoglState.stencil_test = GL_TRUE;
 624                 statechanged = GL_TRUE;
 625                 }*/
 626             break;
 627             }
 628         case GL_TEXTURE_2D:
 629             {
 630             if (!activetmuState->texture_2d.value)
 631                 {
 632                 FlushOnStateChange();
 633                 glEsImpl->glEnable(cap);
 634                 activetmuState->texture_2d.value = GL_TRUE;
 635                 return;
 636                 }
 637             break;
 638             }
 639         default:
 640             break;
 641         }
 642
 643     if (statechanged)
 644         {
 645         FlushOnStateChange();
 646         glEsImpl->glEnable(cap);
 647         }
 648     }
 649
 650 void glDisable (GLenum cap)
 651     {
 652     GLboolean statechanged = GL_FALSE;
 653     switch(cap)
 654         {
 655         case GL_ALPHA_TEST:
 656             {
 657             if (nanoglState.alpha_test)
 658                 {
 659                 nanoglState.alpha_test = GL_FALSE;
 660                 statechanged = GL_TRUE;
 661                 }
 662             break;
 663             }
 664         case GL_BLEND:
 665             {
 666             if (nanoglState.blend)
 667                 {
 668                 nanoglState.blend = GL_FALSE;
 669                 statechanged = GL_TRUE;
 670                 }
 671             break;
 672             }
 673         //case GL_CLIP_PLANEi
 674         case GL_COLOR_LOGIC_OP:
 675             {
 676             if (nanoglState.color_logic_op)
 677                 {
 678                 nanoglState.color_logic_op = GL_FALSE;
 679                 statechanged = GL_TRUE;
 680                 }
 681             break;
 682             }
 683         case GL_COLOR_MATERIAL:
 684             {
 685             if (nanoglState.color_material)
 686                 {
 687                 nanoglState.color_material = GL_FALSE;
 688                 statechanged = GL_TRUE;
 689                 }
 690             break;
 691             }
 692         case GL_CULL_FACE:
 693             {
 694             if (nanoglState.cull_face)
 695                 {
 696                 nanoglState.cull_face = GL_FALSE;
 697                 statechanged = GL_TRUE;
 698                 }
 699             break;
 700             }
 701         case GL_DEPTH_TEST:
 702             {
 703             if (nanoglState.depth_test)
 704                 {
 705                 nanoglState.depth_test = GL_FALSE;
 706                 statechanged = GL_TRUE;
 707                 }
 708             break;
 709             }
 710         case GL_DITHER:
 711             {
 712             if (nanoglState.dither)
 713                 {
 714                 nanoglState.dither = GL_FALSE;
 715                 statechanged = GL_TRUE;
 716                 }
 717             break;
 718             }
 719         case GL_FOG:
 720         //case GL_LIGHTi
 721             {
 722             if (nanoglState.fog)
 723                 {
 724                 nanoglState.fog = GL_FALSE;
 725                 statechanged = GL_TRUE;
 726                 }
 727             break;
 728             }
 729         case GL_LIGHTING:
 730             {
 731             if (nanoglState.lighting)
 732                 {
 733                 nanoglState.lighting = GL_FALSE;
 734                 statechanged = GL_TRUE;
 735                 }
 736             break;
 737             }
 738         case GL_LINE_SMOOTH:
 739             {
 740             if (nanoglState.line_smooth)
 741                 {
 742                 nanoglState.line_smooth = GL_FALSE;
 743                 statechanged = GL_TRUE;
 744                 }
 745             break;
 746             }
 747 /*        case GL_MATRIX_PALETTE_OES:
 748             {
 749             if (nanoglState.matrix_palette_oes)
 750                 {
 751                 nanoglState.matrix_palette_oes = GL_FALSE;
 752                 statechanged = GL_TRUE;
 753                 }
 754             break;
 755             }*/
 756         case GL_MULTISAMPLE:
 757             {
 758             if (nanoglState.multisample)
 759                 {
 760                 nanoglState.multisample = GL_FALSE;
 761                 statechanged = GL_TRUE;
 762                 }
 763             break;
 764             }
 765         case GL_NORMALIZE:
 766             {
 767             if (nanoglState.normalize)
 768                 {
 769                 nanoglState.normalize = GL_FALSE;
 770                 statechanged = GL_TRUE;
 771                 }
 772             break;
 773             }
 774 /*        case GL_POINT_SPRITE_OES:
 775             {
 776             if (nanoglState.point_sprite_oes)
 777                 {
 778                 nanoglState.point_sprite_oes = GL_FALSE;
 779                 statechanged = GL_TRUE;
 780                 }
 781             break;
 782             }*/
 783         case GL_POLYGON_OFFSET_FILL:
 784             {
 785             if (nanoglState.polygon_offset_fill)
 786                 {
 787                 nanoglState.polygon_offset_fill = GL_FALSE;
 788                 statechanged = GL_TRUE;
 789                 }
 790             break;
 791             }
 792         case GL_RESCALE_NORMAL:
 793             {
 794             if (nanoglState.rescale_normal)
 795                 {
 796                 nanoglState.rescale_normal = GL_FALSE;
 797                 statechanged = GL_TRUE;
 798                 }
 799             break;
 800             }
 801         case GL_SAMPLE_ALPHA_TO_COVERAGE:
 802             {
 803             if (nanoglState.sample_alpha_to_coverage)
 804                 {
 805                 nanoglState.sample_alpha_to_coverage = GL_FALSE;
 806                 statechanged = GL_TRUE;
 807                 }
 808             break;
 809             }
 810         case GL_SAMPLE_ALPHA_TO_ONE:
 811             {
 812             if (nanoglState.sample_alpha_to_one)
 813                 {
 814                 nanoglState.sample_alpha_to_one = GL_FALSE;
 815                 statechanged = GL_TRUE;
 816                 }
 817             break;
 818             }
 819         case GL_SAMPLE_COVERAGE:
 820             {
 821             if (nanoglState.sample_coverage)
 822                 {
 823                 nanoglState.sample_coverage = GL_FALSE;
 824                 statechanged = GL_TRUE;
 825                 }
 826             break;
 827             }
 828         case GL_SCISSOR_TEST:
 829             {
 830             if (nanoglState.scissor_test)
 831                 {
 832                 nanoglState.scissor_test = GL_FALSE;
 833                 statechanged = GL_TRUE;
 834                 }
 835             break;
 836             }
 837         case GL_STENCIL_TEST:
 838             {
 839             return;
 840 /*            if (nanoglState.stencil_test)
 841                 {
 842                 nanoglState.stencil_test = GL_FALSE;
 843                 statechanged = GL_TRUE;
 844                 }*/
 845             break;
 846             }
 847         case GL_TEXTURE_2D:
 848             {
 849             if (activetmuState->texture_2d.value)
 850                 {
 851                 FlushOnStateChange();
 852                 glEsImpl->glDisable(cap);
 853                 activetmuState->texture_2d.value = GL_FALSE;
 854                 return;
 855
 856
 857                 }
 858             break;
 859             }
 860         default:
 861             break;
 862         }
 863
 864     if (statechanged)
 865         {
 866         FlushOnStateChange();
 867         glEsImpl->glDisable(cap);
 868         }
 869     }
 870
 871 void glVertex2f(GLfloat x, GLfloat y)
 872     {
 873     glVertex3f(x,y,0.0f);
 874     }
 875
 876
 877 __FORCEINLINE unsigned int ClampTo255(float value)
 878     {
 879     unsigned int retval = (unsigned int)(value);
 880     if (retval > 255)
 881         {
 882         retval = 255;
 883         }
 884     return retval;
 885     }
 886
 887 void glColor3f( GLfloat red, GLfloat green, GLfloat blue)
 888     {
 889     currentVertexAttrib.red = (unsigned char)ClampTo255(red*255.0f);
 890     currentVertexAttrib.green = (unsigned char)ClampTo255(green*255.0f);
 891     currentVertexAttrib.blue = (unsigned char)ClampTo255(blue*255.0f);
 892     currentVertexAttrib.alpha = 255;
 893     }
 894
 895
 896 void glTexCoord2fv( const GLfloat *v )
 897     {
 898     memcpy(&currentVertexAttrib.s, v, 2*sizeof(float));
 899     }
 900
 901
 902 void glTexCoord2f(GLfloat s, GLfloat t)
 903     {
 904     currentVertexAttrib.s = s;
 905     currentVertexAttrib.t = t;
 906     }
 907
 908 void glViewport (GLint x, GLint y, GLsizei width, GLsizei height)
 909     {
 910     FlushOnStateChange();
 911     glEsImpl->glViewport(x,y,width,height);
 912     }
 913
 914 void glLoadIdentity (void)
 915     {
 916     FlushOnStateChange();
 917     glEsImpl->glLoadIdentity();
 918     }
 919
 920 void glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 921     {
 922     currentVertexAttrib.red = (unsigned char)ClampTo255(red*255.0f);
 923     currentVertexAttrib.green = (unsigned char)ClampTo255(green*255.0f);
 924     currentVertexAttrib.blue = (unsigned char)ClampTo255(blue*255.0f);
 925     currentVertexAttrib.alpha = (unsigned char)ClampTo255(alpha*255.0f);
 926     }
 927
 928 void glOrtho (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
 929     {
 930     FlushOnStateChange();
 931     glEsImpl->glOrthof(left,right,bottom,top, zNear,zFar);
 932     }
 933
 934 void glMatrixMode (GLenum mode)
 935     {
 936     if (nanoglState.matrixmode == mode)
 937         {
 938         return;
 939         }
 940     nanoglState.matrixmode = mode;
 941     FlushOnStateChange();
 942     glEsImpl->glMatrixMode(mode);
 943     }
 944
 945 void glTexParameterf (GLenum target, GLenum pname, GLfloat param)
 946     {
 947     if (pname == GL_TEXTURE_BORDER_COLOR)
 948         {
 949         return; // not supported by opengl es
 950         }
 951     if (    (pname == GL_TEXTURE_WRAP_S ||
 952              pname == GL_TEXTURE_WRAP_T) &&
 953              param == GL_CLAMP)
 954              {
 955              param = 0x812F;
 956              }
 957
 958     FlushOnStateChange();
 959     glEsImpl->glTexParameterf(target, pname,param);
 960     }
 961
 962 void glTexParameterfv(  GLenum target, GLenum pname, const GLfloat *params)
 963     {
 964     glTexParameterf(target, pname, params[0]);
 965     }
 966
 967 void glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 968     {
 969     FlushOnStateChange();
 970     internalformat = format;
 971     glEsImpl->glTexImage2D(target, level, internalformat, width, height,border,format,type,pixels);
 972     }
 973
 974 void glDrawBuffer(GLenum /*mode*/)
 975     {
 976     }
 977
 978 void glTranslatef (GLfloat x, GLfloat y, GLfloat z)
 979     {
 980     FlushOnStateChange();
 981     glEsImpl->glTranslatef(x,y,z);
 982     }
 983
 984 void glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 985     {
 986     FlushOnStateChange();
 987     glEsImpl->glRotatef(angle, x, y, z);
 988     }
 989
 990 void glScalef (GLfloat x, GLfloat y, GLfloat z)
 991     {
 992     FlushOnStateChange();
 993     glEsImpl->glScalef(x,y,z);
 994     }
 995
 996 void glDepthRange(GLclampf zNear, GLclampf zFar)
 997     {
 998     if ((nanoglState.depth_range_near == zNear) &&(nanoglState.depth_range_far == zFar))
 999         {
1000         return;
1001         }
1002     else
1003         {
1004         nanoglState.depth_range_near = zNear;
1005         nanoglState.depth_range_far = zFar;
1006         }
1007     FlushOnStateChange();
1008     glEsImpl->glDepthRangef(zNear, zFar);
1009     }
1010
1011 void glDepthFunc (GLenum func)
1012     {
1013     if (nanoglState.depth_func == func)
1014         {
1015         return;
1016         }
1017     else
1018         {
1019         nanoglState.depth_func = func;
1020         }
1021     FlushOnStateChange();
1022     glEsImpl->glDepthFunc(func);
1023     }
1024
1025 void glFinish (void)
1026     {
1027     FlushOnStateChange();
1028     glEsImpl->glFinish();
1029     }
1030
1031 void glGetFloatv (GLenum pname, GLfloat *params)
1032     {
1033     FlushOnStateChange();
1034     glEsImpl->glGetFloatv(pname, params);
1035     }
1036
1037 void glCullFace (GLenum mode)
1038     {
1039     if (nanoglState.cullface == mode)
1040         {
1041         return;
1042         }
1043     else
1044         {
1045         nanoglState.cullface = mode;
1046         }
1047     FlushOnStateChange();
1048     glEsImpl->glCullFace(mode);
1049     }
1050
1051 void glFrustum (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
1052     {
1053     FlushOnStateChange();
1054     glEsImpl->glFrustumf(left,right,bottom,top,zNear,zFar);
1055     }
1056
1057 void glClear (GLbitfield mask)
1058     {
1059     FlushOnStateChange();
1060     glEsImpl->glClear(mask);
1061     }
1062
1063
1064 void glVertex3f( GLfloat x, GLfloat y, GLfloat z )
1065     {
1066     GLfloat* vert = (GLfloat*)ptrVertexAttribArray++;
1067     *vert++ = x;
1068     *vert++ = y;
1069     *vert++ = z;
1070 #if defined(__MULTITEXTURE_SUPPORT__)
1071     memcpy(vert, &currentVertexAttrib.red, 5*sizeof(GLfloat));
1072 #else
1073     memcpy(vert+1, &currentVertexAttrib.red, 3*sizeof(GLfloat));
1074 #endif
1075
1076     }
1077
1078 void glColor4fv( const GLfloat *v )
1079     {
1080     currentVertexAttrib.red = (unsigned char)ClampTo255(v[0]*255.0f);
1081     currentVertexAttrib.green = (unsigned char)ClampTo255(v[1]*255.0f);
1082     currentVertexAttrib.blue = (unsigned char)ClampTo255(v[2]*255.0f);
1083     currentVertexAttrib.alpha = (unsigned char)ClampTo255(v[3]*255.0f);
1084     }
1085
1086 void glColor3ubv( const GLubyte* v)
1087     {
1088     currentVertexAttrib.red = v[0];
1089     currentVertexAttrib.green = v[1];
1090     currentVertexAttrib.blue = v[2];
1091     currentVertexAttrib.alpha = 255;
1092     }
1093
1094 void glColor4ubv( const GLubyte *v )
1095     {
1096     //*((unsigned int*)(&currentVertexAttrib.red)) = *((unsigned int*)(v));
1097     currentVertexAttrib.red = v[0];
1098     currentVertexAttrib.green = v[1];
1099     currentVertexAttrib.blue = v[2];
1100     currentVertexAttrib.alpha = v[3];
1101     }
1102
1103 void glColor3fv( const GLfloat *v )
1104     {
1105     currentVertexAttrib.red = (unsigned char)ClampTo255(v[0]*255.0f);
1106     currentVertexAttrib.green = (unsigned char)ClampTo255(v[1]*255.0f);
1107     currentVertexAttrib.blue = (unsigned char)ClampTo255(v[2]*255.0f);
1108     currentVertexAttrib.alpha = 255;
1109     }
1110
1111 //-- nicknekit: xash3d funcs --
1112
1113 void glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
1114     {
1115     currentVertexAttrib.red = red;
1116     currentVertexAttrib.green = green;
1117     currentVertexAttrib.blue = blue;
1118     currentVertexAttrib.alpha = alpha;
1119     }
1120
1121 void glColor3ub( GLubyte red, GLubyte green, GLubyte blue)
1122     {
1123     currentVertexAttrib.red = red;
1124     currentVertexAttrib.green = green;
1125     currentVertexAttrib.blue = blue;
1126     currentVertexAttrib.alpha = 255;
1127     }
1128
1129 void glNormal3fv( const GLfloat *v )
1130     {
1131     FlushOnStateChange();
1132     glEsImpl->glNormal3f(v[0],v[1],v[2]);
1133     }
1134
1135 void glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
1136     {
1137     FlushOnStateChange();
1138     glEsImpl->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
1139     }
1140
1141 void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
1142     {
1143     glTexImage2D(GL_TEXTURE_2D, level, internalformat,  width, 1, border, format, type, pixels);
1144     }
1145
1146 void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
1147     {
1148     glTexImage2D(GL_TEXTURE_2D, level, internalformat,  width, height, border, format, type, pixels);
1149     }
1150
1151 void glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels )
1152     {
1153     glTexSubImage2D(target,level,xoffset,0,width,1,format,type,pixels);
1154     }
1155
1156 void glTexSubImage3D( GLenum target, GLint level,
1157                                          GLint xoffset, GLint yoffset,
1158                                          GLint zoffset, GLsizei width,
1159                                          GLsizei height, GLsizei depth,
1160                                          GLenum format,
1161                                          GLenum type, const GLvoid *pixels)
1162     {
1163     glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixels);
1164     }
1165
1166
1167
1168 GLboolean glIsTexture(GLuint texture)
1169     {
1170     FlushOnStateChange();
1171     return glEsImpl->glIsTexture(texture);
1172     }
1173
1174
1175 void glTexGeni( GLenum coord, GLenum pname, GLint param )
1176 {
1177 //for mirrors? not needed for original hl?
1178 }
1179
1180 void glTexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
1181 {
1182 //for mirrors? not needed for original hl?
1183 }
1184
1185 //-- --//
1186
1187 void glHint (GLenum target, GLenum mode)
1188     {
1189     FlushOnStateChange();
1190     glEsImpl->glHint(target, mode);
1191     }
1192
1193 void glBlendFunc (GLenum sfactor, GLenum dfactor)
1194     {
1195     if ((nanoglState.sfactor == sfactor) && (nanoglState.dfactor == dfactor))
1196         {
1197         return;
1198         }
1199     nanoglState.sfactor = sfactor;
1200     nanoglState.dfactor = dfactor;
1201     FlushOnStateChange();
1202     glEsImpl->glBlendFunc(sfactor, dfactor);
1203     }
1204
1205 void glPopMatrix (void)
1206     {
1207     FlushOnStateChange();
1208     glEsImpl->glPopMatrix();
1209     }
1210
1211 void glShadeModel (GLenum mode)
1212     {
1213     if (nanoglState.shademodel == mode)
1214         {
1215         return;
1216         }
1217     nanoglState.shademodel = mode;
1218     FlushOnStateChange();
1219     glEsImpl->glShadeModel(mode);
1220     }
1221
1222 void glPushMatrix (void)
1223     {
1224     FlushOnStateChange();
1225     glEsImpl->glPushMatrix();
1226     }
1227
1228 void glTexEnvf (GLenum target, GLenum pname, GLfloat param)
1229     {
1230     if (target == GL_TEXTURE_ENV)
1231         {
1232         if (pname == GL_TEXTURE_ENV_MODE)
1233             {
1234             if (param == activetmuState->texture_env_mode.value)
1235                 {
1236                 return;
1237                 }
1238             else
1239                 {
1240                 FlushOnStateChange();
1241                 glEsImpl->glTexEnvf(target, pname, param);
1242                 activetmuState->texture_env_mode.value = param;
1243                 return;
1244                 }
1245             }
1246         }
1247     FlushOnStateChange();
1248     glEsImpl->glTexEnvf(target, pname, param);
1249     }
1250
1251 void glVertex3fv( const GLfloat *v )
1252     {
1253     GLfloat* vert = (GLfloat*)ptrVertexAttribArray++;
1254     memcpy(vert, v, 3*sizeof(GLfloat));
1255 #if defined(__MULTITEXTURE_SUPPORT__)
1256     memcpy(vert+3, &currentVertexAttrib.red, 5*sizeof(GLfloat));
1257 #else
1258     memcpy(vert+4, &currentVertexAttrib.red, 3*sizeof(GLfloat));
1259 #endif
1260     }
1261
1262
1263 void glDepthMask (GLboolean flag)
1264     {
1265     if (nanoglState.depthmask == flag)
1266         {
1267         return;
1268         }
1269     nanoglState.depthmask = flag;
1270     FlushOnStateChange();
1271     glEsImpl->glDepthMask(flag);
1272     }
1273
1274 void glBindTexture (GLenum target, GLuint texture)
1275     {
1276     if (activetmuState->boundtexture.value == texture)
1277         {
1278         return;
1279         }
1280     FlushOnStateChange();
1281     activetmuState->boundtexture.value = texture;
1282     glEsImpl->glBindTexture(target, texture);
1283     }
1284
1285
1286 void glGetIntegerv (GLenum pname, GLint *params)
1287     {
1288     FlushOnStateChange();
1289     glEsImpl->glGetIntegerv(pname, params);
1290     }
1291
1292 GLubyte nano_extensions_string[4096];
1293 const GLubyte* glGetString (GLenum name)
1294     {
1295
1296     if (name == GL_EXTENSIONS)
1297         {
1298 #if defined(__MULTITEXTURE_SUPPORT__)
1299         sprintf((char*)nano_extensions_string,"%s %s",glEsImpl->glGetString(name),"GL_ARB_multitexture EXT_texture_env_add");
1300 #else
1301         sprintf((char*)nano_extensions_string,"%s %s",glEsImpl->glGetString(name),"EXT_texture_env_add");
1302 #endif
1303         return nano_extensions_string;
1304         }
1305     return glEsImpl->glGetString(name);
1306     }
1307
1308 void glAlphaFunc (GLenum func, GLclampf ref)
1309     {
1310     FlushOnStateChange();
1311     glEsImpl->glAlphaFunc(func,ref);
1312     }
1313
1314 void glFlush (void)
1315     {
1316     FlushOnStateChange();
1317     glEsImpl->glFlush();
1318     }
1319
1320 void glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
1321     {
1322     if (format == GL_DEPTH_COMPONENT)
1323         {
1324         // OpenglEs 1.1 does not support reading depth buffer without an extension
1325         memset(pixels, 0xff,4);
1326         return;
1327         }
1328     FlushOnStateChange();
1329     glEsImpl->glReadPixels(x,y,width,height,format,type,pixels);
1330     }
1331
1332 void glReadBuffer( GLenum /*mode*/ )
1333     {
1334
1335     }
1336
1337 void glLoadMatrixf (const GLfloat *m)
1338     {
1339     FlushOnStateChange();
1340     glEsImpl->glLoadMatrixf(m);
1341     }
1342
1343 void glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
1344     {
1345     FlushOnStateChange();
1346     glEsImpl->glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixels);
1347     }
1348
1349 void glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
1350     {
1351     FlushOnStateChange();
1352     glEsImpl->glClearColor(red,green,blue,alpha);
1353     }
1354
1355 GLenum glGetError (void)
1356     {
1357     FlushOnStateChange();
1358     return GL_NO_ERROR;//glEsImpl->glGetError();
1359     }
1360
1361 void glActiveTexture (GLenum texture)
1362     {
1363     if (activetmu == texture)
1364         {
1365         return;
1366         }
1367     if (delayedttmuchange)
1368         {
1369         delayedttmuchange = GL_FALSE;
1370         }
1371     else
1372         {
1373         delayedttmuchange = GL_TRUE;
1374         delayedtmutarget = texture;
1375         }
1376     if (texture == GL_TEXTURE0)
1377         {
1378         activetmuState = &tmuState0;
1379         }
1380     else
1381         {
1382         activetmuState = &tmuState1;
1383         }
1384     activetmu = texture;
1385     }
1386
1387 void glClientActiveTexture (GLenum texture)
1388     {
1389     clientactivetmu = texture;
1390     }
1391
1392 void glPolygonMode( GLenum face, GLenum mode )
1393     {
1394     }
1395
1396 void glDeleteTextures( GLsizei n, const GLuint *textures )
1397     {
1398     FlushOnStateChange();
1399     glEsImpl->glDeleteTextures(n,textures);
1400     }
1401
1402 void glClearDepth( GLclampf depth )
1403     {
1404     FlushOnStateChange();
1405     glEsImpl->glClearDepthf( depth );
1406     }
1407
1408 void glClipPlane( GLenum plane, const GLdouble *equation )
1409     {
1410     FlushOnStateChange();
1411     float array[4];
1412     array[0] = (GLfloat)(equation[0]);
1413     array[1] = (GLfloat)(equation[1]);
1414     array[2] = (GLfloat)(equation[2]);
1415     array[3] = (GLfloat)(equation[3]);
1416     glEsImpl->glClipPlanef( plane, array );
1417     }
1418
1419 void glScissor( GLint x, GLint  y, GLsizei width, GLsizei height )
1420     {
1421     FlushOnStateChange();
1422     glEsImpl->glScissor( x, y, width,height);
1423     }
1424
1425 void glPointSize( GLfloat size )
1426     {
1427     FlushOnStateChange();
1428     glEsImpl->glPointSize( size );
1429     }
1430
1431 void glArrayElement(GLint i) {}
1432 void glLineWidth(GLfloat width) {}
1433 void glCallList( GLuint list ) {}
1434 void glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) {}
1435 void glStencilFunc( GLenum func, GLint ref, GLuint mask ) {}
1436 void glStencilOp( GLenum fail, GLenum zfail, GLenum zpass ) {}
1437
1438 struct ptrstate vertex_array;
1439 struct ptrstate color_array;
1440 struct ptrstate texture_coord_array;
1441
1442 void glDrawElements( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices )
1443     {
1444     // ensure that all primitives specified between glBegin/glEnd pairs
1445     // are rendered first, and that we have correct tmu in use..
1446     FlushOnStateChange();
1447     // setup correct vertex/color/texcoord pointers
1448     if (arraysValid ||
1449         tmuState0.vertex_array.changed ||
1450         tmuState0.color_array.changed ||
1451         tmuState0.texture_coord_array.changed)
1452         {
1453         glEsImpl->glClientActiveTexture(GL_TEXTURE0);
1454         }
1455     if (arraysValid || tmuState0.vertex_array.changed)
1456         {
1457         if (tmuState0.vertex_array.enabled)
1458             {
1459             glEsImpl->glEnableClientState(GL_VERTEX_ARRAY);
1460             }
1461         else
1462             {
1463             glEsImpl->glDisableClientState(GL_VERTEX_ARRAY);
1464             }
1465         glEsImpl->glVertexPointer(tmuState0.vertex_array.size,
1466                                   tmuState0.vertex_array.type,
1467                                   tmuState0.vertex_array.stride,
1468                                   tmuState0.vertex_array.ptr);
1469         tmuState0.vertex_array.changed = GL_FALSE;
1470         }
1471     if (arraysValid || tmuState0.color_array.changed)
1472         {
1473         if (tmuState0.color_array.enabled)
1474             {
1475             glEsImpl->glEnableClientState(GL_COLOR_ARRAY);
1476             }
1477         else
1478             {
1479             glEsImpl->glDisableClientState(GL_COLOR_ARRAY);
1480             }
1481         glEsImpl->glColorPointer(tmuState0.color_array.size,
1482                                  tmuState0.color_array.type,
1483                                  tmuState0.color_array.stride,
1484                                  tmuState0.color_array.ptr);
1485         tmuState0.color_array.changed = GL_FALSE;
1486         }
1487     if (arraysValid || tmuState0.texture_coord_array.changed)
1488         {
1489         tmuState0.texture_coord_array.changed = GL_FALSE;
1490         if (tmuState0.texture_coord_array.enabled)
1491             {
1492             glEsImpl->glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1493             }
1494         else
1495             {
1496             glEsImpl->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1497             }
1498         glEsImpl->glTexCoordPointer(tmuState0.texture_coord_array.size,
1499                                         tmuState0.texture_coord_array.type,
1500                                         tmuState0.texture_coord_array.stride,
1501                                         tmuState0.texture_coord_array.ptr);
1502         }
1503
1504     if (arraysValid || tmuState1.texture_coord_array.changed)
1505         {
1506         tmuState1.texture_coord_array.changed = GL_FALSE;
1507         glEsImpl->glClientActiveTexture(GL_TEXTURE1);
1508         if (tmuState1.texture_coord_array.enabled)
1509             {
1510             glEsImpl->glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1511             }
1512         else
1513             {
1514             glEsImpl->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1515             }
1516         glEsImpl->glTexCoordPointer(tmuState1.texture_coord_array.size,
1517                                         tmuState1.texture_coord_array.type,
1518                                         tmuState1.texture_coord_array.stride,
1519                                         tmuState1.texture_coord_array.ptr);
1520         }
1521
1522     arraysValid = GL_FALSE;
1523     glEsImpl->glDrawElements(mode, count, type, indices);
1524     }
1525
1526 void glEnableClientState(GLenum  array)
1527     {
1528     struct nanotmuState* clientstate = NULL;
1529     if (clientactivetmu == GL_TEXTURE0)
1530         {
1531         clientstate = &tmuState0;
1532         }
1533     else if (clientactivetmu == GL_TEXTURE1)
1534         {
1535         clientstate = &tmuState1;
1536         }
1537     else
1538         {
1539         return;
1540         }
1541     switch (array)
1542         {
1543         case GL_VERTEX_ARRAY:
1544             if (clientstate->vertex_array.enabled)
1545                 {
1546                 return;
1547                 }
1548             clientstate->vertex_array.enabled = GL_TRUE;
1549             clientstate->vertex_array.changed = GL_TRUE;
1550             break;
1551         case GL_COLOR_ARRAY:
1552             if (clientstate->color_array.enabled)
1553                 {
1554                 return;
1555                 }
1556             clientstate->color_array.enabled = GL_TRUE;
1557             clientstate->color_array.changed = GL_TRUE;
1558
1559             break;
1560         case GL_TEXTURE_COORD_ARRAY:
1561             if (clientstate->texture_coord_array.enabled)
1562                 {
1563                 return;
1564                 }
1565             clientstate->texture_coord_array.enabled = GL_TRUE;
1566             clientstate->texture_coord_array.changed = GL_TRUE;
1567             break;
1568         default:
1569             break;
1570         }
1571     }
1572 void glDisableClientState(GLenum  array)
1573     {
1574     struct nanotmuState* clientstate = NULL;
1575     if (clientactivetmu == GL_TEXTURE0)
1576         {
1577         clientstate = &tmuState0;
1578         }
1579     else if (clientactivetmu == GL_TEXTURE1)
1580         {
1581         clientstate = &tmuState1;
1582         }
1583     else
1584         {
1585         return;
1586         }
1587     switch (array)
1588         {
1589         case GL_VERTEX_ARRAY:
1590             if (!clientstate->vertex_array.enabled)
1591                 {
1592                 return;
1593                 }
1594             clientstate->vertex_array.enabled = GL_FALSE;
1595             clientstate->vertex_array.changed = GL_TRUE;
1596             break;
1597         case GL_COLOR_ARRAY:
1598             if (!clientstate->color_array.enabled)
1599                 {
1600                 return;
1601                 }
1602             clientstate->color_array.enabled = GL_FALSE;
1603             clientstate->color_array.changed = GL_TRUE;
1604
1605             break;
1606         case GL_TEXTURE_COORD_ARRAY:
1607             if (!clientstate->texture_coord_array.enabled)
1608                 {
1609                 return;
1610                 }
1611             clientstate->texture_coord_array.enabled = GL_FALSE;
1612             clientstate->texture_coord_array.changed = GL_TRUE;
1613             break;
1614         default:
1615             break;
1616         }
1617     }
1618 void glVertexPointer(   GLint size,     GLenum type,GLsizei     stride, const GLvoid *pointer )
1619     {
1620     if (tmuState0.vertex_array.size == size &&
1621         tmuState0.vertex_array.stride == stride &&
1622         tmuState0.vertex_array.type == type &&
1623         tmuState0.vertex_array.ptr == pointer)
1624         {
1625         return;
1626         }
1627     tmuState0.vertex_array.size = size;
1628     tmuState0.vertex_array.stride = stride;
1629     tmuState0.vertex_array.type = type;
1630     tmuState0.vertex_array.ptr  = (GLvoid*)pointer;
1631     tmuState0.vertex_array.changed = GL_TRUE;
1632     }
1633 void glTexCoordPointer( GLint   size,  GLenum type,  GLsizei stride,  const     GLvoid *pointer )
1634     {
1635     struct nanotmuState* clientstate = NULL;
1636     if (clientactivetmu == GL_TEXTURE0)
1637         {
1638         clientstate = &tmuState0;
1639         }
1640     else if (clientactivetmu == GL_TEXTURE1)
1641         {
1642         clientstate = &tmuState1;
1643         }
1644     if (clientstate->texture_coord_array.size == size &&
1645         clientstate->texture_coord_array.stride == stride &&
1646         clientstate->texture_coord_array.type == type &&
1647         clientstate->texture_coord_array.ptr == pointer)
1648         {
1649         return;
1650         }
1651     clientstate->texture_coord_array.size = size;
1652     clientstate->texture_coord_array.stride = stride;
1653     clientstate->texture_coord_array.type = type;
1654     clientstate->texture_coord_array.ptr  = (GLvoid*)pointer;
1655     clientstate->texture_coord_array.changed = GL_TRUE;
1656     }
1657 void glColorPointer( GLint size,  GLenum type,  GLsizei stride,  const GLvoid *pointer )
1658     {
1659     if (tmuState0.color_array.size == size &&
1660         tmuState0.color_array.stride == stride &&
1661         tmuState0.color_array.type == type &&
1662         tmuState0.color_array.ptr == pointer)
1663         {
1664         return;
1665         }
1666     tmuState0.color_array.size = size;
1667     tmuState0.color_array.stride = stride;
1668     tmuState0.color_array.type = type;
1669     tmuState0.color_array.ptr  = (GLvoid*)pointer;
1670     tmuState0.color_array.changed = GL_TRUE;
1671     }
1672 void glPolygonOffset( GLfloat factor, GLfloat units )
1673     {
1674     FlushOnStateChange();
1675     glEsImpl->glPolygonOffset(factor, units);
1676     }
1677 void glStencilMask( GLuint mask ) {}
1678 void glClearStencil( GLint s ) {}
1679
1680 #if defined(__MULTITEXTURE_SUPPORT__)
1681
1682 extern "C" void glMultiTexCoord2fARB( GLenum target, GLfloat s, GLfloat t );
1683
1684 void glMultiTexCoord2fARB( GLenum target, GLfloat s, GLfloat t )
1685     {
1686     if (target == GL_TEXTURE0)
1687         {
1688         glTexCoord2f(s,t);
1689         }
1690     else
1691         {
1692         currentVertexAttrib.s_multi = s;
1693         currentVertexAttrib.t_multi = t;
1694         }
1695     }
1696 #endif
1697
1698 /* Vladimir  */
1699 void glDrawArrays( GLenum mode, int first, int count)
1700 {
1701     FlushOnStateChange();
1702     glEsImpl->glDrawArrays(mode, first , count);
1703 }
1704 void glMultMatrixf (const GLfloat *m)
1705 {
1706     FlushOnStateChange();
1707     glEsImpl->glMultMatrixf(m);
1708 }
1709
1710 void glPixelStorei (GLenum pname, GLint param)
1711 {
1712     FlushOnStateChange();
1713     glEsImpl->glPixelStorei(pname, param);
1714 }
1715
1716
1717 void glFogf (GLenum pname, GLfloat param)
1718 {
1719         FlushOnStateChange();
1720         glEsImpl->glFogf(pname, param);
1721 }
1722
1723 void glFogfv (GLenum pname, const GLfloat *params)
1724 {
1725         FlushOnStateChange();
1726         glEsImpl->glFogfv(pname, params);
1727 }
1728
1729 void glGetTexParameteriv (GLenum target, GLenum pname, GLint *params)
1730 {
1731         FlushOnStateChange();
1732         glEsImpl->glGetTexParameteriv(target, pname, params);
1733 }
1734
1735
1736 // This gives: called unimplemented OpenGL ES API (Android)
1737 void glTexParameteri (GLenum target, GLenum pname, GLint param)
1738 {
1739     if (pname == GL_TEXTURE_BORDER_COLOR) {
1740                 return; // not supported by opengl es
1741         }
1742     if (    (pname == GL_TEXTURE_WRAP_S ||
1743              pname == GL_TEXTURE_WRAP_T) &&
1744              param == GL_CLAMP)   {
1745                 param = 0x812F;
1746         }
1747
1748         FlushOnStateChange();
1749         glEsImpl->glTexParameteri(target, pname, param);
1750 }
1751
1752 void glTexParameterx (GLenum target, GLenum pname, GLfixed param)
1753 {
1754     if (pname == GL_TEXTURE_BORDER_COLOR) {
1755                 return; // not supported by opengl es
1756         }
1757     if (    (pname == GL_TEXTURE_WRAP_S ||
1758              pname == GL_TEXTURE_WRAP_T) &&
1759              param == GL_CLAMP)   {
1760                 param = 0x812F;
1761         }
1762         FlushOnStateChange();
1763         glEsImpl->glTexParameterx(target, pname, param);
1764 }
1765
1766 void glGenTextures (GLsizei n, GLuint *textures)
1767 {
1768         FlushOnStateChange();
1769         glEsImpl->glGenTextures(n, textures);
1770 }
1771
1772 void glFrontFace (GLenum mode)
1773 {
1774         FlushOnStateChange();
1775         glEsImpl->glFrontFace(mode);
1776 }
1777
1778
1779
1780 // End Vladimir
1781
1782
1783