Home | History | Annotate | Download | only in service 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef GPU_COMMAND_BUFFER_SERVICE_SHADER_TRANSLATOR_H_
      6 #define GPU_COMMAND_BUFFER_SERVICE_SHADER_TRANSLATOR_H_
      7 
      8 #include <string>
      9 
     10 #include "base/basictypes.h"
     11 #include "base/containers/hash_tables.h"
     12 #include "base/memory/ref_counted.h"
     13 #include "base/memory/scoped_ptr.h"
     14 #include "base/observer_list.h"
     15 #include "gpu/gpu_export.h"
     16 #include "third_party/angle/include/GLSLANG/ShaderLang.h"
     17 
     18 namespace gpu {
     19 namespace gles2 {
     20 
     21 // Translates a GLSL ES 2.0 shader to desktop GLSL shader, or just
     22 // validates GLSL ES 2.0 shaders on a true GLSL ES implementation.
     23 class ShaderTranslatorInterface {
     24  public:
     25   enum GlslImplementationType {
     26     kGlsl,
     27     kGlslES
     28   };
     29 
     30   struct VariableInfo {
     31     VariableInfo()
     32         : type(0),
     33           size(0),
     34           precision(SH_PRECISION_UNDEFINED),
     35           static_use(0) {
     36     }
     37 
     38     VariableInfo(int _type, int _size, int _precision,
     39                  int _static_use, std::string _name)
     40         : type(_type),
     41           size(_size),
     42           precision(_precision),
     43           static_use(_static_use),
     44           name(_name) {
     45     }
     46     bool operator==(
     47         const ShaderTranslatorInterface::VariableInfo& other) const {
     48       return type == other.type &&
     49           size == other.size &&
     50           precision == other.precision &&
     51           strcmp(name.c_str(), other.name.c_str()) == 0;
     52     }
     53 
     54     int type;
     55     int size;
     56     int precision;
     57     int static_use;
     58     std::string name;  // name in the original shader source.
     59   };
     60 
     61   // Mapping between variable name and info.
     62   typedef base::hash_map<std::string, VariableInfo> VariableMap;
     63   // Mapping between hashed name and original name.
     64   typedef base::hash_map<std::string, std::string> NameMap;
     65 
     66   // Initializes the translator.
     67   // Must be called once before using the translator object.
     68   virtual bool Init(
     69       sh::GLenum shader_type,
     70       ShShaderSpec shader_spec,
     71       const ShBuiltInResources* resources,
     72       GlslImplementationType glsl_implementation_type,
     73       ShCompileOptions driver_bug_workarounds) = 0;
     74 
     75   // Translates the given shader source.
     76   // Returns true if translation is successful, false otherwise.
     77   // Always fill |info_log| if it's non-null.
     78   // Upon success, fill |translated_shader|, |attrib_map|, |uniform_map|,
     79   // |varying_map|, and |name_map| if they are non-null.
     80   virtual bool Translate(const std::string& shader_source,
     81                          std::string* info_log,
     82                          std::string* translated_shader,
     83                          VariableMap* attrib_map,
     84                          VariableMap* uniform_map,
     85                          VariableMap* varying_map,
     86                          NameMap* name_map) const = 0;
     87 
     88   // Return a string that is unique for a specfic set of options that would
     89   // possibly affect compilation.
     90   virtual std::string GetStringForOptionsThatWouldAffectCompilation() const = 0;
     91 
     92  protected:
     93   virtual ~ShaderTranslatorInterface() {}
     94 };
     95 
     96 // Implementation of ShaderTranslatorInterface
     97 class GPU_EXPORT ShaderTranslator
     98     : public base::RefCounted<ShaderTranslator>,
     99       NON_EXPORTED_BASE(public ShaderTranslatorInterface) {
    100  public:
    101   class DestructionObserver {
    102    public:
    103     DestructionObserver();
    104     virtual ~DestructionObserver();
    105 
    106     virtual void OnDestruct(ShaderTranslator* translator) = 0;
    107 
    108    private:
    109     DISALLOW_COPY_AND_ASSIGN(DestructionObserver);
    110   };
    111 
    112   ShaderTranslator();
    113 
    114   // Overridden from ShaderTranslatorInterface.
    115   virtual bool Init(
    116       sh::GLenum shader_type,
    117       ShShaderSpec shader_spec,
    118       const ShBuiltInResources* resources,
    119       GlslImplementationType glsl_implementation_type,
    120       ShCompileOptions driver_bug_workarounds) OVERRIDE;
    121 
    122   // Overridden from ShaderTranslatorInterface.
    123   virtual bool Translate(const std::string& shader_source,
    124                          std::string* info_log,
    125                          std::string* translated_source,
    126                          VariableMap* attrib_map,
    127                          VariableMap* uniform_map,
    128                          VariableMap* varying_map,
    129                          NameMap* name_map) const OVERRIDE;
    130 
    131   virtual std::string GetStringForOptionsThatWouldAffectCompilation() const
    132       OVERRIDE;
    133 
    134   void AddDestructionObserver(DestructionObserver* observer);
    135   void RemoveDestructionObserver(DestructionObserver* observer);
    136 
    137  private:
    138   friend class base::RefCounted<ShaderTranslator>;
    139 
    140   virtual ~ShaderTranslator();
    141   int GetCompileOptions() const;
    142 
    143   ShHandle compiler_;
    144   ShBuiltInResources compiler_options_;
    145   bool implementation_is_glsl_es_;
    146   ShCompileOptions driver_bug_workarounds_;
    147   ObserverList<DestructionObserver> destruction_observers_;
    148 
    149   DISALLOW_COPY_AND_ASSIGN(ShaderTranslator);
    150 };
    151 
    152 }  // namespace gles2
    153 }  // namespace gpu
    154 
    155 #endif  // GPU_COMMAND_BUFFER_SERVICE_SHADER_TRANSLATOR_H_
    156 
    157