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 DisplayListCanvas; 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 DisplayListCanvas; 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 181
