command_buffer: Implement EXT_blend_func_extended

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>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/program_cache.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "third_party/re2/re2/re2.h"
+#include "ui/gl/gl_version_info.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
 
 int ShaderTypeToIndex(GLenum shader_type) {
@@ skipping 584 matching lines @@
 
 void Program::ExecuteBindAttribLocationCalls() {
   for (LocationMap::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)
       glBindAttribLocation(service_id_, it->second, mapped_name->c_str());
   }
 }
 
+void Program::ExecuteBindFragDataLocationIndexedCalls() {
+  Shader* fragment_shader =
+      attached_shaders_[ShaderTypeToIndex(GL_FRAGMENT_SHADER)].get();
+  if (fragment_shader->shader_version() == 100 &&
+      !feature_info().gl_version_info().is_es) {
+    // Map gl_SecondaryFragColorEXT / gl_SecondaryFragDataEXT of
+    // EXT_blend_func_extended to real
+    // color indexes, if underlying context is not ES.
+
+    for (auto const& output_var : fragment_shader->output_variable_list()) {
+      const std::string& name = output_var.mappedName;
+      if (name == "gl_FragColor") {
+        DCHECK(output_var.location == -1);
+        DCHECK(output_var.arraySize == 0u);
+        // We leave these unbound by not giving a binding name. The driver will
+        // bind this.
+      } else if (name == "gl_FragData") {
+        DCHECK(output_var.location == -1);
+        DCHECK(output_var.arraySize != 0u);
+        // We leave these unbound by not giving a binding name. The driver will
+        // bind this.
+      } else if (name == "gl_SecondaryFragColorEXT") {
+        DCHECK(feature_info().feature_flags().ext_blend_func_extended);
+        DCHECK(output_var.location == -1);
+        DCHECK(output_var.arraySize == 0u);
+        glBindFragDataLocationIndexed(service_id_, 0, 1,
+                                      "angle_SecondaryFragColor");
+      } else if (name == "gl_SecondaryFragDataEXT") {
+        DCHECK(feature_info().feature_flags().ext_blend_func_extended);
+        DCHECK(output_var.location == -1);
+        DCHECK(output_var.arraySize != 0u);
+        glBindFragDataLocationIndexed(service_id_, 0, 1,
+                                      "angle_SecondaryFragData");
+      }
+    }

[Mark Kilgard, 2015/08/28 19:53:24]

agree with all this

the point being non-ES 2.0 shading languages don't have the gl_*Frag* variables
for this.  But ES 2.0 GLSL didn't have the layout sophistication of modern GLSL
dialects.

Good bridging.

+  }
+}
+
 bool Program::Link(ShaderManager* manager,
                    Program::VaryingsPackingOption varyings_packing_option,
                    const ShaderCacheCallback& shader_callback) {
   ClearLinkStatus();
 
   if (!AttachedShadersExist()) {
     set_log_info("missing shaders");
     return false;
   }
 
@@ skipping 64 matching lines @@
                              "attribute: " + conflicting_name;
       set_log_info(ProcessLogInfo(info_log).c_str());
       return false;
     }
     if (!CheckVaryingsPacking(varyings_packing_option)) {
       set_log_info("Varyings over maximum register limit");
       return false;
     }
 
     ExecuteBindAttribLocationCalls();
+    ExecuteBindFragDataLocationIndexedCalls();
+
     before_time = TimeTicks::Now();
     if (cache && gfx::g_driver_gl.ext.b_GL_ARB_get_program_binary) {
       glProgramParameteri(service_id(),
                           PROGRAM_BINARY_RETRIEVABLE_HINT,
                           GL_TRUE);
     }
     glLinkProgram(service_id());
   }
 
   GLint success = 0;
@@ skipping 1089 matching lines @@
     }
     glGetActiveUniformsiv(
         program, count, &indices[0], kPname[pname_index], &params[0]);
     for (GLsizei ii = 0; ii < count; ++ii) {
       entries[kStride * ii + pname_index] = params[ii];
     }
   }
   return true;
 }
 
+GLint Program::GetFragDataLocation(const std::string& original_name) const {
+  DCHECK(IsValid());
+  Shader* shader =
+      attached_shaders_[ShaderTypeToIndex(GL_FRAGMENT_SHADER)].get();
+  if (!shader->GetOutputVariableInfo(original_name)) {
+    return -1;
+  }
+  return glGetFragDataLocation(service_id_, original_name.c_str());
+}
+
+GLint Program::GetFragDataIndex(const std::string& original_name) const {
+  DCHECK(IsValid());
+  Shader* shader =
+      attached_shaders_[ShaderTypeToIndex(GL_FRAGMENT_SHADER)].get();
+  if (!shader->GetOutputVariableInfo(original_name)) {
+    return -1;
+  }
+  return glGetFragDataIndex(service_id_, original_name.c_str());
+}
+
 void Program::TransformFeedbackVaryings(GLsizei count,
                                         const char* const* varyings,
                                         GLenum buffer_mode) {
   transform_feedback_varyings_.clear();
   for (GLsizei i = 0; i < count; ++i) {
     transform_feedback_varyings_.push_back(std::string(varyings[i]));
   }
   transform_feedback_buffer_mode_ = buffer_mode;
 }
 
 Program::~Program() {
   if (manager_) {
     if (manager_->have_context_) {
       glDeleteProgram(service_id());
     }
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
 ProgramManager::ProgramManager(ProgramCache* program_cache,
                                uint32 max_varying_vectors,
+                               uint32 max_dual_source_draw_buffers,
                                FeatureInfo* feature_info)
     : program_count_(0),
       have_context_(true),
       program_cache_(program_cache),
       max_varying_vectors_(max_varying_vectors),
+      max_dual_source_draw_buffers_(max_dual_source_draw_buffers),
       feature_info_(feature_info) {}
 
 ProgramManager::~ProgramManager() {
   DCHECK(programs_.empty());
 }
 
 void ProgramManager::Destroy(bool have_context) {
   have_context_ = have_context;
   programs_.clear();
 }
@@ skipping 93 matching lines @@
   DCHECK(program);
   program->ClearUniforms(&zero_);
 }
 
 int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu