cc: Moving anti-aliasing decision to parent compositor.

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 265 matching lines @@
 
 void GLRenderer::doNoOp()
 {
     GLC(m_context, m_context->bindFramebuffer(GL_FRAMEBUFFER, 0));
     GLC(m_context, m_context->flush());
 }
 
 void GLRenderer::drawQuad(DrawingFrame& frame, const DrawQuad* quad)
 {
     DCHECK(quad->rect.Contains(quad->visible_rect));
-    if (quad->material != DrawQuad::TEXTURE_CONTENT) {
-        flushTextureQuadCache();

[reveman, 2013/02/26 01:49:28]

I think we should keep this flushTextureQuadCache() call here and only move the
setBlendEnabled() call into draw methods.

[ernstm, 2013/02/26 18:10:57]

Done.

-        setBlendEnabled(quad->ShouldDrawWithBlending());
-    }
 
     switch (quad->material) {
     case DrawQuad::INVALID:
         NOTREACHED();
         break;
     case DrawQuad::CHECKERBOARD:
         drawCheckerboardQuad(frame, CheckerboardDrawQuad::MaterialCast(quad));
         break;
     case DrawQuad::DEBUG_BORDER:
         drawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad));
@@ skipping 17 matching lines @@
         drawTileQuad(frame, TileDrawQuad::MaterialCast(quad));
         break;
     case DrawQuad::YUV_VIDEO_CONTENT:
         drawYUVVideoQuad(frame, YUVVideoDrawQuad::MaterialCast(quad));
         break;
     }
 }
 
 void GLRenderer::drawCheckerboardQuad(const DrawingFrame& frame, const CheckerboardDrawQuad* quad)
 {
+    flushTextureQuadCache();
+    setBlendEnabled(quad->ShouldDrawWithBlending());
+
     const TileCheckerboardProgram* program = tileCheckerboardProgram();
     DCHECK(program && (program->initialized() || isContextLost()));
     setUseProgram(program->program());
 
     SkColor color = quad->color;
     GLC(context(), context()->uniform4f(program->fragmentShader().colorLocation(), SkColorGetR(color) / 255.0, SkColorGetG(color) / 255.0, SkColorGetB(color) / 255.0, 1));
 
     const int checkerboardWidth = 16;
     float frequency = 1.0 / checkerboardWidth;
 
     gfx::Rect tileRect = quad->rect;
     float texOffsetX = tileRect.x() % checkerboardWidth;
     float texOffsetY = tileRect.y() % checkerboardWidth;
     float texScaleX = tileRect.width();
     float texScaleY = tileRect.height();
     GLC(context(), context()->uniform4f(program->fragmentShader().texTransformLocation(), texOffsetX, texOffsetY, texScaleX, texScaleY));
 
     GLC(context(), context()->uniform1f(program->fragmentShader().frequencyLocation(), frequency));
 
     setShaderOpacity(quad->opacity(), program->fragmentShader().alphaLocation());
     drawQuadGeometry(frame, quad->quadTransform(), quad->rect, program->vertexShader().matrixLocation());
 }
 
 void GLRenderer::drawDebugBorderQuad(const DrawingFrame& frame, const DebugBorderDrawQuad* quad)
 {
+    flushTextureQuadCache();
+    setBlendEnabled(quad->ShouldDrawWithBlending());
+
     static float glMatrix[16];
     const SolidColorProgram* program = solidColorProgram();
     DCHECK(program && (program->initialized() || isContextLost()));
     setUseProgram(program->program());
 
     // Use the full quadRect for debug quads to not move the edges based on partial swaps.
     const gfx::Rect& layerRect = quad->rect;
     gfx::Transform renderMatrix = quad->quadTransform();
     renderMatrix.Translate(0.5 * layerRect.width() + layerRect.x(), 0.5 * layerRect.height() + layerRect.y());
     renderMatrix.Scale(layerRect.width(), layerRect.height());
@@ skipping 183 matching lines @@
 
     useRenderPass(frame, targetRenderPass);
 
     if (!usingBackgroundTexture)
         return scoped_ptr<ScopedResource>();
     return backgroundTexture.Pass();
 }
 
 void GLRenderer::drawRenderPassQuad(DrawingFrame& frame, const RenderPassDrawQuad* quad)
 {
+    flushTextureQuadCache();
+    setBlendEnabled(quad->ShouldDrawWithBlending());
+
     CachedResource* contentsTexture = m_renderPassTextures.get(quad->render_pass_id);
     if (!contentsTexture || !contentsTexture->id())
         return;
 
     gfx::Transform quadRectMatrix;
     quadRectTransform(&quadRectMatrix, quad->quadTransform(), quad->rect);
     gfx::Transform contentsDeviceTransform = frame.windowMatrix * frame.projectionMatrix * quadRectMatrix;
     contentsDeviceTransform.FlattenTo2d();
 
     // Can only draw surface if device matrix is invertible.
@@ skipping 149 matching lines @@
     drawQuadGeometry(frame, quad->quadTransform(), quad->rect, shaderMatrixLocation);
 
     // Flush the compositor context before the filter bitmap goes out of
     // scope, so the draw gets processed before the filter texture gets deleted.
     if (filterBitmap.getTexture())
         m_context->flush();
 }
 
 void GLRenderer::drawSolidColorQuad(const DrawingFrame& frame, const SolidColorDrawQuad* quad)
 {
+    flushTextureQuadCache();
+    setBlendEnabled(quad->ShouldDrawWithBlending());
+
     const SolidColorProgram* program = solidColorProgram();
     setUseProgram(program->program());
 
     SkColor color = quad->color;
     float opacity = quad->opacity();
     float alpha = (SkColorGetA(color) / 255.0) * opacity;
 
     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());
@@ skipping 19 matching lines @@
     uniforms.pointLocation = program->vertexShader().pointLocation();
 
     uniforms.samplerLocation = program->fragmentShader().samplerLocation();
     uniforms.alphaLocation = program->fragmentShader().alphaLocation();
     uniforms.fragmentTexTransformLocation = program->fragmentShader().fragmentTexTransformLocation();
     uniforms.edgeLocation = program->fragmentShader().edgeLocation();
 }
 
 void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* quad)
 {
+    flushTextureQuadCache();
+
     gfx::Rect tileRect = quad->visible_rect;
 
     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();
@@ skipping 28 matching lines @@
     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();
 
-
     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);
 
+    // TODO(reveman): Axis-aligned is not enough to avoid anti-aliasing.
+    // Bounding rectangle for quad also needs to be expressible as
+    // an integer rectangle. crbug.com/169374
+    bool isAxisAlignedInTarget = deviceLayerQuad.IsRectilinear();
+    bool useAA = !clipped && !isAxisAlignedInTarget && quad->IsEdge();
+
     TileProgramUniforms uniforms;
-    // For now, we simply skip anti-aliasing with the quad is clipped. This only happens
-    // on perspective transformed layers that go partially behind the camera.
-    if (quad->IsAntialiased() && !clipped) {
+    if (useAA) {
         if (quad->swizzle_contents)
             tileUniformLocation(tileProgramSwizzleAA(), uniforms);
         else
             tileUniformLocation(tileProgramAA(), uniforms);
     } else {
         if (quad->ShouldDrawWithBlending()) {
             if (quad->swizzle_contents)
                 tileUniformLocation(tileProgramSwizzle(), uniforms);
             else
                 tileUniformLocation(tileProgram(), uniforms);
         } else {
             if (quad->swizzle_contents)
                 tileUniformLocation(tileProgramSwizzleOpaque(), uniforms);
             else
                 tileUniformLocation(tileProgramOpaque(), uniforms);
         }
     }
-
+    

[reveman, 2013/02/26 01:49:28]

nit: remove this whitespace change.

[ernstm, 2013/02/26 18:10:57]

Done.

[ernstm, 2013/02/26 18:10:57]

Done.

     setUseProgram(uniforms.program);
     GLC(context(), context()->uniform1i(uniforms.samplerLocation, 0));
     bool scaled = (texToGeomScaleX != 1 || texToGeomScaleY != 1);
-    GLenum filter = (quad->IsAntialiased() || scaled || !quad->quadTransform().IsIdentityOrIntegerTranslation()) ? GL_LINEAR : GL_NEAREST;
+    GLenum filter = (useAA || scaled || !quad->quadTransform().IsIdentityOrIntegerTranslation()) ? GL_LINEAR : GL_NEAREST;
     ResourceProvider::ScopedSamplerGL quadResourceLock(m_resourceProvider, quad->resource_id, GL_TEXTURE_2D, filter);
 
-    bool useAA = !clipped && quad->IsAntialiased();
     if (useAA) {
+        // always enable blending when using antialiasing
+        setBlendEnabled(true);

[reveman, 2013/02/26 01:49:28]

is the setBlendEnabled(quad->ShouldDrawWithBlending() || useAA) line below not
enough?

[ernstm, 2013/02/26 18:10:57]

The line below is enough. This one is a leftover from an earlier version.
On 2013/02/26 01:49:28, David Reveman wrote:

+
         LayerQuad deviceLayerBounds = LayerQuad(gfx::QuadF(deviceLayerQuad.BoundingBox()));
         deviceLayerBounds.inflateAntiAliasingDistance();
 
         LayerQuad deviceLayerEdges = LayerQuad(deviceLayerQuad);
         deviceLayerEdges.inflateAntiAliasingDistance();
 
         float edge[24];
         deviceLayerEdges.toFloatArray(edge);
         deviceLayerBounds.toFloatArray(&edge[12]);
         GLC(context(), context()->uniform3fv(uniforms.edgeLocation, 8, edge));
@@ skipping 15 matching lines @@
         DCHECK(!clipped);
         topRight = MathUtil::mapPoint(deviceTransform, topRight, clipped);
         DCHECK(!clipped);
 
         LayerQuad::Edge bottomEdge(bottomRight, bottomLeft);
         LayerQuad::Edge leftEdge(bottomLeft, topLeft);
         LayerQuad::Edge topEdge(topLeft, topRight);
         LayerQuad::Edge rightEdge(topRight, bottomRight);
 
         // Only apply anti-aliasing to edges not clipped by culling or scissoring.
-        if (quad->top_edge_aa && tileRect.y() == quad->rect.y())
+        if (quad->IsTopEdge() && tileRect.y() == quad->rect.y())
             topEdge = deviceLayerEdges.top();
-        if (quad->left_edge_aa && tileRect.x() == quad->rect.x())
+        if (quad->IsLeftEdge() && tileRect.x() == quad->rect.x())
             leftEdge = deviceLayerEdges.left();
-        if (quad->right_edge_aa && tileRect.right() == quad->rect.right())
+        if (quad->IsRightEdge() && tileRect.right() == quad->rect.right())
             rightEdge = deviceLayerEdges.right();
-        if (quad->bottom_edge_aa && tileRect.bottom() == quad->rect.bottom())
+        if (quad->IsBottomEdge() && tileRect.bottom() == quad->rect.bottom())
             bottomEdge = deviceLayerEdges.bottom();
 
         float sign = gfx::QuadF(tileRect).IsCounterClockwise() ? -1 : 1;
         bottomEdge.scale(sign);
         leftEdge.scale(sign);
         topEdge.scale(sign);
         rightEdge.scale(sign);
 
         // Create device space quad.
         LayerQuad deviceQuad(leftEdge, topEdge, rightEdge, bottomEdge);
@@ skipping 17 matching lines @@
         vertexTexTranslateX *= fragmentTexScaleX;
         vertexTexTranslateY *= fragmentTexScaleY;
         vertexTexTranslateX += fragmentTexTranslateX;
         vertexTexTranslateY += fragmentTexTranslateY;
 
         GLC(context(), context()->uniform4f(uniforms.vertexTexTransformLocation, vertexTexTranslateX, vertexTexTranslateY, vertexTexScaleX, vertexTexScaleY));
 
         localQuad = gfx::RectF(tileRect);
     }
 
+    // Enable blending when the quad properties require it or if we decided 

[reveman, 2013/02/26 01:49:28]

nit: remove whitespace at end of line.

[ernstm, 2013/02/26 18:10:57]

Done.

+    // to use antialiasing.
+    setBlendEnabled(quad->ShouldDrawWithBlending() || useAA);
+
     // 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.
     // The transform and vertex data are used to figure out the extents that the
     // un-antialiased quad should have and which vertex this is and the float
     // quad passed in via uniform is the actual geometry that gets used to draw
     // it. This is why this centered rect is used and not the original quadRect.
     gfx::RectF centeredRect(gfx::PointF(-0.5 * tileRect.width(), -0.5 * tileRect.height()), tileRect.size());
     drawQuadGeometry(frame, quad->quadTransform(), centeredRect, uniforms.matrixLocation);
 }
 
 void GLRenderer::drawYUVVideoQuad(const DrawingFrame& frame, const YUVVideoDrawQuad* quad)
 {
+    flushTextureQuadCache();
+    setBlendEnabled(quad->ShouldDrawWithBlending()); 

[reveman, 2013/02/26 01:49:28]

nit: remove whitespace at end of line.

[ernstm, 2013/02/26 18:10:57]

Done.

+
     const VideoYUVProgram* program = videoYUVProgram();
     DCHECK(program && (program->initialized() || isContextLost()));
 
     const VideoLayerImpl::FramePlane& yPlane = quad->y_plane;
     const VideoLayerImpl::FramePlane& uPlane = quad->u_plane;
     const VideoLayerImpl::FramePlane& vPlane = quad->v_plane;
 
     GLC(context(), context()->activeTexture(GL_TEXTURE1));
     ResourceProvider::ScopedSamplerGL yPlaneLock(m_resourceProvider, yPlane.resourceId, GL_TEXTURE_2D, GL_LINEAR);
     GLC(context(), context()->activeTexture(GL_TEXTURE2));
@@ skipping 32 matching lines @@
 
     setShaderOpacity(quad->opacity(), program->fragmentShader().alphaLocation());
     drawQuadGeometry(frame, quad->quadTransform(), quad->rect, program->vertexShader().matrixLocation());
 
     // Reset active texture back to texture 0.
     GLC(context(), context()->activeTexture(GL_TEXTURE0));
 }
 
 void GLRenderer::drawStreamVideoQuad(const DrawingFrame& frame, const StreamVideoDrawQuad* quad)
 {
+    flushTextureQuadCache();
+    setBlendEnabled(quad->ShouldDrawWithBlending());
+
     static float glMatrix[16];
 
     DCHECK(m_capabilities.usingEglImage);
 
     const VideoStreamTextureProgram* program = videoStreamTextureProgram();
     setUseProgram(program->program());
 
     toGLMatrix(&glMatrix[0], quad->matrix);
     GLC(context(), context()->uniformMatrix4fv(program->vertexShader().texMatrixLocation(), 1, false, glMatrix));
 
@@ skipping 168 matching lines @@
     }
 
     drawQuadGeometry(frame, quad->quadTransform(), quad->rect, binding.matrixLocation);
 
     if (!quad->premultiplied_alpha)
         GLC(m_context, m_context->blendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
 }
 
 void GLRenderer::drawIOSurfaceQuad(const DrawingFrame& frame, const IOSurfaceDrawQuad* quad)
 {
+    flushTextureQuadCache();
+    setBlendEnabled(quad->ShouldDrawWithBlending());
+
     TexTransformTextureProgramBinding binding;
     binding.set(textureIOSurfaceProgram(), context());
 
     setUseProgram(binding.programId);
     GLC(context(), context()->uniform1i(binding.samplerLocation, 0));
     if (quad->orientation == IOSurfaceDrawQuad::FLIPPED)
         GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, quad->io_surface_size.height(), quad->io_surface_size.width(), quad->io_surface_size.height() * -1.0));
     else
         GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, 0, quad->io_surface_size.width(), quad->io_surface_size.height()));
 
@@ skipping 649 matching lines @@
 
     releaseRenderPassTextures();
 }
 
 bool GLRenderer::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc