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