command_buffer: Implement EXT_blend_func_extended

gpu/command_buffer/service/shader_translator.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/shader_translator.h"
 
 #include <string.h>
 #include <GLES2/gl2.h>
 #include <algorithm>
 
@@ skipping 53 matching lines @@
 void GetVaryings(ShHandle compiler, VaryingMap* var_map) {
   if (!var_map)
     return;
   var_map->clear();
   const std::vector<sh::Varying>* varyings = ShGetVaryings(compiler);
   if (varyings) {
     for (size_t ii = 0; ii < varyings->size(); ++ii)
       (*var_map)[(*varyings)[ii].mappedName] = (*varyings)[ii];
   }
 }
+void GetOutputVariables(ShHandle compiler, AttributeList* var_list) {
+  if (!var_list)
+    return;
+  *var_list = *ShGetOutputVariables(compiler);
+}
 
 void GetNameHashingInfo(ShHandle compiler, NameMap* name_map) {
   if (!name_map)
     return;
   name_map->clear();
 
   typedef std::map<std::string, std::string> NameMapANGLE;
   const NameMapANGLE* angle_map = ShGetNameHashingMap(compiler);
   DCHECK(angle_map);
 
@@ skipping 69 matching lines @@
                             ShCompileOptions driver_bug_workarounds) {
   // Make sure Init is called only once.
   DCHECK(compiler_ == NULL);
   DCHECK(shader_type == GL_FRAGMENT_SHADER || shader_type == GL_VERTEX_SHADER);
   DCHECK(shader_spec == SH_GLES2_SPEC || shader_spec == SH_WEBGL_SPEC ||
          shader_spec == SH_GLES3_SPEC || shader_spec == SH_WEBGL2_SPEC);
   DCHECK(resources != NULL);
 
   g_translator_initializer.Get();
 
-
   {
     TRACE_EVENT0("gpu", "ShConstructCompiler");
     compiler_ = ShConstructCompiler(shader_type, shader_spec,
                                     shader_output_language, resources);
   }
   driver_bug_workarounds_ = driver_bug_workarounds;
   return compiler_ != NULL;
 }
 
 int ShaderTranslator::GetCompileOptions() const {
@@ skipping 11 matching lines @@
   return compile_options;
 }
 
 bool ShaderTranslator::Translate(const std::string& shader_source,
                                  std::string* info_log,
                                  std::string* translated_source,
                                  int* shader_version,
                                  AttributeMap* attrib_map,
                                  UniformMap* uniform_map,
                                  VaryingMap* varying_map,
+                                 AttributeList* output_variable_list,
                                  NameMap* name_map) const {
   // Make sure this instance is initialized.
   DCHECK(compiler_ != NULL);
 
   bool success = false;
   {
     TRACE_EVENT0("gpu", "ShCompile");
     const char* const shader_strings[] = { shader_source.c_str() };
     success = ShCompile(
         compiler_, shader_strings, 1, GetCompileOptions());
   }
   if (success) {
     // Get translated shader.
     if (translated_source) {
       *translated_source = ShGetObjectCode(compiler_);
     }
     // Get shader version.
     *shader_version = ShGetShaderVersion(compiler_);
-    // Get info for attribs, uniforms, and varyings.
+    // Get info for attribs, uniforms, varyings and output variables.
     GetAttributes(compiler_, attrib_map);
     GetUniforms(compiler_, uniform_map);
     GetVaryings(compiler_, varying_map);
+    GetOutputVariables(compiler_, output_variable_list);
     // Get info for name hashing.
     GetNameHashingInfo(compiler_, name_map);
   }
 
   // Get info log.
   if (info_log) {
     *info_log = ShGetInfoLog(compiler_);
   }
 
   // We don't need results in the compiler anymore.
@@ skipping 25 matching lines @@
                     destruction_observers_,
                     OnDestruct(this));
 
   if (compiler_ != NULL)
     ShDestruct(compiler_);
 }
 
 }  // namespace gles2
 }  // namespace gpu