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
31namespace android {
32namespace uirenderer {
33
34FrameBuilder::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
54FrameBuilder::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
76void 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
109void FrameBuilder::deferRenderNode(RenderNode& renderNode) {
110    renderNode.computeOrdering();
111
112    mCanvasState.save(SaveFlags::MatrixClip);
113    deferNodePropsAndOps(renderNode);
114    mCanvasState.restore();
115}
116
117void 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
128static Rect nodeBounds(RenderNode& node) {
129    auto& props = node.properties();
130    return Rect(props.getLeft(), props.getTop(),
131            props.getRight(), props.getBottom());
132}
133
134void 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
203void FrameBuilder::onViewportInitialized() {}
204
205void FrameBuilder::onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) {}
206
207void 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
308typedef key_value_pair_t<float, const RenderNodeOp*> ZRenderNodeOpPair;
309
310template <typename V>
311static 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
333template <typename V>
334static 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
341template <typename V>
342void 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
393void 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
467void 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)); },
511void 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
536void 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
551void 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 */
561BakedOpState* 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 */
582static 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
589void FrameBuilder::deferArcOp(const ArcOp& op) {
590    deferStrokeableOp(op, tessBatchId(op));
591}
592
593static bool hasMergeableClip(const BakedOpState& state) {
594    return state.computedState.clipState
595            || state.computedState.clipState->mode == ClipMode::Rectangle;
596}
597
598void 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
622void 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
628void 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
634void 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
646void 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
661void 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
667void 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
673void 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
678void FrameBuilder::deferOvalOp(const OvalOp& op) {
679    deferStrokeableOp(op, tessBatchId(op));
680}
681
682void 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
700void 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
707void 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
712void FrameBuilder::deferRectOp(const RectOp& op) {
713    deferStrokeableOp(op, tessBatchId(op));
714}
715
716void 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
725void 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
736void 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
742static 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
747void 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
777void 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
786void 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
803void 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
824void 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?
832void 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
877void 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
943void 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
984void 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
994void FrameBuilder::finishDefer() {
995    mCaches.fontRenderer.endPrecaching();
996}
997
998} // namespace uirenderer
999} // namespace android
1000