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 glGetDoublev( GLenum pname, GLdouble *params)
1180     {
1181     glGetFloatv( pname, (GLfloat *)params );
1182     }
1183
1184 void glIndexPointer( GLenum type, GLsizei stride, const GLvoid *pointer ) { }
1185 void glTexCoord1f( GLfloat s )
1186 {
1187     glTexCoord2f( s, 0 );
1188 }
1189
1190 void glTexCoord3f( GLfloat s, GLfloat t, GLfloat r )
1191 {
1192     glTexCoord2f( s, t );
1193 }
1194
1195 void glTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q)
1196 {
1197     glTexCoord2f( s, t );
1198 }
1199
1200 void glTexGenf( GLenum coord, GLenum pname, GLfloat param )
1201 {
1202
1203 }
1204
1205 void glRasterPos2f( GLfloat x, GLfloat y ) { }
1206
1207 void glPushAttrib( GLbitfield mask ) { }
1208
1209 void glPopAttrib( ) { }
1210
1211 void glLoadMatrixd( GLdouble *m )
1212 {
1213     glLoadMatrixf( (GLfloat *)m);
1214 }
1215
1216 void glMultMatrixd( GLdouble *m )
1217 {
1218     glMultMatrixf( (GLfloat *)m );
1219 }
1220
1221 void glRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
1222 {
1223     glRotatef( angle, x, y, z );
1224 }
1225
1226 void glScaled( GLdouble x, GLdouble y, GLdouble z)
1227 {
1228     glScalef( x, y, z );
1229 }
1230
1231 void glTranslated( GLdouble x, GLdouble y, GLdouble z )
1232 {
1233     glTranslatef( x, y, z);
1234 }
1235
1236 void glDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels ) { }
1237
1238 GLboolean glIsList( GLuint list ) { }
1239
1240 void glPixelStoref( GLenum pname, GLfloat param )
1241 {
1242     glPixelStorei( pname, param );
1243 }
1244
1245 void glCopyTexImage1D( GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border )
1246 {
1247     glCopyTexImage2D( target, level, internalFormat, x, y, width, 0, border );
1248 }
1249
1250 void glCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width )
1251 {
1252         glCopyTexSubImage2D( target, level, xoffset, 0, x, y, width, 0 );
1253 }
1254
1255 void glPolygonStipple( const GLubyte *mask ) { }
1256
1257 void glGetClipPlane( GLenum plane, const GLdouble *equation ) { }
1258
1259 void glFogi( GLenum pname, GLint param )
1260 {
1261     glFogf( pname, param );
1262 }
1263
1264 void glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
1265     {
1266     currentVertexAttrib.red = red;
1267     currentVertexAttrib.green = green;
1268     currentVertexAttrib.blue = blue;
1269     currentVertexAttrib.alpha = alpha;
1270     }
1271
1272 void glColor3ub( GLubyte red, GLubyte green, GLubyte blue)
1273     {
1274     currentVertexAttrib.red = red;
1275     currentVertexAttrib.green = green;
1276     currentVertexAttrib.blue = blue;
1277     currentVertexAttrib.alpha = 255;
1278     }
1279
1280 void glNormal3fv( const GLfloat *v )
1281     {
1282     FlushOnStateChange();
1283     glEsImpl->glNormal3f(v[0],v[1],v[2]);
1284     }
1285
1286 void glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
1287     {
1288     FlushOnStateChange();
1289     glEsImpl->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
1290     }
1291
1292 void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
1293     {
1294     glTexImage2D(GL_TEXTURE_2D, level, internalformat,  width, 1, border, format, type, pixels);
1295     }
1296
1297 void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
1298     {
1299     glTexImage2D(GL_TEXTURE_2D, level, internalformat,  width, height, border, format, type, pixels);
1300     }
1301
1302 void glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels )
1303     {
1304     glTexSubImage2D(target,level,xoffset,0,width,1,format,type,pixels);
1305     }
1306
1307 void glTexSubImage3D( GLenum target, GLint level,
1308                                          GLint xoffset, GLint yoffset,
1309                                          GLint zoffset, GLsizei width,
1310                                          GLsizei height, GLsizei depth,
1311                                          GLenum format,
1312                                          GLenum type, const GLvoid *pixels)
1313     {
1314     glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixels);
1315     }
1316
1317
1318
1319 GLboolean glIsTexture(GLuint texture)
1320     {
1321     FlushOnStateChange();
1322     return glEsImpl->glIsTexture(texture);
1323     }
1324
1325
1326 void glTexGeni( GLenum coord, GLenum pname, GLint param )
1327 {
1328 //for mirrors? not needed for original hl?
1329 }
1330
1331 void glTexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
1332 {
1333 //for mirrors? not needed for original hl?
1334 }
1335
1336 void glTexEnvi( GLenum target, GLenum pname, GLint param )
1337 {
1338         FlushOnStateChange();
1339         glEsImpl->glTexEnvi( target, pname, param );
1340 }
1341
1342 void glTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
1343 {
1344         for( ; params; params++ )
1345         {
1346                 glTexEnvf( target, pname, *params );
1347         }
1348 }
1349
1350 void glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
1351 {
1352         FlushOnStateChange();
1353         glEsImpl->glCopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height );
1354 }
1355
1356 void glGetTexEnviv( GLenum target, GLenum pname, GLint *params )
1357 {
1358         FlushOnStateChange();
1359         glEsImpl->glGetTexEnviv( target, pname, params );
1360 }
1361
1362 void glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz )
1363 {
1364         FlushOnStateChange();
1365         glEsImpl->glNormal3f( nx, ny, nz );
1366 }
1367
1368 void glGetBooleanv( GLenum pname, GLboolean *params )
1369 {
1370         FlushOnStateChange();
1371         glEsImpl->glGetBooleanv( pname, params );
1372 }
1373
1374 void glNormalPointer( GLenum type, GLsizei stride, const GLvoid *pointer )
1375 {
1376         FlushOnStateChange();
1377         glEsImpl->glNormalPointer( type, stride, pointer );
1378 }
1379
1380 void glIsEnabled( GLenum cap )
1381 {
1382         FlushOnStateChange();
1383         glEsImpl->glIsEnabled( cap );
1384 }
1385
1386 //-- --//
1387
1388 void glHint (GLenum target, GLenum mode)
1389     {
1390     FlushOnStateChange();
1391     glEsImpl->glHint(target, mode);
1392     }
1393
1394 void glBlendFunc (GLenum sfactor, GLenum dfactor)
1395     {
1396     if ((nanoglState.sfactor == sfactor) && (nanoglState.dfactor == dfactor))
1397         {
1398         return;
1399         }
1400     nanoglState.sfactor = sfactor;
1401     nanoglState.dfactor = dfactor;
1402     FlushOnStateChange();
1403     glEsImpl->glBlendFunc(sfactor, dfactor);
1404     }
1405
1406 void glPopMatrix (void)
1407     {
1408     FlushOnStateChange();
1409     glEsImpl->glPopMatrix();
1410     }
1411
1412 void glShadeModel (GLenum mode)
1413     {
1414     if (nanoglState.shademodel == mode)
1415         {
1416         return;
1417         }
1418     nanoglState.shademodel = mode;
1419     FlushOnStateChange();
1420     glEsImpl->glShadeModel(mode);
1421     }
1422
1423 void glPushMatrix (void)
1424     {
1425     FlushOnStateChange();
1426     glEsImpl->glPushMatrix();
1427     }
1428
1429 void glTexEnvf (GLenum target, GLenum pname, GLfloat param)
1430     {
1431     if (target == GL_TEXTURE_ENV)
1432         {
1433         if (pname == GL_TEXTURE_ENV_MODE)
1434             {
1435             if (param == activetmuState->texture_env_mode.value)
1436                 {
1437                 return;
1438                 }
1439             else
1440                 {
1441                 FlushOnStateChange();
1442                 glEsImpl->glTexEnvf(target, pname, param);
1443                 activetmuState->texture_env_mode.value = param;
1444                 return;
1445                 }
1446             }
1447         }
1448     FlushOnStateChange();
1449     glEsImpl->glTexEnvf(target, pname, param);
1450     }
1451
1452 void glVertex3fv( const GLfloat *v )
1453     {
1454     GLfloat* vert = (GLfloat*)ptrVertexAttribArray++;
1455     memcpy(vert, v, 3*sizeof(GLfloat));
1456 #if defined(__MULTITEXTURE_SUPPORT__)
1457     memcpy(vert+3, &currentVertexAttrib.red, 5*sizeof(GLfloat));
1458 #else
1459     memcpy(vert+4, &currentVertexAttrib.red, 3*sizeof(GLfloat));
1460 #endif
1461     }
1462
1463
1464 void glDepthMask (GLboolean flag)
1465     {
1466     if (nanoglState.depthmask == flag)
1467         {
1468         return;
1469         }
1470     nanoglState.depthmask = flag;
1471     FlushOnStateChange();
1472     glEsImpl->glDepthMask(flag);
1473     }
1474
1475 void glBindTexture (GLenum target, GLuint texture)
1476     {
1477     if (activetmuState->boundtexture.value == texture)
1478         {
1479         return;
1480         }
1481     FlushOnStateChange();
1482     activetmuState->boundtexture.value = texture;
1483     glEsImpl->glBindTexture(target, texture);
1484     }
1485
1486
1487 void glGetIntegerv (GLenum pname, GLint *params)
1488     {
1489     FlushOnStateChange();
1490     glEsImpl->glGetIntegerv(pname, params);
1491     }
1492
1493 GLubyte nano_extensions_string[4096];
1494 const GLubyte* glGetString (GLenum name)
1495     {
1496
1497     if (name == GL_EXTENSIONS)
1498         {
1499 #if defined(__MULTITEXTURE_SUPPORT__)
1500         sprintf((char*)nano_extensions_string,"%s %s",glEsImpl->glGetString(name),"GL_ARB_multitexture EXT_texture_env_add");
1501 #else
1502         sprintf((char*)nano_extensions_string,"%s %s",glEsImpl->glGetString(name),"EXT_texture_env_add");
1503 #endif
1504         return nano_extensions_string;
1505         }
1506     return glEsImpl->glGetString(name);
1507     }
1508
1509 void glAlphaFunc (GLenum func, GLclampf ref)
1510     {
1511     FlushOnStateChange();
1512     glEsImpl->glAlphaFunc(func,ref);
1513     }
1514
1515 void glFlush (void)
1516     {
1517     FlushOnStateChange();
1518     glEsImpl->glFlush();
1519     }
1520
1521 void glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
1522     {
1523     if (format == GL_DEPTH_COMPONENT)
1524         {
1525         // OpenglEs 1.1 does not support reading depth buffer without an extension
1526         memset(pixels, 0xff,4);
1527         return;
1528         }
1529     FlushOnStateChange();
1530     glEsImpl->glReadPixels(x,y,width,height,format,type,pixels);
1531     }
1532
1533 void glReadBuffer( GLenum /*mode*/ )
1534     {
1535
1536     }
1537
1538 void glLoadMatrixf (const GLfloat *m)
1539     {
1540     FlushOnStateChange();
1541     glEsImpl->glLoadMatrixf(m);
1542     }
1543
1544 void glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
1545     {
1546     FlushOnStateChange();
1547     glEsImpl->glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixels);
1548     }
1549
1550 void glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
1551     {
1552     FlushOnStateChange();
1553     glEsImpl->glClearColor(red,green,blue,alpha);
1554     }
1555
1556 GLenum glGetError (void)
1557     {
1558     //FlushOnStateChange();
1559     return GL_NO_ERROR;//glEsImpl->glGetError();
1560     }
1561
1562 void glActiveTexture (GLenum texture)
1563     {
1564     if (activetmu == texture)
1565         {
1566         return;
1567         }
1568     if (delayedttmuchange)
1569         {
1570         delayedttmuchange = GL_FALSE;
1571         }
1572     else
1573         {
1574         delayedttmuchange = GL_TRUE;
1575         delayedtmutarget = texture;
1576         }
1577     if (texture == GL_TEXTURE0)
1578         {
1579         activetmuState = &tmuState0;
1580         }
1581     else
1582         {
1583         activetmuState = &tmuState1;
1584         }
1585     activetmu = texture;
1586     }
1587
1588 void glClientActiveTexture (GLenum texture)
1589     {
1590     clientactivetmu = texture;
1591     }
1592
1593 void glPolygonMode( GLenum face, GLenum mode )
1594     {
1595     }
1596
1597 void glDeleteTextures( GLsizei n, const GLuint *textures )
1598     {
1599     FlushOnStateChange();
1600     glEsImpl->glDeleteTextures(n,textures);
1601     }
1602
1603 void glClearDepth( GLclampf depth )
1604     {
1605     FlushOnStateChange();
1606     glEsImpl->glClearDepthf( depth );
1607     }
1608
1609 void glClipPlane( GLenum plane, const GLdouble *equation )
1610     {
1611     FlushOnStateChange();
1612     float array[4];
1613     array[0] = (GLfloat)(equation[0]);
1614     array[1] = (GLfloat)(equation[1]);
1615     array[2] = (GLfloat)(equation[2]);
1616     array[3] = (GLfloat)(equation[3]);
1617     glEsImpl->glClipPlanef( plane, array );
1618     }
1619
1620 void glScissor( GLint x, GLint  y, GLsizei width, GLsizei height )
1621     {
1622     FlushOnStateChange();
1623     glEsImpl->glScissor( x, y, width,height);
1624     }
1625
1626 void glPointSize( GLfloat size )
1627     {
1628     FlushOnStateChange();
1629     glEsImpl->glPointSize( size );
1630     }
1631
1632 void glArrayElement(GLint i) {}
1633 void glLineWidth(GLfloat width) {}
1634 void glCallList( GLuint list ) {}
1635 void glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) {}
1636 void glStencilFunc( GLenum func, GLint ref, GLuint mask ) {}
1637 void glStencilOp( GLenum fail, GLenum zfail, GLenum zpass ) {}
1638
1639 struct ptrstate vertex_array;
1640 struct ptrstate color_array;
1641 struct ptrstate texture_coord_array;
1642
1643 void glDrawElements( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices )
1644     {
1645     // ensure that all primitives specified between glBegin/glEnd pairs
1646     // are rendered first, and that we have correct tmu in use..
1647     FlushOnStateChange();
1648     // setup correct vertex/color/texcoord pointers
1649     if (arraysValid ||
1650         tmuState0.vertex_array.changed ||
1651         tmuState0.color_array.changed ||
1652         tmuState0.texture_coord_array.changed)
1653         {
1654         glEsImpl->glClientActiveTexture(GL_TEXTURE0);
1655         }
1656     if (arraysValid || tmuState0.vertex_array.changed)
1657         {
1658         if (tmuState0.vertex_array.enabled)
1659             {
1660             glEsImpl->glEnableClientState(GL_VERTEX_ARRAY);
1661             }
1662         else
1663             {
1664             glEsImpl->glDisableClientState(GL_VERTEX_ARRAY);
1665             }
1666         glEsImpl->glVertexPointer(tmuState0.vertex_array.size,
1667                                   tmuState0.vertex_array.type,
1668                                   tmuState0.vertex_array.stride,
1669                                   tmuState0.vertex_array.ptr);
1670         tmuState0.vertex_array.changed = GL_FALSE;
1671         }
1672     if (arraysValid || tmuState0.color_array.changed)
1673         {
1674         if (tmuState0.color_array.enabled)
1675             {
1676             glEsImpl->glEnableClientState(GL_COLOR_ARRAY);
1677             }
1678         else
1679             {
1680             glEsImpl->glDisableClientState(GL_COLOR_ARRAY);
1681             }
1682         glEsImpl->glColorPointer(tmuState0.color_array.size,
1683                                  tmuState0.color_array.type,
1684                                  tmuState0.color_array.stride,
1685                                  tmuState0.color_array.ptr);
1686         tmuState0.color_array.changed = GL_FALSE;
1687         }
1688     if (arraysValid || tmuState0.texture_coord_array.changed)
1689         {
1690         tmuState0.texture_coord_array.changed = GL_FALSE;
1691         if (tmuState0.texture_coord_array.enabled)
1692             {
1693             glEsImpl->glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1694             }
1695         else
1696             {
1697             glEsImpl->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1698             }
1699         glEsImpl->glTexCoordPointer(tmuState0.texture_coord_array.size,
1700                                         tmuState0.texture_coord_array.type,
1701                                         tmuState0.texture_coord_array.stride,
1702                                         tmuState0.texture_coord_array.ptr);
1703         }
1704
1705     if (arraysValid || tmuState1.texture_coord_array.changed)
1706         {
1707         tmuState1.texture_coord_array.changed = GL_FALSE;
1708         glEsImpl->glClientActiveTexture(GL_TEXTURE1);
1709         if (tmuState1.texture_coord_array.enabled)
1710             {
1711             glEsImpl->glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1712             }
1713         else
1714             {
1715             glEsImpl->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1716             }
1717         glEsImpl->glTexCoordPointer(tmuState1.texture_coord_array.size,
1718                                         tmuState1.texture_coord_array.type,
1719                                         tmuState1.texture_coord_array.stride,
1720                                         tmuState1.texture_coord_array.ptr);
1721         }
1722
1723     arraysValid = GL_FALSE;
1724     glEsImpl->glDrawElements(mode, count, type, indices);
1725     }
1726
1727 void glEnableClientState(GLenum  array)
1728     {
1729     struct nanotmuState* clientstate = NULL;
1730     if (clientactivetmu == GL_TEXTURE0)
1731         {
1732         clientstate = &tmuState0;
1733         }
1734     else if (clientactivetmu == GL_TEXTURE1)
1735         {
1736         clientstate = &tmuState1;
1737         }
1738     else
1739         {
1740         return;
1741         }
1742     switch (array)
1743         {
1744         case GL_VERTEX_ARRAY:
1745             if (clientstate->vertex_array.enabled)
1746                 {
1747                 return;
1748                 }
1749             clientstate->vertex_array.enabled = GL_TRUE;
1750             clientstate->vertex_array.changed = GL_TRUE;
1751             break;
1752         case GL_COLOR_ARRAY:
1753             if (clientstate->color_array.enabled)
1754                 {
1755                 return;
1756                 }
1757             clientstate->color_array.enabled = GL_TRUE;
1758             clientstate->color_array.changed = GL_TRUE;
1759
1760             break;
1761         case GL_TEXTURE_COORD_ARRAY:
1762             if (clientstate->texture_coord_array.enabled)
1763                 {
1764                 return;
1765                 }
1766             clientstate->texture_coord_array.enabled = GL_TRUE;
1767             clientstate->texture_coord_array.changed = GL_TRUE;
1768             break;
1769         default:
1770             break;
1771         }
1772     }
1773 void glDisableClientState(GLenum  array)
1774     {
1775     struct nanotmuState* clientstate = NULL;
1776     if (clientactivetmu == GL_TEXTURE0)
1777         {
1778         clientstate = &tmuState0;
1779         }
1780     else if (clientactivetmu == GL_TEXTURE1)
1781         {
1782         clientstate = &tmuState1;
1783         }
1784     else
1785         {
1786         return;
1787         }
1788     switch (array)
1789         {
1790         case GL_VERTEX_ARRAY:
1791             if (!clientstate->vertex_array.enabled)
1792                 {
1793                 return;
1794                 }
1795             clientstate->vertex_array.enabled = GL_FALSE;
1796             clientstate->vertex_array.changed = GL_TRUE;
1797             break;
1798         case GL_COLOR_ARRAY:
1799             if (!clientstate->color_array.enabled)
1800                 {
1801                 return;
1802                 }
1803             clientstate->color_array.enabled = GL_FALSE;
1804             clientstate->color_array.changed = GL_TRUE;
1805
1806             break;
1807         case GL_TEXTURE_COORD_ARRAY:
1808             if (!clientstate->texture_coord_array.enabled)
1809                 {
1810                 return;
1811                 }
1812             clientstate->texture_coord_array.enabled = GL_FALSE;
1813             clientstate->texture_coord_array.changed = GL_TRUE;
1814             break;
1815         default:
1816             break;
1817         }
1818     }
1819 void glVertexPointer(   GLint size,     GLenum type,GLsizei     stride, const GLvoid *pointer )
1820     {
1821     if (tmuState0.vertex_array.size == size &&
1822         tmuState0.vertex_array.stride == stride &&
1823         tmuState0.vertex_array.type == type &&
1824         tmuState0.vertex_array.ptr == pointer)
1825         {
1826         return;
1827         }
1828     tmuState0.vertex_array.size = size;
1829     tmuState0.vertex_array.stride = stride;
1830     tmuState0.vertex_array.type = type;
1831     tmuState0.vertex_array.ptr  = (GLvoid*)pointer;
1832     tmuState0.vertex_array.changed = GL_TRUE;
1833     }
1834 void glTexCoordPointer( GLint   size,  GLenum type,  GLsizei stride,  const     GLvoid *pointer )
1835     {
1836     struct nanotmuState* clientstate = NULL;
1837     if (clientactivetmu == GL_TEXTURE0)
1838         {
1839         clientstate = &tmuState0;
1840         }
1841     else if (clientactivetmu == GL_TEXTURE1)
1842         {
1843         clientstate = &tmuState1;
1844         }
1845     if (clientstate->texture_coord_array.size == size &&
1846         clientstate->texture_coord_array.stride == stride &&
1847         clientstate->texture_coord_array.type == type &&
1848         clientstate->texture_coord_array.ptr == pointer)
1849         {
1850         return;
1851         }
1852     clientstate->texture_coord_array.size = size;
1853     clientstate->texture_coord_array.stride = stride;
1854     clientstate->texture_coord_array.type = type;
1855     clientstate->texture_coord_array.ptr  = (GLvoid*)pointer;
1856     clientstate->texture_coord_array.changed = GL_TRUE;
1857     }
1858 void glColorPointer( GLint size,  GLenum type,  GLsizei stride,  const GLvoid *pointer )
1859     {
1860     if (tmuState0.color_array.size == size &&
1861         tmuState0.color_array.stride == stride &&
1862         tmuState0.color_array.type == type &&
1863         tmuState0.color_array.ptr == pointer)
1864         {
1865                 return;
1866         }
1867     tmuState0.color_array.size = size;
1868     tmuState0.color_array.stride = stride;
1869     tmuState0.color_array.type = type;
1870     tmuState0.color_array.ptr  = (GLvoid*)pointer;
1871     tmuState0.color_array.changed = GL_TRUE;
1872     }
1873 void glPolygonOffset( GLfloat factor, GLfloat units )
1874     {
1875     FlushOnStateChange();
1876     glEsImpl->glPolygonOffset(factor, units);
1877     }
1878 void glStencilMask( GLuint mask ) {}
1879 void glClearStencil( GLint s ) {}
1880
1881 #if defined(__MULTITEXTURE_SUPPORT__)
1882
1883 extern "C" void glMultiTexCoord2fARB( GLenum target, GLfloat s, GLfloat t );
1884
1885 void glMultiTexCoord2fARB( GLenum target, GLfloat s, GLfloat t )
1886 {
1887     if (target == GL_TEXTURE0)
1888         {
1889         glTexCoord2f(s,t);
1890         }
1891     else
1892         {
1893         currentVertexAttrib.s_multi = s;
1894         currentVertexAttrib.t_multi = t;
1895         }
1896     }
1897 #endif
1898
1899 /* Vladimir  */
1900 void glDrawArrays( GLenum mode, int first, int count)
1901 {
1902     FlushOnStateChange();
1903     glEsImpl->glDrawArrays(mode, first , count);
1904 }
1905 void glMultMatrixf (const GLfloat *m)
1906 {
1907     FlushOnStateChange();
1908     glEsImpl->glMultMatrixf(m);
1909 }
1910
1911 void glPixelStorei (GLenum pname, GLint param)
1912 {
1913     FlushOnStateChange();
1914     glEsImpl->glPixelStorei(pname, param);
1915 }
1916
1917
1918 void glFogf (GLenum pname, GLfloat param)
1919 {
1920         FlushOnStateChange();
1921         glEsImpl->glFogf(pname, param);
1922 }
1923
1924 void glFogfv (GLenum pname, const GLfloat *params)
1925 {
1926         FlushOnStateChange();
1927         glEsImpl->glFogfv(pname, params);
1928 }
1929
1930 void glGetTexParameteriv (GLenum target, GLenum pname, GLint *params)
1931 {
1932         FlushOnStateChange();
1933         glEsImpl->glGetTexParameteriv(target, pname, params);
1934 }
1935
1936
1937 // This gives: called unimplemented OpenGL ES API (Android)
1938 void glTexParameteri (GLenum target, GLenum pname, GLint param)
1939 {
1940     if (pname == GL_TEXTURE_BORDER_COLOR) {
1941                 return; // not supported by opengl es
1942         }
1943     if (    (pname == GL_TEXTURE_WRAP_S ||
1944              pname == GL_TEXTURE_WRAP_T) &&
1945              param == GL_CLAMP)   {
1946                 param = 0x812F;
1947         }
1948
1949         FlushOnStateChange();
1950         glEsImpl->glTexParameteri(target, pname, param);
1951 }
1952
1953 void glTexParameterx (GLenum target, GLenum pname, GLfixed param)
1954 {
1955     if (pname == GL_TEXTURE_BORDER_COLOR) {
1956                 return; // not supported by opengl es
1957         }
1958     if (    (pname == GL_TEXTURE_WRAP_S ||
1959              pname == GL_TEXTURE_WRAP_T) &&
1960              param == GL_CLAMP)   {
1961                 param = 0x812F;
1962         }
1963         FlushOnStateChange();
1964         glEsImpl->glTexParameterx(target, pname, param);
1965 }
1966
1967 void glGenTextures (GLsizei n, GLuint *textures)
1968 {
1969         FlushOnStateChange();
1970         glEsImpl->glGenTextures(n, textures);
1971 }
1972
1973 void glFrontFace (GLenum mode)
1974 {
1975         FlushOnStateChange();
1976         glEsImpl->glFrontFace(mode);
1977 }
1978
1979
1980
1981 // End Vladimir
1982
1983
1984