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 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 } 76 static GLEScontext* createGLESContext() { 77 return new GLESv2Context(); 78 } 79 80 static void deleteGLESContext(GLEScontext* ctx) { 81 delete ctx; 82 } 83 84 static void setShareGroup(GLEScontext* ctx,ShareGroupPtr grp) { 85 if(ctx) { 86 ctx->setShareGroup(grp); 87 } 88 } 89 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 112 GL_APICALL GLESiface* __translator_getIfaces(EGLiface* eglIface){ 113 s_eglIface = eglIface; 114 return & s_glesIface; 115 } 116 117 } 118 119 static ObjectLocalName TextureLocalName(GLenum target,unsigned int tex) { 120 GET_CTX_RET(0); 121 return (tex!=0? tex : ctx->getDefaultTextureName(target)); 122 } 123 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 324 GL_APICALL void GL_APIENTRY glClear(GLbitfield mask){ 325 GET_CTX(); 326 ctx->drawValidate(); 327 328 ctx->dispatcher().glClear(mask); 329 } 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 } 334 GL_APICALL void GL_APIENTRY glClearDepthf(GLclampf depth){ 335 GET_CTX(); 336 ctx->dispatcher().glClearDepth(depth); 337 } 338 GL_APICALL void GL_APIENTRY glClearStencil(GLint s){ 339 GET_CTX(); 340 ctx->dispatcher().glClearStencil(s); 341 } 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 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 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 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 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 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 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 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 428 GL_APICALL void GL_APIENTRY glCullFace(GLenum mode){ 429 GET_CTX(); 430 ctx->dispatcher().glCullFace(mode); 431 } 432 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 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 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 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 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 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 512 GL_APICALL void GL_APIENTRY glDepthFunc(GLenum func){ 513 GET_CTX(); 514 ctx->dispatcher().glDepthFunc(func); 515 } 516 GL_APICALL void GL_APIENTRY glDepthMask(GLboolean flag){ 517 GET_CTX(); 518 ctx->dispatcher().glDepthMask(flag); 519 } 520 GL_APICALL void GL_APIENTRY glDepthRangef(GLclampf zNear, GLclampf zFar){ 521 GET_CTX(); 522 ctx->dispatcher().glDepthRange(zNear,zFar); 523 } 524 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 545 GL_APICALL void GL_APIENTRY glDisable(GLenum cap){ 546 GET_CTX(); 547 ctx->dispatcher().glDisable(cap); 548 } 549 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 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 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 621 GL_APICALL void GL_APIENTRY glEnable(GLenum cap){ 622 GET_CTX(); 623 ctx->dispatcher().glEnable(cap); 624 } 625 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 633 GL_APICALL void GL_APIENTRY glFinish(void){ 634 GET_CTX(); 635 ctx->dispatcher().glFinish(); 636 } 637 GL_APICALL void GL_APIENTRY glFlush(void){ 638 GET_CTX(); 639 ctx->dispatcher().glFlush(); 640 } 641 642 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 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 725 GL_APICALL void GL_APIENTRY glFrontFace(GLenum mode){ 726 GET_CTX(); 727 ctx->dispatcher().glFrontFace(mode); 728 } 729 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 } 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 1561 GL_APICALL void GL_APIENTRY glLineWidth(GLfloat width){ 1562 GET_CTX(); 1563 ctx->dispatcher().glLineWidth(width); 1564 } 1565 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 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 1612 GL_APICALL void GL_APIENTRY glPolygonOffset(GLfloat factor, GLfloat units){ 1613 GET_CTX(); 1614 ctx->dispatcher().glPolygonOffset(factor,units); 1615 } 1616 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 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 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 1672 GL_APICALL void GL_APIENTRY glSampleCoverage(GLclampf value, GLboolean invert){ 1673 GET_CTX(); 1674 ctx->dispatcher().glSampleCoverage(value,invert); 1675 } 1676 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 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 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 1711 GL_APICALL void GL_APIENTRY glStencilFunc(GLenum func, GLint ref, GLuint mask){ 1712 GET_CTX(); 1713 ctx->dispatcher().glStencilFunc(func,ref,mask); 1714 } 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 } 1719 GL_APICALL void GL_APIENTRY glStencilMask(GLuint mask){ 1720 GET_CTX(); 1721 ctx->dispatcher().glStencilMask(mask); 1722 } 1723 1724 GL_APICALL void GL_APIENTRY glStencilMaskSeparate(GLenum face, GLuint mask){ 1725 GET_CTX(); 1726 ctx->dispatcher().glStencilMaskSeparate(face,mask); 1727 } 1728 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 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 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 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 } 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 } 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 } 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 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 1827 GL_APICALL void GL_APIENTRY glUniform1f(GLint location, GLfloat x){ 1828 GET_CTX(); 1829 ctx->dispatcher().glUniform1f(location,x); 1830 } 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 1836 GL_APICALL void GL_APIENTRY glUniform1i(GLint location, GLint x){ 1837 GET_CTX(); 1838 ctx->dispatcher().glUniform1i(location,x); 1839 } 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 } 1844 GL_APICALL void GL_APIENTRY glUniform2f(GLint location, GLfloat x, GLfloat y){ 1845 GET_CTX(); 1846 ctx->dispatcher().glUniform2f(location,x,y); 1847 } 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 } 1852 GL_APICALL void GL_APIENTRY glUniform2i(GLint location, GLint x, GLint y){ 1853 GET_CTX(); 1854 ctx->dispatcher().glUniform2i(location,x,y); 1855 } 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 } 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 } 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 } 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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
