1 #include "precompiled.h" 2 // 3 // Copyright (c) 2002-2014 The ANGLE Project Authors. All rights reserved. 4 // Use of this source code is governed by a BSD-style license that can be 5 // found in the LICENSE file. 6 // 7 8 // Context.cpp: Implements the gl::Context class, managing all GL state and performing 9 // rendering operations. It is the GLES2 specific implementation of EGLContext. 10 11 #include "libGLESv2/Context.h" 12 13 #include "libGLESv2/main.h" 14 #include "common/utilities.h" 15 #include "libGLESv2/formatutils.h" 16 #include "libGLESv2/Buffer.h" 17 #include "libGLESv2/Fence.h" 18 #include "libGLESv2/Framebuffer.h" 19 #include "libGLESv2/Renderbuffer.h" 20 #include "libGLESv2/Program.h" 21 #include "libGLESv2/ProgramBinary.h" 22 #include "libGLESv2/Query.h" 23 #include "libGLESv2/Texture.h" 24 #include "libGLESv2/ResourceManager.h" 25 #include "libGLESv2/renderer/IndexDataManager.h" 26 #include "libGLESv2/renderer/RenderTarget.h" 27 #include "libGLESv2/renderer/Renderer.h" 28 #include "libGLESv2/VertexArray.h" 29 #include "libGLESv2/Sampler.h" 30 #include "libGLESv2/validationES.h" 31 #include "libGLESv2/TransformFeedback.h" 32 33 #include "libEGL/Surface.h" 34 35 #undef near 36 #undef far 37 38 namespace gl 39 { 40 static const char* makeStaticString(const std::string& str) 41 { 42 static std::set<std::string> strings; 43 std::set<std::string>::iterator it = strings.find(str); 44 if (it != strings.end()) 45 return it->c_str(); 46 47 return strings.insert(str).first->c_str(); 48 } 49 50 Context::Context(int clientVersion, const gl::Context *shareContext, rx::Renderer *renderer, bool notifyResets, bool robustAccess) : mRenderer(renderer) 51 { 52 ASSERT(robustAccess == false); // Unimplemented 53 54 mFenceNVHandleAllocator.setBaseHandle(0); 55 56 setClearColor(0.0f, 0.0f, 0.0f, 0.0f); 57 58 mClientVersion = clientVersion; 59 60 mState.depthClearValue = 1.0f; 61 mState.stencilClearValue = 0; 62 63 mState.rasterizer.rasterizerDiscard = false; 64 mState.rasterizer.cullFace = false; 65 mState.rasterizer.cullMode = GL_BACK; 66 mState.rasterizer.frontFace = GL_CCW; 67 mState.rasterizer.polygonOffsetFill = false; 68 mState.rasterizer.polygonOffsetFactor = 0.0f; 69 mState.rasterizer.polygonOffsetUnits = 0.0f; 70 mState.rasterizer.pointDrawMode = false; 71 mState.rasterizer.multiSample = false; 72 mState.scissorTest = false; 73 mState.scissor.x = 0; 74 mState.scissor.y = 0; 75 mState.scissor.width = 0; 76 mState.scissor.height = 0; 77 78 mState.blend.blend = false; 79 mState.blend.sourceBlendRGB = GL_ONE; 80 mState.blend.sourceBlendAlpha = GL_ONE; 81 mState.blend.destBlendRGB = GL_ZERO; 82 mState.blend.destBlendAlpha = GL_ZERO; 83 mState.blend.blendEquationRGB = GL_FUNC_ADD; 84 mState.blend.blendEquationAlpha = GL_FUNC_ADD; 85 mState.blend.sampleAlphaToCoverage = false; 86 mState.blend.dither = true; 87 88 mState.blendColor.red = 0; 89 mState.blendColor.green = 0; 90 mState.blendColor.blue = 0; 91 mState.blendColor.alpha = 0; 92 93 mState.depthStencil.depthTest = false; 94 mState.depthStencil.depthFunc = GL_LESS; 95 mState.depthStencil.depthMask = true; 96 mState.depthStencil.stencilTest = false; 97 mState.depthStencil.stencilFunc = GL_ALWAYS; 98 mState.depthStencil.stencilMask = -1; 99 mState.depthStencil.stencilWritemask = -1; 100 mState.depthStencil.stencilBackFunc = GL_ALWAYS; 101 mState.depthStencil.stencilBackMask = - 1; 102 mState.depthStencil.stencilBackWritemask = -1; 103 mState.depthStencil.stencilFail = GL_KEEP; 104 mState.depthStencil.stencilPassDepthFail = GL_KEEP; 105 mState.depthStencil.stencilPassDepthPass = GL_KEEP; 106 mState.depthStencil.stencilBackFail = GL_KEEP; 107 mState.depthStencil.stencilBackPassDepthFail = GL_KEEP; 108 mState.depthStencil.stencilBackPassDepthPass = GL_KEEP; 109 110 mState.stencilRef = 0; 111 mState.stencilBackRef = 0; 112 113 mState.sampleCoverage = false; 114 mState.sampleCoverageValue = 1.0f; 115 mState.sampleCoverageInvert = false; 116 mState.generateMipmapHint = GL_DONT_CARE; 117 mState.fragmentShaderDerivativeHint = GL_DONT_CARE; 118 119 mState.lineWidth = 1.0f; 120 121 mState.viewport.x = 0; 122 mState.viewport.y = 0; 123 mState.viewport.width = 0; 124 mState.viewport.height = 0; 125 mState.zNear = 0.0f; 126 mState.zFar = 1.0f; 127 128 mState.blend.colorMaskRed = true; 129 mState.blend.colorMaskGreen = true; 130 mState.blend.colorMaskBlue = true; 131 mState.blend.colorMaskAlpha = true; 132 133 const GLfloat defaultFloatValues[] = { 0.0f, 0.0f, 0.0f, 1.0f }; 134 for (int attribIndex = 0; attribIndex < MAX_VERTEX_ATTRIBS; attribIndex++) 135 { 136 mState.vertexAttribCurrentValues[attribIndex].setFloatValues(defaultFloatValues); 137 } 138 139 if (shareContext != NULL) 140 { 141 mResourceManager = shareContext->mResourceManager; 142 mResourceManager->addRef(); 143 } 144 else 145 { 146 mResourceManager = new ResourceManager(mRenderer); 147 } 148 149 // [OpenGL ES 2.0.24] section 3.7 page 83: 150 // In the initial state, TEXTURE_2D and TEXTURE_CUBE_MAP have twodimensional 151 // and cube map texture state vectors respectively associated with them. 152 // In order that access to these initial textures not be lost, they are treated as texture 153 // objects all of whose names are 0. 154 155 mTexture2DZero.set(new Texture2D(mRenderer, 0)); 156 mTextureCubeMapZero.set(new TextureCubeMap(mRenderer, 0)); 157 mTexture3DZero.set(new Texture3D(mRenderer, 0)); 158 mTexture2DArrayZero.set(new Texture2DArray(mRenderer, 0)); 159 160 for (unsigned int textureUnit = 0; textureUnit < ArraySize(mState.samplers); textureUnit++) 161 { 162 mState.samplers[textureUnit] = 0; 163 } 164 165 mState.activeSampler = 0; 166 bindVertexArray(0); 167 bindArrayBuffer(0); 168 bindElementArrayBuffer(0); 169 bindTextureCubeMap(0); 170 bindTexture2D(0); 171 bindReadFramebuffer(0); 172 bindDrawFramebuffer(0); 173 bindRenderbuffer(0); 174 175 mState.activeQueries[GL_ANY_SAMPLES_PASSED].set(NULL); 176 mState.activeQueries[GL_ANY_SAMPLES_PASSED_CONSERVATIVE].set(NULL); 177 mState.activeQueries[GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN].set(NULL); 178 179 bindGenericUniformBuffer(0); 180 for (int i = 0; i < IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS; i++) 181 { 182 bindIndexedUniformBuffer(0, i, 0, -1); 183 } 184 185 bindGenericTransformFeedbackBuffer(0); 186 for (int i = 0; i < IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS; i++) 187 { 188 bindIndexedTransformFeedbackBuffer(0, i, 0, -1); 189 } 190 191 bindCopyReadBuffer(0); 192 bindCopyWriteBuffer(0); 193 bindPixelPackBuffer(0); 194 bindPixelUnpackBuffer(0); 195 196 // [OpenGL ES 3.0.2] section 2.14.1 pg 85: 197 // In the initial state, a default transform feedback object is bound and treated as 198 // a transform feedback object with a name of zero. That object is bound any time 199 // BindTransformFeedback is called with id of zero 200 mTransformFeedbackZero.set(new TransformFeedback(0)); 201 bindTransformFeedback(0); 202 203 mState.currentProgram = 0; 204 mCurrentProgramBinary.set(NULL); 205 206 mCombinedExtensionsString = NULL; 207 mRendererString = NULL; 208 209 mInvalidEnum = false; 210 mInvalidValue = false; 211 mInvalidOperation = false; 212 mOutOfMemory = false; 213 mInvalidFramebufferOperation = false; 214 215 mHasBeenCurrent = false; 216 mContextLost = false; 217 mResetStatus = GL_NO_ERROR; 218 mResetStrategy = (notifyResets ? GL_LOSE_CONTEXT_ON_RESET_EXT : GL_NO_RESET_NOTIFICATION_EXT); 219 mRobustAccess = robustAccess; 220 221 mSupportsBGRATextures = false; 222 mSupportsDXT1Textures = false; 223 mSupportsDXT3Textures = false; 224 mSupportsDXT5Textures = false; 225 mSupportsEventQueries = false; 226 mSupportsOcclusionQueries = false; 227 mNumCompressedTextureFormats = 0; 228 } 229 230 Context::~Context() 231 { 232 if (mState.currentProgram != 0) 233 { 234 Program *programObject = mResourceManager->getProgram(mState.currentProgram); 235 if (programObject) 236 { 237 programObject->release(); 238 } 239 mState.currentProgram = 0; 240 } 241 mCurrentProgramBinary.set(NULL); 242 243 while (!mFramebufferMap.empty()) 244 { 245 deleteFramebuffer(mFramebufferMap.begin()->first); 246 } 247 248 while (!mFenceNVMap.empty()) 249 { 250 deleteFenceNV(mFenceNVMap.begin()->first); 251 } 252 253 while (!mQueryMap.empty()) 254 { 255 deleteQuery(mQueryMap.begin()->first); 256 } 257 258 while (!mVertexArrayMap.empty()) 259 { 260 deleteVertexArray(mVertexArrayMap.begin()->first); 261 } 262 263 mTransformFeedbackZero.set(NULL); 264 while (!mTransformFeedbackMap.empty()) 265 { 266 deleteTransformFeedback(mTransformFeedbackMap.begin()->first); 267 } 268 269 for (int type = 0; type < TEXTURE_TYPE_COUNT; type++) 270 { 271 for (int sampler = 0; sampler < IMPLEMENTATION_MAX_COMBINED_TEXTURE_IMAGE_UNITS; sampler++) 272 { 273 mState.samplerTexture[type][sampler].set(NULL); 274 } 275 } 276 277 for (int type = 0; type < TEXTURE_TYPE_COUNT; type++) 278 { 279 mIncompleteTextures[type].set(NULL); 280 } 281 282 const GLfloat defaultFloatValues[] = { 0.0f, 0.0f, 0.0f, 1.0f }; 283 for (int attribIndex = 0; attribIndex < MAX_VERTEX_ATTRIBS; attribIndex++) 284 { 285 mState.vertexAttribCurrentValues[attribIndex].setFloatValues(defaultFloatValues); 286 } 287 288 mState.arrayBuffer.set(NULL); 289 mState.renderbuffer.set(NULL); 290 291 mState.transformFeedback.set(NULL); 292 293 mTexture2DZero.set(NULL); 294 mTextureCubeMapZero.set(NULL); 295 mTexture3DZero.set(NULL); 296 mTexture2DArrayZero.set(NULL); 297 298 for (State::ActiveQueryMap::iterator i = mState.activeQueries.begin(); i != mState.activeQueries.end(); i++) 299 { 300 i->second.set(NULL); 301 } 302 303 mState.genericUniformBuffer.set(NULL); 304 for (int i = 0; i < IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS; i++) 305 { 306 mState.uniformBuffers[i].set(NULL); 307 } 308 309 mState.genericTransformFeedbackBuffer.set(NULL); 310 for (int i = 0; i < IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS; i++) 311 { 312 mState.transformFeedbackBuffers[i].set(NULL); 313 } 314 315 mState.copyReadBuffer.set(NULL); 316 mState.copyWriteBuffer.set(NULL); 317 318 mState.pack.pixelBuffer.set(NULL); 319 mState.unpack.pixelBuffer.set(NULL); 320 321 mResourceManager->release(); 322 } 323 324 void Context::makeCurrent(egl::Surface *surface) 325 { 326 if (!mHasBeenCurrent) 327 { 328 mMajorShaderModel = mRenderer->getMajorShaderModel(); 329 mMaximumPointSize = mRenderer->getMaxPointSize(); 330 mSupportsVertexTexture = mRenderer->getVertexTextureSupport(); 331 mSupportsNonPower2Texture = mRenderer->getNonPower2TextureSupport(); 332 mSupportsInstancing = mRenderer->getInstancingSupport(); 333 334 mMaxViewportDimension = mRenderer->getMaxViewportDimension(); 335 mMax2DTextureDimension = std::min(std::min(mRenderer->getMaxTextureWidth(), mRenderer->getMaxTextureHeight()), 336 (int)gl::IMPLEMENTATION_MAX_2D_TEXTURE_SIZE); 337 mMaxCubeTextureDimension = std::min(mMax2DTextureDimension, (int)gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE); 338 mMax3DTextureDimension = std::min(std::min(mMax2DTextureDimension, mRenderer->getMaxTextureDepth()), 339 (int)gl::IMPLEMENTATION_MAX_3D_TEXTURE_SIZE); 340 mMax2DArrayTextureLayers = mRenderer->getMaxTextureArrayLayers(); 341 mMaxRenderbufferDimension = mMax2DTextureDimension; 342 mMax2DTextureLevel = log2(mMax2DTextureDimension) + 1; 343 mMaxCubeTextureLevel = log2(mMaxCubeTextureDimension) + 1; 344 mMax3DTextureLevel = log2(mMax3DTextureDimension) + 1; 345 mMax2DArrayTextureLevel = log2(mMax2DTextureDimension) + 1; 346 mMaxTextureAnisotropy = mRenderer->getTextureMaxAnisotropy(); 347 TRACE("Max2DTextureDimension=%d, MaxCubeTextureDimension=%d, Max3DTextureDimension=%d, Max2DArrayTextureLayers = %d, " 348 "Max2DTextureLevel=%d, MaxCubeTextureLevel=%d, Max3DTextureLevel=%d, Max2DArrayTextureLevel=%d, " 349 "MaxRenderbufferDimension=%d, MaxTextureAnisotropy=%f", 350 mMax2DTextureDimension, mMaxCubeTextureDimension, mMax3DTextureDimension, mMax2DArrayTextureLayers, 351 mMax2DTextureLevel, mMaxCubeTextureLevel, mMax3DTextureLevel, mMax2DArrayTextureLevel, 352 mMaxRenderbufferDimension, mMaxTextureAnisotropy); 353 354 mSupportsEventQueries = mRenderer->getEventQuerySupport(); 355 mSupportsOcclusionQueries = mRenderer->getOcclusionQuerySupport(); 356 mSupportsBGRATextures = mRenderer->getBGRATextureSupport(); 357 mSupportsDXT1Textures = mRenderer->getDXT1TextureSupport(); 358 mSupportsDXT3Textures = mRenderer->getDXT3TextureSupport(); 359 mSupportsDXT5Textures = mRenderer->getDXT5TextureSupport(); 360 mSupportsFloat32Textures = mRenderer->getFloat32TextureSupport(); 361 mSupportsFloat32LinearFilter = mRenderer->getFloat32TextureFilteringSupport(); 362 mSupportsFloat32RenderableTextures = mRenderer->getFloat32TextureRenderingSupport(); 363 mSupportsFloat16Textures = mRenderer->getFloat16TextureSupport(); 364 mSupportsFloat16LinearFilter = mRenderer->getFloat16TextureFilteringSupport(); 365 mSupportsFloat16RenderableTextures = mRenderer->getFloat16TextureRenderingSupport(); 366 mSupportsLuminanceTextures = mRenderer->getLuminanceTextureSupport(); 367 mSupportsLuminanceAlphaTextures = mRenderer->getLuminanceAlphaTextureSupport(); 368 mSupportsRGTextures = mRenderer->getRGTextureSupport(); 369 mSupportsDepthTextures = mRenderer->getDepthTextureSupport(); 370 mSupportsTextureFilterAnisotropy = mRenderer->getTextureFilterAnisotropySupport(); 371 mSupports32bitIndices = mRenderer->get32BitIndexSupport(); 372 mSupportsPBOs = mRenderer->getPBOSupport(); 373 374 mNumCompressedTextureFormats = 0; 375 if (supportsDXT1Textures()) 376 { 377 mNumCompressedTextureFormats += 2; 378 } 379 if (supportsDXT3Textures()) 380 { 381 mNumCompressedTextureFormats += 1; 382 } 383 if (supportsDXT5Textures()) 384 { 385 mNumCompressedTextureFormats += 1; 386 } 387 388 initExtensionString(); 389 initRendererString(); 390 391 mState.viewport.x = 0; 392 mState.viewport.y = 0; 393 mState.viewport.width = surface->getWidth(); 394 mState.viewport.height = surface->getHeight(); 395 396 mState.scissor.x = 0; 397 mState.scissor.y = 0; 398 mState.scissor.width = surface->getWidth(); 399 mState.scissor.height = surface->getHeight(); 400 401 mHasBeenCurrent = true; 402 } 403 404 // Wrap the existing swapchain resources into GL objects and assign them to the '0' names 405 rx::SwapChain *swapchain = surface->getSwapChain(); 406 407 Colorbuffer *colorbufferZero = new Colorbuffer(mRenderer, swapchain); 408 DepthStencilbuffer *depthStencilbufferZero = new DepthStencilbuffer(mRenderer, swapchain); 409 Framebuffer *framebufferZero = new DefaultFramebuffer(mRenderer, colorbufferZero, depthStencilbufferZero); 410 411 setFramebufferZero(framebufferZero); 412 413 // Store the current client version in the renderer 414 mRenderer->setCurrentClientVersion(mClientVersion); 415 } 416 417 // NOTE: this function should not assume that this context is current! 418 void Context::markContextLost() 419 { 420 if (mResetStrategy == GL_LOSE_CONTEXT_ON_RESET_EXT) 421 mResetStatus = GL_UNKNOWN_CONTEXT_RESET_EXT; 422 mContextLost = true; 423 } 424 425 bool Context::isContextLost() 426 { 427 return mContextLost; 428 } 429 430 void Context::setCap(GLenum cap, bool enabled) 431 { 432 switch (cap) 433 { 434 case GL_CULL_FACE: setCullFace(enabled); break; 435 case GL_POLYGON_OFFSET_FILL: setPolygonOffsetFill(enabled); break; 436 case GL_SAMPLE_ALPHA_TO_COVERAGE: setSampleAlphaToCoverage(enabled); break; 437 case GL_SAMPLE_COVERAGE: setSampleCoverage(enabled); break; 438 case GL_SCISSOR_TEST: setScissorTest(enabled); break; 439 case GL_STENCIL_TEST: setStencilTest(enabled); break; 440 case GL_DEPTH_TEST: setDepthTest(enabled); break; 441 case GL_BLEND: setBlend(enabled); break; 442 case GL_DITHER: setDither(enabled); break; 443 case GL_PRIMITIVE_RESTART_FIXED_INDEX: UNIMPLEMENTED(); break; 444 case GL_RASTERIZER_DISCARD: setRasterizerDiscard(enabled); break; 445 default: UNREACHABLE(); 446 } 447 } 448 449 bool Context::getCap(GLenum cap) 450 { 451 switch (cap) 452 { 453 case GL_CULL_FACE: return isCullFaceEnabled(); 454 case GL_POLYGON_OFFSET_FILL: return isPolygonOffsetFillEnabled(); 455 case GL_SAMPLE_ALPHA_TO_COVERAGE: return isSampleAlphaToCoverageEnabled(); 456 case GL_SAMPLE_COVERAGE: return isSampleCoverageEnabled(); 457 case GL_SCISSOR_TEST: return isScissorTestEnabled(); 458 case GL_STENCIL_TEST: return isStencilTestEnabled(); 459 case GL_DEPTH_TEST: return isDepthTestEnabled(); 460 case GL_BLEND: return isBlendEnabled(); 461 case GL_DITHER: return isDitherEnabled(); 462 case GL_PRIMITIVE_RESTART_FIXED_INDEX: UNIMPLEMENTED(); return false; 463 case GL_RASTERIZER_DISCARD: return isRasterizerDiscardEnabled(); 464 default: UNREACHABLE(); return false; 465 } 466 } 467 468 void Context::setClearColor(float red, float green, float blue, float alpha) 469 { 470 mState.colorClearValue.red = red; 471 mState.colorClearValue.green = green; 472 mState.colorClearValue.blue = blue; 473 mState.colorClearValue.alpha = alpha; 474 } 475 476 void Context::setClearDepth(float depth) 477 { 478 mState.depthClearValue = depth; 479 } 480 481 void Context::setClearStencil(int stencil) 482 { 483 mState.stencilClearValue = stencil; 484 } 485 486 void Context::setRasterizerDiscard(bool enabled) 487 { 488 mState.rasterizer.rasterizerDiscard = enabled; 489 } 490 491 bool Context::isRasterizerDiscardEnabled() const 492 { 493 return mState.rasterizer.rasterizerDiscard; 494 } 495 496 void Context::setCullFace(bool enabled) 497 { 498 mState.rasterizer.cullFace = enabled; 499 } 500 501 bool Context::isCullFaceEnabled() const 502 { 503 return mState.rasterizer.cullFace; 504 } 505 506 void Context::setCullMode(GLenum mode) 507 { 508 mState.rasterizer.cullMode = mode; 509 } 510 511 void Context::setFrontFace(GLenum front) 512 { 513 mState.rasterizer.frontFace = front; 514 } 515 516 void Context::setDepthTest(bool enabled) 517 { 518 mState.depthStencil.depthTest = enabled; 519 } 520 521 bool Context::isDepthTestEnabled() const 522 { 523 return mState.depthStencil.depthTest; 524 } 525 526 void Context::setDepthFunc(GLenum depthFunc) 527 { 528 mState.depthStencil.depthFunc = depthFunc; 529 } 530 531 void Context::setDepthRange(float zNear, float zFar) 532 { 533 mState.zNear = zNear; 534 mState.zFar = zFar; 535 } 536 537 void Context::setBlend(bool enabled) 538 { 539 mState.blend.blend = enabled; 540 } 541 542 bool Context::isBlendEnabled() const 543 { 544 return mState.blend.blend; 545 } 546 547 void Context::setBlendFactors(GLenum sourceRGB, GLenum destRGB, GLenum sourceAlpha, GLenum destAlpha) 548 { 549 mState.blend.sourceBlendRGB = sourceRGB; 550 mState.blend.destBlendRGB = destRGB; 551 mState.blend.sourceBlendAlpha = sourceAlpha; 552 mState.blend.destBlendAlpha = destAlpha; 553 } 554 555 void Context::setBlendColor(float red, float green, float blue, float alpha) 556 { 557 mState.blendColor.red = red; 558 mState.blendColor.green = green; 559 mState.blendColor.blue = blue; 560 mState.blendColor.alpha = alpha; 561 } 562 563 void Context::setBlendEquation(GLenum rgbEquation, GLenum alphaEquation) 564 { 565 mState.blend.blendEquationRGB = rgbEquation; 566 mState.blend.blendEquationAlpha = alphaEquation; 567 } 568 569 void Context::setStencilTest(bool enabled) 570 { 571 mState.depthStencil.stencilTest = enabled; 572 } 573 574 bool Context::isStencilTestEnabled() const 575 { 576 return mState.depthStencil.stencilTest; 577 } 578 579 void Context::setStencilParams(GLenum stencilFunc, GLint stencilRef, GLuint stencilMask) 580 { 581 mState.depthStencil.stencilFunc = stencilFunc; 582 mState.stencilRef = (stencilRef > 0) ? stencilRef : 0; 583 mState.depthStencil.stencilMask = stencilMask; 584 } 585 586 void Context::setStencilBackParams(GLenum stencilBackFunc, GLint stencilBackRef, GLuint stencilBackMask) 587 { 588 mState.depthStencil.stencilBackFunc = stencilBackFunc; 589 mState.stencilBackRef = (stencilBackRef > 0) ? stencilBackRef : 0; 590 mState.depthStencil.stencilBackMask = stencilBackMask; 591 } 592 593 void Context::setStencilWritemask(GLuint stencilWritemask) 594 { 595 mState.depthStencil.stencilWritemask = stencilWritemask; 596 } 597 598 void Context::setStencilBackWritemask(GLuint stencilBackWritemask) 599 { 600 mState.depthStencil.stencilBackWritemask = stencilBackWritemask; 601 } 602 603 void Context::setStencilOperations(GLenum stencilFail, GLenum stencilPassDepthFail, GLenum stencilPassDepthPass) 604 { 605 mState.depthStencil.stencilFail = stencilFail; 606 mState.depthStencil.stencilPassDepthFail = stencilPassDepthFail; 607 mState.depthStencil.stencilPassDepthPass = stencilPassDepthPass; 608 } 609 610 void Context::setStencilBackOperations(GLenum stencilBackFail, GLenum stencilBackPassDepthFail, GLenum stencilBackPassDepthPass) 611 { 612 mState.depthStencil.stencilBackFail = stencilBackFail; 613 mState.depthStencil.stencilBackPassDepthFail = stencilBackPassDepthFail; 614 mState.depthStencil.stencilBackPassDepthPass = stencilBackPassDepthPass; 615 } 616 617 void Context::setPolygonOffsetFill(bool enabled) 618 { 619 mState.rasterizer.polygonOffsetFill = enabled; 620 } 621 622 bool Context::isPolygonOffsetFillEnabled() const 623 { 624 return mState.rasterizer.polygonOffsetFill; 625 } 626 627 void Context::setPolygonOffsetParams(GLfloat factor, GLfloat units) 628 { 629 // An application can pass NaN values here, so handle this gracefully 630 mState.rasterizer.polygonOffsetFactor = factor != factor ? 0.0f : factor; 631 mState.rasterizer.polygonOffsetUnits = units != units ? 0.0f : units; 632 } 633 634 void Context::setSampleAlphaToCoverage(bool enabled) 635 { 636 mState.blend.sampleAlphaToCoverage = enabled; 637 } 638 639 bool Context::isSampleAlphaToCoverageEnabled() const 640 { 641 return mState.blend.sampleAlphaToCoverage; 642 } 643 644 void Context::setSampleCoverage(bool enabled) 645 { 646 mState.sampleCoverage = enabled; 647 } 648 649 bool Context::isSampleCoverageEnabled() const 650 { 651 return mState.sampleCoverage; 652 } 653 654 void Context::setSampleCoverageParams(GLclampf value, bool invert) 655 { 656 mState.sampleCoverageValue = value; 657 mState.sampleCoverageInvert = invert; 658 } 659 660 void Context::setScissorTest(bool enabled) 661 { 662 mState.scissorTest = enabled; 663 } 664 665 bool Context::isScissorTestEnabled() const 666 { 667 return mState.scissorTest; 668 } 669 670 void Context::setDither(bool enabled) 671 { 672 mState.blend.dither = enabled; 673 } 674 675 bool Context::isDitherEnabled() const 676 { 677 return mState.blend.dither; 678 } 679 680 void Context::setLineWidth(GLfloat width) 681 { 682 mState.lineWidth = width; 683 } 684 685 void Context::setGenerateMipmapHint(GLenum hint) 686 { 687 mState.generateMipmapHint = hint; 688 } 689 690 void Context::setFragmentShaderDerivativeHint(GLenum hint) 691 { 692 mState.fragmentShaderDerivativeHint = hint; 693 // TODO: Propagate the hint to shader translator so we can write 694 // ddx, ddx_coarse, or ddx_fine depending on the hint. 695 // Ignore for now. It is valid for implementations to ignore hint. 696 } 697 698 void Context::setViewportParams(GLint x, GLint y, GLsizei width, GLsizei height) 699 { 700 mState.viewport.x = x; 701 mState.viewport.y = y; 702 mState.viewport.width = width; 703 mState.viewport.height = height; 704 } 705 706 void Context::setScissorParams(GLint x, GLint y, GLsizei width, GLsizei height) 707 { 708 mState.scissor.x = x; 709 mState.scissor.y = y; 710 mState.scissor.width = width; 711 mState.scissor.height = height; 712 } 713 714 void Context::getScissorParams(GLint *x, GLint *y, GLsizei *width, GLsizei *height) 715 { 716 *x = mState.scissor.x; 717 *y = mState.scissor.y; 718 *width = mState.scissor.width; 719 *height = mState.scissor.height; 720 } 721 722 void Context::setColorMask(bool red, bool green, bool blue, bool alpha) 723 { 724 mState.blend.colorMaskRed = red; 725 mState.blend.colorMaskGreen = green; 726 mState.blend.colorMaskBlue = blue; 727 mState.blend.colorMaskAlpha = alpha; 728 } 729 730 void Context::setDepthMask(bool mask) 731 { 732 mState.depthStencil.depthMask = mask; 733 } 734 735 void Context::setActiveSampler(unsigned int active) 736 { 737 mState.activeSampler = active; 738 } 739 740 GLuint Context::getReadFramebufferHandle() const 741 { 742 return mState.readFramebuffer; 743 } 744 745 GLuint Context::getDrawFramebufferHandle() const 746 { 747 return mState.drawFramebuffer; 748 } 749 750 GLuint Context::getRenderbufferHandle() const 751 { 752 return mState.renderbuffer.id(); 753 } 754 755 GLuint Context::getVertexArrayHandle() const 756 { 757 return mState.vertexArray; 758 } 759 760 GLuint Context::getSamplerHandle(GLuint textureUnit) const 761 { 762 ASSERT(textureUnit < ArraySize(mState.samplers)); 763 return mState.samplers[textureUnit]; 764 } 765 766 unsigned int Context::getActiveSampler() const 767 { 768 return mState.activeSampler; 769 } 770 771 GLuint Context::getArrayBufferHandle() const 772 { 773 return mState.arrayBuffer.id(); 774 } 775 776 bool Context::isQueryActive() const 777 { 778 for (State::ActiveQueryMap::const_iterator i = mState.activeQueries.begin(); 779 i != mState.activeQueries.end(); i++) 780 { 781 if (i->second.get() != NULL) 782 { 783 return true; 784 } 785 } 786 787 return false; 788 } 789 790 const Query *Context::getActiveQuery(GLenum target) const 791 { 792 // All query types should already exist in the activeQueries map 793 ASSERT(mState.activeQueries.find(target) != mState.activeQueries.end()); 794 795 return mState.activeQueries.at(target).get(); 796 } 797 798 GLuint Context::getActiveQueryId(GLenum target) const 799 { 800 const Query *query = getActiveQuery(target); 801 return (query ? query->id() : 0u); 802 } 803 804 void Context::setEnableVertexAttribArray(unsigned int attribNum, bool enabled) 805 { 806 getCurrentVertexArray()->enableAttribute(attribNum, enabled); 807 } 808 809 const VertexAttribute &Context::getVertexAttribState(unsigned int attribNum) const 810 { 811 return getCurrentVertexArray()->getVertexAttribute(attribNum); 812 } 813 814 const VertexAttribCurrentValueData &Context::getVertexAttribCurrentValue(unsigned int attribNum) const 815 { 816 ASSERT(attribNum < MAX_VERTEX_ATTRIBS); 817 return mState.vertexAttribCurrentValues[attribNum]; 818 } 819 820 void Context::setVertexAttribState(unsigned int attribNum, Buffer *boundBuffer, GLint size, GLenum type, bool normalized, 821 bool pureInteger, GLsizei stride, const void *pointer) 822 { 823 getCurrentVertexArray()->setAttributeState(attribNum, boundBuffer, size, type, normalized, pureInteger, stride, pointer); 824 } 825 826 const void *Context::getVertexAttribPointer(unsigned int attribNum) const 827 { 828 return getCurrentVertexArray()->getVertexAttribute(attribNum).mPointer; 829 } 830 831 void Context::setPackAlignment(GLint alignment) 832 { 833 mState.pack.alignment = alignment; 834 } 835 836 GLint Context::getPackAlignment() const 837 { 838 return mState.pack.alignment; 839 } 840 841 void Context::setUnpackAlignment(GLint alignment) 842 { 843 mState.unpack.alignment = alignment; 844 } 845 846 GLint Context::getUnpackAlignment() const 847 { 848 return mState.unpack.alignment; 849 } 850 851 void Context::setPackReverseRowOrder(bool reverseRowOrder) 852 { 853 mState.pack.reverseRowOrder = reverseRowOrder; 854 } 855 856 bool Context::getPackReverseRowOrder() const 857 { 858 return mState.pack.reverseRowOrder; 859 } 860 861 const PixelUnpackState &Context::getUnpackState() const 862 { 863 return mState.unpack; 864 } 865 866 const PixelPackState &Context::getPackState() const 867 { 868 return mState.pack; 869 } 870 871 GLuint Context::createBuffer() 872 { 873 return mResourceManager->createBuffer(); 874 } 875 876 GLuint Context::createProgram() 877 { 878 return mResourceManager->createProgram(); 879 } 880 881 GLuint Context::createShader(GLenum type) 882 { 883 return mResourceManager->createShader(type); 884 } 885 886 GLuint Context::createTexture() 887 { 888 return mResourceManager->createTexture(); 889 } 890 891 GLuint Context::createRenderbuffer() 892 { 893 return mResourceManager->createRenderbuffer(); 894 } 895 896 GLsync Context::createFenceSync(GLenum condition) 897 { 898 GLuint handle = mResourceManager->createFenceSync(); 899 900 gl::FenceSync *fenceSync = mResourceManager->getFenceSync(handle); 901 ASSERT(fenceSync); 902 903 fenceSync->set(condition); 904 905 return reinterpret_cast<GLsync>(handle); 906 } 907 908 GLuint Context::createVertexArray() 909 { 910 GLuint handle = mVertexArrayHandleAllocator.allocate(); 911 912 // Although the spec states VAO state is not initialized until the object is bound, 913 // we create it immediately. The resulting behaviour is transparent to the application, 914 // since it's not currently possible to access the state until the object is bound. 915 mVertexArrayMap[handle] = new VertexArray(mRenderer, handle); 916 917 return handle; 918 } 919 920 GLuint Context::createSampler() 921 { 922 return mResourceManager->createSampler(); 923 } 924 925 GLuint Context::createTransformFeedback() 926 { 927 GLuint handle = mTransformFeedbackAllocator.allocate(); 928 TransformFeedback *transformFeedback = new TransformFeedback(handle); 929 transformFeedback->addRef(); 930 mTransformFeedbackMap[handle] = transformFeedback; 931 return handle; 932 } 933 934 // Returns an unused framebuffer name 935 GLuint Context::createFramebuffer() 936 { 937 GLuint handle = mFramebufferHandleAllocator.allocate(); 938 939 mFramebufferMap[handle] = NULL; 940 941 return handle; 942 } 943 944 GLuint Context::createFenceNV() 945 { 946 GLuint handle = mFenceNVHandleAllocator.allocate(); 947 948 mFenceNVMap[handle] = new FenceNV(mRenderer); 949 950 return handle; 951 } 952 953 // Returns an unused query name 954 GLuint Context::createQuery() 955 { 956 GLuint handle = mQueryHandleAllocator.allocate(); 957 958 mQueryMap[handle] = NULL; 959 960 return handle; 961 } 962 963 void Context::deleteBuffer(GLuint buffer) 964 { 965 if (mResourceManager->getBuffer(buffer)) 966 { 967 detachBuffer(buffer); 968 } 969 970 mResourceManager->deleteBuffer(buffer); 971 } 972 973 void Context::deleteShader(GLuint shader) 974 { 975 mResourceManager->deleteShader(shader); 976 } 977 978 void Context::deleteProgram(GLuint program) 979 { 980 mResourceManager->deleteProgram(program); 981 } 982 983 void Context::deleteTexture(GLuint texture) 984 { 985 if (mResourceManager->getTexture(texture)) 986 { 987 detachTexture(texture); 988 } 989 990 mResourceManager->deleteTexture(texture); 991 } 992 993 void Context::deleteRenderbuffer(GLuint renderbuffer) 994 { 995 if (mResourceManager->getRenderbuffer(renderbuffer)) 996 { 997 detachRenderbuffer(renderbuffer); 998 } 999 1000 mResourceManager->deleteRenderbuffer(renderbuffer); 1001 } 1002 1003 void Context::deleteFenceSync(GLsync fenceSync) 1004 { 1005 // The spec specifies the underlying Fence object is not deleted until all current 1006 // wait commands finish. However, since the name becomes invalid, we cannot query the fence, 1007 // and since our API is currently designed for being called from a single thread, we can delete 1008 // the fence immediately. 1009 mResourceManager->deleteFenceSync(reinterpret_cast<GLuint>(fenceSync)); 1010 } 1011 1012 void Context::deleteVertexArray(GLuint vertexArray) 1013 { 1014 auto vertexArrayObject = mVertexArrayMap.find(vertexArray); 1015 1016 if (vertexArrayObject != mVertexArrayMap.end()) 1017 { 1018 detachVertexArray(vertexArray); 1019 1020 mVertexArrayHandleAllocator.release(vertexArrayObject->first); 1021 delete vertexArrayObject->second; 1022 mVertexArrayMap.erase(vertexArrayObject); 1023 } 1024 } 1025 1026 void Context::deleteSampler(GLuint sampler) 1027 { 1028 if (mResourceManager->getSampler(sampler)) 1029 { 1030 detachSampler(sampler); 1031 } 1032 1033 mResourceManager->deleteSampler(sampler); 1034 } 1035 1036 void Context::deleteTransformFeedback(GLuint transformFeedback) 1037 { 1038 TransformFeedbackMap::const_iterator iter = mTransformFeedbackMap.find(transformFeedback); 1039 if (iter != mTransformFeedbackMap.end()) 1040 { 1041 detachTransformFeedback(transformFeedback); 1042 mTransformFeedbackAllocator.release(transformFeedback); 1043 iter->second->release(); 1044 mTransformFeedbackMap.erase(iter); 1045 } 1046 } 1047 1048 void Context::deleteFramebuffer(GLuint framebuffer) 1049 { 1050 FramebufferMap::iterator framebufferObject = mFramebufferMap.find(framebuffer); 1051 1052 if (framebufferObject != mFramebufferMap.end()) 1053 { 1054 detachFramebuffer(framebuffer); 1055 1056 mFramebufferHandleAllocator.release(framebufferObject->first); 1057 delete framebufferObject->second; 1058 mFramebufferMap.erase(framebufferObject); 1059 } 1060 } 1061 1062 void Context::deleteFenceNV(GLuint fence) 1063 { 1064 FenceNVMap::iterator fenceObject = mFenceNVMap.find(fence); 1065 1066 if (fenceObject != mFenceNVMap.end()) 1067 { 1068 mFenceNVHandleAllocator.release(fenceObject->first); 1069 delete fenceObject->second; 1070 mFenceNVMap.erase(fenceObject); 1071 } 1072 } 1073 1074 void Context::deleteQuery(GLuint query) 1075 { 1076 QueryMap::iterator queryObject = mQueryMap.find(query); 1077 if (queryObject != mQueryMap.end()) 1078 { 1079 mQueryHandleAllocator.release(queryObject->first); 1080 if (queryObject->second) 1081 { 1082 queryObject->second->release(); 1083 } 1084 mQueryMap.erase(queryObject); 1085 } 1086 } 1087 1088 Buffer *Context::getBuffer(GLuint handle) 1089 { 1090 return mResourceManager->getBuffer(handle); 1091 } 1092 1093 Shader *Context::getShader(GLuint handle) const 1094 { 1095 return mResourceManager->getShader(handle); 1096 } 1097 1098 Program *Context::getProgram(GLuint handle) const 1099 { 1100 return mResourceManager->getProgram(handle); 1101 } 1102 1103 Texture *Context::getTexture(GLuint handle) 1104 { 1105 return mResourceManager->getTexture(handle); 1106 } 1107 1108 FramebufferAttachment *Context::getRenderbuffer(GLuint handle) 1109 { 1110 return mResourceManager->getRenderbuffer(handle); 1111 } 1112 1113 FenceSync *Context::getFenceSync(GLsync handle) const 1114 { 1115 return mResourceManager->getFenceSync(reinterpret_cast<GLuint>(handle)); 1116 } 1117 1118 VertexArray *Context::getVertexArray(GLuint handle) const 1119 { 1120 auto vertexArray = mVertexArrayMap.find(handle); 1121 1122 if (vertexArray == mVertexArrayMap.end()) 1123 { 1124 return NULL; 1125 } 1126 else 1127 { 1128 return vertexArray->second; 1129 } 1130 } 1131 1132 Sampler *Context::getSampler(GLuint handle) const 1133 { 1134 return mResourceManager->getSampler(handle); 1135 } 1136 1137 TransformFeedback *Context::getTransformFeedback(GLuint handle) const 1138 { 1139 if (handle == 0) 1140 { 1141 return mTransformFeedbackZero.get(); 1142 } 1143 else 1144 { 1145 TransformFeedbackMap::const_iterator iter = mTransformFeedbackMap.find(handle); 1146 return (iter != mTransformFeedbackMap.end()) ? iter->second : NULL; 1147 } 1148 } 1149 1150 Framebuffer *Context::getReadFramebuffer() 1151 { 1152 return getFramebuffer(mState.readFramebuffer); 1153 } 1154 1155 Framebuffer *Context::getDrawFramebuffer() 1156 { 1157 return mBoundDrawFramebuffer; 1158 } 1159 1160 VertexArray *Context::getCurrentVertexArray() const 1161 { 1162 VertexArray *vao = getVertexArray(mState.vertexArray); 1163 ASSERT(vao != NULL); 1164 return vao; 1165 } 1166 1167 TransformFeedback *Context::getCurrentTransformFeedback() const 1168 { 1169 return mState.transformFeedback.get(); 1170 } 1171 1172 bool Context::isSampler(GLuint samplerName) const 1173 { 1174 return mResourceManager->isSampler(samplerName); 1175 } 1176 1177 void Context::bindArrayBuffer(unsigned int buffer) 1178 { 1179 mResourceManager->checkBufferAllocation(buffer); 1180 1181 mState.arrayBuffer.set(getBuffer(buffer)); 1182 } 1183 1184 void Context::bindElementArrayBuffer(unsigned int buffer) 1185 { 1186 mResourceManager->checkBufferAllocation(buffer); 1187 1188 getCurrentVertexArray()->setElementArrayBuffer(getBuffer(buffer)); 1189 } 1190 1191 void Context::bindTexture2D(GLuint texture) 1192 { 1193 mResourceManager->checkTextureAllocation(texture, TEXTURE_2D); 1194 1195 mState.samplerTexture[TEXTURE_2D][mState.activeSampler].set(getTexture(texture)); 1196 } 1197 1198 void Context::bindTextureCubeMap(GLuint texture) 1199 { 1200 mResourceManager->checkTextureAllocation(texture, TEXTURE_CUBE); 1201 1202 mState.samplerTexture[TEXTURE_CUBE][mState.activeSampler].set(getTexture(texture)); 1203 } 1204 1205 void Context::bindTexture3D(GLuint texture) 1206 { 1207 mResourceManager->checkTextureAllocation(texture, TEXTURE_3D); 1208 1209 mState.samplerTexture[TEXTURE_3D][mState.activeSampler].set(getTexture(texture)); 1210 } 1211 1212 void Context::bindTexture2DArray(GLuint texture) 1213 { 1214 mResourceManager->checkTextureAllocation(texture, TEXTURE_2D_ARRAY); 1215 1216 mState.samplerTexture[TEXTURE_2D_ARRAY][mState.activeSampler].set(getTexture(texture)); 1217 } 1218 1219 void Context::bindReadFramebuffer(GLuint framebuffer) 1220 { 1221 if (!getFramebuffer(framebuffer)) 1222 { 1223 mFramebufferMap[framebuffer] = new Framebuffer(mRenderer); 1224 } 1225 1226 mState.readFramebuffer = framebuffer; 1227 } 1228 1229 void Context::bindDrawFramebuffer(GLuint framebuffer) 1230 { 1231 if (!getFramebuffer(framebuffer)) 1232 { 1233 mFramebufferMap[framebuffer] = new Framebuffer(mRenderer); 1234 } 1235 1236 mState.drawFramebuffer = framebuffer; 1237 1238 mBoundDrawFramebuffer = getFramebuffer(framebuffer); 1239 } 1240 1241 void Context::bindRenderbuffer(GLuint renderbuffer) 1242 { 1243 mResourceManager->checkRenderbufferAllocation(renderbuffer); 1244 1245 mState.renderbuffer.set(getRenderbuffer(renderbuffer)); 1246 } 1247 1248 void Context::bindVertexArray(GLuint vertexArray) 1249 { 1250 if (!getVertexArray(vertexArray)) 1251 { 1252 mVertexArrayMap[vertexArray] = new VertexArray(mRenderer, vertexArray); 1253 } 1254 1255 mState.vertexArray = vertexArray; 1256 } 1257 1258 void Context::bindSampler(GLuint textureUnit, GLuint sampler) 1259 { 1260 ASSERT(textureUnit < ArraySize(mState.samplers)); 1261 mResourceManager->checkSamplerAllocation(sampler); 1262 1263 mState.samplers[textureUnit] = sampler; 1264 } 1265 1266 void Context::bindGenericUniformBuffer(GLuint buffer) 1267 { 1268 mResourceManager->checkBufferAllocation(buffer); 1269 1270 mState.genericUniformBuffer.set(getBuffer(buffer)); 1271 } 1272 1273 void Context::bindIndexedUniformBuffer(GLuint buffer, GLuint index, GLintptr offset, GLsizeiptr size) 1274 { 1275 mResourceManager->checkBufferAllocation(buffer); 1276 1277 mState.uniformBuffers[index].set(getBuffer(buffer), offset, size); 1278 } 1279 1280 void Context::bindGenericTransformFeedbackBuffer(GLuint buffer) 1281 { 1282 mResourceManager->checkBufferAllocation(buffer); 1283 1284 mState.genericTransformFeedbackBuffer.set(getBuffer(buffer)); 1285 } 1286 1287 void Context::bindIndexedTransformFeedbackBuffer(GLuint buffer, GLuint index, GLintptr offset, GLsizeiptr size) 1288 { 1289 mResourceManager->checkBufferAllocation(buffer); 1290 1291 mState.transformFeedbackBuffers[index].set(getBuffer(buffer), offset, size); 1292 } 1293 1294 void Context::bindCopyReadBuffer(GLuint buffer) 1295 { 1296 mResourceManager->checkBufferAllocation(buffer); 1297 1298 mState.copyReadBuffer.set(getBuffer(buffer)); 1299 } 1300 1301 void Context::bindCopyWriteBuffer(GLuint buffer) 1302 { 1303 mResourceManager->checkBufferAllocation(buffer); 1304 1305 mState.copyWriteBuffer.set(getBuffer(buffer)); 1306 } 1307 1308 void Context::bindPixelPackBuffer(GLuint buffer) 1309 { 1310 mResourceManager->checkBufferAllocation(buffer); 1311 1312 mState.pack.pixelBuffer.set(getBuffer(buffer)); 1313 } 1314 1315 void Context::bindPixelUnpackBuffer(GLuint buffer) 1316 { 1317 mResourceManager->checkBufferAllocation(buffer); 1318 1319 mState.unpack.pixelBuffer.set(getBuffer(buffer)); 1320 } 1321 1322 void Context::useProgram(GLuint program) 1323 { 1324 GLuint priorProgram = mState.currentProgram; 1325 mState.currentProgram = program; // Must switch before trying to delete, otherwise it only gets flagged. 1326 1327 if (priorProgram != program) 1328 { 1329 Program *newProgram = mResourceManager->getProgram(program); 1330 Program *oldProgram = mResourceManager->getProgram(priorProgram); 1331 mCurrentProgramBinary.set(NULL); 1332 1333 if (newProgram) 1334 { 1335 newProgram->addRef(); 1336 mCurrentProgramBinary.set(newProgram->getProgramBinary()); 1337 } 1338 1339 if (oldProgram) 1340 { 1341 oldProgram->release(); 1342 } 1343 } 1344 } 1345 1346 void Context::linkProgram(GLuint program) 1347 { 1348 Program *programObject = mResourceManager->getProgram(program); 1349 1350 bool linked = programObject->link(); 1351 1352 // if the current program was relinked successfully we 1353 // need to install the new executables 1354 if (linked && program == mState.currentProgram) 1355 { 1356 mCurrentProgramBinary.set(programObject->getProgramBinary()); 1357 } 1358 } 1359 1360 void Context::setProgramBinary(GLuint program, const void *binary, GLint length) 1361 { 1362 Program *programObject = mResourceManager->getProgram(program); 1363 1364 bool loaded = programObject->setProgramBinary(binary, length); 1365 1366 // if the current program was reloaded successfully we 1367 // need to install the new executables 1368 if (loaded && program == mState.currentProgram) 1369 { 1370 mCurrentProgramBinary.set(programObject->getProgramBinary()); 1371 } 1372 1373 } 1374 1375 void Context::bindTransformFeedback(GLuint transformFeedback) 1376 { 1377 TransformFeedback *transformFeedbackObject = getTransformFeedback(transformFeedback); 1378 mState.transformFeedback.set(transformFeedbackObject); 1379 } 1380 1381 void Context::beginQuery(GLenum target, GLuint query) 1382 { 1383 Query *queryObject = getQuery(query, true, target); 1384 ASSERT(queryObject); 1385 1386 // set query as active for specified target 1387 mState.activeQueries[target].set(queryObject); 1388 1389 // begin query 1390 queryObject->begin(); 1391 } 1392 1393 void Context::endQuery(GLenum target) 1394 { 1395 Query *queryObject = mState.activeQueries[target].get(); 1396 ASSERT(queryObject); 1397 1398 queryObject->end(); 1399 1400 mState.activeQueries[target].set(NULL); 1401 } 1402 1403 void Context::setFramebufferZero(Framebuffer *buffer) 1404 { 1405 delete mFramebufferMap[0]; 1406 mFramebufferMap[0] = buffer; 1407 if (mState.drawFramebuffer == 0) 1408 { 1409 mBoundDrawFramebuffer = buffer; 1410 } 1411 } 1412 1413 void Context::setRenderbufferStorage(GLsizei width, GLsizei height, GLenum internalformat, GLsizei samples) 1414 { 1415 const bool color = gl::IsColorRenderingSupported(internalformat, this); 1416 const bool depth = gl::IsDepthRenderingSupported(internalformat, this); 1417 const bool stencil = gl::IsStencilRenderingSupported(internalformat, this); 1418 1419 RenderbufferStorage *renderbuffer = NULL; 1420 1421 if (color) 1422 { 1423 renderbuffer = new gl::Colorbuffer(mRenderer,width, height, internalformat, samples); 1424 } 1425 else if (depth && stencil) 1426 { 1427 renderbuffer = new gl::DepthStencilbuffer(mRenderer, width, height, samples); 1428 } 1429 else if (depth) 1430 { 1431 renderbuffer = new gl::Depthbuffer(mRenderer, width, height, samples); 1432 } 1433 else if (stencil) 1434 { 1435 renderbuffer = new gl::Stencilbuffer(mRenderer, width, height, samples); 1436 } 1437 else 1438 { 1439 UNREACHABLE(); 1440 return; 1441 } 1442 1443 FramebufferAttachment *renderbufferObject = mState.renderbuffer.get(); 1444 renderbufferObject->setStorage(renderbuffer); 1445 } 1446 1447 Framebuffer *Context::getFramebuffer(unsigned int handle) const 1448 { 1449 FramebufferMap::const_iterator framebuffer = mFramebufferMap.find(handle); 1450 1451 if (framebuffer == mFramebufferMap.end()) 1452 { 1453 return NULL; 1454 } 1455 else 1456 { 1457 return framebuffer->second; 1458 } 1459 } 1460 1461 FenceNV *Context::getFenceNV(unsigned int handle) 1462 { 1463 FenceNVMap::iterator fence = mFenceNVMap.find(handle); 1464 1465 if (fence == mFenceNVMap.end()) 1466 { 1467 return NULL; 1468 } 1469 else 1470 { 1471 return fence->second; 1472 } 1473 } 1474 1475 Query *Context::getQuery(unsigned int handle, bool create, GLenum type) 1476 { 1477 QueryMap::iterator query = mQueryMap.find(handle); 1478 1479 if (query == mQueryMap.end()) 1480 { 1481 return NULL; 1482 } 1483 else 1484 { 1485 if (!query->second && create) 1486 { 1487 query->second = new Query(mRenderer, type, handle); 1488 query->second->addRef(); 1489 } 1490 return query->second; 1491 } 1492 } 1493 1494 Buffer *Context::getTargetBuffer(GLenum target) const 1495 { 1496 switch (target) 1497 { 1498 case GL_ARRAY_BUFFER: return mState.arrayBuffer.get(); 1499 case GL_COPY_READ_BUFFER: return mState.copyReadBuffer.get(); 1500 case GL_COPY_WRITE_BUFFER: return mState.copyWriteBuffer.get(); 1501 case GL_ELEMENT_ARRAY_BUFFER: return getCurrentVertexArray()->getElementArrayBuffer(); 1502 case GL_PIXEL_PACK_BUFFER: return mState.pack.pixelBuffer.get(); 1503 case GL_PIXEL_UNPACK_BUFFER: return mState.unpack.pixelBuffer.get(); 1504 case GL_TRANSFORM_FEEDBACK_BUFFER: return mState.genericTransformFeedbackBuffer.get(); 1505 case GL_UNIFORM_BUFFER: return mState.genericUniformBuffer.get(); 1506 default: UNREACHABLE(); return NULL; 1507 } 1508 } 1509 1510 Buffer *Context::getArrayBuffer() 1511 { 1512 return mState.arrayBuffer.get(); 1513 } 1514 1515 Buffer *Context::getElementArrayBuffer() const 1516 { 1517 return getCurrentVertexArray()->getElementArrayBuffer(); 1518 } 1519 1520 ProgramBinary *Context::getCurrentProgramBinary() 1521 { 1522 return mCurrentProgramBinary.get(); 1523 } 1524 1525 Texture *Context::getTargetTexture(GLenum target) const 1526 { 1527 if (!ValidTextureTarget(this, target)) 1528 { 1529 return NULL; 1530 } 1531 1532 switch (target) 1533 { 1534 case GL_TEXTURE_2D: return getTexture2D(); 1535 case GL_TEXTURE_CUBE_MAP: return getTextureCubeMap(); 1536 case GL_TEXTURE_3D: return getTexture3D(); 1537 case GL_TEXTURE_2D_ARRAY: return getTexture2DArray(); 1538 default: return NULL; 1539 } 1540 } 1541 1542 GLuint Context::getTargetFramebufferHandle(GLenum target) const 1543 { 1544 if (!ValidFramebufferTarget(target)) 1545 { 1546 return GL_INVALID_INDEX; 1547 } 1548 1549 if (target == GL_READ_FRAMEBUFFER_ANGLE) 1550 { 1551 return mState.readFramebuffer; 1552 } 1553 else 1554 { 1555 return mState.drawFramebuffer; 1556 } 1557 } 1558 1559 Framebuffer *Context::getTargetFramebuffer(GLenum target) const 1560 { 1561 GLuint framebufferHandle = getTargetFramebufferHandle(target); 1562 return (framebufferHandle == GL_INVALID_INDEX ? NULL : getFramebuffer(framebufferHandle)); 1563 } 1564 1565 Texture2D *Context::getTexture2D() const 1566 { 1567 return static_cast<Texture2D*>(getSamplerTexture(mState.activeSampler, TEXTURE_2D)); 1568 } 1569 1570 TextureCubeMap *Context::getTextureCubeMap() const 1571 { 1572 return static_cast<TextureCubeMap*>(getSamplerTexture(mState.activeSampler, TEXTURE_CUBE)); 1573 } 1574 1575 Texture3D *Context::getTexture3D() const 1576 { 1577 return static_cast<Texture3D*>(getSamplerTexture(mState.activeSampler, TEXTURE_3D)); 1578 } 1579 1580 Texture2DArray *Context::getTexture2DArray() const 1581 { 1582 return static_cast<Texture2DArray*>(getSamplerTexture(mState.activeSampler, TEXTURE_2D_ARRAY)); 1583 } 1584 1585 Buffer *Context::getGenericUniformBuffer() 1586 { 1587 return mState.genericUniformBuffer.get(); 1588 } 1589 1590 Buffer *Context::getGenericTransformFeedbackBuffer() 1591 { 1592 return mState.genericTransformFeedbackBuffer.get(); 1593 } 1594 1595 Buffer *Context::getCopyReadBuffer() 1596 { 1597 return mState.copyReadBuffer.get(); 1598 } 1599 1600 Buffer *Context::getCopyWriteBuffer() 1601 { 1602 return mState.copyWriteBuffer.get(); 1603 } 1604 1605 Buffer *Context::getPixelPackBuffer() 1606 { 1607 return mState.pack.pixelBuffer.get(); 1608 } 1609 1610 Buffer *Context::getPixelUnpackBuffer() 1611 { 1612 return mState.unpack.pixelBuffer.get(); 1613 } 1614 1615 Texture *Context::getSamplerTexture(unsigned int sampler, TextureType type) const 1616 { 1617 GLuint texid = mState.samplerTexture[type][sampler].id(); 1618 1619 if (texid == 0) // Special case: 0 refers to different initial textures based on the target 1620 { 1621 switch (type) 1622 { 1623 default: UNREACHABLE(); 1624 case TEXTURE_2D: return mTexture2DZero.get(); 1625 case TEXTURE_CUBE: return mTextureCubeMapZero.get(); 1626 case TEXTURE_3D: return mTexture3DZero.get(); 1627 case TEXTURE_2D_ARRAY: return mTexture2DArrayZero.get(); 1628 } 1629 } 1630 1631 return mState.samplerTexture[type][sampler].get(); 1632 } 1633 1634 void Context::getBooleanv(GLenum pname, GLboolean *params) 1635 { 1636 switch (pname) 1637 { 1638 case GL_SHADER_COMPILER: *params = GL_TRUE; break; 1639 case GL_SAMPLE_COVERAGE_INVERT: *params = mState.sampleCoverageInvert; break; 1640 case GL_DEPTH_WRITEMASK: *params = mState.depthStencil.depthMask; break; 1641 case GL_COLOR_WRITEMASK: 1642 params[0] = mState.blend.colorMaskRed; 1643 params[1] = mState.blend.colorMaskGreen; 1644 params[2] = mState.blend.colorMaskBlue; 1645 params[3] = mState.blend.colorMaskAlpha; 1646 break; 1647 case GL_CULL_FACE: *params = mState.rasterizer.cullFace; break; 1648 case GL_POLYGON_OFFSET_FILL: *params = mState.rasterizer.polygonOffsetFill; break; 1649 case GL_SAMPLE_ALPHA_TO_COVERAGE: *params = mState.blend.sampleAlphaToCoverage; break; 1650 case GL_SAMPLE_COVERAGE: *params = mState.sampleCoverage; break; 1651 case GL_SCISSOR_TEST: *params = mState.scissorTest; break; 1652 case GL_STENCIL_TEST: *params = mState.depthStencil.stencilTest; break; 1653 case GL_DEPTH_TEST: *params = mState.depthStencil.depthTest; break; 1654 case GL_BLEND: *params = mState.blend.blend; break; 1655 case GL_DITHER: *params = mState.blend.dither; break; 1656 case GL_CONTEXT_ROBUST_ACCESS_EXT: *params = mRobustAccess ? GL_TRUE : GL_FALSE; break; 1657 case GL_TRANSFORM_FEEDBACK_ACTIVE: *params = getCurrentTransformFeedback()->isStarted(); break; 1658 case GL_TRANSFORM_FEEDBACK_PAUSED: *params = getCurrentTransformFeedback()->isPaused(); break; 1659 default: 1660 UNREACHABLE(); 1661 break; 1662 } 1663 } 1664 1665 void Context::getFloatv(GLenum pname, GLfloat *params) 1666 { 1667 // Please note: DEPTH_CLEAR_VALUE is included in our internal getFloatv implementation 1668 // because it is stored as a float, despite the fact that the GL ES 2.0 spec names 1669 // GetIntegerv as its native query function. As it would require conversion in any 1670 // case, this should make no difference to the calling application. 1671 switch (pname) 1672 { 1673 case GL_LINE_WIDTH: *params = mState.lineWidth; break; 1674 case GL_SAMPLE_COVERAGE_VALUE: *params = mState.sampleCoverageValue; break; 1675 case GL_DEPTH_CLEAR_VALUE: *params = mState.depthClearValue; break; 1676 case GL_POLYGON_OFFSET_FACTOR: *params = mState.rasterizer.polygonOffsetFactor; break; 1677 case GL_POLYGON_OFFSET_UNITS: *params = mState.rasterizer.polygonOffsetUnits; break; 1678 case GL_ALIASED_LINE_WIDTH_RANGE: 1679 params[0] = gl::ALIASED_LINE_WIDTH_RANGE_MIN; 1680 params[1] = gl::ALIASED_LINE_WIDTH_RANGE_MAX; 1681 break; 1682 case GL_ALIASED_POINT_SIZE_RANGE: 1683 params[0] = gl::ALIASED_POINT_SIZE_RANGE_MIN; 1684 params[1] = getMaximumPointSize(); 1685 break; 1686 case GL_DEPTH_RANGE: 1687 params[0] = mState.zNear; 1688 params[1] = mState.zFar; 1689 break; 1690 case GL_COLOR_CLEAR_VALUE: 1691 params[0] = mState.colorClearValue.red; 1692 params[1] = mState.colorClearValue.green; 1693 params[2] = mState.colorClearValue.blue; 1694 params[3] = mState.colorClearValue.alpha; 1695 break; 1696 case GL_BLEND_COLOR: 1697 params[0] = mState.blendColor.red; 1698 params[1] = mState.blendColor.green; 1699 params[2] = mState.blendColor.blue; 1700 params[3] = mState.blendColor.alpha; 1701 break; 1702 case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: 1703 ASSERT(supportsTextureFilterAnisotropy()); 1704 *params = mMaxTextureAnisotropy; 1705 break; 1706 default: 1707 UNREACHABLE(); 1708 break; 1709 } 1710 } 1711 1712 void Context::getIntegerv(GLenum pname, GLint *params) 1713 { 1714 if (pname >= GL_DRAW_BUFFER0_EXT && pname <= GL_DRAW_BUFFER15_EXT) 1715 { 1716 unsigned int colorAttachment = (pname - GL_DRAW_BUFFER0_EXT); 1717 ASSERT(colorAttachment < mRenderer->getMaxRenderTargets()); 1718 Framebuffer *framebuffer = getDrawFramebuffer(); 1719 *params = framebuffer->getDrawBufferState(colorAttachment); 1720 return; 1721 } 1722 1723 // Please note: DEPTH_CLEAR_VALUE is not included in our internal getIntegerv implementation 1724 // because it is stored as a float, despite the fact that the GL ES 2.0 spec names 1725 // GetIntegerv as its native query function. As it would require conversion in any 1726 // case, this should make no difference to the calling application. You may find it in 1727 // Context::getFloatv. 1728 switch (pname) 1729 { 1730 case GL_MAX_VERTEX_ATTRIBS: *params = gl::MAX_VERTEX_ATTRIBS; break; 1731 case GL_MAX_VERTEX_UNIFORM_VECTORS: *params = mRenderer->getMaxVertexUniformVectors(); break; 1732 case GL_MAX_VERTEX_UNIFORM_COMPONENTS: *params = mRenderer->getMaxVertexUniformVectors() * 4; break; 1733 case GL_MAX_VARYING_VECTORS: *params = mRenderer->getMaxVaryingVectors(); break; 1734 case GL_MAX_VARYING_COMPONENTS: *params = mRenderer->getMaxVaryingVectors() * 4; break; 1735 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: *params = mRenderer->getMaxCombinedTextureImageUnits(); break; 1736 case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS: *params = mRenderer->getMaxVertexTextureImageUnits(); break; 1737 case GL_MAX_TEXTURE_IMAGE_UNITS: *params = gl::MAX_TEXTURE_IMAGE_UNITS; break; 1738 case GL_MAX_FRAGMENT_UNIFORM_VECTORS: *params = mRenderer->getMaxFragmentUniformVectors(); break; 1739 case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS: *params = mRenderer->getMaxFragmentUniformVectors() * 4; break; 1740 case GL_MAX_RENDERBUFFER_SIZE: *params = getMaximumRenderbufferDimension(); break; 1741 case GL_MAX_COLOR_ATTACHMENTS_EXT: *params = mRenderer->getMaxRenderTargets(); break; 1742 case GL_MAX_DRAW_BUFFERS_EXT: *params = mRenderer->getMaxRenderTargets(); break; 1743 case GL_NUM_SHADER_BINARY_FORMATS: *params = 0; break; 1744 case GL_SHADER_BINARY_FORMATS: /* no shader binary formats are supported */ break; 1745 case GL_ARRAY_BUFFER_BINDING: *params = mState.arrayBuffer.id(); break; 1746 case GL_ELEMENT_ARRAY_BUFFER_BINDING: *params = getCurrentVertexArray()->getElementArrayBufferId(); break; 1747 //case GL_FRAMEBUFFER_BINDING: // now equivalent to GL_DRAW_FRAMEBUFFER_BINDING_ANGLE 1748 case GL_DRAW_FRAMEBUFFER_BINDING_ANGLE: *params = mState.drawFramebuffer; break; 1749 case GL_READ_FRAMEBUFFER_BINDING_ANGLE: *params = mState.readFramebuffer; break; 1750 case GL_RENDERBUFFER_BINDING: *params = mState.renderbuffer.id(); break; 1751 case GL_VERTEX_ARRAY_BINDING: *params = mState.vertexArray; break; 1752 case GL_CURRENT_PROGRAM: *params = mState.currentProgram; break; 1753 case GL_PACK_ALIGNMENT: *params = mState.pack.alignment; break; 1754 case GL_PACK_REVERSE_ROW_ORDER_ANGLE: *params = mState.pack.reverseRowOrder; break; 1755 case GL_UNPACK_ALIGNMENT: *params = mState.unpack.alignment; break; 1756 case GL_GENERATE_MIPMAP_HINT: *params = mState.generateMipmapHint; break; 1757 case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES: *params = mState.fragmentShaderDerivativeHint; break; 1758 case GL_ACTIVE_TEXTURE: *params = (mState.activeSampler + GL_TEXTURE0); break; 1759 case GL_STENCIL_FUNC: *params = mState.depthStencil.stencilFunc; break; 1760 case GL_STENCIL_REF: *params = mState.stencilRef; break; 1761 case GL_STENCIL_VALUE_MASK: *params = clampToInt(mState.depthStencil.stencilMask); break; 1762 case GL_STENCIL_BACK_FUNC: *params = mState.depthStencil.stencilBackFunc; break; 1763 case GL_STENCIL_BACK_REF: *params = mState.stencilBackRef; break; 1764 case GL_STENCIL_BACK_VALUE_MASK: *params = clampToInt(mState.depthStencil.stencilBackMask); break; 1765 case GL_STENCIL_FAIL: *params = mState.depthStencil.stencilFail; break; 1766 case GL_STENCIL_PASS_DEPTH_FAIL: *params = mState.depthStencil.stencilPassDepthFail; break; 1767 case GL_STENCIL_PASS_DEPTH_PASS: *params = mState.depthStencil.stencilPassDepthPass; break; 1768 case GL_STENCIL_BACK_FAIL: *params = mState.depthStencil.stencilBackFail; break; 1769 case GL_STENCIL_BACK_PASS_DEPTH_FAIL: *params = mState.depthStencil.stencilBackPassDepthFail; break; 1770 case GL_STENCIL_BACK_PASS_DEPTH_PASS: *params = mState.depthStencil.stencilBackPassDepthPass; break; 1771 case GL_DEPTH_FUNC: *params = mState.depthStencil.depthFunc; break; 1772 case GL_BLEND_SRC_RGB: *params = mState.blend.sourceBlendRGB; break; 1773 case GL_BLEND_SRC_ALPHA: *params = mState.blend.sourceBlendAlpha; break; 1774 case GL_BLEND_DST_RGB: *params = mState.blend.destBlendRGB; break; 1775 case GL_BLEND_DST_ALPHA: *params = mState.blend.destBlendAlpha; break; 1776 case GL_BLEND_EQUATION_RGB: *params = mState.blend.blendEquationRGB; break; 1777 case GL_BLEND_EQUATION_ALPHA: *params = mState.blend.blendEquationAlpha; break; 1778 case GL_STENCIL_WRITEMASK: *params = clampToInt(mState.depthStencil.stencilWritemask); break; 1779 case GL_STENCIL_BACK_WRITEMASK: *params = clampToInt(mState.depthStencil.stencilBackWritemask); break; 1780 case GL_STENCIL_CLEAR_VALUE: *params = mState.stencilClearValue; break; 1781 case GL_SUBPIXEL_BITS: *params = 4; break; 1782 case GL_MAX_TEXTURE_SIZE: *params = getMaximum2DTextureDimension(); break; 1783 case GL_MAX_CUBE_MAP_TEXTURE_SIZE: *params = getMaximumCubeTextureDimension(); break; 1784 case GL_MAX_3D_TEXTURE_SIZE: *params = getMaximum3DTextureDimension(); break; 1785 case GL_MAX_ARRAY_TEXTURE_LAYERS: *params = getMaximum2DArrayTextureLayers(); break; 1786 case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT: *params = getUniformBufferOffsetAlignment(); break; 1787 case GL_MAX_UNIFORM_BUFFER_BINDINGS: *params = getMaximumCombinedUniformBufferBindings(); break; 1788 case GL_MAX_VERTEX_UNIFORM_BLOCKS: *params = mRenderer->getMaxVertexShaderUniformBuffers(); break; 1789 case GL_MAX_FRAGMENT_UNIFORM_BLOCKS: *params = mRenderer->getMaxFragmentShaderUniformBuffers(); break; 1790 case GL_MAX_COMBINED_UNIFORM_BLOCKS: *params = getMaximumCombinedUniformBufferBindings(); break; 1791 case GL_MAJOR_VERSION: *params = mClientVersion; break; 1792 case GL_MINOR_VERSION: *params = 0; break; 1793 case GL_MAX_ELEMENTS_INDICES: *params = mRenderer->getMaxRecommendedElementsIndices(); break; 1794 case GL_MAX_ELEMENTS_VERTICES: *params = mRenderer->getMaxRecommendedElementsVertices(); break; 1795 case GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: *params = mRenderer->getMaxTransformFeedbackInterleavedComponents(); break; 1796 case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: *params = mRenderer->getMaxTransformFeedbackBuffers(); break; 1797 case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: *params = mRenderer->getMaxTransformFeedbackSeparateComponents(); break; 1798 case GL_NUM_COMPRESSED_TEXTURE_FORMATS: 1799 params[0] = mNumCompressedTextureFormats; 1800 break; 1801 case GL_MAX_SAMPLES_ANGLE: 1802 *params = static_cast<GLint>(getMaxSupportedSamples()); 1803 break; 1804 case GL_SAMPLE_BUFFERS: 1805 case GL_SAMPLES: 1806 { 1807 gl::Framebuffer *framebuffer = getDrawFramebuffer(); 1808 if (framebuffer->completeness() == GL_FRAMEBUFFER_COMPLETE) 1809 { 1810 switch (pname) 1811 { 1812 case GL_SAMPLE_BUFFERS: 1813 if (framebuffer->getSamples() != 0) 1814 { 1815 *params = 1; 1816 } 1817 else 1818 { 1819 *params = 0; 1820 } 1821 break; 1822 case GL_SAMPLES: 1823 *params = framebuffer->getSamples(); 1824 break; 1825 } 1826 } 1827 else 1828 { 1829 *params = 0; 1830 } 1831 } 1832 break; 1833 case GL_IMPLEMENTATION_COLOR_READ_TYPE: 1834 case GL_IMPLEMENTATION_COLOR_READ_FORMAT: 1835 { 1836 GLenum internalFormat, format, type; 1837 getCurrentReadFormatType(&internalFormat, &format, &type); 1838 if (pname == GL_IMPLEMENTATION_COLOR_READ_FORMAT) 1839 *params = format; 1840 else 1841 *params = type; 1842 } 1843 break; 1844 case GL_MAX_VIEWPORT_DIMS: 1845 { 1846 params[0] = mMaxViewportDimension; 1847 params[1] = mMaxViewportDimension; 1848 } 1849 break; 1850 case GL_COMPRESSED_TEXTURE_FORMATS: 1851 { 1852 if (supportsDXT1Textures()) 1853 { 1854 *params++ = GL_COMPRESSED_RGB_S3TC_DXT1_EXT; 1855 *params++ = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; 1856 } 1857 if (supportsDXT3Textures()) 1858 { 1859 *params++ = GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE; 1860 } 1861 if (supportsDXT5Textures()) 1862 { 1863 *params++ = GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE; 1864 } 1865 } 1866 break; 1867 case GL_VIEWPORT: 1868 params[0] = mState.viewport.x; 1869 params[1] = mState.viewport.y; 1870 params[2] = mState.viewport.width; 1871 params[3] = mState.viewport.height; 1872 break; 1873 case GL_SCISSOR_BOX: 1874 params[0] = mState.scissor.x; 1875 params[1] = mState.scissor.y; 1876 params[2] = mState.scissor.width; 1877 params[3] = mState.scissor.height; 1878 break; 1879 case GL_CULL_FACE_MODE: *params = mState.rasterizer.cullMode; break; 1880 case GL_FRONT_FACE: *params = mState.rasterizer.frontFace; break; 1881 case GL_RED_BITS: 1882 case GL_GREEN_BITS: 1883 case GL_BLUE_BITS: 1884 case GL_ALPHA_BITS: 1885 { 1886 gl::Framebuffer *framebuffer = getDrawFramebuffer(); 1887 gl::FramebufferAttachment *colorbuffer = framebuffer->getFirstColorbuffer(); 1888 1889 if (colorbuffer) 1890 { 1891 switch (pname) 1892 { 1893 case GL_RED_BITS: *params = colorbuffer->getRedSize(); break; 1894 case GL_GREEN_BITS: *params = colorbuffer->getGreenSize(); break; 1895 case GL_BLUE_BITS: *params = colorbuffer->getBlueSize(); break; 1896 case GL_ALPHA_BITS: *params = colorbuffer->getAlphaSize(); break; 1897 } 1898 } 1899 else 1900 { 1901 *params = 0; 1902 } 1903 } 1904 break; 1905 case GL_DEPTH_BITS: 1906 { 1907 gl::Framebuffer *framebuffer = getDrawFramebuffer(); 1908 gl::FramebufferAttachment *depthbuffer = framebuffer->getDepthbuffer(); 1909 1910 if (depthbuffer) 1911 { 1912 *params = depthbuffer->getDepthSize(); 1913 } 1914 else 1915 { 1916 *params = 0; 1917 } 1918 } 1919 break; 1920 case GL_STENCIL_BITS: 1921 { 1922 gl::Framebuffer *framebuffer = getDrawFramebuffer(); 1923 gl::FramebufferAttachment *stencilbuffer = framebuffer->getStencilbuffer(); 1924 1925 if (stencilbuffer) 1926 { 1927 *params = stencilbuffer->getStencilSize(); 1928 } 1929 else 1930 { 1931 *params = 0; 1932 } 1933 } 1934 break; 1935 case GL_TEXTURE_BINDING_2D: 1936 ASSERT(mState.activeSampler < mRenderer->getMaxCombinedTextureImageUnits()); 1937 *params = mState.samplerTexture[TEXTURE_2D][mState.activeSampler].id(); 1938 break; 1939 case GL_TEXTURE_BINDING_CUBE_MAP: 1940 ASSERT(mState.activeSampler < mRenderer->getMaxCombinedTextureImageUnits()); 1941 *params = mState.samplerTexture[TEXTURE_CUBE][mState.activeSampler].id(); 1942 break; 1943 case GL_TEXTURE_BINDING_3D: 1944 ASSERT(mState.activeSampler < mRenderer->getMaxCombinedTextureImageUnits()); 1945 *params = mState.samplerTexture[TEXTURE_3D][mState.activeSampler].id(); 1946 break; 1947 case GL_TEXTURE_BINDING_2D_ARRAY: 1948 ASSERT(mState.activeSampler < mRenderer->getMaxCombinedTextureImageUnits()); 1949 *params = mState.samplerTexture[TEXTURE_2D_ARRAY][mState.activeSampler].id(); 1950 break; 1951 case GL_RESET_NOTIFICATION_STRATEGY_EXT: 1952 *params = mResetStrategy; 1953 break; 1954 case GL_NUM_PROGRAM_BINARY_FORMATS_OES: 1955 *params = 1; 1956 break; 1957 case GL_PROGRAM_BINARY_FORMATS_OES: 1958 *params = GL_PROGRAM_BINARY_ANGLE; 1959 break; 1960 case GL_UNIFORM_BUFFER_BINDING: 1961 *params = mState.genericUniformBuffer.id(); 1962 break; 1963 case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING: 1964 *params = mState.genericTransformFeedbackBuffer.id(); 1965 break; 1966 case GL_COPY_READ_BUFFER_BINDING: 1967 *params = mState.copyReadBuffer.id(); 1968 break; 1969 case GL_COPY_WRITE_BUFFER_BINDING: 1970 *params = mState.copyWriteBuffer.id(); 1971 break; 1972 case GL_PIXEL_PACK_BUFFER_BINDING: 1973 *params = mState.pack.pixelBuffer.id(); 1974 break; 1975 case GL_PIXEL_UNPACK_BUFFER_BINDING: 1976 *params = mState.unpack.pixelBuffer.id(); 1977 break; 1978 case GL_NUM_EXTENSIONS: 1979 *params = static_cast<GLint>(getNumExtensions()); 1980 break; 1981 default: 1982 UNREACHABLE(); 1983 break; 1984 } 1985 } 1986 1987 void Context::getInteger64v(GLenum pname, GLint64 *params) 1988 { 1989 switch (pname) 1990 { 1991 case GL_MAX_ELEMENT_INDEX: 1992 *params = static_cast<GLint64>(std::numeric_limits<unsigned int>::max()); 1993 break; 1994 case GL_MAX_UNIFORM_BLOCK_SIZE: 1995 *params = static_cast<GLint64>(mRenderer->getMaxUniformBufferSize()); 1996 break; 1997 case GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: 1998 { 1999 GLint64 uniformBufferComponents = static_cast<GLint64>(mRenderer->getMaxVertexShaderUniformBuffers()) * static_cast<GLint64>(mRenderer->getMaxUniformBufferSize() / 4); 2000 GLint64 defaultBufferComponents = static_cast<GLint64>(mRenderer->getMaxVertexUniformVectors() * 4); 2001 *params = uniformBufferComponents + defaultBufferComponents; 2002 } 2003 break; 2004 case GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: 2005 { 2006 GLint64 uniformBufferComponents = static_cast<GLint64>(mRenderer->getMaxFragmentShaderUniformBuffers()) * static_cast<GLint64>(mRenderer->getMaxUniformBufferSize() / 4); 2007 GLint64 defaultBufferComponents = static_cast<GLint64>(mRenderer->getMaxVertexUniformVectors() * 4); 2008 *params = uniformBufferComponents + defaultBufferComponents; 2009 } 2010 break; 2011 case GL_MAX_SERVER_WAIT_TIMEOUT: 2012 // We do not wait for server fence objects internally, so report a max timeout of zero. 2013 *params = 0; 2014 break; 2015 default: 2016 UNREACHABLE(); 2017 break; 2018 } 2019 } 2020 2021 bool Context::getIndexedIntegerv(GLenum target, GLuint index, GLint *data) 2022 { 2023 switch (target) 2024 { 2025 case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING: 2026 if (index < IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS) 2027 { 2028 *data = mState.transformFeedbackBuffers[index].id(); 2029 } 2030 break; 2031 case GL_UNIFORM_BUFFER_BINDING: 2032 if (index < IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS) 2033 { 2034 *data = mState.uniformBuffers[index].id(); 2035 } 2036 break; 2037 default: 2038 return false; 2039 } 2040 2041 return true; 2042 } 2043 2044 bool Context::getIndexedInteger64v(GLenum target, GLuint index, GLint64 *data) 2045 { 2046 switch (target) 2047 { 2048 case GL_TRANSFORM_FEEDBACK_BUFFER_START: 2049 if (index < IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS) 2050 { 2051 *data = mState.transformFeedbackBuffers[index].getOffset(); 2052 } 2053 break; 2054 case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE: 2055 if (index < IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS) 2056 { 2057 *data = mState.transformFeedbackBuffers[index].getSize(); 2058 } 2059 break; 2060 case GL_UNIFORM_BUFFER_START: 2061 if (index < IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS) 2062 { 2063 *data = mState.uniformBuffers[index].getOffset(); 2064 } 2065 break; 2066 case GL_UNIFORM_BUFFER_SIZE: 2067 if (index < IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS) 2068 { 2069 *data = mState.uniformBuffers[index].getSize(); 2070 } 2071 break; 2072 default: 2073 return false; 2074 } 2075 2076 return true; 2077 } 2078 2079 bool Context::getQueryParameterInfo(GLenum pname, GLenum *type, unsigned int *numParams) 2080 { 2081 if (pname >= GL_DRAW_BUFFER0_EXT && pname <= GL_DRAW_BUFFER15_EXT) 2082 { 2083 *type = GL_INT; 2084 *numParams = 1; 2085 return true; 2086 } 2087 2088 // Please note: the query type returned for DEPTH_CLEAR_VALUE in this implementation 2089 // is FLOAT rather than INT, as would be suggested by the GL ES 2.0 spec. This is due 2090 // to the fact that it is stored internally as a float, and so would require conversion 2091 // if returned from Context::getIntegerv. Since this conversion is already implemented 2092 // in the case that one calls glGetIntegerv to retrieve a float-typed state variable, we 2093 // place DEPTH_CLEAR_VALUE with the floats. This should make no difference to the calling 2094 // application. 2095 switch (pname) 2096 { 2097 case GL_COMPRESSED_TEXTURE_FORMATS: 2098 { 2099 *type = GL_INT; 2100 *numParams = mNumCompressedTextureFormats; 2101 } 2102 return true; 2103 case GL_SHADER_BINARY_FORMATS: 2104 { 2105 *type = GL_INT; 2106 *numParams = 0; 2107 } 2108 return true; 2109 case GL_MAX_VERTEX_ATTRIBS: 2110 case GL_MAX_VERTEX_UNIFORM_VECTORS: 2111 case GL_MAX_VARYING_VECTORS: 2112 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: 2113 case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS: 2114 case GL_MAX_TEXTURE_IMAGE_UNITS: 2115 case GL_MAX_FRAGMENT_UNIFORM_VECTORS: 2116 case GL_MAX_RENDERBUFFER_SIZE: 2117 case GL_MAX_COLOR_ATTACHMENTS_EXT: 2118 case GL_MAX_DRAW_BUFFERS_EXT: 2119 case GL_NUM_SHADER_BINARY_FORMATS: 2120 case GL_NUM_COMPRESSED_TEXTURE_FORMATS: 2121 case GL_ARRAY_BUFFER_BINDING: 2122 //case GL_FRAMEBUFFER_BINDING: // equivalent to DRAW_FRAMEBUFFER_BINDING_ANGLE 2123 case GL_DRAW_FRAMEBUFFER_BINDING_ANGLE: 2124 case GL_READ_FRAMEBUFFER_BINDING_ANGLE: 2125 case GL_RENDERBUFFER_BINDING: 2126 case GL_CURRENT_PROGRAM: 2127 case GL_PACK_ALIGNMENT: 2128 case GL_PACK_REVERSE_ROW_ORDER_ANGLE: 2129 case GL_UNPACK_ALIGNMENT: 2130 case GL_GENERATE_MIPMAP_HINT: 2131 case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES: 2132 case GL_RED_BITS: 2133 case GL_GREEN_BITS: 2134 case GL_BLUE_BITS: 2135 case GL_ALPHA_BITS: 2136 case GL_DEPTH_BITS: 2137 case GL_STENCIL_BITS: 2138 case GL_ELEMENT_ARRAY_BUFFER_BINDING: 2139 case GL_CULL_FACE_MODE: 2140 case GL_FRONT_FACE: 2141 case GL_ACTIVE_TEXTURE: 2142 case GL_STENCIL_FUNC: 2143 case GL_STENCIL_VALUE_MASK: 2144 case GL_STENCIL_REF: 2145 case GL_STENCIL_FAIL: 2146 case GL_STENCIL_PASS_DEPTH_FAIL: 2147 case GL_STENCIL_PASS_DEPTH_PASS: 2148 case GL_STENCIL_BACK_FUNC: 2149 case GL_STENCIL_BACK_VALUE_MASK: 2150 case GL_STENCIL_BACK_REF: 2151 case GL_STENCIL_BACK_FAIL: 2152 case GL_STENCIL_BACK_PASS_DEPTH_FAIL: 2153 case GL_STENCIL_BACK_PASS_DEPTH_PASS: 2154 case GL_DEPTH_FUNC: 2155 case GL_BLEND_SRC_RGB: 2156 case GL_BLEND_SRC_ALPHA: 2157 case GL_BLEND_DST_RGB: 2158 case GL_BLEND_DST_ALPHA: 2159 case GL_BLEND_EQUATION_RGB: 2160 case GL_BLEND_EQUATION_ALPHA: 2161 case GL_STENCIL_WRITEMASK: 2162 case GL_STENCIL_BACK_WRITEMASK: 2163 case GL_STENCIL_CLEAR_VALUE: 2164 case GL_SUBPIXEL_BITS: 2165 case GL_MAX_TEXTURE_SIZE: 2166 case GL_MAX_CUBE_MAP_TEXTURE_SIZE: 2167 case GL_SAMPLE_BUFFERS: 2168 case GL_SAMPLES: 2169 case GL_IMPLEMENTATION_COLOR_READ_TYPE: 2170 case GL_IMPLEMENTATION_COLOR_READ_FORMAT: 2171 case GL_TEXTURE_BINDING_2D: 2172 case GL_TEXTURE_BINDING_CUBE_MAP: 2173 case GL_RESET_NOTIFICATION_STRATEGY_EXT: 2174 case GL_NUM_PROGRAM_BINARY_FORMATS_OES: 2175 case GL_PROGRAM_BINARY_FORMATS_OES: 2176 { 2177 *type = GL_INT; 2178 *numParams = 1; 2179 } 2180 return true; 2181 case GL_MAX_SAMPLES_ANGLE: 2182 { 2183 if (getMaxSupportedSamples() != 0) 2184 { 2185 *type = GL_INT; 2186 *numParams = 1; 2187 } 2188 else 2189 { 2190 return false; 2191 } 2192 } 2193 return true; 2194 case GL_PIXEL_PACK_BUFFER_BINDING: 2195 case GL_PIXEL_UNPACK_BUFFER_BINDING: 2196 { 2197 if (supportsPBOs()) 2198 { 2199 *type = GL_INT; 2200 *numParams = 1; 2201 } 2202 else 2203 { 2204 return false; 2205 } 2206 } 2207 return true; 2208 case GL_MAX_VIEWPORT_DIMS: 2209 { 2210 *type = GL_INT; 2211 *numParams = 2; 2212 } 2213 return true; 2214 case GL_VIEWPORT: 2215 case GL_SCISSOR_BOX: 2216 { 2217 *type = GL_INT; 2218 *numParams = 4; 2219 } 2220 return true; 2221 case GL_SHADER_COMPILER: 2222 case GL_SAMPLE_COVERAGE_INVERT: 2223 case GL_DEPTH_WRITEMASK: 2224 case GL_CULL_FACE: // CULL_FACE through DITHER are natural to IsEnabled, 2225 case GL_POLYGON_OFFSET_FILL: // but can be retrieved through the Get{Type}v queries. 2226 case GL_SAMPLE_ALPHA_TO_COVERAGE: // For this purpose, they are treated here as bool-natural 2227 case GL_SAMPLE_COVERAGE: 2228 case GL_SCISSOR_TEST: 2229 case GL_STENCIL_TEST: 2230 case GL_DEPTH_TEST: 2231 case GL_BLEND: 2232 case GL_DITHER: 2233 case GL_CONTEXT_ROBUST_ACCESS_EXT: 2234 { 2235 *type = GL_BOOL; 2236 *numParams = 1; 2237 } 2238 return true; 2239 case GL_COLOR_WRITEMASK: 2240 { 2241 *type = GL_BOOL; 2242 *numParams = 4; 2243 } 2244 return true; 2245 case GL_POLYGON_OFFSET_FACTOR: 2246 case GL_POLYGON_OFFSET_UNITS: 2247 case GL_SAMPLE_COVERAGE_VALUE: 2248 case GL_DEPTH_CLEAR_VALUE: 2249 case GL_LINE_WIDTH: 2250 { 2251 *type = GL_FLOAT; 2252 *numParams = 1; 2253 } 2254 return true; 2255 case GL_ALIASED_LINE_WIDTH_RANGE: 2256 case GL_ALIASED_POINT_SIZE_RANGE: 2257 case GL_DEPTH_RANGE: 2258 { 2259 *type = GL_FLOAT; 2260 *numParams = 2; 2261 } 2262 return true; 2263 case GL_COLOR_CLEAR_VALUE: 2264 case GL_BLEND_COLOR: 2265 { 2266 *type = GL_FLOAT; 2267 *numParams = 4; 2268 } 2269 return true; 2270 case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: 2271 if (!supportsTextureFilterAnisotropy()) 2272 { 2273 return false; 2274 } 2275 *type = GL_FLOAT; 2276 *numParams = 1; 2277 return true; 2278 } 2279 2280 if (mClientVersion < 3) 2281 { 2282 return false; 2283 } 2284 2285 // Check for ES3.0+ parameter names 2286 switch (pname) 2287 { 2288 case GL_MAX_UNIFORM_BUFFER_BINDINGS: 2289 case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT: 2290 case GL_UNIFORM_BUFFER_BINDING: 2291 case GL_TRANSFORM_FEEDBACK_BINDING: 2292 case GL_COPY_READ_BUFFER_BINDING: 2293 case GL_COPY_WRITE_BUFFER_BINDING: 2294 case GL_TEXTURE_BINDING_3D: 2295 case GL_TEXTURE_BINDING_2D_ARRAY: 2296 case GL_MAX_3D_TEXTURE_SIZE: 2297 case GL_MAX_ARRAY_TEXTURE_LAYERS: 2298 case GL_MAX_VERTEX_UNIFORM_BLOCKS: 2299 case GL_MAX_FRAGMENT_UNIFORM_BLOCKS: 2300 case GL_MAX_COMBINED_UNIFORM_BLOCKS: 2301 case GL_MAX_VARYING_COMPONENTS: 2302 case GL_VERTEX_ARRAY_BINDING: 2303 case GL_MAX_VERTEX_UNIFORM_COMPONENTS: 2304 case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS: 2305 case GL_NUM_EXTENSIONS: 2306 case GL_MAJOR_VERSION: 2307 case GL_MINOR_VERSION: 2308 case GL_MAX_ELEMENTS_INDICES: 2309 case GL_MAX_ELEMENTS_VERTICES: 2310 case GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: 2311 case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: 2312 case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: 2313 { 2314 *type = GL_INT; 2315 *numParams = 1; 2316 } 2317 return true; 2318 2319 case GL_MAX_ELEMENT_INDEX: 2320 case GL_MAX_UNIFORM_BLOCK_SIZE: 2321 case GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: 2322 case GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: 2323 case GL_MAX_SERVER_WAIT_TIMEOUT: 2324 { 2325 *type = GL_INT_64_ANGLEX; 2326 *numParams = 1; 2327 } 2328 return true; 2329 2330 case GL_TRANSFORM_FEEDBACK_ACTIVE: 2331 case GL_TRANSFORM_FEEDBACK_PAUSED: 2332 { 2333 *type = GL_BOOL; 2334 *numParams = 1; 2335 } 2336 return true; 2337 } 2338 2339 return false; 2340 } 2341 2342 bool Context::getIndexedQueryParameterInfo(GLenum target, GLenum *type, unsigned int *numParams) 2343 { 2344 if (mClientVersion < 3) 2345 { 2346 return false; 2347 } 2348 2349 switch (target) 2350 { 2351 case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING: 2352 case GL_UNIFORM_BUFFER_BINDING: 2353 { 2354 *type = GL_INT; 2355 *numParams = 1; 2356 } 2357 return true; 2358 case GL_TRANSFORM_FEEDBACK_BUFFER_START: 2359 case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE: 2360 case GL_UNIFORM_BUFFER_START: 2361 case GL_UNIFORM_BUFFER_SIZE: 2362 { 2363 *type = GL_INT_64_ANGLEX; 2364 *numParams = 1; 2365 } 2366 } 2367 2368 return false; 2369 } 2370 2371 // Applies the render target surface, depth stencil surface, viewport rectangle and 2372 // scissor rectangle to the renderer 2373 bool Context::applyRenderTarget(GLenum drawMode, bool ignoreViewport) 2374 { 2375 Framebuffer *framebufferObject = getDrawFramebuffer(); 2376 2377 if (!framebufferObject || framebufferObject->completeness() != GL_FRAMEBUFFER_COMPLETE) 2378 { 2379 return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION, false); 2380 } 2381 2382 mRenderer->applyRenderTarget(framebufferObject); 2383 2384 if (!mRenderer->setViewport(mState.viewport, mState.zNear, mState.zFar, drawMode, mState.rasterizer.frontFace, 2385 ignoreViewport)) 2386 { 2387 return false; 2388 } 2389 2390 mRenderer->setScissorRectangle(mState.scissor, mState.scissorTest); 2391 2392 return true; 2393 } 2394 2395 // Applies the fixed-function state (culling, depth test, alpha blending, stenciling, etc) to the Direct3D 9 device 2396 void Context::applyState(GLenum drawMode) 2397 { 2398 Framebuffer *framebufferObject = getDrawFramebuffer(); 2399 int samples = framebufferObject->getSamples(); 2400 2401 mState.rasterizer.pointDrawMode = (drawMode == GL_POINTS); 2402 mState.rasterizer.multiSample = (samples != 0); 2403 mRenderer->setRasterizerState(mState.rasterizer); 2404 2405 unsigned int mask = 0; 2406 if (mState.sampleCoverage) 2407 { 2408 if (mState.sampleCoverageValue != 0) 2409 { 2410 2411 float threshold = 0.5f; 2412 2413 for (int i = 0; i < samples; ++i) 2414 { 2415 mask <<= 1; 2416 2417 if ((i + 1) * mState.sampleCoverageValue >= threshold) 2418 { 2419 threshold += 1.0f; 2420 mask |= 1; 2421 } 2422 } 2423 } 2424 2425 if (mState.sampleCoverageInvert) 2426 { 2427 mask = ~mask; 2428 } 2429 } 2430 else 2431 { 2432 mask = 0xFFFFFFFF; 2433 } 2434 mRenderer->setBlendState(framebufferObject, mState.blend, mState.blendColor, mask); 2435 2436 mRenderer->setDepthStencilState(mState.depthStencil, mState.stencilRef, mState.stencilBackRef, 2437 mState.rasterizer.frontFace == GL_CCW); 2438 } 2439 2440 // Applies the shaders and shader constants to the Direct3D 9 device 2441 void Context::applyShaders(ProgramBinary *programBinary, bool transformFeedbackActive) 2442 { 2443 const VertexAttribute *vertexAttributes = getCurrentVertexArray()->getVertexAttributes(); 2444 2445 VertexFormat inputLayout[gl::MAX_VERTEX_ATTRIBS]; 2446 VertexFormat::GetInputLayout(inputLayout, programBinary, vertexAttributes, mState.vertexAttribCurrentValues); 2447 2448 mRenderer->applyShaders(programBinary, mState.rasterizer.rasterizerDiscard, transformFeedbackActive, inputLayout); 2449 2450 programBinary->applyUniforms(); 2451 } 2452 2453 size_t Context::getCurrentTexturesAndSamplerStates(ProgramBinary *programBinary, SamplerType type, Texture **outTextures, 2454 TextureType *outTextureTypes, SamplerState *outSamplers) 2455 { 2456 size_t samplerRange = programBinary->getUsedSamplerRange(type); 2457 for (size_t i = 0; i < samplerRange; i++) 2458 { 2459 outTextureTypes[i] = programBinary->getSamplerTextureType(type, i); 2460 GLint textureUnit = programBinary->getSamplerMapping(type, i); // OpenGL texture image unit index 2461 if (textureUnit != -1) 2462 { 2463 outTextures[i] = getSamplerTexture(textureUnit, outTextureTypes[i]); 2464 outTextures[i]->getSamplerState(&outSamplers[i]); 2465 if (mState.samplers[textureUnit] != 0) 2466 { 2467 Sampler *samplerObject = getSampler(mState.samplers[textureUnit]); 2468 samplerObject->getState(&outSamplers[i]); 2469 } 2470 } 2471 else 2472 { 2473 outTextures[i] = NULL; 2474 } 2475 } 2476 2477 return samplerRange; 2478 } 2479 2480 void Context::generateSwizzles(Texture *textures[], size_t count) 2481 { 2482 for (size_t i = 0; i < count; i++) 2483 { 2484 if (textures[i] && textures[i]->isSwizzled()) 2485 { 2486 mRenderer->generateSwizzle(textures[i]); 2487 } 2488 } 2489 } 2490 2491 // For each Direct3D sampler of either the pixel or vertex stage, 2492 // looks up the corresponding OpenGL texture image unit and texture type, 2493 // and sets the texture and its addressing/filtering state (or NULL when inactive). 2494 void Context::applyTextures(SamplerType shaderType, Texture *textures[], TextureType *textureTypes, SamplerState *samplers, 2495 size_t textureCount, const FramebufferTextureSerialArray& framebufferSerials, 2496 size_t framebufferSerialCount) 2497 { 2498 // Range of Direct3D samplers of given sampler type 2499 size_t samplerCount = (shaderType == SAMPLER_PIXEL) ? MAX_TEXTURE_IMAGE_UNITS 2500 : mRenderer->getMaxVertexTextureImageUnits(); 2501 2502 for (size_t samplerIndex = 0; samplerIndex < textureCount; samplerIndex++) 2503 { 2504 Texture *texture = textures[samplerIndex]; 2505 const SamplerState &sampler = samplers[samplerIndex]; 2506 TextureType textureType = textureTypes[samplerIndex]; 2507 2508 if (texture) 2509 { 2510 // TODO: std::binary_search may become unavailable using older versions of GCC 2511 if (texture->isSamplerComplete(sampler) && 2512 !std::binary_search(framebufferSerials.begin(), framebufferSerials.begin() + framebufferSerialCount, texture->getTextureSerial())) 2513 { 2514 mRenderer->setSamplerState(shaderType, samplerIndex, sampler); 2515 mRenderer->setTexture(shaderType, samplerIndex, texture); 2516 texture->resetDirty(); 2517 } 2518 else 2519 { 2520 Texture *incompleteTexture = getIncompleteTexture(textureType); 2521 mRenderer->setTexture(shaderType, samplerIndex, incompleteTexture); 2522 incompleteTexture->resetDirty(); 2523 } 2524 } 2525 else 2526 { 2527 mRenderer->setTexture(shaderType, samplerIndex, NULL); 2528 } 2529 } 2530 2531 for (size_t samplerIndex = textureCount; samplerIndex < samplerCount; samplerIndex++) 2532 { 2533 mRenderer->setTexture(shaderType, samplerIndex, NULL); 2534 } 2535 } 2536 2537 bool Context::applyUniformBuffers() 2538 { 2539 Program *programObject = getProgram(mState.currentProgram); 2540 ProgramBinary *programBinary = programObject->getProgramBinary(); 2541 2542 std::vector<gl::Buffer*> boundBuffers; 2543 2544 for (unsigned int uniformBlockIndex = 0; uniformBlockIndex < programBinary->getActiveUniformBlockCount(); uniformBlockIndex++) 2545 { 2546 GLuint blockBinding = programObject->getUniformBlockBinding(uniformBlockIndex); 2547 const OffsetBindingPointer<Buffer>& boundBuffer = mState.uniformBuffers[blockBinding]; 2548 if (boundBuffer.id() == 0) 2549 { 2550 // undefined behaviour 2551 return false; 2552 } 2553 else 2554 { 2555 gl::Buffer *uniformBuffer = boundBuffer.get(); 2556 ASSERT(uniformBuffer); 2557 boundBuffers.push_back(uniformBuffer); 2558 } 2559 } 2560 2561 return programBinary->applyUniformBuffers(boundBuffers); 2562 } 2563 2564 bool Context::applyTransformFeedbackBuffers() 2565 { 2566 TransformFeedback *curTransformFeedback = getCurrentTransformFeedback(); 2567 if (curTransformFeedback && curTransformFeedback->isStarted() && !curTransformFeedback->isPaused()) 2568 { 2569 Buffer *transformFeedbackBuffers[IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS]; 2570 GLintptr transformFeedbackOffsets[IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS]; 2571 for (size_t i = 0; i < IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS; i++) 2572 { 2573 transformFeedbackBuffers[i] = mState.transformFeedbackBuffers[i].get(); 2574 transformFeedbackOffsets[i] = mState.transformFeedbackBuffers[i].getOffset(); 2575 } 2576 mRenderer->applyTransformFeedbackBuffers(transformFeedbackBuffers, transformFeedbackOffsets); 2577 return true; 2578 } 2579 else 2580 { 2581 return false; 2582 } 2583 } 2584 2585 void Context::markTransformFeedbackUsage() 2586 { 2587 for (size_t i = 0; i < IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS; i++) 2588 { 2589 Buffer *buffer = mState.transformFeedbackBuffers[i].get(); 2590 if (buffer) 2591 { 2592 buffer->markTransformFeedbackUsage(); 2593 } 2594 } 2595 } 2596 2597 void Context::clear(GLbitfield mask) 2598 { 2599 if (isRasterizerDiscardEnabled()) 2600 { 2601 return; 2602 } 2603 2604 ClearParameters clearParams = { 0 }; 2605 for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++) 2606 { 2607 clearParams.clearColor[i] = false; 2608 } 2609 clearParams.colorFClearValue = mState.colorClearValue; 2610 clearParams.colorClearType = GL_FLOAT; 2611 clearParams.colorMaskRed = mState.blend.colorMaskRed; 2612 clearParams.colorMaskGreen = mState.blend.colorMaskGreen; 2613 clearParams.colorMaskBlue = mState.blend.colorMaskBlue; 2614 clearParams.colorMaskAlpha = mState.blend.colorMaskAlpha; 2615 clearParams.clearDepth = false; 2616 clearParams.depthClearValue = mState.depthClearValue; 2617 clearParams.clearStencil = false; 2618 clearParams.stencilClearValue = mState.stencilClearValue; 2619 clearParams.stencilWriteMask = mState.depthStencil.stencilWritemask; 2620 clearParams.scissorEnabled = mState.scissorTest; 2621 clearParams.scissor = mState.scissor; 2622 2623 Framebuffer *framebufferObject = getDrawFramebuffer(); 2624 if (mask & GL_COLOR_BUFFER_BIT) 2625 { 2626 if (framebufferObject->hasEnabledColorAttachment()) 2627 { 2628 for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++) 2629 { 2630 clearParams.clearColor[i] = true; 2631 } 2632 } 2633 } 2634 2635 if (mask & GL_DEPTH_BUFFER_BIT) 2636 { 2637 if (mState.depthStencil.depthMask && framebufferObject->getDepthbufferType() != GL_NONE) 2638 { 2639 clearParams.clearDepth = true; 2640 } 2641 } 2642 2643 if (mask & GL_STENCIL_BUFFER_BIT) 2644 { 2645 if (framebufferObject->getStencilbufferType() != GL_NONE) 2646 { 2647 rx::RenderTarget *depthStencil = framebufferObject->getStencilbuffer()->getDepthStencil(); 2648 if (!depthStencil) 2649 { 2650 ERR("Depth stencil pointer unexpectedly null."); 2651 return; 2652 } 2653 2654 if (gl::GetStencilBits(depthStencil->getActualFormat(), mClientVersion) > 0) 2655 { 2656 clearParams.clearStencil = true; 2657 } 2658 } 2659 } 2660 2661 2662 if (!applyRenderTarget(GL_TRIANGLES, true)) // Clips the clear to the scissor rectangle but not the viewport 2663 { 2664 return; 2665 } 2666 2667 mRenderer->clear(clearParams, framebufferObject); 2668 } 2669 2670 void Context::clearBufferfv(GLenum buffer, int drawbuffer, const float *values) 2671 { 2672 if (isRasterizerDiscardEnabled()) 2673 { 2674 return; 2675 } 2676 2677 // glClearBufferfv can be called to clear the color buffer or depth buffer 2678 ClearParameters clearParams = { 0 }; 2679 2680 if (buffer == GL_COLOR) 2681 { 2682 for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++) 2683 { 2684 clearParams.clearColor[i] = (drawbuffer == static_cast<int>(i)); 2685 } 2686 clearParams.colorFClearValue = ColorF(values[0], values[1], values[2], values[3]); 2687 clearParams.colorClearType = GL_FLOAT; 2688 } 2689 else 2690 { 2691 for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++) 2692 { 2693 clearParams.clearColor[i] = false; 2694 } 2695 clearParams.colorFClearValue = mState.colorClearValue; 2696 clearParams.colorClearType = GL_FLOAT; 2697 } 2698 2699 clearParams.colorMaskRed = mState.blend.colorMaskRed; 2700 clearParams.colorMaskGreen = mState.blend.colorMaskGreen; 2701 clearParams.colorMaskBlue = mState.blend.colorMaskBlue; 2702 clearParams.colorMaskAlpha = mState.blend.colorMaskAlpha; 2703 2704 if (buffer == GL_DEPTH) 2705 { 2706 clearParams.clearDepth = true; 2707 clearParams.depthClearValue = values[0]; 2708 } 2709 else 2710 { 2711 clearParams.clearDepth = false; 2712 clearParams.depthClearValue = mState.depthClearValue; 2713 } 2714 2715 clearParams.clearStencil = false; 2716 clearParams.stencilClearValue = mState.stencilClearValue; 2717 clearParams.stencilWriteMask = mState.depthStencil.stencilWritemask; 2718 clearParams.scissorEnabled = mState.scissorTest; 2719 clearParams.scissor = mState.scissor; 2720 2721 if (!applyRenderTarget(GL_TRIANGLES, true)) // Clips the clear to the scissor rectangle but not the viewport 2722 { 2723 return; 2724 } 2725 2726 mRenderer->clear(clearParams, getDrawFramebuffer()); 2727 } 2728 2729 void Context::clearBufferuiv(GLenum buffer, int drawbuffer, const unsigned int *values) 2730 { 2731 if (isRasterizerDiscardEnabled()) 2732 { 2733 return; 2734 } 2735 2736 // glClearBufferuv can only be called to clear a color buffer 2737 ClearParameters clearParams = { 0 }; 2738 for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++) 2739 { 2740 clearParams.clearColor[i] = (drawbuffer == static_cast<int>(i)); 2741 } 2742 clearParams.colorUIClearValue = ColorUI(values[0], values[1], values[2], values[3]); 2743 clearParams.colorClearType = GL_UNSIGNED_INT; 2744 clearParams.colorMaskRed = mState.blend.colorMaskRed; 2745 clearParams.colorMaskGreen = mState.blend.colorMaskGreen; 2746 clearParams.colorMaskBlue = mState.blend.colorMaskBlue; 2747 clearParams.colorMaskAlpha = mState.blend.colorMaskAlpha; 2748 clearParams.clearDepth = false; 2749 clearParams.depthClearValue = mState.depthClearValue; 2750 clearParams.clearStencil = false; 2751 clearParams.stencilClearValue = mState.stencilClearValue; 2752 clearParams.stencilWriteMask = mState.depthStencil.stencilWritemask; 2753 clearParams.scissorEnabled = mState.scissorTest; 2754 clearParams.scissor = mState.scissor; 2755 2756 if (!applyRenderTarget(GL_TRIANGLES, true)) // Clips the clear to the scissor rectangle but not the viewport 2757 { 2758 return; 2759 } 2760 2761 mRenderer->clear(clearParams, getDrawFramebuffer()); 2762 } 2763 2764 void Context::clearBufferiv(GLenum buffer, int drawbuffer, const int *values) 2765 { 2766 if (isRasterizerDiscardEnabled()) 2767 { 2768 return; 2769 } 2770 2771 // glClearBufferfv can be called to clear the color buffer or stencil buffer 2772 ClearParameters clearParams = { 0 }; 2773 2774 if (buffer == GL_COLOR) 2775 { 2776 for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++) 2777 { 2778 clearParams.clearColor[i] = (drawbuffer == static_cast<int>(i)); 2779 } 2780 clearParams.colorIClearValue = ColorI(values[0], values[1], values[2], values[3]); 2781 clearParams.colorClearType = GL_INT; 2782 } 2783 else 2784 { 2785 for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++) 2786 { 2787 clearParams.clearColor[i] = false; 2788 } 2789 clearParams.colorFClearValue = mState.colorClearValue; 2790 clearParams.colorClearType = GL_FLOAT; 2791 } 2792 2793 clearParams.colorMaskRed = mState.blend.colorMaskRed; 2794 clearParams.colorMaskGreen = mState.blend.colorMaskGreen; 2795 clearParams.colorMaskBlue = mState.blend.colorMaskBlue; 2796 clearParams.colorMaskAlpha = mState.blend.colorMaskAlpha; 2797 2798 clearParams.clearDepth = false; 2799 clearParams.depthClearValue = mState.depthClearValue; 2800 2801 if (buffer == GL_STENCIL) 2802 { 2803 clearParams.clearStencil = true; 2804 clearParams.stencilClearValue = values[1]; 2805 } 2806 else 2807 { 2808 clearParams.clearStencil = false; 2809 clearParams.stencilClearValue = mState.stencilClearValue; 2810 } 2811 clearParams.stencilWriteMask = mState.depthStencil.stencilWritemask; 2812 2813 clearParams.scissorEnabled = mState.scissorTest; 2814 clearParams.scissor = mState.scissor; 2815 2816 if (!applyRenderTarget(GL_TRIANGLES, true)) // Clips the clear to the scissor rectangle but not the viewport 2817 { 2818 return; 2819 } 2820 2821 mRenderer->clear(clearParams, getDrawFramebuffer()); 2822 } 2823 2824 void Context::clearBufferfi(GLenum buffer, int drawbuffer, float depth, int stencil) 2825 { 2826 if (isRasterizerDiscardEnabled()) 2827 { 2828 return; 2829 } 2830 2831 // glClearBufferfi can only be called to clear a depth stencil buffer 2832 ClearParameters clearParams = { 0 }; 2833 for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++) 2834 { 2835 clearParams.clearColor[i] = false; 2836 } 2837 clearParams.colorFClearValue = mState.colorClearValue; 2838 clearParams.colorClearType = GL_FLOAT; 2839 clearParams.colorMaskRed = mState.blend.colorMaskRed; 2840 clearParams.colorMaskGreen = mState.blend.colorMaskGreen; 2841 clearParams.colorMaskBlue = mState.blend.colorMaskBlue; 2842 clearParams.colorMaskAlpha = mState.blend.colorMaskAlpha; 2843 clearParams.clearDepth = true; 2844 clearParams.depthClearValue = depth; 2845 clearParams.clearStencil = true; 2846 clearParams.stencilClearValue = stencil; 2847 clearParams.stencilWriteMask = mState.depthStencil.stencilWritemask; 2848 clearParams.scissorEnabled = mState.scissorTest; 2849 clearParams.scissor = mState.scissor; 2850 2851 if (!applyRenderTarget(GL_TRIANGLES, true)) // Clips the clear to the scissor rectangle but not the viewport 2852 { 2853 return; 2854 } 2855 2856 mRenderer->clear(clearParams, getDrawFramebuffer()); 2857 } 2858 2859 void Context::readPixels(GLint x, GLint y, GLsizei width, GLsizei height, 2860 GLenum format, GLenum type, GLsizei *bufSize, void* pixels) 2861 { 2862 gl::Framebuffer *framebuffer = getReadFramebuffer(); 2863 2864 bool isSized = IsSizedInternalFormat(format, mClientVersion); 2865 GLenum sizedInternalFormat = (isSized ? format : GetSizedInternalFormat(format, type, mClientVersion)); 2866 GLuint outputPitch = GetRowPitch(sizedInternalFormat, type, mClientVersion, width, mState.pack.alignment); 2867 2868 mRenderer->readPixels(framebuffer, x, y, width, height, format, type, outputPitch, mState.pack, pixels); 2869 } 2870 2871 void Context::drawArrays(GLenum mode, GLint first, GLsizei count, GLsizei instances) 2872 { 2873 if (!mState.currentProgram) 2874 { 2875 return gl::error(GL_INVALID_OPERATION); 2876 } 2877 2878 ProgramBinary *programBinary = getCurrentProgramBinary(); 2879 programBinary->applyUniforms(); 2880 2881 Texture *vsTextures[IMPLEMENTATION_MAX_VERTEX_TEXTURE_IMAGE_UNITS]; 2882 TextureType vsTextureTypes[IMPLEMENTATION_MAX_VERTEX_TEXTURE_IMAGE_UNITS]; 2883 SamplerState vsSamplers[IMPLEMENTATION_MAX_VERTEX_TEXTURE_IMAGE_UNITS]; 2884 size_t vsTextureCount = getCurrentTexturesAndSamplerStates(programBinary, SAMPLER_VERTEX, vsTextures, vsTextureTypes, vsSamplers); 2885 2886 Texture *psTextures[MAX_TEXTURE_IMAGE_UNITS]; 2887 TextureType psTextureTypes[MAX_TEXTURE_IMAGE_UNITS]; 2888 SamplerState psSamplers[MAX_TEXTURE_IMAGE_UNITS]; 2889 size_t psTextureCount = getCurrentTexturesAndSamplerStates(programBinary, SAMPLER_PIXEL, psTextures, psTextureTypes, psSamplers); 2890 2891 generateSwizzles(vsTextures, vsTextureCount); 2892 generateSwizzles(psTextures, psTextureCount); 2893 2894 if (!mRenderer->applyPrimitiveType(mode, count)) 2895 { 2896 return; 2897 } 2898 2899 if (!applyRenderTarget(mode, false)) 2900 { 2901 return; 2902 } 2903 2904 applyState(mode); 2905 2906 GLenum err = mRenderer->applyVertexBuffer(programBinary, getCurrentVertexArray()->getVertexAttributes(), mState.vertexAttribCurrentValues, first, count, instances); 2907 if (err != GL_NO_ERROR) 2908 { 2909 return gl::error(err); 2910 } 2911 2912 bool transformFeedbackActive = applyTransformFeedbackBuffers(); 2913 2914 applyShaders(programBinary, transformFeedbackActive); 2915 2916 FramebufferTextureSerialArray frameBufferSerials; 2917 size_t framebufferSerialCount = getBoundFramebufferTextureSerials(&frameBufferSerials); 2918 2919 applyTextures(SAMPLER_VERTEX, vsTextures, vsTextureTypes, vsSamplers, vsTextureCount, frameBufferSerials, framebufferSerialCount); 2920 applyTextures(SAMPLER_PIXEL, psTextures, psTextureTypes, psSamplers, psTextureCount, frameBufferSerials, framebufferSerialCount); 2921 2922 if (!applyUniformBuffers()) 2923 { 2924 return; 2925 } 2926 2927 if (!programBinary->validateSamplers(NULL)) 2928 { 2929 return gl::error(GL_INVALID_OPERATION); 2930 } 2931 2932 if (!skipDraw(mode)) 2933 { 2934 mRenderer->drawArrays(mode, count, instances, transformFeedbackActive); 2935 2936 if (transformFeedbackActive) 2937 { 2938 markTransformFeedbackUsage(); 2939 } 2940 } 2941 } 2942 2943 void Context::drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instances) 2944 { 2945 if (!mState.currentProgram) 2946 { 2947 return gl::error(GL_INVALID_OPERATION); 2948 } 2949 2950 VertexArray *vao = getCurrentVertexArray(); 2951 if (!indices && !vao->getElementArrayBuffer()) 2952 { 2953 return gl::error(GL_INVALID_OPERATION); 2954 } 2955 2956 ProgramBinary *programBinary = getCurrentProgramBinary(); 2957 programBinary->applyUniforms(); 2958 2959 Texture *vsTextures[IMPLEMENTATION_MAX_VERTEX_TEXTURE_IMAGE_UNITS]; 2960 TextureType vsTextureTypes[IMPLEMENTATION_MAX_VERTEX_TEXTURE_IMAGE_UNITS]; 2961 SamplerState vsSamplers[IMPLEMENTATION_MAX_VERTEX_TEXTURE_IMAGE_UNITS]; 2962 size_t vsTextureCount = getCurrentTexturesAndSamplerStates(programBinary, SAMPLER_VERTEX, vsTextures, vsTextureTypes, vsSamplers); 2963 2964 Texture *psTextures[MAX_TEXTURE_IMAGE_UNITS]; 2965 TextureType psTextureTypes[MAX_TEXTURE_IMAGE_UNITS]; 2966 SamplerState psSamplers[MAX_TEXTURE_IMAGE_UNITS]; 2967 size_t psTextureCount = getCurrentTexturesAndSamplerStates(programBinary, SAMPLER_PIXEL, psTextures, psTextureTypes, psSamplers); 2968 2969 generateSwizzles(vsTextures, vsTextureCount); 2970 generateSwizzles(psTextures, psTextureCount); 2971 2972 if (!mRenderer->applyPrimitiveType(mode, count)) 2973 { 2974 return; 2975 } 2976 2977 if (!applyRenderTarget(mode, false)) 2978 { 2979 return; 2980 } 2981 2982 applyState(mode); 2983 2984 rx::TranslatedIndexData indexInfo; 2985 GLenum err = mRenderer->applyIndexBuffer(indices, vao->getElementArrayBuffer(), count, mode, type, &indexInfo); 2986 if (err != GL_NO_ERROR) 2987 { 2988 return gl::error(err); 2989 } 2990 2991 GLsizei vertexCount = indexInfo.maxIndex - indexInfo.minIndex + 1; 2992 err = mRenderer->applyVertexBuffer(programBinary, vao->getVertexAttributes(), mState.vertexAttribCurrentValues, indexInfo.minIndex, vertexCount, instances); 2993 if (err != GL_NO_ERROR) 2994 { 2995 return gl::error(err); 2996 } 2997 2998 bool transformFeedbackActive = applyTransformFeedbackBuffers(); 2999 // Transform feedback is not allowed for DrawElements, this error should have been caught at the API validation 3000 // layer. 3001 ASSERT(!transformFeedbackActive); 3002 3003 applyShaders(programBinary, transformFeedbackActive); 3004 3005 FramebufferTextureSerialArray frameBufferSerials; 3006 size_t framebufferSerialCount = getBoundFramebufferTextureSerials(&frameBufferSerials); 3007 3008 applyTextures(SAMPLER_VERTEX, vsTextures, vsTextureTypes, vsSamplers, vsTextureCount, frameBufferSerials, framebufferSerialCount); 3009 applyTextures(SAMPLER_PIXEL, psTextures, psTextureTypes, psSamplers, psTextureCount, frameBufferSerials, framebufferSerialCount); 3010 3011 if (!applyUniformBuffers()) 3012 { 3013 return; 3014 } 3015 3016 if (!programBinary->validateSamplers(NULL)) 3017 { 3018 return gl::error(GL_INVALID_OPERATION); 3019 } 3020 3021 if (!skipDraw(mode)) 3022 { 3023 mRenderer->drawElements(mode, count, type, indices, vao->getElementArrayBuffer(), indexInfo, instances); 3024 } 3025 } 3026 3027 // Implements glFlush when block is false, glFinish when block is true 3028 void Context::sync(bool block) 3029 { 3030 mRenderer->sync(block); 3031 } 3032 3033 void Context::recordInvalidEnum() 3034 { 3035 mInvalidEnum = true; 3036 } 3037 3038 void Context::recordInvalidValue() 3039 { 3040 mInvalidValue = true; 3041 } 3042 3043 void Context::recordInvalidOperation() 3044 { 3045 mInvalidOperation = true; 3046 } 3047 3048 void Context::recordOutOfMemory() 3049 { 3050 mOutOfMemory = true; 3051 } 3052 3053 void Context::recordInvalidFramebufferOperation() 3054 { 3055 mInvalidFramebufferOperation = true; 3056 } 3057 3058 // Get one of the recorded errors and clear its flag, if any. 3059 // [OpenGL ES 2.0.24] section 2.5 page 13. 3060 GLenum Context::getError() 3061 { 3062 if (mInvalidEnum) 3063 { 3064 mInvalidEnum = false; 3065 3066 return GL_INVALID_ENUM; 3067 } 3068 3069 if (mInvalidValue) 3070 { 3071 mInvalidValue = false; 3072 3073 return GL_INVALID_VALUE; 3074 } 3075 3076 if (mInvalidOperation) 3077 { 3078 mInvalidOperation = false; 3079 3080 return GL_INVALID_OPERATION; 3081 } 3082 3083 if (mOutOfMemory) 3084 { 3085 mOutOfMemory = false; 3086 3087 return GL_OUT_OF_MEMORY; 3088 } 3089 3090 if (mInvalidFramebufferOperation) 3091 { 3092 mInvalidFramebufferOperation = false; 3093 3094 return GL_INVALID_FRAMEBUFFER_OPERATION; 3095 } 3096 3097 return GL_NO_ERROR; 3098 } 3099 3100 GLenum Context::getResetStatus() 3101 { 3102 if (mResetStatus == GL_NO_ERROR && !mContextLost) 3103 { 3104 // mResetStatus will be set by the markContextLost callback 3105 // in the case a notification is sent 3106 mRenderer->testDeviceLost(true); 3107 } 3108 3109 GLenum status = mResetStatus; 3110 3111 if (mResetStatus != GL_NO_ERROR) 3112 { 3113 ASSERT(mContextLost); 3114 3115 if (mRenderer->testDeviceResettable()) 3116 { 3117 mResetStatus = GL_NO_ERROR; 3118 } 3119 } 3120 3121 return status; 3122 } 3123 3124 bool Context::isResetNotificationEnabled() 3125 { 3126 return (mResetStrategy == GL_LOSE_CONTEXT_ON_RESET_EXT); 3127 } 3128 3129 int Context::getClientVersion() const 3130 { 3131 return mClientVersion; 3132 } 3133 3134 int Context::getMajorShaderModel() const 3135 { 3136 return mMajorShaderModel; 3137 } 3138 3139 float Context::getMaximumPointSize() const 3140 { 3141 return mMaximumPointSize; 3142 } 3143 3144 unsigned int Context::getMaximumCombinedTextureImageUnits() const 3145 { 3146 return mRenderer->getMaxCombinedTextureImageUnits(); 3147 } 3148 3149 unsigned int Context::getMaximumCombinedUniformBufferBindings() const 3150 { 3151 return mRenderer->getMaxVertexShaderUniformBuffers() + 3152 mRenderer->getMaxFragmentShaderUniformBuffers(); 3153 } 3154 3155 int Context::getMaxSupportedSamples() const 3156 { 3157 return mRenderer->getMaxSupportedSamples(); 3158 } 3159 3160 GLsizei Context::getMaxSupportedFormatSamples(GLenum internalFormat) const 3161 { 3162 return mRenderer->getMaxSupportedFormatSamples(internalFormat); 3163 } 3164 3165 GLsizei Context::getNumSampleCounts(GLenum internalFormat) const 3166 { 3167 return mRenderer->getNumSampleCounts(internalFormat); 3168 } 3169 3170 void Context::getSampleCounts(GLenum internalFormat, GLsizei bufSize, GLint *params) const 3171 { 3172 mRenderer->getSampleCounts(internalFormat, bufSize, params); 3173 } 3174 3175 unsigned int Context::getMaxTransformFeedbackBufferBindings() const 3176 { 3177 return mRenderer->getMaxTransformFeedbackBuffers(); 3178 } 3179 3180 GLintptr Context::getUniformBufferOffsetAlignment() const 3181 { 3182 // setting a large alignment forces uniform buffers to bind with zero offset 3183 return static_cast<GLintptr>(std::numeric_limits<GLint>::max()); 3184 } 3185 3186 unsigned int Context::getMaximumRenderTargets() const 3187 { 3188 return mRenderer->getMaxRenderTargets(); 3189 } 3190 3191 bool Context::supportsEventQueries() const 3192 { 3193 return mSupportsEventQueries; 3194 } 3195 3196 bool Context::supportsOcclusionQueries() const 3197 { 3198 return mSupportsOcclusionQueries; 3199 } 3200 3201 bool Context::supportsBGRATextures() const 3202 { 3203 return mSupportsBGRATextures; 3204 } 3205 3206 bool Context::supportsDXT1Textures() const 3207 { 3208 return mSupportsDXT1Textures; 3209 } 3210 3211 bool Context::supportsDXT3Textures() const 3212 { 3213 return mSupportsDXT3Textures; 3214 } 3215 3216 bool Context::supportsDXT5Textures() const 3217 { 3218 return mSupportsDXT5Textures; 3219 } 3220 3221 bool Context::supportsFloat32Textures() const 3222 { 3223 return mSupportsFloat32Textures; 3224 } 3225 3226 bool Context::supportsFloat32LinearFilter() const 3227 { 3228 return mSupportsFloat32LinearFilter; 3229 } 3230 3231 bool Context::supportsFloat32RenderableTextures() const 3232 { 3233 return mSupportsFloat32RenderableTextures; 3234 } 3235 3236 bool Context::supportsFloat16Textures() const 3237 { 3238 return mSupportsFloat16Textures; 3239 } 3240 3241 bool Context::supportsFloat16LinearFilter() const 3242 { 3243 return mSupportsFloat16LinearFilter; 3244 } 3245 3246 bool Context::supportsFloat16RenderableTextures() const 3247 { 3248 return mSupportsFloat16RenderableTextures; 3249 } 3250 3251 int Context::getMaximumRenderbufferDimension() const 3252 { 3253 return mMaxRenderbufferDimension; 3254 } 3255 3256 int Context::getMaximum2DTextureDimension() const 3257 { 3258 return mMax2DTextureDimension; 3259 } 3260 3261 int Context::getMaximumCubeTextureDimension() const 3262 { 3263 return mMaxCubeTextureDimension; 3264 } 3265 3266 int Context::getMaximum3DTextureDimension() const 3267 { 3268 return mMax3DTextureDimension; 3269 } 3270 3271 int Context::getMaximum2DArrayTextureLayers() const 3272 { 3273 return mMax2DArrayTextureLayers; 3274 } 3275 3276 int Context::getMaximum2DTextureLevel() const 3277 { 3278 return mMax2DTextureLevel; 3279 } 3280 3281 int Context::getMaximumCubeTextureLevel() const 3282 { 3283 return mMaxCubeTextureLevel; 3284 } 3285 3286 int Context::getMaximum3DTextureLevel() const 3287 { 3288 return mMax3DTextureLevel; 3289 } 3290 3291 int Context::getMaximum2DArrayTextureLevel() const 3292 { 3293 return mMax2DArrayTextureLevel; 3294 } 3295 3296 bool Context::supportsLuminanceTextures() const 3297 { 3298 return mSupportsLuminanceTextures; 3299 } 3300 3301 bool Context::supportsLuminanceAlphaTextures() const 3302 { 3303 return mSupportsLuminanceAlphaTextures; 3304 } 3305 3306 bool Context::supportsRGTextures() const 3307 { 3308 return mSupportsRGTextures; 3309 } 3310 3311 bool Context::supportsDepthTextures() const 3312 { 3313 return mSupportsDepthTextures; 3314 } 3315 3316 bool Context::supports32bitIndices() const 3317 { 3318 return mSupports32bitIndices; 3319 } 3320 3321 bool Context::supportsNonPower2Texture() const 3322 { 3323 return mSupportsNonPower2Texture; 3324 } 3325 3326 bool Context::supportsInstancing() const 3327 { 3328 return mSupportsInstancing; 3329 } 3330 3331 bool Context::supportsTextureFilterAnisotropy() const 3332 { 3333 return mSupportsTextureFilterAnisotropy; 3334 } 3335 3336 bool Context::supportsPBOs() const 3337 { 3338 return mSupportsPBOs; 3339 } 3340 3341 float Context::getTextureMaxAnisotropy() const 3342 { 3343 return mMaxTextureAnisotropy; 3344 } 3345 3346 void Context::getCurrentReadFormatType(GLenum *internalFormat, GLenum *format, GLenum *type) 3347 { 3348 Framebuffer *framebuffer = getReadFramebuffer(); 3349 ASSERT(framebuffer && framebuffer->completeness() == GL_FRAMEBUFFER_COMPLETE); 3350 3351 FramebufferAttachment *attachment = framebuffer->getReadColorbuffer(); 3352 ASSERT(attachment); 3353 3354 *internalFormat = attachment->getActualFormat(); 3355 *format = gl::GetFormat(attachment->getActualFormat(), mClientVersion); 3356 *type = gl::GetType(attachment->getActualFormat(), mClientVersion); 3357 } 3358 3359 void Context::detachBuffer(GLuint buffer) 3360 { 3361 // [OpenGL ES 2.0.24] section 2.9 page 22: 3362 // If a buffer object is deleted while it is bound, all bindings to that object in the current context 3363 // (i.e. in the thread that called Delete-Buffers) are reset to zero. 3364 3365 if (mState.arrayBuffer.id() == buffer) 3366 { 3367 mState.arrayBuffer.set(NULL); 3368 } 3369 3370 // mark as freed among the vertex array objects 3371 for (auto vaoIt = mVertexArrayMap.begin(); vaoIt != mVertexArrayMap.end(); vaoIt++) 3372 { 3373 vaoIt->second->detachBuffer(buffer); 3374 } 3375 } 3376 3377 void Context::detachTexture(GLuint texture) 3378 { 3379 // [OpenGL ES 2.0.24] section 3.8 page 84: 3380 // If a texture object is deleted, it is as if all texture units which are bound to that texture object are 3381 // rebound to texture object zero 3382 3383 for (int type = 0; type < TEXTURE_TYPE_COUNT; type++) 3384 { 3385 for (int sampler = 0; sampler < IMPLEMENTATION_MAX_COMBINED_TEXTURE_IMAGE_UNITS; sampler++) 3386 { 3387 if (mState.samplerTexture[type][sampler].id() == texture) 3388 { 3389 mState.samplerTexture[type][sampler].set(NULL); 3390 } 3391 } 3392 } 3393 3394 // [OpenGL ES 2.0.24] section 4.4 page 112: 3395 // If a texture object is deleted while its image is attached to the currently bound framebuffer, then it is 3396 // as if Texture2DAttachment had been called, with a texture of 0, for each attachment point to which this 3397 // image was attached in the currently bound framebuffer. 3398 3399 Framebuffer *readFramebuffer = getReadFramebuffer(); 3400 Framebuffer *drawFramebuffer = getDrawFramebuffer(); 3401 3402 if (readFramebuffer) 3403 { 3404 readFramebuffer->detachTexture(texture); 3405 } 3406 3407 if (drawFramebuffer && drawFramebuffer != readFramebuffer) 3408 { 3409 drawFramebuffer->detachTexture(texture); 3410 } 3411 } 3412 3413 void Context::detachFramebuffer(GLuint framebuffer) 3414 { 3415 // [OpenGL ES 2.0.24] section 4.4 page 107: 3416 // If a framebuffer that is currently bound to the target FRAMEBUFFER is deleted, it is as though 3417 // BindFramebuffer had been executed with the target of FRAMEBUFFER and framebuffer of zero. 3418 3419 if (mState.readFramebuffer == framebuffer) 3420 { 3421 bindReadFramebuffer(0); 3422 } 3423 3424 if (mState.drawFramebuffer == framebuffer) 3425 { 3426 bindDrawFramebuffer(0); 3427 } 3428 } 3429 3430 void Context::detachRenderbuffer(GLuint renderbuffer) 3431 { 3432 // [OpenGL ES 2.0.24] section 4.4 page 109: 3433 // If a renderbuffer that is currently bound to RENDERBUFFER is deleted, it is as though BindRenderbuffer 3434 // had been executed with the target RENDERBUFFER and name of zero. 3435 3436 if (mState.renderbuffer.id() == renderbuffer) 3437 { 3438 bindRenderbuffer(0); 3439 } 3440 3441 // [OpenGL ES 2.0.24] section 4.4 page 111: 3442 // If a renderbuffer object is deleted while its image is attached to the currently bound framebuffer, 3443 // then it is as if FramebufferRenderbuffer had been called, with a renderbuffer of 0, for each attachment 3444 // point to which this image was attached in the currently bound framebuffer. 3445 3446 Framebuffer *readFramebuffer = getReadFramebuffer(); 3447 Framebuffer *drawFramebuffer = getDrawFramebuffer(); 3448 3449 if (readFramebuffer) 3450 { 3451 readFramebuffer->detachRenderbuffer(renderbuffer); 3452 } 3453 3454 if (drawFramebuffer && drawFramebuffer != readFramebuffer) 3455 { 3456 drawFramebuffer->detachRenderbuffer(renderbuffer); 3457 } 3458 } 3459 3460 void Context::detachVertexArray(GLuint vertexArray) 3461 { 3462 // [OpenGL ES 3.0.2] section 2.10 page 43: 3463 // If a vertex array object that is currently bound is deleted, the binding 3464 // for that object reverts to zero and the default vertex array becomes current. 3465 if (mState.vertexArray == vertexArray) 3466 { 3467 bindVertexArray(0); 3468 } 3469 } 3470 3471 void Context::detachTransformFeedback(GLuint transformFeedback) 3472 { 3473 if (mState.transformFeedback.id() == transformFeedback) 3474 { 3475 bindTransformFeedback(0); 3476 } 3477 } 3478 3479 void Context::detachSampler(GLuint sampler) 3480 { 3481 // [OpenGL ES 3.0.2] section 3.8.2 pages 123-124: 3482 // If a sampler object that is currently bound to one or more texture units is 3483 // deleted, it is as though BindSampler is called once for each texture unit to 3484 // which the sampler is bound, with unit set to the texture unit and sampler set to zero. 3485 for (unsigned int textureUnit = 0; textureUnit < ArraySize(mState.samplers); textureUnit++) 3486 { 3487 if (mState.samplers[textureUnit] == sampler) 3488 { 3489 mState.samplers[textureUnit] = 0; 3490 } 3491 } 3492 } 3493 3494 Texture *Context::getIncompleteTexture(TextureType type) 3495 { 3496 Texture *t = mIncompleteTextures[type].get(); 3497 3498 if (t == NULL) 3499 { 3500 const GLubyte color[] = { 0, 0, 0, 255 }; 3501 const PixelUnpackState incompleteUnpackState(1); 3502 3503 switch (type) 3504 { 3505 default: 3506 UNREACHABLE(); 3507 // default falls through to TEXTURE_2D 3508 3509 case TEXTURE_2D: 3510 { 3511 Texture2D *incomplete2d = new Texture2D(mRenderer, Texture::INCOMPLETE_TEXTURE_ID); 3512 incomplete2d->setImage(0, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color); 3513 t = incomplete2d; 3514 } 3515 break; 3516 3517 case TEXTURE_CUBE: 3518 { 3519 TextureCubeMap *incompleteCube = new TextureCubeMap(mRenderer, Texture::INCOMPLETE_TEXTURE_ID); 3520 3521 incompleteCube->setImagePosX(0, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color); 3522 incompleteCube->setImageNegX(0, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color); 3523 incompleteCube->setImagePosY(0, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color); 3524 incompleteCube->setImageNegY(0, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color); 3525 incompleteCube->setImagePosZ(0, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color); 3526 incompleteCube->setImageNegZ(0, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color); 3527 3528 t = incompleteCube; 3529 } 3530 break; 3531 3532 case TEXTURE_3D: 3533 { 3534 Texture3D *incomplete3d = new Texture3D(mRenderer, Texture::INCOMPLETE_TEXTURE_ID); 3535 incomplete3d->setImage(0, 1, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color); 3536 3537 t = incomplete3d; 3538 } 3539 break; 3540 3541 case TEXTURE_2D_ARRAY: 3542 { 3543 Texture2DArray *incomplete2darray = new Texture2DArray(mRenderer, Texture::INCOMPLETE_TEXTURE_ID); 3544 incomplete2darray->setImage(0, 1, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color); 3545 3546 t = incomplete2darray; 3547 } 3548 break; 3549 } 3550 3551 mIncompleteTextures[type].set(t); 3552 } 3553 3554 return t; 3555 } 3556 3557 bool Context::skipDraw(GLenum drawMode) 3558 { 3559 if (drawMode == GL_POINTS) 3560 { 3561 // ProgramBinary assumes non-point rendering if gl_PointSize isn't written, 3562 // which affects varying interpolation. Since the value of gl_PointSize is 3563 // undefined when not written, just skip drawing to avoid unexpected results. 3564 if (!getCurrentProgramBinary()->usesPointSize()) 3565 { 3566 // This is stictly speaking not an error, but developers should be 3567 // notified of risking undefined behavior. 3568 ERR("Point rendering without writing to gl_PointSize."); 3569 3570 return true; 3571 } 3572 } 3573 else if (IsTriangleMode(drawMode)) 3574 { 3575 if (mState.rasterizer.cullFace && mState.rasterizer.cullMode == GL_FRONT_AND_BACK) 3576 { 3577 return true; 3578 } 3579 } 3580 3581 return false; 3582 } 3583 3584 void Context::setVertexAttribf(GLuint index, const GLfloat values[4]) 3585 { 3586 ASSERT(index < gl::MAX_VERTEX_ATTRIBS); 3587 mState.vertexAttribCurrentValues[index].setFloatValues(values); 3588 } 3589 3590 void Context::setVertexAttribu(GLuint index, const GLuint values[4]) 3591 { 3592 ASSERT(index < gl::MAX_VERTEX_ATTRIBS); 3593 mState.vertexAttribCurrentValues[index].setUnsignedIntValues(values); 3594 } 3595 3596 void Context::setVertexAttribi(GLuint index, const GLint values[4]) 3597 { 3598 ASSERT(index < gl::MAX_VERTEX_ATTRIBS); 3599 mState.vertexAttribCurrentValues[index].setIntValues(values); 3600 } 3601 3602 void Context::setVertexAttribDivisor(GLuint index, GLuint divisor) 3603 { 3604 getCurrentVertexArray()->setVertexAttribDivisor(index, divisor); 3605 } 3606 3607 void Context::samplerParameteri(GLuint sampler, GLenum pname, GLint param) 3608 { 3609 mResourceManager->checkSamplerAllocation(sampler); 3610 3611 Sampler *samplerObject = getSampler(sampler); 3612 ASSERT(samplerObject); 3613 3614 switch (pname) 3615 { 3616 case GL_TEXTURE_MIN_FILTER: samplerObject->setMinFilter(static_cast<GLenum>(param)); break; 3617 case GL_TEXTURE_MAG_FILTER: samplerObject->setMagFilter(static_cast<GLenum>(param)); break; 3618 case GL_TEXTURE_WRAP_S: samplerObject->setWrapS(static_cast<GLenum>(param)); break; 3619 case GL_TEXTURE_WRAP_T: samplerObject->setWrapT(static_cast<GLenum>(param)); break; 3620 case GL_TEXTURE_WRAP_R: samplerObject->setWrapR(static_cast<GLenum>(param)); break; 3621 case GL_TEXTURE_MIN_LOD: samplerObject->setMinLod(static_cast<GLfloat>(param)); break; 3622 case GL_TEXTURE_MAX_LOD: samplerObject->setMaxLod(static_cast<GLfloat>(param)); break; 3623 case GL_TEXTURE_COMPARE_MODE: samplerObject->setComparisonMode(static_cast<GLenum>(param)); break; 3624 case GL_TEXTURE_COMPARE_FUNC: samplerObject->setComparisonFunc(static_cast<GLenum>(param)); break; 3625 default: UNREACHABLE(); break; 3626 } 3627 } 3628 3629 void Context::samplerParameterf(GLuint sampler, GLenum pname, GLfloat param) 3630 { 3631 mResourceManager->checkSamplerAllocation(sampler); 3632 3633 Sampler *samplerObject = getSampler(sampler); 3634 ASSERT(samplerObject); 3635 3636 switch (pname) 3637 { 3638 case GL_TEXTURE_MIN_FILTER: samplerObject->setMinFilter(uiround<GLenum>(param)); break; 3639 case GL_TEXTURE_MAG_FILTER: samplerObject->setMagFilter(uiround<GLenum>(param)); break; 3640 case GL_TEXTURE_WRAP_S: samplerObject->setWrapS(uiround<GLenum>(param)); break; 3641 case GL_TEXTURE_WRAP_T: samplerObject->setWrapT(uiround<GLenum>(param)); break; 3642 case GL_TEXTURE_WRAP_R: samplerObject->setWrapR(uiround<GLenum>(param)); break; 3643 case GL_TEXTURE_MIN_LOD: samplerObject->setMinLod(param); break; 3644 case GL_TEXTURE_MAX_LOD: samplerObject->setMaxLod(param); break; 3645 case GL_TEXTURE_COMPARE_MODE: samplerObject->setComparisonMode(uiround<GLenum>(param)); break; 3646 case GL_TEXTURE_COMPARE_FUNC: samplerObject->setComparisonFunc(uiround<GLenum>(param)); break; 3647 default: UNREACHABLE(); break; 3648 } 3649 } 3650 3651 GLint Context::getSamplerParameteri(GLuint sampler, GLenum pname) 3652 { 3653 mResourceManager->checkSamplerAllocation(sampler); 3654 3655 Sampler *samplerObject = getSampler(sampler); 3656 ASSERT(samplerObject); 3657 3658 switch (pname) 3659 { 3660 case GL_TEXTURE_MIN_FILTER: return static_cast<GLint>(samplerObject->getMinFilter()); 3661 case GL_TEXTURE_MAG_FILTER: return static_cast<GLint>(samplerObject->getMagFilter()); 3662 case GL_TEXTURE_WRAP_S: return static_cast<GLint>(samplerObject->getWrapS()); 3663 case GL_TEXTURE_WRAP_T: return static_cast<GLint>(samplerObject->getWrapT()); 3664 case GL_TEXTURE_WRAP_R: return static_cast<GLint>(samplerObject->getWrapR()); 3665 case GL_TEXTURE_MIN_LOD: return uiround<GLint>(samplerObject->getMinLod()); 3666 case GL_TEXTURE_MAX_LOD: return uiround<GLint>(samplerObject->getMaxLod()); 3667 case GL_TEXTURE_COMPARE_MODE: return static_cast<GLint>(samplerObject->getComparisonMode()); 3668 case GL_TEXTURE_COMPARE_FUNC: return static_cast<GLint>(samplerObject->getComparisonFunc()); 3669 default: UNREACHABLE(); return 0; 3670 } 3671 } 3672 3673 GLfloat Context::getSamplerParameterf(GLuint sampler, GLenum pname) 3674 { 3675 mResourceManager->checkSamplerAllocation(sampler); 3676 3677 Sampler *samplerObject = getSampler(sampler); 3678 ASSERT(samplerObject); 3679 3680 switch (pname) 3681 { 3682 case GL_TEXTURE_MIN_FILTER: return static_cast<GLfloat>(samplerObject->getMinFilter()); 3683 case GL_TEXTURE_MAG_FILTER: return static_cast<GLfloat>(samplerObject->getMagFilter()); 3684 case GL_TEXTURE_WRAP_S: return static_cast<GLfloat>(samplerObject->getWrapS()); 3685 case GL_TEXTURE_WRAP_T: return static_cast<GLfloat>(samplerObject->getWrapT()); 3686 case GL_TEXTURE_WRAP_R: return static_cast<GLfloat>(samplerObject->getWrapR()); 3687 case GL_TEXTURE_MIN_LOD: return samplerObject->getMinLod(); 3688 case GL_TEXTURE_MAX_LOD: return samplerObject->getMaxLod(); 3689 case GL_TEXTURE_COMPARE_MODE: return static_cast<GLfloat>(samplerObject->getComparisonMode()); 3690 case GL_TEXTURE_COMPARE_FUNC: return static_cast<GLfloat>(samplerObject->getComparisonFunc()); 3691 default: UNREACHABLE(); return 0; 3692 } 3693 } 3694 3695 // keep list sorted in following order 3696 // OES extensions 3697 // EXT extensions 3698 // Vendor extensions 3699 void Context::initExtensionString() 3700 { 3701 // Do not report extension in GLES 3 contexts for now 3702 if (mClientVersion == 2) 3703 { 3704 // OES extensions 3705 if (supports32bitIndices()) 3706 { 3707 mExtensionStringList.push_back("GL_OES_element_index_uint"); 3708 } 3709 3710 mExtensionStringList.push_back("GL_OES_packed_depth_stencil"); 3711 mExtensionStringList.push_back("GL_OES_get_program_binary"); 3712 mExtensionStringList.push_back("GL_OES_rgb8_rgba8"); 3713 3714 if (supportsPBOs()) 3715 { 3716 mExtensionStringList.push_back("NV_pixel_buffer_object"); 3717 mExtensionStringList.push_back("GL_OES_mapbuffer"); 3718 mExtensionStringList.push_back("GL_EXT_map_buffer_range"); 3719 } 3720 3721 if (mRenderer->getDerivativeInstructionSupport()) 3722 { 3723 mExtensionStringList.push_back("GL_OES_standard_derivatives"); 3724 } 3725 3726 if (supportsFloat16Textures()) 3727 { 3728 mExtensionStringList.push_back("GL_OES_texture_half_float"); 3729 } 3730 if (supportsFloat16LinearFilter()) 3731 { 3732 mExtensionStringList.push_back("GL_OES_texture_half_float_linear"); 3733 } 3734 if (supportsFloat32Textures()) 3735 { 3736 mExtensionStringList.push_back("GL_OES_texture_float"); 3737 } 3738 if (supportsFloat32LinearFilter()) 3739 { 3740 mExtensionStringList.push_back("GL_OES_texture_float_linear"); 3741 } 3742 3743 if (supportsRGTextures()) 3744 { 3745 mExtensionStringList.push_back("GL_EXT_texture_rg"); 3746 } 3747 3748 if (supportsNonPower2Texture()) 3749 { 3750 mExtensionStringList.push_back("GL_OES_texture_npot"); 3751 } 3752 3753 // Multi-vendor (EXT) extensions 3754 if (supportsOcclusionQueries()) 3755 { 3756 mExtensionStringList.push_back("GL_EXT_occlusion_query_boolean"); 3757 } 3758 3759 mExtensionStringList.push_back("GL_EXT_read_format_bgra"); 3760 mExtensionStringList.push_back("GL_EXT_robustness"); 3761 mExtensionStringList.push_back("GL_EXT_shader_texture_lod"); 3762 3763 if (supportsDXT1Textures()) 3764 { 3765 mExtensionStringList.push_back("GL_EXT_texture_compression_dxt1"); 3766 } 3767 3768 if (supportsTextureFilterAnisotropy()) 3769 { 3770 mExtensionStringList.push_back("GL_EXT_texture_filter_anisotropic"); 3771 } 3772 3773 if (supportsBGRATextures()) 3774 { 3775 mExtensionStringList.push_back("GL_EXT_texture_format_BGRA8888"); 3776 } 3777 3778 if (mRenderer->getMaxRenderTargets() > 1) 3779 { 3780 mExtensionStringList.push_back("GL_EXT_draw_buffers"); 3781 } 3782 3783 mExtensionStringList.push_back("GL_EXT_texture_storage"); 3784 mExtensionStringList.push_back("GL_EXT_frag_depth"); 3785 mExtensionStringList.push_back("GL_EXT_blend_minmax"); 3786 3787 // ANGLE-specific extensions 3788 if (supportsDepthTextures()) 3789 { 3790 mExtensionStringList.push_back("GL_ANGLE_depth_texture"); 3791 } 3792 3793 mExtensionStringList.push_back("GL_ANGLE_framebuffer_blit"); 3794 if (getMaxSupportedSamples() != 0) 3795 { 3796 mExtensionStringList.push_back("GL_ANGLE_framebuffer_multisample"); 3797 } 3798 3799 if (supportsInstancing()) 3800 { 3801 mExtensionStringList.push_back("GL_ANGLE_instanced_arrays"); 3802 } 3803 3804 mExtensionStringList.push_back("GL_ANGLE_pack_reverse_row_order"); 3805 3806 if (supportsDXT3Textures()) 3807 { 3808 mExtensionStringList.push_back("GL_ANGLE_texture_compression_dxt3"); 3809 } 3810 if (supportsDXT5Textures()) 3811 { 3812 mExtensionStringList.push_back("GL_ANGLE_texture_compression_dxt5"); 3813 } 3814 3815 mExtensionStringList.push_back("GL_ANGLE_texture_usage"); 3816 mExtensionStringList.push_back("GL_ANGLE_translated_shader_source"); 3817 3818 // Other vendor-specific extensions 3819 if (supportsEventQueries()) 3820 { 3821 mExtensionStringList.push_back("GL_NV_fence"); 3822 } 3823 } 3824 3825 if (mClientVersion == 3) 3826 { 3827 mExtensionStringList.push_back("GL_EXT_color_buffer_float"); 3828 3829 mExtensionStringList.push_back("GL_EXT_read_format_bgra"); 3830 3831 if (supportsBGRATextures()) 3832 { 3833 mExtensionStringList.push_back("GL_EXT_texture_format_BGRA8888"); 3834 } 3835 } 3836 3837 // Join the extension strings to one long string for use with GetString 3838 std::stringstream strstr; 3839 for (unsigned int extensionIndex = 0; extensionIndex < mExtensionStringList.size(); extensionIndex++) 3840 { 3841 strstr << mExtensionStringList[extensionIndex]; 3842 strstr << " "; 3843 } 3844 3845 mCombinedExtensionsString = makeStaticString(strstr.str()); 3846 } 3847 3848 const char *Context::getCombinedExtensionsString() const 3849 { 3850 return mCombinedExtensionsString; 3851 } 3852 3853 const char *Context::getExtensionString(const GLuint index) const 3854 { 3855 ASSERT(index < mExtensionStringList.size()); 3856 return mExtensionStringList[index].c_str(); 3857 } 3858 3859 unsigned int Context::getNumExtensions() const 3860 { 3861 return mExtensionStringList.size(); 3862 } 3863 3864 void Context::initRendererString() 3865 { 3866 std::ostringstream rendererString; 3867 rendererString << "ANGLE ("; 3868 rendererString << mRenderer->getRendererDescription(); 3869 rendererString << ")"; 3870 3871 mRendererString = makeStaticString(rendererString.str()); 3872 } 3873 3874 const char *Context::getRendererString() const 3875 { 3876 return mRendererString; 3877 } 3878 3879 size_t Context::getBoundFramebufferTextureSerials(FramebufferTextureSerialArray *outSerialArray) 3880 { 3881 size_t serialCount = 0; 3882 3883 Framebuffer *drawFramebuffer = getDrawFramebuffer(); 3884 for (unsigned int i = 0; i < IMPLEMENTATION_MAX_DRAW_BUFFERS; i++) 3885 { 3886 FramebufferAttachment *attachment = drawFramebuffer->getColorbuffer(i); 3887 if (attachment && attachment->isTexture()) 3888 { 3889 (*outSerialArray)[serialCount++] = attachment->getTextureSerial(); 3890 } 3891 } 3892 3893 FramebufferAttachment *depthStencilAttachment = drawFramebuffer->getDepthOrStencilbuffer(); 3894 if (depthStencilAttachment && depthStencilAttachment->isTexture()) 3895 { 3896 (*outSerialArray)[serialCount++] = depthStencilAttachment->getTextureSerial(); 3897 } 3898 3899 std::sort(outSerialArray->begin(), outSerialArray->begin() + serialCount); 3900 3901 return serialCount; 3902 } 3903 3904 void Context::blitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, 3905 GLbitfield mask, GLenum filter) 3906 { 3907 Framebuffer *readFramebuffer = getReadFramebuffer(); 3908 Framebuffer *drawFramebuffer = getDrawFramebuffer(); 3909 3910 bool blitRenderTarget = false; 3911 bool blitDepth = false; 3912 bool blitStencil = false; 3913 if ((mask & GL_COLOR_BUFFER_BIT) && readFramebuffer->getReadColorbuffer() && drawFramebuffer->getFirstColorbuffer()) 3914 { 3915 blitRenderTarget = true; 3916 } 3917 if ((mask & GL_STENCIL_BUFFER_BIT) && readFramebuffer->getStencilbuffer() && drawFramebuffer->getStencilbuffer()) 3918 { 3919 blitStencil = true; 3920 } 3921 if ((mask & GL_DEPTH_BUFFER_BIT) && readFramebuffer->getDepthbuffer() && drawFramebuffer->getDepthbuffer()) 3922 { 3923 blitDepth = true; 3924 } 3925 3926 gl::Rectangle srcRect(srcX0, srcY0, srcX1 - srcX0, srcY1 - srcY0); 3927 gl::Rectangle dstRect(dstX0, dstY0, dstX1 - dstX0, dstY1 - dstY0); 3928 if (blitRenderTarget || blitDepth || blitStencil) 3929 { 3930 const gl::Rectangle *scissor = mState.scissorTest ? &mState.scissor : NULL; 3931 mRenderer->blitRect(readFramebuffer, srcRect, drawFramebuffer, dstRect, scissor, 3932 blitRenderTarget, blitDepth, blitStencil, filter); 3933 } 3934 } 3935 3936 void Context::invalidateFrameBuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, 3937 GLint x, GLint y, GLsizei width, GLsizei height) 3938 { 3939 Framebuffer *frameBuffer = NULL; 3940 switch (target) 3941 { 3942 case GL_FRAMEBUFFER: 3943 case GL_DRAW_FRAMEBUFFER: 3944 frameBuffer = getDrawFramebuffer(); 3945 break; 3946 case GL_READ_FRAMEBUFFER: 3947 frameBuffer = getReadFramebuffer(); 3948 break; 3949 default: 3950 UNREACHABLE(); 3951 } 3952 3953 if (frameBuffer && frameBuffer->completeness() == GL_FRAMEBUFFER_COMPLETE) 3954 { 3955 for (int i = 0; i < numAttachments; ++i) 3956 { 3957 rx::RenderTarget *renderTarget = NULL; 3958 3959 if (attachments[i] >= GL_COLOR_ATTACHMENT0 && attachments[i] <= GL_COLOR_ATTACHMENT15) 3960 { 3961 gl::FramebufferAttachment *attachment = frameBuffer->getColorbuffer(attachments[i] - GL_COLOR_ATTACHMENT0); 3962 if (attachment) 3963 { 3964 renderTarget = attachment->getRenderTarget(); 3965 } 3966 } 3967 else if (attachments[i] == GL_COLOR) 3968 { 3969 gl::FramebufferAttachment *attachment = frameBuffer->getColorbuffer(0); 3970 if (attachment) 3971 { 3972 renderTarget = attachment->getRenderTarget(); 3973 } 3974 } 3975 else 3976 { 3977 gl::FramebufferAttachment *attachment = NULL; 3978 switch (attachments[i]) 3979 { 3980 case GL_DEPTH_ATTACHMENT: 3981 case GL_DEPTH: 3982 attachment = frameBuffer->getDepthbuffer(); 3983 break; 3984 case GL_STENCIL_ATTACHMENT: 3985 case GL_STENCIL: 3986 attachment = frameBuffer->getStencilbuffer(); 3987 break; 3988 case GL_DEPTH_STENCIL_ATTACHMENT: 3989 attachment = frameBuffer->getDepthOrStencilbuffer(); 3990 break; 3991 default: 3992 UNREACHABLE(); 3993 } 3994 3995 if (attachment) 3996 { 3997 renderTarget = attachment->getDepthStencil(); 3998 } 3999 } 4000 4001 if (renderTarget) 4002 { 4003 renderTarget->invalidate(x, y, width, height); 4004 } 4005 } 4006 } 4007 } 4008 4009 bool Context::hasMappedBuffer(GLenum target) const 4010 { 4011 if (target == GL_ARRAY_BUFFER) 4012 { 4013 for (unsigned int attribIndex = 0; attribIndex < gl::MAX_VERTEX_ATTRIBS; attribIndex++) 4014 { 4015 const gl::VertexAttribute &vertexAttrib = getVertexAttribState(attribIndex); 4016 gl::Buffer *boundBuffer = vertexAttrib.mBoundBuffer.get(); 4017 if (vertexAttrib.mArrayEnabled && boundBuffer && boundBuffer->mapped()) 4018 { 4019 return true; 4020 } 4021 } 4022 } 4023 else if (target == GL_ELEMENT_ARRAY_BUFFER) 4024 { 4025 Buffer *elementBuffer = getElementArrayBuffer(); 4026 return (elementBuffer && elementBuffer->mapped()); 4027 } 4028 else if (target == GL_TRANSFORM_FEEDBACK_BUFFER) 4029 { 4030 UNIMPLEMENTED(); 4031 } 4032 else UNREACHABLE(); 4033 return false; 4034 } 4035 4036 } 4037 4038 extern "C" 4039 { 4040 gl::Context *glCreateContext(int clientVersion, const gl::Context *shareContext, rx::Renderer *renderer, bool notifyResets, bool robustAccess) 4041 { 4042 return new gl::Context(clientVersion, shareContext, renderer, notifyResets, robustAccess); 4043 } 4044 4045 void glDestroyContext(gl::Context *context) 4046 { 4047 delete context; 4048 4049 if (context == gl::getContext()) 4050 { 4051 gl::makeCurrent(NULL, NULL, NULL); 4052 } 4053 } 4054 4055 void glMakeCurrent(gl::Context *context, egl::Display *display, egl::Surface *surface) 4056 { 4057 gl::makeCurrent(context, display, surface); 4058 } 4059 4060 gl::Context *glGetCurrentContext() 4061 { 4062 return gl::getContext(); 4063 } 4064 4065 } 4066
