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