| // |
| // Copyright 2020 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. |
| // |
| // ProgramExecutable.cpp: Collects the interfaces common to both Programs and |
| // ProgramPipelines in order to execute/draw with either. |
| |
| #include "libANGLE/ProgramExecutable.h" |
| |
| #include "common/string_utils.h" |
| #include "libANGLE/Context.h" |
| #include "libANGLE/Program.h" |
| #include "libANGLE/Shader.h" |
| |
| namespace gl |
| { |
| namespace |
| { |
| bool IncludeSameArrayElement(const std::set<std::string> &nameSet, const std::string &name) |
| { |
| std::vector<unsigned int> subscripts; |
| std::string baseName = ParseResourceName(name, &subscripts); |
| for (const std::string &nameInSet : nameSet) |
| { |
| std::vector<unsigned int> arrayIndices; |
| std::string arrayName = ParseResourceName(nameInSet, &arrayIndices); |
| if (baseName == arrayName && |
| (subscripts.empty() || arrayIndices.empty() || subscripts == arrayIndices)) |
| { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| // Find the matching varying or field by name. |
| const sh::ShaderVariable *FindOutputVaryingOrField(const ProgramMergedVaryings &varyings, |
| ShaderType stage, |
| const std::string &name) |
| { |
| const sh::ShaderVariable *var = nullptr; |
| for (const ProgramVaryingRef &ref : varyings) |
| { |
| if (ref.frontShaderStage != stage) |
| { |
| continue; |
| } |
| |
| const sh::ShaderVariable *varying = ref.get(stage); |
| if (varying->name == name) |
| { |
| var = varying; |
| break; |
| } |
| GLuint fieldIndex = 0; |
| var = varying->findField(name, &fieldIndex); |
| if (var != nullptr) |
| { |
| break; |
| } |
| } |
| return var; |
| } |
| |
| bool FindUsedOutputLocation(std::vector<VariableLocation> &outputLocations, |
| unsigned int baseLocation, |
| unsigned int elementCount, |
| const std::vector<VariableLocation> &reservedLocations, |
| unsigned int variableIndex) |
| { |
| if (baseLocation + elementCount > outputLocations.size()) |
| { |
| elementCount = baseLocation < outputLocations.size() |
| ? static_cast<unsigned int>(outputLocations.size() - baseLocation) |
| : 0; |
| } |
| for (unsigned int elementIndex = 0; elementIndex < elementCount; elementIndex++) |
| { |
| const unsigned int location = baseLocation + elementIndex; |
| if (outputLocations[location].used()) |
| { |
| VariableLocation locationInfo(elementIndex, variableIndex); |
| if (std::find(reservedLocations.begin(), reservedLocations.end(), locationInfo) == |
| reservedLocations.end()) |
| { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| void AssignOutputLocations(std::vector<VariableLocation> &outputLocations, |
| unsigned int baseLocation, |
| unsigned int elementCount, |
| const std::vector<VariableLocation> &reservedLocations, |
| unsigned int variableIndex, |
| sh::ShaderVariable &outputVariable) |
| { |
| if (baseLocation + elementCount > outputLocations.size()) |
| { |
| outputLocations.resize(baseLocation + elementCount); |
| } |
| for (unsigned int elementIndex = 0; elementIndex < elementCount; elementIndex++) |
| { |
| VariableLocation locationInfo(elementIndex, variableIndex); |
| if (std::find(reservedLocations.begin(), reservedLocations.end(), locationInfo) == |
| reservedLocations.end()) |
| { |
| outputVariable.location = baseLocation; |
| const unsigned int location = baseLocation + elementIndex; |
| outputLocations[location] = locationInfo; |
| } |
| } |
| } |
| |
| int GetOutputLocationForLink(const ProgramAliasedBindings &fragmentOutputLocations, |
| const sh::ShaderVariable &outputVariable) |
| { |
| if (outputVariable.location != -1) |
| { |
| return outputVariable.location; |
| } |
| int apiLocation = fragmentOutputLocations.getBinding(outputVariable); |
| if (apiLocation != -1) |
| { |
| return apiLocation; |
| } |
| return -1; |
| } |
| |
| bool IsOutputSecondaryForLink(const ProgramAliasedBindings &fragmentOutputIndexes, |
| const sh::ShaderVariable &outputVariable) |
| { |
| if (outputVariable.index != -1) |
| { |
| ASSERT(outputVariable.index == 0 || outputVariable.index == 1); |
| return (outputVariable.index == 1); |
| } |
| int apiIndex = fragmentOutputIndexes.getBinding(outputVariable); |
| if (apiIndex != -1) |
| { |
| // Index layout qualifier from the shader takes precedence, so the index from the API is |
| // checked only if the index was not set in the shader. This is not specified in the EXT |
| // spec, but is specified in desktop OpenGL specs. |
| return (apiIndex == 1); |
| } |
| // EXT_blend_func_extended: Outputs get index 0 by default. |
| return false; |
| } |
| |
| RangeUI AddUniforms(const ShaderMap<Program *> &programs, |
| ShaderBitSet activeShaders, |
| std::vector<LinkedUniform> &outputUniforms, |
| const std::function<RangeUI(const ProgramState &)> &getRange) |
| { |
| unsigned int startRange = static_cast<unsigned int>(outputUniforms.size()); |
| for (ShaderType shaderType : activeShaders) |
| { |
| const ProgramState &programState = programs[shaderType]->getState(); |
| const std::vector<LinkedUniform> &programUniforms = programState.getUniforms(); |
| const RangeUI uniformRange = getRange(programState); |
| |
| outputUniforms.insert(outputUniforms.end(), programUniforms.begin() + uniformRange.low(), |
| programUniforms.begin() + uniformRange.high()); |
| } |
| return RangeUI(startRange, static_cast<unsigned int>(outputUniforms.size())); |
| } |
| |
| template <typename BlockT> |
| void AppendActiveBlocks(ShaderType shaderType, |
| const std::vector<BlockT> &blocksIn, |
| std::vector<BlockT> &blocksOut) |
| { |
| for (const BlockT &block : blocksIn) |
| { |
| if (block.isActive(shaderType)) |
| { |
| blocksOut.push_back(block); |
| } |
| } |
| } |
| } // anonymous namespace |
| |
| ProgramExecutable::ProgramExecutable() |
| : mMaxActiveAttribLocation(0), |
| mAttributesTypeMask(0), |
| mAttributesMask(0), |
| mActiveSamplerRefCounts{}, |
| mCanDrawWith(false), |
| mYUVOutput(false), |
| mTransformFeedbackBufferMode(GL_INTERLEAVED_ATTRIBS), |
| mDefaultUniformRange(0, 0), |
| mSamplerUniformRange(0, 0), |
| mImageUniformRange(0, 0), |
| mAtomicCounterUniformRange(0, 0), |
| mFragmentInoutRange(0, 0), |
| mEnablesPerSampleShading(false), |
| // [GL_EXT_geometry_shader] Table 20.22 |
| mGeometryShaderInputPrimitiveType(PrimitiveMode::Triangles), |
| mGeometryShaderOutputPrimitiveType(PrimitiveMode::TriangleStrip), |
| mGeometryShaderInvocations(1), |
| mGeometryShaderMaxVertices(0), |
| mTessControlShaderVertices(0), |
| mTessGenMode(GL_NONE), |
| mTessGenSpacing(GL_NONE), |
| mTessGenVertexOrder(GL_NONE), |
| mTessGenPointMode(GL_NONE) |
| { |
| reset(true); |
| } |
| |
| ProgramExecutable::ProgramExecutable(const ProgramExecutable &other) |
| : mLinkedShaderStages(other.mLinkedShaderStages), |
| mActiveAttribLocationsMask(other.mActiveAttribLocationsMask), |
| mMaxActiveAttribLocation(other.mMaxActiveAttribLocation), |
| mAttributesTypeMask(other.mAttributesTypeMask), |
| mAttributesMask(other.mAttributesMask), |
| mActiveSamplersMask(other.mActiveSamplersMask), |
| mActiveSamplerRefCounts(other.mActiveSamplerRefCounts), |
| mActiveSamplerTypes(other.mActiveSamplerTypes), |
| mActiveSamplerYUV(other.mActiveSamplerYUV), |
| mActiveSamplerFormats(other.mActiveSamplerFormats), |
| mActiveSamplerShaderBits(other.mActiveSamplerShaderBits), |
| mActiveImagesMask(other.mActiveImagesMask), |
| mActiveImageShaderBits(other.mActiveImageShaderBits), |
| mCanDrawWith(other.mCanDrawWith), |
| mOutputVariables(other.mOutputVariables), |
| mOutputLocations(other.mOutputLocations), |
| mSecondaryOutputLocations(other.mSecondaryOutputLocations), |
| mYUVOutput(other.mYUVOutput), |
| mProgramInputs(other.mProgramInputs), |
| mLinkedTransformFeedbackVaryings(other.mLinkedTransformFeedbackVaryings), |
| mTransformFeedbackStrides(other.mTransformFeedbackStrides), |
| mTransformFeedbackBufferMode(other.mTransformFeedbackBufferMode), |
| mUniforms(other.mUniforms), |
| mDefaultUniformRange(other.mDefaultUniformRange), |
| mSamplerUniformRange(other.mSamplerUniformRange), |
| mImageUniformRange(other.mImageUniformRange), |
| mAtomicCounterUniformRange(other.mAtomicCounterUniformRange), |
| mUniformBlocks(other.mUniformBlocks), |
| mActiveUniformBlockBindings(other.mActiveUniformBlockBindings), |
| mAtomicCounterBuffers(other.mAtomicCounterBuffers), |
| mShaderStorageBlocks(other.mShaderStorageBlocks), |
| mFragmentInoutRange(other.mFragmentInoutRange), |
| mEnablesPerSampleShading(other.mEnablesPerSampleShading), |
| mAdvancedBlendEquations(other.mAdvancedBlendEquations) |
| { |
| reset(true); |
| } |
| |
| ProgramExecutable::~ProgramExecutable() = default; |
| |
| void ProgramExecutable::reset(bool clearInfoLog) |
| { |
| if (clearInfoLog) |
| { |
| resetInfoLog(); |
| } |
| mActiveAttribLocationsMask.reset(); |
| mAttributesTypeMask.reset(); |
| mAttributesMask.reset(); |
| mMaxActiveAttribLocation = 0; |
| |
| mActiveSamplersMask.reset(); |
| mActiveSamplerRefCounts = {}; |
| mActiveSamplerTypes.fill(TextureType::InvalidEnum); |
| mActiveSamplerYUV.reset(); |
| mActiveSamplerFormats.fill(SamplerFormat::InvalidEnum); |
| |
| mActiveImagesMask.reset(); |
| |
| mProgramInputs.clear(); |
| mLinkedTransformFeedbackVaryings.clear(); |
| mTransformFeedbackStrides.clear(); |
| mUniforms.clear(); |
| mUniformBlocks.clear(); |
| mActiveUniformBlockBindings.reset(); |
| mShaderStorageBlocks.clear(); |
| mAtomicCounterBuffers.clear(); |
| mOutputVariables.clear(); |
| mOutputLocations.clear(); |
| mActiveOutputVariablesMask.reset(); |
| mSecondaryOutputLocations.clear(); |
| mYUVOutput = false; |
| mSamplerBindings.clear(); |
| mImageBindings.clear(); |
| |
| mDefaultUniformRange = RangeUI(0, 0); |
| mSamplerUniformRange = RangeUI(0, 0); |
| mImageUniformRange = RangeUI(0, 0); |
| mAtomicCounterUniformRange = RangeUI(0, 0); |
| |
| mFragmentInoutRange = RangeUI(0, 0); |
| mEnablesPerSampleShading = false; |
| mAdvancedBlendEquations.reset(); |
| |
| mGeometryShaderInputPrimitiveType = PrimitiveMode::Triangles; |
| mGeometryShaderOutputPrimitiveType = PrimitiveMode::TriangleStrip; |
| mGeometryShaderInvocations = 1; |
| mGeometryShaderMaxVertices = 0; |
| |
| mTessControlShaderVertices = 0; |
| mTessGenMode = GL_NONE; |
| mTessGenSpacing = GL_NONE; |
| mTessGenVertexOrder = GL_NONE; |
| mTessGenPointMode = GL_NONE; |
| |
| mOutputVariableTypes.clear(); |
| mDrawBufferTypeMask.reset(); |
| } |
| |
| void ProgramExecutable::load(bool isSeparable, gl::BinaryInputStream *stream) |
| { |
| static_assert(MAX_VERTEX_ATTRIBS * 2 <= sizeof(uint32_t) * 8, |
| "Too many vertex attribs for mask: All bits of mAttributesTypeMask types and " |
| "mask fit into 32 bits each"); |
| mAttributesTypeMask = gl::ComponentTypeMask(stream->readInt<uint32_t>()); |
| mAttributesMask = gl::AttributesMask(stream->readInt<uint32_t>()); |
| mActiveAttribLocationsMask = gl::AttributesMask(stream->readInt<uint32_t>()); |
| mMaxActiveAttribLocation = stream->readInt<unsigned int>(); |
| |
| unsigned int fragmentInoutRangeLow = stream->readInt<uint32_t>(); |
| unsigned int fragmentInoutRangeHigh = stream->readInt<uint32_t>(); |
| mFragmentInoutRange = RangeUI(fragmentInoutRangeLow, fragmentInoutRangeHigh); |
| |
| mEnablesPerSampleShading = stream->readBool(); |
| |
| static_assert(sizeof(mAdvancedBlendEquations.bits()) == sizeof(uint32_t)); |
| mAdvancedBlendEquations = BlendEquationBitSet(stream->readInt<uint32_t>()); |
| |
| mLinkedShaderStages = ShaderBitSet(stream->readInt<uint8_t>()); |
| |
| mGeometryShaderInputPrimitiveType = stream->readEnum<PrimitiveMode>(); |
| mGeometryShaderOutputPrimitiveType = stream->readEnum<PrimitiveMode>(); |
| mGeometryShaderInvocations = stream->readInt<int>(); |
| mGeometryShaderMaxVertices = stream->readInt<int>(); |
| |
| mTessControlShaderVertices = stream->readInt<int>(); |
| mTessGenMode = stream->readInt<GLenum>(); |
| mTessGenSpacing = stream->readInt<GLenum>(); |
| mTessGenVertexOrder = stream->readInt<GLenum>(); |
| mTessGenPointMode = stream->readInt<GLenum>(); |
| |
| size_t attribCount = stream->readInt<size_t>(); |
| ASSERT(getProgramInputs().empty()); |
| for (size_t attribIndex = 0; attribIndex < attribCount; ++attribIndex) |
| { |
| sh::ShaderVariable attrib; |
| LoadShaderVar(stream, &attrib); |
| attrib.location = stream->readInt<int>(); |
| mProgramInputs.push_back(attrib); |
| } |
| |
| size_t uniformCount = stream->readInt<size_t>(); |
| ASSERT(getUniforms().empty()); |
| for (size_t uniformIndex = 0; uniformIndex < uniformCount; ++uniformIndex) |
| { |
| LinkedUniform uniform; |
| LoadShaderVar(stream, &uniform); |
| |
| uniform.bufferIndex = stream->readInt<int>(); |
| LoadBlockMemberInfo(stream, &uniform.blockInfo); |
| |
| stream->readIntVector<unsigned int>(&uniform.outerArraySizes); |
| uniform.outerArrayOffset = stream->readInt<unsigned int>(); |
| |
| uniform.typeInfo = &GetUniformTypeInfo(uniform.type); |
| |
| // Active shader info |
| for (ShaderType shaderType : gl::AllShaderTypes()) |
| { |
| uniform.setActive(shaderType, stream->readBool()); |
| } |
| |
| mUniforms.push_back(uniform); |
| } |
| |
| size_t uniformBlockCount = stream->readInt<size_t>(); |
| ASSERT(getUniformBlocks().empty()); |
| for (size_t uniformBlockIndex = 0; uniformBlockIndex < uniformBlockCount; ++uniformBlockIndex) |
| { |
| InterfaceBlock uniformBlock; |
| LoadInterfaceBlock(stream, &uniformBlock); |
| mUniformBlocks.push_back(uniformBlock); |
| |
| mActiveUniformBlockBindings.set(uniformBlockIndex, uniformBlock.binding != 0); |
| } |
| |
| size_t shaderStorageBlockCount = stream->readInt<size_t>(); |
| ASSERT(getShaderStorageBlocks().empty()); |
| for (size_t shaderStorageBlockIndex = 0; shaderStorageBlockIndex < shaderStorageBlockCount; |
| ++shaderStorageBlockIndex) |
| { |
| InterfaceBlock shaderStorageBlock; |
| LoadInterfaceBlock(stream, &shaderStorageBlock); |
| mShaderStorageBlocks.push_back(shaderStorageBlock); |
| } |
| |
| size_t atomicCounterBufferCount = stream->readInt<size_t>(); |
| ASSERT(getAtomicCounterBuffers().empty()); |
| for (size_t bufferIndex = 0; bufferIndex < atomicCounterBufferCount; ++bufferIndex) |
| { |
| AtomicCounterBuffer atomicCounterBuffer; |
| LoadShaderVariableBuffer(stream, &atomicCounterBuffer); |
| |
| mAtomicCounterBuffers.push_back(atomicCounterBuffer); |
| } |
| |
| size_t transformFeedbackVaryingCount = stream->readInt<size_t>(); |
| ASSERT(mLinkedTransformFeedbackVaryings.empty()); |
| for (size_t transformFeedbackVaryingIndex = 0; |
| transformFeedbackVaryingIndex < transformFeedbackVaryingCount; |
| ++transformFeedbackVaryingIndex) |
| { |
| sh::ShaderVariable varying; |
| stream->readIntVector<unsigned int>(&varying.arraySizes); |
| stream->readInt(&varying.type); |
| stream->readString(&varying.name); |
| |
| GLuint arrayIndex = stream->readInt<GLuint>(); |
| |
| mLinkedTransformFeedbackVaryings.emplace_back(varying, arrayIndex); |
| } |
| |
| mTransformFeedbackBufferMode = stream->readInt<GLint>(); |
| |
| size_t outputCount = stream->readInt<size_t>(); |
| ASSERT(getOutputVariables().empty()); |
| for (size_t outputIndex = 0; outputIndex < outputCount; ++outputIndex) |
| { |
| sh::ShaderVariable output; |
| LoadShaderVar(stream, &output); |
| output.location = stream->readInt<int>(); |
| output.index = stream->readInt<int>(); |
| mOutputVariables.push_back(output); |
| } |
| |
| size_t outputVarCount = stream->readInt<size_t>(); |
| ASSERT(getOutputLocations().empty()); |
| for (size_t outputIndex = 0; outputIndex < outputVarCount; ++outputIndex) |
| { |
| VariableLocation locationData; |
| stream->readInt(&locationData.arrayIndex); |
| stream->readInt(&locationData.index); |
| stream->readBool(&locationData.ignored); |
| mOutputLocations.push_back(locationData); |
| } |
| |
| mActiveOutputVariablesMask = |
| gl::DrawBufferMask(stream->readInt<gl::DrawBufferMask::value_type>()); |
| |
| size_t outputTypeCount = stream->readInt<size_t>(); |
| for (size_t outputIndex = 0; outputIndex < outputTypeCount; ++outputIndex) |
| { |
| mOutputVariableTypes.push_back(stream->readInt<GLenum>()); |
| } |
| |
| static_assert(IMPLEMENTATION_MAX_DRAW_BUFFERS * 2 <= 8 * sizeof(uint32_t), |
| "All bits of mDrawBufferTypeMask and mActiveOutputVariables types and mask fit " |
| "into 32 bits each"); |
| mDrawBufferTypeMask = gl::ComponentTypeMask(stream->readInt<uint32_t>()); |
| |
| stream->readBool(&mYUVOutput); |
| |
| size_t secondaryOutputVarCount = stream->readInt<size_t>(); |
| ASSERT(getSecondaryOutputLocations().empty()); |
| for (size_t outputIndex = 0; outputIndex < secondaryOutputVarCount; ++outputIndex) |
| { |
| VariableLocation locationData; |
| stream->readInt(&locationData.arrayIndex); |
| stream->readInt(&locationData.index); |
| stream->readBool(&locationData.ignored); |
| mSecondaryOutputLocations.push_back(locationData); |
| } |
| |
| unsigned int defaultUniformRangeLow = stream->readInt<unsigned int>(); |
| unsigned int defaultUniformRangeHigh = stream->readInt<unsigned int>(); |
| mDefaultUniformRange = RangeUI(defaultUniformRangeLow, defaultUniformRangeHigh); |
| |
| unsigned int samplerRangeLow = stream->readInt<unsigned int>(); |
| unsigned int samplerRangeHigh = stream->readInt<unsigned int>(); |
| mSamplerUniformRange = RangeUI(samplerRangeLow, samplerRangeHigh); |
| |
| size_t samplerCount = stream->readInt<size_t>(); |
| for (size_t samplerIndex = 0; samplerIndex < samplerCount; ++samplerIndex) |
| { |
| TextureType textureType = stream->readEnum<TextureType>(); |
| GLenum samplerType = stream->readInt<GLenum>(); |
| SamplerFormat format = stream->readEnum<SamplerFormat>(); |
| size_t bindingCount = stream->readInt<size_t>(); |
| mSamplerBindings.emplace_back(textureType, samplerType, format, bindingCount); |
| } |
| |
| unsigned int imageRangeLow = stream->readInt<unsigned int>(); |
| unsigned int imageRangeHigh = stream->readInt<unsigned int>(); |
| mImageUniformRange = RangeUI(imageRangeLow, imageRangeHigh); |
| |
| size_t imageBindingCount = stream->readInt<size_t>(); |
| for (size_t imageIndex = 0; imageIndex < imageBindingCount; ++imageIndex) |
| { |
| size_t elementCount = stream->readInt<size_t>(); |
| TextureType textureType = static_cast<TextureType>(stream->readInt<unsigned int>()); |
| ImageBinding imageBinding(elementCount, textureType); |
| for (size_t elementIndex = 0; elementIndex < elementCount; ++elementIndex) |
| { |
| imageBinding.boundImageUnits[elementIndex] = stream->readInt<unsigned int>(); |
| } |
| mImageBindings.emplace_back(imageBinding); |
| } |
| |
| unsigned int atomicCounterRangeLow = stream->readInt<unsigned int>(); |
| unsigned int atomicCounterRangeHigh = stream->readInt<unsigned int>(); |
| mAtomicCounterUniformRange = RangeUI(atomicCounterRangeLow, atomicCounterRangeHigh); |
| |
| // These values are currently only used by PPOs, so only load them when the program is marked |
| // separable to save memory. |
| if (isSeparable) |
| { |
| for (ShaderType shaderType : mLinkedShaderStages) |
| { |
| mLinkedOutputVaryings[shaderType].resize(stream->readInt<size_t>()); |
| for (sh::ShaderVariable &variable : mLinkedOutputVaryings[shaderType]) |
| { |
| LoadShaderVar(stream, &variable); |
| } |
| mLinkedInputVaryings[shaderType].resize(stream->readInt<size_t>()); |
| for (sh::ShaderVariable &variable : mLinkedInputVaryings[shaderType]) |
| { |
| LoadShaderVar(stream, &variable); |
| } |
| mLinkedUniforms[shaderType].resize(stream->readInt<size_t>()); |
| for (sh::ShaderVariable &variable : mLinkedUniforms[shaderType]) |
| { |
| LoadShaderVar(stream, &variable); |
| } |
| mLinkedUniformBlocks[shaderType].resize(stream->readInt<size_t>()); |
| for (sh::InterfaceBlock &shaderStorageBlock : mLinkedUniformBlocks[shaderType]) |
| { |
| LoadShInterfaceBlock(stream, &shaderStorageBlock); |
| } |
| mLinkedShaderVersions[shaderType] = stream->readInt<int>(); |
| } |
| } |
| } |
| |
| void ProgramExecutable::save(bool isSeparable, gl::BinaryOutputStream *stream) const |
| { |
| static_assert(MAX_VERTEX_ATTRIBS * 2 <= sizeof(uint32_t) * 8, |
| "All bits of mAttributesTypeMask types and mask fit into 32 bits each"); |
| stream->writeInt(static_cast<uint32_t>(mAttributesTypeMask.to_ulong())); |
| stream->writeInt(static_cast<uint32_t>(mAttributesMask.to_ulong())); |
| stream->writeInt(static_cast<uint32_t>(mActiveAttribLocationsMask.to_ulong())); |
| stream->writeInt(mMaxActiveAttribLocation); |
| |
| stream->writeInt(mFragmentInoutRange.low()); |
| stream->writeInt(mFragmentInoutRange.high()); |
| |
| stream->writeBool(mEnablesPerSampleShading); |
| stream->writeInt(mAdvancedBlendEquations.bits()); |
| |
| stream->writeInt(mLinkedShaderStages.bits()); |
| |
| ASSERT(mGeometryShaderInvocations >= 1 && mGeometryShaderMaxVertices >= 0); |
| stream->writeEnum(mGeometryShaderInputPrimitiveType); |
| stream->writeEnum(mGeometryShaderOutputPrimitiveType); |
| stream->writeInt(mGeometryShaderInvocations); |
| stream->writeInt(mGeometryShaderMaxVertices); |
| |
| stream->writeInt(mTessControlShaderVertices); |
| stream->writeInt(mTessGenMode); |
| stream->writeInt(mTessGenSpacing); |
| stream->writeInt(mTessGenVertexOrder); |
| stream->writeInt(mTessGenPointMode); |
| |
| stream->writeInt(getProgramInputs().size()); |
| for (const sh::ShaderVariable &attrib : getProgramInputs()) |
| { |
| WriteShaderVar(stream, attrib); |
| stream->writeInt(attrib.location); |
| } |
| |
| stream->writeInt(getUniforms().size()); |
| for (const LinkedUniform &uniform : getUniforms()) |
| { |
| WriteShaderVar(stream, uniform); |
| |
| stream->writeInt(uniform.bufferIndex); |
| WriteBlockMemberInfo(stream, uniform.blockInfo); |
| |
| stream->writeIntVector(uniform.outerArraySizes); |
| stream->writeInt(uniform.outerArrayOffset); |
| |
| // Active shader info |
| for (ShaderType shaderType : gl::AllShaderTypes()) |
| { |
| stream->writeBool(uniform.isActive(shaderType)); |
| } |
| } |
| |
| stream->writeInt(getUniformBlocks().size()); |
| for (const InterfaceBlock &uniformBlock : getUniformBlocks()) |
| { |
| WriteInterfaceBlock(stream, uniformBlock); |
| } |
| |
| stream->writeInt(getShaderStorageBlocks().size()); |
| for (const InterfaceBlock &shaderStorageBlock : getShaderStorageBlocks()) |
| { |
| WriteInterfaceBlock(stream, shaderStorageBlock); |
| } |
| |
| stream->writeInt(mAtomicCounterBuffers.size()); |
| for (const AtomicCounterBuffer &atomicCounterBuffer : getAtomicCounterBuffers()) |
| { |
| WriteShaderVariableBuffer(stream, atomicCounterBuffer); |
| } |
| |
| stream->writeInt(getLinkedTransformFeedbackVaryings().size()); |
| for (const auto &var : getLinkedTransformFeedbackVaryings()) |
| { |
| stream->writeIntVector(var.arraySizes); |
| stream->writeInt(var.type); |
| stream->writeString(var.name); |
| |
| stream->writeIntOrNegOne(var.arrayIndex); |
| } |
| |
| stream->writeInt(getTransformFeedbackBufferMode()); |
| |
| stream->writeInt(getOutputVariables().size()); |
| for (const sh::ShaderVariable &output : getOutputVariables()) |
| { |
| WriteShaderVar(stream, output); |
| stream->writeInt(output.location); |
| stream->writeInt(output.index); |
| } |
| |
| stream->writeInt(getOutputLocations().size()); |
| for (const auto &outputVar : getOutputLocations()) |
| { |
| stream->writeInt(outputVar.arrayIndex); |
| stream->writeIntOrNegOne(outputVar.index); |
| stream->writeBool(outputVar.ignored); |
| } |
| |
| stream->writeInt(static_cast<int>(mActiveOutputVariablesMask.to_ulong())); |
| |
| stream->writeInt(mOutputVariableTypes.size()); |
| for (const auto &outputVariableType : mOutputVariableTypes) |
| { |
| stream->writeInt(outputVariableType); |
| } |
| |
| static_assert( |
| IMPLEMENTATION_MAX_DRAW_BUFFERS * 2 <= 8 * sizeof(uint32_t), |
| "All bits of mDrawBufferTypeMask and mActiveOutputVariables can be contained in 32 bits"); |
| stream->writeInt(static_cast<int>(mDrawBufferTypeMask.to_ulong())); |
| |
| stream->writeBool(mYUVOutput); |
| |
| stream->writeInt(getSecondaryOutputLocations().size()); |
| for (const auto &outputVar : getSecondaryOutputLocations()) |
| { |
| stream->writeInt(outputVar.arrayIndex); |
| stream->writeIntOrNegOne(outputVar.index); |
| stream->writeBool(outputVar.ignored); |
| } |
| |
| stream->writeInt(getDefaultUniformRange().low()); |
| stream->writeInt(getDefaultUniformRange().high()); |
| |
| stream->writeInt(getSamplerUniformRange().low()); |
| stream->writeInt(getSamplerUniformRange().high()); |
| |
| stream->writeInt(getSamplerBindings().size()); |
| for (const auto &samplerBinding : getSamplerBindings()) |
| { |
| stream->writeEnum(samplerBinding.textureType); |
| stream->writeInt(samplerBinding.samplerType); |
| stream->writeEnum(samplerBinding.format); |
| stream->writeInt(samplerBinding.boundTextureUnits.size()); |
| } |
| |
| stream->writeInt(getImageUniformRange().low()); |
| stream->writeInt(getImageUniformRange().high()); |
| |
| stream->writeInt(getImageBindings().size()); |
| for (const auto &imageBinding : getImageBindings()) |
| { |
| stream->writeInt(imageBinding.boundImageUnits.size()); |
| stream->writeInt(static_cast<unsigned int>(imageBinding.textureType)); |
| for (size_t i = 0; i < imageBinding.boundImageUnits.size(); ++i) |
| { |
| stream->writeInt(imageBinding.boundImageUnits[i]); |
| } |
| } |
| |
| stream->writeInt(getAtomicCounterUniformRange().low()); |
| stream->writeInt(getAtomicCounterUniformRange().high()); |
| |
| // These values are currently only used by PPOs, so only save them when the program is marked |
| // separable to save memory. |
| if (isSeparable) |
| { |
| for (ShaderType shaderType : mLinkedShaderStages) |
| { |
| stream->writeInt(mLinkedOutputVaryings[shaderType].size()); |
| for (const sh::ShaderVariable &shaderVariable : mLinkedOutputVaryings[shaderType]) |
| { |
| WriteShaderVar(stream, shaderVariable); |
| } |
| stream->writeInt(mLinkedInputVaryings[shaderType].size()); |
| for (const sh::ShaderVariable &shaderVariable : mLinkedInputVaryings[shaderType]) |
| { |
| WriteShaderVar(stream, shaderVariable); |
| } |
| stream->writeInt(mLinkedUniforms[shaderType].size()); |
| for (const sh::ShaderVariable &shaderVariable : mLinkedUniforms[shaderType]) |
| { |
| WriteShaderVar(stream, shaderVariable); |
| } |
| stream->writeInt(mLinkedUniformBlocks[shaderType].size()); |
| for (const sh::InterfaceBlock &shaderStorageBlock : mLinkedUniformBlocks[shaderType]) |
| { |
| WriteShInterfaceBlock(stream, shaderStorageBlock); |
| } |
| stream->writeInt(mLinkedShaderVersions[shaderType]); |
| } |
| } |
| } |
| |
| int ProgramExecutable::getInfoLogLength() const |
| { |
| return static_cast<int>(mInfoLog.getLength()); |
| } |
| |
| void ProgramExecutable::getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog) const |
| { |
| return mInfoLog.getLog(bufSize, length, infoLog); |
| } |
| |
| std::string ProgramExecutable::getInfoLogString() const |
| { |
| return mInfoLog.str(); |
| } |
| |
| bool ProgramExecutable::isAttribLocationActive(size_t attribLocation) const |
| { |
| ASSERT(attribLocation < mActiveAttribLocationsMask.size()); |
| return mActiveAttribLocationsMask[attribLocation]; |
| } |
| |
| AttributesMask ProgramExecutable::getAttributesMask() const |
| { |
| return mAttributesMask; |
| } |
| |
| bool ProgramExecutable::hasDefaultUniforms() const |
| { |
| return !getDefaultUniformRange().empty(); |
| } |
| |
| bool ProgramExecutable::hasTextures() const |
| { |
| return !getSamplerBindings().empty(); |
| } |
| |
| bool ProgramExecutable::hasUniformBuffers() const |
| { |
| return !mUniformBlocks.empty(); |
| } |
| |
| bool ProgramExecutable::hasStorageBuffers() const |
| { |
| return !mShaderStorageBlocks.empty(); |
| } |
| |
| bool ProgramExecutable::hasAtomicCounterBuffers() const |
| { |
| return !mAtomicCounterBuffers.empty(); |
| } |
| |
| bool ProgramExecutable::hasImages() const |
| { |
| return !mImageBindings.empty(); |
| } |
| |
| bool ProgramExecutable::usesFramebufferFetch() const |
| { |
| return (mFragmentInoutRange.length() > 0); |
| } |
| |
| GLuint ProgramExecutable::getUniformIndexFromImageIndex(GLuint imageIndex) const |
| { |
| ASSERT(imageIndex < mImageUniformRange.length()); |
| return imageIndex + mImageUniformRange.low(); |
| } |
| |
| GLuint ProgramExecutable::getUniformIndexFromSamplerIndex(GLuint samplerIndex) const |
| { |
| ASSERT(samplerIndex < mSamplerUniformRange.length()); |
| return samplerIndex + mSamplerUniformRange.low(); |
| } |
| |
| void ProgramExecutable::setActive(size_t textureUnit, |
| const SamplerBinding &samplerBinding, |
| const gl::LinkedUniform &samplerUniform) |
| { |
| mActiveSamplersMask.set(textureUnit); |
| mActiveSamplerTypes[textureUnit] = samplerBinding.textureType; |
| mActiveSamplerYUV[textureUnit] = IsSamplerYUVType(samplerBinding.samplerType); |
| mActiveSamplerFormats[textureUnit] = samplerBinding.format; |
| mActiveSamplerShaderBits[textureUnit] = samplerUniform.activeShaders(); |
| } |
| |
| void ProgramExecutable::setInactive(size_t textureUnit) |
| { |
| mActiveSamplersMask.reset(textureUnit); |
| mActiveSamplerTypes[textureUnit] = TextureType::InvalidEnum; |
| mActiveSamplerYUV.reset(textureUnit); |
| mActiveSamplerFormats[textureUnit] = SamplerFormat::InvalidEnum; |
| mActiveSamplerShaderBits[textureUnit].reset(); |
| } |
| |
| void ProgramExecutable::hasSamplerTypeConflict(size_t textureUnit) |
| { |
| // Conflicts are marked with InvalidEnum |
| mActiveSamplerYUV.reset(textureUnit); |
| mActiveSamplerTypes[textureUnit] = TextureType::InvalidEnum; |
| } |
| |
| void ProgramExecutable::hasSamplerFormatConflict(size_t textureUnit) |
| { |
| // Conflicts are marked with InvalidEnum |
| mActiveSamplerFormats[textureUnit] = SamplerFormat::InvalidEnum; |
| } |
| |
| void ProgramExecutable::updateActiveSamplers(const ProgramState &programState) |
| { |
| const std::vector<SamplerBinding> &samplerBindings = programState.getSamplerBindings(); |
| |
| for (uint32_t samplerIndex = 0; samplerIndex < samplerBindings.size(); ++samplerIndex) |
| { |
| const SamplerBinding &samplerBinding = samplerBindings[samplerIndex]; |
| |
| for (GLint textureUnit : samplerBinding.boundTextureUnits) |
| { |
| if (++mActiveSamplerRefCounts[textureUnit] == 1) |
| { |
| uint32_t uniformIndex = programState.getUniformIndexFromSamplerIndex(samplerIndex); |
| setActive(textureUnit, samplerBinding, programState.getUniforms()[uniformIndex]); |
| } |
| else |
| { |
| if (mActiveSamplerTypes[textureUnit] != samplerBinding.textureType || |
| mActiveSamplerYUV.test(textureUnit) != |
| IsSamplerYUVType(samplerBinding.samplerType)) |
| { |
| hasSamplerTypeConflict(textureUnit); |
| } |
| |
| if (mActiveSamplerFormats[textureUnit] != samplerBinding.format) |
| { |
| hasSamplerFormatConflict(textureUnit); |
| } |
| } |
| mActiveSamplersMask.set(textureUnit); |
| } |
| } |
| |
| // Invalidate the validation cache. |
| resetCachedValidateSamplersResult(); |
| } |
| |
| void ProgramExecutable::updateActiveImages(const ProgramExecutable &executable) |
| { |
| const std::vector<ImageBinding> &imageBindings = executable.getImageBindings(); |
| for (uint32_t imageIndex = 0; imageIndex < imageBindings.size(); ++imageIndex) |
| { |
| const gl::ImageBinding &imageBinding = imageBindings.at(imageIndex); |
| |
| uint32_t uniformIndex = executable.getUniformIndexFromImageIndex(imageIndex); |
| const gl::LinkedUniform &imageUniform = executable.getUniforms()[uniformIndex]; |
| const ShaderBitSet shaderBits = imageUniform.activeShaders(); |
| for (GLint imageUnit : imageBinding.boundImageUnits) |
| { |
| mActiveImagesMask.set(imageUnit); |
| mActiveImageShaderBits[imageUnit] |= shaderBits; |
| } |
| } |
| } |
| |
| void ProgramExecutable::setSamplerUniformTextureTypeAndFormat( |
| size_t textureUnitIndex, |
| std::vector<SamplerBinding> &samplerBindings) |
| { |
| bool foundBinding = false; |
| TextureType foundType = TextureType::InvalidEnum; |
| bool foundYUV = false; |
| SamplerFormat foundFormat = SamplerFormat::InvalidEnum; |
| |
| for (uint32_t samplerIndex = 0; samplerIndex < samplerBindings.size(); ++samplerIndex) |
| { |
| const SamplerBinding &binding = samplerBindings[samplerIndex]; |
| |
| // A conflict exists if samplers of different types are sourced by the same texture unit. |
| // We need to check all bound textures to detect this error case. |
| for (GLuint textureUnit : binding.boundTextureUnits) |
| { |
| if (textureUnit != textureUnitIndex) |
| { |
| continue; |
| } |
| |
| if (!foundBinding) |
| { |
| foundBinding = true; |
| foundType = binding.textureType; |
| foundYUV = IsSamplerYUVType(binding.samplerType); |
| foundFormat = binding.format; |
| uint32_t uniformIndex = getUniformIndexFromSamplerIndex(samplerIndex); |
| setActive(textureUnit, binding, mUniforms[uniformIndex]); |
| } |
| else |
| { |
| if (foundType != binding.textureType || |
| foundYUV != IsSamplerYUVType(binding.samplerType)) |
| { |
| hasSamplerTypeConflict(textureUnit); |
| } |
| |
| if (foundFormat != binding.format) |
| { |
| hasSamplerFormatConflict(textureUnit); |
| } |
| } |
| } |
| } |
| } |
| |
| void ProgramExecutable::updateCanDrawWith() |
| { |
| mCanDrawWith = hasLinkedShaderStage(ShaderType::Vertex); |
| } |
| |
| void ProgramExecutable::saveLinkedStateInfo(const ProgramState &state) |
| { |
| for (ShaderType shaderType : getLinkedShaderStages()) |
| { |
| Shader *shader = state.getAttachedShader(shaderType); |
| ASSERT(shader); |
| mLinkedOutputVaryings[shaderType] = shader->getOutputVaryings(); |
| mLinkedInputVaryings[shaderType] = shader->getInputVaryings(); |
| mLinkedShaderVersions[shaderType] = shader->getShaderVersion(); |
| mLinkedUniforms[shaderType] = shader->getUniforms(); |
| mLinkedUniformBlocks[shaderType] = shader->getUniformBlocks(); |
| } |
| } |
| |
| bool ProgramExecutable::isYUVOutput() const |
| { |
| return mYUVOutput; |
| } |
| |
| ShaderType ProgramExecutable::getLinkedTransformFeedbackStage() const |
| { |
| return GetLastPreFragmentStage(mLinkedShaderStages); |
| } |
| |
| bool ProgramExecutable::linkMergedVaryings( |
| const Context *context, |
| const ProgramMergedVaryings &mergedVaryings, |
| const std::vector<std::string> &transformFeedbackVaryingNames, |
| const LinkingVariables &linkingVariables, |
| bool isSeparable, |
| ProgramVaryingPacking *varyingPacking) |
| { |
| ShaderType tfStage = GetLastPreFragmentStage(linkingVariables.isShaderStageUsedBitset); |
| |
| if (!linkValidateTransformFeedback(context, mergedVaryings, tfStage, |
| transformFeedbackVaryingNames)) |
| { |
| return false; |
| } |
| |
| // Map the varyings to the register file |
| // In WebGL, we use a slightly different handling for packing variables. |
| gl::PackMode packMode = PackMode::ANGLE_RELAXED; |
| if (context->getLimitations().noFlexibleVaryingPacking) |
| { |
| // D3D9 pack mode is strictly more strict than WebGL, so takes priority. |
| packMode = PackMode::ANGLE_NON_CONFORMANT_D3D9; |
| } |
| else if (context->isWebGL()) |
| { |
| packMode = PackMode::WEBGL_STRICT; |
| } |
| |
| // Build active shader stage map. |
| ShaderBitSet activeShadersMask; |
| for (ShaderType shaderType : kAllGraphicsShaderTypes) |
| { |
| // - Check for attached shaders to handle the case of a Program linking the currently |
| // attached shaders. |
| // - Check for linked shaders to handle the case of a PPO linking separable programs before |
| // drawing. |
| if (linkingVariables.isShaderStageUsedBitset[shaderType] || |
| getLinkedShaderStages().test(shaderType)) |
| { |
| activeShadersMask[shaderType] = true; |
| } |
| } |
| |
| if (!varyingPacking->collectAndPackUserVaryings(mInfoLog, context->getCaps(), packMode, |
| activeShadersMask, mergedVaryings, |
| transformFeedbackVaryingNames, isSeparable)) |
| { |
| return false; |
| } |
| |
| gatherTransformFeedbackVaryings(mergedVaryings, tfStage, transformFeedbackVaryingNames); |
| updateTransformFeedbackStrides(); |
| |
| return true; |
| } |
| |
| bool ProgramExecutable::linkValidateTransformFeedback( |
| const Context *context, |
| const ProgramMergedVaryings &varyings, |
| ShaderType stage, |
| const std::vector<std::string> &transformFeedbackVaryingNames) |
| { |
| const Version &version = context->getClientVersion(); |
| |
| // Validate the tf names regardless of the actual program varyings. |
| std::set<std::string> uniqueNames; |
| for (const std::string &tfVaryingName : transformFeedbackVaryingNames) |
| { |
| if (version < Version(3, 1) && tfVaryingName.find('[') != std::string::npos) |
| { |
| mInfoLog << "Capture of array elements is undefined and not supported."; |
| return false; |
| } |
| if (version >= Version(3, 1)) |
| { |
| if (IncludeSameArrayElement(uniqueNames, tfVaryingName)) |
| { |
| mInfoLog << "Two transform feedback varyings include the same array element (" |
| << tfVaryingName << ")."; |
| return false; |
| } |
| } |
| else |
| { |
| if (uniqueNames.count(tfVaryingName) > 0) |
| { |
| mInfoLog << "Two transform feedback varyings specify the same output variable (" |
| << tfVaryingName << ")."; |
| return false; |
| } |
| } |
| uniqueNames.insert(tfVaryingName); |
| } |
| |
| // Validate against program varyings. |
| size_t totalComponents = 0; |
| for (const std::string &tfVaryingName : transformFeedbackVaryingNames) |
| { |
| std::vector<unsigned int> subscripts; |
| std::string baseName = ParseResourceName(tfVaryingName, &subscripts); |
| |
| const sh::ShaderVariable *var = FindOutputVaryingOrField(varyings, stage, baseName); |
| if (var == nullptr) |
| { |
| mInfoLog << "Transform feedback varying " << tfVaryingName |
| << " does not exist in the vertex shader."; |
| return false; |
| } |
| |
| // Validate the matching variable. |
| if (var->isStruct()) |
| { |
| mInfoLog << "Struct cannot be captured directly (" << baseName << ")."; |
| return false; |
| } |
| |
| size_t elementCount = 0; |
| size_t componentCount = 0; |
| |
| if (var->isArray()) |
| { |
| if (version < Version(3, 1)) |
| { |
| mInfoLog << "Capture of arrays is undefined and not supported."; |
| return false; |
| } |
| |
| // GLSL ES 3.10 section 4.3.6: A vertex output can't be an array of arrays. |
| ASSERT(!var->isArrayOfArrays()); |
| |
| if (!subscripts.empty() && subscripts[0] >= var->getOutermostArraySize()) |
| { |
| mInfoLog << "Cannot capture outbound array element '" << tfVaryingName << "'."; |
| return false; |
| } |
| elementCount = (subscripts.empty() ? var->getOutermostArraySize() : 1); |
| } |
| else |
| { |
| if (!subscripts.empty()) |
| { |
| mInfoLog << "Varying '" << baseName |
| << "' is not an array to be captured by element."; |
| return false; |
| } |
| elementCount = 1; |
| } |
| |
| const Caps &caps = context->getCaps(); |
| |
| // TODO(jmadill): Investigate implementation limits on D3D11 |
| componentCount = VariableComponentCount(var->type) * elementCount; |
| if (mTransformFeedbackBufferMode == GL_SEPARATE_ATTRIBS && |
| componentCount > static_cast<GLuint>(caps.maxTransformFeedbackSeparateComponents)) |
| { |
| mInfoLog << "Transform feedback varying " << tfVaryingName << " components (" |
| << componentCount << ") exceed the maximum separate components (" |
| << caps.maxTransformFeedbackSeparateComponents << ")."; |
| return false; |
| } |
| |
| totalComponents += componentCount; |
| if (mTransformFeedbackBufferMode == GL_INTERLEAVED_ATTRIBS && |
| totalComponents > static_cast<GLuint>(caps.maxTransformFeedbackInterleavedComponents)) |
| { |
| mInfoLog << "Transform feedback varying total components (" << totalComponents |
| << ") exceed the maximum interleaved components (" |
| << caps.maxTransformFeedbackInterleavedComponents << ")."; |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| void ProgramExecutable::gatherTransformFeedbackVaryings( |
| const ProgramMergedVaryings &varyings, |
| ShaderType stage, |
| const std::vector<std::string> &transformFeedbackVaryingNames) |
| { |
| // Gather the linked varyings that are used for transform feedback, they should all exist. |
| mLinkedTransformFeedbackVaryings.clear(); |
| for (const std::string &tfVaryingName : transformFeedbackVaryingNames) |
| { |
| std::vector<unsigned int> subscripts; |
| std::string baseName = ParseResourceName(tfVaryingName, &subscripts); |
| size_t subscript = GL_INVALID_INDEX; |
| if (!subscripts.empty()) |
| { |
| subscript = subscripts.back(); |
| } |
| for (const ProgramVaryingRef &ref : varyings) |
| { |
| if (ref.frontShaderStage != stage) |
| { |
| continue; |
| } |
| |
| const sh::ShaderVariable *varying = ref.get(stage); |
| if (baseName == varying->name) |
| { |
| mLinkedTransformFeedbackVaryings.emplace_back(*varying, |
| static_cast<GLuint>(subscript)); |
| break; |
| } |
| else if (varying->isStruct()) |
| { |
| GLuint fieldIndex = 0; |
| const auto *field = varying->findField(tfVaryingName, &fieldIndex); |
| if (field != nullptr) |
| { |
| mLinkedTransformFeedbackVaryings.emplace_back(*field, *varying); |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| void ProgramExecutable::updateTransformFeedbackStrides() |
| { |
| if (mLinkedTransformFeedbackVaryings.empty()) |
| { |
| return; |
| } |
| |
| if (mTransformFeedbackBufferMode == GL_INTERLEAVED_ATTRIBS) |
| { |
| mTransformFeedbackStrides.resize(1); |
| size_t totalSize = 0; |
| for (const TransformFeedbackVarying &varying : mLinkedTransformFeedbackVaryings) |
| { |
| totalSize += varying.size() * VariableExternalSize(varying.type); |
| } |
| mTransformFeedbackStrides[0] = static_cast<GLsizei>(totalSize); |
| } |
| else |
| { |
| mTransformFeedbackStrides.resize(mLinkedTransformFeedbackVaryings.size()); |
| for (size_t i = 0; i < mLinkedTransformFeedbackVaryings.size(); i++) |
| { |
| TransformFeedbackVarying &varying = mLinkedTransformFeedbackVaryings[i]; |
| mTransformFeedbackStrides[i] = |
| static_cast<GLsizei>(varying.size() * VariableExternalSize(varying.type)); |
| } |
| } |
| } |
| |
| bool ProgramExecutable::validateSamplersImpl(InfoLog *infoLog, const Caps &caps) const |
| { |
| // if any two active samplers in a program are of different types, but refer to the same |
| // texture image unit, and this is the current program, then ValidateProgram will fail, and |
| // DrawArrays and DrawElements will issue the INVALID_OPERATION error. |
| for (size_t textureUnit : mActiveSamplersMask) |
| { |
| if (mActiveSamplerTypes[textureUnit] == TextureType::InvalidEnum) |
| { |
| if (infoLog) |
| { |
| (*infoLog) << "Samplers of conflicting types refer to the same texture " |
| "image unit (" |
| << textureUnit << ")."; |
| } |
| |
| mCachedValidateSamplersResult = false; |
| return false; |
| } |
| |
| if (mActiveSamplerFormats[textureUnit] == SamplerFormat::InvalidEnum) |
| { |
| if (infoLog) |
| { |
| (*infoLog) << "Samplers of conflicting formats refer to the same texture " |
| "image unit (" |
| << textureUnit << ")."; |
| } |
| |
| mCachedValidateSamplersResult = false; |
| return false; |
| } |
| } |
| |
| mCachedValidateSamplersResult = true; |
| return true; |
| } |
| |
| bool ProgramExecutable::linkValidateOutputVariables( |
| const Caps &caps, |
| const Extensions &extensions, |
| const Version &version, |
| GLuint combinedImageUniformsCount, |
| GLuint combinedShaderStorageBlocksCount, |
| const std::vector<sh::ShaderVariable> &outputVariables, |
| int fragmentShaderVersion, |
| const ProgramAliasedBindings &fragmentOutputLocations, |
| const ProgramAliasedBindings &fragmentOutputIndices) |
| { |
| ASSERT(mOutputVariableTypes.empty()); |
| ASSERT(mActiveOutputVariablesMask.none()); |
| ASSERT(mDrawBufferTypeMask.none()); |
| ASSERT(!mYUVOutput); |
| |
| // Gather output variable types |
| for (const sh::ShaderVariable &outputVariable : outputVariables) |
| { |
| if (outputVariable.isBuiltIn() && outputVariable.name != "gl_FragColor" && |
| outputVariable.name != "gl_FragData") |
| { |
| continue; |
| } |
| |
| unsigned int baseLocation = |
| (outputVariable.location == -1 ? 0u |
| : static_cast<unsigned int>(outputVariable.location)); |
| |
| // GLSL ES 3.10 section 4.3.6: Output variables cannot be arrays of arrays or arrays of |
| // structures, so we may use getBasicTypeElementCount(). |
| unsigned int elementCount = outputVariable.getBasicTypeElementCount(); |
| for (unsigned int elementIndex = 0; elementIndex < elementCount; elementIndex++) |
| { |
| const unsigned int location = baseLocation + elementIndex; |
| if (location >= mOutputVariableTypes.size()) |
| { |
| mOutputVariableTypes.resize(location + 1, GL_NONE); |
| } |
| ASSERT(location < mActiveOutputVariablesMask.size()); |
| mActiveOutputVariablesMask.set(location); |
| mOutputVariableTypes[location] = VariableComponentType(outputVariable.type); |
| ComponentType componentType = GLenumToComponentType(mOutputVariableTypes[location]); |
| SetComponentTypeMask(componentType, location, &mDrawBufferTypeMask); |
| } |
| |
| if (outputVariable.yuv) |
| { |
| ASSERT(outputVariables.size() == 1); |
| mYUVOutput = true; |
| } |
| } |
| |
| if (version >= ES_3_1) |
| { |
| // [OpenGL ES 3.1] Chapter 8.22 Page 203: |
| // A link error will be generated if the sum of the number of active image uniforms used in |
| // all shaders, the number of active shader storage blocks, and the number of active |
| // fragment shader outputs exceeds the implementation-dependent value of |
| // MAX_COMBINED_SHADER_OUTPUT_RESOURCES. |
| if (combinedImageUniformsCount + combinedShaderStorageBlocksCount + |
| mActiveOutputVariablesMask.count() > |
| static_cast<GLuint>(caps.maxCombinedShaderOutputResources)) |
| { |
| mInfoLog |
| << "The sum of the number of active image uniforms, active shader storage blocks " |
| "and active fragment shader outputs exceeds " |
| "MAX_COMBINED_SHADER_OUTPUT_RESOURCES (" |
| << caps.maxCombinedShaderOutputResources << ")"; |
| return false; |
| } |
| } |
| |
| mOutputVariables = outputVariables; |
| |
| if (fragmentShaderVersion == 100) |
| { |
| return true; |
| } |
| |
| // EXT_blend_func_extended doesn't specify anything related to binding specific elements of an |
| // output array in explicit terms. |
| // |
| // Assuming fragData is an output array, you can defend the position that: |
| // P1) you must support binding "fragData" because it's specified |
| // P2) you must support querying "fragData[x]" because it's specified |
| // P3) you must support binding "fragData[0]" because it's a frequently used pattern |
| // |
| // Then you can make the leap of faith: |
| // P4) you must support binding "fragData[x]" because you support "fragData[0]" |
| // P5) you must support binding "fragData[x]" because you support querying "fragData[x]" |
| // |
| // The spec brings in the "world of arrays" when it mentions binding the arrays and the |
| // automatic binding. Thus it must be interpreted that the thing is not undefined, rather you |
| // must infer the only possible interpretation (?). Note again: this need of interpretation |
| // might be completely off of what GL spec logic is. |
| // |
| // The other complexity is that unless you implement this feature, it's hard to understand what |
| // should happen when the client invokes the feature. You cannot add an additional error as it |
| // is not specified. One can ignore it, but obviously it creates the discrepancies... |
| |
| std::vector<VariableLocation> reservedLocations; |
| |
| // Process any output API bindings for arrays that don't alias to the first element. |
| for (const auto &bindingPair : fragmentOutputLocations) |
| { |
| const std::string &name = bindingPair.first; |
| const ProgramBinding &binding = bindingPair.second; |
| |
| size_t nameLengthWithoutArrayIndex; |
| unsigned int arrayIndex = ParseArrayIndex(name, &nameLengthWithoutArrayIndex); |
| if (arrayIndex == 0 || arrayIndex == GL_INVALID_INDEX) |
| { |
| continue; |
| } |
| for (unsigned int outputVariableIndex = 0; outputVariableIndex < mOutputVariables.size(); |
| outputVariableIndex++) |
| { |
| const sh::ShaderVariable &outputVariable = mOutputVariables[outputVariableIndex]; |
| // Check that the binding corresponds to an output array and its array index fits. |
| if (outputVariable.isBuiltIn() || !outputVariable.isArray() || |
| !angle::BeginsWith(outputVariable.name, name, nameLengthWithoutArrayIndex) || |
| arrayIndex >= outputVariable.getOutermostArraySize()) |
| { |
| continue; |
| } |
| |
| // Get the API index that corresponds to this exact binding. |
| // This index may differ from the index used for the array's base. |
| std::vector<VariableLocation> &outputLocations = |
| fragmentOutputIndices.getBindingByName(name) == 1 ? mSecondaryOutputLocations |
| : mOutputLocations; |
| unsigned int location = binding.location; |
| VariableLocation locationInfo(arrayIndex, outputVariableIndex); |
| if (location >= outputLocations.size()) |
| { |
| outputLocations.resize(location + 1); |
| } |
| if (outputLocations[location].used()) |
| { |
| mInfoLog << "Location of variable " << outputVariable.name |
| << " conflicts with another variable."; |
| return false; |
| } |
| outputLocations[location] = locationInfo; |
| |
| // Note the array binding location so that it can be skipped later. |
| reservedLocations.push_back(locationInfo); |
| } |
| } |
| |
| // Reserve locations for output variables whose location is fixed in the shader or through the |
| // API. Otherwise, the remaining unallocated outputs will be processed later. |
| for (unsigned int outputVariableIndex = 0; outputVariableIndex < mOutputVariables.size(); |
| outputVariableIndex++) |
| { |
| const sh::ShaderVariable &outputVariable = mOutputVariables[outputVariableIndex]; |
| |
| // Don't store outputs for gl_FragDepth, gl_FragColor, etc. |
| if (outputVariable.isBuiltIn()) |
| continue; |
| |
| int fixedLocation = GetOutputLocationForLink(fragmentOutputLocations, outputVariable); |
| if (fixedLocation == -1) |
| { |
| // Here we're only reserving locations for variables whose location is fixed. |
| continue; |
| } |
| unsigned int baseLocation = static_cast<unsigned int>(fixedLocation); |
| |
| std::vector<VariableLocation> &outputLocations = |
| IsOutputSecondaryForLink(fragmentOutputIndices, outputVariable) |
| ? mSecondaryOutputLocations |
| : mOutputLocations; |
| |
| // GLSL ES 3.10 section 4.3.6: Output variables cannot be arrays of arrays or arrays of |
| // structures, so we may use getBasicTypeElementCount(). |
| unsigned int elementCount = outputVariable.getBasicTypeElementCount(); |
| if (FindUsedOutputLocation(outputLocations, baseLocation, elementCount, reservedLocations, |
| outputVariableIndex)) |
| { |
| mInfoLog << "Location of variable " << outputVariable.name |
| << " conflicts with another variable."; |
| return false; |
| } |
| AssignOutputLocations(outputLocations, baseLocation, elementCount, reservedLocations, |
| outputVariableIndex, mOutputVariables[outputVariableIndex]); |
| } |
| |
| // Here we assign locations for the output variables that don't yet have them. Note that we're |
| // not necessarily able to fit the variables optimally, since then we might have to try |
| // different arrangements of output arrays. Now we just assign the locations in the order that |
| // we got the output variables. The spec isn't clear on what kind of algorithm is required for |
| // finding locations for the output variables, so this should be acceptable at least for now. |
| GLuint maxLocation = static_cast<GLuint>(caps.maxDrawBuffers); |
| if (!mSecondaryOutputLocations.empty()) |
| { |
| // EXT_blend_func_extended: Program outputs will be validated against |
| // MAX_DUAL_SOURCE_DRAW_BUFFERS_EXT if there's even one output with index one. |
| maxLocation = caps.maxDualSourceDrawBuffers; |
| } |
| |
| for (unsigned int outputVariableIndex = 0; outputVariableIndex < mOutputVariables.size(); |
| outputVariableIndex++) |
| { |
| const sh::ShaderVariable &outputVariable = mOutputVariables[outputVariableIndex]; |
| |
| // Don't store outputs for gl_FragDepth, gl_FragColor, etc. |
| if (outputVariable.isBuiltIn()) |
| continue; |
| |
| int fixedLocation = GetOutputLocationForLink(fragmentOutputLocations, outputVariable); |
| std::vector<VariableLocation> &outputLocations = |
| IsOutputSecondaryForLink(fragmentOutputIndices, outputVariable) |
| ? mSecondaryOutputLocations |
| : mOutputLocations; |
| unsigned int baseLocation = 0; |
| unsigned int elementCount = outputVariable.getBasicTypeElementCount(); |
| if (fixedLocation != -1) |
| { |
| // Secondary inputs might have caused the max location to drop below what has already |
| // been explicitly assigned locations. Check for any fixed locations above the max |
| // that should cause linking to fail. |
| baseLocation = static_cast<unsigned int>(fixedLocation); |
| } |
| else |
| { |
| // No fixed location, so try to fit the output in unassigned locations. |
| // Try baseLocations starting from 0 one at a time and see if the variable fits. |
| while (FindUsedOutputLocation(outputLocations, baseLocation, elementCount, |
| reservedLocations, outputVariableIndex)) |
| { |
| baseLocation++; |
| } |
| AssignOutputLocations(outputLocations, baseLocation, elementCount, reservedLocations, |
| outputVariableIndex, mOutputVariables[outputVariableIndex]); |
| } |
| |
| // Check for any elements assigned above the max location that are actually used. |
| if (baseLocation + elementCount > maxLocation && |
| (baseLocation >= maxLocation || |
| FindUsedOutputLocation(outputLocations, maxLocation, |
| baseLocation + elementCount - maxLocation, reservedLocations, |
| outputVariableIndex))) |
| { |
| // EXT_blend_func_extended: Linking can fail: |
| // "if the explicit binding assignments do not leave enough space for the linker to |
| // automatically assign a location for a varying out array, which requires multiple |
| // contiguous locations." |
| mInfoLog << "Could not fit output variable into available locations: " |
| << outputVariable.name; |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| bool ProgramExecutable::linkUniforms( |
| const Context *context, |
| const ShaderMap<std::vector<sh::ShaderVariable>> &shaderUniforms, |
| InfoLog &infoLog, |
| const ProgramAliasedBindings &uniformLocationBindings, |
| GLuint *combinedImageUniformsCountOut, |
| std::vector<UnusedUniform> *unusedUniformsOutOrNull, |
| std::vector<VariableLocation> *uniformLocationsOutOrNull) |
| { |
| UniformLinker linker(mLinkedShaderStages, shaderUniforms); |
| if (!linker.link(context->getCaps(), infoLog, uniformLocationBindings)) |
| { |
| return false; |
| } |
| |
| linker.getResults(&mUniforms, unusedUniformsOutOrNull, uniformLocationsOutOrNull); |
| |
| linkSamplerAndImageBindings(combinedImageUniformsCountOut); |
| |
| if (!linkAtomicCounterBuffers(context, infoLog)) |
| { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| void ProgramExecutable::linkSamplerAndImageBindings(GLuint *combinedImageUniforms) |
| { |
| ASSERT(combinedImageUniforms); |
| |
| // Iterate over mExecutable->mUniforms from the back, and find the range of subpass inputs, |
| // atomic counters, images and samplers in that order. |
| auto highIter = mUniforms.rbegin(); |
| auto lowIter = highIter; |
| |
| unsigned int high = static_cast<unsigned int>(mUniforms.size()); |
| unsigned int low = high; |
| |
| // Note that uniform block uniforms are not yet appended to this list. |
| ASSERT(mUniforms.empty() || highIter->isAtomicCounter() || highIter->isImage() || |
| highIter->isSampler() || highIter->isInDefaultBlock() || highIter->isFragmentInOut); |
| |
| for (; lowIter != mUniforms.rend() && lowIter->isFragmentInOut; ++lowIter) |
| { |
| --low; |
| } |
| |
| mFragmentInoutRange = RangeUI(low, high); |
| |
| highIter = lowIter; |
| high = low; |
| |
| for (; lowIter != mUniforms.rend() && lowIter->isAtomicCounter(); ++lowIter) |
| { |
| --low; |
| } |
| |
| mAtomicCounterUniformRange = RangeUI(low, high); |
| |
| highIter = lowIter; |
| high = low; |
| |
| for (; lowIter != mUniforms.rend() && lowIter->isImage(); ++lowIter) |
| { |
| --low; |
| } |
| |
| mImageUniformRange = RangeUI(low, high); |
| *combinedImageUniforms = 0u; |
| // If uniform is a image type, insert it into the mImageBindings array. |
| for (unsigned int imageIndex : mImageUniformRange) |
| { |
| // ES3.1 (section 7.6.1) and GLSL ES3.1 (section 4.4.5), Uniform*i{v} commands |
| // cannot load values into a uniform defined as an image. if declare without a |
| // binding qualifier, any uniform image variable (include all elements of |
| // unbound image array) should be bound to unit zero. |
| auto &imageUniform = mUniforms[imageIndex]; |
| TextureType textureType = ImageTypeToTextureType(imageUniform.type); |
| const GLuint arraySize = imageUniform.isArray() ? imageUniform.arraySizes[0] : 1u; |
| |
| if (imageUniform.binding == -1) |
| { |
| mImageBindings.emplace_back( |
| ImageBinding(imageUniform.getBasicTypeElementCount(), textureType)); |
| } |
| else |
| { |
| // The arrays of arrays are flattened to arrays, it needs to record the array offset for |
| // the correct binding image unit. |
| mImageBindings.emplace_back( |
| ImageBinding(imageUniform.binding + imageUniform.parentArrayIndex() * arraySize, |
| imageUniform.getBasicTypeElementCount(), textureType)); |
| } |
| |
| *combinedImageUniforms += imageUniform.activeShaderCount() * arraySize; |
| } |
| |
| highIter = lowIter; |
| high = low; |
| |
| for (; lowIter != mUniforms.rend() && lowIter->isSampler(); ++lowIter) |
| { |
| --low; |
| } |
| |
| mSamplerUniformRange = RangeUI(low, high); |
| |
| // If uniform is a sampler type, insert it into the mSamplerBindings array. |
| for (unsigned int samplerIndex : mSamplerUniformRange) |
| { |
| const auto &samplerUniform = mUniforms[samplerIndex]; |
| TextureType textureType = SamplerTypeToTextureType(samplerUniform.type); |
| GLenum samplerType = samplerUniform.typeInfo->type; |
| unsigned int elementCount = samplerUniform.getBasicTypeElementCount(); |
| SamplerFormat format = samplerUniform.typeInfo->samplerFormat; |
| mSamplerBindings.emplace_back(textureType, samplerType, format, elementCount); |
| } |
| |
| // Whatever is left constitutes the default uniforms. |
| mDefaultUniformRange = RangeUI(0, low); |
| } |
| |
| bool ProgramExecutable::linkAtomicCounterBuffers(const Context *context, InfoLog &infoLog) |
| { |
| for (unsigned int index : mAtomicCounterUniformRange) |
| { |
| auto &uniform = mUniforms[index]; |
| uniform.blockInfo.offset = uniform.offset; |
| uniform.blockInfo.arrayStride = (uniform.isArray() ? 4 : 0); |
| uniform.blockInfo.matrixStride = 0; |
| uniform.blockInfo.isRowMajorMatrix = false; |
| |
| bool found = false; |
| for (unsigned int bufferIndex = 0; bufferIndex < getActiveAtomicCounterBufferCount(); |
| ++bufferIndex) |
| { |
| auto &buffer = mAtomicCounterBuffers[bufferIndex]; |
| if (buffer.binding == uniform.binding) |
| { |
| buffer.memberIndexes.push_back(index); |
| uniform.bufferIndex = bufferIndex; |
| found = true; |
| buffer.unionReferencesWith(uniform); |
| break; |
| } |
| } |
| if (!found) |
| { |
| AtomicCounterBuffer atomicCounterBuffer; |
| atomicCounterBuffer.binding = uniform.binding; |
| atomicCounterBuffer.memberIndexes.push_back(index); |
| atomicCounterBuffer.unionReferencesWith(uniform); |
| mAtomicCounterBuffers.push_back(atomicCounterBuffer); |
| uniform.bufferIndex = static_cast<int>(getActiveAtomicCounterBufferCount() - 1); |
| } |
| } |
| |
| // Count each atomic counter buffer to validate against |
| // per-stage and combined gl_Max*AtomicCounterBuffers. |
| GLint combinedShaderACBCount = 0; |
| gl::ShaderMap<GLint> perShaderACBCount = {}; |
| for (unsigned int bufferIndex = 0; bufferIndex < getActiveAtomicCounterBufferCount(); |
| ++bufferIndex) |
| { |
| AtomicCounterBuffer &acb = mAtomicCounterBuffers[bufferIndex]; |
| const ShaderBitSet shaderStages = acb.activeShaders(); |
| for (gl::ShaderType shaderType : shaderStages) |
| { |
| ++perShaderACBCount[shaderType]; |
| } |
| ++combinedShaderACBCount; |
| } |
| const Caps &caps = context->getCaps(); |
| if (combinedShaderACBCount > caps.maxCombinedAtomicCounterBuffers) |
| { |
| infoLog << " combined AtomicCounterBuffers count exceeds limit"; |
| return false; |
| } |
| for (gl::ShaderType stage : gl::AllShaderTypes()) |
| { |
| if (perShaderACBCount[stage] > caps.maxShaderAtomicCounterBuffers[stage]) |
| { |
| infoLog << GetShaderTypeString(stage) |
| << " shader AtomicCounterBuffers count exceeds limit"; |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| void ProgramExecutable::copyInputsFromProgram(const ProgramState &programState) |
| { |
| mProgramInputs = programState.getProgramInputs(); |
| } |
| |
| void ProgramExecutable::copyShaderBuffersFromProgram(const ProgramState &programState, |
| ShaderType shaderType) |
| { |
| AppendActiveBlocks(shaderType, programState.getUniformBlocks(), mUniformBlocks); |
| AppendActiveBlocks(shaderType, programState.getShaderStorageBlocks(), mShaderStorageBlocks); |
| AppendActiveBlocks(shaderType, programState.getAtomicCounterBuffers(), mAtomicCounterBuffers); |
| } |
| |
| void ProgramExecutable::clearSamplerBindings() |
| { |
| mSamplerBindings.clear(); |
| } |
| |
| void ProgramExecutable::copySamplerBindingsFromProgram(const ProgramState &programState) |
| { |
| const std::vector<SamplerBinding> &bindings = programState.getSamplerBindings(); |
| mSamplerBindings.insert(mSamplerBindings.end(), bindings.begin(), bindings.end()); |
| } |
| |
| void ProgramExecutable::copyImageBindingsFromProgram(const ProgramState &programState) |
| { |
| const std::vector<ImageBinding> &bindings = programState.getImageBindings(); |
| mImageBindings.insert(mImageBindings.end(), bindings.begin(), bindings.end()); |
| } |
| |
| void ProgramExecutable::copyOutputsFromProgram(const ProgramState &programState) |
| { |
| mOutputVariables = programState.getOutputVariables(); |
| mOutputLocations = programState.getOutputLocations(); |
| mSecondaryOutputLocations = programState.getSecondaryOutputLocations(); |
| } |
| |
| void ProgramExecutable::copyUniformsFromProgramMap(const ShaderMap<Program *> &programs) |
| { |
| // Merge default uniforms. |
| auto getDefaultRange = [](const ProgramState &state) { return state.getDefaultUniformRange(); }; |
| mDefaultUniformRange = AddUniforms(programs, mLinkedShaderStages, mUniforms, getDefaultRange); |
| |
| // Merge sampler uniforms. |
| auto getSamplerRange = [](const ProgramState &state) { return state.getSamplerUniformRange(); }; |
| mSamplerUniformRange = AddUniforms(programs, mLinkedShaderStages, mUniforms, getSamplerRange); |
| |
| // Merge image uniforms. |
| auto getImageRange = [](const ProgramState &state) { return state.getImageUniformRange(); }; |
| mImageUniformRange = AddUniforms(programs, mLinkedShaderStages, mUniforms, getImageRange); |
| |
| // Merge atomic counter uniforms. |
| auto getAtomicRange = [](const ProgramState &state) { |
| return state.getAtomicCounterUniformRange(); |
| }; |
| mAtomicCounterUniformRange = |
| AddUniforms(programs, mLinkedShaderStages, mUniforms, getAtomicRange); |
| |
| // Merge fragment in/out uniforms. |
| auto getInoutRange = [](const ProgramState &state) { return state.getFragmentInoutRange(); }; |
| mFragmentInoutRange = AddUniforms(programs, mLinkedShaderStages, mUniforms, getInoutRange); |
| } |
| } // namespace gl |
