Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e2e53a70 authored by Chris Craik's avatar Chris Craik
Browse files

Simplify TreeInfo 

Change-Id: I8f05e9046236d607016b6c2bb77a333cfb47ba47
parent 37028137

libs/hwui/RenderNode.cpp

+8 −8
Original line number Diff line number Diff line
@@ -250,7 +250,8 @@ void RenderNode::pushLayerUpdate(TreeInfo& info) { 


    bool transformUpdateNeeded = false;

    if (!mLayer) {

        mLayer = LayerRenderer::createRenderLayer(info.renderState, getWidth(), getHeight());

        mLayer = LayerRenderer::createRenderLayer(

                info.canvasContext.getRenderState(), getWidth(), getHeight());

        applyLayerPropertiesToLayer(info);

        damageSelf(info);

        transformUpdateNeeded = true;
@@ -293,12 +294,10 @@ void RenderNode::pushLayerUpdate(TreeInfo& info) { 
        info.renderer->pushLayerUpdate(mLayer);

    }



    if (info.canvasContext) {

    // There might be prefetched layers that need to be accounted for.

    // That might be us, so tell CanvasContext that this layer is in the

    // tree and should not be destroyed.

        info.canvasContext->markLayerInUse(this);

    }

    info.canvasContext.markLayerInUse(this);

}



/**
@@ -419,7 +418,8 @@ void RenderNode::prepareSubTree(TreeInfo& info, bool functorsNeedLayer, DisplayL 
        TextureCache& cache = Caches::getInstance().textureCache;

        info.out.hasFunctors |= subtree->getFunctors().size();

        for (auto&& bitmapResource : subtree->getBitmapResources()) {

            info.prepareTextures = cache.prefetchAndMarkInUse(info.canvasContext, bitmapResource);

            void* ownerToken = &info.canvasContext;

            info.prepareTextures = cache.prefetchAndMarkInUse(ownerToken, bitmapResource);

        }

        for (auto&& op : subtree->getChildren()) {

            RenderNode* childNode = op->renderNode;

libs/hwui/TreeInfo.h

+13 −37
Original line number Diff line number Diff line
@@ -55,70 +55,46 @@ public: 
        MODE_RT_ONLY,

    };



    explicit TreeInfo(TraversalMode mode, RenderState& renderState)

    TreeInfo(TraversalMode mode, renderthread::CanvasContext& canvasContext)

            : mode(mode)

            , prepareTextures(mode == MODE_FULL)

        , runAnimations(true)

        , damageAccumulator(nullptr)

        , renderState(renderState)

        , renderer(nullptr)

        , errorHandler(nullptr)

        , canvasContext(nullptr)

    {}



    explicit TreeInfo(TraversalMode mode, const TreeInfo& clone)

        : mode(mode)

        , prepareTextures(mode == MODE_FULL)

        , runAnimations(clone.runAnimations)

        , damageAccumulator(clone.damageAccumulator)

        , renderState(clone.renderState)

        , renderer(clone.renderer)

        , errorHandler(clone.errorHandler)

        , canvasContext(clone.canvasContext)

            , canvasContext(canvasContext)

    {}



    TraversalMode mode;

    // TODO: Remove this? Currently this is used to signal to stop preparing

    // textures if we run out of cache space.

    bool prepareTextures;

    renderthread::CanvasContext& canvasContext;

    // TODO: buildLayer uses this to suppress running any animations, but this

    // should probably be refactored somehow. The reason this is done is

    // because buildLayer is not setup for injecting the animationHook, as well

    // as this being otherwise wasted work as all the animators will be

    // re-evaluated when the frame is actually drawn

    bool runAnimations;

    bool runAnimations = true;



    // Must not be null during actual usage

    DamageAccumulator* damageAccumulator;

    RenderState& renderState;

    DamageAccumulator* damageAccumulator = nullptr;

    // The renderer that will be drawing the next frame. Use this to push any

    // layer updates or similar. May be NULL.

    OpenGLRenderer* renderer;

    ErrorHandler* errorHandler;

    // May be NULL (TODO: can it really?)

    renderthread::CanvasContext* canvasContext;

    OpenGLRenderer* renderer = nullptr;

    ErrorHandler* errorHandler = nullptr;



    struct Out {

        Out()

            : hasFunctors(false)

            , hasAnimations(false)

            , requiresUiRedraw(false)

            , canDrawThisFrame(true)

        {}

        bool hasFunctors;

        bool hasFunctors = false;

        // This is only updated if evaluateAnimations is true

        bool hasAnimations;

        bool hasAnimations = false;

        // This is set to true if there is an animation that RenderThread cannot

        // animate itself, such as if hasFunctors is true

        // This is only set if hasAnimations is true

        bool requiresUiRedraw;

        bool requiresUiRedraw = false;

        // This is set to true if draw() can be called this frame

        // false means that we must delay until the next vsync pulse as frame

        // production is outrunning consumption

        // NOTE that if this is false CanvasContext will set either requiresUiRedraw

        // *OR* will post itself for the next vsync automatically, use this

        // only to avoid calling draw()

        bool canDrawThisFrame;

        bool canDrawThisFrame = true;

    } out;



    // TODO: Damage calculations

libs/hwui/renderthread/CanvasContext.cpp

+2 −3
Original line number Diff line number Diff line
@@ -197,7 +197,6 @@ void CanvasContext::prepareTree(TreeInfo& info, int64_t* uiFrameInfo, 


    info.damageAccumulator = &mDamageAccumulator;

    info.renderer = mCanvas;

    info.canvasContext = this;



    mAnimationContext->startFrame(info.mode);

    for (const sp<RenderNode>& node : mRenderNodes) {
@@ -487,7 +486,7 @@ void CanvasContext::prepareAndDraw(RenderNode* node) { 
        .setVsync(mRenderThread.timeLord().computeFrameTimeNanos(),

                mRenderThread.timeLord().latestVsync());



    TreeInfo info(TreeInfo::MODE_RT_ONLY, mRenderThread.renderState());

    TreeInfo info(TreeInfo::MODE_RT_ONLY, *this);

    prepareTree(info, frameInfo, systemTime(CLOCK_MONOTONIC), node);

    if (info.out.canDrawThisFrame) {

        draw();
@@ -531,7 +530,7 @@ void CanvasContext::buildLayer(RenderNode* node) { 
    // buildLayer() will leave the tree in an unknown state, so we must stop drawing

    stopDrawing();



    TreeInfo info(TreeInfo::MODE_FULL, mRenderThread.renderState());

    TreeInfo info(TreeInfo::MODE_FULL, *this);

    info.damageAccumulator = &mDamageAccumulator;

    info.renderer = mCanvas;

    info.runAnimations = false;

libs/hwui/renderthread/CanvasContext.h

+4 −0
Original line number Diff line number Diff line
@@ -130,6 +130,10 @@ public: 
        mContentDrawBounds.set(left, top, right, bottom);

    }



    RenderState& getRenderState() {

        return mRenderThread.renderState();

    }



private:

    friend class RegisterFrameCallbackTask;

    // TODO: Replace with something better for layer & other GL object

libs/hwui/renderthread/DrawFrameTask.cpp

+1 −1
Original line number Diff line number Diff line
@@ -87,7 +87,7 @@ void DrawFrameTask::run() { 
    bool canUnblockUiThread;

    bool canDrawThisFrame;

    {

        TreeInfo info(TreeInfo::MODE_FULL, mRenderThread->renderState());

        TreeInfo info(TreeInfo::MODE_FULL, *mContext);

        canUnblockUiThread = syncFrameState(info);

        canDrawThisFrame = info.out.canDrawThisFrame;

    }