FrameBuilder.h 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#pragma once
18
19#include "BakedOpState.h"
20#include "CanvasState.h"
21#include "DisplayList.h"
22#include "LayerBuilder.h"
23#include "RecordedOp.h"
24
25#include <vector>
26#include <unordered_map>
27
28struct SkRect;
29
30namespace android {
31namespace uirenderer {
32
33class BakedOpState;
34class LayerUpdateQueue;
35class OffscreenBuffer;
36class Rect;
37
38/**
39 * Traverses all of the drawing commands from the layers and RenderNodes passed into it, preparing
40 * them to be rendered.
41 *
42 * Resolves final drawing state for each operation (including clip, alpha and matrix), and then
43 * reorder and merge each op as it is resolved for drawing efficiency. Each layer of content (either
44 * from the LayerUpdateQueue, or temporary layers created by saveLayer operations in the
45 * draw stream) will create different reorder contexts, each in its own LayerBuilder.
46 *
47 * Then the prepared or 'baked' drawing commands can be issued by calling the templated
48 * replayBakedOps() function, which will dispatch them (including any created merged op collections)
49 * to a Dispatcher and Renderer. See BakedOpDispatcher for how these baked drawing operations are
50 * resolved into Glops and rendered via BakedOpRenderer.
51 *
52 * This class is also the authoritative source for traversing RenderNodes, both for standard op
53 * traversal within a DisplayList, and for out of order RenderNode traversal for Z and projection.
54 */
55class FrameBuilder : public CanvasStateClient {
56public:
57    FrameBuilder(const LayerUpdateQueue& layers, const SkRect& clip,
58            uint32_t viewportWidth, uint32_t viewportHeight,
59            const std::vector< sp<RenderNode> >& nodes, const Vector3& lightCenter);
60
61    virtual ~FrameBuilder() {}
62
63    /**
64     * replayBakedOps() is templated based on what class will receive ops being replayed.
65     *
66     * It constructs a lookup array of lambdas, which allows a recorded BakeOpState to use
67     * state->op->opId to lookup a receiver that will be called when the op is replayed.
68     *
69     */
70    template <typename StaticDispatcher, typename Renderer>
71    void replayBakedOps(Renderer& renderer) {
72        /**
73         * Defines a LUT of lambdas which allow a recorded BakedOpState to use state->op->opId to
74         * dispatch the op via a method on a static dispatcher when the op is replayed.
75         *
76         * For example a BitmapOp would resolve, via the lambda lookup, to calling:
77         *
78         * StaticDispatcher::onBitmapOp(Renderer& renderer, const BitmapOp& op, const BakedOpState& state);
79         */
80        #define X(Type) \
81                [](void* renderer, const BakedOpState& state) { \
82                    StaticDispatcher::on##Type(*(static_cast<Renderer*>(renderer)), \
83                            static_cast<const Type&>(*(state.op)), state); \
84                },
85        static BakedOpReceiver unmergedReceivers[] = BUILD_RENDERABLE_OP_LUT(X);
86        #undef X
87
88        /**
89         * Defines a LUT of lambdas which allow merged arrays of BakedOpState* to be passed to a
90         * static dispatcher when the group of merged ops is replayed.
91         */
92        #define X(Type) \
93                [](void* renderer, const MergedBakedOpList& opList) { \
94                    StaticDispatcher::onMerged##Type##s(*(static_cast<Renderer*>(renderer)), opList); \
95                },
96        static MergedOpReceiver mergedReceivers[] = BUILD_MERGEABLE_OP_LUT(X);
97        #undef X
98
99        // Relay through layers in reverse order, since layers
100        // later in the list will be drawn by earlier ones
101        for (int i = mLayerBuilders.size() - 1; i >= 1; i--) {
102            LayerBuilder& layer = *(mLayerBuilders[i]);
103            if (layer.renderNode) {
104                // cached HW layer - can't skip layer if empty
105                renderer.startRepaintLayer(layer.offscreenBuffer, layer.repaintRect);
106                layer.replayBakedOpsImpl((void*)&renderer, unmergedReceivers, mergedReceivers);
107                renderer.endLayer();
108            } else if (!layer.empty()) { // save layer - skip entire layer if empty
109                layer.offscreenBuffer = renderer.startTemporaryLayer(layer.width, layer.height);
110                layer.replayBakedOpsImpl((void*)&renderer, unmergedReceivers, mergedReceivers);
111                renderer.endLayer();
112            }
113        }
114
115        const LayerBuilder& fbo0 = *(mLayerBuilders[0]);
116        renderer.startFrame(fbo0.width, fbo0.height, fbo0.repaintRect);
117        fbo0.replayBakedOpsImpl((void*)&renderer, unmergedReceivers, mergedReceivers);
118        renderer.endFrame(fbo0.repaintRect);
119    }
120
121    void dump() const {
122        for (auto&& layer : mLayerBuilders) {
123            layer->dump();
124        }
125    }
126
127    ///////////////////////////////////////////////////////////////////
128    /// CanvasStateClient interface
129    ///////////////////////////////////////////////////////////////////
130    virtual void onViewportInitialized() override;
131    virtual void onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) override;
132    virtual GLuint getTargetFbo() const override { return 0; }
133
134private:
135    enum class ChildrenSelectMode {
136        Negative,
137        Positive
138    };
139    void saveForLayer(uint32_t layerWidth, uint32_t layerHeight,
140            float contentTranslateX, float contentTranslateY,
141            const Rect& repaintRect,
142            const Vector3& lightCenter,
143            const BeginLayerOp* beginLayerOp, RenderNode* renderNode);
144    void restoreForLayer();
145
146    LayerBuilder& currentLayer() { return *(mLayerBuilders[mLayerStack.back()]); }
147
148    BakedOpState* tryBakeOpState(const RecordedOp& recordedOp) {
149        return BakedOpState::tryConstruct(mAllocator, *mCanvasState.writableSnapshot(), recordedOp);
150    }
151
152    // should always be surrounded by a save/restore pair, and not called if DisplayList is null
153    void deferNodePropsAndOps(RenderNode& node);
154
155    template <typename V>
156    void defer3dChildren(ChildrenSelectMode mode, const V& zTranslatedNodes);
157
158    void deferShadow(const RenderNodeOp& casterOp);
159
160    void deferProjectedChildren(const RenderNode& renderNode);
161
162    void deferNodeOps(const RenderNode& renderNode);
163
164    void deferRenderNodeOpImpl(const RenderNodeOp& op);
165
166    void replayBakedOpsImpl(void* arg, BakedOpReceiver* receivers);
167
168    SkPath* createFrameAllocatedPath() {
169        return mAllocator.create<SkPath>();
170    }
171
172    void deferStrokeableOp(const RecordedOp& op, batchid_t batchId,
173            BakedOpState::StrokeBehavior strokeBehavior = BakedOpState::StrokeBehavior::StyleDefined);
174
175    /**
176     * Declares all FrameBuilder::deferXXXXOp() methods for every RecordedOp type.
177     *
178     * These private methods are called from within deferImpl to defer each individual op
179     * type differently.
180     */
181#define X(Type) void defer##Type(const Type& op);
182    MAP_DEFERRABLE_OPS(X)
183#undef X
184
185    // List of every deferred layer's render state. Replayed in reverse order to render a frame.
186    std::vector<LayerBuilder*> mLayerBuilders;
187
188    /*
189     * Stack of indices within mLayerBuilders representing currently active layers. If drawing
190     * layerA within a layerB, will contain, in order:
191     *  - 0 (representing FBO 0, always present)
192     *  - layerB's index
193     *  - layerA's index
194     *
195     * Note that this doesn't vector doesn't always map onto all values of mLayerBuilders. When a
196     * layer is finished deferring, it will still be represented in mLayerBuilders, but it's index
197     * won't be in mLayerStack. This is because it can be replayed, but can't have any more drawing
198     * ops added to it.
199    */
200    std::vector<size_t> mLayerStack;
201
202    CanvasState mCanvasState;
203
204    // contains ResolvedOps and Batches
205    LinearAllocator mAllocator;
206};
207
208}; // namespace uirenderer
209}; // namespace android
210