RenderNode.h revision 3f085429fd47ebd32ac2463b3eae2a5a6c17be25 
1/*
2 * Copyright (C) 2014 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#ifndef RENDERNODE_H
17#define RENDERNODE_H
18
19#ifndef LOG_TAG
20    #define LOG_TAG "OpenGLRenderer"
21#endif
22
23#include <SkCamera.h>
24#include <SkMatrix.h>
25
26#include <private/hwui/DrawGlInfo.h>
27
28#include <utils/KeyedVector.h>
29#include <utils/LinearAllocator.h>
30#include <utils/RefBase.h>
31#include <utils/SortedVector.h>
32#include <utils/String8.h>
33#include <utils/Vector.h>
34
35#include <cutils/compiler.h>
36
37#include <androidfw/ResourceTypes.h>
38
39#include "Debug.h"
40#include "Matrix.h"
41#include "DeferredDisplayList.h"
42#include "DisplayList.h"
43#include "RenderProperties.h"
44#include "utils/VirtualLightRefBase.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;
60class SkiaShader;
61
62class ClipRectOp;
63class SaveLayerOp;
64class SaveOp;
65class RestoreToCountOp;
66class DrawDisplayListOp;
67
68struct TreeInfo {
69    TreeInfo()
70            : hasFunctors(false)
71            , prepareTextures(false)
72    {}
73
74    bool hasFunctors;
75    bool prepareTextures;
76    // TODO: Damage calculations? Flag to skip staging pushes for RT animations?
77};
78
79/**
80 * Primary class for storing recorded canvas commands, as well as per-View/ViewGroup display properties.
81 *
82 * Recording of canvas commands is somewhat similar to SkPicture, except the canvas-recording
83 * functionality is split between DisplayListRenderer (which manages the recording), DisplayListData
84 * (which holds the actual data), and DisplayList (which holds properties and performs playback onto
85 * a renderer).
86 *
87 * Note that DisplayListData is swapped out from beneath an individual DisplayList when a view's
88 * recorded stream of canvas operations is refreshed. The DisplayList (and its properties) stay
89 * attached.
90 */
91class RenderNode : public VirtualLightRefBase {
92public:
93    ANDROID_API RenderNode();
94    ANDROID_API ~RenderNode();
95
96    // See flags defined in DisplayList.java
97    enum ReplayFlag {
98        kReplayFlag_ClipChildren = 0x1
99    };
100
101    ANDROID_API static void outputLogBuffer(int fd);
102
103    ANDROID_API void setStagingDisplayList(DisplayListData* newData);
104
105    void computeOrdering();
106
107    void deferNodeTree(DeferStateStruct& deferStruct);
108    void deferNodeInParent(DeferStateStruct& deferStruct, const int level);
109
110    void replayNodeTree(ReplayStateStruct& replayStruct);
111    void replayNodeInParent(ReplayStateStruct& replayStruct, const int level);
112
113    ANDROID_API void output(uint32_t level = 1);
114
115    bool isRenderable() const {
116        return mDisplayListData && mDisplayListData->hasDrawOps;
117    }
118
119    const char* getName() const {
120        return mName.string();
121    }
122
123    void setName(const char* name) {
124        if (name) {
125            char* lastPeriod = strrchr(name, '.');
126            if (lastPeriod) {
127                mName.setTo(lastPeriod + 1);
128            } else {
129                mName.setTo(name);
130            }
131        }
132    }
133
134    const RenderProperties& properties() {
135        return mProperties;
136    }
137
138    const RenderProperties& stagingProperties() {
139        return mStagingProperties;
140    }
141
142    RenderProperties& mutateStagingProperties() {
143        mNeedsPropertiesSync = true;
144        return mStagingProperties;
145    }
146
147    int getWidth() {
148        return properties().getWidth();
149    }
150
151    int getHeight() {
152        return properties().getHeight();
153    }
154
155    ANDROID_API void prepareTree(TreeInfo& info);
156
157private:
158    typedef key_value_pair_t<float, DrawDisplayListOp*> ZDrawDisplayListOpPair;
159
160    static size_t findNonNegativeIndex(const Vector<ZDrawDisplayListOpPair>& nodes) {
161        for (size_t i = 0; i < nodes.size(); i++) {
162            if (nodes[i].key >= 0.0f) return i;
163        }
164        return nodes.size();
165    }
166
167    enum ChildrenSelectMode {
168        kNegativeZChildren,
169        kPositiveZChildren
170    };
171
172    void applyViewPropertyTransforms(mat4& matrix, bool true3dTransform = false);
173
174    void computeOrderingImpl(DrawDisplayListOp* opState,
175            const SkPath* outlineOfProjectionSurface,
176            Vector<DrawDisplayListOp*>* compositedChildrenOfProjectionSurface,
177            const mat4* transformFromProjectionSurface);
178
179    template <class T>
180    inline void setViewProperties(OpenGLRenderer& renderer, T& handler);
181
182    void buildZSortedChildList(Vector<ZDrawDisplayListOpPair>& zTranslatedNodes);
183
184    template<class T>
185    inline void issueDrawShadowOperation(const Matrix4& transformFromParent, T& handler);
186
187    template <class T>
188    inline void issueOperationsOf3dChildren(const Vector<ZDrawDisplayListOpPair>& zTranslatedNodes,
189            ChildrenSelectMode mode, OpenGLRenderer& renderer, T& handler);
190
191    template <class T>
192    inline void issueOperationsOfProjectedChildren(OpenGLRenderer& renderer, T& handler);
193
194    /**
195     * Issue the RenderNode's operations into a handler, recursing for subtrees through
196     * DrawDisplayListOp's defer() or replay() methods
197     */
198    template <class T>
199    inline void issueOperations(OpenGLRenderer& renderer, T& handler);
200
201    class TextContainer {
202    public:
203        size_t length() const {
204            return mByteLength;
205        }
206
207        const char* text() const {
208            return (const char*) mText;
209        }
210
211        size_t mByteLength;
212        const char* mText;
213    };
214
215    void prepareTreeImpl(TreeInfo& info);
216    void pushStagingChanges(TreeInfo& info);
217    void prepareSubTree(TreeInfo& info, DisplayListData* subtree);
218
219    String8 mName;
220
221    bool mNeedsPropertiesSync;
222    RenderProperties mProperties;
223    RenderProperties mStagingProperties;
224
225    bool mNeedsDisplayListDataSync;
226    DisplayListData* mDisplayListData;
227    DisplayListData* mStagingDisplayListData;
228
229    /**
230     * Draw time state - these properties are only set and used during rendering
231     */
232
233    // for projection surfaces, contains a list of all children items
234    Vector<DrawDisplayListOp*> mProjectedNodes;
235}; // class RenderNode
236
237} /* namespace uirenderer */
238} /* namespace android */
239
240#endif /* RENDERNODE_H */
241