cc: Refactored shader locations

cc/output/shader.h

 // Copyright 2011 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 CC_OUTPUT_SHADER_H_
 #define CC_OUTPUT_SHADER_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 41 matching lines @@
   BLEND_MODE_DIFFERENCE,
   BLEND_MODE_EXCLUSION,
   BLEND_MODE_MULTIPLY,
   BLEND_MODE_HUE,
   BLEND_MODE_SATURATION,
   BLEND_MODE_COLOR,
   BLEND_MODE_LUMINOSITY,
   LAST_BLEND_MODE = BLEND_MODE_LUMINOSITY
 };
 
+struct ShaderLocations {
+  ShaderLocations();
+
+  int sampler = -1;
+  int quad = -1;
+  int edge = -1;
+  int viewport = -1;
+  int mask_sampler = -1;
+  int mask_tex_coord_scale = -1;
+  int mask_tex_coord_offset = -1;
+  int matrix = -1;
+  int alpha = -1;
+  int color_matrix = -1;
+  int color_offset = -1;
+  int tex_transform = -1;
+  int backdrop = -1;
+  int backdrop_rect = -1;
+};
+
 // Note: The highp_threshold_cache must be provided by the caller to make
 // the caching multi-thread/context safe in an easy low-overhead manner.
 // The caller must make sure to clear highp_threshold_cache to 0, so it can be
 // reinitialized, if a new or different context is used.
 CC_EXPORT TexCoordPrecision
     TexCoordPrecisionRequired(gpu::gles2::GLES2Interface* context,
                               int* highp_threshold_cache,
                               int highp_threshold_min,
                               const gfx::Point& max_coordinate);
 
@@ skipping 77 matching lines @@
 class VertexShaderPosTexTransform {
  public:
   VertexShaderPosTexTransform();
 
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index);
   std::string GetShaderString() const;
   static std::string GetShaderHead();
   static std::string GetShaderBody();
+  void FillLocations(ShaderLocations* locations) const;
 
   int matrix_location() const { return matrix_location_; }
   int tex_transform_location() const { return tex_transform_location_; }
   int vertex_opacity_location() const { return vertex_opacity_location_; }
 
  private:
   int matrix_location_;
   int tex_transform_location_;
   int vertex_opacity_location_;
 
@@ skipping 52 matching lines @@
 class VertexShaderQuadTexTransformAA {
  public:
   VertexShaderQuadTexTransformAA();
 
   void Init(gpu::gles2::GLES2Interface* context,
            unsigned program,
            int* base_uniform_index);
   std::string GetShaderString() const;
   static std::string GetShaderHead();
   static std::string GetShaderBody();
+  void FillLocations(ShaderLocations* locations) const;
 
   int matrix_location() const { return matrix_location_; }
   int viewport_location() const { return viewport_location_; }
   int quad_location() const { return quad_location_; }
   int edge_location() const { return edge_location_; }
   int tex_transform_location() const { return tex_transform_location_; }
 
  private:
   int matrix_location_;
   int viewport_location_;
@@ skipping 212 matching lines @@
   static std::string GetShaderHead();
   static std::string GetShaderBody();
 };
 
 class FragmentShaderRGBATexAlpha : public FragmentTexAlphaBinding {
  public:
   std::string GetShaderString(
       TexCoordPrecision precision, SamplerType sampler) const;
   static std::string GetShaderHead();
   static std::string GetShaderBody();
+  void FillLocations(ShaderLocations* locations) const;
 };
 
 class FragmentShaderRGBATexColorMatrixAlpha
     : public FragmentTexColorMatrixAlphaBinding {
  public:
   std::string GetShaderString(TexCoordPrecision precision,
                               SamplerType sampler) const;
   static std::string GetShaderHead();
   static std::string GetShaderBody();
+  void FillLocations(ShaderLocations* locations) const;
 };
 
 class FragmentShaderRGBATexOpaque : public FragmentTexOpaqueBinding {
  public:
   std::string GetShaderString(
       TexCoordPrecision precision, SamplerType sampler) const;
   static std::string GetShaderHead();
   static std::string GetShaderBody();
 };
 
@@ skipping 27 matching lines @@
  public:
   FragmentShaderRGBATexAlphaAA();
 
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index);
   std::string GetShaderString(
       TexCoordPrecision precision, SamplerType sampler) const;
   static std::string GetShaderHead();
   static std::string GetShaderBody();
+  void FillLocations(ShaderLocations* locations) const;
 
   int alpha_location() const { return alpha_location_; }
   int sampler_location() const { return sampler_location_; }
 
  private:
   int sampler_location_;
   int alpha_location_;
 
   DISALLOW_COPY_AND_ASSIGN(FragmentShaderRGBATexAlphaAA);
 };
@@ skipping 38 matching lines @@
   static std::string GetShaderBody();
 };
 
 class FragmentShaderRGBATexAlphaMask : public FragmentTexBlendMode {
  public:
   FragmentShaderRGBATexAlphaMask();
   std::string GetShaderString(
       TexCoordPrecision precision, SamplerType sampler) const;
   static std::string GetShaderHead();
   static std::string GetShaderBody();
-
+  void FillLocations(ShaderLocations* locations) const;
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index);
   int alpha_location() const { return alpha_location_; }
   int sampler_location() const { return sampler_location_; }
   int mask_sampler_location() const { return mask_sampler_location_; }
   int mask_tex_coord_scale_location() const {
     return mask_tex_coord_scale_location_;
   }
   int mask_tex_coord_offset_location() const {
@@ skipping 10 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(FragmentShaderRGBATexAlphaMask);
 };
 
 class FragmentShaderRGBATexAlphaMaskAA : public FragmentTexBlendMode {
  public:
   FragmentShaderRGBATexAlphaMaskAA();
   std::string GetShaderString(
       TexCoordPrecision precision, SamplerType sampler) const;
   static std::string GetShaderHead();
   static std::string GetShaderBody();
-
+  void FillLocations(ShaderLocations* locations) const;
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index);
   int alpha_location() const { return alpha_location_; }
   int sampler_location() const { return sampler_location_; }
   int mask_sampler_location() const { return mask_sampler_location_; }
   int mask_tex_coord_scale_location() const {
     return mask_tex_coord_scale_location_;
   }
   int mask_tex_coord_offset_location() const {
@@ skipping 11 matching lines @@
 };
 
 class FragmentShaderRGBATexAlphaMaskColorMatrixAA
     : public FragmentTexBlendMode {
  public:
   FragmentShaderRGBATexAlphaMaskColorMatrixAA();
   std::string GetShaderString(
       TexCoordPrecision precision, SamplerType sampler) const;
   static std::string GetShaderHead();
   static std::string GetShaderBody();
-
+  void FillLocations(ShaderLocations* locations) const;
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index);
   int alpha_location() const { return alpha_location_; }
   int sampler_location() const { return sampler_location_; }
   int mask_sampler_location() const { return mask_sampler_location_; }
   int mask_tex_coord_scale_location() const {
     return mask_tex_coord_scale_location_;
   }
   int mask_tex_coord_offset_location() const {
@@ skipping 12 matching lines @@
   int color_offset_location_;
 };
 
 class FragmentShaderRGBATexAlphaColorMatrixAA : public FragmentTexBlendMode {
  public:
   FragmentShaderRGBATexAlphaColorMatrixAA();
   std::string GetShaderString(
       TexCoordPrecision precision, SamplerType sampler) const;
   static std::string GetShaderHead();
   static std::string GetShaderBody();
-
+  void FillLocations(ShaderLocations* locations) const;
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index);
   int alpha_location() const { return alpha_location_; }
   int sampler_location() const { return sampler_location_; }
   int color_matrix_location() const { return color_matrix_location_; }
   int color_offset_location() const { return color_offset_location_; }
 
  private:
   int sampler_location_;
   int alpha_location_;
   int color_matrix_location_;
   int color_offset_location_;
 };
 
 class FragmentShaderRGBATexAlphaMaskColorMatrix : public FragmentTexBlendMode {
  public:
   FragmentShaderRGBATexAlphaMaskColorMatrix();
   std::string GetShaderString(
       TexCoordPrecision precision, SamplerType sampler) const;
   static std::string GetShaderHead();
   static std::string GetShaderBody();
-
+  void FillLocations(ShaderLocations* locations) const;
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index);
   int alpha_location() const { return alpha_location_; }
   int sampler_location() const { return sampler_location_; }
   int mask_sampler_location() const { return mask_sampler_location_; }
   int mask_tex_coord_scale_location() const {
     return mask_tex_coord_scale_location_;
   }
   int mask_tex_coord_offset_location() const {
@@ skipping 136 matching lines @@
   int tex_transform_location_;
   int frequency_location_;
   int color_location_;
 
   DISALLOW_COPY_AND_ASSIGN(FragmentShaderCheckerboard);
 };
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_SHADER_H_