Micro-optimize Uniform updates.

src/libANGLE/Program.cpp

@@ -1405,19 +1405,27 @@ bool Program::isValidUniformLocation(GLint location) const
             mState.mUniformLocations[static_cast<size_t>(location)].used);
 }
 
-bool Program::isIgnoredUniformLocation(GLint location) const
+const LinkedUniform &Program::getUniformByLocation(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);
+    ASSERT(location >= 0 && static_cast<size_t>(location) < mState.mUniformLocations.size());
+    return mState.mUniforms[mState.getUniformIndexFromLocation(location)];
 }
 
-const LinkedUniform &Program::getUniformByLocation(GLint location) const
+const VariableLocation &Program::getUniformLocation(GLint location) const
 {
     ASSERT(location >= 0 && static_cast<size_t>(location) < mState.mUniformLocations.size());
-    return mState.mUniforms[mState.getUniformIndexFromLocation(location)];
+    return mState.mUniformLocations[location];
+}
+
+const std::vector<VariableLocation> &Program::getUniformLocations() const
+{
+    return mState.mUniformLocations;
+}
+
+const LinkedUniform &Program::getUniformByIndex(GLuint index) const
+{
+    ASSERT(index < static_cast<size_t>(mState.mUniforms.size()));
+    return mState.mUniforms[index];
 }
 
 GLint Program::getUniformLocation(const std::string &name) const

src/libANGLE/Program.h

@@ -330,8 +330,10 @@ class Program final : angle::NonCopyable, public LabeledObject
     GLint getActiveUniformMaxLength() const;
     GLint getActiveUniformi(GLuint index, GLenum pname) const;
     bool isValidUniformLocation(GLint location) const;
-    bool isIgnoredUniformLocation(GLint location) const;
     const LinkedUniform &getUniformByLocation(GLint location) const;
+    const VariableLocation &getUniformLocation(GLint location) const;
+    const std::vector<VariableLocation> &getUniformLocations() const;
+    const LinkedUniform &getUniformByIndex(GLuint index) const;
 
     GLint getUniformLocation(const std::string &name) const;
     GLuint getUniformIndex(const std::string &name) const;
@@ -464,8 +466,6 @@ class Program final : angle::NonCopyable, public LabeledObject
                                        const Caps &caps) const;
 
     void gatherTransformFeedbackVaryings(const MergedVaryings &varyings);
-    bool assignUniformBlockRegister(InfoLog &infoLog, UniformBlock *uniformBlock, GLenum shader, unsigned int registerIndex, const Caps &caps);
-    void defineOutputVariables(Shader *fragmentShader);
 
     MergedVaryings getMergedVaryings() const;
     std::vector<PackedVarying> getPackedVaryings(const MergedVaryings &mergedVaryings) const;

src/libANGLE/Uniform.cpp

@@ -117,7 +117,7 @@ size_t LinkedUniform::getElementComponents() const
 uint8_t *LinkedUniform::getDataPtrToElement(size_t elementIndex)
 {
     ASSERT((!isArray() && elementIndex == 0) || (isArray() && elementIndex < arraySize));
-    return data() + getElementSize() * elementIndex;
+    return data() + (elementIndex > 0 ? (getElementSize() * elementIndex) : 0u);
 }
 
 const uint8_t *LinkedUniform::getDataPtrToElement(size_t elementIndex) const

src/libANGLE/validationES.cpp

@@ -2700,19 +2700,34 @@ static bool ValidateUniformCommonBase(gl::Context *context,
         return false;
     }
 
-    if (program->isIgnoredUniformLocation(location))
+    if (location == -1)
     {
         // Silently ignore the uniform command
         return false;
     }
 
-    if (!program->isValidUniformLocation(location))
+    const auto &uniformLocations = program->getUniformLocations();
+    size_t castedLocation = static_cast<size_t>(location);
+    if (castedLocation >= uniformLocations.size())
+    {
+        context->handleError(Error(GL_INVALID_OPERATION, "Invalid uniform location"));
+        return false;
+    }
+
+    const auto &uniformLocation = uniformLocations[castedLocation];
+    if (uniformLocation.ignored)
+    {
+        // Silently ignore the uniform command
+        return false;
+    }
+
+    if (!uniformLocation.used)
     {
         context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
-    const LinkedUniform &uniform = program->getUniformByLocation(location);
+    const auto &uniform = program->getUniformByIndex(uniformLocation.index);
 
     // attempting to write an array to a non-array uniform is an INVALID_OPERATION
     if (!uniform.isArray() && count > 1)