Capture/Replay: Enable capturing slingshot scenes

src/common/PackedEnums.cpp

@@ -396,7 +396,7 @@ std::ostream &operator<<(std::ostream &os, VertexAttribType value)
             os << "GL_UNSIGNED_INT";
             break;
         case VertexAttribType::UnsignedInt2101010:
-            os << "GL_UNSIGNED_INT_10_10_10_2";
+            os << "GL_UNSIGNED_INT_2_10_10_10_REV";
             break;
         case VertexAttribType::UnsignedInt1010102:
             os << "GL_UNSIGNED_INT_10_10_10_2_OES";

src/libANGLE/FrameCapture.cpp

@@ -1371,30 +1371,43 @@ void CaptureUpdateUniformLocations(const gl::Program *program, std::vector<CallC
     for (GLint location = 0; location < static_cast<GLint>(locations.size()); ++location)
     {
         const gl::VariableLocation &locationVar = locations[location];
-        const gl::LinkedUniform &uniform        = uniforms[locationVar.index];
 
+        // This handles the case where the application calls glBindUniformLocationCHROMIUM
+        // on an unused uniform. We must still store a -1 into gUniformLocations in case the
+        // application attempts to call a glUniform* call. To do this we'll pass in a blank name to
+        // force glGetUniformLocation to return -1.
+        std::string name;
         ParamBuffer params;
         params.addValueParam("program", ParamType::TShaderProgramID, program->id());
 
-        std::string name = uniform.name;
-
-        if (uniform.isArray())
+        if (locationVar.index >= uniforms.size())
         {
-            if (locationVar.arrayIndex > 0)
-            {
-                // Non-sequential array uniform locations are not currently handled.
-                // In practice array locations shouldn't ever be non-sequential.
-                ASSERT(uniform.location == -1 ||
-                       location == uniform.location + static_cast<int>(locationVar.arrayIndex));
-                continue;
-            }
+            name = "";
+        }
+        else
+        {
+            const gl::LinkedUniform &uniform = uniforms[locationVar.index];
 
-            if (uniform.isArrayOfArrays())
+            name = uniform.name;
+
+            if (uniform.isArray())
             {
-                UNIMPLEMENTED();
-            }
+                if (locationVar.arrayIndex > 0)
+                {
+                    // Non-sequential array uniform locations are not currently handled.
+                    // In practice array locations shouldn't ever be non-sequential.
+                    ASSERT(uniform.location == -1 ||
+                           location == uniform.location + static_cast<int>(locationVar.arrayIndex));
+                    continue;
+                }
+
+                if (uniform.isArrayOfArrays())
+                {
+                    UNIMPLEMENTED();
+                }
 
-            name = gl::StripLastArrayIndex(name);
+                name = gl::StripLastArrayIndex(name);
+            }
         }
 
         ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
@@ -4223,19 +4236,43 @@ gl::Program *GetProgramForCapture(const gl::State &glState, gl::ShaderProgramID
     return program;
 }
 
+void CaptureGetActiveUniformBlockivParameters(const gl::State &glState,
+                                              gl::ShaderProgramID handle,
+                                              GLuint uniformBlockIndex,
+                                              GLenum pname,
+                                              ParamCapture *paramCapture)
+{
+    int numParams = 1;
+
+    // From the OpenGL ES 3.0 spec:
+    // If pname is UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, then a list of the
+    // active uniform indices for the uniform block identified by uniformBlockIndex is
+    // returned. The number of elements that will be written to params is the value of
+    // UNIFORM_BLOCK_ACTIVE_UNIFORMS for uniformBlockIndex
+    if (pname == GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES)
+    {
+        gl::Program *program = GetProgramForCapture(glState, handle);
+        if (program)
+        {
+            gl::QueryActiveUniformBlockiv(program, uniformBlockIndex,
+                                          GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, &numParams);
+        }
+    }
+
+    paramCapture->readBufferSizeBytes = sizeof(GLint) * numParams;
+}
+
 void CaptureGetParameter(const gl::State &glState,
                          GLenum pname,
                          size_t typeSize,
                          ParamCapture *paramCapture)
 {
-    GLenum nativeType;
-    unsigned int numParams;
-    if (!gl::GetQueryParameterInfo(glState, pname, &nativeType, &numParams))
-    {
-        numParams = 1;
-    }
-
-    paramCapture->readBufferSizeBytes = typeSize * numParams;
+    // kMaxReportedCapabilities is the biggest array we'll need to hold data from glGet calls.
+    // This value needs to be updated if any new extensions are introduced that would allow for
+    // more compressed texture formats. The current value is taken from:
+    // http://opengles.gpuinfo.org/displaycapability.php?name=GL_NUM_COMPRESSED_TEXTURE_FORMATS&esversion=2
+    constexpr unsigned int kMaxReportedCapabilities = 69;
+    paramCapture->readBufferSizeBytes               = typeSize * kMaxReportedCapabilities;
 }
 
 void CaptureGenHandlesImpl(GLsizei n, GLuint *handles, ParamCapture *paramCapture)

src/libANGLE/FrameCapture.h

@@ -389,6 +389,12 @@ void CaptureGetParameter(const gl::State &glState,
                          size_t typeSize,
                          ParamCapture *paramCapture);
 
+void CaptureGetActiveUniformBlockivParameters(const gl::State &glState,
+                                              gl::ShaderProgramID handle,
+                                              GLuint uniformBlockIndex,
+                                              GLenum pname,
+                                              ParamCapture *paramCapture);
+
 template <typename T>
 void CaptureClearBufferValue(GLenum buffer, const T *value, ParamCapture *paramCapture)
 {

src/libANGLE/capture_gles_3_0_params.cpp

@@ -205,7 +205,13 @@ void CaptureGetActiveUniformBlockName_length(const State &glState,
                                              GLchar *uniformBlockName,
                                              ParamCapture *paramCapture)
 {
-    UNIMPLEMENTED();
+    // From the OpenGL ES 3.0 spec:
+    // The actual number of characters written into uniformBlockName, excluding the null terminator,
+    // is returned in length. If length is NULL, no length is returned.
+    if (length)
+    {
+        paramCapture->readBufferSizeBytes = sizeof(GLsizei);
+    }
 }
 
 void CaptureGetActiveUniformBlockName_uniformBlockName(const State &glState,
@@ -217,7 +223,10 @@ void CaptureGetActiveUniformBlockName_uniformBlockName(const State &glState,
                                                        GLchar *uniformBlockName,
                                                        ParamCapture *paramCapture)
 {
-    UNIMPLEMENTED();
+    // From the OpenGL ES 3.0 spec:
+    // bufSize contains the maximum number of characters (including the null terminator) that will
+    // be written back to uniformBlockName.
+    CaptureStringLimit(uniformBlockName, bufSize, paramCapture);
 }
 
 void CaptureGetActiveUniformBlockiv_params(const State &glState,
@@ -228,7 +237,8 @@ void CaptureGetActiveUniformBlockiv_params(const State &glState,
                                            GLint *params,
                                            ParamCapture *paramCapture)
 {
-    UNIMPLEMENTED();
+    CaptureGetActiveUniformBlockivParameters(glState, program, uniformBlockIndex, pname,
+                                             paramCapture);
 }
 
 void CaptureGetActiveUniformsiv_uniformIndices(const State &glState,
@@ -240,7 +250,11 @@ void CaptureGetActiveUniformsiv_uniformIndices(const State &glState,
                                                GLint *params,
                                                ParamCapture *paramCapture)
 {
-    UNIMPLEMENTED();
+    // From the OpenGL ES 3.0 spec:
+    // For GetActiveUniformsiv, uniformCountindicates both the number of
+    // elements in the array of indices uniformIndices and the number of
+    // parameters written to params upon successful return.
+    CaptureMemory(uniformIndices, sizeof(GLuint) * uniformCount, paramCapture);
 }
 
 void CaptureGetActiveUniformsiv_params(const State &glState,
@@ -252,7 +266,11 @@ void CaptureGetActiveUniformsiv_params(const State &glState,
                                        GLint *params,
                                        ParamCapture *paramCapture)
 {
-    UNIMPLEMENTED();
+    // From the OpenGL ES 3.0 spec:
+    // For GetActiveUniformsiv, uniformCountindicates both the number of
+    // elements in the array of indices uniformIndices and the number of
+    // parameters written to params upon successful return.
+    paramCapture->readBufferSizeBytes = sizeof(GLint) * uniformCount;
 }
 
 void CaptureGetBufferParameteri64v_params(const State &glState,