Clear uniforms

gpu/command_buffer/service/program_manager.cc

 // Copyright (c) 2012 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/program_manager.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
+#include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 namespace gpu {
 namespace gles2 {
 
 static int ShaderTypeToIndex(GLenum shader_type) {
   switch (shader_type) {
     case GL_VERTEX_SHADER:
       return 0;
     case GL_FRAGMENT_SHADER:
@@ skipping 26 matching lines @@
 
 ProgramManager::ProgramInfo::ProgramInfo(
     ProgramManager* manager, GLuint service_id)
     : manager_(manager),
       use_count_(0),
       max_attrib_name_length_(0),
       max_uniform_name_length_(0),
       service_id_(service_id),
       deleted_(false),
       valid_(false),
-      link_status_(false) {
+      link_status_(false),
+      uniforms_cleared_(false) {
   manager_->StartTracking(this);
 }
 
 void ProgramManager::ProgramInfo::Reset() {
   valid_ = false;
   link_status_ = false;
   max_uniform_name_length_ = 0;
   max_attrib_name_length_ = 0;
   attrib_infos_.clear();
   uniform_infos_.clear();
   sampler_indices_.clear();
   attrib_location_to_index_map_.clear();
 }
 
 void ProgramManager::ProgramInfo::UpdateLogInfo() {
   GLint max_len = 0;
   glGetProgramiv(service_id_, GL_INFO_LOG_LENGTH, &max_len);
   if (max_len == 0) {
     set_log_info(NULL);
     return;
   }
   scoped_array<char> temp(new char[max_len]);
   GLint len = 0;
   glGetProgramInfoLog(service_id_, max_len, &len, temp.get());
   DCHECK(max_len == 0 || len < max_len);
   DCHECK(len == 0 || temp[len] == '\0');
   set_log_info(std::string(temp.get(), len).c_str());
 }
 
+void ProgramManager::ProgramInfo::ClearUniforms(
+    std::vector<uint8>* zero_buffer) {
+  DCHECK(zero_buffer);
+  if (uniforms_cleared_) {
+    return;
+  }
+  uniforms_cleared_ = true;
+  for (size_t ii = 0; ii < uniform_infos_.size(); ++ii) {
+    const UniformInfo& uniform_info = uniform_infos_[ii];
+    GLint location = uniform_info.element_locations[0];
+    GLsizei size = uniform_info.size;
+    uint32 unit_size =  GLES2Util::GetGLDataTypeSizeForUniforms(
+        uniform_info.type);
+    uint32 size_needed = size * unit_size;
+    if (size_needed > zero_buffer->size()) {
+      zero_buffer->resize(size_needed, 0u);
+    }
+    const void* zero = &(*zero_buffer)[0];
+    switch (uniform_info.type) {
+    case GL_FLOAT:
+      glUniform1fv(location, size, reinterpret_cast<const GLfloat*>(zero));
+      break;
+    case GL_FLOAT_VEC2:
+      glUniform2fv(location, size, reinterpret_cast<const GLfloat*>(zero));
+      break;
+    case GL_FLOAT_VEC3:
+      glUniform3fv(location, size, reinterpret_cast<const GLfloat*>(zero));
+      break;
+    case GL_FLOAT_VEC4:
+      glUniform4fv(location, size, reinterpret_cast<const GLfloat*>(zero));
+      break;
+    case GL_INT:
+    case GL_BOOL:
+    case GL_SAMPLER_2D:
+    case GL_SAMPLER_CUBE:
+    case GL_SAMPLER_EXTERNAL_OES:
+      glUniform1iv(location, size, reinterpret_cast<const GLint*>(zero));
+      break;
+    case GL_INT_VEC2:
+    case GL_BOOL_VEC2:
+      glUniform2iv(location, size, reinterpret_cast<const GLint*>(zero));
+      break;
+    case GL_INT_VEC3:
+    case GL_BOOL_VEC3:
+      glUniform3iv(location, size, reinterpret_cast<const GLint*>(zero));
+      break;
+    case GL_INT_VEC4:
+    case GL_BOOL_VEC4:
+      glUniform4iv(location, size, reinterpret_cast<const GLint*>(zero));
+      break;
+    case GL_FLOAT_MAT2:
+      glUniformMatrix2fv(
+          location, size, false, reinterpret_cast<const GLfloat*>(zero));
+      break;
+    case GL_FLOAT_MAT3:
+      glUniformMatrix3fv(
+          location, size, false, reinterpret_cast<const GLfloat*>(zero));
+      break;
+    case GL_FLOAT_MAT4:
+      glUniformMatrix4fv(
+          location, size, false, reinterpret_cast<const GLfloat*>(zero));
+      break;
+    default:
+      NOTREACHED();
+      break;
+    }
+  }
+}
+
 void ProgramManager::ProgramInfo::Update() {
   Reset();
   UpdateLogInfo();
   link_status_ = true;
+  uniforms_cleared_ = false;
   GLint num_attribs = 0;
   GLint max_len = 0;
   GLint max_location = -1;
   glGetProgramiv(service_id_, GL_ACTIVE_ATTRIBUTES, &num_attribs);
   glGetProgramiv(service_id_, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &max_len);
   // TODO(gman): Should we check for error?
   scoped_array<char> name_buffer(new char[max_len]);
   for (GLint ii = 0; ii < num_attribs; ++ii) {
     GLsizei length = 0;
     GLsizei size = 0;
@@ skipping 65 matching lines @@
 void ProgramManager::ProgramInfo::ExecuteBindAttribLocationCalls() {
   for (std::map<std::string, GLint>::const_iterator it =
            bind_attrib_location_map_.begin();
        it != bind_attrib_location_map_.end(); ++it) {
     const std::string* mapped_name = GetAttribMappedName(it->first);
     if (mapped_name && *mapped_name != it->first)
       glBindAttribLocation(service_id_, it->second, mapped_name->c_str());
   }
 }
 
-void ProgramManager::ProgramInfo::Link() {
+bool ProgramManager::ProgramInfo::Link() {
   ClearLinkStatus();
   if (!CanLink()) {
     set_log_info("missing shaders");
-    return;
+    return false;
   }
   if (DetectAttribLocationBindingConflicts()) {
     set_log_info("glBindAttribLocation() conflicts");
-    return;
+    return false;
   }
   ExecuteBindAttribLocationCalls();
   glLinkProgram(service_id());
   GLint success = 0;
   glGetProgramiv(service_id(), GL_LINK_STATUS, &success);
-  if (success) {
+  if (success == GL_TRUE) {
     Update();
   } else {
     UpdateLogInfo();
   }
+  return success == GL_TRUE;
 }
 
 void ProgramManager::ProgramInfo::Validate() {
   if (!IsValid()) {
     set_log_info("program not linked");
     return;
   }
   glValidateProgram(service_id());
   UpdateLogInfo();
 }
@@ skipping 476 matching lines @@
   DCHECK(info);
   DCHECK(IsOwned(info));
   info->MarkAsDeleted();
   RemoveProgramInfoIfUnused(shader_manager, info);
 }
 
 void ProgramManager::UseProgram(ProgramManager::ProgramInfo* info) {
   DCHECK(info);
   DCHECK(IsOwned(info));
   info->IncUseCount();
+  ClearUniforms(info);
 }
 
 void ProgramManager::UnuseProgram(
     ShaderManager* shader_manager,
     ProgramManager::ProgramInfo* info) {
   DCHECK(shader_manager);
   DCHECK(info);
   DCHECK(IsOwned(info));
   info->DecUseCount();
   RemoveProgramInfoIfUnused(shader_manager, info);
 }
 
+void ProgramManager::ClearUniforms(ProgramManager::ProgramInfo* info) {
+  DCHECK(info);
+  info->ClearUniforms(&zero_);
+}
+
 // Swizzles the locations to prevent developers from assuming they
 // can do math on uniforms. According to the OpenGL ES 2.0 spec
 // the location of "someuniform[1]" is not 'n' more than "someuniform[0]".
 static GLint Swizzle(GLint location) {
   return (location & 0xF0000000U) |
          ((location & 0x0AAAAAAAU) >> 1) |
          ((location & 0x05555555U) << 1);
 }
 
 // Adds uniform_swizzle_ to prevent developers from assuming that locations are
 // always the same across GPUs and drivers.
 GLint ProgramManager::SwizzleLocation(GLint v) const {
   return v < 0 ? v : (Swizzle(v) + uniform_swizzle_);
 }
 
 GLint ProgramManager::UnswizzleLocation(GLint v) const {
   return v < 0 ? v : Swizzle(v - uniform_swizzle_);
 }
 
 }  // namespace gles2
 }  // namespace gpu