• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
29 struct SkRect;
30 
31 namespace android {
32 namespace uirenderer {
33 
34 class BakedOpState;
35 class LayerUpdateQueue;
36 class OffscreenBuffer;
37 class Rect;
38 
39 /**
40  * Processes, optimizes, and stores rendering commands from RenderNodes and
41  * LayerUpdateQueue, building content needed to render a frame.
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  */
56 class FrameBuilder : public CanvasStateClient {
57 public:
58     struct LightGeometry {
59         Vector3 center;
60         float radius;
61     };
62 
63     FrameBuilder(const SkRect& clip,
64             uint32_t viewportWidth, uint32_t viewportHeight,
65             const LightGeometry& lightGeometry, Caches& caches);
66 
67     FrameBuilder(const LayerUpdateQueue& layerUpdateQueue,
68             const LightGeometry& lightGeometry, Caches& caches);
69 
70     void deferLayers(const LayerUpdateQueue& layers);
71 
72     void deferRenderNode(RenderNode& renderNode);
73 
74     void deferRenderNode(float tx, float ty, Rect clipRect, RenderNode& renderNode);
75 
76     void deferRenderNodeScene(const std::vector< sp<RenderNode> >& nodes,
77             const Rect& contentDrawBounds);
78 
~FrameBuilder()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>
replayBakedOps(Renderer & 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 
dump()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;
getTargetFbo()167     virtual GLuint getTargetFbo() const override { return 0; }
168 
169 private:
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 
currentLayer()182     LayerBuilder& currentLayer() { return *(mLayerBuilders[mLayerStack.back()]); }
183 
tryBakeOpState(const RecordedOp & recordedOp)184     BakedOpState* tryBakeOpState(const RecordedOp& recordedOp) {
185         return BakedOpState::tryConstruct(mAllocator, *mCanvasState.writableSnapshot(), recordedOp);
186     }
tryBakeUnboundedOpState(const RecordedOp & recordedOp)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(const ClipBase* reorderClip, ChildrenSelectMode mode,
197             const V& zTranslatedNodes);
198 
199     void deferShadow(const ClipBase* reorderClip, const RenderNodeOp& casterOp);
200 
201     void deferProjectedChildren(const RenderNode& renderNode);
202 
203     void deferNodeOps(const RenderNode& renderNode);
204 
205     void deferRenderNodeOpImpl(const RenderNodeOp& op);
206 
207     void replayBakedOpsImpl(void* arg, BakedOpReceiver* receivers);
208 
createFrameAllocatedPath()209     SkPath* createFrameAllocatedPath() {
210         return mAllocator.create<SkPath>();
211     }
212 
213     BakedOpState* deferStrokeableOp(const RecordedOp& op, batchid_t batchId,
214             BakedOpState::StrokeBehavior strokeBehavior = BakedOpState::StrokeBehavior::StyleDefined);
215 
216     /**
217      * Declares all FrameBuilder::deferXXXXOp() methods for every RecordedOp type.
218      *
219      * These private methods are called from within deferImpl to defer each individual op
220      * type differently.
221      */
222 #define X(Type) void defer##Type(const Type& op);
223     MAP_DEFERRABLE_OPS(X)
224 #undef X
225 
226     // contains single-frame objects, such as BakedOpStates, LayerBuilders, Batches
227     LinearAllocator mAllocator;
228     LinearStdAllocator<void*> mStdAllocator;
229 
230     // List of every deferred layer's render state. Replayed in reverse order to render a frame.
231     LsaVector<LayerBuilder*> mLayerBuilders;
232 
233     /*
234      * Stack of indices within mLayerBuilders representing currently active layers. If drawing
235      * layerA within a layerB, will contain, in order:
236      *  - 0 (representing FBO 0, always present)
237      *  - layerB's index
238      *  - layerA's index
239      *
240      * Note that this doesn't vector doesn't always map onto all values of mLayerBuilders. When a
241      * layer is finished deferring, it will still be represented in mLayerBuilders, but it's index
242      * won't be in mLayerStack. This is because it can be replayed, but can't have any more drawing
243      * ops added to it.
244     */
245     LsaVector<size_t> mLayerStack;
246 
247     CanvasState mCanvasState;
248 
249     Caches& mCaches;
250 
251     float mLightRadius;
252 
253     const bool mDrawFbo0;
254 };
255 
256 }; // namespace uirenderer
257 }; // namespace android
258