cc: Clamp texture coordinates in all tile shaders

cc/gl_renderer.cc

 // Copyright 2010 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/gl_renderer.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 680 matching lines @@
 
     GLC(context(), context()->uniform4f(program->fragmentShader().colorLocation(), (SkColorGetR(color) / 255.0) * alpha, (SkColorGetG(color) / 255.0) * alpha, (SkColorGetB(color) / 255.0) * alpha, alpha));
 
     drawQuadGeometry(frame, quad->quadTransform(), quad->rect, program->vertexShader().matrixLocation());
 }
 
 struct TileProgramUniforms {
     unsigned program;
     unsigned samplerLocation;
     unsigned vertexTexTransformLocation;
-    unsigned fragmentTexTransformLocation;
+    unsigned fragmentTexClampLocation;
     unsigned edgeLocation;
     unsigned matrixLocation;
     unsigned alphaLocation;
     unsigned pointLocation;
 };
 
 template<class T>
 static void tileUniformLocation(T program, TileProgramUniforms& uniforms)
 {
     uniforms.program = program->program();
     uniforms.vertexTexTransformLocation = program->vertexShader().vertexTexTransformLocation();
     uniforms.matrixLocation = program->vertexShader().matrixLocation();
     uniforms.pointLocation = program->vertexShader().pointLocation();
 
     uniforms.samplerLocation = program->fragmentShader().samplerLocation();
     uniforms.alphaLocation = program->fragmentShader().alphaLocation();
-    uniforms.fragmentTexTransformLocation = program->fragmentShader().fragmentTexTransformLocation();
+    uniforms.fragmentTexClampLocation = program->fragmentShader().fragmentTexClampLocation();
     uniforms.edgeLocation = program->fragmentShader().edgeLocation();
 }
 
 void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* quad)
 {
     gfx::Rect tileRect = quad->visible_rect;
+    gfx::RectF texCoordRect = quad->tex_coord_rect;
+    const gfx::Size& textureSize = quad->texture_size;
 
-    gfx::RectF texCoordRect = quad->tex_coord_rect;
     float texToGeomScaleX = quad->rect.width() / texCoordRect.width();
     float texToGeomScaleY = quad->rect.height() / texCoordRect.height();
 
     // texCoordRect corresponds to quadRect, but quadVisibleRect may be
     // smaller than quadRect due to occlusion or clipping. Adjust
     // texCoordRect to match.
     gfx::Vector2d topLeftDiff = tileRect.origin() - quad->rect.origin();
     gfx::Vector2d bottomRightDiff =
         tileRect.bottom_right() - quad->rect.bottom_right();
     texCoordRect.Inset(topLeftDiff.x() / texToGeomScaleX,
                        topLeftDiff.y() / texToGeomScaleY,
                        -bottomRightDiff.x() / texToGeomScaleX,
                        -bottomRightDiff.y() / texToGeomScaleY);
 
-    gfx::RectF clampGeomRect(tileRect);
-    gfx::RectF clampTexRect(texCoordRect);
-    // Clamp texture coordinates to avoid sampling outside the layer
-    // by deflating the tile region half a texel or half a texel
-    // minus epsilon for one pixel layers. The resulting clamp region
-    // is mapped to the unit square by the vertex shader and mapped
-    // back to normalized texture coordinates by the fragment shader
-    // after being clamped to 0-1 range.
-    const float epsilon = 1 / 1024.0f;
-    float texClampX = std::min(0.5f, 0.5f * clampTexRect.width() - epsilon);
-    float texClampY = std::min(0.5f, 0.5f * clampTexRect.height() - epsilon);
-    float geomClampX = std::min(texClampX * texToGeomScaleX,
-                                0.5f * clampGeomRect.width() - epsilon);
-    float geomClampY = std::min(texClampY * texToGeomScaleY,
-                                0.5f * clampGeomRect.height() - epsilon);
-    clampGeomRect.Inset(geomClampX, geomClampY, geomClampX, geomClampY);
-    clampTexRect.Inset(texClampX, texClampY, texClampX, texClampY);
+    // Map geometry to texture coordinates in the vertex shader.

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

I combined the vertex and fragment shader "transformations" into just a vertex
shader "transformation" that doesn't worry about clamping.

+    float vertexTexScaleX = texCoordRect.width() / textureSize.width();
+    float vertexTexScaleY = texCoordRect.height() / textureSize.height();
+    float vertexTexTranslateX = (texCoordRect.x() - (tileRect.x() / texToGeomScaleX)) / textureSize.width();
+    float vertexTexTranslateY = (texCoordRect.y() - (tileRect.y() / texToGeomScaleY)) / textureSize.height();
 
-    // Map clamping rectangle to unit square.
-    float vertexTexTranslateX = -clampGeomRect.x() / clampGeomRect.width();
-    float vertexTexTranslateY = -clampGeomRect.y() / clampGeomRect.height();
-    float vertexTexScaleX = tileRect.width() / clampGeomRect.width();
-    float vertexTexScaleY = tileRect.height() / clampGeomRect.height();
-
-    // Map to normalized texture coordinates.
-    const gfx::Size& textureSize = quad->texture_size;
-    float fragmentTexTranslateX = clampTexRect.x() / textureSize.width();
-    float fragmentTexTranslateY = clampTexRect.y() / textureSize.height();
-    float fragmentTexScaleX = clampTexRect.width() / textureSize.width();
-    float fragmentTexScaleY = clampTexRect.height() / textureSize.height();
-
+    // Manually clamp in the fragment shader.

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

This logic handles the clamping in the fragment shader.

+    float fragmentTexClampXMin = (texCoordRect.x()      + 0.5f) / textureSize.width();
+    float fragmentTexClampXMax = (texCoordRect.right()  - 0.5f) / textureSize.width();
+    float fragmentTexClampYMin = (texCoordRect.y()      + 0.5f) / textureSize.height();
+    float fragmentTexClampYMax = (texCoordRect.bottom() - 0.5f) / textureSize.height();
 
     gfx::QuadF localQuad;
     gfx::Transform deviceTransform = frame.windowMatrix * frame.projectionMatrix * quad->quadTransform();
     deviceTransform.FlattenTo2d();
     if (!deviceTransform.IsInvertible())
         return;
 
     bool clipped = false;
     gfx::QuadF deviceLayerQuad = MathUtil::mapQuad(deviceTransform, gfx::QuadF(quad->visibleContentRect()), clipped);
     DCHECK(!clipped);
@@ skipping 33 matching lines @@
 
         LayerQuad deviceLayerEdges = LayerQuad(deviceLayerQuad);
         deviceLayerEdges.inflateAntiAliasingDistance();
 
         float edge[24];
         deviceLayerEdges.toFloatArray(edge);
         deviceLayerBounds.toFloatArray(&edge[12]);
         GLC(context(), context()->uniform3fv(uniforms.edgeLocation, 8, edge));
 
         GLC(context(), context()->uniform4f(uniforms.vertexTexTransformLocation, vertexTexTranslateX, vertexTexTranslateY, vertexTexScaleX, vertexTexScaleY));
-        GLC(context(), context()->uniform4f(uniforms.fragmentTexTransformLocation, fragmentTexTranslateX, fragmentTexTranslateY, fragmentTexScaleX, fragmentTexScaleY));
+        GLC(context(), context()->uniform4f(uniforms.fragmentTexClampLocation, fragmentTexClampXMin, fragmentTexClampYMin, fragmentTexClampXMax, fragmentTexClampYMax));
 
         gfx::PointF bottomRight = tileRect.bottom_right();
         gfx::PointF bottomLeft = tileRect.bottom_left();
         gfx::PointF topLeft = tileRect.origin();
         gfx::PointF topRight = tileRect.top_right();
 
         // Map points to device space.
         bottomRight = MathUtil::mapPoint(deviceTransform, bottomRight, clipped);
         DCHECK(!clipped);
         bottomLeft = MathUtil::mapPoint(deviceTransform, bottomLeft, clipped);
@@ skipping 30 matching lines @@
         // Map device space quad to local space. deviceTransform has no 3d component since it was flattened, so we don't need to project.
         // We should have already checked that the transform was uninvertible above.
         gfx::Transform inverseDeviceTransform(gfx::Transform::kSkipInitialization);
         bool didInvert = deviceTransform.GetInverse(&inverseDeviceTransform);
         DCHECK(didInvert);
         localQuad = MathUtil::mapQuad(inverseDeviceTransform, deviceQuad.ToQuadF(), clipped);
 
         // We should not DCHECK(!clipped) here, because anti-aliasing inflation may cause deviceQuad to become
         // clipped. To our knowledge this scenario does not need to be handled differently than the unclipped case.
     } else {
-        // Move fragment shader transform to vertex shader. We can do this while
-        // still producing correct results as fragmentTexTransformLocation
-        // should always be non-negative when tiles are transformed in a way
-        // that could result in sampling outside the layer.
-        vertexTexScaleX *= fragmentTexScaleX;
-        vertexTexScaleY *= fragmentTexScaleY;
-        vertexTexTranslateX *= fragmentTexScaleX;
-        vertexTexTranslateY *= fragmentTexScaleY;
-        vertexTexTranslateX += fragmentTexTranslateX;
-        vertexTexTranslateY += fragmentTexTranslateY;
-
         GLC(context(), context()->uniform4f(uniforms.vertexTexTransformLocation, vertexTexTranslateX, vertexTexTranslateY, vertexTexScaleX, vertexTexScaleY));
-
+        GLC(context(), context()->uniform4f(uniforms.fragmentTexClampLocation, fragmentTexClampXMin, fragmentTexClampYMin, fragmentTexClampXMax, fragmentTexClampYMax));
         localQuad = gfx::RectF(tileRect);
     }
 
     // Normalize to tileRect.
     localQuad.Scale(1.0f / tileRect.width(), 1.0f / tileRect.height());
 
     setShaderOpacity(quad->opacity(), uniforms.alphaLocation);
     setShaderQuadF(localQuad, uniforms.pointLocation);
 
     // The tile quad shader behaves differently compared to all other shaders.
@@ skipping 900 matching lines @@
 
     releaseRenderPassTextures();
 }
 
 bool GLRenderer::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc