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