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 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 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 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(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 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
