RenderNode.cpp revision 945701126bedff0786f540c41c63c9af37fbbe73 
1/*
2 * Copyright (C) 2014 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#define ATRACE_TAG ATRACE_TAG_VIEW
18#define LOG_TAG "OpenGLRenderer"
19
20#include "RenderNode.h"
21
22#include <algorithm>
23#include <string>
24
25#include <SkCanvas.h>
26#include <algorithm>
27
28#include <utils/Trace.h>
29
30#include "DamageAccumulator.h"
31#include "Debug.h"
32#include "DisplayListOp.h"
33#include "DisplayListLogBuffer.h"
34#include "LayerRenderer.h"
35#include "OpenGLRenderer.h"
36#include "TreeInfo.h"
37#include "utils/MathUtils.h"
38#include "renderthread/CanvasContext.h"
39
40namespace android {
41namespace uirenderer {
42
43void RenderNode::outputLogBuffer(int fd) {
44    DisplayListLogBuffer& logBuffer = DisplayListLogBuffer::getInstance();
45    if (logBuffer.isEmpty()) {
46        return;
47    }
48
49    FILE *file = fdopen(fd, "a");
50
51    fprintf(file, "\nRecent DisplayList operations\n");
52    logBuffer.outputCommands(file);
53
54    if (Caches::hasInstance()) {
55        String8 cachesLog;
56        Caches::getInstance().dumpMemoryUsage(cachesLog);
57        fprintf(file, "\nCaches:\n%s\n", cachesLog.string());
58    } else {
59        fprintf(file, "\nNo caches instance.\n");
60    }
61
62    fflush(file);
63}
64
65void RenderNode::debugDumpLayers(const char* prefix) {
66    if (mLayer) {
67        ALOGD("%sNode %p (%s) has layer %p (fbo = %u, wasBuildLayered = %s)",
68                prefix, this, getName(), mLayer, mLayer->getFbo(),
69                mLayer->wasBuildLayered ? "true" : "false");
70    }
71    if (mDisplayListData) {
72        for (size_t i = 0; i < mDisplayListData->children().size(); i++) {
73            mDisplayListData->children()[i]->mRenderNode->debugDumpLayers(prefix);
74        }
75    }
76}
77
78RenderNode::RenderNode()
79        : mDirtyPropertyFields(0)
80        , mNeedsDisplayListDataSync(false)
81        , mDisplayListData(0)
82        , mStagingDisplayListData(0)
83        , mAnimatorManager(*this)
84        , mLayer(0)
85        , mParentCount(0) {
86}
87
88RenderNode::~RenderNode() {
89    deleteDisplayListData();
90    delete mStagingDisplayListData;
91    LayerRenderer::destroyLayerDeferred(mLayer);
92}
93
94void RenderNode::setStagingDisplayList(DisplayListData* data) {
95    mNeedsDisplayListDataSync = true;
96    delete mStagingDisplayListData;
97    mStagingDisplayListData = data;
98    if (mStagingDisplayListData) {
99        Caches::getInstance().registerFunctors(mStagingDisplayListData->functors.size());
100    }
101}
102
103/**
104 * This function is a simplified version of replay(), where we simply retrieve and log the
105 * display list. This function should remain in sync with the replay() function.
106 */
107void RenderNode::output(uint32_t level) {
108    ALOGD("%*sStart display list (%p, %s, render=%d)", (level - 1) * 2, "", this,
109            getName(), isRenderable());
110    ALOGD("%*s%s %d", level * 2, "", "Save",
111            SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag);
112
113    properties().debugOutputProperties(level);
114    int flags = DisplayListOp::kOpLogFlag_Recurse;
115    if (mDisplayListData) {
116        // TODO: consider printing the chunk boundaries here
117        for (unsigned int i = 0; i < mDisplayListData->displayListOps.size(); i++) {
118            mDisplayListData->displayListOps[i]->output(level, flags);
119        }
120    }
121
122    ALOGD("%*sDone (%p, %s)", (level - 1) * 2, "", this, getName());
123}
124
125int RenderNode::getDebugSize() {
126    int size = sizeof(RenderNode);
127    if (mStagingDisplayListData) {
128        size += mStagingDisplayListData->getUsedSize();
129    }
130    if (mDisplayListData && mDisplayListData != mStagingDisplayListData) {
131        size += mDisplayListData->getUsedSize();
132    }
133    return size;
134}
135
136void RenderNode::prepareTree(TreeInfo& info) {
137    ATRACE_CALL();
138    LOG_ALWAYS_FATAL_IF(!info.damageAccumulator, "DamageAccumulator missing");
139
140    prepareTreeImpl(info);
141}
142
143void RenderNode::addAnimator(const sp<BaseRenderNodeAnimator>& animator) {
144    mAnimatorManager.addAnimator(animator);
145}
146
147void RenderNode::damageSelf(TreeInfo& info) {
148    if (isRenderable()) {
149        if (properties().getClipDamageToBounds()) {
150            info.damageAccumulator->dirty(0, 0, properties().getWidth(), properties().getHeight());
151        } else {
152            // Hope this is big enough?
153            // TODO: Get this from the display list ops or something
154            info.damageAccumulator->dirty(INT_MIN, INT_MIN, INT_MAX, INT_MAX);
155        }
156    }
157}
158
159void RenderNode::prepareLayer(TreeInfo& info, uint32_t dirtyMask) {
160    LayerType layerType = properties().layerProperties().type();
161    if (CC_UNLIKELY(layerType == kLayerTypeRenderLayer)) {
162        // Damage applied so far needs to affect our parent, but does not require
163        // the layer to be updated. So we pop/push here to clear out the current
164        // damage and get a clean state for display list or children updates to
165        // affect, which will require the layer to be updated
166        info.damageAccumulator->popTransform();
167        info.damageAccumulator->pushTransform(this);
168        if (dirtyMask & DISPLAY_LIST) {
169            damageSelf(info);
170        }
171    }
172}
173
174void RenderNode::pushLayerUpdate(TreeInfo& info) {
175    LayerType layerType = properties().layerProperties().type();
176    // If we are not a layer OR we cannot be rendered (eg, view was detached)
177    // we need to destroy any Layers we may have had previously
178    if (CC_LIKELY(layerType != kLayerTypeRenderLayer) || CC_UNLIKELY(!isRenderable())) {
179        if (CC_UNLIKELY(mLayer)) {
180            LayerRenderer::destroyLayer(mLayer);
181            mLayer = NULL;
182        }
183        return;
184    }
185
186    bool transformUpdateNeeded = false;
187    if (!mLayer) {
188        mLayer = LayerRenderer::createRenderLayer(info.renderState, getWidth(), getHeight());
189        applyLayerPropertiesToLayer(info);
190        damageSelf(info);
191        transformUpdateNeeded = true;
192    } else if (mLayer->layer.getWidth() != getWidth() || mLayer->layer.getHeight() != getHeight()) {
193        if (!LayerRenderer::resizeLayer(mLayer, getWidth(), getHeight())) {
194            LayerRenderer::destroyLayer(mLayer);
195            mLayer = 0;
196        }
197        damageSelf(info);
198        transformUpdateNeeded = true;
199    }
200
201    SkRect dirty;
202    info.damageAccumulator->peekAtDirty(&dirty);
203
204    if (!mLayer) {
205        if (info.errorHandler) {
206            std::string msg = "Unable to create layer for ";
207            msg += getName();
208            info.errorHandler->onError(msg);
209        }
210        return;
211    }
212
213    if (transformUpdateNeeded) {
214        // update the transform in window of the layer to reset its origin wrt light source position
215        Matrix4 windowTransform;
216        info.damageAccumulator->computeCurrentTransform(&windowTransform);
217        mLayer->setWindowTransform(windowTransform);
218    }
219
220    if (dirty.intersect(0, 0, getWidth(), getHeight())) {
221        dirty.roundOut();
222        mLayer->updateDeferred(this, dirty.fLeft, dirty.fTop, dirty.fRight, dirty.fBottom);
223    }
224    // This is not inside the above if because we may have called
225    // updateDeferred on a previous prepare pass that didn't have a renderer
226    if (info.renderer && mLayer->deferredUpdateScheduled) {
227        info.renderer->pushLayerUpdate(mLayer);
228    }
229
230    if (CC_UNLIKELY(info.canvasContext)) {
231        // If canvasContext is not null that means there are prefetched layers
232        // that need to be accounted for. That might be us, so tell CanvasContext
233        // that this layer is in the tree and should not be destroyed.
234        info.canvasContext->markLayerInUse(this);
235    }
236}
237
238void RenderNode::prepareTreeImpl(TreeInfo& info) {
239    info.damageAccumulator->pushTransform(this);
240
241    if (info.mode == TreeInfo::MODE_FULL) {
242        pushStagingPropertiesChanges(info);
243    }
244    uint32_t animatorDirtyMask = 0;
245    if (CC_LIKELY(info.runAnimations)) {
246        animatorDirtyMask = mAnimatorManager.animate(info);
247    }
248    prepareLayer(info, animatorDirtyMask);
249    if (info.mode == TreeInfo::MODE_FULL) {
250        pushStagingDisplayListChanges(info);
251    }
252    prepareSubTree(info, mDisplayListData);
253    pushLayerUpdate(info);
254
255    info.damageAccumulator->popTransform();
256}
257
258void RenderNode::pushStagingPropertiesChanges(TreeInfo& info) {
259    // Push the animators first so that setupStartValueIfNecessary() is called
260    // before properties() is trampled by stagingProperties(), as they are
261    // required by some animators.
262    if (CC_LIKELY(info.runAnimations)) {
263        mAnimatorManager.pushStaging();
264    }
265    if (mDirtyPropertyFields) {
266        mDirtyPropertyFields = 0;
267        damageSelf(info);
268        info.damageAccumulator->popTransform();
269        mProperties = mStagingProperties;
270        applyLayerPropertiesToLayer(info);
271        // We could try to be clever and only re-damage if the matrix changed.
272        // However, we don't need to worry about that. The cost of over-damaging
273        // here is only going to be a single additional map rect of this node
274        // plus a rect join(). The parent's transform (and up) will only be
275        // performed once.
276        info.damageAccumulator->pushTransform(this);
277        damageSelf(info);
278    }
279}
280
281void RenderNode::applyLayerPropertiesToLayer(TreeInfo& info) {
282    if (CC_LIKELY(!mLayer)) return;
283
284    const LayerProperties& props = properties().layerProperties();
285    mLayer->setAlpha(props.alpha(), props.xferMode());
286    mLayer->setColorFilter(props.colorFilter());
287    mLayer->setBlend(props.needsBlending());
288}
289
290void RenderNode::pushStagingDisplayListChanges(TreeInfo& info) {
291    if (mNeedsDisplayListDataSync) {
292        mNeedsDisplayListDataSync = false;
293        // Make sure we inc first so that we don't fluctuate between 0 and 1,
294        // which would thrash the layer cache
295        if (mStagingDisplayListData) {
296            for (size_t i = 0; i < mStagingDisplayListData->children().size(); i++) {
297                mStagingDisplayListData->children()[i]->mRenderNode->incParentRefCount();
298            }
299        }
300        // Damage with the old display list first then the new one to catch any
301        // changes in isRenderable or, in the future, bounds
302        damageSelf(info);
303        deleteDisplayListData();
304        mDisplayListData = mStagingDisplayListData;
305        mStagingDisplayListData = NULL;
306        if (mDisplayListData) {
307            for (size_t i = 0; i < mDisplayListData->functors.size(); i++) {
308                (*mDisplayListData->functors[i])(DrawGlInfo::kModeSync, NULL);
309            }
310        }
311        damageSelf(info);
312    }
313}
314
315void RenderNode::deleteDisplayListData() {
316    if (mDisplayListData) {
317        for (size_t i = 0; i < mDisplayListData->children().size(); i++) {
318            mDisplayListData->children()[i]->mRenderNode->decParentRefCount();
319        }
320    }
321    delete mDisplayListData;
322    mDisplayListData = NULL;
323}
324
325void RenderNode::prepareSubTree(TreeInfo& info, DisplayListData* subtree) {
326    if (subtree) {
327        TextureCache& cache = Caches::getInstance().textureCache;
328        info.out.hasFunctors |= subtree->functors.size();
329        // TODO: Fix ownedBitmapResources to not require disabling prepareTextures
330        // and thus falling out of async drawing path.
331        if (subtree->ownedBitmapResources.size()) {
332            info.prepareTextures = false;
333        }
334        for (size_t i = 0; info.prepareTextures && i < subtree->bitmapResources.size(); i++) {
335            info.prepareTextures = cache.prefetchAndMarkInUse(subtree->bitmapResources[i]);
336        }
337        for (size_t i = 0; i < subtree->children().size(); i++) {
338            DrawRenderNodeOp* op = subtree->children()[i];
339            RenderNode* childNode = op->mRenderNode;
340            info.damageAccumulator->pushTransform(&op->mTransformFromParent);
341            childNode->prepareTreeImpl(info);
342            info.damageAccumulator->popTransform();
343        }
344    }
345}
346
347void RenderNode::destroyHardwareResources() {
348    if (mLayer) {
349        LayerRenderer::destroyLayer(mLayer);
350        mLayer = NULL;
351    }
352    if (mDisplayListData) {
353        for (size_t i = 0; i < mDisplayListData->children().size(); i++) {
354            mDisplayListData->children()[i]->mRenderNode->destroyHardwareResources();
355        }
356        if (mNeedsDisplayListDataSync) {
357            // Next prepare tree we are going to push a new display list, so we can
358            // drop our current one now
359            deleteDisplayListData();
360        }
361    }
362}
363
364void RenderNode::decParentRefCount() {
365    LOG_ALWAYS_FATAL_IF(!mParentCount, "already 0!");
366    mParentCount--;
367    if (!mParentCount) {
368        // If a child of ours is being attached to our parent then this will incorrectly
369        // destroy its hardware resources. However, this situation is highly unlikely
370        // and the failure is "just" that the layer is re-created, so this should
371        // be safe enough
372        destroyHardwareResources();
373    }
374}
375
376/*
377 * For property operations, we pass a savecount of 0, since the operations aren't part of the
378 * displaylist, and thus don't have to compensate for the record-time/playback-time discrepancy in
379 * base saveCount (i.e., how RestoreToCount uses saveCount + properties().getCount())
380 */
381#define PROPERTY_SAVECOUNT 0
382
383template <class T>
384void RenderNode::setViewProperties(OpenGLRenderer& renderer, T& handler) {
385#if DEBUG_DISPLAY_LIST
386    properties().debugOutputProperties(handler.level() + 1);
387#endif
388    if (properties().getLeft() != 0 || properties().getTop() != 0) {
389        renderer.translate(properties().getLeft(), properties().getTop());
390    }
391    if (properties().getStaticMatrix()) {
392        renderer.concatMatrix(*properties().getStaticMatrix());
393    } else if (properties().getAnimationMatrix()) {
394        renderer.concatMatrix(*properties().getAnimationMatrix());
395    }
396    if (properties().hasTransformMatrix()) {
397        if (properties().isTransformTranslateOnly()) {
398            renderer.translate(properties().getTranslationX(), properties().getTranslationY());
399        } else {
400            renderer.concatMatrix(*properties().getTransformMatrix());
401        }
402    }
403    const bool isLayer = properties().layerProperties().type() != kLayerTypeNone;
404    int clipFlags = properties().getClippingFlags();
405    if (properties().getAlpha() < 1) {
406        if (isLayer) {
407            clipFlags &= ~CLIP_TO_BOUNDS; // bounds clipping done by layer
408
409            renderer.setOverrideLayerAlpha(properties().getAlpha());
410        } else if (!properties().getHasOverlappingRendering()) {
411            renderer.scaleAlpha(properties().getAlpha());
412        } else {
413            Rect layerBounds(0, 0, getWidth(), getHeight());
414            int saveFlags = SkCanvas::kHasAlphaLayer_SaveFlag;
415            if (clipFlags) {
416                saveFlags |= SkCanvas::kClipToLayer_SaveFlag;
417                properties().getClippingRectForFlags(clipFlags, &layerBounds);
418                clipFlags = 0; // all clipping done by saveLayer
419            }
420
421            SaveLayerOp* op = new (handler.allocator()) SaveLayerOp(
422                    layerBounds.left, layerBounds.top, layerBounds.right, layerBounds.bottom,
423                    properties().getAlpha() * 255, saveFlags);
424            handler(op, PROPERTY_SAVECOUNT, properties().getClipToBounds());
425        }
426    }
427    if (clipFlags) {
428        Rect clipRect;
429        properties().getClippingRectForFlags(clipFlags, &clipRect);
430        ClipRectOp* op = new (handler.allocator()) ClipRectOp(
431                clipRect.left, clipRect.top, clipRect.right, clipRect.bottom,
432                SkRegion::kIntersect_Op);
433        handler(op, PROPERTY_SAVECOUNT, properties().getClipToBounds());
434    }
435
436    // TODO: support nesting round rect clips
437    if (mProperties.getRevealClip().willClip()) {
438        Rect bounds;
439        mProperties.getRevealClip().getBounds(&bounds);
440        renderer.setClippingRoundRect(handler.allocator(), bounds, mProperties.getRevealClip().getRadius());
441    } else if (mProperties.getOutline().willClip()) {
442        renderer.setClippingOutline(handler.allocator(), &(mProperties.getOutline()));
443    }
444}
445
446/**
447 * Apply property-based transformations to input matrix
448 *
449 * If true3dTransform is set to true, the transform applied to the input matrix will use true 4x4
450 * matrix computation instead of the Skia 3x3 matrix + camera hackery.
451 */
452void RenderNode::applyViewPropertyTransforms(mat4& matrix, bool true3dTransform) const {
453    if (properties().getLeft() != 0 || properties().getTop() != 0) {
454        matrix.translate(properties().getLeft(), properties().getTop());
455    }
456    if (properties().getStaticMatrix()) {
457        mat4 stat(*properties().getStaticMatrix());
458        matrix.multiply(stat);
459    } else if (properties().getAnimationMatrix()) {
460        mat4 anim(*properties().getAnimationMatrix());
461        matrix.multiply(anim);
462    }
463
464    bool applyTranslationZ = true3dTransform && !MathUtils::isZero(properties().getZ());
465    if (properties().hasTransformMatrix() || applyTranslationZ) {
466        if (properties().isTransformTranslateOnly()) {
467            matrix.translate(properties().getTranslationX(), properties().getTranslationY(),
468                    true3dTransform ? properties().getZ() : 0.0f);
469        } else {
470            if (!true3dTransform) {
471                matrix.multiply(*properties().getTransformMatrix());
472            } else {
473                mat4 true3dMat;
474                true3dMat.loadTranslate(
475                        properties().getPivotX() + properties().getTranslationX(),
476                        properties().getPivotY() + properties().getTranslationY(),
477                        properties().getZ());
478                true3dMat.rotate(properties().getRotationX(), 1, 0, 0);
479                true3dMat.rotate(properties().getRotationY(), 0, 1, 0);
480                true3dMat.rotate(properties().getRotation(), 0, 0, 1);
481                true3dMat.scale(properties().getScaleX(), properties().getScaleY(), 1);
482                true3dMat.translate(-properties().getPivotX(), -properties().getPivotY());
483
484                matrix.multiply(true3dMat);
485            }
486        }
487    }
488}
489
490/**
491 * Organizes the DisplayList hierarchy to prepare for background projection reordering.
492 *
493 * This should be called before a call to defer() or drawDisplayList()
494 *
495 * Each DisplayList that serves as a 3d root builds its list of composited children,
496 * which are flagged to not draw in the standard draw loop.
497 */
498void RenderNode::computeOrdering() {
499    ATRACE_CALL();
500    mProjectedNodes.clear();
501
502    // TODO: create temporary DDLOp and call computeOrderingImpl on top DisplayList so that
503    // transform properties are applied correctly to top level children
504    if (mDisplayListData == NULL) return;
505    for (unsigned int i = 0; i < mDisplayListData->children().size(); i++) {
506        DrawRenderNodeOp* childOp = mDisplayListData->children()[i];
507        childOp->mRenderNode->computeOrderingImpl(childOp,
508                properties().getOutline().getPath(), &mProjectedNodes, &mat4::identity());
509    }
510}
511
512void RenderNode::computeOrderingImpl(
513        DrawRenderNodeOp* opState,
514        const SkPath* outlineOfProjectionSurface,
515        Vector<DrawRenderNodeOp*>* compositedChildrenOfProjectionSurface,
516        const mat4* transformFromProjectionSurface) {
517    mProjectedNodes.clear();
518    if (mDisplayListData == NULL || mDisplayListData->isEmpty()) return;
519
520    // TODO: should avoid this calculation in most cases
521    // TODO: just calculate single matrix, down to all leaf composited elements
522    Matrix4 localTransformFromProjectionSurface(*transformFromProjectionSurface);
523    localTransformFromProjectionSurface.multiply(opState->mTransformFromParent);
524
525    if (properties().getProjectBackwards()) {
526        // composited projectee, flag for out of order draw, save matrix, and store in proj surface
527        opState->mSkipInOrderDraw = true;
528        opState->mTransformFromCompositingAncestor.load(localTransformFromProjectionSurface);
529        compositedChildrenOfProjectionSurface->add(opState);
530    } else {
531        // standard in order draw
532        opState->mSkipInOrderDraw = false;
533    }
534
535    if (mDisplayListData->children().size() > 0) {
536        const bool isProjectionReceiver = mDisplayListData->projectionReceiveIndex >= 0;
537        bool haveAppliedPropertiesToProjection = false;
538        for (unsigned int i = 0; i < mDisplayListData->children().size(); i++) {
539            DrawRenderNodeOp* childOp = mDisplayListData->children()[i];
540            RenderNode* child = childOp->mRenderNode;
541
542            const SkPath* projectionOutline = NULL;
543            Vector<DrawRenderNodeOp*>* projectionChildren = NULL;
544            const mat4* projectionTransform = NULL;
545            if (isProjectionReceiver && !child->properties().getProjectBackwards()) {
546                // if receiving projections, collect projecting descendent
547
548                // Note that if a direct descendent is projecting backwards, we pass it's
549                // grandparent projection collection, since it shouldn't project onto it's
550                // parent, where it will already be drawing.
551                projectionOutline = properties().getOutline().getPath();
552                projectionChildren = &mProjectedNodes;
553                projectionTransform = &mat4::identity();
554            } else {
555                if (!haveAppliedPropertiesToProjection) {
556                    applyViewPropertyTransforms(localTransformFromProjectionSurface);
557                    haveAppliedPropertiesToProjection = true;
558                }
559                projectionOutline = outlineOfProjectionSurface;
560                projectionChildren = compositedChildrenOfProjectionSurface;
561                projectionTransform = &localTransformFromProjectionSurface;
562            }
563            child->computeOrderingImpl(childOp,
564                    projectionOutline, projectionChildren, projectionTransform);
565        }
566    }
567}
568
569class DeferOperationHandler {
570public:
571    DeferOperationHandler(DeferStateStruct& deferStruct, int level)
572        : mDeferStruct(deferStruct), mLevel(level) {}
573    inline void operator()(DisplayListOp* operation, int saveCount, bool clipToBounds) {
574        operation->defer(mDeferStruct, saveCount, mLevel, clipToBounds);
575    }
576    inline LinearAllocator& allocator() { return *(mDeferStruct.mAllocator); }
577    inline void startMark(const char* name) {} // do nothing
578    inline void endMark() {}
579    inline int level() { return mLevel; }
580    inline int replayFlags() { return mDeferStruct.mReplayFlags; }
581    inline SkPath* allocPathForFrame() { return mDeferStruct.allocPathForFrame(); }
582
583private:
584    DeferStateStruct& mDeferStruct;
585    const int mLevel;
586};
587
588void RenderNode::defer(DeferStateStruct& deferStruct, const int level) {
589    DeferOperationHandler handler(deferStruct, level);
590    issueOperations<DeferOperationHandler>(deferStruct.mRenderer, handler);
591}
592
593class ReplayOperationHandler {
594public:
595    ReplayOperationHandler(ReplayStateStruct& replayStruct, int level)
596        : mReplayStruct(replayStruct), mLevel(level) {}
597    inline void operator()(DisplayListOp* operation, int saveCount, bool clipToBounds) {
598#if DEBUG_DISPLAY_LIST_OPS_AS_EVENTS
599        mReplayStruct.mRenderer.eventMark(operation->name());
600#endif
601        operation->replay(mReplayStruct, saveCount, mLevel, clipToBounds);
602    }
603    inline LinearAllocator& allocator() { return *(mReplayStruct.mAllocator); }
604    inline void startMark(const char* name) {
605        mReplayStruct.mRenderer.startMark(name);
606    }
607    inline void endMark() {
608        mReplayStruct.mRenderer.endMark();
609    }
610    inline int level() { return mLevel; }
611    inline int replayFlags() { return mReplayStruct.mReplayFlags; }
612    inline SkPath* allocPathForFrame() { return mReplayStruct.allocPathForFrame(); }
613
614private:
615    ReplayStateStruct& mReplayStruct;
616    const int mLevel;
617};
618
619void RenderNode::replay(ReplayStateStruct& replayStruct, const int level) {
620    ReplayOperationHandler handler(replayStruct, level);
621    issueOperations<ReplayOperationHandler>(replayStruct.mRenderer, handler);
622}
623
624void RenderNode::buildZSortedChildList(const DisplayListData::Chunk& chunk,
625        Vector<ZDrawRenderNodeOpPair>& zTranslatedNodes) {
626    if (chunk.beginChildIndex == chunk.endChildIndex) return;
627
628    for (unsigned int i = chunk.beginChildIndex; i < chunk.endChildIndex; i++) {
629        DrawRenderNodeOp* childOp = mDisplayListData->children()[i];
630        RenderNode* child = childOp->mRenderNode;
631        float childZ = child->properties().getZ();
632
633        if (!MathUtils::isZero(childZ) && chunk.reorderChildren) {
634            zTranslatedNodes.add(ZDrawRenderNodeOpPair(childZ, childOp));
635            childOp->mSkipInOrderDraw = true;
636        } else if (!child->properties().getProjectBackwards()) {
637            // regular, in order drawing DisplayList
638            childOp->mSkipInOrderDraw = false;
639        }
640    }
641
642    // Z sort any 3d children (stable-ness makes z compare fall back to standard drawing order)
643    std::stable_sort(zTranslatedNodes.begin(), zTranslatedNodes.end());
644}
645
646template <class T>
647void RenderNode::issueDrawShadowOperation(const Matrix4& transformFromParent, T& handler) {
648    if (properties().getAlpha() <= 0.0f
649            || properties().getOutline().getAlpha() <= 0.0f
650            || !properties().getOutline().getPath()) {
651        // no shadow to draw
652        return;
653    }
654
655    mat4 shadowMatrixXY(transformFromParent);
656    applyViewPropertyTransforms(shadowMatrixXY);
657
658    // Z matrix needs actual 3d transformation, so mapped z values will be correct
659    mat4 shadowMatrixZ(transformFromParent);
660    applyViewPropertyTransforms(shadowMatrixZ, true);
661
662    const SkPath* casterOutlinePath = properties().getOutline().getPath();
663    const SkPath* revealClipPath = properties().getRevealClip().getPath();
664    if (revealClipPath && revealClipPath->isEmpty()) return;
665
666    float casterAlpha = properties().getAlpha() * properties().getOutline().getAlpha();
667
668    const SkPath* outlinePath = casterOutlinePath;
669    if (revealClipPath) {
670        // if we can't simply use the caster's path directly, create a temporary one
671        SkPath* frameAllocatedPath = handler.allocPathForFrame();
672
673        // intersect the outline with the convex reveal clip
674        Op(*casterOutlinePath, *revealClipPath, kIntersect_PathOp, frameAllocatedPath);
675        outlinePath = frameAllocatedPath;
676    }
677
678    DisplayListOp* shadowOp  = new (handler.allocator()) DrawShadowOp(
679            shadowMatrixXY, shadowMatrixZ, casterAlpha, outlinePath);
680    handler(shadowOp, PROPERTY_SAVECOUNT, properties().getClipToBounds());
681}
682
683#define SHADOW_DELTA 0.1f
684
685template <class T>
686void RenderNode::issueOperationsOf3dChildren(ChildrenSelectMode mode,
687        const Matrix4& initialTransform, const Vector<ZDrawRenderNodeOpPair>& zTranslatedNodes,
688        OpenGLRenderer& renderer, T& handler) {
689    const int size = zTranslatedNodes.size();
690    if (size == 0
691            || (mode == kNegativeZChildren && zTranslatedNodes[0].key > 0.0f)
692            || (mode == kPositiveZChildren && zTranslatedNodes[size - 1].key < 0.0f)) {
693        // no 3d children to draw
694        return;
695    }
696
697    // Apply the base transform of the parent of the 3d children. This isolates
698    // 3d children of the current chunk from transformations made in previous chunks.
699    int rootRestoreTo = renderer.save(SkCanvas::kMatrix_SaveFlag);
700    renderer.setMatrix(initialTransform);
701
702    /**
703     * Draw shadows and (potential) casters mostly in order, but allow the shadows of casters
704     * with very similar Z heights to draw together.
705     *
706     * This way, if Views A & B have the same Z height and are both casting shadows, the shadows are
707     * underneath both, and neither's shadow is drawn on top of the other.
708     */
709    const size_t nonNegativeIndex = findNonNegativeIndex(zTranslatedNodes);
710    size_t drawIndex, shadowIndex, endIndex;
711    if (mode == kNegativeZChildren) {
712        drawIndex = 0;
713        endIndex = nonNegativeIndex;
714        shadowIndex = endIndex; // draw no shadows
715    } else {
716        drawIndex = nonNegativeIndex;
717        endIndex = size;
718        shadowIndex = drawIndex; // potentially draw shadow for each pos Z child
719    }
720
721    DISPLAY_LIST_LOGD("%*s%d %s 3d children:", (handler.level() + 1) * 2, "",
722            endIndex - drawIndex, mode == kNegativeZChildren ? "negative" : "positive");
723
724    float lastCasterZ = 0.0f;
725    while (shadowIndex < endIndex || drawIndex < endIndex) {
726        if (shadowIndex < endIndex) {
727            DrawRenderNodeOp* casterOp = zTranslatedNodes[shadowIndex].value;
728            RenderNode* caster = casterOp->mRenderNode;
729            const float casterZ = zTranslatedNodes[shadowIndex].key;
730            // attempt to render the shadow if the caster about to be drawn is its caster,
731            // OR if its caster's Z value is similar to the previous potential caster
732            if (shadowIndex == drawIndex || casterZ - lastCasterZ < SHADOW_DELTA) {
733                caster->issueDrawShadowOperation(casterOp->mTransformFromParent, handler);
734
735                lastCasterZ = casterZ; // must do this even if current caster not casting a shadow
736                shadowIndex++;
737                continue;
738            }
739        }
740
741        // only the actual child DL draw needs to be in save/restore,
742        // since it modifies the renderer's matrix
743        int restoreTo = renderer.save(SkCanvas::kMatrix_SaveFlag);
744
745        DrawRenderNodeOp* childOp = zTranslatedNodes[drawIndex].value;
746        RenderNode* child = childOp->mRenderNode;
747
748        renderer.concatMatrix(childOp->mTransformFromParent);
749        childOp->mSkipInOrderDraw = false; // this is horrible, I'm so sorry everyone
750        handler(childOp, renderer.getSaveCount() - 1, properties().getClipToBounds());
751        childOp->mSkipInOrderDraw = true;
752
753        renderer.restoreToCount(restoreTo);
754        drawIndex++;
755    }
756    renderer.restoreToCount(rootRestoreTo);
757}
758
759template <class T>
760void RenderNode::issueOperationsOfProjectedChildren(OpenGLRenderer& renderer, T& handler) {
761    DISPLAY_LIST_LOGD("%*s%d projected children:", (handler.level() + 1) * 2, "", mProjectedNodes.size());
762    const SkPath* projectionReceiverOutline = properties().getOutline().getPath();
763    int restoreTo = renderer.getSaveCount();
764
765    LinearAllocator& alloc = handler.allocator();
766    handler(new (alloc) SaveOp(SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag),
767            PROPERTY_SAVECOUNT, properties().getClipToBounds());
768
769    // Transform renderer to match background we're projecting onto
770    // (by offsetting canvas by translationX/Y of background rendernode, since only those are set)
771    const DisplayListOp* op =
772            (mDisplayListData->displayListOps[mDisplayListData->projectionReceiveIndex]);
773    const DrawRenderNodeOp* backgroundOp = reinterpret_cast<const DrawRenderNodeOp*>(op);
774    const RenderProperties& backgroundProps = backgroundOp->mRenderNode->properties();
775    renderer.translate(backgroundProps.getTranslationX(), backgroundProps.getTranslationY());
776
777    // If the projection reciever has an outline, we mask each of the projected rendernodes to it
778    // Either with clipRect, or special saveLayer masking
779    if (projectionReceiverOutline != NULL) {
780        const SkRect& outlineBounds = projectionReceiverOutline->getBounds();
781        if (projectionReceiverOutline->isRect(NULL)) {
782            // mask to the rect outline simply with clipRect
783            ClipRectOp* clipOp = new (alloc) ClipRectOp(
784                    outlineBounds.left(), outlineBounds.top(),
785                    outlineBounds.right(), outlineBounds.bottom(), SkRegion::kIntersect_Op);
786            handler(clipOp, PROPERTY_SAVECOUNT, properties().getClipToBounds());
787        } else {
788            // wrap the projected RenderNodes with a SaveLayer that will mask to the outline
789            SaveLayerOp* op = new (alloc) SaveLayerOp(
790                    outlineBounds.left(), outlineBounds.top(),
791                    outlineBounds.right(), outlineBounds.bottom(),
792                    255, SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag | SkCanvas::kARGB_ClipLayer_SaveFlag);
793            op->setMask(projectionReceiverOutline);
794            handler(op, PROPERTY_SAVECOUNT, properties().getClipToBounds());
795
796            /* TODO: add optimizations here to take advantage of placement/size of projected
797             * children (which may shrink saveLayer area significantly). This is dependent on
798             * passing actual drawing/dirtying bounds of projected content down to native.
799             */
800        }
801    }
802
803    // draw projected nodes
804    for (size_t i = 0; i < mProjectedNodes.size(); i++) {
805        DrawRenderNodeOp* childOp = mProjectedNodes[i];
806
807        // matrix save, concat, and restore can be done safely without allocating operations
808        int restoreTo = renderer.save(SkCanvas::kMatrix_SaveFlag);
809        renderer.concatMatrix(childOp->mTransformFromCompositingAncestor);
810        childOp->mSkipInOrderDraw = false; // this is horrible, I'm so sorry everyone
811        handler(childOp, renderer.getSaveCount() - 1, properties().getClipToBounds());
812        childOp->mSkipInOrderDraw = true;
813        renderer.restoreToCount(restoreTo);
814    }
815
816    if (projectionReceiverOutline != NULL) {
817        handler(new (alloc) RestoreToCountOp(restoreTo),
818                PROPERTY_SAVECOUNT, properties().getClipToBounds());
819    }
820}
821
822/**
823 * This function serves both defer and replay modes, and will organize the displayList's component
824 * operations for a single frame:
825 *
826 * Every 'simple' state operation that affects just the matrix and alpha (or other factors of
827 * DeferredDisplayState) may be issued directly to the renderer, but complex operations (with custom
828 * defer logic) and operations in displayListOps are issued through the 'handler' which handles the
829 * defer vs replay logic, per operation
830 */
831template <class T>
832void RenderNode::issueOperations(OpenGLRenderer& renderer, T& handler) {
833    const int level = handler.level();
834    if (mDisplayListData->isEmpty()) {
835        DISPLAY_LIST_LOGD("%*sEmpty display list (%p, %s)", level * 2, "", this, getName());
836        return;
837    }
838
839    const bool drawLayer = (mLayer && (&renderer != mLayer->renderer));
840    // If we are updating the contents of mLayer, we don't want to apply any of
841    // the RenderNode's properties to this issueOperations pass. Those will all
842    // be applied when the layer is drawn, aka when this is true.
843    const bool useViewProperties = (!mLayer || drawLayer);
844    if (useViewProperties) {
845        const Outline& outline = properties().getOutline();
846        if (properties().getAlpha() <= 0 || (outline.getShouldClip() && outline.isEmpty())) {
847            DISPLAY_LIST_LOGD("%*sRejected display list (%p, %s)", level * 2, "", this, getName());
848            return;
849        }
850    }
851
852    handler.startMark(getName());
853
854#if DEBUG_DISPLAY_LIST
855    const Rect& clipRect = renderer.getLocalClipBounds();
856    DISPLAY_LIST_LOGD("%*sStart display list (%p, %s), localClipBounds: %.0f, %.0f, %.0f, %.0f",
857            level * 2, "", this, getName(),
858            clipRect.left, clipRect.top, clipRect.right, clipRect.bottom);
859#endif
860
861    LinearAllocator& alloc = handler.allocator();
862    int restoreTo = renderer.getSaveCount();
863    handler(new (alloc) SaveOp(SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag),
864            PROPERTY_SAVECOUNT, properties().getClipToBounds());
865
866    DISPLAY_LIST_LOGD("%*sSave %d %d", (level + 1) * 2, "",
867            SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag, restoreTo);
868
869    if (useViewProperties) {
870        setViewProperties<T>(renderer, handler);
871    }
872
873    bool quickRejected = properties().getClipToBounds()
874            && renderer.quickRejectConservative(0, 0, properties().getWidth(), properties().getHeight());
875    if (!quickRejected) {
876        Matrix4 initialTransform(*(renderer.currentTransform()));
877
878        if (drawLayer) {
879            handler(new (alloc) DrawLayerOp(mLayer, 0, 0),
880                    renderer.getSaveCount() - 1, properties().getClipToBounds());
881        } else {
882            const int saveCountOffset = renderer.getSaveCount() - 1;
883            const int projectionReceiveIndex = mDisplayListData->projectionReceiveIndex;
884            DisplayListLogBuffer& logBuffer = DisplayListLogBuffer::getInstance();
885            for (size_t chunkIndex = 0; chunkIndex < mDisplayListData->getChunks().size(); chunkIndex++) {
886                const DisplayListData::Chunk& chunk = mDisplayListData->getChunks()[chunkIndex];
887
888                Vector<ZDrawRenderNodeOpPair> zTranslatedNodes;
889                buildZSortedChildList(chunk, zTranslatedNodes);
890
891                issueOperationsOf3dChildren(kNegativeZChildren,
892                        initialTransform, zTranslatedNodes, renderer, handler);
893
894
895                for (int opIndex = chunk.beginOpIndex; opIndex < chunk.endOpIndex; opIndex++) {
896                    DisplayListOp *op = mDisplayListData->displayListOps[opIndex];
897#if DEBUG_DISPLAY_LIST
898                    op->output(level + 1);
899#endif
900                    logBuffer.writeCommand(level, op->name());
901                    handler(op, saveCountOffset, properties().getClipToBounds());
902
903                    if (CC_UNLIKELY(!mProjectedNodes.isEmpty() && opIndex == projectionReceiveIndex)) {
904                        issueOperationsOfProjectedChildren(renderer, handler);
905                    }
906                }
907
908                issueOperationsOf3dChildren(kPositiveZChildren,
909                        initialTransform, zTranslatedNodes, renderer, handler);
910            }
911        }
912    }
913
914    DISPLAY_LIST_LOGD("%*sRestoreToCount %d", (level + 1) * 2, "", restoreTo);
915    handler(new (alloc) RestoreToCountOp(restoreTo),
916            PROPERTY_SAVECOUNT, properties().getClipToBounds());
917    renderer.setOverrideLayerAlpha(1.0f);
918
919    DISPLAY_LIST_LOGD("%*sDone (%p, %s)", level * 2, "", this, getName());
920    handler.endMark();
921}
922
923} /* namespace uirenderer */
924} /* namespace android */
925