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