diff options
Diffstat (limited to 'gfx/angle/src/libANGLE/Program.cpp')
| -rwxr-xr-x | gfx/angle/src/libANGLE/Program.cpp | 2961 |
1 files changed, 2961 insertions, 0 deletions
diff --git a/gfx/angle/src/libANGLE/Program.cpp b/gfx/angle/src/libANGLE/Program.cpp new file mode 100755 index 000000000..06d8d1534 --- /dev/null +++ b/gfx/angle/src/libANGLE/Program.cpp @@ -0,0 +1,2961 @@ +// +// Copyright (c) 2002-2014 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. +// + +// Program.cpp: Implements the gl::Program class. Implements GL program objects +// and related functionality. [OpenGL ES 2.0.24] section 2.10.3 page 28. + +#include "libANGLE/Program.h" + +#include <algorithm> + +#include "common/BitSetIterator.h" +#include "common/debug.h" +#include "common/platform.h" +#include "common/utilities.h" +#include "common/version.h" +#include "compiler/translator/blocklayout.h" +#include "libANGLE/ContextState.h" +#include "libANGLE/ResourceManager.h" +#include "libANGLE/features.h" +#include "libANGLE/renderer/GLImplFactory.h" +#include "libANGLE/renderer/ProgramImpl.h" +#include "libANGLE/queryconversions.h" +#include "libANGLE/Uniform.h" + +namespace gl +{ + +namespace +{ + +void WriteShaderVar(BinaryOutputStream *stream, const sh::ShaderVariable &var) +{ + stream->writeInt(var.type); + stream->writeInt(var.precision); + stream->writeString(var.name); + stream->writeString(var.mappedName); + stream->writeInt(var.arraySize); + stream->writeInt(var.staticUse); + stream->writeString(var.structName); + ASSERT(var.fields.empty()); +} + +void LoadShaderVar(BinaryInputStream *stream, sh::ShaderVariable *var) +{ + var->type = stream->readInt<GLenum>(); + var->precision = stream->readInt<GLenum>(); + var->name = stream->readString(); + var->mappedName = stream->readString(); + var->arraySize = stream->readInt<unsigned int>(); + var->staticUse = stream->readBool(); + var->structName = stream->readString(); +} + +// This simplified cast function doesn't need to worry about advanced concepts like +// depth range values, or casting to bool. +template <typename DestT, typename SrcT> +DestT UniformStateQueryCast(SrcT value); + +// From-Float-To-Integer Casts +template <> +GLint UniformStateQueryCast(GLfloat value) +{ + return clampCast<GLint>(roundf(value)); +} + +template <> +GLuint UniformStateQueryCast(GLfloat value) +{ + return clampCast<GLuint>(roundf(value)); +} + +// From-Integer-to-Integer Casts +template <> +GLint UniformStateQueryCast(GLuint value) +{ + return clampCast<GLint>(value); +} + +template <> +GLuint UniformStateQueryCast(GLint value) +{ + return clampCast<GLuint>(value); +} + +// From-Boolean-to-Anything Casts +template <> +GLfloat UniformStateQueryCast(GLboolean value) +{ + return (value == GL_TRUE ? 1.0f : 0.0f); +} + +template <> +GLint UniformStateQueryCast(GLboolean value) +{ + return (value == GL_TRUE ? 1 : 0); +} + +template <> +GLuint UniformStateQueryCast(GLboolean value) +{ + return (value == GL_TRUE ? 1u : 0u); +} + +// Default to static_cast +template <typename DestT, typename SrcT> +DestT UniformStateQueryCast(SrcT value) +{ + return static_cast<DestT>(value); +} + +template <typename SrcT, typename DestT> +void UniformStateQueryCastLoop(DestT *dataOut, const uint8_t *srcPointer, int components) +{ + for (int comp = 0; comp < components; ++comp) + { + // We only work with strides of 4 bytes for uniform components. (GLfloat/GLint) + // Don't use SrcT stride directly since GLboolean has a stride of 1 byte. + size_t offset = comp * 4; + const SrcT *typedSrcPointer = reinterpret_cast<const SrcT *>(&srcPointer[offset]); + dataOut[comp] = UniformStateQueryCast<DestT>(*typedSrcPointer); + } +} + +bool UniformInList(const std::vector<LinkedUniform> &list, const std::string &name) +{ + for (const LinkedUniform &uniform : list) + { + if (uniform.name == name) + return true; + } + + return false; +} + +} // anonymous namespace + +const char *const g_fakepath = "C:\\fakepath"; + +InfoLog::InfoLog() +{ +} + +InfoLog::~InfoLog() +{ +} + +size_t InfoLog::getLength() const +{ + const std::string &logString = mStream.str(); + return logString.empty() ? 0 : logString.length() + 1; +} + +void InfoLog::getLog(GLsizei bufSize, GLsizei *length, char *infoLog) const +{ + size_t index = 0; + + if (bufSize > 0) + { + const std::string str(mStream.str()); + + if (!str.empty()) + { + index = std::min(static_cast<size_t>(bufSize) - 1, str.length()); + memcpy(infoLog, str.c_str(), index); + } + + infoLog[index] = '\0'; + } + + if (length) + { + *length = static_cast<GLsizei>(index); + } +} + +// append a santized message to the program info log. +// The D3D compiler includes a fake file path in some of the warning or error +// messages, so lets remove all occurrences of this fake file path from the log. +void InfoLog::appendSanitized(const char *message) +{ + std::string msg(message); + + size_t found; + do + { + found = msg.find(g_fakepath); + if (found != std::string::npos) + { + msg.erase(found, strlen(g_fakepath)); + } + } + while (found != std::string::npos); + + mStream << message << std::endl; +} + +void InfoLog::reset() +{ +} + +VariableLocation::VariableLocation() : name(), element(0), index(0), used(false), ignored(false) +{ +} + +VariableLocation::VariableLocation(const std::string &name, + unsigned int element, + unsigned int index) + : name(name), element(element), index(index), used(true), ignored(false) +{ +} + +void Program::Bindings::bindLocation(GLuint index, const std::string &name) +{ + mBindings[name] = index; +} + +int Program::Bindings::getBinding(const std::string &name) const +{ + auto iter = mBindings.find(name); + return (iter != mBindings.end()) ? iter->second : -1; +} + +Program::Bindings::const_iterator Program::Bindings::begin() const +{ + return mBindings.begin(); +} + +Program::Bindings::const_iterator Program::Bindings::end() const +{ + return mBindings.end(); +} + +ProgramState::ProgramState() + : mLabel(), + mAttachedFragmentShader(nullptr), + mAttachedVertexShader(nullptr), + mAttachedComputeShader(nullptr), + mTransformFeedbackBufferMode(GL_INTERLEAVED_ATTRIBS), + mBinaryRetrieveableHint(false) +{ + mComputeShaderLocalSize.fill(1); +} + +ProgramState::~ProgramState() +{ + if (mAttachedVertexShader != nullptr) + { + mAttachedVertexShader->release(); + } + + if (mAttachedFragmentShader != nullptr) + { + mAttachedFragmentShader->release(); + } + + if (mAttachedComputeShader != nullptr) + { + mAttachedComputeShader->release(); + } +} + +const std::string &ProgramState::getLabel() +{ + return mLabel; +} + +const LinkedUniform *ProgramState::getUniformByName(const std::string &name) const +{ + for (const LinkedUniform &linkedUniform : mUniforms) + { + if (linkedUniform.name == name) + { + return &linkedUniform; + } + } + + return nullptr; +} + +GLint ProgramState::getUniformLocation(const std::string &name) const +{ + size_t subscript = GL_INVALID_INDEX; + std::string baseName = gl::ParseUniformName(name, &subscript); + + for (size_t location = 0; location < mUniformLocations.size(); ++location) + { + const VariableLocation &uniformLocation = mUniformLocations[location]; + if (!uniformLocation.used) + { + continue; + } + + const LinkedUniform &uniform = mUniforms[uniformLocation.index]; + + if (uniform.name == baseName) + { + if (uniform.isArray()) + { + if (uniformLocation.element == subscript || + (uniformLocation.element == 0 && subscript == GL_INVALID_INDEX)) + { + return static_cast<GLint>(location); + } + } + else + { + if (subscript == GL_INVALID_INDEX) + { + return static_cast<GLint>(location); + } + } + } + } + + return -1; +} + +GLuint ProgramState::getUniformIndex(const std::string &name) const +{ + size_t subscript = GL_INVALID_INDEX; + std::string baseName = gl::ParseUniformName(name, &subscript); + + // The app is not allowed to specify array indices other than 0 for arrays of basic types + if (subscript != 0 && subscript != GL_INVALID_INDEX) + { + return GL_INVALID_INDEX; + } + + for (size_t index = 0; index < mUniforms.size(); index++) + { + const LinkedUniform &uniform = mUniforms[index]; + if (uniform.name == baseName) + { + if (uniform.isArray() || subscript == GL_INVALID_INDEX) + { + return static_cast<GLuint>(index); + } + } + } + + return GL_INVALID_INDEX; +} + +Program::Program(rx::GLImplFactory *factory, ResourceManager *manager, GLuint handle) + : mProgram(factory->createProgram(mState)), + mValidated(false), + mLinked(false), + mDeleteStatus(false), + mRefCount(0), + mResourceManager(manager), + mHandle(handle), + mSamplerUniformRange(0, 0) +{ + ASSERT(mProgram); + + resetUniformBlockBindings(); + unlink(); +} + +Program::~Program() +{ + unlink(true); + + SafeDelete(mProgram); +} + +void Program::setLabel(const std::string &label) +{ + mState.mLabel = label; +} + +const std::string &Program::getLabel() const +{ + return mState.mLabel; +} + +void Program::attachShader(Shader *shader) +{ + switch (shader->getType()) + { + case GL_VERTEX_SHADER: + { + ASSERT(!mState.mAttachedVertexShader); + mState.mAttachedVertexShader = shader; + mState.mAttachedVertexShader->addRef(); + break; + } + case GL_FRAGMENT_SHADER: + { + ASSERT(!mState.mAttachedFragmentShader); + mState.mAttachedFragmentShader = shader; + mState.mAttachedFragmentShader->addRef(); + break; + } + case GL_COMPUTE_SHADER: + { + ASSERT(!mState.mAttachedComputeShader); + mState.mAttachedComputeShader = shader; + mState.mAttachedComputeShader->addRef(); + break; + } + default: + UNREACHABLE(); + } +} + +bool Program::detachShader(Shader *shader) +{ + switch (shader->getType()) + { + case GL_VERTEX_SHADER: + { + if (mState.mAttachedVertexShader != shader) + { + return false; + } + + shader->release(); + mState.mAttachedVertexShader = nullptr; + break; + } + case GL_FRAGMENT_SHADER: + { + if (mState.mAttachedFragmentShader != shader) + { + return false; + } + + shader->release(); + mState.mAttachedFragmentShader = nullptr; + break; + } + case GL_COMPUTE_SHADER: + { + if (mState.mAttachedComputeShader != shader) + { + return false; + } + + shader->release(); + mState.mAttachedComputeShader = nullptr; + break; + } + default: + UNREACHABLE(); + } + + return true; +} + +int Program::getAttachedShadersCount() const +{ + return (mState.mAttachedVertexShader ? 1 : 0) + (mState.mAttachedFragmentShader ? 1 : 0) + + (mState.mAttachedComputeShader ? 1 : 0); +} + +void Program::bindAttributeLocation(GLuint index, const char *name) +{ + mAttributeBindings.bindLocation(index, name); +} + +void Program::bindUniformLocation(GLuint index, const char *name) +{ + // Bind the base uniform name only since array indices other than 0 cannot be bound + mUniformBindings.bindLocation(index, ParseUniformName(name, nullptr)); +} + +void Program::bindFragmentInputLocation(GLint index, const char *name) +{ + mFragmentInputBindings.bindLocation(index, name); +} + +BindingInfo Program::getFragmentInputBindingInfo(GLint index) const +{ + BindingInfo ret; + ret.type = GL_NONE; + ret.valid = false; + + const Shader *fragmentShader = mState.getAttachedFragmentShader(); + ASSERT(fragmentShader); + + // Find the actual fragment shader varying we're interested in + const std::vector<sh::Varying> &inputs = fragmentShader->getVaryings(); + + for (const auto &binding : mFragmentInputBindings) + { + if (binding.second != static_cast<GLuint>(index)) + continue; + + ret.valid = true; + + std::string originalName = binding.first; + unsigned int arrayIndex = ParseAndStripArrayIndex(&originalName); + + for (const auto &in : inputs) + { + if (in.name == originalName) + { + if (in.isArray()) + { + // The client wants to bind either "name" or "name[0]". + // GL ES 3.1 spec refers to active array names with language such as: + // "if the string identifies the base name of an active array, where the + // string would exactly match the name of the variable if the suffix "[0]" + // were appended to the string". + if (arrayIndex == GL_INVALID_INDEX) + arrayIndex = 0; + + ret.name = in.mappedName + "[" + ToString(arrayIndex) + "]"; + } + else + { + ret.name = in.mappedName; + } + ret.type = in.type; + return ret; + } + } + } + + return ret; +} + +void Program::pathFragmentInputGen(GLint index, + GLenum genMode, + GLint components, + const GLfloat *coeffs) +{ + // If the location is -1 then the command is silently ignored + if (index == -1) + return; + + const auto &binding = getFragmentInputBindingInfo(index); + + // If the input doesn't exist then then the command is silently ignored + // This could happen through optimization for example, the shader translator + // decides that a variable is not actually being used and optimizes it away. + if (binding.name.empty()) + return; + + mProgram->setPathFragmentInputGen(binding.name, genMode, components, coeffs); +} + +// The attached shaders are checked for linking errors by matching up their variables. +// Uniform, input and output variables get collected. +// The code gets compiled into binaries. +Error Program::link(const ContextState &data) +{ + unlink(false); + + mInfoLog.reset(); + resetUniformBlockBindings(); + + const Caps &caps = data.getCaps(); + + bool isComputeShaderAttached = (mState.mAttachedComputeShader != nullptr); + bool nonComputeShadersAttached = + (mState.mAttachedVertexShader != nullptr || mState.mAttachedFragmentShader != nullptr); + // Check whether we both have a compute and non-compute shaders attached. + // If there are of both types attached, then linking should fail. + // OpenGL ES 3.10, 7.3 Program Objects, under LinkProgram + if (isComputeShaderAttached == true && nonComputeShadersAttached == true) + { + mInfoLog << "Both a compute and non-compute shaders are attached to the same program."; + return NoError(); + } + + if (mState.mAttachedComputeShader) + { + if (!mState.mAttachedComputeShader->isCompiled()) + { + mInfoLog << "Attached compute shader is not compiled."; + return NoError(); + } + ASSERT(mState.mAttachedComputeShader->getType() == GL_COMPUTE_SHADER); + + mState.mComputeShaderLocalSize = mState.mAttachedComputeShader->getWorkGroupSize(); + + // GLSL ES 3.10, 4.4.1.1 Compute Shader Inputs + // If the work group size is not specified, a link time error should occur. + if (!mState.mComputeShaderLocalSize.isDeclared()) + { + mInfoLog << "Work group size is not specified."; + return NoError(); + } + + if (!linkUniforms(mInfoLog, caps, mUniformBindings)) + { + return NoError(); + } + + if (!linkUniformBlocks(mInfoLog, caps)) + { + return NoError(); + } + + ANGLE_TRY_RESULT(mProgram->link(data, mInfoLog), mLinked); + if (!mLinked) + { + return NoError(); + } + } + else + { + if (!mState.mAttachedFragmentShader || !mState.mAttachedFragmentShader->isCompiled()) + { + return NoError(); + } + ASSERT(mState.mAttachedFragmentShader->getType() == GL_FRAGMENT_SHADER); + + if (!mState.mAttachedVertexShader || !mState.mAttachedVertexShader->isCompiled()) + { + return NoError(); + } + ASSERT(mState.mAttachedVertexShader->getType() == GL_VERTEX_SHADER); + + if (mState.mAttachedFragmentShader->getShaderVersion() != + mState.mAttachedVertexShader->getShaderVersion()) + { + mInfoLog << "Fragment shader version does not match vertex shader version."; + return NoError(); + } + + if (!linkAttributes(data, mInfoLog, mAttributeBindings, mState.mAttachedVertexShader)) + { + return NoError(); + } + + if (!linkVaryings(mInfoLog, mState.mAttachedVertexShader, mState.mAttachedFragmentShader)) + { + return NoError(); + } + + if (!linkUniforms(mInfoLog, caps, mUniformBindings)) + { + return NoError(); + } + + if (!linkUniformBlocks(mInfoLog, caps)) + { + return NoError(); + } + + const auto &mergedVaryings = getMergedVaryings(); + + if (!linkValidateTransformFeedback(mInfoLog, mergedVaryings, caps)) + { + return NoError(); + } + + linkOutputVariables(); + + ANGLE_TRY_RESULT(mProgram->link(data, mInfoLog), mLinked); + if (!mLinked) + { + return NoError(); + } + + gatherTransformFeedbackVaryings(mergedVaryings); + } + + gatherInterfaceBlockInfo(); + + return NoError(); +} + +// Returns the program object to an unlinked state, before re-linking, or at destruction +void Program::unlink(bool destroy) +{ + if (destroy) // Object being destructed + { + if (mState.mAttachedFragmentShader) + { + mState.mAttachedFragmentShader->release(); + mState.mAttachedFragmentShader = nullptr; + } + + if (mState.mAttachedVertexShader) + { + mState.mAttachedVertexShader->release(); + mState.mAttachedVertexShader = nullptr; + } + + if (mState.mAttachedComputeShader) + { + mState.mAttachedComputeShader->release(); + mState.mAttachedComputeShader = nullptr; + } + } + + mState.mAttributes.clear(); + mState.mActiveAttribLocationsMask.reset(); + mState.mTransformFeedbackVaryingVars.clear(); + mState.mUniforms.clear(); + mState.mUniformLocations.clear(); + mState.mUniformBlocks.clear(); + mState.mOutputVariables.clear(); + mState.mComputeShaderLocalSize.fill(1); + + mValidated = false; + + mLinked = false; +} + +bool Program::isLinked() const +{ + return mLinked; +} + +Error Program::loadBinary(GLenum binaryFormat, const void *binary, GLsizei length) +{ + unlink(false); + +#if ANGLE_PROGRAM_BINARY_LOAD != ANGLE_ENABLED + return Error(GL_NO_ERROR); +#else + ASSERT(binaryFormat == GL_PROGRAM_BINARY_ANGLE); + if (binaryFormat != GL_PROGRAM_BINARY_ANGLE) + { + mInfoLog << "Invalid program binary format."; + return Error(GL_NO_ERROR); + } + + BinaryInputStream stream(binary, length); + + int majorVersion = stream.readInt<int>(); + int minorVersion = stream.readInt<int>(); + if (majorVersion != ANGLE_MAJOR_VERSION || minorVersion != ANGLE_MINOR_VERSION) + { + mInfoLog << "Invalid program binary version."; + return Error(GL_NO_ERROR); + } + + unsigned char commitString[ANGLE_COMMIT_HASH_SIZE]; + stream.readBytes(commitString, ANGLE_COMMIT_HASH_SIZE); + if (memcmp(commitString, ANGLE_COMMIT_HASH, sizeof(unsigned char) * ANGLE_COMMIT_HASH_SIZE) != 0) + { + mInfoLog << "Invalid program binary version."; + return Error(GL_NO_ERROR); + } + + mState.mComputeShaderLocalSize[0] = stream.readInt<int>(); + mState.mComputeShaderLocalSize[1] = stream.readInt<int>(); + mState.mComputeShaderLocalSize[2] = stream.readInt<int>(); + + static_assert(MAX_VERTEX_ATTRIBS <= sizeof(unsigned long) * 8, + "Too many vertex attribs for mask"); + mState.mActiveAttribLocationsMask = stream.readInt<unsigned long>(); + + unsigned int attribCount = stream.readInt<unsigned int>(); + ASSERT(mState.mAttributes.empty()); + for (unsigned int attribIndex = 0; attribIndex < attribCount; ++attribIndex) + { + sh::Attribute attrib; + LoadShaderVar(&stream, &attrib); + attrib.location = stream.readInt<int>(); + mState.mAttributes.push_back(attrib); + } + + unsigned int uniformCount = stream.readInt<unsigned int>(); + ASSERT(mState.mUniforms.empty()); + for (unsigned int uniformIndex = 0; uniformIndex < uniformCount; ++uniformIndex) + { + LinkedUniform uniform; + LoadShaderVar(&stream, &uniform); + + uniform.blockIndex = stream.readInt<int>(); + uniform.blockInfo.offset = stream.readInt<int>(); + uniform.blockInfo.arrayStride = stream.readInt<int>(); + uniform.blockInfo.matrixStride = stream.readInt<int>(); + uniform.blockInfo.isRowMajorMatrix = stream.readBool(); + + mState.mUniforms.push_back(uniform); + } + + const unsigned int uniformIndexCount = stream.readInt<unsigned int>(); + ASSERT(mState.mUniformLocations.empty()); + for (unsigned int uniformIndexIndex = 0; uniformIndexIndex < uniformIndexCount; + uniformIndexIndex++) + { + VariableLocation variable; + stream.readString(&variable.name); + stream.readInt(&variable.element); + stream.readInt(&variable.index); + stream.readBool(&variable.used); + stream.readBool(&variable.ignored); + + mState.mUniformLocations.push_back(variable); + } + + unsigned int uniformBlockCount = stream.readInt<unsigned int>(); + ASSERT(mState.mUniformBlocks.empty()); + for (unsigned int uniformBlockIndex = 0; uniformBlockIndex < uniformBlockCount; + ++uniformBlockIndex) + { + UniformBlock uniformBlock; + stream.readString(&uniformBlock.name); + stream.readBool(&uniformBlock.isArray); + stream.readInt(&uniformBlock.arrayElement); + stream.readInt(&uniformBlock.dataSize); + stream.readBool(&uniformBlock.vertexStaticUse); + stream.readBool(&uniformBlock.fragmentStaticUse); + + unsigned int numMembers = stream.readInt<unsigned int>(); + for (unsigned int blockMemberIndex = 0; blockMemberIndex < numMembers; blockMemberIndex++) + { + uniformBlock.memberUniformIndexes.push_back(stream.readInt<unsigned int>()); + } + + mState.mUniformBlocks.push_back(uniformBlock); + } + + unsigned int transformFeedbackVaryingCount = stream.readInt<unsigned int>(); + ASSERT(mState.mTransformFeedbackVaryingVars.empty()); + for (unsigned int transformFeedbackVaryingIndex = 0; + transformFeedbackVaryingIndex < transformFeedbackVaryingCount; + ++transformFeedbackVaryingIndex) + { + sh::Varying varying; + stream.readInt(&varying.arraySize); + stream.readInt(&varying.type); + stream.readString(&varying.name); + + mState.mTransformFeedbackVaryingVars.push_back(varying); + } + + stream.readInt(&mState.mTransformFeedbackBufferMode); + + unsigned int outputVarCount = stream.readInt<unsigned int>(); + for (unsigned int outputIndex = 0; outputIndex < outputVarCount; ++outputIndex) + { + int locationIndex = stream.readInt<int>(); + VariableLocation locationData; + stream.readInt(&locationData.element); + stream.readInt(&locationData.index); + stream.readString(&locationData.name); + mState.mOutputVariables[locationIndex] = locationData; + } + + stream.readInt(&mSamplerUniformRange.start); + stream.readInt(&mSamplerUniformRange.end); + + ANGLE_TRY_RESULT(mProgram->load(mInfoLog, &stream), mLinked); + + return NoError(); +#endif // #if ANGLE_PROGRAM_BINARY_LOAD == ANGLE_ENABLED +} + +Error Program::saveBinary(GLenum *binaryFormat, void *binary, GLsizei bufSize, GLsizei *length) const +{ + if (binaryFormat) + { + *binaryFormat = GL_PROGRAM_BINARY_ANGLE; + } + + BinaryOutputStream stream; + + stream.writeInt(ANGLE_MAJOR_VERSION); + stream.writeInt(ANGLE_MINOR_VERSION); + stream.writeBytes(reinterpret_cast<const unsigned char*>(ANGLE_COMMIT_HASH), ANGLE_COMMIT_HASH_SIZE); + + stream.writeInt(mState.mComputeShaderLocalSize[0]); + stream.writeInt(mState.mComputeShaderLocalSize[1]); + stream.writeInt(mState.mComputeShaderLocalSize[2]); + + stream.writeInt(mState.mActiveAttribLocationsMask.to_ulong()); + + stream.writeInt(mState.mAttributes.size()); + for (const sh::Attribute &attrib : mState.mAttributes) + { + WriteShaderVar(&stream, attrib); + stream.writeInt(attrib.location); + } + + stream.writeInt(mState.mUniforms.size()); + for (const gl::LinkedUniform &uniform : mState.mUniforms) + { + WriteShaderVar(&stream, uniform); + + // FIXME: referenced + + stream.writeInt(uniform.blockIndex); + stream.writeInt(uniform.blockInfo.offset); + stream.writeInt(uniform.blockInfo.arrayStride); + stream.writeInt(uniform.blockInfo.matrixStride); + stream.writeInt(uniform.blockInfo.isRowMajorMatrix); + } + + stream.writeInt(mState.mUniformLocations.size()); + for (const auto &variable : mState.mUniformLocations) + { + stream.writeString(variable.name); + stream.writeInt(variable.element); + stream.writeInt(variable.index); + stream.writeInt(variable.used); + stream.writeInt(variable.ignored); + } + + stream.writeInt(mState.mUniformBlocks.size()); + for (const UniformBlock &uniformBlock : mState.mUniformBlocks) + { + stream.writeString(uniformBlock.name); + stream.writeInt(uniformBlock.isArray); + stream.writeInt(uniformBlock.arrayElement); + stream.writeInt(uniformBlock.dataSize); + + stream.writeInt(uniformBlock.vertexStaticUse); + stream.writeInt(uniformBlock.fragmentStaticUse); + + stream.writeInt(uniformBlock.memberUniformIndexes.size()); + for (unsigned int memberUniformIndex : uniformBlock.memberUniformIndexes) + { + stream.writeInt(memberUniformIndex); + } + } + + stream.writeInt(mState.mTransformFeedbackVaryingVars.size()); + for (const sh::Varying &varying : mState.mTransformFeedbackVaryingVars) + { + stream.writeInt(varying.arraySize); + stream.writeInt(varying.type); + stream.writeString(varying.name); + } + + stream.writeInt(mState.mTransformFeedbackBufferMode); + + stream.writeInt(mState.mOutputVariables.size()); + for (const auto &outputPair : mState.mOutputVariables) + { + stream.writeInt(outputPair.first); + stream.writeIntOrNegOne(outputPair.second.element); + stream.writeInt(outputPair.second.index); + stream.writeString(outputPair.second.name); + } + + stream.writeInt(mSamplerUniformRange.start); + stream.writeInt(mSamplerUniformRange.end); + + gl::Error error = mProgram->save(&stream); + if (error.isError()) + { + return error; + } + + GLsizei streamLength = static_cast<GLsizei>(stream.length()); + const void *streamState = stream.data(); + + if (streamLength > bufSize) + { + if (length) + { + *length = 0; + } + + // TODO: This should be moved to the validation layer but computing the size of the binary before saving + // it causes the save to happen twice. It may be possible to write the binary to a separate buffer, validate + // sizes and then copy it. + return Error(GL_INVALID_OPERATION); + } + + if (binary) + { + char *ptr = reinterpret_cast<char*>(binary); + + memcpy(ptr, streamState, streamLength); + ptr += streamLength; + + ASSERT(ptr - streamLength == binary); + } + + if (length) + { + *length = streamLength; + } + + return Error(GL_NO_ERROR); +} + +GLint Program::getBinaryLength() const +{ + GLint length; + Error error = saveBinary(nullptr, nullptr, std::numeric_limits<GLint>::max(), &length); + if (error.isError()) + { + return 0; + } + + return length; +} + +void Program::setBinaryRetrievableHint(bool retrievable) +{ + // TODO(jmadill) : replace with dirty bits + mProgram->setBinaryRetrievableHint(retrievable); + mState.mBinaryRetrieveableHint = retrievable; +} + +bool Program::getBinaryRetrievableHint() const +{ + return mState.mBinaryRetrieveableHint; +} + +void Program::release() +{ + mRefCount--; + + if (mRefCount == 0 && mDeleteStatus) + { + mResourceManager->deleteProgram(mHandle); + } +} + +void Program::addRef() +{ + mRefCount++; +} + +unsigned int Program::getRefCount() const +{ + return mRefCount; +} + +int Program::getInfoLogLength() const +{ + return static_cast<int>(mInfoLog.getLength()); +} + +void Program::getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog) const +{ + return mInfoLog.getLog(bufSize, length, infoLog); +} + +void Program::getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shaders) const +{ + int total = 0; + + if (mState.mAttachedComputeShader) + { + if (total < maxCount) + { + shaders[total] = mState.mAttachedComputeShader->getHandle(); + total++; + } + } + + if (mState.mAttachedVertexShader) + { + if (total < maxCount) + { + shaders[total] = mState.mAttachedVertexShader->getHandle(); + total++; + } + } + + if (mState.mAttachedFragmentShader) + { + if (total < maxCount) + { + shaders[total] = mState.mAttachedFragmentShader->getHandle(); + total++; + } + } + + if (count) + { + *count = total; + } +} + +GLuint Program::getAttributeLocation(const std::string &name) const +{ + for (const sh::Attribute &attribute : mState.mAttributes) + { + if (attribute.name == name && attribute.staticUse) + { + return attribute.location; + } + } + + return static_cast<GLuint>(-1); +} + +bool Program::isAttribLocationActive(size_t attribLocation) const +{ + ASSERT(attribLocation < mState.mActiveAttribLocationsMask.size()); + return mState.mActiveAttribLocationsMask[attribLocation]; +} + +void Program::getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) +{ + if (!mLinked) + { + if (bufsize > 0) + { + name[0] = '\0'; + } + + if (length) + { + *length = 0; + } + + *type = GL_NONE; + *size = 1; + return; + } + + size_t attributeIndex = 0; + + for (const sh::Attribute &attribute : mState.mAttributes) + { + // Skip over inactive attributes + if (attribute.staticUse) + { + if (static_cast<size_t>(index) == attributeIndex) + { + break; + } + attributeIndex++; + } + } + + ASSERT(index == attributeIndex && attributeIndex < mState.mAttributes.size()); + const sh::Attribute &attrib = mState.mAttributes[attributeIndex]; + + if (bufsize > 0) + { + const char *string = attrib.name.c_str(); + + strncpy(name, string, bufsize); + name[bufsize - 1] = '\0'; + + if (length) + { + *length = static_cast<GLsizei>(strlen(name)); + } + } + + // Always a single 'type' instance + *size = 1; + *type = attrib.type; +} + +GLint Program::getActiveAttributeCount() const +{ + if (!mLinked) + { + return 0; + } + + GLint count = 0; + + for (const sh::Attribute &attrib : mState.mAttributes) + { + count += (attrib.staticUse ? 1 : 0); + } + + return count; +} + +GLint Program::getActiveAttributeMaxLength() const +{ + if (!mLinked) + { + return 0; + } + + size_t maxLength = 0; + + for (const sh::Attribute &attrib : mState.mAttributes) + { + if (attrib.staticUse) + { + maxLength = std::max(attrib.name.length() + 1, maxLength); + } + } + + return static_cast<GLint>(maxLength); +} + +GLint Program::getFragDataLocation(const std::string &name) const +{ + std::string baseName(name); + unsigned int arrayIndex = ParseAndStripArrayIndex(&baseName); + for (auto outputPair : mState.mOutputVariables) + { + const VariableLocation &outputVariable = outputPair.second; + if (outputVariable.name == baseName && (arrayIndex == GL_INVALID_INDEX || arrayIndex == outputVariable.element)) + { + return static_cast<GLint>(outputPair.first); + } + } + return -1; +} + +void Program::getActiveUniform(GLuint index, + GLsizei bufsize, + GLsizei *length, + GLint *size, + GLenum *type, + GLchar *name) const +{ + if (mLinked) + { + // index must be smaller than getActiveUniformCount() + ASSERT(index < mState.mUniforms.size()); + const LinkedUniform &uniform = mState.mUniforms[index]; + + if (bufsize > 0) + { + std::string string = uniform.name; + if (uniform.isArray()) + { + string += "[0]"; + } + + strncpy(name, string.c_str(), bufsize); + name[bufsize - 1] = '\0'; + + if (length) + { + *length = static_cast<GLsizei>(strlen(name)); + } + } + + *size = uniform.elementCount(); + *type = uniform.type; + } + else + { + if (bufsize > 0) + { + name[0] = '\0'; + } + + if (length) + { + *length = 0; + } + + *size = 0; + *type = GL_NONE; + } +} + +GLint Program::getActiveUniformCount() const +{ + if (mLinked) + { + return static_cast<GLint>(mState.mUniforms.size()); + } + else + { + return 0; + } +} + +GLint Program::getActiveUniformMaxLength() const +{ + size_t maxLength = 0; + + if (mLinked) + { + for (const LinkedUniform &uniform : mState.mUniforms) + { + if (!uniform.name.empty()) + { + size_t length = uniform.name.length() + 1u; + if (uniform.isArray()) + { + length += 3; // Counting in "[0]". + } + maxLength = std::max(length, maxLength); + } + } + } + + return static_cast<GLint>(maxLength); +} + +GLint Program::getActiveUniformi(GLuint index, GLenum pname) const +{ + ASSERT(static_cast<size_t>(index) < mState.mUniforms.size()); + const gl::LinkedUniform &uniform = mState.mUniforms[index]; + switch (pname) + { + case GL_UNIFORM_TYPE: return static_cast<GLint>(uniform.type); + case GL_UNIFORM_SIZE: return static_cast<GLint>(uniform.elementCount()); + case GL_UNIFORM_NAME_LENGTH: return static_cast<GLint>(uniform.name.size() + 1 + (uniform.isArray() ? 3 : 0)); + case GL_UNIFORM_BLOCK_INDEX: return uniform.blockIndex; + case GL_UNIFORM_OFFSET: return uniform.blockInfo.offset; + case GL_UNIFORM_ARRAY_STRIDE: return uniform.blockInfo.arrayStride; + case GL_UNIFORM_MATRIX_STRIDE: return uniform.blockInfo.matrixStride; + case GL_UNIFORM_IS_ROW_MAJOR: return static_cast<GLint>(uniform.blockInfo.isRowMajorMatrix); + default: + UNREACHABLE(); + break; + } + return 0; +} + +bool Program::isValidUniformLocation(GLint location) const +{ + ASSERT(angle::IsValueInRangeForNumericType<GLint>(mState.mUniformLocations.size())); + return (location >= 0 && static_cast<size_t>(location) < mState.mUniformLocations.size() && + mState.mUniformLocations[static_cast<size_t>(location)].used); +} + +bool Program::isIgnoredUniformLocation(GLint location) const +{ + // Location is ignored if it is -1 or it was bound but non-existant in the shader or optimized + // out + return location == -1 || + (location >= 0 && static_cast<size_t>(location) < mState.mUniformLocations.size() && + mState.mUniformLocations[static_cast<size_t>(location)].ignored); +} + +const LinkedUniform &Program::getUniformByLocation(GLint location) const +{ + ASSERT(location >= 0 && static_cast<size_t>(location) < mState.mUniformLocations.size()); + return mState.mUniforms[mState.mUniformLocations[location].index]; +} + +GLint Program::getUniformLocation(const std::string &name) const +{ + return mState.getUniformLocation(name); +} + +GLuint Program::getUniformIndex(const std::string &name) const +{ + return mState.getUniformIndex(name); +} + +void Program::setUniform1fv(GLint location, GLsizei count, const GLfloat *v) +{ + GLsizei clampedCount = setUniformInternal(location, count, 1, v); + mProgram->setUniform1fv(location, clampedCount, v); +} + +void Program::setUniform2fv(GLint location, GLsizei count, const GLfloat *v) +{ + GLsizei clampedCount = setUniformInternal(location, count, 2, v); + mProgram->setUniform2fv(location, clampedCount, v); +} + +void Program::setUniform3fv(GLint location, GLsizei count, const GLfloat *v) +{ + GLsizei clampedCount = setUniformInternal(location, count, 3, v); + mProgram->setUniform3fv(location, clampedCount, v); +} + +void Program::setUniform4fv(GLint location, GLsizei count, const GLfloat *v) +{ + GLsizei clampedCount = setUniformInternal(location, count, 4, v); + mProgram->setUniform4fv(location, clampedCount, v); +} + +void Program::setUniform1iv(GLint location, GLsizei count, const GLint *v) +{ + GLsizei clampedCount = setUniformInternal(location, count, 1, v); + mProgram->setUniform1iv(location, clampedCount, v); +} + +void Program::setUniform2iv(GLint location, GLsizei count, const GLint *v) +{ + GLsizei clampedCount = setUniformInternal(location, count, 2, v); + mProgram->setUniform2iv(location, clampedCount, v); +} + +void Program::setUniform3iv(GLint location, GLsizei count, const GLint *v) +{ + GLsizei clampedCount = setUniformInternal(location, count, 3, v); + mProgram->setUniform3iv(location, clampedCount, v); +} + +void Program::setUniform4iv(GLint location, GLsizei count, const GLint *v) +{ + GLsizei clampedCount = setUniformInternal(location, count, 4, v); + mProgram->setUniform4iv(location, clampedCount, v); +} + +void Program::setUniform1uiv(GLint location, GLsizei count, const GLuint *v) +{ + GLsizei clampedCount = setUniformInternal(location, count, 1, v); + mProgram->setUniform1uiv(location, clampedCount, v); +} + +void Program::setUniform2uiv(GLint location, GLsizei count, const GLuint *v) +{ + GLsizei clampedCount = setUniformInternal(location, count, 2, v); + mProgram->setUniform2uiv(location, clampedCount, v); +} + +void Program::setUniform3uiv(GLint location, GLsizei count, const GLuint *v) +{ + GLsizei clampedCount = setUniformInternal(location, count, 3, v); + mProgram->setUniform3uiv(location, clampedCount, v); +} + +void Program::setUniform4uiv(GLint location, GLsizei count, const GLuint *v) +{ + GLsizei clampedCount = setUniformInternal(location, count, 4, v); + mProgram->setUniform4uiv(location, clampedCount, v); +} + +void Program::setUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v) +{ + GLsizei clampedCount = setMatrixUniformInternal<2, 2>(location, count, transpose, v); + mProgram->setUniformMatrix2fv(location, clampedCount, transpose, v); +} + +void Program::setUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v) +{ + GLsizei clampedCount = setMatrixUniformInternal<3, 3>(location, count, transpose, v); + mProgram->setUniformMatrix3fv(location, clampedCount, transpose, v); +} + +void Program::setUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v) +{ + GLsizei clampedCount = setMatrixUniformInternal<4, 4>(location, count, transpose, v); + mProgram->setUniformMatrix4fv(location, clampedCount, transpose, v); +} + +void Program::setUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v) +{ + GLsizei clampedCount = setMatrixUniformInternal<2, 3>(location, count, transpose, v); + mProgram->setUniformMatrix2x3fv(location, clampedCount, transpose, v); +} + +void Program::setUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v) +{ + GLsizei clampedCount = setMatrixUniformInternal<2, 4>(location, count, transpose, v); + mProgram->setUniformMatrix2x4fv(location, clampedCount, transpose, v); +} + +void Program::setUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v) +{ + GLsizei clampedCount = setMatrixUniformInternal<3, 2>(location, count, transpose, v); + mProgram->setUniformMatrix3x2fv(location, clampedCount, transpose, v); +} + +void Program::setUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v) +{ + GLsizei clampedCount = setMatrixUniformInternal<3, 4>(location, count, transpose, v); + mProgram->setUniformMatrix3x4fv(location, clampedCount, transpose, v); +} + +void Program::setUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v) +{ + GLsizei clampedCount = setMatrixUniformInternal<4, 2>(location, count, transpose, v); + mProgram->setUniformMatrix4x2fv(location, clampedCount, transpose, v); +} + +void Program::setUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v) +{ + GLsizei clampedCount = setMatrixUniformInternal<4, 3>(location, count, transpose, v); + mProgram->setUniformMatrix4x3fv(location, clampedCount, transpose, v); +} + +void Program::getUniformfv(GLint location, GLfloat *v) const +{ + getUniformInternal(location, v); +} + +void Program::getUniformiv(GLint location, GLint *v) const +{ + getUniformInternal(location, v); +} + +void Program::getUniformuiv(GLint location, GLuint *v) const +{ + getUniformInternal(location, v); +} + +void Program::flagForDeletion() +{ + mDeleteStatus = true; +} + +bool Program::isFlaggedForDeletion() const +{ + return mDeleteStatus; +} + +void Program::validate(const Caps &caps) +{ + mInfoLog.reset(); + + if (mLinked) + { + mValidated = (mProgram->validate(caps, &mInfoLog) == GL_TRUE); + } + else + { + mInfoLog << "Program has not been successfully linked."; + } +} + +bool Program::validateSamplers(InfoLog *infoLog, const Caps &caps) +{ + // Skip cache if we're using an infolog, so we get the full error. + // Also skip the cache if the sample mapping has changed, or if we haven't ever validated. + if (infoLog == nullptr && mCachedValidateSamplersResult.valid()) + { + return mCachedValidateSamplersResult.value(); + } + + if (mTextureUnitTypesCache.empty()) + { + mTextureUnitTypesCache.resize(caps.maxCombinedTextureImageUnits, GL_NONE); + } + else + { + std::fill(mTextureUnitTypesCache.begin(), mTextureUnitTypesCache.end(), GL_NONE); + } + + // 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 (unsigned int samplerIndex = mSamplerUniformRange.start; + samplerIndex < mSamplerUniformRange.end; ++samplerIndex) + { + const LinkedUniform &uniform = mState.mUniforms[samplerIndex]; + ASSERT(uniform.isSampler()); + + if (!uniform.staticUse) + continue; + + const GLuint *dataPtr = reinterpret_cast<const GLuint *>(uniform.getDataPtrToElement(0)); + GLenum textureType = SamplerTypeToTextureType(uniform.type); + + for (unsigned int arrayElement = 0; arrayElement < uniform.elementCount(); ++arrayElement) + { + GLuint textureUnit = dataPtr[arrayElement]; + + if (textureUnit >= caps.maxCombinedTextureImageUnits) + { + if (infoLog) + { + (*infoLog) << "Sampler uniform (" << textureUnit + << ") exceeds GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS (" + << caps.maxCombinedTextureImageUnits << ")"; + } + + mCachedValidateSamplersResult = false; + return false; + } + + if (mTextureUnitTypesCache[textureUnit] != GL_NONE) + { + if (textureType != mTextureUnitTypesCache[textureUnit]) + { + if (infoLog) + { + (*infoLog) << "Samplers of conflicting types refer to the same texture " + "image unit (" + << textureUnit << ")."; + } + + mCachedValidateSamplersResult = false; + return false; + } + } + else + { + mTextureUnitTypesCache[textureUnit] = textureType; + } + } + } + + mCachedValidateSamplersResult = true; + return true; +} + +bool Program::isValidated() const +{ + return mValidated; +} + +GLuint Program::getActiveUniformBlockCount() const +{ + return static_cast<GLuint>(mState.mUniformBlocks.size()); +} + +void Program::getActiveUniformBlockName(GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName) const +{ + ASSERT( + uniformBlockIndex < + mState.mUniformBlocks.size()); // index must be smaller than getActiveUniformBlockCount() + + const UniformBlock &uniformBlock = mState.mUniformBlocks[uniformBlockIndex]; + + if (bufSize > 0) + { + std::string string = uniformBlock.name; + + if (uniformBlock.isArray) + { + string += ArrayString(uniformBlock.arrayElement); + } + + strncpy(uniformBlockName, string.c_str(), bufSize); + uniformBlockName[bufSize - 1] = '\0'; + + if (length) + { + *length = static_cast<GLsizei>(strlen(uniformBlockName)); + } + } +} + +GLint Program::getActiveUniformBlockMaxLength() const +{ + int maxLength = 0; + + if (mLinked) + { + unsigned int numUniformBlocks = static_cast<unsigned int>(mState.mUniformBlocks.size()); + for (unsigned int uniformBlockIndex = 0; uniformBlockIndex < numUniformBlocks; uniformBlockIndex++) + { + const UniformBlock &uniformBlock = mState.mUniformBlocks[uniformBlockIndex]; + if (!uniformBlock.name.empty()) + { + const int length = static_cast<int>(uniformBlock.name.length()) + 1; + + // Counting in "[0]". + const int arrayLength = (uniformBlock.isArray ? 3 : 0); + + maxLength = std::max(length + arrayLength, maxLength); + } + } + } + + return maxLength; +} + +GLuint Program::getUniformBlockIndex(const std::string &name) const +{ + size_t subscript = GL_INVALID_INDEX; + std::string baseName = gl::ParseUniformName(name, &subscript); + + unsigned int numUniformBlocks = static_cast<unsigned int>(mState.mUniformBlocks.size()); + for (unsigned int blockIndex = 0; blockIndex < numUniformBlocks; blockIndex++) + { + const gl::UniformBlock &uniformBlock = mState.mUniformBlocks[blockIndex]; + if (uniformBlock.name == baseName) + { + const bool arrayElementZero = + (subscript == GL_INVALID_INDEX && + (!uniformBlock.isArray || uniformBlock.arrayElement == 0)); + if (subscript == uniformBlock.arrayElement || arrayElementZero) + { + return blockIndex; + } + } + } + + return GL_INVALID_INDEX; +} + +const UniformBlock &Program::getUniformBlockByIndex(GLuint index) const +{ + ASSERT(index < static_cast<GLuint>(mState.mUniformBlocks.size())); + return mState.mUniformBlocks[index]; +} + +void Program::bindUniformBlock(GLuint uniformBlockIndex, GLuint uniformBlockBinding) +{ + mState.mUniformBlockBindings[uniformBlockIndex] = uniformBlockBinding; + mProgram->setUniformBlockBinding(uniformBlockIndex, uniformBlockBinding); +} + +GLuint Program::getUniformBlockBinding(GLuint uniformBlockIndex) const +{ + return mState.getUniformBlockBinding(uniformBlockIndex); +} + +void Program::resetUniformBlockBindings() +{ + for (unsigned int blockId = 0; blockId < IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS; blockId++) + { + mState.mUniformBlockBindings[blockId] = 0; + } + mState.mActiveUniformBlockBindings.reset(); +} + +void Program::setTransformFeedbackVaryings(GLsizei count, const GLchar *const *varyings, GLenum bufferMode) +{ + mState.mTransformFeedbackVaryingNames.resize(count); + for (GLsizei i = 0; i < count; i++) + { + mState.mTransformFeedbackVaryingNames[i] = varyings[i]; + } + + mState.mTransformFeedbackBufferMode = bufferMode; +} + +void Program::getTransformFeedbackVarying(GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name) const +{ + if (mLinked) + { + ASSERT(index < mState.mTransformFeedbackVaryingVars.size()); + const sh::Varying &varying = mState.mTransformFeedbackVaryingVars[index]; + GLsizei lastNameIdx = std::min(bufSize - 1, static_cast<GLsizei>(varying.name.length())); + if (length) + { + *length = lastNameIdx; + } + if (size) + { + *size = varying.elementCount(); + } + if (type) + { + *type = varying.type; + } + if (name) + { + memcpy(name, varying.name.c_str(), lastNameIdx); + name[lastNameIdx] = '\0'; + } + } +} + +GLsizei Program::getTransformFeedbackVaryingCount() const +{ + if (mLinked) + { + return static_cast<GLsizei>(mState.mTransformFeedbackVaryingVars.size()); + } + else + { + return 0; + } +} + +GLsizei Program::getTransformFeedbackVaryingMaxLength() const +{ + if (mLinked) + { + GLsizei maxSize = 0; + for (const sh::Varying &varying : mState.mTransformFeedbackVaryingVars) + { + maxSize = std::max(maxSize, static_cast<GLsizei>(varying.name.length() + 1)); + } + + return maxSize; + } + else + { + return 0; + } +} + +GLenum Program::getTransformFeedbackBufferMode() const +{ + return mState.mTransformFeedbackBufferMode; +} + +bool Program::linkVaryings(InfoLog &infoLog, + const Shader *vertexShader, + const Shader *fragmentShader) const +{ + ASSERT(vertexShader->getShaderVersion() == fragmentShader->getShaderVersion()); + + const std::vector<sh::Varying> &vertexVaryings = vertexShader->getVaryings(); + const std::vector<sh::Varying> &fragmentVaryings = fragmentShader->getVaryings(); + + std::map<GLuint, std::string> staticFragmentInputLocations; + + for (const sh::Varying &output : fragmentVaryings) + { + bool matched = false; + + // Built-in varyings obey special rules + if (output.isBuiltIn()) + { + continue; + } + + for (const sh::Varying &input : vertexVaryings) + { + if (output.name == input.name) + { + ASSERT(!input.isBuiltIn()); + if (!linkValidateVaryings(infoLog, output.name, input, output, + vertexShader->getShaderVersion())) + { + return false; + } + + matched = true; + break; + } + } + + // We permit unmatched, unreferenced varyings + if (!matched && output.staticUse) + { + infoLog << "Fragment varying " << output.name << " does not match any vertex varying"; + return false; + } + + // Check for aliased path rendering input bindings (if any). + // If more than one binding refer statically to the same + // location the link must fail. + + if (!output.staticUse) + continue; + + const auto inputBinding = mFragmentInputBindings.getBinding(output.name); + if (inputBinding == -1) + continue; + + const auto it = staticFragmentInputLocations.find(inputBinding); + if (it == std::end(staticFragmentInputLocations)) + { + staticFragmentInputLocations.insert(std::make_pair(inputBinding, output.name)); + } + else + { + infoLog << "Binding for fragment input " << output.name << " conflicts with " + << it->second; + return false; + } + } + + // TODO(jmadill): verify no unmatched vertex varyings? + + return true; +} + +bool Program::validateVertexAndFragmentUniforms(InfoLog &infoLog) const +{ + // Check that uniforms defined in the vertex and fragment shaders are identical + std::map<std::string, LinkedUniform> linkedUniforms; + const std::vector<sh::Uniform> &vertexUniforms = mState.mAttachedVertexShader->getUniforms(); + const std::vector<sh::Uniform> &fragmentUniforms = + mState.mAttachedFragmentShader->getUniforms(); + + for (const sh::Uniform &vertexUniform : vertexUniforms) + { + linkedUniforms[vertexUniform.name] = LinkedUniform(vertexUniform); + } + + for (const sh::Uniform &fragmentUniform : fragmentUniforms) + { + auto entry = linkedUniforms.find(fragmentUniform.name); + if (entry != linkedUniforms.end()) + { + LinkedUniform *vertexUniform = &entry->second; + const std::string &uniformName = "uniform '" + vertexUniform->name + "'"; + if (!linkValidateUniforms(infoLog, uniformName, *vertexUniform, fragmentUniform)) + { + return false; + } + } + } + return true; +} + +bool Program::linkUniforms(gl::InfoLog &infoLog, + const gl::Caps &caps, + const Bindings &uniformBindings) +{ + if (mState.mAttachedVertexShader && mState.mAttachedFragmentShader) + { + ASSERT(mState.mAttachedComputeShader == nullptr); + if (!validateVertexAndFragmentUniforms(infoLog)) + { + return false; + } + } + + // Flatten the uniforms list (nested fields) into a simple list (no nesting). + // Also check the maximum uniform vector and sampler counts. + if (!flattenUniformsAndCheckCaps(caps, infoLog)) + { + return false; + } + + if (!indexUniforms(infoLog, caps, uniformBindings)) + { + return false; + } + + return true; +} + +bool Program::indexUniforms(gl::InfoLog &infoLog, + const gl::Caps &caps, + const Bindings &uniformBindings) +{ + // Uniforms awaiting a location + std::vector<VariableLocation> unboundUniforms; + std::map<GLuint, VariableLocation> boundUniforms; + int maxUniformLocation = -1; + + // Gather bound and unbound uniforms + for (size_t uniformIndex = 0; uniformIndex < mState.mUniforms.size(); uniformIndex++) + { + const gl::LinkedUniform &uniform = mState.mUniforms[uniformIndex]; + + if (uniform.isBuiltIn()) + { + continue; + } + + int bindingLocation = uniformBindings.getBinding(uniform.name); + + // Verify that this location isn't bound twice + if (bindingLocation != -1 && boundUniforms.find(bindingLocation) != boundUniforms.end()) + { + infoLog << "Multiple uniforms bound to location " << bindingLocation << "."; + return false; + } + + for (unsigned int arrayIndex = 0; arrayIndex < uniform.elementCount(); arrayIndex++) + { + VariableLocation location(uniform.name, arrayIndex, + static_cast<unsigned int>(uniformIndex)); + + if (arrayIndex == 0 && bindingLocation != -1) + { + boundUniforms[bindingLocation] = location; + maxUniformLocation = std::max(maxUniformLocation, bindingLocation); + } + else + { + unboundUniforms.push_back(location); + } + } + } + + // Gather the reserved bindings, ones that are bound but not referenced. Other uniforms should + // not be assigned to those locations. + std::set<GLuint> reservedLocations; + for (const auto &binding : uniformBindings) + { + GLuint location = binding.second; + if (boundUniforms.find(location) == boundUniforms.end()) + { + reservedLocations.insert(location); + maxUniformLocation = std::max(maxUniformLocation, static_cast<int>(location)); + } + } + + // Make enough space for all uniforms, bound and unbound + mState.mUniformLocations.resize( + std::max(unboundUniforms.size() + boundUniforms.size() + reservedLocations.size(), + static_cast<size_t>(maxUniformLocation + 1))); + + // Assign bound uniforms + for (const auto &boundUniform : boundUniforms) + { + mState.mUniformLocations[boundUniform.first] = boundUniform.second; + } + + // Assign reserved uniforms + for (const auto &reservedLocation : reservedLocations) + { + mState.mUniformLocations[reservedLocation].ignored = true; + } + + // Assign unbound uniforms + size_t nextUniformLocation = 0; + for (const auto &unboundUniform : unboundUniforms) + { + while (mState.mUniformLocations[nextUniformLocation].used || + mState.mUniformLocations[nextUniformLocation].ignored) + { + nextUniformLocation++; + } + + ASSERT(nextUniformLocation < mState.mUniformLocations.size()); + mState.mUniformLocations[nextUniformLocation] = unboundUniform; + nextUniformLocation++; + } + + return true; +} + +bool Program::linkValidateInterfaceBlockFields(InfoLog &infoLog, + const std::string &uniformName, + const sh::InterfaceBlockField &vertexUniform, + const sh::InterfaceBlockField &fragmentUniform) +{ + // We don't validate precision on UBO fields. See resolution of Khronos bug 10287. + if (!linkValidateVariablesBase(infoLog, uniformName, vertexUniform, fragmentUniform, false)) + { + return false; + } + + if (vertexUniform.isRowMajorLayout != fragmentUniform.isRowMajorLayout) + { + infoLog << "Matrix packings for " << uniformName << " differ between vertex and fragment shaders"; + return false; + } + + return true; +} + +// Determines the mapping between GL attributes and Direct3D 9 vertex stream usage indices +bool Program::linkAttributes(const ContextState &data, + InfoLog &infoLog, + const Bindings &attributeBindings, + const Shader *vertexShader) +{ + unsigned int usedLocations = 0; + mState.mAttributes = vertexShader->getActiveAttributes(); + GLuint maxAttribs = data.getCaps().maxVertexAttributes; + + // TODO(jmadill): handle aliasing robustly + if (mState.mAttributes.size() > maxAttribs) + { + infoLog << "Too many vertex attributes."; + return false; + } + + std::vector<sh::Attribute *> usedAttribMap(maxAttribs, nullptr); + + // Link attributes that have a binding location + for (sh::Attribute &attribute : mState.mAttributes) + { + // TODO(jmadill): do staticUse filtering step here, or not at all + ASSERT(attribute.staticUse); + + int bindingLocation = attributeBindings.getBinding(attribute.name); + if (attribute.location == -1 && bindingLocation != -1) + { + attribute.location = bindingLocation; + } + + if (attribute.location != -1) + { + // Location is set by glBindAttribLocation or by location layout qualifier + const int regs = VariableRegisterCount(attribute.type); + + if (static_cast<GLuint>(regs + attribute.location) > maxAttribs) + { + infoLog << "Active attribute (" << attribute.name << ") at location " + << attribute.location << " is too big to fit"; + + return false; + } + + for (int reg = 0; reg < regs; reg++) + { + const int regLocation = attribute.location + reg; + sh::ShaderVariable *linkedAttribute = usedAttribMap[regLocation]; + + // In GLSL 3.00, attribute aliasing produces a link error + // In GLSL 1.00, attribute aliasing is allowed, but ANGLE currently has a bug + if (linkedAttribute) + { + // TODO(jmadill): fix aliasing on ES2 + // if (mProgram->getShaderVersion() >= 300) + { + infoLog << "Attribute '" << attribute.name << "' aliases attribute '" + << linkedAttribute->name << "' at location " << regLocation; + return false; + } + } + else + { + usedAttribMap[regLocation] = &attribute; + } + + usedLocations |= 1 << regLocation; + } + } + } + + // Link attributes that don't have a binding location + for (sh::Attribute &attribute : mState.mAttributes) + { + ASSERT(attribute.staticUse); + + // Not set by glBindAttribLocation or by location layout qualifier + if (attribute.location == -1) + { + int regs = VariableRegisterCount(attribute.type); + int availableIndex = AllocateFirstFreeBits(&usedLocations, regs, maxAttribs); + + if (availableIndex == -1 || static_cast<GLuint>(availableIndex + regs) > maxAttribs) + { + infoLog << "Too many active attributes (" << attribute.name << ")"; + return false; + } + + attribute.location = availableIndex; + } + } + + for (const sh::Attribute &attribute : mState.mAttributes) + { + ASSERT(attribute.staticUse); + ASSERT(attribute.location != -1); + int regs = VariableRegisterCount(attribute.type); + + for (int r = 0; r < regs; r++) + { + mState.mActiveAttribLocationsMask.set(attribute.location + r); + } + } + + return true; +} + +bool Program::validateUniformBlocksCount(GLuint maxUniformBlocks, + const std::vector<sh::InterfaceBlock> &intefaceBlocks, + const std::string &errorMessage, + InfoLog &infoLog) const +{ + GLuint blockCount = 0; + for (const sh::InterfaceBlock &block : intefaceBlocks) + { + if (block.staticUse || block.layout != sh::BLOCKLAYOUT_PACKED) + { + if (++blockCount > maxUniformBlocks) + { + infoLog << errorMessage << maxUniformBlocks << ")"; + return false; + } + } + } + return true; +} + +bool Program::validateVertexAndFragmentInterfaceBlocks( + const std::vector<sh::InterfaceBlock> &vertexInterfaceBlocks, + const std::vector<sh::InterfaceBlock> &fragmentInterfaceBlocks, + InfoLog &infoLog) const +{ + // Check that interface blocks defined in the vertex and fragment shaders are identical + typedef std::map<std::string, const sh::InterfaceBlock *> UniformBlockMap; + UniformBlockMap linkedUniformBlocks; + + for (const sh::InterfaceBlock &vertexInterfaceBlock : vertexInterfaceBlocks) + { + linkedUniformBlocks[vertexInterfaceBlock.name] = &vertexInterfaceBlock; + } + + for (const sh::InterfaceBlock &fragmentInterfaceBlock : fragmentInterfaceBlocks) + { + auto entry = linkedUniformBlocks.find(fragmentInterfaceBlock.name); + if (entry != linkedUniformBlocks.end()) + { + const sh::InterfaceBlock &vertexInterfaceBlock = *entry->second; + if (!areMatchingInterfaceBlocks(infoLog, vertexInterfaceBlock, fragmentInterfaceBlock)) + { + return false; + } + } + } + return true; +} + +bool Program::linkUniformBlocks(InfoLog &infoLog, const Caps &caps) +{ + if (mState.mAttachedComputeShader) + { + const Shader &computeShader = *mState.mAttachedComputeShader; + const auto &computeInterfaceBlocks = computeShader.getInterfaceBlocks(); + + if (!validateUniformBlocksCount( + caps.maxComputeUniformBlocks, computeInterfaceBlocks, + "Compute shader uniform block count exceeds GL_MAX_COMPUTE_UNIFORM_BLOCKS (", + infoLog)) + { + return false; + } + return true; + } + + const Shader &vertexShader = *mState.mAttachedVertexShader; + const Shader &fragmentShader = *mState.mAttachedFragmentShader; + + const auto &vertexInterfaceBlocks = vertexShader.getInterfaceBlocks(); + const auto &fragmentInterfaceBlocks = fragmentShader.getInterfaceBlocks(); + + if (!validateUniformBlocksCount( + caps.maxVertexUniformBlocks, vertexInterfaceBlocks, + "Vertex shader uniform block count exceeds GL_MAX_VERTEX_UNIFORM_BLOCKS (", infoLog)) + { + return false; + } + if (!validateUniformBlocksCount( + caps.maxFragmentUniformBlocks, fragmentInterfaceBlocks, + "Fragment shader uniform block count exceeds GL_MAX_FRAGMENT_UNIFORM_BLOCKS (", + infoLog)) + { + + return false; + } + if (!validateVertexAndFragmentInterfaceBlocks(vertexInterfaceBlocks, fragmentInterfaceBlocks, + infoLog)) + { + return false; + } + + return true; +} + +bool Program::areMatchingInterfaceBlocks(gl::InfoLog &infoLog, + const sh::InterfaceBlock &vertexInterfaceBlock, + const sh::InterfaceBlock &fragmentInterfaceBlock) const +{ + const char* blockName = vertexInterfaceBlock.name.c_str(); + // validate blocks for the same member types + if (vertexInterfaceBlock.fields.size() != fragmentInterfaceBlock.fields.size()) + { + infoLog << "Types for interface block '" << blockName + << "' differ between vertex and fragment shaders"; + return false; + } + if (vertexInterfaceBlock.arraySize != fragmentInterfaceBlock.arraySize) + { + infoLog << "Array sizes differ for interface block '" << blockName + << "' between vertex and fragment shaders"; + return false; + } + if (vertexInterfaceBlock.layout != fragmentInterfaceBlock.layout || vertexInterfaceBlock.isRowMajorLayout != fragmentInterfaceBlock.isRowMajorLayout) + { + infoLog << "Layout qualifiers differ for interface block '" << blockName + << "' between vertex and fragment shaders"; + return false; + } + const unsigned int numBlockMembers = + static_cast<unsigned int>(vertexInterfaceBlock.fields.size()); + for (unsigned int blockMemberIndex = 0; blockMemberIndex < numBlockMembers; blockMemberIndex++) + { + const sh::InterfaceBlockField &vertexMember = vertexInterfaceBlock.fields[blockMemberIndex]; + const sh::InterfaceBlockField &fragmentMember = fragmentInterfaceBlock.fields[blockMemberIndex]; + if (vertexMember.name != fragmentMember.name) + { + infoLog << "Name mismatch for field " << blockMemberIndex + << " of interface block '" << blockName + << "': (in vertex: '" << vertexMember.name + << "', in fragment: '" << fragmentMember.name << "')"; + return false; + } + std::string memberName = "interface block '" + vertexInterfaceBlock.name + "' member '" + vertexMember.name + "'"; + if (!linkValidateInterfaceBlockFields(infoLog, memberName, vertexMember, fragmentMember)) + { + return false; + } + } + return true; +} + +bool Program::linkValidateVariablesBase(InfoLog &infoLog, const std::string &variableName, const sh::ShaderVariable &vertexVariable, + const sh::ShaderVariable &fragmentVariable, bool validatePrecision) +{ + if (vertexVariable.type != fragmentVariable.type) + { + infoLog << "Types for " << variableName << " differ between vertex and fragment shaders"; + return false; + } + if (vertexVariable.arraySize != fragmentVariable.arraySize) + { + infoLog << "Array sizes for " << variableName << " differ between vertex and fragment shaders"; + return false; + } + if (validatePrecision && vertexVariable.precision != fragmentVariable.precision) + { + infoLog << "Precisions for " << variableName << " differ between vertex and fragment shaders"; + return false; + } + + if (vertexVariable.fields.size() != fragmentVariable.fields.size()) + { + infoLog << "Structure lengths for " << variableName << " differ between vertex and fragment shaders"; + return false; + } + const unsigned int numMembers = static_cast<unsigned int>(vertexVariable.fields.size()); + for (unsigned int memberIndex = 0; memberIndex < numMembers; memberIndex++) + { + const sh::ShaderVariable &vertexMember = vertexVariable.fields[memberIndex]; + const sh::ShaderVariable &fragmentMember = fragmentVariable.fields[memberIndex]; + + if (vertexMember.name != fragmentMember.name) + { + infoLog << "Name mismatch for field '" << memberIndex + << "' of " << variableName + << ": (in vertex: '" << vertexMember.name + << "', in fragment: '" << fragmentMember.name << "')"; + return false; + } + + const std::string memberName = variableName.substr(0, variableName.length() - 1) + "." + + vertexMember.name + "'"; + + if (!linkValidateVariablesBase(infoLog, vertexMember.name, vertexMember, fragmentMember, validatePrecision)) + { + return false; + } + } + + return true; +} + +bool Program::linkValidateUniforms(InfoLog &infoLog, const std::string &uniformName, const sh::Uniform &vertexUniform, const sh::Uniform &fragmentUniform) +{ +#if ANGLE_PROGRAM_LINK_VALIDATE_UNIFORM_PRECISION == ANGLE_ENABLED + const bool validatePrecision = true; +#else + const bool validatePrecision = false; +#endif + + if (!linkValidateVariablesBase(infoLog, uniformName, vertexUniform, fragmentUniform, validatePrecision)) + { + return false; + } + + return true; +} + +bool Program::linkValidateVaryings(InfoLog &infoLog, + const std::string &varyingName, + const sh::Varying &vertexVarying, + const sh::Varying &fragmentVarying, + int shaderVersion) +{ + if (!linkValidateVariablesBase(infoLog, varyingName, vertexVarying, fragmentVarying, false)) + { + return false; + } + + if (!sh::InterpolationTypesMatch(vertexVarying.interpolation, fragmentVarying.interpolation)) + { + infoLog << "Interpolation types for " << varyingName + << " differ between vertex and fragment shaders."; + return false; + } + + if (shaderVersion == 100 && vertexVarying.isInvariant != fragmentVarying.isInvariant) + { + infoLog << "Invariance for " << varyingName + << " differs between vertex and fragment shaders."; + return false; + } + + return true; +} + +bool Program::linkValidateTransformFeedback(InfoLog &infoLog, + const std::vector<const sh::Varying *> &varyings, + const Caps &caps) const +{ + size_t totalComponents = 0; + + std::set<std::string> uniqueNames; + + for (const std::string &tfVaryingName : mState.mTransformFeedbackVaryingNames) + { + bool found = false; + for (const sh::Varying *varying : varyings) + { + if (tfVaryingName == varying->name) + { + if (uniqueNames.count(tfVaryingName) > 0) + { + infoLog << "Two transform feedback varyings specify the same output variable (" + << tfVaryingName << ")."; + return false; + } + uniqueNames.insert(tfVaryingName); + + if (varying->isArray()) + { + infoLog << "Capture of arrays is undefined and not supported."; + return false; + } + + // TODO(jmadill): Investigate implementation limits on D3D11 + size_t componentCount = gl::VariableComponentCount(varying->type); + if (mState.mTransformFeedbackBufferMode == GL_SEPARATE_ATTRIBS && + componentCount > caps.maxTransformFeedbackSeparateComponents) + { + infoLog << "Transform feedback varying's " << varying->name << " components (" + << componentCount << ") exceed the maximum separate components (" + << caps.maxTransformFeedbackSeparateComponents << ")."; + return false; + } + + totalComponents += componentCount; + found = true; + break; + } + } + + if (tfVaryingName.find('[') != std::string::npos) + { + infoLog << "Capture of array elements is undefined and not supported."; + return false; + } + + // All transform feedback varyings are expected to exist since packVaryings checks for them. + ASSERT(found); + } + + if (mState.mTransformFeedbackBufferMode == GL_INTERLEAVED_ATTRIBS && + totalComponents > caps.maxTransformFeedbackInterleavedComponents) + { + infoLog << "Transform feedback varying total components (" << totalComponents + << ") exceed the maximum interleaved components (" + << caps.maxTransformFeedbackInterleavedComponents << ")."; + return false; + } + + return true; +} + +void Program::gatherTransformFeedbackVaryings(const std::vector<const sh::Varying *> &varyings) +{ + // Gather the linked varyings that are used for transform feedback, they should all exist. + mState.mTransformFeedbackVaryingVars.clear(); + for (const std::string &tfVaryingName : mState.mTransformFeedbackVaryingNames) + { + for (const sh::Varying *varying : varyings) + { + if (tfVaryingName == varying->name) + { + mState.mTransformFeedbackVaryingVars.push_back(*varying); + break; + } + } + } +} + +std::vector<const sh::Varying *> Program::getMergedVaryings() const +{ + std::set<std::string> uniqueNames; + std::vector<const sh::Varying *> varyings; + + for (const sh::Varying &varying : mState.mAttachedVertexShader->getVaryings()) + { + if (uniqueNames.count(varying.name) == 0) + { + uniqueNames.insert(varying.name); + varyings.push_back(&varying); + } + } + + for (const sh::Varying &varying : mState.mAttachedFragmentShader->getVaryings()) + { + if (uniqueNames.count(varying.name) == 0) + { + uniqueNames.insert(varying.name); + varyings.push_back(&varying); + } + } + + return varyings; +} + +void Program::linkOutputVariables() +{ + const Shader *fragmentShader = mState.mAttachedFragmentShader; + ASSERT(fragmentShader != nullptr); + + // Skip this step for GLES2 shaders. + if (fragmentShader->getShaderVersion() == 100) + return; + + const auto &shaderOutputVars = fragmentShader->getActiveOutputVariables(); + + // TODO(jmadill): any caps validation here? + + for (unsigned int outputVariableIndex = 0; outputVariableIndex < shaderOutputVars.size(); + outputVariableIndex++) + { + const sh::OutputVariable &outputVariable = shaderOutputVars[outputVariableIndex]; + + // Don't store outputs for gl_FragDepth, gl_FragColor, etc. + if (outputVariable.isBuiltIn()) + continue; + + // Since multiple output locations must be specified, use 0 for non-specified locations. + int baseLocation = (outputVariable.location == -1 ? 0 : outputVariable.location); + + ASSERT(outputVariable.staticUse); + + for (unsigned int elementIndex = 0; elementIndex < outputVariable.elementCount(); + elementIndex++) + { + const int location = baseLocation + elementIndex; + ASSERT(mState.mOutputVariables.count(location) == 0); + unsigned int element = outputVariable.isArray() ? elementIndex : GL_INVALID_INDEX; + mState.mOutputVariables[location] = + VariableLocation(outputVariable.name, element, outputVariableIndex); + } + } +} + +bool Program::flattenUniformsAndCheckCapsForShader(const gl::Shader &shader, + GLuint maxUniformComponents, + GLuint maxTextureImageUnits, + const std::string &componentsErrorMessage, + const std::string &samplerErrorMessage, + std::vector<LinkedUniform> &samplerUniforms, + InfoLog &infoLog) +{ + VectorAndSamplerCount vasCount; + for (const sh::Uniform &uniform : shader.getUniforms()) + { + if (uniform.staticUse) + { + vasCount += flattenUniform(uniform, uniform.name, &samplerUniforms); + } + } + + if (vasCount.vectorCount > maxUniformComponents) + { + infoLog << componentsErrorMessage << maxUniformComponents << ")."; + return false; + } + + if (vasCount.samplerCount > maxTextureImageUnits) + { + infoLog << samplerErrorMessage << maxTextureImageUnits << ")."; + return false; + } + + return true; +} + +bool Program::flattenUniformsAndCheckCaps(const Caps &caps, InfoLog &infoLog) +{ + std::vector<LinkedUniform> samplerUniforms; + + if (mState.mAttachedComputeShader) + { + const gl::Shader *computeShader = mState.getAttachedComputeShader(); + + // TODO (mradev): check whether we need finer-grained component counting + if (!flattenUniformsAndCheckCapsForShader( + *computeShader, caps.maxComputeUniformComponents / 4, + caps.maxComputeTextureImageUnits, + "Compute shader active uniforms exceed MAX_COMPUTE_UNIFORM_COMPONENTS (", + "Compute shader sampler count exceeds MAX_COMPUTE_TEXTURE_IMAGE_UNITS (", + samplerUniforms, infoLog)) + { + return false; + } + } + else + { + const gl::Shader *vertexShader = mState.getAttachedVertexShader(); + + if (!flattenUniformsAndCheckCapsForShader( + *vertexShader, caps.maxVertexUniformVectors, caps.maxVertexTextureImageUnits, + "Vertex shader active uniforms exceed MAX_VERTEX_UNIFORM_VECTORS (", + "Vertex shader sampler count exceeds MAX_VERTEX_TEXTURE_IMAGE_UNITS (", + samplerUniforms, infoLog)) + { + return false; + } + const gl::Shader *fragmentShader = mState.getAttachedFragmentShader(); + + if (!flattenUniformsAndCheckCapsForShader( + *fragmentShader, caps.maxFragmentUniformVectors, caps.maxTextureImageUnits, + "Fragment shader active uniforms exceed MAX_FRAGMENT_UNIFORM_VECTORS (", + "Fragment shader sampler count exceeds MAX_TEXTURE_IMAGE_UNITS (", samplerUniforms, + infoLog)) + { + return false; + } + } + + mSamplerUniformRange.start = static_cast<unsigned int>(mState.mUniforms.size()); + mSamplerUniformRange.end = + mSamplerUniformRange.start + static_cast<unsigned int>(samplerUniforms.size()); + + mState.mUniforms.insert(mState.mUniforms.end(), samplerUniforms.begin(), samplerUniforms.end()); + + return true; +} + +Program::VectorAndSamplerCount Program::flattenUniform(const sh::ShaderVariable &uniform, + const std::string &fullName, + std::vector<LinkedUniform> *samplerUniforms) +{ + VectorAndSamplerCount vectorAndSamplerCount; + + if (uniform.isStruct()) + { + for (unsigned int elementIndex = 0; elementIndex < uniform.elementCount(); elementIndex++) + { + const std::string &elementString = (uniform.isArray() ? ArrayString(elementIndex) : ""); + + for (size_t fieldIndex = 0; fieldIndex < uniform.fields.size(); fieldIndex++) + { + const sh::ShaderVariable &field = uniform.fields[fieldIndex]; + const std::string &fieldFullName = (fullName + elementString + "." + field.name); + + vectorAndSamplerCount += flattenUniform(field, fieldFullName, samplerUniforms); + } + } + + return vectorAndSamplerCount; + } + + // Not a struct + bool isSampler = IsSamplerType(uniform.type); + if (!UniformInList(mState.getUniforms(), fullName) && + !UniformInList(*samplerUniforms, fullName)) + { + gl::LinkedUniform linkedUniform(uniform.type, uniform.precision, fullName, + uniform.arraySize, -1, + sh::BlockMemberInfo::getDefaultBlockInfo()); + linkedUniform.staticUse = true; + + // Store sampler uniforms separately, so we'll append them to the end of the list. + if (isSampler) + { + samplerUniforms->push_back(linkedUniform); + } + else + { + mState.mUniforms.push_back(linkedUniform); + } + } + + unsigned int elementCount = uniform.elementCount(); + + // Samplers aren't "real" uniforms, so they don't count towards register usage. + // Likewise, don't count "real" uniforms towards sampler count. + vectorAndSamplerCount.vectorCount = + (isSampler ? 0 : (VariableRegisterCount(uniform.type) * elementCount)); + vectorAndSamplerCount.samplerCount = (isSampler ? elementCount : 0); + + return vectorAndSamplerCount; +} + +void Program::gatherInterfaceBlockInfo() +{ + ASSERT(mState.mUniformBlocks.empty()); + + if (mState.mAttachedComputeShader) + { + const gl::Shader *computeShader = mState.getAttachedComputeShader(); + + for (const sh::InterfaceBlock &computeBlock : computeShader->getInterfaceBlocks()) + { + + // Only 'packed' blocks are allowed to be considered inactive. + if (!computeBlock.staticUse && computeBlock.layout == sh::BLOCKLAYOUT_PACKED) + continue; + + for (gl::UniformBlock &block : mState.mUniformBlocks) + { + if (block.name == computeBlock.name) + { + block.computeStaticUse = computeBlock.staticUse; + } + } + + defineUniformBlock(computeBlock, GL_COMPUTE_SHADER); + } + return; + } + + std::set<std::string> visitedList; + + const gl::Shader *vertexShader = mState.getAttachedVertexShader(); + + for (const sh::InterfaceBlock &vertexBlock : vertexShader->getInterfaceBlocks()) + { + // Only 'packed' blocks are allowed to be considered inactive. + if (!vertexBlock.staticUse && vertexBlock.layout == sh::BLOCKLAYOUT_PACKED) + continue; + + if (visitedList.count(vertexBlock.name) > 0) + continue; + + defineUniformBlock(vertexBlock, GL_VERTEX_SHADER); + visitedList.insert(vertexBlock.name); + } + + const gl::Shader *fragmentShader = mState.getAttachedFragmentShader(); + + for (const sh::InterfaceBlock &fragmentBlock : fragmentShader->getInterfaceBlocks()) + { + // Only 'packed' blocks are allowed to be considered inactive. + if (!fragmentBlock.staticUse && fragmentBlock.layout == sh::BLOCKLAYOUT_PACKED) + continue; + + if (visitedList.count(fragmentBlock.name) > 0) + { + for (gl::UniformBlock &block : mState.mUniformBlocks) + { + if (block.name == fragmentBlock.name) + { + block.fragmentStaticUse = fragmentBlock.staticUse; + } + } + + continue; + } + + defineUniformBlock(fragmentBlock, GL_FRAGMENT_SHADER); + visitedList.insert(fragmentBlock.name); + } +} + +template <typename VarT> +void Program::defineUniformBlockMembers(const std::vector<VarT> &fields, + const std::string &prefix, + int blockIndex) +{ + for (const VarT &field : fields) + { + const std::string &fullName = (prefix.empty() ? field.name : prefix + "." + field.name); + + if (field.isStruct()) + { + for (unsigned int arrayElement = 0; arrayElement < field.elementCount(); arrayElement++) + { + const std::string uniformElementName = + fullName + (field.isArray() ? ArrayString(arrayElement) : ""); + defineUniformBlockMembers(field.fields, uniformElementName, blockIndex); + } + } + else + { + // If getBlockMemberInfo returns false, the uniform is optimized out. + sh::BlockMemberInfo memberInfo; + if (!mProgram->getUniformBlockMemberInfo(fullName, &memberInfo)) + { + continue; + } + + LinkedUniform newUniform(field.type, field.precision, fullName, field.arraySize, + blockIndex, memberInfo); + + // Since block uniforms have no location, we don't need to store them in the uniform + // locations list. + mState.mUniforms.push_back(newUniform); + } + } +} + +void Program::defineUniformBlock(const sh::InterfaceBlock &interfaceBlock, GLenum shaderType) +{ + int blockIndex = static_cast<int>(mState.mUniformBlocks.size()); + size_t blockSize = 0; + + // Don't define this block at all if it's not active in the implementation. + std::stringstream blockNameStr; + blockNameStr << interfaceBlock.name; + if (interfaceBlock.arraySize > 0) + { + blockNameStr << "[0]"; + } + if (!mProgram->getUniformBlockSize(blockNameStr.str(), &blockSize)) + { + return; + } + + // Track the first and last uniform index to determine the range of active uniforms in the + // block. + size_t firstBlockUniformIndex = mState.mUniforms.size(); + defineUniformBlockMembers(interfaceBlock.fields, interfaceBlock.fieldPrefix(), blockIndex); + size_t lastBlockUniformIndex = mState.mUniforms.size(); + + std::vector<unsigned int> blockUniformIndexes; + for (size_t blockUniformIndex = firstBlockUniformIndex; + blockUniformIndex < lastBlockUniformIndex; ++blockUniformIndex) + { + blockUniformIndexes.push_back(static_cast<unsigned int>(blockUniformIndex)); + } + + if (interfaceBlock.arraySize > 0) + { + for (unsigned int arrayElement = 0; arrayElement < interfaceBlock.arraySize; ++arrayElement) + { + UniformBlock block(interfaceBlock.name, true, arrayElement); + block.memberUniformIndexes = blockUniformIndexes; + + switch (shaderType) + { + case GL_VERTEX_SHADER: + { + block.vertexStaticUse = interfaceBlock.staticUse; + break; + } + case GL_FRAGMENT_SHADER: + { + block.fragmentStaticUse = interfaceBlock.staticUse; + break; + } + case GL_COMPUTE_SHADER: + { + block.computeStaticUse = interfaceBlock.staticUse; + break; + } + default: + UNREACHABLE(); + } + + // Since all block elements in an array share the same active uniforms, they will all be + // active once any uniform member is used. So, since interfaceBlock.name[0] was active, + // here we will add every block element in the array. + block.dataSize = static_cast<unsigned int>(blockSize); + mState.mUniformBlocks.push_back(block); + } + } + else + { + UniformBlock block(interfaceBlock.name, false, 0); + block.memberUniformIndexes = blockUniformIndexes; + + switch (shaderType) + { + case GL_VERTEX_SHADER: + { + block.vertexStaticUse = interfaceBlock.staticUse; + break; + } + case GL_FRAGMENT_SHADER: + { + block.fragmentStaticUse = interfaceBlock.staticUse; + break; + } + case GL_COMPUTE_SHADER: + { + block.computeStaticUse = interfaceBlock.staticUse; + break; + } + default: + UNREACHABLE(); + } + + block.dataSize = static_cast<unsigned int>(blockSize); + mState.mUniformBlocks.push_back(block); + } +} + +template <typename T> +GLsizei Program::setUniformInternal(GLint location, GLsizei countIn, int vectorSize, const T *v) +{ + const VariableLocation &locationInfo = mState.mUniformLocations[location]; + LinkedUniform *linkedUniform = &mState.mUniforms[locationInfo.index]; + uint8_t *destPointer = linkedUniform->getDataPtrToElement(locationInfo.element); + + // OpenGL ES 3.0.4 spec pg 67: "Values for any array element that exceeds the highest array + // element index used, as reported by GetActiveUniform, will be ignored by the GL." + unsigned int remainingElements = linkedUniform->elementCount() - locationInfo.element; + GLsizei maxElementCount = + static_cast<GLsizei>(remainingElements * linkedUniform->getElementComponents()); + + GLsizei count = countIn; + GLsizei clampedCount = count * vectorSize; + if (clampedCount > maxElementCount) + { + clampedCount = maxElementCount; + count = maxElementCount / vectorSize; + } + + if (VariableComponentType(linkedUniform->type) == GL_BOOL) + { + // Do a cast conversion for boolean types. From the spec: + // "The uniform is set to FALSE if the input value is 0 or 0.0f, and set to TRUE otherwise." + GLint *destAsInt = reinterpret_cast<GLint *>(destPointer); + for (GLsizei component = 0; component < clampedCount; ++component) + { + destAsInt[component] = (v[component] != static_cast<T>(0) ? GL_TRUE : GL_FALSE); + } + } + else + { + // Invalide the validation cache if we modify the sampler data. + if (linkedUniform->isSampler() && memcmp(destPointer, v, sizeof(T) * clampedCount) != 0) + { + mCachedValidateSamplersResult.reset(); + } + + memcpy(destPointer, v, sizeof(T) * clampedCount); + } + + return count; +} + +template <size_t cols, size_t rows, typename T> +GLsizei Program::setMatrixUniformInternal(GLint location, + GLsizei count, + GLboolean transpose, + const T *v) +{ + if (!transpose) + { + return setUniformInternal(location, count, cols * rows, v); + } + + // Perform a transposing copy. + const VariableLocation &locationInfo = mState.mUniformLocations[location]; + LinkedUniform *linkedUniform = &mState.mUniforms[locationInfo.index]; + T *destPtr = reinterpret_cast<T *>(linkedUniform->getDataPtrToElement(locationInfo.element)); + + // OpenGL ES 3.0.4 spec pg 67: "Values for any array element that exceeds the highest array + // element index used, as reported by GetActiveUniform, will be ignored by the GL." + unsigned int remainingElements = linkedUniform->elementCount() - locationInfo.element; + GLsizei clampedCount = std::min(count, static_cast<GLsizei>(remainingElements)); + + for (GLsizei element = 0; element < clampedCount; ++element) + { + size_t elementOffset = element * rows * cols; + + for (size_t row = 0; row < rows; ++row) + { + for (size_t col = 0; col < cols; ++col) + { + destPtr[col * rows + row + elementOffset] = v[row * cols + col + elementOffset]; + } + } + } + + return clampedCount; +} + +template <typename DestT> +void Program::getUniformInternal(GLint location, DestT *dataOut) const +{ + const VariableLocation &locationInfo = mState.mUniformLocations[location]; + const LinkedUniform &uniform = mState.mUniforms[locationInfo.index]; + + const uint8_t *srcPointer = uniform.getDataPtrToElement(locationInfo.element); + + GLenum componentType = VariableComponentType(uniform.type); + if (componentType == GLTypeToGLenum<DestT>::value) + { + memcpy(dataOut, srcPointer, uniform.getElementSize()); + return; + } + + int components = VariableComponentCount(uniform.type); + + switch (componentType) + { + case GL_INT: + UniformStateQueryCastLoop<GLint>(dataOut, srcPointer, components); + break; + case GL_UNSIGNED_INT: + UniformStateQueryCastLoop<GLuint>(dataOut, srcPointer, components); + break; + case GL_BOOL: + UniformStateQueryCastLoop<GLboolean>(dataOut, srcPointer, components); + break; + case GL_FLOAT: + UniformStateQueryCastLoop<GLfloat>(dataOut, srcPointer, components); + break; + default: + UNREACHABLE(); + } +} +} |