Don't invert contentsDeviceTransform twice when rendering render passes.

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 "config.h"
 
 #include "cc/gl_renderer.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 385 matching lines @@
     platformTextureDescription.fWidth = sourceTexture->size().width();
     platformTextureDescription.fHeight = sourceTexture->size().height();
     platformTextureDescription.fConfig = kSkia8888_GrPixelConfig;
     platformTextureDescription.fTextureHandle = lock.textureId();
     SkAutoTUnref<GrTexture> texture(grContext->createPlatformTexture(platformTextureDescription));
 
     // Place the platform texture inside an SkBitmap.
     SkBitmap source;
     source.setConfig(SkBitmap::kARGB_8888_Config, sourceTexture->size().width(), sourceTexture->size().height());
     source.setPixelRef(new SkGrPixelRef(texture.get()))->unref();
-    
+
     // Create a scratch texture for backing store.
     GrTextureDesc desc;
     desc.fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit;
     desc.fSampleCnt = 0;
     desc.fWidth = source.width();
     desc.fHeight = source.height();
     desc.fConfig = kSkia8888_GrPixelConfig;
     GrAutoScratchTexture scratchTexture(grContext, desc, GrContext::kExact_ScratchTexMatch);
     SkAutoTUnref<GrTexture> backingStore(scratchTexture.detach());
 
     // Create a device and canvas using that backing store.
     SkGpuDevice device(grContext, backingStore.get());
     SkCanvas canvas(&device);
 
     // Draw the source bitmap through the filter to the canvas.
     SkPaint paint;
     paint.setImageFilter(filter);
     canvas.clear(0x0);
     canvas.drawSprite(source, 0, 0, &paint);
     canvas.flush();
     context3d->flush();
     return device.accessBitmap(false);
 }
 
-scoped_ptr<ScopedTexture> GLRenderer::drawBackgroundFilters(DrawingFrame& frame, const RenderPassDrawQuad* quad, const WebKit::WebFilterOperations& filters, const WebTransformationMatrix& contentsDeviceTransform)
+scoped_ptr<ScopedTexture> GLRenderer::drawBackgroundFilters(
+    DrawingFrame& frame, const RenderPassDrawQuad* quad,
+    const WebKit::WebFilterOperations& filters,
+    const WebTransformationMatrix& deviceMatrix,
+    const WebTransformationMatrix& deviceMatrixInv)
 {
     // This method draws a background filter, which applies a filter to any pixels behind the quad and seen through its background.
     // The algorithm works as follows:
     // 1. Compute a bounding box around the pixels that will be visible through the quad.
     // 2. Read the pixels in the bounding box into a buffer R.
     // 3. Apply the background filter to R, so that it is applied in the pixels' coordinate space.
     // 4. Apply the quad's inverse transform to map the pixels in R into the quad's content space. This implicitly
     // clips R by the content bounds of the quad since the destination texture has bounds matching the quad's content.
     // 5. Draw the background texture for the contents using the same transform as used to draw the contents itself. This is done
     // without blending to replace the current background pixels with the new filtered background.
     // 6. Draw the contents of the quad over drop of the new background with blending, as per usual. The filtered background
     // pixels will show through any non-opaque pixels in this draws.
     //
     // Pixel copies in this algorithm occur at steps 2, 3, 4, and 5.
 
     // FIXME: When this algorithm changes, update LayerTreeHost::prioritizeTextures() accordingly.
 
     if (filters.isEmpty())
         return scoped_ptr<ScopedTexture>();
 
     // FIXME: We only allow background filters on an opaque render surface because other surfaces may contain
     // translucent pixels, and the contents behind those translucent pixels wouldn't have the filter applied.
     if (frame.currentRenderPass->hasTransparentBackground())
         return scoped_ptr<ScopedTexture>();
     DCHECK(!frame.currentTexture);
 
     // FIXME: Do a single readback for both the surface and replica and cache the filtered results (once filter textures are not reused).
-    gfx::Rect deviceRect = gfx::ToEnclosingRect(MathUtil::mapClippedRect(contentsDeviceTransform, sharedGeometryQuad().BoundingBox()));
+    gfx::Rect deviceRect = gfx::ToEnclosingRect(MathUtil::mapClippedRect(deviceMatrix, sharedGeometryQuad().BoundingBox()));
 
     int top, right, bottom, left;
     filters.getOutsets(top, right, bottom, left);
     deviceRect.Inset(-left, -top, -right, -bottom);
 
     deviceRect.Intersect(frame.currentRenderPass->outputRect());
 
     scoped_ptr<ScopedTexture> deviceBackgroundTexture = ScopedTexture::create(m_resourceProvider);
     if (!getFramebufferTexture(deviceBackgroundTexture.get(), deviceRect))
         return scoped_ptr<ScopedTexture>();
@@ skipping 10 matching lines @@
         return scoped_ptr<ScopedTexture>();
 
     const RenderPass* targetRenderPass = frame.currentRenderPass;
     bool usingBackgroundTexture = useScopedTexture(frame, backgroundTexture.get(), quad->quadRect());
 
     if (usingBackgroundTexture) {
         // Copy the readback pixels from device to the background texture for the surface.
         WebTransformationMatrix deviceToFramebufferTransform;
         deviceToFramebufferTransform.translate(quad->quadRect().width() / 2.0, quad->quadRect().height() / 2.0);
         deviceToFramebufferTransform.scale3d(quad->quadRect().width(), quad->quadRect().height(), 1);
-        deviceToFramebufferTransform.multiply(contentsDeviceTransform.inverse());
+        deviceToFramebufferTransform.multiply(deviceMatrixInv);
         copyTextureToFramebuffer(frame, filteredDeviceBackgroundTextureId, deviceRect, deviceToFramebufferTransform);
     }
 
     useRenderPass(frame, targetRenderPass);
 
     if (!usingBackgroundTexture)
         return scoped_ptr<ScopedTexture>();
     return backgroundTexture.Pass();
 }
 
 void GLRenderer::drawRenderPassQuad(DrawingFrame& frame, const RenderPassDrawQuad* quad)
 {
     CachedTexture* contentsTexture = m_renderPassTextures.get(quad->renderPassId());
     if (!contentsTexture || !contentsTexture->id())
         return;
 
     const RenderPass* renderPass = frame.renderPassesById->get(quad->renderPassId());
     DCHECK(renderPass);
     if (!renderPass)
         return;
 
     WebTransformationMatrix quadRectMatrix;
     quadRectTransform(&quadRectMatrix, quad->quadTransform(), quad->quadRect());
-    WebTransformationMatrix contentsDeviceTransform = (frame.windowMatrix * frame.projectionMatrix * quadRectMatrix).to2dTransform();
+    WebTransformationMatrix deviceMatrix = (frame.windowMatrix * frame.projectionMatrix * quadRectMatrix).to2dTransform();

[jamesr, 2012/11/06 23:53:43]

what's the reason for the rename?

 
     // Can only draw surface if device matrix is invertible.
-    if (!contentsDeviceTransform.isInvertible())
+    if (!deviceMatrix.isInvertible())
         return;
 
-    scoped_ptr<ScopedTexture> backgroundTexture = drawBackgroundFilters(frame, quad, renderPass->backgroundFilters(), contentsDeviceTransform);
+    WebTransformationMatrix deviceMatrixInv = deviceMatrix.inverse();
+    scoped_ptr<ScopedTexture> backgroundTexture = drawBackgroundFilters(
+        frame, quad, renderPass->backgroundFilters(),
+        deviceMatrix, deviceMatrixInv);
 
     // FIXME: Cache this value so that we don't have to do it for both the surface and its replica.
     // Apply filters to the contents texture.
     SkBitmap filterBitmap;
     if (renderPass->filter()) {
         filterBitmap = applyImageFilter(this, renderPass->filter(), contentsTexture);
     } else {
         filterBitmap = applyFilters(this, renderPass->filters(), contentsTexture);
     }
     scoped_ptr<ResourceProvider::ScopedReadLockGL> contentsResourceLock;
     unsigned contentsTextureId = 0;
     if (filterBitmap.getTexture()) {
         GrTexture* texture = reinterpret_cast<GrTexture*>(filterBitmap.getTexture());
         contentsTextureId = texture->getTextureHandle();
     } else {
         contentsResourceLock = make_scoped_ptr(new ResourceProvider::ScopedReadLockGL(m_resourceProvider, contentsTexture->id()));
         contentsTextureId = contentsResourceLock->textureId();
     }
 
     // Draw the background texture if there is one.
     if (backgroundTexture) {
         DCHECK(backgroundTexture->size() == quad->quadRect().size());
         ResourceProvider::ScopedReadLockGL lock(m_resourceProvider, backgroundTexture->id());
         copyTextureToFramebuffer(frame, lock.textureId(), quad->quadRect(), quad->quadTransform());
     }
 
     bool clipped = false;
-    gfx::QuadF deviceQuad = MathUtil::mapQuad(contentsDeviceTransform, sharedGeometryQuad(), clipped);
+    gfx::QuadF deviceQuad = MathUtil::mapQuad(deviceMatrix, sharedGeometryQuad(), clipped);
     DCHECK(!clipped);
     LayerQuad deviceLayerBounds = LayerQuad(gfx::QuadF(deviceQuad.BoundingBox()));
     LayerQuad deviceLayerEdges = LayerQuad(deviceQuad);
 
     // Use anti-aliasing programs only when necessary.
     bool useAA = (!deviceQuad.IsRectilinear() || !deviceQuad.BoundingBox().IsExpressibleAsRect());
     if (useAA) {
         deviceLayerBounds.inflateAntiAliasingDistance();
         deviceLayerEdges.inflateAntiAliasingDistance();
     }
@@ skipping 68 matching lines @@
         GLC(context(), context()->activeTexture(GL_TEXTURE0));
     }
 
     if (shaderEdgeLocation != -1) {
         float edge[24];
         deviceLayerEdges.toFloatArray(edge);
         deviceLayerBounds.toFloatArray(&edge[12]);
         GLC(context(), context()->uniform3fv(shaderEdgeLocation, 8, edge));
     }
 
-    // Map device space quad to surface space. contentsDeviceTransform has no 3d component since it was generated with to2dTransform() so we don't need to project.
-    gfx::QuadF surfaceQuad = MathUtil::mapQuad(contentsDeviceTransform.inverse(), deviceLayerEdges.ToQuadF(), clipped);
+    // Map device space quad to surface space. deviceMatrix has no 3d component since it was generated with to2dTransform() so we don't need to project.
+    gfx::QuadF surfaceQuad = MathUtil::mapQuad(deviceMatrixInv, deviceLayerEdges.ToQuadF(), clipped);
     DCHECK(!clipped);
 
     setShaderOpacity(quad->opacity(), shaderAlphaLocation);
     setShaderQuadF(surfaceQuad, shaderQuadLocation);
     drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), shaderMatrixLocation);
 }
 
 void GLRenderer::drawSolidColorQuad(const DrawingFrame& frame, const SolidColorDrawQuad* quad)
 {
     const SolidColorProgram* program = solidColorProgram();
@@ skipping 59 matching lines @@
 
     // Map to normalized texture coordinates.
     const gfx::Size& textureSize = quad->textureSize();
     float fragmentTexTranslateX = textureOffset.x() / textureSize.width();
     float fragmentTexTranslateY = textureOffset.y() / textureSize.height();
     float fragmentTexScaleX = clampRect.width() / textureSize.width();
     float fragmentTexScaleY = clampRect.height() / textureSize.height();
 
 
     gfx::QuadF localQuad;
-    WebTransformationMatrix deviceTransform = WebTransformationMatrix(frame.windowMatrix * frame.projectionMatrix * quad->quadTransform()).to2dTransform();
-    if (!deviceTransform.isInvertible())
+    WebTransformationMatrix deviceMatrix = WebTransformationMatrix(frame.windowMatrix * frame.projectionMatrix * quad->quadTransform()).to2dTransform();

[jamesr, 2012/11/06 23:53:43]

this rename seems somewhat arbitrary

+    if (!deviceMatrix.isInvertible())
         return;
 
     bool clipped = false;
-    gfx::QuadF deviceLayerQuad = MathUtil::mapQuad(deviceTransform, gfx::QuadF(quad->visibleContentRect()), clipped);
+    gfx::QuadF deviceLayerQuad = MathUtil::mapQuad(deviceMatrix, gfx::QuadF(quad->visibleContentRect()), clipped);
     DCHECK(!clipped);
 
     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 (quad->swizzleContents())
             tileUniformLocation(tileProgramSwizzleAA(), uniforms);
         else
             tileUniformLocation(tileProgramAA(), uniforms);
@@ skipping 34 matching lines @@
 
         GLC(context(), context()->uniform4f(uniforms.vertexTexTransformLocation, vertexTexTranslateX, vertexTexTranslateY, vertexTexScaleX, vertexTexScaleY));
         GLC(context(), context()->uniform4f(uniforms.fragmentTexTransformLocation, fragmentTexTranslateX, fragmentTexTranslateY, fragmentTexScaleX, fragmentTexScaleY));
 
         gfx::PointF bottomRight(tileRect.right(), tileRect.bottom());
         gfx::PointF bottomLeft(tileRect.x(), tileRect.bottom());
         gfx::PointF topLeft(tileRect.x(), tileRect.y());
         gfx::PointF topRight(tileRect.right(), tileRect.y());
 
         // Map points to device space.
-        bottomRight = MathUtil::mapPoint(deviceTransform, bottomRight, clipped);
+        bottomRight = MathUtil::mapPoint(deviceMatrix, bottomRight, clipped);
         DCHECK(!clipped);
-        bottomLeft = MathUtil::mapPoint(deviceTransform, bottomLeft, clipped);
+        bottomLeft = MathUtil::mapPoint(deviceMatrix, bottomLeft, clipped);
         DCHECK(!clipped);
-        topLeft = MathUtil::mapPoint(deviceTransform, topLeft, clipped);
+        topLeft = MathUtil::mapPoint(deviceMatrix, topLeft, clipped);
         DCHECK(!clipped);
-        topRight = MathUtil::mapPoint(deviceTransform, topRight, clipped);
+        topRight = MathUtil::mapPoint(deviceMatrix, 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->topEdgeAA() && tileRect.y() == quad->quadRect().y())
             topEdge = deviceLayerEdges.top();
         if (quad->leftEdgeAA() && tileRect.x() == quad->quadRect().x())
             leftEdge = deviceLayerEdges.left();
         if (quad->rightEdgeAA() && tileRect.right() == quad->quadRect().right())
             rightEdge = deviceLayerEdges.right();
         if (quad->bottomEdgeAA() && tileRect.bottom() == quad->quadRect().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);
 
-        // Map device space quad to local space. contentsDeviceTransform has no 3d component since it was generated with to2dTransform() so we don't need to project.
-        WebTransformationMatrix inverseDeviceTransform = deviceTransform.inverse();
-        localQuad = MathUtil::mapQuad(inverseDeviceTransform, deviceQuad.ToQuadF(), clipped);
+        // Map device space quad to local space. deviceMatrix has no 3d component since it was generated with to2dTransform() so we don't need to project.
+        WebTransformationMatrix deviceMatrixInv = deviceMatrix.inverse();
+        localQuad = MathUtil::mapQuad(deviceMatrixInv, 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;
@@ skipping 801 matching lines @@
 
     releaseRenderPassTextures();
 }
 
 bool GLRenderer::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc