DisplayList.h revision 8afd0f245cc0c4a0366f39f41b5f78e47ee83be3 
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
45class SkBitmap;
46class SkPaint;
47class SkPath;
48class SkRegion;
49
50namespace android {
51namespace uirenderer {
52
53class DeferredDisplayList;
54class DisplayListOp;
55class DisplayListRenderer;
56class OpenGLRenderer;
57class Rect;
58class Layer;
59
60class ClipRectOp;
61class SaveLayerOp;
62class SaveOp;
63class RestoreToCountOp;
64class DrawRenderNodeOp;
65
66/**
67 * Holds data used in the playback a tree of DisplayLists.
68 */
69class PlaybackStateStruct {
70protected:
71    PlaybackStateStruct(OpenGLRenderer& renderer, int replayFlags, LinearAllocator* allocator)
72            : mRenderer(renderer)
73            , mReplayFlags(replayFlags)
74            , mAllocator(allocator) {}
75
76public:
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
89private:
90    // Paths kept alive for the duration of the frame
91    std::vector<SkPath> mTempPaths;
92};
93
94class DeferStateStruct : public PlaybackStateStruct {
95public:
96    DeferStateStruct(DeferredDisplayList& deferredList, OpenGLRenderer& renderer, int replayFlags)
97            : PlaybackStateStruct(renderer, replayFlags, &(deferredList.mAllocator)),
98            mDeferredList(deferredList) {}
99
100    DeferredDisplayList& mDeferredList;
101};
102
103class ReplayStateStruct : public PlaybackStateStruct {
104public:
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 */
117class DisplayListData {
118    friend class DisplayListRenderer;
119public:
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
175private:
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