Apply varying packing rule.

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 <utility>
 #include <vector>
@@ skipping 100 matching lines @@
       return false;
     }
     index = index * 10 + digit;
   }
 
   *element_index = index;
   *new_name = name.substr(0, open_pos);
   return true;
 }
 
+bool IsBuiltInVarying(const std::string& name) {
+  // Built-in variables.
+  const char* kBuiltInVaryings[] = {
+      "gl_FragCoord",
+      "gl_FrontFacing",
+      "gl_PointCoord"
+  };
+  for (size_t ii = 0; ii < arraysize(kBuiltInVaryings); ++ii) {
+    if (name == kBuiltInVaryings[ii])
+      return true;
+  }
+  return false;
+}
+
 }  // anonymous namespace.
 
 Program::UniformInfo::UniformInfo()
     : size(0),
       type(GL_NONE),
       fake_location_base(0),
       is_array(false) {
 }
 
 Program::UniformInfo::UniformInfo(
@@ skipping 406 matching lines @@
   if (DetectUniformsMismatch()) {
     set_log_info("Uniforms with the same name but different type/precision");
     return false;
   }
   if (DetectVaryingsMismatch()) {
     set_log_info("Varyings with the same name but different type, "
                  "or statically used varyings in fragment shader are not "
                  "declared in vertex shader");
     return false;
   }
+  if (!CheckVaryingsPacking()) {
+    set_log_info("Varyings over maximum register limit");
+    return false;
+  }
 
   TimeTicks before_time = TimeTicks::HighResNow();
   bool link = true;
   ProgramCache* cache = manager_->program_cache_;
   if (cache) {
     DCHECK(attached_shaders_[0]->signature_source() &&
            attached_shaders_[1]->signature_source());
     ProgramCache::LinkedProgramStatus status = cache->GetLinkedProgramStatus(
         *attached_shaders_[0]->signature_source(),
         vertex_translator,
@@ skipping 470 matching lines @@
          attached_shaders_[1] &&
          attached_shaders_[1]->shader_type() == GL_FRAGMENT_SHADER);
   const ShaderTranslator::VariableMap* vertex_varyings =
       &(attached_shaders_[0]->varying_map());
   const ShaderTranslator::VariableMap* fragment_varyings =
       &(attached_shaders_[1]->varying_map());
 
   for (ShaderTranslator::VariableMap::const_iterator iter =
            fragment_varyings->begin();
        iter != fragment_varyings->end(); ++iter) {
-    // Built-in variables.
-    const char* kBuiltInVaryings[] = {
-        "gl_FragCoord",
-        "gl_FrontFacing",
-        "gl_PointCoord"
-    };
     const std::string& name = iter->first;
-    bool is_built_in = false;
-    for (size_t ii = 0; ii < arraysize(kBuiltInVaryings); ++ii) {
-      if (name == kBuiltInVaryings[ii]) {
-        is_built_in = true;
-        break;
-      }
-    }
-    if (is_built_in)
+    if (IsBuiltInVarying(name))
       continue;
 
     ShaderTranslator::VariableMap::const_iterator hit =
         vertex_varyings->find(name);
     if (hit == vertex_varyings->end()) {
       if (iter->second.static_use)
         return true;
       continue;
     }
 
     if (hit->second.type != iter->second.type ||
         hit->second.size != iter->second.size)
       return true;
 
   }
   return false;
 }
 
+bool Program::CheckVaryingsPacking() const {
+  DCHECK(attached_shaders_[0] &&
+         attached_shaders_[0]->shader_type() == GL_VERTEX_SHADER &&
+         attached_shaders_[1] &&
+         attached_shaders_[1]->shader_type() == GL_FRAGMENT_SHADER);
+  const ShaderTranslator::VariableMap* vertex_varyings =
+      &(attached_shaders_[0]->varying_map());
+  const ShaderTranslator::VariableMap* fragment_varyings =
+      &(attached_shaders_[1]->varying_map());
+
+  std::map<std::string, ShVariableInfo> combined_map;
+
+  for (ShaderTranslator::VariableMap::const_iterator iter =
+           fragment_varyings->begin();
+       iter != fragment_varyings->end(); ++iter) {
+    if (!iter->second.static_use)
+      continue;
+    if (!IsBuiltInVarying(iter->first)) {
+      ShaderTranslator::VariableMap::const_iterator vertex_iter =
+          vertex_varyings->find(iter->first);
+      if (vertex_iter == vertex_varyings->end() ||
+          !vertex_iter->second.static_use)
+        continue;
+    }
+
+    ShVariableInfo var;
+    var.type = static_cast<ShDataType>(iter->second.type);
+    var.size = iter->second.size;
+    combined_map[iter->first] = var;
+  }
+
+  if (combined_map.size() == 0)
+    return true;
+  scoped_ptr<ShVariableInfo[]> variables(
+      new ShVariableInfo[combined_map.size()]);
+  size_t index = 0;
+  for (std::map<std::string, ShVariableInfo>::const_iterator iter =
+           combined_map.begin();
+       iter != combined_map.end(); ++iter) {
+    variables[index].type = iter->second.type;
+    variables[index].size = iter->second.size;
+    ++index;
+  }
+  return ShCheckVariablesWithinPackingLimits(
+      static_cast<int>(manager_->max_varying_vectors()),
+      variables.get(),
+      combined_map.size()) == 1;
+}
+
 static uint32 ComputeOffset(const void* start, const void* position) {
   return static_cast<const uint8*>(position) -
          static_cast<const uint8*>(start);
 }
 
 void Program::GetProgramInfo(
     ProgramManager* manager, CommonDecoder::Bucket* bucket) const {
   // NOTE: It seems to me the math in here does not need check for overflow
   // because the data being calucated from has various small limits. The max
   // number of attribs + uniforms is somewhere well under 1024. The maximum size
@@ skipping 77 matching lines @@
   if (manager_) {
     if (manager_->have_context_) {
       glDeleteProgram(service_id());
     }
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
 
-ProgramManager::ProgramManager(ProgramCache* program_cache)
+ProgramManager::ProgramManager(ProgramCache* program_cache,
+                               uint32 max_varying_vectors)
     : program_count_(0),
       have_context_(true),
       disable_workarounds_(
           CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kDisableGpuDriverBugWorkarounds)),
-      program_cache_(program_cache) { }
+      program_cache_(program_cache),
+      max_varying_vectors_(max_varying_vectors) { }
 
 ProgramManager::~ProgramManager() {
   DCHECK(programs_.empty());
 }
 
 void ProgramManager::Destroy(bool have_context) {
   have_context_ = have_context;
   programs_.clear();
 }
 
@@ skipping 98 matching lines @@
     program->ClearUniforms(&zero_);
   }
 }
 
 int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu