The great shader refactor: Separate initialization from ctor

cc/output/shader.cc

 // 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.
 
 #include "cc/output/shader.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 180 matching lines @@
   if (is_ya_uv_) {
     uniforms.push_back("yaTexScale");
     uniforms.push_back("yaTexOffset");
     uniforms.push_back("uvTexScale");
     uniforms.push_back("uvTexOffset");
   }
   if (has_matrix_)
     uniforms.push_back("matrix");
   if (has_vertex_opacity_)
     uniforms.push_back("opacity");
-  if (has_aa_) {
+  if (aa_mode_ == USE_AA) {
     uniforms.push_back("viewport");
     uniforms.push_back("edge");
   }
   if (position_source_ == POSITION_SOURCE_ATTRIBUTE_INDEXED_UNIFORM)
     uniforms.push_back("quad");
 
   locations.resize(uniforms.size());
 
   GetProgramUniformLocations(context, program, uniforms.size(), uniforms.data(),
                              locations.data(), base_uniform_index);
@@ skipping 13 matching lines @@
   if (is_ya_uv_) {
     ya_tex_scale_location_ = locations[index++];
     ya_tex_offset_location_ = locations[index++];
     uv_tex_scale_location_ = locations[index++];
     uv_tex_offset_location_ = locations[index++];
   }
   if (has_matrix_)
     matrix_location_ = locations[index++];
   if (has_vertex_opacity_)
     vertex_opacity_location_ = locations[index++];
-  if (has_aa_) {
+  if (aa_mode_ == USE_AA) {
     viewport_location_ = locations[index++];
     edge_location_ = locations[index++];
   }
   if (position_source_ == POSITION_SOURCE_ATTRIBUTE_INDEXED_UNIFORM)
     quad_location_ = locations[index++];
 }
 
 void VertexShaderBase::FillLocations(ShaderLocations* locations) const {
   locations->quad = quad_location();
   locations->edge = edge_location();
@@ skipping 45 matching lines @@
       SRC("gl_Position = matrix[quad_index] * pos;");
     } else {
       HDR("uniform mat4 matrix;");
       SRC("gl_Position = matrix * pos;");
     }
   } else {
     SRC("gl_Position = pos;");
   }
 
   // Compute the anti-aliasing edge distances.
-  if (has_aa_) {
+  if (aa_mode_ == USE_AA) {
     HDR("uniform TexCoordPrecision vec3 edge[8];");
     HDR("uniform vec4 viewport;");
     HDR("varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.");
     SRC("// Compute anti-aliasing properties.\n");
     SRC("vec2 ndc_pos = 0.5 * (1.0 + gl_Position.xy / gl_Position.w);");
     SRC("vec3 screen_pos = vec3(viewport.xy + viewport.zw * ndc_pos, 1.0);");
     SRC("edge_dist[0] = vec4(dot(edge[0], screen_pos),");
     SRC("                    dot(edge[1], screen_pos),");
     SRC("                    dot(edge[2], screen_pos),");
     SRC("                    dot(edge[3], screen_pos)) * gl_Position.w;");
@@ skipping 76 matching lines @@
     HDR("varying TexCoordPrecision vec2 dummy_varying;");
     SRC("dummy_varying = dummy_uniform;");
   }
 
   source += "}\n";
   return header + source;
 }
 
 FragmentShaderBase::FragmentShaderBase() {}
 
-std::string FragmentShaderBase::GetShaderString(TexCoordPrecision precision,
-                                                SamplerType sampler) const {
+std::string FragmentShaderBase::GetShaderString() const {
+  TexCoordPrecision precision = tex_coord_precision_;
   // The AA shader values will use TexCoordPrecision.
-  if (has_aa_ && precision == TEX_COORD_PRECISION_NA)
+  if (aa_mode_ == USE_AA && precision == TEX_COORD_PRECISION_NA)
     precision = TEX_COORD_PRECISION_MEDIUM;
   return SetFragmentTexCoordPrecision(
       precision, SetFragmentSamplerType(
-                     sampler, SetBlendModeFunctions(GetShaderSource())));
+                     sampler_type_, SetBlendModeFunctions(GetShaderSource())));
 }
 
 void FragmentShaderBase::Init(GLES2Interface* context,
                               unsigned program,
                               int* base_uniform_index) {
   std::vector<const char*> uniforms;
   std::vector<int> locations;
   if (has_blend_mode()) {
     uniforms.push_back("s_backdropTexture");
     uniforms.push_back("s_originalBackdropTexture");
     uniforms.push_back("backdropRect");
   }
-  if (has_mask_sampler_) {
+  if (mask_mode_ != NO_MASK) {
     uniforms.push_back("s_mask");
     uniforms.push_back("maskTexCoordScale");
     uniforms.push_back("maskTexCoordOffset");
   }
   if (has_color_matrix_) {
     uniforms.push_back("colorMatrix");
     uniforms.push_back("colorOffset");
   }
   if (has_uniform_alpha_)
     uniforms.push_back("alpha");
@@ skipping 14 matching lines @@
 
   GetProgramUniformLocations(context, program, uniforms.size(), uniforms.data(),
                              locations.data(), base_uniform_index);
 
   size_t index = 0;
   if (has_blend_mode()) {
     backdrop_location_ = locations[index++];
     original_backdrop_location_ = locations[index++];
     backdrop_rect_location_ = locations[index++];
   }
-  if (has_mask_sampler_) {
+  if (mask_mode_ != NO_MASK) {
     mask_sampler_location_ = locations[index++];
     mask_tex_coord_scale_location_ = locations[index++];
     mask_tex_coord_offset_location_ = locations[index++];
   }
   if (has_color_matrix_) {
     color_matrix_location_ = locations[index++];
     color_offset_location_ = locations[index++];
   }
   if (has_uniform_alpha_)
     alpha_location_ = locations[index++];
@@ skipping 10 matching lines @@
       break;
   }
   DCHECK_EQ(index, locations.size());
 }
 
 void FragmentShaderBase::FillLocations(ShaderLocations* locations) const {
   if (has_blend_mode()) {
     locations->backdrop = backdrop_location_;
     locations->backdrop_rect = backdrop_rect_location_;
   }
-  if (mask_for_background())
+  if (mask_for_background_)
     locations->original_backdrop = original_backdrop_location_;
-  if (has_mask_sampler_) {
+  if (mask_mode_ != NO_MASK) {
     locations->mask_sampler = mask_sampler_location_;
     locations->mask_tex_coord_scale = mask_tex_coord_scale_location_;
     locations->mask_tex_coord_offset = mask_tex_coord_offset_location_;
   }
   if (has_color_matrix_) {
     locations->color_matrix = color_matrix_location_;
     locations->color_offset = color_offset_location_;
   }
   if (has_uniform_alpha_)
     locations->alpha = alpha_location_;
@@ skipping 15 matching lines @@
     return "#define ApplyBlendMode(X, Y) (X)\n" + shader_string;
   }
 
   static const std::string kUniforms = SHADER0([]() {
     uniform sampler2D s_backdropTexture;
     uniform sampler2D s_originalBackdropTexture;
     uniform TexCoordPrecision vec4 backdropRect;
   });
 
   std::string mixFunction;
-  if (mask_for_background()) {
+  if (mask_for_background_) {
     mixFunction = SHADER0([]() {
       vec4 MixBackdrop(TexCoordPrecision vec2 bgTexCoord, float mask) {
         vec4 backdrop = texture2D(s_backdropTexture, bgTexCoord);
         vec4 original_backdrop =
             texture2D(s_originalBackdropTexture, bgTexCoord);
         return mix(original_backdrop, backdrop, mask);
       }
     });
   } else {
     mixFunction = SHADER0([]() {
@@ skipping 307 matching lines @@
     HDR("uniform vec4 colorOffset;");
     SRC("// Apply color matrix");
     SRC("float nonZeroAlpha = max(texColor.a, 0.00001);");
     SRC("texColor = vec4(texColor.rgb / nonZeroAlpha, nonZeroAlpha);");
     SRC("texColor = colorMatrix * texColor + colorOffset;");
     SRC("texColor.rgb *= texColor.a;");
     SRC("texColor = clamp(texColor, 0.0, 1.0);");
   }
 
   // Read the mask texture.
-  if (has_mask_sampler_) {
+  if (mask_mode_ != NO_MASK) {
     HDR("uniform SamplerType s_mask;");
     HDR("uniform vec2 maskTexCoordScale;");
     HDR("uniform vec2 maskTexCoordOffset;");
     SRC("// Read the mask");
     SRC("TexCoordPrecision vec2 maskTexCoord =");
     SRC("    vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,");
     SRC("         maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);");
     SRC("vec4 maskColor = TextureLookup(s_mask, maskTexCoord);");
   }
 
   // Compute AA.
-  if (has_aa_) {
+  if (aa_mode_ == USE_AA) {
     HDR("varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.");
     SRC("// Compute AA");
     SRC("vec4 d4 = min(edge_dist[0], edge_dist[1]);");
     SRC("vec2 d2 = min(d4.xz, d4.yw);");
     SRC("float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);");
   }
 
   // Premultiply by alpha.
-  if (has_premultiply_alpha_) {
+  if (premultiply_alpha_mode_ == NON_PREMULTIPLIED_ALPHA) {
     SRC("// Premultiply alpha");
     SRC("texColor.rgb *= texColor.a;");
   }
 
   // Apply background texture.
   if (has_background_color_) {
     HDR("uniform vec4 background_color;");
     SRC("// Apply uniform background color blending");
     SRC("texColor += background_color * (1.0 - texColor.a);");
   }
 
   // Apply swizzle.
-  if (has_swizzle_) {
+  if (swizzle_mode_ == DO_SWIZZLE) {
     SRC("// Apply swizzle");
     SRC("texColor = texColor.bgra;\n");
   }
 
   // Include header text for alpha.
   if (has_uniform_alpha_) {
     HDR("uniform float alpha;");
   }
   if (has_varying_alpha_) {
     HDR("varying float v_alpha;");
   }
 
   // Apply uniform alpha, aa, varying alpha, and the mask.
-  if (has_varying_alpha_ || has_aa_ || has_uniform_alpha_ ||
-      has_mask_sampler_) {
+  if (has_varying_alpha_ || aa_mode_ == USE_AA || has_uniform_alpha_ ||
+      mask_mode_ != NO_MASK) {
     SRC("// Apply alpha from uniform, varying, aa, and mask.");
     std::string line = "  texColor = texColor";
     if (has_varying_alpha_)
       line += " * v_alpha";
     if (has_uniform_alpha_)
       line += " * alpha";
-    if (has_aa_)
+    if (aa_mode_ == USE_AA)
       line += " * aa";
-    if (has_mask_sampler_)
+    if (mask_mode_ != NO_MASK)
       line += " * maskColor.a";
     line += ";\n";
     source += line;
   }
 
   // Write the fragment color.
   SRC("// Write the fragment color");
   switch (frag_color_mode_) {
     case FRAG_COLOR_MODE_DEFAULT:
       DCHECK_EQ(blend_mode_, BLEND_MODE_NONE);
       SRC("gl_FragColor = texColor;");
       break;
     case FRAG_COLOR_MODE_OPAQUE:
       DCHECK_EQ(blend_mode_, BLEND_MODE_NONE);
       SRC("gl_FragColor = vec4(texColor.rgb, 1.0);");
       break;
     case FRAG_COLOR_MODE_APPLY_BLEND_MODE:
-      if (has_mask_sampler_)
+      if (mask_mode_ != NO_MASK)
         SRC("gl_FragColor = ApplyBlendMode(texColor, maskColor.w);");
       else
         SRC("gl_FragColor = ApplyBlendMode(texColor, 0.0);");
       break;
   }
   source += "}\n";
 
   return header + source;
 }
 
 FragmentShaderYUVVideo::FragmentShaderYUVVideo() {}
 
-void FragmentShaderYUVVideo::SetFeatures(bool use_alpha_texture,
-                                         bool use_nv12,
-                                         bool use_color_lut) {
-  use_alpha_texture_ = use_alpha_texture;
-  use_nv12_ = use_nv12;
-  use_color_lut_ = use_color_lut;
-}
-
 void FragmentShaderYUVVideo::Init(GLES2Interface* context,
                                   unsigned program,
                                   int* base_uniform_index) {
   static const char* uniforms[] = {
       "y_texture",
       "u_texture",
       "v_texture",
       "uv_texture",
       "a_texture",
       "lut_texture",
@@ skipping 120 matching lines @@
           max(uv_clamp_rect.xy, min(uv_clamp_rect.zw, v_uvTexCoord));
       vec3 yuv = vec3(y_raw, GetUV(uv_clamped));
       gl_FragColor = vec4(yuv2rgb(yuv), 1.0) * GetAlpha(ya_clamped);
     }
   });
 
   return head + functions;
 }
 
 }  // namespace cc