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 "Matrix.h" 42 #include "DeferredDisplayList.h" 43 #include "RenderProperties.h" 44 45 class SkBitmap; 46 class SkPaint; 47 class SkPath; 48 class SkRegion; 49 50 namespace android { 51 namespace uirenderer { 52 53 class DeferredDisplayList; 54 class DisplayListOp; 55 class DisplayListRenderer; 56 class OpenGLRenderer; 57 class Rect; 58 class Layer; 59 60 class ClipRectOp; 61 class SaveLayerOp; 62 class SaveOp; 63 class RestoreToCountOp; 64 class DrawRenderNodeOp; 65 66 /** 67 * Holds data used in the playback a tree of DisplayLists. 68 */ 69 class PlaybackStateStruct { 70 protected: 71 PlaybackStateStruct(OpenGLRenderer& renderer, int replayFlags, LinearAllocator* allocator) 72 : mRenderer(renderer) 73 , mReplayFlags(replayFlags) 74 , mAllocator(allocator) {} 75 76 public: 77 OpenGLRenderer& mRenderer; 78 const int mReplayFlags; 79 80 // Allocator with the lifetime of a single frame. 81 // replay uses an Allocator owned by the struct, while defer shares the DeferredDisplayList's Allocator 82 LinearAllocator * const mAllocator; 83 84 SkPath* allocPathForFrame() { 85 mTempPaths.push_back(); 86 return &mTempPaths.back(); 87 } 88 89 private: 90 // Paths kept alive for the duration of the frame 91 std::vector<SkPath> mTempPaths; 92 }; 93 94 class DeferStateStruct : public PlaybackStateStruct { 95 public: 96 DeferStateStruct(DeferredDisplayList& deferredList, OpenGLRenderer& renderer, int replayFlags) 97 : PlaybackStateStruct(renderer, replayFlags, &(deferredList.mAllocator)), 98 mDeferredList(deferredList) {} 99 100 DeferredDisplayList& mDeferredList; 101 }; 102 103 class ReplayStateStruct : public PlaybackStateStruct { 104 public: 105 ReplayStateStruct(OpenGLRenderer& renderer, Rect& dirty, int replayFlags) 106 : PlaybackStateStruct(renderer, replayFlags, &mReplayAllocator), 107 mDirty(dirty), mDrawGlStatus(DrawGlInfo::kStatusDone) {} 108 109 Rect& mDirty; 110 status_t mDrawGlStatus; 111 LinearAllocator mReplayAllocator; 112 }; 113 114 /** 115 * Data structure that holds the list of commands used in display list stream 116 */ 117 class DisplayListData { 118 friend class DisplayListRenderer; 119 public: 120 struct Chunk { 121 // range of included ops in DLD::displayListOps 122 size_t beginOpIndex; 123 size_t endOpIndex; 124 125 // range of included children in DLD::mChildren 126 size_t beginChildIndex; 127 size_t endChildIndex; 128 129 // whether children with non-zero Z in the chunk should be reordered 130 bool reorderChildren; 131 }; 132 133 DisplayListData(); 134 ~DisplayListData(); 135 136 // pointers to all ops within display list, pointing into allocator data 137 Vector<DisplayListOp*> displayListOps; 138 139 // index of DisplayListOp restore, after which projected descendents should be drawn 140 int projectionReceiveIndex; 141 142 Vector<const SkBitmap*> bitmapResources; 143 Vector<const SkBitmap*> ownedBitmapResources; 144 Vector<const Res_png_9patch*> patchResources; 145 146 Vector<const SkPaint*> paints; 147 Vector<const SkPath*> paths; 148 SortedVector<const SkPath*> sourcePaths; 149 Vector<const SkRegion*> regions; 150 Vector<Layer*> layers; 151 Vector<Functor*> functors; 152 153 const Vector<Chunk>& getChunks() const { 154 return chunks; 155 } 156 157 size_t addChild(DrawRenderNodeOp* childOp); 158 const Vector<DrawRenderNodeOp*>& children() { return mChildren; } 159 160 void refProperty(CanvasPropertyPrimitive* prop) { 161 mReferenceHolders.push(prop); 162 } 163 164 void refProperty(CanvasPropertyPaint* prop) { 165 mReferenceHolders.push(prop); 166 } 167 168 size_t getUsedSize() { 169 return allocator.usedSize(); 170 } 171 bool isEmpty() { 172 return !hasDrawOps; 173 } 174 175 private: 176 Vector< sp<VirtualLightRefBase> > mReferenceHolders; 177 178 // list of children display lists for quick, non-drawing traversal 179 Vector<DrawRenderNodeOp*> mChildren; 180 181 Vector<Chunk> chunks; 182 183 // allocator into which all ops were allocated 184 LinearAllocator allocator; 185 bool hasDrawOps; 186 187 void cleanupResources(); 188 }; 189 190 }; // namespace uirenderer 191 }; // namespace android 192 193 #endif // ANDROID_HWUI_OPENGL_RENDERER_H 194
