cc: Clamp texture coordinates in all tile shaders

cc/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/shader.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebGraphicsContext3D.h"
 
@@ skipping 345 matching lines @@
         "s_texture",
     };
     int locations[1];
 
     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 
     m_samplerLocation = locations[0];
     DCHECK(m_samplerLocation != -1);
 }
 
+FragmentTexClampOpaqueBinding::FragmentTexClampOpaqueBinding()
+    : m_samplerLocation(-1)
+{
+}
+
+void FragmentTexClampOpaqueBinding::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
+{
+    static const char* shaderUniforms[] = {
+        "s_texture",
+        "fragmentTexClamp",
+    };
+    int locations[2];
+
+    getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
+
+    m_samplerLocation = locations[0];
+    m_fragmentTexClampLocation = locations[2];
+    DCHECK(m_samplerLocation != -1);
+}
+
 std::string FragmentShaderRGBATexFlipVaryingAlpha::getShaderString() const
 {
     return SHADER(
         precision mediump float;
         varying vec2 v_texCoord;
         varying float v_alpha;
         uniform sampler2D s_texture;
         void main()
         {
             vec4 texColor = texture2D(s_texture, vec2(v_texCoord.x, 1.0 - v_texCoord.y));
@@ skipping 37 matching lines @@
         uniform sampler2D s_texture;
         uniform float alpha;
         void main()
         {
             vec4 texColor = texture2D(s_texture, v_texCoord);
             gl_FragColor = texColor * alpha;
         }
     );
 }
 
+std::string FragmentShaderRGBATexAlpha::getShaderString() const
+{
+    return SHADER(
+        precision mediump float;
+        varying vec2 v_texCoord;
+        uniform sampler2D s_texture;
+        uniform float alpha;
+        uniform vec4 fragmentTexClamp;
+        void main()
+        {
+            vec2 texCoord = clamp(v_texCoord, fragmentTexClamp.xy, fragmentTexClamp.zw);
+            vec4 texColor = texture2D(s_texture, texCoord);
+            gl_FragColor = texColor * alpha;
+        }
+    );
+}
+
+
 std::string FragmentShaderRGBATexVaryingAlpha::getShaderString() const
 {
     return SHADER(
         precision mediump float;
         varying vec2 v_texCoord;
         varying float v_alpha;
         uniform sampler2D s_texture;
         void main()
         {
             vec4 texColor = texture2D(s_texture, v_texCoord);
@@ skipping 26 matching lines @@
             "varying vec2 v_texCoord;\n"
             "varying float v_alpha;\n"
             "uniform sampler2DRect s_texture;\n"
             "void main()\n"
             "{\n"
             "    vec4 texColor = texture2DRect(s_texture, v_texCoord);\n"
             "    gl_FragColor = texColor * v_alpha;\n"
             "}\n";
 }
 
-std::string FragmentShaderRGBATexOpaque::getShaderString() const
+std::string FragmentShaderRGBATexClampOpaque::getShaderString() const
 {
     return SHADER(
         precision mediump float;
         varying vec2 v_texCoord;
         uniform sampler2D s_texture;
+        uniform vec4 fragmentTexClamp;
         void main()
         {
-            vec4 texColor = texture2D(s_texture, v_texCoord);
+            vec2 texCoord = clamp(v_texCoord, fragmentTexClamp.xy, fragmentTexClamp.zw);
+            vec4 texColor = texture2D(s_texture, texCoord);
             gl_FragColor = vec4(texColor.rgb, 1.0);
         }
     );
 }
 
 std::string FragmentShaderRGBATex::getShaderString() const
 {
     return SHADER(
         precision mediump float;
         varying vec2 v_texCoord;
         uniform sampler2D s_texture;
         void main()
         {
             gl_FragColor = texture2D(s_texture, v_texCoord);
         }
     );
 }
 
-std::string FragmentShaderRGBATexSwizzleAlpha::getShaderString() const
+std::string FragmentShaderRGBATexClampSwizzleAlpha::getShaderString() const
 {
     return SHADER(
         precision mediump float;
         varying vec2 v_texCoord;
         uniform sampler2D s_texture;
         uniform float alpha;
         void main()
         {
             vec4 texColor = texture2D(s_texture, v_texCoord);
             gl_FragColor = vec4(texColor.z, texColor.y, texColor.x, texColor.w) * alpha;
         }
     );
 }
 
-std::string FragmentShaderRGBATexSwizzleOpaque::getShaderString() const
+std::string FragmentShaderRGBATexClampSwizzleOpaque::getShaderString() const
 {
     return SHADER(
         precision mediump float;
         varying vec2 v_texCoord;
         uniform sampler2D s_texture;
+        uniform vec4 fragmentTexClamp;
         void main()
         {
-            vec4 texColor = texture2D(s_texture, v_texCoord);
+            vec2 texCoord = clamp(v_texCoord, fragmentTexClamp.xy, fragmentTexClamp.zw);
+            vec4 texColor = texture2D(s_texture, texCoord);
             gl_FragColor = vec4(texColor.z, texColor.y, texColor.x, 1.0);
         }
     );
 }
 
 FragmentShaderRGBATexAlphaAA::FragmentShaderRGBATexAlphaAA()
     : m_samplerLocation(-1)
     , m_alphaLocation(-1)
     , m_edgeLocation(-1)
 {
@@ skipping 37 matching lines @@
             float a6 = clamp(dot(edge[6], pos), 0.0, 1.0);
             float a7 = clamp(dot(edge[7], pos), 0.0, 1.0);
             gl_FragColor = texColor * alpha * min(min(a0, a2) * min(a1, a3), min(a4, a6) * min(a5, a7));
         }
     );
 }
 
 FragmentTexClampAlphaAABinding::FragmentTexClampAlphaAABinding()
     : m_samplerLocation(-1)
     , m_alphaLocation(-1)
-    , m_fragmentTexTransformLocation(-1)
+    , m_fragmentTexClampLocation(-1)
     , m_edgeLocation(-1)
 {
 }
 
 void FragmentTexClampAlphaAABinding::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
 {
     static const char* shaderUniforms[] = {
         "s_texture",
         "alpha",
-        "fragmentTexTransform",
+        "fragmentTexClamp",
         "edge",
     };
     int locations[4];
 
     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 
     m_samplerLocation = locations[0];
     m_alphaLocation = locations[1];
-    m_fragmentTexTransformLocation = locations[2];
+    m_fragmentTexClampLocation = locations[2];
     m_edgeLocation = locations[3];
-    DCHECK(m_samplerLocation != -1 && m_alphaLocation != -1 && m_fragmentTexTransformLocation != -1 && m_edgeLocation != -1);
+    DCHECK(m_samplerLocation != -1 && m_alphaLocation != -1 && m_fragmentTexClampLocation != -1 && m_edgeLocation != -1);
 }
 
 std::string FragmentShaderRGBATexClampAlphaAA::getShaderString() const
 {
     return SHADER(
         precision mediump float;
         varying vec2 v_texCoord;
         uniform sampler2D s_texture;
         uniform float alpha;
-        uniform vec4 fragmentTexTransform;
+        uniform vec4 fragmentTexClamp;
         uniform vec3 edge[8];
         void main()
         {
-            vec2 texCoord = clamp(v_texCoord, 0.0, 1.0) * fragmentTexTransform.zw + fragmentTexTransform.xy;
+            vec2 texCoord = clamp(v_texCoord, fragmentTexClamp.xy, fragmentTexClamp.zw);

[brianderson, 2013/01/29 03:03:48]

Will this be more efficient?

[reveman, 2013/01/29 03:40:23]

I'm worried it might be significantly less efficient. Afaik, clamp(v_texCoord,
0.0, 1.0) is basically free on all hardware (same as using _SAT modifier in ARB
assembly languages) while other parameters to clamp() might require branching.

[brianderson, 2013/01/29 18:45:12]

The _SAT modifier is pretty cool.

Clamp would be very simple to implement in silicon, so I'd hope hardware
supports it natively, preventing the shader compiler from having to inserting a
branch. If not, a branch would be really bad though...

I guess what is best will be highly dependent on what hardware+drivers we're
running on.

If we stick with the _SAT+MAD, for example, I worry about other shaders that
will have to do the MAD followed by another multiply (such as alpha). Some gpu's
have a pipeline with multiple execution stages where each stage can only execute
a subset of instructions. If a shader needs to use the same stage more than
once, it'll have to cycle through the whole pipeline an additional time.

In any case, figuring out what's best would require a lot of looking at assembly
for different GPU's and then knowing how that assembly runs on the hardware.

My current plan is to revert to _SAT+MAD because it's safer.

We should engage with gpu vendors though - maybe even ask them to evaluate our
shaders for us and submit patches.

             vec4 texColor = texture2D(s_texture, texCoord);
             vec3 pos = vec3(gl_FragCoord.xy, 1);
             float a0 = clamp(dot(edge[0], pos), 0.0, 1.0);
             float a1 = clamp(dot(edge[1], pos), 0.0, 1.0);
             float a2 = clamp(dot(edge[2], pos), 0.0, 1.0);
             float a3 = clamp(dot(edge[3], pos), 0.0, 1.0);
             float a4 = clamp(dot(edge[4], pos), 0.0, 1.0);
             float a5 = clamp(dot(edge[5], pos), 0.0, 1.0);
             float a6 = clamp(dot(edge[6], pos), 0.0, 1.0);
             float a7 = clamp(dot(edge[7], pos), 0.0, 1.0);
             gl_FragColor = texColor * alpha * min(min(a0, a2) * min(a1, a3), min(a4, a6) * min(a5, a7));
         }
     );
 }
 
 std::string FragmentShaderRGBATexClampSwizzleAlphaAA::getShaderString() const
 {
     return SHADER(
         precision mediump float;
         varying vec2 v_texCoord;
         uniform sampler2D s_texture;
         uniform float alpha;
-        uniform vec4 fragmentTexTransform;
+        uniform vec4 fragmentTexClamp;
         uniform vec3 edge[8];
         void main()
         {
-            vec2 texCoord = clamp(v_texCoord, 0.0, 1.0) * fragmentTexTransform.zw + fragmentTexTransform.xy;
+            vec2 texCoord = clamp(v_texCoord, fragmentTexClamp.xy, fragmentTexClamp.zw);
             vec4 texColor = texture2D(s_texture, texCoord);
             vec3 pos = vec3(gl_FragCoord.xy, 1);
             float a0 = clamp(dot(edge[0], pos), 0.0, 1.0);
             float a1 = clamp(dot(edge[1], pos), 0.0, 1.0);
             float a2 = clamp(dot(edge[2], pos), 0.0, 1.0);
             float a3 = clamp(dot(edge[3], pos), 0.0, 1.0);
             float a4 = clamp(dot(edge[4], pos), 0.0, 1.0);
             float a5 = clamp(dot(edge[5], pos), 0.0, 1.0);
             float a6 = clamp(dot(edge[6], pos), 0.0, 1.0);
             float a7 = clamp(dot(edge[7], pos), 0.0, 1.0);
@@ skipping 246 matching lines @@
             vec4 color2 = color;
             vec2 texCoord = clamp(v_texCoord, 0.0, 1.0) * texTransform.zw + texTransform.xy;
             vec2 coord = mod(floor(texCoord * frequency * 2.0), 2.0);
             float picker = abs(coord.x - coord.y);
             gl_FragColor = mix(color1, color2, picker) * alpha;
         }
     );
 }
 
 }  // namespace cc