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