libs/hwui/FrameBuilder.h

   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