src/OpenGL/libGLES_CM/main.cpp

   1 // SwiftShader Software Renderer\r
   2 //\r
   3 // Copyright(c) 2005-2013 TransGaming Inc.\r
   4 //\r
   5 // All rights reserved. No part of this software may be copied, distributed, transmitted,\r
   6 // transcribed, stored in a retrieval system, translated into any human or computer\r
   7 // language by any means, or disclosed to third parties without the explicit written\r
   8 // agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express\r
   9 // or implied, including but not limited to any patent rights, are granted to you.\r
  10 //\r
  11 \r
  12 // main.cpp: DLL entry point and management of thread-local data.\r
  13 \r
  14 #include "main.h"\r
  15 \r
  16 #include "libGLES_CM.hpp"\r
  17 #include "Framebuffer.h"\r
  18 #include "libEGL/Surface.h"\r
  19 #include "Common/Thread.hpp"\r
  20 #include "Common/SharedLibrary.hpp"\r
  21 #include "common/debug.h"\r
  22 #include "Main/Register.hpp"\r
  23 \r
  24 #include <GLES/glext.h>\r
  25 \r
  26 #if !defined(_MSC_VER)\r
  27 #define CONSTRUCTOR __attribute__((constructor))\r
  28 #define DESTRUCTOR __attribute__((destructor))\r
  29 #else\r
  30 #define CONSTRUCTOR\r
  31 #define DESTRUCTOR\r
  32 #endif\r
  33 \r
  34 static void glAttachThread()\r
  35 {\r
  36     TRACE("()");\r
  37 }\r
  38 \r
  39 static void glDetachThread()\r
  40 {\r
  41     TRACE("()");\r
  42 }\r
  43 \r
  44 CONSTRUCTOR static void glAttachProcess()\r
  45 {\r
  46     TRACE("()");\r
  47 \r
  48     glAttachThread();\r
  49 }\r
  50 \r
  51 DESTRUCTOR static void glDetachProcess()\r
  52 {\r
  53     TRACE("()");\r
  54 \r
  55         glDetachThread();\r
  56 }\r
  57 \r
  58 #if defined(_WIN32)\r
  59 extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)\r
  60 {\r
  61     switch(reason)\r
  62     {\r
  63     case DLL_PROCESS_ATTACH:\r
  64         glAttachProcess();\r
  65         break;\r
  66     case DLL_THREAD_ATTACH:\r
  67         glAttachThread();\r
  68         break;\r
  69     case DLL_THREAD_DETACH:\r
  70         glDetachThread();\r
  71         break;\r
  72     case DLL_PROCESS_DETACH:\r
  73         glDetachProcess();\r
  74         break;\r
  75     default:\r
  76         break;\r
  77     }\r
  78 \r
  79     return TRUE;\r
  80 }\r
  81 #endif\r
  82 \r
  83 namespace es1\r
  84 {\r
  85 es1::Context *getContext()\r
  86 {\r
  87         egl::Context *context = libEGL->clientGetCurrentContext();\r
  88 \r
  89         if(context && context->getClientVersion() == 1)\r
  90         {\r
  91                 return static_cast<es1::Context*>(context);\r
  92         }\r
  93 \r
  94         return 0;\r
  95 }\r
  96 \r
  97 egl::Display *getDisplay()\r
  98 {\r
  99     return libEGL->clientGetCurrentDisplay();\r
 100 }\r
 101 \r
 102 Device *getDevice()\r
 103 {\r
 104     Context *context = getContext();\r
 105 \r
 106     return context ? context->getDevice() : 0;\r
 107 }\r
 108 \r
 109 // Records an error code\r
 110 void error(GLenum errorCode)\r
 111 {\r
 112     es1::Context *context = es1::getContext();\r
 113 \r
 114     if(context)\r
 115     {\r
 116         switch(errorCode)\r
 117         {\r
 118         case GL_INVALID_ENUM:\r
 119             context->recordInvalidEnum();\r
 120             TRACE("\t! Error generated: invalid enum\n");\r
 121             break;\r
 122         case GL_INVALID_VALUE:\r
 123             context->recordInvalidValue();\r
 124             TRACE("\t! Error generated: invalid value\n");\r
 125             break;\r
 126         case GL_INVALID_OPERATION:\r
 127             context->recordInvalidOperation();\r
 128             TRACE("\t! Error generated: invalid operation\n");\r
 129             break;\r
 130         case GL_OUT_OF_MEMORY:\r
 131             context->recordOutOfMemory();\r
 132             TRACE("\t! Error generated: out of memory\n");\r
 133             break;\r
 134         case GL_INVALID_FRAMEBUFFER_OPERATION_OES:\r
 135             context->recordInvalidFramebufferOperation();\r
 136             TRACE("\t! Error generated: invalid framebuffer operation\n");\r
 137             break;\r
 138                 case GL_STACK_OVERFLOW:\r
 139                         context->recordMatrixStackOverflow();\r
 140             TRACE("\t! Error generated: matrix stack overflow\n");\r
 141             break;\r
 142                 case GL_STACK_UNDERFLOW:\r
 143                         context->recordMatrixStackUnderflow();\r
 144             TRACE("\t! Error generated: matrix stack underflow\n");\r
 145             break;\r
 146         default: UNREACHABLE(errorCode);\r
 147         }\r
 148     }\r
 149 }\r
 150 }\r
 151 \r
 152 namespace es1\r
 153 {\r
 154 void ActiveTexture(GLenum texture);\r
 155 void AlphaFunc(GLenum func, GLclampf ref);\r
 156 void AlphaFuncx(GLenum func, GLclampx ref);\r
 157 void BindBuffer(GLenum target, GLuint buffer);\r
 158 void BindFramebuffer(GLenum target, GLuint framebuffer);\r
 159 void BindFramebufferOES(GLenum target, GLuint framebuffer);\r
 160 void BindRenderbufferOES(GLenum target, GLuint renderbuffer);\r
 161 void BindTexture(GLenum target, GLuint texture);\r
 162 void BlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha);\r
 163 void BlendEquationOES(GLenum mode);\r
 164 void BlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha);\r
 165 void BlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);\r
 166 void BlendFunc(GLenum sfactor, GLenum dfactor);\r
 167 void BlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);\r
 168 void BufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage);\r
 169 void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data);\r
 170 GLenum CheckFramebufferStatusOES(GLenum target);\r
 171 void Clear(GLbitfield mask);\r
 172 void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);\r
 173 void ClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha);\r
 174 void ClearDepthf(GLclampf depth);\r
 175 void ClearDepthx(GLclampx depth);\r
 176 void ClearStencil(GLint s);\r
 177 void ClientActiveTexture(GLenum texture);\r
 178 void ClipPlanef(GLenum plane, const GLfloat *equation);\r
 179 void ClipPlanex(GLenum plane, const GLfixed *equation);\r
 180 void Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);\r
 181 void Color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);\r
 182 void Color4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);\r
 183 void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);\r
 184 void ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);\r
 185 void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height,\r
 186                           GLint border, GLsizei imageSize, const GLvoid* data);\r
 187 void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,\r
 188                              GLenum format, GLsizei imageSize, const GLvoid* data);\r
 189 void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);\r
 190 void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);\r
 191 void CullFace(GLenum mode);\r
 192 void DeleteBuffers(GLsizei n, const GLuint* buffers);\r
 193 void DeleteFramebuffersOES(GLsizei n, const GLuint* framebuffers);\r
 194 void DeleteRenderbuffersOES(GLsizei n, const GLuint* renderbuffers);\r
 195 void DeleteTextures(GLsizei n, const GLuint* textures);\r
 196 void DepthFunc(GLenum func);\r
 197 void DepthMask(GLboolean flag);\r
 198 void DepthRangex(GLclampx zNear, GLclampx zFar);\r
 199 void DepthRangef(GLclampf zNear, GLclampf zFar);\r
 200 void Disable(GLenum cap);\r
 201 void DisableClientState(GLenum array);\r
 202 void DrawArrays(GLenum mode, GLint first, GLsizei count);\r
 203 void DrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices);\r
 204 void Enable(GLenum cap);\r
 205 void EnableClientState(GLenum array);\r
 206 void Finish(void);\r
 207 void Flush(void);\r
 208 void FramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);\r
 209 void FramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);\r
 210 void Fogf(GLenum pname, GLfloat param);\r
 211 void Fogfv(GLenum pname, const GLfloat *params);\r
 212 void Fogx(GLenum pname, GLfixed param);\r
 213 void Fogxv(GLenum pname, const GLfixed *params);\r
 214 void FrontFace(GLenum mode);\r
 215 void Frustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);\r
 216 void Frustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);\r
 217 void GenerateMipmapOES(GLenum target);\r
 218 void GenBuffers(GLsizei n, GLuint* buffers);\r
 219 void GenFramebuffersOES(GLsizei n, GLuint* framebuffers);\r
 220 void GenRenderbuffersOES(GLsizei n, GLuint* renderbuffers);\r
 221 void GenTextures(GLsizei n, GLuint* textures);\r
 222 void GetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint* params);\r
 223 void GetBooleanv(GLenum pname, GLboolean* params);\r
 224 void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params);\r
 225 void GetClipPlanef(GLenum pname, GLfloat eqn[4]);\r
 226 void GetClipPlanex(GLenum pname, GLfixed eqn[4]);\r
 227 GLenum GetError(void);\r
 228 void GetFixedv(GLenum pname, GLfixed *params);\r
 229 void GetFloatv(GLenum pname, GLfloat* params);\r
 230 void GetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint* params);\r
 231 void GetIntegerv(GLenum pname, GLint* params);\r
 232 void GetLightfv(GLenum light, GLenum pname, GLfloat *params);\r
 233 void GetLightxv(GLenum light, GLenum pname, GLfixed *params);\r
 234 void GetMaterialfv(GLenum face, GLenum pname, GLfloat *params);\r
 235 void GetMaterialxv(GLenum face, GLenum pname, GLfixed *params);\r
 236 void GetPointerv(GLenum pname, GLvoid **params);\r
 237 const GLubyte* GetString(GLenum name);\r
 238 void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params);\r
 239 void GetTexParameteriv(GLenum target, GLenum pname, GLint* params);\r
 240 void GetTexEnvfv(GLenum env, GLenum pname, GLfloat *params);\r
 241 void GetTexEnviv(GLenum env, GLenum pname, GLint *params);\r
 242 void GetTexEnvxv(GLenum env, GLenum pname, GLfixed *params);\r
 243 void GetTexParameterxv(GLenum target, GLenum pname, GLfixed *params);\r
 244 void Hint(GLenum target, GLenum mode);\r
 245 GLboolean IsBuffer(GLuint buffer);\r
 246 GLboolean IsEnabled(GLenum cap);\r
 247 GLboolean IsFramebufferOES(GLuint framebuffer);\r
 248 GLboolean IsTexture(GLuint texture);\r
 249 GLboolean IsRenderbufferOES(GLuint renderbuffer);\r
 250 void LightModelf(GLenum pname, GLfloat param);\r
 251 void LightModelfv(GLenum pname, const GLfloat *params);\r
 252 void LightModelx(GLenum pname, GLfixed param);\r
 253 void LightModelxv(GLenum pname, const GLfixed *params);\r
 254 void Lightf(GLenum light, GLenum pname, GLfloat param);\r
 255 void Lightfv(GLenum light, GLenum pname, const GLfloat *params);\r
 256 void Lightx(GLenum light, GLenum pname, GLfixed param);\r
 257 void Lightxv(GLenum light, GLenum pname, const GLfixed *params);\r
 258 void LineWidth(GLfloat width);\r
 259 void LineWidthx(GLfixed width);\r
 260 void LoadIdentity(void);\r
 261 void LoadMatrixf(const GLfloat *m);\r
 262 void LoadMatrixx(const GLfixed *m);\r
 263 void LogicOp(GLenum opcode);\r
 264 void Materialf(GLenum face, GLenum pname, GLfloat param);\r
 265 void Materialfv(GLenum face, GLenum pname, const GLfloat *params);\r
 266 void Materialx(GLenum face, GLenum pname, GLfixed param);\r
 267 void Materialxv(GLenum face, GLenum pname, const GLfixed *params);\r
 268 void MatrixMode(GLenum mode);\r
 269 void MultMatrixf(const GLfloat *m);\r
 270 void MultMatrixx(const GLfixed *m);\r
 271 void MultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);\r
 272 void MultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q);\r
 273 void Normal3f(GLfloat nx, GLfloat ny, GLfloat nz);\r
 274 void Normal3x(GLfixed nx, GLfixed ny, GLfixed nz);\r
 275 void NormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);\r
 276 void Orthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);\r
 277 void Orthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);\r
 278 void PixelStorei(GLenum pname, GLint param);\r
 279 void PointParameterf(GLenum pname, GLfloat param);\r
 280 void PointParameterfv(GLenum pname, const GLfloat *params);\r
 281 void PointParameterx(GLenum pname, GLfixed param);\r
 282 void PointParameterxv(GLenum pname, const GLfixed *params);\r
 283 void PointSize(GLfloat size);\r
 284 void PointSizePointerOES(GLenum type, GLsizei stride, const GLvoid *pointer);\r
 285 void PointSizex(GLfixed size);\r
 286 void PolygonOffset(GLfloat factor, GLfloat units);\r
 287 void PolygonOffsetx(GLfixed factor, GLfixed units);\r
 288 void PopMatrix(void);\r
 289 void PushMatrix(void);\r
 290 void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels);\r
 291 void RenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);\r
 292 void Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);\r
 293 void Rotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z);\r
 294 void SampleCoverage(GLclampf value, GLboolean invert);\r
 295 void SampleCoveragex(GLclampx value, GLboolean invert);\r
 296 void Scalef(GLfloat x, GLfloat y, GLfloat z);\r
 297 void Scalex(GLfixed x, GLfixed y, GLfixed z);\r
 298 void Scissor(GLint x, GLint y, GLsizei width, GLsizei height);\r
 299 void ShadeModel(GLenum mode);\r
 300 void StencilFunc(GLenum func, GLint ref, GLuint mask);\r
 301 void StencilMask(GLuint mask);\r
 302 void StencilOp(GLenum fail, GLenum zfail, GLenum zpass);\r
 303 void TexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);\r
 304 void TexEnvf(GLenum target, GLenum pname, GLfloat param);\r
 305 void TexEnvfv(GLenum target, GLenum pname, const GLfloat *params);\r
 306 void TexEnvi(GLenum target, GLenum pname, GLint param);\r
 307 void TexEnvx(GLenum target, GLenum pname, GLfixed param);\r
 308 void TexEnviv(GLenum target, GLenum pname, const GLint *params);\r
 309 void TexEnvxv(GLenum target, GLenum pname, const GLfixed *params);\r
 310 void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,\r
 311                 GLint border, GLenum format, GLenum type, const GLvoid* pixels);\r
 312 void TexParameterf(GLenum target, GLenum pname, GLfloat param);\r
 313 void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params);\r
 314 void TexParameteri(GLenum target, GLenum pname, GLint param);\r
 315 void TexParameteriv(GLenum target, GLenum pname, const GLint* params);\r
 316 void TexParameterx(GLenum target, GLenum pname, GLfixed param);\r
 317 void TexParameterxv(GLenum target, GLenum pname, const GLfixed *params);\r
 318 void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,\r
 319                    GLenum format, GLenum type, const GLvoid* pixels);\r
 320 void Translatef(GLfloat x, GLfloat y, GLfloat z);\r
 321 void Translatex(GLfixed x, GLfixed y, GLfixed z);\r
 322 void VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);\r
 323 void Viewport(GLint x, GLint y, GLsizei width, GLsizei height);\r
 324 void EGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image);\r
 325 void EGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image);\r
 326 void DrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height);\r
 327 void DrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height);\r
 328 void DrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height);\r
 329 void DrawTexsvOES(const GLshort *coords);\r
 330 void DrawTexivOES(const GLint *coords);\r
 331 void DrawTexxvOES(const GLfixed *coords);\r
 332 void DrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height);\r
 333 void DrawTexfvOES(const GLfloat *coords);\r
 334 }\r
 335 \r
 336 egl::Context *es1CreateContext(const egl::Config *config, const egl::Context *shareContext);\r
 337 extern "C" __eglMustCastToProperFunctionPointerType es1GetProcAddress(const char *procname);\r
 338 egl::Image *createBackBuffer(int width, int height, const egl::Config *config);\r
 339 egl::Image *createDepthStencil(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard);\r
 340 sw::FrameBuffer *createFrameBuffer(EGLNativeDisplayType display, EGLNativeWindowType window, int width, int height);\r
 341 \r
 342 extern "C"\r
 343 {\r
 344 EGLAPI EGLint EGLAPIENTRY eglGetError(void)\r
 345 {\r
 346         return libEGL->eglGetError();\r
 347 }\r
 348 \r
 349 EGLAPI EGLDisplay EGLAPIENTRY eglGetDisplay(EGLNativeDisplayType display_id)\r
 350 {\r
 351         return libEGL->eglGetDisplay(display_id);\r
 352 }\r
 353 \r
 354 EGLAPI EGLBoolean EGLAPIENTRY eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)\r
 355 {\r
 356         return libEGL->eglInitialize(dpy, major, minor);\r
 357 }\r
 358 \r
 359 EGLAPI EGLBoolean EGLAPIENTRY eglTerminate(EGLDisplay dpy)\r
 360 {\r
 361         return libEGL->eglTerminate(dpy);\r
 362 }\r
 363 \r
 364 EGLAPI const char *EGLAPIENTRY eglQueryString(EGLDisplay dpy, EGLint name)\r
 365 {\r
 366         return libEGL->eglQueryString(dpy, name);\r
 367 }\r
 368 \r
 369 EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)\r
 370 {\r
 371         return libEGL->eglGetConfigs(dpy, configs, config_size, num_config);\r
 372 }\r
 373 \r
 374 EGLAPI EGLBoolean EGLAPIENTRY eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config)\r
 375 {\r
 376         return libEGL->eglChooseConfig(dpy, attrib_list, configs, config_size, num_config);\r
 377 }\r
 378 \r
 379 EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)\r
 380 {\r
 381         return libEGL->eglGetConfigAttrib(dpy, config, attribute, value);\r
 382 }\r
 383 \r
 384 EGLAPI EGLSurface EGLAPIENTRY eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType window, const EGLint *attrib_list)\r
 385 {\r
 386         return libEGL->eglCreateWindowSurface(dpy, config, window, attrib_list);\r
 387 }\r
 388 \r
 389 EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)\r
 390 {\r
 391         return libEGL->eglCreatePbufferSurface(dpy, config, attrib_list);\r
 392 }\r
 393 \r
 394 EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list)\r
 395 {\r
 396         return libEGL->eglCreatePixmapSurface(dpy, config, pixmap, attrib_list);\r
 397 }\r
 398 \r
 399 EGLAPI EGLBoolean EGLAPIENTRY eglDestroySurface(EGLDisplay dpy, EGLSurface surface)\r
 400 {\r
 401         return libEGL->eglDestroySurface(dpy, surface);\r
 402 }\r
 403 \r
 404 EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)\r
 405 {\r
 406         return libEGL->eglQuerySurface(dpy, surface, attribute, value);\r
 407 }\r
 408 \r
 409 EGLAPI EGLBoolean EGLAPIENTRY eglBindAPI(EGLenum api)\r
 410 {\r
 411         return libEGL->eglBindAPI(api);\r
 412 }\r
 413 \r
 414 EGLAPI EGLenum EGLAPIENTRY eglQueryAPI(void)\r
 415 {\r
 416         return libEGL->eglQueryAPI();\r
 417 }\r
 418 \r
 419 EGLAPI EGLBoolean EGLAPIENTRY eglWaitClient(void)\r
 420 {\r
 421         return libEGL->eglWaitClient();\r
 422 }\r
 423 \r
 424 EGLAPI EGLBoolean EGLAPIENTRY eglReleaseThread(void)\r
 425 {\r
 426         return libEGL->eglReleaseThread();\r
 427 }\r
 428 \r
 429 EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)\r
 430 {\r
 431         return libEGL->eglCreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);\r
 432 }\r
 433 \r
 434 EGLAPI EGLBoolean EGLAPIENTRY eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)\r
 435 {\r
 436         return libEGL->eglSurfaceAttrib(dpy, surface, attribute, value);\r
 437 }\r
 438 \r
 439 EGLAPI EGLBoolean EGLAPIENTRY eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)\r
 440 {\r
 441         return libEGL->eglBindTexImage(dpy, surface, buffer);\r
 442 }\r
 443 \r
 444 EGLAPI EGLBoolean EGLAPIENTRY eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)\r
 445 {\r
 446         return libEGL->eglReleaseTexImage(dpy, surface, buffer);\r
 447 }\r
 448 \r
 449 EGLAPI EGLBoolean EGLAPIENTRY eglSwapInterval(EGLDisplay dpy, EGLint interval)\r
 450 {\r
 451         return libEGL->eglSwapInterval(dpy, interval);\r
 452 }\r
 453 \r
 454 EGLAPI EGLContext EGLAPIENTRY eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list)\r
 455 {\r
 456         return libEGL->eglCreateContext(dpy, config, share_context, attrib_list);\r
 457 }\r
 458 \r
 459 EGLAPI EGLBoolean EGLAPIENTRY eglDestroyContext(EGLDisplay dpy, EGLContext ctx)\r
 460 {\r
 461         return libEGL->eglDestroyContext(dpy, ctx);\r
 462 }\r
 463 \r
 464 EGLAPI EGLBoolean EGLAPIENTRY eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)\r
 465 {\r
 466         return libEGL->eglMakeCurrent(dpy, draw, read, ctx);\r
 467 }\r
 468 \r
 469 EGLAPI EGLContext EGLAPIENTRY eglGetCurrentContext(void)\r
 470 {\r
 471         return libEGL->eglGetCurrentContext();\r
 472 }\r
 473 \r
 474 EGLAPI EGLSurface EGLAPIENTRY eglGetCurrentSurface(EGLint readdraw)\r
 475 {\r
 476         return libEGL->eglGetCurrentSurface(readdraw);\r
 477 }\r
 478 \r
 479 EGLAPI EGLDisplay EGLAPIENTRY eglGetCurrentDisplay(void)\r
 480 {\r
 481         return libEGL->eglGetCurrentDisplay();\r
 482 }\r
 483 \r
 484 EGLAPI EGLBoolean EGLAPIENTRY eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value)\r
 485 {\r
 486         return libEGL->eglQueryContext(dpy, ctx, attribute, value);\r
 487 }\r
 488 \r
 489 EGLAPI EGLBoolean EGLAPIENTRY eglWaitGL(void)\r
 490 {\r
 491         return libEGL->eglWaitGL();\r
 492 }\r
 493 \r
 494 EGLAPI EGLBoolean EGLAPIENTRY eglWaitNative(EGLint engine)\r
 495 {\r
 496         return libEGL->eglWaitNative(engine);\r
 497 }\r
 498 \r
 499 EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)\r
 500 {\r
 501         return libEGL->eglSwapBuffers(dpy, surface);\r
 502 }\r
 503 \r
 504 EGLAPI EGLBoolean EGLAPIENTRY eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)\r
 505 {\r
 506         return libEGL->eglCopyBuffers(dpy, surface, target);\r
 507 }\r
 508 \r
 509 EGLAPI EGLImageKHR EGLAPIENTRY eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list)\r
 510 {\r
 511         return libEGL->eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list);\r
 512 }\r
 513 \r
 514 EGLAPI EGLBoolean EGLAPIENTRY eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)\r
 515 {\r
 516         return libEGL->eglDestroyImageKHR(dpy, image);\r
 517 }\r
 518 \r
 519 EGLAPI __eglMustCastToProperFunctionPointerType EGLAPIENTRY eglGetProcAddress(const char *procname)\r
 520 {\r
 521         return libEGL->eglGetProcAddress(procname);\r
 522 }\r
 523 \r
 524 GL_API void GL_APIENTRY glActiveTexture(GLenum texture)\r
 525 {\r
 526         return es1::ActiveTexture(texture);\r
 527 }\r
 528 \r
 529 GL_API void GL_APIENTRY glAlphaFunc(GLenum func, GLclampf ref)\r
 530 {\r
 531         return es1::AlphaFunc(func, ref);\r
 532 }\r
 533 \r
 534 GL_API void GL_APIENTRY glAlphaFuncx(GLenum func, GLclampx ref)\r
 535 {\r
 536         return es1::AlphaFuncx(func, ref);\r
 537 }\r
 538 \r
 539 GL_API void GL_APIENTRY glBindBuffer(GLenum target, GLuint buffer)\r
 540 {\r
 541         return es1::BindBuffer(target, buffer);\r
 542 }\r
 543 \r
 544 GL_API void GL_APIENTRY glBindFramebuffer(GLenum target, GLuint framebuffer)\r
 545 {\r
 546         return es1::BindFramebuffer(target, framebuffer);\r
 547 }\r
 548 \r
 549 GL_API void GL_APIENTRY glBindFramebufferOES(GLenum target, GLuint framebuffer)\r
 550 {\r
 551         return es1::BindFramebufferOES(target, framebuffer);\r
 552 }\r
 553 \r
 554 GL_API void GL_APIENTRY glBindRenderbufferOES(GLenum target, GLuint renderbuffer)\r
 555 {\r
 556         return es1::BindRenderbufferOES(target, renderbuffer);\r
 557 }\r
 558 \r
 559 GL_API void GL_APIENTRY glBindTexture(GLenum target, GLuint texture)\r
 560 {\r
 561         return es1::BindTexture(target, texture);\r
 562 }\r
 563 \r
 564 GL_API void GL_APIENTRY glBlendEquationOES(GLenum mode)\r
 565 {\r
 566         return es1::BlendEquationSeparateOES(mode, mode);\r
 567 }\r
 568 \r
 569 GL_API void GL_APIENTRY glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha)\r
 570 {\r
 571         return es1::BlendEquationSeparateOES(modeRGB, modeAlpha);\r
 572 }\r
 573 \r
 574 GL_API void GL_APIENTRY glBlendFunc(GLenum sfactor, GLenum dfactor)\r
 575 {\r
 576         return es1::BlendFuncSeparateOES(sfactor, dfactor, sfactor, dfactor);\r
 577 }\r
 578 \r
 579 GL_API void GL_APIENTRY glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)\r
 580 {\r
 581         return es1::BlendFuncSeparateOES(srcRGB, dstRGB, srcAlpha, dstAlpha);\r
 582 }\r
 583 \r
 584 GL_API void GL_APIENTRY glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)\r
 585 {\r
 586         return es1::BufferData(target, size, data, usage);\r
 587 }\r
 588 \r
 589 GL_API void GL_APIENTRY glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)\r
 590 {\r
 591         return es1::BufferSubData(target, offset, size, data);\r
 592 }\r
 593 \r
 594 GL_API GLenum GL_APIENTRY glCheckFramebufferStatusOES(GLenum target)\r
 595 {\r
 596         return es1::CheckFramebufferStatusOES(target);\r
 597 }\r
 598 \r
 599 GL_API void GL_APIENTRY glClear(GLbitfield mask)\r
 600 {\r
 601         return es1::Clear(mask);\r
 602 }\r
 603 \r
 604 GL_API void GL_APIENTRY glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)\r
 605 {\r
 606         return es1::ClearColor(red, green, blue, alpha);\r
 607 }\r
 608 \r
 609 GL_API void GL_APIENTRY glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)\r
 610 {\r
 611         return es1::ClearColorx(red, green, blue, alpha);\r
 612 }\r
 613 \r
 614 GL_API void GL_APIENTRY glClearDepthf(GLclampf depth)\r
 615 {\r
 616         return es1::ClearDepthf(depth);\r
 617 }\r
 618 \r
 619 GL_API void GL_APIENTRY glClearDepthx(GLclampx depth)\r
 620 {\r
 621         return es1::ClearDepthx(depth);\r
 622 }\r
 623 \r
 624 GL_API void GL_APIENTRY glClearStencil(GLint s)\r
 625 {\r
 626         return es1::ClearStencil(s);\r
 627 }\r
 628 \r
 629 GL_API void GL_APIENTRY glClientActiveTexture(GLenum texture)\r
 630 {\r
 631         return es1::ClientActiveTexture(texture);\r
 632 }\r
 633 \r
 634 GL_API void GL_APIENTRY glClipPlanef(GLenum plane, const GLfloat *equation)\r
 635 {\r
 636         return es1::ClipPlanef(plane, equation);\r
 637 }\r
 638 \r
 639 GL_API void GL_APIENTRY glClipPlanex(GLenum plane, const GLfixed *equation)\r
 640 {\r
 641         return es1::ClipPlanex(plane, equation);\r
 642 }\r
 643 \r
 644 GL_API void GL_APIENTRY glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)\r
 645 {\r
 646         return es1::Color4f(red, green, blue, alpha);\r
 647 }\r
 648 \r
 649 GL_API void GL_APIENTRY glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)\r
 650 {\r
 651         return es1::Color4ub(red, green, blue, alpha);\r
 652 }\r
 653 \r
 654 GL_API void GL_APIENTRY glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)\r
 655 {\r
 656         return es1::Color4x(red, green, blue, alpha);\r
 657 }\r
 658 \r
 659 GL_API void GL_APIENTRY glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)\r
 660 {\r
 661         return es1::ColorMask(red, green, blue, alpha);\r
 662 }\r
 663 \r
 664 GL_API void GL_APIENTRY glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)\r
 665 {\r
 666         return es1::ColorPointer(size, type, stride, pointer);\r
 667 }\r
 668 \r
 669 GL_API void GL_APIENTRY glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height,\r
 670                                                GLint border, GLsizei imageSize, const GLvoid* data)\r
 671 {\r
 672         return es1::CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);\r
 673 }\r
 674 \r
 675 GL_API void GL_APIENTRY glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,\r
 676                                                   GLenum format, GLsizei imageSize, const GLvoid* data)\r
 677 {\r
 678         return es1::CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);\r
 679 }\r
 680 \r
 681 GL_API void GL_APIENTRY glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)\r
 682 {\r
 683         return es1::CopyTexImage2D(target, level, internalformat, x, y, width, height, border);\r
 684 }\r
 685 \r
 686 GL_API void GL_APIENTRY glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)\r
 687 {\r
 688         return es1::CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);\r
 689 }\r
 690 \r
 691 GL_API void GL_APIENTRY glCullFace(GLenum mode)\r
 692 {\r
 693         return es1::CullFace(mode);\r
 694 }\r
 695 \r
 696 GL_API void GL_APIENTRY glDeleteBuffers(GLsizei n, const GLuint* buffers)\r
 697 {\r
 698         return es1::DeleteBuffers(n, buffers);\r
 699 }\r
 700 \r
 701 GL_API void GL_APIENTRY glDeleteFramebuffersOES(GLsizei n, const GLuint* framebuffers)\r
 702 {\r
 703         return es1::DeleteFramebuffersOES(n, framebuffers);\r
 704 }\r
 705 \r
 706 GL_API void GL_APIENTRY glDeleteRenderbuffersOES(GLsizei n, const GLuint* renderbuffers)\r
 707 {\r
 708         return es1::DeleteRenderbuffersOES(n, renderbuffers);\r
 709 }\r
 710 \r
 711 GL_API void GL_APIENTRY glDeleteTextures(GLsizei n, const GLuint* textures)\r
 712 {\r
 713         return es1::DeleteTextures(n, textures);\r
 714 }\r
 715 \r
 716 GL_API void GL_APIENTRY glDepthFunc(GLenum func)\r
 717 {\r
 718         return es1::DepthFunc(func);\r
 719 }\r
 720 \r
 721 GL_API void GL_APIENTRY glDepthMask(GLboolean flag)\r
 722 {\r
 723         return es1::DepthMask(flag);\r
 724 }\r
 725 \r
 726 GL_API void GL_APIENTRY glDepthRangex(GLclampx zNear, GLclampx zFar)\r
 727 {\r
 728         return es1::DepthRangex(zNear, zFar);\r
 729 }\r
 730 \r
 731 GL_API void GL_APIENTRY glDepthRangef(GLclampf zNear, GLclampf zFar)\r
 732 {\r
 733         return es1::DepthRangef(zNear, zFar);\r
 734 }\r
 735 \r
 736 GL_API void GL_APIENTRY glDisable(GLenum cap)\r
 737 {\r
 738         return es1::Disable(cap);\r
 739 }\r
 740 \r
 741 GL_API void GL_APIENTRY glDisableClientState(GLenum array)\r
 742 {\r
 743         return es1::DisableClientState(array);\r
 744 }\r
 745 \r
 746 GL_API void GL_APIENTRY glDrawArrays(GLenum mode, GLint first, GLsizei count)\r
 747 {\r
 748         return es1::DrawArrays(mode, first, count);\r
 749 }\r
 750 \r
 751 GL_API void GL_APIENTRY glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)\r
 752 {\r
 753         return es1::DrawElements(mode, count, type, indices);\r
 754 }\r
 755 \r
 756 GL_API void GL_APIENTRY glEnable(GLenum cap)\r
 757 {\r
 758         return es1::Enable(cap);\r
 759 }\r
 760 \r
 761 GL_API void GL_APIENTRY glEnableClientState(GLenum array)\r
 762 {\r
 763         return es1::EnableClientState(array);\r
 764 }\r
 765 \r
 766 GL_API void GL_APIENTRY glFinish(void)\r
 767 {\r
 768         return es1::Finish();\r
 769 }\r
 770 \r
 771 GL_API void GL_APIENTRY glFlush(void)\r
 772 {\r
 773         return es1::Flush();\r
 774 }\r
 775 \r
 776 GL_API void GL_APIENTRY glFramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)\r
 777 {\r
 778         return es1::FramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer);\r
 779 }\r
 780 \r
 781 GL_API void GL_APIENTRY glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)\r
 782 {\r
 783         return es1::FramebufferTexture2DOES(target, attachment, textarget, texture, level);\r
 784 }\r
 785 \r
 786 GL_API void GL_APIENTRY glFogf(GLenum pname, GLfloat param)\r
 787 {\r
 788         return es1::Fogf(pname, param);\r
 789 }\r
 790 \r
 791 GL_API void GL_APIENTRY glFogfv(GLenum pname, const GLfloat *params)\r
 792 {\r
 793         return es1::Fogfv(pname, params);\r
 794 }\r
 795 \r
 796 GL_API void GL_APIENTRY glFogx(GLenum pname, GLfixed param)\r
 797 {\r
 798         return es1::Fogx(pname, param);\r
 799 }\r
 800 \r
 801 GL_API void GL_APIENTRY glFogxv(GLenum pname, const GLfixed *params)\r
 802 {\r
 803         return es1::Fogxv(pname, params);\r
 804 }\r
 805 \r
 806 GL_API void GL_APIENTRY glFrontFace(GLenum mode)\r
 807 {\r
 808         return es1::FrontFace(mode);\r
 809 }\r
 810 \r
 811 GL_API void GL_APIENTRY glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)\r
 812 {\r
 813         return es1::Frustumf(left, right, bottom, top, zNear, zFar);\r
 814 }\r
 815 \r
 816 GL_API void GL_APIENTRY glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)\r
 817 {\r
 818         return es1::Frustumx(left, right, bottom, top, zNear, zFar);\r
 819 }\r
 820 \r
 821 GL_API void GL_APIENTRY glGenerateMipmapOES(GLenum target)\r
 822 {\r
 823         return es1::GenerateMipmapOES(target);\r
 824 }\r
 825 \r
 826 GL_API void GL_APIENTRY glGenBuffers(GLsizei n, GLuint* buffers)\r
 827 {\r
 828         return es1::GenBuffers(n, buffers);\r
 829 }\r
 830 \r
 831 GL_API void GL_APIENTRY glGenFramebuffersOES(GLsizei n, GLuint* framebuffers)\r
 832 {\r
 833         return es1::GenFramebuffersOES(n, framebuffers);\r
 834 }\r
 835 \r
 836 GL_API void GL_APIENTRY glGenRenderbuffersOES(GLsizei n, GLuint* renderbuffers)\r
 837 {\r
 838         return es1::GenRenderbuffersOES(n, renderbuffers);\r
 839 }\r
 840 \r
 841 GL_API void GL_APIENTRY glGenTextures(GLsizei n, GLuint* textures)\r
 842 {\r
 843         return es1::GenTextures(n, textures);\r
 844 }\r
 845 \r
 846 GL_API void GL_APIENTRY glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint* params)\r
 847 {\r
 848         return es1::GetRenderbufferParameterivOES(target, pname, params);\r
 849 }\r
 850 \r
 851 GL_API void GL_APIENTRY glGetBooleanv(GLenum pname, GLboolean* params)\r
 852 {\r
 853         return es1::GetBooleanv(pname, params);\r
 854 }\r
 855 \r
 856 GL_API void GL_APIENTRY glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)\r
 857 {\r
 858         return es1::GetBufferParameteriv(target, pname, params);\r
 859 }\r
 860 \r
 861 GL_API void GL_APIENTRY glGetClipPlanef(GLenum pname, GLfloat eqn[4])\r
 862 {\r
 863         return es1::GetClipPlanef(pname, eqn);\r
 864 }\r
 865 \r
 866 GL_API void GL_APIENTRY glGetClipPlanex(GLenum pname, GLfixed eqn[4])\r
 867 {\r
 868         return es1::GetClipPlanex(pname, eqn);\r
 869 }\r
 870 \r
 871 GL_API GLenum GL_APIENTRY glGetError(void)\r
 872 {\r
 873         return es1::GetError();\r
 874 }\r
 875 \r
 876 GL_API void GL_APIENTRY glGetFixedv(GLenum pname, GLfixed *params)\r
 877 {\r
 878         return es1::GetFixedv(pname, params);\r
 879 }\r
 880 \r
 881 GL_API void GL_APIENTRY glGetFloatv(GLenum pname, GLfloat* params)\r
 882 {\r
 883         return es1::GetFloatv(pname, params);\r
 884 }\r
 885 \r
 886 GL_API void GL_APIENTRY glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint* params)\r
 887 {\r
 888         return es1::GetFramebufferAttachmentParameterivOES(target, attachment, pname, params);\r
 889 }\r
 890 \r
 891 GL_API void GL_APIENTRY glGetIntegerv(GLenum pname, GLint* params)\r
 892 {\r
 893         return es1::GetIntegerv(pname, params);\r
 894 }\r
 895 \r
 896 GL_API void GL_APIENTRY glGetLightfv(GLenum light, GLenum pname, GLfloat *params)\r
 897 {\r
 898         return es1::GetLightfv(light, pname, params);\r
 899 }\r
 900 \r
 901 GL_API void GL_APIENTRY glGetLightxv(GLenum light, GLenum pname, GLfixed *params)\r
 902 {\r
 903         return es1::GetLightxv(light, pname, params);\r
 904 }\r
 905 \r
 906 GL_API void GL_APIENTRY glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)\r
 907 {\r
 908         return es1::GetMaterialfv(face, pname, params);\r
 909 }\r
 910 \r
 911 GL_API void GL_APIENTRY glGetMaterialxv(GLenum face, GLenum pname, GLfixed *params)\r
 912 {\r
 913         return es1::GetMaterialxv(face, pname, params);\r
 914 }\r
 915 \r
 916 GL_API void GL_APIENTRY glGetPointerv(GLenum pname, GLvoid **params)\r
 917 {\r
 918         return es1::GetPointerv(pname, params);\r
 919 }\r
 920 \r
 921 GL_API const GLubyte* GL_APIENTRY glGetString(GLenum name)\r
 922 {\r
 923         return es1::GetString(name);\r
 924 }\r
 925 \r
 926 GL_API void GL_APIENTRY glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)\r
 927 {\r
 928         return es1::GetTexParameterfv(target, pname, params);\r
 929 }\r
 930 \r
 931 GL_API void GL_APIENTRY glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)\r
 932 {\r
 933         return es1::GetTexParameteriv(target, pname, params);\r
 934 }\r
 935 \r
 936 GL_API void GL_APIENTRY glGetTexEnvfv(GLenum env, GLenum pname, GLfloat *params)\r
 937 {\r
 938         return es1::GetTexEnvfv(env, pname, params);\r
 939 }\r
 940 \r
 941 GL_API void GL_APIENTRY glGetTexEnviv(GLenum env, GLenum pname, GLint *params)\r
 942 {\r
 943         return es1::GetTexEnviv(env, pname, params);\r
 944 }\r
 945 \r
 946 GL_API void GL_APIENTRY glGetTexEnvxv(GLenum env, GLenum pname, GLfixed *params)\r
 947 {\r
 948         return es1::GetTexEnvxv(env, pname, params);\r
 949 }\r
 950 \r
 951 GL_API void GL_APIENTRY glGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params)\r
 952 {\r
 953         return es1::GetTexParameterxv(target, pname, params);\r
 954 }\r
 955 \r
 956 GL_API void GL_APIENTRY glHint(GLenum target, GLenum mode)\r
 957 {\r
 958         return es1::Hint(target, mode);\r
 959 }\r
 960 \r
 961 GL_API GLboolean GL_APIENTRY glIsBuffer(GLuint buffer)\r
 962 {\r
 963         return es1::IsBuffer(buffer);\r
 964 }\r
 965 \r
 966 GL_API GLboolean GL_APIENTRY glIsEnabled(GLenum cap)\r
 967 {\r
 968         return es1::IsEnabled(cap);\r
 969 }\r
 970 \r
 971 GL_API GLboolean GL_APIENTRY glIsFramebufferOES(GLuint framebuffer)\r
 972 {\r
 973         return es1::IsFramebufferOES(framebuffer);\r
 974 }\r
 975 \r
 976 GL_API GLboolean GL_APIENTRY glIsTexture(GLuint texture)\r
 977 {\r
 978         return es1::IsTexture(texture);\r
 979 }\r
 980 \r
 981 GL_API GLboolean GL_APIENTRY glIsRenderbufferOES(GLuint renderbuffer)\r
 982 {\r
 983         return es1::IsRenderbufferOES(renderbuffer);\r
 984 }\r
 985 \r
 986 GL_API void GL_APIENTRY glLightModelf(GLenum pname, GLfloat param)\r
 987 {\r
 988         return es1::LightModelf(pname, param);\r
 989 }\r
 990 \r
 991 GL_API void GL_APIENTRY glLightModelfv(GLenum pname, const GLfloat *params)\r
 992 {\r
 993         return es1::LightModelfv(pname, params);\r
 994 }\r
 995 \r
 996 GL_API void GL_APIENTRY glLightModelx(GLenum pname, GLfixed param)\r
 997 {\r
 998         return es1::LightModelx(pname, param);\r
 999 }\r
1000 \r
1001 GL_API void GL_APIENTRY glLightModelxv(GLenum pname, const GLfixed *params)\r
1002 {\r
1003         return es1::LightModelxv(pname, params);\r
1004 }\r
1005 \r
1006 GL_API void GL_APIENTRY glLightf(GLenum light, GLenum pname, GLfloat param)\r
1007 {\r
1008         return es1::Lightf(light, pname, param);\r
1009 }\r
1010 \r
1011 GL_API void GL_APIENTRY glLightfv(GLenum light, GLenum pname, const GLfloat *params)\r
1012 {\r
1013         return es1::Lightfv(light, pname, params);\r
1014 }\r
1015 \r
1016 GL_API void GL_APIENTRY glLightx(GLenum light, GLenum pname, GLfixed param)\r
1017 {\r
1018         return es1::Lightx(light, pname, param);\r
1019 }\r
1020 \r
1021 GL_API void GL_APIENTRY glLightxv(GLenum light, GLenum pname, const GLfixed *params)\r
1022 {\r
1023         return es1::Lightxv(light, pname, params);\r
1024 }\r
1025 \r
1026 GL_API void GL_APIENTRY glLineWidth(GLfloat width)\r
1027 {\r
1028         return es1::LineWidth(width);\r
1029 }\r
1030 \r
1031 GL_API void GL_APIENTRY glLineWidthx(GLfixed width)\r
1032 {\r
1033         return es1::LineWidthx(width);\r
1034 }\r
1035 \r
1036 GL_API void GL_APIENTRY glLoadIdentity(void)\r
1037 {\r
1038         return es1::LoadIdentity();\r
1039 }\r
1040 \r
1041 GL_API void GL_APIENTRY glLoadMatrixf(const GLfloat *m)\r
1042 {\r
1043         return es1::LoadMatrixf(m);\r
1044 }\r
1045 \r
1046 GL_API void GL_APIENTRY glLoadMatrixx(const GLfixed *m)\r
1047 {\r
1048         return es1::LoadMatrixx(m);\r
1049 }\r
1050 \r
1051 GL_API void GL_APIENTRY glLogicOp(GLenum opcode)\r
1052 {\r
1053         return es1::LogicOp(opcode);\r
1054 }\r
1055 \r
1056 GL_API void GL_APIENTRY glMaterialf(GLenum face, GLenum pname, GLfloat param)\r
1057 {\r
1058         return es1::Materialf(face, pname, param);\r
1059 }\r
1060 \r
1061 GL_API void GL_APIENTRY glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)\r
1062 {\r
1063         return es1::Materialfv(face, pname, params);\r
1064 }\r
1065 \r
1066 GL_API void GL_APIENTRY glMaterialx(GLenum face, GLenum pname, GLfixed param)\r
1067 {\r
1068         return es1::Materialx(face, pname, param);\r
1069 }\r
1070 \r
1071 GL_API void GL_APIENTRY glMaterialxv(GLenum face, GLenum pname, const GLfixed *params)\r
1072 {\r
1073         return es1::Materialxv(face, pname, params);\r
1074 }\r
1075 \r
1076 GL_API void GL_APIENTRY glMatrixMode(GLenum mode)\r
1077 {\r
1078         return es1::MatrixMode(mode);\r
1079 }\r
1080 \r
1081 GL_API void GL_APIENTRY glMultMatrixf(const GLfloat *m)\r
1082 {\r
1083         return es1::MultMatrixf(m);\r
1084 }\r
1085 \r
1086 GL_API void GL_APIENTRY glMultMatrixx(const GLfixed *m)\r
1087 {\r
1088         return es1::MultMatrixx(m);\r
1089 }\r
1090 \r
1091 GL_API void GL_APIENTRY glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)\r
1092 {\r
1093         return es1::MultiTexCoord4f(target, s, t, r, q);\r
1094 }\r
1095 \r
1096 GL_API void GL_APIENTRY glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)\r
1097 {\r
1098         return es1::MultiTexCoord4x(target, s, t, r, q);\r
1099 }\r
1100 \r
1101 GL_API void GL_APIENTRY glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)\r
1102 {\r
1103         return es1::Normal3f(nx, ny, nz);\r
1104 }\r
1105 \r
1106 GL_API void GL_APIENTRY glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz)\r
1107 {\r
1108         return es1::Normal3x(nx, ny, nz);\r
1109 }\r
1110 \r
1111 GL_API void GL_APIENTRY glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)\r
1112 {\r
1113         return es1::NormalPointer(type, stride, pointer);\r
1114 }\r
1115 \r
1116 GL_API void GL_APIENTRY glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)\r
1117 {\r
1118         return es1::Orthof(left, right, bottom, top, zNear, zFar);\r
1119 }\r
1120 \r
1121 GL_API void GL_APIENTRY glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)\r
1122 {\r
1123         return es1::Orthox(left, right, bottom, top, zNear, zFar);\r
1124 }\r
1125 \r
1126 GL_API void GL_APIENTRY glPixelStorei(GLenum pname, GLint param)\r
1127 {\r
1128         return es1::PixelStorei(pname, param);\r
1129 }\r
1130 \r
1131 GL_API void GL_APIENTRY glPointParameterf(GLenum pname, GLfloat param)\r
1132 {\r
1133         return es1::PointParameterf(pname, param);\r
1134 }\r
1135 \r
1136 GL_API void GL_APIENTRY glPointParameterfv(GLenum pname, const GLfloat *params)\r
1137 {\r
1138         return es1::PointParameterfv(pname, params);\r
1139 }\r
1140 \r
1141 GL_API void GL_APIENTRY glPointParameterx(GLenum pname, GLfixed param)\r
1142 {\r
1143         return es1::PointParameterx(pname, param);\r
1144 }\r
1145 \r
1146 GL_API void GL_APIENTRY glPointParameterxv(GLenum pname, const GLfixed *params)\r
1147 {\r
1148         return es1::PointParameterxv(pname, params);\r
1149 }\r
1150 \r
1151 GL_API void GL_APIENTRY glPointSize(GLfloat size)\r
1152 {\r
1153         return es1::PointSize(size);\r
1154 }\r
1155 \r
1156 GL_API void GL_APIENTRY glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid *pointer)\r
1157 {\r
1158         return es1::PointSizePointerOES(type, stride, pointer);\r
1159 }\r
1160 \r
1161 GL_API void GL_APIENTRY glPointSizex(GLfixed size)\r
1162 {\r
1163         return es1::PointSizex(size);\r
1164 }\r
1165 \r
1166 GL_API void GL_APIENTRY glPolygonOffset(GLfloat factor, GLfloat units)\r
1167 {\r
1168         return es1::PolygonOffset(factor, units);\r
1169 }\r
1170 \r
1171 GL_API void GL_APIENTRY glPolygonOffsetx(GLfixed factor, GLfixed units)\r
1172 {\r
1173         return es1::PolygonOffsetx(factor, units);\r
1174 }\r
1175 \r
1176 GL_API void GL_APIENTRY glPopMatrix(void)\r
1177 {\r
1178         return es1::PopMatrix();\r
1179 }\r
1180 \r
1181 GL_API void GL_APIENTRY glPushMatrix(void)\r
1182 {\r
1183         return es1::PushMatrix();\r
1184 }\r
1185 \r
1186 GL_API void GL_APIENTRY glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)\r
1187 {\r
1188         return es1::ReadPixels(x, y, width, height, format, type, pixels);\r
1189 }\r
1190 \r
1191 GL_API void GL_APIENTRY glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)\r
1192 {\r
1193         return es1::RenderbufferStorageOES(target, internalformat, width, height);\r
1194 }\r
1195 \r
1196 GL_API void GL_APIENTRY glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)\r
1197 {\r
1198         return es1::Rotatef(angle, x, y, z);\r
1199 }\r
1200 \r
1201 GL_API void GL_APIENTRY glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)\r
1202 {\r
1203         return es1::Rotatex(angle, x, y, z);\r
1204 }\r
1205 \r
1206 GL_API void GL_APIENTRY glSampleCoverage(GLclampf value, GLboolean invert)\r
1207 {\r
1208         return es1::SampleCoverage(value, invert);\r
1209 }\r
1210 \r
1211 GL_API void GL_APIENTRY glSampleCoveragex(GLclampx value, GLboolean invert)\r
1212 {\r
1213         return es1::SampleCoveragex(value, invert);\r
1214 }\r
1215 \r
1216 GL_API void GL_APIENTRY glScalef(GLfloat x, GLfloat y, GLfloat z)\r
1217 {\r
1218         return es1::Scalef(x, y, z);\r
1219 }\r
1220 \r
1221 GL_API void GL_APIENTRY glScalex(GLfixed x, GLfixed y, GLfixed z)\r
1222 {\r
1223         return es1::Scalex(x, y, z);\r
1224 }\r
1225 \r
1226 GL_API void GL_APIENTRY glScissor(GLint x, GLint y, GLsizei width, GLsizei height)\r
1227 {\r
1228         return es1::Scissor(x, y, width, height);\r
1229 }\r
1230 \r
1231 GL_API void GL_APIENTRY glShadeModel(GLenum mode)\r
1232 {\r
1233         return es1::ShadeModel(mode);\r
1234 }\r
1235 \r
1236 GL_API void GL_APIENTRY glStencilFunc(GLenum func, GLint ref, GLuint mask)\r
1237 {\r
1238         return es1::StencilFunc(func, ref, mask);\r
1239 }\r
1240 \r
1241 GL_API void GL_APIENTRY glStencilMask(GLuint mask)\r
1242 {\r
1243         return es1::StencilMask(mask);\r
1244 }\r
1245 \r
1246 GL_API void GL_APIENTRY glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)\r
1247 {\r
1248         return es1::StencilOp(fail, zfail, zpass);\r
1249 }\r
1250 \r
1251 GL_API void GL_APIENTRY glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)\r
1252 {\r
1253         return es1::TexCoordPointer(size, type, stride, pointer);\r
1254 }\r
1255 \r
1256 GL_API void GL_APIENTRY glTexEnvf(GLenum target, GLenum pname, GLfloat param)\r
1257 {\r
1258         return es1::TexEnvf(target, pname, param);\r
1259 }\r
1260 \r
1261 GL_API void GL_APIENTRY glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)\r
1262 {\r
1263         return es1::TexEnvfv(target, pname, params);\r
1264 }\r
1265 \r
1266 GL_API void GL_APIENTRY glTexEnvi(GLenum target, GLenum pname, GLint param)\r
1267 {\r
1268         return es1::TexEnvi(target, pname, param);\r
1269 }\r
1270 \r
1271 GL_API void GL_APIENTRY glTexEnvx(GLenum target, GLenum pname, GLfixed param)\r
1272 {\r
1273         return es1::TexEnvx(target, pname, param);\r
1274 }\r
1275 \r
1276 GL_API void GL_APIENTRY glTexEnviv(GLenum target, GLenum pname, const GLint *params)\r
1277 {\r
1278         return es1::TexEnviv(target, pname, params);\r
1279 }\r
1280 \r
1281 GL_API void GL_APIENTRY glTexEnvxv(GLenum target, GLenum pname, const GLfixed *params)\r
1282 {\r
1283         return es1::TexEnvxv(target, pname, params);\r
1284 }\r
1285 \r
1286 GL_API void GL_APIENTRY glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,\r
1287                                      GLint border, GLenum format, GLenum type, const GLvoid* pixels)\r
1288 {\r
1289         return es1::TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);\r
1290 }\r
1291 \r
1292 GL_API void GL_APIENTRY glTexParameterf(GLenum target, GLenum pname, GLfloat param)\r
1293 {\r
1294         return es1::TexParameterf(target, pname, param);\r
1295 }\r
1296 \r
1297 GL_API void GL_APIENTRY glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)\r
1298 {\r
1299         return es1::TexParameterfv(target, pname, params);\r
1300 }\r
1301 \r
1302 GL_API void GL_APIENTRY glTexParameteri(GLenum target, GLenum pname, GLint param)\r
1303 {\r
1304         return es1::TexParameteri(target, pname, param);\r
1305 }\r
1306 \r
1307 GL_API void GL_APIENTRY glTexParameteriv(GLenum target, GLenum pname, const GLint* params)\r
1308 {\r
1309         return es1::TexParameteriv(target, pname, params);\r
1310 }\r
1311 \r
1312 GL_API void GL_APIENTRY glTexParameterx(GLenum target, GLenum pname, GLfixed param)\r
1313 {\r
1314         return es1::TexParameterx(target, pname, param);\r
1315 }\r
1316 \r
1317 GL_API void GL_APIENTRY glTexParameterxv(GLenum target, GLenum pname, const GLfixed *params)\r
1318 {\r
1319         return es1::TexParameterxv(target, pname, params);\r
1320 }\r
1321 \r
1322 GL_API void GL_APIENTRY glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,\r
1323                                         GLenum format, GLenum type, const GLvoid* pixels)\r
1324 {\r
1325         return es1::TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);\r
1326 }\r
1327 \r
1328 GL_API void GL_APIENTRY glTranslatef(GLfloat x, GLfloat y, GLfloat z)\r
1329 {\r
1330         return es1::Translatef(x, y, z);\r
1331 }\r
1332 \r
1333 GL_API void GL_APIENTRY glTranslatex(GLfixed x, GLfixed y, GLfixed z)\r
1334 {\r
1335         return es1::Translatex(x, y, z);\r
1336 }\r
1337 \r
1338 GL_API void GL_APIENTRY glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)\r
1339 {\r
1340         return es1::VertexPointer(size, type, stride, pointer);\r
1341 }\r
1342 \r
1343 GL_API void GL_APIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height)\r
1344 {\r
1345         return es1::Viewport(x, y, width, height);\r
1346 }\r
1347 \r
1348 GL_API void GL_APIENTRY glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)\r
1349 {\r
1350         return es1::EGLImageTargetTexture2DOES(target, image);\r
1351 }\r
1352 \r
1353 GL_API void GL_APIENTRY glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)\r
1354 {\r
1355         return es1::EGLImageTargetRenderbufferStorageOES(target, image);\r
1356 }\r
1357 \r
1358 GL_API void GL_APIENTRY glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height)\r
1359 {\r
1360         return es1::DrawTexsOES(x,y, z, width, height);\r
1361 }\r
1362 \r
1363 GL_API void GL_APIENTRY glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)\r
1364 {\r
1365         return es1::DrawTexiOES(x,y, z, width, height);\r
1366 }\r
1367 \r
1368 GL_API void GL_APIENTRY glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height)\r
1369 {\r
1370         return es1::DrawTexxOES(x,y, z, width, height);\r
1371 }\r
1372 \r
1373 GL_API void GL_APIENTRY glDrawTexsvOES(const GLshort *coords)\r
1374 {\r
1375         return es1::DrawTexsvOES(coords);\r
1376 }\r
1377 \r
1378 GL_API void GL_APIENTRY glDrawTexivOES(const GLint *coords)\r
1379 {\r
1380         return es1::DrawTexivOES(coords);\r
1381 }\r
1382 \r
1383 GL_API void GL_APIENTRY glDrawTexxvOES(const GLfixed *coords)\r
1384 {\r
1385         return es1::DrawTexxvOES(coords);\r
1386 }\r
1387 \r
1388 GL_API void GL_APIENTRY glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height)\r
1389 {\r
1390         return es1::DrawTexfOES(x, y, z, width, height);\r
1391 }\r
1392 \r
1393 GL_API void GL_APIENTRY glDrawTexfvOES(const GLfloat *coords)\r
1394 {\r
1395         return es1::DrawTexfvOES(coords);\r
1396 }\r
1397 \r
1398 void GL_APIENTRY Register(const char *licenseKey)\r
1399 {\r
1400         RegisterLicenseKey(licenseKey);\r
1401 }\r
1402 }\r
1403 \r
1404 LibGLES_CMexports::LibGLES_CMexports()\r
1405 {\r
1406         this->glActiveTexture = es1::ActiveTexture;\r
1407         this->glAlphaFunc = es1::AlphaFunc;\r
1408         this->glAlphaFuncx = es1::AlphaFuncx;\r
1409         this->glBindBuffer = es1::BindBuffer;\r
1410         this->glBindFramebuffer = es1::BindFramebuffer;\r
1411         this->glBindFramebufferOES = es1::BindFramebufferOES;\r
1412         this->glBindRenderbufferOES = es1::BindRenderbufferOES;\r
1413         this->glBindTexture = es1::BindTexture;\r
1414         this->glBlendEquationSeparateOES = es1::BlendEquationSeparateOES;\r
1415         this->glBlendEquationOES = es1::BlendEquationOES;\r
1416         this->glBlendEquationSeparateOES = es1::BlendEquationSeparateOES;\r
1417         this->glBlendFuncSeparateOES = es1::BlendFuncSeparateOES;\r
1418         this->glBlendFunc = es1::BlendFunc;\r
1419         this->glBlendFuncSeparateOES = es1::BlendFuncSeparateOES;\r
1420         this->glBufferData = es1::BufferData;\r
1421         this->glBufferSubData = es1::BufferSubData;\r
1422         this->glCheckFramebufferStatusOES = es1::CheckFramebufferStatusOES;\r
1423         this->glClear = es1::Clear;\r
1424         this->glClearColor = es1::ClearColor;\r
1425         this->glClearColorx = es1::ClearColorx;\r
1426         this->glClearDepthf = es1::ClearDepthf;\r
1427         this->glClearDepthx = es1::ClearDepthx;\r
1428         this->glClearStencil = es1::ClearStencil;\r
1429         this->glClientActiveTexture = es1::ClientActiveTexture;\r
1430         this->glClipPlanef = es1::ClipPlanef;\r
1431         this->glClipPlanex = es1::ClipPlanex;\r
1432         this->glColor4f = es1::Color4f;\r
1433         this->glColor4ub = es1::Color4ub;\r
1434         this->glColor4x = es1::Color4x;\r
1435         this->glColorMask = es1::ColorMask;\r
1436         this->glColorPointer = es1::ColorPointer;\r
1437         this->glCompressedTexImage2D = es1::CompressedTexImage2D;\r
1438         this->glCompressedTexSubImage2D = es1::CompressedTexSubImage2D;\r
1439         this->glCopyTexImage2D = es1::CopyTexImage2D;\r
1440         this->glCopyTexSubImage2D = es1::CopyTexSubImage2D;\r
1441         this->glCullFace = es1::CullFace;\r
1442         this->glDeleteBuffers = es1::DeleteBuffers;\r
1443         this->glDeleteFramebuffersOES = es1::DeleteFramebuffersOES;\r
1444         this->glDeleteRenderbuffersOES = es1::DeleteRenderbuffersOES;\r
1445         this->glDeleteTextures = es1::DeleteTextures;\r
1446         this->glDepthFunc = es1::DepthFunc;\r
1447         this->glDepthMask = es1::DepthMask;\r
1448         this->glDepthRangex = es1::DepthRangex;\r
1449         this->glDepthRangef = es1::DepthRangef;\r
1450         this->glDisable = es1::Disable;\r
1451         this->glDisableClientState = es1::DisableClientState;\r
1452         this->glDrawArrays = es1::DrawArrays;\r
1453         this->glDrawElements = es1::DrawElements;\r
1454         this->glEnable = es1::Enable;\r
1455         this->glEnableClientState = es1::EnableClientState;\r
1456         this->glFinish = es1::Finish;\r
1457         this->glFlush = es1::Flush;\r
1458         this->glFramebufferRenderbufferOES = es1::FramebufferRenderbufferOES;\r
1459         this->glFramebufferTexture2DOES = es1::FramebufferTexture2DOES;\r
1460         this->glFogf = es1::Fogf;\r
1461         this->glFogfv = es1::Fogfv;\r
1462         this->glFogx = es1::Fogx;\r
1463         this->glFogxv = es1::Fogxv;\r
1464         this->glFrontFace = es1::FrontFace;\r
1465         this->glFrustumf = es1::Frustumf;\r
1466         this->glFrustumx = es1::Frustumx;\r
1467         this->glGenerateMipmapOES = es1::GenerateMipmapOES;\r
1468         this->glGenBuffers = es1::GenBuffers;\r
1469         this->glGenFramebuffersOES = es1::GenFramebuffersOES;\r
1470         this->glGenRenderbuffersOES = es1::GenRenderbuffersOES;\r
1471         this->glGenTextures = es1::GenTextures;\r
1472         this->glGetRenderbufferParameterivOES = es1::GetRenderbufferParameterivOES;\r
1473         this->glGetBooleanv = es1::GetBooleanv;\r
1474         this->glGetBufferParameteriv = es1::GetBufferParameteriv;\r
1475         this->glGetClipPlanef = es1::GetClipPlanef;\r
1476         this->glGetClipPlanex = es1::GetClipPlanex;\r
1477         this->glGetError = es1::GetError;\r
1478         this->glGetFixedv = es1::GetFixedv;\r
1479         this->glGetFloatv = es1::GetFloatv;\r
1480         this->glGetFramebufferAttachmentParameterivOES = es1::GetFramebufferAttachmentParameterivOES;\r
1481         this->glGetIntegerv = es1::GetIntegerv;\r
1482         this->glGetLightfv = es1::GetLightfv;\r
1483         this->glGetLightxv = es1::GetLightxv;\r
1484         this->glGetMaterialfv = es1::GetMaterialfv;\r
1485         this->glGetMaterialxv = es1::GetMaterialxv;\r
1486         this->glGetPointerv = es1::GetPointerv;\r
1487         this->glGetString = es1::GetString;\r
1488         this->glGetTexParameterfv = es1::GetTexParameterfv;\r
1489         this->glGetTexParameteriv = es1::GetTexParameteriv;\r
1490         this->glGetTexEnvfv = es1::GetTexEnvfv;\r
1491         this->glGetTexEnviv = es1::GetTexEnviv;\r
1492         this->glGetTexEnvxv = es1::GetTexEnvxv;\r
1493         this->glGetTexParameterxv = es1::GetTexParameterxv;\r
1494         this->glHint = es1::Hint;\r
1495         this->glIsBuffer = es1::IsBuffer;\r
1496         this->glIsEnabled = es1::IsEnabled;\r
1497         this->glIsFramebufferOES = es1::IsFramebufferOES;\r
1498         this->glIsTexture = es1::IsTexture;\r
1499         this->glIsRenderbufferOES = es1::IsRenderbufferOES;\r
1500         this->glLightModelf = es1::LightModelf;\r
1501         this->glLightModelfv = es1::LightModelfv;\r
1502         this->glLightModelx = es1::LightModelx;\r
1503         this->glLightModelxv = es1::LightModelxv;\r
1504         this->glLightf = es1::Lightf;\r
1505         this->glLightfv = es1::Lightfv;\r
1506         this->glLightx = es1::Lightx;\r
1507         this->glLightxv = es1::Lightxv;\r
1508         this->glLineWidth = es1::LineWidth;\r
1509         this->glLineWidthx = es1::LineWidthx;\r
1510         this->glLoadIdentity = es1::LoadIdentity;\r
1511         this->glLoadMatrixf = es1::LoadMatrixf;\r
1512         this->glLoadMatrixx = es1::LoadMatrixx;\r
1513         this->glLogicOp = es1::LogicOp;\r
1514         this->glMaterialf = es1::Materialf;\r
1515         this->glMaterialfv = es1::Materialfv;\r
1516         this->glMaterialx = es1::Materialx;\r
1517         this->glMaterialxv = es1::Materialxv;\r
1518         this->glMatrixMode = es1::MatrixMode;\r
1519         this->glMultMatrixf = es1::MultMatrixf;\r
1520         this->glMultMatrixx = es1::MultMatrixx;\r
1521         this->glMultiTexCoord4f = es1::MultiTexCoord4f;\r
1522         this->glMultiTexCoord4x = es1::MultiTexCoord4x;\r
1523         this->glNormal3f = es1::Normal3f;\r
1524         this->glNormal3x = es1::Normal3x;\r
1525         this->glNormalPointer = es1::NormalPointer;\r
1526         this->glOrthof = es1::Orthof;\r
1527         this->glOrthox = es1::Orthox;\r
1528         this->glPixelStorei = es1::PixelStorei;\r
1529         this->glPointParameterf = es1::PointParameterf;\r
1530         this->glPointParameterfv = es1::PointParameterfv;\r
1531         this->glPointParameterx = es1::PointParameterx;\r
1532         this->glPointParameterxv = es1::PointParameterxv;\r
1533         this->glPointSize = es1::PointSize;\r
1534         this->glPointSizePointerOES = es1::PointSizePointerOES;\r
1535         this->glPointSizex = es1::PointSizex;\r
1536         this->glPolygonOffset = es1::PolygonOffset;\r
1537         this->glPolygonOffsetx = es1::PolygonOffsetx;\r
1538         this->glPopMatrix = es1::PopMatrix;\r
1539         this->glPushMatrix = es1::PushMatrix;\r
1540         this->glReadPixels = es1::ReadPixels;\r
1541         this->glRenderbufferStorageOES = es1::RenderbufferStorageOES;\r
1542         this->glRotatef = es1::Rotatef;\r
1543         this->glRotatex = es1::Rotatex;\r
1544         this->glSampleCoverage = es1::SampleCoverage;\r
1545         this->glSampleCoveragex = es1::SampleCoveragex;\r
1546         this->glScalef = es1::Scalef;\r
1547         this->glScalex = es1::Scalex;\r
1548         this->glScissor = es1::Scissor;\r
1549         this->glShadeModel = es1::ShadeModel;\r
1550         this->glStencilFunc = es1::StencilFunc;\r
1551         this->glStencilMask = es1::StencilMask;\r
1552         this->glStencilOp = es1::StencilOp;\r
1553         this->glTexCoordPointer = es1::TexCoordPointer;\r
1554         this->glTexEnvf = es1::TexEnvf;\r
1555         this->glTexEnvfv = es1::TexEnvfv;\r
1556         this->glTexEnvi = es1::TexEnvi;\r
1557         this->glTexEnvx = es1::TexEnvx;\r
1558         this->glTexEnviv = es1::TexEnviv;\r
1559         this->glTexEnvxv = es1::TexEnvxv;\r
1560         this->glTexImage2D = es1::TexImage2D;\r
1561         this->glTexParameterf = es1::TexParameterf;\r
1562         this->glTexParameterfv = es1::TexParameterfv;\r
1563         this->glTexParameteri = es1::TexParameteri;\r
1564         this->glTexParameteriv = es1::TexParameteriv;\r
1565         this->glTexParameterx = es1::TexParameterx;\r
1566         this->glTexParameterxv = es1::TexParameterxv;\r
1567         this->glTexSubImage2D = es1::TexSubImage2D;\r
1568         this->glTranslatef = es1::Translatef;\r
1569         this->glTranslatex = es1::Translatex;\r
1570         this->glVertexPointer = es1::VertexPointer;\r
1571         this->glViewport = es1::Viewport;\r
1572         this->glEGLImageTargetTexture2DOES = es1::EGLImageTargetTexture2DOES;\r
1573         this->glEGLImageTargetRenderbufferStorageOES = es1::EGLImageTargetRenderbufferStorageOES;\r
1574         this->glDrawTexsOES = es1::DrawTexsOES;\r
1575         this->glDrawTexiOES = es1::DrawTexiOES;\r
1576         this->glDrawTexxOES = es1::DrawTexxOES;\r
1577         this->glDrawTexsvOES = es1::DrawTexsvOES;\r
1578         this->glDrawTexivOES = es1::DrawTexivOES;\r
1579         this->glDrawTexxvOES = es1::DrawTexxvOES;\r
1580         this->glDrawTexfOES = es1::DrawTexfOES;\r
1581         this->glDrawTexfvOES = es1::DrawTexfvOES;\r
1582 \r
1583         this->es1CreateContext = ::es1CreateContext;\r
1584         this->es1GetProcAddress = ::es1GetProcAddress;\r
1585         this->createBackBuffer = ::createBackBuffer;\r
1586         this->createDepthStencil = ::createDepthStencil;\r
1587         this->createFrameBuffer = ::createFrameBuffer;\r
1588 }\r
1589 \r
1590 extern "C" GL_API LibGLES_CMexports *libGLES_CM_swiftshader()\r
1591 {\r
1592         static LibGLES_CMexports libGLES_CM;\r
1593         return &libGLES_CM;\r
1594 }\r
1595 \r
1596 LibEGL libEGL;