RenderNode.h revision a7090e0cfd7c719a6d4c03aae34f5db98754cbdd 
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 <set>
24#include <vector>
25
26#include <SkCamera.h>
27#include <SkMatrix.h>
28
29#include <private/hwui/DrawGlInfo.h>
30
31#include <utils/KeyedVector.h>
32#include <utils/LinearAllocator.h>
33#include <utils/RefBase.h>
34#include <utils/SortedVector.h>
35#include <utils/String8.h>
36#include <utils/Vector.h>
37
38#include <cutils/compiler.h>
39
40#include <androidfw/ResourceTypes.h>
41
42#include "DamageAccumulator.h"
43#include "Debug.h"
44#include "Matrix.h"
45#include "DeferredDisplayList.h"
46#include "DisplayList.h"
47#include "RenderProperties.h"
48#include "TreeInfo.h"
49
50class SkBitmap;
51class SkPaint;
52class SkPath;
53class SkRegion;
54
55namespace android {
56namespace uirenderer {
57
58class DeferredDisplayList;
59class DisplayListOp;
60class DisplayListRenderer;
61class OpenGLRenderer;
62class Rect;
63class Layer;
64class SkiaShader;
65
66class ClipRectOp;
67class SaveLayerOp;
68class SaveOp;
69class RestoreToCountOp;
70class DrawRenderNodeOp;
71
72/**
73 * Primary class for storing recorded canvas commands, as well as per-View/ViewGroup display properties.
74 *
75 * Recording of canvas commands is somewhat similar to SkPicture, except the canvas-recording
76 * functionality is split between DisplayListRenderer (which manages the recording), DisplayListData
77 * (which holds the actual data), and DisplayList (which holds properties and performs playback onto
78 * a renderer).
79 *
80 * Note that DisplayListData is swapped out from beneath an individual DisplayList when a view's
81 * recorded stream of canvas operations is refreshed. The DisplayList (and its properties) stay
82 * attached.
83 */
84class RenderNode : public VirtualLightRefBase {
85public:
86    enum DirtyPropertyMask {
87        GENERIC         = 1 << 1,
88        TRANSLATION_X   = 1 << 2,
89        TRANSLATION_Y   = 1 << 3,
90        TRANSLATION_Z   = 1 << 4,
91        SCALE_X         = 1 << 5,
92        SCALE_Y         = 1 << 6,
93        ROTATION        = 1 << 7,
94        ROTATION_X      = 1 << 8,
95        ROTATION_Y      = 1 << 9,
96        X               = 1 << 10,
97        Y               = 1 << 11,
98        Z               = 1 << 12,
99        ALPHA           = 1 << 13,
100    };
101
102    ANDROID_API RenderNode();
103    ANDROID_API virtual ~RenderNode();
104
105    // See flags defined in DisplayList.java
106    enum ReplayFlag {
107        kReplayFlag_ClipChildren = 0x1
108    };
109
110    ANDROID_API static void outputLogBuffer(int fd);
111
112    ANDROID_API void setStagingDisplayList(DisplayListData* newData);
113
114    void computeOrdering();
115
116    void defer(DeferStateStruct& deferStruct, const int level);
117    void replay(ReplayStateStruct& replayStruct, const int level);
118
119    ANDROID_API void output(uint32_t level = 1);
120    ANDROID_API int getDebugSize();
121
122    bool isRenderable() const {
123        return mDisplayListData && mDisplayListData->hasDrawOps;
124    }
125
126    bool hasProjectionReceiver() const {
127        return mDisplayListData && mDisplayListData->projectionReceiveIndex >= 0;
128    }
129
130    const char* getName() const {
131        return mName.string();
132    }
133
134    void setName(const char* name) {
135        if (name) {
136            char* lastPeriod = strrchr(name, '.');
137            if (lastPeriod) {
138                mName.setTo(lastPeriod + 1);
139            } else {
140                mName.setTo(name);
141            }
142        }
143    }
144
145    bool isPropertyFieldDirty(DirtyPropertyMask field) const {
146        return mDirtyPropertyFields & field;
147    }
148
149    void setPropertyFieldsDirty(uint32_t fields) {
150        mDirtyPropertyFields |= fields;
151    }
152
153    const RenderProperties& properties() const {
154        return mProperties;
155    }
156
157    RenderProperties& animatorProperties() {
158        return mProperties;
159    }
160
161    const RenderProperties& stagingProperties() {
162        return mStagingProperties;
163    }
164
165    RenderProperties& mutateStagingProperties() {
166        return mStagingProperties;
167    }
168
169    int getWidth() {
170        return properties().getWidth();
171    }
172
173    int getHeight() {
174        return properties().getHeight();
175    }
176
177    ANDROID_API virtual void prepareTree(TreeInfo& info);
178
179    // UI thread only!
180    ANDROID_API void addAnimator(const sp<BaseRenderNodeAnimator>& animator) {
181        animator->onAttached(this);
182        mStagingAnimators.insert(animator);
183        mNeedsAnimatorsSync = true;
184    }
185
186    // UI thread only!
187    ANDROID_API void removeAnimator(const sp<BaseRenderNodeAnimator>& animator) {
188        mStagingAnimators.erase(animator);
189        // Force a sync of the staging property value
190        mDirtyPropertyFields |= animator->dirtyMask();
191        mNeedsAnimatorsSync = true;
192    }
193
194protected:
195    virtual void damageSelf(TreeInfo& info);
196
197private:
198    typedef key_value_pair_t<float, DrawRenderNodeOp*> ZDrawRenderNodeOpPair;
199
200    static size_t findNonNegativeIndex(const Vector<ZDrawRenderNodeOpPair>& nodes) {
201        for (size_t i = 0; i < nodes.size(); i++) {
202            if (nodes[i].key >= 0.0f) return i;
203        }
204        return nodes.size();
205    }
206
207    enum ChildrenSelectMode {
208        kNegativeZChildren,
209        kPositiveZChildren
210    };
211
212    void applyViewPropertyTransforms(mat4& matrix, bool true3dTransform = false);
213
214    void computeOrderingImpl(DrawRenderNodeOp* opState,
215            const SkPath* outlineOfProjectionSurface,
216            Vector<DrawRenderNodeOp*>* compositedChildrenOfProjectionSurface,
217            const mat4* transformFromProjectionSurface);
218
219    template <class T>
220    inline void setViewProperties(OpenGLRenderer& renderer, T& handler);
221
222    void buildZSortedChildList(Vector<ZDrawRenderNodeOpPair>& zTranslatedNodes);
223
224    template<class T>
225    inline void issueDrawShadowOperation(const Matrix4& transformFromParent, T& handler);
226
227    template <class T>
228    inline int issueOperationsOfNegZChildren(
229            const Vector<ZDrawRenderNodeOpPair>& zTranslatedNodes,
230            OpenGLRenderer& renderer, T& handler);
231    template <class T>
232    inline void issueOperationsOfPosZChildren(int shadowRestoreTo,
233            const Vector<ZDrawRenderNodeOpPair>& zTranslatedNodes,
234            OpenGLRenderer& renderer, T& handler);
235    template <class T>
236    inline void issueOperationsOf3dChildren(const Vector<ZDrawRenderNodeOpPair>& zTranslatedNodes,
237            ChildrenSelectMode mode, OpenGLRenderer& renderer, T& handler);
238
239    template <class T>
240    inline void issueOperationsOfProjectedChildren(OpenGLRenderer& renderer, T& handler);
241
242    /**
243     * Issue the RenderNode's operations into a handler, recursing for subtrees through
244     * DrawRenderNodeOp's defer() or replay() methods
245     */
246    template <class T>
247    inline void issueOperations(OpenGLRenderer& renderer, T& handler);
248
249    class TextContainer {
250    public:
251        size_t length() const {
252            return mByteLength;
253        }
254
255        const char* text() const {
256            return (const char*) mText;
257        }
258
259        size_t mByteLength;
260        const char* mText;
261    };
262
263    void prepareTreeImpl(TreeInfo& info);
264    void pushStagingPropertiesChanges(TreeInfo& info);
265    void pushStagingDisplayListChanges(TreeInfo& info);
266    void evaluateAnimations(TreeInfo& info);
267    void prepareSubTree(TreeInfo& info, DisplayListData* subtree);
268    void applyLayerPropertiesToLayer(TreeInfo& info);
269    void prepareLayer(TreeInfo& info);
270    void pushLayerUpdate(TreeInfo& info);
271
272    String8 mName;
273
274    uint32_t mDirtyPropertyFields;
275    RenderProperties mProperties;
276    RenderProperties mStagingProperties;
277
278    bool mNeedsDisplayListDataSync;
279    DisplayListData* mDisplayListData;
280    DisplayListData* mStagingDisplayListData;
281
282    bool mNeedsAnimatorsSync;
283    std::set< sp<BaseRenderNodeAnimator> > mStagingAnimators;
284    std::vector< sp<BaseRenderNodeAnimator> > mAnimators;
285
286    // Owned by RT. Lifecycle is managed by prepareTree(), with the exception
287    // being in ~RenderNode() which may happen on any thread.
288    Layer* mLayer;
289
290    /**
291     * Draw time state - these properties are only set and used during rendering
292     */
293
294    // for projection surfaces, contains a list of all children items
295    Vector<DrawRenderNodeOp*> mProjectedNodes;
296}; // class RenderNode
297
298} /* namespace uirenderer */
299} /* namespace android */
300
301#endif /* RENDERNODE_H */
302