Home | History | Annotate | Download | only in hwui 
      1 /*
      2  * Copyright (C) 2016 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include "FrameBuilder.h"
     18 
     19 #include "LayerUpdateQueue.h"
     20 #include "RenderNode.h"
     21 #include "VectorDrawable.h"
     22 #include "renderstate/OffscreenBufferPool.h"
     23 #include "hwui/Canvas.h"
     24 #include "utils/FatVector.h"
     25 #include "utils/PaintUtils.h"
     26 #include "utils/TraceUtils.h"
     27 
     28 #include <SkPathOps.h>
     29 #include <utils/TypeHelpers.h>
     30 
     31 namespace android {
     32 namespace uirenderer {
     33 
     34 FrameBuilder::FrameBuilder(const SkRect& clip,
     35         uint32_t viewportWidth, uint32_t viewportHeight,
     36         const LightGeometry& lightGeometry, Caches& caches)
     37         : mStdAllocator(mAllocator)
     38         , mLayerBuilders(mStdAllocator)
     39         , mLayerStack(mStdAllocator)
     40         , mCanvasState(*this)
     41         , mCaches(caches)
     42         , mLightRadius(lightGeometry.radius)
     43         , mDrawFbo0(true) {
     44 
     45     // Prepare to defer Fbo0
     46     auto fbo0 = mAllocator.create<LayerBuilder>(viewportWidth, viewportHeight, Rect(clip));
     47     mLayerBuilders.push_back(fbo0);
     48     mLayerStack.push_back(0);
     49     mCanvasState.initializeSaveStack(viewportWidth, viewportHeight,
     50             clip.fLeft, clip.fTop, clip.fRight, clip.fBottom,
     51             lightGeometry.center);
     52 }
     53 
     54 FrameBuilder::FrameBuilder(const LayerUpdateQueue& layers,
     55         const LightGeometry& lightGeometry, Caches& caches)
     56         : mStdAllocator(mAllocator)
     57         , mLayerBuilders(mStdAllocator)
     58         , mLayerStack(mStdAllocator)
     59         , mCanvasState(*this)
     60         , mCaches(caches)
     61         , mLightRadius(lightGeometry.radius)
     62         , mDrawFbo0(false) {
     63     // TODO: remove, with each layer on its own save stack
     64 
     65     // Prepare to defer Fbo0 (which will be empty)
     66     auto fbo0 = mAllocator.create<LayerBuilder>(1, 1, Rect(1, 1));
     67     mLayerBuilders.push_back(fbo0);
     68     mLayerStack.push_back(0);
     69     mCanvasState.initializeSaveStack(1, 1,
     70             0, 0, 1, 1,
     71             lightGeometry.center);
     72 
     73     deferLayers(layers);
     74 }
     75 
     76 void FrameBuilder::deferLayers(const LayerUpdateQueue& layers) {
     77     // Render all layers to be updated, in order. Defer in reverse order, so that they'll be
     78     // updated in the order they're passed in (mLayerBuilders are issued to Renderer in reverse)
     79     for (int i = layers.entries().size() - 1; i >= 0; i--) {
     80         RenderNode* layerNode = layers.entries()[i].renderNode;
     81         // only schedule repaint if node still on layer - possible it may have been
     82         // removed during a dropped frame, but layers may still remain scheduled so
     83         // as not to lose info on what portion is damaged
     84         OffscreenBuffer* layer = layerNode->getLayer();
     85         if (CC_LIKELY(layer)) {
     86             ATRACE_FORMAT("Optimize HW Layer DisplayList %s %ux%u",
     87                     layerNode->getName(), layerNode->getWidth(), layerNode->getHeight());
     88 
     89             Rect layerDamage = layers.entries()[i].damage;
     90             // TODO: ensure layer damage can't be larger than layer
     91             layerDamage.doIntersect(0, 0, layer->viewportWidth, layer->viewportHeight);
     92             layerNode->computeOrdering();
     93 
     94             // map current light center into RenderNode's coordinate space
     95             Vector3 lightCenter = mCanvasState.currentSnapshot()->getRelativeLightCenter();
     96             layer->inverseTransformInWindow.mapPoint3d(lightCenter);
     97 
     98             saveForLayer(layerNode->getWidth(), layerNode->getHeight(), 0, 0,
     99                     layerDamage, lightCenter, nullptr, layerNode);
    100 
    101             if (layerNode->getDisplayList()) {
    102                 deferNodeOps(*layerNode);
    103             }
    104             restoreForLayer();
    105         }
    106     }
    107 }
    108 
    109 void FrameBuilder::deferRenderNode(RenderNode& renderNode) {
    110     renderNode.computeOrdering();
    111 
    112     mCanvasState.save(SaveFlags::MatrixClip);
    113     deferNodePropsAndOps(renderNode);
    114     mCanvasState.restore();
    115 }
    116 
    117 void FrameBuilder::deferRenderNode(float tx, float ty, Rect clipRect, RenderNode& renderNode) {
    118     renderNode.computeOrdering();
    119 
    120     mCanvasState.save(SaveFlags::MatrixClip);
    121     mCanvasState.translate(tx, ty);
    122     mCanvasState.clipRect(clipRect.left, clipRect.top, clipRect.right, clipRect.bottom,
    123             SkRegion::kIntersect_Op);
    124     deferNodePropsAndOps(renderNode);
    125     mCanvasState.restore();
    126 }
    127 
    128 static Rect nodeBounds(RenderNode& node) {
    129     auto& props = node.properties();
    130     return Rect(props.getLeft(), props.getTop(),
    131             props.getRight(), props.getBottom());
    132 }
    133 
    134 void FrameBuilder::deferRenderNodeScene(const std::vector< sp<RenderNode> >& nodes,
    135         const Rect& contentDrawBounds) {
    136     if (nodes.size() < 1) return;
    137     if (nodes.size() == 1) {
    138         if (!nodes[0]->nothingToDraw()) {
    139             deferRenderNode(*nodes[0]);
    140         }
    141         return;
    142     }
    143     // It there are multiple render nodes, they are laid out as follows:
    144     // #0 - backdrop (content + caption)
    145     // #1 - content (local bounds are at (0,0), will be translated and clipped to backdrop)
    146     // #2 - additional overlay nodes
    147     // Usually the backdrop cannot be seen since it will be entirely covered by the content. While
    148     // resizing however it might become partially visible. The following render loop will crop the
    149     // backdrop against the content and draw the remaining part of it. It will then draw the content
    150     // cropped to the backdrop (since that indicates a shrinking of the window).
    151     //
    152     // Additional nodes will be drawn on top with no particular clipping semantics.
    153 
    154     // Usually the contents bounds should be mContentDrawBounds - however - we will
    155     // move it towards the fixed edge to give it a more stable appearance (for the moment).
    156     // If there is no content bounds we ignore the layering as stated above and start with 2.
    157 
    158     // Backdrop bounds in render target space
    159     const Rect backdrop = nodeBounds(*nodes[0]);
    160 
    161     // Bounds that content will fill in render target space (note content node bounds may be bigger)
    162     Rect content(contentDrawBounds.getWidth(), contentDrawBounds.getHeight());
    163     content.translate(backdrop.left, backdrop.top);
    164     if (!content.contains(backdrop) && !nodes[0]->nothingToDraw()) {
    165         // Content doesn't entirely overlap backdrop, so fill around content (right/bottom)
    166 
    167         // Note: in the future, if content doesn't snap to backdrop's left/top, this may need to
    168         // also fill left/top. Currently, both 2up and freeform position content at the top/left of
    169         // the backdrop, so this isn't necessary.
    170         if (content.right < backdrop.right) {
    171             // draw backdrop to right side of content
    172             deferRenderNode(0, 0, Rect(content.right, backdrop.top,
    173                     backdrop.right, backdrop.bottom), *nodes[0]);
    174         }
    175         if (content.bottom < backdrop.bottom) {
    176             // draw backdrop to bottom of content
    177             // Note: bottom fill uses content left/right, to avoid overdrawing left/right fill
    178             deferRenderNode(0, 0, Rect(content.left, content.bottom,
    179                     content.right, backdrop.bottom), *nodes[0]);
    180         }
    181     }
    182 
    183     if (!backdrop.isEmpty()) {
    184         // content node translation to catch up with backdrop
    185         float dx = contentDrawBounds.left - backdrop.left;
    186         float dy = contentDrawBounds.top - backdrop.top;
    187 
    188         Rect contentLocalClip = backdrop;
    189         contentLocalClip.translate(dx, dy);
    190         deferRenderNode(-dx, -dy, contentLocalClip, *nodes[1]);
    191     } else {
    192         deferRenderNode(*nodes[1]);
    193     }
    194 
    195     // remaining overlay nodes, simply defer
    196     for (size_t index = 2; index < nodes.size(); index++) {
    197         if (!nodes[index]->nothingToDraw()) {
    198             deferRenderNode(*nodes[index]);
    199         }
    200     }
    201 }
    202 
    203 void FrameBuilder::onViewportInitialized() {}
    204 
    205 void FrameBuilder::onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) {}
    206 
    207 void FrameBuilder::deferNodePropsAndOps(RenderNode& node) {
    208     const RenderProperties& properties = node.properties();
    209     const Outline& outline = properties.getOutline();
    210     if (properties.getAlpha() <= 0
    211             || (outline.getShouldClip() && outline.isEmpty())
    212             || properties.getScaleX() == 0
    213             || properties.getScaleY() == 0) {
    214         return; // rejected
    215     }
    216 
    217     if (properties.getLeft() != 0 || properties.getTop() != 0) {
    218         mCanvasState.translate(properties.getLeft(), properties.getTop());
    219     }
    220     if (properties.getStaticMatrix()) {
    221         mCanvasState.concatMatrix(*properties.getStaticMatrix());
    222     } else if (properties.getAnimationMatrix()) {
    223         mCanvasState.concatMatrix(*properties.getAnimationMatrix());
    224     }
    225     if (properties.hasTransformMatrix()) {
    226         if (properties.isTransformTranslateOnly()) {
    227             mCanvasState.translate(properties.getTranslationX(), properties.getTranslationY());
    228         } else {
    229             mCanvasState.concatMatrix(*properties.getTransformMatrix());
    230         }
    231     }
    232 
    233     const int width = properties.getWidth();
    234     const int height = properties.getHeight();
    235 
    236     Rect saveLayerBounds; // will be set to non-empty if saveLayer needed
    237     const bool isLayer = properties.effectiveLayerType() != LayerType::None;
    238     int clipFlags = properties.getClippingFlags();
    239     if (properties.getAlpha() < 1) {
    240         if (isLayer) {
    241             clipFlags &= ~CLIP_TO_BOUNDS; // bounds clipping done by layer
    242         }
    243         if (CC_LIKELY(isLayer || !properties.getHasOverlappingRendering())) {
    244             // simply scale rendering content's alpha
    245             mCanvasState.scaleAlpha(properties.getAlpha());
    246         } else {
    247             // schedule saveLayer by initializing saveLayerBounds
    248             saveLayerBounds.set(0, 0, width, height);
    249             if (clipFlags) {
    250                 properties.getClippingRectForFlags(clipFlags, &saveLayerBounds);
    251                 clipFlags = 0; // all clipping done by savelayer
    252             }
    253         }
    254 
    255         if (CC_UNLIKELY(ATRACE_ENABLED() && properties.promotedToLayer())) {
    256             // pretend alpha always causes savelayer to warn about
    257             // performance problem affecting old versions
    258             ATRACE_FORMAT("%s alpha caused saveLayer %dx%d", node.getName(), width, height);
    259         }
    260     }
    261     if (clipFlags) {
    262         Rect clipRect;
    263         properties.getClippingRectForFlags(clipFlags, &clipRect);
    264         mCanvasState.clipRect(clipRect.left, clipRect.top, clipRect.right, clipRect.bottom,
    265                 SkRegion::kIntersect_Op);
    266     }
    267 
    268     if (properties.getRevealClip().willClip()) {
    269         Rect bounds;
    270         properties.getRevealClip().getBounds(&bounds);
    271         mCanvasState.setClippingRoundRect(mAllocator,
    272                 bounds, properties.getRevealClip().getRadius());
    273     } else if (properties.getOutline().willClip()) {
    274         mCanvasState.setClippingOutline(mAllocator, &(properties.getOutline()));
    275     }
    276 
    277     bool quickRejected = mCanvasState.currentSnapshot()->getRenderTargetClip().isEmpty()
    278             || (properties.getClipToBounds()
    279                     && mCanvasState.quickRejectConservative(0, 0, width, height));
    280     if (!quickRejected) {
    281         // not rejected, so defer render as either Layer, or direct (possibly wrapped in saveLayer)
    282         if (node.getLayer()) {
    283             // HW layer
    284             LayerOp* drawLayerOp = mAllocator.create_trivial<LayerOp>(node);
    285             BakedOpState* bakedOpState = tryBakeOpState(*drawLayerOp);
    286             if (bakedOpState) {
    287                 // Node's layer already deferred, schedule it to render into parent layer
    288                 currentLayer().deferUnmergeableOp(mAllocator, bakedOpState, OpBatchType::Bitmap);
    289             }
    290         } else if (CC_UNLIKELY(!saveLayerBounds.isEmpty())) {
    291             // draw DisplayList contents within temporary, since persisted layer could not be used.
    292             // (temp layers are clipped to viewport, since they don't persist offscreen content)
    293             SkPaint saveLayerPaint;
    294             saveLayerPaint.setAlpha(properties.getAlpha());
    295             deferBeginLayerOp(*mAllocator.create_trivial<BeginLayerOp>(
    296                     saveLayerBounds,
    297                     Matrix4::identity(),
    298                     nullptr, // no record-time clip - need only respect defer-time one
    299                     &saveLayerPaint));
    300             deferNodeOps(node);
    301             deferEndLayerOp(*mAllocator.create_trivial<EndLayerOp>());
    302         } else {
    303             deferNodeOps(node);
    304         }
    305     }
    306 }
    307 
    308 typedef key_value_pair_t<float, const RenderNodeOp*> ZRenderNodeOpPair;
    309 
    310 template <typename V>
    311 static void buildZSortedChildList(V* zTranslatedNodes,
    312         const DisplayList& displayList, const DisplayList::Chunk& chunk) {
    313     if (chunk.beginChildIndex == chunk.endChildIndex) return;
    314 
    315     for (size_t i = chunk.beginChildIndex; i < chunk.endChildIndex; i++) {
    316         RenderNodeOp* childOp = displayList.getChildren()[i];
    317         RenderNode* child = childOp->renderNode;
    318         float childZ = child->properties().getZ();
    319 
    320         if (!MathUtils::isZero(childZ) && chunk.reorderChildren) {
    321             zTranslatedNodes->push_back(ZRenderNodeOpPair(childZ, childOp));
    322             childOp->skipInOrderDraw = true;
    323         } else if (!child->properties().getProjectBackwards()) {
    324             // regular, in order drawing DisplayList
    325             childOp->skipInOrderDraw = false;
    326         }
    327     }
    328 
    329     // Z sort any 3d children (stable-ness makes z compare fall back to standard drawing order)
    330     std::stable_sort(zTranslatedNodes->begin(), zTranslatedNodes->end());
    331 }
    332 
    333 template <typename V>
    334 static size_t findNonNegativeIndex(const V& zTranslatedNodes) {
    335     for (size_t i = 0; i < zTranslatedNodes.size(); i++) {
    336         if (zTranslatedNodes[i].key >= 0.0f) return i;
    337     }
    338     return zTranslatedNodes.size();
    339 }
    340 
    341 template <typename V>
    342 void FrameBuilder::defer3dChildren(const ClipBase* reorderClip, ChildrenSelectMode mode,
    343         const V& zTranslatedNodes) {
    344     const int size = zTranslatedNodes.size();
    345     if (size == 0
    346             || (mode == ChildrenSelectMode::Negative&& zTranslatedNodes[0].key > 0.0f)
    347             || (mode == ChildrenSelectMode::Positive && zTranslatedNodes[size - 1].key < 0.0f)) {
    348         // no 3d children to draw
    349         return;
    350     }
    351 
    352     /**
    353      * Draw shadows and (potential) casters mostly in order, but allow the shadows of casters
    354      * with very similar Z heights to draw together.
    355      *
    356      * This way, if Views A & B have the same Z height and are both casting shadows, the shadows are
    357      * underneath both, and neither's shadow is drawn on top of the other.
    358      */
    359     const size_t nonNegativeIndex = findNonNegativeIndex(zTranslatedNodes);
    360     size_t drawIndex, shadowIndex, endIndex;
    361     if (mode == ChildrenSelectMode::Negative) {
    362         drawIndex = 0;
    363         endIndex = nonNegativeIndex;
    364         shadowIndex = endIndex; // draw no shadows
    365     } else {
    366         drawIndex = nonNegativeIndex;
    367         endIndex = size;
    368         shadowIndex = drawIndex; // potentially draw shadow for each pos Z child
    369     }
    370 
    371     float lastCasterZ = 0.0f;
    372     while (shadowIndex < endIndex || drawIndex < endIndex) {
    373         if (shadowIndex < endIndex) {
    374             const RenderNodeOp* casterNodeOp = zTranslatedNodes[shadowIndex].value;
    375             const float casterZ = zTranslatedNodes[shadowIndex].key;
    376             // attempt to render the shadow if the caster about to be drawn is its caster,
    377             // OR if its caster's Z value is similar to the previous potential caster
    378             if (shadowIndex == drawIndex || casterZ - lastCasterZ < 0.1f) {
    379                 deferShadow(reorderClip, *casterNodeOp);
    380 
    381                 lastCasterZ = casterZ; // must do this even if current caster not casting a shadow
    382                 shadowIndex++;
    383                 continue;
    384             }
    385         }
    386 
    387         const RenderNodeOp* childOp = zTranslatedNodes[drawIndex].value;
    388         deferRenderNodeOpImpl(*childOp);
    389         drawIndex++;
    390     }
    391 }
    392 
    393 void FrameBuilder::deferShadow(const ClipBase* reorderClip, const RenderNodeOp& casterNodeOp) {
    394     auto& node = *casterNodeOp.renderNode;
    395     auto& properties = node.properties();
    396 
    397     if (properties.getAlpha() <= 0.0f
    398             || properties.getOutline().getAlpha() <= 0.0f
    399             || !properties.getOutline().getPath()
    400             || properties.getScaleX() == 0
    401             || properties.getScaleY() == 0) {
    402         // no shadow to draw
    403         return;
    404     }
    405 
    406     const SkPath* casterOutlinePath = properties.getOutline().getPath();
    407     const SkPath* revealClipPath = properties.getRevealClip().getPath();
    408     if (revealClipPath && revealClipPath->isEmpty()) return;
    409 
    410     float casterAlpha = properties.getAlpha() * properties.getOutline().getAlpha();
    411 
    412     // holds temporary SkPath to store the result of intersections
    413     SkPath* frameAllocatedPath = nullptr;
    414     const SkPath* casterPath = casterOutlinePath;
    415 
    416     // intersect the shadow-casting path with the reveal, if present
    417     if (revealClipPath) {
    418         frameAllocatedPath = createFrameAllocatedPath();
    419 
    420         Op(*casterPath, *revealClipPath, kIntersect_SkPathOp, frameAllocatedPath);
    421         casterPath = frameAllocatedPath;
    422     }
    423 
    424     // intersect the shadow-casting path with the clipBounds, if present
    425     if (properties.getClippingFlags() & CLIP_TO_CLIP_BOUNDS) {
    426         if (!frameAllocatedPath) {
    427             frameAllocatedPath = createFrameAllocatedPath();
    428         }
    429         Rect clipBounds;
    430         properties.getClippingRectForFlags(CLIP_TO_CLIP_BOUNDS, &clipBounds);
    431         SkPath clipBoundsPath;
    432         clipBoundsPath.addRect(clipBounds.left, clipBounds.top,
    433                 clipBounds.right, clipBounds.bottom);
    434 
    435         Op(*casterPath, clipBoundsPath, kIntersect_SkPathOp, frameAllocatedPath);
    436         casterPath = frameAllocatedPath;
    437     }
    438 
    439     // apply reorder clip to shadow, so it respects clip at beginning of reorderable chunk
    440     int restoreTo = mCanvasState.save(SaveFlags::MatrixClip);
    441     mCanvasState.writableSnapshot()->applyClip(reorderClip,
    442             *mCanvasState.currentSnapshot()->transform);
    443     if (CC_LIKELY(!mCanvasState.getRenderTargetClipBounds().isEmpty())) {
    444         Matrix4 shadowMatrixXY(casterNodeOp.localMatrix);
    445         Matrix4 shadowMatrixZ(casterNodeOp.localMatrix);
    446         node.applyViewPropertyTransforms(shadowMatrixXY, false);
    447         node.applyViewPropertyTransforms(shadowMatrixZ, true);
    448 
    449         sp<TessellationCache::ShadowTask> task = mCaches.tessellationCache.getShadowTask(
    450                 mCanvasState.currentTransform(),
    451                 mCanvasState.getLocalClipBounds(),
    452                 casterAlpha >= 1.0f,
    453                 casterPath,
    454                 &shadowMatrixXY, &shadowMatrixZ,
    455                 mCanvasState.currentSnapshot()->getRelativeLightCenter(),
    456                 mLightRadius);
    457         ShadowOp* shadowOp = mAllocator.create<ShadowOp>(task, casterAlpha);
    458         BakedOpState* bakedOpState = BakedOpState::tryShadowOpConstruct(
    459                 mAllocator, *mCanvasState.writableSnapshot(), shadowOp);
    460         if (CC_LIKELY(bakedOpState)) {
    461             currentLayer().deferUnmergeableOp(mAllocator, bakedOpState, OpBatchType::Shadow);
    462         }
    463     }
    464     mCanvasState.restoreToCount(restoreTo);
    465 }
    466 
    467 void FrameBuilder::deferProjectedChildren(const RenderNode& renderNode) {
    468     int count = mCanvasState.save(SaveFlags::MatrixClip);
    469     const SkPath* projectionReceiverOutline = renderNode.properties().getOutline().getPath();
    470 
    471     SkPath transformedMaskPath; // on stack, since BakedOpState makes a deep copy
    472     if (projectionReceiverOutline) {
    473         // transform the mask for this projector into render target space
    474         // TODO: consider combining both transforms by stashing transform instead of applying
    475         SkMatrix skCurrentTransform;
    476         mCanvasState.currentTransform()->copyTo(skCurrentTransform);
    477         projectionReceiverOutline->transform(
    478                 skCurrentTransform,
    479                 &transformedMaskPath);
    480         mCanvasState.setProjectionPathMask(mAllocator, &transformedMaskPath);
    481     }
    482 
    483     for (size_t i = 0; i < renderNode.mProjectedNodes.size(); i++) {
    484         RenderNodeOp* childOp = renderNode.mProjectedNodes[i];
    485         RenderNode& childNode = *childOp->renderNode;
    486 
    487         // Draw child if it has content, but ignore state in childOp - matrix already applied to
    488         // transformFromCompositingAncestor, and record-time clip is ignored when projecting
    489         if (!childNode.nothingToDraw()) {
    490             int restoreTo = mCanvasState.save(SaveFlags::MatrixClip);
    491 
    492             // Apply transform between ancestor and projected descendant
    493             mCanvasState.concatMatrix(childOp->transformFromCompositingAncestor);
    494 
    495             deferNodePropsAndOps(childNode);
    496 
    497             mCanvasState.restoreToCount(restoreTo);
    498         }
    499     }
    500     mCanvasState.restoreToCount(count);
    501 }
    502 
    503 /**
    504  * Used to define a list of lambdas referencing private FrameBuilder::onXX::defer() methods.
    505  *
    506  * This allows opIds embedded in the RecordedOps to be used for dispatching to these lambdas.
    507  * E.g. a BitmapOp op then would be dispatched to FrameBuilder::onBitmapOp(const BitmapOp&)
    508  */
    509 #define OP_RECEIVER(Type) \
    510         [](FrameBuilder& frameBuilder, const RecordedOp& op) { frameBuilder.defer##Type(static_cast<const Type&>(op)); },
    511 void FrameBuilder::deferNodeOps(const RenderNode& renderNode) {
    512     typedef void (*OpDispatcher) (FrameBuilder& frameBuilder, const RecordedOp& op);
    513     static OpDispatcher receivers[] = BUILD_DEFERRABLE_OP_LUT(OP_RECEIVER);
    514 
    515     // can't be null, since DL=null node rejection happens before deferNodePropsAndOps
    516     const DisplayList& displayList = *(renderNode.getDisplayList());
    517     for (auto& chunk : displayList.getChunks()) {
    518         FatVector<ZRenderNodeOpPair, 16> zTranslatedNodes;
    519         buildZSortedChildList(&zTranslatedNodes, displayList, chunk);
    520 
    521         defer3dChildren(chunk.reorderClip, ChildrenSelectMode::Negative, zTranslatedNodes);
    522         for (size_t opIndex = chunk.beginOpIndex; opIndex < chunk.endOpIndex; opIndex++) {
    523             const RecordedOp* op = displayList.getOps()[opIndex];
    524             receivers[op->opId](*this, *op);
    525 
    526             if (CC_UNLIKELY(!renderNode.mProjectedNodes.empty()
    527                     && displayList.projectionReceiveIndex >= 0
    528                     && static_cast<int>(opIndex) == displayList.projectionReceiveIndex)) {
    529                 deferProjectedChildren(renderNode);
    530             }
    531         }
    532         defer3dChildren(chunk.reorderClip, ChildrenSelectMode::Positive, zTranslatedNodes);
    533     }
    534 }
    535 
    536 void FrameBuilder::deferRenderNodeOpImpl(const RenderNodeOp& op) {
    537     if (op.renderNode->nothingToDraw()) return;
    538     int count = mCanvasState.save(SaveFlags::MatrixClip);
    539 
    540     // apply state from RecordedOp (clip first, since op's clip is transformed by current matrix)
    541     mCanvasState.writableSnapshot()->applyClip(op.localClip,
    542             *mCanvasState.currentSnapshot()->transform);
    543     mCanvasState.concatMatrix(op.localMatrix);
    544 
    545     // then apply state from node properties, and defer ops
    546     deferNodePropsAndOps(*op.renderNode);
    547 
    548     mCanvasState.restoreToCount(count);
    549 }
    550 
    551 void FrameBuilder::deferRenderNodeOp(const RenderNodeOp& op) {
    552     if (!op.skipInOrderDraw) {
    553         deferRenderNodeOpImpl(op);
    554     }
    555 }
    556 
    557 /**
    558  * Defers an unmergeable, strokeable op, accounting correctly
    559  * for paint's style on the bounds being computed.
    560  */
    561 BakedOpState* FrameBuilder::deferStrokeableOp(const RecordedOp& op, batchid_t batchId,
    562         BakedOpState::StrokeBehavior strokeBehavior) {
    563     // Note: here we account for stroke when baking the op
    564     BakedOpState* bakedState = BakedOpState::tryStrokeableOpConstruct(
    565             mAllocator, *mCanvasState.writableSnapshot(), op, strokeBehavior);
    566     if (!bakedState) return nullptr; // quick rejected
    567 
    568     if (op.opId == RecordedOpId::RectOp && op.paint->getStyle() != SkPaint::kStroke_Style) {
    569         bakedState->setupOpacity(op.paint);
    570     }
    571 
    572     currentLayer().deferUnmergeableOp(mAllocator, bakedState, batchId);
    573     return bakedState;
    574 }
    575 
    576 /**
    577  * Returns batch id for tessellatable shapes, based on paint. Checks to see if path effect/AA will
    578  * be used, since they trigger significantly different rendering paths.
    579  *
    580  * Note: not used for lines/points, since they don't currently support path effects.
    581  */
    582 static batchid_t tessBatchId(const RecordedOp& op) {
    583     const SkPaint& paint = *(op.paint);
    584     return paint.getPathEffect()
    585             ? OpBatchType::AlphaMaskTexture
    586             : (paint.isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices);
    587 }
    588 
    589 void FrameBuilder::deferArcOp(const ArcOp& op) {
    590     deferStrokeableOp(op, tessBatchId(op));
    591 }
    592 
    593 static bool hasMergeableClip(const BakedOpState& state) {
    594     return state.computedState.clipState
    595             || state.computedState.clipState->mode == ClipMode::Rectangle;
    596 }
    597 
    598 void FrameBuilder::deferBitmapOp(const BitmapOp& op) {
    599     BakedOpState* bakedState = tryBakeOpState(op);
    600     if (!bakedState) return; // quick rejected
    601 
    602     if (op.bitmap->isOpaque()) {
    603         bakedState->setupOpacity(op.paint);
    604     }
    605 
    606     // Don't merge non-simply transformed or neg scale ops, SET_TEXTURE doesn't handle rotation
    607     // Don't merge A8 bitmaps - the paint's color isn't compared by mergeId, or in
    608     // MergingDrawBatch::canMergeWith()
    609     if (bakedState->computedState.transform.isSimple()
    610             && bakedState->computedState.transform.positiveScale()
    611             && PaintUtils::getXfermodeDirect(op.paint) == SkXfermode::kSrcOver_Mode
    612             && op.bitmap->colorType() != kAlpha_8_SkColorType
    613             && hasMergeableClip(*bakedState)) {
    614         mergeid_t mergeId = reinterpret_cast<mergeid_t>(op.bitmap->getGenerationID());
    615         // TODO: AssetAtlas in mergeId
    616         currentLayer().deferMergeableOp(mAllocator, bakedState, OpBatchType::Bitmap, mergeId);
    617     } else {
    618         currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap);
    619     }
    620 }
    621 
    622 void FrameBuilder::deferBitmapMeshOp(const BitmapMeshOp& op) {
    623     BakedOpState* bakedState = tryBakeOpState(op);
    624     if (!bakedState) return; // quick rejected
    625     currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap);
    626 }
    627 
    628 void FrameBuilder::deferBitmapRectOp(const BitmapRectOp& op) {
    629     BakedOpState* bakedState = tryBakeOpState(op);
    630     if (!bakedState) return; // quick rejected
    631     currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap);
    632 }
    633 
    634 void FrameBuilder::deferVectorDrawableOp(const VectorDrawableOp& op) {
    635     const SkBitmap& bitmap = op.vectorDrawable->getBitmapUpdateIfDirty();
    636     SkPaint* paint = op.vectorDrawable->getPaint();
    637     const BitmapRectOp* resolvedOp = mAllocator.create_trivial<BitmapRectOp>(op.unmappedBounds,
    638             op.localMatrix,
    639             op.localClip,
    640             paint,
    641             &bitmap,
    642             Rect(bitmap.width(), bitmap.height()));
    643     deferBitmapRectOp(*resolvedOp);
    644 }
    645 
    646 void FrameBuilder::deferCirclePropsOp(const CirclePropsOp& op) {
    647     // allocate a temporary oval op (with mAllocator, so it persists until render), so the
    648     // renderer doesn't have to handle the RoundRectPropsOp type, and so state baking is simple.
    649     float x = *(op.x);
    650     float y = *(op.y);
    651     float radius = *(op.radius);
    652     Rect unmappedBounds(x - radius, y - radius, x + radius, y + radius);
    653     const OvalOp* resolvedOp = mAllocator.create_trivial<OvalOp>(
    654             unmappedBounds,
    655             op.localMatrix,
    656             op.localClip,
    657             op.paint);
    658     deferOvalOp(*resolvedOp);
    659 }
    660 
    661 void FrameBuilder::deferColorOp(const ColorOp& op) {
    662     BakedOpState* bakedState = tryBakeUnboundedOpState(op);
    663     if (!bakedState) return; // quick rejected
    664     currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Vertices);
    665 }
    666 
    667 void FrameBuilder::deferFunctorOp(const FunctorOp& op) {
    668     BakedOpState* bakedState = tryBakeUnboundedOpState(op);
    669     if (!bakedState) return; // quick rejected
    670     currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Functor);
    671 }
    672 
    673 void FrameBuilder::deferLinesOp(const LinesOp& op) {
    674     batchid_t batch = op.paint->isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices;
    675     deferStrokeableOp(op, batch, BakedOpState::StrokeBehavior::Forced);
    676 }
    677 
    678 void FrameBuilder::deferOvalOp(const OvalOp& op) {
    679     deferStrokeableOp(op, tessBatchId(op));
    680 }
    681 
    682 void FrameBuilder::deferPatchOp(const PatchOp& op) {
    683     BakedOpState* bakedState = tryBakeOpState(op);
    684     if (!bakedState) return; // quick rejected
    685 
    686     if (bakedState->computedState.transform.isPureTranslate()
    687             && PaintUtils::getXfermodeDirect(op.paint) == SkXfermode::kSrcOver_Mode
    688             && hasMergeableClip(*bakedState)) {
    689         mergeid_t mergeId = reinterpret_cast<mergeid_t>(op.bitmap->getGenerationID());
    690         // TODO: AssetAtlas in mergeId
    691 
    692         // Only use the MergedPatch batchId when merged, so Bitmap+Patch don't try to merge together
    693         currentLayer().deferMergeableOp(mAllocator, bakedState, OpBatchType::MergedPatch, mergeId);
    694     } else {
    695         // Use Bitmap batchId since Bitmap+Patch use same shader
    696         currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap);
    697     }
    698 }
    699 
    700 void FrameBuilder::deferPathOp(const PathOp& op) {
    701     auto state = deferStrokeableOp(op, OpBatchType::AlphaMaskTexture);
    702     if (CC_LIKELY(state)) {
    703         mCaches.pathCache.precache(op.path, op.paint);
    704     }
    705 }
    706 
    707 void FrameBuilder::deferPointsOp(const PointsOp& op) {
    708     batchid_t batch = op.paint->isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices;
    709     deferStrokeableOp(op, batch, BakedOpState::StrokeBehavior::Forced);
    710 }
    711 
    712 void FrameBuilder::deferRectOp(const RectOp& op) {
    713     deferStrokeableOp(op, tessBatchId(op));
    714 }
    715 
    716 void FrameBuilder::deferRoundRectOp(const RoundRectOp& op) {
    717     auto state = deferStrokeableOp(op, tessBatchId(op));
    718     if (CC_LIKELY(state && !op.paint->getPathEffect())) {
    719         // TODO: consider storing tessellation task in BakedOpState
    720         mCaches.tessellationCache.precacheRoundRect(state->computedState.transform, *(op.paint),
    721                 op.unmappedBounds.getWidth(), op.unmappedBounds.getHeight(), op.rx, op.ry);
    722     }
    723 }
    724 
    725 void FrameBuilder::deferRoundRectPropsOp(const RoundRectPropsOp& op) {
    726     // allocate a temporary round rect op (with mAllocator, so it persists until render), so the
    727     // renderer doesn't have to handle the RoundRectPropsOp type, and so state baking is simple.
    728     const RoundRectOp* resolvedOp = mAllocator.create_trivial<RoundRectOp>(
    729             Rect(*(op.left), *(op.top), *(op.right), *(op.bottom)),
    730             op.localMatrix,
    731             op.localClip,
    732             op.paint, *op.rx, *op.ry);
    733     deferRoundRectOp(*resolvedOp);
    734 }
    735 
    736 void FrameBuilder::deferSimpleRectsOp(const SimpleRectsOp& op) {
    737     BakedOpState* bakedState = tryBakeOpState(op);
    738     if (!bakedState) return; // quick rejected
    739     currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Vertices);
    740 }
    741 
    742 static batchid_t textBatchId(const SkPaint& paint) {
    743     // TODO: better handling of shader (since we won't care about color then)
    744     return paint.getColor() == SK_ColorBLACK ? OpBatchType::Text : OpBatchType::ColorText;
    745 }
    746 
    747 void FrameBuilder::deferTextOp(const TextOp& op) {
    748     BakedOpState* bakedState = BakedOpState::tryStrokeableOpConstruct(
    749             mAllocator, *mCanvasState.writableSnapshot(), op,
    750             BakedOpState::StrokeBehavior::StyleDefined);
    751     if (!bakedState) return; // quick rejected
    752 
    753     batchid_t batchId = textBatchId(*(op.paint));
    754     if (bakedState->computedState.transform.isPureTranslate()
    755             && PaintUtils::getXfermodeDirect(op.paint) == SkXfermode::kSrcOver_Mode
    756             && hasMergeableClip(*bakedState)) {
    757         mergeid_t mergeId = reinterpret_cast<mergeid_t>(op.paint->getColor());
    758         currentLayer().deferMergeableOp(mAllocator, bakedState, batchId, mergeId);
    759     } else {
    760         currentLayer().deferUnmergeableOp(mAllocator, bakedState, batchId);
    761     }
    762 
    763     FontRenderer& fontRenderer = mCaches.fontRenderer.getFontRenderer();
    764     auto& totalTransform = bakedState->computedState.transform;
    765     if (totalTransform.isPureTranslate() || totalTransform.isPerspective()) {
    766         fontRenderer.precache(op.paint, op.glyphs, op.glyphCount, SkMatrix::I());
    767     } else {
    768         // Partial transform case, see BakedOpDispatcher::renderTextOp
    769         float sx, sy;
    770         totalTransform.decomposeScale(sx, sy);
    771         fontRenderer.precache(op.paint, op.glyphs, op.glyphCount, SkMatrix::MakeScale(
    772                 roundf(std::max(1.0f, sx)),
    773                 roundf(std::max(1.0f, sy))));
    774     }
    775 }
    776 
    777 void FrameBuilder::deferTextOnPathOp(const TextOnPathOp& op) {
    778     BakedOpState* bakedState = tryBakeUnboundedOpState(op);
    779     if (!bakedState) return; // quick rejected
    780     currentLayer().deferUnmergeableOp(mAllocator, bakedState, textBatchId(*(op.paint)));
    781 
    782     mCaches.fontRenderer.getFontRenderer().precache(
    783             op.paint, op.glyphs, op.glyphCount, SkMatrix::I());
    784 }
    785 
    786 void FrameBuilder::deferTextureLayerOp(const TextureLayerOp& op) {
    787     if (CC_UNLIKELY(!op.layer->isRenderable())) return;
    788 
    789     const TextureLayerOp* textureLayerOp = &op;
    790     // Now safe to access transform (which was potentially unready at record time)
    791     if (!op.layer->getTransform().isIdentity()) {
    792         // non-identity transform present, so 'inject it' into op by copying + replacing matrix
    793         Matrix4 combinedMatrix(op.localMatrix);
    794         combinedMatrix.multiply(op.layer->getTransform());
    795         textureLayerOp = mAllocator.create<TextureLayerOp>(op, combinedMatrix);
    796     }
    797     BakedOpState* bakedState = tryBakeOpState(*textureLayerOp);
    798 
    799     if (!bakedState) return; // quick rejected
    800     currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::TextureLayer);
    801 }
    802 
    803 void FrameBuilder::saveForLayer(uint32_t layerWidth, uint32_t layerHeight,
    804         float contentTranslateX, float contentTranslateY,
    805         const Rect& repaintRect,
    806         const Vector3& lightCenter,
    807         const BeginLayerOp* beginLayerOp, RenderNode* renderNode) {
    808     mCanvasState.save(SaveFlags::MatrixClip);
    809     mCanvasState.writableSnapshot()->initializeViewport(layerWidth, layerHeight);
    810     mCanvasState.writableSnapshot()->roundRectClipState = nullptr;
    811     mCanvasState.writableSnapshot()->setRelativeLightCenter(lightCenter);
    812     mCanvasState.writableSnapshot()->transform->loadTranslate(
    813             contentTranslateX, contentTranslateY, 0);
    814     mCanvasState.writableSnapshot()->setClip(
    815             repaintRect.left, repaintRect.top, repaintRect.right, repaintRect.bottom);
    816 
    817     // create a new layer repaint, and push its index on the stack
    818     mLayerStack.push_back(mLayerBuilders.size());
    819     auto newFbo = mAllocator.create<LayerBuilder>(layerWidth, layerHeight,
    820             repaintRect, beginLayerOp, renderNode);
    821     mLayerBuilders.push_back(newFbo);
    822 }
    823 
    824 void FrameBuilder::restoreForLayer() {
    825     // restore canvas, and pop finished layer off of the stack
    826     mCanvasState.restore();
    827     mLayerStack.pop_back();
    828 }
    829 
    830 // TODO: defer time rejection (when bounds become empty) + tests
    831 // Option - just skip layers with no bounds at playback + defer?
    832 void FrameBuilder::deferBeginLayerOp(const BeginLayerOp& op) {
    833     uint32_t layerWidth = (uint32_t) op.unmappedBounds.getWidth();
    834     uint32_t layerHeight = (uint32_t) op.unmappedBounds.getHeight();
    835 
    836     auto previous = mCanvasState.currentSnapshot();
    837     Vector3 lightCenter = previous->getRelativeLightCenter();
    838 
    839     // Combine all transforms used to present saveLayer content:
    840     // parent content transform * canvas transform * bounds offset
    841     Matrix4 contentTransform(*(previous->transform));
    842     contentTransform.multiply(op.localMatrix);
    843     contentTransform.translate(op.unmappedBounds.left, op.unmappedBounds.top);
    844 
    845     Matrix4 inverseContentTransform;
    846     inverseContentTransform.loadInverse(contentTransform);
    847 
    848     // map the light center into layer-relative space
    849     inverseContentTransform.mapPoint3d(lightCenter);
    850 
    851     // Clip bounds of temporary layer to parent's clip rect, so:
    852     Rect saveLayerBounds(layerWidth, layerHeight);
    853     //     1) transform Rect(width, height) into parent's space
    854     //        note: left/top offsets put in contentTransform above
    855     contentTransform.mapRect(saveLayerBounds);
    856     //     2) intersect with parent's clip
    857     saveLayerBounds.doIntersect(previous->getRenderTargetClip());
    858     //     3) and transform back
    859     inverseContentTransform.mapRect(saveLayerBounds);
    860     saveLayerBounds.doIntersect(Rect(layerWidth, layerHeight));
    861     saveLayerBounds.roundOut();
    862 
    863     // if bounds are reduced, will clip the layer's area by reducing required bounds...
    864     layerWidth = saveLayerBounds.getWidth();
    865     layerHeight = saveLayerBounds.getHeight();
    866     // ...and shifting drawing content to account for left/top side clipping
    867     float contentTranslateX = -saveLayerBounds.left;
    868     float contentTranslateY = -saveLayerBounds.top;
    869 
    870     saveForLayer(layerWidth, layerHeight,
    871             contentTranslateX, contentTranslateY,
    872             Rect(layerWidth, layerHeight),
    873             lightCenter,
    874             &op, nullptr);
    875 }
    876 
    877 void FrameBuilder::deferEndLayerOp(const EndLayerOp& /* ignored */) {
    878     const BeginLayerOp& beginLayerOp = *currentLayer().beginLayerOp;
    879     int finishedLayerIndex = mLayerStack.back();
    880 
    881     restoreForLayer();
    882 
    883     // saveLayer will clip & translate the draw contents, so we need
    884     // to translate the drawLayer by how much the contents was translated
    885     // TODO: Unify this with beginLayerOp so we don't have to calculate this
    886     // twice
    887     uint32_t layerWidth = (uint32_t) beginLayerOp.unmappedBounds.getWidth();
    888     uint32_t layerHeight = (uint32_t) beginLayerOp.unmappedBounds.getHeight();
    889 
    890     auto previous = mCanvasState.currentSnapshot();
    891     Vector3 lightCenter = previous->getRelativeLightCenter();
    892 
    893     // Combine all transforms used to present saveLayer content:
    894     // parent content transform * canvas transform * bounds offset
    895     Matrix4 contentTransform(*(previous->transform));
    896     contentTransform.multiply(beginLayerOp.localMatrix);
    897     contentTransform.translate(beginLayerOp.unmappedBounds.left,
    898             beginLayerOp.unmappedBounds.top);
    899 
    900     Matrix4 inverseContentTransform;
    901     inverseContentTransform.loadInverse(contentTransform);
    902 
    903     // map the light center into layer-relative space
    904     inverseContentTransform.mapPoint3d(lightCenter);
    905 
    906     // Clip bounds of temporary layer to parent's clip rect, so:
    907     Rect saveLayerBounds(layerWidth, layerHeight);
    908     //     1) transform Rect(width, height) into parent's space
    909     //        note: left/top offsets put in contentTransform above
    910     contentTransform.mapRect(saveLayerBounds);
    911     //     2) intersect with parent's clip
    912     saveLayerBounds.doIntersect(previous->getRenderTargetClip());
    913     //     3) and transform back
    914     inverseContentTransform.mapRect(saveLayerBounds);
    915     saveLayerBounds.doIntersect(Rect(layerWidth, layerHeight));
    916     saveLayerBounds.roundOut();
    917 
    918     Matrix4 localMatrix(beginLayerOp.localMatrix);
    919     localMatrix.translate(saveLayerBounds.left, saveLayerBounds.top);
    920 
    921     // record the draw operation into the previous layer's list of draw commands
    922     // uses state from the associated beginLayerOp, since it has all the state needed for drawing
    923     LayerOp* drawLayerOp = mAllocator.create_trivial<LayerOp>(
    924             beginLayerOp.unmappedBounds,
    925             localMatrix,
    926             beginLayerOp.localClip,
    927             beginLayerOp.paint,
    928             &(mLayerBuilders[finishedLayerIndex]->offscreenBuffer));
    929     BakedOpState* bakedOpState = tryBakeOpState(*drawLayerOp);
    930 
    931     if (bakedOpState) {
    932         // Layer will be drawn into parent layer (which is now current, since we popped mLayerStack)
    933         currentLayer().deferUnmergeableOp(mAllocator, bakedOpState, OpBatchType::Bitmap);
    934     } else {
    935         // Layer won't be drawn - delete its drawing batches to prevent it from doing any work
    936         // TODO: need to prevent any render work from being done
    937         // - create layerop earlier for reject purposes?
    938         mLayerBuilders[finishedLayerIndex]->clear();
    939         return;
    940     }
    941 }
    942 
    943 void FrameBuilder::deferBeginUnclippedLayerOp(const BeginUnclippedLayerOp& op) {
    944     Matrix4 boundsTransform(*(mCanvasState.currentSnapshot()->transform));
    945     boundsTransform.multiply(op.localMatrix);
    946 
    947     Rect dstRect(op.unmappedBounds);
    948     boundsTransform.mapRect(dstRect);
    949     dstRect.roundOut();
    950     dstRect.doIntersect(mCanvasState.currentSnapshot()->getRenderTargetClip());
    951 
    952     if (dstRect.isEmpty()) {
    953         // Unclipped layer rejected - push a null op, so next EndUnclippedLayerOp is ignored
    954         currentLayer().activeUnclippedSaveLayers.push_back(nullptr);
    955     } else {
    956         // Allocate a holding position for the layer object (copyTo will produce, copyFrom will consume)
    957         OffscreenBuffer** layerHandle = mAllocator.create<OffscreenBuffer*>(nullptr);
    958 
    959         /**
    960          * First, defer an operation to copy out the content from the rendertarget into a layer.
    961          */
    962         auto copyToOp = mAllocator.create_trivial<CopyToLayerOp>(op, layerHandle);
    963         BakedOpState* bakedState = BakedOpState::directConstruct(mAllocator,
    964                 &(currentLayer().repaintClip), dstRect, *copyToOp);
    965         currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::CopyToLayer);
    966 
    967         /**
    968          * Defer a clear rect, so that clears from multiple unclipped layers can be drawn
    969          * both 1) simultaneously, and 2) as long after the copyToLayer executes as possible
    970          */
    971         currentLayer().deferLayerClear(dstRect);
    972 
    973         /**
    974          * And stash an operation to copy that layer back under the rendertarget until
    975          * a balanced EndUnclippedLayerOp is seen
    976          */
    977         auto copyFromOp = mAllocator.create_trivial<CopyFromLayerOp>(op, layerHandle);
    978         bakedState = BakedOpState::directConstruct(mAllocator,
    979                 &(currentLayer().repaintClip), dstRect, *copyFromOp);
    980         currentLayer().activeUnclippedSaveLayers.push_back(bakedState);
    981     }
    982 }
    983 
    984 void FrameBuilder::deferEndUnclippedLayerOp(const EndUnclippedLayerOp& /* ignored */) {
    985     LOG_ALWAYS_FATAL_IF(currentLayer().activeUnclippedSaveLayers.empty(), "no layer to end!");
    986 
    987     BakedOpState* copyFromLayerOp = currentLayer().activeUnclippedSaveLayers.back();
    988     currentLayer().activeUnclippedSaveLayers.pop_back();
    989     if (copyFromLayerOp) {
    990         currentLayer().deferUnmergeableOp(mAllocator, copyFromLayerOp, OpBatchType::CopyFromLayer);
    991     }
    992 }
    993 
    994 void FrameBuilder::finishDefer() {
    995     mCaches.fontRenderer.endPrecaching();
    996 }
    997 
    998 } // namespace uirenderer
    999 } // namespace android
   1000