1 /*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #ifdef _WIN32
18 #undef GL_API
19 #define GL_API __declspec(dllexport)
20 #define GL_APICALL __declspec(dllexport)
21 #endif
22
23 #define GL_GLEXT_PROTOTYPES
24 #include "GLEScmContext.h"
25 #include "GLEScmValidate.h"
26 #include "GLEScmUtils.h"
27 #include <GLcommon/TextureUtils.h>
28 #include "apigen-codec-common/ErrorLog.h"
29
30 #include <GLcommon/GLDispatch.h>
31 #include <GLcommon/GLconversion_macros.h>
32 #include <GLcommon/TextureData.h>
33 #include <GLcommon/TranslatorIfaces.h>
34 #include <GLcommon/FramebufferData.h>
35
36 #include "host-common/crash_reporter.h"
37
38 #include <cmath>
39 #include <unordered_map>
40
41 #include <stdio.h>
42
43 #define DEBUG 0
44
45 #if DEBUG
46 #define GLES_CM_TRACE() fprintf(stderr, "%s\n", __func__); ERRCHECK()
47 #else
48 #define GLES_CM_TRACE()
49 #endif
50
51 #define GLES1_NAMESPACED(f) translator::gles1::f
52
53 namespace translator {
54 namespace gles1 {
55
56 GL_API void GL_APIENTRY glFlush( void);
57 GL_API void GL_APIENTRY glFinish( void);
58 GL_API GLenum GL_APIENTRY glGetError( void);
59
60 } // namespace gles1
61 } // namespace translator
62
63 extern "C" {
64
65 //decleration
66 static void initGLESx(bool isGles2Gles);
67 static void initContext(GLEScontext* ctx,ShareGroupPtr grp);
68 static void setMaxGlesVersion(GLESVersion version);
69 static void deleteGLESContext(GLEScontext* ctx);
70 static void setShareGroup(GLEScontext* ctx,ShareGroupPtr grp);
71 static GLEScontext* createGLESContext(int maj, int min,
72 GlobalNameSpace* globalNameSpace, android::base::Stream* stream);
73 static __translatorMustCastToProperFunctionPointerType getProcAddressGles1(const char* procName);
74 static bool vulkanInteropSupported();
75 }
76
77 /************************************** GLES EXTENSIONS *********************************************************/
78 typedef std::unordered_map<std::string, __translatorMustCastToProperFunctionPointerType> ProcTableMap;
79 ProcTableMap *s_glesExtensions = NULL;
80 /****************************************************************************************************************/
81
82 static EGLiface* s_eglIface = NULL;
83 static GLESiface s_glesIface = {
84 .initGLESx = initGLESx,
85 .createGLESContext = createGLESContext,
86 .initContext = initContext,
87 .setMaxGlesVersion = setMaxGlesVersion,
88 .deleteGLESContext = deleteGLESContext,
89 .flush = (FUNCPTR_NO_ARGS_RET_VOID)GLES1_NAMESPACED(glFlush),
90 .finish = (FUNCPTR_NO_ARGS_RET_VOID)GLES1_NAMESPACED(glFinish),
91 .getError = (FUNCPTR_NO_ARGS_RET_INT)GLES1_NAMESPACED(glGetError),
92 .setShareGroup = setShareGroup,
93 .getProcAddress = getProcAddressGles1,
94 .fenceSync = NULL,
95 .clientWaitSync = NULL,
96 .waitSync = NULL,
97 .deleteSync = NULL,
98 .preSaveTexture = NULL,
99 .postSaveTexture = NULL,
100 .saveTexture = NULL,
101 .createTexture = NULL,
102 .restoreTexture = NULL,
103 .deleteRbo = NULL,
104 .blitFromCurrentReadBufferANDROID = NULL,
105 .vulkanInteropSupported = vulkanInteropSupported,
106 .getSynciv = NULL,
107 };
108
109 #include <GLcommon/GLESmacros.h>
110
111 namespace translator {
112 namespace gles1 {
113
114 GL_API void GL_APIENTRY glBindTexture (GLenum target, GLuint texture);
115 GL_APICALL void GL_APIENTRY glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image);
116 GL_APICALL void GL_APIENTRY glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image);
117
118 GL_APICALL void GL_APIENTRY glVertexAttribPointerWithDataSize(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr, GLsizei dataSize);
119 GL_APICALL void GL_APIENTRY glVertexAttribIPointerWithDataSize(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* ptr, GLsizei dataSize);
120
121 GL_API void GL_APIENTRY glColorPointerWithDataSize( GLint size, GLenum type,
122 GLsizei stride, const GLvoid *pointer, GLsizei dataSize);
123 GL_API void GL_APIENTRY glNormalPointerWithDataSize(GLenum type,
124 GLsizei stride, const GLvoid *pointer, GLsizei dataSize);
125 GL_API void GL_APIENTRY glTexCoordPointerWithDataSize( GLint size, GLenum type,
126 GLsizei stride, const GLvoid *pointer, GLsizei dataSize);
127 GL_API void GL_APIENTRY glVertexPointerWithDataSize( GLint size, GLenum type,
128 GLsizei stride, const GLvoid *pointer, GLsizei dataSize);
129
130 GL_API void GL_APIENTRY glBlendEquationOES(GLenum mode);
131 GL_API void GL_APIENTRY glBlendEquationSeparateOES (GLenum modeRGB, GLenum modeAlpha);
132 GL_API void GL_APIENTRY glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
133 GL_API void GL_APIENTRY glCurrentPaletteMatrixOES(GLuint index);
134 GL_API void GL_APIENTRY glLoadPaletteFromModelViewMatrixOES();
135 GL_API void GL_APIENTRY glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
136 GL_API void GL_APIENTRY glWeightPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
137 GL_API void GL_APIENTRY glDepthRangef( GLclampf zNear, GLclampf zFar);
138 GL_API void GL_APIENTRY glFrustumf( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
139 GL_API void GL_APIENTRY glOrthof( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
140 GL_API void GL_APIENTRY glClipPlanef( GLenum plane, const GLfloat *equation);
141 GL_API void GL_APIENTRY glGetClipPlanef( GLenum pname, GLfloat eqn[4]);
142 GL_API void GL_APIENTRY glClearDepthf( GLclampf depth);
143 GL_API void GL_APIENTRY glPointSizePointerOES( GLenum type, GLsizei stride, const GLvoid *pointer);
144 GL_API void GL_APIENTRY glTexGenfOES (GLenum coord, GLenum pname, GLfloat param);
145 GL_API void GL_APIENTRY glTexGenfvOES (GLenum coord, GLenum pname, const GLfloat *params);
146 GL_API void GL_APIENTRY glTexGeniOES (GLenum coord, GLenum pname, GLint param);
147 GL_API void GL_APIENTRY glTexGenivOES (GLenum coord, GLenum pname, const GLint *params);
148 GL_API void GL_APIENTRY glTexGenxOES (GLenum coord, GLenum pname, GLfixed param);
149 GL_API void GL_APIENTRY glTexGenxvOES (GLenum coord, GLenum pname, const GLfixed *params);
150 GL_API void GL_APIENTRY glGetTexGenfvOES (GLenum coord, GLenum pname, GLfloat *params);
151 GL_API void GL_APIENTRY glGetTexGenivOES (GLenum coord, GLenum pname, GLint *params);
152 GL_API void GL_APIENTRY glGetTexGenxvOES (GLenum coord, GLenum pname, GLfixed *params);
153 GL_API void GL_APIENTRY glDrawTexsOES (GLshort x, GLshort y, GLshort z, GLshort width, GLshort height);
154 GL_API void GL_APIENTRY glDrawTexiOES (GLint x, GLint y, GLint z, GLint width, GLint height);
155 GL_API void GL_APIENTRY glDrawTexfOES (GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height);
156 GL_API void GL_APIENTRY glDrawTexxOES (GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height);
157 GL_API void GL_APIENTRY glDrawTexsvOES (const GLshort * coords);
158 GL_API void GL_APIENTRY glDrawTexivOES (const GLint * coords);
159 GL_API void GL_APIENTRY glDrawTexfvOES (const GLfloat * coords);
160 GL_API void GL_APIENTRY glDrawTexfvOES (const GLfloat * coords);
161 GL_API void GL_APIENTRY glDrawTexxvOES (const GLfixed * coords);
162
163 GL_API void GLAPIENTRY glGenRenderbuffersOES(GLsizei n, GLuint *renderbuffers);
164 GL_API GLboolean GL_APIENTRY glIsRenderbufferOES(GLuint renderbuffer);
165 GL_API void GLAPIENTRY glBindRenderbufferOES(GLenum target, GLuint renderbuffer);
166 GL_API void GLAPIENTRY glDeleteRenderbuffersOES(GLsizei n, const GLuint *renderbuffers);
167 GL_API void GLAPIENTRY glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
168 GL_API void GLAPIENTRY glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint* params);
169
170 GL_API GLboolean GLAPIENTRY glIsFramebufferOES(GLuint framebuffer);
171 GL_API void GLAPIENTRY glBindFramebufferOES(GLenum target, GLuint framebuffer);
172 GL_API void GLAPIENTRY glDeleteFramebuffersOES(GLsizei n, const GLuint *framebuffers);
173 GL_API void GLAPIENTRY glGenFramebuffersOES(GLsizei n, GLuint *framebuffers);
174 GL_API void GLAPIENTRY glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
175 GL_API void GLAPIENTRY glFramebufferRenderbufferOES(GLenum target, GLenum attachment,GLenum renderbuffertarget, GLuint renderbuffer);
176 GL_API void GLAPIENTRY glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint *params);
177
178 GL_API GLenum GLAPIENTRY glCheckFramebufferStatusOES(GLenum target);
179
180 GL_API void GL_APIENTRY glGenerateMipmapOES(GLenum target);
181
182 } // namespace gles1
183 } // namespace translator
184
185 extern "C" {
186
setMaxGlesVersion(GLESVersion version)187 static void setMaxGlesVersion(GLESVersion version) {
188 GLEScmContext::setMaxGlesVersion(version);
189 }
190
191 #define ERRCHECK() { \
192 GLint err = ctx->dispatcher().glGetError(); \
193 if (err) fprintf(stderr, "%s:%d GL err 0x%x\n", __func__, __LINE__, err); } \
194
195 #define CORE_ERR_FORWARD() \
196 if (isCoreProfile()) { \
197 GLint __core_error = ctx->getErrorCoreProfile(); \
198 SET_ERROR_IF(__core_error, __core_error); \
199 } \
200
initGLESx(bool isGles2Gles)201 static void initGLESx(bool isGles2Gles) {
202 setGles2Gles(isGles2Gles);
203 return;
204 }
205
initContext(GLEScontext * ctx,ShareGroupPtr grp)206 static void initContext(GLEScontext* ctx,ShareGroupPtr grp) {
207 setCoreProfile(ctx->isCoreProfile());
208 GLEScmContext::initGlobal(s_eglIface);
209
210 // TODO: Properly restore GLES1 context from snapshot.
211 // This is just to avoid a crash.
212 if (ctx->needRestore()) {
213 // TODO: metrics for GLES1 snapshots
214 fprintf(stderr,
215 "Warning: restoring GLES1 context from snapshot. App "
216 "may need reloading.\n");
217 }
218
219 if (!ctx->shareGroup()) {
220 ctx->setShareGroup(grp);
221 }
222 if (!ctx->isInitialized()) {
223 ctx->init();
224 translator::gles1::glBindTexture(GL_TEXTURE_2D,0);
225 translator::gles1::glBindTexture(GL_TEXTURE_CUBE_MAP_OES,0);
226 }
227 if (ctx->needRestore()) {
228 ctx->restore();
229 }
230 }
231
createGLESContext(int maj,int min,GlobalNameSpace * globalNameSpace,android::base::Stream * stream)232 static GLEScontext* createGLESContext(int maj, int min,
233 GlobalNameSpace* globalNameSpace, android::base::Stream* stream) {
234 (void)stream;
235 return new GLEScmContext(maj, min, globalNameSpace, stream);
236 }
237
deleteGLESContext(GLEScontext * ctx)238 static void deleteGLESContext(GLEScontext* ctx) {
239 if(ctx) delete ctx;
240 }
241
setShareGroup(GLEScontext * ctx,ShareGroupPtr grp)242 static void setShareGroup(GLEScontext* ctx,ShareGroupPtr grp) {
243 if(ctx) {
244 ctx->setShareGroup(grp);
245 }
246 }
247
vulkanInteropSupported()248 static bool vulkanInteropSupported() {
249 return GLEScontext::vulkanInteropSupported();
250 }
251
getProcAddressGles1(const char * procName)252 static __translatorMustCastToProperFunctionPointerType getProcAddressGles1(const char* procName) {
253 GET_CTX_RET(NULL)
254 ctx->getGlobalLock();
255 static bool proc_table_initialized = false;
256 if (!proc_table_initialized) {
257 proc_table_initialized = true;
258 if (!s_glesExtensions)
259 s_glesExtensions = new ProcTableMap();
260 else
261 s_glesExtensions->clear();
262
263 (*s_glesExtensions)["glEGLImageTargetTexture2DOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glEGLImageTargetTexture2DOES);
264 (*s_glesExtensions)["glEGLImageTargetRenderbufferStorageOES"]=(__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glEGLImageTargetRenderbufferStorageOES);
265 (*s_glesExtensions)["glBlendEquationSeparateOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glBlendEquationSeparateOES);
266 (*s_glesExtensions)["glBlendFuncSeparateOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glBlendFuncSeparateOES);
267 (*s_glesExtensions)["glBlendEquationOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glBlendEquationOES);
268
269 if (ctx->getCaps()->GL_ARB_MATRIX_PALETTE && ctx->getCaps()->GL_ARB_VERTEX_BLEND) {
270 (*s_glesExtensions)["glCurrentPaletteMatrixOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glCurrentPaletteMatrixOES);
271 (*s_glesExtensions)["glLoadPaletteFromModelViewMatrixOES"]=(__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glLoadPaletteFromModelViewMatrixOES);
272 (*s_glesExtensions)["glMatrixIndexPointerOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glMatrixIndexPointerOES);
273 (*s_glesExtensions)["glWeightPointerOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glWeightPointerOES);
274 }
275 (*s_glesExtensions)["glDepthRangefOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glDepthRangef);
276 (*s_glesExtensions)["glFrustumfOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glFrustumf);
277 (*s_glesExtensions)["glOrthofOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glOrthof);
278 (*s_glesExtensions)["glClipPlanefOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glClipPlanef);
279 (*s_glesExtensions)["glGetClipPlanefOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glGetClipPlanef);
280 (*s_glesExtensions)["glClearDepthfOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glClearDepthf);
281 (*s_glesExtensions)["glPointSizePointerOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glPointSizePointerOES);
282 (*s_glesExtensions)["glTexGenfOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glTexGenfOES);
283 (*s_glesExtensions)["glTexGenfvOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glTexGenfvOES);
284 (*s_glesExtensions)["glTexGeniOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glTexGeniOES);
285 (*s_glesExtensions)["glTexGenivOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glTexGenivOES);
286 (*s_glesExtensions)["glTexGenxOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glTexGenxOES);
287 (*s_glesExtensions)["glTexGenxvOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glTexGenxvOES);
288 (*s_glesExtensions)["glGetTexGenfvOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glGetTexGenfvOES);
289 (*s_glesExtensions)["glGetTexGenivOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glGetTexGenivOES);
290 (*s_glesExtensions)["glGetTexGenxvOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glGetTexGenxvOES);
291 if (ctx->getCaps()->GL_EXT_FRAMEBUFFER_OBJECT) {
292 (*s_glesExtensions)["glIsRenderbufferOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glIsRenderbufferOES);
293 (*s_glesExtensions)["glBindRenderbufferOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glBindRenderbufferOES);
294 (*s_glesExtensions)["glDeleteRenderbuffersOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glDeleteRenderbuffersOES);
295 (*s_glesExtensions)["glGenRenderbuffersOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glGenRenderbuffersOES);
296 (*s_glesExtensions)["glRenderbufferStorageOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glRenderbufferStorageOES);
297 (*s_glesExtensions)["glGetRenderbufferParameterivOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glGetRenderbufferParameterivOES);
298 (*s_glesExtensions)["glIsFramebufferOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glIsFramebufferOES);
299 (*s_glesExtensions)["glBindFramebufferOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glBindFramebufferOES);
300 (*s_glesExtensions)["glDeleteFramebuffersOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glDeleteFramebuffersOES);
301 (*s_glesExtensions)["glGenFramebuffersOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glGenFramebuffersOES);
302 (*s_glesExtensions)["glCheckFramebufferStatusOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glCheckFramebufferStatusOES);
303 (*s_glesExtensions)["glFramebufferTexture2DOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glFramebufferTexture2DOES);
304 (*s_glesExtensions)["glFramebufferRenderbufferOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glFramebufferRenderbufferOES);
305 (*s_glesExtensions)["glGetFramebufferAttachmentParameterivOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glGetFramebufferAttachmentParameterivOES);
306 (*s_glesExtensions)["glGenerateMipmapOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glGenerateMipmapOES);
307 }
308 (*s_glesExtensions)["glDrawTexsOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glDrawTexsOES);
309 (*s_glesExtensions)["glDrawTexiOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glDrawTexiOES);
310 (*s_glesExtensions)["glDrawTexfOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glDrawTexfOES);
311 (*s_glesExtensions)["glDrawTexxOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glDrawTexxOES);
312 (*s_glesExtensions)["glDrawTexsvOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glDrawTexsvOES);
313 (*s_glesExtensions)["glDrawTexivOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glDrawTexivOES);
314 (*s_glesExtensions)["glDrawTexfvOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glDrawTexfvOES);
315 (*s_glesExtensions)["glDrawTexxvOES"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glDrawTexxvOES);
316
317 // Vertex array functions with size for snapshot
318 (*s_glesExtensions)["glColorPointerWithDataSize"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glColorPointerWithDataSize);
319 (*s_glesExtensions)["glNormalPointerWithDataSize"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glNormalPointerWithDataSize);
320 (*s_glesExtensions)["glTexCoordPointerWithDataSize"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glTexCoordPointerWithDataSize);
321 (*s_glesExtensions)["glVertexPointerWithDataSize"] = (__translatorMustCastToProperFunctionPointerType)GLES1_NAMESPACED(glVertexPointerWithDataSize);
322 }
323 __translatorMustCastToProperFunctionPointerType ret=NULL;
324 ProcTableMap::iterator val = s_glesExtensions->find(procName);
325 if (val!=s_glesExtensions->end())
326 ret = val->second;
327 ctx->releaseGlobalLock();
328
329 return ret;
330 }
331
332 GL_APICALL GLESiface* GL_APIENTRY static_translator_glescm_getIfaces(const EGLiface* eglIface);
333
static_translator_glescm_getIfaces(const EGLiface * eglIface)334 GLESiface* static_translator_glescm_getIfaces(const EGLiface* eglIface) {
335 s_eglIface = (EGLiface*)eglIface;
336 return &s_glesIface;
337 }
338
339 } // extern "C"
340
getTextureData(ObjectLocalName tex)341 static TextureData* getTextureData(ObjectLocalName tex){
342 GET_CTX_RET(NULL);
343
344 if (!ctx->shareGroup()->isObject(NamedObjectType::TEXTURE, tex)) {
345 return NULL;
346 }
347
348 TextureData *texData = NULL;
349 auto objData =
350 ctx->shareGroup()->getObjectData(NamedObjectType::TEXTURE, tex);
351 if(!objData){
352 texData = new TextureData();
353 ctx->shareGroup()->setObjectData(NamedObjectType::TEXTURE, tex,
354 ObjectDataPtr(texData));
355 } else {
356 texData = (TextureData*)objData;
357 }
358 return texData;
359 }
360
getTextureTargetData(GLenum target)361 static TextureData* getTextureTargetData(GLenum target){
362 GET_CTX_RET(NULL);
363 unsigned int tex = ctx->getBindedTexture(target);
364 return getTextureData(ctx->getTextureLocalName(target,tex));
365 }
366
367 namespace translator {
368 namespace gles1 {
369
glIsBuffer(GLuint buffer)370 GL_API GLboolean GL_APIENTRY glIsBuffer(GLuint buffer) {
371 GET_CTX_RET(GL_FALSE)
372 GLES_CM_TRACE()
373
374 if(buffer && ctx->shareGroup().get()) {
375 auto objData = ctx->shareGroup()->getObjectData(
376 NamedObjectType::VERTEXBUFFER, buffer);
377 return objData ? ((GLESbuffer*)objData)->wasBinded()
378 : GL_FALSE;
379 }
380 return GL_FALSE;
381 }
382
glIsEnabled(GLenum cap)383 GL_API GLboolean GL_APIENTRY glIsEnabled( GLenum cap) {
384 GET_CTX_CM_RET(GL_FALSE)
385 GLES_CM_TRACE()
386 RET_AND_SET_ERROR_IF(!GLEScmValidate::capability(cap,ctx->getMaxLights(),ctx->getMaxClipPlanes()),GL_INVALID_ENUM,GL_FALSE);
387
388 if (cap == GL_POINT_SIZE_ARRAY_OES)
389 return ctx->isArrEnabled(cap);
390 else if (cap==GL_TEXTURE_GEN_STR_OES)
391 return (ctx->dispatcher().glIsEnabled(GL_TEXTURE_GEN_S) &&
392 ctx->dispatcher().glIsEnabled(GL_TEXTURE_GEN_T) &&
393 ctx->dispatcher().glIsEnabled(GL_TEXTURE_GEN_R));
394 else
395 return ctx->dispatcher().glIsEnabled(cap);
396 }
397
glIsTexture(GLuint texture)398 GL_API GLboolean GL_APIENTRY glIsTexture( GLuint texture) {
399 GET_CTX_RET(GL_FALSE)
400 GLES_CM_TRACE()
401
402 if(texture == 0) // Special case
403 return GL_FALSE;
404
405 TextureData* tex = getTextureData(texture);
406 return tex ? tex->wasBound : GL_FALSE;
407 }
408
glGetError(void)409 GL_API GLenum GL_APIENTRY glGetError(void) {
410 GET_CTX_RET(GL_NO_ERROR)
411 GLES_CM_TRACE()
412 GLenum err = ctx->getGLerror();
413 if(err != GL_NO_ERROR) {
414 ctx->setGLerror(GL_NO_ERROR);
415 return err;
416 }
417
418 return ctx->dispatcher().glGetError();
419 }
420
glGetString(GLenum name)421 GL_API const GLubyte * GL_APIENTRY glGetString( GLenum name) {
422 GET_CTX_RET(NULL)
423 GLES_CM_TRACE()
424 switch(name) {
425 case GL_VENDOR:
426 return (const GLubyte*)ctx->getVendorString(true /* is gles1 */);
427 case GL_RENDERER:
428 return (const GLubyte*)ctx->getRendererString(true /* is gles1 */);
429 case GL_VERSION:
430 return (const GLubyte*)ctx->getVersionString(true /* is gles1 */);
431 case GL_EXTENSIONS:
432 return (const GLubyte*)ctx->getExtensionString(true /* is gles1 */);
433 default:
434 RET_AND_SET_ERROR_IF(true,GL_INVALID_ENUM,NULL);
435 }
436 }
437
glActiveTexture(GLenum texture)438 GL_API void GL_APIENTRY glActiveTexture( GLenum texture) {
439 GET_CTX_CM()
440 GLES_CM_TRACE()
441 SET_ERROR_IF(!GLEScmValidate::textureEnum(texture,ctx->getMaxTexUnits()),GL_INVALID_ENUM);
442 ctx->setActiveTexture(texture);
443 ctx->dispatcher().glActiveTexture(texture);
444 }
445
glAlphaFunc(GLenum func,GLclampf ref)446 GL_API void GL_APIENTRY glAlphaFunc( GLenum func, GLclampf ref) {
447 GET_CTX()
448 GLES_CM_TRACE()
449 SET_ERROR_IF(!GLEScmValidate::alphaFunc(func),GL_INVALID_ENUM);
450 ctx->dispatcher().glAlphaFunc(func,ref);
451 }
452
453
glAlphaFuncx(GLenum func,GLclampx ref)454 GL_API void GL_APIENTRY glAlphaFuncx( GLenum func, GLclampx ref) {
455 GET_CTX()
456 GLES_CM_TRACE()
457 SET_ERROR_IF(!GLEScmValidate::alphaFunc(func),GL_INVALID_ENUM);
458 ctx->dispatcher().glAlphaFunc(func,X2F(ref));
459 }
460
461
glBindBuffer(GLenum target,GLuint buffer)462 GL_API void GL_APIENTRY glBindBuffer( GLenum target, GLuint buffer) {
463 GET_CTX()
464 GLES_CM_TRACE()
465 SET_ERROR_IF(!GLEScmValidate::bufferTarget(target),GL_INVALID_ENUM);
466
467 //if buffer wasn't generated before,generate one
468 if (buffer && ctx->shareGroup().get() &&
469 !ctx->shareGroup()->isObject(NamedObjectType::VERTEXBUFFER, buffer)) {
470 ctx->shareGroup()->genName(NamedObjectType::VERTEXBUFFER, buffer);
471 ctx->shareGroup()->setObjectData(NamedObjectType::VERTEXBUFFER, buffer,
472 ObjectDataPtr(new GLESbuffer()));
473 }
474 ctx->bindBuffer(target,buffer);
475 ctx->dispatcher().glBindBuffer(target, ctx->shareGroup()->getGlobalName(
476 NamedObjectType::VERTEXBUFFER, buffer));
477 if (buffer) {
478 GLESbuffer* vbo =
479 (GLESbuffer*)ctx->shareGroup()
480 ->getObjectData(NamedObjectType::VERTEXBUFFER, buffer);
481 vbo->setBinded();
482 }
483 }
484
485
glBindTexture(GLenum target,GLuint texture)486 GL_API void GL_APIENTRY glBindTexture( GLenum target, GLuint texture) {
487 GET_CTX_CM()
488 GLES_CM_TRACE()
489 SET_ERROR_IF(!GLEScmValidate::textureTarget(target),GL_INVALID_ENUM)
490
491 //for handling default texture (0)
492 ObjectLocalName localTexName = ctx->getTextureLocalName(target,texture);
493
494 GLuint globalTextureName = localTexName;
495 if(ctx->shareGroup().get()){
496 globalTextureName = ctx->shareGroup()->getGlobalName(
497 NamedObjectType::TEXTURE, localTexName);
498 //if texture wasn't generated before,generate one
499 if(!globalTextureName){
500 ctx->shareGroup()->genName(NamedObjectType::TEXTURE, localTexName);
501 globalTextureName = ctx->shareGroup()->getGlobalName(
502 NamedObjectType::TEXTURE, localTexName);
503 }
504
505 TextureData* texData = getTextureData(localTexName);
506 if (texData->target==0)
507 texData->setTarget(target);
508 //if texture was already bound to another target
509 SET_ERROR_IF(ctx->GLTextureTargetToLocal(texData->target) != ctx->GLTextureTargetToLocal(target), GL_INVALID_OPERATION);
510 texData->setGlobalName(globalTextureName);
511 if (!texData->wasBound) {
512 texData->resetSaveableTexture();
513 }
514 texData->wasBound = true;
515 }
516
517 ctx->setBindedTexture(target, texture, globalTextureName);
518 ctx->dispatcher().glBindTexture(target, globalTextureName);
519 }
520
glBlendFunc(GLenum sfactor,GLenum dfactor)521 GL_API void GL_APIENTRY glBlendFunc( GLenum sfactor, GLenum dfactor) {
522 GET_CTX()
523 GLES_CM_TRACE()
524 SET_ERROR_IF(!GLEScmValidate::blendSrc(sfactor) || !GLEScmValidate::blendDst(dfactor),GL_INVALID_ENUM)
525 ctx->setBlendFuncSeparate(sfactor, dfactor, sfactor, dfactor);
526 ctx->dispatcher().glBlendFunc(sfactor,dfactor);
527 }
528
glBufferData(GLenum target,GLsizeiptr size,const GLvoid * data,GLenum usage)529 GL_API void GL_APIENTRY glBufferData( GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage) {
530 GET_CTX()
531 GLES_CM_TRACE()
532 SET_ERROR_IF(!GLEScmValidate::bufferTarget(target),GL_INVALID_ENUM);
533 SET_ERROR_IF(!ctx->isBindedBuffer(target),GL_INVALID_OPERATION);
534 ctx->setBufferData(target,size,data,usage);
535 ctx->dispatcher().glBufferData(target, size, data, usage);
536 }
537
glBufferSubData(GLenum target,GLintptr offset,GLsizeiptr size,const GLvoid * data)538 GL_API void GL_APIENTRY glBufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data) {
539 GET_CTX()
540 GLES_CM_TRACE()
541 SET_ERROR_IF(!ctx->isBindedBuffer(target),GL_INVALID_OPERATION);
542 SET_ERROR_IF(!GLEScmValidate::bufferTarget(target),GL_INVALID_ENUM);
543 SET_ERROR_IF(!ctx->setBufferSubData(target,offset,size,data),GL_INVALID_VALUE);
544 ctx->dispatcher().glBufferSubData(target, offset, size, data);
545 }
546
glClear(GLbitfield mask)547 GL_API void GL_APIENTRY glClear( GLbitfield mask) {
548 GET_CTX()
549 GLES_CM_TRACE()
550 ERRCHECK()
551 ctx->drawValidate();
552 ERRCHECK()
553 ctx->dispatcher().glClear(mask);
554 ERRCHECK()
555 }
556
glClearColor(GLclampf red,GLclampf green,GLclampf blue,GLclampf alpha)557 GL_API void GL_APIENTRY glClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
558 GET_CTX()
559 GLES_CM_TRACE()
560 ctx->setClearColor(red, green, blue, alpha);
561 ctx->dispatcher().glClearColor(red,green,blue,alpha);
562 }
563
glClearColorx(GLclampx red,GLclampx green,GLclampx blue,GLclampx alpha)564 GL_API void GL_APIENTRY glClearColorx( GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) {
565 GET_CTX()
566 GLES_CM_TRACE()
567 ctx->setClearColor(X2F(red),X2F(green),X2F(blue),X2F(alpha));
568 ctx->dispatcher().glClearColor(X2F(red),X2F(green),X2F(blue),X2F(alpha));
569 }
570
571
glClearDepthf(GLclampf depth)572 GL_API void GL_APIENTRY glClearDepthf( GLclampf depth) {
573 GET_CTX()
574 GLES_CM_TRACE()
575 ctx->setClearDepth(depth);
576 ctx->dispatcher().glClearDepth(depth);
577 }
578
glClearDepthx(GLclampx depth)579 GL_API void GL_APIENTRY glClearDepthx( GLclampx depth) {
580 GET_CTX()
581 GLES_CM_TRACE()
582 ctx->setClearDepth(X2F(depth));
583 ctx->dispatcher().glClearDepth(X2F(depth));
584 }
585
glClearStencil(GLint s)586 GL_API void GL_APIENTRY glClearStencil( GLint s) {
587 GET_CTX()
588 GLES_CM_TRACE()
589 ctx->setClearStencil(s);
590 ctx->dispatcher().glClearStencil(s);
591 }
592
glClientActiveTexture(GLenum texture)593 GL_API void GL_APIENTRY glClientActiveTexture( GLenum texture) {
594 GET_CTX_CM()
595 GLES_CM_TRACE()
596 SET_ERROR_IF(!GLEScmValidate::textureEnum(texture,ctx->getMaxTexUnits()),GL_INVALID_ENUM);
597 ctx->clientActiveTexture(texture);
598 }
599
glClipPlanef(GLenum plane,const GLfloat * equation)600 GL_API void GL_APIENTRY glClipPlanef( GLenum plane, const GLfloat *equation) {
601 GET_CTX()
602 GLES_CM_TRACE()
603 GLdouble tmpEquation[4];
604
605 for(int i = 0; i < 4; i++) {
606 tmpEquation[i] = static_cast<GLdouble>(equation[i]);
607 }
608 ctx->dispatcher().glClipPlane(plane,tmpEquation);
609 }
610
glClipPlanex(GLenum plane,const GLfixed * equation)611 GL_API void GL_APIENTRY glClipPlanex( GLenum plane, const GLfixed *equation) {
612 GET_CTX()
613 GLES_CM_TRACE()
614 GLdouble tmpEquation[4];
615 for(int i = 0; i < 4; i++) {
616 tmpEquation[i] = X2D(equation[i]);
617 }
618 ctx->dispatcher().glClipPlane(plane,tmpEquation);
619 }
620
glColor4f(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)621 GL_API void GL_APIENTRY glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
622 GET_CTX_CM()
623 GLES_CM_TRACE()
624 ctx->color4f(red, green, blue, alpha);
625 }
626
glColor4ub(GLubyte red,GLubyte green,GLubyte blue,GLubyte alpha)627 GL_API void GL_APIENTRY glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {
628 GET_CTX_CM()
629 GLES_CM_TRACE()
630 ctx->color4ub(red, green, blue, alpha);
631 }
632
glColor4x(GLfixed red,GLfixed green,GLfixed blue,GLfixed alpha)633 GL_API void GL_APIENTRY glColor4x( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) {
634 GET_CTX_CM()
635 GLES_CM_TRACE()
636 ctx->color4f(X2F(red),X2F(green),X2F(blue),X2F(alpha));
637 }
638
glColorMask(GLboolean red,GLboolean green,GLboolean blue,GLboolean alpha)639 GL_API void GL_APIENTRY glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
640 GET_CTX()
641 GLES_CM_TRACE()
642 ctx->setColorMask(red, green, blue, alpha);
643 ctx->dispatcher().glColorMask(red,green,blue,alpha);
644 }
645
glColorPointer(GLint size,GLenum type,GLsizei stride,const GLvoid * pointer)646 GL_API void GL_APIENTRY glColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
647 GET_CTX_CM()
648 GLES_CM_TRACE()
649 SET_ERROR_IF(!GLEScmValidate::colorPointerParams(size,stride),GL_INVALID_VALUE);
650 SET_ERROR_IF(!GLEScmValidate::colorPointerType(type),GL_INVALID_ENUM);
651 ctx->setPointer(GL_COLOR_ARRAY,size,type,stride,pointer, 0);
652 }
653
glColorPointerWithDataSize(GLint size,GLenum type,GLsizei stride,const GLvoid * pointer,GLsizei dataSize)654 GL_API void GL_APIENTRY glColorPointerWithDataSize( GLint size, GLenum type,
655 GLsizei stride, const GLvoid *pointer, GLsizei dataSize) {
656 GET_CTX_CM()
657 GLES_CM_TRACE()
658 SET_ERROR_IF(!GLEScmValidate::colorPointerParams(size,stride),GL_INVALID_VALUE);
659 SET_ERROR_IF(!GLEScmValidate::colorPointerType(type),GL_INVALID_ENUM);
660 ctx->setPointer(GL_COLOR_ARRAY,size,type,stride,pointer, dataSize);
661 }
662
maxMipmapLevel(GLsizei width,GLsizei height)663 static int maxMipmapLevel(GLsizei width, GLsizei height) {
664 // + 0.5 for potential floating point rounding issue
665 return log2(std::max(width, height) + 0.5);
666 }
667
s_glInitTexImage2D(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum * format,GLenum * type,GLint * internalformat_out,bool * needAutoMipmap)668 void s_glInitTexImage2D(GLenum target, GLint level, GLint internalformat,
669 GLsizei width, GLsizei height, GLint border, GLenum* format,
670 GLenum* type, GLint* internalformat_out,
671 bool* needAutoMipmap) {
672 GET_CTX();
673
674 if (ctx->shareGroup().get()) {
675 TextureData *texData = getTextureTargetData(target);
676
677 if (texData) {
678 texData->hasStorage = true;
679 if (needAutoMipmap) {
680 *needAutoMipmap = texData->requiresAutoMipmap;
681 }
682 if (texData->requiresAutoMipmap) {
683 texData->setMipmapLevelAtLeast(maxMipmapLevel(width, height));
684 } else {
685 texData->setMipmapLevelAtLeast(
686 static_cast<unsigned int>(level));
687 }
688 }
689
690 if (texData && level == 0) {
691 assert(texData->target == GL_TEXTURE_2D ||
692 texData->target == GL_TEXTURE_CUBE_MAP);
693 texData->internalFormat = internalformat;
694 if (internalformat_out) {
695 *internalformat_out = texData->internalFormat;
696 }
697 texData->width = width;
698 texData->height = height;
699 texData->border = border;
700 if (format) texData->format = *format;
701 if (type) texData->type = *type;
702
703 if (texData->sourceEGLImage != 0) {
704 //
705 // This texture was a target of EGLImage,
706 // but now it is re-defined so we need to
707 // re-generate global texture name for it.
708 //
709 unsigned int tex = ctx->getBindedTexture(target);
710 ctx->shareGroup()->genName(NamedObjectType::TEXTURE, tex,
711 false);
712 unsigned int globalTextureName =
713 ctx->shareGroup()->getGlobalName(
714 NamedObjectType::TEXTURE, tex);
715 ctx->dispatcher().glBindTexture(GL_TEXTURE_2D,
716 globalTextureName);
717 texData->sourceEGLImage = 0;
718 texData->setGlobalName(globalTextureName);
719 }
720 texData->resetSaveableTexture();
721 }
722 texData->makeDirty();
723 }
724 }
725
726 GL_API void GL_APIENTRY glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
727
glCompressedTexImage2D(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const GLvoid * data)728 GL_API void GL_APIENTRY glCompressedTexImage2D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) {
729 GET_CTX_CM()
730 GLES_CM_TRACE()
731 SET_ERROR_IF(!GLEScmValidate::textureTargetEx(target),GL_INVALID_ENUM);
732 SET_ERROR_IF(!data,GL_INVALID_OPERATION);
733
734 if (shouldPassthroughCompressedFormat(ctx, internalformat)) {
735 doCompressedTexImage2DNative(ctx, target, level, internalformat, width,
736 height, border, imageSize, data);
737 } else {
738 doCompressedTexImage2D(ctx, target, level, internalformat,
739 width, height, border,
740 imageSize, data, glTexImage2D);
741 }
742
743 TextureData* texData = getTextureTargetData(target);
744 if (texData) {
745 texData->compressed = true;
746 texData->compressedFormat = internalformat;
747 if (shouldPassthroughCompressedFormat(ctx, internalformat)) {
748 texData->internalFormat = internalformat;
749 }
750 }
751 }
752
glCompressedTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const GLvoid * data)753 GL_API void GL_APIENTRY glCompressedTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) {
754 GET_CTX_CM()
755 GLES_CM_TRACE()
756 SET_ERROR_IF(!(GLEScmValidate::texCompImgFrmt(format) && GLEScmValidate::textureTargetEx(target)),GL_INVALID_ENUM);
757 SET_ERROR_IF(level < 0 || level > log2(ctx->getMaxTexSize()),GL_INVALID_VALUE)
758 SET_ERROR_IF(!data,GL_INVALID_OPERATION);
759
760 if (shouldPassthroughCompressedFormat(ctx, format)) {
761 doCompressedTexSubImage2DNative(ctx, target, level, xoffset, yoffset, width,
762 height, format, imageSize, data);
763 } else {
764 GLenum uncompressedFrmt;
765 unsigned char* uncompressed = uncompressTexture(format,uncompressedFrmt,width,height,imageSize,data,level);
766 ctx->dispatcher().glTexSubImage2D(target,level,xoffset,yoffset,width,height,uncompressedFrmt,GL_UNSIGNED_BYTE,uncompressed);
767 delete uncompressed;
768 }
769
770 TextureData* texData = getTextureTargetData(target);
771 if (texData) {
772 texData->setMipmapLevelAtLeast(level);
773 texData->makeDirty();
774 }
775 }
776
glCopyTexImage2D(GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height,GLint border)777 GL_API void GL_APIENTRY glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {
778 GET_CTX()
779 GLES_CM_TRACE()
780 SET_ERROR_IF(!(GLEScmValidate::pixelFrmt(ctx,internalformat)
781 && GLEScmValidate::textureTargetEx(target)),GL_INVALID_ENUM);
782 SET_ERROR_IF(border != 0,GL_INVALID_VALUE);
783
784 GLenum format = baseFormatOfInternalFormat((GLint)internalformat);
785 GLenum type = accurateTypeOfInternalFormat((GLint)internalformat);
786 s_glInitTexImage2D(
787 target, level, internalformat, width, height, border,
788 &format, &type, (GLint*)&internalformat, nullptr);
789
790 TextureData* texData = getTextureTargetData(target);
791 if (texData && isCoreProfile() &&
792 isCoreProfileEmulatedFormat(texData->format)) {
793 GLEScontext::prepareCoreProfileEmulatedTexture(
794 getTextureTargetData(target),
795 false, target, format, type,
796 (GLint*)&internalformat, &format);
797 ctx->copyTexImageWithEmulation(
798 texData, false, target, level, internalformat,
799 0, 0, x, y, width, height, border);
800 } else {
801 ctx->dispatcher().glCopyTexImage2D(
802 target, level, internalformat,
803 x, y, width, height, border);
804 }
805 }
806
glCopyTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height)807 GL_API void GL_APIENTRY glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
808 GET_CTX()
809 GLES_CM_TRACE()
810 SET_ERROR_IF(!GLEScmValidate::textureTargetEx(target),GL_INVALID_ENUM);
811 if (ctx->shareGroup().get()){
812 TextureData *texData = getTextureTargetData(target);
813 SET_ERROR_IF(!texData, GL_INVALID_OPERATION);
814 texData->makeDirty();
815 }
816 ctx->dispatcher().glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height);
817 }
818
glCullFace(GLenum mode)819 GL_API void GL_APIENTRY glCullFace( GLenum mode) {
820 GET_CTX()
821 GLES_CM_TRACE()
822 ctx->setCullFace(mode);
823 ctx->dispatcher().glCullFace(mode);
824 }
825
glDeleteBuffers(GLsizei n,const GLuint * buffers)826 GL_API void GL_APIENTRY glDeleteBuffers( GLsizei n, const GLuint *buffers) {
827 GET_CTX()
828 GLES_CM_TRACE()
829 SET_ERROR_IF(n<0,GL_INVALID_VALUE);
830 if(ctx->shareGroup().get()) {
831 for(int i=0; i < n; i++){
832 ctx->shareGroup()->deleteName(NamedObjectType::VERTEXBUFFER,
833 buffers[i]);
834 ctx->unbindBuffer(buffers[i]);
835 }
836 }
837 }
838
glDeleteTextures(GLsizei n,const GLuint * textures)839 GL_API void GL_APIENTRY glDeleteTextures( GLsizei n, const GLuint *textures) {
840 GET_CTX()
841 GLES_CM_TRACE()
842 SET_ERROR_IF(n<0,GL_INVALID_VALUE);
843 if(ctx->shareGroup().get()) {
844 for(int i=0; i < n; i++){
845 if(textures[i] != 0)
846 {
847 if(ctx->getBindedTexture(GL_TEXTURE_2D) == textures[i])
848 ctx->setBindedTexture(GL_TEXTURE_2D,0);
849 if (ctx->getBindedTexture(GL_TEXTURE_CUBE_MAP) == textures[i])
850 ctx->setBindedTexture(GL_TEXTURE_CUBE_MAP,0);
851 ctx->shareGroup()->deleteName(NamedObjectType::TEXTURE,
852 textures[i]);
853 }
854 }
855 }
856 }
857
glDepthFunc(GLenum func)858 GL_API void GL_APIENTRY glDepthFunc( GLenum func) {
859 GET_CTX()
860 GLES_CM_TRACE()
861 ctx->setDepthFunc(func);
862 ctx->dispatcher().glDepthFunc(func);
863 }
864
glDepthMask(GLboolean flag)865 GL_API void GL_APIENTRY glDepthMask( GLboolean flag) {
866 GET_CTX()
867 GLES_CM_TRACE()
868 ctx->setDepthMask(flag);
869 ctx->dispatcher().glDepthMask(flag);
870 }
871
glDepthRangef(GLclampf zNear,GLclampf zFar)872 GL_API void GL_APIENTRY glDepthRangef( GLclampf zNear, GLclampf zFar) {
873 GET_CTX()
874 GLES_CM_TRACE()
875 ctx->setDepthRangef(zNear, zFar);
876 ctx->dispatcher().glDepthRange(zNear,zFar);
877 }
878
glDepthRangex(GLclampx zNear,GLclampx zFar)879 GL_API void GL_APIENTRY glDepthRangex( GLclampx zNear, GLclampx zFar) {
880 GET_CTX()
881 GLES_CM_TRACE()
882 ctx->setDepthRangef(X2F(zNear),X2F(zFar));
883 ctx->dispatcher().glDepthRange(X2F(zNear),X2F(zFar));
884 }
885
glDisable(GLenum cap)886 GL_API void GL_APIENTRY glDisable( GLenum cap) {
887 GET_CTX_CM()
888 GLES_CM_TRACE()
889 ctx->disable(cap);
890 }
891
glDisableClientState(GLenum array)892 GL_API void GL_APIENTRY glDisableClientState( GLenum array) {
893 GET_CTX_CM()
894 GLES_CM_TRACE()
895 SET_ERROR_IF(!GLEScmValidate::supportedArrays(array),GL_INVALID_ENUM)
896
897 ctx->enableArr(array,false);
898
899 if(array != GL_POINT_SIZE_ARRAY_OES) ctx->disableClientState(array);
900 }
901
902
glDrawArrays(GLenum mode,GLint first,GLsizei count)903 GL_API void GL_APIENTRY glDrawArrays( GLenum mode, GLint first, GLsizei count) {
904 GET_CTX_CM()
905 GLES_CM_TRACE()
906 SET_ERROR_IF(count < 0,GL_INVALID_VALUE)
907 SET_ERROR_IF(!GLEScmValidate::drawMode(mode),GL_INVALID_ENUM)
908
909 ctx->drawArrays(mode, first, count);
910 }
911
glDrawElements(GLenum mode,GLsizei count,GLenum type,const GLvoid * elementsIndices)912 GL_API void GL_APIENTRY glDrawElements( GLenum mode, GLsizei count, GLenum type, const GLvoid *elementsIndices) {
913 GET_CTX_CM()
914 GLES_CM_TRACE()
915 SET_ERROR_IF(count < 0,GL_INVALID_VALUE)
916 SET_ERROR_IF((!GLEScmValidate::drawMode(mode) || !GLEScmValidate::drawType(type)),GL_INVALID_ENUM)
917
918 ctx->drawElements(mode, count, type, elementsIndices);
919 }
920
glEnable(GLenum cap)921 GL_API void GL_APIENTRY glEnable( GLenum cap) {
922 GET_CTX_CM()
923 GLES_CM_TRACE()
924 ctx->enable(cap);
925 }
926
glEnableClientState(GLenum array)927 GL_API void GL_APIENTRY glEnableClientState( GLenum array) {
928 GET_CTX_CM()
929 GLES_CM_TRACE()
930 SET_ERROR_IF(!GLEScmValidate::supportedArrays(array),GL_INVALID_ENUM)
931
932 ctx->enableArr(array,true);
933 if(array != GL_POINT_SIZE_ARRAY_OES) {
934 ctx->enableClientState(array);
935 }
936 }
937
glFinish(void)938 GL_API void GL_APIENTRY glFinish( void) {
939 GET_CTX()
940 GLES_CM_TRACE()
941 ctx->dispatcher().glFinish();
942 }
943
glFlush(void)944 GL_API void GL_APIENTRY glFlush( void) {
945 GET_CTX()
946 GLES_CM_TRACE()
947 ctx->dispatcher().glFlush();
948 }
949
glFogf(GLenum pname,GLfloat param)950 GL_API void GL_APIENTRY glFogf( GLenum pname, GLfloat param) {
951 GET_CTX_CM()
952 GLES_CM_TRACE()
953 ctx->fogf(pname,param);
954 }
955
glFogfv(GLenum pname,const GLfloat * params)956 GL_API void GL_APIENTRY glFogfv( GLenum pname, const GLfloat *params) {
957 GET_CTX_CM()
958 GLES_CM_TRACE()
959 ctx->fogfv(pname,params);
960 }
961
glFogx(GLenum pname,GLfixed param)962 GL_API void GL_APIENTRY glFogx( GLenum pname, GLfixed param) {
963 GET_CTX_CM()
964 GLES_CM_TRACE()
965 ctx->fogf(pname,(pname == GL_FOG_MODE)? static_cast<GLfloat>(param):X2F(param));
966 }
967
glFogxv(GLenum pname,const GLfixed * params)968 GL_API void GL_APIENTRY glFogxv( GLenum pname, const GLfixed *params) {
969 GET_CTX_CM()
970 GLES_CM_TRACE()
971 if(pname == GL_FOG_MODE) {
972 GLfloat tmpParam = static_cast<GLfloat>(params[0]);
973 ctx->fogfv(pname,&tmpParam);
974 } else {
975 GLfloat tmpParams[4];
976 for(int i=0; i< 4; i++) {
977 tmpParams[i] = X2F(params[i]);
978 }
979 ctx->fogfv(pname,tmpParams);
980 }
981
982 }
983
glFrontFace(GLenum mode)984 GL_API void GL_APIENTRY glFrontFace( GLenum mode) {
985 GET_CTX()
986 GLES_CM_TRACE()
987 ctx->setFrontFace(mode);
988 ctx->dispatcher().glFrontFace(mode);
989 }
990
glFrustumf(GLfloat left,GLfloat right,GLfloat bottom,GLfloat top,GLfloat zNear,GLfloat zFar)991 GL_API void GL_APIENTRY glFrustumf( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) {
992 GET_CTX_CM()
993 GLES_CM_TRACE()
994 ctx->frustumf(left, right, bottom, top, zNear,zFar);
995 ERRCHECK()
996 }
997
glFrustumx(GLfixed left,GLfixed right,GLfixed bottom,GLfixed top,GLfixed zNear,GLfixed zFar)998 GL_API void GL_APIENTRY glFrustumx( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) {
999 GET_CTX_CM()
1000 GLES_CM_TRACE()
1001 ctx->frustumf(X2F(left),X2F(right),X2F(bottom),X2F(top),X2F(zNear),X2F(zFar));
1002 }
1003
glGenBuffers(GLsizei n,GLuint * buffers)1004 GL_API void GL_APIENTRY glGenBuffers( GLsizei n, GLuint *buffers) {
1005 GET_CTX()
1006 GLES_CM_TRACE()
1007 SET_ERROR_IF(n<0,GL_INVALID_VALUE);
1008 if(ctx->shareGroup().get()) {
1009 for(int i=0; i<n ;i++) {
1010 buffers[i] = ctx->shareGroup()->genName(
1011 NamedObjectType::VERTEXBUFFER, 0, true);
1012 //generating vbo object related to this buffer name
1013 ctx->shareGroup()->setObjectData(NamedObjectType::VERTEXBUFFER,
1014 buffers[i],
1015 ObjectDataPtr(new GLESbuffer()));
1016 }
1017 }
1018 }
1019
glGenTextures(GLsizei n,GLuint * textures)1020 GL_API void GL_APIENTRY glGenTextures( GLsizei n, GLuint *textures) {
1021 GET_CTX();
1022 GLES_CM_TRACE()
1023 if(ctx->shareGroup().get()) {
1024 for(int i=0; i<n ;i++) {
1025 textures[i] = ctx->shareGroup()->genName(NamedObjectType::TEXTURE,
1026 0, true);
1027 }
1028 }
1029 }
1030
1031 GL_API void GL_APIENTRY glGetIntegerv( GLenum pname, GLint *params);
1032
glGetBooleanv(GLenum pname,GLboolean * params)1033 GL_API void GL_APIENTRY glGetBooleanv( GLenum pname, GLboolean *params) {
1034 GET_CTX()
1035 GLES_CM_TRACE()
1036
1037 #define TO_GLBOOL(params, x) \
1038 *params = x ? GL_TRUE : GL_FALSE; \
1039
1040 if(ctx->glGetBooleanv(pname, params))
1041 {
1042 return;
1043 }
1044
1045 switch(pname)
1046 {
1047 case GL_FRAMEBUFFER_BINDING_OES:
1048 case GL_RENDERBUFFER_BINDING_OES:
1049 {
1050 GLint name;
1051 glGetIntegerv(pname,&name);
1052 *params = name!=0 ? GL_TRUE: GL_FALSE;
1053 }
1054 break;
1055 case GL_TEXTURE_GEN_STR_OES:
1056 {
1057 GLboolean state_s = GL_FALSE;
1058 GLboolean state_t = GL_FALSE;
1059 GLboolean state_r = GL_FALSE;
1060 ctx->dispatcher().glGetBooleanv(GL_TEXTURE_GEN_S,&state_s);
1061 ctx->dispatcher().glGetBooleanv(GL_TEXTURE_GEN_T,&state_t);
1062 ctx->dispatcher().glGetBooleanv(GL_TEXTURE_GEN_R,&state_r);
1063 *params = state_s && state_t && state_r ? GL_TRUE: GL_FALSE;
1064 }
1065 break;
1066 case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
1067 *params = (GLboolean)getCompressedFormats(1, NULL);
1068 break;
1069 case GL_COMPRESSED_TEXTURE_FORMATS:
1070 {
1071 int nparams = getCompressedFormats(1, NULL);
1072 if (nparams>0) {
1073 int * iparams = new int[nparams];
1074 getCompressedFormats(1, iparams);
1075 for (int i=0; i<nparams; i++) params[i] = (GLboolean)iparams[i];
1076 delete [] iparams;
1077 }
1078 }
1079 break;
1080 case GL_GENERATE_MIPMAP_HINT:
1081 if (isCoreProfile()) {
1082 TO_GLBOOL(params, ctx->getHint(GL_GENERATE_MIPMAP_HINT));
1083 } else {
1084 ctx->dispatcher().glGetBooleanv(pname,params);
1085 }
1086 break;
1087 case GL_RED_BITS:
1088 case GL_GREEN_BITS:
1089 case GL_BLUE_BITS:
1090 case GL_ALPHA_BITS:
1091 case GL_DEPTH_BITS:
1092 case GL_STENCIL_BITS:
1093 if (isCoreProfile()) {
1094 GLuint fboBinding = ctx->getFramebufferBinding(GL_DRAW_FRAMEBUFFER);
1095 TO_GLBOOL(params, ctx->queryCurrFboBits(fboBinding, pname));
1096 } else {
1097 ctx->dispatcher().glGetBooleanv(pname,params);
1098 }
1099 break;
1100 default:
1101 ctx->dispatcher().glGetBooleanv(pname,params);
1102 }
1103 }
1104
glGetBufferParameteriv(GLenum target,GLenum pname,GLint * params)1105 GL_API void GL_APIENTRY glGetBufferParameteriv( GLenum target, GLenum pname, GLint *params) {
1106 GET_CTX()
1107 GLES_CM_TRACE()
1108 SET_ERROR_IF(!(GLEScmValidate::bufferTarget(target) && GLEScmValidate::bufferParam(pname)),GL_INVALID_ENUM);
1109 SET_ERROR_IF(!ctx->isBindedBuffer(target),GL_INVALID_OPERATION);
1110 switch(pname) {
1111 case GL_BUFFER_SIZE:
1112 ctx->getBufferSize(target,params);
1113 break;
1114 case GL_BUFFER_USAGE:
1115 ctx->getBufferUsage(target,params);
1116 break;
1117 }
1118
1119 }
1120
glGetClipPlanef(GLenum pname,GLfloat eqn[4])1121 GL_API void GL_APIENTRY glGetClipPlanef( GLenum pname, GLfloat eqn[4]) {
1122 GET_CTX()
1123 GLES_CM_TRACE()
1124 GLdouble tmpEqn[4];
1125
1126 ctx->dispatcher().glGetClipPlane(pname,tmpEqn);
1127 for(int i =0 ;i < 4; i++){
1128 eqn[i] = static_cast<GLfloat>(tmpEqn[i]);
1129 }
1130 }
1131
glGetClipPlanex(GLenum pname,GLfixed eqn[4])1132 GL_API void GL_APIENTRY glGetClipPlanex( GLenum pname, GLfixed eqn[4]) {
1133 GET_CTX()
1134 GLES_CM_TRACE()
1135 GLdouble tmpEqn[4];
1136
1137 ctx->dispatcher().glGetClipPlane(pname,tmpEqn);
1138 for(int i =0 ;i < 4; i++){
1139 eqn[i] = F2X(tmpEqn[i]);
1140 }
1141 }
1142
1143 GL_API void GL_APIENTRY glGetFloatv( GLenum pname, GLfloat *params);
1144
glGetFixedv(GLenum pname,GLfixed * params)1145 GL_API void GL_APIENTRY glGetFixedv( GLenum pname, GLfixed *params) {
1146 GET_CTX()
1147 GLES_CM_TRACE()
1148
1149 if(ctx->glGetFixedv(pname, params))
1150 {
1151 return;
1152 }
1153
1154 size_t nParams = glParamSize(pname);
1155 GLfloat fParams[16];
1156
1157 switch(pname)
1158 {
1159 case GL_FRAMEBUFFER_BINDING_OES:
1160 case GL_RENDERBUFFER_BINDING_OES:
1161 case GL_TEXTURE_GEN_STR_OES:
1162 glGetFloatv(pname,&fParams[0]);
1163 break;
1164 case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
1165 *params = I2X(getCompressedFormats(1, NULL));
1166 return;
1167 break;
1168 case GL_COMPRESSED_TEXTURE_FORMATS:
1169 {
1170 int nparams = getCompressedFormats(1, NULL);
1171 if (nparams>0) {
1172 int * iparams = new int[nparams];
1173 getCompressedFormats(1, iparams);
1174 for (int i=0; i<nparams; i++) params[i] = I2X(iparams[i]);
1175 delete [] iparams;
1176 }
1177 return;
1178 }
1179 break;
1180 default:
1181 ctx->dispatcher().glGetFloatv(pname,fParams);
1182 }
1183
1184 if (nParams)
1185 {
1186 for(size_t i =0 ; i < nParams;i++) {
1187 params[i] = F2X(fParams[i]);
1188 }
1189 }
1190 }
1191
glGetFloatv(GLenum pname,GLfloat * params)1192 GL_API void GL_APIENTRY glGetFloatv( GLenum pname, GLfloat *params) {
1193 GET_CTX()
1194 GLES_CM_TRACE()
1195
1196 if(ctx->glGetFloatv(pname, params))
1197 {
1198 return;
1199 }
1200
1201 GLint i;
1202
1203 switch (pname) {
1204 case GL_FRAMEBUFFER_BINDING_OES:
1205 case GL_RENDERBUFFER_BINDING_OES:
1206 case GL_TEXTURE_GEN_STR_OES:
1207 glGetIntegerv(pname,&i);
1208 *params = (GLfloat)i;
1209 break;
1210 case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
1211 *params = (GLfloat)getCompressedFormats(1, NULL);
1212 break;
1213 case GL_COMPRESSED_TEXTURE_FORMATS:
1214 {
1215 int nparams = getCompressedFormats(1, NULL);
1216 if (nparams>0) {
1217 int * iparams = new int[nparams];
1218 getCompressedFormats(1, iparams);
1219 for (int i=0; i<nparams; i++) params[i] = (GLfloat)iparams[i];
1220 delete [] iparams;
1221 }
1222 }
1223 break;
1224 default:
1225 ctx->dispatcher().glGetFloatv(pname,params);
1226 }
1227 }
1228
glGetIntegerv(GLenum pname,GLint * params)1229 GL_API void GL_APIENTRY glGetIntegerv( GLenum pname, GLint *params) {
1230 GET_CTX()
1231 GLES_CM_TRACE()
1232
1233 if(ctx->glGetIntegerv(pname, params))
1234 {
1235 return;
1236 }
1237
1238 GLint i;
1239 GLfloat f;
1240
1241 switch(pname)
1242 {
1243 case GL_READ_BUFFER:
1244 case GL_DRAW_BUFFER0:
1245 if (ctx->shareGroup().get()) {
1246 ctx->dispatcher().glGetIntegerv(pname, &i);
1247 GLenum target = pname == GL_READ_BUFFER ? GL_READ_FRAMEBUFFER : GL_DRAW_FRAMEBUFFER;
1248 if (ctx->isDefaultFBOBound(target) && (GLint)i == GL_COLOR_ATTACHMENT0) {
1249 i = GL_BACK;
1250 }
1251 *params = i;
1252 }
1253 break;
1254 case GL_TEXTURE_GEN_STR_OES:
1255 ctx->dispatcher().glGetIntegerv(GL_TEXTURE_GEN_S,¶ms[0]);
1256 break;
1257 case GL_FRAMEBUFFER_BINDING_OES:
1258 ctx->dispatcher().glGetIntegerv(pname,&i);
1259 *params = ctx->getFBOLocalName(i);
1260 break;
1261 case GL_RENDERBUFFER_BINDING_OES:
1262 if (ctx->shareGroup().get()) {
1263 ctx->dispatcher().glGetIntegerv(pname,&i);
1264 *params = ctx->shareGroup()->getLocalName(
1265 NamedObjectType::RENDERBUFFER, i);
1266 }
1267 break;
1268 case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
1269 *params = getCompressedFormats(1, NULL);
1270 break;
1271 case GL_COMPRESSED_TEXTURE_FORMATS:
1272 getCompressedFormats(1, params);
1273 break;
1274 case GL_MAX_CLIP_PLANES:
1275 ctx->dispatcher().glGetIntegerv(pname,params);
1276 if(*params > 6)
1277 {
1278 // GLES spec requires only 6, and the ATI driver erronously
1279 // returns 8 (although it supports only 6). This WAR is simple,
1280 // compliant and good enough for developers.
1281 *params = 6;
1282 }
1283 break;
1284 case GL_ALPHA_TEST_REF:
1285 // Both the ATI and nVidia OpenGL drivers return the wrong answer
1286 // here. So return the right one.
1287 ctx->dispatcher().glGetFloatv(pname,&f);
1288 *params = (int)(f * (float)0x7fffffff);
1289 break;
1290 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
1291 ctx->dispatcher().glGetIntegerv(pname,params);
1292 if(*params > 16)
1293 {
1294 // GLES spec requires only 2, and the ATI driver erronously
1295 // returns 32 (although it supports only 16). This WAR is simple,
1296 // compliant and good enough for developers.
1297 *params = 16;
1298 }
1299 break;
1300 case GL_GENERATE_MIPMAP_HINT:
1301 if (isCoreProfile()) {
1302 *params = ctx->getHint(GL_GENERATE_MIPMAP_HINT);
1303 } else {
1304 ctx->dispatcher().glGetIntegerv(pname,params);
1305 }
1306 break;
1307 case GL_RED_BITS:
1308 case GL_GREEN_BITS:
1309 case GL_BLUE_BITS:
1310 case GL_ALPHA_BITS:
1311 case GL_DEPTH_BITS:
1312 case GL_STENCIL_BITS:
1313 if (isCoreProfile()) {
1314 GLuint fboBinding = ctx->getFramebufferBinding(GL_DRAW_FRAMEBUFFER);
1315 *params = ctx->queryCurrFboBits(fboBinding, pname);
1316 } else {
1317 ctx->dispatcher().glGetIntegerv(pname,params);
1318 }
1319 break;
1320
1321 default:
1322 ctx->dispatcher().glGetIntegerv(pname,params);
1323 }
1324 }
1325
glGetLightfv(GLenum light,GLenum pname,GLfloat * params)1326 GL_API void GL_APIENTRY glGetLightfv( GLenum light, GLenum pname, GLfloat *params) {
1327 GET_CTX_CM()
1328 GLES_CM_TRACE()
1329 ctx->getLightfv(light,pname,params);
1330 }
1331
glGetLightxv(GLenum light,GLenum pname,GLfixed * params)1332 GL_API void GL_APIENTRY glGetLightxv( GLenum light, GLenum pname, GLfixed *params) {
1333 GET_CTX_CM()
1334 GLES_CM_TRACE()
1335 GLfloat tmpParams[4];
1336
1337 ctx->getLightfv(light,pname,tmpParams);
1338 switch (pname){
1339 case GL_AMBIENT:
1340 case GL_DIFFUSE:
1341 case GL_SPECULAR:
1342 case GL_POSITION:
1343 params[3] = F2X(tmpParams[3]);
1344 case GL_SPOT_DIRECTION:
1345 params[2] = F2X(tmpParams[2]);
1346 case GL_SPOT_EXPONENT:
1347 case GL_SPOT_CUTOFF:
1348 case GL_CONSTANT_ATTENUATION:
1349 case GL_LINEAR_ATTENUATION:
1350 case GL_QUADRATIC_ATTENUATION:
1351 params[1] = F2X(tmpParams[1]);
1352 break;
1353 default:{
1354 ctx->setGLerror(GL_INVALID_ENUM);
1355 return;
1356 }
1357
1358 }
1359 params[0] = F2X(tmpParams[0]);
1360 }
1361
glGetMaterialfv(GLenum face,GLenum pname,GLfloat * params)1362 GL_API void GL_APIENTRY glGetMaterialfv( GLenum face, GLenum pname, GLfloat *params) {
1363 GET_CTX_CM()
1364 GLES_CM_TRACE()
1365 ctx->getMaterialfv(face,pname,params);
1366 }
1367
glGetMaterialxv(GLenum face,GLenum pname,GLfixed * params)1368 GL_API void GL_APIENTRY glGetMaterialxv( GLenum face, GLenum pname, GLfixed *params) {
1369 GET_CTX_CM()
1370 GLES_CM_TRACE()
1371 GLfloat tmpParams[4];
1372 ctx->getMaterialfv(face,pname,tmpParams);
1373 switch(pname){
1374 case GL_AMBIENT:
1375 case GL_DIFFUSE:
1376 case GL_SPECULAR:
1377 case GL_EMISSION:
1378 case GL_AMBIENT_AND_DIFFUSE:
1379 params[3] = tmpParams[3];
1380 params[2] = tmpParams[2];
1381 params[1] = tmpParams[1];
1382 case GL_SHININESS:
1383 params[0] = tmpParams[0];
1384 break;
1385 default:{
1386 ctx->setGLerror(GL_INVALID_ENUM);
1387 return;
1388 }
1389 }
1390 }
1391
glGetPointerv(GLenum pname,void ** params)1392 GL_API void GL_APIENTRY glGetPointerv( GLenum pname, void **params) {
1393 GET_CTX()
1394 GLES_CM_TRACE()
1395 const GLESpointer* p = ctx->getPointer(pname);
1396 if(p) {
1397 if (p->getAttribType() == GLESpointer::BUFFER) {
1398 *params = SafePointerFromUInt(p->getBufferOffset());
1399 } else if (p->getAttribType() == GLESpointer::ARRAY) {
1400 *params = const_cast<void *>(p->getArrayData());
1401 }
1402 } else {
1403 ctx->setGLerror(GL_INVALID_ENUM);
1404 }
1405
1406 }
1407
glGetTexEnvfv(GLenum env,GLenum pname,GLfloat * params)1408 GL_API void GL_APIENTRY glGetTexEnvfv( GLenum env, GLenum pname, GLfloat *params) {
1409 GET_CTX_CM()
1410 GLES_CM_TRACE()
1411
1412 ctx->getTexEnvfv(env, pname, params);
1413 }
1414
glGetTexEnviv(GLenum env,GLenum pname,GLint * params)1415 GL_API void GL_APIENTRY glGetTexEnviv( GLenum env, GLenum pname, GLint *params) {
1416 GET_CTX_CM()
1417 GLES_CM_TRACE()
1418
1419 ctx->getTexEnviv(env, pname, params);
1420 }
1421
glGetTexEnvxv(GLenum env,GLenum pname,GLfixed * params)1422 GL_API void GL_APIENTRY glGetTexEnvxv( GLenum env, GLenum pname, GLfixed *params) {
1423 GET_CTX_CM()
1424 GLES_CM_TRACE()
1425 GLfloat tmpParams[4];
1426
1427 ctx->getTexEnvfv(env, pname, tmpParams);
1428
1429 if(pname == GL_TEXTURE_ENV_MODE) {
1430 params[0] = static_cast<GLfixed>(tmpParams[0]);
1431 } else {
1432 for(int i=0 ; i < 4 ; i++)
1433 params[i] = F2X(tmpParams[i]);
1434 }
1435 }
1436
glGetTexParameterfv(GLenum target,GLenum pname,GLfloat * params)1437 GL_API void GL_APIENTRY glGetTexParameterfv( GLenum target, GLenum pname, GLfloat *params) {
1438 GET_CTX()
1439 GLES_CM_TRACE()
1440 if (pname==GL_TEXTURE_CROP_RECT_OES) {
1441 TextureData *texData = getTextureTargetData(target);
1442 SET_ERROR_IF(texData==NULL,GL_INVALID_OPERATION);
1443 for (int i=0;i<4;++i)
1444 params[i] = texData->crop_rect[i];
1445 }
1446 else {
1447 ctx->dispatcher().glGetTexParameterfv(target,pname,params);
1448 }
1449 }
1450
glGetTexParameteriv(GLenum target,GLenum pname,GLint * params)1451 GL_API void GL_APIENTRY glGetTexParameteriv( GLenum target, GLenum pname, GLint *params) {
1452 GET_CTX()
1453 GLES_CM_TRACE()
1454 if (pname==GL_TEXTURE_CROP_RECT_OES) {
1455 TextureData *texData = getTextureTargetData(target);
1456 SET_ERROR_IF(texData==NULL,GL_INVALID_OPERATION);
1457 for (int i=0;i<4;++i)
1458 params[i] = texData->crop_rect[i];
1459 }
1460 else {
1461 ctx->dispatcher().glGetTexParameteriv(target,pname,params);
1462 }
1463 }
1464
glGetTexParameterxv(GLenum target,GLenum pname,GLfixed * params)1465 GL_API void GL_APIENTRY glGetTexParameterxv( GLenum target, GLenum pname, GLfixed *params) {
1466 GET_CTX()
1467 GLES_CM_TRACE()
1468 if (pname==GL_TEXTURE_CROP_RECT_OES) {
1469 TextureData *texData = getTextureTargetData(target);
1470 SET_ERROR_IF(texData==NULL,GL_INVALID_OPERATION);
1471 for (int i=0;i<4;++i)
1472 params[i] = F2X(texData->crop_rect[i]);
1473 }
1474 else {
1475 GLfloat tmpParam;
1476 ctx->dispatcher().glGetTexParameterfv(target,pname,&tmpParam);
1477 params[0] = static_cast<GLfixed>(tmpParam);
1478 }
1479 }
1480
glHint(GLenum target,GLenum mode)1481 GL_API void GL_APIENTRY glHint( GLenum target, GLenum mode) {
1482 GET_CTX()
1483 GLES_CM_TRACE()
1484 SET_ERROR_IF(!GLEScmValidate::hintTargetMode(target,mode),GL_INVALID_ENUM);
1485
1486 // No GLES1 hints are supported.
1487 if (isGles2Gles() || isCoreProfile()) {
1488 ctx->setHint(target, mode);
1489 } else {
1490 ctx->dispatcher().glHint(target,mode);
1491 }
1492 }
1493
glLightModelf(GLenum pname,GLfloat param)1494 GL_API void GL_APIENTRY glLightModelf( GLenum pname, GLfloat param) {
1495 GET_CTX_CM()
1496 GLES_CM_TRACE()
1497 ctx->lightModelf(pname,param);
1498 }
1499
glLightModelfv(GLenum pname,const GLfloat * params)1500 GL_API void GL_APIENTRY glLightModelfv( GLenum pname, const GLfloat *params) {
1501 GET_CTX_CM()
1502 GLES_CM_TRACE()
1503
1504 ctx->lightModelfv(pname,params);
1505 }
1506
glLightModelx(GLenum pname,GLfixed param)1507 GL_API void GL_APIENTRY glLightModelx( GLenum pname, GLfixed param) {
1508 GET_CTX_CM()
1509 GLES_CM_TRACE()
1510 GLfloat tmpParam = static_cast<GLfloat>(param);
1511 ctx->lightModelf(pname,tmpParam);
1512 }
1513
glLightModelxv(GLenum pname,const GLfixed * params)1514 GL_API void GL_APIENTRY glLightModelxv( GLenum pname, const GLfixed *params) {
1515 GET_CTX_CM()
1516 GLES_CM_TRACE()
1517 GLfloat tmpParams[4];
1518 if(pname == GL_LIGHT_MODEL_TWO_SIDE) {
1519 tmpParams[0] = X2F(params[0]);
1520 } else if (pname == GL_LIGHT_MODEL_AMBIENT) {
1521 for(int i=0;i<4;i++) {
1522 tmpParams[i] = X2F(params[i]);
1523 }
1524 }
1525
1526 ctx->lightModelfv(pname,tmpParams);
1527 }
1528
glLightf(GLenum light,GLenum pname,GLfloat param)1529 GL_API void GL_APIENTRY glLightf( GLenum light, GLenum pname, GLfloat param) {
1530 GET_CTX_CM()
1531 GLES_CM_TRACE()
1532 ctx->lightf(light,pname,param);
1533 }
1534
glLightfv(GLenum light,GLenum pname,const GLfloat * params)1535 GL_API void GL_APIENTRY glLightfv( GLenum light, GLenum pname, const GLfloat *params) {
1536 GET_CTX_CM()
1537 GLES_CM_TRACE()
1538 ctx->lightfv(light,pname,params);
1539 }
1540
glLightx(GLenum light,GLenum pname,GLfixed param)1541 GL_API void GL_APIENTRY glLightx( GLenum light, GLenum pname, GLfixed param) {
1542 GET_CTX_CM()
1543 GLES_CM_TRACE()
1544 ctx->lightf(light,pname,X2F(param));
1545 }
1546
glLightxv(GLenum light,GLenum pname,const GLfixed * params)1547 GL_API void GL_APIENTRY glLightxv( GLenum light, GLenum pname, const GLfixed *params) {
1548 GET_CTX_CM()
1549 GLES_CM_TRACE()
1550 GLfloat tmpParams[4];
1551
1552 switch (pname) {
1553 case GL_AMBIENT:
1554 case GL_DIFFUSE:
1555 case GL_SPECULAR:
1556 case GL_EMISSION:
1557 case GL_POSITION:
1558 tmpParams[3] = X2F(params[3]);
1559 case GL_SPOT_DIRECTION:
1560 tmpParams[2] = X2F(params[2]);
1561 tmpParams[1] = X2F(params[1]);
1562 case GL_SPOT_EXPONENT:
1563 case GL_SPOT_CUTOFF:
1564 case GL_CONSTANT_ATTENUATION:
1565 case GL_LINEAR_ATTENUATION:
1566 case GL_QUADRATIC_ATTENUATION:
1567 tmpParams[0] = X2F(params[0]);
1568 break;
1569 default: {
1570 ctx->setGLerror(GL_INVALID_ENUM);
1571 return;
1572 }
1573 }
1574 ctx->lightfv(light,pname,tmpParams);
1575 }
1576
glLineWidth(GLfloat width)1577 GL_API void GL_APIENTRY glLineWidth( GLfloat width) {
1578 GET_CTX()
1579 GLES_CM_TRACE()
1580 ctx->setLineWidth(width);
1581 ctx->dispatcher().glLineWidth(width);
1582 }
1583
glLineWidthx(GLfixed width)1584 GL_API void GL_APIENTRY glLineWidthx( GLfixed width) {
1585 GET_CTX()
1586 GLES_CM_TRACE()
1587 ctx->setLineWidth(X2F(width));
1588 ctx->dispatcher().glLineWidth(X2F(width));
1589 }
1590
glLoadIdentity(void)1591 GL_API void GL_APIENTRY glLoadIdentity( void) {
1592 GET_CTX_CM()
1593 GLES_CM_TRACE()
1594 ctx->loadIdentity();
1595 ERRCHECK()
1596 }
1597
glLoadMatrixf(const GLfloat * m)1598 GL_API void GL_APIENTRY glLoadMatrixf( const GLfloat *m) {
1599 GET_CTX_CM()
1600 GLES_CM_TRACE()
1601 ctx->loadMatrixf(m);
1602 }
1603
glLoadMatrixx(const GLfixed * m)1604 GL_API void GL_APIENTRY glLoadMatrixx( const GLfixed *m) {
1605 GET_CTX_CM()
1606 GLES_CM_TRACE()
1607 GLfloat mat[16];
1608 for(int i=0; i< 16 ; i++) {
1609 mat[i] = X2F(m[i]);
1610 }
1611 ctx->loadMatrixf(mat);
1612 }
1613
glLogicOp(GLenum opcode)1614 GL_API void GL_APIENTRY glLogicOp( GLenum opcode) {
1615 GET_CTX()
1616 GLES_CM_TRACE()
1617 ctx->dispatcher().glLogicOp(opcode);
1618 }
1619
glMaterialf(GLenum face,GLenum pname,GLfloat param)1620 GL_API void GL_APIENTRY glMaterialf( GLenum face, GLenum pname, GLfloat param) {
1621 GET_CTX_CM()
1622 GLES_CM_TRACE()
1623
1624 ctx->materialf(face, pname, param);
1625 }
1626
glMaterialfv(GLenum face,GLenum pname,const GLfloat * params)1627 GL_API void GL_APIENTRY glMaterialfv( GLenum face, GLenum pname, const GLfloat *params) {
1628 GET_CTX_CM()
1629 GLES_CM_TRACE()
1630
1631 ctx->materialfv(face, pname, params);
1632 }
1633
glMaterialx(GLenum face,GLenum pname,GLfixed param)1634 GL_API void GL_APIENTRY glMaterialx( GLenum face, GLenum pname, GLfixed param) {
1635 GET_CTX_CM()
1636 GLES_CM_TRACE()
1637
1638 ctx->materialf(face, pname, X2F(param));
1639 }
1640
glMaterialxv(GLenum face,GLenum pname,const GLfixed * params)1641 GL_API void GL_APIENTRY glMaterialxv( GLenum face, GLenum pname, const GLfixed *params) {
1642 GET_CTX_CM()
1643 GLES_CM_TRACE()
1644 GLfloat tmpParams[4];
1645
1646 for(int i=0; i< 4; i++) {
1647 tmpParams[i] = X2F(params[i]);
1648 }
1649
1650 ctx->materialfv(face, pname, tmpParams);
1651 }
1652
glMatrixMode(GLenum mode)1653 GL_API void GL_APIENTRY glMatrixMode( GLenum mode) {
1654 GET_CTX_CM()
1655 GLES_CM_TRACE()
1656 SET_ERROR_IF(mode != GL_TEXTURE &&
1657 mode != GL_PROJECTION &&
1658 mode != GL_MODELVIEW, GL_INVALID_ENUM);
1659 ERRCHECK()
1660 ctx->matrixMode(mode);
1661 ERRCHECK()
1662 }
1663
glMultMatrixf(const GLfloat * m)1664 GL_API void GL_APIENTRY glMultMatrixf( const GLfloat *m) {
1665 GET_CTX_CM()
1666 GLES_CM_TRACE()
1667 ctx->multMatrixf(m);
1668 }
1669
glMultMatrixx(const GLfixed * m)1670 GL_API void GL_APIENTRY glMultMatrixx( const GLfixed *m) {
1671 GET_CTX_CM()
1672 GLES_CM_TRACE()
1673 GLfloat mat[16];
1674 for(int i=0; i< 16 ; i++) {
1675 mat[i] = X2F(m[i]);
1676 }
1677 ctx->multMatrixf(mat);
1678 }
1679
glMultiTexCoord4f(GLenum target,GLfloat s,GLfloat t,GLfloat r,GLfloat q)1680 GL_API void GL_APIENTRY glMultiTexCoord4f( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
1681 GET_CTX_CM()
1682 GLES_CM_TRACE()
1683 SET_ERROR_IF(!GLEScmValidate::textureEnum(target,ctx->getMaxTexUnits()),GL_INVALID_ENUM);
1684 ctx->multiTexCoord4f(target, s, t, r, q);
1685 }
1686
glMultiTexCoord4x(GLenum target,GLfixed s,GLfixed t,GLfixed r,GLfixed q)1687 GL_API void GL_APIENTRY glMultiTexCoord4x( GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) {
1688 GET_CTX_CM()
1689 GLES_CM_TRACE()
1690 SET_ERROR_IF(!GLEScmValidate::textureEnum(target,ctx->getMaxTexUnits()),GL_INVALID_ENUM);
1691 ctx->multiTexCoord4f(target,X2F(s),X2F(t),X2F(r),X2F(q));
1692 }
1693
glNormal3f(GLfloat nx,GLfloat ny,GLfloat nz)1694 GL_API void GL_APIENTRY glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz) {
1695 GET_CTX_CM()
1696 GLES_CM_TRACE()
1697 ctx->normal3f(nx, ny, nz);
1698 }
1699
glNormal3x(GLfixed nx,GLfixed ny,GLfixed nz)1700 GL_API void GL_APIENTRY glNormal3x( GLfixed nx, GLfixed ny, GLfixed nz) {
1701 GET_CTX_CM()
1702 GLES_CM_TRACE()
1703 ctx->normal3f(X2F(nx),X2F(ny),X2F(nz));
1704 }
1705
glNormalPointer(GLenum type,GLsizei stride,const GLvoid * pointer)1706 GL_API void GL_APIENTRY glNormalPointer( GLenum type, GLsizei stride, const GLvoid *pointer) {
1707 GET_CTX()
1708 GLES_CM_TRACE()
1709 SET_ERROR_IF(stride < 0,GL_INVALID_VALUE);
1710 SET_ERROR_IF(!GLEScmValidate::normalPointerType(type),GL_INVALID_ENUM);
1711 ctx->setPointer(GL_NORMAL_ARRAY,3,type,stride,pointer, 0);//3 normal verctor
1712 }
1713
glNormalPointerWithDataSize(GLenum type,GLsizei stride,const GLvoid * pointer,GLsizei dataSize)1714 GL_API void GL_APIENTRY glNormalPointerWithDataSize(GLenum type, GLsizei stride,
1715 const GLvoid *pointer, GLsizei dataSize) {
1716 GET_CTX()
1717 GLES_CM_TRACE()
1718 SET_ERROR_IF(stride < 0,GL_INVALID_VALUE);
1719 SET_ERROR_IF(!GLEScmValidate::normalPointerType(type),GL_INVALID_ENUM);
1720 ctx->setPointer(GL_NORMAL_ARRAY,3,type,stride,pointer, dataSize);//3 normal verctor
1721 }
1722
glOrthof(GLfloat left,GLfloat right,GLfloat bottom,GLfloat top,GLfloat zNear,GLfloat zFar)1723 GL_API void GL_APIENTRY glOrthof( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) {
1724 GET_CTX_CM()
1725 GLES_CM_TRACE()
1726 ctx->orthof(left,right,bottom,top,zNear,zFar);
1727 }
1728
glOrthox(GLfixed left,GLfixed right,GLfixed bottom,GLfixed top,GLfixed zNear,GLfixed zFar)1729 GL_API void GL_APIENTRY glOrthox( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) {
1730 GET_CTX_CM()
1731 GLES_CM_TRACE()
1732 ctx->orthof(left,right,bottom,top,zNear,zFar);
1733 }
1734
glPixelStorei(GLenum pname,GLint param)1735 GL_API void GL_APIENTRY glPixelStorei( GLenum pname, GLint param) {
1736 GET_CTX()
1737 GLES_CM_TRACE()
1738 SET_ERROR_IF(!(pname == GL_PACK_ALIGNMENT || pname == GL_UNPACK_ALIGNMENT),GL_INVALID_ENUM);
1739 SET_ERROR_IF(!((param==1)||(param==2)||(param==4)||(param==8)), GL_INVALID_VALUE);
1740 ctx->setPixelStorei(pname, param);
1741 ctx->dispatcher().glPixelStorei(pname,param);
1742 }
1743
glPointParameterf(GLenum pname,GLfloat param)1744 GL_API void GL_APIENTRY glPointParameterf( GLenum pname, GLfloat param) {
1745 GET_CTX()
1746 GLES_CM_TRACE()
1747 ctx->dispatcher().glPointParameterf(pname,param);
1748 }
1749
glPointParameterfv(GLenum pname,const GLfloat * params)1750 GL_API void GL_APIENTRY glPointParameterfv( GLenum pname, const GLfloat *params) {
1751 GET_CTX()
1752 GLES_CM_TRACE()
1753 ctx->dispatcher().glPointParameterfv(pname,params);
1754 }
1755
glPointParameterx(GLenum pname,GLfixed param)1756 GL_API void GL_APIENTRY glPointParameterx( GLenum pname, GLfixed param)
1757 {
1758 GET_CTX()
1759 GLES_CM_TRACE()
1760 ctx->dispatcher().glPointParameterf(pname,X2F(param));
1761 }
1762
glPointParameterxv(GLenum pname,const GLfixed * params)1763 GL_API void GL_APIENTRY glPointParameterxv( GLenum pname, const GLfixed *params) {
1764 GET_CTX()
1765 GLES_CM_TRACE()
1766
1767 GLfloat tmpParam = X2F(*params) ;
1768 ctx->dispatcher().glPointParameterfv(pname,&tmpParam);
1769 }
1770
glPointSize(GLfloat size)1771 GL_API void GL_APIENTRY glPointSize( GLfloat size) {
1772 GET_CTX()
1773 GLES_CM_TRACE()
1774 ctx->dispatcher().glPointSize(size);
1775 }
1776
glPointSizePointerOES(GLenum type,GLsizei stride,const GLvoid * pointer)1777 GL_API void GL_APIENTRY glPointSizePointerOES( GLenum type, GLsizei stride, const GLvoid *pointer) {
1778 GET_CTX()
1779 GLES_CM_TRACE()
1780 SET_ERROR_IF(stride < 0,GL_INVALID_VALUE);
1781 SET_ERROR_IF(!GLEScmValidate::pointPointerType(type),GL_INVALID_ENUM);
1782 ctx->setPointer(GL_POINT_SIZE_ARRAY_OES,1,type,stride,pointer, 0);
1783 }
1784
glPointSizex(GLfixed size)1785 GL_API void GL_APIENTRY glPointSizex( GLfixed size) {
1786 GET_CTX()
1787 GLES_CM_TRACE()
1788 ctx->dispatcher().glPointSize(X2F(size));
1789 }
1790
glPolygonOffset(GLfloat factor,GLfloat units)1791 GL_API void GL_APIENTRY glPolygonOffset( GLfloat factor, GLfloat units) {
1792 GET_CTX()
1793 GLES_CM_TRACE()
1794 ctx->setPolygonOffset(factor, units);
1795 ctx->dispatcher().glPolygonOffset(factor,units);
1796 }
1797
glPolygonOffsetx(GLfixed factor,GLfixed units)1798 GL_API void GL_APIENTRY glPolygonOffsetx( GLfixed factor, GLfixed units) {
1799 GET_CTX()
1800 GLES_CM_TRACE()
1801 ctx->setPolygonOffset(X2F(factor), X2F(units));
1802 ctx->dispatcher().glPolygonOffset(X2F(factor),X2F(units));
1803 }
1804
glPopMatrix(void)1805 GL_API void GL_APIENTRY glPopMatrix(void) {
1806 GET_CTX_CM()
1807 GLES_CM_TRACE()
1808 ctx->popMatrix();
1809 CORE_ERR_FORWARD()
1810 }
1811
glPushMatrix(void)1812 GL_API void GL_APIENTRY glPushMatrix(void) {
1813 GET_CTX_CM()
1814 GLES_CM_TRACE()
1815 ctx->pushMatrix();
1816 CORE_ERR_FORWARD()
1817 }
1818
glReadPixels(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLvoid * pixels)1819 GL_API void GL_APIENTRY glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) {
1820 GET_CTX()
1821 GLES_CM_TRACE()
1822
1823 SET_ERROR_IF(!(GLEScmValidate::pixelFrmt(ctx,format) && GLEScmValidate::pixelType(ctx,type)),GL_INVALID_ENUM);
1824 SET_ERROR_IF(!(GLEScmValidate::pixelOp(format,type)),GL_INVALID_OPERATION);
1825
1826 // Just stop allowing glReadPixels on multisampled default FBO for now.
1827 SET_ERROR_IF(ctx->isDefaultFBOBound(GL_FRAMEBUFFER_EXT) &&
1828 ctx->getDefaultFBOMultisamples(), GL_INVALID_OPERATION);
1829
1830 ctx->dispatcher().glReadPixels(x,y,width,height,format,type,pixels);
1831 }
1832
glRotatef(GLfloat angle,GLfloat x,GLfloat y,GLfloat z)1833 GL_API void GL_APIENTRY glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
1834 GET_CTX_CM()
1835 GLES_CM_TRACE()
1836 ctx->rotatef(angle, x, y, z);
1837 }
1838
glRotatex(GLfixed angle,GLfixed x,GLfixed y,GLfixed z)1839 GL_API void GL_APIENTRY glRotatex( GLfixed angle, GLfixed x, GLfixed y, GLfixed z) {
1840 GET_CTX_CM()
1841 GLES_CM_TRACE()
1842 ctx->rotatef(angle,X2F(x),X2F(y),X2F(z));
1843 }
1844
glSampleCoverage(GLclampf value,GLboolean invert)1845 GL_API void GL_APIENTRY glSampleCoverage( GLclampf value, GLboolean invert) {
1846 GET_CTX()
1847 GLES_CM_TRACE()
1848 ctx->setSampleCoverage(value, invert);
1849 ctx->dispatcher().glSampleCoverage(value,invert);
1850 }
1851
glSampleCoveragex(GLclampx value,GLboolean invert)1852 GL_API void GL_APIENTRY glSampleCoveragex( GLclampx value, GLboolean invert) {
1853 GET_CTX()
1854 GLES_CM_TRACE()
1855 ctx->setSampleCoverage(X2F(value), invert);
1856 ctx->dispatcher().glSampleCoverage(X2F(value),invert);
1857 }
1858
glScalef(GLfloat x,GLfloat y,GLfloat z)1859 GL_API void GL_APIENTRY glScalef( GLfloat x, GLfloat y, GLfloat z) {
1860 GET_CTX_CM()
1861 GLES_CM_TRACE()
1862 ctx->scalef(x, y, z);
1863 }
1864
glScalex(GLfixed x,GLfixed y,GLfixed z)1865 GL_API void GL_APIENTRY glScalex( GLfixed x, GLfixed y, GLfixed z) {
1866 GET_CTX_CM()
1867 GLES_CM_TRACE()
1868 ctx->scalef(X2F(x),X2F(y),X2F(z));
1869 }
1870
glScissor(GLint x,GLint y,GLsizei width,GLsizei height)1871 GL_API void GL_APIENTRY glScissor( GLint x, GLint y, GLsizei width, GLsizei height) {
1872 GET_CTX()
1873 GLES_CM_TRACE()
1874 ctx->setScissor(x, y, width, height);
1875 ctx->dispatcher().glScissor(x,y,width,height);
1876 }
1877
glShadeModel(GLenum mode)1878 GL_API void GL_APIENTRY glShadeModel( GLenum mode ) {
1879 GET_CTX_CM()
1880 GLES_CM_TRACE()
1881 ctx->shadeModel(mode);
1882 }
1883
glStencilFunc(GLenum func,GLint ref,GLuint mask)1884 GL_API void GL_APIENTRY glStencilFunc( GLenum func, GLint ref, GLuint mask) {
1885 GET_CTX()
1886 GLES_CM_TRACE()
1887 ctx->setStencilFuncSeparate(GL_FRONT_AND_BACK, func, ref, mask);
1888 ctx->dispatcher().glStencilFunc(func,ref,mask);
1889 }
1890
glStencilMask(GLuint mask)1891 GL_API void GL_APIENTRY glStencilMask( GLuint mask) {
1892 GET_CTX()
1893 GLES_CM_TRACE()
1894 ctx->setStencilMaskSeparate(GL_FRONT_AND_BACK, mask);
1895 ctx->dispatcher().glStencilMask(mask);
1896 }
1897
glStencilOp(GLenum fail,GLenum zfail,GLenum zpass)1898 GL_API void GL_APIENTRY glStencilOp( GLenum fail, GLenum zfail, GLenum zpass) {
1899 GET_CTX()
1900 GLES_CM_TRACE()
1901 SET_ERROR_IF(!(GLEScmValidate::stencilOp(fail) && GLEScmValidate::stencilOp(zfail) && GLEScmValidate::stencilOp(zpass)),GL_INVALID_ENUM);
1902 ctx->setStencilOpSeparate(GL_FRONT_AND_BACK, fail, zfail, zpass);
1903 ctx->dispatcher().glStencilOp(fail,zfail,zpass);
1904 }
1905
glTexCoordPointer(GLint size,GLenum type,GLsizei stride,const GLvoid * pointer)1906 GL_API void GL_APIENTRY glTexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
1907 GET_CTX()
1908 GLES_CM_TRACE()
1909 SET_ERROR_IF(!GLEScmValidate::texCoordPointerParams(size,stride),GL_INVALID_VALUE);
1910 SET_ERROR_IF(!GLEScmValidate::texCoordPointerType(type),GL_INVALID_ENUM);
1911 ctx->setPointer(GL_TEXTURE_COORD_ARRAY,size,type,stride,pointer, 0);
1912 }
1913
glTexCoordPointerWithDataSize(GLint size,GLenum type,GLsizei stride,const GLvoid * pointer,GLsizei dataSize)1914 GL_API void GL_APIENTRY glTexCoordPointerWithDataSize( GLint size, GLenum type,
1915 GLsizei stride, const GLvoid *pointer, GLsizei dataSize) {
1916 GET_CTX()
1917 GLES_CM_TRACE()
1918 SET_ERROR_IF(!GLEScmValidate::texCoordPointerParams(size,stride),GL_INVALID_VALUE);
1919 SET_ERROR_IF(!GLEScmValidate::texCoordPointerType(type),GL_INVALID_ENUM);
1920 ctx->setPointer(GL_TEXTURE_COORD_ARRAY,size,type,stride,pointer, dataSize);
1921 }
1922
glTexEnvf(GLenum target,GLenum pname,GLfloat param)1923 GL_API void GL_APIENTRY glTexEnvf( GLenum target, GLenum pname, GLfloat param) {
1924 GET_CTX_CM()
1925 GLES_CM_TRACE()
1926 SET_ERROR_IF(!GLEScmValidate::texEnv(target,pname),GL_INVALID_ENUM);
1927 ctx->texEnvf(target,pname,param);
1928 }
1929
glTexEnvfv(GLenum target,GLenum pname,const GLfloat * params)1930 GL_API void GL_APIENTRY glTexEnvfv( GLenum target, GLenum pname, const GLfloat *params) {
1931 GET_CTX_CM()
1932 GLES_CM_TRACE()
1933 SET_ERROR_IF(!GLEScmValidate::texEnv(target,pname),GL_INVALID_ENUM);
1934 ctx->texEnvfv(target, pname, params);
1935 }
1936
glTexEnvi(GLenum target,GLenum pname,GLint param)1937 GL_API void GL_APIENTRY glTexEnvi( GLenum target, GLenum pname, GLint param) {
1938 GET_CTX_CM()
1939 GLES_CM_TRACE()
1940 SET_ERROR_IF(!GLEScmValidate::texEnv(target,pname),GL_INVALID_ENUM);
1941 ctx->texEnvi(target, pname, param);
1942 }
1943
glTexEnviv(GLenum target,GLenum pname,const GLint * params)1944 GL_API void GL_APIENTRY glTexEnviv( GLenum target, GLenum pname, const GLint *params) {
1945 GET_CTX_CM()
1946 GLES_CM_TRACE()
1947 SET_ERROR_IF(!GLEScmValidate::texEnv(target,pname),GL_INVALID_ENUM);
1948 ctx->texEnviv(target, pname, params);
1949 }
1950
glTexEnvx(GLenum target,GLenum pname,GLfixed param)1951 GL_API void GL_APIENTRY glTexEnvx( GLenum target, GLenum pname, GLfixed param) {
1952 GET_CTX_CM()
1953 GLES_CM_TRACE()
1954 SET_ERROR_IF(!GLEScmValidate::texEnv(target,pname),GL_INVALID_ENUM);
1955
1956 GLfloat tmpParam = static_cast<GLfloat>(param);
1957 ctx->texEnvf(target, pname, tmpParam);
1958 CORE_ERR_FORWARD()
1959 }
1960
glTexEnvxv(GLenum target,GLenum pname,const GLfixed * params)1961 GL_API void GL_APIENTRY glTexEnvxv( GLenum target, GLenum pname, const GLfixed *params) {
1962 GET_CTX_CM()
1963 GLES_CM_TRACE()
1964 SET_ERROR_IF(!GLEScmValidate::texEnv(target,pname),GL_INVALID_ENUM);
1965
1966 GLfloat tmpParams[4];
1967 if(pname == GL_TEXTURE_ENV_COLOR) {
1968 for(int i =0;i<4;i++) {
1969 tmpParams[i] = X2F(params[i]);
1970 }
1971 } else {
1972 tmpParams[0] = static_cast<GLfloat>(params[0]);
1973 }
1974
1975 ctx->texEnvfv(target, pname, tmpParams);
1976 CORE_ERR_FORWARD()
1977 }
1978
glTexImage2D(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,const GLvoid * pixels)1979 GL_API void GL_APIENTRY glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {
1980 GET_CTX()
1981 GLES_CM_TRACE()
1982
1983 SET_ERROR_IF(!(GLEScmValidate::textureTargetEx(target) &&
1984 GLEScmValidate::pixelFrmt(ctx,internalformat) &&
1985 GLEScmValidate::pixelFrmt(ctx,format) &&
1986 GLEScmValidate::pixelType(ctx,type)),GL_INVALID_ENUM);
1987
1988 SET_ERROR_IF(!(GLEScmValidate::pixelOp(format,type) && internalformat == ((GLint)format)),GL_INVALID_OPERATION);
1989
1990 bool needAutoMipmap = false;
1991
1992 s_glInitTexImage2D(target, level, internalformat, width, height, border,
1993 &format, &type, &internalformat, &needAutoMipmap);
1994
1995 // TODO: Emulate swizzles
1996 if (isCoreProfile()) {
1997 GLEScontext::prepareCoreProfileEmulatedTexture(
1998 getTextureTargetData(target),
1999 false, target, format, type,
2000 &internalformat, &format);
2001 }
2002
2003 ctx->dispatcher().glTexImage2D(target,level,
2004 internalformat,width,height,
2005 border,format,type,pixels);
2006
2007 if (needAutoMipmap) {
2008 if ((isCoreProfile() || isGles2Gles()) &&
2009 !isCubeMapFaceTarget(target)) {
2010 ctx->dispatcher().glGenerateMipmap(target);
2011 } else if (isGles2Gles()) {
2012 ctx->dispatcher().glGenerateMipmap(target);
2013 } else {
2014 ctx->dispatcher().glGenerateMipmapEXT(target);
2015 }
2016 }
2017 }
2018
handleMipmapGeneration(GLenum target,GLenum pname,bool param)2019 static bool handleMipmapGeneration(GLenum target, GLenum pname, bool param)
2020 {
2021 GET_CTX_RET(false)
2022 GLES_CM_TRACE()
2023
2024 if (pname == GL_GENERATE_MIPMAP) {
2025 TextureData *texData = getTextureTargetData(target);
2026 if (texData) {
2027 if (param) {
2028 texData->setMipmapLevelAtLeast(maxMipmapLevel(texData->width,
2029 texData->height));
2030 }
2031 if (isCoreProfile() || isGles2Gles() ||
2032 !ctx->isAutoMipmapSupported()) {
2033 texData->requiresAutoMipmap = param;
2034 return true;
2035 }
2036 }
2037 }
2038
2039 return false;
2040 }
2041
glTexParameterf(GLenum target,GLenum pname,GLfloat param)2042 GL_API void GL_APIENTRY glTexParameterf( GLenum target, GLenum pname, GLfloat param) {
2043 GET_CTX()
2044 GLES_CM_TRACE()
2045 SET_ERROR_IF(!GLEScmValidate::texParams(target,pname),GL_INVALID_ENUM);
2046
2047 if(handleMipmapGeneration(target, pname, (bool)param))
2048 return;
2049
2050 TextureData *texData = getTextureTargetData(target);
2051 texData->setTexParam(pname, static_cast<GLint>(param));
2052 ctx->dispatcher().glTexParameterf(target,pname,param);
2053 }
2054
glTexParameterfv(GLenum target,GLenum pname,const GLfloat * params)2055 GL_API void GL_APIENTRY glTexParameterfv( GLenum target, GLenum pname, const GLfloat *params) {
2056 GET_CTX()
2057 GLES_CM_TRACE()
2058 SET_ERROR_IF(!GLEScmValidate::texParams(target,pname),GL_INVALID_ENUM);
2059
2060 if(handleMipmapGeneration(target, pname, (bool)(*params)))
2061 return;
2062
2063 TextureData *texData = getTextureTargetData(target);
2064
2065 if (pname==GL_TEXTURE_CROP_RECT_OES) {
2066 SET_ERROR_IF(texData==NULL,GL_INVALID_OPERATION);
2067 for (int i=0;i<4;++i)
2068 texData->crop_rect[i] = params[i];
2069 } else {
2070 texData->setTexParam(pname, static_cast<GLint>(params[0]));
2071 ctx->dispatcher().glTexParameterfv(target,pname,params);
2072 }
2073 }
2074
glTexParameteri(GLenum target,GLenum pname,GLint param)2075 GL_API void GL_APIENTRY glTexParameteri( GLenum target, GLenum pname, GLint param) {
2076 GET_CTX()
2077 GLES_CM_TRACE()
2078 SET_ERROR_IF(!GLEScmValidate::texParams(target,pname),GL_INVALID_ENUM);
2079
2080 if(handleMipmapGeneration(target, pname, (bool)param))
2081 return;
2082
2083 TextureData *texData = getTextureTargetData(target);
2084 texData->setTexParam(pname, (GLint)param);
2085 ctx->dispatcher().glTexParameteri(target,pname,param);
2086 }
2087
glTexParameteriv(GLenum target,GLenum pname,const GLint * params)2088 GL_API void GL_APIENTRY glTexParameteriv( GLenum target, GLenum pname, const GLint *params) {
2089 GET_CTX()
2090 GLES_CM_TRACE()
2091 SET_ERROR_IF(!GLEScmValidate::texParams(target,pname),GL_INVALID_ENUM);
2092
2093 if(handleMipmapGeneration(target, pname, (bool)(*params)))
2094 return;
2095
2096 TextureData *texData = getTextureTargetData(target);
2097 if (pname==GL_TEXTURE_CROP_RECT_OES) {
2098 SET_ERROR_IF(texData==NULL,GL_INVALID_OPERATION);
2099 for (int i=0;i<4;++i)
2100 texData->crop_rect[i] = params[i];
2101 }
2102 else {
2103 texData->setTexParam(pname, (GLint)params[0]);
2104 ctx->dispatcher().glTexParameteriv(target,pname,params);
2105 }
2106 }
2107
glTexParameterx(GLenum target,GLenum pname,GLfixed param)2108 GL_API void GL_APIENTRY glTexParameterx( GLenum target, GLenum pname, GLfixed param) {
2109 GET_CTX()
2110 GLES_CM_TRACE()
2111 SET_ERROR_IF(!GLEScmValidate::texParams(target,pname),GL_INVALID_ENUM);
2112 if(handleMipmapGeneration(target, pname, (bool)param))
2113 return;
2114
2115 TextureData *texData = getTextureTargetData(target);
2116 texData->setTexParam(pname, static_cast<GLint>(param));
2117 ctx->dispatcher().glTexParameterf(target,pname,static_cast<GLfloat>(param));
2118 }
2119
glTexParameterxv(GLenum target,GLenum pname,const GLfixed * params)2120 GL_API void GL_APIENTRY glTexParameterxv( GLenum target, GLenum pname, const GLfixed *params) {
2121 GET_CTX()
2122 GLES_CM_TRACE()
2123 SET_ERROR_IF(!GLEScmValidate::texParams(target,pname),GL_INVALID_ENUM);
2124
2125 if(handleMipmapGeneration(target, pname, (bool)(*params)))
2126 return;
2127
2128 TextureData *texData = getTextureTargetData(target);
2129 if (pname==GL_TEXTURE_CROP_RECT_OES) {
2130 SET_ERROR_IF(texData==NULL,GL_INVALID_OPERATION);
2131 for (int i=0;i<4;++i)
2132 texData->crop_rect[i] = X2F(params[i]);
2133 }
2134 else {
2135 GLfloat param = static_cast<GLfloat>(params[0]);
2136 texData->setTexParam(pname, static_cast<GLint>(params[0]));
2137 ctx->dispatcher().glTexParameterfv(target,pname,¶m);
2138 }
2139 }
2140
glTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid * pixels)2141 GL_API void GL_APIENTRY glTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) {
2142 GET_CTX()
2143 GLES_CM_TRACE()
2144 SET_ERROR_IF(!(GLEScmValidate::textureTargetEx(target) &&
2145 GLEScmValidate::pixelFrmt(ctx,format)&&
2146 GLEScmValidate::pixelType(ctx,type)),GL_INVALID_ENUM);
2147 SET_ERROR_IF(!GLEScmValidate::pixelOp(format,type),GL_INVALID_OPERATION);
2148 // set an error if level < 0 or level > log 2 max
2149 SET_ERROR_IF(level < 0 || 1<<level > ctx->getMaxTexSize(), GL_INVALID_VALUE);
2150 SET_ERROR_IF(xoffset < 0 || yoffset < 0 || width < 0 || height < 0, GL_INVALID_VALUE);
2151 if (ctx->shareGroup().get()) {
2152 TextureData *texData = getTextureTargetData(target);
2153 SET_ERROR_IF(!texData, GL_INVALID_OPERATION);
2154 SET_ERROR_IF(xoffset + width > (GLint)texData->width ||
2155 yoffset + height > (GLint)texData->height,
2156 GL_INVALID_VALUE);
2157 }
2158 SET_ERROR_IF(!pixels,GL_INVALID_OPERATION);
2159
2160 ctx->dispatcher().glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixels);
2161
2162 if (ctx->shareGroup().get()){
2163 TextureData *texData = getTextureTargetData(target);
2164 if(texData && texData->requiresAutoMipmap)
2165 {
2166 ctx->dispatcher().glGenerateMipmapEXT(target);
2167 }
2168 texData->setMipmapLevelAtLeast(level);
2169 texData->makeDirty();
2170 }
2171 }
2172
glTranslatef(GLfloat x,GLfloat y,GLfloat z)2173 GL_API void GL_APIENTRY glTranslatef( GLfloat x, GLfloat y, GLfloat z) {
2174 GET_CTX_CM()
2175 GLES_CM_TRACE()
2176 ctx->translatef(x, y, z);
2177 }
2178
glTranslatex(GLfixed x,GLfixed y,GLfixed z)2179 GL_API void GL_APIENTRY glTranslatex( GLfixed x, GLfixed y, GLfixed z) {
2180 GET_CTX_CM()
2181 GLES_CM_TRACE()
2182 ctx->translatef(X2F(x),X2F(y),X2F(z));
2183 }
2184
glVertexPointer(GLint size,GLenum type,GLsizei stride,const GLvoid * pointer)2185 GL_API void GL_APIENTRY glVertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
2186 GET_CTX()
2187 GLES_CM_TRACE()
2188
2189 SET_ERROR_IF(!GLEScmValidate::vertexPointerParams(size,stride),GL_INVALID_VALUE);
2190 SET_ERROR_IF(!GLEScmValidate::vertexPointerType(type),GL_INVALID_ENUM);
2191 ctx->setPointer(GL_VERTEX_ARRAY,size,type,stride,pointer, 0);
2192 }
2193
glVertexPointerWithDataSize(GLint size,GLenum type,GLsizei stride,const GLvoid * pointer,GLsizei dataSize)2194 GL_API void GL_APIENTRY glVertexPointerWithDataSize( GLint size, GLenum type,
2195 GLsizei stride, const GLvoid *pointer, GLsizei dataSize) {
2196 GET_CTX()
2197 GLES_CM_TRACE()
2198
2199 SET_ERROR_IF(!GLEScmValidate::vertexPointerParams(size,stride),GL_INVALID_VALUE);
2200 SET_ERROR_IF(!GLEScmValidate::vertexPointerType(type),GL_INVALID_ENUM);
2201 ctx->setPointer(GL_VERTEX_ARRAY,size,type,stride,pointer, dataSize);
2202 }
2203
glViewport(GLint x,GLint y,GLsizei width,GLsizei height)2204 GL_API void GL_APIENTRY glViewport( GLint x, GLint y, GLsizei width, GLsizei height) {
2205 GET_CTX()
2206 GLES_CM_TRACE()
2207 ctx->setViewport(x, y, width, height);
2208 ctx->dispatcher().glViewport(x,y,width,height);
2209 }
2210
glEGLImageTargetTexture2DOES(GLenum target,GLeglImageOES image)2211 GL_API void GL_APIENTRY glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
2212 {
2213 GET_CTX();
2214 GLES_CM_TRACE()
2215 SET_ERROR_IF(!GLEScmValidate::textureTargetLimited(target),GL_INVALID_ENUM);
2216 unsigned int imagehndl = SafeUIntFromPointer(image);
2217 ImagePtr img = s_eglIface->getEGLImage(imagehndl);
2218 if (img) {
2219 // Create the texture object in the underlying EGL implementation,
2220 // flag to the OpenGL layer to skip the image creation and map the
2221 // current binded texture object to the existing global object.
2222 if (ctx->shareGroup().get()) {
2223 ObjectLocalName tex = ctx->getTextureLocalName(target,ctx->getBindedTexture(target));
2224 // replace mapping and bind the new global object
2225 ctx->shareGroup()->replaceGlobalObject(NamedObjectType::TEXTURE, tex,
2226 img->globalTexObj);
2227 ctx->dispatcher().glBindTexture(GL_TEXTURE_2D,
2228 img->globalTexObj->getGlobalName());
2229 TextureData *texData = getTextureTargetData(target);
2230 SET_ERROR_IF(texData==NULL,GL_INVALID_OPERATION);
2231 texData->width = img->width;
2232 texData->height = img->height;
2233 texData->border = img->border;
2234 texData->internalFormat = img->internalFormat;
2235 texData->format = img->format;
2236 texData->type = img->type;
2237 texData->texStorageLevels = img->texStorageLevels;
2238 texData->sourceEGLImage = imagehndl;
2239 texData->setGlobalName(img->globalTexObj->getGlobalName());
2240 texData->setSaveableTexture(
2241 SaveableTexturePtr(img->saveableTexture));
2242 if (img->sync) {
2243 // insert gpu side fence to make sure we are done with any blit ops.
2244 ctx->dispatcher().glWaitSync(img->sync, 0, GL_TIMEOUT_IGNORED);
2245 }
2246 }
2247 }
2248 }
2249
glEGLImageTargetRenderbufferStorageOES(GLenum target,GLeglImageOES image)2250 GL_API void GL_APIENTRY glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
2251 {
2252 GET_CTX();
2253 GLES_CM_TRACE()
2254 SET_ERROR_IF(target != GL_RENDERBUFFER_OES,GL_INVALID_ENUM);
2255 unsigned int imagehndl = SafeUIntFromPointer(image);
2256 ImagePtr img = s_eglIface->getEGLImage(imagehndl);
2257 SET_ERROR_IF(!img,GL_INVALID_VALUE);
2258 SET_ERROR_IF(!ctx->shareGroup().get(),GL_INVALID_OPERATION);
2259
2260 // Get current bounded renderbuffer
2261 // raise INVALID_OPERATIOn if no renderbuffer is bounded
2262 GLuint rb = ctx->getRenderbufferBinding();
2263 SET_ERROR_IF(rb == 0,GL_INVALID_OPERATION);
2264 auto objData =
2265 ctx->shareGroup()->getObjectData(NamedObjectType::RENDERBUFFER, rb);
2266 RenderbufferData *rbData = (RenderbufferData *)objData;
2267 SET_ERROR_IF(!rbData,GL_INVALID_OPERATION);
2268
2269 //
2270 // acquire the texture in the renderbufferData that it is an eglImage target
2271 //
2272 rbData->eglImageGlobalTexObject = img->globalTexObj;
2273 rbData->saveableTexture = img->saveableTexture;
2274 img->saveableTexture->makeDirty();
2275
2276 //
2277 // if the renderbuffer is attached to a framebuffer
2278 // change the framebuffer attachment in the undelying OpenGL
2279 // to point to the eglImage texture object.
2280 //
2281 if (rbData->attachedFB) {
2282 // update the framebuffer attachment point to the
2283 // underlying texture of the img
2284 GLuint prevFB = ctx->getFramebufferBinding(GL_FRAMEBUFFER_EXT);
2285 if (prevFB != rbData->attachedFB) {
2286 if (isCoreProfile() || isGles2Gles()) {
2287 ctx->dispatcher().glBindFramebuffer(GL_FRAMEBUFFER,
2288 rbData->attachedFB);
2289 } else {
2290 ctx->dispatcher().glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,
2291 rbData->attachedFB);
2292 }
2293 }
2294 if (isCoreProfile() || isGles2Gles()) {
2295 ctx->dispatcher().glFramebufferTexture2D(GL_FRAMEBUFFER,
2296 rbData->attachedPoint,
2297 GL_TEXTURE_2D,
2298 img->globalTexObj->getGlobalName(),
2299 0);
2300 } else {
2301 ctx->dispatcher().glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
2302 rbData->attachedPoint,
2303 GL_TEXTURE_2D,
2304 img->globalTexObj->getGlobalName(),
2305 0);
2306 }
2307 if (prevFB != rbData->attachedFB) {
2308 if (isCoreProfile() || isGles2Gles()) {
2309 ctx->dispatcher().glBindFramebuffer(GL_FRAMEBUFFER,
2310 prevFB);
2311 } else {
2312 ctx->dispatcher().glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,
2313 prevFB);
2314 }
2315 }
2316 }
2317 }
2318
2319 /* GL_OES_blend_subtract*/
glBlendEquationOES(GLenum mode)2320 GL_API void GL_APIENTRY glBlendEquationOES(GLenum mode) {
2321 GET_CTX()
2322 GLES_CM_TRACE()
2323 SET_ERROR_IF(!(GLEScmValidate::blendEquationMode(mode)), GL_INVALID_ENUM);
2324 ctx->setBlendEquationSeparate(mode, mode);
2325 ctx->dispatcher().glBlendEquation(mode);
2326 }
2327
2328 /* GL_OES_blend_equation_separate */
glBlendEquationSeparateOES(GLenum modeRGB,GLenum modeAlpha)2329 GL_API void GL_APIENTRY glBlendEquationSeparateOES (GLenum modeRGB, GLenum modeAlpha) {
2330 GET_CTX()
2331 GLES_CM_TRACE()
2332 SET_ERROR_IF(!(GLEScmValidate::blendEquationMode(modeRGB) && GLEScmValidate::blendEquationMode(modeAlpha)), GL_INVALID_ENUM);
2333 ctx->setBlendEquationSeparate(modeRGB, modeAlpha);
2334 ctx->dispatcher().glBlendEquationSeparate(modeRGB,modeAlpha);
2335 }
2336
2337 /* GL_OES_blend_func_separate */
glBlendFuncSeparateOES(GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)2338 GL_API void GL_APIENTRY glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
2339 GET_CTX()
2340 GLES_CM_TRACE()
2341 SET_ERROR_IF(!GLEScmValidate::blendSrc(srcRGB) || !GLEScmValidate::blendDst(dstRGB) ||
2342 !GLEScmValidate::blendSrc(srcAlpha) || ! GLEScmValidate::blendDst(dstAlpha) ,GL_INVALID_ENUM);
2343 ctx->setBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
2344 ctx->dispatcher().glBlendFuncSeparate(srcRGB,dstRGB,srcAlpha,dstAlpha);
2345 }
2346
2347 /* GL_OES_framebuffer_object */
glIsRenderbufferOES(GLuint renderbuffer)2348 GL_API GLboolean GL_APIENTRY glIsRenderbufferOES(GLuint renderbuffer) {
2349 GET_CTX_RET(GL_FALSE)
2350 GLES_CM_TRACE()
2351 RET_AND_SET_ERROR_IF(!ctx->getCaps()->GL_EXT_FRAMEBUFFER_OBJECT,GL_INVALID_OPERATION,GL_FALSE);
2352 if(renderbuffer && ctx->shareGroup().get()){
2353 return ctx->shareGroup()->isObject(NamedObjectType::RENDERBUFFER,
2354 renderbuffer)
2355 ? GL_TRUE
2356 : GL_FALSE;
2357 }
2358 if (isCoreProfile() || isGles2Gles()) {
2359 return ctx->dispatcher().glIsRenderbuffer(renderbuffer);
2360 } else {
2361 return ctx->dispatcher().glIsRenderbufferEXT(renderbuffer);
2362 }
2363 }
2364
glBindRenderbufferOES(GLenum target,GLuint renderbuffer)2365 GL_API void GLAPIENTRY glBindRenderbufferOES(GLenum target, GLuint renderbuffer) {
2366 GET_CTX()
2367 GLES_CM_TRACE()
2368 SET_ERROR_IF(!ctx->getCaps()->GL_EXT_FRAMEBUFFER_OBJECT,GL_INVALID_OPERATION);
2369 SET_ERROR_IF(!GLEScmValidate::renderbufferTarget(target),GL_INVALID_ENUM);
2370
2371 //if buffer wasn't generated before,generate one
2372 if (renderbuffer && ctx->shareGroup().get() &&
2373 !ctx->shareGroup()->isObject(NamedObjectType::RENDERBUFFER,
2374 renderbuffer)) {
2375 ctx->shareGroup()->genName(NamedObjectType::RENDERBUFFER, renderbuffer);
2376 ctx->shareGroup()->setObjectData(NamedObjectType::RENDERBUFFER,
2377 renderbuffer,
2378 ObjectDataPtr(new RenderbufferData()));
2379 }
2380
2381 int globalBufferName =
2382 (renderbuffer != 0)
2383 ? ctx->shareGroup()->getGlobalName(
2384 NamedObjectType::RENDERBUFFER, renderbuffer)
2385 : 0;
2386 if (isCoreProfile() || isGles2Gles()) {
2387 ctx->dispatcher().glBindRenderbuffer(target,globalBufferName);
2388 } else {
2389 ctx->dispatcher().glBindRenderbufferEXT(target,globalBufferName);
2390 }
2391
2392 // update renderbuffer binding state
2393 ctx->setRenderbufferBinding(renderbuffer);
2394 }
2395
glDeleteRenderbuffersOES(GLsizei n,const GLuint * renderbuffers)2396 GL_API void GLAPIENTRY glDeleteRenderbuffersOES(GLsizei n, const GLuint *renderbuffers) {
2397 GET_CTX()
2398 GLES_CM_TRACE()
2399 SET_ERROR_IF(!ctx->getCaps()->GL_EXT_FRAMEBUFFER_OBJECT,GL_INVALID_OPERATION);
2400 for (int i=0;i<n;++i) {
2401 ctx->shareGroup()->deleteName(NamedObjectType::RENDERBUFFER,
2402 renderbuffers[i]);
2403 }
2404 }
2405
glGenRenderbuffersOES(GLsizei n,GLuint * renderbuffers)2406 GL_API void GLAPIENTRY glGenRenderbuffersOES(GLsizei n, GLuint *renderbuffers) {
2407 GET_CTX()
2408 GLES_CM_TRACE()
2409 SET_ERROR_IF(!ctx->getCaps()->GL_EXT_FRAMEBUFFER_OBJECT,GL_INVALID_OPERATION);
2410 SET_ERROR_IF(n<0,GL_INVALID_VALUE);
2411 if(ctx->shareGroup().get()) {
2412 for(int i=0; i<n ;i++) {
2413 renderbuffers[i] = ctx->shareGroup()->genName(
2414 NamedObjectType::RENDERBUFFER, 0, true);
2415 ctx->shareGroup()->setObjectData(
2416 NamedObjectType::RENDERBUFFER, renderbuffers[i],
2417 ObjectDataPtr(new RenderbufferData()));
2418 }
2419 }
2420 }
2421
glRenderbufferStorageOES(GLenum target,GLenum internalformat,GLsizei width,GLsizei height)2422 GL_API void GLAPIENTRY glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height){
2423 GET_CTX()
2424 GLES_CM_TRACE()
2425 SET_ERROR_IF(!ctx->getCaps()->GL_EXT_FRAMEBUFFER_OBJECT,GL_INVALID_OPERATION);
2426 SET_ERROR_IF(!GLEScmValidate::renderbufferTarget(target) || !GLEScmValidate::renderbufferInternalFrmt(ctx,internalformat) ,GL_INVALID_ENUM);
2427 if (internalformat==GL_RGB565_OES) //RGB565 not supported by GL
2428 internalformat = GL_RGB8_OES;
2429
2430 // Get current bounded renderbuffer
2431 // raise INVALID_OPERATIOn if no renderbuffer is bounded
2432 GLuint rb = ctx->getRenderbufferBinding();
2433 SET_ERROR_IF(rb == 0,GL_INVALID_OPERATION);
2434 auto objData = ctx->shareGroup()->getObjectData(NamedObjectType::RENDERBUFFER, rb);
2435 RenderbufferData *rbData = (RenderbufferData *)objData;
2436 SET_ERROR_IF(!rbData,GL_INVALID_OPERATION);
2437
2438 //
2439 // if the renderbuffer was an eglImage target, release
2440 // its underlying texture.
2441 //
2442 rbData->eglImageGlobalTexObject.reset();
2443 rbData->saveableTexture.reset();
2444
2445 ctx->dispatcher().glRenderbufferStorageEXT(target,internalformat,width,height);
2446 }
2447
glGetRenderbufferParameterivOES(GLenum target,GLenum pname,GLint * params)2448 GL_API void GLAPIENTRY glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint* params) {
2449 GET_CTX()
2450 GLES_CM_TRACE()
2451 SET_ERROR_IF(!ctx->getCaps()->GL_EXT_FRAMEBUFFER_OBJECT,GL_INVALID_OPERATION);
2452 SET_ERROR_IF(!GLEScmValidate::renderbufferTarget(target) || !GLEScmValidate::renderbufferParams(pname) ,GL_INVALID_ENUM);
2453
2454 //
2455 // If this is a renderbuffer which is eglimage's target, we
2456 // should query the underlying eglimage's texture object instead.
2457 //
2458 GLuint rb = ctx->getRenderbufferBinding();
2459 if (rb) {
2460 auto objData = ctx->shareGroup()->getObjectData(
2461 NamedObjectType::RENDERBUFFER, rb);
2462 RenderbufferData *rbData = (RenderbufferData *)objData;
2463 if (rbData && rbData->eglImageGlobalTexObject) {
2464 GLenum texPname;
2465 switch(pname) {
2466 case GL_RENDERBUFFER_WIDTH_OES:
2467 texPname = GL_TEXTURE_WIDTH;
2468 break;
2469 case GL_RENDERBUFFER_HEIGHT_OES:
2470 texPname = GL_TEXTURE_HEIGHT;
2471 break;
2472 case GL_RENDERBUFFER_INTERNAL_FORMAT_OES:
2473 texPname = GL_TEXTURE_INTERNAL_FORMAT;
2474 break;
2475 case GL_RENDERBUFFER_RED_SIZE_OES:
2476 texPname = GL_TEXTURE_RED_SIZE;
2477 break;
2478 case GL_RENDERBUFFER_GREEN_SIZE_OES:
2479 texPname = GL_TEXTURE_GREEN_SIZE;
2480 break;
2481 case GL_RENDERBUFFER_BLUE_SIZE_OES:
2482 texPname = GL_TEXTURE_BLUE_SIZE;
2483 break;
2484 case GL_RENDERBUFFER_ALPHA_SIZE_OES:
2485 texPname = GL_TEXTURE_ALPHA_SIZE;
2486 break;
2487 case GL_RENDERBUFFER_DEPTH_SIZE_OES:
2488 texPname = GL_TEXTURE_DEPTH_SIZE;
2489 break;
2490 case GL_RENDERBUFFER_STENCIL_SIZE_OES:
2491 default:
2492 *params = 0; //XXX
2493 return;
2494 break;
2495 }
2496
2497 GLint prevTex;
2498 ctx->dispatcher().glGetIntegerv(GL_TEXTURE_BINDING_2D, &prevTex);
2499 ctx->dispatcher().glBindTexture(GL_TEXTURE_2D,
2500 rbData->eglImageGlobalTexObject->getGlobalName());
2501 ctx->dispatcher().glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
2502 texPname,
2503 params);
2504 ctx->dispatcher().glBindTexture(GL_TEXTURE_2D, prevTex);
2505 return;
2506 }
2507 }
2508
2509 ctx->dispatcher().glGetRenderbufferParameterivEXT(target,pname,params);
2510 }
2511
glIsFramebufferOES(GLuint framebuffer)2512 GL_API GLboolean GLAPIENTRY glIsFramebufferOES(GLuint framebuffer) {
2513 GET_CTX_RET(GL_FALSE)
2514 GLES_CM_TRACE()
2515 RET_AND_SET_ERROR_IF(!ctx->getCaps()->GL_EXT_FRAMEBUFFER_OBJECT,GL_INVALID_OPERATION,GL_FALSE);
2516 if (framebuffer) {
2517 return ctx->isFBO(framebuffer)
2518 ? GL_TRUE
2519 : GL_FALSE;
2520 }
2521 if (isCoreProfile() || isGles2Gles()) {
2522 return ctx->dispatcher().glIsFramebuffer(framebuffer);
2523 } else {
2524 return ctx->dispatcher().glIsFramebufferEXT(framebuffer);
2525 }
2526 }
2527
glBindFramebufferOES(GLenum target,GLuint framebuffer)2528 GL_API void GLAPIENTRY glBindFramebufferOES(GLenum target, GLuint framebuffer) {
2529 GET_CTX()
2530 GLES_CM_TRACE()
2531 SET_ERROR_IF(!ctx->getCaps()->GL_EXT_FRAMEBUFFER_OBJECT,GL_INVALID_OPERATION);
2532 SET_ERROR_IF(!GLEScmValidate::framebufferTarget(target) ,GL_INVALID_ENUM);
2533 if (framebuffer && !ctx->isFBO(framebuffer)) {
2534 ctx->genFBOName(framebuffer);
2535 ctx->setFBOData(framebuffer,
2536 ObjectDataPtr(
2537 new FramebufferData(
2538 framebuffer,
2539 ctx->getFBOGlobalName(framebuffer))));
2540 }
2541 int globalBufferName =
2542 (framebuffer != 0)
2543 ? ctx->getFBOGlobalName(framebuffer)
2544 : ctx->getDefaultFBOGlobalName();
2545 if (isCoreProfile() || isGles2Gles()) {
2546 ctx->dispatcher().glBindFramebuffer(target,globalBufferName);
2547 } else {
2548 ctx->dispatcher().glBindFramebufferEXT(target,globalBufferName);
2549 }
2550
2551 // update framebuffer binding state
2552 ctx->setFramebufferBinding(GL_FRAMEBUFFER_EXT, framebuffer);
2553 }
2554
glDeleteFramebuffersOES(GLsizei n,const GLuint * framebuffers)2555 GL_API void GLAPIENTRY glDeleteFramebuffersOES(GLsizei n, const GLuint *framebuffers) {
2556 GET_CTX()
2557 GLES_CM_TRACE()
2558 SET_ERROR_IF(!ctx->getCaps()->GL_EXT_FRAMEBUFFER_OBJECT,GL_INVALID_OPERATION);
2559 GLuint fbName = ctx->getFramebufferBinding(GL_FRAMEBUFFER_EXT);
2560 for (int i=0;i<n;++i) {
2561 if (framebuffers[i] == fbName)
2562 glBindFramebufferOES(GL_FRAMEBUFFER_EXT, 0);
2563 ctx->deleteFBO(framebuffers[i]);
2564 }
2565 }
2566
glGenFramebuffersOES(GLsizei n,GLuint * framebuffers)2567 GL_API void GLAPIENTRY glGenFramebuffersOES(GLsizei n, GLuint *framebuffers) {
2568 GET_CTX()
2569 GLES_CM_TRACE()
2570 SET_ERROR_IF(!ctx->getCaps()->GL_EXT_FRAMEBUFFER_OBJECT,GL_INVALID_OPERATION);
2571 SET_ERROR_IF(n<0,GL_INVALID_VALUE);
2572 for (int i=0;i<n;i++) {
2573 framebuffers[i] = ctx->genFBOName(0, true);
2574 ctx->setFBOData(framebuffers[i],
2575 ObjectDataPtr(
2576 new FramebufferData(
2577 framebuffers[i],
2578 ctx->getFBOGlobalName(framebuffers[i]))));
2579 }
2580 }
2581
glCheckFramebufferStatusOES(GLenum target)2582 GL_API GLenum GLAPIENTRY glCheckFramebufferStatusOES(GLenum target) {
2583 GET_CTX_RET(0)
2584 GLES_CM_TRACE()
2585 RET_AND_SET_ERROR_IF(!ctx->getCaps()->GL_EXT_FRAMEBUFFER_OBJECT,GL_INVALID_OPERATION,0);
2586 RET_AND_SET_ERROR_IF(!GLEScmValidate::framebufferTarget(target) ,GL_INVALID_ENUM,0);
2587 return ctx->dispatcher().glCheckFramebufferStatusEXT(target);
2588 }
2589
glFramebufferTexture2DOES(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level)2590 GL_API void GLAPIENTRY glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {
2591 GET_CTX()
2592 GLES_CM_TRACE()
2593 SET_ERROR_IF(!ctx->getCaps()->GL_EXT_FRAMEBUFFER_OBJECT,GL_INVALID_OPERATION);
2594 SET_ERROR_IF(!GLEScmValidate::framebufferTarget(target) || !GLEScmValidate::framebufferAttachment(attachment) ||
2595 !GLEScmValidate::textureTargetEx(textarget),GL_INVALID_ENUM);
2596 SET_ERROR_IF(!ctx->shareGroup().get(), GL_INVALID_OPERATION);
2597 SET_ERROR_IF(ctx->isDefaultFBOBound(target), GL_INVALID_OPERATION);
2598
2599 GLuint globalTexName = 0;
2600 if(texture) {
2601 if (!ctx->shareGroup()->isObject(NamedObjectType::TEXTURE, texture)) {
2602 ctx->shareGroup()->genName(NamedObjectType::TEXTURE, texture);
2603 }
2604 ObjectLocalName texname = ctx->getTextureLocalName(textarget,texture);
2605 globalTexName = ctx->shareGroup()->getGlobalName(
2606 NamedObjectType::TEXTURE, texname);
2607 }
2608
2609 ctx->dispatcher().glFramebufferTexture2DEXT(target,attachment,textarget,globalTexName,level);
2610
2611 // Update the the current framebuffer object attachment state
2612 GLuint fbName = ctx->getFramebufferBinding(GL_FRAMEBUFFER_EXT);
2613 auto fbObj = ctx->getFBOData(fbName);
2614 if (fbObj) {
2615 fbObj->setAttachment(
2616 ctx, attachment, textarget,
2617 texture, ObjectDataPtr());
2618 }
2619 }
2620
glFramebufferRenderbufferOES(GLenum target,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer)2621 GL_API void GLAPIENTRY glFramebufferRenderbufferOES(GLenum target, GLenum attachment,GLenum renderbuffertarget, GLuint renderbuffer) {
2622 GET_CTX()
2623 GLES_CM_TRACE()
2624 SET_ERROR_IF(!ctx->getCaps()->GL_EXT_FRAMEBUFFER_OBJECT,GL_INVALID_OPERATION);
2625 SET_ERROR_IF(!GLEScmValidate::framebufferTarget(target) ||
2626 !GLEScmValidate::framebufferAttachment(attachment) ||
2627 !GLEScmValidate::renderbufferTarget(renderbuffertarget), GL_INVALID_ENUM);
2628 SET_ERROR_IF(!ctx->shareGroup().get(), GL_INVALID_OPERATION);
2629 SET_ERROR_IF(ctx->isDefaultFBOBound(target), GL_INVALID_OPERATION);
2630
2631 GLuint globalBufferName = 0;
2632 ObjectDataPtr obj;
2633
2634 // generate the renderbuffer object if not yet exist
2635 if (renderbuffer) {
2636 if (!ctx->shareGroup()->isObject(NamedObjectType::RENDERBUFFER,
2637 renderbuffer)) {
2638 ctx->shareGroup()->genName(NamedObjectType::RENDERBUFFER,
2639 renderbuffer);
2640 obj = ObjectDataPtr(new RenderbufferData());
2641 ctx->shareGroup()->setObjectData(
2642 NamedObjectType::RENDERBUFFER, renderbuffer, obj);
2643 }
2644 else {
2645 obj = ctx->shareGroup()->getObjectDataPtr(
2646 NamedObjectType::RENDERBUFFER, renderbuffer);
2647 }
2648 globalBufferName = ctx->shareGroup()->getGlobalName(
2649 NamedObjectType::RENDERBUFFER, renderbuffer);
2650 }
2651
2652 // Update the the current framebuffer object attachment state
2653 GLuint fbName = ctx->getFramebufferBinding(GL_FRAMEBUFFER_EXT);
2654 auto fbObj = ctx->getFBOData(fbName);
2655 if (fbObj) {
2656 fbObj->setAttachment(
2657 ctx, attachment, renderbuffertarget, renderbuffer, obj);
2658 }
2659
2660 if (renderbuffer && obj.get() != NULL) {
2661 RenderbufferData *rbData = (RenderbufferData *)obj.get();
2662 if (rbData->eglImageGlobalTexObject) {
2663 //
2664 // This renderbuffer object is an eglImage target
2665 // attach the eglimage's texture instead the renderbuffer.
2666 //
2667 ctx->dispatcher().glFramebufferTexture2DEXT(target,
2668 attachment,
2669 GL_TEXTURE_2D,
2670 rbData->eglImageGlobalTexObject->getGlobalName(),
2671 0);
2672 return;
2673 }
2674 }
2675
2676 if (isCoreProfile() || isGles2Gles()) {
2677 ctx->dispatcher().glFramebufferRenderbuffer(target,attachment,renderbuffertarget,globalBufferName);
2678 } else {
2679 ctx->dispatcher().glFramebufferRenderbufferEXT(target,attachment,renderbuffertarget,globalBufferName);
2680 }
2681 }
2682
glGetFramebufferAttachmentParameterivOES(GLenum target,GLenum attachment,GLenum pname,GLint * params)2683 GL_API void GLAPIENTRY glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint *params) {
2684 GET_CTX()
2685 GLES_CM_TRACE()
2686 SET_ERROR_IF(!ctx->getCaps()->GL_EXT_FRAMEBUFFER_OBJECT,GL_INVALID_OPERATION);
2687 SET_ERROR_IF(!GLEScmValidate::framebufferTarget(target) || !GLEScmValidate::framebufferAttachment(attachment) ||
2688 !GLEScmValidate::framebufferAttachmentParams(pname), GL_INVALID_ENUM);
2689
2690 //
2691 // Take the attachment attribute from our state - if available
2692 //
2693 GLuint fbName = ctx->getFramebufferBinding(GL_FRAMEBUFFER_EXT);
2694 if (fbName) {
2695 auto fbObj = ctx->getFBOData(fbName);
2696 if (fbObj) {
2697 GLenum target;
2698 GLuint name = fbObj->getAttachment(attachment, &target, NULL);
2699 if (pname == GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES) {
2700 *params = target;
2701 return;
2702 }
2703 else if (pname == GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES) {
2704 *params = name;
2705 return;
2706 }
2707 }
2708 }
2709
2710 if (ctx->isDefaultFBOBound(target)) {
2711 SET_ERROR_IF(
2712 attachment == GL_DEPTH_ATTACHMENT ||
2713 attachment == GL_STENCIL_ATTACHMENT ||
2714 attachment == GL_DEPTH_STENCIL_ATTACHMENT ||
2715 (attachment >= GL_COLOR_ATTACHMENT0 &&
2716 attachment <= GL_COLOR_ATTACHMENT15), GL_INVALID_OPERATION);
2717 SET_ERROR_IF(pname == GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, GL_INVALID_ENUM);
2718
2719 if (attachment == GL_BACK)
2720 attachment = GL_COLOR_ATTACHMENT0;
2721 if (attachment == GL_DEPTH)
2722 attachment = GL_DEPTH_ATTACHMENT;
2723 if (attachment == GL_STENCIL)
2724 attachment = GL_STENCIL_ATTACHMENT;
2725 }
2726
2727 ctx->dispatcher().glGetFramebufferAttachmentParameterivEXT(target,attachment,pname,params);
2728
2729 if (ctx->isDefaultFBOBound(target) && *params == GL_RENDERBUFFER) {
2730 *params = GL_FRAMEBUFFER_DEFAULT;
2731 }
2732 }
2733
glGenerateMipmapOES(GLenum target)2734 GL_API void GL_APIENTRY glGenerateMipmapOES(GLenum target) {
2735 GET_CTX()
2736 GLES_CM_TRACE()
2737 SET_ERROR_IF(!ctx->getCaps()->GL_EXT_FRAMEBUFFER_OBJECT,GL_INVALID_OPERATION);
2738 SET_ERROR_IF(!GLEScmValidate::textureTargetLimited(target),GL_INVALID_ENUM);
2739 if (ctx->shareGroup().get()) {
2740 TextureData *texData = getTextureTargetData(target);
2741 if (texData) {
2742 unsigned int width = texData->width;
2743 unsigned int height = texData->height;
2744 // set error code if either the width or height is not a power of two.
2745 SET_ERROR_IF(width == 0 || height == 0 ||
2746 (width & (width - 1)) != 0 || (height & (height - 1)) != 0,
2747 GL_INVALID_OPERATION);
2748 texData->setMipmapLevelAtLeast(maxMipmapLevel(texData->width,
2749 texData->height));
2750 }
2751 }
2752 ctx->dispatcher().glGenerateMipmapEXT(target);
2753 }
2754
glCurrentPaletteMatrixOES(GLuint index)2755 GL_API void GL_APIENTRY glCurrentPaletteMatrixOES(GLuint index) {
2756 GET_CTX()
2757 GLES_CM_TRACE()
2758 SET_ERROR_IF(!(ctx->getCaps()->GL_ARB_MATRIX_PALETTE && ctx->getCaps()->GL_ARB_VERTEX_BLEND),GL_INVALID_OPERATION);
2759 ctx->dispatcher().glCurrentPaletteMatrixARB(index);
2760 }
2761
glLoadPaletteFromModelViewMatrixOES()2762 GL_API void GL_APIENTRY glLoadPaletteFromModelViewMatrixOES() {
2763 GET_CTX()
2764 GLES_CM_TRACE()
2765 SET_ERROR_IF(!(ctx->getCaps()->GL_ARB_MATRIX_PALETTE && ctx->getCaps()->GL_ARB_VERTEX_BLEND),GL_INVALID_OPERATION);
2766 GLint matrix[16];
2767 ctx->dispatcher().glGetIntegerv(GL_MODELVIEW_MATRIX,matrix);
2768 ctx->dispatcher().glMatrixIndexuivARB(1,(GLuint*)matrix);
2769
2770 }
2771
glMatrixIndexPointerOES(GLint size,GLenum type,GLsizei stride,const GLvoid * pointer)2772 GL_API void GL_APIENTRY glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
2773 GET_CTX()
2774 GLES_CM_TRACE()
2775 SET_ERROR_IF(!(ctx->getCaps()->GL_ARB_MATRIX_PALETTE && ctx->getCaps()->GL_ARB_VERTEX_BLEND),GL_INVALID_OPERATION);
2776 ctx->dispatcher().glMatrixIndexPointerARB(size,type,stride,pointer);
2777 }
2778
glWeightPointerOES(GLint size,GLenum type,GLsizei stride,const GLvoid * pointer)2779 GL_API void GL_APIENTRY glWeightPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
2780 GET_CTX()
2781 GLES_CM_TRACE()
2782 SET_ERROR_IF(!(ctx->getCaps()->GL_ARB_MATRIX_PALETTE && ctx->getCaps()->GL_ARB_VERTEX_BLEND),GL_INVALID_OPERATION);
2783 ctx->dispatcher().glWeightPointerARB(size,type,stride,pointer);
2784
2785 }
2786
glTexGenfOES(GLenum coord,GLenum pname,GLfloat param)2787 GL_API void GL_APIENTRY glTexGenfOES (GLenum coord, GLenum pname, GLfloat param) {
2788 GET_CTX()
2789 GLES_CM_TRACE()
2790 SET_ERROR_IF(!GLEScmValidate::texGen(coord,pname),GL_INVALID_ENUM);
2791 if (coord == GL_TEXTURE_GEN_STR_OES) {
2792 ctx->dispatcher().glTexGenf(GL_S,pname,param);
2793 ctx->dispatcher().glTexGenf(GL_T,pname,param);
2794 ctx->dispatcher().glTexGenf(GL_R,pname,param);
2795 }
2796 else
2797 ctx->dispatcher().glTexGenf(coord,pname,param);
2798 }
2799
glTexGenfvOES(GLenum coord,GLenum pname,const GLfloat * params)2800 GL_API void GL_APIENTRY glTexGenfvOES (GLenum coord, GLenum pname, const GLfloat *params) {
2801 GET_CTX()
2802 GLES_CM_TRACE()
2803 SET_ERROR_IF(!GLEScmValidate::texGen(coord,pname),GL_INVALID_ENUM);
2804 if (coord == GL_TEXTURE_GEN_STR_OES) {
2805 ctx->dispatcher().glTexGenfv(GL_S,pname,params);
2806 ctx->dispatcher().glTexGenfv(GL_T,pname,params);
2807 ctx->dispatcher().glTexGenfv(GL_R,pname,params);
2808 }
2809 else
2810 ctx->dispatcher().glTexGenfv(coord,pname,params);
2811 }
glTexGeniOES(GLenum coord,GLenum pname,GLint param)2812 GL_API void GL_APIENTRY glTexGeniOES (GLenum coord, GLenum pname, GLint param) {
2813 GET_CTX_CM()
2814 GLES_CM_TRACE()
2815 SET_ERROR_IF(!GLEScmValidate::texGen(coord,pname),GL_INVALID_ENUM);
2816 ctx->texGeni(coord, pname, param);
2817 }
glTexGenivOES(GLenum coord,GLenum pname,const GLint * params)2818 GL_API void GL_APIENTRY glTexGenivOES (GLenum coord, GLenum pname, const GLint *params) {
2819 GET_CTX_CM()
2820 GLES_CM_TRACE()
2821 SET_ERROR_IF(!GLEScmValidate::texGen(coord,pname),GL_INVALID_ENUM);
2822 ctx->texGeniv(coord, pname, params);
2823 }
glTexGenxOES(GLenum coord,GLenum pname,GLfixed param)2824 GL_API void GL_APIENTRY glTexGenxOES (GLenum coord, GLenum pname, GLfixed param) {
2825 GET_CTX_CM()
2826 GLES_CM_TRACE()
2827 SET_ERROR_IF(!GLEScmValidate::texGen(coord,pname),GL_INVALID_ENUM);
2828 ctx->texGenf(coord, pname, X2F(param));
2829 }
glTexGenxvOES(GLenum coord,GLenum pname,const GLfixed * params)2830 GL_API void GL_APIENTRY glTexGenxvOES (GLenum coord, GLenum pname, const GLfixed *params) {
2831 GET_CTX_CM()
2832 GLES_CM_TRACE()
2833 SET_ERROR_IF(!GLEScmValidate::texGen(coord,pname),GL_INVALID_ENUM);
2834 GLfloat tmpParams[1];
2835 tmpParams[0] = X2F(params[0]);
2836 ctx->texGenfv(coord, pname, tmpParams);
2837 }
2838
glGetTexGenfvOES(GLenum coord,GLenum pname,GLfloat * params)2839 GL_API void GL_APIENTRY glGetTexGenfvOES (GLenum coord, GLenum pname, GLfloat *params) {
2840 GET_CTX_CM()
2841 GLES_CM_TRACE()
2842 ctx->getTexGenfv(coord, pname, params);
2843 }
glGetTexGenivOES(GLenum coord,GLenum pname,GLint * params)2844 GL_API void GL_APIENTRY glGetTexGenivOES (GLenum coord, GLenum pname, GLint *params) {
2845 GET_CTX_CM()
2846 GLES_CM_TRACE()
2847 ctx->getTexGeniv(coord, pname, params);
2848 }
2849
glGetTexGenxvOES(GLenum coord,GLenum pname,GLfixed * params)2850 GL_API void GL_APIENTRY glGetTexGenxvOES (GLenum coord, GLenum pname, GLfixed *params) {
2851 GET_CTX_CM()
2852 GLES_CM_TRACE()
2853 GLfloat tmpParams[1];
2854 ctx->getTexGenfv(coord, pname, tmpParams);
2855 params[0] = F2X(tmpParams[0]);
2856 }
2857
2858
2859 template <class T, GLenum TypeName>
glDrawTexOES(T x,T y,T z,T width,T height)2860 void glDrawTexOES (T x, T y, T z, T width, T height) {
2861 GET_CTX_CM()
2862 GLES_CM_TRACE()
2863
2864 SET_ERROR_IF((width<=0 || height<=0),GL_INVALID_VALUE);
2865
2866 ctx->drawValidate();
2867 ctx->drawTexOES((float)x, (float)y, (float)z, (float)width, (float)height);
2868 }
2869
glDrawTexsOES(GLshort x,GLshort y,GLshort z,GLshort width,GLshort height)2870 GL_API void GL_APIENTRY glDrawTexsOES (GLshort x, GLshort y, GLshort z, GLshort width, GLshort height) {
2871 GET_CTX_CM()
2872 GLES_CM_TRACE()
2873 glDrawTexOES<GLshort,GL_SHORT>(x,y,z,width,height);
2874 }
2875
glDrawTexiOES(GLint x,GLint y,GLint z,GLint width,GLint height)2876 GL_API void GL_APIENTRY glDrawTexiOES (GLint x, GLint y, GLint z, GLint width, GLint height) {
2877 GET_CTX_CM()
2878 GLES_CM_TRACE()
2879 glDrawTexOES<GLint,GL_INT>(x,y,z,width,height);
2880 }
2881
glDrawTexfOES(GLfloat x,GLfloat y,GLfloat z,GLfloat width,GLfloat height)2882 GL_API void GL_APIENTRY glDrawTexfOES (GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height) {
2883 GET_CTX_CM()
2884 GLES_CM_TRACE()
2885 glDrawTexOES<GLfloat,GL_FLOAT>(x,y,z,width,height);
2886 }
2887
glDrawTexxOES(GLfixed x,GLfixed y,GLfixed z,GLfixed width,GLfixed height)2888 GL_API void GL_APIENTRY glDrawTexxOES (GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height) {
2889 GET_CTX_CM()
2890 GLES_CM_TRACE()
2891 glDrawTexOES<GLfloat,GL_FLOAT>(X2F(x),X2F(y),X2F(z),X2F(width),X2F(height));
2892 }
2893
glDrawTexsvOES(const GLshort * coords)2894 GL_API void GL_APIENTRY glDrawTexsvOES (const GLshort * coords) {
2895 GET_CTX_CM()
2896 GLES_CM_TRACE()
2897 glDrawTexOES<GLshort,GL_SHORT>(coords[0],coords[1],coords[2],coords[3],coords[4]);
2898 }
2899
glDrawTexivOES(const GLint * coords)2900 GL_API void GL_APIENTRY glDrawTexivOES (const GLint * coords) {
2901 GET_CTX_CM()
2902 GLES_CM_TRACE()
2903 glDrawTexOES<GLint,GL_INT>(coords[0],coords[1],coords[2],coords[3],coords[4]);
2904 }
2905
glDrawTexfvOES(const GLfloat * coords)2906 GL_API void GL_APIENTRY glDrawTexfvOES (const GLfloat * coords) {
2907 GET_CTX_CM()
2908 GLES_CM_TRACE()
2909 glDrawTexOES<GLfloat,GL_FLOAT>(coords[0],coords[1],coords[2],coords[3],coords[4]);
2910 }
2911
glDrawTexxvOES(const GLfixed * coords)2912 GL_API void GL_APIENTRY glDrawTexxvOES (const GLfixed * coords) {
2913 GET_CTX_CM()
2914 GLES_CM_TRACE()
2915 glDrawTexOES<GLfloat,GL_FLOAT>(X2F(coords[0]),X2F(coords[1]),X2F(coords[2]),X2F(coords[3]),X2F(coords[4]));
2916 }
2917
2918 } // namespace translator
2919 } // namespace gles1
2920