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_APICALL
19 #define GL_API __declspec(dllexport)
20 #define GL_APICALL __declspec(dllexport)
21 #endif
22
23 #define GL_GLEXT_PROTOTYPES
24 #include <stdio.h>
25 #include <GLES2/gl2.h>
26 #include <GLES2/gl2ext.h>
27 #include <GLcommon/TranslatorIfaces.h>
28 #include <GLcommon/gldefs.h>
29 #include "GLESv2Context.h"
30 #include "GLESv2Validate.h"
31 #include "ShaderParser.h"
32 #include "ProgramData.h"
33 #include <GLcommon/TextureUtils.h>
34 #include <GLcommon/FramebufferData.h>
35
36 extern "C" {
37
38 //decleration
39 static void initContext(GLEScontext* ctx,ShareGroupPtr grp);
40 static void deleteGLESContext(GLEScontext* ctx);
41 static void setShareGroup(GLEScontext* ctx,ShareGroupPtr grp);
42 static GLEScontext* createGLESContext();
43 static __translatorMustCastToProperFunctionPointerType getProcAddress(const char* procName);
44
45 }
46
47 /************************************** GLES EXTENSIONS *********************************************************/
48 //extentions descriptor
49 typedef std::map<std::string, __translatorMustCastToProperFunctionPointerType> ProcTableMap;
50 ProcTableMap *s_glesExtensions = NULL;
51 /****************************************************************************************************************/
52
53 static EGLiface* s_eglIface = NULL;
54 static GLESiface s_glesIface = {
55 createGLESContext:createGLESContext,
56 initContext :initContext,
57 deleteGLESContext:deleteGLESContext,
58 flush :(FUNCPTR)glFlush,
59 finish :(FUNCPTR)glFinish,
60 setShareGroup :setShareGroup,
61 getProcAddress :getProcAddress
62 };
63
64 #include <GLcommon/GLESmacros.h>
65
66 extern "C" {
67
initContext(GLEScontext * ctx,ShareGroupPtr grp)68 static void initContext(GLEScontext* ctx,ShareGroupPtr grp) {
69 if (!ctx->isInitialized()) {
70 ctx->setShareGroup(grp);
71 ctx->init();
72 glBindTexture(GL_TEXTURE_2D,0);
73 glBindTexture(GL_TEXTURE_CUBE_MAP,0);
74 }
75 }
createGLESContext()76 static GLEScontext* createGLESContext() {
77 return new GLESv2Context();
78 }
79
deleteGLESContext(GLEScontext * ctx)80 static void deleteGLESContext(GLEScontext* ctx) {
81 delete ctx;
82 }
83
setShareGroup(GLEScontext * ctx,ShareGroupPtr grp)84 static void setShareGroup(GLEScontext* ctx,ShareGroupPtr grp) {
85 if(ctx) {
86 ctx->setShareGroup(grp);
87 }
88 }
89
getProcAddress(const char * procName)90 static __translatorMustCastToProperFunctionPointerType getProcAddress(const char* procName) {
91 GET_CTX_RET(NULL)
92 ctx->getGlobalLock();
93 static bool proc_table_initialized = false;
94 if (!proc_table_initialized) {
95 proc_table_initialized = true;
96 if (!s_glesExtensions)
97 s_glesExtensions = new ProcTableMap();
98 else
99 s_glesExtensions->clear();
100 (*s_glesExtensions)["glEGLImageTargetTexture2DOES"] = (__translatorMustCastToProperFunctionPointerType)glEGLImageTargetTexture2DOES;
101 (*s_glesExtensions)["glEGLImageTargetRenderbufferStorageOES"]=(__translatorMustCastToProperFunctionPointerType)glEGLImageTargetRenderbufferStorageOES;
102 }
103 __translatorMustCastToProperFunctionPointerType ret=NULL;
104 ProcTableMap::iterator val = s_glesExtensions->find(procName);
105 if (val!=s_glesExtensions->end())
106 ret = val->second;
107 ctx->releaseGlobalLock();
108
109 return ret;
110 }
111
__translator_getIfaces(EGLiface * eglIface)112 GL_APICALL GLESiface* __translator_getIfaces(EGLiface* eglIface){
113 s_eglIface = eglIface;
114 return & s_glesIface;
115 }
116
117 }
118
TextureLocalName(GLenum target,unsigned int tex)119 static ObjectLocalName TextureLocalName(GLenum target,unsigned int tex) {
120 GET_CTX_RET(0);
121 return (tex!=0? tex : ctx->getDefaultTextureName(target));
122 }
123
getTextureData(ObjectLocalName tex)124 static TextureData* getTextureData(ObjectLocalName tex) {
125 GET_CTX_RET(NULL);
126 TextureData *texData = NULL;
127 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(TEXTURE,tex);
128 if(!objData.Ptr()){
129 texData = new TextureData();
130 ctx->shareGroup()->setObjectData(TEXTURE, tex, ObjectDataPtr(texData));
131 } else {
132 texData = (TextureData*)objData.Ptr();
133 }
134 return texData;
135 }
136
getTextureTargetData(GLenum target)137 static TextureData* getTextureTargetData(GLenum target){
138 GET_CTX_RET(NULL);
139 unsigned int tex = ctx->getBindedTexture(target);
140 return getTextureData(TextureLocalName(target,tex));
141 }
142
glActiveTexture(GLenum texture)143 GL_APICALL void GL_APIENTRY glActiveTexture(GLenum texture){
144 GET_CTX_V2();
145 SET_ERROR_IF (!GLESv2Validate::textureEnum(texture,ctx->getMaxTexUnits()),GL_INVALID_ENUM);
146 ctx->setActiveTexture(texture);
147 ctx->dispatcher().glActiveTexture(texture);
148 }
149
glAttachShader(GLuint program,GLuint shader)150 GL_APICALL void GL_APIENTRY glAttachShader(GLuint program, GLuint shader){
151 GET_CTX();
152 if(ctx->shareGroup().Ptr()) {
153 const GLuint globalProgramName = ctx->shareGroup()->getGlobalName(SHADER,program);
154 SET_ERROR_IF(globalProgramName==0, GL_INVALID_VALUE);
155 const GLuint globalShaderName = ctx->shareGroup()->getGlobalName(SHADER,shader);
156 SET_ERROR_IF(globalShaderName==0, GL_INVALID_VALUE);
157
158 ObjectDataPtr programData = ctx->shareGroup()->getObjectData(SHADER,program);
159 ObjectDataPtr shaderData = ctx->shareGroup()->getObjectData(SHADER,shader);
160 SET_ERROR_IF(!shaderData.Ptr() || !programData.Ptr() ,GL_INVALID_OPERATION);
161 SET_ERROR_IF(!(shaderData.Ptr()->getDataType() ==SHADER_DATA) ||
162 !(programData.Ptr()->getDataType()==PROGRAM_DATA) ,GL_INVALID_OPERATION);
163
164 GLenum shaderType = ((ShaderParser*)shaderData.Ptr())->getType();
165 ProgramData* pData = (ProgramData*)programData.Ptr();
166 SET_ERROR_IF((pData->getAttachedShader(shaderType)!=0), GL_INVALID_OPERATION);
167 pData->attachShader(shader,shaderType);
168 ctx->dispatcher().glAttachShader(globalProgramName,globalShaderName);
169 }
170 }
171
glBindAttribLocation(GLuint program,GLuint index,const GLchar * name)172 GL_APICALL void GL_APIENTRY glBindAttribLocation(GLuint program, GLuint index, const GLchar* name){
173 GET_CTX();
174 SET_ERROR_IF(!GLESv2Validate::attribName(name),GL_INVALID_OPERATION);
175 SET_ERROR_IF(!GLESv2Validate::attribIndex(index),GL_INVALID_VALUE);
176 if(ctx->shareGroup().Ptr()) {
177 const GLuint globalProgramName = ctx->shareGroup()->getGlobalName(SHADER,program);
178 SET_ERROR_IF(globalProgramName==0, GL_INVALID_VALUE);
179 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,program);
180 SET_ERROR_IF(objData.Ptr()->getDataType()!=PROGRAM_DATA,GL_INVALID_OPERATION);
181
182 ctx->dispatcher().glBindAttribLocation(globalProgramName,index,name);
183 }
184 }
185
glBindBuffer(GLenum target,GLuint buffer)186 GL_APICALL void GL_APIENTRY glBindBuffer(GLenum target, GLuint buffer){
187 GET_CTX();
188 SET_ERROR_IF(!GLESv2Validate::bufferTarget(target),GL_INVALID_ENUM);
189 //if buffer wasn't generated before,generate one
190 if(buffer && ctx->shareGroup().Ptr() && !ctx->shareGroup()->isObject(VERTEXBUFFER,buffer)){
191 ctx->shareGroup()->genName(VERTEXBUFFER,buffer);
192 ctx->shareGroup()->setObjectData(VERTEXBUFFER,buffer,ObjectDataPtr(new GLESbuffer()));
193 }
194 ctx->bindBuffer(target,buffer);
195 if (buffer) {
196 GLESbuffer* vbo = (GLESbuffer*)ctx->shareGroup()->getObjectData(VERTEXBUFFER,buffer).Ptr();
197 vbo->setBinded();
198 }
199 }
200
glBindFramebuffer(GLenum target,GLuint framebuffer)201 GL_APICALL void GL_APIENTRY glBindFramebuffer(GLenum target, GLuint framebuffer){
202 GET_CTX();
203 SET_ERROR_IF(!GLESv2Validate::framebufferTarget(target),GL_INVALID_ENUM);
204
205 GLuint globalFrameBufferName = framebuffer;
206 if(framebuffer && ctx->shareGroup().Ptr()){
207 globalFrameBufferName = ctx->shareGroup()->getGlobalName(FRAMEBUFFER,framebuffer);
208 //if framebuffer wasn't generated before,generate one
209 if(!globalFrameBufferName){
210 ctx->shareGroup()->genName(FRAMEBUFFER,framebuffer);
211 ctx->shareGroup()->setObjectData(FRAMEBUFFER, framebuffer,
212 ObjectDataPtr(new FramebufferData(framebuffer)));
213 globalFrameBufferName = ctx->shareGroup()->getGlobalName(FRAMEBUFFER,framebuffer);
214 }
215 }
216 ctx->dispatcher().glBindFramebufferEXT(target,globalFrameBufferName);
217
218 // update framebuffer binding state
219 ctx->setFramebufferBinding(framebuffer);
220 }
221
glBindRenderbuffer(GLenum target,GLuint renderbuffer)222 GL_APICALL void GL_APIENTRY glBindRenderbuffer(GLenum target, GLuint renderbuffer){
223 GET_CTX();
224 SET_ERROR_IF(!GLESv2Validate::renderbufferTarget(target),GL_INVALID_ENUM);
225
226 GLuint globalRenderBufferName = renderbuffer;
227 if(renderbuffer && ctx->shareGroup().Ptr()){
228 globalRenderBufferName = ctx->shareGroup()->getGlobalName(RENDERBUFFER,renderbuffer);
229 //if renderbuffer wasn't generated before,generate one
230 if(!globalRenderBufferName){
231 ctx->shareGroup()->genName(RENDERBUFFER,renderbuffer);
232 ctx->shareGroup()->setObjectData(RENDERBUFFER,
233 renderbuffer,
234 ObjectDataPtr(new RenderbufferData()));
235 globalRenderBufferName = ctx->shareGroup()->getGlobalName(RENDERBUFFER,renderbuffer);
236 }
237 }
238 ctx->dispatcher().glBindRenderbufferEXT(target,globalRenderBufferName);
239
240 // update renderbuffer binding state
241 ctx->setRenderbufferBinding(renderbuffer);
242 }
243
glBindTexture(GLenum target,GLuint texture)244 GL_APICALL void GL_APIENTRY glBindTexture(GLenum target, GLuint texture){
245 GET_CTX();
246 SET_ERROR_IF(!GLESv2Validate::textureTarget(target),GL_INVALID_ENUM)
247
248 //for handling default texture (0)
249 ObjectLocalName localTexName = TextureLocalName(target,texture);
250
251 GLuint globalTextureName = localTexName;
252 if(ctx->shareGroup().Ptr()){
253 globalTextureName = ctx->shareGroup()->getGlobalName(TEXTURE,localTexName);
254 //if texture wasn't generated before,generate one
255 if(!globalTextureName){
256 ctx->shareGroup()->genName(TEXTURE,localTexName);
257 globalTextureName = ctx->shareGroup()->getGlobalName(TEXTURE,localTexName);
258 }
259
260 TextureData* texData = getTextureData(localTexName);
261 if (texData->target==0)
262 texData->target = target;
263 //if texture was already bound to another target
264 SET_ERROR_IF(ctx->GLTextureTargetToLocal(texData->target) != ctx->GLTextureTargetToLocal(target), GL_INVALID_OPERATION);
265 texData->wasBound = true;
266 }
267
268 ctx->setBindedTexture(target,texture);
269 ctx->dispatcher().glBindTexture(target,globalTextureName);
270 }
271
glBlendColor(GLclampf red,GLclampf green,GLclampf blue,GLclampf alpha)272 GL_APICALL void GL_APIENTRY glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha){
273 GET_CTX();
274 ctx->dispatcher().glBlendColor(red,green,blue,alpha);
275 }
276
glBlendEquation(GLenum mode)277 GL_APICALL void GL_APIENTRY glBlendEquation( GLenum mode ){
278 GET_CTX();
279 SET_ERROR_IF(!GLESv2Validate::blendEquationMode(mode),GL_INVALID_ENUM)
280 ctx->dispatcher().glBlendEquation(mode);
281 }
282
glBlendEquationSeparate(GLenum modeRGB,GLenum modeAlpha)283 GL_APICALL void GL_APIENTRY glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha){
284 GET_CTX();
285 SET_ERROR_IF(!(GLESv2Validate::blendEquationMode(modeRGB) && GLESv2Validate::blendEquationMode(modeAlpha)),GL_INVALID_ENUM);
286 ctx->dispatcher().glBlendEquationSeparate(modeRGB,modeAlpha);
287 }
288
glBlendFunc(GLenum sfactor,GLenum dfactor)289 GL_APICALL void GL_APIENTRY glBlendFunc(GLenum sfactor, GLenum dfactor){
290 GET_CTX();
291 SET_ERROR_IF(!GLESv2Validate::blendSrc(sfactor) || !GLESv2Validate::blendDst(dfactor),GL_INVALID_ENUM)
292 ctx->dispatcher().glBlendFunc(sfactor,dfactor);
293 }
294
glBlendFuncSeparate(GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)295 GL_APICALL void GL_APIENTRY glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha){
296 GET_CTX();
297 SET_ERROR_IF(
298 !(GLESv2Validate::blendSrc(srcRGB) && GLESv2Validate::blendDst(dstRGB) && GLESv2Validate::blendSrc(srcAlpha) && GLESv2Validate::blendDst(dstAlpha)),GL_INVALID_ENUM);
299 ctx->dispatcher().glBlendFuncSeparate(srcRGB,dstRGB,srcAlpha,dstAlpha);
300 }
301
glBufferData(GLenum target,GLsizeiptr size,const GLvoid * data,GLenum usage)302 GL_APICALL void GL_APIENTRY glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage){
303 GET_CTX();
304 SET_ERROR_IF(!GLESv2Validate::bufferTarget(target),GL_INVALID_ENUM);
305 SET_ERROR_IF(!ctx->isBindedBuffer(target),GL_INVALID_OPERATION);
306 ctx->setBufferData(target,size,data,usage);
307 }
308
glBufferSubData(GLenum target,GLintptr offset,GLsizeiptr size,const GLvoid * data)309 GL_APICALL void GL_APIENTRY glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data){
310 GET_CTX();
311 SET_ERROR_IF(!ctx->isBindedBuffer(target),GL_INVALID_OPERATION);
312 SET_ERROR_IF(!GLESv2Validate::bufferTarget(target),GL_INVALID_ENUM);
313 SET_ERROR_IF(!ctx->setBufferSubData(target,offset,size,data),GL_INVALID_VALUE);
314 }
315
316
glCheckFramebufferStatus(GLenum target)317 GL_APICALL GLenum GL_APIENTRY glCheckFramebufferStatus(GLenum target){
318 GET_CTX_RET(GL_FRAMEBUFFER_COMPLETE);
319 RET_AND_SET_ERROR_IF(!GLESv2Validate::framebufferTarget(target),GL_INVALID_ENUM,GL_FRAMEBUFFER_COMPLETE);
320 ctx->drawValidate();
321 return ctx->dispatcher().glCheckFramebufferStatusEXT(target);
322 }
323
glClear(GLbitfield mask)324 GL_APICALL void GL_APIENTRY glClear(GLbitfield mask){
325 GET_CTX();
326 ctx->drawValidate();
327
328 ctx->dispatcher().glClear(mask);
329 }
glClearColor(GLclampf red,GLclampf green,GLclampf blue,GLclampf alpha)330 GL_APICALL void GL_APIENTRY glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha){
331 GET_CTX();
332 ctx->dispatcher().glClearColor(red,green,blue,alpha);
333 }
glClearDepthf(GLclampf depth)334 GL_APICALL void GL_APIENTRY glClearDepthf(GLclampf depth){
335 GET_CTX();
336 ctx->dispatcher().glClearDepth(depth);
337 }
glClearStencil(GLint s)338 GL_APICALL void GL_APIENTRY glClearStencil(GLint s){
339 GET_CTX();
340 ctx->dispatcher().glClearStencil(s);
341 }
glColorMask(GLboolean red,GLboolean green,GLboolean blue,GLboolean alpha)342 GL_APICALL void GL_APIENTRY glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha){
343 GET_CTX();
344 ctx->dispatcher().glColorMask(red,green,blue,alpha);
345 }
346
glCompileShader(GLuint shader)347 GL_APICALL void GL_APIENTRY glCompileShader(GLuint shader){
348 GET_CTX();
349 if(ctx->shareGroup().Ptr()) {
350 const GLuint globalShaderName = ctx->shareGroup()->getGlobalName(SHADER,shader);
351 SET_ERROR_IF(globalShaderName==0, GL_INVALID_VALUE);
352 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,shader);
353 SET_ERROR_IF(objData.Ptr()->getDataType()!= SHADER_DATA,GL_INVALID_OPERATION);
354 ShaderParser* sp = (ShaderParser*)objData.Ptr();
355 ctx->dispatcher().glCompileShader(globalShaderName);
356
357 GLsizei infoLogLength=0;
358 GLchar* infoLog;
359 ctx->dispatcher().glGetShaderiv(globalShaderName,GL_INFO_LOG_LENGTH,&infoLogLength);
360 infoLog = new GLchar[infoLogLength+1];
361 ctx->dispatcher().glGetShaderInfoLog(globalShaderName,infoLogLength,NULL,infoLog);
362 sp->setInfoLog(infoLog);
363 }
364 }
365
glCompressedTexImage2D(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const GLvoid * data)366 GL_APICALL void GL_APIENTRY glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data)
367 {
368 GET_CTX();
369 SET_ERROR_IF(!GLESv2Validate::textureTargetEx(target),GL_INVALID_ENUM);
370
371 doCompressedTexImage2D(ctx, target, level, internalformat,
372 width, height, border,
373 imageSize, data, (void*)glTexImage2D);
374 }
375
glCompressedTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const GLvoid * data)376 GL_APICALL void GL_APIENTRY glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data){
377 GET_CTX();
378 SET_ERROR_IF(!GLESv2Validate::textureTargetEx(target),GL_INVALID_ENUM);
379 ctx->dispatcher().glCompressedTexSubImage2D(target,level,xoffset,yoffset,width,height,format,imageSize,data);
380 }
381
glCopyTexImage2D(GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height,GLint border)382 GL_APICALL void GL_APIENTRY glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border){
383 GET_CTX();
384 SET_ERROR_IF(!(GLESv2Validate::pixelFrmt(ctx,internalformat) && GLESv2Validate::textureTargetEx(target)),GL_INVALID_ENUM);
385 SET_ERROR_IF(border != 0,GL_INVALID_VALUE);
386 ctx->dispatcher().glCopyTexImage2D(target,level,internalformat,x,y,width,height,border);
387 }
388
glCopyTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height)389 GL_APICALL void GL_APIENTRY glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height){
390 GET_CTX();
391 SET_ERROR_IF(!GLESv2Validate::textureTargetEx(target),GL_INVALID_ENUM);
392 ctx->dispatcher().glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height);
393 }
394
glCreateProgram(void)395 GL_APICALL GLuint GL_APIENTRY glCreateProgram(void){
396 GET_CTX_RET(0);
397 const GLuint globalProgramName = ctx->dispatcher().glCreateProgram();
398 if(ctx->shareGroup().Ptr() && globalProgramName) {
399 ProgramData* programInfo = new ProgramData();
400 const GLuint localProgramName = ctx->shareGroup()->genName(SHADER, 0, true);
401 ctx->shareGroup()->replaceGlobalName(SHADER,localProgramName,globalProgramName);
402 ctx->shareGroup()->setObjectData(SHADER,localProgramName,ObjectDataPtr(programInfo));
403 return localProgramName;
404 }
405 if(globalProgramName){
406 ctx->dispatcher().glDeleteProgram(globalProgramName);
407 }
408 return 0;
409 }
410
glCreateShader(GLenum type)411 GL_APICALL GLuint GL_APIENTRY glCreateShader(GLenum type){
412 GET_CTX_V2_RET(0);
413 RET_AND_SET_ERROR_IF(!GLESv2Validate::shaderType(type),GL_INVALID_ENUM,0);
414 const GLuint globalShaderName = ctx->dispatcher().glCreateShader(type);
415 if(ctx->shareGroup().Ptr() && globalShaderName) {
416 const GLuint localShaderName = ctx->shareGroup()->genName(SHADER, 0, true);
417 ShaderParser* sp = new ShaderParser(type);
418 ctx->shareGroup()->replaceGlobalName(SHADER,localShaderName,globalShaderName);
419 ctx->shareGroup()->setObjectData(SHADER,localShaderName,ObjectDataPtr(sp));
420 return localShaderName;
421 }
422 if(globalShaderName){
423 ctx->dispatcher().glDeleteShader(globalShaderName);
424 }
425 return 0;
426 }
427
glCullFace(GLenum mode)428 GL_APICALL void GL_APIENTRY glCullFace(GLenum mode){
429 GET_CTX();
430 ctx->dispatcher().glCullFace(mode);
431 }
432
glDeleteBuffers(GLsizei n,const GLuint * buffers)433 GL_APICALL void GL_APIENTRY glDeleteBuffers(GLsizei n, const GLuint* buffers){
434 GET_CTX();
435 SET_ERROR_IF(n<0,GL_INVALID_VALUE);
436 if(ctx->shareGroup().Ptr()) {
437 for(int i=0; i < n; i++){
438 ctx->shareGroup()->deleteName(VERTEXBUFFER,buffers[i]);
439 }
440 }
441 }
442
glDeleteFramebuffers(GLsizei n,const GLuint * framebuffers)443 GL_APICALL void GL_APIENTRY glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers){
444 GET_CTX();
445 SET_ERROR_IF(n<0,GL_INVALID_VALUE);
446 if(ctx->shareGroup().Ptr()) {
447 for(int i=0; i < n; i++){
448 const GLuint globalFrameBufferName = ctx->shareGroup()->getGlobalName(FRAMEBUFFER,framebuffers[i]);
449 ctx->shareGroup()->deleteName(FRAMEBUFFER,framebuffers[i]);
450 ctx->dispatcher().glDeleteFramebuffersEXT(1,&globalFrameBufferName);
451 }
452 }
453 }
454
glDeleteRenderbuffers(GLsizei n,const GLuint * renderbuffers)455 GL_APICALL void GL_APIENTRY glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers){
456 GET_CTX();
457 SET_ERROR_IF(n<0,GL_INVALID_VALUE);
458 if(ctx->shareGroup().Ptr()) {
459 for(int i=0; i < n; i++){
460 const GLuint globalRenderBufferName = ctx->shareGroup()->getGlobalName(RENDERBUFFER,renderbuffers[i]);
461 ctx->shareGroup()->deleteName(RENDERBUFFER,renderbuffers[i]);
462 ctx->dispatcher().glDeleteRenderbuffersEXT(1,&globalRenderBufferName);
463 }
464 }
465 }
466
glDeleteTextures(GLsizei n,const GLuint * textures)467 GL_APICALL void GL_APIENTRY glDeleteTextures(GLsizei n, const GLuint* textures){
468 GET_CTX();
469 SET_ERROR_IF(n<0,GL_INVALID_VALUE);
470 if(ctx->shareGroup().Ptr()) {
471 for(int i=0; i < n; i++){
472 if (textures[i]!=0) {
473 TextureData* tData = getTextureData(textures[i]);
474 // delete the underlying OpenGL texture but only if this
475 // texture is not a target of EGLImage.
476 if (!tData || tData->sourceEGLImage == 0) {
477 const GLuint globalTextureName = ctx->shareGroup()->getGlobalName(TEXTURE,textures[i]);
478 ctx->dispatcher().glDeleteTextures(1,&globalTextureName);
479 }
480 ctx->shareGroup()->deleteName(TEXTURE,textures[i]);
481
482 if (ctx->getBindedTexture(GL_TEXTURE_2D) == textures[i])
483 ctx->setBindedTexture(GL_TEXTURE_2D,0);
484 if (ctx->getBindedTexture(GL_TEXTURE_CUBE_MAP) == textures[i])
485 ctx->setBindedTexture(GL_TEXTURE_CUBE_MAP,0);
486 }
487 }
488 }
489 }
490
glDeleteProgram(GLuint program)491 GL_APICALL void GL_APIENTRY glDeleteProgram(GLuint program){
492 GET_CTX();
493 if(program && ctx->shareGroup().Ptr()) {
494 const GLuint globalProgramName = ctx->shareGroup()->getGlobalName(SHADER,program);
495 SET_ERROR_IF(!globalProgramName, GL_INVALID_VALUE);
496 ctx->shareGroup()->deleteName(SHADER,program);
497 ctx->dispatcher().glDeleteProgram(globalProgramName);
498 }
499 }
500
glDeleteShader(GLuint shader)501 GL_APICALL void GL_APIENTRY glDeleteShader(GLuint shader){
502 GET_CTX();
503 if(shader && ctx->shareGroup().Ptr()) {
504 const GLuint globalShaderName = ctx->shareGroup()->getGlobalName(SHADER,shader);
505 SET_ERROR_IF(!globalShaderName, GL_INVALID_VALUE);
506 ctx->shareGroup()->deleteName(SHADER,shader);
507 ctx->dispatcher().glDeleteShader(globalShaderName);
508 }
509
510 }
511
glDepthFunc(GLenum func)512 GL_APICALL void GL_APIENTRY glDepthFunc(GLenum func){
513 GET_CTX();
514 ctx->dispatcher().glDepthFunc(func);
515 }
glDepthMask(GLboolean flag)516 GL_APICALL void GL_APIENTRY glDepthMask(GLboolean flag){
517 GET_CTX();
518 ctx->dispatcher().glDepthMask(flag);
519 }
glDepthRangef(GLclampf zNear,GLclampf zFar)520 GL_APICALL void GL_APIENTRY glDepthRangef(GLclampf zNear, GLclampf zFar){
521 GET_CTX();
522 ctx->dispatcher().glDepthRange(zNear,zFar);
523 }
524
glDetachShader(GLuint program,GLuint shader)525 GL_APICALL void GL_APIENTRY glDetachShader(GLuint program, GLuint shader){
526 GET_CTX();
527 if(ctx->shareGroup().Ptr()) {
528 const GLuint globalProgramName = ctx->shareGroup()->getGlobalName(SHADER,program);
529 SET_ERROR_IF(globalProgramName==0, GL_INVALID_VALUE);
530 const GLuint globalShaderName = ctx->shareGroup()->getGlobalName(SHADER,shader);
531 SET_ERROR_IF(globalShaderName==0, GL_INVALID_VALUE);
532
533 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,program);
534 SET_ERROR_IF(!objData.Ptr(),GL_INVALID_OPERATION);
535 SET_ERROR_IF(!(objData.Ptr()->getDataType()==PROGRAM_DATA) ,GL_INVALID_OPERATION);
536
537 ProgramData* programData = (ProgramData*)objData.Ptr();
538 SET_ERROR_IF(!programData->isAttached(shader),GL_INVALID_OPERATION);
539 programData->detachShader(shader);
540
541 ctx->dispatcher().glDetachShader(globalProgramName,globalShaderName);
542 }
543 }
544
glDisable(GLenum cap)545 GL_APICALL void GL_APIENTRY glDisable(GLenum cap){
546 GET_CTX();
547 ctx->dispatcher().glDisable(cap);
548 }
549
glDisableVertexAttribArray(GLuint index)550 GL_APICALL void GL_APIENTRY glDisableVertexAttribArray(GLuint index){
551 GET_CTX();
552 SET_ERROR_IF((!GLESv2Validate::arrayIndex(ctx,index)),GL_INVALID_VALUE);
553 ctx->enableArr(index,false);
554 ctx->dispatcher().glDisableVertexAttribArray(index);
555 }
556
glDrawArrays(GLenum mode,GLint first,GLsizei count)557 GL_APICALL void GL_APIENTRY glDrawArrays(GLenum mode, GLint first, GLsizei count){
558 GET_CTX_V2();
559 SET_ERROR_IF(count < 0,GL_INVALID_VALUE)
560 SET_ERROR_IF(!GLESv2Validate::drawMode(mode),GL_INVALID_ENUM);
561
562 ctx->drawValidate();
563
564 GLESConversionArrays tmpArrs;
565 ctx->setupArraysPointers(tmpArrs,first,count,0,NULL,true);
566
567 ctx->validateAtt0PreDraw(count);
568
569 //Enable texture generation for GL_POINTS and gl_PointSize shader variable
570 //GLES2 assumes this is enabled by default, we need to set this state for GL
571 if (mode==GL_POINTS) {
572 ctx->dispatcher().glEnable(GL_POINT_SPRITE);
573 ctx->dispatcher().glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
574 }
575
576 ctx->dispatcher().glDrawArrays(mode,first,count);
577
578 if (mode==GL_POINTS) {
579 ctx->dispatcher().glDisable(GL_VERTEX_PROGRAM_POINT_SIZE);
580 ctx->dispatcher().glDisable(GL_POINT_SPRITE);
581 }
582
583 ctx->validateAtt0PostDraw();
584 }
585
glDrawElements(GLenum mode,GLsizei count,GLenum type,const GLvoid * elementsIndices)586 GL_APICALL void GL_APIENTRY glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* elementsIndices){
587 GET_CTX_V2();
588 SET_ERROR_IF(count < 0,GL_INVALID_VALUE)
589 SET_ERROR_IF(!(GLESv2Validate::drawMode(mode) && GLESv2Validate::drawType(type)),GL_INVALID_ENUM);
590
591 ctx->drawValidate();
592
593 const GLvoid* indices = elementsIndices;
594 if(ctx->isBindedBuffer(GL_ELEMENT_ARRAY_BUFFER)) { // if vbo is binded take the indices from the vbo
595 const unsigned char* buf = static_cast<unsigned char *>(ctx->getBindedBuffer(GL_ELEMENT_ARRAY_BUFFER));
596 indices = buf + SafeUIntFromPointer(elementsIndices);
597 }
598
599 GLESConversionArrays tmpArrs;
600 ctx->setupArraysPointers(tmpArrs,0,count,type,indices,false);
601
602 int maxIndex = ctx->findMaxIndex(count, type, indices);
603 ctx->validateAtt0PreDraw(maxIndex);
604
605 //See glDrawArrays
606 if (mode==GL_POINTS) {
607 ctx->dispatcher().glEnable(GL_POINT_SPRITE);
608 ctx->dispatcher().glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
609 }
610
611 ctx->dispatcher().glDrawElements(mode,count,type,indices);
612
613 if (mode==GL_POINTS) {
614 ctx->dispatcher().glDisable(GL_VERTEX_PROGRAM_POINT_SIZE);
615 ctx->dispatcher().glDisable(GL_POINT_SPRITE);
616 }
617
618 ctx->validateAtt0PostDraw();
619 }
620
glEnable(GLenum cap)621 GL_APICALL void GL_APIENTRY glEnable(GLenum cap){
622 GET_CTX();
623 ctx->dispatcher().glEnable(cap);
624 }
625
glEnableVertexAttribArray(GLuint index)626 GL_APICALL void GL_APIENTRY glEnableVertexAttribArray(GLuint index){
627 GET_CTX();
628 SET_ERROR_IF(!(GLESv2Validate::arrayIndex(ctx,index)),GL_INVALID_VALUE);
629 ctx->enableArr(index,true);
630 ctx->dispatcher().glEnableVertexAttribArray(index);
631 }
632
glFinish(void)633 GL_APICALL void GL_APIENTRY glFinish(void){
634 GET_CTX();
635 ctx->dispatcher().glFinish();
636 }
glFlush(void)637 GL_APICALL void GL_APIENTRY glFlush(void){
638 GET_CTX();
639 ctx->dispatcher().glFlush();
640 }
641
642
glFramebufferRenderbuffer(GLenum target,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer)643 GL_APICALL void GL_APIENTRY glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer){
644 GET_CTX();
645 SET_ERROR_IF(!(GLESv2Validate::framebufferTarget(target) &&
646 GLESv2Validate::renderbufferTarget(renderbuffertarget) &&
647 GLESv2Validate::framebufferAttachment(attachment)),GL_INVALID_ENUM);
648 SET_ERROR_IF(!ctx->shareGroup().Ptr(), GL_INVALID_OPERATION);
649
650 GLuint globalRenderbufferName = 0;
651 ObjectDataPtr obj;
652
653 // generate the renderbuffer object if not yet exist
654 if(renderbuffer) {
655 if (!ctx->shareGroup()->isObject(RENDERBUFFER,renderbuffer)) {
656 ctx->shareGroup()->genName(RENDERBUFFER,renderbuffer);
657 obj = ObjectDataPtr(new RenderbufferData());
658 ctx->shareGroup()->setObjectData(RENDERBUFFER,
659 renderbuffer, obj);
660 }
661 else {
662 obj = ctx->shareGroup()->getObjectData(RENDERBUFFER, renderbuffer);
663 }
664
665 globalRenderbufferName = ctx->shareGroup()->getGlobalName(RENDERBUFFER,renderbuffer);
666 }
667
668 // Update the the current framebuffer object attachment state
669 GLuint fbName = ctx->getFramebufferBinding();
670 ObjectDataPtr fbObj = ctx->shareGroup()->getObjectData(FRAMEBUFFER,fbName);
671 if (fbObj.Ptr() != NULL) {
672 FramebufferData *fbData = (FramebufferData *)fbObj.Ptr();
673 fbData->setAttachment(attachment, renderbuffertarget, renderbuffer, obj);
674 }
675
676 if (renderbuffer && obj.Ptr() != NULL) {
677 RenderbufferData *rbData = (RenderbufferData *)obj.Ptr();
678 if (rbData->sourceEGLImage != 0) {
679 //
680 // This renderbuffer object is an eglImage target
681 // attach the eglimage's texture instead the renderbuffer.
682 //
683 ctx->dispatcher().glFramebufferTexture2DEXT(target,
684 attachment,
685 GL_TEXTURE_2D,
686 rbData->eglImageGlobalTexName,0);
687 return;
688 }
689 }
690
691 ctx->dispatcher().glFramebufferRenderbufferEXT(target,attachment,renderbuffertarget,globalRenderbufferName);
692 }
693
glFramebufferTexture2D(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level)694 GL_APICALL void GL_APIENTRY glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level){
695 GET_CTX();
696 SET_ERROR_IF(!(GLESv2Validate::framebufferTarget(target) &&
697 GLESv2Validate::textureTargetEx(textarget) &&
698 GLESv2Validate::framebufferAttachment(attachment)),GL_INVALID_ENUM);
699 SET_ERROR_IF(level != 0, GL_INVALID_VALUE);
700 SET_ERROR_IF(!ctx->shareGroup().Ptr(), GL_INVALID_OPERATION);
701
702 GLuint globalTextureName = 0;
703
704 if(texture) {
705 if (!ctx->shareGroup()->isObject(TEXTURE,texture)) {
706 ctx->shareGroup()->genName(TEXTURE,texture);
707 }
708 ObjectLocalName texname = TextureLocalName(textarget,texture);
709 globalTextureName = ctx->shareGroup()->getGlobalName(TEXTURE,texname);
710 }
711
712 ctx->dispatcher().glFramebufferTexture2DEXT(target,attachment,textarget,globalTextureName,level);
713
714 // Update the the current framebuffer object attachment state
715 GLuint fbName = ctx->getFramebufferBinding();
716 ObjectDataPtr fbObj = ctx->shareGroup()->getObjectData(FRAMEBUFFER,fbName);
717 if (fbObj.Ptr() != NULL) {
718 FramebufferData *fbData = (FramebufferData *)fbObj.Ptr();
719 fbData->setAttachment(attachment, textarget,
720 texture, ObjectDataPtr(NULL));
721 }
722 }
723
724
glFrontFace(GLenum mode)725 GL_APICALL void GL_APIENTRY glFrontFace(GLenum mode){
726 GET_CTX();
727 ctx->dispatcher().glFrontFace(mode);
728 }
729
glGenBuffers(GLsizei n,GLuint * buffers)730 GL_APICALL void GL_APIENTRY glGenBuffers(GLsizei n, GLuint* buffers){
731 GET_CTX();
732 SET_ERROR_IF(n<0,GL_INVALID_VALUE);
733 if(ctx->shareGroup().Ptr()) {
734 for(int i=0; i<n ;i++) {
735 buffers[i] = ctx->shareGroup()->genName(VERTEXBUFFER, 0, true);
736 //generating vbo object related to this buffer name
737 ctx->shareGroup()->setObjectData(VERTEXBUFFER,buffers[i],ObjectDataPtr(new GLESbuffer()));
738 }
739 }
740 }
741
glGenerateMipmap(GLenum target)742 GL_APICALL void GL_APIENTRY glGenerateMipmap(GLenum target){
743 GET_CTX();
744 SET_ERROR_IF(!GLESv2Validate::textureTargetEx(target),GL_INVALID_ENUM);
745 ctx->dispatcher().glGenerateMipmapEXT(target);
746 }
747
glGenFramebuffers(GLsizei n,GLuint * framebuffers)748 GL_APICALL void GL_APIENTRY glGenFramebuffers(GLsizei n, GLuint* framebuffers){
749 GET_CTX();
750 SET_ERROR_IF(n<0,GL_INVALID_VALUE);
751 if(ctx->shareGroup().Ptr()) {
752 for(int i=0; i<n ;i++) {
753 framebuffers[i] = ctx->shareGroup()->genName(FRAMEBUFFER, 0 ,true);
754 ctx->shareGroup()->setObjectData(FRAMEBUFFER, framebuffers[i],
755 ObjectDataPtr(new FramebufferData(framebuffers[i])));
756 }
757 }
758 }
759
glGenRenderbuffers(GLsizei n,GLuint * renderbuffers)760 GL_APICALL void GL_APIENTRY glGenRenderbuffers(GLsizei n, GLuint* renderbuffers){
761 GET_CTX();
762 SET_ERROR_IF(n<0,GL_INVALID_VALUE);
763 if(ctx->shareGroup().Ptr()) {
764 for(int i=0; i<n ;i++) {
765 renderbuffers[i] = ctx->shareGroup()->genName(RENDERBUFFER, 0, true);
766 ctx->shareGroup()->setObjectData(RENDERBUFFER,
767 renderbuffers[i],
768 ObjectDataPtr(new RenderbufferData()));
769 }
770 }
771 }
772
glGenTextures(GLsizei n,GLuint * textures)773 GL_APICALL void GL_APIENTRY glGenTextures(GLsizei n, GLuint* textures){
774 GET_CTX();
775 SET_ERROR_IF(n<0,GL_INVALID_VALUE);
776 if(ctx->shareGroup().Ptr()) {
777 for(int i=0; i<n ;i++) {
778 textures[i] = ctx->shareGroup()->genName(TEXTURE, 0, true);
779 }
780 }
781 }
782
glGetActiveAttrib(GLuint program,GLuint index,GLsizei bufsize,GLsizei * length,GLint * size,GLenum * type,GLchar * name)783 GL_APICALL void GL_APIENTRY glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name){
784 GET_CTX();
785 if(ctx->shareGroup().Ptr()) {
786 const GLuint globalProgramName = ctx->shareGroup()->getGlobalName(SHADER,program);
787 SET_ERROR_IF(globalProgramName==0, GL_INVALID_VALUE);
788 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,program);
789 SET_ERROR_IF(objData.Ptr()->getDataType()!=PROGRAM_DATA,GL_INVALID_OPERATION);
790 ctx->dispatcher().glGetActiveAttrib(globalProgramName,index,bufsize,length,size,type,name);
791 }
792 }
793
glGetActiveUniform(GLuint program,GLuint index,GLsizei bufsize,GLsizei * length,GLint * size,GLenum * type,GLchar * name)794 GL_APICALL void GL_APIENTRY glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name){
795 GET_CTX();
796 if(ctx->shareGroup().Ptr()) {
797 const GLuint globalProgramName = ctx->shareGroup()->getGlobalName(SHADER,program);
798 SET_ERROR_IF(globalProgramName==0, GL_INVALID_VALUE);
799 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,program);
800 SET_ERROR_IF(objData.Ptr()->getDataType()!=PROGRAM_DATA,GL_INVALID_OPERATION);
801 ctx->dispatcher().glGetActiveUniform(globalProgramName,index,bufsize,length,size,type,name);
802 }
803 }
804
glGetAttachedShaders(GLuint program,GLsizei maxcount,GLsizei * count,GLuint * shaders)805 GL_APICALL void GL_APIENTRY glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders){
806 GET_CTX();
807 if(ctx->shareGroup().Ptr()) {
808 const GLuint globalProgramName = ctx->shareGroup()->getGlobalName(SHADER,program);
809 SET_ERROR_IF(globalProgramName==0, GL_INVALID_VALUE);
810 ctx->dispatcher().glGetAttachedShaders(globalProgramName,maxcount,count,shaders);
811 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,program);
812 SET_ERROR_IF(objData.Ptr()->getDataType()!=PROGRAM_DATA,GL_INVALID_OPERATION);
813 GLint numShaders=0;
814 ctx->dispatcher().glGetProgramiv(globalProgramName,GL_ATTACHED_SHADERS,&numShaders);
815 for(int i=0 ; i < maxcount && i<numShaders ;i++){
816 shaders[i] = ctx->shareGroup()->getLocalName(SHADER,shaders[i]);
817 }
818 }
819 }
820
glGetAttribLocation(GLuint program,const GLchar * name)821 GL_APICALL int GL_APIENTRY glGetAttribLocation(GLuint program, const GLchar* name){
822 GET_CTX_RET(-1);
823 if(ctx->shareGroup().Ptr()) {
824 const GLuint globalProgramName = ctx->shareGroup()->getGlobalName(SHADER,program);
825 RET_AND_SET_ERROR_IF(globalProgramName==0, GL_INVALID_VALUE,-1);
826 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,program);
827 RET_AND_SET_ERROR_IF(objData.Ptr()->getDataType()!=PROGRAM_DATA,GL_INVALID_OPERATION,-1);
828 ProgramData* pData = (ProgramData *)objData.Ptr();
829 RET_AND_SET_ERROR_IF(pData->getLinkStatus() != GL_TRUE,GL_INVALID_OPERATION,-1);
830 return ctx->dispatcher().glGetAttribLocation(globalProgramName,name);
831 }
832 return -1;
833 }
834
glGetBooleanv(GLenum pname,GLboolean * params)835 GL_APICALL void GL_APIENTRY glGetBooleanv(GLenum pname, GLboolean* params){
836 GET_CTX();
837
838 if (ctx->glGetBooleanv(pname,params))
839 {
840 return;
841 }
842
843 switch(pname)
844 {
845 case GL_SHADER_COMPILER:
846 case GL_SHADER_BINARY_FORMATS:
847 case GL_NUM_SHADER_BINARY_FORMATS:
848 case GL_MAX_VERTEX_UNIFORM_VECTORS:
849 case GL_MAX_VARYING_VECTORS:
850 case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
851 if(ctx->getCaps()->GL_ARB_ES2_COMPATIBILITY)
852 ctx->dispatcher().glGetBooleanv(pname,params);
853 else
854 {
855 GLint iparam;
856 glGetIntegerv(pname,&iparam);
857 *params = (iparam != 0);
858 }
859 break;
860
861 default:
862 ctx->dispatcher().glGetBooleanv(pname,params);
863 }
864 }
865
glGetBufferParameteriv(GLenum target,GLenum pname,GLint * params)866 GL_APICALL void GL_APIENTRY glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params){
867 GET_CTX();
868 SET_ERROR_IF(!(GLESv2Validate::bufferTarget(target) && GLESv2Validate::bufferParam(pname)),GL_INVALID_ENUM);
869 SET_ERROR_IF(!ctx->isBindedBuffer(target),GL_INVALID_OPERATION);
870 switch(pname) {
871 case GL_BUFFER_SIZE:
872 ctx->getBufferSize(target,params);
873 break;
874 case GL_BUFFER_USAGE:
875 ctx->getBufferUsage(target,params);
876 break;
877 }
878 }
879
880
glGetError(void)881 GL_APICALL GLenum GL_APIENTRY glGetError(void){
882 GET_CTX_RET(GL_NO_ERROR)
883 GLenum err = ctx->getGLerror();
884 if(err != GL_NO_ERROR) {
885 ctx->setGLerror(GL_NO_ERROR);
886 return err;
887 }
888 return ctx->dispatcher().glGetError();
889 }
890
glGetFloatv(GLenum pname,GLfloat * params)891 GL_APICALL void GL_APIENTRY glGetFloatv(GLenum pname, GLfloat* params){
892 GET_CTX();
893
894 if (ctx->glGetFloatv(pname,params)) {
895 return;
896 }
897
898 GLint i;
899
900 switch (pname) {
901 case GL_CURRENT_PROGRAM:
902 case GL_FRAMEBUFFER_BINDING:
903 case GL_RENDERBUFFER_BINDING:
904 glGetIntegerv(pname,&i);
905 *params = (GLfloat)i;
906 break;
907 case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
908 *params = (GLfloat)getCompressedFormats(NULL);
909 break;
910 case GL_COMPRESSED_TEXTURE_FORMATS:
911 {
912 int nparams = getCompressedFormats(NULL);
913 if (nparams>0) {
914 int * iparams = new int[nparams];
915 getCompressedFormats(iparams);
916 for (int i=0; i<nparams; i++) params[i] = (GLfloat)iparams[i];
917 delete [] iparams;
918 }
919 }
920 break;
921
922 case GL_SHADER_COMPILER:
923 case GL_SHADER_BINARY_FORMATS:
924 case GL_NUM_SHADER_BINARY_FORMATS:
925 case GL_MAX_VERTEX_UNIFORM_VECTORS:
926 case GL_MAX_VARYING_VECTORS:
927 case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
928 if(ctx->getCaps()->GL_ARB_ES2_COMPATIBILITY)
929 ctx->dispatcher().glGetFloatv(pname,params);
930 else
931 {
932 glGetIntegerv(pname,&i);
933 *params = (GLfloat)i;
934 }
935 break;
936
937 default:
938 ctx->dispatcher().glGetFloatv(pname,params);
939 }
940 }
941
glGetIntegerv(GLenum pname,GLint * params)942 GL_APICALL void GL_APIENTRY glGetIntegerv(GLenum pname, GLint* params){
943 int destroyCtx = 0;
944 GET_CTX();
945
946 if (!ctx) {
947 ctx = createGLESContext();
948 if (ctx)
949 destroyCtx = 1;
950 }
951 if (ctx->glGetIntegerv(pname,params))
952 {
953 if (destroyCtx)
954 deleteGLESContext(ctx);
955 return;
956 }
957
958 bool es2 = ctx->getCaps()->GL_ARB_ES2_COMPATIBILITY;
959 GLint i;
960
961 switch (pname) {
962 case GL_CURRENT_PROGRAM:
963 if (ctx->shareGroup().Ptr()) {
964 ctx->dispatcher().glGetIntegerv(pname,&i);
965 *params = ctx->shareGroup()->getLocalName(SHADER,i);
966 }
967 break;
968 case GL_FRAMEBUFFER_BINDING:
969 if (ctx->shareGroup().Ptr()) {
970 ctx->dispatcher().glGetIntegerv(pname,&i);
971 *params = ctx->shareGroup()->getLocalName(FRAMEBUFFER,i);
972 }
973 break;
974 case GL_RENDERBUFFER_BINDING:
975 if (ctx->shareGroup().Ptr()) {
976 ctx->dispatcher().glGetIntegerv(pname,&i);
977 *params = ctx->shareGroup()->getLocalName(RENDERBUFFER,i);
978 }
979 break;
980
981 case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
982 *params = getCompressedFormats(NULL);
983 break;
984 case GL_COMPRESSED_TEXTURE_FORMATS:
985 getCompressedFormats(params);
986 break;
987
988 case GL_SHADER_COMPILER:
989 if(es2)
990 ctx->dispatcher().glGetIntegerv(pname,params);
991 else
992 *params = 1;
993 break;
994
995 case GL_SHADER_BINARY_FORMATS:
996 if(es2)
997 ctx->dispatcher().glGetIntegerv(pname,params);
998 break;
999
1000 case GL_NUM_SHADER_BINARY_FORMATS:
1001 if(es2)
1002 ctx->dispatcher().glGetIntegerv(pname,params);
1003 else
1004 *params = 0;
1005 break;
1006
1007 case GL_MAX_VERTEX_UNIFORM_VECTORS:
1008 if(es2)
1009 ctx->dispatcher().glGetIntegerv(pname,params);
1010 else
1011 *params = 128;
1012 break;
1013
1014 case GL_MAX_VARYING_VECTORS:
1015 if(es2)
1016 ctx->dispatcher().glGetIntegerv(pname,params);
1017 else
1018 *params = 8;
1019 break;
1020
1021 case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
1022 if(es2)
1023 ctx->dispatcher().glGetIntegerv(pname,params);
1024 else
1025 *params = 16;
1026 break;
1027
1028 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
1029 ctx->dispatcher().glGetIntegerv(pname,params);
1030 if(*params > 16)
1031 {
1032 // GLES spec requires only 2, and the ATI driver erronously
1033 // returns 32 (although it supports only 16). This WAR is simple,
1034 // compliant and good enough for developers.
1035 *params = 16;
1036 }
1037 break;
1038 default:
1039 ctx->dispatcher().glGetIntegerv(pname,params);
1040 }
1041 if (destroyCtx)
1042 deleteGLESContext(ctx);
1043 }
1044
glGetFramebufferAttachmentParameteriv(GLenum target,GLenum attachment,GLenum pname,GLint * params)1045 GL_APICALL void GL_APIENTRY glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params){
1046 GET_CTX();
1047 SET_ERROR_IF(!(GLESv2Validate::framebufferTarget(target) &&
1048 GLESv2Validate::framebufferAttachment(attachment) &&
1049 GLESv2Validate::framebufferAttachmentParams(pname)),GL_INVALID_ENUM);
1050
1051 //
1052 // Take the attachment attribute from our state - if available
1053 //
1054 GLuint fbName = ctx->getFramebufferBinding();
1055 if (fbName) {
1056 ObjectDataPtr fbObj = ctx->shareGroup()->getObjectData(FRAMEBUFFER,fbName);
1057 if (fbObj.Ptr() != NULL) {
1058 FramebufferData *fbData = (FramebufferData *)fbObj.Ptr();
1059 GLenum target;
1060 GLuint name = fbData->getAttachment(attachment, &target, NULL);
1061 if (pname == GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE) {
1062 if (target == GL_TEXTURE_2D) {
1063 *params = GL_TEXTURE;
1064 return;
1065 }
1066 else if (target == GL_RENDERBUFFER) {
1067 *params = GL_RENDERBUFFER;
1068 return;
1069 }
1070 }
1071 else if (pname == GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME) {
1072 *params = name;
1073 return;
1074 }
1075 }
1076 }
1077
1078 ctx->dispatcher().glGetFramebufferAttachmentParameterivEXT(target,attachment,pname,params);
1079 }
1080
glGetRenderbufferParameteriv(GLenum target,GLenum pname,GLint * params)1081 GL_APICALL void GL_APIENTRY glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params){
1082 GET_CTX();
1083 SET_ERROR_IF(!(GLESv2Validate::renderbufferTarget(target) && GLESv2Validate::renderbufferParams(pname)),GL_INVALID_ENUM);
1084
1085 //
1086 // If this is a renderbuffer which is eglimage's target, we
1087 // should query the underlying eglimage's texture object instead.
1088 //
1089 GLuint rb = ctx->getRenderbufferBinding();
1090 if (rb) {
1091 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(RENDERBUFFER,rb);
1092 RenderbufferData *rbData = (RenderbufferData *)objData.Ptr();
1093 if (rbData && rbData->sourceEGLImage != 0) {
1094 GLenum texPname;
1095 switch(pname) {
1096 case GL_RENDERBUFFER_WIDTH:
1097 texPname = GL_TEXTURE_WIDTH;
1098 break;
1099 case GL_RENDERBUFFER_HEIGHT:
1100 texPname = GL_TEXTURE_HEIGHT;
1101 break;
1102 case GL_RENDERBUFFER_INTERNAL_FORMAT:
1103 texPname = GL_TEXTURE_INTERNAL_FORMAT;
1104 break;
1105 case GL_RENDERBUFFER_RED_SIZE:
1106 texPname = GL_TEXTURE_RED_SIZE;
1107 break;
1108 case GL_RENDERBUFFER_GREEN_SIZE:
1109 texPname = GL_TEXTURE_GREEN_SIZE;
1110 break;
1111 case GL_RENDERBUFFER_BLUE_SIZE:
1112 texPname = GL_TEXTURE_BLUE_SIZE;
1113 break;
1114 case GL_RENDERBUFFER_ALPHA_SIZE:
1115 texPname = GL_TEXTURE_ALPHA_SIZE;
1116 break;
1117 case GL_RENDERBUFFER_DEPTH_SIZE:
1118 texPname = GL_TEXTURE_DEPTH_SIZE;
1119 break;
1120 case GL_RENDERBUFFER_STENCIL_SIZE:
1121 default:
1122 *params = 0; //XXX
1123 return;
1124 break;
1125 }
1126
1127 GLint prevTex;
1128 ctx->dispatcher().glGetIntegerv(GL_TEXTURE_BINDING_2D, &prevTex);
1129 ctx->dispatcher().glBindTexture(GL_TEXTURE_2D,
1130 rbData->eglImageGlobalTexName);
1131 ctx->dispatcher().glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
1132 texPname,
1133 params);
1134 ctx->dispatcher().glBindTexture(GL_TEXTURE_2D, prevTex);
1135 return;
1136 }
1137 }
1138
1139 ctx->dispatcher().glGetRenderbufferParameterivEXT(target,pname,params);
1140 }
1141
1142
glGetProgramiv(GLuint program,GLenum pname,GLint * params)1143 GL_APICALL void GL_APIENTRY glGetProgramiv(GLuint program, GLenum pname, GLint* params){
1144 GET_CTX();
1145 SET_ERROR_IF(!GLESv2Validate::programParam(pname),GL_INVALID_ENUM);
1146 if(ctx->shareGroup().Ptr()) {
1147 const GLuint globalProgramName = ctx->shareGroup()->getGlobalName(SHADER,program);
1148 SET_ERROR_IF(globalProgramName==0, GL_INVALID_VALUE);
1149 switch(pname) {
1150 case GL_LINK_STATUS:
1151 {
1152 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,program);
1153 SET_ERROR_IF(!objData.Ptr() ,GL_INVALID_OPERATION);
1154 SET_ERROR_IF(objData.Ptr()->getDataType()!=PROGRAM_DATA,GL_INVALID_OPERATION);
1155 ProgramData* programData = (ProgramData*)objData.Ptr();
1156 params[0] = programData->getLinkStatus();
1157 }
1158 break;
1159 //validate status should not return GL_TRUE if link failed
1160 case GL_VALIDATE_STATUS:
1161 {
1162 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,program);
1163 SET_ERROR_IF(!objData.Ptr() ,GL_INVALID_OPERATION);
1164 SET_ERROR_IF(objData.Ptr()->getDataType()!=PROGRAM_DATA,GL_INVALID_OPERATION);
1165 ProgramData* programData = (ProgramData*)objData.Ptr();
1166 if (programData->getLinkStatus()==GL_TRUE)
1167 ctx->dispatcher().glGetProgramiv(globalProgramName,pname,params);
1168 else
1169 params[0] = GL_FALSE;
1170 }
1171 break;
1172 case GL_INFO_LOG_LENGTH:
1173 {
1174 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,program);
1175 SET_ERROR_IF(!objData.Ptr() ,GL_INVALID_OPERATION);
1176 SET_ERROR_IF(objData.Ptr()->getDataType()!=PROGRAM_DATA,GL_INVALID_OPERATION);
1177 ProgramData* programData = (ProgramData*)objData.Ptr();
1178 GLint logLength = strlen(programData->getInfoLog());
1179 params[0] = (logLength>0) ? logLength+1 : 0;
1180 }
1181 break;
1182 default:
1183 ctx->dispatcher().glGetProgramiv(globalProgramName,pname,params);
1184 }
1185 }
1186 }
1187
glGetProgramInfoLog(GLuint program,GLsizei bufsize,GLsizei * length,GLchar * infolog)1188 GL_APICALL void GL_APIENTRY glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog){
1189 GET_CTX();
1190 if(ctx->shareGroup().Ptr()) {
1191 const GLuint globalProgramName = ctx->shareGroup()->getGlobalName(SHADER,program);
1192 SET_ERROR_IF(globalProgramName==0, GL_INVALID_VALUE);
1193 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,program);
1194 SET_ERROR_IF(!objData.Ptr() ,GL_INVALID_OPERATION);
1195 SET_ERROR_IF(objData.Ptr()->getDataType()!=PROGRAM_DATA,GL_INVALID_OPERATION);
1196 ProgramData* programData = (ProgramData*)objData.Ptr();
1197
1198 if (bufsize==0) {
1199 if (length) {
1200 *length = 0;
1201 }
1202 return;
1203 }
1204
1205 GLsizei logLength;
1206 logLength = strlen(programData->getInfoLog());
1207
1208 GLsizei returnLength=0;
1209 if (infolog) {
1210 returnLength = bufsize-1 < logLength ? bufsize-1 : logLength;
1211 strncpy(infolog,programData->getInfoLog(),returnLength+1);
1212 infolog[returnLength] = '\0';
1213 }
1214 if (length) {
1215 *length = returnLength;
1216 }
1217 }
1218 }
1219
glGetShaderiv(GLuint shader,GLenum pname,GLint * params)1220 GL_APICALL void GL_APIENTRY glGetShaderiv(GLuint shader, GLenum pname, GLint* params){
1221 GET_CTX();
1222 if(ctx->shareGroup().Ptr()) {
1223 const GLuint globalShaderName = ctx->shareGroup()->getGlobalName(SHADER,shader);
1224 SET_ERROR_IF(globalShaderName==0, GL_INVALID_VALUE);
1225 switch(pname) {
1226 case GL_INFO_LOG_LENGTH:
1227 {
1228 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,shader);
1229 SET_ERROR_IF(!objData.Ptr() ,GL_INVALID_OPERATION);
1230 SET_ERROR_IF(objData.Ptr()->getDataType()!=SHADER_DATA,GL_INVALID_OPERATION);
1231 ShaderParser* sp = (ShaderParser*)objData.Ptr();
1232 GLint logLength = strlen(sp->getInfoLog());
1233 params[0] = (logLength>0) ? logLength+1 : 0;
1234 }
1235 break;
1236 default:
1237 ctx->dispatcher().glGetShaderiv(globalShaderName,pname,params);
1238 }
1239 }
1240 }
1241
1242
glGetShaderInfoLog(GLuint shader,GLsizei bufsize,GLsizei * length,GLchar * infolog)1243 GL_APICALL void GL_APIENTRY glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog){
1244 GET_CTX();
1245 if(ctx->shareGroup().Ptr()) {
1246 const GLuint globalShaderName = ctx->shareGroup()->getGlobalName(SHADER,shader);
1247 SET_ERROR_IF(globalShaderName==0, GL_INVALID_VALUE);
1248 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,shader);
1249 SET_ERROR_IF(!objData.Ptr() ,GL_INVALID_OPERATION);
1250 SET_ERROR_IF(objData.Ptr()->getDataType()!=SHADER_DATA,GL_INVALID_OPERATION);
1251 ShaderParser* sp = (ShaderParser*)objData.Ptr();
1252
1253 if (bufsize==0) {
1254 if (length) {
1255 *length = 0;
1256 }
1257 return;
1258 }
1259
1260 GLsizei logLength;
1261 logLength = strlen(sp->getInfoLog());
1262
1263 GLsizei returnLength=0;
1264 if (infolog) {
1265 returnLength = bufsize-1 <logLength ? bufsize-1 : logLength;
1266 strncpy(infolog,sp->getInfoLog(),returnLength+1);
1267 infolog[returnLength] = '\0';
1268 }
1269 if (length) {
1270 *length = returnLength;
1271 }
1272 }
1273 }
1274
glGetShaderPrecisionFormat(GLenum shadertype,GLenum precisiontype,GLint * range,GLint * precision)1275 GL_APICALL void GL_APIENTRY glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision){
1276 GET_CTX_V2();
1277 SET_ERROR_IF(!(GLESv2Validate::shaderType(shadertype) && GLESv2Validate::precisionType(precisiontype)),GL_INVALID_ENUM);
1278
1279 switch (precisiontype) {
1280 case GL_LOW_INT:
1281 case GL_MEDIUM_INT:
1282 case GL_HIGH_INT:
1283 range[0] = range[1] = 16;
1284 *precision = 0;
1285 break;
1286
1287 case GL_LOW_FLOAT:
1288 case GL_MEDIUM_FLOAT:
1289 case GL_HIGH_FLOAT:
1290 if(ctx->dispatcher().glGetShaderPrecisionFormat != NULL) {
1291 ctx->dispatcher().glGetShaderPrecisionFormat(shadertype,precisiontype,range,precision);
1292 } else {
1293 range[0] = range[1] = 127;
1294 *precision = 24;
1295 }
1296 break;
1297 }
1298 }
1299
glGetShaderSource(GLuint shader,GLsizei bufsize,GLsizei * length,GLchar * source)1300 GL_APICALL void GL_APIENTRY glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source){
1301 GET_CTX();
1302 if(ctx->shareGroup().Ptr()) {
1303 const GLuint globalShaderName = ctx->shareGroup()->getGlobalName(SHADER,shader);
1304 SET_ERROR_IF(globalShaderName == 0,GL_INVALID_VALUE);
1305 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,shader);
1306 SET_ERROR_IF(!objData.Ptr(),GL_INVALID_OPERATION);
1307 SET_ERROR_IF(objData.Ptr()->getDataType()!=SHADER_DATA,GL_INVALID_OPERATION);
1308 const char* src = ((ShaderParser*)objData.Ptr())->getOriginalSrc();
1309 int srcLength = 0;
1310 if (src) {
1311 srcLength = strlen(src);
1312 }
1313
1314 int returnLength = bufsize<srcLength ? bufsize-1 : srcLength;
1315 if (returnLength) {
1316 strncpy(source,src, returnLength);
1317 source[returnLength] = '\0';
1318 }
1319
1320 if (length)
1321 *length = returnLength;
1322 }
1323 }
1324
1325
glGetString(GLenum name)1326 GL_APICALL const GLubyte* GL_APIENTRY glGetString(GLenum name){
1327 GET_CTX_RET(NULL)
1328 static const GLubyte SHADING[] = "OpenGL ES GLSL ES 1.0.17";
1329 switch(name) {
1330 case GL_VENDOR:
1331 return (const GLubyte*)ctx->getVendorString();
1332 case GL_RENDERER:
1333 return (const GLubyte*)ctx->getRendererString();
1334 case GL_VERSION:
1335 return (const GLubyte*)ctx->getVersionString();
1336 case GL_SHADING_LANGUAGE_VERSION:
1337 return SHADING;
1338 case GL_EXTENSIONS:
1339 return (const GLubyte*)ctx->getExtensionString();
1340 default:
1341 RET_AND_SET_ERROR_IF(true,GL_INVALID_ENUM,NULL);
1342 }
1343 }
1344
glGetTexParameterfv(GLenum target,GLenum pname,GLfloat * params)1345 GL_APICALL void GL_APIENTRY glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params){
1346 GET_CTX();
1347 SET_ERROR_IF(!(GLESv2Validate::textureTarget(target) && GLESv2Validate::textureParams(pname)),GL_INVALID_ENUM);
1348 ctx->dispatcher().glGetTexParameterfv(target,pname,params);
1349
1350 }
glGetTexParameteriv(GLenum target,GLenum pname,GLint * params)1351 GL_APICALL void GL_APIENTRY glGetTexParameteriv(GLenum target, GLenum pname, GLint* params){
1352 GET_CTX();
1353 SET_ERROR_IF(!(GLESv2Validate::textureTarget(target) && GLESv2Validate::textureParams(pname)),GL_INVALID_ENUM);
1354 ctx->dispatcher().glGetTexParameteriv(target,pname,params);
1355 }
1356
glGetUniformfv(GLuint program,GLint location,GLfloat * params)1357 GL_APICALL void GL_APIENTRY glGetUniformfv(GLuint program, GLint location, GLfloat* params){
1358 GET_CTX();
1359 SET_ERROR_IF(location < 0,GL_INVALID_OPERATION);
1360 if(ctx->shareGroup().Ptr()) {
1361 const GLuint globalProgramName = ctx->shareGroup()->getGlobalName(SHADER,program);
1362 SET_ERROR_IF(globalProgramName==0, GL_INVALID_VALUE);
1363 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,program);
1364 SET_ERROR_IF(objData.Ptr()->getDataType()!=PROGRAM_DATA,GL_INVALID_OPERATION);
1365 ProgramData* pData = (ProgramData *)objData.Ptr();
1366 SET_ERROR_IF(pData->getLinkStatus() != GL_TRUE,GL_INVALID_OPERATION);
1367 ctx->dispatcher().glGetUniformfv(globalProgramName,location,params);
1368 }
1369 }
1370
glGetUniformiv(GLuint program,GLint location,GLint * params)1371 GL_APICALL void GL_APIENTRY glGetUniformiv(GLuint program, GLint location, GLint* params){
1372 GET_CTX();
1373 SET_ERROR_IF(location < 0,GL_INVALID_OPERATION);
1374 if(ctx->shareGroup().Ptr()) {
1375 const GLuint globalProgramName = ctx->shareGroup()->getGlobalName(SHADER,program);
1376 SET_ERROR_IF(globalProgramName==0, GL_INVALID_VALUE);
1377 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,program);
1378 SET_ERROR_IF(objData.Ptr()->getDataType()!=PROGRAM_DATA,GL_INVALID_OPERATION);
1379 ProgramData* pData = (ProgramData *)objData.Ptr();
1380 SET_ERROR_IF(pData->getLinkStatus() != GL_TRUE,GL_INVALID_OPERATION);
1381 ctx->dispatcher().glGetUniformiv(globalProgramName,location,params);
1382 }
1383 }
1384
glGetUniformLocation(GLuint program,const GLchar * name)1385 GL_APICALL int GL_APIENTRY glGetUniformLocation(GLuint program, const GLchar* name){
1386 GET_CTX_RET(-1);
1387 if(ctx->shareGroup().Ptr()) {
1388 const GLuint globalProgramName = ctx->shareGroup()->getGlobalName(SHADER,program);
1389 RET_AND_SET_ERROR_IF(globalProgramName==0, GL_INVALID_VALUE,-1);
1390 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,program);
1391 RET_AND_SET_ERROR_IF(objData.Ptr()->getDataType()!=PROGRAM_DATA,GL_INVALID_OPERATION,-1);
1392 ProgramData* pData = (ProgramData *)objData.Ptr();
1393 RET_AND_SET_ERROR_IF(pData->getLinkStatus() != GL_TRUE,GL_INVALID_OPERATION,-1);
1394 return ctx->dispatcher().glGetUniformLocation(globalProgramName,name);
1395 }
1396 return -1;
1397 }
1398
1399
1400
glGetVertexAttribfv(GLuint index,GLenum pname,GLfloat * params)1401 GL_APICALL void GL_APIENTRY glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params){
1402 GET_CTX_V2();
1403 const GLESpointer* p = ctx->getPointer(index);
1404 if(p) {
1405 switch(pname){
1406 case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
1407 *params = 0;
1408 break;
1409 case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
1410 *params = p->isEnable();
1411 break;
1412 case GL_VERTEX_ATTRIB_ARRAY_SIZE:
1413 *params = p->getSize();
1414 break;
1415 case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
1416 *params = p->getStride();
1417 break;
1418 case GL_VERTEX_ATTRIB_ARRAY_TYPE:
1419 *params = p->getType();
1420 break;
1421 case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
1422 *params = p->isNormalize();
1423 break;
1424 case GL_CURRENT_VERTEX_ATTRIB:
1425 if(index == 0)
1426 {
1427 const float* att0 = ctx->getAtt0();
1428 for(int i=0; i<4; i++)
1429 params[i] = att0[i];
1430 }
1431 else
1432 ctx->dispatcher().glGetVertexAttribfv(index,pname,params);
1433 break;
1434 default:
1435 ctx->setGLerror(GL_INVALID_ENUM);
1436 }
1437 } else {
1438 ctx->setGLerror(GL_INVALID_VALUE);
1439 }
1440 }
1441
glGetVertexAttribiv(GLuint index,GLenum pname,GLint * params)1442 GL_APICALL void GL_APIENTRY glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params){
1443 GET_CTX_V2();
1444 const GLESpointer* p = ctx->getPointer(index);
1445 if(p) {
1446 switch(pname){
1447 case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
1448 *params = 0;
1449 break;
1450 case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
1451 *params = p->isEnable();
1452 break;
1453 case GL_VERTEX_ATTRIB_ARRAY_SIZE:
1454 *params = p->getSize();
1455 break;
1456 case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
1457 *params = p->getStride();
1458 break;
1459 case GL_VERTEX_ATTRIB_ARRAY_TYPE:
1460 *params = p->getType();
1461 break;
1462 case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
1463 *params = p->isNormalize();
1464 break;
1465 case GL_CURRENT_VERTEX_ATTRIB:
1466 if(index == 0)
1467 {
1468 const float* att0 = ctx->getAtt0();
1469 for(int i=0; i<4; i++)
1470 params[i] = (GLint)att0[i];
1471 }
1472 else
1473 ctx->dispatcher().glGetVertexAttribiv(index,pname,params);
1474 break;
1475 default:
1476 ctx->setGLerror(GL_INVALID_ENUM);
1477 }
1478 } else {
1479 ctx->setGLerror(GL_INVALID_VALUE);
1480 }
1481 }
1482
glGetVertexAttribPointerv(GLuint index,GLenum pname,GLvoid ** pointer)1483 GL_APICALL void GL_APIENTRY glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer){
1484 GET_CTX();
1485 SET_ERROR_IF(pname != GL_VERTEX_ATTRIB_ARRAY_POINTER,GL_INVALID_ENUM);
1486 SET_ERROR_IF((!GLESv2Validate::arrayIndex(ctx,index)),GL_INVALID_VALUE);
1487
1488 const GLESpointer* p = ctx->getPointer(index);
1489 if(p) {
1490 *pointer = const_cast<void *>( p->getBufferData());
1491 } else {
1492 ctx->setGLerror(GL_INVALID_VALUE);
1493 }
1494 }
1495
glHint(GLenum target,GLenum mode)1496 GL_APICALL void GL_APIENTRY glHint(GLenum target, GLenum mode){
1497 GET_CTX();
1498 SET_ERROR_IF(!GLESv2Validate::hintTargetMode(target,mode),GL_INVALID_ENUM);
1499 ctx->dispatcher().glHint(target,mode);
1500 }
1501
glIsEnabled(GLenum cap)1502 GL_APICALL GLboolean GL_APIENTRY glIsEnabled(GLenum cap){
1503 GET_CTX_RET(GL_FALSE);
1504 RET_AND_SET_ERROR_IF(!GLESv2Validate::capability(cap),GL_INVALID_ENUM,GL_FALSE);
1505 return ctx->dispatcher().glIsEnabled(cap);
1506 }
1507
glIsBuffer(GLuint buffer)1508 GL_APICALL GLboolean GL_APIENTRY glIsBuffer(GLuint buffer){
1509 GET_CTX_RET(GL_FALSE)
1510 if(buffer && ctx->shareGroup().Ptr()) {
1511 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(VERTEXBUFFER,buffer);
1512 return objData.Ptr() ? ((GLESbuffer*)objData.Ptr())->wasBinded():GL_FALSE;
1513 }
1514 return GL_FALSE;
1515 }
1516
glIsFramebuffer(GLuint framebuffer)1517 GL_APICALL GLboolean GL_APIENTRY glIsFramebuffer(GLuint framebuffer){
1518 GET_CTX_RET(GL_FALSE)
1519 if(framebuffer && ctx->shareGroup().Ptr()){
1520 return ctx->shareGroup()->isObject(FRAMEBUFFER,framebuffer) ? GL_TRUE :GL_FALSE;
1521 }
1522 return GL_FALSE;
1523 }
1524
glIsRenderbuffer(GLuint renderbuffer)1525 GL_APICALL GLboolean GL_APIENTRY glIsRenderbuffer(GLuint renderbuffer){
1526 GET_CTX_RET(GL_FALSE)
1527 if(renderbuffer && ctx->shareGroup().Ptr()){
1528 return ctx->shareGroup()->isObject(RENDERBUFFER,renderbuffer) ? GL_TRUE :GL_FALSE;
1529 }
1530 return GL_FALSE;
1531 }
1532
glIsTexture(GLuint texture)1533 GL_APICALL GLboolean GL_APIENTRY glIsTexture(GLuint texture){
1534 GET_CTX_RET(GL_FALSE)
1535 if (texture==0)
1536 return GL_FALSE;
1537 TextureData* tex = getTextureData(texture);
1538 return tex ? tex->wasBound : GL_FALSE;
1539 }
1540
glIsProgram(GLuint program)1541 GL_APICALL GLboolean GL_APIENTRY glIsProgram(GLuint program){
1542 GET_CTX_RET(GL_FALSE)
1543 if(program && ctx->shareGroup().Ptr() &&
1544 ctx->shareGroup()->isObject(SHADER,program)) {
1545 const GLuint globalProgramName = ctx->shareGroup()->getGlobalName(SHADER,program);
1546 return ctx->dispatcher().glIsProgram(globalProgramName);
1547 }
1548 return GL_FALSE;
1549 }
1550
glIsShader(GLuint shader)1551 GL_APICALL GLboolean GL_APIENTRY glIsShader(GLuint shader){
1552 GET_CTX_RET(GL_FALSE)
1553 if(shader && ctx->shareGroup().Ptr() &&
1554 ctx->shareGroup()->isObject(SHADER,shader)) {
1555 const GLuint globalShaderName = ctx->shareGroup()->getGlobalName(SHADER,shader);
1556 return ctx->dispatcher().glIsShader(globalShaderName);
1557 }
1558 return GL_FALSE;
1559 }
1560
glLineWidth(GLfloat width)1561 GL_APICALL void GL_APIENTRY glLineWidth(GLfloat width){
1562 GET_CTX();
1563 ctx->dispatcher().glLineWidth(width);
1564 }
1565
glLinkProgram(GLuint program)1566 GL_APICALL void GL_APIENTRY glLinkProgram(GLuint program){
1567 GET_CTX();
1568 GLint linkStatus = GL_FALSE;
1569 if(ctx->shareGroup().Ptr()) {
1570 const GLuint globalProgramName = ctx->shareGroup()->getGlobalName(SHADER,program);
1571 SET_ERROR_IF(globalProgramName==0, GL_INVALID_VALUE);
1572
1573 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,program);
1574 SET_ERROR_IF(!objData.Ptr(), GL_INVALID_OPERATION);
1575 SET_ERROR_IF(objData.Ptr()->getDataType()!=PROGRAM_DATA, GL_INVALID_OPERATION);
1576 ProgramData* programData = (ProgramData*)objData.Ptr();
1577 GLint fragmentShader = programData->getAttachedFragmentShader();
1578 GLint vertexShader = programData->getAttachedVertexShader();
1579 if (vertexShader != 0 && fragmentShader!=0) {
1580 /* validating that the fragment & vertex shaders were compiled successfuly*/
1581 GLint fCompileStatus = GL_FALSE;
1582 GLint vCompileStatus = GL_FALSE;
1583 GLuint fragmentShaderGlobal = ctx->shareGroup()->getGlobalName(SHADER,fragmentShader);
1584 GLuint vertexShaderGlobal = ctx->shareGroup()->getGlobalName(SHADER,vertexShader);
1585 ctx->dispatcher().glGetShaderiv(fragmentShaderGlobal,GL_COMPILE_STATUS,&fCompileStatus);
1586 ctx->dispatcher().glGetShaderiv(vertexShaderGlobal,GL_COMPILE_STATUS,&vCompileStatus);
1587
1588 if(fCompileStatus != 0 && vCompileStatus != 0){
1589 ctx->dispatcher().glLinkProgram(globalProgramName);
1590 ctx->dispatcher().glGetProgramiv(globalProgramName,GL_LINK_STATUS,&linkStatus);
1591 }
1592 }
1593 programData->setLinkStatus(linkStatus);
1594
1595 GLsizei infoLogLength=0;
1596 GLchar* infoLog;
1597 ctx->dispatcher().glGetProgramiv(globalProgramName,GL_INFO_LOG_LENGTH,&infoLogLength);
1598 infoLog = new GLchar[infoLogLength+1];
1599 ctx->dispatcher().glGetProgramInfoLog(globalProgramName,infoLogLength,NULL,infoLog);
1600 programData->setInfoLog(infoLog);
1601 }
1602 }
1603
glPixelStorei(GLenum pname,GLint param)1604 GL_APICALL void GL_APIENTRY glPixelStorei(GLenum pname, GLint param){
1605 GET_CTX();
1606 SET_ERROR_IF(!GLESv2Validate::pixelStoreParam(pname),GL_INVALID_ENUM);
1607 SET_ERROR_IF(!((param==1)||(param==2)||(param==4)||(param==8)), GL_INVALID_VALUE);
1608 ctx->setUnpackAlignment(param);
1609 ctx->dispatcher().glPixelStorei(pname,param);
1610 }
1611
glPolygonOffset(GLfloat factor,GLfloat units)1612 GL_APICALL void GL_APIENTRY glPolygonOffset(GLfloat factor, GLfloat units){
1613 GET_CTX();
1614 ctx->dispatcher().glPolygonOffset(factor,units);
1615 }
1616
glReadPixels(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLvoid * pixels)1617 GL_APICALL void GL_APIENTRY glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels){
1618 GET_CTX();
1619 SET_ERROR_IF(!(GLESv2Validate::readPixelFrmt(format) && GLESv2Validate::pixelType(ctx,type)),GL_INVALID_ENUM);
1620 SET_ERROR_IF(!(GLESv2Validate::pixelOp(format,type)),GL_INVALID_OPERATION);
1621 ctx->dispatcher().glReadPixels(x,y,width,height,format,type,pixels);
1622 }
1623
1624
glReleaseShaderCompiler(void)1625 GL_APICALL void GL_APIENTRY glReleaseShaderCompiler(void){
1626 GET_CTX();
1627
1628 if(ctx->dispatcher().glReleaseShaderCompiler != NULL)
1629 {
1630 ctx->dispatcher().glReleaseShaderCompiler();
1631 }
1632 }
1633
glRenderbufferStorage(GLenum target,GLenum internalformat,GLsizei width,GLsizei height)1634 GL_APICALL void GL_APIENTRY glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height){
1635 GET_CTX();
1636 GLenum internal = internalformat;
1637 switch (internalformat) {
1638 case GL_RGB565:
1639 internal = GL_RGB;
1640 break;
1641 case GL_RGB5_A1:
1642 internal = GL_RGBA;
1643 break;
1644 default:
1645 internal = internalformat;
1646 break;
1647 }
1648
1649 // Get current bounded renderbuffer
1650 // raise INVALID_OPERATIOn if no renderbuffer is bounded
1651 GLuint rb = ctx->getRenderbufferBinding();
1652 SET_ERROR_IF(rb == 0,GL_INVALID_OPERATION);
1653 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(RENDERBUFFER,rb);
1654 RenderbufferData *rbData = (RenderbufferData *)objData.Ptr();
1655 SET_ERROR_IF(!rbData,GL_INVALID_OPERATION);
1656
1657 //
1658 // if the renderbuffer was an eglImage target, detach from
1659 // the eglImage.
1660 //
1661 if (rbData->sourceEGLImage != 0) {
1662 if (rbData->eglImageDetach) {
1663 (*rbData->eglImageDetach)(rbData->sourceEGLImage);
1664 }
1665 rbData->sourceEGLImage = 0;
1666 rbData->eglImageGlobalTexName = 0;
1667 }
1668
1669 ctx->dispatcher().glRenderbufferStorageEXT(target,internal,width,height);
1670 }
1671
glSampleCoverage(GLclampf value,GLboolean invert)1672 GL_APICALL void GL_APIENTRY glSampleCoverage(GLclampf value, GLboolean invert){
1673 GET_CTX();
1674 ctx->dispatcher().glSampleCoverage(value,invert);
1675 }
1676
glScissor(GLint x,GLint y,GLsizei width,GLsizei height)1677 GL_APICALL void GL_APIENTRY glScissor(GLint x, GLint y, GLsizei width, GLsizei height){
1678 GET_CTX();
1679 ctx->dispatcher().glScissor(x,y,width,height);
1680 }
1681
glShaderBinary(GLsizei n,const GLuint * shaders,GLenum binaryformat,const GLvoid * binary,GLsizei length)1682 GL_APICALL void GL_APIENTRY glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length){
1683 GET_CTX();
1684
1685 SET_ERROR_IF( (ctx->dispatcher().glShaderBinary == NULL), GL_INVALID_OPERATION);
1686
1687 if(ctx->shareGroup().Ptr()){
1688 for(int i=0; i < n ; i++){
1689 const GLuint globalShaderName = ctx->shareGroup()->getGlobalName(SHADER,shaders[i]);
1690 SET_ERROR_IF(globalShaderName == 0,GL_INVALID_VALUE);
1691 ctx->dispatcher().glShaderBinary(1,&globalShaderName,binaryformat,binary,length);
1692 }
1693 }
1694 }
1695
glShaderSource(GLuint shader,GLsizei count,const GLchar ** string,const GLint * length)1696 GL_APICALL void GL_APIENTRY glShaderSource(GLuint shader, GLsizei count, const GLchar** string, const GLint* length){
1697 GET_CTX_V2();
1698 SET_ERROR_IF(count < 0,GL_INVALID_VALUE);
1699 if(ctx->shareGroup().Ptr()){
1700 const GLuint globalShaderName = ctx->shareGroup()->getGlobalName(SHADER,shader);
1701 SET_ERROR_IF(globalShaderName == 0,GL_INVALID_VALUE);
1702 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,shader);
1703 SET_ERROR_IF(!objData.Ptr(),GL_INVALID_OPERATION);
1704 SET_ERROR_IF(objData.Ptr()->getDataType()!=SHADER_DATA,GL_INVALID_OPERATION);
1705 ShaderParser* sp = (ShaderParser*)objData.Ptr();
1706 sp->setSrc(ctx->glslVersion(),count,string,length);
1707 ctx->dispatcher().glShaderSource(globalShaderName,1,sp->parsedLines(),NULL);
1708 }
1709 }
1710
glStencilFunc(GLenum func,GLint ref,GLuint mask)1711 GL_APICALL void GL_APIENTRY glStencilFunc(GLenum func, GLint ref, GLuint mask){
1712 GET_CTX();
1713 ctx->dispatcher().glStencilFunc(func,ref,mask);
1714 }
glStencilFuncSeparate(GLenum face,GLenum func,GLint ref,GLuint mask)1715 GL_APICALL void GL_APIENTRY glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask){
1716 GET_CTX();
1717 ctx->dispatcher().glStencilFuncSeparate(face,func,ref,mask);
1718 }
glStencilMask(GLuint mask)1719 GL_APICALL void GL_APIENTRY glStencilMask(GLuint mask){
1720 GET_CTX();
1721 ctx->dispatcher().glStencilMask(mask);
1722 }
1723
glStencilMaskSeparate(GLenum face,GLuint mask)1724 GL_APICALL void GL_APIENTRY glStencilMaskSeparate(GLenum face, GLuint mask){
1725 GET_CTX();
1726 ctx->dispatcher().glStencilMaskSeparate(face,mask);
1727 }
1728
glStencilOp(GLenum fail,GLenum zfail,GLenum zpass)1729 GL_APICALL void GL_APIENTRY glStencilOp(GLenum fail, GLenum zfail, GLenum zpass){
1730 GET_CTX();
1731 ctx->dispatcher().glStencilOp(fail,zfail,zpass);
1732 }
1733
glStencilOpSeparate(GLenum face,GLenum fail,GLenum zfail,GLenum zpass)1734 GL_APICALL void GL_APIENTRY glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass){
1735 GET_CTX();
1736 ctx->dispatcher().glStencilOp(fail,zfail,zpass);
1737 }
1738
glTexImage2D(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,const GLvoid * pixels)1739 GL_APICALL void GL_APIENTRY glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels){
1740 GET_CTX();
1741 SET_ERROR_IF(!(GLESv2Validate::textureTargetEx(target) &&
1742 GLESv2Validate::pixelFrmt(ctx,internalformat) &&
1743 GLESv2Validate::pixelFrmt(ctx,format)&&
1744 GLESv2Validate::pixelType(ctx,type)),GL_INVALID_ENUM);
1745
1746 SET_ERROR_IF((format == GL_DEPTH_COMPONENT || internalformat == GL_DEPTH_COMPONENT) &&
1747 (type != GL_UNSIGNED_SHORT && type != GL_UNSIGNED_INT), GL_INVALID_OPERATION);
1748
1749 SET_ERROR_IF((type == GL_UNSIGNED_SHORT || type == GL_UNSIGNED_INT) &&
1750 (format != GL_DEPTH_COMPONENT || internalformat != GL_DEPTH_COMPONENT), GL_INVALID_OPERATION);
1751
1752 SET_ERROR_IF(!(GLESv2Validate::pixelOp(format,type) && internalformat == ((GLint)format)),GL_INVALID_OPERATION);
1753 SET_ERROR_IF(border != 0,GL_INVALID_VALUE);
1754
1755 if (ctx->shareGroup().Ptr()){
1756 TextureData *texData = getTextureTargetData(target);
1757 if(texData) {
1758 texData->width = width;
1759 texData->height = height;
1760 texData->border = border;
1761 texData->internalFormat = internalformat;
1762 texData->target = target;
1763
1764 if (texData->sourceEGLImage != 0) {
1765 //
1766 // This texture was a target of EGLImage,
1767 // but now it is re-defined so we need to detach
1768 // from the EGLImage and re-generate global texture name
1769 // for it.
1770 //
1771 if (texData->eglImageDetach) {
1772 (*texData->eglImageDetach)(texData->sourceEGLImage);
1773 }
1774 unsigned int tex = ctx->getBindedTexture(target);
1775 ctx->shareGroup()->replaceGlobalName(TEXTURE,
1776 tex,
1777 texData->oldGlobal);
1778 ctx->dispatcher().glBindTexture(GL_TEXTURE_2D, texData->oldGlobal);
1779 texData->sourceEGLImage = 0;
1780 texData->oldGlobal = 0;
1781 }
1782 }
1783 }
1784
1785 if (type==GL_HALF_FLOAT_OES)
1786 type = GL_HALF_FLOAT_NV;
1787 if (pixels==NULL && type==GL_UNSIGNED_SHORT_5_5_5_1)
1788 type = GL_UNSIGNED_SHORT;
1789 ctx->dispatcher().glTexImage2D(target,level,internalformat,width,height,border,format,type,pixels);
1790 }
1791
1792
glTexParameterf(GLenum target,GLenum pname,GLfloat param)1793 GL_APICALL void GL_APIENTRY glTexParameterf(GLenum target, GLenum pname, GLfloat param){
1794 GET_CTX();
1795 SET_ERROR_IF(!(GLESv2Validate::textureTarget(target) && GLESv2Validate::textureParams(pname)),GL_INVALID_ENUM);
1796 ctx->dispatcher().glTexParameterf(target,pname,param);
1797 }
glTexParameterfv(GLenum target,GLenum pname,const GLfloat * params)1798 GL_APICALL void GL_APIENTRY glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params){
1799 GET_CTX();
1800 SET_ERROR_IF(!(GLESv2Validate::textureTarget(target) && GLESv2Validate::textureParams(pname)),GL_INVALID_ENUM);
1801 ctx->dispatcher().glTexParameterfv(target,pname,params);
1802 }
glTexParameteri(GLenum target,GLenum pname,GLint param)1803 GL_APICALL void GL_APIENTRY glTexParameteri(GLenum target, GLenum pname, GLint param){
1804 GET_CTX();
1805 SET_ERROR_IF(!(GLESv2Validate::textureTarget(target) && GLESv2Validate::textureParams(pname)),GL_INVALID_ENUM);
1806 ctx->dispatcher().glTexParameteri(target,pname,param);
1807 }
glTexParameteriv(GLenum target,GLenum pname,const GLint * params)1808 GL_APICALL void GL_APIENTRY glTexParameteriv(GLenum target, GLenum pname, const GLint* params){
1809 GET_CTX();
1810 SET_ERROR_IF(!(GLESv2Validate::textureTarget(target) && GLESv2Validate::textureParams(pname)),GL_INVALID_ENUM);
1811 ctx->dispatcher().glTexParameteriv(target,pname,params);
1812 }
1813
glTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid * pixels)1814 GL_APICALL void GL_APIENTRY glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels){
1815 GET_CTX();
1816 SET_ERROR_IF(!(GLESv2Validate::textureTargetEx(target) &&
1817 GLESv2Validate::pixelFrmt(ctx,format)&&
1818 GLESv2Validate::pixelType(ctx,type)),GL_INVALID_ENUM);
1819 SET_ERROR_IF(!GLESv2Validate::pixelOp(format,type),GL_INVALID_OPERATION);
1820 if (type==GL_HALF_FLOAT_OES)
1821 type = GL_HALF_FLOAT_NV;
1822
1823 ctx->dispatcher().glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixels);
1824
1825 }
1826
glUniform1f(GLint location,GLfloat x)1827 GL_APICALL void GL_APIENTRY glUniform1f(GLint location, GLfloat x){
1828 GET_CTX();
1829 ctx->dispatcher().glUniform1f(location,x);
1830 }
glUniform1fv(GLint location,GLsizei count,const GLfloat * v)1831 GL_APICALL void GL_APIENTRY glUniform1fv(GLint location, GLsizei count, const GLfloat* v){
1832 GET_CTX();
1833 ctx->dispatcher().glUniform1fv(location,count,v);
1834 }
1835
glUniform1i(GLint location,GLint x)1836 GL_APICALL void GL_APIENTRY glUniform1i(GLint location, GLint x){
1837 GET_CTX();
1838 ctx->dispatcher().glUniform1i(location,x);
1839 }
glUniform1iv(GLint location,GLsizei count,const GLint * v)1840 GL_APICALL void GL_APIENTRY glUniform1iv(GLint location, GLsizei count, const GLint* v){
1841 GET_CTX();
1842 ctx->dispatcher().glUniform1iv(location,count,v);
1843 }
glUniform2f(GLint location,GLfloat x,GLfloat y)1844 GL_APICALL void GL_APIENTRY glUniform2f(GLint location, GLfloat x, GLfloat y){
1845 GET_CTX();
1846 ctx->dispatcher().glUniform2f(location,x,y);
1847 }
glUniform2fv(GLint location,GLsizei count,const GLfloat * v)1848 GL_APICALL void GL_APIENTRY glUniform2fv(GLint location, GLsizei count, const GLfloat* v){
1849 GET_CTX();
1850 ctx->dispatcher().glUniform2fv(location,count,v);
1851 }
glUniform2i(GLint location,GLint x,GLint y)1852 GL_APICALL void GL_APIENTRY glUniform2i(GLint location, GLint x, GLint y){
1853 GET_CTX();
1854 ctx->dispatcher().glUniform2i(location,x,y);
1855 }
glUniform2iv(GLint location,GLsizei count,const GLint * v)1856 GL_APICALL void GL_APIENTRY glUniform2iv(GLint location, GLsizei count, const GLint* v){
1857 GET_CTX();
1858 ctx->dispatcher().glUniform2iv(location,count,v);
1859 }
glUniform3f(GLint location,GLfloat x,GLfloat y,GLfloat z)1860 GL_APICALL void GL_APIENTRY glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z){
1861 GET_CTX();
1862 ctx->dispatcher().glUniform3f(location,x,y,z);
1863 }
glUniform3fv(GLint location,GLsizei count,const GLfloat * v)1864 GL_APICALL void GL_APIENTRY glUniform3fv(GLint location, GLsizei count, const GLfloat* v){
1865 GET_CTX();
1866 ctx->dispatcher().glUniform3fv(location,count,v);
1867 }
glUniform3i(GLint location,GLint x,GLint y,GLint z)1868 GL_APICALL void GL_APIENTRY glUniform3i(GLint location, GLint x, GLint y, GLint z){
1869 GET_CTX();
1870 ctx->dispatcher().glUniform3i(location,x,y,z);
1871 }
1872
glUniform3iv(GLint location,GLsizei count,const GLint * v)1873 GL_APICALL void GL_APIENTRY glUniform3iv(GLint location, GLsizei count, const GLint* v){
1874 GET_CTX();
1875 ctx->dispatcher().glUniform3iv(location,count,v);
1876 }
1877
glUniform4f(GLint location,GLfloat x,GLfloat y,GLfloat z,GLfloat w)1878 GL_APICALL void GL_APIENTRY glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w){
1879 GET_CTX();
1880 ctx->dispatcher().glUniform4f(location,x,y,z,w);
1881 }
1882
glUniform4fv(GLint location,GLsizei count,const GLfloat * v)1883 GL_APICALL void GL_APIENTRY glUniform4fv(GLint location, GLsizei count, const GLfloat* v){
1884 GET_CTX();
1885 ctx->dispatcher().glUniform4fv(location,count,v);
1886 }
1887
glUniform4i(GLint location,GLint x,GLint y,GLint z,GLint w)1888 GL_APICALL void GL_APIENTRY glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w){
1889 GET_CTX();
1890 ctx->dispatcher().glUniform4i(location,x,y,z,w);
1891 }
1892
glUniform4iv(GLint location,GLsizei count,const GLint * v)1893 GL_APICALL void GL_APIENTRY glUniform4iv(GLint location, GLsizei count, const GLint* v){
1894 GET_CTX();
1895 ctx->dispatcher().glUniform4iv(location,count,v);
1896 }
1897
glUniformMatrix2fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1898 GL_APICALL void GL_APIENTRY glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value){
1899 GET_CTX();
1900 SET_ERROR_IF(transpose != GL_FALSE,GL_INVALID_VALUE);
1901 ctx->dispatcher().glUniformMatrix2fv(location,count,transpose,value);
1902 }
1903
glUniformMatrix3fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1904 GL_APICALL void GL_APIENTRY glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value){
1905 GET_CTX();
1906 SET_ERROR_IF(transpose != GL_FALSE,GL_INVALID_VALUE);
1907 ctx->dispatcher().glUniformMatrix3fv(location,count,transpose,value);
1908 }
1909
glUniformMatrix4fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1910 GL_APICALL void GL_APIENTRY glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value){
1911 GET_CTX();
1912 SET_ERROR_IF(transpose != GL_FALSE,GL_INVALID_VALUE);
1913 ctx->dispatcher().glUniformMatrix4fv(location,count,transpose,value);
1914 }
1915
glUseProgram(GLuint program)1916 GL_APICALL void GL_APIENTRY glUseProgram(GLuint program){
1917 GET_CTX();
1918 if(ctx->shareGroup().Ptr()) {
1919 const GLuint globalProgramName = ctx->shareGroup()->getGlobalName(SHADER,program);
1920 SET_ERROR_IF(program!=0 && globalProgramName==0,GL_INVALID_VALUE);
1921 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,program);
1922 SET_ERROR_IF(objData.Ptr() && (objData.Ptr()->getDataType()!=PROGRAM_DATA),GL_INVALID_OPERATION);
1923 ctx->dispatcher().glUseProgram(globalProgramName);
1924 }
1925 }
1926
glValidateProgram(GLuint program)1927 GL_APICALL void GL_APIENTRY glValidateProgram(GLuint program){
1928 GET_CTX();
1929 if(ctx->shareGroup().Ptr()) {
1930 const GLuint globalProgramName = ctx->shareGroup()->getGlobalName(SHADER,program);
1931 SET_ERROR_IF(globalProgramName==0, GL_INVALID_VALUE);
1932 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(SHADER,program);
1933 SET_ERROR_IF(objData.Ptr()->getDataType()!=PROGRAM_DATA,GL_INVALID_OPERATION);
1934 ProgramData* programData = (ProgramData*)objData.Ptr();
1935 ctx->dispatcher().glValidateProgram(globalProgramName);
1936
1937 GLsizei infoLogLength=0;
1938 GLchar* infoLog;
1939 ctx->dispatcher().glGetProgramiv(globalProgramName,GL_INFO_LOG_LENGTH,&infoLogLength);
1940 infoLog = new GLchar[infoLogLength+1];
1941 ctx->dispatcher().glGetProgramInfoLog(globalProgramName,infoLogLength,NULL,infoLog);
1942 programData->setInfoLog(infoLog);
1943 }
1944 }
1945
glVertexAttrib1f(GLuint indx,GLfloat x)1946 GL_APICALL void GL_APIENTRY glVertexAttrib1f(GLuint indx, GLfloat x){
1947 GET_CTX_V2();
1948 ctx->dispatcher().glVertexAttrib1f(indx,x);
1949 if(indx == 0)
1950 ctx->setAttribute0value(x, 0.0, 0.0, 1.0);
1951 }
1952
glVertexAttrib1fv(GLuint indx,const GLfloat * values)1953 GL_APICALL void GL_APIENTRY glVertexAttrib1fv(GLuint indx, const GLfloat* values){
1954 GET_CTX_V2();
1955 ctx->dispatcher().glVertexAttrib1fv(indx,values);
1956 if(indx == 0)
1957 ctx->setAttribute0value(values[0], 0.0, 0.0, 1.0);
1958 }
1959
glVertexAttrib2f(GLuint indx,GLfloat x,GLfloat y)1960 GL_APICALL void GL_APIENTRY glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y){
1961 GET_CTX_V2();
1962 ctx->dispatcher().glVertexAttrib2f(indx,x,y);
1963 if(indx == 0)
1964 ctx->setAttribute0value(x, y, 0.0, 1.0);
1965 }
1966
glVertexAttrib2fv(GLuint indx,const GLfloat * values)1967 GL_APICALL void GL_APIENTRY glVertexAttrib2fv(GLuint indx, const GLfloat* values){
1968 GET_CTX_V2();
1969 ctx->dispatcher().glVertexAttrib2fv(indx,values);
1970 if(indx == 0)
1971 ctx->setAttribute0value(values[0], values[1], 0.0, 1.0);
1972 }
1973
glVertexAttrib3f(GLuint indx,GLfloat x,GLfloat y,GLfloat z)1974 GL_APICALL void GL_APIENTRY glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z){
1975 GET_CTX_V2();
1976 ctx->dispatcher().glVertexAttrib3f(indx,x,y,z);
1977 if(indx == 0)
1978 ctx->setAttribute0value(x, y, z, 1.0);
1979 }
1980
glVertexAttrib3fv(GLuint indx,const GLfloat * values)1981 GL_APICALL void GL_APIENTRY glVertexAttrib3fv(GLuint indx, const GLfloat* values){
1982 GET_CTX_V2();
1983 ctx->dispatcher().glVertexAttrib3fv(indx,values);
1984 if(indx == 0)
1985 ctx->setAttribute0value(values[0], values[1], values[2], 1.0);
1986 }
1987
glVertexAttrib4f(GLuint indx,GLfloat x,GLfloat y,GLfloat z,GLfloat w)1988 GL_APICALL void GL_APIENTRY glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w){
1989 GET_CTX_V2();
1990 ctx->dispatcher().glVertexAttrib4f(indx,x,y,z,w);
1991 if(indx == 0)
1992 ctx->setAttribute0value(x, y, z, w);
1993 }
1994
glVertexAttrib4fv(GLuint indx,const GLfloat * values)1995 GL_APICALL void GL_APIENTRY glVertexAttrib4fv(GLuint indx, const GLfloat* values){
1996 GET_CTX_V2();
1997 ctx->dispatcher().glVertexAttrib4fv(indx,values);
1998 if(indx == 0)
1999 ctx->setAttribute0value(values[0], values[1], values[2], values[3]);
2000 }
2001
glVertexAttribPointer(GLuint indx,GLint size,GLenum type,GLboolean normalized,GLsizei stride,const GLvoid * ptr)2002 GL_APICALL void GL_APIENTRY glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr){
2003 GET_CTX();
2004 SET_ERROR_IF((!GLESv2Validate::arrayIndex(ctx,indx)),GL_INVALID_VALUE);
2005 if (type == GL_HALF_FLOAT_OES) type = GL_HALF_FLOAT;
2006 ctx->setPointer(indx,size,type,stride,ptr,normalized);
2007 }
2008
glViewport(GLint x,GLint y,GLsizei width,GLsizei height)2009 GL_APICALL void GL_APIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height){
2010 GET_CTX();
2011 ctx->dispatcher().glViewport(x,y,width,height);
2012 }
2013
glEGLImageTargetTexture2DOES(GLenum target,GLeglImageOES image)2014 GL_APICALL void GL_APIENTRY glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
2015 {
2016 GET_CTX();
2017 SET_ERROR_IF(!GLESv2Validate::textureTargetLimited(target),GL_INVALID_ENUM);
2018 unsigned int imagehndl = SafeUIntFromPointer(image);
2019 EglImage *img = s_eglIface->eglAttachEGLImage(imagehndl);
2020 if (img) {
2021 // Create the texture object in the underlying EGL implementation,
2022 // flag to the OpenGL layer to skip the image creation and map the
2023 // current binded texture object to the existing global object.
2024 if (ctx->shareGroup().Ptr()) {
2025 ObjectLocalName tex = TextureLocalName(target,ctx->getBindedTexture(target));
2026 unsigned int oldGlobal = ctx->shareGroup()->getGlobalName(TEXTURE, tex);
2027 // Delete old texture object but only if it is not a target of a EGLImage
2028 if (oldGlobal) {
2029 TextureData* oldTexData = getTextureData(tex);
2030 if (!oldTexData || oldTexData->sourceEGLImage == 0) {
2031 ctx->dispatcher().glDeleteTextures(1, &oldGlobal);
2032 }
2033 }
2034 // replace mapping and bind the new global object
2035 ctx->shareGroup()->replaceGlobalName(TEXTURE, tex,img->globalTexName);
2036 ctx->dispatcher().glBindTexture(GL_TEXTURE_2D, img->globalTexName);
2037 TextureData *texData = getTextureTargetData(target);
2038 SET_ERROR_IF(texData==NULL,GL_INVALID_OPERATION);
2039 texData->width = img->width;
2040 texData->height = img->height;
2041 texData->border = img->border;
2042 texData->internalFormat = img->internalFormat;
2043 texData->sourceEGLImage = imagehndl;
2044 texData->eglImageDetach = s_eglIface->eglDetachEGLImage;
2045 texData->oldGlobal = oldGlobal;
2046 }
2047 }
2048 }
2049
glEGLImageTargetRenderbufferStorageOES(GLenum target,GLeglImageOES image)2050 GL_APICALL void GL_APIENTRY glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
2051 {
2052 GET_CTX();
2053 SET_ERROR_IF(target != GL_RENDERBUFFER_OES,GL_INVALID_ENUM);
2054 unsigned int imagehndl = SafeUIntFromPointer(image);
2055 EglImage *img = s_eglIface->eglAttachEGLImage(imagehndl);
2056 SET_ERROR_IF(!img,GL_INVALID_VALUE);
2057 SET_ERROR_IF(!ctx->shareGroup().Ptr(),GL_INVALID_OPERATION);
2058
2059 // Get current bounded renderbuffer
2060 // raise INVALID_OPERATIOn if no renderbuffer is bounded
2061 GLuint rb = ctx->getRenderbufferBinding();
2062 SET_ERROR_IF(rb == 0,GL_INVALID_OPERATION);
2063 ObjectDataPtr objData = ctx->shareGroup()->getObjectData(RENDERBUFFER,rb);
2064 RenderbufferData *rbData = (RenderbufferData *)objData.Ptr();
2065 SET_ERROR_IF(!rbData,GL_INVALID_OPERATION);
2066
2067 //
2068 // flag in the renderbufferData that it is an eglImage target
2069 //
2070 rbData->sourceEGLImage = imagehndl;
2071 rbData->eglImageDetach = s_eglIface->eglDetachEGLImage;
2072 rbData->eglImageGlobalTexName = img->globalTexName;
2073
2074 //
2075 // if the renderbuffer is attached to a framebuffer
2076 // change the framebuffer attachment in the undelying OpenGL
2077 // to point to the eglImage texture object.
2078 //
2079 if (rbData->attachedFB) {
2080 // update the framebuffer attachment point to the
2081 // underlying texture of the img
2082 GLuint prevFB = ctx->getFramebufferBinding();
2083 if (prevFB != rbData->attachedFB) {
2084 ctx->dispatcher().glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,
2085 rbData->attachedFB);
2086 }
2087 ctx->dispatcher().glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
2088 rbData->attachedPoint,
2089 GL_TEXTURE_2D,
2090 img->globalTexName,0);
2091 if (prevFB != rbData->attachedFB) {
2092 ctx->dispatcher().glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,
2093 prevFB);
2094 }
2095 }
2096 }
2097