src/graphics/opengl/FGrpGles1.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.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://www.apache.org/licenses/LICENSE-2.0/
  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 using namespace Tizen::Base;
  43 using namespace Tizen::Ui;
  44 using namespace Tizen::Ui::Controls;
  45
  46 namespace Tizen { namespace Graphics
  47 {
  48
  49 namespace Opengl
  50 {
  51
  52 #if !defined(FGRAPHICS_INTERNAL_USE_DYNAMIC_LOADING)
  53
  54 #ifdef __cplusplus
  55 extern "C"
  56 {
  57 #endif
  58
  59 void
  60 _GlAlphaFunc_1(GLenum func, GLclampf ref)
  61 {
  62         glAlphaFunc(func, ref);
  63 }
  64
  65 void
  66 _GlClearColor_1(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
  67 {
  68         glClearColor(red, green, blue, alpha);
  69 }
  70
  71 void
  72 _GlClearDepthf_1(GLclampf depth)
  73 {
  74         glClearDepthf(depth);
  75 }
  76
  77 void
  78 _GlClipPlanef_1(GLenum plane, const GLfloat* pEquation)
  79 {
  80         glClipPlanef(plane, pEquation);
  81 }
  82
  83 void
  84 _GlColor4f_1(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
  85 {
  86         glColor4f(red, green, blue, alpha);
  87 }
  88
  89 void
  90 _GlDepthRangef_1(GLclampf zNear, GLclampf zFar)
  91 {
  92         glDepthRangef(zNear, zFar);
  93 }
  94
  95 void
  96 _GlFogf_1(GLenum pname, GLfloat param)
  97 {
  98         glFogf(pname, param);
  99 }
 100
 101 void
 102 _GlFogfv_1(GLenum pname, const GLfloat* pParams)
 103 {
 104         glFogfv(pname, pParams);
 105 }
 106
 107 void
 108 _GlFrustumf_1(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
 109 {
 110         glFrustumf(left, right, bottom, top, zNear, zFar);
 111 }
 112
 113 void
 114 _GlGetClipPlanef_1(GLenum pname, GLfloat eqn[4])
 115 {
 116         glGetClipPlanef(pname, eqn);
 117 }
 118
 119 void
 120 _GlGetFloatv_1(GLenum pname, GLfloat* pParams)
 121 {
 122         glGetFloatv(pname, pParams);
 123 }
 124
 125 void
 126 _GlGetLightfv_1(GLenum light, GLenum pname, GLfloat* pParams)
 127 {
 128         glGetLightfv(light, pname, pParams);
 129 }
 130
 131 void
 132 _GlGetMaterialfv_1(GLenum face, GLenum pname, GLfloat* pParams)
 133 {
 134         glGetMaterialfv(face, pname, pParams);
 135 }
 136
 137 void
 138 _GlGetTexEnvfv_1(GLenum env, GLenum pname, GLfloat* pParams)
 139 {
 140         glGetTexEnvfv(env, pname, pParams);
 141 }
 142
 143 void
 144 _GlGetTexParameterfv_1(GLenum target, GLenum pname, GLfloat* pParams)
 145 {
 146         glGetTexParameterfv(target, pname, pParams);
 147 }
 148
 149 void
 150 _GlLightModelf_1(GLenum pname, GLfloat param)
 151 {
 152         glLightModelf(pname, param);
 153 }
 154
 155 void
 156 _GlLightModelfv_1(GLenum pname, const GLfloat* pParams)
 157 {
 158         glLightModelfv(pname, pParams);
 159 }
 160
 161 void
 162 _GlLightf_1(GLenum light, GLenum pname, GLfloat param)
 163 {
 164         glLightf(light, pname, param);
 165 }
 166
 167 void
 168 _GlLightfv_1(GLenum light, GLenum pname, const GLfloat* pParams)
 169 {
 170         glLightfv(light, pname, pParams);
 171 }
 172
 173 void
 174 _GlLineWidth_1(GLfloat width)
 175 {
 176         glLineWidth(width);
 177 }
 178
 179 void
 180 _GlLoadMatrixf_1(const GLfloat* pM)
 181 {
 182         glLoadMatrixf(pM);
 183 }
 184
 185 void
 186 _GlMaterialf_1(GLenum face, GLenum pname, GLfloat param)
 187 {
 188         glMaterialf(face, pname, param);
 189 }
 190
 191 void
 192 _GlMaterialfv_1(GLenum face, GLenum pname, const GLfloat* pParams)
 193 {
 194         glMaterialfv(face, pname, pParams);
 195 }
 196
 197 void
 198 _GlMultMatrixf_1(const GLfloat* pM)
 199 {
 200         glMultMatrixf(pM);
 201 }
 202
 203 void
 204 _GlMultiTexCoord4f_1(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 205 {
 206         glMultiTexCoord4f(target, s, t, r, q);
 207 }
 208
 209 void
 210 _GlNormal3f_1(GLfloat nx, GLfloat ny, GLfloat nz)
 211 {
 212         glNormal3f(nx, ny, nz);
 213 }
 214
 215 void
 216 _GlOrthof_1(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
 217 {
 218         glOrthof(left, right, bottom, top, zNear, zFar);
 219 }
 220
 221 void
 222 _GlPointParameterf_1(GLenum pname, GLfloat param)
 223 {
 224         glPointParameterf(pname, param);
 225 }
 226
 227 void
 228 _GlPointParameterfv_1(GLenum pname, const GLfloat* pParams)
 229 {
 230         glPointParameterfv(pname, pParams);
 231 }
 232
 233 void
 234 _GlPointSize_1(GLfloat size)
 235 {
 236         glPointSize(size);
 237 }
 238
 239 void
 240 _GlPolygonOffset_1(GLfloat factor, GLfloat units)
 241 {
 242         glPolygonOffset(factor, units);
 243 }
 244
 245 void
 246 _GlRotatef_1(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 247 {
 248         glRotatef(angle, x, y, z);
 249 }
 250
 251 void
 252 _GlScalef_1(GLfloat x, GLfloat y, GLfloat z)
 253 {
 254         glScalef(x, y, z);
 255 }
 256
 257 void
 258 _GlTexEnvf_1(GLenum target, GLenum pname, GLfloat param)
 259 {
 260         glTexEnvf(target, pname, param);
 261 }
 262
 263 void
 264 _GlTexEnvfv_1(GLenum target, GLenum pname, const GLfloat* pParams)
 265 {
 266         glTexEnvfv(target, pname, pParams);
 267 }
 268
 269 void
 270 _GlTexParameterf_1(GLenum target, GLenum pname, GLfloat param)
 271 {
 272         glTexParameterf(target, pname, param);
 273 }
 274
 275 void
 276 _GlTexParameterfv_1(GLenum target, GLenum pname, const GLfloat* pParams)
 277 {
 278         glTexParameterfv(target, pname, pParams);
 279 }
 280
 281 void
 282 _GlTranslatef_1(GLfloat x, GLfloat y, GLfloat z)
 283 {
 284         glTranslatef(x, y, z);
 285 }
 286
 287 void
 288 _GlActiveTexture_1(GLenum texture)
 289 {
 290         glActiveTexture(texture);
 291 }
 292
 293 void
 294 _GlAlphaFuncx_1(GLenum func, GLclampx ref)
 295 {
 296         glAlphaFuncx(func, ref);
 297 }
 298
 299 void
 300 _GlBindBuffer_1(GLenum target, GLuint buffer)
 301 {
 302         glBindBuffer(target, buffer);
 303 }
 304
 305 void
 306 _GlBindTexture_1(GLenum target, GLuint texture)
 307 {
 308         glBindTexture(target, texture);
 309 }
 310
 311 void
 312 _GlBlendFunc_1(GLenum sfactor, GLenum dfactor)
 313 {
 314         glBlendFunc(sfactor, dfactor);
 315 }
 316
 317 void
 318 _GlBufferData_1(GLenum target, GLsizeiptr size, const GLvoid* pData, GLenum usage)
 319 {
 320         glBufferData(target, size, pData, usage);
 321 }
 322
 323 void
 324 _GlBufferSubData_1(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* pData)
 325 {
 326         glBufferSubData(target, offset, size, pData);
 327 }
 328
 329 void
 330 _GlClear_1(GLbitfield mask)
 331 {
 332         glClear(mask);
 333 }
 334
 335 void
 336 _GlClearColorx_1(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
 337 {
 338         glClearColorx(red, green, blue, alpha);
 339 }
 340
 341 void
 342 _GlClearDepthx_1(GLclampx depth)
 343 {
 344         glClearDepthx(depth);
 345 }
 346
 347 void
 348 _GlClearStencil_1(GLint s)
 349 {
 350         glClearStencil(s);
 351 }
 352
 353 void
 354 _GlClientActiveTexture_1(GLenum texture)
 355 {
 356         glClientActiveTexture(texture);
 357 }
 358
 359 void
 360 _GlClipPlanex_1(GLenum plane, const GLfixed* pEquation)
 361 {
 362         glClipPlanex(plane, pEquation);
 363 }
 364
 365 void
 366 _GlColor4ub_1(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 367 {
 368         glColor4ub(red, green, blue, alpha);
 369 }
 370
 371 void
 372 _GlColor4x_1(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
 373 {
 374         glColor4x(red, green, blue, alpha);
 375 }
 376
 377 void
 378 _GlColorMask_1(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 379 {
 380         glColorMask(red, green, blue, alpha);
 381 }
 382
 383 void
 384 _GlColorPointer_1(GLint size, GLenum type, GLsizei stride, const GLvoid* pPointer)
 385 {
 386         glColorPointer(size, type, stride, pPointer);
 387 }
 388
 389 void
 390 _GlCompressedTexImage2D_1(GLenum target, GLint level, GLenum internalformat,
 391                 GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* pData)
 392 {
 393         glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, pData);
 394 }
 395
 396 void
 397 _GlCompressedTexSubImage2D_1(GLenum target, GLint level, GLint xoffset, GLint yoffset,
 398                 GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* pData)
 399 {
 400         glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, pData);
 401 }
 402
 403 void
 404 _GlCopyTexImage2D_1(GLenum target, GLint level,
 405                 GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 406 {
 407         glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 408 }
 409
 410 void
 411 _GlCopyTexSubImage2D_1(GLenum target, GLint level,
 412                 GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 413 {
 414         glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 415 }
 416
 417 void
 418 _GlCullFace_1(GLenum mode)
 419 {
 420         glCullFace(mode);
 421 }
 422
 423 void
 424 _GlDeleteBuffers_1(GLsizei n, const GLuint* pBuffers)
 425 {
 426         glDeleteBuffers(n, pBuffers);
 427 }
 428
 429 void
 430 _GlDeleteTextures_1(GLsizei n, const GLuint* pTextures)
 431 {
 432         glDeleteTextures(n, pTextures);
 433 }
 434
 435 void
 436 _GlDepthFunc_1(GLenum func)
 437 {
 438         glDepthFunc(func);
 439 }
 440
 441 void
 442 _GlDepthMask_1(GLboolean flag)
 443 {
 444         glDepthMask(flag);
 445 }
 446
 447 void
 448 _GlDepthRangex_1(GLclampx zNear, GLclampx zFar)
 449 {
 450         glDepthRangex(zNear, zFar);
 451 }
 452
 453 void
 454 _GlDisable_1(GLenum cap)
 455 {
 456         glDisable(cap);
 457 }
 458
 459 void
 460 _GlDisableClientState_1(GLenum array)
 461 {
 462         glDisableClientState(array);
 463 }
 464
 465 void
 466 _GlDrawArrays_1(GLenum mode, GLint first, GLsizei count)
 467 {
 468         glDrawArrays(mode, first, count);
 469 }
 470
 471 void
 472 _GlDrawElements_1(GLenum mode, GLsizei count, GLenum type, const GLvoid* pIndices)
 473 {
 474         glDrawElements(mode, count, type, pIndices);
 475 }
 476
 477 void
 478 _GlEnable_1(GLenum cap)
 479 {
 480         glEnable(cap);
 481 }
 482
 483 void
 484 _GlEnableClientState_1(GLenum array)
 485 {
 486         glEnableClientState(array);
 487 }
 488
 489 void
 490 _GlFinish_1(void)
 491 {
 492         glFinish();
 493 }
 494
 495 void
 496 _GlFlush_1(void)
 497 {
 498         glFlush();
 499 }
 500
 501 void
 502 _GlFogx_1(GLenum pname, GLfixed param)
 503 {
 504         glFogx(pname, param);
 505 }
 506
 507 void
 508 _GlFogxv_1(GLenum pname, const GLfixed* pParams)
 509 {
 510         glFogxv(pname, pParams);
 511 }
 512
 513 void
 514 _GlFrontFace_1(GLenum mode)
 515 {
 516         glFrontFace(mode);
 517 }
 518
 519 void
 520 _GlFrustumx_1(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
 521 {
 522         glFrustumx(left, right, bottom, top, zNear, zFar);
 523 }
 524
 525 void
 526 _GlGetBooleanv_1(GLenum pname, GLboolean* pParams)
 527 {
 528         glGetBooleanv(pname, pParams);
 529 }
 530
 531 void
 532 _GlGetBufferParameteriv_1(GLenum target, GLenum pname, GLint* pParams)
 533 {
 534         glGetBufferParameteriv(target, pname, pParams);
 535 }
 536
 537 void
 538 _GlGetClipPlanex_1(GLenum pname, GLfixed eqn[4])
 539 {
 540         glGetClipPlanex(pname, eqn);
 541 }
 542
 543 void
 544 _GlGenBuffers_1(GLsizei n, GLuint* pBuffers)
 545 {
 546         glGenBuffers(n, pBuffers);
 547 }
 548
 549 void
 550 _GlGenTextures_1(GLsizei n, GLuint* pTextures)
 551 {
 552         glGenTextures(n, pTextures);
 553 }
 554
 555 GLenum
 556 _GlGetError_1(void)
 557 {
 558         return glGetError();
 559 }
 560
 561 void
 562 _GlGetFixedv_1(GLenum pname, GLfixed* pParams)
 563 {
 564         glGetFixedv(pname, pParams);
 565 }
 566
 567 void
 568 _GlGetIntegerv_1(GLenum pname, GLint* pParams)
 569 {
 570         glGetIntegerv(pname, pParams);
 571 }
 572
 573 void
 574 _GlGetLightxv_1(GLenum light, GLenum pname, GLfixed* pParams)
 575 {
 576         glGetLightxv(light, pname, pParams);
 577 }
 578
 579 void
 580 _GlGetMaterialxv_1(GLenum face, GLenum pname, GLfixed* pParams)
 581 {
 582         glGetMaterialxv(face, pname, pParams);
 583 }
 584
 585 void
 586 _GlGetPointerv_1(GLenum pname, void** ppParams)
 587 {
 588         glGetPointerv(pname, ppParams);
 589 }
 590
 591 const GLubyte*
 592 _GlGetString_1(GLenum name)
 593 {
 594         return glGetString(name);
 595 }
 596
 597 void
 598 _GlGetTexEnviv_1(GLenum env, GLenum pname, GLint* pParams)
 599 {
 600         glGetTexEnviv(env, pname, pParams);
 601 }
 602
 603 void
 604 _GlGetTexEnvxv_1(GLenum env, GLenum pname, GLfixed* pParams)
 605 {
 606         glGetTexEnvxv(env, pname, pParams);
 607 }
 608
 609 void
 610 _GlGetTexParameteriv_1(GLenum target, GLenum pname, GLint* pParams)
 611 {
 612         glGetTexParameteriv(target, pname, pParams);
 613 }
 614
 615 void
 616 _GlGetTexParameterxv_1(GLenum target, GLenum pname, GLfixed* pParams)
 617 {
 618         glGetTexParameterxv(target, pname, pParams);
 619 }
 620
 621 void
 622 _GlHint_1(GLenum target, GLenum mode)
 623 {
 624         glHint(target, mode);
 625 }
 626
 627 GLboolean
 628 _GlIsBuffer_1(GLuint buffer)
 629 {
 630         return glIsBuffer(buffer);
 631 }
 632
 633 GLboolean
 634 _GlIsEnabled_1(GLenum cap)
 635 {
 636         return glIsEnabled(cap);
 637 }
 638
 639 GLboolean
 640 _GlIsTexture_1(GLuint texture)
 641 {
 642         return glIsTexture(texture);
 643 }
 644
 645 void
 646 _GlLightModelx_1(GLenum pname, GLfixed param)
 647 {
 648         glLightModelx(pname, param);
 649 }
 650
 651 void
 652 _GlLightModelxv_1(GLenum pname, const GLfixed* pParams)
 653 {
 654         glLightModelxv(pname, pParams);
 655 }
 656
 657 void
 658 _GlLightx_1(GLenum light, GLenum pname, GLfixed param)
 659 {
 660         glLightx(light, pname, param);
 661 }
 662
 663 void
 664 _GlLightxv_1(GLenum light, GLenum pname, const GLfixed* pParams)
 665 {
 666         glLightxv(light, pname, pParams);
 667 }
 668
 669 void
 670 _GlLineWidthx_1(GLfixed width)
 671 {
 672         glLineWidthx(width);
 673 }
 674
 675 void
 676 _GlLoadIdentity_1(void)
 677 {
 678         glLoadIdentity();
 679 }
 680
 681 void
 682 _GlLoadMatrixx_1(const GLfixed* pM)
 683 {
 684         glLoadMatrixx(pM);
 685 }
 686
 687 void
 688 _GlLogicOp_1(GLenum opcode)
 689 {
 690         glLogicOp(opcode);
 691 }
 692
 693 void
 694 _GlMaterialx_1(GLenum face, GLenum pname, GLfixed param)
 695 {
 696         glMaterialx(face, pname, param);
 697 }
 698
 699 void
 700 _GlMaterialxv_1(GLenum face, GLenum pname, const GLfixed* pParams)
 701 {
 702         glMaterialxv(face, pname, pParams);
 703 }
 704
 705 void
 706 _GlMatrixMode_1(GLenum mode)
 707 {
 708         glMatrixMode(mode);
 709 }
 710
 711 void
 712 _GlMultMatrixx_1(const GLfixed* pM)
 713 {
 714         glMultMatrixx(pM);
 715 }
 716
 717 void
 718 _GlMultiTexCoord4x_1(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
 719 {
 720         glMultiTexCoord4x(target, s, t, r, q);
 721 }
 722
 723 void
 724 _GlNormal3x_1(GLfixed nx, GLfixed ny, GLfixed nz)
 725 {
 726         glNormal3x(nx, ny, nz);
 727 }
 728
 729 void
 730 _GlNormalPointer_1(GLenum type, GLsizei stride, const GLvoid* pPointer)
 731 {
 732         glNormalPointer(type, stride, pPointer);
 733 }
 734
 735 void
 736 _GlOrthox_1(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
 737 {
 738         glOrthox(left, right, bottom, top, zNear, zFar);
 739 }
 740
 741 void
 742 _GlPixelStorei_1(GLenum pname, GLint param)
 743 {
 744         glPixelStorei(pname, param);
 745 }
 746
 747 void
 748 _GlPointParameterx_1(GLenum pname, GLfixed param)
 749 {
 750         glPointParameterx(pname, param);
 751 }
 752
 753 void
 754 _GlPointParameterxv_1(GLenum pname, const GLfixed* pParams)
 755 {
 756         glPointParameterxv(pname, pParams);
 757 }
 758
 759 void
 760 _GlPointSizex_1(GLfixed size)
 761 {
 762         glPointSizex(size);
 763 }
 764
 765 void
 766 _GlPolygonOffsetx_1(GLfixed factor, GLfixed units)
 767 {
 768         glPolygonOffsetx(factor, units);
 769 }
 770
 771 void
 772 _GlPopMatrix_1(void)
 773 {
 774         glPopMatrix();
 775 }
 776
 777 void
 778 _GlPushMatrix_1(void)
 779 {
 780         glPushMatrix();
 781 }
 782
 783 void
 784 _GlReadPixels_1(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pPixels)
 785 {
 786         glReadPixels(x, y, width, height, format, type, pPixels);
 787 }
 788
 789 void
 790 _GlRotatex_1(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
 791 {
 792         glRotatex(angle, x, y, z);
 793 }
 794
 795 void
 796 _GlSampleCoverage_1(GLclampf value, GLboolean invert)
 797 {
 798         glSampleCoverage(value, invert);
 799 }
 800
 801 void
 802 _GlSampleCoveragex_1(GLclampx value, GLboolean invert)
 803 {
 804         glSampleCoveragex(value, invert);
 805 }
 806
 807 void
 808 _GlScalex_1(GLfixed x, GLfixed y, GLfixed z)
 809 {
 810         glScalex(x, y, z);
 811 }
 812
 813 void
 814 _GlScissor_1(GLint x, GLint y, GLsizei width, GLsizei height)
 815 {
 816         glScissor(x, y, width, height);
 817 }
 818
 819 void
 820 _GlShadeModel_1(GLenum mode)
 821 {
 822         glShadeModel(mode);
 823 }
 824
 825 void
 826 _GlStencilFunc_1(GLenum func, GLint ref, GLuint mask)
 827 {
 828         glStencilFunc(func, ref, mask);
 829 }
 830
 831 void
 832 _GlStencilMask_1(GLuint mask)
 833 {
 834         glStencilMask(mask);
 835 }
 836
 837 void
 838 _GlStencilOp_1(GLenum fail, GLenum zfail, GLenum zpass)
 839 {
 840         glStencilOp(fail, zfail, zpass);
 841 }
 842
 843 void
 844 _GlTexCoordPointer_1(GLint size, GLenum type, GLsizei stride, const GLvoid* pPointer)
 845 {
 846         glTexCoordPointer(size, type, stride, pPointer);
 847 }
 848
 849 void
 850 _GlTexEnvi_1(GLenum target, GLenum pname, GLint param)
 851 {
 852         glTexEnvi(target, pname, param);
 853 }
 854
 855 void
 856 _GlTexEnvx_1(GLenum target, GLenum pname, GLfixed param)
 857 {
 858         glTexEnvx(target, pname, param);
 859 }
 860
 861 void
 862 _GlTexEnviv_1(GLenum target, GLenum pname, const GLint* pParams)
 863 {
 864         glTexEnviv(target, pname, pParams);
 865 }
 866
 867 void
 868 _GlTexEnvxv_1(GLenum target, GLenum pname, const GLfixed* pParams)
 869 {
 870         glTexEnvxv(target, pname, pParams);
 871 }
 872
 873 void
 874 _GlTexImage2D_1(GLenum target, GLint level, GLint internalformat,
 875                 GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pPixels)
 876 {
 877         glTexImage2D(target, level, internalformat, width, height, border, format, type, pPixels);
 878 }
 879
 880 void
 881 _GlTexParameteri_1(GLenum target, GLenum pname, GLint param)
 882 {
 883         glTexParameteri(target, pname, param);
 884 }
 885
 886 void
 887 _GlTexParameterx_1(GLenum target, GLenum pname, GLfixed param)
 888 {
 889         glTexParameterx(target, pname, param);
 890 }
 891
 892 void
 893 _GlTexParameteriv_1(GLenum target, GLenum pname, const GLint* pParams)
 894 {
 895         glTexParameteriv(target, pname, pParams);
 896 }
 897
 898 void
 899 _GlTexParameterxv_1(GLenum target, GLenum pname, const GLfixed* pParams)
 900 {
 901         glTexParameterxv(target, pname, pParams);
 902 }
 903
 904 void
 905 _GlTexSubImage2D_1(GLenum target, GLint level, GLint xoffset, GLint yoffset,
 906                 GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pPixels)
 907 {
 908         glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pPixels);
 909 }
 910
 911 void
 912 _GlTranslatex_1(GLfixed x, GLfixed y, GLfixed z)
 913 {
 914         glTranslatex(x, y, z);
 915 }
 916
 917 void
 918 _GlVertexPointer_1(GLint size, GLenum type, GLsizei stride, const GLvoid* pPointer)
 919 {
 920         glVertexPointer(size, type, stride, pPointer);
 921 }
 922
 923 void
 924 _GlViewport_1(GLint x, GLint y, GLsizei width, GLsizei height)
 925 {
 926         glViewport(x, y, width, height);
 927 }
 928
 929 void
 930 _GlPointSizePointerOES_1(GLenum type, GLsizei stride, const GLvoid* pPointer)
 931 {
 932         glPointSizePointerOES(type, stride, pPointer);
 933 }
 934
 935 void
 936 _GlCurrentPaletteMatrixOES_1(GLuint matrixpaletteindex)
 937 {
 938         //glCurrentPaletteMatrixOES(matrixpaletteindex);
 939 }
 940 void
 941 _GlLoadPaletteFromModelViewMatrixOES_1(void)
 942 {
 943         //glLoadPaletteFromModelViewMatrixOES();
 944 }
 945 void
 946 _GlMatrixIndexPointerOES_1(GLint size, GLenum type, GLsizei stride, const GLvoid* pPointer)
 947 {
 948         //glMatrixIndexPointerOES(size, type, stride, pPointer);
 949 }
 950 void
 951 _GlWeightPointerOES_1(GLint size, GLenum type, GLsizei stride, const GLvoid* pPointer)
 952 {
 953         //glWeightPointerOES(size, type, stride, pPointer);
 954 }
 955
 956 //  FBO is extension functions in OpenGL ES 1.1
 957 //Start of FBO Functions
 958 GLboolean
 959 _GlIsRenderbufferOES_1(GLuint renderbuffer)
 960 {
 961         //return glIsRenderbufferOES(renderbuffer);
 962         return false;
 963 }
 964 void
 965 _GlBindRenderbufferOES_1(GLenum target, GLuint renderbuffer)
 966 {
 967         //glBindRenderbufferOES(target, renderbuffer);
 968 }
 969 void
 970 _GlDeleteRenderbuffersOES_1(GLsizei n, const GLuint* pRenderbuffers)
 971 {
 972         //glDeleteRenderbuffersOES(n, pRenderbuffers);
 973 }
 974 void
 975 _GlGenRenderbuffersOES_1(GLsizei n, GLuint* pRenderbuffers)
 976 {
 977         //glGenRenderbuffersOES(n, pRenderbuffers);
 978 }
 979 void
 980 _GlRenderbufferStorageOES_1(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 981 {
 982         //glRenderbufferStorageOES(target, internalformat, width, height);
 983 }
 984 void
 985 _GlGetRenderbufferParameterivOES_1(GLenum target, GLenum pname, GLint* pParams)
 986 {
 987         //glGetRenderbufferParameterivOES(target, pname, pParams);
 988 }
 989 GLboolean
 990 _GlIsFramebufferOES_1(GLuint framebuffer)
 991 {
 992         //return glIsFramebufferOES(framebuffer);
 993         return false;
 994 }
 995 void
 996 _GlBindFramebufferOES_1(GLenum target, GLuint framebuffer)
 997 {
 998         //glBindFramebufferOES(target, framebuffer);
 999 }
1000 void
1001 _GlDeleteFramebuffersOES_1(GLsizei n, const GLuint* pFramebuffers)
1002 {
1003         //glDeleteFramebuffersOES(n, pFramebuffers);
1004 }
1005 void
1006 _GlGenFramebuffersOES_1(GLsizei n, GLuint* pFramebuffers)
1007 {
1008         //glGenFramebuffersOES(n, pFramebuffers);
1009 }
1010 GLenum
1011 _GlCheckFramebufferStatusOES_1(GLenum target)
1012 {
1013         //return glCheckFramebufferStatusOES(target);;
1014         return false;
1015 }
1016 void
1017 _GlFramebufferRenderbufferOES_1(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
1018 {
1019         //glFramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer);
1020 }
1021 void
1022 _GlFramebufferTexture2DOES_1(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
1023 {
1024         //glFramebufferTexture2DOES(target, attachment, textarget, texture, level);
1025 }
1026 void
1027 _GlGetFramebufferAttachmentParameterivOES_1(GLenum target, GLenum attachment, GLenum pname, GLint* pParams)
1028 {
1029         //glGetFramebufferAttachmentParameterivOES(target, attachment, pname, pParams);
1030 }
1031 void
1032 _GlGenerateMipmapOES_1(GLenum target)
1033 {
1034         //glGenerateMipmapOES(target);
1035 }
1036 //End of FBO Functions
1037
1038 #ifdef __cplusplus
1039 }
1040 #endif
1041
1042 #else
1043
1044 #define _GLES_CHECK_INTERFACE_VOID_1 if (!_GlesInterfaceInitialize_1()) \
1045         { \
1046                 return; \
1047         }
1048 #define _GLES_CHECK_INTERFACE_GLBOOLEAN_1 if (!_GlesInterfaceInitialize_1()) \
1049         { \
1050                 return GL_FALSE; \
1051         }
1052 #define _GLES_CHECK_INTERFACE_GLENUM_1 if (!_GlesInterfaceInitialize_1()) \
1053         { \
1054                 return 0; \
1055         }
1056 #define _GLES_CHECK_INTERFACE_CONST_GLUBYTEP_1 if (!_GlesInterfaceInitialize_1()) \
1057         { \
1058                 return (const GLubyte*) 0; \
1059         }
1060
1061 #define FGRAPHICS_INTERNAL_USE_RESTORE_CONTEXT
1062 #if defined(FGRAPHICS_INTERNAL_USE_RESTORE_CONTEXT)
1063 void _RestoreContext(void);
1064 #endif
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 #if defined(_OSP_EMUL_)
1422                 _pGlesLib1 = dlopen("/usr/lib/libGLESv1_CM.so", RTLD_LAZY | RTLD_GLOBAL);
1423 #else
1424                 _pGlesLib1 = dlopen("/usr/lib/driver/libGLESv1_CM.so", RTLD_LAZY | RTLD_GLOBAL);
1425                 if (_pGlesLib1 == NULL)
1426                 {
1427                         _pGlesLib1 = dlopen("/usr/lib/libGLESv1_CM.so", RTLD_LAZY | RTLD_GLOBAL);
1428                         if (_pGlesLib1 == NULL)
1429                         {
1430                                 _pGlesLib1 = dlopen("/usr/lib/libGLES_CM.so", RTLD_LAZY | RTLD_GLOBAL);
1431                                 if (_pGlesLib1 == NULL)
1432                                 {
1433                                         _pGlesLib1 = dlopen("/usr/lib/egl/libGLES_CM.so", RTLD_LAZY | RTLD_GLOBAL);
1434                                 }
1435                         }
1436                 }
1437 #endif
1438                 if (_pGlesLib1 == NULL)
1439                 {
1440                         SysLog(NID_GRP, "gles1 dlopen failed! %s", dlerror());
1441                         return false;
1442                 }
1443
1444                 for (count = 0; count < _MAX_GLES_FUNCTION_1; count++)
1445                 {
1446                         *ppPtr = (ptrdiff_t*) (dlsym(_pGlesLib1, _glesStrings1[count]));
1447
1448                         if (*ppPtr == NULL)
1449                         {
1450                                 SysLog(NID_GRP, "dlsym failed! %s name : %s", dlerror(), _glesStrings1[count]);
1451                         }
1452                         ppPtr++;
1453                 }
1454         }
1455
1456 #if defined(FGRAPHICS_INTERNAL_USE_RESTORE_CONTEXT)
1457         _RestoreContext();
1458 #endif
1459
1460         return true;
1461 }
1462
1463 }
1464
1465 #ifdef __cplusplus
1466 extern "C"
1467 {
1468 #endif
1469
1470 _OSP_LOCAL_ void
1471 _GlesInterfaceTerminate_1(void)
1472 {
1473         if (_pGlesLib1 != NULL)
1474         {
1475                 dlclose(_pGlesLib1);
1476                 _pGlesLib1 = NULL;
1477         }
1478 }
1479
1480 void
1481 _GlAlphaFunc_1(GLenum func, GLclampf ref)
1482 {
1483         _GLES_CHECK_INTERFACE_VOID_1
1484         _glesImpl1.glAlphaFunc(func, ref);
1485 }
1486
1487 void
1488 _GlClearColor_1(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
1489 {
1490         _GLES_CHECK_INTERFACE_VOID_1
1491         _glesImpl1.glClearColor(red, green, blue, alpha);
1492 }
1493
1494 void
1495 _GlClearDepthf_1(GLclampf depth)
1496 {
1497         _GLES_CHECK_INTERFACE_VOID_1
1498         _glesImpl1.glClearDepthf(depth);
1499 }
1500
1501 void
1502 _GlClipPlanef_1(GLenum plane, const GLfloat* pEquation)
1503 {
1504         _GLES_CHECK_INTERFACE_VOID_1
1505         _glesImpl1.glClipPlanef(plane, pEquation);
1506 }
1507
1508 void
1509 _GlColor4f_1(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
1510 {
1511         _GLES_CHECK_INTERFACE_VOID_1
1512         _glesImpl1.glColor4f(red, green, blue, alpha);
1513 }
1514
1515 void
1516 _GlDepthRangef_1(GLclampf zNear, GLclampf zFar)
1517 {
1518         _GLES_CHECK_INTERFACE_VOID_1
1519         _glesImpl1.glDepthRangef(zNear, zFar);
1520 }
1521
1522 void
1523 _GlFogf_1(GLenum pname, GLfloat param)
1524 {
1525         _GLES_CHECK_INTERFACE_VOID_1
1526         _glesImpl1.glFogf(pname, param);
1527 }
1528
1529 void
1530 _GlFogfv_1(GLenum pname, const GLfloat* pParams)
1531 {
1532         _GLES_CHECK_INTERFACE_VOID_1
1533         _glesImpl1.glFogfv(pname, pParams);
1534 }
1535
1536 void
1537 _GlFrustumf_1(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
1538 {
1539         _GLES_CHECK_INTERFACE_VOID_1
1540         _glesImpl1.glFrustumf(left, right, bottom, top, zNear, zFar);
1541 }
1542
1543 void
1544 _GlGetClipPlanef_1(GLenum pname, GLfloat eqn[4])
1545 {
1546         _GLES_CHECK_INTERFACE_VOID_1
1547         _glesImpl1.glGetClipPlanef(pname, eqn);
1548 }
1549
1550 void
1551 _GlGetFloatv_1(GLenum pname, GLfloat* pParams)
1552 {
1553         _GLES_CHECK_INTERFACE_VOID_1
1554         _glesImpl1.glGetFloatv(pname, pParams);
1555 }
1556
1557 void
1558 _GlGetLightfv_1(GLenum light, GLenum pname, GLfloat* pParams)
1559 {
1560         _GLES_CHECK_INTERFACE_VOID_1
1561         _glesImpl1.glGetLightfv(light, pname, pParams);
1562 }
1563
1564 void
1565 _GlGetMaterialfv_1(GLenum face, GLenum pname, GLfloat* pParams)
1566 {
1567         _GLES_CHECK_INTERFACE_VOID_1
1568         _glesImpl1.glGetMaterialfv(face, pname, pParams);
1569 }
1570
1571 void
1572 _GlGetTexEnvfv_1(GLenum env, GLenum pname, GLfloat* pParams)
1573 {
1574         _GLES_CHECK_INTERFACE_VOID_1
1575         _glesImpl1.glGetTexEnvfv(env, pname, pParams);
1576 }
1577
1578 void
1579 _GlGetTexParameterfv_1(GLenum target, GLenum pname, GLfloat* pParams)
1580 {
1581         _GLES_CHECK_INTERFACE_VOID_1
1582         _glesImpl1.glGetTexParameterfv(target, pname, pParams);
1583 }
1584
1585 void
1586 _GlLightModelf_1(GLenum pname, GLfloat param)
1587 {
1588         _GLES_CHECK_INTERFACE_VOID_1
1589         _glesImpl1.glLightModelf(pname, param);
1590 }
1591
1592 void
1593 _GlLightModelfv_1(GLenum pname, const GLfloat* pParams)
1594 {
1595         _GLES_CHECK_INTERFACE_VOID_1
1596         _glesImpl1.glLightModelfv(pname, pParams);
1597 }
1598
1599 void
1600 _GlLightf_1(GLenum light, GLenum pname, GLfloat param)
1601 {
1602         _GLES_CHECK_INTERFACE_VOID_1
1603         _glesImpl1.glLightf(light, pname, param);
1604 }
1605
1606 void
1607 _GlLightfv_1(GLenum light, GLenum pname, const GLfloat* pParams)
1608 {
1609         _GLES_CHECK_INTERFACE_VOID_1
1610         _glesImpl1.glLightfv(light, pname, pParams);
1611 }
1612
1613 void
1614 _GlLineWidth_1(GLfloat width)
1615 {
1616         _GLES_CHECK_INTERFACE_VOID_1
1617         _glesImpl1.glLineWidth(width);
1618 }
1619
1620 void
1621 _GlLoadMatrixf_1(const GLfloat* pM)
1622 {
1623         _GLES_CHECK_INTERFACE_VOID_1
1624         _glesImpl1.glLoadMatrixf(pM);
1625 }
1626
1627 void
1628 _GlMaterialf_1(GLenum face, GLenum pname, GLfloat param)
1629 {
1630         _GLES_CHECK_INTERFACE_VOID_1
1631         _glesImpl1.glMaterialf(face, pname, param);
1632 }
1633
1634 void
1635 _GlMaterialfv_1(GLenum face, GLenum pname, const GLfloat* pParams)
1636 {
1637         _GLES_CHECK_INTERFACE_VOID_1
1638         _glesImpl1.glMaterialfv(face, pname, pParams);
1639 }
1640
1641 void
1642 _GlMultMatrixf_1(const GLfloat* pM)
1643 {
1644         _GLES_CHECK_INTERFACE_VOID_1
1645         _glesImpl1.glMultMatrixf(pM);
1646 }
1647
1648 void
1649 _GlMultiTexCoord4f_1(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
1650 {
1651         _GLES_CHECK_INTERFACE_VOID_1
1652         _glesImpl1.glMultiTexCoord4f(target, s, t, r, q);
1653 }
1654
1655 void
1656 _GlNormal3f_1(GLfloat nx, GLfloat ny, GLfloat nz)
1657 {
1658         _GLES_CHECK_INTERFACE_VOID_1
1659         _glesImpl1.glNormal3f(nx, ny, nz);
1660 }
1661
1662 void
1663 _GlOrthof_1(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
1664 {
1665         _GLES_CHECK_INTERFACE_VOID_1
1666         _glesImpl1.glOrthof(left, right, bottom, top, zNear, zFar);
1667 }
1668
1669 void
1670 _GlPointParameterf_1(GLenum pname, GLfloat param)
1671 {
1672         _GLES_CHECK_INTERFACE_VOID_1
1673         _glesImpl1.glPointParameterf(pname, param);
1674 }
1675
1676 void
1677 _GlPointParameterfv_1(GLenum pname, const GLfloat* pParams)
1678 {
1679         _GLES_CHECK_INTERFACE_VOID_1
1680         _glesImpl1.glPointParameterfv(pname, pParams);
1681 }
1682
1683 void
1684 _GlPointSize_1(GLfloat size)
1685 {
1686         _GLES_CHECK_INTERFACE_VOID_1
1687         _glesImpl1.glPointSize(size);
1688 }
1689
1690 void
1691 _GlPolygonOffset_1(GLfloat factor, GLfloat units)
1692 {
1693         _GLES_CHECK_INTERFACE_VOID_1
1694         _glesImpl1.glPolygonOffset(factor, units);
1695 }
1696
1697 void
1698 _GlRotatef_1(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
1699 {
1700         _GLES_CHECK_INTERFACE_VOID_1
1701         _glesImpl1.glRotatef(angle, x, y, z);
1702 }
1703
1704 void
1705 _GlScalef_1(GLfloat x, GLfloat y, GLfloat z)
1706 {
1707         _GLES_CHECK_INTERFACE_VOID_1
1708         _glesImpl1.glScalef(x, y, z);
1709 }
1710
1711 void
1712 _GlTexEnvf_1(GLenum target, GLenum pname, GLfloat param)
1713 {
1714         _GLES_CHECK_INTERFACE_VOID_1
1715         _glesImpl1.glTexEnvf(target, pname, param);
1716 }
1717
1718 void
1719 _GlTexEnvfv_1(GLenum target, GLenum pname, const GLfloat* pParams)
1720 {
1721         _GLES_CHECK_INTERFACE_VOID_1
1722         _glesImpl1.glTexEnvfv(target, pname, pParams);
1723 }
1724
1725 void
1726 _GlTexParameterf_1(GLenum target, GLenum pname, GLfloat param)
1727 {
1728         _GLES_CHECK_INTERFACE_VOID_1
1729         _glesImpl1.glTexParameterf(target, pname, param);
1730 }
1731
1732 void
1733 _GlTexParameterfv_1(GLenum target, GLenum pname, const GLfloat* pParams)
1734 {
1735         _GLES_CHECK_INTERFACE_VOID_1
1736         _glesImpl1.glTexParameterfv(target, pname, pParams);
1737 }
1738
1739 void
1740 _GlTranslatef_1(GLfloat x, GLfloat y, GLfloat z)
1741 {
1742         _GLES_CHECK_INTERFACE_VOID_1
1743         _glesImpl1.glTranslatef(x, y, z);
1744 }
1745
1746 void
1747 _GlActiveTexture_1(GLenum texture)
1748 {
1749         _GLES_CHECK_INTERFACE_VOID_1
1750         _glesImpl1.glActiveTexture(texture);
1751 }
1752
1753 void
1754 _GlAlphaFuncx_1(GLenum func, GLclampx ref)
1755 {
1756         _GLES_CHECK_INTERFACE_VOID_1
1757         _glesImpl1.glAlphaFuncx(func, ref);
1758 }
1759
1760 void
1761 _GlBindBuffer_1(GLenum target, GLuint buffer)
1762 {
1763         _GLES_CHECK_INTERFACE_VOID_1
1764         _glesImpl1.glBindBuffer(target, buffer);
1765 }
1766
1767 void
1768 _GlBindTexture_1(GLenum target, GLuint texture)
1769 {
1770         _GLES_CHECK_INTERFACE_VOID_1
1771         _glesImpl1.glBindTexture(target, texture);
1772 }
1773
1774 void
1775 _GlBlendFunc_1(GLenum sfactor, GLenum dfactor)
1776 {
1777         _GLES_CHECK_INTERFACE_VOID_1
1778         _glesImpl1.glBlendFunc(sfactor, dfactor);
1779 }
1780
1781 void
1782 _GlBufferData_1(GLenum target, GLsizeiptr size, const GLvoid* pData, GLenum usage)
1783 {
1784         _GLES_CHECK_INTERFACE_VOID_1
1785         _glesImpl1.glBufferData(target, size, pData, usage);
1786 }
1787
1788 void
1789 _GlBufferSubData_1(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* pData)
1790 {
1791         _GLES_CHECK_INTERFACE_VOID_1
1792         _glesImpl1.glBufferSubData(target, offset, size, pData);
1793 }
1794
1795 void
1796 _GlClear_1(GLbitfield mask)
1797 {
1798         _GLES_CHECK_INTERFACE_VOID_1
1799         _glesImpl1.glClear(mask);
1800 }
1801
1802 void
1803 _GlClearColorx_1(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
1804 {
1805         _GLES_CHECK_INTERFACE_VOID_1
1806         _glesImpl1.glClearColorx(red, green, blue, alpha);
1807 }
1808
1809 void
1810 _GlClearDepthx_1(GLclampx depth)
1811 {
1812         _GLES_CHECK_INTERFACE_VOID_1
1813         _glesImpl1.glClearDepthx(depth);
1814 }
1815
1816 void
1817 _GlClearStencil_1(GLint s)
1818 {
1819         _GLES_CHECK_INTERFACE_VOID_1
1820         _glesImpl1.glClearStencil(s);
1821 }
1822
1823 void
1824 _GlClientActiveTexture_1(GLenum texture)
1825 {
1826         _GLES_CHECK_INTERFACE_VOID_1
1827         _glesImpl1.glClientActiveTexture(texture);
1828 }
1829
1830 void
1831 _GlClipPlanex_1(GLenum plane, const GLfixed* pEquation)
1832 {
1833         _GLES_CHECK_INTERFACE_VOID_1
1834         _glesImpl1.glClipPlanex(plane, pEquation);
1835 }
1836
1837 void
1838 _GlColor4ub_1(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
1839 {
1840         _GLES_CHECK_INTERFACE_VOID_1
1841         _glesImpl1.glColor4ub(red, green, blue, alpha);
1842 }
1843
1844 void
1845 _GlColor4x_1(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
1846 {
1847         _GLES_CHECK_INTERFACE_VOID_1
1848         _glesImpl1.glColor4x(red, green, blue, alpha);
1849 }
1850
1851 void
1852 _GlColorMask_1(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
1853 {
1854         _GLES_CHECK_INTERFACE_VOID_1
1855         _glesImpl1.glColorMask(red, green, blue, alpha);
1856 }
1857
1858 void
1859 _GlColorPointer_1(GLint size, GLenum type, GLsizei stride, const GLvoid* pPointer)
1860 {
1861         _GLES_CHECK_INTERFACE_VOID_1
1862         _glesImpl1.glColorPointer(size, type, stride, pPointer);
1863 }
1864
1865 void
1866 _GlCompressedTexImage2D_1(GLenum target, GLint level, GLenum internalformat,
1867                 GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* pData)
1868 {
1869         _GLES_CHECK_INTERFACE_VOID_1
1870         _glesImpl1.glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, pData);
1871 }
1872
1873 void
1874 _GlCompressedTexSubImage2D_1(GLenum target, GLint level, GLint xoffset, GLint yoffset,
1875                 GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* pData)
1876 {
1877         _GLES_CHECK_INTERFACE_VOID_1
1878         _glesImpl1.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, pData);
1879 }
1880
1881 void
1882 _GlCopyTexImage2D_1(GLenum target, GLint level,
1883                 GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
1884 {
1885         _GLES_CHECK_INTERFACE_VOID_1
1886         _glesImpl1.glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
1887 }
1888
1889 void
1890 _GlCopyTexSubImage2D_1(GLenum target, GLint level,
1891                 GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
1892 {
1893         _GLES_CHECK_INTERFACE_VOID_1
1894         _glesImpl1.glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
1895 }
1896
1897 void
1898 _GlCullFace_1(GLenum mode)
1899 {
1900         _GLES_CHECK_INTERFACE_VOID_1
1901         _glesImpl1.glCullFace(mode);
1902 }
1903
1904 void
1905 _GlDeleteBuffers_1(GLsizei n, const GLuint* pBuffers)
1906 {
1907         _GLES_CHECK_INTERFACE_VOID_1
1908         _glesImpl1.glDeleteBuffers(n, pBuffers);
1909 }
1910
1911 void
1912 _GlDeleteTextures_1(GLsizei n, const GLuint* pTextures)
1913 {
1914         _GLES_CHECK_INTERFACE_VOID_1
1915         _glesImpl1.glDeleteTextures(n, pTextures);
1916 }
1917
1918 void
1919 _GlDepthFunc_1(GLenum func)
1920 {
1921         _GLES_CHECK_INTERFACE_VOID_1
1922         _glesImpl1.glDepthFunc(func);
1923 }
1924
1925 void
1926 _GlDepthMask_1(GLboolean flag)
1927 {
1928         _GLES_CHECK_INTERFACE_VOID_1
1929         _glesImpl1.glDepthMask(flag);
1930 }
1931
1932 void
1933 _GlDepthRangex_1(GLclampx zNear, GLclampx zFar)
1934 {
1935         _GLES_CHECK_INTERFACE_VOID_1
1936         _glesImpl1.glDepthRangex(zNear, zFar);
1937 }
1938
1939 void
1940 _GlDisable_1(GLenum cap)
1941 {
1942         _GLES_CHECK_INTERFACE_VOID_1
1943         _glesImpl1.glDisable(cap);
1944 }
1945
1946 void
1947 _GlDisableClientState_1(GLenum array)
1948 {
1949         _GLES_CHECK_INTERFACE_VOID_1
1950         _glesImpl1.glDisableClientState(array);
1951 }
1952
1953 void
1954 _GlDrawArrays_1(GLenum mode, GLint first, GLsizei count)
1955 {
1956         _GLES_CHECK_INTERFACE_VOID_1
1957         _glesImpl1.glDrawArrays(mode, first, count);
1958 }
1959
1960 void
1961 _GlDrawElements_1(GLenum mode, GLsizei count, GLenum type, const GLvoid* pIndices)
1962 {
1963         _GLES_CHECK_INTERFACE_VOID_1
1964         _glesImpl1.glDrawElements(mode, count, type, pIndices);
1965 }
1966
1967 void
1968 _GlEnable_1(GLenum cap)
1969 {
1970         _GLES_CHECK_INTERFACE_VOID_1
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         _glesImpl1.glBindFramebufferOES(target, framebuffer);
2585 }
2586
2587 void
2588 _GlDeleteFramebuffersOES_1(GLsizei n, const GLuint* pFramebuffers)
2589 {
2590         _GLES_CHECK_INTERFACE_VOID_1
2591         _glesImpl1.glDeleteFramebuffersOES(n, pFramebuffers);
2592 }
2593
2594 void
2595 _GlGenFramebuffersOES_1(GLsizei n, GLuint* pFramebuffers)
2596 {
2597         _GLES_CHECK_INTERFACE_VOID_1
2598         _glesImpl1.glGenFramebuffersOES(n, pFramebuffers);
2599 }
2600
2601 GLenum
2602 _GlCheckFramebufferStatusOES_1(GLenum target)
2603 {
2604         _GLES_CHECK_INTERFACE_GLENUM_1
2605         return _glesImpl1.glCheckFramebufferStatusOES(target);
2606 }
2607
2608 void
2609 _GlFramebufferRenderbufferOES_1(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
2610 {
2611         _GLES_CHECK_INTERFACE_VOID_1
2612         _glesImpl1.glFramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer);
2613 }
2614
2615 void
2616 _GlFramebufferTexture2DOES_1(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
2617 {
2618         _GLES_CHECK_INTERFACE_VOID_1
2619         _glesImpl1.glFramebufferTexture2DOES(target, attachment, textarget, texture, level);
2620 }
2621
2622 void
2623 _GlGetFramebufferAttachmentParameterivOES_1(GLenum target, GLenum attachment, GLenum pname, GLint* pParams)
2624 {
2625         _GLES_CHECK_INTERFACE_VOID_1
2626         _glesImpl1.glGetFramebufferAttachmentParameterivOES(target, attachment, pname, pParams);
2627 }
2628
2629 void
2630 _GlGenerateMipmapOES_1(GLenum target)
2631 {
2632         _GLES_CHECK_INTERFACE_VOID_1
2633         _glesImpl1.glGenerateMipmapOES(target);
2634 }
2635 //End of FBO Functions
2636
2637 #ifdef __cplusplus
2638 }
2639 #endif
2640
2641 #endif //#if !defined(FGRAPHICS_INTERNAL_USE_DYNAMIC_LOADING)
2642
2643 } // Opengl
2644
2645 }} // Tizen::Graphics