| // |
| // Copyright 2015 The ANGLE Project Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // |
| |
| // ProgramGL.cpp: Implements the class methods for ProgramGL. |
| |
| #include "libANGLE/renderer/gl/ProgramGL.h" |
| |
| #include "common/WorkerThread.h" |
| #include "common/angleutils.h" |
| #include "common/bitset_utils.h" |
| #include "common/debug.h" |
| #include "common/string_utils.h" |
| #include "common/utilities.h" |
| #include "libANGLE/Context.h" |
| #include "libANGLE/ProgramLinkedResources.h" |
| #include "libANGLE/Uniform.h" |
| #include "libANGLE/queryconversions.h" |
| #include "libANGLE/renderer/gl/ContextGL.h" |
| #include "libANGLE/renderer/gl/FunctionsGL.h" |
| #include "libANGLE/renderer/gl/RendererGL.h" |
| #include "libANGLE/renderer/gl/ShaderGL.h" |
| #include "libANGLE/renderer/gl/StateManagerGL.h" |
| #include "libANGLE/trace.h" |
| #include "platform/PlatformMethods.h" |
| #include "platform/autogen/FeaturesGL_autogen.h" |
| |
| namespace rx |
| { |
| namespace |
| { |
| |
| // Returns mapped name of a transform feedback varying. The original name may contain array |
| // brackets with an index inside, which will get copied to the mapped name. The varying must be |
| // known to be declared in the shader. |
| std::string GetTransformFeedbackVaryingMappedName(const gl::SharedCompiledShaderState &shaderState, |
| const std::string &tfVaryingName) |
| { |
| ASSERT(shaderState->shaderType != gl::ShaderType::Fragment && |
| shaderState->shaderType != gl::ShaderType::Compute); |
| const auto &varyings = shaderState->outputVaryings; |
| auto bracketPos = tfVaryingName.find("["); |
| if (bracketPos != std::string::npos) |
| { |
| auto tfVaryingBaseName = tfVaryingName.substr(0, bracketPos); |
| for (const auto &varying : varyings) |
| { |
| if (varying.name == tfVaryingBaseName) |
| { |
| std::string mappedNameWithArrayIndex = |
| varying.mappedName + tfVaryingName.substr(bracketPos); |
| return mappedNameWithArrayIndex; |
| } |
| } |
| } |
| else |
| { |
| for (const auto &varying : varyings) |
| { |
| if (varying.name == tfVaryingName) |
| { |
| return varying.mappedName; |
| } |
| else if (varying.isStruct()) |
| { |
| GLuint fieldIndex = 0; |
| const auto *field = varying.findField(tfVaryingName, &fieldIndex); |
| if (field == nullptr) |
| { |
| continue; |
| } |
| ASSERT(field != nullptr && !field->isStruct() && |
| (!field->isArray() || varying.isShaderIOBlock)); |
| std::string mappedName; |
| // If it's an I/O block without an instance name, don't include the block name. |
| if (!varying.isShaderIOBlock || !varying.name.empty()) |
| { |
| mappedName = varying.isShaderIOBlock ? varying.mappedStructOrBlockName |
| : varying.mappedName; |
| mappedName += '.'; |
| } |
| return mappedName + field->mappedName; |
| } |
| } |
| } |
| UNREACHABLE(); |
| return std::string(); |
| } |
| |
| } // anonymous namespace |
| |
| ProgramGL::ProgramGL(const gl::ProgramState &data, |
| const FunctionsGL *functions, |
| const angle::FeaturesGL &features, |
| StateManagerGL *stateManager, |
| const std::shared_ptr<RendererGL> &renderer) |
| : ProgramImpl(data), |
| mFunctions(functions), |
| mFeatures(features), |
| mStateManager(stateManager), |
| mHasAppliedTransformFeedbackVaryings(false), |
| mClipDistanceEnabledUniformLocation(-1), |
| mMultiviewBaseViewLayerIndexUniformLocation(-1), |
| mProgramID(0), |
| mRenderer(renderer), |
| mLinkedInParallel(false) |
| { |
| ASSERT(mFunctions); |
| ASSERT(mStateManager); |
| |
| mProgramID = mFunctions->createProgram(); |
| } |
| |
| ProgramGL::~ProgramGL() |
| { |
| mFunctions->deleteProgram(mProgramID); |
| mProgramID = 0; |
| } |
| |
| std::unique_ptr<LinkEvent> ProgramGL::load(const gl::Context *context, |
| gl::BinaryInputStream *stream, |
| gl::InfoLog &infoLog) |
| { |
| ANGLE_TRACE_EVENT0("gpu.angle", "ProgramGL::load"); |
| preLink(); |
| |
| // Read the binary format, size and blob |
| GLenum binaryFormat = stream->readInt<GLenum>(); |
| GLint binaryLength = stream->readInt<GLint>(); |
| const uint8_t *binary = stream->data() + stream->offset(); |
| stream->skip(binaryLength); |
| |
| // Load the binary |
| mFunctions->programBinary(mProgramID, binaryFormat, binary, binaryLength); |
| |
| // Verify that the program linked |
| if (!checkLinkStatus(infoLog)) |
| { |
| return std::make_unique<LinkEventDone>(angle::Result::Incomplete); |
| } |
| |
| postLink(); |
| reapplyUBOBindingsIfNeeded(context); |
| |
| return std::make_unique<LinkEventDone>(angle::Result::Continue); |
| } |
| |
| void ProgramGL::save(const gl::Context *context, gl::BinaryOutputStream *stream) |
| { |
| GLint binaryLength = 0; |
| mFunctions->getProgramiv(mProgramID, GL_PROGRAM_BINARY_LENGTH, &binaryLength); |
| |
| std::vector<uint8_t> binary(std::max(binaryLength, 1)); |
| GLenum binaryFormat = GL_NONE; |
| mFunctions->getProgramBinary(mProgramID, binaryLength, &binaryLength, &binaryFormat, |
| binary.data()); |
| |
| stream->writeInt(binaryFormat); |
| stream->writeInt(binaryLength); |
| stream->writeBytes(binary.data(), binaryLength); |
| |
| reapplyUBOBindingsIfNeeded(context); |
| } |
| |
| void ProgramGL::reapplyUBOBindingsIfNeeded(const gl::Context *context) |
| { |
| // Re-apply UBO bindings to work around driver bugs. |
| const angle::FeaturesGL &features = GetImplAs<ContextGL>(context)->getFeaturesGL(); |
| if (features.reapplyUBOBindingsAfterUsingBinaryProgram.enabled) |
| { |
| const auto &blocks = mState.getUniformBlocks(); |
| for (size_t blockIndex : mState.getActiveUniformBlockBindingsMask()) |
| { |
| setUniformBlockBinding(static_cast<GLuint>(blockIndex), blocks[blockIndex].binding); |
| } |
| } |
| } |
| |
| void ProgramGL::setBinaryRetrievableHint(bool retrievable) |
| { |
| // glProgramParameteri isn't always available on ES backends. |
| if (mFunctions->programParameteri) |
| { |
| mFunctions->programParameteri(mProgramID, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, |
| retrievable ? GL_TRUE : GL_FALSE); |
| } |
| } |
| |
| void ProgramGL::setSeparable(bool separable) |
| { |
| mFunctions->programParameteri(mProgramID, GL_PROGRAM_SEPARABLE, separable ? GL_TRUE : GL_FALSE); |
| } |
| |
| using LinkImplFunctor = std::function<bool(std::string &)>; |
| class ProgramGL::LinkTask final : public angle::Closure |
| { |
| public: |
| LinkTask(LinkImplFunctor &&functor) : mLinkImplFunctor(functor), mFallbackToMainContext(false) |
| {} |
| |
| void operator()() override |
| { |
| ANGLE_TRACE_EVENT0("gpu.angle", "ProgramGL::LinkTask::run"); |
| mFallbackToMainContext = mLinkImplFunctor(mInfoLog); |
| } |
| |
| bool fallbackToMainContext() { return mFallbackToMainContext; } |
| const std::string &getInfoLog() { return mInfoLog; } |
| |
| private: |
| LinkImplFunctor mLinkImplFunctor; |
| bool mFallbackToMainContext; |
| std::string mInfoLog; |
| }; |
| |
| using PostLinkImplFunctor = std::function<angle::Result(bool, const std::string &)>; |
| |
| // The event for a parallelized linking using the native driver extension. |
| class ProgramGL::LinkEventNativeParallel final : public LinkEvent |
| { |
| public: |
| LinkEventNativeParallel(PostLinkImplFunctor &&functor, |
| const FunctionsGL *functions, |
| GLuint programID) |
| : mPostLinkImplFunctor(functor), mFunctions(functions), mProgramID(programID) |
| {} |
| |
| angle::Result wait(const gl::Context *context) override |
| { |
| ANGLE_TRACE_EVENT0("gpu.angle", "ProgramGL::LinkEventNativeParallel::wait"); |
| |
| GLint linkStatus = GL_FALSE; |
| mFunctions->getProgramiv(mProgramID, GL_LINK_STATUS, &linkStatus); |
| if (linkStatus == GL_TRUE) |
| { |
| return mPostLinkImplFunctor(false, std::string()); |
| } |
| return angle::Result::Incomplete; |
| } |
| |
| bool isLinking() override |
| { |
| GLint completionStatus = GL_FALSE; |
| mFunctions->getProgramiv(mProgramID, GL_COMPLETION_STATUS, &completionStatus); |
| return completionStatus == GL_FALSE; |
| } |
| |
| private: |
| PostLinkImplFunctor mPostLinkImplFunctor; |
| const FunctionsGL *mFunctions; |
| GLuint mProgramID; |
| }; |
| |
| // The event for a parallelized linking using the worker thread pool. |
| class ProgramGL::LinkEventGL final : public LinkEvent |
| { |
| public: |
| LinkEventGL(std::shared_ptr<angle::WorkerThreadPool> workerPool, |
| std::shared_ptr<ProgramGL::LinkTask> linkTask, |
| PostLinkImplFunctor &&functor) |
| : mLinkTask(linkTask), |
| mWaitableEvent( |
| std::shared_ptr<angle::WaitableEvent>(workerPool->postWorkerTask(mLinkTask))), |
| mPostLinkImplFunctor(functor) |
| {} |
| |
| angle::Result wait(const gl::Context *context) override |
| { |
| ANGLE_TRACE_EVENT0("gpu.angle", "ProgramGL::LinkEventGL::wait"); |
| |
| mWaitableEvent->wait(); |
| return mPostLinkImplFunctor(mLinkTask->fallbackToMainContext(), mLinkTask->getInfoLog()); |
| } |
| |
| bool isLinking() override { return !mWaitableEvent->isReady(); } |
| |
| private: |
| std::shared_ptr<ProgramGL::LinkTask> mLinkTask; |
| std::shared_ptr<angle::WaitableEvent> mWaitableEvent; |
| PostLinkImplFunctor mPostLinkImplFunctor; |
| }; |
| |
| void ProgramGL::prepareForLink(const gl::ShaderMap<ShaderImpl *> &shaders) |
| { |
| for (gl::ShaderType shaderType : gl::AllShaderTypes()) |
| { |
| mAttachedShaders[shaderType] = 0; |
| |
| if (shaders[shaderType] != nullptr) |
| { |
| const ShaderGL *shaderGL = GetAs<ShaderGL>(shaders[shaderType]); |
| mAttachedShaders[shaderType] = shaderGL->getShaderID(); |
| } |
| } |
| } |
| |
| std::unique_ptr<LinkEvent> ProgramGL::link(const gl::Context *context, |
| const gl::ProgramLinkedResources &resources, |
| gl::InfoLog &infoLog, |
| const gl::ProgramMergedVaryings & /*mergedVaryings*/) |
| { |
| ANGLE_TRACE_EVENT0("gpu.angle", "ProgramGL::link"); |
| |
| preLink(); |
| |
| if (mAttachedShaders[gl::ShaderType::Compute] != 0) |
| { |
| mFunctions->attachShader(mProgramID, mAttachedShaders[gl::ShaderType::Compute]); |
| } |
| else |
| { |
| // Set the transform feedback state |
| std::vector<std::string> transformFeedbackVaryingMappedNames; |
| for (const auto &tfVarying : mState.getTransformFeedbackVaryingNames()) |
| { |
| gl::ShaderType tfShaderType = |
| mState.getExecutable().hasLinkedShaderStage(gl::ShaderType::Geometry) |
| ? gl::ShaderType::Geometry |
| : gl::ShaderType::Vertex; |
| std::string tfVaryingMappedName = GetTransformFeedbackVaryingMappedName( |
| mState.getAttachedShader(tfShaderType), tfVarying); |
| transformFeedbackVaryingMappedNames.push_back(tfVaryingMappedName); |
| } |
| |
| if (transformFeedbackVaryingMappedNames.empty()) |
| { |
| // Only clear the transform feedback state if transform feedback varyings have already |
| // been set. |
| if (mHasAppliedTransformFeedbackVaryings) |
| { |
| ASSERT(mFunctions->transformFeedbackVaryings); |
| mFunctions->transformFeedbackVaryings(mProgramID, 0, nullptr, |
| mState.getTransformFeedbackBufferMode()); |
| mHasAppliedTransformFeedbackVaryings = false; |
| } |
| } |
| else |
| { |
| ASSERT(mFunctions->transformFeedbackVaryings); |
| std::vector<const GLchar *> transformFeedbackVaryings; |
| for (const auto &varying : transformFeedbackVaryingMappedNames) |
| { |
| transformFeedbackVaryings.push_back(varying.c_str()); |
| } |
| mFunctions->transformFeedbackVaryings( |
| mProgramID, static_cast<GLsizei>(transformFeedbackVaryingMappedNames.size()), |
| &transformFeedbackVaryings[0], mState.getTransformFeedbackBufferMode()); |
| mHasAppliedTransformFeedbackVaryings = true; |
| } |
| |
| for (const gl::ShaderType shaderType : gl::kAllGraphicsShaderTypes) |
| { |
| if (mAttachedShaders[shaderType] != 0) |
| { |
| mFunctions->attachShader(mProgramID, mAttachedShaders[shaderType]); |
| } |
| } |
| |
| // Bind attribute locations to match the GL layer. |
| for (const gl::ProgramInput &attribute : mState.getProgramInputs()) |
| { |
| if (!attribute.isActive() || attribute.isBuiltIn()) |
| { |
| continue; |
| } |
| |
| mFunctions->bindAttribLocation(mProgramID, attribute.getLocation(), |
| attribute.mappedName.c_str()); |
| } |
| |
| // Bind the secondary fragment color outputs defined in EXT_blend_func_extended. We only use |
| // the API to bind fragment output locations in case EXT_blend_func_extended is enabled. |
| // Otherwise shader-assigned locations will work. |
| if (context->getExtensions().blendFuncExtendedEXT) |
| { |
| const gl::SharedCompiledShaderState &fragmentShader = |
| mState.getAttachedShader(gl::ShaderType::Fragment); |
| if (fragmentShader && fragmentShader->shaderVersion == 100 && |
| mFunctions->standard == STANDARD_GL_DESKTOP) |
| { |
| const auto &shaderOutputs = fragmentShader->activeOutputVariables; |
| for (const auto &output : shaderOutputs) |
| { |
| // TODO(http://anglebug.com/1085) This could be cleaner if the transformed names |
| // would be set correctly in ShaderVariable::mappedName. This would require some |
| // refactoring in the translator. Adding a mapped name dictionary for builtins |
| // into the symbol table would be one fairly clean way to do it. |
| if (output.name == "gl_SecondaryFragColorEXT") |
| { |
| mFunctions->bindFragDataLocationIndexed(mProgramID, 0, 0, |
| "webgl_FragColor"); |
| mFunctions->bindFragDataLocationIndexed(mProgramID, 0, 1, |
| "webgl_SecondaryFragColor"); |
| } |
| else if (output.name == "gl_SecondaryFragDataEXT") |
| { |
| // Basically we should have a loop here going over the output |
| // array binding "webgl_FragData[i]" and "webgl_SecondaryFragData[i]" array |
| // indices to the correct color buffers and color indices. |
| // However I'm not sure if this construct is legal or not, neither ARB or |
| // EXT version of the spec mention this. They only mention that |
| // automatically assigned array locations for ESSL 3.00 output arrays need |
| // to have contiguous locations. |
| // |
| // In practice it seems that binding array members works on some drivers and |
| // fails on others. One option could be to modify the shader translator to |
| // expand the arrays into individual output variables instead of using an |
| // array. |
| // |
| // For now we're going to have a limitation of assuming that |
| // GL_MAX_DUAL_SOURCE_DRAW_BUFFERS is *always* 1 and then only bind the |
| // basename of the variable ignoring any indices. This appears to work |
| // uniformly. |
| ASSERT(output.isArray() && output.getOutermostArraySize() == 1); |
| |
| mFunctions->bindFragDataLocationIndexed(mProgramID, 0, 0, "webgl_FragData"); |
| mFunctions->bindFragDataLocationIndexed(mProgramID, 0, 1, |
| "webgl_SecondaryFragData"); |
| } |
| } |
| } |
| else if (fragmentShader && fragmentShader->shaderVersion >= 300) |
| { |
| // ESSL 3.00 and up. |
| const auto &outputLocations = mState.getOutputLocations(); |
| const auto &secondaryOutputLocations = mState.getSecondaryOutputLocations(); |
| for (size_t outputLocationIndex = 0u; outputLocationIndex < outputLocations.size(); |
| ++outputLocationIndex) |
| { |
| const gl::VariableLocation &outputLocation = |
| outputLocations[outputLocationIndex]; |
| if (outputLocation.arrayIndex == 0 && outputLocation.used() && |
| !outputLocation.ignored) |
| { |
| const sh::ShaderVariable &outputVar = |
| mState.getOutputVariables()[outputLocation.index]; |
| if (outputVar.location == -1 || outputVar.index == -1) |
| { |
| // We only need to assign the location and index via the API in case the |
| // variable doesn't have a shader-assigned location and index. If a |
| // variable doesn't have its location set in the shader it doesn't have |
| // the index set either. |
| ASSERT(outputVar.index == -1); |
| mFunctions->bindFragDataLocationIndexed( |
| mProgramID, static_cast<int>(outputLocationIndex), 0, |
| outputVar.mappedName.c_str()); |
| } |
| } |
| } |
| for (size_t outputLocationIndex = 0u; |
| outputLocationIndex < secondaryOutputLocations.size(); ++outputLocationIndex) |
| { |
| const gl::VariableLocation &outputLocation = |
| secondaryOutputLocations[outputLocationIndex]; |
| if (outputLocation.arrayIndex == 0 && outputLocation.used() && |
| !outputLocation.ignored) |
| { |
| const sh::ShaderVariable &outputVar = |
| mState.getOutputVariables()[outputLocation.index]; |
| if (outputVar.location == -1 || outputVar.index == -1) |
| { |
| // We only need to assign the location and index via the API in case the |
| // variable doesn't have a shader-assigned location and index. If a |
| // variable doesn't have its location set in the shader it doesn't have |
| // the index set either. |
| ASSERT(outputVar.index == -1); |
| mFunctions->bindFragDataLocationIndexed( |
| mProgramID, static_cast<int>(outputLocationIndex), 1, |
| outputVar.mappedName.c_str()); |
| } |
| } |
| } |
| } |
| } |
| } |
| auto workerPool = context->getShaderCompileThreadPool(); |
| auto linkTask = std::make_shared<LinkTask>([this](std::string &infoLog) { |
| std::string workerInfoLog; |
| ScopedWorkerContextGL worker(mRenderer.get(), &workerInfoLog); |
| if (!worker()) |
| { |
| #if !defined(NDEBUG) |
| infoLog += "bindWorkerContext failed.\n" + workerInfoLog; |
| #endif |
| // Fallback to the main context. |
| return true; |
| } |
| |
| mFunctions->linkProgram(mProgramID); |
| |
| // Make sure the driver actually does the link job. |
| GLint linkStatus = GL_FALSE; |
| mFunctions->getProgramiv(mProgramID, GL_LINK_STATUS, &linkStatus); |
| |
| return false; |
| }); |
| |
| auto postLinkImplTask = [this, &infoLog, &resources](bool fallbackToMainContext, |
| const std::string &workerInfoLog) { |
| infoLog << workerInfoLog; |
| if (fallbackToMainContext) |
| { |
| mFunctions->linkProgram(mProgramID); |
| } |
| |
| if (mAttachedShaders[gl::ShaderType::Compute] != 0) |
| { |
| mFunctions->detachShader(mProgramID, mAttachedShaders[gl::ShaderType::Compute]); |
| } |
| else |
| { |
| for (const gl::ShaderType shaderType : gl::kAllGraphicsShaderTypes) |
| { |
| if (mAttachedShaders[shaderType] != 0) |
| { |
| mFunctions->detachShader(mProgramID, mAttachedShaders[shaderType]); |
| } |
| } |
| } |
| // Verify the link |
| if (!checkLinkStatus(infoLog)) |
| { |
| return angle::Result::Incomplete; |
| } |
| |
| if (mFeatures.alwaysCallUseProgramAfterLink.enabled) |
| { |
| mStateManager->forceUseProgram(mProgramID); |
| } |
| |
| linkResources(resources); |
| postLink(); |
| |
| return angle::Result::Continue; |
| }; |
| |
| if (mRenderer->hasNativeParallelCompile()) |
| { |
| mFunctions->linkProgram(mProgramID); |
| |
| return std::make_unique<LinkEventNativeParallel>(postLinkImplTask, mFunctions, mProgramID); |
| } |
| else if (workerPool->isAsync() && |
| (!mFeatures.dontRelinkProgramsInParallel.enabled || !mLinkedInParallel)) |
| { |
| mLinkedInParallel = true; |
| return std::make_unique<LinkEventGL>(workerPool, linkTask, postLinkImplTask); |
| } |
| else |
| { |
| return std::make_unique<LinkEventDone>(postLinkImplTask(true, std::string())); |
| } |
| } |
| |
| GLboolean ProgramGL::validate(const gl::Caps & /*caps*/, gl::InfoLog * /*infoLog*/) |
| { |
| // TODO(jmadill): implement validate |
| return true; |
| } |
| |
| void ProgramGL::setUniform1fv(GLint location, GLsizei count, const GLfloat *v) |
| { |
| if (mFunctions->programUniform1fv != nullptr) |
| { |
| mFunctions->programUniform1fv(mProgramID, uniLoc(location), count, v); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniform1fv(uniLoc(location), count, v); |
| } |
| } |
| |
| void ProgramGL::setUniform2fv(GLint location, GLsizei count, const GLfloat *v) |
| { |
| if (mFunctions->programUniform2fv != nullptr) |
| { |
| mFunctions->programUniform2fv(mProgramID, uniLoc(location), count, v); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniform2fv(uniLoc(location), count, v); |
| } |
| } |
| |
| void ProgramGL::setUniform3fv(GLint location, GLsizei count, const GLfloat *v) |
| { |
| if (mFunctions->programUniform3fv != nullptr) |
| { |
| mFunctions->programUniform3fv(mProgramID, uniLoc(location), count, v); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniform3fv(uniLoc(location), count, v); |
| } |
| } |
| |
| void ProgramGL::setUniform4fv(GLint location, GLsizei count, const GLfloat *v) |
| { |
| if (mFunctions->programUniform4fv != nullptr) |
| { |
| mFunctions->programUniform4fv(mProgramID, uniLoc(location), count, v); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniform4fv(uniLoc(location), count, v); |
| } |
| } |
| |
| void ProgramGL::setUniform1iv(GLint location, GLsizei count, const GLint *v) |
| { |
| if (mFunctions->programUniform1iv != nullptr) |
| { |
| mFunctions->programUniform1iv(mProgramID, uniLoc(location), count, v); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniform1iv(uniLoc(location), count, v); |
| } |
| } |
| |
| void ProgramGL::setUniform2iv(GLint location, GLsizei count, const GLint *v) |
| { |
| if (mFunctions->programUniform2iv != nullptr) |
| { |
| mFunctions->programUniform2iv(mProgramID, uniLoc(location), count, v); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniform2iv(uniLoc(location), count, v); |
| } |
| } |
| |
| void ProgramGL::setUniform3iv(GLint location, GLsizei count, const GLint *v) |
| { |
| if (mFunctions->programUniform3iv != nullptr) |
| { |
| mFunctions->programUniform3iv(mProgramID, uniLoc(location), count, v); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniform3iv(uniLoc(location), count, v); |
| } |
| } |
| |
| void ProgramGL::setUniform4iv(GLint location, GLsizei count, const GLint *v) |
| { |
| if (mFunctions->programUniform4iv != nullptr) |
| { |
| mFunctions->programUniform4iv(mProgramID, uniLoc(location), count, v); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniform4iv(uniLoc(location), count, v); |
| } |
| } |
| |
| void ProgramGL::setUniform1uiv(GLint location, GLsizei count, const GLuint *v) |
| { |
| if (mFunctions->programUniform1uiv != nullptr) |
| { |
| mFunctions->programUniform1uiv(mProgramID, uniLoc(location), count, v); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniform1uiv(uniLoc(location), count, v); |
| } |
| } |
| |
| void ProgramGL::setUniform2uiv(GLint location, GLsizei count, const GLuint *v) |
| { |
| if (mFunctions->programUniform2uiv != nullptr) |
| { |
| mFunctions->programUniform2uiv(mProgramID, uniLoc(location), count, v); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniform2uiv(uniLoc(location), count, v); |
| } |
| } |
| |
| void ProgramGL::setUniform3uiv(GLint location, GLsizei count, const GLuint *v) |
| { |
| if (mFunctions->programUniform3uiv != nullptr) |
| { |
| mFunctions->programUniform3uiv(mProgramID, uniLoc(location), count, v); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniform3uiv(uniLoc(location), count, v); |
| } |
| } |
| |
| void ProgramGL::setUniform4uiv(GLint location, GLsizei count, const GLuint *v) |
| { |
| if (mFunctions->programUniform4uiv != nullptr) |
| { |
| mFunctions->programUniform4uiv(mProgramID, uniLoc(location), count, v); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniform4uiv(uniLoc(location), count, v); |
| } |
| } |
| |
| void ProgramGL::setUniformMatrix2fv(GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| if (mFunctions->programUniformMatrix2fv != nullptr) |
| { |
| mFunctions->programUniformMatrix2fv(mProgramID, uniLoc(location), count, transpose, value); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniformMatrix2fv(uniLoc(location), count, transpose, value); |
| } |
| } |
| |
| void ProgramGL::setUniformMatrix3fv(GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| if (mFunctions->programUniformMatrix3fv != nullptr) |
| { |
| mFunctions->programUniformMatrix3fv(mProgramID, uniLoc(location), count, transpose, value); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniformMatrix3fv(uniLoc(location), count, transpose, value); |
| } |
| } |
| |
| void ProgramGL::setUniformMatrix4fv(GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| if (mFunctions->programUniformMatrix4fv != nullptr) |
| { |
| mFunctions->programUniformMatrix4fv(mProgramID, uniLoc(location), count, transpose, value); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniformMatrix4fv(uniLoc(location), count, transpose, value); |
| } |
| } |
| |
| void ProgramGL::setUniformMatrix2x3fv(GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| if (mFunctions->programUniformMatrix2x3fv != nullptr) |
| { |
| mFunctions->programUniformMatrix2x3fv(mProgramID, uniLoc(location), count, transpose, |
| value); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniformMatrix2x3fv(uniLoc(location), count, transpose, value); |
| } |
| } |
| |
| void ProgramGL::setUniformMatrix3x2fv(GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| if (mFunctions->programUniformMatrix3x2fv != nullptr) |
| { |
| mFunctions->programUniformMatrix3x2fv(mProgramID, uniLoc(location), count, transpose, |
| value); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniformMatrix3x2fv(uniLoc(location), count, transpose, value); |
| } |
| } |
| |
| void ProgramGL::setUniformMatrix2x4fv(GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| if (mFunctions->programUniformMatrix2x4fv != nullptr) |
| { |
| mFunctions->programUniformMatrix2x4fv(mProgramID, uniLoc(location), count, transpose, |
| value); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniformMatrix2x4fv(uniLoc(location), count, transpose, value); |
| } |
| } |
| |
| void ProgramGL::setUniformMatrix4x2fv(GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| if (mFunctions->programUniformMatrix4x2fv != nullptr) |
| { |
| mFunctions->programUniformMatrix4x2fv(mProgramID, uniLoc(location), count, transpose, |
| value); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniformMatrix4x2fv(uniLoc(location), count, transpose, value); |
| } |
| } |
| |
| void ProgramGL::setUniformMatrix3x4fv(GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| if (mFunctions->programUniformMatrix3x4fv != nullptr) |
| { |
| mFunctions->programUniformMatrix3x4fv(mProgramID, uniLoc(location), count, transpose, |
| value); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniformMatrix3x4fv(uniLoc(location), count, transpose, value); |
| } |
| } |
| |
| void ProgramGL::setUniformMatrix4x3fv(GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| if (mFunctions->programUniformMatrix4x3fv != nullptr) |
| { |
| mFunctions->programUniformMatrix4x3fv(mProgramID, uniLoc(location), count, transpose, |
| value); |
| } |
| else |
| { |
| mStateManager->useProgram(mProgramID); |
| mFunctions->uniformMatrix4x3fv(uniLoc(location), count, transpose, value); |
| } |
| } |
| |
| void ProgramGL::setUniformBlockBinding(GLuint uniformBlockIndex, GLuint uniformBlockBinding) |
| { |
| // Lazy init |
| if (mUniformBlockRealLocationMap.empty()) |
| { |
| mUniformBlockRealLocationMap.reserve(mState.getUniformBlocks().size()); |
| for (const gl::InterfaceBlock &uniformBlock : mState.getUniformBlocks()) |
| { |
| const std::string &mappedNameWithIndex = uniformBlock.mappedNameWithArrayIndex(); |
| GLuint blockIndex = |
| mFunctions->getUniformBlockIndex(mProgramID, mappedNameWithIndex.c_str()); |
| mUniformBlockRealLocationMap.push_back(blockIndex); |
| } |
| } |
| |
| GLuint realBlockIndex = mUniformBlockRealLocationMap[uniformBlockIndex]; |
| if (realBlockIndex != GL_INVALID_INDEX) |
| { |
| mFunctions->uniformBlockBinding(mProgramID, realBlockIndex, uniformBlockBinding); |
| } |
| } |
| |
| bool ProgramGL::getUniformBlockSize(const std::string & /* blockName */, |
| const std::string &blockMappedName, |
| size_t *sizeOut) const |
| { |
| ASSERT(mProgramID != 0u); |
| |
| GLuint blockIndex = mFunctions->getUniformBlockIndex(mProgramID, blockMappedName.c_str()); |
| if (blockIndex == GL_INVALID_INDEX) |
| { |
| *sizeOut = 0; |
| return false; |
| } |
| |
| GLint dataSize = 0; |
| mFunctions->getActiveUniformBlockiv(mProgramID, blockIndex, GL_UNIFORM_BLOCK_DATA_SIZE, |
| &dataSize); |
| *sizeOut = static_cast<size_t>(dataSize); |
| return true; |
| } |
| |
| bool ProgramGL::getUniformBlockMemberInfo(const std::string & /* memberUniformName */, |
| const std::string &memberUniformMappedName, |
| sh::BlockMemberInfo *memberInfoOut) const |
| { |
| GLuint uniformIndex; |
| const GLchar *memberNameGLStr = memberUniformMappedName.c_str(); |
| mFunctions->getUniformIndices(mProgramID, 1, &memberNameGLStr, &uniformIndex); |
| |
| if (uniformIndex == GL_INVALID_INDEX) |
| { |
| *memberInfoOut = sh::kDefaultBlockMemberInfo; |
| return false; |
| } |
| |
| mFunctions->getActiveUniformsiv(mProgramID, 1, &uniformIndex, GL_UNIFORM_OFFSET, |
| &memberInfoOut->offset); |
| mFunctions->getActiveUniformsiv(mProgramID, 1, &uniformIndex, GL_UNIFORM_ARRAY_STRIDE, |
| &memberInfoOut->arrayStride); |
| mFunctions->getActiveUniformsiv(mProgramID, 1, &uniformIndex, GL_UNIFORM_MATRIX_STRIDE, |
| &memberInfoOut->matrixStride); |
| |
| // TODO(jmadill): possibly determine this at the gl::Program level. |
| GLint isRowMajorMatrix = 0; |
| mFunctions->getActiveUniformsiv(mProgramID, 1, &uniformIndex, GL_UNIFORM_IS_ROW_MAJOR, |
| &isRowMajorMatrix); |
| memberInfoOut->isRowMajorMatrix = gl::ConvertToBool(isRowMajorMatrix); |
| return true; |
| } |
| |
| bool ProgramGL::getShaderStorageBlockMemberInfo(const std::string & /* memberName */, |
| const std::string &memberUniformMappedName, |
| sh::BlockMemberInfo *memberInfoOut) const |
| { |
| const GLchar *memberNameGLStr = memberUniformMappedName.c_str(); |
| GLuint index = |
| mFunctions->getProgramResourceIndex(mProgramID, GL_BUFFER_VARIABLE, memberNameGLStr); |
| |
| if (index == GL_INVALID_INDEX) |
| { |
| *memberInfoOut = sh::kDefaultBlockMemberInfo; |
| return false; |
| } |
| |
| constexpr int kPropCount = 5; |
| std::array<GLenum, kPropCount> props = { |
| {GL_ARRAY_STRIDE, GL_IS_ROW_MAJOR, GL_MATRIX_STRIDE, GL_OFFSET, GL_TOP_LEVEL_ARRAY_STRIDE}}; |
| std::array<GLint, kPropCount> params; |
| GLsizei length; |
| mFunctions->getProgramResourceiv(mProgramID, GL_BUFFER_VARIABLE, index, kPropCount, |
| props.data(), kPropCount, &length, params.data()); |
| ASSERT(kPropCount == length); |
| memberInfoOut->arrayStride = params[0]; |
| memberInfoOut->isRowMajorMatrix = params[1] != 0; |
| memberInfoOut->matrixStride = params[2]; |
| memberInfoOut->offset = params[3]; |
| memberInfoOut->topLevelArrayStride = params[4]; |
| |
| return true; |
| } |
| |
| bool ProgramGL::getShaderStorageBlockSize(const std::string &name, |
| const std::string &mappedName, |
| size_t *sizeOut) const |
| { |
| const GLchar *nameGLStr = mappedName.c_str(); |
| GLuint index = |
| mFunctions->getProgramResourceIndex(mProgramID, GL_SHADER_STORAGE_BLOCK, nameGLStr); |
| |
| if (index == GL_INVALID_INDEX) |
| { |
| *sizeOut = 0; |
| return false; |
| } |
| |
| GLenum prop = GL_BUFFER_DATA_SIZE; |
| GLsizei length = 0; |
| GLint dataSize = 0; |
| mFunctions->getProgramResourceiv(mProgramID, GL_SHADER_STORAGE_BLOCK, index, 1, &prop, 1, |
| &length, &dataSize); |
| *sizeOut = static_cast<size_t>(dataSize); |
| return true; |
| } |
| |
| void ProgramGL::getAtomicCounterBufferSizeMap(std::map<int, unsigned int> *sizeMapOut) const |
| { |
| if (mFunctions->getProgramInterfaceiv == nullptr) |
| { |
| return; |
| } |
| |
| int resourceCount = 0; |
| mFunctions->getProgramInterfaceiv(mProgramID, GL_ATOMIC_COUNTER_BUFFER, GL_ACTIVE_RESOURCES, |
| &resourceCount); |
| |
| for (int index = 0; index < resourceCount; index++) |
| { |
| constexpr int kPropCount = 2; |
| std::array<GLenum, kPropCount> props = {{GL_BUFFER_BINDING, GL_BUFFER_DATA_SIZE}}; |
| std::array<GLint, kPropCount> params; |
| GLsizei length; |
| mFunctions->getProgramResourceiv(mProgramID, GL_ATOMIC_COUNTER_BUFFER, index, kPropCount, |
| props.data(), kPropCount, &length, params.data()); |
| ASSERT(kPropCount == length); |
| int bufferBinding = params[0]; |
| unsigned int bufferDataSize = params[1]; |
| sizeMapOut->insert(std::pair<int, unsigned int>(bufferBinding, bufferDataSize)); |
| } |
| } |
| |
| void ProgramGL::preLink() |
| { |
| // Reset the program state |
| mUniformRealLocationMap.clear(); |
| mUniformBlockRealLocationMap.clear(); |
| |
| mClipDistanceEnabledUniformLocation = -1; |
| mMultiviewBaseViewLayerIndexUniformLocation = -1; |
| } |
| |
| bool ProgramGL::checkLinkStatus(gl::InfoLog &infoLog) |
| { |
| GLint linkStatus = GL_FALSE; |
| mFunctions->getProgramiv(mProgramID, GL_LINK_STATUS, &linkStatus); |
| if (linkStatus == GL_FALSE) |
| { |
| // Linking or program binary loading failed, put the error into the info log. |
| GLint infoLogLength = 0; |
| mFunctions->getProgramiv(mProgramID, GL_INFO_LOG_LENGTH, &infoLogLength); |
| |
| // Info log length includes the null terminator, so 1 means that the info log is an empty |
| // string. |
| if (infoLogLength > 1) |
| { |
| std::vector<char> buf(infoLogLength); |
| mFunctions->getProgramInfoLog(mProgramID, infoLogLength, nullptr, &buf[0]); |
| |
| infoLog << buf.data(); |
| |
| WARN() << "Program link or binary loading failed: " << buf.data(); |
| } |
| else |
| { |
| WARN() << "Program link or binary loading failed with no info log."; |
| } |
| |
| // This may happen under normal circumstances if we're loading program binaries and the |
| // driver or hardware has changed. |
| ASSERT(mProgramID != 0); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| void ProgramGL::postLink() |
| { |
| // Query the uniform information |
| ASSERT(mUniformRealLocationMap.empty()); |
| const auto &uniformLocations = mState.getUniformLocations(); |
| const auto &uniforms = mState.getUniforms(); |
| mUniformRealLocationMap.resize(uniformLocations.size(), GL_INVALID_INDEX); |
| for (size_t uniformLocation = 0; uniformLocation < uniformLocations.size(); uniformLocation++) |
| { |
| const auto &entry = uniformLocations[uniformLocation]; |
| if (!entry.used()) |
| { |
| continue; |
| } |
| |
| // From the GLES 3.0.5 spec: |
| // "Locations for sequential array indices are not required to be sequential." |
| const gl::LinkedUniform &uniform = uniforms[entry.index]; |
| const std::string &uniformMappedName = mState.getUniformMappedNames()[entry.index]; |
| std::stringstream fullNameStr; |
| if (uniform.isArray()) |
| { |
| ASSERT(angle::EndsWith(uniformMappedName, "[0]")); |
| fullNameStr << uniformMappedName.substr(0, uniformMappedName.length() - 3); |
| fullNameStr << "[" << entry.arrayIndex << "]"; |
| } |
| else |
| { |
| fullNameStr << uniformMappedName; |
| } |
| const std::string &fullName = fullNameStr.str(); |
| |
| GLint realLocation = mFunctions->getUniformLocation(mProgramID, fullName.c_str()); |
| mUniformRealLocationMap[uniformLocation] = realLocation; |
| } |
| |
| if (mFeatures.emulateClipDistanceState.enabled && mState.getExecutable().hasClipDistance()) |
| { |
| ASSERT(mFunctions->standard == STANDARD_GL_ES); |
| mClipDistanceEnabledUniformLocation = |
| mFunctions->getUniformLocation(mProgramID, "angle_ClipDistanceEnabled"); |
| ASSERT(mClipDistanceEnabledUniformLocation != -1); |
| } |
| |
| if (mState.usesMultiview()) |
| { |
| mMultiviewBaseViewLayerIndexUniformLocation = |
| mFunctions->getUniformLocation(mProgramID, "multiviewBaseViewLayerIndex"); |
| ASSERT(mMultiviewBaseViewLayerIndexUniformLocation != -1); |
| } |
| } |
| |
| void ProgramGL::updateEnabledClipDistances(uint8_t enabledClipDistancesPacked) const |
| { |
| ASSERT(mState.getExecutable().hasClipDistance()); |
| ASSERT(mClipDistanceEnabledUniformLocation != -1); |
| |
| ASSERT(mFunctions->programUniform1ui != nullptr); |
| mFunctions->programUniform1ui(mProgramID, mClipDistanceEnabledUniformLocation, |
| enabledClipDistancesPacked); |
| } |
| |
| void ProgramGL::enableLayeredRenderingPath(int baseViewIndex) const |
| { |
| ASSERT(mState.usesMultiview()); |
| ASSERT(mMultiviewBaseViewLayerIndexUniformLocation != -1); |
| |
| ASSERT(mFunctions->programUniform1i != nullptr); |
| mFunctions->programUniform1i(mProgramID, mMultiviewBaseViewLayerIndexUniformLocation, |
| baseViewIndex); |
| } |
| |
| void ProgramGL::getUniformfv(const gl::Context *context, GLint location, GLfloat *params) const |
| { |
| mFunctions->getUniformfv(mProgramID, uniLoc(location), params); |
| } |
| |
| void ProgramGL::getUniformiv(const gl::Context *context, GLint location, GLint *params) const |
| { |
| mFunctions->getUniformiv(mProgramID, uniLoc(location), params); |
| } |
| |
| void ProgramGL::getUniformuiv(const gl::Context *context, GLint location, GLuint *params) const |
| { |
| mFunctions->getUniformuiv(mProgramID, uniLoc(location), params); |
| } |
| |
| void ProgramGL::markUnusedUniformLocations(std::vector<gl::VariableLocation> *uniformLocations, |
| std::vector<gl::SamplerBinding> *samplerBindings, |
| std::vector<gl::ImageBinding> *imageBindings) |
| { |
| GLint maxLocation = static_cast<GLint>(uniformLocations->size()); |
| for (GLint location = 0; location < maxLocation; ++location) |
| { |
| if (uniLoc(location) == -1) |
| { |
| auto &locationRef = (*uniformLocations)[location]; |
| if (mState.isSamplerUniformIndex(locationRef.index)) |
| { |
| GLuint samplerIndex = mState.getSamplerIndexFromUniformIndex(locationRef.index); |
| gl::SamplerBinding &samplerBinding = (*samplerBindings)[samplerIndex]; |
| if (locationRef.arrayIndex < samplerBinding.boundTextureUnits.size()) |
| { |
| // Crop unused sampler bindings in the sampler array. |
| samplerBinding.boundTextureUnits.resize(locationRef.arrayIndex); |
| } |
| } |
| else if (mState.isImageUniformIndex(locationRef.index)) |
| { |
| GLuint imageIndex = mState.getImageIndexFromUniformIndex(locationRef.index); |
| gl::ImageBinding &imageBinding = (*imageBindings)[imageIndex]; |
| if (locationRef.arrayIndex < imageBinding.boundImageUnits.size()) |
| { |
| // Crop unused image bindings in the image array. |
| imageBinding.boundImageUnits.resize(locationRef.arrayIndex); |
| } |
| } |
| // If the location has been previously bound by a glBindUniformLocation call, it should |
| // be marked as ignored. Otherwise it's unused. |
| if (mState.getUniformLocationBindings().getBindingByLocation(location) != -1) |
| { |
| locationRef.markIgnored(); |
| } |
| else |
| { |
| locationRef.markUnused(); |
| } |
| } |
| } |
| } |
| |
| void ProgramGL::linkResources(const gl::ProgramLinkedResources &resources) |
| { |
| // Gather interface block info. |
| auto getUniformBlockSize = [this](const std::string &name, const std::string &mappedName, |
| size_t *sizeOut) { |
| return this->getUniformBlockSize(name, mappedName, sizeOut); |
| }; |
| |
| auto getUniformBlockMemberInfo = [this](const std::string &name, const std::string &mappedName, |
| sh::BlockMemberInfo *infoOut) { |
| return this->getUniformBlockMemberInfo(name, mappedName, infoOut); |
| }; |
| |
| resources.uniformBlockLinker.linkBlocks(getUniformBlockSize, getUniformBlockMemberInfo); |
| |
| auto getShaderStorageBlockSize = [this](const std::string &name, const std::string &mappedName, |
| size_t *sizeOut) { |
| return this->getShaderStorageBlockSize(name, mappedName, sizeOut); |
| }; |
| |
| auto getShaderStorageBlockMemberInfo = [this](const std::string &name, |
| const std::string &mappedName, |
| sh::BlockMemberInfo *infoOut) { |
| return this->getShaderStorageBlockMemberInfo(name, mappedName, infoOut); |
| }; |
| resources.shaderStorageBlockLinker.linkBlocks(getShaderStorageBlockSize, |
| getShaderStorageBlockMemberInfo); |
| |
| // Gather atomic counter buffer info. |
| std::map<int, unsigned int> sizeMap; |
| getAtomicCounterBufferSizeMap(&sizeMap); |
| resources.atomicCounterBufferLinker.link(sizeMap); |
| } |
| |
| angle::Result ProgramGL::syncState(const gl::Context *context, |
| const gl::Program::DirtyBits &dirtyBits) |
| { |
| for (size_t dirtyBit : dirtyBits) |
| { |
| ASSERT(dirtyBit <= gl::Program::DIRTY_BIT_UNIFORM_BLOCK_BINDING_MAX); |
| GLuint binding = static_cast<GLuint>(dirtyBit); |
| setUniformBlockBinding(binding, mState.getUniformBlockBinding(binding)); |
| } |
| return angle::Result::Continue; |
| } |
| } // namespace rx |
