diff options
Diffstat (limited to 'gfx/angle/checkout/src/libANGLE/ProgramExecutable.cpp')
| -rw-r--r-- | gfx/angle/checkout/src/libANGLE/ProgramExecutable.cpp | 1785 |
1 files changed, 1785 insertions, 0 deletions
diff --git a/gfx/angle/checkout/src/libANGLE/ProgramExecutable.cpp b/gfx/angle/checkout/src/libANGLE/ProgramExecutable.cpp new file mode 100644 index 0000000000..6005519347 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/ProgramExecutable.cpp @@ -0,0 +1,1785 @@ +// +// 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), + mHasDiscard(false), + 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), + mHasDiscard(other.mHasDiscard), + 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); + mHasDiscard = false; + 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); + + mHasDiscard = stream->readBool(); + 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(mHasDiscard); + 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 Context *context, const ProgramState &state) +{ + for (ShaderType shaderType : getLinkedShaderStages()) + { + Shader *shader = state.getAttachedShader(shaderType); + ASSERT(shader); + mLinkedOutputVaryings[shaderType] = shader->getOutputVaryings(context); + mLinkedInputVaryings[shaderType] = shader->getInputVaryings(context); + mLinkedShaderVersions[shaderType] = shader->getShaderVersion(context); + mLinkedUniforms[shaderType] = shader->getUniforms(context); + mLinkedUniformBlocks[shaderType] = shader->getUniformBlocks(context); + } +} + +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); + } + + // From OpneGLES spec. 11.1.2.1: A program will fail to link if: + // the count specified by TransformFeedbackVaryings is non-zero, but the + // program object has no vertex, tessellation evaluation, or geometry shader + if (transformFeedbackVaryingNames.size() > 0 && + !gl::ShaderTypeSupportsTransformFeedback(getLinkedTransformFeedbackStage())) + { + mInfoLog << "Linked transform feedback stage " << getLinkedTransformFeedbackStage() + << " does not support transform feedback varying."; + return false; + } + + // 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 |