Implement UniformBlockBinding, and necessary state to track uniform block bindings on the API side.

src/libGLESv2/Program.cpp

@@ -141,6 +141,8 @@ Program::Program(rx::Renderer *renderer, ResourceManager *manager, GLuint handle
     mLinked = false;
     mRefCount = 0;
     mRenderer = renderer;
+
+    resetUniformBlockBindings();
 }
 
 Program::~Program()
@@ -243,6 +245,7 @@ bool Program::link()
     unlink(false);
 
     mInfoLog.reset();
+    resetUniformBlockBindings();
 
     mProgramBinary.set(new ProgramBinary(mRenderer));
     mLinked = mProgramBinary->link(mInfoLog, mAttributeBindings, mFragmentShader, mVertexShader);
@@ -522,4 +525,22 @@ bool Program::isValidated() const
     }
 }
 
+void Program::bindUniformBlock(GLuint uniformBlockIndex, GLuint uniformBlockBinding)
+{
+    mUniformBlockBindings[uniformBlockIndex] = uniformBlockBinding;
+}
+
+GLuint Program::getUniformBlockBinding(GLuint uniformBlockIndex) const
+{
+    return mUniformBlockBindings[uniformBlockIndex];
+}
+
+void Program::resetUniformBlockBindings()
+{
+    for (unsigned int blockId = 0; blockId < IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS; blockId++)
+    {
+        mUniformBlockBindings[blockId] = 0;
+    }
+}
+
 }

src/libGLESv2/Program.h

@@ -92,6 +92,9 @@ class Program
     GLint getActiveUniformCount();
     GLint getActiveUniformMaxLength();
 
+    void bindUniformBlock(GLuint uniformBlockIndex, GLuint uniformBlockBinding);
+    GLuint getUniformBlockBinding(GLuint uniformBlockIndex) const;
+
     void addRef();
     void release();
     unsigned int getRefCount() const;
@@ -107,12 +110,15 @@ class Program
     DISALLOW_COPY_AND_ASSIGN(Program);
 
     void unlink(bool destroy = false);
+    void resetUniformBlockBindings();
 
     FragmentShader *mFragmentShader;
     VertexShader *mVertexShader;
 
     AttributeBindings mAttributeBindings;
 
+    GLuint mUniformBlockBindings[IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS];
+
     BindingPointer<ProgramBinary> mProgramBinary;
     bool mLinked;
     bool mDeleteStatus;   // Flag to indicate that the program can be deleted when no longer in use

src/libGLESv2/ProgramBinary.cpp

@@ -2356,6 +2356,11 @@ GLint ProgramBinary::getActiveUniformi(GLuint index, GLenum pname) const
     return 0;
 }
 
+GLuint ProgramBinary::getActiveUniformBlockCount() const
+{
+    return mUniformBlocks.size();
+}
+
 void ProgramBinary::validate(InfoLog &infoLog)
 {
     applyUniforms();

src/libGLESv2/ProgramBinary.h

@@ -124,6 +124,8 @@ class ProgramBinary : public RefCountObject
     GLint getActiveUniformMaxLength() const;
     GLint getActiveUniformi(GLuint index, GLenum pname) const;
 
+    GLuint getActiveUniformBlockCount() const;
+
     void validate(InfoLog &infoLog);
     bool validateSamplers(InfoLog *infoLog);
     bool isValidated() const;

src/libGLESv2/libGLESv2.cpp

@@ -9783,9 +9783,36 @@ void __stdcall glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, G
             {
                 return gl::error(GL_INVALID_OPERATION);
             }
+
+            if (uniformBlockBinding >= context->getMaximumCombinedUniformBufferBindings())
+            {
+                return gl::error(GL_INVALID_VALUE);
             }
 
-        UNIMPLEMENTED();
+            gl::Program *programObject = context->getProgram(program);
+
+            if (!programObject)
+            {
+                if (context->getShader(program))
+                {
+                    return gl::error(GL_INVALID_OPERATION);
+                }
+                else
+                {
+                    return gl::error(GL_INVALID_VALUE);
+                }
+            }
+
+            gl::ProgramBinary *programBinary = programObject->getProgramBinary();
+
+            // if never linked, there won't be any uniform blocks
+            if (!programBinary || uniformBlockIndex >= programBinary->getActiveUniformBlockCount())
+            {
+                return gl::error(GL_INVALID_VALUE);
+            }
+
+            programObject->bindUniformBlock(uniformBlockIndex, uniformBlockBinding);
+        }
     }
     catch(std::bad_alloc&)
     {