DisplayList.h revision 2dc236b2bae13b9a0ed9b3f7320502aecd7983b3 
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<Layer*> layers;
152    Vector<Functor*> functors;
153
154    const Vector<Chunk>& getChunks() const {
155        return chunks;
156    }
157
158    size_t addChild(DrawRenderNodeOp* childOp);
159    const Vector<DrawRenderNodeOp*>& children() { return mChildren; }
160
161    void refProperty(CanvasPropertyPrimitive* prop) {
162        mReferenceHolders.push(prop);
163    }
164
165    void refProperty(CanvasPropertyPaint* prop) {
166        mReferenceHolders.push(prop);
167    }
168
169    size_t getUsedSize() {
170        return allocator.usedSize();
171    }
172    bool isEmpty() {
173        return !hasDrawOps;
174    }
175
176private:
177    Vector< sp<VirtualLightRefBase> > mReferenceHolders;
178
179    // list of children display lists for quick, non-drawing traversal
180    Vector<DrawRenderNodeOp*> mChildren;
181
182    Vector<Chunk> chunks;
183
184    // allocator into which all ops were allocated
185    LinearAllocator allocator;
186    bool hasDrawOps;
187
188    void cleanupResources();
189};
190
191}; // namespace uirenderer
192}; // namespace android
193
194#endif // ANDROID_HWUI_OPENGL_RENDERER_H
195