nanoWrap.cpp

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