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