Implements glGetUniformiv and glGetUniformfv.

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <vector>
 #include <string>
@@ skipping 17 matching lines @@
 // Check that certain assumptions the code makes are true. There are places in
 // the code where shared memory is passed direclty to GL. Example, glUniformiv,
 // glShaderSource. The command buffer code assumes GLint and GLsizei (and maybe
 // a few others) are 32bits. If they are not 32bits the code will have to change
 // to call those GL functions with service side memory and then copy the results
 // to shared memory, converting the sizes.
 COMPILE_ASSERT(sizeof(GLint) == sizeof(uint32),  // NOLINT
                GLint_not_same_size_as_uint32);
 COMPILE_ASSERT(sizeof(GLsizei) == sizeof(uint32),  // NOLINT
                GLint_not_same_size_as_uint32);
+COMPILE_ASSERT(sizeof(GLfloat) == sizeof(float),  // NOLINT
+               GLfloat_not_same_size_as_float);
 
 namespace {
 
 size_t GetGLTypeSize(GLenum type) {
   switch (type) {
     case GL_BYTE:
       return sizeof(GLbyte);  // NOLINT
     case GL_UNSIGNED_BYTE:
       return sizeof(GLubyte);  // NOLINT
     case GL_SHORT:
@@ skipping 254 matching lines @@
 //
 // NOTE: To support shared resources an instance of this class will
 // need to be shared by multiple GLES2Decoders.
 class ProgramManager {
  public:
   // This is used to track which attributes a particular program needs
   // so we can verify at glDrawXXX time that every attribute is either disabled
   // or if enabled that it points to a valid source.
   class ProgramInfo {
    public:
+    struct UniformInfo {
+      GLsizei GetSizeInBytes() const;
+
+      GLsizei size;
+      GLenum type;
+      GLint location;
+    };
+
+    typedef std::vector<UniformInfo> UniformInfoVector;
     typedef std::vector<GLuint> AttribLocationVector;
 
     ProgramInfo() {
     }
 
     void SetNumAttributes(int num_attribs) {
       attrib_locations_.resize(num_attribs);
     }
 
     void SetAttributeLocation(GLuint index, int location) {
       DCHECK(index < attrib_locations_.size());
       attrib_locations_[index] = location;
     }
 
     const AttribLocationVector& GetAttribLocations() const {
       return attrib_locations_;
     }
+
+    void SetNumUniforms(int num_uniforms) {
+      uniform_infos_.resize(num_uniforms);
+    }
+
+    void SetUniformInfo(
+        GLint index, GLsizei size, GLenum type, GLint location) {
+      UniformInfo& info = uniform_infos_[index];
+      info.size = size;
+      info.type = type;
+      info.location = location;
+    }
+
+    const UniformInfo* GetUniformInfoByLocation(GLint location) {
+      for (GLuint ii = 0; ii < uniform_infos_.size(); ++ii) {
+        if (uniform_infos_[ii].location == location) {
+          return &uniform_infos_[ii];
+        }
+      }
+      return NULL;
+    }
+
+
    private:
     AttribLocationVector attrib_locations_;
+
+    // Uniform info by info.
+    UniformInfoVector uniform_infos_;
   };
 
   ProgramInfo* GetProgramInfo(GLuint program);
 
   // Updates the program info for the given program.
   void UpdateProgramInfo(GLuint program);
 
   // Deletes the program info for the given program.
   void RemoveProgramInfo(GLuint program);
 
  private:
   // Info for each "successfully linked" program by service side program Id.
   // TODO(gman): Choose a faster container.
   typedef std::map<GLuint, ProgramInfo> ProgramInfoMap;
   ProgramInfoMap program_infos_;
 };
 
+GLsizei ProgramManager::ProgramInfo::UniformInfo::GetSizeInBytes() const {
+  return GLES2Util::GetGLDataTypeSize(type) * size;
+}
+
 ProgramManager::ProgramInfo* ProgramManager::GetProgramInfo(GLuint program) {
   ProgramInfoMap::iterator it = program_infos_.find(program);
   return it != program_infos_.end() ? &it->second : NULL;
 }
 
 void ProgramManager::UpdateProgramInfo(GLuint program) {
   ProgramInfo* info = GetProgramInfo(program);
   if (!info) {
     std::pair<ProgramInfoMap::iterator, bool> result =
         program_infos_.insert(std::make_pair(program, ProgramInfo()));
     DCHECK(result.second);
     info = &result.first->second;
   }
   GLint num_attribs = 0;
   GLint max_len = 0;
   glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &num_attribs);
   info->SetNumAttributes(num_attribs);
   glGetProgramiv(program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &max_len);
   // TODO(gman): Should we check for error?
-  scoped_array<char> name_buffer(new char[max_len + 1]);
+  scoped_array<char> name_buffer(new char[max_len]);
   for (GLint ii = 0; ii < num_attribs; ++ii) {
     GLsizei length;
     GLsizei size;
     GLenum type;
     glGetActiveAttrib(
-        program, ii, max_len + 1, &length, &size, &type, name_buffer.get());
+        program, ii, max_len, &length, &size, &type, name_buffer.get());
     // TODO(gman): Should we check for error?
     GLint location = glGetAttribLocation(program, name_buffer.get());
     info->SetAttributeLocation(ii, location);
   }
+  GLint num_uniforms;
+  glGetProgramiv(program, GL_ACTIVE_UNIFORMS, &num_uniforms);
+  info->SetNumUniforms(num_uniforms);
+  glGetProgramiv(program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &max_len);
+  name_buffer.reset(new char[max_len]);
+  for (GLint ii = 0; ii < num_uniforms; ++ii) {
+    GLsizei length;
+    GLsizei size;
+    GLenum type;
+    glGetActiveUniform(
+        program, ii, max_len, &length, &size, &type, name_buffer.get());
+    // TODO(gman): Should we check for error?
+    GLint location = glGetUniformLocation(program, name_buffer.get());
+    info->SetUniformInfo(ii, size, type, location);
+  }
 }
 
 void ProgramManager::RemoveProgramInfo(GLuint program) {
   ProgramInfoMap::iterator it = program_infos_.find(program);
   if (it != program_infos_.end()) {
     program_infos_.erase(it);
   }
 }
 
 // This class implements GLES2Decoder so we don't have to expose all the GLES2
@@ skipping 218 matching lines @@
   // Checks if the current program and vertex attributes are valid for drawing.
   bool IsDrawValid(GLuint max_vertex_accessed);
 
   // Gets the buffer id for a given target.
   GLuint GetBufferForTarget(GLenum target) {
     DCHECK(target == GL_ARRAY_BUFFER || target == GL_ELEMENT_ARRAY_BUFFER);
     return target == GL_ARRAY_BUFFER ? bound_array_buffer_ :
                                        bound_element_array_buffer_;
   }
 
+  // Validates the program and location for a glGetUniform call and returns
+  // a SizeResult setup to receive the result. Returns true if glGetUniform
+  // should be called.
+  bool GetUniformSetup(
+      GLuint program, GLint location,
+      uint32 shm_id, uint32 shm_offset,
+      error::Error* error, GLuint* service_id, SizedResult** result);
+
   // Generate a member function prototype for each command in an automated and
   // typesafe way.
   #define GLES2_CMD_OP(name) \
      Error Handle ## name(             \
        uint32 immediate_data_size,          \
        const gles2::name& args);            \
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
 
   #undef GLES2_CMD_OP
@@ skipping 1230 matching lines @@
   }
   if (index >= max_vertex_attribs_) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   result->size = sizeof(GLuint);
   *result->GetDataAs<GLuint*>() = vertex_attrib_infos_[index].offset();
   return error::kNoError;
 }
 
+bool GLES2DecoderImpl::GetUniformSetup(
+    GLuint program, GLint location,
+    uint32 shm_id, uint32 shm_offset,
+    error::Error* error, GLuint* service_id, SizedResult** result) {
+  *error = error::kNoError;
+  // Make sure we have enough room for the result on failure.
+  *result = GetSharedMemoryAs<SizedResult*>(
+      shm_id, shm_offset, SizedResult::GetSize(0));
+  if (!*result) {
+    *error = error::kOutOfBounds;
+    return false;
+  }
+  // Set the result size to 0 so the client does not have to check for success.
+  (*result)->size = 0;
+  if (!id_manager_->GetServiceId(program, service_id)) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
+  ProgramManager::ProgramInfo* info = GetProgramInfo(*service_id);
+  if (!info) {
+    // Program was not linked successfully. (ie, glLinkProgram)
+    SetGLError(GL_INVALID_OPERATION);
+    return false;
+  }
+  const ProgramManager::ProgramInfo::UniformInfo* uniform_info =
+      info->GetUniformInfoByLocation(location);
+  if (!uniform_info) {
+    // No such location.
+    SetGLError(GL_INVALID_OPERATION);
+    return false;
+  }
+  GLsizei size = uniform_info->GetSizeInBytes();
+  if (size == 0) {
+    SetGLError(GL_INVALID_OPERATION);
+    return false;
+  }
+  *result = GetSharedMemoryAs<SizedResult*>(
+      shm_id, shm_offset, SizedResult::GetSize(size));
+  if (!*result) {
+    *error = error::kOutOfBounds;
+    return false;
+  }
+  (*result)->size = size;
+  return true;
+}
+
 error::Error GLES2DecoderImpl::HandleGetUniformiv(
     uint32 immediate_data_size, const gles2::GetUniformiv& c) {
-  // TODO(gman): Implement.
-  NOTREACHED();
-  return error::kNoError;
+  GLuint program = c.program;
+  GLint location = c.location;
+  GLuint service_id;
+  Error error;
+  SizedResult* result;
+  if (GetUniformSetup(
+      program, location, c.params_shm_id, c.params_shm_offset,
+      &error, &service_id, &result)) {
+    glGetUniformiv(service_id, location, result->GetDataAs<GLint*>());
+  }
+  return error;
 }
 
 error::Error GLES2DecoderImpl::HandleGetUniformfv(
     uint32 immediate_data_size, const gles2::GetUniformfv& c) {
-  // TODO(gman): Implement.
-  NOTREACHED();
-  return error::kNoError;
+  GLuint program = c.program;
+  GLint location = c.location;
+  GLuint service_id;
+  Error error;
+  SizedResult* result;
+  if (GetUniformSetup(
+      program, location, c.params_shm_id, c.params_shm_offset,
+      &error, &service_id, &result)) {
+    glGetUniformfv(service_id, location, result->GetDataAs<GLfloat*>());
+  }
+  return error;
 }
 
 error::Error GLES2DecoderImpl::HandleGetShaderPrecisionFormat(
     uint32 immediate_data_size, const gles2::GetShaderPrecisionFormat& c) {
   // TODO(gman): Implement.
   NOTREACHED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetAttachedShaders(
@@ skipping 17 matching lines @@
   return error::kNoError;
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu