FrameBuilder.cpp revision 6e068c0182f6f85bccb855a647510724d1c65a13
1ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy/* 2ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy * Copyright (C) 2016 The Android Open Source Project 3ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy * 4ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy * Licensed under the Apache License, Version 2.0 (the "License"); 5ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy * you may not use this file except in compliance with the License. 6ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy * You may obtain a copy of the License at 7ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy * 8ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy * http://www.apache.org/licenses/LICENSE-2.0 9ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy * 10ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy * Unless required by applicable law or agreed to in writing, software 11ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy * distributed under the License is distributed on an "AS IS" BASIS, 12ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy * See the License for the specific language governing permissions and 14ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy * limitations under the License. 15ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy */ 16ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy 175f803623559aab395a29d575c37c4e39c23a4b4eChris Craik#include "FrameBuilder.h" 185f803623559aab395a29d575c37c4e39c23a4b4eChris Craik 19ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy#include "Canvas.h" 20ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy#include "LayerUpdateQueue.h" 21ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy#include "RenderNode.h" 22ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy#include "renderstate/OffscreenBufferPool.h" 23ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy#include "utils/FatVector.h" 24ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy#include "utils/PaintUtils.h" 25ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy#include "utils/TraceUtils.h" 26ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy 27ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy#include <SkPathOps.h> 28ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy#include <utils/TypeHelpers.h> 29ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy 30e4aa95e3627226bcb0d8cc3e42dca6e4df8f421cChris Craiknamespace android { 31e4aa95e3627226bcb0d8cc3e42dca6e4df8f421cChris Craiknamespace uirenderer { 32e4aa95e3627226bcb0d8cc3e42dca6e4df8f421cChris Craik 33e4aa95e3627226bcb0d8cc3e42dca6e4df8f421cChris CraikFrameBuilder::FrameBuilder(const LayerUpdateQueue& layers, const SkRect& clip, 34e4aa95e3627226bcb0d8cc3e42dca6e4df8f421cChris Craik uint32_t viewportWidth, uint32_t viewportHeight, 35e4aa95e3627226bcb0d8cc3e42dca6e4df8f421cChris Craik const std::vector< sp<RenderNode> >& nodes, 36e4aa95e3627226bcb0d8cc3e42dca6e4df8f421cChris Craik const LightGeometry& lightGeometry, const Rect &contentDrawBounds, Caches* caches) 37deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik : mCanvasState(*this) 38deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik , mCaches(caches) 39ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy , mLightRadius(lightGeometry.radius) { 40ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy ATRACE_NAME("prepare drawing commands"); 41ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy 428ce00301a023eecaeb8891ce906f67b513ebb42aRomain Guy mLayerBuilders.reserve(layers.entries().size()); 43ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy mLayerStack.reserve(layers.entries().size()); 44ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy 45ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy // Prepare to defer Fbo0 46ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy auto fbo0 = mAllocator.create<LayerBuilder>(viewportWidth, viewportHeight, Rect(clip)); 47ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy mLayerBuilders.push_back(fbo0); 48ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy mLayerStack.push_back(0); 49e4aa95e3627226bcb0d8cc3e42dca6e4df8f421cChris Craik mCanvasState.initializeSaveStack(viewportWidth, viewportHeight, 50e4aa95e3627226bcb0d8cc3e42dca6e4df8f421cChris Craik clip.fLeft, clip.fTop, clip.fRight, clip.fBottom, 51e4aa95e3627226bcb0d8cc3e42dca6e4df8f421cChris Craik lightGeometry.center); 52e4aa95e3627226bcb0d8cc3e42dca6e4df8f421cChris Craik 53e4aa95e3627226bcb0d8cc3e42dca6e4df8f421cChris Craik // Render all layers to be updated, in order. Defer in reverse order, so that they'll be 54e4aa95e3627226bcb0d8cc3e42dca6e4df8f421cChris Craik // updated in the order they're passed in (mLayerBuilders are issued to Renderer in reverse) 55e4aa95e3627226bcb0d8cc3e42dca6e4df8f421cChris Craik for (int i = layers.entries().size() - 1; i >= 0; i--) { 56a64a2bef1048db5a742843f1e3bea9e80d0defc5Chris Craik RenderNode* layerNode = layers.entries()[i].renderNode; 57deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik // only schedule repaint if node still on layer - possible it may have been 5869e5adffb19135d51bde8e458f4907d7265f3e23Chris Craik // removed during a dropped frame, but layers may still remain scheduled so 5969e5adffb19135d51bde8e458f4907d7265f3e23Chris Craik // as not to lose info on what portion is damaged 60ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy if (CC_LIKELY(layerNode->getLayer() != nullptr)) { 61ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy const Rect& layerDamage = layers.entries()[i].damage; 62ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy layerNode->computeOrdering(); 63ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy 64ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy // map current light center into RenderNode's coordinate space 65ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy Vector3 lightCenter = mCanvasState.currentSnapshot()->getRelativeLightCenter(); 66ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy layerNode->getLayer()->inverseTransformInWindow.mapPoint3d(lightCenter); 67ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy 68ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy saveForLayer(layerNode->getWidth(), layerNode->getHeight(), 0, 0, 69ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy layerDamage, lightCenter, nullptr, layerNode); 708ce00301a023eecaeb8891ce906f67b513ebb42aRomain Guy 710baaac5e9adf3ee280ae1239e2e58754a9d2b099Romain Guy if (layerNode->getDisplayList()) { 72967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy deferNodeOps(*layerNode); 738ce00301a023eecaeb8891ce906f67b513ebb42aRomain Guy } 74ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy restoreForLayer(); 75ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy } 76967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy } 77ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy 78ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy // It there are multiple render nodes, they are laid out as follows: 79ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy // #0 - backdrop (content + caption) 80ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy // #1 - content (positioned at (0,0) and clipped to - its bounds mContentDrawBounds) 81ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy // #2 - additional overlay nodes 82ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy // Usually the backdrop cannot be seen since it will be entirely covered by the content. While 83ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy // resizing however it might become partially visible. The following render loop will crop the 84ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy // backdrop against the content and draw the remaining part of it. It will then draw the content 85ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy // cropped to the backdrop (since that indicates a shrinking of the window). 86ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy // 87ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy // Additional nodes will be drawn on top with no particular clipping semantics. 88ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy 89ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy // The bounds of the backdrop against which the content should be clipped. 90ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy Rect backdropBounds = contentDrawBounds; 91967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy // Usually the contents bounds should be mContentDrawBounds - however - we will 928ce00301a023eecaeb8891ce906f67b513ebb42aRomain Guy // move it towards the fixed edge to give it a more stable appearance (for the moment). 930baaac5e9adf3ee280ae1239e2e58754a9d2b099Romain Guy // If there is no content bounds we ignore the layering as stated above and start with 2. 94967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy int layer = (contentDrawBounds.isEmpty() || nodes.size() == 1) ? 2 : 0; 95967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy 96967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy for (const sp<RenderNode>& node : nodes) { 97967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy if (node->nothingToDraw()) continue; 98967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy node->computeOrdering(); 990baaac5e9adf3ee280ae1239e2e58754a9d2b099Romain Guy int count = mCanvasState.save(SaveFlags::MatrixClip); 1000baaac5e9adf3ee280ae1239e2e58754a9d2b099Romain Guy 101967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy if (layer == 0) { 102967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy const RenderProperties& properties = node->properties(); 1030baaac5e9adf3ee280ae1239e2e58754a9d2b099Romain Guy Rect targetBounds(properties.getLeft(), properties.getTop(), 104967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy properties.getRight(), properties.getBottom()); 105967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy // Move the content bounds towards the fixed corner of the backdrop. 106967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy const int x = targetBounds.left; 107967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy const int y = targetBounds.top; 108967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy // Remember the intersection of the target bounds and the intersection bounds against 109967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy // which we have to crop the content. 1100baaac5e9adf3ee280ae1239e2e58754a9d2b099Romain Guy backdropBounds.set(x, y, x + backdropBounds.getWidth(), y + backdropBounds.getHeight()); 1110baaac5e9adf3ee280ae1239e2e58754a9d2b099Romain Guy backdropBounds.doIntersect(targetBounds); 1120baaac5e9adf3ee280ae1239e2e58754a9d2b099Romain Guy } else if (layer == 1) { 1130baaac5e9adf3ee280ae1239e2e58754a9d2b099Romain Guy // We shift and clip the content to match its final location in the window. 114967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy const float left = contentDrawBounds.left; 115967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy const float top = contentDrawBounds.top; 1168ce00301a023eecaeb8891ce906f67b513ebb42aRomain Guy const float dx = backdropBounds.left - left; 1178ce00301a023eecaeb8891ce906f67b513ebb42aRomain Guy const float dy = backdropBounds.top - top; 1188ce00301a023eecaeb8891ce906f67b513ebb42aRomain Guy const float width = backdropBounds.getWidth(); 1198ce00301a023eecaeb8891ce906f67b513ebb42aRomain Guy const float height = backdropBounds.getHeight(); 1208ce00301a023eecaeb8891ce906f67b513ebb42aRomain Guy mCanvasState.translate(dx, dy); 1218ce00301a023eecaeb8891ce906f67b513ebb42aRomain Guy // It gets cropped against the bounds of the backdrop to stay inside. 1228ce00301a023eecaeb8891ce906f67b513ebb42aRomain Guy mCanvasState.clipRect(left, top, left + width, top + height, SkRegion::kIntersect_Op); 1238ce00301a023eecaeb8891ce906f67b513ebb42aRomain Guy } 124967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy 125967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy deferNodePropsAndOps(*node); 126ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy mCanvasState.restoreToCount(count); 127ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy layer++; 128ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy } 129ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy} 130ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy 131ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guyvoid FrameBuilder::onViewportInitialized() {} 132ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy 133ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guyvoid FrameBuilder::onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) {} 134ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy 135ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guyvoid FrameBuilder::deferNodePropsAndOps(RenderNode& node) { 136967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy const RenderProperties& properties = node.properties(); 1378ce00301a023eecaeb8891ce906f67b513ebb42aRomain Guy const Outline& outline = properties.getOutline(); 138735738c4ddf3229caa5f6e634bf591953ac29944Romain Guy if (properties.getAlpha() <= 0 1390baaac5e9adf3ee280ae1239e2e58754a9d2b099Romain Guy || (outline.getShouldClip() && outline.isEmpty()) 140967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy || properties.getScaleX() == 0 141967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy || properties.getScaleY() == 0) { 142967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy return; // rejected 143967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy } 144967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy 145967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy if (properties.getLeft() != 0 || properties.getTop() != 0) { 146ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy mCanvasState.translate(properties.getLeft(), properties.getTop()); 147ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy } 148967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy if (properties.getStaticMatrix()) { 149967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy mCanvasState.concatMatrix(*properties.getStaticMatrix()); 150967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy } else if (properties.getAnimationMatrix()) { 151ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy mCanvasState.concatMatrix(*properties.getAnimationMatrix()); 152ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy } 153967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy if (properties.hasTransformMatrix()) { 1540baaac5e9adf3ee280ae1239e2e58754a9d2b099Romain Guy if (properties.isTransformTranslateOnly()) { 1550baaac5e9adf3ee280ae1239e2e58754a9d2b099Romain Guy mCanvasState.translate(properties.getTranslationX(), properties.getTranslationY()); 1560baaac5e9adf3ee280ae1239e2e58754a9d2b099Romain Guy } else { 1570baaac5e9adf3ee280ae1239e2e58754a9d2b099Romain Guy mCanvasState.concatMatrix(*properties.getTransformMatrix()); 1580baaac5e9adf3ee280ae1239e2e58754a9d2b099Romain Guy } 159ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy } 160ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy 161ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy const int width = properties.getWidth(); 162ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy const int height = properties.getHeight(); 163ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy 164ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy Rect saveLayerBounds; // will be set to non-empty if saveLayer needed 165ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy const bool isLayer = properties.effectiveLayerType() != LayerType::None; 166ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy int clipFlags = properties.getClippingFlags(); 167ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy if (properties.getAlpha() < 1) { 168ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy if (isLayer) { 169ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy clipFlags &= ~CLIP_TO_BOUNDS; // bounds clipping done by layer 1708ce00301a023eecaeb8891ce906f67b513ebb42aRomain Guy } 1710baaac5e9adf3ee280ae1239e2e58754a9d2b099Romain Guy if (CC_LIKELY(isLayer || !properties.getHasOverlappingRendering())) { 172967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy // simply scale rendering content's alpha 173ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy mCanvasState.scaleAlpha(properties.getAlpha()); 174ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy } else { 175ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy // schedule saveLayer by initializing saveLayerBounds 176a3dc55f83ab583e0a66b893c71b849afa046770aRomain Guy saveLayerBounds.set(0, 0, width, height); 177a3dc55f83ab583e0a66b893c71b849afa046770aRomain Guy if (clipFlags) { 178a3dc55f83ab583e0a66b893c71b849afa046770aRomain Guy properties.getClippingRectForFlags(clipFlags, &saveLayerBounds); 179a3dc55f83ab583e0a66b893c71b849afa046770aRomain Guy clipFlags = 0; // all clipping done by savelayer 180ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy } 181ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy } 182ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy 183ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy if (CC_UNLIKELY(ATRACE_ENABLED() && properties.promotedToLayer())) { 184ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy // pretend alpha always causes savelayer to warn about 185ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy // performance problem affecting old versions 186ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy ATRACE_FORMAT("%s alpha caused saveLayer %dx%d", node.getName(), width, height); 187ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy } 188ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy } 189ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy if (clipFlags) { 190ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy Rect clipRect; 1913bbacf27c0be1bae4e4483577fc89ae3113abe5dRomain Guy properties.getClippingRectForFlags(clipFlags, &clipRect); 1923bbacf27c0be1bae4e4483577fc89ae3113abe5dRomain Guy mCanvasState.clipRect(clipRect.left, clipRect.top, clipRect.right, clipRect.bottom, 1933bbacf27c0be1bae4e4483577fc89ae3113abe5dRomain Guy SkRegion::kIntersect_Op); 194ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy } 1953c099c42fd7ead1429076055990ae39b72c904f4Romain Guy 196967e2bf3ac8943a8e8a374bf86021915445cda67Romain Guy if (properties.getRevealClip().willClip()) { 197ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy Rect bounds; 198ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy properties.getRevealClip().getBounds(&bounds); 199ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy mCanvasState.setClippingRoundRect(mAllocator, 200ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy bounds, properties.getRevealClip().getRadius()); 201ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy } else if (properties.getOutline().willClip()) { 202ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy mCanvasState.setClippingOutline(mAllocator, &(properties.getOutline())); 203ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy } 20469e5adffb19135d51bde8e458f4907d7265f3e23Chris Craik 20569e5adffb19135d51bde8e458f4907d7265f3e23Chris Craik if (!mCanvasState.quickRejectConservative(0, 0, width, height)) { 20669e5adffb19135d51bde8e458f4907d7265f3e23Chris Craik // not rejected, so defer render as either Layer, or direct (possibly wrapped in saveLayer) 20769e5adffb19135d51bde8e458f4907d7265f3e23Chris Craik if (node.getLayer()) { 20869e5adffb19135d51bde8e458f4907d7265f3e23Chris Craik // HW layer 20969e5adffb19135d51bde8e458f4907d7265f3e23Chris Craik LayerOp* drawLayerOp = new (mAllocator) LayerOp(node); 21069e5adffb19135d51bde8e458f4907d7265f3e23Chris Craik BakedOpState* bakedOpState = tryBakeOpState(*drawLayerOp); 211ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy if (bakedOpState) { 212ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy // Node's layer already deferred, schedule it to render into parent layer 213ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy currentLayer().deferUnmergeableOp(mAllocator, bakedOpState, OpBatchType::Bitmap); 214ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy } 215ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy } else if (CC_UNLIKELY(!saveLayerBounds.isEmpty())) { 216af4d04cab6d48ae0d6a5e79bd30f679af87abaadChris Craik // draw DisplayList contents within temporary, since persisted layer could not be used. 217deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik // (temp layers are clipped to viewport, since they don't persist offscreen content) 218deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik SkPaint saveLayerPaint; 219af4d04cab6d48ae0d6a5e79bd30f679af87abaadChris Craik saveLayerPaint.setAlpha(properties.getAlpha()); 220af4d04cab6d48ae0d6a5e79bd30f679af87abaadChris Craik deferBeginLayerOp(*new (mAllocator) BeginLayerOp( 221af4d04cab6d48ae0d6a5e79bd30f679af87abaadChris Craik saveLayerBounds, 222af4d04cab6d48ae0d6a5e79bd30f679af87abaadChris Craik Matrix4::identity(), 223af4d04cab6d48ae0d6a5e79bd30f679af87abaadChris Craik nullptr, // no record-time clip - need only respect defer-time one 224deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik &saveLayerPaint)); 225deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik deferNodeOps(node); 226deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik deferEndLayerOp(*new (mAllocator) EndLayerOp()); 227deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik } else { 228af4d04cab6d48ae0d6a5e79bd30f679af87abaadChris Craik deferNodeOps(node); 229af4d04cab6d48ae0d6a5e79bd30f679af87abaadChris Craik } 230af4d04cab6d48ae0d6a5e79bd30f679af87abaadChris Craik } 231af4d04cab6d48ae0d6a5e79bd30f679af87abaadChris Craik} 232deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik 233deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craiktypedef key_value_pair_t<float, const RenderNodeOp*> ZRenderNodeOpPair; 234deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik 235deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craiktemplate <typename V> 236deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craikstatic void buildZSortedChildList(V* zTranslatedNodes, 237deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik const DisplayList& displayList, const DisplayList::Chunk& chunk) { 238deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik if (chunk.beginChildIndex == chunk.endChildIndex) return; 239deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik 240deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik for (size_t i = chunk.beginChildIndex; i < chunk.endChildIndex; i++) { 241deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik RenderNodeOp* childOp = displayList.getChildren()[i]; 242deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik RenderNode* child = childOp->renderNode; 243deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik float childZ = child->properties().getZ(); 244deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik 245deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik if (!MathUtils::isZero(childZ) && chunk.reorderChildren) { 246deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik zTranslatedNodes->push_back(ZRenderNodeOpPair(childZ, childOp)); 247deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik childOp->skipInOrderDraw = true; 248deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik } else if (!child->properties().getProjectBackwards()) { 249af4d04cab6d48ae0d6a5e79bd30f679af87abaadChris Craik // regular, in order drawing DisplayList 250af4d04cab6d48ae0d6a5e79bd30f679af87abaadChris Craik childOp->skipInOrderDraw = false; 251af4d04cab6d48ae0d6a5e79bd30f679af87abaadChris Craik } 252deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik } 253deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik 254deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik // Z sort any 3d children (stable-ness makes z compare fall back to standard drawing order) 255deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik std::stable_sort(zTranslatedNodes->begin(), zTranslatedNodes->end()); 256deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik} 257deeda3d337aed1eee218b89a7aba5992ced371f0Chris Craik 258ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guytemplate <typename V> 259ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guystatic size_t findNonNegativeIndex(const V& zTranslatedNodes) { 260ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy for (size_t i = 0; i < zTranslatedNodes.size(); i++) { 261ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy if (zTranslatedNodes[i].key >= 0.0f) return i; 262ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy } 263ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy return zTranslatedNodes.size(); 264ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy} 2655f803623559aab395a29d575c37c4e39c23a4b4eChris Craik 2665f803623559aab395a29d575c37c4e39c23a4b4eChris Craiktemplate <typename V> 267a64a2bef1048db5a742843f1e3bea9e80d0defc5Chris Craikvoid FrameBuilder::defer3dChildren(ChildrenSelectMode mode, const V& zTranslatedNodes) { 2685f803623559aab395a29d575c37c4e39c23a4b4eChris Craik const int size = zTranslatedNodes.size(); 2695f803623559aab395a29d575c37c4e39c23a4b4eChris Craik if (size == 0 2705f803623559aab395a29d575c37c4e39c23a4b4eChris Craik || (mode == ChildrenSelectMode::Negative&& zTranslatedNodes[0].key > 0.0f) 2715f803623559aab395a29d575c37c4e39c23a4b4eChris Craik || (mode == ChildrenSelectMode::Positive && zTranslatedNodes[size - 1].key < 0.0f)) { 2725f803623559aab395a29d575c37c4e39c23a4b4eChris Craik // no 3d children to draw 2735f803623559aab395a29d575c37c4e39c23a4b4eChris Craik return; 274ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy } 275ada4d53d50dc869b8278573ad640dc44118d3bcfRomain Guy 276 /** 277 * Draw shadows and (potential) casters mostly in order, but allow the shadows of casters 278 * with very similar Z heights to draw together. 279 * 280 * This way, if Views A & B have the same Z height and are both casting shadows, the shadows are 281 * underneath both, and neither's shadow is drawn on top of the other. 282 */ 283 const size_t nonNegativeIndex = findNonNegativeIndex(zTranslatedNodes); 284 size_t drawIndex, shadowIndex, endIndex; 285 if (mode == ChildrenSelectMode::Negative) { 286 drawIndex = 0; 287 endIndex = nonNegativeIndex; 288 shadowIndex = endIndex; // draw no shadows 289 } else { 290 drawIndex = nonNegativeIndex; 291 endIndex = size; 292 shadowIndex = drawIndex; // potentially draw shadow for each pos Z child 293 } 294 295 float lastCasterZ = 0.0f; 296 while (shadowIndex < endIndex || drawIndex < endIndex) { 297 if (shadowIndex < endIndex) { 298 const RenderNodeOp* casterNodeOp = zTranslatedNodes[shadowIndex].value; 299 const float casterZ = zTranslatedNodes[shadowIndex].key; 300 // attempt to render the shadow if the caster about to be drawn is its caster, 301 // OR if its caster's Z value is similar to the previous potential caster 302 if (shadowIndex == drawIndex || casterZ - lastCasterZ < 0.1f) { 303 deferShadow(*casterNodeOp); 304 305 lastCasterZ = casterZ; // must do this even if current caster not casting a shadow 306 shadowIndex++; 307 continue; 308 } 309 } 310 311 const RenderNodeOp* childOp = zTranslatedNodes[drawIndex].value; 312 deferRenderNodeOpImpl(*childOp); 313 drawIndex++; 314 } 315} 316 317void FrameBuilder::deferShadow(const RenderNodeOp& casterNodeOp) { 318 auto& node = *casterNodeOp.renderNode; 319 auto& properties = node.properties(); 320 321 if (properties.getAlpha() <= 0.0f 322 || properties.getOutline().getAlpha() <= 0.0f 323 || !properties.getOutline().getPath() 324 || properties.getScaleX() == 0 325 || properties.getScaleY() == 0) { 326 // no shadow to draw 327 return; 328 } 329 330 const SkPath* casterOutlinePath = properties.getOutline().getPath(); 331 const SkPath* revealClipPath = properties.getRevealClip().getPath(); 332 if (revealClipPath && revealClipPath->isEmpty()) return; 333 334 float casterAlpha = properties.getAlpha() * properties.getOutline().getAlpha(); 335 336 // holds temporary SkPath to store the result of intersections 337 SkPath* frameAllocatedPath = nullptr; 338 const SkPath* casterPath = casterOutlinePath; 339 340 // intersect the shadow-casting path with the reveal, if present 341 if (revealClipPath) { 342 frameAllocatedPath = createFrameAllocatedPath(); 343 344 Op(*casterPath, *revealClipPath, kIntersect_SkPathOp, frameAllocatedPath); 345 casterPath = frameAllocatedPath; 346 } 347 348 // intersect the shadow-casting path with the clipBounds, if present 349 if (properties.getClippingFlags() & CLIP_TO_CLIP_BOUNDS) { 350 if (!frameAllocatedPath) { 351 frameAllocatedPath = createFrameAllocatedPath(); 352 } 353 Rect clipBounds; 354 properties.getClippingRectForFlags(CLIP_TO_CLIP_BOUNDS, &clipBounds); 355 SkPath clipBoundsPath; 356 clipBoundsPath.addRect(clipBounds.left, clipBounds.top, 357 clipBounds.right, clipBounds.bottom); 358 359 Op(*casterPath, clipBoundsPath, kIntersect_SkPathOp, frameAllocatedPath); 360 casterPath = frameAllocatedPath; 361 } 362 363 364 if (CC_LIKELY(!mCanvasState.getRenderTargetClipBounds().isEmpty())) { 365 Matrix4 shadowMatrixXY(casterNodeOp.localMatrix); 366 Matrix4 shadowMatrixZ(casterNodeOp.localMatrix); 367 node.applyViewPropertyTransforms(shadowMatrixXY, false); 368 node.applyViewPropertyTransforms(shadowMatrixZ, true); 369 370 LOG_ALWAYS_FATAL_IF(!mCaches, "Caches needed for shadows"); 371 sp<TessellationCache::ShadowTask> task = mCaches->tessellationCache.getShadowTask( 372 mCanvasState.currentTransform(), 373 mCanvasState.getLocalClipBounds(), 374 casterAlpha >= 1.0f, 375 casterPath, 376 &shadowMatrixXY, &shadowMatrixZ, 377 mCanvasState.currentSnapshot()->getRelativeLightCenter(), 378 mLightRadius); 379 ShadowOp* shadowOp = mAllocator.create<ShadowOp>(task, casterAlpha); 380 BakedOpState* bakedOpState = BakedOpState::tryShadowOpConstruct( 381 mAllocator, *mCanvasState.writableSnapshot(), shadowOp); 382 if (CC_LIKELY(bakedOpState)) { 383 currentLayer().deferUnmergeableOp(mAllocator, bakedOpState, OpBatchType::Shadow); 384 } 385 } 386} 387 388void FrameBuilder::deferProjectedChildren(const RenderNode& renderNode) { 389 const SkPath* projectionReceiverOutline = renderNode.properties().getOutline().getPath(); 390 int count = mCanvasState.save(SaveFlags::MatrixClip); 391 392 // can't be null, since DL=null node rejection happens before deferNodePropsAndOps 393 const DisplayList& displayList = *(renderNode.getDisplayList()); 394 395 const RecordedOp* op = (displayList.getOps()[displayList.projectionReceiveIndex]); 396 const RenderNodeOp* backgroundOp = static_cast<const RenderNodeOp*>(op); 397 const RenderProperties& backgroundProps = backgroundOp->renderNode->properties(); 398 399 // Transform renderer to match background we're projecting onto 400 // (by offsetting canvas by translationX/Y of background rendernode, since only those are set) 401 mCanvasState.translate(backgroundProps.getTranslationX(), backgroundProps.getTranslationY()); 402 403 // If the projection receiver has an outline, we mask projected content to it 404 // (which we know, apriori, are all tessellated paths) 405 mCanvasState.setProjectionPathMask(mAllocator, projectionReceiverOutline); 406 407 // draw projected nodes 408 for (size_t i = 0; i < renderNode.mProjectedNodes.size(); i++) { 409 RenderNodeOp* childOp = renderNode.mProjectedNodes[i]; 410 411 int restoreTo = mCanvasState.save(SaveFlags::Matrix); 412 mCanvasState.concatMatrix(childOp->transformFromCompositingAncestor); 413 deferRenderNodeOpImpl(*childOp); 414 mCanvasState.restoreToCount(restoreTo); 415 } 416 417 mCanvasState.restoreToCount(count); 418} 419 420/** 421 * Used to define a list of lambdas referencing private FrameBuilder::onXX::defer() methods. 422 * 423 * This allows opIds embedded in the RecordedOps to be used for dispatching to these lambdas. 424 * E.g. a BitmapOp op then would be dispatched to FrameBuilder::onBitmapOp(const BitmapOp&) 425 */ 426#define OP_RECEIVER(Type) \ 427 [](FrameBuilder& frameBuilder, const RecordedOp& op) { frameBuilder.defer##Type(static_cast<const Type&>(op)); }, 428void FrameBuilder::deferNodeOps(const RenderNode& renderNode) { 429 typedef void (*OpDispatcher) (FrameBuilder& frameBuilder, const RecordedOp& op); 430 static OpDispatcher receivers[] = BUILD_DEFERRABLE_OP_LUT(OP_RECEIVER); 431 432 // can't be null, since DL=null node rejection happens before deferNodePropsAndOps 433 const DisplayList& displayList = *(renderNode.getDisplayList()); 434 for (const DisplayList::Chunk& chunk : displayList.getChunks()) { 435 FatVector<ZRenderNodeOpPair, 16> zTranslatedNodes; 436 buildZSortedChildList(&zTranslatedNodes, displayList, chunk); 437 438 defer3dChildren(ChildrenSelectMode::Negative, zTranslatedNodes); 439 for (size_t opIndex = chunk.beginOpIndex; opIndex < chunk.endOpIndex; opIndex++) { 440 const RecordedOp* op = displayList.getOps()[opIndex]; 441 receivers[op->opId](*this, *op); 442 443 if (CC_UNLIKELY(!renderNode.mProjectedNodes.empty() 444 && displayList.projectionReceiveIndex >= 0 445 && static_cast<int>(opIndex) == displayList.projectionReceiveIndex)) { 446 deferProjectedChildren(renderNode); 447 } 448 } 449 defer3dChildren(ChildrenSelectMode::Positive, zTranslatedNodes); 450 } 451} 452 453void FrameBuilder::deferRenderNodeOpImpl(const RenderNodeOp& op) { 454 if (op.renderNode->nothingToDraw()) return; 455 int count = mCanvasState.save(SaveFlags::MatrixClip); 456 457 // apply state from RecordedOp (clip first, since op's clip is transformed by current matrix) 458 mCanvasState.writableSnapshot()->mutateClipArea().applyClip(op.localClip, 459 *mCanvasState.currentSnapshot()->transform); 460 mCanvasState.concatMatrix(op.localMatrix); 461 462 // then apply state from node properties, and defer ops 463 deferNodePropsAndOps(*op.renderNode); 464 465 mCanvasState.restoreToCount(count); 466} 467 468void FrameBuilder::deferRenderNodeOp(const RenderNodeOp& op) { 469 if (!op.skipInOrderDraw) { 470 deferRenderNodeOpImpl(op); 471 } 472} 473 474/** 475 * Defers an unmergeable, strokeable op, accounting correctly 476 * for paint's style on the bounds being computed. 477 */ 478void FrameBuilder::deferStrokeableOp(const RecordedOp& op, batchid_t batchId, 479 BakedOpState::StrokeBehavior strokeBehavior) { 480 // Note: here we account for stroke when baking the op 481 BakedOpState* bakedState = BakedOpState::tryStrokeableOpConstruct( 482 mAllocator, *mCanvasState.writableSnapshot(), op, strokeBehavior); 483 if (!bakedState) return; // quick rejected 484 currentLayer().deferUnmergeableOp(mAllocator, bakedState, batchId); 485} 486 487/** 488 * Returns batch id for tessellatable shapes, based on paint. Checks to see if path effect/AA will 489 * be used, since they trigger significantly different rendering paths. 490 * 491 * Note: not used for lines/points, since they don't currently support path effects. 492 */ 493static batchid_t tessBatchId(const RecordedOp& op) { 494 const SkPaint& paint = *(op.paint); 495 return paint.getPathEffect() 496 ? OpBatchType::AlphaMaskTexture 497 : (paint.isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices); 498} 499 500void FrameBuilder::deferArcOp(const ArcOp& op) { 501 deferStrokeableOp(op, tessBatchId(op)); 502} 503 504static bool hasMergeableClip(const BakedOpState& state) { 505 return state.computedState.clipState 506 || state.computedState.clipState->mode == ClipMode::Rectangle; 507} 508 509void FrameBuilder::deferBitmapOp(const BitmapOp& op) { 510 BakedOpState* bakedState = tryBakeOpState(op); 511 if (!bakedState) return; // quick rejected 512 513 currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap); 514 515 // TODO: Fix this ( b/26569206 ) 516/* 517 // Don't merge non-simply transformed or neg scale ops, SET_TEXTURE doesn't handle rotation 518 // Don't merge A8 bitmaps - the paint's color isn't compared by mergeId, or in 519 // MergingDrawBatch::canMergeWith() 520 if (bakedState->computedState.transform.isSimple() 521 && bakedState->computedState.transform.positiveScale() 522 && PaintUtils::getXfermodeDirect(op.paint) == SkXfermode::kSrcOver_Mode 523 && op.bitmap->colorType() != kAlpha_8_SkColorType 524 && hasMergeableClip(*bakedState)) { 525 mergeid_t mergeId = reinterpret_cast<mergeid_t>(op.bitmap->getGenerationID()); 526 // TODO: AssetAtlas in mergeId 527 currentLayer().deferMergeableOp(mAllocator, bakedState, OpBatchType::Bitmap, mergeId); 528 } else { 529 currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap); 530 } 531*/ 532} 533 534void FrameBuilder::deferBitmapMeshOp(const BitmapMeshOp& op) { 535 BakedOpState* bakedState = tryBakeOpState(op); 536 if (!bakedState) return; // quick rejected 537 currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap); 538} 539 540void FrameBuilder::deferBitmapRectOp(const BitmapRectOp& op) { 541 BakedOpState* bakedState = tryBakeOpState(op); 542 if (!bakedState) return; // quick rejected 543 currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap); 544} 545 546void FrameBuilder::deferCirclePropsOp(const CirclePropsOp& op) { 547 // allocate a temporary oval op (with mAllocator, so it persists until render), so the 548 // renderer doesn't have to handle the RoundRectPropsOp type, and so state baking is simple. 549 float x = *(op.x); 550 float y = *(op.y); 551 float radius = *(op.radius); 552 Rect unmappedBounds(x - radius, y - radius, x + radius, y + radius); 553 const OvalOp* resolvedOp = new (mAllocator) OvalOp( 554 unmappedBounds, 555 op.localMatrix, 556 op.localClip, 557 op.paint); 558 deferOvalOp(*resolvedOp); 559} 560 561void FrameBuilder::deferFunctorOp(const FunctorOp& op) { 562 BakedOpState* bakedState = tryBakeOpState(op); 563 if (!bakedState) return; // quick rejected 564 currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Functor); 565} 566 567void FrameBuilder::deferLinesOp(const LinesOp& op) { 568 batchid_t batch = op.paint->isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices; 569 deferStrokeableOp(op, batch, BakedOpState::StrokeBehavior::Forced); 570} 571 572void FrameBuilder::deferOvalOp(const OvalOp& op) { 573 deferStrokeableOp(op, tessBatchId(op)); 574} 575 576void FrameBuilder::deferPatchOp(const PatchOp& op) { 577 BakedOpState* bakedState = tryBakeOpState(op); 578 if (!bakedState) return; // quick rejected 579 580 if (bakedState->computedState.transform.isPureTranslate() 581 && PaintUtils::getXfermodeDirect(op.paint) == SkXfermode::kSrcOver_Mode 582 && hasMergeableClip(*bakedState)) { 583 mergeid_t mergeId = reinterpret_cast<mergeid_t>(op.bitmap->getGenerationID()); 584 // TODO: AssetAtlas in mergeId 585 586 // Only use the MergedPatch batchId when merged, so Bitmap+Patch don't try to merge together 587 currentLayer().deferMergeableOp(mAllocator, bakedState, OpBatchType::MergedPatch, mergeId); 588 } else { 589 // Use Bitmap batchId since Bitmap+Patch use same shader 590 currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap); 591 } 592} 593 594void FrameBuilder::deferPathOp(const PathOp& op) { 595 deferStrokeableOp(op, OpBatchType::Bitmap); 596} 597 598void FrameBuilder::deferPointsOp(const PointsOp& op) { 599 batchid_t batch = op.paint->isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices; 600 deferStrokeableOp(op, batch, BakedOpState::StrokeBehavior::Forced); 601} 602 603void FrameBuilder::deferRectOp(const RectOp& op) { 604 deferStrokeableOp(op, tessBatchId(op)); 605} 606 607void FrameBuilder::deferRoundRectOp(const RoundRectOp& op) { 608 deferStrokeableOp(op, tessBatchId(op)); 609} 610 611void FrameBuilder::deferRoundRectPropsOp(const RoundRectPropsOp& op) { 612 // allocate a temporary round rect op (with mAllocator, so it persists until render), so the 613 // renderer doesn't have to handle the RoundRectPropsOp type, and so state baking is simple. 614 const RoundRectOp* resolvedOp = new (mAllocator) RoundRectOp( 615 Rect(*(op.left), *(op.top), *(op.right), *(op.bottom)), 616 op.localMatrix, 617 op.localClip, 618 op.paint, *op.rx, *op.ry); 619 deferRoundRectOp(*resolvedOp); 620} 621 622void FrameBuilder::deferSimpleRectsOp(const SimpleRectsOp& op) { 623 BakedOpState* bakedState = tryBakeOpState(op); 624 if (!bakedState) return; // quick rejected 625 currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Vertices); 626} 627 628static batchid_t textBatchId(const SkPaint& paint) { 629 // TODO: better handling of shader (since we won't care about color then) 630 return paint.getColor() == SK_ColorBLACK ? OpBatchType::Text : OpBatchType::ColorText; 631} 632 633void FrameBuilder::deferTextOp(const TextOp& op) { 634 BakedOpState* bakedState = tryBakeOpState(op); 635 if (!bakedState) return; // quick rejected 636 637 batchid_t batchId = textBatchId(*(op.paint)); 638 if (bakedState->computedState.transform.isPureTranslate() 639 && PaintUtils::getXfermodeDirect(op.paint) == SkXfermode::kSrcOver_Mode 640 && hasMergeableClip(*bakedState)) { 641 mergeid_t mergeId = reinterpret_cast<mergeid_t>(op.paint->getColor()); 642 currentLayer().deferMergeableOp(mAllocator, bakedState, batchId, mergeId); 643 } else { 644 currentLayer().deferUnmergeableOp(mAllocator, bakedState, batchId); 645 } 646} 647 648void FrameBuilder::deferTextOnPathOp(const TextOnPathOp& op) { 649 BakedOpState* bakedState = tryBakeOpState(op); 650 if (!bakedState) return; // quick rejected 651 currentLayer().deferUnmergeableOp(mAllocator, bakedState, textBatchId(*(op.paint))); 652} 653 654void FrameBuilder::deferTextureLayerOp(const TextureLayerOp& op) { 655 BakedOpState* bakedState = tryBakeOpState(op); 656 if (!bakedState) return; // quick rejected 657 currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::TextureLayer); 658} 659 660void FrameBuilder::saveForLayer(uint32_t layerWidth, uint32_t layerHeight, 661 float contentTranslateX, float contentTranslateY, 662 const Rect& repaintRect, 663 const Vector3& lightCenter, 664 const BeginLayerOp* beginLayerOp, RenderNode* renderNode) { 665 mCanvasState.save(SaveFlags::MatrixClip); 666 mCanvasState.writableSnapshot()->initializeViewport(layerWidth, layerHeight); 667 mCanvasState.writableSnapshot()->roundRectClipState = nullptr; 668 mCanvasState.writableSnapshot()->setRelativeLightCenter(lightCenter); 669 mCanvasState.writableSnapshot()->transform->loadTranslate( 670 contentTranslateX, contentTranslateY, 0); 671 mCanvasState.writableSnapshot()->setClip( 672 repaintRect.left, repaintRect.top, repaintRect.right, repaintRect.bottom); 673 674 // create a new layer repaint, and push its index on the stack 675 mLayerStack.push_back(mLayerBuilders.size()); 676 auto newFbo = mAllocator.create<LayerBuilder>(layerWidth, layerHeight, 677 repaintRect, beginLayerOp, renderNode); 678 mLayerBuilders.push_back(newFbo); 679} 680 681void FrameBuilder::restoreForLayer() { 682 // restore canvas, and pop finished layer off of the stack 683 mCanvasState.restore(); 684 mLayerStack.pop_back(); 685} 686 687// TODO: defer time rejection (when bounds become empty) + tests 688// Option - just skip layers with no bounds at playback + defer? 689void FrameBuilder::deferBeginLayerOp(const BeginLayerOp& op) { 690 uint32_t layerWidth = (uint32_t) op.unmappedBounds.getWidth(); 691 uint32_t layerHeight = (uint32_t) op.unmappedBounds.getHeight(); 692 693 auto previous = mCanvasState.currentSnapshot(); 694 Vector3 lightCenter = previous->getRelativeLightCenter(); 695 696 // Combine all transforms used to present saveLayer content: 697 // parent content transform * canvas transform * bounds offset 698 Matrix4 contentTransform(*(previous->transform)); 699 contentTransform.multiply(op.localMatrix); 700 contentTransform.translate(op.unmappedBounds.left, op.unmappedBounds.top); 701 702 Matrix4 inverseContentTransform; 703 inverseContentTransform.loadInverse(contentTransform); 704 705 // map the light center into layer-relative space 706 inverseContentTransform.mapPoint3d(lightCenter); 707 708 // Clip bounds of temporary layer to parent's clip rect, so: 709 Rect saveLayerBounds(layerWidth, layerHeight); 710 // 1) transform Rect(width, height) into parent's space 711 // note: left/top offsets put in contentTransform above 712 contentTransform.mapRect(saveLayerBounds); 713 // 2) intersect with parent's clip 714 saveLayerBounds.doIntersect(previous->getRenderTargetClip()); 715 // 3) and transform back 716 inverseContentTransform.mapRect(saveLayerBounds); 717 saveLayerBounds.doIntersect(Rect(layerWidth, layerHeight)); 718 saveLayerBounds.roundOut(); 719 720 // if bounds are reduced, will clip the layer's area by reducing required bounds... 721 layerWidth = saveLayerBounds.getWidth(); 722 layerHeight = saveLayerBounds.getHeight(); 723 // ...and shifting drawing content to account for left/top side clipping 724 float contentTranslateX = -saveLayerBounds.left; 725 float contentTranslateY = -saveLayerBounds.top; 726 727 saveForLayer(layerWidth, layerHeight, 728 contentTranslateX, contentTranslateY, 729 Rect(layerWidth, layerHeight), 730 lightCenter, 731 &op, nullptr); 732} 733 734void FrameBuilder::deferEndLayerOp(const EndLayerOp& /* ignored */) { 735 const BeginLayerOp& beginLayerOp = *currentLayer().beginLayerOp; 736 int finishedLayerIndex = mLayerStack.back(); 737 738 restoreForLayer(); 739 740 // record the draw operation into the previous layer's list of draw commands 741 // uses state from the associated beginLayerOp, since it has all the state needed for drawing 742 LayerOp* drawLayerOp = new (mAllocator) LayerOp( 743 beginLayerOp.unmappedBounds, 744 beginLayerOp.localMatrix, 745 beginLayerOp.localClip, 746 beginLayerOp.paint, 747 &(mLayerBuilders[finishedLayerIndex]->offscreenBuffer)); 748 BakedOpState* bakedOpState = tryBakeOpState(*drawLayerOp); 749 750 if (bakedOpState) { 751 // Layer will be drawn into parent layer (which is now current, since we popped mLayerStack) 752 currentLayer().deferUnmergeableOp(mAllocator, bakedOpState, OpBatchType::Bitmap); 753 } else { 754 // Layer won't be drawn - delete its drawing batches to prevent it from doing any work 755 // TODO: need to prevent any render work from being done 756 // - create layerop earlier for reject purposes? 757 mLayerBuilders[finishedLayerIndex]->clear(); 758 return; 759 } 760} 761 762void FrameBuilder::deferBeginUnclippedLayerOp(const BeginUnclippedLayerOp& op) { 763 Matrix4 boundsTransform(*(mCanvasState.currentSnapshot()->transform)); 764 boundsTransform.multiply(op.localMatrix); 765 766 Rect dstRect(op.unmappedBounds); 767 boundsTransform.mapRect(dstRect); 768 dstRect.doIntersect(mCanvasState.currentSnapshot()->getRenderTargetClip()); 769 770 // Allocate a holding position for the layer object (copyTo will produce, copyFrom will consume) 771 OffscreenBuffer** layerHandle = mAllocator.create<OffscreenBuffer*>(nullptr); 772 773 /** 774 * First, defer an operation to copy out the content from the rendertarget into a layer. 775 */ 776 auto copyToOp = new (mAllocator) CopyToLayerOp(op, layerHandle); 777 BakedOpState* bakedState = BakedOpState::directConstruct(mAllocator, 778 &(currentLayer().viewportClip), dstRect, *copyToOp); 779 currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::CopyToLayer); 780 781 /** 782 * Defer a clear rect, so that clears from multiple unclipped layers can be drawn 783 * both 1) simultaneously, and 2) as long after the copyToLayer executes as possible 784 */ 785 currentLayer().deferLayerClear(dstRect); 786 787 /** 788 * And stash an operation to copy that layer back under the rendertarget until 789 * a balanced EndUnclippedLayerOp is seen 790 */ 791 auto copyFromOp = new (mAllocator) CopyFromLayerOp(op, layerHandle); 792 bakedState = BakedOpState::directConstruct(mAllocator, 793 &(currentLayer().viewportClip), dstRect, *copyFromOp); 794 currentLayer().activeUnclippedSaveLayers.push_back(bakedState); 795} 796 797void FrameBuilder::deferEndUnclippedLayerOp(const EndUnclippedLayerOp& /* ignored */) { 798 LOG_ALWAYS_FATAL_IF(currentLayer().activeUnclippedSaveLayers.empty(), "no layer to end!"); 799 800 BakedOpState* copyFromLayerOp = currentLayer().activeUnclippedSaveLayers.back(); 801 currentLayer().deferUnmergeableOp(mAllocator, copyFromLayerOp, OpBatchType::CopyFromLayer); 802 currentLayer().activeUnclippedSaveLayers.pop_back(); 803} 804 805} // namespace uirenderer 806} // namespace android 807