src/graphics/opengl/FGrpGles1.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /*
  19  * @file        FGrpGles1.cpp
  20  * @brief       This is the implementation file for OpenGL ES 1.X.
  21  *
  22  */
  23
  24
  25 #define FGRAPHICS_INTERNAL_USE_DYNAMIC_LOADING
  26 #if defined(FGRAPHICS_INTERNAL_USE_DYNAMIC_LOADING)
  27 #include <string>
  28 #include <string.h>
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31 #include <stddef.h>
  32 #include <dlfcn.h>
  33 #endif
  34
  35 #include <GLES/gl.h>
  36 #include <GLES/glext.h>
  37
  38 #if defined(FGRAPHICS_INTERNAL_USE_DYNAMIC_LOADING)
  39 #include <FBaseSysLog.h>
  40 #endif
  41
  42 #define FGRAPHICS_INTERNAL_USE_FBO
  43 #if defined(FGRAPHICS_INTERNAL_USE_FBO)
  44 #include <FUiCtrlFrame.h>
  45 #endif
  46
  47 using namespace Tizen::Base;
  48 using namespace Tizen::Ui;
  49 using namespace Tizen::Ui::Controls;
  50
  51 namespace Tizen { namespace Graphics
  52 {
  53
  54 namespace Opengl
  55 {
  56
  57 #if !defined(FGRAPHICS_INTERNAL_USE_DYNAMIC_LOADING)
  58
  59 #ifdef __cplusplus
  60 extern "C"
  61 {
  62 #endif
  63
  64 void
  65 _GlAlphaFunc_1(GLenum func, GLclampf ref)
  66 {
  67         glAlphaFunc(func, ref);
  68 }
  69
  70 void
  71 _GlClearColor_1(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
  72 {
  73         glClearColor(red, green, blue, alpha);
  74 }
  75
  76 void
  77 _GlClearDepthf_1(GLclampf depth)
  78 {
  79         glClearDepthf(depth);
  80 }
  81
  82 void
  83 _GlClipPlanef_1(GLenum plane, const GLfloat* pEquation)
  84 {
  85         glClipPlanef(plane, pEquation);
  86 }
  87
  88 void
  89 _GlColor4f_1(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
  90 {
  91         glColor4f(red, green, blue, alpha);
  92 }
  93
  94 void
  95 _GlDepthRangef_1(GLclampf zNear, GLclampf zFar)
  96 {
  97         glDepthRangef(zNear, zFar);
  98 }
  99
 100 void
 101 _GlFogf_1(GLenum pname, GLfloat param)
 102 {
 103         glFogf(pname, param);
 104 }
 105
 106 void
 107 _GlFogfv_1(GLenum pname, const GLfloat* pParams)
 108 {
 109         glFogfv(pname, pParams);
 110 }
 111
 112 void
 113 _GlFrustumf_1(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
 114 {
 115         glFrustumf(left, right, bottom, top, zNear, zFar);
 116 }
 117
 118 void
 119 _GlGetClipPlanef_1(GLenum pname, GLfloat eqn[4])
 120 {
 121         glGetClipPlanef(pname, eqn);
 122 }
 123
 124 void
 125 _GlGetFloatv_1(GLenum pname, GLfloat* pParams)
 126 {
 127         glGetFloatv(pname, pParams);
 128 }
 129
 130 void
 131 _GlGetLightfv_1(GLenum light, GLenum pname, GLfloat* pParams)
 132 {
 133         glGetLightfv(light, pname, pParams);
 134 }
 135
 136 void
 137 _GlGetMaterialfv_1(GLenum face, GLenum pname, GLfloat* pParams)
 138 {
 139         glGetMaterialfv(face, pname, pParams);
 140 }
 141
 142 void
 143 _GlGetTexEnvfv_1(GLenum env, GLenum pname, GLfloat* pParams)
 144 {
 145         glGetTexEnvfv(env, pname, pParams);
 146 }
 147
 148 void
 149 _GlGetTexParameterfv_1(GLenum target, GLenum pname, GLfloat* pParams)
 150 {
 151         glGetTexParameterfv(target, pname, pParams);
 152 }
 153
 154 void
 155 _GlLightModelf_1(GLenum pname, GLfloat param)
 156 {
 157         glLightModelf(pname, param);
 158 }
 159
 160 void
 161 _GlLightModelfv_1(GLenum pname, const GLfloat* pParams)
 162 {
 163         glLightModelfv(pname, pParams);
 164 }
 165
 166 void
 167 _GlLightf_1(GLenum light, GLenum pname, GLfloat param)
 168 {
 169         glLightf(light, pname, param);
 170 }
 171
 172 void
 173 _GlLightfv_1(GLenum light, GLenum pname, const GLfloat* pParams)
 174 {
 175         glLightfv(light, pname, pParams);
 176 }
 177
 178 void
 179 _GlLineWidth_1(GLfloat width)
 180 {
 181         glLineWidth(width);
 182 }
 183
 184 void
 185 _GlLoadMatrixf_1(const GLfloat* pM)
 186 {
 187         glLoadMatrixf(pM);
 188 }
 189
 190 void
 191 _GlMaterialf_1(GLenum face, GLenum pname, GLfloat param)
 192 {
 193         glMaterialf(face, pname, param);
 194 }
 195
 196 void
 197 _GlMaterialfv_1(GLenum face, GLenum pname, const GLfloat* pParams)
 198 {
 199         glMaterialfv(face, pname, pParams);
 200 }
 201
 202 void
 203 _GlMultMatrixf_1(const GLfloat* pM)
 204 {
 205         glMultMatrixf(pM);
 206 }
 207
 208 void
 209 _GlMultiTexCoord4f_1(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 210 {
 211         glMultiTexCoord4f(target, s, t, r, q);
 212 }
 213
 214 void
 215 _GlNormal3f_1(GLfloat nx, GLfloat ny, GLfloat nz)
 216 {
 217         glNormal3f(nx, ny, nz);
 218 }
 219
 220 void
 221 _GlOrthof_1(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
 222 {
 223         glOrthof(left, right, bottom, top, zNear, zFar);
 224 }
 225
 226 void
 227 _GlPointParameterf_1(GLenum pname, GLfloat param)
 228 {
 229         glPointParameterf(pname, param);
 230 }
 231
 232 void
 233 _GlPointParameterfv_1(GLenum pname, const GLfloat* pParams)
 234 {
 235         glPointParameterfv(pname, pParams);
 236 }
 237
 238 void
 239 _GlPointSize_1(GLfloat size)
 240 {
 241         glPointSize(size);
 242 }
 243
 244 void
 245 _GlPolygonOffset_1(GLfloat factor, GLfloat units)
 246 {
 247         glPolygonOffset(factor, units);
 248 }
 249
 250 void
 251 _GlRotatef_1(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 252 {
 253         glRotatef(angle, x, y, z);
 254 }
 255
 256 void
 257 _GlScalef_1(GLfloat x, GLfloat y, GLfloat z)
 258 {
 259         glScalef(x, y, z);
 260 }
 261
 262 void
 263 _GlTexEnvf_1(GLenum target, GLenum pname, GLfloat param)
 264 {
 265         glTexEnvf(target, pname, param);
 266 }
 267
 268 void
 269 _GlTexEnvfv_1(GLenum target, GLenum pname, const GLfloat* pParams)
 270 {
 271         glTexEnvfv(target, pname, pParams);
 272 }
 273
 274 void
 275 _GlTexParameterf_1(GLenum target, GLenum pname, GLfloat param)
 276 {
 277         glTexParameterf(target, pname, param);
 278 }
 279
 280 void
 281 _GlTexParameterfv_1(GLenum target, GLenum pname, const GLfloat* pParams)
 282 {
 283         glTexParameterfv(target, pname, pParams);
 284 }
 285
 286 void
 287 _GlTranslatef_1(GLfloat x, GLfloat y, GLfloat z)
 288 {
 289         glTranslatef(x, y, z);
 290 }
 291
 292 void
 293 _GlActiveTexture_1(GLenum texture)
 294 {
 295         glActiveTexture(texture);
 296 }
 297
 298 void
 299 _GlAlphaFuncx_1(GLenum func, GLclampx ref)
 300 {
 301         glAlphaFuncx(func, ref);
 302 }
 303
 304 void
 305 _GlBindBuffer_1(GLenum target, GLuint buffer)
 306 {
 307         glBindBuffer(target, buffer);
 308 }
 309
 310 void
 311 _GlBindTexture_1(GLenum target, GLuint texture)
 312 {
 313         glBindTexture(target, texture);
 314 }
 315
 316 void
 317 _GlBlendFunc_1(GLenum sfactor, GLenum dfactor)
 318 {
 319         glBlendFunc(sfactor, dfactor);
 320 }
 321
 322 void
 323 _GlBufferData_1(GLenum target, GLsizeiptr size, const GLvoid* pData, GLenum usage)
 324 {
 325         glBufferData(target, size, pData, usage);
 326 }
 327
 328 void
 329 _GlBufferSubData_1(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* pData)
 330 {
 331         glBufferSubData(target, offset, size, pData);
 332 }
 333
 334 void
 335 _GlClear_1(GLbitfield mask)
 336 {
 337         glClear(mask);
 338 }
 339
 340 void
 341 _GlClearColorx_1(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
 342 {
 343         glClearColorx(red, green, blue, alpha);
 344 }
 345
 346 void
 347 _GlClearDepthx_1(GLclampx depth)
 348 {
 349         glClearDepthx(depth);
 350 }
 351
 352 void
 353 _GlClearStencil_1(GLint s)
 354 {
 355         glClearStencil(s);
 356 }
 357
 358 void
 359 _GlClientActiveTexture_1(GLenum texture)
 360 {
 361         glClientActiveTexture(texture);
 362 }
 363
 364 void
 365 _GlClipPlanex_1(GLenum plane, const GLfixed* pEquation)
 366 {
 367         glClipPlanex(plane, pEquation);
 368 }
 369
 370 void
 371 _GlColor4ub_1(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 372 {
 373         glColor4ub(red, green, blue, alpha);
 374 }
 375
 376 void
 377 _GlColor4x_1(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
 378 {
 379         glColor4x(red, green, blue, alpha);
 380 }
 381
 382 void
 383 _GlColorMask_1(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 384 {
 385         glColorMask(red, green, blue, alpha);
 386 }
 387
 388 void
 389 _GlColorPointer_1(GLint size, GLenum type, GLsizei stride, const GLvoid* pPointer)
 390 {
 391         glColorPointer(size, type, stride, pPointer);
 392 }
 393
 394 void
 395 _GlCompressedTexImage2D_1(GLenum target, GLint level, GLenum internalformat,
 396                 GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* pData)
 397 {
 398         glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, pData);
 399 }
 400
 401 void
 402 _GlCompressedTexSubImage2D_1(GLenum target, GLint level, GLint xoffset, GLint yoffset,
 403                 GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* pData)
 404 {
 405         glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, pData);
 406 }
 407
 408 void
 409 _GlCopyTexImage2D_1(GLenum target, GLint level,
 410                 GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 411 {
 412         glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 413 }
 414
 415 void
 416 _GlCopyTexSubImage2D_1(GLenum target, GLint level,
 417                 GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 418 {
 419         glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 420 }
 421
 422 void
 423 _GlCullFace_1(GLenum mode)
 424 {
 425         glCullFace(mode);
 426 }
 427
 428 void
 429 _GlDeleteBuffers_1(GLsizei n, const GLuint* pBuffers)
 430 {
 431         glDeleteBuffers(n, pBuffers);
 432 }
 433
 434 void
 435 _GlDeleteTextures_1(GLsizei n, const GLuint* pTextures)
 436 {
 437         glDeleteTextures(n, pTextures);
 438 }
 439
 440 void
 441 _GlDepthFunc_1(GLenum func)
 442 {
 443         glDepthFunc(func);
 444 }
 445
 446 void
 447 _GlDepthMask_1(GLboolean flag)
 448 {
 449         glDepthMask(flag);
 450 }
 451
 452 void
 453 _GlDepthRangex_1(GLclampx zNear, GLclampx zFar)
 454 {
 455         glDepthRangex(zNear, zFar);
 456 }
 457
 458 void
 459 _GlDisable_1(GLenum cap)
 460 {
 461         glDisable(cap);
 462 }
 463
 464 void
 465 _GlDisableClientState_1(GLenum array)
 466 {
 467         glDisableClientState(array);
 468 }
 469
 470 void
 471 _GlDrawArrays_1(GLenum mode, GLint first, GLsizei count)
 472 {
 473         glDrawArrays(mode, first, count);
 474 }
 475
 476 void
 477 _GlDrawElements_1(GLenum mode, GLsizei count, GLenum type, const GLvoid* pIndices)
 478 {
 479         glDrawElements(mode, count, type, pIndices);
 480 }
 481
 482 void
 483 _GlEnable_1(GLenum cap)
 484 {
 485         glEnable(cap);
 486 }
 487
 488 void
 489 _GlEnableClientState_1(GLenum array)
 490 {
 491         glEnableClientState(array);
 492 }
 493
 494 void
 495 _GlFinish_1(void)
 496 {
 497         glFinish();
 498 }
 499
 500 void
 501 _GlFlush_1(void)
 502 {
 503         glFlush();
 504 }
 505
 506 void
 507 _GlFogx_1(GLenum pname, GLfixed param)
 508 {
 509         glFogx(pname, param);
 510 }
 511
 512 void
 513 _GlFogxv_1(GLenum pname, const GLfixed* pParams)
 514 {
 515         glFogxv(pname, pParams);
 516 }
 517
 518 void
 519 _GlFrontFace_1(GLenum mode)
 520 {
 521         glFrontFace(mode);
 522 }
 523
 524 void
 525 _GlFrustumx_1(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
 526 {
 527         glFrustumx(left, right, bottom, top, zNear, zFar);
 528 }
 529
 530 void
 531 _GlGetBooleanv_1(GLenum pname, GLboolean* pParams)
 532 {
 533         glGetBooleanv(pname, pParams);
 534 }
 535
 536 void
 537 _GlGetBufferParameteriv_1(GLenum target, GLenum pname, GLint* pParams)
 538 {
 539         glGetBufferParameteriv(target, pname, pParams);
 540 }
 541
 542 void
 543 _GlGetClipPlanex_1(GLenum pname, GLfixed eqn[4])
 544 {
 545         glGetClipPlanex(pname, eqn);
 546 }
 547
 548 void
 549 _GlGenBuffers_1(GLsizei n, GLuint* pBuffers)
 550 {
 551         glGenBuffers(n, pBuffers);
 552 }
 553
 554 void
 555 _GlGenTextures_1(GLsizei n, GLuint* pTextures)
 556 {
 557         glGenTextures(n, pTextures);
 558 }
 559
 560 GLenum
 561 _GlGetError_1(void)
 562 {
 563         return glGetError();
 564 }
 565
 566 void
 567 _GlGetFixedv_1(GLenum pname, GLfixed* pParams)
 568 {
 569         glGetFixedv(pname, pParams);
 570 }
 571
 572 void
 573 _GlGetIntegerv_1(GLenum pname, GLint* pParams)
 574 {
 575         glGetIntegerv(pname, pParams);
 576 }
 577
 578 void
 579 _GlGetLightxv_1(GLenum light, GLenum pname, GLfixed* pParams)
 580 {
 581         glGetLightxv(light, pname, pParams);
 582 }
 583
 584 void
 585 _GlGetMaterialxv_1(GLenum face, GLenum pname, GLfixed* pParams)
 586 {
 587         glGetMaterialxv(face, pname, pParams);
 588 }
 589
 590 void
 591 _GlGetPointerv_1(GLenum pname, void** ppParams)
 592 {
 593         glGetPointerv(pname, ppParams);
 594 }
 595
 596 const GLubyte*
 597 _GlGetString_1(GLenum name)
 598 {
 599         return glGetString(name);
 600 }
 601
 602 void
 603 _GlGetTexEnviv_1(GLenum env, GLenum pname, GLint* pParams)
 604 {
 605         glGetTexEnviv(env, pname, pParams);
 606 }
 607
 608 void
 609 _GlGetTexEnvxv_1(GLenum env, GLenum pname, GLfixed* pParams)
 610 {
 611         glGetTexEnvxv(env, pname, pParams);
 612 }
 613
 614 void
 615 _GlGetTexParameteriv_1(GLenum target, GLenum pname, GLint* pParams)
 616 {
 617         glGetTexParameteriv(target, pname, pParams);
 618 }
 619
 620 void
 621 _GlGetTexParameterxv_1(GLenum target, GLenum pname, GLfixed* pParams)
 622 {
 623         glGetTexParameterxv(target, pname, pParams);
 624 }
 625
 626 void
 627 _GlHint_1(GLenum target, GLenum mode)
 628 {
 629         glHint(target, mode);
 630 }
 631
 632 GLboolean
 633 _GlIsBuffer_1(GLuint buffer)
 634 {
 635         return glIsBuffer(buffer);
 636 }
 637
 638 GLboolean
 639 _GlIsEnabled_1(GLenum cap)
 640 {
 641         return glIsEnabled(cap);
 642 }
 643
 644 GLboolean
 645 _GlIsTexture_1(GLuint texture)
 646 {
 647         return glIsTexture(texture);
 648 }
 649
 650 void
 651 _GlLightModelx_1(GLenum pname, GLfixed param)
 652 {
 653         glLightModelx(pname, param);
 654 }
 655
 656 void
 657 _GlLightModelxv_1(GLenum pname, const GLfixed* pParams)
 658 {
 659         glLightModelxv(pname, pParams);
 660 }
 661
 662 void
 663 _GlLightx_1(GLenum light, GLenum pname, GLfixed param)
 664 {
 665         glLightx(light, pname, param);
 666 }
 667
 668 void
 669 _GlLightxv_1(GLenum light, GLenum pname, const GLfixed* pParams)
 670 {
 671         glLightxv(light, pname, pParams);
 672 }
 673
 674 void
 675 _GlLineWidthx_1(GLfixed width)
 676 {
 677         glLineWidthx(width);
 678 }
 679
 680 void
 681 _GlLoadIdentity_1(void)
 682 {
 683         glLoadIdentity();
 684 }
 685
 686 void
 687 _GlLoadMatrixx_1(const GLfixed* pM)
 688 {
 689         glLoadMatrixx(pM);
 690 }
 691
 692 void
 693 _GlLogicOp_1(GLenum opcode)
 694 {
 695         glLogicOp(opcode);
 696 }
 697
 698 void
 699 _GlMaterialx_1(GLenum face, GLenum pname, GLfixed param)
 700 {
 701         glMaterialx(face, pname, param);
 702 }
 703
 704 void
 705 _GlMaterialxv_1(GLenum face, GLenum pname, const GLfixed* pParams)
 706 {
 707         glMaterialxv(face, pname, pParams);
 708 }
 709
 710 void
 711 _GlMatrixMode_1(GLenum mode)
 712 {
 713         glMatrixMode(mode);
 714 }
 715
 716 void
 717 _GlMultMatrixx_1(const GLfixed* pM)
 718 {
 719         glMultMatrixx(pM);
 720 }
 721
 722 void
 723 _GlMultiTexCoord4x_1(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
 724 {
 725         glMultiTexCoord4x(target, s, t, r, q);
 726 }
 727
 728 void
 729 _GlNormal3x_1(GLfixed nx, GLfixed ny, GLfixed nz)
 730 {
 731         glNormal3x(nx, ny, nz);
 732 }
 733
 734 void
 735 _GlNormalPointer_1(GLenum type, GLsizei stride, const GLvoid* pPointer)
 736 {
 737         glNormalPointer(type, stride, pPointer);
 738 }
 739
 740 void
 741 _GlOrthox_1(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
 742 {
 743         glOrthox(left, right, bottom, top, zNear, zFar);
 744 }
 745
 746 void
 747 _GlPixelStorei_1(GLenum pname, GLint param)
 748 {
 749         glPixelStorei(pname, param);
 750 }
 751
 752 void
 753 _GlPointParameterx_1(GLenum pname, GLfixed param)
 754 {
 755         glPointParameterx(pname, param);
 756 }
 757
 758 void
 759 _GlPointParameterxv_1(GLenum pname, const GLfixed* pParams)
 760 {
 761         glPointParameterxv(pname, pParams);
 762 }
 763
 764 void
 765 _GlPointSizex_1(GLfixed size)
 766 {
 767         glPointSizex(size);
 768 }
 769
 770 void
 771 _GlPolygonOffsetx_1(GLfixed factor, GLfixed units)
 772 {
 773         glPolygonOffsetx(factor, units);
 774 }
 775
 776 void
 777 _GlPopMatrix_1(void)
 778 {
 779         glPopMatrix();
 780 }
 781
 782 void
 783 _GlPushMatrix_1(void)
 784 {
 785         glPushMatrix();
 786 }
 787
 788 void
 789 _GlReadPixels_1(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pPixels)
 790 {
 791         glReadPixels(x, y, width, height, format, type, pPixels);
 792 }
 793
 794 void
 795 _GlRotatex_1(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
 796 {
 797         glRotatex(angle, x, y, z);
 798 }
 799
 800 void
 801 _GlSampleCoverage_1(GLclampf value, GLboolean invert)
 802 {
 803         glSampleCoverage(value, invert);
 804 }
 805
 806 void
 807 _GlSampleCoveragex_1(GLclampx value, GLboolean invert)
 808 {
 809         glSampleCoveragex(value, invert);
 810 }
 811
 812 void
 813 _GlScalex_1(GLfixed x, GLfixed y, GLfixed z)
 814 {
 815         glScalex(x, y, z);
 816 }
 817
 818 void
 819 _GlScissor_1(GLint x, GLint y, GLsizei width, GLsizei height)
 820 {
 821         glScissor(x, y, width, height);
 822 }
 823
 824 void
 825 _GlShadeModel_1(GLenum mode)
 826 {
 827         glShadeModel(mode);
 828 }
 829
 830 void
 831 _GlStencilFunc_1(GLenum func, GLint ref, GLuint mask)
 832 {
 833         glStencilFunc(func, ref, mask);
 834 }
 835
 836 void
 837 _GlStencilMask_1(GLuint mask)
 838 {
 839         glStencilMask(mask);
 840 }
 841
 842 void
 843 _GlStencilOp_1(GLenum fail, GLenum zfail, GLenum zpass)
 844 {
 845         glStencilOp(fail, zfail, zpass);
 846 }
 847
 848 void
 849 _GlTexCoordPointer_1(GLint size, GLenum type, GLsizei stride, const GLvoid* pPointer)
 850 {
 851         glTexCoordPointer(size, type, stride, pPointer);
 852 }
 853
 854 void
 855 _GlTexEnvi_1(GLenum target, GLenum pname, GLint param)
 856 {
 857         glTexEnvi(target, pname, param);
 858 }
 859
 860 void
 861 _GlTexEnvx_1(GLenum target, GLenum pname, GLfixed param)
 862 {
 863         glTexEnvx(target, pname, param);
 864 }
 865
 866 void
 867 _GlTexEnviv_1(GLenum target, GLenum pname, const GLint* pParams)
 868 {
 869         glTexEnviv(target, pname, pParams);
 870 }
 871
 872 void
 873 _GlTexEnvxv_1(GLenum target, GLenum pname, const GLfixed* pParams)
 874 {
 875         glTexEnvxv(target, pname, pParams);
 876 }
 877
 878 void
 879 _GlTexImage2D_1(GLenum target, GLint level, GLint internalformat,
 880                 GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pPixels)
 881 {
 882         glTexImage2D(target, level, internalformat, width, height, border, format, type, pPixels);
 883 }
 884
 885 void
 886 _GlTexParameteri_1(GLenum target, GLenum pname, GLint param)
 887 {
 888         glTexParameteri(target, pname, param);
 889 }
 890
 891 void
 892 _GlTexParameterx_1(GLenum target, GLenum pname, GLfixed param)
 893 {
 894         glTexParameterx(target, pname, param);
 895 }
 896
 897 void
 898 _GlTexParameteriv_1(GLenum target, GLenum pname, const GLint* pParams)
 899 {
 900         glTexParameteriv(target, pname, pParams);
 901 }
 902
 903 void
 904 _GlTexParameterxv_1(GLenum target, GLenum pname, const GLfixed* pParams)
 905 {
 906         glTexParameterxv(target, pname, pParams);
 907 }
 908
 909 void
 910 _GlTexSubImage2D_1(GLenum target, GLint level, GLint xoffset, GLint yoffset,
 911                 GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pPixels)
 912 {
 913         glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pPixels);
 914 }
 915
 916 void
 917 _GlTranslatex_1(GLfixed x, GLfixed y, GLfixed z)
 918 {
 919         glTranslatex(x, y, z);
 920 }
 921
 922 void
 923 _GlVertexPointer_1(GLint size, GLenum type, GLsizei stride, const GLvoid* pPointer)
 924 {
 925         glVertexPointer(size, type, stride, pPointer);
 926 }
 927
 928 void
 929 _GlViewport_1(GLint x, GLint y, GLsizei width, GLsizei height)
 930 {
 931         glViewport(x, y, width, height);
 932 }
 933
 934 void
 935 _GlPointSizePointerOES_1(GLenum type, GLsizei stride, const GLvoid* pPointer)
 936 {
 937         glPointSizePointerOES(type, stride, pPointer);
 938 }
 939
 940 void
 941 _GlCurrentPaletteMatrixOES_1(GLuint matrixpaletteindex)
 942 {
 943         //glCurrentPaletteMatrixOES(matrixpaletteindex);
 944 }
 945 void
 946 _GlLoadPaletteFromModelViewMatrixOES_1(void)
 947 {
 948         //glLoadPaletteFromModelViewMatrixOES();
 949 }
 950 void
 951 _GlMatrixIndexPointerOES_1(GLint size, GLenum type, GLsizei stride, const GLvoid* pPointer)
 952 {
 953         //glMatrixIndexPointerOES(size, type, stride, pPointer);
 954 }
 955 void
 956 _GlWeightPointerOES_1(GLint size, GLenum type, GLsizei stride, const GLvoid* pPointer)
 957 {
 958         //glWeightPointerOES(size, type, stride, pPointer);
 959 }
 960
 961 //  FBO is extension functions in OpenGL ES 1.1
 962 //Start of FBO Functions
 963 GLboolean
 964 _GlIsRenderbufferOES_1(GLuint renderbuffer)
 965 {
 966         //return glIsRenderbufferOES(renderbuffer);
 967         return false;
 968 }
 969 void
 970 _GlBindRenderbufferOES_1(GLenum target, GLuint renderbuffer)
 971 {
 972         //glBindRenderbufferOES(target, renderbuffer);
 973 }
 974 void
 975 _GlDeleteRenderbuffersOES_1(GLsizei n, const GLuint* pRenderbuffers)
 976 {
 977         //glDeleteRenderbuffersOES(n, pRenderbuffers);
 978 }
 979 void
 980 _GlGenRenderbuffersOES_1(GLsizei n, GLuint* pRenderbuffers)
 981 {
 982         //glGenRenderbuffersOES(n, pRenderbuffers);
 983 }
 984 void
 985 _GlRenderbufferStorageOES_1(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 986 {
 987         //glRenderbufferStorageOES(target, internalformat, width, height);
 988 }
 989 void
 990 _GlGetRenderbufferParameterivOES_1(GLenum target, GLenum pname, GLint* pParams)
 991 {
 992         //glGetRenderbufferParameterivOES(target, pname, pParams);
 993 }
 994 GLboolean
 995 _GlIsFramebufferOES_1(GLuint framebuffer)
 996 {
 997         //return glIsFramebufferOES(framebuffer);
 998         return false;
 999 }
1000 void
1001 _GlBindFramebufferOES_1(GLenum target, GLuint framebuffer)
1002 {
1003         //glBindFramebufferOES(target, framebuffer);
1004 }
1005 void
1006 _GlDeleteFramebuffersOES_1(GLsizei n, const GLuint* pFramebuffers)
1007 {
1008         //glDeleteFramebuffersOES(n, pFramebuffers);
1009 }
1010 void
1011 _GlGenFramebuffersOES_1(GLsizei n, GLuint* pFramebuffers)
1012 {
1013         //glGenFramebuffersOES(n, pFramebuffers);
1014 }
1015 GLenum
1016 _GlCheckFramebufferStatusOES_1(GLenum target)
1017 {
1018         //return glCheckFramebufferStatusOES(target);;
1019         return false;
1020 }
1021 void
1022 _GlFramebufferRenderbufferOES_1(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
1023 {
1024         //glFramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer);
1025 }
1026 void
1027 _GlFramebufferTexture2DOES_1(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
1028 {
1029         //glFramebufferTexture2DOES(target, attachment, textarget, texture, level);
1030 }
1031 void
1032 _GlGetFramebufferAttachmentParameterivOES_1(GLenum target, GLenum attachment, GLenum pname, GLint* pParams)
1033 {
1034         //glGetFramebufferAttachmentParameterivOES(target, attachment, pname, pParams);
1035 }
1036 void
1037 _GlGenerateMipmapOES_1(GLenum target)
1038 {
1039         //glGenerateMipmapOES(target);
1040 }
1041 //End of FBO Functions
1042
1043 #ifdef __cplusplus
1044 }
1045 #endif
1046
1047 #else
1048
1049 #define _GLES_CHECK_INTERFACE_VOID_1 if (!_GlesInterfaceInitialize_1()) \
1050         { \
1051                 return; \
1052         }
1053 #define _GLES_CHECK_INTERFACE_GLBOOLEAN_1 if (!_GlesInterfaceInitialize_1()) \
1054         { \
1055                 return GL_FALSE; \
1056         }
1057 #define _GLES_CHECK_INTERFACE_GLENUM_1 if (!_GlesInterfaceInitialize_1()) \
1058         { \
1059                 return 0; \
1060         }
1061 #define _GLES_CHECK_INTERFACE_CONST_GLUBYTEP_1 if (!_GlesInterfaceInitialize_1()) \
1062         { \
1063                 return (const GLubyte*) 0; \
1064         }
1065
1066 namespace // unnamed
1067 {
1068
1069 struct _GlesInterface1
1070 {
1071         void (* glAlphaFunc)(GLenum func, GLclampf ref);
1072         void (* glClearColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
1073         void (* glClearDepthf)(GLclampf depth);
1074         void (* glClipPlanef)(GLenum plane, const GLfloat* pEquation);
1075         void (* glColor4f)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
1076         void (* glDepthRangef)(GLclampf zNear, GLclampf zFar);
1077         void (* glFogf)(GLenum pname, GLfloat param);
1078         void (* glFogfv)(GLenum pname, const GLfloat* pParams);
1079         void (* glFrustumf)(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
1080         void (* glGetClipPlanef)(GLenum pname, GLfloat eqn[4]);
1081         void (* glGetFloatv)(GLenum pname, GLfloat* pParams);
1082         void (* glGetLightfv)(GLenum light, GLenum pname, GLfloat* pParams);
1083         void (* glGetMaterialfv)(GLenum face, GLenum pname, GLfloat* pParams);
1084         void (* glGetTexEnvfv)(GLenum env, GLenum pname, GLfloat* pParams);
1085         void (* glGetTexParameterfv)(GLenum target, GLenum pname, GLfloat* pParams);
1086         void (* glLightModelf)(GLenum pname, GLfloat param);
1087         void (* glLightModelfv)(GLenum pname, const GLfloat* pParams);
1088         void (* glLightf)(GLenum light, GLenum pname, GLfloat param);
1089         void (* glLightfv)(GLenum light, GLenum pname, const GLfloat* pParams);
1090         void (* glLineWidth)(GLfloat width);
1091         void (* glLoadMatrixf)(const GLfloat* pM);
1092         void (* glMaterialf)(GLenum face, GLenum pname, GLfloat param);
1093         void (* glMaterialfv)(GLenum face, GLenum pname, const GLfloat* pParams);
1094         void (* glMultMatrixf)(const GLfloat* pM);
1095         void (* glMultiTexCoord4f)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
1096         void (* glNormal3f)(GLfloat nx, GLfloat ny, GLfloat nz);
1097         void (* glOrthof)(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
1098         void (* glPointParameterf)(GLenum pname, GLfloat param);
1099         void (* glPointParameterfv)(GLenum pname, const GLfloat* pParams);
1100         void (* glPointSize)(GLfloat size);
1101         void (* glPolygonOffset)(GLfloat factor, GLfloat units);
1102         void (* glRotatef)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
1103         void (* glScalef)(GLfloat x, GLfloat y, GLfloat z);
1104         void (* glTexEnvf)(GLenum target, GLenum pname, GLfloat param);
1105         void (* glTexEnvfv)(GLenum target, GLenum pname, const GLfloat* pParams);
1106         void (* glTexParameterf)(GLenum target, GLenum pname, GLfloat param);
1107         void (* glTexParameterfv)(GLenum target, GLenum pname, const GLfloat* pParams);
1108         void (* glTranslatef)(GLfloat x, GLfloat y, GLfloat z);
1109         void (* glActiveTexture)(GLenum texture);
1110         void (* glAlphaFuncx)(GLenum func, GLclampx ref);
1111         void (* glBindBuffer)(GLenum target, GLuint buffer);
1112         void (* glBindTexture)(GLenum target, GLuint texture);
1113         void (* glBlendFunc)(GLenum sfactor, GLenum dfactor);
1114         void (* glBufferData)(GLenum target, GLsizeiptr size, const GLvoid* pData, GLenum usage);
1115         void (* glBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* pData);
1116         void (* glClear)(GLbitfield mask);
1117         void (* glClearColorx)(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha);
1118         void (* glClearDepthx)(GLclampx depth);
1119         void (* glClearStencil)(GLint s);
1120         void (* glClientActiveTexture)(GLenum texture);
1121         void (* glClipPlanex)(GLenum plane, const GLfixed* pEquation);
1122         void (* glColor4ub)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
1123         void (* glColor4x)(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
1124         void (* glColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
1125         void (* glColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid* pPointer);
1126         void (* glCompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* pData);
1127         void (* glCompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* pData);
1128         void (* glCopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
1129         void (* glCopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
1130         void (* glCullFace)(GLenum mode);
1131         void (* glDeleteBuffers)(GLsizei n, const GLuint* pBuffers);
1132         void (* glDeleteTextures)(GLsizei n, const GLuint* pTextures);
1133         void (* glDepthFunc)(GLenum func);
1134         void (* glDepthMask)(GLboolean flag);
1135         void (* glDepthRangex)(GLclampx zNear, GLclampx zFar);
1136         void (* glDisable)(GLenum cap);
1137         void (* glDisableClientState)(GLenum array);
1138         void (* glDrawArrays)(GLenum mode, GLint first, GLsizei count);
1139         void (* glDrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid* pIndices);
1140         void (* glEnable)(GLenum cap);
1141         void (* glEnableClientState)(GLenum array);
1142         void (* glFinish)(void);
1143         void (* glFlush)(void);
1144         void (* glFogx)(GLenum pname, GLfixed param);
1145         void (* glFogxv)(GLenum pname, const GLfixed* pParams);
1146         void (* glFrontFace)(GLenum mode);
1147         void (* glFrustumx)(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
1148         void (* glGetBooleanv)(GLenum pname, GLboolean* pParams);
1149         void (* glGetBufferParameteriv)(GLenum target, GLenum pname, GLint* pParams);
1150         void (* glGetClipPlanex)(GLenum pname, GLfixed eqn[4]);
1151         void (* glGenBuffers)(GLsizei n, GLuint* pBuffers);
1152         void (* glGenTextures)(GLsizei n, GLuint* pTextures);
1153         GLenum (* glGetError)(void);
1154         void (* glGetFixedv)(GLenum pname, GLfixed* pParams);
1155         void (* glGetIntegerv)(GLenum pname, GLint* pParams);
1156         void (* glGetLightxv)(GLenum light, GLenum pname, GLfixed* pParams);
1157         void (* glGetMaterialxv)(GLenum face, GLenum pname, GLfixed* pParams);
1158         void (* glGetPointerv)(GLenum pname, void** ppParams);
1159         const GLubyte* (*glGetString)(GLenum name);
1160         void (* glGetTexEnviv)(GLenum env, GLenum pname, GLint* pParams);
1161         void (* glGetTexEnvxv)(GLenum env, GLenum pname, GLfixed* pParams);
1162         void (* glGetTexParameteriv)(GLenum target, GLenum pname, GLint* pParams);
1163         void (* glGetTexParameterxv)(GLenum target, GLenum pname, GLfixed* pParams);
1164         void (* glHint)(GLenum target, GLenum mode);
1165         GLboolean (* glIsBuffer)(GLuint buffer);
1166         GLboolean (* glIsEnabled)(GLenum cap);
1167         GLboolean (* glIsTexture)(GLuint texture);
1168         void (* glLightModelx)(GLenum pname, GLfixed param);
1169         void (* glLightModelxv)(GLenum pname, const GLfixed* pParams);
1170         void (* glLightx)(GLenum light, GLenum pname, GLfixed param);
1171         void (* glLightxv)(GLenum light, GLenum pname, const GLfixed* pParams);
1172         void (* glLineWidthx)(GLfixed width);
1173         void (* glLoadIdentity)(void);
1174         void (* glLoadMatrixx)(const GLfixed* pM);
1175         void (* glLogicOp)(GLenum opcode);
1176         void (* glMaterialx)(GLenum face, GLenum pname, GLfixed param);
1177         void (* glMaterialxv)(GLenum face, GLenum pname, const GLfixed* pParams);
1178         void (* glMatrixMode)(GLenum mode);
1179         void (* glMultMatrixx)(const GLfixed* pM);
1180         void (* glMultiTexCoord4x)(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q);
1181         void (* glNormal3x)(GLfixed nx, GLfixed ny, GLfixed nz);
1182         void (* glNormalPointer)(GLenum type, GLsizei stride, const GLvoid* pPointer);
1183         void (* glOrthox)(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
1184         void (* glPixelStorei)(GLenum pname, GLint param);
1185         void (* glPointParameterx)(GLenum pname, GLfixed param);
1186         void (* glPointParameterxv)(GLenum pname, const GLfixed* pParams);
1187         void (* glPointSizex)(GLfixed size);
1188         void (* glPolygonOffsetx)(GLfixed factor, GLfixed units);
1189         void (* glPopMatrix)(void);
1190         void (* glPushMatrix)(void);
1191         void (* glReadPixels)(GLint x, GLint y,
1192                         GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pPixels);
1193         void (* glRotatex)(GLfixed angle, GLfixed x, GLfixed y, GLfixed z);
1194         void (* glSampleCoverage)(GLclampf value, GLboolean invert);
1195         void (* glSampleCoveragex)(GLclampx value, GLboolean invert);
1196         void (* glScalex)(GLfixed x, GLfixed y, GLfixed z);
1197         void (* glScissor)(GLint x, GLint y, GLsizei width, GLsizei height);
1198         void (* glShadeModel)(GLenum mode);
1199         void (* glStencilFunc)(GLenum func, GLint ref, GLuint mask);
1200         void (* glStencilMask)(GLuint mask);
1201         void (* glStencilOp)(GLenum fail, GLenum zfail, GLenum zpass);
1202         void (* glTexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid* pPointer);
1203         void (* glTexEnvi)(GLenum target, GLenum pname, GLint param);
1204         void (* glTexEnvx)(GLenum target, GLenum pname, GLfixed param);
1205         void (* glTexEnviv)(GLenum target, GLenum pname, const GLint* pParams);
1206         void (* glTexEnvxv)(GLenum target, GLenum pname, const GLfixed* pParams);
1207         void (* glTexImage2D)(GLenum target, GLint level, GLint internalformat,
1208                         GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pPixels);
1209         void (* glTexParameteri)(GLenum target, GLenum pname, GLint param);
1210         void (* glTexParameterx)(GLenum target, GLenum pname, GLfixed param);
1211         void (* glTexParameteriv)(GLenum target, GLenum pname, const GLint* pParams);
1212         void (* glTexParameterxv)(GLenum target, GLenum pname, const GLfixed* pParams);
1213         void (* glTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset,
1214                         GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pPixels);
1215         void (* glTranslatex)(GLfixed x, GLfixed y, GLfixed z);
1216         void (* glVertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid* Pointer);
1217         void (* glViewport)(GLint x, GLint y, GLsizei width, GLsizei height);
1218         void (* glPointSizePointerOES)(GLenum type, GLsizei stride, const GLvoid* pPointer);
1219         void (* glCurrentPaletteMatrixOES) (GLuint matrixpaletteindex);
1220         void (* glLoadPaletteFromModelViewMatrixOES) (void);
1221         void (* glMatrixIndexPointerOES) (GLint size, GLenum type, GLsizei stride, const GLvoid* pPointer);
1222         void (* glWeightPointerOES) (GLint size, GLenum type, GLsizei stride, const GLvoid* pPointer);
1223         GLboolean (* glIsRenderbufferOES) (GLuint renderbuffer);
1224         void (* glBindRenderbufferOES) (GLenum target, GLuint renderbuffer);
1225         void (* glDeleteRenderbuffersOES) (GLsizei n, const GLuint* pRenderbuffers);
1226         void (* glGenRenderbuffersOES) (GLsizei n, GLuint* pRenderbuffers);
1227         void (* glRenderbufferStorageOES) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
1228         void (* glGetRenderbufferParameterivOES) (GLenum target, GLenum pname, GLint* pParams);
1229         GLboolean (* glIsFramebufferOES) (GLuint framebuffer);
1230         void (* glBindFramebufferOES) (GLenum target, GLuint framebuffer);
1231         void (* glDeleteFramebuffersOES) (GLsizei n, const GLuint* pFramebuffers);
1232         void (* glGenFramebuffersOES) (GLsizei n, GLuint* pFramebuffers);
1233         GLenum (* glCheckFramebufferStatusOES) (GLenum target);
1234         void (* glFramebufferRenderbufferOES) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
1235         void (* glFramebufferTexture2DOES) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
1236         void (* glGetFramebufferAttachmentParameterivOES) (GLenum target, GLenum attachment, GLenum pname, GLint* pParams);
1237         void (* glGenerateMipmapOES) (GLenum target);
1238 };
1239
1240 void* _pGlesLib1 = NULL;
1241 _GlesInterface1 _glesImpl1 = {0, };
1242
1243 const int _MAX_GLES_FUNCTION_1 = 164; //145 // extensions 164;
1244 const char _glesStrings1[_MAX_GLES_FUNCTION_1][64] =
1245 {
1246         "glAlphaFunc",
1247         "glClearColor",
1248         "glClearDepthf",
1249         "glClipPlanef",
1250         "glColor4f",
1251         "glDepthRangef",
1252         "glFogf",
1253         "glFogfv",
1254         "glFrustumf",
1255         "glGetClipPlanef",
1256         "glGetFloatv", //10
1257         "glGetLightfv",
1258         "glGetMaterialfv",
1259         "glGetTexEnvfv",
1260         "glGetTexParameterfv",
1261         "glLightModelf",
1262         "glLightModelfv",
1263         "glLightf",
1264         "glLightfv",
1265         "glLineWidth",
1266         "glLoadMatrixf", //20
1267         "glMaterialf",
1268         "glMaterialfv",
1269         "glMultMatrixf",
1270         "glMultiTexCoord4f",
1271         "glNormal3f",
1272         "glOrthof",
1273         "glPointParameterf",
1274         "glPointParameterfv",
1275         "glPointSize",
1276         "glPolygonOffset", //30
1277         "glRotatef",
1278         "glScalef",
1279         "glTexEnvf",
1280         "glTexEnvfv",
1281         "glTexParameterf",
1282         "glTexParameterfv",
1283         "glTranslatef",
1284         "glActiveTexture",
1285         "glAlphaFuncx",
1286         "glBindBuffer", //40
1287         "glBindTexture",
1288         "glBlendFunc",
1289         "glBufferData",
1290         "glBufferSubData",
1291         "glClear",
1292         "glClearColorx",
1293         "glClearDepthx",
1294         "glClearStencil",
1295         "glClientActiveTexture",
1296         "glClipPlanex", //50
1297         "glColor4ub",
1298         "glColor4x",
1299         "glColorMask",
1300         "glColorPointer",
1301         "glCompressedTexImage2D",
1302         "glCompressedTexSubImage2D",
1303         "glCopyTexImage2D",
1304         "glCopyTexSubImage2D",
1305         "glCullFace",
1306         "glDeleteBuffers", //60
1307         "glDeleteTextures",
1308         "glDepthFunc",
1309         "glDepthMask",
1310         "glDepthRangex",
1311         "glDisable",
1312         "glDisableClientState",
1313         "glDrawArrays",
1314         "glDrawElements",
1315         "glEnable",
1316         "glEnableClientState", //70
1317         "glFinish",
1318         "glFlush",
1319         "glFogx",
1320         "glFogxv",
1321         "glFrontFace",
1322         "glFrustumx",
1323         "glGetBooleanv",
1324         "glGetBufferParameteriv",
1325         "glGetClipPlanex",
1326         "glGenBuffers", //80
1327         "glGenTextures",
1328         "glGetError",
1329         "glGetFixedv",
1330         "glGetIntegerv",
1331         "glGetLightxv",
1332         "glGetMaterialxv",
1333         "glGetPointerv",
1334         "glGetString",
1335         "glGetTexEnviv",
1336         "glGetTexEnvxv", //90
1337         "glGetTexParameteriv",
1338         "glGetTexParameterxv",
1339         "glHint",
1340         "glIsBuffer",
1341         "glIsEnabled",
1342         "glIsTexture",
1343         "glLightModelx",
1344         "glLightModelxv",
1345         "glLightx",
1346         "glLightxv", //100
1347         "glLineWidthx",
1348         "glLoadIdentity",
1349         "glLoadMatrixx",
1350         "glLogicOp",
1351         "glMaterialx",
1352         "glMaterialxv",
1353         "glMatrixMode",
1354         "glMultMatrixx",
1355         "glMultiTexCoord4x",
1356         "glNormal3x", //110
1357         "glNormalPointer",
1358         "glOrthox",
1359         "glPixelStorei",
1360         "glPointParameterx",
1361         "glPointParameterxv",
1362         "glPointSizex",
1363         "glPolygonOffsetx",
1364         "glPopMatrix",
1365         "glPushMatrix",
1366         "glReadPixels", //120
1367         "glRotatex",
1368         "glSampleCoverage",
1369         "glSampleCoveragex",
1370         "glScalex",
1371         "glScissor",
1372         "glShadeModel",
1373         "glStencilFunc",
1374         "glStencilMask",
1375         "glStencilOp",
1376         "glTexCoordPointer", //130
1377         "glTexEnvi",
1378         "glTexEnvx",
1379         "glTexEnviv",
1380         "glTexEnvxv",
1381         "glTexImage2D",
1382         "glTexParameteri",
1383         "glTexParameterx",
1384         "glTexParameteriv",
1385         "glTexParameterxv",
1386         "glTexSubImage2D", //140
1387         "glTranslatex",
1388         "glVertexPointer",
1389         "glViewport",
1390         "glPointSizePointerOES", //144
1391         "glCurrentPaletteMatrixOES",
1392         "glLoadPaletteFromModelViewMatrixOES",
1393         "glMatrixIndexPointerOES",
1394         "glWeightPointerOES",
1395         "glIsRenderbufferOES",
1396         "glBindRenderbufferOES", //150
1397         "glDeleteRenderbuffersOES",
1398         "glGenRenderbuffersOES",
1399         "glRenderbufferStorageOES",
1400         "glGetRenderbufferParameterivOES",
1401         "glIsFramebufferOES",
1402         "glBindFramebufferOES",
1403         "glDeleteFramebuffersOES",
1404         "glGenFramebuffersOES",
1405         "glCheckFramebufferStatusOES",
1406         "glFramebufferRenderbufferOES", //160
1407         "glFramebufferTexture2DOES",
1408         "glGetFramebufferAttachmentParameterivOES",
1409         "glGenerateMipmapOES" //163
1410 };
1411
1412 bool
1413 _GlesInterfaceInitialize_1(void)
1414 {
1415         int count = 0;
1416
1417         if (_pGlesLib1 == NULL)
1418         {
1419                 ptrdiff_t** ppPtr = (ptrdiff_t**) (&_glesImpl1);
1420
1421                 _pGlesLib1 = dlopen("libGLESv1_CM.so", RTLD_LAZY | RTLD_GLOBAL);
1422                 if (_pGlesLib1 == NULL)
1423                 {
1424                         SysLog(NID_GRP, "gles1 dlopen failed! %s", dlerror());
1425                         return false;
1426                 }
1427
1428                 for (count = 0; count < _MAX_GLES_FUNCTION_1; count++)
1429                 {
1430                         *ppPtr = (ptrdiff_t*) (dlsym(_pGlesLib1, _glesStrings1[count]));
1431
1432                         if (*ppPtr == NULL)
1433                         {
1434                                 SysLog(NID_GRP, "dlsym failed! %s name : %s", dlerror(), _glesStrings1[count]);
1435                         }
1436                         ppPtr++;
1437                 }
1438         }
1439
1440         return true;
1441 }
1442
1443 }
1444
1445 #ifdef __cplusplus
1446 extern "C"
1447 {
1448 #endif
1449
1450 #if defined(FGRAPHICS_INTERNAL_USE_FBO)
1451 GLuint _GlesGetCurrentFbo(void);
1452 bool _GlesFboEnableStencil(GLuint& frameBufferObject, GLuint& renderBuffer);
1453 #endif
1454
1455 _OSP_LOCAL_ void
1456 _GlesInterfaceTerminate_1(void)
1457 {
1458         if (_pGlesLib1 != NULL)
1459         {
1460                 dlclose(_pGlesLib1);
1461                 _pGlesLib1 = NULL;
1462         }
1463 }
1464
1465 void
1466 _GlAlphaFunc_1(GLenum func, GLclampf ref)
1467 {
1468         _GLES_CHECK_INTERFACE_VOID_1
1469         _glesImpl1.glAlphaFunc(func, ref);
1470 }
1471
1472 void
1473 _GlClearColor_1(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
1474 {
1475         _GLES_CHECK_INTERFACE_VOID_1
1476         _glesImpl1.glClearColor(red, green, blue, alpha);
1477 }
1478
1479 void
1480 _GlClearDepthf_1(GLclampf depth)
1481 {
1482         _GLES_CHECK_INTERFACE_VOID_1
1483         _glesImpl1.glClearDepthf(depth);
1484 }
1485
1486 void
1487 _GlClipPlanef_1(GLenum plane, const GLfloat* pEquation)
1488 {
1489         _GLES_CHECK_INTERFACE_VOID_1
1490         _glesImpl1.glClipPlanef(plane, pEquation);
1491 }
1492
1493 void
1494 _GlColor4f_1(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
1495 {
1496         _GLES_CHECK_INTERFACE_VOID_1
1497         _glesImpl1.glColor4f(red, green, blue, alpha);
1498 }
1499
1500 void
1501 _GlDepthRangef_1(GLclampf zNear, GLclampf zFar)
1502 {
1503         _GLES_CHECK_INTERFACE_VOID_1
1504         _glesImpl1.glDepthRangef(zNear, zFar);
1505 }
1506
1507 void
1508 _GlFogf_1(GLenum pname, GLfloat param)
1509 {
1510         _GLES_CHECK_INTERFACE_VOID_1
1511         _glesImpl1.glFogf(pname, param);
1512 }
1513
1514 void
1515 _GlFogfv_1(GLenum pname, const GLfloat* pParams)
1516 {
1517         _GLES_CHECK_INTERFACE_VOID_1
1518         _glesImpl1.glFogfv(pname, pParams);
1519 }
1520
1521 void
1522 _GlFrustumf_1(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
1523 {
1524         _GLES_CHECK_INTERFACE_VOID_1
1525         _glesImpl1.glFrustumf(left, right, bottom, top, zNear, zFar);
1526 }
1527
1528 void
1529 _GlGetClipPlanef_1(GLenum pname, GLfloat eqn[4])
1530 {
1531         _GLES_CHECK_INTERFACE_VOID_1
1532         _glesImpl1.glGetClipPlanef(pname, eqn);
1533 }
1534
1535 void
1536 _GlGetFloatv_1(GLenum pname, GLfloat* pParams)
1537 {
1538         _GLES_CHECK_INTERFACE_VOID_1
1539         _glesImpl1.glGetFloatv(pname, pParams);
1540 }
1541
1542 void
1543 _GlGetLightfv_1(GLenum light, GLenum pname, GLfloat* pParams)
1544 {
1545         _GLES_CHECK_INTERFACE_VOID_1
1546         _glesImpl1.glGetLightfv(light, pname, pParams);
1547 }
1548
1549 void
1550 _GlGetMaterialfv_1(GLenum face, GLenum pname, GLfloat* pParams)
1551 {
1552         _GLES_CHECK_INTERFACE_VOID_1
1553         _glesImpl1.glGetMaterialfv(face, pname, pParams);
1554 }
1555
1556 void
1557 _GlGetTexEnvfv_1(GLenum env, GLenum pname, GLfloat* pParams)
1558 {
1559         _GLES_CHECK_INTERFACE_VOID_1
1560         _glesImpl1.glGetTexEnvfv(env, pname, pParams);
1561 }
1562
1563 void
1564 _GlGetTexParameterfv_1(GLenum target, GLenum pname, GLfloat* pParams)
1565 {
1566         _GLES_CHECK_INTERFACE_VOID_1
1567         _glesImpl1.glGetTexParameterfv(target, pname, pParams);
1568 }
1569
1570 void
1571 _GlLightModelf_1(GLenum pname, GLfloat param)
1572 {
1573         _GLES_CHECK_INTERFACE_VOID_1
1574         _glesImpl1.glLightModelf(pname, param);
1575 }
1576
1577 void
1578 _GlLightModelfv_1(GLenum pname, const GLfloat* pParams)
1579 {
1580         _GLES_CHECK_INTERFACE_VOID_1
1581         _glesImpl1.glLightModelfv(pname, pParams);
1582 }
1583
1584 void
1585 _GlLightf_1(GLenum light, GLenum pname, GLfloat param)
1586 {
1587         _GLES_CHECK_INTERFACE_VOID_1
1588         _glesImpl1.glLightf(light, pname, param);
1589 }
1590
1591 void
1592 _GlLightfv_1(GLenum light, GLenum pname, const GLfloat* pParams)
1593 {
1594         _GLES_CHECK_INTERFACE_VOID_1
1595         _glesImpl1.glLightfv(light, pname, pParams);
1596 }
1597
1598 void
1599 _GlLineWidth_1(GLfloat width)
1600 {
1601         _GLES_CHECK_INTERFACE_VOID_1
1602         _glesImpl1.glLineWidth(width);
1603 }
1604
1605 void
1606 _GlLoadMatrixf_1(const GLfloat* pM)
1607 {
1608         _GLES_CHECK_INTERFACE_VOID_1
1609         _glesImpl1.glLoadMatrixf(pM);
1610 }
1611
1612 void
1613 _GlMaterialf_1(GLenum face, GLenum pname, GLfloat param)
1614 {
1615         _GLES_CHECK_INTERFACE_VOID_1
1616         _glesImpl1.glMaterialf(face, pname, param);
1617 }
1618
1619 void
1620 _GlMaterialfv_1(GLenum face, GLenum pname, const GLfloat* pParams)
1621 {
1622         _GLES_CHECK_INTERFACE_VOID_1
1623         _glesImpl1.glMaterialfv(face, pname, pParams);
1624 }
1625
1626 void
1627 _GlMultMatrixf_1(const GLfloat* pM)
1628 {
1629         _GLES_CHECK_INTERFACE_VOID_1
1630         _glesImpl1.glMultMatrixf(pM);
1631 }
1632
1633 void
1634 _GlMultiTexCoord4f_1(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
1635 {
1636         _GLES_CHECK_INTERFACE_VOID_1
1637         _glesImpl1.glMultiTexCoord4f(target, s, t, r, q);
1638 }
1639
1640 void
1641 _GlNormal3f_1(GLfloat nx, GLfloat ny, GLfloat nz)
1642 {
1643         _GLES_CHECK_INTERFACE_VOID_1
1644         _glesImpl1.glNormal3f(nx, ny, nz);
1645 }
1646
1647 void
1648 _GlOrthof_1(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
1649 {
1650         _GLES_CHECK_INTERFACE_VOID_1
1651         _glesImpl1.glOrthof(left, right, bottom, top, zNear, zFar);
1652 }
1653
1654 void
1655 _GlPointParameterf_1(GLenum pname, GLfloat param)
1656 {
1657         _GLES_CHECK_INTERFACE_VOID_1
1658         _glesImpl1.glPointParameterf(pname, param);
1659 }
1660
1661 void
1662 _GlPointParameterfv_1(GLenum pname, const GLfloat* pParams)
1663 {
1664         _GLES_CHECK_INTERFACE_VOID_1
1665         _glesImpl1.glPointParameterfv(pname, pParams);
1666 }
1667
1668 void
1669 _GlPointSize_1(GLfloat size)
1670 {
1671         _GLES_CHECK_INTERFACE_VOID_1
1672         _glesImpl1.glPointSize(size);
1673 }
1674
1675 void
1676 _GlPolygonOffset_1(GLfloat factor, GLfloat units)
1677 {
1678         _GLES_CHECK_INTERFACE_VOID_1
1679         _glesImpl1.glPolygonOffset(factor, units);
1680 }
1681
1682 void
1683 _GlRotatef_1(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
1684 {
1685         _GLES_CHECK_INTERFACE_VOID_1
1686         _glesImpl1.glRotatef(angle, x, y, z);
1687 }
1688
1689 void
1690 _GlScalef_1(GLfloat x, GLfloat y, GLfloat z)
1691 {
1692         _GLES_CHECK_INTERFACE_VOID_1
1693         _glesImpl1.glScalef(x, y, z);
1694 }
1695
1696 void
1697 _GlTexEnvf_1(GLenum target, GLenum pname, GLfloat param)
1698 {
1699         _GLES_CHECK_INTERFACE_VOID_1
1700         _glesImpl1.glTexEnvf(target, pname, param);
1701 }
1702
1703 void
1704 _GlTexEnvfv_1(GLenum target, GLenum pname, const GLfloat* pParams)
1705 {
1706         _GLES_CHECK_INTERFACE_VOID_1
1707         _glesImpl1.glTexEnvfv(target, pname, pParams);
1708 }
1709
1710 void
1711 _GlTexParameterf_1(GLenum target, GLenum pname, GLfloat param)
1712 {
1713         _GLES_CHECK_INTERFACE_VOID_1
1714         _glesImpl1.glTexParameterf(target, pname, param);
1715 }
1716
1717 void
1718 _GlTexParameterfv_1(GLenum target, GLenum pname, const GLfloat* pParams)
1719 {
1720         _GLES_CHECK_INTERFACE_VOID_1
1721         _glesImpl1.glTexParameterfv(target, pname, pParams);
1722 }
1723
1724 void
1725 _GlTranslatef_1(GLfloat x, GLfloat y, GLfloat z)
1726 {
1727         _GLES_CHECK_INTERFACE_VOID_1
1728         _glesImpl1.glTranslatef(x, y, z);
1729 }
1730
1731 void
1732 _GlActiveTexture_1(GLenum texture)
1733 {
1734         _GLES_CHECK_INTERFACE_VOID_1
1735         _glesImpl1.glActiveTexture(texture);
1736 }
1737
1738 void
1739 _GlAlphaFuncx_1(GLenum func, GLclampx ref)
1740 {
1741         _GLES_CHECK_INTERFACE_VOID_1
1742         _glesImpl1.glAlphaFuncx(func, ref);
1743 }
1744
1745 void
1746 _GlBindBuffer_1(GLenum target, GLuint buffer)
1747 {
1748         _GLES_CHECK_INTERFACE_VOID_1
1749         _glesImpl1.glBindBuffer(target, buffer);
1750 }
1751
1752 void
1753 _GlBindTexture_1(GLenum target, GLuint texture)
1754 {
1755         _GLES_CHECK_INTERFACE_VOID_1
1756         _glesImpl1.glBindTexture(target, texture);
1757 }
1758
1759 void
1760 _GlBlendFunc_1(GLenum sfactor, GLenum dfactor)
1761 {
1762         _GLES_CHECK_INTERFACE_VOID_1
1763         _glesImpl1.glBlendFunc(sfactor, dfactor);
1764 }
1765
1766 void
1767 _GlBufferData_1(GLenum target, GLsizeiptr size, const GLvoid* pData, GLenum usage)
1768 {
1769         _GLES_CHECK_INTERFACE_VOID_1
1770         _glesImpl1.glBufferData(target, size, pData, usage);
1771 }
1772
1773 void
1774 _GlBufferSubData_1(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* pData)
1775 {
1776         _GLES_CHECK_INTERFACE_VOID_1
1777         _glesImpl1.glBufferSubData(target, offset, size, pData);
1778 }
1779
1780 void
1781 _GlClear_1(GLbitfield mask)
1782 {
1783         _GLES_CHECK_INTERFACE_VOID_1
1784         _glesImpl1.glClear(mask);
1785 }
1786
1787 void
1788 _GlClearColorx_1(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
1789 {
1790         _GLES_CHECK_INTERFACE_VOID_1
1791         _glesImpl1.glClearColorx(red, green, blue, alpha);
1792 }
1793
1794 void
1795 _GlClearDepthx_1(GLclampx depth)
1796 {
1797         _GLES_CHECK_INTERFACE_VOID_1
1798         _glesImpl1.glClearDepthx(depth);
1799 }
1800
1801 void
1802 _GlClearStencil_1(GLint s)
1803 {
1804         _GLES_CHECK_INTERFACE_VOID_1
1805         _glesImpl1.glClearStencil(s);
1806 }
1807
1808 void
1809 _GlClientActiveTexture_1(GLenum texture)
1810 {
1811         _GLES_CHECK_INTERFACE_VOID_1
1812         _glesImpl1.glClientActiveTexture(texture);
1813 }
1814
1815 void
1816 _GlClipPlanex_1(GLenum plane, const GLfixed* pEquation)
1817 {
1818         _GLES_CHECK_INTERFACE_VOID_1
1819         _glesImpl1.glClipPlanex(plane, pEquation);
1820 }
1821
1822 void
1823 _GlColor4ub_1(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
1824 {
1825         _GLES_CHECK_INTERFACE_VOID_1
1826         _glesImpl1.glColor4ub(red, green, blue, alpha);
1827 }
1828
1829 void
1830 _GlColor4x_1(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
1831 {
1832         _GLES_CHECK_INTERFACE_VOID_1
1833         _glesImpl1.glColor4x(red, green, blue, alpha);
1834 }
1835
1836 void
1837 _GlColorMask_1(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
1838 {
1839         _GLES_CHECK_INTERFACE_VOID_1
1840         _glesImpl1.glColorMask(red, green, blue, alpha);
1841 }
1842
1843 void
1844 _GlColorPointer_1(GLint size, GLenum type, GLsizei stride, const GLvoid* pPointer)
1845 {
1846         _GLES_CHECK_INTERFACE_VOID_1
1847         _glesImpl1.glColorPointer(size, type, stride, pPointer);
1848 }
1849
1850 void
1851 _GlCompressedTexImage2D_1(GLenum target, GLint level, GLenum internalformat,
1852                 GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* pData)
1853 {
1854         _GLES_CHECK_INTERFACE_VOID_1
1855         _glesImpl1.glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, pData);
1856 }
1857
1858 void
1859 _GlCompressedTexSubImage2D_1(GLenum target, GLint level, GLint xoffset, GLint yoffset,
1860                 GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* pData)
1861 {
1862         _GLES_CHECK_INTERFACE_VOID_1
1863         _glesImpl1.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, pData);
1864 }
1865
1866 void
1867 _GlCopyTexImage2D_1(GLenum target, GLint level,
1868                 GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
1869 {
1870         _GLES_CHECK_INTERFACE_VOID_1
1871         _glesImpl1.glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
1872 }
1873
1874 void
1875 _GlCopyTexSubImage2D_1(GLenum target, GLint level,
1876                 GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
1877 {
1878         _GLES_CHECK_INTERFACE_VOID_1
1879         _glesImpl1.glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
1880 }
1881
1882 void
1883 _GlCullFace_1(GLenum mode)
1884 {
1885         _GLES_CHECK_INTERFACE_VOID_1
1886         _glesImpl1.glCullFace(mode);
1887 }
1888
1889 void
1890 _GlDeleteBuffers_1(GLsizei n, const GLuint* pBuffers)
1891 {
1892         _GLES_CHECK_INTERFACE_VOID_1
1893         _glesImpl1.glDeleteBuffers(n, pBuffers);
1894 }
1895
1896 void
1897 _GlDeleteTextures_1(GLsizei n, const GLuint* pTextures)
1898 {
1899         _GLES_CHECK_INTERFACE_VOID_1
1900         _glesImpl1.glDeleteTextures(n, pTextures);
1901 }
1902
1903 void
1904 _GlDepthFunc_1(GLenum func)
1905 {
1906         _GLES_CHECK_INTERFACE_VOID_1
1907         _glesImpl1.glDepthFunc(func);
1908 }
1909
1910 void
1911 _GlDepthMask_1(GLboolean flag)
1912 {
1913         _GLES_CHECK_INTERFACE_VOID_1
1914         _glesImpl1.glDepthMask(flag);
1915 }
1916
1917 void
1918 _GlDepthRangex_1(GLclampx zNear, GLclampx zFar)
1919 {
1920         _GLES_CHECK_INTERFACE_VOID_1
1921         _glesImpl1.glDepthRangex(zNear, zFar);
1922 }
1923
1924 void
1925 _GlDisable_1(GLenum cap)
1926 {
1927         _GLES_CHECK_INTERFACE_VOID_1
1928         _glesImpl1.glDisable(cap);
1929 }
1930
1931 void
1932 _GlDisableClientState_1(GLenum array)
1933 {
1934         _GLES_CHECK_INTERFACE_VOID_1
1935         _glesImpl1.glDisableClientState(array);
1936 }
1937
1938 void
1939 _GlDrawArrays_1(GLenum mode, GLint first, GLsizei count)
1940 {
1941         _GLES_CHECK_INTERFACE_VOID_1
1942         _glesImpl1.glDrawArrays(mode, first, count);
1943 }
1944
1945 void
1946 _GlDrawElements_1(GLenum mode, GLsizei count, GLenum type, const GLvoid* pIndices)
1947 {
1948         _GLES_CHECK_INTERFACE_VOID_1
1949         _glesImpl1.glDrawElements(mode, count, type, pIndices);
1950 }
1951
1952 void
1953 _GlEnable_1(GLenum cap)
1954 {
1955         _GLES_CHECK_INTERFACE_VOID_1
1956 #if defined(FGRAPHICS_INTERNAL_USE_FBO)
1957         if (cap == GL_STENCIL_TEST)
1958         {
1959                 GLuint frameBufferObject = 0;
1960                 GLuint stencilRenderBuffer = 0;
1961
1962                 bool ret = _GlesFboEnableStencil(frameBufferObject, stencilRenderBuffer);
1963
1964                 if (ret)
1965                 {
1966                         _glesImpl1.glBindFramebufferOES(GL_FRAMEBUFFER_OES, frameBufferObject);
1967                         _glesImpl1.glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_STENCIL_ATTACHMENT_OES, GL_RENDERBUFFER_OES, stencilRenderBuffer);
1968                 }
1969         }
1970 #endif
1971         _glesImpl1.glEnable(cap);
1972 }
1973
1974 void
1975 _GlEnableClientState_1(GLenum array)
1976 {
1977         _GLES_CHECK_INTERFACE_VOID_1
1978         _glesImpl1.glEnableClientState(array);
1979 }
1980
1981 void
1982 _GlFinish_1(void)
1983 {
1984         _GLES_CHECK_INTERFACE_VOID_1
1985         _glesImpl1.glFinish();
1986 }
1987
1988 void
1989 _GlFlush_1(void)
1990 {
1991         _GLES_CHECK_INTERFACE_VOID_1
1992         _glesImpl1.glFlush();
1993 }
1994
1995 void
1996 _GlFogx_1(GLenum pname, GLfixed param)
1997 {
1998         _GLES_CHECK_INTERFACE_VOID_1
1999         _glesImpl1.glFogx(pname, param);
2000 }
2001
2002 void
2003 _GlFogxv_1(GLenum pname, const GLfixed* pParams)
2004 {
2005         _GLES_CHECK_INTERFACE_VOID_1
2006         _glesImpl1.glFogxv(pname, pParams);
2007 }
2008
2009 void
2010 _GlFrontFace_1(GLenum mode)
2011 {
2012         _GLES_CHECK_INTERFACE_VOID_1
2013         _glesImpl1.glFrontFace(mode);
2014 }
2015
2016 void
2017 _GlFrustumx_1(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
2018 {
2019         _GLES_CHECK_INTERFACE_VOID_1
2020         _glesImpl1.glFrustumx(left, right, bottom, top, zNear, zFar);
2021 }
2022
2023 void
2024 _GlGetBooleanv_1(GLenum pname, GLboolean* pParams)
2025 {
2026         _GLES_CHECK_INTERFACE_VOID_1
2027         _glesImpl1.glGetBooleanv(pname, pParams);
2028 }
2029
2030 void
2031 _GlGetBufferParameteriv_1(GLenum target, GLenum pname, GLint* pParams)
2032 {
2033         _GLES_CHECK_INTERFACE_VOID_1
2034         _glesImpl1.glGetBufferParameteriv(target, pname, pParams);
2035 }
2036
2037 void
2038 _GlGetClipPlanex_1(GLenum pname, GLfixed eqn[4])
2039 {
2040         _GLES_CHECK_INTERFACE_VOID_1
2041         _glesImpl1.glGetClipPlanex(pname, eqn);
2042 }
2043
2044 void
2045 _GlGenBuffers_1(GLsizei n, GLuint* pBuffers)
2046 {
2047         _GLES_CHECK_INTERFACE_VOID_1
2048         _glesImpl1.glGenBuffers(n, pBuffers);
2049 }
2050
2051 void
2052 _GlGenTextures_1(GLsizei n, GLuint* pTextures)
2053 {
2054         _GLES_CHECK_INTERFACE_VOID_1
2055         _glesImpl1.glGenTextures(n, pTextures);
2056 }
2057
2058 GLenum
2059 _GlGetError_1(void)
2060 {
2061         _GLES_CHECK_INTERFACE_GLENUM_1
2062         return _glesImpl1.glGetError();
2063 }
2064
2065 void
2066 _GlGetFixedv_1(GLenum pname, GLfixed* pParams)
2067 {
2068         _GLES_CHECK_INTERFACE_VOID_1
2069         _glesImpl1.glGetFixedv(pname, pParams);
2070 }
2071
2072 void
2073 _GlGetIntegerv_1(GLenum pname, GLint* pParams)
2074 {
2075         _GLES_CHECK_INTERFACE_VOID_1
2076         _glesImpl1.glGetIntegerv(pname, pParams);
2077 }
2078
2079 void
2080 _GlGetLightxv_1(GLenum light, GLenum pname, GLfixed* pParams)
2081 {
2082         _GLES_CHECK_INTERFACE_VOID_1
2083         _glesImpl1.glGetLightxv(light, pname, pParams);
2084 }
2085
2086 void
2087 _GlGetMaterialxv_1(GLenum face, GLenum pname, GLfixed* pParams)
2088 {
2089         _GLES_CHECK_INTERFACE_VOID_1
2090         _glesImpl1.glGetMaterialxv(face, pname, pParams);
2091 }
2092
2093 void
2094 _GlGetPointerv_1(GLenum pname, void** ppParams)
2095 {
2096         _GLES_CHECK_INTERFACE_VOID_1
2097         _glesImpl1.glGetPointerv(pname, ppParams);
2098 }
2099
2100 const GLubyte*
2101 _GlGetString_1(GLenum name)
2102 {
2103         _GLES_CHECK_INTERFACE_CONST_GLUBYTEP_1
2104         return _glesImpl1.glGetString(name);
2105 }
2106
2107 void
2108 _GlGetTexEnviv_1(GLenum env, GLenum pname, GLint* pParams)
2109 {
2110         _GLES_CHECK_INTERFACE_VOID_1
2111         _glesImpl1.glGetTexEnviv(env, pname, pParams);
2112 }
2113
2114 void
2115 _GlGetTexEnvxv_1(GLenum env, GLenum pname, GLfixed* pParams)
2116 {
2117         _GLES_CHECK_INTERFACE_VOID_1
2118         _glesImpl1.glGetTexEnvxv(env, pname, pParams);
2119 }
2120
2121 void
2122 _GlGetTexParameteriv_1(GLenum target, GLenum pname, GLint* pParams)
2123 {
2124         _GLES_CHECK_INTERFACE_VOID_1
2125         _glesImpl1.glGetTexParameteriv(target, pname, pParams);
2126 }
2127
2128 void
2129 _GlGetTexParameterxv_1(GLenum target, GLenum pname, GLfixed* pParams)
2130 {
2131         _GLES_CHECK_INTERFACE_VOID_1
2132         _glesImpl1.glGetTexParameterxv(target, pname, pParams);
2133 }
2134
2135 void
2136 _GlHint_1(GLenum target, GLenum mode)
2137 {
2138         _GLES_CHECK_INTERFACE_VOID_1
2139         _glesImpl1.glHint(target, mode);
2140 }
2141
2142 GLboolean
2143 _GlIsBuffer_1(GLuint buffer)
2144 {
2145         _GLES_CHECK_INTERFACE_GLBOOLEAN_1
2146         return _glesImpl1.glIsBuffer(buffer);
2147 }
2148
2149 GLboolean
2150 _GlIsEnabled_1(GLenum cap)
2151 {
2152         _GLES_CHECK_INTERFACE_GLBOOLEAN_1
2153         return _glesImpl1.glIsEnabled(cap);
2154 }
2155
2156 GLboolean
2157 _GlIsTexture_1(GLuint texture)
2158 {
2159         _GLES_CHECK_INTERFACE_GLBOOLEAN_1
2160         return _glesImpl1.glIsTexture(texture);
2161 }
2162
2163 void
2164 _GlLightModelx_1(GLenum pname, GLfixed param)
2165 {
2166         _GLES_CHECK_INTERFACE_VOID_1
2167         _glesImpl1.glLightModelx(pname, param);
2168 }
2169
2170 void
2171 _GlLightModelxv_1(GLenum pname, const GLfixed* pParams)
2172 {
2173         _GLES_CHECK_INTERFACE_VOID_1
2174         _glesImpl1.glLightModelxv(pname, pParams);
2175 }
2176
2177 void
2178 _GlLightx_1(GLenum light, GLenum pname, GLfixed param)
2179 {
2180         _GLES_CHECK_INTERFACE_VOID_1
2181         _glesImpl1.glLightx(light, pname, param);
2182 }
2183
2184 void
2185 _GlLightxv_1(GLenum light, GLenum pname, const GLfixed* pParams)
2186 {
2187         _GLES_CHECK_INTERFACE_VOID_1
2188         _glesImpl1.glLightxv(light, pname, pParams);
2189 }
2190
2191 void
2192 _GlLineWidthx_1(GLfixed width)
2193 {
2194         _GLES_CHECK_INTERFACE_VOID_1
2195         _glesImpl1.glLineWidthx(width);
2196 }
2197
2198 void
2199 _GlLoadIdentity_1(void)
2200 {
2201         _GLES_CHECK_INTERFACE_VOID_1
2202         _glesImpl1.glLoadIdentity();
2203 }
2204
2205 void
2206 _GlLoadMatrixx_1(const GLfixed* pM)
2207 {
2208         _GLES_CHECK_INTERFACE_VOID_1
2209         _glesImpl1.glLoadMatrixx(pM);
2210 }
2211
2212 void
2213 _GlLogicOp_1(GLenum opcode)
2214 {
2215         _GLES_CHECK_INTERFACE_VOID_1
2216         _glesImpl1.glLogicOp(opcode);
2217 }
2218
2219 void
2220 _GlMaterialx_1(GLenum face, GLenum pname, GLfixed param)
2221 {
2222         _GLES_CHECK_INTERFACE_VOID_1
2223         _glesImpl1.glMaterialx(face, pname, param);
2224 }
2225
2226 void
2227 _GlMaterialxv_1(GLenum face, GLenum pname, const GLfixed* pParams)
2228 {
2229         _GLES_CHECK_INTERFACE_VOID_1
2230         _glesImpl1.glMaterialxv(face, pname, pParams);
2231 }
2232
2233 void
2234 _GlMatrixMode_1(GLenum mode)
2235 {
2236         _GLES_CHECK_INTERFACE_VOID_1
2237         _glesImpl1.glMatrixMode(mode);
2238 }
2239
2240 void
2241 _GlMultMatrixx_1(const GLfixed* pM)
2242 {
2243         _GLES_CHECK_INTERFACE_VOID_1
2244         _glesImpl1.glMultMatrixx(pM);
2245 }
2246
2247 void
2248 _GlMultiTexCoord4x_1(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
2249 {
2250         _GLES_CHECK_INTERFACE_VOID_1
2251         _glesImpl1.glMultiTexCoord4x(target, s, t, r, q);
2252 }
2253
2254 void
2255 _GlNormal3x_1(GLfixed nx, GLfixed ny, GLfixed nz)
2256 {
2257         _GLES_CHECK_INTERFACE_VOID_1
2258         _glesImpl1.glNormal3x(nx, ny, nz);
2259 }
2260
2261 void
2262 _GlNormalPointer_1(GLenum type, GLsizei stride, const GLvoid* pPointer)
2263 {
2264         _GLES_CHECK_INTERFACE_VOID_1
2265         _glesImpl1.glNormalPointer(type, stride, pPointer);
2266 }
2267
2268 void
2269 _GlOrthox_1(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
2270 {
2271         _GLES_CHECK_INTERFACE_VOID_1
2272         _glesImpl1.glOrthox(left, right, bottom, top, zNear, zFar);
2273 }
2274
2275 void
2276 _GlPixelStorei_1(GLenum pname, GLint param)
2277 {
2278         _GLES_CHECK_INTERFACE_VOID_1
2279         _glesImpl1.glPixelStorei(pname, param);
2280 }
2281
2282 void
2283 _GlPointParameterx_1(GLenum pname, GLfixed param)
2284 {
2285         _GLES_CHECK_INTERFACE_VOID_1
2286         _glesImpl1.glPointParameterx(pname, param);
2287 }
2288
2289 void
2290 _GlPointParameterxv_1(GLenum pname, const GLfixed* pParams)
2291 {
2292         _GLES_CHECK_INTERFACE_VOID_1
2293         _glesImpl1.glPointParameterxv(pname, pParams);
2294 }
2295
2296 void
2297 _GlPointSizex_1(GLfixed size)
2298 {
2299         _GLES_CHECK_INTERFACE_VOID_1
2300         _glesImpl1.glPointSizex(size);
2301 }
2302
2303 void
2304 _GlPolygonOffsetx_1(GLfixed factor, GLfixed units)
2305 {
2306         _GLES_CHECK_INTERFACE_VOID_1
2307         _glesImpl1.glPolygonOffsetx(factor, units);
2308 }
2309
2310 void
2311 _GlPopMatrix_1(void)
2312 {
2313         _GLES_CHECK_INTERFACE_VOID_1
2314         _glesImpl1.glPopMatrix();
2315 }
2316
2317 void
2318 _GlPushMatrix_1(void)
2319 {
2320         _GLES_CHECK_INTERFACE_VOID_1
2321         _glesImpl1.glPushMatrix();
2322 }
2323
2324 void
2325 _GlReadPixels_1(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pPixels)
2326 {
2327         _GLES_CHECK_INTERFACE_VOID_1
2328         _glesImpl1.glReadPixels(x, y, width, height, format, type, pPixels);
2329 }
2330
2331 void
2332 _GlRotatex_1(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
2333 {
2334         _GLES_CHECK_INTERFACE_VOID_1
2335         _glesImpl1.glRotatex(angle, x, y, z);
2336 }
2337
2338 void
2339 _GlSampleCoverage_1(GLclampf value, GLboolean invert)
2340 {
2341         _GLES_CHECK_INTERFACE_VOID_1
2342         _glesImpl1.glSampleCoverage(value, invert);
2343 }
2344
2345 void
2346 _GlSampleCoveragex_1(GLclampx value, GLboolean invert)
2347 {
2348         _GLES_CHECK_INTERFACE_VOID_1
2349         _glesImpl1.glSampleCoveragex(value, invert);
2350 }
2351
2352 void
2353 _GlScalex_1(GLfixed x, GLfixed y, GLfixed z)
2354 {
2355         _GLES_CHECK_INTERFACE_VOID_1
2356         _glesImpl1.glScalex(x, y, z);
2357 }
2358
2359 void
2360 _GlScissor_1(GLint x, GLint y, GLsizei width, GLsizei height)
2361 {
2362         _GLES_CHECK_INTERFACE_VOID_1
2363         _glesImpl1.glScissor(x, y, width, height);
2364 }
2365
2366 void
2367 _GlShadeModel_1(GLenum mode)
2368 {
2369         _GLES_CHECK_INTERFACE_VOID_1
2370         _glesImpl1.glShadeModel(mode);
2371 }
2372
2373 void
2374 _GlStencilFunc_1(GLenum func, GLint ref, GLuint mask)
2375 {
2376         _GLES_CHECK_INTERFACE_VOID_1
2377         _glesImpl1.glStencilFunc(func, ref, mask);
2378 }
2379
2380 void
2381 _GlStencilMask_1(GLuint mask)
2382 {
2383         _GLES_CHECK_INTERFACE_VOID_1
2384         _glesImpl1.glStencilMask(mask);
2385 }
2386
2387 void
2388 _GlStencilOp_1(GLenum fail, GLenum zfail, GLenum zpass)
2389 {
2390         _GLES_CHECK_INTERFACE_VOID_1
2391         _glesImpl1.glStencilOp(fail, zfail, zpass);
2392 }
2393
2394 void
2395 _GlTexCoordPointer_1(GLint size, GLenum type, GLsizei stride, const GLvoid* pPointer)
2396 {
2397         _GLES_CHECK_INTERFACE_VOID_1
2398         _glesImpl1.glTexCoordPointer(size, type, stride, pPointer);
2399 }
2400
2401 void
2402 _GlTexEnvi_1(GLenum target, GLenum pname, GLint param)
2403 {
2404         _GLES_CHECK_INTERFACE_VOID_1
2405         _glesImpl1.glTexEnvi(target, pname, param);
2406 }
2407
2408 void
2409 _GlTexEnvx_1(GLenum target, GLenum pname, GLfixed param)
2410 {
2411         _GLES_CHECK_INTERFACE_VOID_1
2412         _glesImpl1.glTexEnvx(target, pname, param);
2413 }
2414
2415 void
2416 _GlTexEnviv_1(GLenum target, GLenum pname, const GLint* pParams)
2417 {
2418         _GLES_CHECK_INTERFACE_VOID_1
2419         _glesImpl1.glTexEnviv(target, pname, pParams);
2420 }
2421
2422 void
2423 _GlTexEnvxv_1(GLenum target, GLenum pname, const GLfixed* pParams)
2424 {
2425         _GLES_CHECK_INTERFACE_VOID_1
2426         _glesImpl1.glTexEnvxv(target, pname, pParams);
2427 }
2428
2429 void
2430 _GlTexImage2D_1(GLenum target, GLint level, GLint internalformat,
2431                 GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pPixels)
2432 {
2433         _GLES_CHECK_INTERFACE_VOID_1
2434         _glesImpl1.glTexImage2D(target, level, internalformat, width, height, border, format, type, pPixels);
2435 }
2436
2437 void
2438 _GlTexParameteri_1(GLenum target, GLenum pname, GLint param)
2439 {
2440         _GLES_CHECK_INTERFACE_VOID_1
2441         _glesImpl1.glTexParameteri(target, pname, param);
2442 }
2443
2444 void
2445 _GlTexParameterx_1(GLenum target, GLenum pname, GLfixed param)
2446 {
2447         _GLES_CHECK_INTERFACE_VOID_1
2448         _glesImpl1.glTexParameterx(target, pname, param);
2449 }
2450
2451 void
2452 _GlTexParameteriv_1(GLenum target, GLenum pname, const GLint* pParams)
2453 {
2454         _GLES_CHECK_INTERFACE_VOID_1
2455         _glesImpl1.glTexParameteriv(target, pname, pParams);
2456 }
2457
2458 void
2459 _GlTexParameterxv_1(GLenum target, GLenum pname, const GLfixed* pParams)
2460 {
2461         _GLES_CHECK_INTERFACE_VOID_1
2462         _glesImpl1.glTexParameterxv(target, pname, pParams);
2463 }
2464
2465 void
2466 _GlTexSubImage2D_1(GLenum target, GLint level, GLint xoffset, GLint yoffset,
2467                 GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pPixels)
2468 {
2469         _GLES_CHECK_INTERFACE_VOID_1
2470         _glesImpl1.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pPixels);
2471 }
2472
2473 void
2474 _GlTranslatex_1(GLfixed x, GLfixed y, GLfixed z)
2475 {
2476         _GLES_CHECK_INTERFACE_VOID_1
2477         _glesImpl1.glTranslatex(x, y, z);
2478 }
2479
2480 void
2481 _GlVertexPointer_1(GLint size, GLenum type, GLsizei stride, const GLvoid* pPointer)
2482 {
2483         _GLES_CHECK_INTERFACE_VOID_1
2484         _glesImpl1.glVertexPointer(size, type, stride, pPointer);
2485 }
2486
2487 void
2488 _GlViewport_1(GLint x, GLint y, GLsizei width, GLsizei height)
2489 {
2490         _GLES_CHECK_INTERFACE_VOID_1
2491         _glesImpl1.glViewport(x, y, width, height);
2492 }
2493
2494 void
2495 _GlPointSizePointerOES_1(GLenum type, GLsizei stride, const GLvoid* pPointer)
2496 {
2497         _GLES_CHECK_INTERFACE_VOID_1
2498         _glesImpl1.glPointSizePointerOES(type, stride, pPointer);
2499 }
2500
2501 void
2502 _GlCurrentPaletteMatrixOES_1(GLuint matrixpaletteindex)
2503 {
2504         _GLES_CHECK_INTERFACE_VOID_1
2505         _glesImpl1.glCurrentPaletteMatrixOES(matrixpaletteindex);
2506 }
2507
2508 void
2509 _GlLoadPaletteFromModelViewMatrixOES_1(void)
2510 {
2511         _GLES_CHECK_INTERFACE_VOID_1
2512         _glesImpl1.glLoadPaletteFromModelViewMatrixOES();
2513 }
2514
2515 void
2516 _GlMatrixIndexPointerOES_1(GLint size, GLenum type, GLsizei stride, const GLvoid* pPointer)
2517 {
2518         _GLES_CHECK_INTERFACE_VOID_1
2519         _glesImpl1.glMatrixIndexPointerOES(size, type, stride, pPointer);
2520 }
2521
2522 void
2523 _GlWeightPointerOES_1(GLint size, GLenum type, GLsizei stride, const GLvoid* pPointer)
2524 {
2525         _GLES_CHECK_INTERFACE_VOID_1
2526         _glesImpl1.glWeightPointerOES(size, type, stride, pPointer);
2527 }
2528
2529 //  FBO is extension functions in OpenGL ES 1.1
2530 //Start of FBO Functions
2531 GLboolean
2532 _GlIsRenderbufferOES_1(GLuint renderbuffer)
2533 {
2534         _GLES_CHECK_INTERFACE_GLBOOLEAN_1
2535         return _glesImpl1.glIsRenderbufferOES(renderbuffer);
2536 }
2537
2538 void
2539 _GlBindRenderbufferOES_1(GLenum target, GLuint renderbuffer)
2540 {
2541         _GLES_CHECK_INTERFACE_VOID_1
2542         _glesImpl1.glBindRenderbufferOES(target, renderbuffer);
2543 }
2544
2545 void
2546 _GlDeleteRenderbuffersOES_1(GLsizei n, const GLuint* pRenderbuffers)
2547 {
2548         _GLES_CHECK_INTERFACE_VOID_1
2549         _glesImpl1.glDeleteRenderbuffersOES(n, pRenderbuffers);
2550 }
2551
2552 void
2553 _GlGenRenderbuffersOES_1(GLsizei n, GLuint* pRenderbuffers)
2554 {
2555         _GLES_CHECK_INTERFACE_VOID_1
2556         _glesImpl1.glGenRenderbuffersOES(n, pRenderbuffers);
2557 }
2558
2559 void
2560 _GlRenderbufferStorageOES_1(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
2561 {
2562         _GLES_CHECK_INTERFACE_VOID_1
2563         _glesImpl1.glRenderbufferStorageOES(target, internalformat, width, height);
2564 }
2565
2566 void
2567 _GlGetRenderbufferParameterivOES_1(GLenum target, GLenum pname, GLint* pParams)
2568 {
2569         _GLES_CHECK_INTERFACE_VOID_1
2570         _glesImpl1.glGetRenderbufferParameterivOES(target, pname, pParams);
2571 }
2572
2573 GLboolean
2574 _GlIsFramebufferOES_1(GLuint framebuffer)
2575 {
2576         _GLES_CHECK_INTERFACE_GLBOOLEAN_1
2577         return _glesImpl1.glIsFramebufferOES(framebuffer);
2578 }
2579
2580 void
2581 _GlBindFramebufferOES_1(GLenum target, GLuint framebuffer)
2582 {
2583         _GLES_CHECK_INTERFACE_VOID_1
2584
2585 #if defined(FGRAPHICS_INTERNAL_USE_FBO)
2586         if (framebuffer == 0)
2587         {
2588                 framebuffer = _GlesGetCurrentFbo();
2589         }
2590 #endif
2591
2592         _glesImpl1.glBindFramebufferOES(target, framebuffer);
2593 }
2594
2595 void
2596 _GlDeleteFramebuffersOES_1(GLsizei n, const GLuint* pFramebuffers)
2597 {
2598         _GLES_CHECK_INTERFACE_VOID_1
2599         _glesImpl1.glDeleteFramebuffersOES(n, pFramebuffers);
2600 }
2601
2602 void
2603 _GlGenFramebuffersOES_1(GLsizei n, GLuint* pFramebuffers)
2604 {
2605         _GLES_CHECK_INTERFACE_VOID_1
2606         _glesImpl1.glGenFramebuffersOES(n, pFramebuffers);
2607 }
2608
2609 GLenum
2610 _GlCheckFramebufferStatusOES_1(GLenum target)
2611 {
2612         _GLES_CHECK_INTERFACE_GLENUM_1
2613         return _glesImpl1.glCheckFramebufferStatusOES(target);
2614 }
2615
2616 void
2617 _GlFramebufferRenderbufferOES_1(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
2618 {
2619         _GLES_CHECK_INTERFACE_VOID_1
2620         _glesImpl1.glFramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer);
2621 }
2622
2623 void
2624 _GlFramebufferTexture2DOES_1(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
2625 {
2626         _GLES_CHECK_INTERFACE_VOID_1
2627         _glesImpl1.glFramebufferTexture2DOES(target, attachment, textarget, texture, level);
2628 }
2629
2630 void
2631 _GlGetFramebufferAttachmentParameterivOES_1(GLenum target, GLenum attachment, GLenum pname, GLint* pParams)
2632 {
2633         _GLES_CHECK_INTERFACE_VOID_1
2634         _glesImpl1.glGetFramebufferAttachmentParameterivOES(target, attachment, pname, pParams);
2635 }
2636
2637 void
2638 _GlGenerateMipmapOES_1(GLenum target)
2639 {
2640         _GLES_CHECK_INTERFACE_VOID_1
2641         _glesImpl1.glGenerateMipmapOES(target);
2642 }
2643 //End of FBO Functions
2644
2645 #if defined(FGRAPHICS_INTERNAL_USE_FBO)
2646 _OSP_LOCAL_ int
2647 _GlesFboGetPowerOf2(int value)
2648 {
2649         int result = 1;
2650
2651         while(result < value)
2652         {
2653                 result <<= 1;
2654         }
2655
2656         return result;
2657 }
2658
2659 _OSP_LOCAL_ void
2660 _GlesFboTerminate_1(GLuint& frameBufferObject, GLuint& depthRenderBuffer, GLuint& stencilRenderBuffer, GLuint& textureId)
2661 {
2662         _GLES_CHECK_INTERFACE_VOID_1
2663         _glesImpl1.glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0);
2664
2665         if (frameBufferObject != 0)
2666         {
2667                 _glesImpl1.glDeleteFramebuffersOES(1, &frameBufferObject);
2668                 frameBufferObject = 0;
2669         }
2670
2671         if (depthRenderBuffer != 0)
2672         {
2673                 _glesImpl1.glDeleteRenderbuffersOES(1, &depthRenderBuffer);
2674                 depthRenderBuffer = 0;
2675         }
2676
2677         if (stencilRenderBuffer != 0)
2678         {
2679                 _glesImpl1.glDeleteRenderbuffersOES(1, &stencilRenderBuffer);
2680                 stencilRenderBuffer = 0;
2681         }
2682
2683         if (textureId != 0)
2684         {
2685                 _glesImpl1.glDeleteTextures(1, &textureId);
2686                 textureId = 0;
2687         }
2688 }
2689
2690 _OSP_LOCAL_ bool
2691 _GlesFboInitialize_1(int& fboWidth, int& fboHeight, GLuint& frameBufferObject, GLuint& depthRenderBuffer
2692                 , GLuint& stencilRenderBuffer, GLuint colorSize, GLuint depthSize, GLuint stencilSize, GLuint& textureId)
2693 {
2694         _GLES_CHECK_INTERFACE_GLBOOLEAN_1
2695         const char* pString = (const char*)_glesImpl1.glGetString(GL_EXTENSIONS);
2696         String extensions(pString);
2697         if (!extensions.Contains(L"GL_OES_framebuffer_object"))
2698         {
2699                 SysLog(NID_GRP, "FBO not supported : %ls", extensions.GetPointer());
2700                 return false;
2701         }
2702
2703         if (!extensions.Contains(L"GL_OES_texture_npot"))
2704         {
2705                 fboWidth = _GlesFboGetPowerOf2(fboWidth);
2706                 fboHeight = _GlesFboGetPowerOf2(fboHeight);
2707         }
2708
2709         GLint maxSize = 0;
2710         _glesImpl1.glGetIntegerv(GL_MAX_RENDERBUFFER_SIZE_OES, &maxSize);
2711         if (fboWidth > maxSize || fboHeight > maxSize)
2712         {
2713                 SysLog(NID_GRP, "FBO Incompatible size");
2714                 return false;
2715         }
2716
2717         _glesImpl1.glEnable(GL_TEXTURE_2D);
2718
2719         _glesImpl1.glGenFramebuffersOES(1, &frameBufferObject);
2720         _glesImpl1.glGenRenderbuffersOES(1, &depthRenderBuffer);
2721         _glesImpl1.glGenRenderbuffersOES(1, &stencilRenderBuffer);
2722         _glesImpl1.glGenTextures(1, &textureId);
2723         if (frameBufferObject == 0 || depthRenderBuffer == 0 || stencilRenderBuffer == 0 || textureId == 0)
2724         {
2725                 SysLog(NID_GRP, "FBO generating failed! fbo:%d depth:%d stencil:%d tex:%d"
2726                                 , frameBufferObject, depthRenderBuffer, stencilRenderBuffer, textureId);
2727                 _GlesFboTerminate_1(frameBufferObject, depthRenderBuffer, stencilRenderBuffer, textureId);
2728         }
2729
2730         _glesImpl1.glBindTexture(GL_TEXTURE_2D, textureId);
2731         if (colorSize > 16)
2732         {
2733                 _glesImpl1.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, fboWidth, fboHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
2734         }
2735         else
2736         {
2737                 _glesImpl1.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, fboWidth, fboHeight, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, NULL);
2738         }
2739         _glesImpl1.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2740         _glesImpl1.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2741         _glesImpl1.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2742         _glesImpl1.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2743
2744         if (depthSize > 0)
2745         {
2746                 GLenum internalFormat = GL_DEPTH_COMPONENT16_OES;
2747
2748                 if (depthSize > 24)
2749                 {
2750                         if (extensions.Contains(L"GL_OES_depth32"))
2751                         {
2752                                 internalFormat = GL_DEPTH_COMPONENT32_OES;
2753                         }
2754                 }
2755                 else if (depthSize > 16)
2756                 {
2757                         if (extensions.Contains(L"GL_OES_depth24"))
2758                         {
2759                                 internalFormat = GL_DEPTH_COMPONENT24_OES;
2760                         }
2761                 }
2762
2763                 _glesImpl1.glBindRenderbufferOES(GL_RENDERBUFFER_OES, depthRenderBuffer);
2764                 _glesImpl1.glRenderbufferStorageOES(GL_RENDERBUFFER_OES, internalFormat, fboWidth, fboHeight);
2765         }
2766
2767         if (stencilSize > 0)
2768         {
2769                 GLenum internalFormat = 0;
2770
2771                 if (extensions.Contains(L"GL_OES_stencil8"))
2772                 {
2773                         internalFormat = GL_STENCIL_INDEX8_OES;
2774                 }
2775
2776                 if (stencilSize == 1)
2777                 {
2778                         if (extensions.Contains(L"GL_OES_stencil1"))
2779                         {
2780                                 internalFormat = GL_STENCIL_INDEX1_OES;
2781                         }
2782                 }
2783                 else if (stencilSize <= 4)
2784                 {
2785                         if (extensions.Contains(L"GL_OES_stencil4"))
2786                         {
2787                                 internalFormat = GL_STENCIL_INDEX4_OES;
2788                         }
2789                 }
2790
2791                 if (internalFormat != 0)
2792                 {
2793                         _glesImpl1.glBindRenderbufferOES(GL_RENDERBUFFER_OES, stencilRenderBuffer);
2794                         _glesImpl1.glRenderbufferStorageOES(GL_RENDERBUFFER_OES, internalFormat, fboWidth, fboHeight);
2795                 }
2796         }
2797
2798         _glesImpl1.glBindFramebufferOES(GL_FRAMEBUFFER_OES, frameBufferObject);
2799         _glesImpl1.glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_TEXTURE_2D, textureId, 0);
2800         if (depthSize != 0)
2801         {
2802                 _glesImpl1.glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES
2803                                 , GL_RENDERBUFFER_OES, depthRenderBuffer);
2804         }
2805
2806         _glesImpl1.glBindTexture(GL_TEXTURE_2D, 0);
2807
2808         GLenum ret = _glesImpl1.glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES);
2809         if (ret != GL_FRAMEBUFFER_COMPLETE_OES)
2810         {
2811                 _GlesFboTerminate_1(frameBufferObject, depthRenderBuffer, stencilRenderBuffer, textureId);
2812                 SysLog(NID_GRP, "FBO glCheckFramebufferStatus failed! %#x", (unsigned int)ret);
2813                 return false;
2814         }
2815
2816         return true;
2817 }
2818
2819 _OSP_LOCAL_ void
2820 _GlesFboBinding_1(const GLuint frameBufferObject)
2821 {
2822         _GLES_CHECK_INTERFACE_VOID_1
2823         _glesImpl1.glBindFramebufferOES(GL_FRAMEBUFFER_OES, frameBufferObject);
2824 }
2825
2826 _OSP_LOCAL_ void
2827 _GlesFboSwapBuffers_1(const Frame* pFrame, int fboWidth, int fboHeight, const GLuint frameBufferObject, const GLuint textureId)
2828 {
2829         _GLES_CHECK_INTERFACE_VOID_1
2830         GLboolean isEnabledCullFace = GL_FALSE;
2831         GLboolean isEnabledStencil = GL_FALSE;
2832         GLboolean isEnabledDepth = GL_FALSE;
2833         GLboolean isEnabledScissor = GL_FALSE;
2834         GLboolean isEnabledBlend = GL_FALSE;
2835         GLboolean isEnabledTexture = GL_FALSE;
2836         GLboolean isEnabledVertexArray = GL_FALSE;
2837         GLboolean isEnabledNormalArray = GL_FALSE;
2838         GLboolean isEnabledColorArray = GL_FALSE;
2839         GLboolean isEnabledTextureCoordArray = GL_FALSE;
2840
2841         isEnabledCullFace = _glesImpl1.glIsEnabled(GL_CULL_FACE);
2842         isEnabledStencil = _glesImpl1.glIsEnabled(GL_STENCIL_TEST);
2843         isEnabledDepth = _glesImpl1.glIsEnabled(GL_DEPTH_TEST);
2844         isEnabledScissor = _glesImpl1.glIsEnabled(GL_SCISSOR_TEST);
2845         isEnabledBlend = _glesImpl1.glIsEnabled(GL_BLEND);
2846         isEnabledNormalArray = _glesImpl1.glIsEnabled(GL_NORMAL_ARRAY);
2847         isEnabledColorArray = _glesImpl1.glIsEnabled(GL_COLOR_ARRAY);
2848         _glesImpl1.glDisable(GL_CULL_FACE);
2849         _glesImpl1.glDisable(GL_STENCIL_TEST);
2850         _glesImpl1.glDisable(GL_DEPTH_TEST);
2851         _glesImpl1.glDisable(GL_SCISSOR_TEST);
2852         _glesImpl1.glDisable(GL_BLEND);
2853         _glesImpl1.glDisableClientState(GL_NORMAL_ARRAY);
2854         _glesImpl1.glDisableClientState(GL_COLOR_ARRAY);
2855
2856         isEnabledTexture = _glesImpl1.glIsEnabled(GL_TEXTURE_2D);
2857         isEnabledVertexArray = _glesImpl1.glIsEnabled(GL_VERTEX_ARRAY);
2858         isEnabledTextureCoordArray = _glesImpl1.glIsEnabled(GL_TEXTURE_COORD_ARRAY);
2859         _glesImpl1.glEnable(GL_TEXTURE_2D);
2860         _glesImpl1.glEnableClientState(GL_VERTEX_ARRAY);
2861         _glesImpl1.glEnableClientState(GL_TEXTURE_COORD_ARRAY);
2862
2863         GLint previousTextureId = 0;
2864         GLint previousMatrixMode = 0;
2865         GLint previousArrayBuffer = 0;
2866         GLint previousElementArrayBuffer = 0;
2867         GLint previousViewport[4] = {0,};
2868         _glesImpl1.glGetIntegerv(GL_TEXTURE_BINDING_2D, &previousTextureId);
2869         _glesImpl1.glGetIntegerv(GL_MATRIX_MODE, &previousMatrixMode);
2870         _glesImpl1.glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &previousArrayBuffer);
2871         _glesImpl1.glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &previousElementArrayBuffer);
2872         _glesImpl1.glGetIntegerv(GL_VIEWPORT, previousViewport);
2873
2874         GLfloat currentColor[4] = {0.0f, };
2875         GLfloat currentNormal[3] = {0.0f, };
2876         _glesImpl1.glGetFloatv(GL_CURRENT_COLOR, currentColor);
2877         _glesImpl1.glGetFloatv(GL_CURRENT_NORMAL, currentNormal);
2878         _glesImpl1.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
2879         _glesImpl1.glNormal3f(0.0f, 0.0f, 1.0f);
2880
2881         _glesImpl1.glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0);
2882         _glesImpl1.glBindTexture( GL_TEXTURE_2D, textureId);
2883
2884         _glesImpl1.glMatrixMode(GL_PROJECTION);
2885         _glesImpl1.glPushMatrix();
2886         _glesImpl1.glLoadIdentity();
2887         _glesImpl1.glOrthof(-1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f);
2888
2889         _glesImpl1.glMatrixMode(GL_TEXTURE);
2890         _glesImpl1.glPushMatrix();
2891         _glesImpl1.glLoadIdentity();
2892
2893         _glesImpl1.glMatrixMode(GL_MODELVIEW);
2894         _glesImpl1.glPushMatrix();
2895         _glesImpl1.glLoadIdentity();
2896
2897         int x = 0;
2898         int y = 0;
2899         int width = 0;
2900         int height = 0;
2901         pFrame->GetBounds(x, y, width, height);
2902
2903         GLfloat ratioX1 = 0.0f;
2904         GLfloat ratioX2 = (GLfloat)width / fboWidth;
2905         GLfloat ratioY1 = 0.0f;
2906         GLfloat ratioY2 = (GLfloat)height / fboHeight;
2907
2908         GLfloat texture[] = {
2909                         ratioX1, ratioY1,
2910                         ratioX2, ratioY1,
2911                         ratioX1, ratioY2,
2912                         ratioX2, ratioY2,
2913         };
2914
2915         OrientationStatus orientationStatus = pFrame->GetOrientationStatus();
2916         switch(orientationStatus)
2917         {
2918                 default:
2919                 case ORIENTATION_STATUS_NONE:
2920                 case ORIENTATION_STATUS_PORTRAIT:
2921                         _glesImpl1.glViewport(0, 0, width, height);
2922                 break;
2923
2924                 case ORIENTATION_STATUS_LANDSCAPE:
2925                         texture[0] = ratioX2;
2926                         texture[1] = ratioY1;
2927                         texture[2] = ratioX2;
2928                         texture[3] = ratioY2;
2929                         texture[4] = ratioX1;
2930                         texture[5] = ratioY1;
2931                         texture[6] = ratioX1;
2932                         texture[7] = ratioY2;
2933                         _glesImpl1.glViewport(0, 0, height, width);
2934                 break;
2935
2936                 case ORIENTATION_STATUS_PORTRAIT_REVERSE:
2937                         texture[0] = ratioX2;
2938                         texture[1] = ratioY2;
2939                         texture[2] = ratioX1;
2940                         texture[3] = ratioY2;
2941                         texture[4] = ratioX2;
2942                         texture[5] = ratioY1;
2943                         texture[6] = ratioX1;
2944                         texture[7] = ratioY1;
2945                         _glesImpl1.glViewport(0, 0, width, height);
2946                 break;
2947
2948                 case ORIENTATION_STATUS_LANDSCAPE_REVERSE:
2949                         texture[0] = ratioX1;
2950                         texture[1] = ratioY2;
2951                         texture[2] = ratioX1;
2952                         texture[3] = ratioY1;
2953                         texture[4] = ratioX2;
2954                         texture[5] = ratioY2;
2955                         texture[6] = ratioX2;
2956                         texture[7] = ratioY1;
2957                         _glesImpl1.glViewport(0, 0, height, width);
2958                 break;
2959         }
2960
2961         GLfloat vertex[] = {
2962                         -1.0f, -1.0f,
2963                          1.0f, -1.0f,
2964                         -1.0f,  1.0f,
2965                          1.0f,  1.0f,
2966         };
2967
2968         _glesImpl1.glBindBuffer(GL_ARRAY_BUFFER, 0);
2969         _glesImpl1.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
2970
2971         _glesImpl1.glVertexPointer(2, GL_FLOAT, 0, vertex);
2972         _glesImpl1.glTexCoordPointer(2, GL_FLOAT, 0, texture);
2973
2974         _glesImpl1.glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
2975
2976         _glesImpl1.glPopMatrix();
2977         _glesImpl1.glMatrixMode(GL_TEXTURE);
2978         _glesImpl1.glPopMatrix();
2979         _glesImpl1.glMatrixMode(GL_PROJECTION);
2980         _glesImpl1.glPopMatrix();
2981
2982         _glesImpl1.glBindFramebufferOES(GL_FRAMEBUFFER_OES, frameBufferObject);
2983         if (isEnabledCullFace)
2984         {
2985                 _glesImpl1.glEnable(GL_CULL_FACE);
2986         }
2987         if (isEnabledStencil)
2988         {
2989                 _glesImpl1.glEnable(GL_STENCIL_TEST);
2990         }
2991         if (isEnabledDepth)
2992         {
2993                 _glesImpl1.glEnable(GL_DEPTH_TEST);
2994         }
2995         if (isEnabledScissor)
2996         {
2997                 _glesImpl1.glEnable(GL_SCISSOR_TEST);
2998         }
2999         if (isEnabledBlend)
3000         {
3001                 _glesImpl1.glEnable(GL_BLEND);
3002         }
3003         if (isEnabledNormalArray)
3004         {
3005                 _glesImpl1.glIsEnabled(GL_NORMAL_ARRAY);
3006         }
3007         if (isEnabledColorArray)
3008         {
3009                 _glesImpl1.glIsEnabled(GL_COLOR_ARRAY);
3010         }
3011
3012         if (!isEnabledTexture)
3013         {
3014                 _glesImpl1.glDisable(GL_TEXTURE_2D);
3015         }
3016         if (!isEnabledVertexArray)
3017         {
3018                 _glesImpl1.glDisableClientState(GL_VERTEX_ARRAY);
3019         }
3020         if (!isEnabledTextureCoordArray)
3021         {
3022                 _glesImpl1.glDisableClientState(GL_TEXTURE_COORD_ARRAY);
3023         }
3024
3025         _glesImpl1.glBindTexture( GL_TEXTURE_2D, previousTextureId);
3026         _glesImpl1.glMatrixMode(previousMatrixMode);
3027         _glesImpl1.glBindBuffer(GL_ARRAY_BUFFER, previousArrayBuffer);
3028         _glesImpl1.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, previousElementArrayBuffer);
3029         _glesImpl1.glViewport(previousViewport[0], previousViewport[1], previousViewport[2], previousViewport[3]);
3030         _glesImpl1.glColor4f(currentColor[0], currentColor[1], currentColor[2], currentColor[3]);
3031         _glesImpl1.glNormal3f(currentNormal[0], currentNormal[1], currentNormal[2]);
3032 }
3033
3034 #endif //#if defined(FGRAPHICS_INTERNAL_USE_FBO)
3035
3036 #ifdef __cplusplus
3037 }
3038 #endif
3039
3040 #endif //#if !defined(FGRAPHICS_INTERNAL_USE_DYNAMIC_LOADING)
3041
3042 } // Opengl
3043
3044 }} // Tizen::Graphics