RenderNode.h revision 8de65a8e05285df52a1e6f0c1d5616dd233298a7 
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
68/**
69 * Primary class for storing recorded canvas commands, as well as per-View/ViewGroup display properties.
70 *
71 * Recording of canvas commands is somewhat similar to SkPicture, except the canvas-recording
72 * functionality is split between DisplayListRenderer (which manages the recording), DisplayListData
73 * (which holds the actual data), and DisplayList (which holds properties and performs playback onto
74 * a renderer).
75 *
76 * Note that DisplayListData is swapped out from beneath an individual DisplayList when a view's
77 * recorded stream of canvas operations is refreshed. The DisplayList (and its properties) stay
78 * attached.
79 */
80class RenderNode : public VirtualLightRefBase {
81public:
82    ANDROID_API RenderNode();
83    ANDROID_API ~RenderNode();
84
85    // See flags defined in DisplayList.java
86    enum ReplayFlag {
87        kReplayFlag_ClipChildren = 0x1
88    };
89
90    ANDROID_API static void outputLogBuffer(int fd);
91
92    ANDROID_API void setStagingDisplayList(DisplayListData* newData);
93
94    void computeOrdering();
95
96    void deferNodeTree(DeferStateStruct& deferStruct);
97    void deferNodeInParent(DeferStateStruct& deferStruct, const int level);
98
99    void replayNodeTree(ReplayStateStruct& replayStruct);
100    void replayNodeInParent(ReplayStateStruct& replayStruct, const int level);
101
102    ANDROID_API void output(uint32_t level = 1);
103
104    bool isRenderable() const {
105        return mDisplayListData && mDisplayListData->hasDrawOps;
106    }
107
108    void setName(const char* name) {
109        if (name) {
110            char* lastPeriod = strrchr(name, '.');
111            if (lastPeriod) {
112                mName.setTo(lastPeriod + 1);
113            } else {
114                mName.setTo(name);
115            }
116        }
117    }
118
119    const RenderProperties& properties() {
120        return mProperties;
121    }
122
123    const RenderProperties& stagingProperties() {
124        return mStagingProperties;
125    }
126
127    RenderProperties& mutateStagingProperties() {
128        mNeedsPropertiesSync = true;
129        return mStagingProperties;
130    }
131
132    bool isProjectionReceiver() {
133        return properties().isProjectionReceiver();
134    }
135
136    int getWidth() {
137        return properties().getWidth();
138    }
139
140    int getHeight() {
141        return properties().getHeight();
142    }
143
144    ANDROID_API void pushStagingChanges();
145
146    // Returns true if this RenderNode or any of its children have functors
147    bool hasFunctors();
148
149private:
150    typedef key_value_pair_t<float, DrawDisplayListOp*> ZDrawDisplayListOpPair;
151
152    static size_t findNonNegativeIndex(const Vector<ZDrawDisplayListOpPair>& nodes) {
153        for (size_t i = 0; i < nodes.size(); i++) {
154            if (nodes[i].key >= 0.0f) return i;
155        }
156        return nodes.size();
157    }
158
159    enum ChildrenSelectMode {
160        kNegativeZChildren,
161        kPositiveZChildren
162    };
163
164    void applyViewPropertyTransforms(mat4& matrix, bool true3dTransform = false);
165
166    void computeOrderingImpl(DrawDisplayListOp* opState,
167            Vector<DrawDisplayListOp*>* compositedChildrenOfProjectionSurface,
168            const mat4* transformFromProjectionSurface);
169
170    template <class T>
171    inline void setViewProperties(OpenGLRenderer& renderer, T& handler);
172
173    void buildZSortedChildList(Vector<ZDrawDisplayListOpPair>& zTranslatedNodes);
174
175    template<class T>
176    inline void issueDrawShadowOperation(const Matrix4& transformFromParent, T& handler);
177
178    template <class T>
179    inline void issueOperationsOf3dChildren(const Vector<ZDrawDisplayListOpPair>& zTranslatedNodes,
180            ChildrenSelectMode mode, OpenGLRenderer& renderer, T& handler);
181
182    template <class T>
183    inline void issueOperationsOfProjectedChildren(OpenGLRenderer& renderer, T& handler);
184
185    /**
186     * Issue the RenderNode's operations into a handler, recursing for subtrees through
187     * DrawDisplayListOp's defer() or replay() methods
188     */
189    template <class T>
190    inline void issueOperations(OpenGLRenderer& renderer, T& handler);
191
192    class TextContainer {
193    public:
194        size_t length() const {
195            return mByteLength;
196        }
197
198        const char* text() const {
199            return (const char*) mText;
200        }
201
202        size_t mByteLength;
203        const char* mText;
204    };
205
206    static void pushSubTreeStagingChanges(DisplayListData* subtree);
207
208    String8 mName;
209    bool mDestroyed; // used for debugging crash, TODO: remove once invalid state crash fixed
210
211    bool mNeedsPropertiesSync;
212    RenderProperties mProperties;
213    RenderProperties mStagingProperties;
214
215    bool mNeedsDisplayListDataSync;
216    DisplayListData* mDisplayListData;
217    DisplayListData* mStagingDisplayListData;
218
219    /**
220     * Draw time state - these properties are only set and used during rendering
221     */
222
223    // for projection surfaces, contains a list of all children items
224    Vector<DrawDisplayListOp*> mProjectedNodes;
225}; // class RenderNode
226
227} /* namespace uirenderer */
228} /* namespace android */
229
230#endif /* RENDERNODE_H */
231