FrameBuilder.cpp revision f158b49c888f722194afe5a80539a2b020c130bc 
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 "renderstate/OffscreenBufferPool.h"
22#include "utils/FatVector.h"
23#include "utils/PaintUtils.h"
24#include "utils/TraceUtils.h"
25
26#include <SkCanvas.h>
27#include <SkPathOps.h>
28#include <utils/TypeHelpers.h>
29
30namespace android {
31namespace uirenderer {
32
33FrameBuilder::FrameBuilder(const LayerUpdateQueue& layers, const SkRect& clip,
34        uint32_t viewportWidth, uint32_t viewportHeight,
35        const std::vector< sp<RenderNode> >& nodes, const Vector3& lightCenter)
36        : mCanvasState(*this) {
37    ATRACE_NAME("prepare drawing commands");
38
39    mLayerBuilders.reserve(layers.entries().size());
40    mLayerStack.reserve(layers.entries().size());
41
42    // Prepare to defer Fbo0
43    auto fbo0 = mAllocator.create<LayerBuilder>(viewportWidth, viewportHeight, Rect(clip));
44    mLayerBuilders.push_back(fbo0);
45    mLayerStack.push_back(0);
46    mCanvasState.initializeSaveStack(viewportWidth, viewportHeight,
47            clip.fLeft, clip.fTop, clip.fRight, clip.fBottom,
48            lightCenter);
49
50    // Render all layers to be updated, in order. Defer in reverse order, so that they'll be
51    // updated in the order they're passed in (mLayerBuilders are issued to Renderer in reverse)
52    for (int i = layers.entries().size() - 1; i >= 0; i--) {
53        RenderNode* layerNode = layers.entries()[i].renderNode;
54        const Rect& layerDamage = layers.entries()[i].damage;
55        layerNode->computeOrdering();
56
57        // map current light center into RenderNode's coordinate space
58        Vector3 lightCenter = mCanvasState.currentSnapshot()->getRelativeLightCenter();
59        layerNode->getLayer()->inverseTransformInWindow.mapPoint3d(lightCenter);
60
61        saveForLayer(layerNode->getWidth(), layerNode->getHeight(), 0, 0,
62                layerDamage, lightCenter, nullptr, layerNode);
63
64        if (layerNode->getDisplayList()) {
65            deferNodeOps(*layerNode);
66        }
67        restoreForLayer();
68    }
69
70    // Defer Fbo0
71    for (const sp<RenderNode>& node : nodes) {
72        if (node->nothingToDraw()) continue;
73        node->computeOrdering();
74
75        int count = mCanvasState.save(SkCanvas::kClip_SaveFlag | SkCanvas::kMatrix_SaveFlag);
76        deferNodePropsAndOps(*node);
77        mCanvasState.restoreToCount(count);
78    }
79}
80
81void FrameBuilder::onViewportInitialized() {}
82
83void FrameBuilder::onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) {}
84
85void FrameBuilder::deferNodePropsAndOps(RenderNode& node) {
86    const RenderProperties& properties = node.properties();
87    const Outline& outline = properties.getOutline();
88    if (properties.getAlpha() <= 0
89            || (outline.getShouldClip() && outline.isEmpty())
90            || properties.getScaleX() == 0
91            || properties.getScaleY() == 0) {
92        return; // rejected
93    }
94
95    if (properties.getLeft() != 0 || properties.getTop() != 0) {
96        mCanvasState.translate(properties.getLeft(), properties.getTop());
97    }
98    if (properties.getStaticMatrix()) {
99        mCanvasState.concatMatrix(*properties.getStaticMatrix());
100    } else if (properties.getAnimationMatrix()) {
101        mCanvasState.concatMatrix(*properties.getAnimationMatrix());
102    }
103    if (properties.hasTransformMatrix()) {
104        if (properties.isTransformTranslateOnly()) {
105            mCanvasState.translate(properties.getTranslationX(), properties.getTranslationY());
106        } else {
107            mCanvasState.concatMatrix(*properties.getTransformMatrix());
108        }
109    }
110
111    const int width = properties.getWidth();
112    const int height = properties.getHeight();
113
114    Rect saveLayerBounds; // will be set to non-empty if saveLayer needed
115    const bool isLayer = properties.effectiveLayerType() != LayerType::None;
116    int clipFlags = properties.getClippingFlags();
117    if (properties.getAlpha() < 1) {
118        if (isLayer) {
119            clipFlags &= ~CLIP_TO_BOUNDS; // bounds clipping done by layer
120        }
121        if (CC_LIKELY(isLayer || !properties.getHasOverlappingRendering())) {
122            // simply scale rendering content's alpha
123            mCanvasState.scaleAlpha(properties.getAlpha());
124        } else {
125            // schedule saveLayer by initializing saveLayerBounds
126            saveLayerBounds.set(0, 0, width, height);
127            if (clipFlags) {
128                properties.getClippingRectForFlags(clipFlags, &saveLayerBounds);
129                clipFlags = 0; // all clipping done by savelayer
130            }
131        }
132
133        if (CC_UNLIKELY(ATRACE_ENABLED() && properties.promotedToLayer())) {
134            // pretend alpha always causes savelayer to warn about
135            // performance problem affecting old versions
136            ATRACE_FORMAT("%s alpha caused saveLayer %dx%d", node.getName(), width, height);
137        }
138    }
139    if (clipFlags) {
140        Rect clipRect;
141        properties.getClippingRectForFlags(clipFlags, &clipRect);
142        mCanvasState.clipRect(clipRect.left, clipRect.top, clipRect.right, clipRect.bottom,
143                SkRegion::kIntersect_Op);
144    }
145
146    if (properties.getRevealClip().willClip()) {
147        Rect bounds;
148        properties.getRevealClip().getBounds(&bounds);
149        mCanvasState.setClippingRoundRect(mAllocator,
150                bounds, properties.getRevealClip().getRadius());
151    } else if (properties.getOutline().willClip()) {
152        mCanvasState.setClippingOutline(mAllocator, &(properties.getOutline()));
153    }
154
155    if (!mCanvasState.quickRejectConservative(0, 0, width, height)) {
156        // not rejected, so defer render as either Layer, or direct (possibly wrapped in saveLayer)
157        if (node.getLayer()) {
158            // HW layer
159            LayerOp* drawLayerOp = new (mAllocator) LayerOp(node);
160            BakedOpState* bakedOpState = tryBakeOpState(*drawLayerOp);
161            if (bakedOpState) {
162                // Node's layer already deferred, schedule it to render into parent layer
163                currentLayer().deferUnmergeableOp(mAllocator, bakedOpState, OpBatchType::Bitmap);
164            }
165        } else if (CC_UNLIKELY(!saveLayerBounds.isEmpty())) {
166            // draw DisplayList contents within temporary, since persisted layer could not be used.
167            // (temp layers are clipped to viewport, since they don't persist offscreen content)
168            SkPaint saveLayerPaint;
169            saveLayerPaint.setAlpha(properties.getAlpha());
170            deferBeginLayerOp(*new (mAllocator) BeginLayerOp(
171                    saveLayerBounds,
172                    Matrix4::identity(),
173                    nullptr, // no record-time clip - need only respect defer-time one
174                    &saveLayerPaint));
175            deferNodeOps(node);
176            deferEndLayerOp(*new (mAllocator) EndLayerOp());
177        } else {
178            deferNodeOps(node);
179        }
180    }
181}
182
183typedef key_value_pair_t<float, const RenderNodeOp*> ZRenderNodeOpPair;
184
185template <typename V>
186static void buildZSortedChildList(V* zTranslatedNodes,
187        const DisplayList& displayList, const DisplayList::Chunk& chunk) {
188    if (chunk.beginChildIndex == chunk.endChildIndex) return;
189
190    for (size_t i = chunk.beginChildIndex; i < chunk.endChildIndex; i++) {
191        RenderNodeOp* childOp = displayList.getChildren()[i];
192        RenderNode* child = childOp->renderNode;
193        float childZ = child->properties().getZ();
194
195        if (!MathUtils::isZero(childZ) && chunk.reorderChildren) {
196            zTranslatedNodes->push_back(ZRenderNodeOpPair(childZ, childOp));
197            childOp->skipInOrderDraw = true;
198        } else if (!child->properties().getProjectBackwards()) {
199            // regular, in order drawing DisplayList
200            childOp->skipInOrderDraw = false;
201        }
202    }
203
204    // Z sort any 3d children (stable-ness makes z compare fall back to standard drawing order)
205    std::stable_sort(zTranslatedNodes->begin(), zTranslatedNodes->end());
206}
207
208template <typename V>
209static size_t findNonNegativeIndex(const V& zTranslatedNodes) {
210    for (size_t i = 0; i < zTranslatedNodes.size(); i++) {
211        if (zTranslatedNodes[i].key >= 0.0f) return i;
212    }
213    return zTranslatedNodes.size();
214}
215
216template <typename V>
217void FrameBuilder::defer3dChildren(ChildrenSelectMode mode, const V& zTranslatedNodes) {
218    const int size = zTranslatedNodes.size();
219    if (size == 0
220            || (mode == ChildrenSelectMode::Negative&& zTranslatedNodes[0].key > 0.0f)
221            || (mode == ChildrenSelectMode::Positive && zTranslatedNodes[size - 1].key < 0.0f)) {
222        // no 3d children to draw
223        return;
224    }
225
226    /**
227     * Draw shadows and (potential) casters mostly in order, but allow the shadows of casters
228     * with very similar Z heights to draw together.
229     *
230     * This way, if Views A & B have the same Z height and are both casting shadows, the shadows are
231     * underneath both, and neither's shadow is drawn on top of the other.
232     */
233    const size_t nonNegativeIndex = findNonNegativeIndex(zTranslatedNodes);
234    size_t drawIndex, shadowIndex, endIndex;
235    if (mode == ChildrenSelectMode::Negative) {
236        drawIndex = 0;
237        endIndex = nonNegativeIndex;
238        shadowIndex = endIndex; // draw no shadows
239    } else {
240        drawIndex = nonNegativeIndex;
241        endIndex = size;
242        shadowIndex = drawIndex; // potentially draw shadow for each pos Z child
243    }
244
245    float lastCasterZ = 0.0f;
246    while (shadowIndex < endIndex || drawIndex < endIndex) {
247        if (shadowIndex < endIndex) {
248            const RenderNodeOp* casterNodeOp = zTranslatedNodes[shadowIndex].value;
249            const float casterZ = zTranslatedNodes[shadowIndex].key;
250            // attempt to render the shadow if the caster about to be drawn is its caster,
251            // OR if its caster's Z value is similar to the previous potential caster
252            if (shadowIndex == drawIndex || casterZ - lastCasterZ < 0.1f) {
253                deferShadow(*casterNodeOp);
254
255                lastCasterZ = casterZ; // must do this even if current caster not casting a shadow
256                shadowIndex++;
257                continue;
258            }
259        }
260
261        const RenderNodeOp* childOp = zTranslatedNodes[drawIndex].value;
262        deferRenderNodeOpImpl(*childOp);
263        drawIndex++;
264    }
265}
266
267void FrameBuilder::deferShadow(const RenderNodeOp& casterNodeOp) {
268    auto& node = *casterNodeOp.renderNode;
269    auto& properties = node.properties();
270
271    if (properties.getAlpha() <= 0.0f
272            || properties.getOutline().getAlpha() <= 0.0f
273            || !properties.getOutline().getPath()
274            || properties.getScaleX() == 0
275            || properties.getScaleY() == 0) {
276        // no shadow to draw
277        return;
278    }
279
280    const SkPath* casterOutlinePath = properties.getOutline().getPath();
281    const SkPath* revealClipPath = properties.getRevealClip().getPath();
282    if (revealClipPath && revealClipPath->isEmpty()) return;
283
284    float casterAlpha = properties.getAlpha() * properties.getOutline().getAlpha();
285
286    // holds temporary SkPath to store the result of intersections
287    SkPath* frameAllocatedPath = nullptr;
288    const SkPath* casterPath = casterOutlinePath;
289
290    // intersect the shadow-casting path with the reveal, if present
291    if (revealClipPath) {
292        frameAllocatedPath = createFrameAllocatedPath();
293
294        Op(*casterPath, *revealClipPath, kIntersect_SkPathOp, frameAllocatedPath);
295        casterPath = frameAllocatedPath;
296    }
297
298    // intersect the shadow-casting path with the clipBounds, if present
299    if (properties.getClippingFlags() & CLIP_TO_CLIP_BOUNDS) {
300        if (!frameAllocatedPath) {
301            frameAllocatedPath = createFrameAllocatedPath();
302        }
303        Rect clipBounds;
304        properties.getClippingRectForFlags(CLIP_TO_CLIP_BOUNDS, &clipBounds);
305        SkPath clipBoundsPath;
306        clipBoundsPath.addRect(clipBounds.left, clipBounds.top,
307                clipBounds.right, clipBounds.bottom);
308
309        Op(*casterPath, clipBoundsPath, kIntersect_SkPathOp, frameAllocatedPath);
310        casterPath = frameAllocatedPath;
311    }
312
313    ShadowOp* shadowOp = new (mAllocator) ShadowOp(casterNodeOp, casterAlpha, casterPath,
314            mCanvasState.getLocalClipBounds(),
315            mCanvasState.currentSnapshot()->getRelativeLightCenter());
316    BakedOpState* bakedOpState = BakedOpState::tryShadowOpConstruct(
317            mAllocator, *mCanvasState.writableSnapshot(), shadowOp);
318    if (CC_LIKELY(bakedOpState)) {
319        currentLayer().deferUnmergeableOp(mAllocator, bakedOpState, OpBatchType::Shadow);
320    }
321}
322
323void FrameBuilder::deferProjectedChildren(const RenderNode& renderNode) {
324    const SkPath* projectionReceiverOutline = renderNode.properties().getOutline().getPath();
325    int count = mCanvasState.save(SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag);
326
327    // can't be null, since DL=null node rejection happens before deferNodePropsAndOps
328    const DisplayList& displayList = *(renderNode.getDisplayList());
329
330    const RecordedOp* op = (displayList.getOps()[displayList.projectionReceiveIndex]);
331    const RenderNodeOp* backgroundOp = static_cast<const RenderNodeOp*>(op);
332    const RenderProperties& backgroundProps = backgroundOp->renderNode->properties();
333
334    // Transform renderer to match background we're projecting onto
335    // (by offsetting canvas by translationX/Y of background rendernode, since only those are set)
336    mCanvasState.translate(backgroundProps.getTranslationX(), backgroundProps.getTranslationY());
337
338    // If the projection receiver has an outline, we mask projected content to it
339    // (which we know, apriori, are all tessellated paths)
340    mCanvasState.setProjectionPathMask(mAllocator, projectionReceiverOutline);
341
342    // draw projected nodes
343    for (size_t i = 0; i < renderNode.mProjectedNodes.size(); i++) {
344        RenderNodeOp* childOp = renderNode.mProjectedNodes[i];
345
346        int restoreTo = mCanvasState.save(SkCanvas::kMatrix_SaveFlag);
347        mCanvasState.concatMatrix(childOp->transformFromCompositingAncestor);
348        deferRenderNodeOpImpl(*childOp);
349        mCanvasState.restoreToCount(restoreTo);
350    }
351
352    mCanvasState.restoreToCount(count);
353}
354
355/**
356 * Used to define a list of lambdas referencing private FrameBuilder::onXX::defer() methods.
357 *
358 * This allows opIds embedded in the RecordedOps to be used for dispatching to these lambdas.
359 * E.g. a BitmapOp op then would be dispatched to FrameBuilder::onBitmapOp(const BitmapOp&)
360 */
361#define OP_RECEIVER(Type) \
362        [](FrameBuilder& frameBuilder, const RecordedOp& op) { frameBuilder.defer##Type(static_cast<const Type&>(op)); },
363void FrameBuilder::deferNodeOps(const RenderNode& renderNode) {
364    typedef void (*OpDispatcher) (FrameBuilder& frameBuilder, const RecordedOp& op);
365    static OpDispatcher receivers[] = BUILD_DEFERRABLE_OP_LUT(OP_RECEIVER);
366
367    // can't be null, since DL=null node rejection happens before deferNodePropsAndOps
368    const DisplayList& displayList = *(renderNode.getDisplayList());
369    for (const DisplayList::Chunk& chunk : displayList.getChunks()) {
370        FatVector<ZRenderNodeOpPair, 16> zTranslatedNodes;
371        buildZSortedChildList(&zTranslatedNodes, displayList, chunk);
372
373        defer3dChildren(ChildrenSelectMode::Negative, zTranslatedNodes);
374        for (size_t opIndex = chunk.beginOpIndex; opIndex < chunk.endOpIndex; opIndex++) {
375            const RecordedOp* op = displayList.getOps()[opIndex];
376            receivers[op->opId](*this, *op);
377
378            if (CC_UNLIKELY(!renderNode.mProjectedNodes.empty()
379                    && displayList.projectionReceiveIndex >= 0
380                    && static_cast<int>(opIndex) == displayList.projectionReceiveIndex)) {
381                deferProjectedChildren(renderNode);
382            }
383        }
384        defer3dChildren(ChildrenSelectMode::Positive, zTranslatedNodes);
385    }
386}
387
388void FrameBuilder::deferRenderNodeOpImpl(const RenderNodeOp& op) {
389    if (op.renderNode->nothingToDraw()) return;
390    int count = mCanvasState.save(SkCanvas::kClip_SaveFlag | SkCanvas::kMatrix_SaveFlag);
391
392    // apply state from RecordedOp (clip first, since op's clip is transformed by current matrix)
393    mCanvasState.writableSnapshot()->mutateClipArea().applyClip(op.localClip,
394            *mCanvasState.currentSnapshot()->transform);
395    mCanvasState.concatMatrix(op.localMatrix);
396
397    // then apply state from node properties, and defer ops
398    deferNodePropsAndOps(*op.renderNode);
399
400    mCanvasState.restoreToCount(count);
401}
402
403void FrameBuilder::deferRenderNodeOp(const RenderNodeOp& op) {
404    if (!op.skipInOrderDraw) {
405        deferRenderNodeOpImpl(op);
406    }
407}
408
409/**
410 * Defers an unmergeable, strokeable op, accounting correctly
411 * for paint's style on the bounds being computed.
412 */
413void FrameBuilder::deferStrokeableOp(const RecordedOp& op, batchid_t batchId,
414        BakedOpState::StrokeBehavior strokeBehavior) {
415    // Note: here we account for stroke when baking the op
416    BakedOpState* bakedState = BakedOpState::tryStrokeableOpConstruct(
417            mAllocator, *mCanvasState.writableSnapshot(), op, strokeBehavior);
418    if (!bakedState) return; // quick rejected
419    currentLayer().deferUnmergeableOp(mAllocator, bakedState, batchId);
420}
421
422/**
423 * Returns batch id for tessellatable shapes, based on paint. Checks to see if path effect/AA will
424 * be used, since they trigger significantly different rendering paths.
425 *
426 * Note: not used for lines/points, since they don't currently support path effects.
427 */
428static batchid_t tessBatchId(const RecordedOp& op) {
429    const SkPaint& paint = *(op.paint);
430    return paint.getPathEffect()
431            ? OpBatchType::AlphaMaskTexture
432            : (paint.isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices);
433}
434
435void FrameBuilder::deferArcOp(const ArcOp& op) {
436    deferStrokeableOp(op, tessBatchId(op));
437}
438
439static bool hasMergeableClip(const BakedOpState& state) {
440    return state.computedState.clipState
441            || state.computedState.clipState->mode == ClipMode::Rectangle;
442}
443
444void FrameBuilder::deferBitmapOp(const BitmapOp& op) {
445    BakedOpState* bakedState = tryBakeOpState(op);
446    if (!bakedState) return; // quick rejected
447
448    // Don't merge non-simply transformed or neg scale ops, SET_TEXTURE doesn't handle rotation
449    // Don't merge A8 bitmaps - the paint's color isn't compared by mergeId, or in
450    // MergingDrawBatch::canMergeWith()
451    if (bakedState->computedState.transform.isSimple()
452            && bakedState->computedState.transform.positiveScale()
453            && PaintUtils::getXfermodeDirect(op.paint) == SkXfermode::kSrcOver_Mode
454            && op.bitmap->colorType() != kAlpha_8_SkColorType
455            && hasMergeableClip(*bakedState)) {
456        mergeid_t mergeId = reinterpret_cast<mergeid_t>(op.bitmap->getGenerationID());
457        // TODO: AssetAtlas in mergeId
458        currentLayer().deferMergeableOp(mAllocator, bakedState, OpBatchType::Bitmap, mergeId);
459    } else {
460        currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap);
461    }
462}
463
464void FrameBuilder::deferBitmapMeshOp(const BitmapMeshOp& op) {
465    BakedOpState* bakedState = tryBakeOpState(op);
466    if (!bakedState) return; // quick rejected
467    currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap);
468}
469
470void FrameBuilder::deferBitmapRectOp(const BitmapRectOp& op) {
471    BakedOpState* bakedState = tryBakeOpState(op);
472    if (!bakedState) return; // quick rejected
473    currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap);
474}
475
476void FrameBuilder::deferCirclePropsOp(const CirclePropsOp& op) {
477    // allocate a temporary oval op (with mAllocator, so it persists until render), so the
478    // renderer doesn't have to handle the RoundRectPropsOp type, and so state baking is simple.
479    float x = *(op.x);
480    float y = *(op.y);
481    float radius = *(op.radius);
482    Rect unmappedBounds(x - radius, y - radius, x + radius, y + radius);
483    const OvalOp* resolvedOp = new (mAllocator) OvalOp(
484            unmappedBounds,
485            op.localMatrix,
486            op.localClip,
487            op.paint);
488    deferOvalOp(*resolvedOp);
489}
490
491void FrameBuilder::deferFunctorOp(const FunctorOp& op) {
492    BakedOpState* bakedState = tryBakeOpState(op);
493    if (!bakedState) return; // quick rejected
494    currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Functor);
495}
496
497void FrameBuilder::deferLinesOp(const LinesOp& op) {
498    batchid_t batch = op.paint->isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices;
499    deferStrokeableOp(op, batch, BakedOpState::StrokeBehavior::Forced);
500}
501
502void FrameBuilder::deferOvalOp(const OvalOp& op) {
503    deferStrokeableOp(op, tessBatchId(op));
504}
505
506void FrameBuilder::deferPatchOp(const PatchOp& op) {
507    BakedOpState* bakedState = tryBakeOpState(op);
508    if (!bakedState) return; // quick rejected
509
510    if (bakedState->computedState.transform.isPureTranslate()
511            && PaintUtils::getXfermodeDirect(op.paint) == SkXfermode::kSrcOver_Mode
512            && hasMergeableClip(*bakedState)) {
513        mergeid_t mergeId = reinterpret_cast<mergeid_t>(op.bitmap->getGenerationID());
514        // TODO: AssetAtlas in mergeId
515
516        // Only use the MergedPatch batchId when merged, so Bitmap+Patch don't try to merge together
517        currentLayer().deferMergeableOp(mAllocator, bakedState, OpBatchType::MergedPatch, mergeId);
518    } else {
519        // Use Bitmap batchId since Bitmap+Patch use same shader
520        currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap);
521    }
522}
523
524void FrameBuilder::deferPathOp(const PathOp& op) {
525    deferStrokeableOp(op, OpBatchType::Bitmap);
526}
527
528void FrameBuilder::deferPointsOp(const PointsOp& op) {
529    batchid_t batch = op.paint->isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices;
530    deferStrokeableOp(op, batch, BakedOpState::StrokeBehavior::Forced);
531}
532
533void FrameBuilder::deferRectOp(const RectOp& op) {
534    deferStrokeableOp(op, tessBatchId(op));
535}
536
537void FrameBuilder::deferRoundRectOp(const RoundRectOp& op) {
538    deferStrokeableOp(op, tessBatchId(op));
539}
540
541void FrameBuilder::deferRoundRectPropsOp(const RoundRectPropsOp& op) {
542    // allocate a temporary round rect op (with mAllocator, so it persists until render), so the
543    // renderer doesn't have to handle the RoundRectPropsOp type, and so state baking is simple.
544    const RoundRectOp* resolvedOp = new (mAllocator) RoundRectOp(
545            Rect(*(op.left), *(op.top), *(op.right), *(op.bottom)),
546            op.localMatrix,
547            op.localClip,
548            op.paint, *op.rx, *op.ry);
549    deferRoundRectOp(*resolvedOp);
550}
551
552void FrameBuilder::deferSimpleRectsOp(const SimpleRectsOp& op) {
553    BakedOpState* bakedState = tryBakeOpState(op);
554    if (!bakedState) return; // quick rejected
555    currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Vertices);
556}
557
558static batchid_t textBatchId(const SkPaint& paint) {
559    // TODO: better handling of shader (since we won't care about color then)
560    return paint.getColor() == SK_ColorBLACK ? OpBatchType::Text : OpBatchType::ColorText;
561}
562
563void FrameBuilder::deferTextOp(const TextOp& op) {
564    BakedOpState* bakedState = tryBakeOpState(op);
565    if (!bakedState) return; // quick rejected
566
567    batchid_t batchId = textBatchId(*(op.paint));
568    if (bakedState->computedState.transform.isPureTranslate()
569            && PaintUtils::getXfermodeDirect(op.paint) == SkXfermode::kSrcOver_Mode
570            && hasMergeableClip(*bakedState)) {
571        mergeid_t mergeId = reinterpret_cast<mergeid_t>(op.paint->getColor());
572        currentLayer().deferMergeableOp(mAllocator, bakedState, batchId, mergeId);
573    } else {
574        currentLayer().deferUnmergeableOp(mAllocator, bakedState, batchId);
575    }
576}
577
578void FrameBuilder::deferTextOnPathOp(const TextOnPathOp& op) {
579    BakedOpState* bakedState = tryBakeOpState(op);
580    if (!bakedState) return; // quick rejected
581    currentLayer().deferUnmergeableOp(mAllocator, bakedState, textBatchId(*(op.paint)));
582}
583
584void FrameBuilder::deferTextureLayerOp(const TextureLayerOp& op) {
585    BakedOpState* bakedState = tryBakeOpState(op);
586    if (!bakedState) return; // quick rejected
587    currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::TextureLayer);
588}
589
590void FrameBuilder::saveForLayer(uint32_t layerWidth, uint32_t layerHeight,
591        float contentTranslateX, float contentTranslateY,
592        const Rect& repaintRect,
593        const Vector3& lightCenter,
594        const BeginLayerOp* beginLayerOp, RenderNode* renderNode) {
595    mCanvasState.save(SkCanvas::kClip_SaveFlag | SkCanvas::kMatrix_SaveFlag);
596    mCanvasState.writableSnapshot()->initializeViewport(layerWidth, layerHeight);
597    mCanvasState.writableSnapshot()->roundRectClipState = nullptr;
598    mCanvasState.writableSnapshot()->setRelativeLightCenter(lightCenter);
599    mCanvasState.writableSnapshot()->transform->loadTranslate(
600            contentTranslateX, contentTranslateY, 0);
601    mCanvasState.writableSnapshot()->setClip(
602            repaintRect.left, repaintRect.top, repaintRect.right, repaintRect.bottom);
603
604    // create a new layer repaint, and push its index on the stack
605    mLayerStack.push_back(mLayerBuilders.size());
606    auto newFbo = mAllocator.create<LayerBuilder>(layerWidth, layerHeight,
607            repaintRect, beginLayerOp, renderNode);
608    mLayerBuilders.push_back(newFbo);
609}
610
611void FrameBuilder::restoreForLayer() {
612    // restore canvas, and pop finished layer off of the stack
613    mCanvasState.restore();
614    mLayerStack.pop_back();
615}
616
617// TODO: defer time rejection (when bounds become empty) + tests
618// Option - just skip layers with no bounds at playback + defer?
619void FrameBuilder::deferBeginLayerOp(const BeginLayerOp& op) {
620    uint32_t layerWidth = (uint32_t) op.unmappedBounds.getWidth();
621    uint32_t layerHeight = (uint32_t) op.unmappedBounds.getHeight();
622
623    auto previous = mCanvasState.currentSnapshot();
624    Vector3 lightCenter = previous->getRelativeLightCenter();
625
626    // Combine all transforms used to present saveLayer content:
627    // parent content transform * canvas transform * bounds offset
628    Matrix4 contentTransform(*(previous->transform));
629    contentTransform.multiply(op.localMatrix);
630    contentTransform.translate(op.unmappedBounds.left, op.unmappedBounds.top);
631
632    Matrix4 inverseContentTransform;
633    inverseContentTransform.loadInverse(contentTransform);
634
635    // map the light center into layer-relative space
636    inverseContentTransform.mapPoint3d(lightCenter);
637
638    // Clip bounds of temporary layer to parent's clip rect, so:
639    Rect saveLayerBounds(layerWidth, layerHeight);
640    //     1) transform Rect(width, height) into parent's space
641    //        note: left/top offsets put in contentTransform above
642    contentTransform.mapRect(saveLayerBounds);
643    //     2) intersect with parent's clip
644    saveLayerBounds.doIntersect(previous->getRenderTargetClip());
645    //     3) and transform back
646    inverseContentTransform.mapRect(saveLayerBounds);
647    saveLayerBounds.doIntersect(Rect(layerWidth, layerHeight));
648    saveLayerBounds.roundOut();
649
650    // if bounds are reduced, will clip the layer's area by reducing required bounds...
651    layerWidth = saveLayerBounds.getWidth();
652    layerHeight = saveLayerBounds.getHeight();
653    // ...and shifting drawing content to account for left/top side clipping
654    float contentTranslateX = -saveLayerBounds.left;
655    float contentTranslateY = -saveLayerBounds.top;
656
657    saveForLayer(layerWidth, layerHeight,
658            contentTranslateX, contentTranslateY,
659            Rect(layerWidth, layerHeight),
660            lightCenter,
661            &op, nullptr);
662}
663
664void FrameBuilder::deferEndLayerOp(const EndLayerOp& /* ignored */) {
665    const BeginLayerOp& beginLayerOp = *currentLayer().beginLayerOp;
666    int finishedLayerIndex = mLayerStack.back();
667
668    restoreForLayer();
669
670    // record the draw operation into the previous layer's list of draw commands
671    // uses state from the associated beginLayerOp, since it has all the state needed for drawing
672    LayerOp* drawLayerOp = new (mAllocator) LayerOp(
673            beginLayerOp.unmappedBounds,
674            beginLayerOp.localMatrix,
675            beginLayerOp.localClip,
676            beginLayerOp.paint,
677            &(mLayerBuilders[finishedLayerIndex]->offscreenBuffer));
678    BakedOpState* bakedOpState = tryBakeOpState(*drawLayerOp);
679
680    if (bakedOpState) {
681        // Layer will be drawn into parent layer (which is now current, since we popped mLayerStack)
682        currentLayer().deferUnmergeableOp(mAllocator, bakedOpState, OpBatchType::Bitmap);
683    } else {
684        // Layer won't be drawn - delete its drawing batches to prevent it from doing any work
685        // TODO: need to prevent any render work from being done
686        // - create layerop earlier for reject purposes?
687        mLayerBuilders[finishedLayerIndex]->clear();
688        return;
689    }
690}
691
692void FrameBuilder::deferBeginUnclippedLayerOp(const BeginUnclippedLayerOp& op) {
693    Matrix4 boundsTransform(*(mCanvasState.currentSnapshot()->transform));
694    boundsTransform.multiply(op.localMatrix);
695
696    Rect dstRect(op.unmappedBounds);
697    boundsTransform.mapRect(dstRect);
698    dstRect.doIntersect(mCanvasState.currentSnapshot()->getRenderTargetClip());
699
700    // Allocate a holding position for the layer object (copyTo will produce, copyFrom will consume)
701    OffscreenBuffer** layerHandle = mAllocator.create<OffscreenBuffer*>(nullptr);
702
703    /**
704     * First, defer an operation to copy out the content from the rendertarget into a layer.
705     */
706    auto copyToOp = new (mAllocator) CopyToLayerOp(op, layerHandle);
707    BakedOpState* bakedState = BakedOpState::directConstruct(mAllocator,
708            &(currentLayer().viewportClip), dstRect, *copyToOp);
709    currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::CopyToLayer);
710
711    /**
712     * Defer a clear rect, so that clears from multiple unclipped layers can be drawn
713     * both 1) simultaneously, and 2) as long after the copyToLayer executes as possible
714     */
715    currentLayer().deferLayerClear(dstRect);
716
717    /**
718     * And stash an operation to copy that layer back under the rendertarget until
719     * a balanced EndUnclippedLayerOp is seen
720     */
721    auto copyFromOp = new (mAllocator) CopyFromLayerOp(op, layerHandle);
722    bakedState = BakedOpState::directConstruct(mAllocator,
723            &(currentLayer().viewportClip), dstRect, *copyFromOp);
724    currentLayer().activeUnclippedSaveLayers.push_back(bakedState);
725}
726
727void FrameBuilder::deferEndUnclippedLayerOp(const EndUnclippedLayerOp& /* ignored */) {
728    LOG_ALWAYS_FATAL_IF(currentLayer().activeUnclippedSaveLayers.empty(), "no layer to end!");
729
730    BakedOpState* copyFromLayerOp = currentLayer().activeUnclippedSaveLayers.back();
731    currentLayer().deferUnmergeableOp(mAllocator, copyFromLayerOp, OpBatchType::CopyFromLayer);
732    currentLayer().activeUnclippedSaveLayers.pop_back();
733}
734
735} // namespace uirenderer
736} // namespace android
737