cc: Support texture rect targets for masks

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 <algorithm>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 1104 matching lines @@
 }
 
 std::string FragmentShaderRGBATexAlphaMask::GetShaderString(
     TexCoordPrecision precision,
     SamplerType sampler) const {
   // clang-format off
   return FRAGMENT_SHADER(
       // clang-format on
       precision mediump float;
       varying TexCoordPrecision vec2 v_texCoord;
-      uniform SamplerType s_texture;
+      uniform sampler2D s_texture;

[reveman, 2014/10/22 12:40:38]

Is the mask shader always used with a render surface as s_texture input and
that's why this can be hard coded to sampler2D?

[enne (OOO), 2014/10/22 19:20:44]

Yeah, that's exactly it.  Currently, masks only apply to render surfaces and so
they're always sampler2D.

I could generalize this, but I don't really see this changing any time soon.

Is your worry that this assumption about sampler2D isn't correct? Or, is it that
it isn't made clear enough?

[reveman, 2014/10/22 20:36:47]

I just wanted to make sure I understood this change correctly. Pretty sure I'm
the one to blame for the incorrect SamplerType/TextureLookup usage here. Thanks
for fixing it!

It would be nice to explicitly pass sampler and precision parameters to the
FRAGMENT_SHADER macro instead of assuming variables named |precision| and
|sampler| exists. That would allow us to change the name of the "sampler"
parameter above to "mask_sampler" and I think that would be enough to remove any
confusion here. That could be done as a follow up though. Maybe just add a TODO
here for now.

       uniform SamplerType s_mask;
       uniform TexCoordPrecision vec2 maskTexCoordScale;
       uniform TexCoordPrecision vec2 maskTexCoordOffset;
       uniform float alpha;
       void main() {
-        vec4 texColor = TextureLookup(s_texture, v_texCoord);
+        vec4 texColor = texture2D(s_texture, v_texCoord);
         TexCoordPrecision vec2 maskTexCoord =
             vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,
                  maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
         vec4 maskColor = TextureLookup(s_mask, maskTexCoord);
         gl_FragColor = texColor * alpha * maskColor.w;
       }
       // clang-format off
   );  // NOLINT(whitespace/parens)
   // clang-format on
 }
@@ skipping 27 matching lines @@
   mask_tex_coord_offset_location_ = locations[4];
 }
 
 std::string FragmentShaderRGBATexAlphaMaskAA::GetShaderString(
     TexCoordPrecision precision,
     SamplerType sampler) const {
   // clang-format off
   return FRAGMENT_SHADER(
       // clang-format on
       precision mediump float;
-      uniform SamplerType s_texture;
+      uniform sampler2D s_texture;
       uniform SamplerType s_mask;
       uniform TexCoordPrecision vec2 maskTexCoordScale;
       uniform TexCoordPrecision vec2 maskTexCoordOffset;
       uniform float alpha;
       varying TexCoordPrecision vec2 v_texCoord;
       varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
 
       void main() {
-        vec4 texColor = TextureLookup(s_texture, v_texCoord);
+        vec4 texColor = texture2D(s_texture, v_texCoord);
         TexCoordPrecision vec2 maskTexCoord =
             vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,
                  maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
         vec4 maskColor = TextureLookup(s_mask, maskTexCoord);
         vec4 d4 = min(edge_dist[0], edge_dist[1]);
         vec2 d2 = min(d4.xz, d4.yw);
         float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
         gl_FragColor = texColor * alpha * maskColor.w * aa;
       }
       // clang-format off
@@ skipping 41 matching lines @@
   color_offset_location_ = locations[6];
 }
 
 std::string FragmentShaderRGBATexAlphaMaskColorMatrixAA::GetShaderString(
     TexCoordPrecision precision,
     SamplerType sampler) const {
   // clang-format off
   return FRAGMENT_SHADER(
       // clang-format on
       precision mediump float;
-      uniform SamplerType s_texture;
+      uniform sampler2D s_texture;
       uniform SamplerType s_mask;
       uniform vec2 maskTexCoordScale;
       uniform vec2 maskTexCoordOffset;
       uniform mat4 colorMatrix;
       uniform vec4 colorOffset;
       uniform float alpha;
       varying TexCoordPrecision vec2 v_texCoord;
       varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
 
       void main() {
-        vec4 texColor = TextureLookup(s_texture, v_texCoord);
+        vec4 texColor = texture2D(s_texture, v_texCoord);
         float nonZeroAlpha = max(texColor.a, 0.00001);
         texColor = vec4(texColor.rgb / nonZeroAlpha, nonZeroAlpha);
         texColor = colorMatrix * texColor + colorOffset;
         texColor.rgb *= texColor.a;
         texColor = clamp(texColor, 0.0, 1.0);
         TexCoordPrecision vec2 maskTexCoord =
             vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,
                  maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
         vec4 maskColor = TextureLookup(s_mask, maskTexCoord);
         vec4 d4 = min(edge_dist[0], edge_dist[1]);
@@ skipping 103 matching lines @@
 }
 
 std::string FragmentShaderRGBATexAlphaMaskColorMatrix::GetShaderString(
     TexCoordPrecision precision,
     SamplerType sampler) const {
   // clang-format off
   return FRAGMENT_SHADER(
       // clang-format on
       precision mediump float;
       varying TexCoordPrecision vec2 v_texCoord;
-      uniform SamplerType s_texture;
+      uniform sampler2D s_texture;
       uniform SamplerType s_mask;
       uniform vec2 maskTexCoordScale;
       uniform vec2 maskTexCoordOffset;
       uniform mat4 colorMatrix;
       uniform vec4 colorOffset;
       uniform float alpha;
       void main() {
-        vec4 texColor = TextureLookup(s_texture, v_texCoord);
+        vec4 texColor = texture2D(s_texture, v_texCoord);
         float nonZeroAlpha = max(texColor.a, 0.00001);
         texColor = vec4(texColor.rgb / nonZeroAlpha, nonZeroAlpha);
         texColor = colorMatrix * texColor + colorOffset;
         texColor.rgb *= texColor.a;
         texColor = clamp(texColor, 0.0, 1.0);
         TexCoordPrecision vec2 maskTexCoord =
             vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,
                  maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
         vec4 maskColor = TextureLookup(s_mask, maskTexCoord);
         gl_FragColor = texColor * alpha * maskColor.w;
@@ skipping 252 matching lines @@
         vec2 coord = mod(floor(texCoord * frequency * 2.0), 2.0);
         float picker = abs(coord.x - coord.y);  // NOLINT
         gl_FragColor = mix(color1, color2, picker) * alpha;
       }
       // clang-format off
   );  // NOLINT(whitespace/parens)
   // clang-format on
 }
 
 }  // namespace cc