nanoWrap.c

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