command_buffer: Implement EXT_blend_func_extended

gpu/command_buffer/service/program_manager.h

 // 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.
 
 #ifndef GPU_COMMAND_BUFFER_SERVICE_PROGRAM_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_PROGRAM_MANAGER_H_
 
 #include <map>
 #include <string>
 #include <vector>
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "gpu/command_buffer/service/common_decoder.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/gpu_export.h"
 
 namespace gpu {
 namespace gles2 {
 
+class FeatureInfo;
 class ProgramCache;
 class ProgramManager;
 class Shader;
 class ShaderManager;
 class FeatureInfo;
 
 // This is used to track which attributes a particular program needs
 // so we can verify at glDrawXXX time that every attribute is either disabled
 // or if enabled that it points to a valid source.
 class GPU_EXPORT Program : public base::RefCounted<Program> {
@@ skipping 29 matching lines @@
     kUniformMatrix4x2f = 1 << 19,
     kUniformMatrix4x3f = 1 << 20,
   };
   struct FragmentInputInfo {
     FragmentInputInfo(GLenum _type, GLuint _location)
         : type(_type), location(_location) {}
     FragmentInputInfo() : type(GL_NONE), location(0) {}
     GLenum type;
     GLuint location;
   };
+  struct ProgramOutputInfo {
+    ProgramOutputInfo(GLuint _color_name,
+                      GLuint _index,
+                      const std::string& _name)
+        : color_name(_color_name), index(_index), name(_name) {}
+    ProgramOutputInfo() : color_name(0), index(0) {}
+    GLuint color_name;
+    GLuint index;
+    std::string name;
+  };
 
   struct UniformInfo {
     UniformInfo();
     UniformInfo(const std::string& client_name,
                 GLint client_location_base,
                 GLenum _type,
                 bool _is_array,
                 const std::vector<GLint>& service_locations);
     ~UniformInfo();
     bool IsSampler() const {
@@ skipping 55 matching lines @@
     bool inactive_;
   };
 
   typedef std::vector<UniformInfo> UniformInfoVector;
   typedef std::vector<ShaderVariableLocationEntry<UniformInfo>>
       UniformLocationVector;
   typedef std::vector<VertexAttrib> AttribInfoVector;
   typedef std::vector<FragmentInputInfo> FragmentInputInfoVector;
   typedef std::vector<ShaderVariableLocationEntry<FragmentInputInfo>>
       FragmentInputLocationVector;
+  typedef std::vector<ProgramOutputInfo> ProgramOutputInfoVector;
   typedef std::vector<int> SamplerIndices;
   typedef std::map<std::string, GLint> LocationMap;
+  typedef std::map<std::string, std::pair<GLuint, GLuint>> LocationIndexMap;
   typedef std::vector<std::string> StringVector;
 
   Program(ProgramManager* manager, GLuint service_id);
 
   GLuint service_id() const {
     return service_id_;
   }
 
   const SamplerIndices& sampler_indices() {
     return sampler_indices_;
@@ skipping 43 matching lines @@
   GLint GetUniformFakeLocation(const std::string& name) const;
 
   // Gets the UniformInfo of a uniform by location.
   const UniformInfo* GetUniformInfoByFakeLocation(
       GLint fake_location, GLint* real_location, GLint* array_index) const;
 
   // Returns true if |fake_location| is a location for an inactive uniform,
   // -1 for bound, non-existing uniform.
   bool IsInactiveUniformLocationByFakeLocation(GLint fake_location) const;
 
+  // Gets the ProgramOutputInfo of a fragment output by name.
+  const ProgramOutputInfo* GetProgramOutputInfo(
+      const std::string& original_name) const;
+
   // Gets all the program info.
   void GetProgramInfo(
       ProgramManager* manager, CommonDecoder::Bucket* bucket) const;
 
   // Gets all the UniformBlock info.
   // Return false on overflow.
   bool GetUniformBlocks(CommonDecoder::Bucket* bucket) const;
 
   // Gets all the TransformFeedbackVarying info.
   // Return false on overflow.
   bool GetTransformFeedbackVaryings(CommonDecoder::Bucket* bucket) const;
 
   // Gather all info through glGetActiveUniformsiv, except for size, type,
   // name_length, which we gather through glGetActiveUniform in
   // glGetProgramInfoCHROMIUM.
   bool GetUniformsES3(CommonDecoder::Bucket* bucket) const;
 
+  // Returns the fragment shader output variable color name binding.
+  // Returns -1 if |original_name| is not an out variable or error.
+  GLint GetFragDataLocation(const std::string& original_name) const;
+
+  // Returns the fragment shader output variable color index binding.
+  // Returns -1 if |original_name| is not an out variable or error.
+  GLint GetFragDataIndex(const std::string& original_name) const;
+
   // Sets the sampler values for a uniform.
   // This is safe to call for any location. If the location is not
   // a sampler uniform nothing will happen.
   // Returns false if fake_location is a sampler and any value
   // is >= num_texture_units. Returns true otherwise.
   bool SetSamplers(
       GLint num_texture_units, GLint fake_location,
       GLsizei count, const GLint* value);
 
   bool IsDeleted() const {
@@ skipping 39 matching lines @@
   // returns false if error.
   bool SetUniformLocationBinding(const std::string& name, GLint location);
 
   // Detects if the shader version combination is not valid.
   bool DetectShaderVersionMismatch() const;
 
   // Sets fragment input-location binding from a
   // glBindFragmentInputLocationCHROMIUM() call.
   void SetFragmentInputLocationBinding(const std::string& name, GLint location);
 
+  // Sets program output variable location. Also sets color index to zero.
+  void SetProgramOutputLocationBinding(const std::string& name,
+                                       GLuint colorName);
+
+  // Sets program output variable location and color index.
+  void SetProgramOutputLocationIndexedBinding(const std::string& name,
+                                              GLuint colorName,
+                                              GLuint index);
+
   // Detects if there are attribute location conflicts from
   // glBindAttribLocation() calls.
   // We only consider the declared attributes in the program.
   bool DetectAttribLocationBindingConflicts() const;
 
   // Detects if there are uniform location conflicts from
   // glBindUniformLocationCHROMIUM() calls.
   // We only consider the statically used uniforms in the program.
   bool DetectUniformLocationBindingConflicts() const;
 
   // Detects if there are uniforms of the same name but different type
   // or precision in vertex/fragment shaders.
   // Return true and set the first found conflicting hashed name to
   // conflicting_name if such cases are detected.
   bool DetectUniformsMismatch(std::string* conflicting_name) const;
 
   // Return true if a varying is statically used in fragment shader, but it
   // is not declared in vertex shader.
   bool DetectVaryingsMismatch(std::string* conflicting_name) const;
 
   // Detects if there are fragment input location conflicts from
   // glBindFragmentInputLocationCHROMIUM() calls.
   // We only consider the statically used fragment inputs in the program.
   bool DetectFragmentInputLocationBindingConflicts() const;
 
+  // Detects if there are program output location conflicts from
+  // glBindFragDataLocation and ..LocationIndexedEXT calls.
+  // We only consider the statically used program outputs in the program.
+  bool DetectProgramOutputLocationBindingConflicts() const;
+
   // Return true if any built-in invariant matching rules are broken as in
   // GLSL ES spec 1.00.17, section 4.6.4, Invariance and Linkage.
   bool DetectBuiltInInvariantConflicts() const;
 
   // Return true if an uniform and an attribute share the same name.
   bool DetectGlobalNameConflicts(std::string* conflicting_name) const;
 
   // Return false if varyings can't be packed into the max available
   // varying registers.
   bool CheckVaryingsPacking(VaryingsPackingOption option) const;
@@ skipping 42 matching lines @@
     deleted_ =  true;
   }
 
   // Resets the program.
   void Reset();
 
   // Updates the program info after a successful link.
   void Update();
   void UpdateUniforms();
   void UpdateFragmentInputs();
+  void UpdateProgramOutputs();
 
   // Process the program log, replacing the hashed names with original names.
   std::string ProcessLogInfo(const std::string& log);
 
   // Updates the program log info from GL
   void UpdateLogInfo();
 
   template <typename VarT>
   void GetUniformBlockMembers(
       Shader* shader, const std::vector<VarT>& fields,
@@ skipping 13 matching lines @@
   // glBindAttribLocation() again with the mapped names.
   // This is called right before the glLink() call, but after shaders are
   // translated.
   void ExecuteBindAttribLocationCalls();
 
   // The names of transform feedback varyings need to be hashed just
   // like bound attributes' locations, just before the link call.
   // Returns false upon failure.
   bool ExecuteTransformFeedbackVaryingsCall();
 
+  void ExecuteProgramOutputBindCalls();
+
   // Query VertexAttrib data returned by ANGLE translator by the mapped name.
   void GetVertexAttribData(
       const std::string& name, std::string* original_name, GLenum* type) const;
 
   void DetachShaders(ShaderManager* manager);
 
   static inline size_t GetUniformLocationIndexFromFakeLocation(
       GLint fake_location) {
     return static_cast<size_t>(fake_location & 0xFFFF);
   }
@@ skipping 22 matching lines @@
   // Uniform info by index.
   UniformInfoVector uniform_infos_;
   UniformLocationVector uniform_locations_;
 
   // The indices of the uniforms that are samplers.
   SamplerIndices sampler_indices_;
 
   FragmentInputInfoVector fragment_input_infos_;
   FragmentInputLocationVector fragment_input_locations_;
 
+  ProgramOutputInfoVector program_output_infos_;
+
   // The program this Program is tracking.
   GLuint service_id_;
 
   // Shaders by type of shader.
   scoped_refptr<Shader>
       attached_shaders_[kMaxAttachedShaders];
 
   // True if this program is marked as deleted.
   bool deleted_;
 
@@ skipping 15 matching lines @@
   // uniform-location binding map from glBindUniformLocationCHROMIUM() calls.
   LocationMap bind_uniform_location_map_;
 
   std::vector<std::string> transform_feedback_varyings_;
 
   GLenum transform_feedback_buffer_mode_;
 
   // Fragment input-location binding map from
   // glBindFragmentInputLocationCHROMIUM() calls.
   LocationMap bind_fragment_input_location_map_;
+
+  // output variable - (location,index) binding map from
+  // glBindFragDataLocation() and ..IndexedEXT() calls.
+  LocationIndexMap bind_program_output_location_index_map_;
 };
 
 // Tracks the Programs.
 //
 // NOTE: To support shared resources an instance of this class will
 // need to be shared by multiple GLES2Decoders.
 class GPU_EXPORT ProgramManager {
  public:
   explicit ProgramManager(ProgramCache* program_cache,
                           uint32 max_varying_vectors,
+                          uint32 max_dual_source_draw_buffers,
                           FeatureInfo* feature_info);
   ~ProgramManager();
 
   // Must call before destruction.
   void Destroy(bool have_context);
 
   // Creates a new program.
   Program* CreateProgram(GLuint client_id, GLuint service_id);
 
   // Gets a program.
@@ skipping 10 matching lines @@
 
   // Marks a program as used.
   void UseProgram(Program* program);
 
   // Makes a program as unused. If deleted the program will be removed.
   void UnuseProgram(ShaderManager* shader_manager, Program* program);
 
   // Clears the uniforms for this program.
   void ClearUniforms(Program* program);
 
-  // Returns true if prefix is invalid for gl.
-  static bool IsInvalidPrefix(const char* name, size_t length);
+  // Returns true if |name| has a prefix that is intended for GL built-in shader
+  // variables.
+  static bool HasBuiltInPrefix(const std::string& name);
 
   // Check if a Program is owned by this ProgramManager.
   bool IsOwned(Program* program) const;
 
   static int32 MakeFakeLocation(int32 index, int32 element);
 
   uint32 max_varying_vectors() const {
     return max_varying_vectors_;
   }
 
+  uint32 max_dual_source_draw_buffers() const {
+    return max_dual_source_draw_buffers_;
+  }
+
  private:
   friend class Program;
 
   void StartTracking(Program* program);
   void StopTracking(Program* program);
 
   void RemoveProgramInfoIfUnused(
       ShaderManager* shader_manager, Program* program);
 
   // Info for each "successfully linked" program by service side program Id.
   // TODO(gman): Choose a faster container.
   typedef std::map<GLuint, scoped_refptr<Program> > ProgramMap;
   ProgramMap programs_;
 
   // Counts the number of Program allocated with 'this' as its manager.
   // Allows to check no Program will outlive this.
   unsigned int program_count_;
 
   bool have_context_;
 
   // Used to clear uniforms.
   std::vector<uint8> zero_;
 
   ProgramCache* program_cache_;
 
   uint32 max_varying_vectors_;
+  uint32 max_dual_source_draw_buffers_;
 
   scoped_refptr<FeatureInfo> feature_info_;
 
   DISALLOW_COPY_AND_ASSIGN(ProgramManager);
 };
 
 inline const FeatureInfo& Program::feature_info() const {
   return *manager_->feature_info_.get();
 }
 
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_PROGRAM_MANAGER_H_