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 struct nanotmuState
 141 {
 142         struct booleanstate texture_2d;
 143         struct floatstate texture_env_mode;
 144         struct uintstate boundtexture;
 145         struct ptrstate vertex_array;
 146         struct ptrstate color_array;
 147         struct ptrstate texture_coord_array;
 148         struct ptrstate normal_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         {3, GL_FLOAT, 0, NULL, GL_FALSE, GL_FALSE},
 163 };
 164
 165 static struct nanotmuState *activetmuState = &tmuState0;
 166
 167 extern "C++" GlESInterface *glEsImpl;
 168
 169 static GLenum wrapperPrimitiveMode = GL_QUADS;
 170 GLboolean useTexCoordArray         = GL_FALSE;
 171 static GLenum activetmu            = GL_TEXTURE0;
 172 static GLenum clientactivetmu      = GL_TEXTURE0;
 173
 174 #if defined( __MULTITEXTURE_SUPPORT__ )
 175 GLboolean useMultiTexCoordArray = GL_FALSE;
 176 #endif
 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[60000];
 210
 211 static GLushort indexArray[50000];
 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, 255, 255, 255, 255, 0.0f, 0.0f, 0.0f, 0.0f};
 224 #else
 225 static VertexAttrib currentVertexAttribInit = {
 226     0.0f, 0.0f, 0.0f, 0.0f, 255, 255, 255, 255, 0.0f, 0.0f,
 227 };
 228 #endif
 229 static GLushort *ptrIndexArray = NULL;
 230
 231 static GLboolean arraysValid = GL_FALSE;
 232
 233 void InitGLStructs( )
 234 {
 235         ptrVertexAttribArray     = vertexattribs;
 236         ptrVertexAttribArrayMark = ptrVertexAttribArray;
 237         ptrIndexArray            = indexArray;
 238
 239         memcpy( &nanoglState, &nanoglInitState, sizeof( struct nanoState ) );
 240         memcpy( &tmuState0, &tmuInitState, sizeof( struct nanotmuState ) );
 241         memcpy( &tmuState1, &tmuInitState, sizeof( struct nanotmuState ) );
 242         memcpy( &currentVertexAttrib, &currentVertexAttribInit, sizeof( struct VertexAttrib ) );
 243
 244         activetmuState       = &tmuState0;
 245         wrapperPrimitiveMode = GL_QUADS;
 246         useTexCoordArray     = GL_FALSE;
 247         activetmu            = GL_TEXTURE0;
 248         clientactivetmu      = GL_TEXTURE0;
 249         delayedttmuchange    = GL_FALSE;
 250         delayedtmutarget     = GL_TEXTURE0;
 251         vertexCount          = 0;
 252         indexCount           = 0;
 253         vertexMark           = 0;
 254         indexbase            = 0;
 255         arraysValid          = GL_FALSE;
 256 }
 257
 258 void ResetNanoState( )
 259 {
 260
 261         if ( tmuState0.color_array.enabled )
 262         {
 263                 glEsImpl->glEnableClientState( GL_COLOR_ARRAY );
 264         }
 265         else
 266         {
 267                 glEsImpl->glDisableClientState( GL_COLOR_ARRAY );
 268         }
 269
 270         if ( tmuState0.vertex_array.enabled )
 271         {
 272                 glEsImpl->glEnableClientState( GL_VERTEX_ARRAY );
 273         }
 274         else
 275         {
 276                 glEsImpl->glDisableClientState( GL_VERTEX_ARRAY );
 277         }
 278
 279         if ( tmuState0.texture_coord_array.enabled )
 280         {
 281                 glEsImpl->glEnableClientState( GL_TEXTURE_COORD_ARRAY );
 282         }
 283         else
 284         {
 285                 glEsImpl->glDisableClientState( GL_TEXTURE_COORD_ARRAY );
 286         }
 287
 288         if ( tmuState0.normal_array.enabled )
 289         {
 290                 glEsImpl->glEnableClientState( GL_NORMAL_ARRAY );
 291         }
 292         else
 293         {
 294                 glEsImpl->glDisableClientState( GL_NORMAL_ARRAY );
 295         }
 296         glEsImpl->glVertexPointer( tmuState0.vertex_array.size,
 297                                    tmuState0.vertex_array.type,
 298                                    tmuState0.vertex_array.stride,
 299                                    tmuState0.vertex_array.ptr );
 300
 301         glEsImpl->glTexCoordPointer( tmuState0.texture_coord_array.size,
 302                                      tmuState0.texture_coord_array.type,
 303                                      tmuState0.texture_coord_array.stride,
 304                                      tmuState0.texture_coord_array.ptr );
 305
 306         glEsImpl->glColorPointer( tmuState0.color_array.size,
 307                                   tmuState0.color_array.type,
 308                                   tmuState0.color_array.stride,
 309                                   tmuState0.color_array.ptr );
 310
 311         glEsImpl->glNormalPointer(
 312             tmuState0.normal_array.type,
 313             tmuState0.normal_array.stride,
 314             tmuState0.normal_array.ptr );
 315
 316         glEsImpl->glMatrixMode( nanoglState.matrixmode );
 317
 318         glEsImpl->glColor4f( currentVertexAttrib.red, currentVertexAttrib.green, currentVertexAttrib.blue, currentVertexAttrib.alpha );
 319
 320         glEsImpl->glBlendFunc( nanoglState.sfactor, nanoglState.dfactor );
 321
 322         //glEsImpl->glBindTexture(GL_TEXTURE_2D, stackTextureState);
 323
 324         glEsImpl->glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, activetmuState->texture_env_mode.value );
 325
 326         arraysValid = GL_FALSE;
 327 }
 328
 329 void FlushOnStateChange( )
 330 {
 331         if ( delayedttmuchange )
 332         {
 333                 delayedttmuchange = GL_FALSE;
 334 #ifndef USE_CORE_PROFILE
 335                 glEsImpl->glActiveTexture( delayedtmutarget );
 336 #endif
 337         }
 338
 339         if ( !vertexCount )
 340                 return;
 341
 342         if ( !arraysValid )
 343         {
 344                 glEsImpl->glClientActiveTexture( GL_TEXTURE0 );
 345                 glEsImpl->glVertexPointer( 3, GL_FLOAT, sizeof( VertexAttrib ), &vertexattribs[0].x );
 346                 glEsImpl->glColorPointer( 4, GL_UNSIGNED_BYTE, sizeof( VertexAttrib ), &vertexattribs[0].red );
 347                 glEsImpl->glTexCoordPointer( 2, GL_FLOAT, sizeof( VertexAttrib ), &vertexattribs[0].s );
 348                 glEsImpl->glEnableClientState( GL_VERTEX_ARRAY );
 349                 glEsImpl->glEnableClientState( GL_TEXTURE_COORD_ARRAY );
 350                 glEsImpl->glEnableClientState( GL_COLOR_ARRAY );
 351 #if defined( __MULTITEXTURE_SUPPORT__ )
 352                 glEsImpl->glClientActiveTexture( GL_TEXTURE1 );
 353                 glEsImpl->glTexCoordPointer( 2, GL_FLOAT, sizeof( VertexAttrib ), &vertexattribs[0].s_multi );
 354                 glEsImpl->glEnableClientState( GL_TEXTURE_COORD_ARRAY );
 355                 glEsImpl->glClientActiveTexture( GL_TEXTURE0 );
 356 #endif
 357                 arraysValid = GL_TRUE;
 358         }
 359
 360         glEsImpl->glDrawElements( GL_TRIANGLES, vertexCount, GL_UNSIGNED_SHORT, indexArray );
 361
 362 #if defined( __MULTITEXTURE_SUPPORT__ )
 363         useMultiTexCoordArray = GL_FALSE;
 364 #endif
 365         vertexCount              = 0;
 366         indexCount               = 0;
 367         ptrVertexAttribArray     = vertexattribs;
 368         ptrVertexAttribArrayMark = ptrVertexAttribArray;
 369         ptrIndexArray            = indexArray;
 370         useTexCoordArray         = GL_FALSE;
 371 }
 372 void nanoGL_Flush( )
 373 {
 374         FlushOnStateChange( );
 375 }
 376 void nanoGL_Reset( )
 377 {
 378         ResetNanoState( );
 379 }
 380 void glBegin( GLenum mode )
 381 {
 382         wrapperPrimitiveMode     = mode;
 383         vertexMark               = vertexCount;
 384         ptrVertexAttribArrayMark = ptrVertexAttribArray;
 385         indexbase                = indexCount;
 386 }
 387
 388 void glEnd( void )
 389 {
 390         vertexCount += ( (unsigned char *)ptrVertexAttribArray - (unsigned char *)ptrVertexAttribArrayMark ) / sizeof( VertexAttrib );
 391         if ( vertexCount < 3 )
 392         {
 393                 return;
 394         }
 395         switch ( wrapperPrimitiveMode )
 396         {
 397         case GL_QUADS:
 398         {
 399                 *ptrIndexArray++ = indexCount;
 400                 *ptrIndexArray++ = indexCount + 1;
 401                 *ptrIndexArray++ = indexCount + 2;
 402                 *ptrIndexArray++ = indexCount;
 403                 *ptrIndexArray++ = indexCount + 2;
 404                 *ptrIndexArray++ = indexCount + 3;
 405                 indexCount += 4;
 406                 vertexCount += 2;
 407         }
 408         break;
 409         case GL_TRIANGLES:
 410         {
 411                 int vcount = ( vertexCount - vertexMark ) / 3;
 412                 for ( int count = 0; count < vcount; count++ )
 413                 {
 414                         *ptrIndexArray++ = indexCount;
 415                         *ptrIndexArray++ = indexCount + 1;
 416                         *ptrIndexArray++ = indexCount + 2;
 417                         indexCount += 3;
 418                 }
 419         }
 420         break;
 421         case GL_TRIANGLE_STRIP:
 422         {
 423                 *ptrIndexArray++ = indexCount;
 424                 *ptrIndexArray++ = indexCount + 1;
 425                 *ptrIndexArray++ = indexCount + 2;
 426                 indexCount += 3;
 427                 int vcount = ( ( vertexCount - vertexMark ) - 3 );
 428                 if ( vcount && ( (long)ptrIndexArray & 0x02 ) )
 429                 {
 430                         *ptrIndexArray++ = indexCount - 1; // 2
 431                         *ptrIndexArray++ = indexCount - 2; // 1
 432                         *ptrIndexArray++ = indexCount;     // 3
 433                         indexCount++;
 434                         vcount -= 1;
 435                         int odd = vcount & 1;
 436                         vcount /= 2;
 437                         unsigned int *longptr = (unsigned int *)ptrIndexArray;
 438
 439                         for ( int count = 0; count < vcount; count++ )
 440                         {
 441                                 *( longptr++ ) = ( indexCount - 2 ) | ( ( indexCount - 1 ) << 16 );
 442                                 *( longptr++ ) = ( indexCount ) | ( ( indexCount ) << 16 );
 443                                 *( longptr++ ) = ( indexCount - 1 ) | ( ( indexCount + 1 ) << 16 );
 444                                 indexCount += 2;
 445                         }
 446                         ptrIndexArray = (unsigned short *)( longptr );
 447                         if ( odd )
 448                         {
 449                                 *ptrIndexArray++ = indexCount - 2; // 2
 450                                 *ptrIndexArray++ = indexCount - 1; // 1
 451                                 *ptrIndexArray++ = indexCount;     // 3
 452                                 indexCount++;
 453                         }
 454                 }
 455                 else
 456                 {
 457                         //already aligned
 458                         int odd = vcount & 1;
 459                         vcount /= 2;
 460                         unsigned int *longptr = (unsigned int *)ptrIndexArray;
 461
 462                         for ( int count = 0; count < vcount; count++ )
 463                         {
 464                                 *( longptr++ ) = ( indexCount - 1 ) | ( ( indexCount - 2 ) << 16 );
 465                                 *( longptr++ ) = ( indexCount ) | ( ( indexCount - 1 ) << 16 );
 466                                 *( longptr++ ) = ( indexCount ) | ( ( indexCount + 1 ) << 16 );
 467                                 indexCount += 2;
 468                         }
 469                         ptrIndexArray = (unsigned short *)( longptr );
 470                         if ( odd )
 471                         {
 472
 473                                 *ptrIndexArray++ = indexCount - 1; // 2
 474                                 *ptrIndexArray++ = indexCount - 2; // 1
 475                                 *ptrIndexArray++ = indexCount;     // 3
 476                                 indexCount++;
 477                         }
 478                 }
 479                 vertexCount += ( vertexCount - vertexMark - 3 ) * 2;
 480         }
 481         break;
 482         case GL_POLYGON:
 483         case GL_TRIANGLE_FAN:
 484         {
 485                 *ptrIndexArray++ = indexCount++;
 486                 *ptrIndexArray++ = indexCount++;
 487                 *ptrIndexArray++ = indexCount++;
 488                 int vcount = ( ( vertexCount - vertexMark ) - 3 );
 489                 for ( int count = 0; count < vcount; count++ )
 490                 {
 491                         *ptrIndexArray++ = indexbase;
 492                         *ptrIndexArray++ = indexCount - 1;
 493                         *ptrIndexArray++ = indexCount++;
 494                         vertexCount += 2;
 495                 }
 496         }
 497         break;
 498
 499         default:
 500                 break;
 501         }
 502         if ( ptrVertexAttribArray - vertexattribs > 20000 * sizeof( VertexAttrib ) ||
 503              ptrIndexArray - indexArray > 15000 * sizeof( GLushort ) )
 504                 FlushOnStateChange( );
 505 }
 506
 507 void glEnable( GLenum cap )
 508 {
 509         GLboolean statechanged = GL_FALSE;
 510         switch ( cap )
 511         {
 512         case GL_ALPHA_TEST:
 513         {
 514                 if ( !nanoglState.alpha_test )
 515                 {
 516                         nanoglState.alpha_test = GL_TRUE;
 517                         statechanged           = GL_TRUE;
 518                 }
 519                 break;
 520         }
 521         case GL_BLEND:
 522         {
 523                 if ( !nanoglState.blend )
 524                 {
 525                         nanoglState.blend = GL_TRUE;
 526                         statechanged      = GL_TRUE;
 527                 }
 528                 break;
 529         }
 530         //case GL_CLIP_PLANEi
 531         case GL_COLOR_LOGIC_OP:
 532         {
 533                 if ( !nanoglState.color_logic_op )
 534                 {
 535                         nanoglState.color_logic_op = GL_TRUE;
 536                         statechanged               = GL_TRUE;
 537                 }
 538                 break;
 539         }
 540         case GL_COLOR_MATERIAL:
 541         {
 542                 if ( !nanoglState.color_material )
 543                 {
 544                         nanoglState.color_material = GL_TRUE;
 545                         statechanged               = GL_TRUE;
 546                 }
 547                 break;
 548         }
 549         case GL_CULL_FACE:
 550         {
 551                 if ( !nanoglState.cull_face )
 552                 {
 553                         nanoglState.cull_face = GL_TRUE;
 554                         statechanged          = GL_TRUE;
 555                 }
 556                 break;
 557         }
 558         case GL_DEPTH_TEST:
 559         {
 560                 if ( !nanoglState.depth_test )
 561                 {
 562                         nanoglState.depth_test = GL_TRUE;
 563                         statechanged           = GL_TRUE;
 564                 }
 565                 break;
 566         }
 567         case GL_DITHER:
 568         {
 569                 if ( !nanoglState.dither )
 570                 {
 571                         nanoglState.dither = GL_TRUE;
 572                         statechanged       = GL_TRUE;
 573                 }
 574                 break;
 575         }
 576         case GL_FOG:
 577                 //case GL_LIGHTi
 578                 {
 579                         if ( !nanoglState.fog )
 580                         {
 581                                 nanoglState.fog = GL_TRUE;
 582                                 statechanged    = GL_TRUE;
 583                         }
 584                         break;
 585                 }
 586         case GL_LIGHTING:
 587         {
 588                 if ( !nanoglState.lighting )
 589                 {
 590                         nanoglState.lighting = GL_TRUE;
 591                         statechanged         = GL_TRUE;
 592                 }
 593                 break;
 594         }
 595         case GL_LINE_SMOOTH:
 596         {
 597                 if ( !nanoglState.line_smooth )
 598                 {
 599                         nanoglState.line_smooth = GL_TRUE;
 600                         statechanged            = GL_TRUE;
 601                 }
 602                 break;
 603         }
 604         /*        case GL_MATRIX_PALETTE_OES:
 605             {
 606             if (!nanoglState.matrix_palette_oes)
 607                 {
 608                 nanoglState.matrix_palette_oes = GL_TRUE;
 609                 statechanged = GL_TRUE;
 610                 }
 611             break;
 612             }*/
 613         case GL_MULTISAMPLE:
 614         {
 615                 if ( !nanoglState.multisample )
 616                 {
 617                         nanoglState.multisample = GL_TRUE;
 618                         statechanged            = GL_TRUE;
 619                 }
 620                 break;
 621         }
 622         case GL_NORMALIZE:
 623         {
 624                 if ( !nanoglState.normalize )
 625                 {
 626                         nanoglState.normalize = GL_TRUE;
 627                         statechanged          = GL_TRUE;
 628                 }
 629                 break;
 630         }
 631         /*        case GL_POINT_SPRITE_OES:
 632             {
 633             if (!nanoglState.point_sprite_oes)
 634                 {
 635                 nanoglState.point_sprite_oes = GL_TRUE;
 636                 statechanged = GL_TRUE;
 637                 }
 638             break;
 639             }*/
 640         case GL_POLYGON_OFFSET_FILL:
 641         {
 642                 if ( !nanoglState.polygon_offset_fill )
 643                 {
 644                         nanoglState.polygon_offset_fill = GL_TRUE;
 645                         statechanged                    = GL_TRUE;
 646                 }
 647                 break;
 648         }
 649         case GL_RESCALE_NORMAL:
 650         {
 651                 if ( !nanoglState.rescale_normal )
 652                 {
 653                         nanoglState.rescale_normal = GL_TRUE;
 654                         statechanged               = GL_TRUE;
 655                 }
 656                 break;
 657         }
 658         case GL_SAMPLE_ALPHA_TO_COVERAGE:
 659         {
 660                 if ( !nanoglState.sample_alpha_to_coverage )
 661                 {
 662                         nanoglState.sample_alpha_to_coverage = GL_TRUE;
 663                         statechanged                         = GL_TRUE;
 664                 }
 665                 break;
 666         }
 667         case GL_SAMPLE_ALPHA_TO_ONE:
 668         {
 669                 if ( !nanoglState.sample_alpha_to_one )
 670                 {
 671                         nanoglState.sample_alpha_to_one = GL_TRUE;
 672                         statechanged                    = GL_TRUE;
 673                 }
 674                 break;
 675         }
 676         case GL_SAMPLE_COVERAGE:
 677         {
 678                 if ( !nanoglState.sample_coverage )
 679                 {
 680                         nanoglState.sample_coverage = GL_TRUE;
 681                         statechanged                = GL_TRUE;
 682                 }
 683                 break;
 684         }
 685         case GL_SCISSOR_TEST:
 686         {
 687                 if ( !nanoglState.scissor_test )
 688                 {
 689                         nanoglState.scissor_test = GL_TRUE;
 690                         statechanged             = GL_TRUE;
 691                 }
 692                 break;
 693         }
 694         case GL_STENCIL_TEST:
 695         {
 696                 return;
 697                 /*            if (!nanoglState.stencil_test)
 698                 {
 699                 nanoglState.stencil_test = GL_TRUE;
 700                 statechanged = GL_TRUE;
 701                 }*/
 702                 break;
 703         }
 704         case GL_TEXTURE_2D:
 705         {
 706                 if ( !activetmuState->texture_2d.value )
 707                 {
 708                         FlushOnStateChange( );
 709                         glEsImpl->glEnable( cap );
 710                         activetmuState->texture_2d.value = GL_TRUE;
 711                         return;
 712                 }
 713                 break;
 714         }
 715         default:
 716                 break;
 717         }
 718
 719         if ( statechanged )
 720         {
 721                 FlushOnStateChange( );
 722                 glEsImpl->glEnable( cap );
 723         }
 724 }
 725
 726 void glDisable( GLenum cap )
 727 {
 728         GLboolean statechanged = GL_FALSE;
 729         switch ( cap )
 730         {
 731         case GL_ALPHA_TEST:
 732         {
 733                 if ( nanoglState.alpha_test )
 734                 {
 735                         nanoglState.alpha_test = GL_FALSE;
 736                         statechanged           = GL_TRUE;
 737                 }
 738                 break;
 739         }
 740         case GL_BLEND:
 741         {
 742                 if ( nanoglState.blend )
 743                 {
 744                         nanoglState.blend = GL_FALSE;
 745                         statechanged      = GL_TRUE;
 746                 }
 747                 break;
 748         }
 749         //case GL_CLIP_PLANEi
 750         case GL_COLOR_LOGIC_OP:
 751         {
 752                 if ( nanoglState.color_logic_op )
 753                 {
 754                         nanoglState.color_logic_op = GL_FALSE;
 755                         statechanged               = GL_TRUE;
 756                 }
 757                 break;
 758         }
 759         case GL_COLOR_MATERIAL:
 760         {
 761                 if ( nanoglState.color_material )
 762                 {
 763                         nanoglState.color_material = GL_FALSE;
 764                         statechanged               = GL_TRUE;
 765                 }
 766                 break;
 767         }
 768         case GL_CULL_FACE:
 769         {
 770                 if ( nanoglState.cull_face )
 771                 {
 772                         nanoglState.cull_face = GL_FALSE;
 773                         statechanged          = GL_TRUE;
 774                 }
 775                 break;
 776         }
 777         case GL_DEPTH_TEST:
 778         {
 779                 if ( nanoglState.depth_test )
 780                 {
 781                         nanoglState.depth_test = GL_FALSE;
 782                         statechanged           = GL_TRUE;
 783                 }
 784                 break;
 785         }
 786         case GL_DITHER:
 787         {
 788                 if ( nanoglState.dither )
 789                 {
 790                         nanoglState.dither = GL_FALSE;
 791                         statechanged       = GL_TRUE;
 792                 }
 793                 break;
 794         }
 795         case GL_FOG:
 796                 //case GL_LIGHTi
 797                 {
 798                         if ( nanoglState.fog )
 799                         {
 800                                 nanoglState.fog = GL_FALSE;
 801                                 statechanged    = GL_TRUE;
 802                         }
 803                         break;
 804                 }
 805         case GL_LIGHTING:
 806         {
 807                 if ( nanoglState.lighting )
 808                 {
 809                         nanoglState.lighting = GL_FALSE;
 810                         statechanged         = GL_TRUE;
 811                 }
 812                 break;
 813         }
 814         case GL_LINE_SMOOTH:
 815         {
 816                 if ( nanoglState.line_smooth )
 817                 {
 818                         nanoglState.line_smooth = GL_FALSE;
 819                         statechanged            = GL_TRUE;
 820                 }
 821                 break;
 822         }
 823         /*        case GL_MATRIX_PALETTE_OES:
 824             {
 825             if (nanoglState.matrix_palette_oes)
 826                 {
 827                 nanoglState.matrix_palette_oes = GL_FALSE;
 828                 statechanged = GL_TRUE;
 829                 }
 830             break;
 831             }*/
 832         case GL_MULTISAMPLE:
 833         {
 834                 if ( nanoglState.multisample )
 835                 {
 836                         nanoglState.multisample = GL_FALSE;
 837                         statechanged            = GL_TRUE;
 838                 }
 839                 break;
 840         }
 841         case GL_NORMALIZE:
 842         {
 843                 if ( nanoglState.normalize )
 844                 {
 845                         nanoglState.normalize = GL_FALSE;
 846                         statechanged          = GL_TRUE;
 847                 }
 848                 break;
 849         }
 850         /*        case GL_POINT_SPRITE_OES:
 851             {
 852             if (nanoglState.point_sprite_oes)
 853                 {
 854                 nanoglState.point_sprite_oes = GL_FALSE;
 855                 statechanged = GL_TRUE;
 856                 }
 857             break;
 858             }*/
 859         case GL_POLYGON_OFFSET_FILL:
 860         {
 861                 if ( nanoglState.polygon_offset_fill )
 862                 {
 863                         nanoglState.polygon_offset_fill = GL_FALSE;
 864                         statechanged                    = GL_TRUE;
 865                 }
 866                 break;
 867         }
 868         case GL_RESCALE_NORMAL:
 869         {
 870                 if ( nanoglState.rescale_normal )
 871                 {
 872                         nanoglState.rescale_normal = GL_FALSE;
 873                         statechanged               = GL_TRUE;
 874                 }
 875                 break;
 876         }
 877         case GL_SAMPLE_ALPHA_TO_COVERAGE:
 878         {
 879                 if ( nanoglState.sample_alpha_to_coverage )
 880                 {
 881                         nanoglState.sample_alpha_to_coverage = GL_FALSE;
 882                         statechanged                         = GL_TRUE;
 883                 }
 884                 break;
 885         }
 886         case GL_SAMPLE_ALPHA_TO_ONE:
 887         {
 888                 if ( nanoglState.sample_alpha_to_one )
 889                 {
 890                         nanoglState.sample_alpha_to_one = GL_FALSE;
 891                         statechanged                    = GL_TRUE;
 892                 }
 893                 break;
 894         }
 895         case GL_SAMPLE_COVERAGE:
 896         {
 897                 if ( nanoglState.sample_coverage )
 898                 {
 899                         nanoglState.sample_coverage = GL_FALSE;
 900                         statechanged                = GL_TRUE;
 901                 }
 902                 break;
 903         }
 904         case GL_SCISSOR_TEST:
 905         {
 906                 if ( nanoglState.scissor_test )
 907                 {
 908                         nanoglState.scissor_test = GL_FALSE;
 909                         statechanged             = GL_TRUE;
 910                 }
 911                 break;
 912         }
 913         case GL_STENCIL_TEST:
 914         {
 915                 return;
 916                 /*            if (nanoglState.stencil_test)
 917                 {
 918                 nanoglState.stencil_test = GL_FALSE;
 919                 statechanged = GL_TRUE;
 920                 }*/
 921                 break;
 922         }
 923         case GL_TEXTURE_2D:
 924         {
 925                 if ( activetmuState->texture_2d.value )
 926                 {
 927                         FlushOnStateChange( );
 928                         glEsImpl->glDisable( cap );
 929                         activetmuState->texture_2d.value = GL_FALSE;
 930                         return;
 931                 }
 932                 break;
 933         }
 934         default:
 935                 break;
 936         }
 937
 938         if ( statechanged )
 939         {
 940                 FlushOnStateChange( );
 941                 glEsImpl->glDisable( cap );
 942         }
 943 }
 944
 945 void glVertex2f( GLfloat x, GLfloat y )
 946 {
 947         glVertex3f( x, y, 0.0f );
 948 }
 949
 950 __FORCEINLINE unsigned int ClampTo255( float value )
 951 {
 952         unsigned int retval = (unsigned int)( value );
 953         if ( retval > 255 )
 954         {
 955                 retval = 255;
 956         }
 957         return retval;
 958 }
 959
 960 void glColor3f( GLfloat red, GLfloat green, GLfloat blue )
 961 {
 962         currentVertexAttrib.red   = (unsigned char)ClampTo255( red * 255.0f );
 963         currentVertexAttrib.green = (unsigned char)ClampTo255( green * 255.0f );
 964         currentVertexAttrib.blue  = (unsigned char)ClampTo255( blue * 255.0f );
 965         currentVertexAttrib.alpha = 255;
 966 }
 967
 968 void glTexCoord2fv( const GLfloat *v )
 969 {
 970         memcpy( &currentVertexAttrib.s, v, 2 * sizeof( float ) );
 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 #ifdef USE_CORE_PROFILE
1003         glEsImpl->glOrtho( left, right, bottom, top, zNear, zFar );
1004 #else
1005         glEsImpl->glOrthof( left, right, bottom, top, zNear, zFar );
1006 #endif
1007 }
1008
1009 void glMatrixMode( GLenum mode )
1010 {
1011         if ( nanoglState.matrixmode == mode )
1012         {
1013                 return;
1014         }
1015         nanoglState.matrixmode = mode;
1016         FlushOnStateChange( );
1017         glEsImpl->glMatrixMode( mode );
1018 }
1019
1020 void glTexParameterf( GLenum target, GLenum pname, GLfloat param )
1021 {
1022         if ( pname == GL_TEXTURE_BORDER_COLOR )
1023         {
1024                 return; // not supported by opengl es
1025         }
1026         if ( ( pname == GL_TEXTURE_WRAP_S ||
1027                pname == GL_TEXTURE_WRAP_T ) &&
1028              param == GL_CLAMP )
1029         {
1030                 param = 0x812F;
1031         }
1032
1033         FlushOnStateChange( );
1034         glEsImpl->glTexParameterf( target, pname, param );
1035 }
1036
1037 void glTexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
1038 {
1039         glTexParameterf( target, pname, params[0] );
1040 }
1041
1042 void glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels )
1043 {
1044         FlushOnStateChange( );
1045         internalformat = format;
1046         glEsImpl->glTexImage2D( target, level, internalformat, width, height, border, format, type, pixels );
1047 }
1048
1049 void glDrawBuffer( GLenum /*mode*/ )
1050 {
1051 }
1052
1053 void glTranslatef( GLfloat x, GLfloat y, GLfloat z )
1054 {
1055         FlushOnStateChange( );
1056         glEsImpl->glTranslatef( x, y, z );
1057 }
1058
1059 void glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
1060 {
1061         FlushOnStateChange( );
1062         glEsImpl->glRotatef( angle, x, y, z );
1063 }
1064
1065 void glScalef( GLfloat x, GLfloat y, GLfloat z )
1066 {
1067         FlushOnStateChange( );
1068         glEsImpl->glScalef( x, y, z );
1069 }
1070
1071 void glDepthRange( GLclampf zNear, GLclampf zFar )
1072 {
1073         if ( ( nanoglState.depth_range_near == zNear ) && ( nanoglState.depth_range_far == zFar ) )
1074         {
1075                 return;
1076         }
1077         else
1078         {
1079                 nanoglState.depth_range_near = zNear;
1080                 nanoglState.depth_range_far  = zFar;
1081         }
1082         FlushOnStateChange( );
1083 #ifdef USE_CORE_PROFILE
1084         glEsImpl->glDepthRange( zNear, zFar );
1085 #else
1086         glEsImpl->glDepthRangef( zNear, zFar );
1087 #endif
1088 }
1089
1090 void glDepthFunc( GLenum func )
1091 {
1092         if ( nanoglState.depth_func == func )
1093         {
1094                 return;
1095         }
1096         else
1097         {
1098                 nanoglState.depth_func = func;
1099         }
1100         FlushOnStateChange( );
1101         glEsImpl->glDepthFunc( func );
1102 }
1103
1104 void glFinish( void )
1105 {
1106         FlushOnStateChange( );
1107         glEsImpl->glFinish( );
1108 }
1109
1110 void glGetFloatv( GLenum pname, GLfloat *params )
1111 {
1112         FlushOnStateChange( );
1113         glEsImpl->glGetFloatv( pname, params );
1114 }
1115
1116 void glCullFace( GLenum mode )
1117 {
1118         if ( nanoglState.cullface == mode )
1119         {
1120                 return;
1121         }
1122         else
1123         {
1124                 nanoglState.cullface = mode;
1125         }
1126         FlushOnStateChange( );
1127         glEsImpl->glCullFace( mode );
1128 }
1129
1130 void glFrustum( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar )
1131 {
1132         FlushOnStateChange( );
1133         glEsImpl->glFrustumf( left, right, bottom, top, zNear, zFar );
1134 }
1135
1136 void glClear( GLbitfield mask )
1137 {
1138         FlushOnStateChange( );
1139         glEsImpl->glClear( mask );
1140 }
1141
1142 void glVertex3f( GLfloat x, GLfloat y, GLfloat z )
1143 {
1144         GLfloat *vert = (GLfloat *)ptrVertexAttribArray++;
1145         *vert++       = x;
1146         *vert++       = y;
1147         *vert++ = z;
1148 #if defined( __MULTITEXTURE_SUPPORT__ )
1149         memcpy( vert, &currentVertexAttrib.red, 5 * sizeof( GLfloat ) );
1150 #else
1151         memcpy( vert + 1, &currentVertexAttrib.red, 3 * sizeof( GLfloat ) );
1152 #endif
1153 }
1154
1155 void glColor4fv( const GLfloat *v )
1156 {
1157         currentVertexAttrib.red   = (unsigned char)ClampTo255( v[0] * 255.0f );
1158         currentVertexAttrib.green = (unsigned char)ClampTo255( v[1] * 255.0f );
1159         currentVertexAttrib.blue  = (unsigned char)ClampTo255( v[2] * 255.0f );
1160         currentVertexAttrib.alpha = (unsigned char)ClampTo255( v[3] * 255.0f );
1161 }
1162
1163 void glColor3ubv( const GLubyte *v )
1164 {
1165         currentVertexAttrib.red   = v[0];
1166         currentVertexAttrib.green = v[1];
1167         currentVertexAttrib.blue  = v[2];
1168         currentVertexAttrib.alpha = 255;
1169 }
1170
1171 void glColor4ubv( const GLubyte *v )
1172 {
1173         //*((unsigned int*)(&currentVertexAttrib.red)) = *((unsigned int*)(v));
1174         currentVertexAttrib.red   = v[0];
1175         currentVertexAttrib.green = v[1];
1176         currentVertexAttrib.blue  = v[2];
1177         currentVertexAttrib.alpha = v[3];
1178 }
1179
1180 void glColor3fv( const GLfloat *v )
1181 {
1182         currentVertexAttrib.red   = (unsigned char)ClampTo255( v[0] * 255.0f );
1183         currentVertexAttrib.green = (unsigned char)ClampTo255( v[1] * 255.0f );
1184         currentVertexAttrib.blue  = (unsigned char)ClampTo255( v[2] * 255.0f );
1185         currentVertexAttrib.alpha = 255;
1186 }
1187
1188 //-- nicknekit: xash3d funcs --
1189
1190 void glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
1191 {
1192         currentVertexAttrib.red   = red;
1193         currentVertexAttrib.green = green;
1194         currentVertexAttrib.blue  = blue;
1195         currentVertexAttrib.alpha = alpha;
1196 }
1197
1198 void glColor3ub( GLubyte red, GLubyte green, GLubyte blue )
1199 {
1200         currentVertexAttrib.red   = red;
1201         currentVertexAttrib.green = green;
1202         currentVertexAttrib.blue  = blue;
1203         currentVertexAttrib.alpha = 255;
1204 }
1205
1206 void glNormal3fv( const GLfloat *v )
1207 {
1208         FlushOnStateChange( );
1209         glEsImpl->glNormal3f( v[0], v[1], v[2] );
1210 }
1211
1212 void glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
1213 {
1214         FlushOnStateChange( );
1215         glEsImpl->glCopyTexImage2D( target, level, internalformat, x, y, width, height, border );
1216 }
1217
1218 void glTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels )
1219 {
1220         glTexImage2D( GL_TEXTURE_2D, level, internalformat, width, 1, border, format, type, pixels );
1221 }
1222
1223 void glTexImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels )
1224 {
1225         glTexImage2D( GL_TEXTURE_2D, level, internalformat, width, height, border, format, type, pixels );
1226 }
1227
1228 void glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels )
1229 {
1230         glTexSubImage2D( target, level, xoffset, 0, width, 1, format, type, pixels );
1231 }
1232
1233 void glTexSubImage3D( GLenum target, GLint level,
1234                       GLint xoffset, GLint yoffset,
1235                       GLint zoffset, GLsizei width,
1236                       GLsizei height, GLsizei depth,
1237                       GLenum format,
1238                       GLenum type, const GLvoid *pixels )
1239 {
1240         glTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels );
1241 }
1242
1243 GLboolean glIsTexture( GLuint texture )
1244 {
1245         FlushOnStateChange( );
1246         return glEsImpl->glIsTexture( texture );
1247 }
1248
1249 void glTexGeni( GLenum coord, GLenum pname, GLint param )
1250 {
1251         //for mirrors? not needed for original hl?
1252 }
1253
1254 void glTexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
1255 {
1256         //for mirrors? not needed for original hl?
1257 }
1258
1259 //-- --//
1260
1261 void glHint( GLenum target, GLenum mode )
1262 {
1263         FlushOnStateChange( );
1264         glEsImpl->glHint( target, mode );
1265 }
1266
1267 void glBlendFunc( GLenum sfactor, GLenum dfactor )
1268 {
1269         if ( ( nanoglState.sfactor == sfactor ) && ( nanoglState.dfactor == dfactor ) )
1270         {
1271                 return;
1272         }
1273         nanoglState.sfactor = sfactor;
1274         nanoglState.dfactor = dfactor;
1275         FlushOnStateChange( );
1276         glEsImpl->glBlendFunc( sfactor, dfactor );
1277 }
1278
1279 void glPopMatrix( void )
1280 {
1281         FlushOnStateChange( );
1282         glEsImpl->glPopMatrix( );
1283 }
1284
1285 void glShadeModel( GLenum mode )
1286 {
1287         if ( nanoglState.shademodel == mode )
1288         {
1289                 return;
1290         }
1291         nanoglState.shademodel = mode;
1292         FlushOnStateChange( );
1293         glEsImpl->glShadeModel( mode );
1294 }
1295
1296 void glPushMatrix( void )
1297 {
1298         FlushOnStateChange( );
1299         glEsImpl->glPushMatrix( );
1300 }
1301
1302 void glTexEnvf( GLenum target, GLenum pname, GLfloat param )
1303 {
1304         if ( target == GL_TEXTURE_ENV )
1305         {
1306                 if ( pname == GL_TEXTURE_ENV_MODE )
1307                 {
1308                         if ( param == activetmuState->texture_env_mode.value )
1309                         {
1310                                 return;
1311                         }
1312                         else
1313                         {
1314                                 FlushOnStateChange( );
1315                                 glEsImpl->glTexEnvf( target, pname, param );
1316                                 activetmuState->texture_env_mode.value = param;
1317                                 return;
1318                         }
1319                 }
1320         }
1321         FlushOnStateChange( );
1322         glEsImpl->glTexEnvf( target, pname, param );
1323 }
1324
1325 void glVertex3fv( const GLfloat *v )
1326 {
1327         GLfloat *vert = (GLfloat *)ptrVertexAttribArray++;
1328         memcpy( vert, v, 3 * sizeof( GLfloat ) );
1329 #if defined( __MULTITEXTURE_SUPPORT__ )
1330         memcpy( vert + 3, &currentVertexAttrib.red, 5 * sizeof( GLfloat ) );
1331 #else
1332         memcpy( vert + 4, &currentVertexAttrib.red, 3 * sizeof( GLfloat ) );
1333 #endif
1334 }
1335
1336 void glDepthMask( GLboolean flag )
1337 {
1338         if ( nanoglState.depthmask == flag )
1339         {
1340                 return;
1341         }
1342         nanoglState.depthmask = flag;
1343         FlushOnStateChange( );
1344         glEsImpl->glDepthMask( flag );
1345 }
1346
1347 void glBindTexture( GLenum target, GLuint texture )
1348 {
1349         if ( activetmuState->boundtexture.value == texture )
1350         {
1351                 return;
1352         }
1353         FlushOnStateChange( );
1354         activetmuState->boundtexture.value = texture;
1355         glEsImpl->glBindTexture( target, texture );
1356 }
1357
1358 void glGetIntegerv( GLenum pname, GLint *params )
1359 {
1360         FlushOnStateChange( );
1361         glEsImpl->glGetIntegerv( pname, params );
1362 }
1363
1364 GLubyte nano_extensions_string[4096];
1365 const GLubyte *glGetString( GLenum name )
1366 {
1367
1368         if ( name == GL_EXTENSIONS )
1369         {
1370 #if defined( __MULTITEXTURE_SUPPORT__ )
1371                 sprintf( (char *)nano_extensions_string, "%s %s", glEsImpl->glGetString( name ), "GL_ARB_multitexture EXT_texture_env_add" );
1372 #else
1373                 sprintf( (char *)nano_extensions_string, "%s %s", glEsImpl->glGetString( name ), "EXT_texture_env_add" );
1374 #endif
1375                 return nano_extensions_string;
1376         }
1377         return glEsImpl->glGetString( name );
1378 }
1379
1380 void glAlphaFunc( GLenum func, GLclampf ref )
1381 {
1382         FlushOnStateChange( );
1383         glEsImpl->glAlphaFunc( func, ref );
1384 }
1385
1386 void glFlush( void )
1387 {
1388         FlushOnStateChange( );
1389         glEsImpl->glFlush( );
1390 }
1391
1392 void glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels )
1393 {
1394         if ( format == GL_DEPTH_COMPONENT )
1395         {
1396                 // OpenglEs 1.1 does not support reading depth buffer without an extension
1397                 memset( pixels, 0xff, 4 );
1398                 return;
1399         }
1400         FlushOnStateChange( );
1401         glEsImpl->glReadPixels( x, y, width, height, format, type, pixels );
1402 }
1403
1404 void glReadBuffer( GLenum /*mode*/ )
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 {
1504 }
1505 void glLineWidth( GLfloat width )
1506 {
1507 }
1508 void glCallList( GLuint list )
1509 {
1510 }
1511 void glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )
1512 {
1513 }
1514 void glStencilFunc( GLenum func, GLint ref, GLuint mask )
1515 {
1516 }
1517 void glStencilOp( GLenum fail, GLenum zfail, GLenum zpass )
1518 {
1519 }
1520
1521 struct ptrstate vertex_array;
1522 struct ptrstate color_array;
1523 struct ptrstate texture_coord_array;
1524
1525 void glDrawElements( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices )
1526 {
1527         // ensure that all primitives specified between glBegin/glEnd pairs
1528         // are rendered first, and that we have correct tmu in use..
1529         FlushOnStateChange( );
1530         // setup correct vertex/color/texcoord pointers
1531         if ( arraysValid ||
1532              tmuState0.vertex_array.changed ||
1533              tmuState0.color_array.changed ||
1534              tmuState0.texture_coord_array.changed || tmuState0.normal_array.changed )
1535         {
1536                 glEsImpl->glClientActiveTexture( GL_TEXTURE0 );
1537         }
1538         if ( arraysValid || tmuState0.vertex_array.changed )
1539         {
1540                 if ( tmuState0.vertex_array.enabled )
1541                 {
1542                         glEsImpl->glEnableClientState( GL_VERTEX_ARRAY );
1543                 }
1544                 else
1545                 {
1546                         glEsImpl->glDisableClientState( GL_VERTEX_ARRAY );
1547                 }
1548                 glEsImpl->glVertexPointer( tmuState0.vertex_array.size,
1549                                            tmuState0.vertex_array.type,
1550                                            tmuState0.vertex_array.stride,
1551                                            tmuState0.vertex_array.ptr );
1552                 tmuState0.vertex_array.changed = GL_FALSE;
1553         }
1554         if ( arraysValid || tmuState0.color_array.changed )
1555         {
1556                 if ( tmuState0.color_array.enabled )
1557                 {
1558                         glEsImpl->glEnableClientState( GL_COLOR_ARRAY );
1559                 }
1560                 else
1561                 {
1562                         glEsImpl->glDisableClientState( GL_COLOR_ARRAY );
1563                 }
1564                 glEsImpl->glColorPointer( tmuState0.color_array.size,
1565                                           tmuState0.color_array.type,
1566                                           tmuState0.color_array.stride,
1567                                           tmuState0.color_array.ptr );
1568                 tmuState0.color_array.changed = GL_FALSE;
1569         }
1570         if ( arraysValid || tmuState0.normal_array.changed )
1571         {
1572                 if ( tmuState0.normal_array.enabled )
1573                 {
1574                         glEsImpl->glEnableClientState( GL_NORMAL_ARRAY );
1575                 }
1576                 else
1577                 {
1578                         glEsImpl->glDisableClientState( GL_NORMAL_ARRAY );
1579                 }
1580                 glEsImpl->glNormalPointer( tmuState0.normal_array.type,
1581                                            tmuState0.normal_array.stride,
1582                                            tmuState0.normal_array.ptr );
1583                 tmuState0.normal_array.changed = GL_FALSE;
1584         }
1585         if ( arraysValid || tmuState0.texture_coord_array.changed )
1586         {
1587                 tmuState0.texture_coord_array.changed = GL_FALSE;
1588                 if ( tmuState0.texture_coord_array.enabled )
1589                 {
1590                         glEsImpl->glEnableClientState( GL_TEXTURE_COORD_ARRAY );
1591                 }
1592                 else
1593                 {
1594                         glEsImpl->glDisableClientState( GL_TEXTURE_COORD_ARRAY );
1595                 }
1596                 glEsImpl->glTexCoordPointer( tmuState0.texture_coord_array.size,
1597                                              tmuState0.texture_coord_array.type,
1598                                              tmuState0.texture_coord_array.stride,
1599                                              tmuState0.texture_coord_array.ptr );
1600         }
1601
1602         if ( arraysValid || tmuState1.texture_coord_array.changed )
1603         {
1604                 tmuState1.texture_coord_array.changed = GL_FALSE;
1605                 glEsImpl->glClientActiveTexture( GL_TEXTURE1 );
1606                 if ( tmuState1.texture_coord_array.enabled )
1607                 {
1608                         glEsImpl->glEnableClientState( GL_TEXTURE_COORD_ARRAY );
1609                 }
1610                 else
1611                 {
1612                         glEsImpl->glDisableClientState( GL_TEXTURE_COORD_ARRAY );
1613                 }
1614                 glEsImpl->glTexCoordPointer( tmuState1.texture_coord_array.size,
1615                                              tmuState1.texture_coord_array.type,
1616                                              tmuState1.texture_coord_array.stride,
1617                                              tmuState1.texture_coord_array.ptr );
1618         }
1619
1620         arraysValid = GL_FALSE;
1621         glEsImpl->glDrawElements( mode, count, type, indices );
1622 }
1623
1624 void glEnableClientState( GLenum array )
1625 {
1626         struct nanotmuState *clientstate = NULL;
1627         if ( clientactivetmu == GL_TEXTURE0 )
1628         {
1629                 clientstate = &tmuState0;
1630         }
1631         else if ( clientactivetmu == GL_TEXTURE1 )
1632         {
1633                 clientstate = &tmuState1;
1634         }
1635         else
1636         {
1637                 return;
1638         }
1639         switch ( array )
1640         {
1641         case GL_VERTEX_ARRAY:
1642                 if ( clientstate->vertex_array.enabled )
1643                 {
1644                         return;
1645                 }
1646                 clientstate->vertex_array.enabled = GL_TRUE;
1647                 clientstate->vertex_array.changed = GL_TRUE;
1648                 break;
1649         case GL_COLOR_ARRAY:
1650                 if ( clientstate->color_array.enabled )
1651                 {
1652                         return;
1653                 }
1654                 clientstate->color_array.enabled = GL_TRUE;
1655                 clientstate->color_array.changed = GL_TRUE;
1656
1657                 break;
1658         case GL_NORMAL_ARRAY:
1659                 if ( clientstate->normal_array.enabled )
1660                 {
1661                         return;
1662                 }
1663                 clientstate->normal_array.enabled = GL_TRUE;
1664                 clientstate->normal_array.changed = GL_TRUE;
1665
1666                 break;
1667         case GL_TEXTURE_COORD_ARRAY:
1668                 if ( clientstate->texture_coord_array.enabled )
1669                 {
1670                         return;
1671                 }
1672                 clientstate->texture_coord_array.enabled = GL_TRUE;
1673                 clientstate->texture_coord_array.changed = GL_TRUE;
1674                 break;
1675         default:
1676                 break;
1677         }
1678 }
1679 void glDisableClientState( GLenum array )
1680 {
1681         struct nanotmuState *clientstate = NULL;
1682         if ( clientactivetmu == GL_TEXTURE0 )
1683         {
1684                 clientstate = &tmuState0;
1685         }
1686         else if ( clientactivetmu == GL_TEXTURE1 )
1687         {
1688                 clientstate = &tmuState1;
1689         }
1690         else
1691         {
1692                 return;
1693         }
1694         switch ( array )
1695         {
1696         case GL_VERTEX_ARRAY:
1697                 if ( !clientstate->vertex_array.enabled )
1698                 {
1699                         return;
1700                 }
1701                 clientstate->vertex_array.enabled = GL_FALSE;
1702                 clientstate->vertex_array.changed = GL_TRUE;
1703                 break;
1704         case GL_COLOR_ARRAY:
1705                 if ( !clientstate->color_array.enabled )
1706                 {
1707                         return;
1708                 }
1709                 clientstate->color_array.enabled = GL_FALSE;
1710                 clientstate->color_array.changed = GL_TRUE;
1711
1712                 break;
1713         case GL_NORMAL_ARRAY:
1714                 if ( !clientstate->normal_array.enabled )
1715                 {
1716                         return;
1717                 }
1718                 clientstate->normal_array.enabled = GL_FALSE;
1719                 clientstate->normal_array.changed = GL_TRUE;
1720
1721                 break;
1722         case GL_TEXTURE_COORD_ARRAY:
1723                 if ( !clientstate->texture_coord_array.enabled )
1724                 {
1725                         return;
1726                 }
1727                 clientstate->texture_coord_array.enabled = GL_FALSE;
1728                 clientstate->texture_coord_array.changed = GL_TRUE;
1729                 break;
1730         default:
1731                 break;
1732         }
1733 }
1734 void glVertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
1735 {
1736         if ( tmuState0.vertex_array.size == size &&
1737              tmuState0.vertex_array.stride == stride &&
1738              tmuState0.vertex_array.type == type &&
1739              tmuState0.vertex_array.ptr == pointer )
1740         {
1741                 return;
1742         }
1743         tmuState0.vertex_array.size    = size;
1744         tmuState0.vertex_array.stride  = stride;
1745         tmuState0.vertex_array.type    = type;
1746         tmuState0.vertex_array.ptr     = (GLvoid *)pointer;
1747         tmuState0.vertex_array.changed = GL_TRUE;
1748 }
1749 void glTexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
1750 {
1751         struct nanotmuState *clientstate = NULL;
1752         if ( clientactivetmu == GL_TEXTURE0 )
1753         {
1754                 clientstate = &tmuState0;
1755         }
1756         else if ( clientactivetmu == GL_TEXTURE1 )
1757         {
1758                 clientstate = &tmuState1;
1759         }
1760         if ( clientstate->texture_coord_array.size == size &&
1761              clientstate->texture_coord_array.stride == stride &&
1762              clientstate->texture_coord_array.type == type &&
1763              clientstate->texture_coord_array.ptr == pointer )
1764         {
1765                 return;
1766         }
1767         clientstate->texture_coord_array.size    = size;
1768         clientstate->texture_coord_array.stride  = stride;
1769         clientstate->texture_coord_array.type    = type;
1770         clientstate->texture_coord_array.ptr     = (GLvoid *)pointer;
1771         clientstate->texture_coord_array.changed = GL_TRUE;
1772 }
1773 void glColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
1774 {
1775         if ( tmuState0.color_array.size == size &&
1776              tmuState0.color_array.stride == stride &&
1777              tmuState0.color_array.type == type &&
1778              tmuState0.color_array.ptr == pointer )
1779         {
1780                 return;
1781         }
1782         tmuState0.color_array.size    = size;
1783         tmuState0.color_array.stride  = stride;
1784         tmuState0.color_array.type    = type;
1785         tmuState0.color_array.ptr     = (GLvoid *)pointer;
1786         tmuState0.color_array.changed = GL_TRUE;
1787 }
1788
1789 void glNormalPointer( GLenum type, GLsizei stride, const GLvoid *pointer )
1790 {
1791         int size = 0;
1792         if ( tmuState0.normal_array.size == size &&
1793              tmuState0.normal_array.stride == stride &&
1794              tmuState0.normal_array.type == type &&
1795              tmuState0.normal_array.ptr == pointer )
1796         {
1797                 return;
1798         }
1799         tmuState0.normal_array.size    = size;
1800         tmuState0.normal_array.stride  = stride;
1801         tmuState0.normal_array.type    = type;
1802         tmuState0.normal_array.ptr     = (GLvoid *)pointer;
1803         tmuState0.normal_array.changed = GL_TRUE;
1804 }
1805 void glPolygonOffset( GLfloat factor, GLfloat units )
1806 {
1807         FlushOnStateChange( );
1808         glEsImpl->glPolygonOffset( factor, units );
1809 }
1810 void glStencilMask( GLuint mask )
1811 {
1812 }
1813 void glClearStencil( GLint s )
1814 {
1815 }
1816
1817 #if defined( __MULTITEXTURE_SUPPORT__ )
1818
1819 extern "C" void glMultiTexCoord2fARB( GLenum target, GLfloat s, GLfloat t );
1820
1821 void glMultiTexCoord2fARB( GLenum target, GLfloat s, GLfloat t )
1822 {
1823         if ( target == GL_TEXTURE0 )
1824         {
1825                 glTexCoord2f( s, t );
1826         }
1827         else
1828         {
1829                 currentVertexAttrib.s_multi = s;
1830                 currentVertexAttrib.t_multi = t;
1831         }
1832 }
1833 #endif
1834
1835 /* Vladimir  */
1836 /*void glDrawArrays( GLenum mode, int first, int count)
1837 {
1838     FlushOnStateChange();
1839     glEsImpl->glDrawArrays(mode, first , count);
1840 }*/
1841 void glMultMatrixf( const GLfloat *m )
1842 {
1843         FlushOnStateChange( );
1844         glEsImpl->glMultMatrixf( m );
1845 }
1846
1847 void glPixelStorei( GLenum pname, GLint param )
1848 {
1849         FlushOnStateChange( );
1850         glEsImpl->glPixelStorei( pname, param );
1851 }
1852
1853 void glFogf( GLenum pname, GLfloat param )
1854 {
1855         FlushOnStateChange( );
1856         glEsImpl->glFogf( pname, param );
1857 }
1858
1859 void glFogfv( GLenum pname, const GLfloat *params )
1860 {
1861         FlushOnStateChange( );
1862         glEsImpl->glFogfv( pname, params );
1863 }
1864
1865 void glGetTexParameteriv( GLenum target, GLenum pname, GLint *params )
1866 {
1867         FlushOnStateChange( );
1868         glEsImpl->glGetTexParameteriv( target, pname, params );
1869 }
1870
1871 // This gives: called unimplemented OpenGL ES API (Android)
1872 void glTexParameteri( GLenum target, GLenum pname, GLint param )
1873 {
1874         if ( pname == GL_TEXTURE_BORDER_COLOR )
1875         {
1876                 return; // not supported by opengl es
1877         }
1878         if ( ( pname == GL_TEXTURE_WRAP_S ||
1879                pname == GL_TEXTURE_WRAP_T ) &&
1880              param == GL_CLAMP )
1881         {
1882                 param = 0x812F;
1883         }
1884
1885         FlushOnStateChange( );
1886         glEsImpl->glTexParameteri( target, pname, param );
1887 }
1888
1889 void glTexParameterx( GLenum target, GLenum pname, GLfixed param )
1890 {
1891         if ( pname == GL_TEXTURE_BORDER_COLOR )
1892         {
1893                 return; // not supported by opengl es
1894         }
1895         if ( ( pname == GL_TEXTURE_WRAP_S ||
1896                pname == GL_TEXTURE_WRAP_T ) &&
1897              param == GL_CLAMP )
1898         {
1899                 param = 0x812F;
1900         }
1901         FlushOnStateChange( );
1902         glEsImpl->glTexParameterx( target, pname, param );
1903 }
1904
1905 void glGenTextures( GLsizei n, GLuint *textures )
1906 {
1907         FlushOnStateChange( );
1908         glEsImpl->glGenTextures( n, textures );
1909 }
1910
1911 void glFrontFace( GLenum mode )
1912 {
1913         FlushOnStateChange( );
1914         glEsImpl->glFrontFace( mode );
1915 }
1916 // End Vladimir
1917
1918 void glTexEnvi( GLenum target, GLenum pname, GLint param )
1919 {
1920         if ( target == GL_TEXTURE_ENV )
1921         {
1922                 if ( pname == GL_TEXTURE_ENV_MODE )
1923                 {
1924                         if ( param == activetmuState->texture_env_mode.value )
1925                         {
1926                                 return;
1927                         }
1928                         else
1929                         {
1930                                 FlushOnStateChange( );
1931                                 glEsImpl->glTexEnvi( target, pname, param );
1932                                 activetmuState->texture_env_mode.value = param;
1933                                 return;
1934                         }
1935                 }
1936         }
1937         FlushOnStateChange( );
1938         glEsImpl->glTexEnvi( target, pname, param );
1939 }
1940
1941 #ifdef __MULTITEXTURE_SUPPORT__
1942 void glMultiTexCoord3fARB( GLenum a, GLfloat b, GLfloat c, GLfloat )
1943 {
1944         return glMultiTexCoord2fARB( a, b, c );
1945 }
1946
1947 void glMultiTexCoord2f( GLenum, GLfloat, GLfloat )
1948 {
1949 }
1950 #endif
1951 void glDrawArrays( GLenum mode, GLint first, GLsizei count )
1952 {
1953         // ensure that all primitives specified between glBegin/glEnd pairs
1954         // are rendered first, and that we have correct tmu in use..
1955         if ( mode == GL_QUADS )
1956                 mode = GL_TRIANGLE_FAN;
1957         FlushOnStateChange( );
1958         // setup correct vertex/color/texcoord pointers
1959         if ( arraysValid ||
1960              tmuState0.vertex_array.changed ||
1961              tmuState0.color_array.changed ||
1962              tmuState0.texture_coord_array.changed || tmuState0.normal_array.changed )
1963         {
1964                 glEsImpl->glClientActiveTexture( GL_TEXTURE0 );
1965         }
1966         if ( arraysValid || tmuState0.vertex_array.changed )
1967         {
1968                 if ( tmuState0.vertex_array.enabled )
1969                 {
1970                         glEsImpl->glEnableClientState( GL_VERTEX_ARRAY );
1971                 }
1972                 else
1973                 {
1974                         glEsImpl->glDisableClientState( GL_VERTEX_ARRAY );
1975                 }
1976                 glEsImpl->glVertexPointer( tmuState0.vertex_array.size,
1977                                            tmuState0.vertex_array.type,
1978                                            tmuState0.vertex_array.stride,
1979                                            tmuState0.vertex_array.ptr );
1980                 tmuState0.vertex_array.changed = GL_FALSE;
1981         }
1982         if ( arraysValid || tmuState0.color_array.changed )
1983         {
1984                 if ( tmuState0.color_array.enabled )
1985                 {
1986                         glEsImpl->glEnableClientState( GL_COLOR_ARRAY );
1987                 }
1988                 else
1989                 {
1990                         glEsImpl->glDisableClientState( GL_COLOR_ARRAY );
1991                 }
1992                 glEsImpl->glColorPointer( tmuState0.color_array.size,
1993                                           tmuState0.color_array.type,
1994                                           tmuState0.color_array.stride,
1995                                           tmuState0.color_array.ptr );
1996                 tmuState0.color_array.changed = GL_FALSE;
1997         }
1998         if ( arraysValid || tmuState0.normal_array.changed )
1999         {
2000                 if ( tmuState0.normal_array.enabled )
2001                 {
2002                         glEsImpl->glEnableClientState( GL_NORMAL_ARRAY );
2003                 }
2004                 else
2005                 {
2006                         glEsImpl->glDisableClientState( GL_NORMAL_ARRAY );
2007                 }
2008                 glEsImpl->glNormalPointer( tmuState0.normal_array.type,
2009                                            tmuState0.normal_array.stride,
2010                                            tmuState0.normal_array.ptr );
2011                 tmuState0.normal_array.changed = GL_FALSE;
2012         }
2013         if ( arraysValid || tmuState0.texture_coord_array.changed )
2014         {
2015                 tmuState0.texture_coord_array.changed = GL_FALSE;
2016                 if ( tmuState0.texture_coord_array.enabled )
2017                 {
2018                         glEsImpl->glEnableClientState( GL_TEXTURE_COORD_ARRAY );
2019                 }
2020                 else
2021                 {
2022                         glEsImpl->glDisableClientState( GL_TEXTURE_COORD_ARRAY );
2023                 }
2024                 glEsImpl->glTexCoordPointer( tmuState0.texture_coord_array.size,
2025                                              tmuState0.texture_coord_array.type,
2026                                              tmuState0.texture_coord_array.stride,
2027                                              tmuState0.texture_coord_array.ptr );
2028         }
2029
2030         if ( arraysValid || tmuState1.texture_coord_array.changed )
2031         {
2032                 tmuState1.texture_coord_array.changed = GL_FALSE;
2033                 glEsImpl->glClientActiveTexture( GL_TEXTURE1 );
2034                 if ( tmuState1.texture_coord_array.enabled )
2035                 {
2036                         glEsImpl->glEnableClientState( GL_TEXTURE_COORD_ARRAY );
2037                 }
2038                 else
2039                 {
2040                         glEsImpl->glDisableClientState( GL_TEXTURE_COORD_ARRAY );
2041                 }
2042                 glEsImpl->glTexCoordPointer( tmuState1.texture_coord_array.size,
2043                                              tmuState1.texture_coord_array.type,
2044                                              tmuState1.texture_coord_array.stride,
2045                                              tmuState1.texture_coord_array.ptr );
2046         }
2047
2048         arraysValid = GL_FALSE;
2049         glEsImpl->glDrawArrays( mode, first, count );
2050 }
2051 /*void glNormalPointer(GLenum type, GLsizei stride, const void *ptr)
2052 {
2053     glEsImpl->glNormalPointer( type, stride, ptr );
2054 }*/
2055
2056 void glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
2057 {
2058         FlushOnStateChange( );
2059         glEsImpl->glCopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height );
2060 }
2061
2062 void glGenFramebuffers( GLsizei n, GLuint *framebuffers )
2063 {
2064         FlushOnStateChange( );
2065         glEsImpl->glGenFramebuffers( n, framebuffers );
2066 }
2067
2068 void glGenRenderbuffers( GLsizei n, GLuint *renderbuffers )
2069 {
2070         FlushOnStateChange( );
2071         glEsImpl->glGenRenderbuffers( n, renderbuffers );
2072 }
2073
2074 void glBindRenderbuffer( GLenum target, GLuint renderbuffer )
2075 {
2076         FlushOnStateChange( );
2077         glEsImpl->glBindRenderbuffer( target, renderbuffer );
2078 }
2079
2080 void glBindFramebuffer( GLenum target, GLuint framebuffer )
2081 {
2082         FlushOnStateChange( );
2083         glEsImpl->glBindFramebuffer( target, framebuffer );
2084 }
2085
2086 void glFramebufferRenderbuffer( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer )
2087 {
2088         FlushOnStateChange( );
2089         glEsImpl->glFramebufferRenderbuffer( target, attachment, renderbuffertarget, renderbuffer );
2090 }
2091
2092 void glDeleteFramebuffers( GLsizei n, const GLuint *framebuffers )
2093 {
2094         FlushOnStateChange( );
2095         glEsImpl->glDeleteFramebuffers( n, framebuffers );
2096 }
2097
2098 void glDeleteRenderbuffers( GLsizei n, const GLuint *renderbuffers )
2099 {
2100         FlushOnStateChange( );
2101         glEsImpl->glDeleteRenderbuffers( n, renderbuffers );
2102 }
2103 void glFramebufferTexture2D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
2104 {
2105         FlushOnStateChange( );
2106         glEsImpl->glFramebufferTexture2D( target, attachment, textarget, texture, level );
2107 }
2108
2109 void glRenderbufferStorage( GLenum target, GLenum internalformat, GLsizei width, GLsizei height )
2110 {
2111         FlushOnStateChange( );
2112         glEsImpl->glRenderbufferStorage( target, internalformat, width, height );
2113 }