libs/hwui/DisplayList.h

   1 /*
   2  * Copyright (C) 2013 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 #ifndef ANDROID_HWUI_DISPLAY_LIST_H
  18 #define ANDROID_HWUI_DISPLAY_LIST_H
  19
  20 #ifndef LOG_TAG
  21     #define LOG_TAG "OpenGLRenderer"
  22 #endif
  23
  24 #include <SkCamera.h>
  25 #include <SkMatrix.h>
  26
  27 #include <private/hwui/DrawGlInfo.h>
  28
  29 #include <utils/KeyedVector.h>
  30 #include <utils/LinearAllocator.h>
  31 #include <utils/RefBase.h>
  32 #include <utils/SortedVector.h>
  33 #include <utils/String8.h>
  34 #include <utils/Vector.h>
  35
  36 #include <cutils/compiler.h>
  37
  38 #include <androidfw/ResourceTypes.h>
  39
  40 #include "Debug.h"
  41 #include "CanvasProperty.h"
  42 #include "DeferredDisplayList.h"
  43 #include "Matrix.h"
  44 #include "RenderProperties.h"
  45
  46 class SkBitmap;
  47 class SkPaint;
  48 class SkPath;
  49 class SkRegion;
  50
  51 namespace android {
  52 namespace uirenderer {
  53
  54 class DeferredDisplayList;
  55 class DisplayListOp;
  56 class DisplayListRenderer;
  57 class OpenGLRenderer;
  58 class Rect;
  59 class Layer;
  60
  61 class ClipRectOp;
  62 class SaveLayerOp;
  63 class SaveOp;
  64 class RestoreToCountOp;
  65 class DrawRenderNodeOp;
  66
  67 /**
  68  * Holds data used in the playback a tree of DisplayLists.
  69  */
  70 struct PlaybackStateStruct {
  71 protected:
  72     PlaybackStateStruct(OpenGLRenderer& renderer, int replayFlags, LinearAllocator* allocator)
  73             : mRenderer(renderer)
  74             , mReplayFlags(replayFlags)
  75             , mAllocator(allocator) {}
  76
  77 public:
  78     OpenGLRenderer& mRenderer;
  79     const int mReplayFlags;
  80
  81     // Allocator with the lifetime of a single frame. replay uses an Allocator owned by the struct,
  82     // while defer shares the DeferredDisplayList's Allocator
  83     // TODO: move this allocator to be owned by object with clear frame lifecycle
  84     LinearAllocator * const mAllocator;
  85
  86     SkPath* allocPathForFrame() {
  87         return mRenderer.allocPathForFrame();
  88     }
  89 };
  90
  91 struct DeferStateStruct : public PlaybackStateStruct {
  92     DeferStateStruct(DeferredDisplayList& deferredList, OpenGLRenderer& renderer, int replayFlags)
  93             : PlaybackStateStruct(renderer, replayFlags, &(deferredList.mAllocator)),
  94             mDeferredList(deferredList) {}
  95
  96     DeferredDisplayList& mDeferredList;
  97 };
  98
  99 struct ReplayStateStruct : public PlaybackStateStruct {
 100     ReplayStateStruct(OpenGLRenderer& renderer, Rect& dirty, int replayFlags)
 101             : PlaybackStateStruct(renderer, replayFlags, &mReplayAllocator),
 102             mDirty(dirty) {}
 103
 104     Rect& mDirty;
 105     LinearAllocator mReplayAllocator;
 106 };
 107
 108 /**
 109  * Data structure that holds the list of commands used in display list stream
 110  */
 111 class DisplayListData {
 112     friend class DisplayListRenderer;
 113 public:
 114     struct Chunk {
 115         // range of included ops in DLD::displayListOps
 116         size_t beginOpIndex;
 117         size_t endOpIndex;
 118
 119         // range of included children in DLD::mChildren
 120         size_t beginChildIndex;
 121         size_t endChildIndex;
 122
 123         // whether children with non-zero Z in the chunk should be reordered
 124         bool reorderChildren;
 125     };
 126
 127     DisplayListData();
 128     ~DisplayListData();
 129
 130     // pointers to all ops within display list, pointing into allocator data
 131     Vector<DisplayListOp*> displayListOps;
 132
 133     // index of DisplayListOp restore, after which projected descendents should be drawn
 134     int projectionReceiveIndex;
 135
 136     Vector<const SkBitmap*> bitmapResources;
 137     Vector<const SkPath*> pathResources;
 138     Vector<const Res_png_9patch*> patchResources;
 139
 140     std::vector<std::unique_ptr<const SkPaint>> paints;
 141     std::vector<std::unique_ptr<const SkRegion>> regions;
 142     Vector<Functor*> functors;
 143
 144     const Vector<Chunk>& getChunks() const {
 145         return chunks;
 146     }
 147
 148     size_t addChild(DrawRenderNodeOp* childOp);
 149     const Vector<DrawRenderNodeOp*>& children() { return mChildren; }
 150
 151     void ref(VirtualLightRefBase* prop) {
 152         mReferenceHolders.push(prop);
 153     }
 154
 155     size_t getUsedSize() {
 156         return allocator.usedSize();
 157     }
 158     bool isEmpty() {
 159         return !hasDrawOps;
 160     }
 161
 162 private:
 163     Vector< sp<VirtualLightRefBase> > mReferenceHolders;
 164
 165     // list of children display lists for quick, non-drawing traversal
 166     Vector<DrawRenderNodeOp*> mChildren;
 167
 168     Vector<Chunk> chunks;
 169
 170     // allocator into which all ops were allocated
 171     LinearAllocator allocator;
 172     bool hasDrawOps;
 173
 174     void cleanupResources();
 175 };
 176
 177 }; // namespace uirenderer
 178 }; // namespace android
 179
 180 #endif // ANDROID_HWUI_OPENGL_RENDERER_H