The great shader refactor: Prepare to merge all vertex shaders.

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 95 matching lines @@
                               int* highp_threshold_cache,
                               int highp_threshold_min,
                               const gfx::Point& max_coordinate);
 
 CC_EXPORT TexCoordPrecision TexCoordPrecisionRequired(
     gpu::gles2::GLES2Interface* context,
     int *highp_threshold_cache,
     int highp_threshold_min,
     const gfx::Size& max_size);
 
-class VertexShaderPosTex {
+class VertexShaderBase {
  public:
-  VertexShaderPosTex();
-
+  VertexShaderBase();
   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_; }
 
- private:
-  int matrix_location_;
+  int vertex_tex_transform_location() const {
+    return vertex_tex_transform_location_;
+  }
 
-  DISALLOW_COPY_AND_ASSIGN(VertexShaderPosTex);
-};
+  int tex_matrix_location() const { return tex_matrix_location_; }
 
-class VertexShaderPosTexYUVStretchOffset {
- public:
-  VertexShaderPosTexYUVStretchOffset();
-
-  void Init(gpu::gles2::GLES2Interface* context,
-            unsigned program,
-            int* base_uniform_index);
-  std::string GetShaderString() const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
-
-  int matrix_location() const { return matrix_location_; }
   int ya_tex_scale_location() const { return ya_tex_scale_location_; }
   int ya_tex_offset_location() const { return ya_tex_offset_location_; }
   int uv_tex_scale_location() const { return uv_tex_scale_location_; }
   int uv_tex_offset_location() const { return uv_tex_offset_location_; }
 
- private:
-  int matrix_location_;
-  int ya_tex_scale_location_;
-  int ya_tex_offset_location_;
-  int uv_tex_scale_location_;
-  int uv_tex_offset_location_;
+  int matrix_location() const { return matrix_location_; }
 
-  DISALLOW_COPY_AND_ASSIGN(VertexShaderPosTexYUVStretchOffset);
+  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:
+  virtual std::string GetShaderSource() const = 0;
+

[ccameron, 2017/01/04 09:06:12]

has_tex_transform_, has_vertex_tex_transform, has_text_matrix, and
has_ya_uv_tex_scale_offset are all mutually-exclusive.

They also have inconsistent meanings (e.g, some refer to arrays to index into,
some are just uniforms).

For now I grouped these together by the _location() accessor function name, to
minimize diffs.

+  bool has_tex_transform_ = false;
+  int tex_transform_location_ = -1;
+
+  bool has_vertex_tex_transform_ = false;
+  int vertex_tex_transform_location_ = -1;
+
+  bool has_tex_matrix_ = false;
+  int tex_matrix_location_ = -1;
+
+  bool has_ya_uv_tex_scale_offset_ = false;
+  int ya_tex_scale_location_ = -1;
+  int ya_tex_offset_location_ = -1;
+  int uv_tex_scale_location_ = -1;
+  int uv_tex_offset_location_ = -1;
+
+  bool has_matrix_ = false;
+  int matrix_location_ = -1;
+
+  bool has_vertex_opacity_ = false;
+  int vertex_opacity_location_ = -1;
+
+  bool has_aa_ = false;
+  int viewport_location_ = -1;
+  int edge_location_ = -1;
+
+  bool has_quad_ = false;
+  int quad_location_ = -1;
 };
 
-class VertexShaderPos {
+class VertexShaderPosTex : public VertexShaderBase {
  public:
-  VertexShaderPos();
-
-  void Init(gpu::gles2::GLES2Interface* context,
-            unsigned program,
-            int* base_uniform_index);
-  std::string GetShaderString() const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
-
-  int matrix_location() const { return matrix_location_; }
-
- private:
-  int matrix_location_;
-
-  DISALLOW_COPY_AND_ASSIGN(VertexShaderPos);
+  VertexShaderPosTex() { has_matrix_ = true; }
+  std::string GetShaderSource() const override;
 };
 
-class VertexShaderPosTexIdentity {
+class VertexShaderPosTexYUVStretchOffset : public VertexShaderBase {
  public:
-  void Init(gpu::gles2::GLES2Interface* context,
-            unsigned program,
-            int* base_uniform_index) {}
-  std::string GetShaderString() const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
+  VertexShaderPosTexYUVStretchOffset() {
+    has_matrix_ = true;
+    has_ya_uv_tex_scale_offset_ = true;
+  }
+  std::string GetShaderSource() const override;
 };
 
-class VertexShaderPosTexTransform {
+class VertexShaderPos : public VertexShaderBase {
  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_;
-
-  DISALLOW_COPY_AND_ASSIGN(VertexShaderPosTexTransform);
+  VertexShaderPos() { has_matrix_ = true; }
+  std::string GetShaderSource() const override;
 };
 
-class VertexShaderQuad {
+class VertexShaderPosTexIdentity : public VertexShaderBase {
  public:
-  VertexShaderQuad();
-
-  void Init(gpu::gles2::GLES2Interface* context,
-           unsigned program,
-           int* base_uniform_index);
-  std::string GetShaderString() const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
-
-  int matrix_location() const { return matrix_location_; }
-  int viewport_location() const { return -1; }
-  int quad_location() const { return quad_location_; }
-  int edge_location() const { return -1; }
-
- private:
-  int matrix_location_;
-  int quad_location_;
-
-  DISALLOW_COPY_AND_ASSIGN(VertexShaderQuad);
+  std::string GetShaderSource() const override;
 };
 
-class VertexShaderQuadAA {
+class VertexShaderPosTexTransform : public VertexShaderBase {
  public:
-  VertexShaderQuadAA();
-
-  void Init(gpu::gles2::GLES2Interface* context,
-           unsigned program,
-           int* base_uniform_index);
-  std::string GetShaderString() const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
-
-  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_; }
-
- private:
-  int matrix_location_;
-  int viewport_location_;
-  int quad_location_;
-  int edge_location_;
-
-  DISALLOW_COPY_AND_ASSIGN(VertexShaderQuadAA);
+  VertexShaderPosTexTransform() {
+    has_matrix_ = true;
+    has_tex_transform_ = true;
+    has_vertex_opacity_ = true;
+  }
+  std::string GetShaderSource() const override;
 };
 
-
-class VertexShaderQuadTexTransformAA {
+class VertexShaderQuad : public VertexShaderBase {
  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_;
-  int quad_location_;
-  int edge_location_;
-  int tex_transform_location_;
-
-  DISALLOW_COPY_AND_ASSIGN(VertexShaderQuadTexTransformAA);
+  VertexShaderQuad() {
+    has_matrix_ = true;
+    has_quad_ = true;
+  }
+  std::string GetShaderSource() const override;
 };
 
-class VertexShaderTile {
+class VertexShaderQuadAA : public VertexShaderBase {
  public:
-  VertexShaderTile();
-
-  void Init(gpu::gles2::GLES2Interface* context,
-            unsigned program,
-            int* base_uniform_index);
-  std::string GetShaderString() const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
-
-  int matrix_location() const { return matrix_location_; }
-  int viewport_location() const { return -1; }
-  int quad_location() const { return quad_location_; }
-  int edge_location() const { return -1; }
-  int vertex_tex_transform_location() const {
-    return vertex_tex_transform_location_;
+  VertexShaderQuadAA() {
+    has_matrix_ = true;
+    has_aa_ = true;
+    has_quad_ = true;
   }
-
- private:
-  int matrix_location_;
-  int quad_location_;
-  int vertex_tex_transform_location_;
-
-  DISALLOW_COPY_AND_ASSIGN(VertexShaderTile);
+  std::string GetShaderSource() const override;
 };
 
-class VertexShaderTileAA {
+class VertexShaderQuadTexTransformAA : public VertexShaderBase {
  public:
-  VertexShaderTileAA();
-
-  void Init(gpu::gles2::GLES2Interface* context,
-            unsigned program,
-            int* base_uniform_index);
-  std::string GetShaderString() const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
-
-  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 vertex_tex_transform_location() const {
-    return vertex_tex_transform_location_;
+  VertexShaderQuadTexTransformAA() {
+    has_matrix_ = true;
+    has_aa_ = true;
+    has_quad_ = true;
+    has_tex_transform_ = true;
   }
-
- private:
-  int matrix_location_;
-  int viewport_location_;
-  int quad_location_;
-  int edge_location_;
-  int vertex_tex_transform_location_;
-
-  DISALLOW_COPY_AND_ASSIGN(VertexShaderTileAA);
+  std::string GetShaderSource() const override;
 };
 
-class VertexShaderVideoTransform {
+class VertexShaderTile : public VertexShaderBase {
  public:
-  VertexShaderVideoTransform();
+  VertexShaderTile() {
+    has_matrix_ = true;
+    has_quad_ = true;
+    has_vertex_tex_transform_ = true;
+  }
+  std::string GetShaderSource() const override;
+};
 
-  void Init(gpu::gles2::GLES2Interface* context,
-            unsigned program,
-            int* base_uniform_index);
-  std::string GetShaderString() const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
+class VertexShaderTileAA : public VertexShaderBase {
+ public:
+  VertexShaderTileAA() {
+    has_matrix_ = true;
+    has_quad_ = true;
+    has_vertex_tex_transform_ = true;
+    has_aa_ = true;
+  }
+  std::string GetShaderSource() const override;
+};
 
-  int matrix_location() const { return matrix_location_; }
-  int tex_matrix_location() const { return tex_matrix_location_; }
-
- private:
-  int matrix_location_;
-  int tex_matrix_location_;
-
-  DISALLOW_COPY_AND_ASSIGN(VertexShaderVideoTransform);
+class VertexShaderVideoTransform : public VertexShaderBase {
+ public:
+  VertexShaderVideoTransform() {
+    has_matrix_ = true;
+    has_tex_matrix_ = true;
+  }
+  std::string GetShaderSource() const override;
 };
 
 class FragmentShaderBase {
  public:
   virtual void Init(gpu::gles2::GLES2Interface* context,
                     unsigned program,
                     int* base_uniform_index);
   std::string GetShaderString(TexCoordPrecision precision,
                               SamplerType sampler) const;
   void FillLocations(ShaderLocations* locations) const;
@@ skipping 299 matching lines @@
   FragmentShaderColorAA() {
     input_color_type_ = INPUT_COLOR_SOURCE_UNIFORM;
     has_aa_ = true;
     frag_color_mode_ = FRAG_COLOR_MODE_DEFAULT;
   }
 };
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_SHADER_H_