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