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 #include <SkCamera.h> 21 #include <SkMatrix.h> 22 23 #include <private/hwui/DrawGlInfo.h> 24 25 #include <utils/KeyedVector.h> 26 #include <utils/LinearAllocator.h> 27 #include <utils/RefBase.h> 28 #include <utils/SortedVector.h> 29 #include <utils/String8.h> 30 31 #include <cutils/compiler.h> 32 33 #include <androidfw/ResourceTypes.h> 34 35 #include "Debug.h" 36 #include "CanvasProperty.h" 37 #include "DeferredDisplayList.h" 38 #include "GlFunctorLifecycleListener.h" 39 #include "Matrix.h" 40 #include "RenderProperties.h" 41 42 #include <vector> 43 44 class SkBitmap; 45 class SkPaint; 46 class SkPath; 47 class SkRegion; 48 49 namespace android { 50 namespace uirenderer { 51 52 class DeferredDisplayList; 53 class DisplayListOp; 54 class DisplayListCanvas; 55 class OpenGLRenderer; 56 class Rect; 57 class Layer; 58 59 #if HWUI_NEW_OPS 60 struct RecordedOp; 61 struct RenderNodeOp; 62 63 typedef RecordedOp BaseOpType; 64 typedef RenderNodeOp NodeOpType; 65 #else 66 class DrawRenderNodeOp; 67 68 typedef DisplayListOp BaseOpType; 69 typedef DrawRenderNodeOp NodeOpType; 70 #endif 71 72 namespace VectorDrawable { 73 class Tree; 74 }; 75 typedef uirenderer::VectorDrawable::Tree VectorDrawableRoot; 76 77 /** 78 * Holds data used in the playback a tree of DisplayLists. 79 */ 80 struct PlaybackStateStruct { 81 protected: PlaybackStateStructPlaybackStateStruct82 PlaybackStateStruct(OpenGLRenderer& renderer, int replayFlags, LinearAllocator* allocator) 83 : mRenderer(renderer) 84 , mReplayFlags(replayFlags) 85 , mAllocator(allocator) {} 86 87 public: 88 OpenGLRenderer& mRenderer; 89 const int mReplayFlags; 90 91 // Allocator with the lifetime of a single frame. replay uses an Allocator owned by the struct, 92 // while defer shares the DeferredDisplayList's Allocator 93 // TODO: move this allocator to be owned by object with clear frame lifecycle 94 LinearAllocator * const mAllocator; 95 allocPathForFramePlaybackStateStruct96 SkPath* allocPathForFrame() { 97 return mRenderer.allocPathForFrame(); 98 } 99 }; 100 101 struct DeferStateStruct : public PlaybackStateStruct { DeferStateStructDeferStateStruct102 DeferStateStruct(DeferredDisplayList& deferredList, OpenGLRenderer& renderer, int replayFlags) 103 : PlaybackStateStruct(renderer, replayFlags, &(deferredList.mAllocator)), 104 mDeferredList(deferredList) {} 105 106 DeferredDisplayList& mDeferredList; 107 }; 108 109 struct ReplayStateStruct : public PlaybackStateStruct { ReplayStateStructReplayStateStruct110 ReplayStateStruct(OpenGLRenderer& renderer, Rect& dirty, int replayFlags) 111 : PlaybackStateStruct(renderer, replayFlags, &mReplayAllocator), 112 mDirty(dirty) {} 113 114 Rect& mDirty; 115 LinearAllocator mReplayAllocator; 116 }; 117 118 struct FunctorContainer { 119 Functor* functor; 120 GlFunctorLifecycleListener* listener; 121 }; 122 123 /** 124 * Data structure that holds the list of commands used in display list stream 125 */ 126 class DisplayList { 127 friend class DisplayListCanvas; 128 friend class RecordingCanvas; 129 public: 130 struct Chunk { 131 // range of included ops in DisplayList::ops() 132 size_t beginOpIndex; 133 size_t endOpIndex; 134 135 // range of included children in DisplayList::children() 136 size_t beginChildIndex; 137 size_t endChildIndex; 138 139 // whether children with non-zero Z in the chunk should be reordered 140 bool reorderChildren; 141 #if HWUI_NEW_OPS 142 const ClipBase* reorderClip; 143 #endif 144 }; 145 146 DisplayList(); 147 ~DisplayList(); 148 149 // index of DisplayListOp restore, after which projected descendants should be drawn 150 int projectionReceiveIndex; 151 getChunks()152 const LsaVector<Chunk>& getChunks() const { return chunks; } getOps()153 const LsaVector<BaseOpType*>& getOps() const { return ops; } 154 getChildren()155 const LsaVector<NodeOpType*>& getChildren() const { return children; } 156 getBitmapResources()157 const LsaVector<const SkBitmap*>& getBitmapResources() const { return bitmapResources; } getFunctors()158 const LsaVector<FunctorContainer>& getFunctors() const { return functors; } getVectorDrawables()159 const LsaVector<VectorDrawableRoot*>& getVectorDrawables() { return vectorDrawables; } 160 161 size_t addChild(NodeOpType* childOp); 162 163 ref(VirtualLightRefBase * prop)164 void ref(VirtualLightRefBase* prop) { 165 referenceHolders.push_back(prop); 166 } 167 getUsedSize()168 size_t getUsedSize() { 169 return allocator.usedSize(); 170 } isEmpty()171 bool isEmpty() { 172 #if HWUI_NEW_OPS 173 return ops.empty(); 174 #else 175 return !hasDrawOps; 176 #endif 177 } 178 179 private: 180 // allocator into which all ops and LsaVector arrays allocated 181 LinearAllocator allocator; 182 LinearStdAllocator<void*> stdAllocator; 183 184 LsaVector<Chunk> chunks; 185 LsaVector<BaseOpType*> ops; 186 187 // list of Ops referring to RenderNode children for quick, non-drawing traversal 188 LsaVector<NodeOpType*> children; 189 190 // Resources - Skia objects + 9 patches referred to by this DisplayList 191 LsaVector<const SkBitmap*> bitmapResources; 192 LsaVector<const SkPath*> pathResources; 193 LsaVector<const Res_png_9patch*> patchResources; 194 LsaVector<std::unique_ptr<const SkPaint>> paints; 195 LsaVector<std::unique_ptr<const SkRegion>> regions; 196 LsaVector< sp<VirtualLightRefBase> > referenceHolders; 197 198 // List of functors 199 LsaVector<FunctorContainer> functors; 200 201 // List of VectorDrawables that need to be notified of pushStaging. Note that this list gets nothing 202 // but a callback during sync DisplayList, unlike the list of functors defined above, which 203 // gets special treatment exclusive for webview. 204 LsaVector<VectorDrawableRoot*> vectorDrawables; 205 206 bool hasDrawOps; // only used if !HWUI_NEW_OPS 207 208 void cleanupResources(); 209 }; 210 211 }; // namespace uirenderer 212 }; // namespace android 213 214 #endif // ANDROID_HWUI_OPENGL_RENDERER_H 215