The great shader refactor: Separate initialization from ctor

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/macros.h"
@@ skipping 44 matching lines @@
 
 // Position source for the vertex shader.
 enum PositionSource {
   // The position is read directly from the position attribute.
   POSITION_SOURCE_ATTRIBUTE,
   // The position is read by attribute index into a uniform array for xy, and
   // getting zw from the attribute.
   POSITION_SOURCE_ATTRIBUTE_INDEXED_UNIFORM,
 };
 
+enum AAMode {
+  NO_AA = 0,
+  USE_AA = 1,
+};
+
+enum SwizzleMode {
+  NO_SWIZZLE = 0,
+  DO_SWIZZLE = 1,
+};
+
+enum PremultipliedAlphaMode {
+  PREMULTIPLIED_ALPHA = 0,
+  NON_PREMULTIPLIED_ALPHA = 1,
+};
+
 enum SamplerType {
   SAMPLER_TYPE_NA = 0,
   SAMPLER_TYPE_2D = 1,
   SAMPLER_TYPE_2D_RECT = 2,
   SAMPLER_TYPE_EXTERNAL_OES = 3,
   LAST_SAMPLER_TYPE = 3
 };
 
 enum BlendMode {
   BLEND_MODE_NONE,
@@ skipping 93 matching lines @@
   int matrix_location() const { return matrix_location_; }
 
   int vertex_opacity_location() const { return vertex_opacity_location_; }
 
   int viewport_location() const { return viewport_location_; }
   int edge_location() const { return edge_location_; }
 
   int quad_location() const { return quad_location_; }
 
  protected:
+  template <class VertexShader, class FragmentShader>
+  friend class ProgramBinding;
+
   // Use arrays of uniforms for matrix, texTransform, and opacity.
   bool use_uniform_arrays_ = false;
 
   PositionSource position_source_ = POSITION_SOURCE_ATTRIBUTE;
   TexCoordSource tex_coord_source_ = TEX_COORD_SOURCE_NONE;
   TexCoordTransform tex_coord_transform_ = TEX_COORD_TRANSFORM_NONE;
 
   // Used only with TEX_COORD_TRANSFORM_VEC4.
   int vertex_tex_transform_location_ = -1;
 
@@ skipping 15 matching lines @@
   int quad_location_ = -1;
 
   // Extra dummy variables to work around bugs on Android.
   // TODO(ccameron): This is likley unneeded cargo-culting.
   // http://crbug.com/240602
   bool has_dummy_variables_ = false;
 
   bool has_vertex_opacity_ = false;
   int vertex_opacity_location_ = -1;
 
-  bool has_aa_ = false;
+  AAMode aa_mode_ = NO_AA;
   int viewport_location_ = -1;
   int edge_location_ = -1;
 };
 
 class VertexShaderPosTex : public VertexShaderBase {
  public:
-  VertexShaderPosTex() {
+  void SetSubclassProperties() {
     tex_coord_source_ = TEX_COORD_SOURCE_ATTRIBUTE;
     has_matrix_ = true;
   }
 };
 
 class VertexShaderPosTexYUVStretchOffset : public VertexShaderBase {
  public:
-  VertexShaderPosTexYUVStretchOffset() {
+  void SetSubclassProperties() {
     tex_coord_source_ = TEX_COORD_SOURCE_ATTRIBUTE;
     has_matrix_ = true;
     is_ya_uv_ = true;
   }
 };
 
 class VertexShaderPos : public VertexShaderBase {
  public:
-  VertexShaderPos() { has_matrix_ = true; }
+  void SetSubclassProperties() { has_matrix_ = true; }
 };
 
 class VertexShaderPosTexTransform : public VertexShaderBase {
  public:
-  VertexShaderPosTexTransform() {
+  void SetSubclassProperties() {
     tex_coord_source_ = TEX_COORD_SOURCE_ATTRIBUTE;
     tex_coord_transform_ = TEX_COORD_TRANSFORM_VEC4;
     has_matrix_ = true;
     has_vertex_opacity_ = true;
     use_uniform_arrays_ = true;
   }
 };
 
 class VertexShaderQuad : public VertexShaderBase {
  public:
-  VertexShaderQuad() {
+  void SetSubclassProperties() {
     position_source_ = POSITION_SOURCE_ATTRIBUTE_INDEXED_UNIFORM;
     has_matrix_ = true;
 #if defined(OS_ANDROID)
     has_dummy_variables_ = true;
 #endif
   }
 };
 
 class VertexShaderQuadAA : public VertexShaderBase {
  public:
-  VertexShaderQuadAA() {
+  void SetSubclassProperties() {
     position_source_ = POSITION_SOURCE_ATTRIBUTE_INDEXED_UNIFORM;
     has_matrix_ = true;
-    has_aa_ = true;
+    aa_mode_ = USE_AA;
   }
 };
 
 class VertexShaderQuadTexTransformAA : public VertexShaderBase {
  public:
-  VertexShaderQuadTexTransformAA() {
+  void SetSubclassProperties() {
     position_source_ = POSITION_SOURCE_ATTRIBUTE_INDEXED_UNIFORM;
     tex_coord_source_ = TEX_COORD_SOURCE_POSITION;
     tex_coord_transform_ = TEX_COORD_TRANSFORM_TRANSLATED_VEC4;
     has_matrix_ = true;
-    has_aa_ = true;
+    aa_mode_ = USE_AA;
   }
 };
 
 class VertexShaderTile : public VertexShaderBase {
  public:
-  VertexShaderTile() {
+  void SetSubclassProperties() {
     position_source_ = POSITION_SOURCE_ATTRIBUTE_INDEXED_UNIFORM;
     tex_coord_source_ = TEX_COORD_SOURCE_ATTRIBUTE;
     tex_coord_transform_ = TEX_COORD_TRANSFORM_VEC4;
     has_matrix_ = true;
   }
 };
 
 class VertexShaderTileAA : public VertexShaderBase {
  public:
-  VertexShaderTileAA() {
+  void SetSubclassProperties() {
     position_source_ = POSITION_SOURCE_ATTRIBUTE_INDEXED_UNIFORM;
     tex_coord_source_ = TEX_COORD_SOURCE_POSITION;
     tex_coord_transform_ = TEX_COORD_TRANSFORM_VEC4;
     has_matrix_ = true;
-    has_aa_ = true;
+    aa_mode_ = USE_AA;
   }
 };
 
 class VertexShaderVideoTransform : public VertexShaderBase {
  public:
-  VertexShaderVideoTransform() {
+  void SetSubclassProperties() {
     tex_coord_source_ = TEX_COORD_SOURCE_ATTRIBUTE;
     tex_coord_transform_ = TEX_COORD_TRANSFORM_MATRIX;
     has_matrix_ = true;
   }
 };
 
 class FragmentShaderBase {
  public:
   virtual void Init(gpu::gles2::GLES2Interface* context,
                     unsigned program,
                     int* base_uniform_index);
-  std::string GetShaderString(TexCoordPrecision precision,
-                              SamplerType sampler) const;
+  std::string GetShaderString() const;
   void FillLocations(ShaderLocations* locations) const;
 
-  BlendMode blend_mode() const { return blend_mode_; }
-  void set_blend_mode(BlendMode blend_mode) { blend_mode_ = blend_mode; }
-  bool has_blend_mode() const { return blend_mode_ != BLEND_MODE_NONE; }
-  void set_mask_for_background(bool mask_for_background) {
-    mask_for_background_ = mask_for_background;
-  }
-  bool mask_for_background() const { return mask_for_background_; }
-
   int sampler_location() const { return sampler_location_; }
   int alpha_location() const { return alpha_location_; }
   int color_location() const { return color_location_; }
   int background_color_location() const { return background_color_location_; }
   int fragment_tex_transform_location() const {
     return fragment_tex_transform_location_;
   }
 
  protected:
   FragmentShaderBase();
   virtual std::string GetShaderSource() const;
+  bool has_blend_mode() const { return blend_mode_ != BLEND_MODE_NONE; }
 
   std::string SetBlendModeFunctions(const std::string& shader_string) const;
 
   // Settings that are modified by sub-classes.
-  bool has_aa_ = false;
+  AAMode aa_mode_ = NO_AA;
   bool has_varying_alpha_ = false;
-  bool has_swizzle_ = false;
-  bool has_premultiply_alpha_ = false;
+  SwizzleMode swizzle_mode_ = NO_SWIZZLE;
+  PremultipliedAlphaMode premultiply_alpha_mode_ = PREMULTIPLIED_ALPHA;
   FragColorMode frag_color_mode_ = FRAG_COLOR_MODE_DEFAULT;
   InputColorSource input_color_type_ = INPUT_COLOR_SOURCE_RGBA_TEXTURE;
 
   // Used only if |blend_mode_| is not BLEND_MODE_NONE.
   int backdrop_location_ = -1;
   int original_backdrop_location_ = -1;
   int backdrop_rect_location_ = -1;
 
   // Used only if |input_color_type_| is INPUT_COLOR_SOURCE_RGBA_TEXTURE.
   bool has_rgba_fragment_tex_transform_ = false;
   int sampler_location_ = -1;
   int fragment_tex_transform_location_ = -1;
 
   // Always use sampler2D and texture2D for the RGBA texture, regardless of the
   // specified SamplerType.
   // TODO(ccameron): Change GLRenderer to always specify the correct
   // SamplerType.
   bool ignore_sampler_type_ = false;
 
   // Used only if |input_color_type_| is INPUT_COLOR_SOURCE_UNIFORM.
   int color_location_ = -1;
 
-  bool has_mask_sampler_ = false;
+  MaskMode mask_mode_ = NO_MASK;
   int mask_sampler_location_ = -1;
   int mask_tex_coord_scale_location_ = -1;
   int mask_tex_coord_offset_location_ = -1;
 
   bool has_color_matrix_ = false;
   int color_matrix_location_ = -1;
   int color_offset_location_ = -1;
 
   bool has_uniform_alpha_ = false;
   int alpha_location_ = -1;
 
   bool has_background_color_ = false;
   int background_color_location_ = -1;
 
- private:
+  TexCoordPrecision tex_coord_precision_ = TEX_COORD_PRECISION_NA;
+  SamplerType sampler_type_ = SAMPLER_TYPE_NA;
+
   BlendMode blend_mode_ = BLEND_MODE_NONE;
   bool mask_for_background_ = false;
 
+ private:
+  template <class VertexShader, class FragmentShader>
+  friend class ProgramBinding;
+
   std::string GetHelperFunctions() const;
   std::string GetBlendFunction() const;
   std::string GetBlendFunctionBodyForRGB() const;
 
   DISALLOW_COPY_AND_ASSIGN(FragmentShaderBase);
 };
 
 class FragmentShaderRGBATexVaryingAlpha : public FragmentShaderBase {
  public:
-  FragmentShaderRGBATexVaryingAlpha() {
+  void SetSubclassProperties() {
     has_varying_alpha_ = true;
     frag_color_mode_ = FRAG_COLOR_MODE_DEFAULT;
   }
 };
 
 class FragmentShaderRGBATexPremultiplyAlpha : public FragmentShaderBase {
  public:
-  FragmentShaderRGBATexPremultiplyAlpha() {
+  void SetSubclassProperties() {
     has_varying_alpha_ = true;
-    has_premultiply_alpha_ = true;
+    premultiply_alpha_mode_ = NON_PREMULTIPLIED_ALPHA;
     frag_color_mode_ = FRAG_COLOR_MODE_DEFAULT;
   }
 };
 
 class FragmentShaderTexBackgroundVaryingAlpha : public FragmentShaderBase {
  public:
-  FragmentShaderTexBackgroundVaryingAlpha() {
+  void SetSubclassProperties() {
     has_background_color_ = true;
     has_varying_alpha_ = true;
     frag_color_mode_ = FRAG_COLOR_MODE_DEFAULT;
   }
 };
 
 class FragmentShaderTexBackgroundPremultiplyAlpha : public FragmentShaderBase {
  public:
-  FragmentShaderTexBackgroundPremultiplyAlpha() {
+  void SetSubclassProperties() {
     has_background_color_ = true;
     has_varying_alpha_ = true;
-    has_premultiply_alpha_ = true;
+    premultiply_alpha_mode_ = NON_PREMULTIPLIED_ALPHA;
     frag_color_mode_ = FRAG_COLOR_MODE_DEFAULT;
   }
 };
 
 class FragmentShaderRGBATexAlpha : public FragmentShaderBase {
  public:
-  FragmentShaderRGBATexAlpha() {
+  void SetSubclassProperties() {
     has_uniform_alpha_ = true;
     frag_color_mode_ = FRAG_COLOR_MODE_APPLY_BLEND_MODE;
   }
 };
 
 class FragmentShaderRGBATexColorMatrixAlpha : public FragmentShaderBase {
  public:
-  FragmentShaderRGBATexColorMatrixAlpha() {
+  void SetSubclassProperties() {
     has_uniform_alpha_ = true;
     has_color_matrix_ = true;
     frag_color_mode_ = FRAG_COLOR_MODE_APPLY_BLEND_MODE;
   }
 };
 
 class FragmentShaderRGBATexOpaque : public FragmentShaderBase {
  public:
-  FragmentShaderRGBATexOpaque() { frag_color_mode_ = FRAG_COLOR_MODE_OPAQUE; }
+  void SetSubclassProperties() { frag_color_mode_ = FRAG_COLOR_MODE_OPAQUE; }
 };
 
 class FragmentShaderRGBATex : public FragmentShaderBase {
  public:
-  FragmentShaderRGBATex() { frag_color_mode_ = FRAG_COLOR_MODE_DEFAULT; }
+  void SetSubclassProperties() { frag_color_mode_ = FRAG_COLOR_MODE_DEFAULT; }
 };
 
 // Swizzles the red and blue component of sampled texel with alpha.
 class FragmentShaderRGBATexSwizzleAlpha : public FragmentShaderBase {
  public:
-  FragmentShaderRGBATexSwizzleAlpha() {
+  void SetSubclassProperties() {
     has_uniform_alpha_ = true;
-    has_swizzle_ = true;
+    swizzle_mode_ = DO_SWIZZLE;
     frag_color_mode_ = FRAG_COLOR_MODE_DEFAULT;
   }
 };
 
 // Swizzles the red and blue component of sampled texel without alpha.
 class FragmentShaderRGBATexSwizzleOpaque : public FragmentShaderBase {
  public:
-  FragmentShaderRGBATexSwizzleOpaque() {
-    has_swizzle_ = true;
+  void SetSubclassProperties() {
+    swizzle_mode_ = DO_SWIZZLE;
     frag_color_mode_ = FRAG_COLOR_MODE_OPAQUE;
   }
 };
 
 class FragmentShaderRGBATexAlphaAA : public FragmentShaderBase {
  public:
-  FragmentShaderRGBATexAlphaAA() {
-    has_aa_ = true;
+  void SetSubclassProperties() {
+    aa_mode_ = USE_AA;
     has_uniform_alpha_ = true;
     frag_color_mode_ = FRAG_COLOR_MODE_APPLY_BLEND_MODE;
   }
 };
 
 class FragmentShaderRGBATexClampAlphaAA : public FragmentShaderBase {
  public:
-  FragmentShaderRGBATexClampAlphaAA() {
-    has_aa_ = true;
+  void SetSubclassProperties() {
+    aa_mode_ = USE_AA;
     has_uniform_alpha_ = true;
     has_rgba_fragment_tex_transform_ = true;
     frag_color_mode_ = FRAG_COLOR_MODE_DEFAULT;
   }
 };
 
 // Swizzles the red and blue component of sampled texel.
 class FragmentShaderRGBATexClampSwizzleAlphaAA : public FragmentShaderBase {
  public:
-  FragmentShaderRGBATexClampSwizzleAlphaAA() {
-    has_aa_ = true;
+  void SetSubclassProperties() {
+    aa_mode_ = USE_AA;
     has_uniform_alpha_ = true;
     has_rgba_fragment_tex_transform_ = true;
-    has_swizzle_ = true;
+    swizzle_mode_ = DO_SWIZZLE;
     frag_color_mode_ = FRAG_COLOR_MODE_DEFAULT;
   }
 };
 
 class FragmentShaderRGBATexAlphaMask : public FragmentShaderBase {
  public:
-  FragmentShaderRGBATexAlphaMask() {
+  void SetSubclassProperties() {
     has_uniform_alpha_ = true;
-    has_mask_sampler_ = true;
+    mask_mode_ = HAS_MASK;
     frag_color_mode_ = FRAG_COLOR_MODE_APPLY_BLEND_MODE;
     ignore_sampler_type_ = true;
   }
 };
 
 class FragmentShaderRGBATexAlphaMaskAA : public FragmentShaderBase {
  public:
-  FragmentShaderRGBATexAlphaMaskAA() {
-    has_aa_ = true;
+  void SetSubclassProperties() {
+    aa_mode_ = USE_AA;
     has_uniform_alpha_ = true;
-    has_mask_sampler_ = true;
+    mask_mode_ = HAS_MASK;
     frag_color_mode_ = FRAG_COLOR_MODE_APPLY_BLEND_MODE;
     ignore_sampler_type_ = true;
   }
 };
 
 class FragmentShaderRGBATexAlphaMaskColorMatrixAA : public FragmentShaderBase {
  public:
-  FragmentShaderRGBATexAlphaMaskColorMatrixAA() {
-    has_aa_ = true;
+  void SetSubclassProperties() {
+    aa_mode_ = USE_AA;
     has_uniform_alpha_ = true;
-    has_mask_sampler_ = true;
+    mask_mode_ = HAS_MASK;
     has_color_matrix_ = true;
     frag_color_mode_ = FRAG_COLOR_MODE_APPLY_BLEND_MODE;
     ignore_sampler_type_ = true;
   }
 };
 
 class FragmentShaderRGBATexAlphaColorMatrixAA : public FragmentShaderBase {
  public:
-  FragmentShaderRGBATexAlphaColorMatrixAA() {
-    has_aa_ = true;
+  void SetSubclassProperties() {
+    aa_mode_ = USE_AA;
     has_uniform_alpha_ = true;
     has_color_matrix_ = true;
     frag_color_mode_ = FRAG_COLOR_MODE_APPLY_BLEND_MODE;
   }
 };
 
 class FragmentShaderRGBATexAlphaMaskColorMatrix : public FragmentShaderBase {
  public:
-  FragmentShaderRGBATexAlphaMaskColorMatrix() {
+  void SetSubclassProperties() {
     has_uniform_alpha_ = true;
-    has_mask_sampler_ = true;
+    mask_mode_ = HAS_MASK;
     has_color_matrix_ = true;
     frag_color_mode_ = FRAG_COLOR_MODE_APPLY_BLEND_MODE;
     ignore_sampler_type_ = true;
   }
 };
 
 class FragmentShaderYUVVideo : public FragmentShaderBase {
  public:
   FragmentShaderYUVVideo();
-  void SetFeatures(bool use_alpha_texture, bool use_nv12, bool use_color_lut);
+
+  void SetSubclassProperties() {}
 
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index) override;
   int y_texture_location() const { return y_texture_location_; }
   int u_texture_location() const { return u_texture_location_; }
   int v_texture_location() const { return v_texture_location_; }
   int uv_texture_location() const { return uv_texture_location_; }
   int a_texture_location() const { return a_texture_location_; }
   int lut_texture_location() const { return lut_texture_location_; }
   int alpha_location() const { return alpha_location_; }
   int yuv_matrix_location() const { return yuv_matrix_location_; }
   int yuv_adj_location() const { return yuv_adj_location_; }
   int ya_clamp_rect_location() const { return ya_clamp_rect_location_; }
   int uv_clamp_rect_location() const { return uv_clamp_rect_location_; }
   int resource_multiplier_location() const {
     return resource_multiplier_location_;
   }
   int resource_offset_location() const { return resource_offset_location_; }
 
  private:
+  template <class VertexShader, class FragmentShader>
+  friend class ProgramBinding;
+
   std::string GetShaderSource() const override;
 
   bool use_alpha_texture_ = false;
   bool use_nv12_ = false;
   bool use_color_lut_ = false;
 
   int y_texture_location_ = -1;
   int u_texture_location_ = -1;
   int v_texture_location_ = -1;
   int uv_texture_location_ = -1;
   int a_texture_location_ = -1;
   int lut_texture_location_ = -1;
   int alpha_location_ = -1;
   int yuv_matrix_location_ = -1;
   int yuv_adj_location_ = -1;
   int ya_clamp_rect_location_ = -1;
   int uv_clamp_rect_location_ = -1;
   int resource_multiplier_location_ = -1;
   int resource_offset_location_ = -1;
 };
 
 class FragmentShaderColor : public FragmentShaderBase {
  public:
-  FragmentShaderColor() {
+  void SetSubclassProperties() {
     input_color_type_ = INPUT_COLOR_SOURCE_UNIFORM;
     frag_color_mode_ = FRAG_COLOR_MODE_DEFAULT;
   }
 };
 
 class FragmentShaderColorAA : public FragmentShaderBase {
  public:
-  FragmentShaderColorAA() {
+  void SetSubclassProperties() {
     input_color_type_ = INPUT_COLOR_SOURCE_UNIFORM;
-    has_aa_ = true;
+    aa_mode_ = USE_AA;
     frag_color_mode_ = FRAG_COLOR_MODE_DEFAULT;
   }
 };
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_SHADER_H_