John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 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 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 19 | #include <SkCamera.h> |
| 20 | #include <SkMatrix.h> |
| 21 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 22 | #include <utils/LinearAllocator.h> |
| 23 | #include <utils/RefBase.h> |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 24 | #include <utils/String8.h> |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 25 | |
| 26 | #include <cutils/compiler.h> |
| 27 | |
| 28 | #include <androidfw/ResourceTypes.h> |
| 29 | |
John Reck | 68bfe0a | 2014-06-24 15:34:58 -0700 | [diff] [blame] | 30 | #include "AnimatorManager.h" |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 31 | #include "Debug.h" |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 32 | #include "DisplayList.h" |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 33 | #include "Matrix.h" |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 34 | #include "RenderProperties.h" |
| 35 | |
John Reck | 272a685 | 2015-07-29 16:48:58 -0700 | [diff] [blame] | 36 | #include <vector> |
| 37 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 38 | class SkBitmap; |
| 39 | class SkPaint; |
| 40 | class SkPath; |
| 41 | class SkRegion; |
| 42 | |
| 43 | namespace android { |
| 44 | namespace uirenderer { |
| 45 | |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 46 | class CanvasState; |
Chris Craik | db663fe | 2015-04-20 13:34:45 -0700 | [diff] [blame] | 47 | class DisplayListCanvas; |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 48 | class DisplayListOp; |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 49 | class OpenGLRenderer; |
| 50 | class Rect; |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 51 | class SkiaShader; |
| 52 | |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 53 | #if HWUI_NEW_OPS |
Chris Craik | f158b49 | 2016-01-12 14:45:08 -0800 | [diff] [blame] | 54 | class FrameBuilder; |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 55 | class OffscreenBuffer; |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 56 | struct RenderNodeOp; |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 57 | typedef OffscreenBuffer layer_t; |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 58 | typedef RenderNodeOp renderNodeOp_t; |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 59 | #else |
| 60 | class Layer; |
| 61 | typedef Layer layer_t; |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 62 | typedef DrawRenderNodeOp renderNodeOp_t; |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 63 | #endif |
| 64 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 65 | class ClipRectOp; |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 66 | class DrawRenderNodeOp; |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 67 | class SaveLayerOp; |
| 68 | class SaveOp; |
| 69 | class RestoreToCountOp; |
Tom Hudson | 2dc236b | 2014-10-15 15:46:42 -0400 | [diff] [blame] | 70 | class TreeInfo; |
John Reck | 44b49f0 | 2016-03-25 14:29:48 -0700 | [diff] [blame] | 71 | class TreeObserver; |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 72 | |
John Reck | e248bd1 | 2015-08-05 13:53:53 -0700 | [diff] [blame] | 73 | namespace proto { |
| 74 | class RenderNode; |
| 75 | } |
| 76 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 77 | /** |
| 78 | * Primary class for storing recorded canvas commands, as well as per-View/ViewGroup display properties. |
| 79 | * |
| 80 | * Recording of canvas commands is somewhat similar to SkPicture, except the canvas-recording |
Chris Craik | 003cc3d | 2015-10-16 10:24:55 -0700 | [diff] [blame] | 81 | * functionality is split between DisplayListCanvas (which manages the recording), DisplayList |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 82 | * (which holds the actual data), and DisplayList (which holds properties and performs playback onto |
| 83 | * a renderer). |
| 84 | * |
Chris Craik | 003cc3d | 2015-10-16 10:24:55 -0700 | [diff] [blame] | 85 | * Note that DisplayList is swapped out from beneath an individual RenderNode when a view's |
| 86 | * recorded stream of canvas operations is refreshed. The RenderNode (and its properties) stay |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 87 | * attached. |
| 88 | */ |
John Reck | 087bc0c | 2014-04-04 16:20:08 -0700 | [diff] [blame] | 89 | class RenderNode : public VirtualLightRefBase { |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 90 | friend class TestUtils; // allow TestUtils to access syncDisplayList / syncProperties |
Chris Craik | f158b49 | 2016-01-12 14:45:08 -0800 | [diff] [blame] | 91 | friend class FrameBuilder; |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 92 | public: |
John Reck | ff941dc | 2014-05-14 16:34:14 -0700 | [diff] [blame] | 93 | enum DirtyPropertyMask { |
| 94 | GENERIC = 1 << 1, |
| 95 | TRANSLATION_X = 1 << 2, |
| 96 | TRANSLATION_Y = 1 << 3, |
| 97 | TRANSLATION_Z = 1 << 4, |
| 98 | SCALE_X = 1 << 5, |
| 99 | SCALE_Y = 1 << 6, |
| 100 | ROTATION = 1 << 7, |
| 101 | ROTATION_X = 1 << 8, |
| 102 | ROTATION_Y = 1 << 9, |
| 103 | X = 1 << 10, |
| 104 | Y = 1 << 11, |
| 105 | Z = 1 << 12, |
| 106 | ALPHA = 1 << 13, |
John Reck | a7c2ea2 | 2014-08-08 13:21:00 -0700 | [diff] [blame] | 107 | DISPLAY_LIST = 1 << 14, |
John Reck | ff941dc | 2014-05-14 16:34:14 -0700 | [diff] [blame] | 108 | }; |
| 109 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 110 | ANDROID_API RenderNode(); |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 111 | ANDROID_API virtual ~RenderNode(); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 112 | |
| 113 | // See flags defined in DisplayList.java |
| 114 | enum ReplayFlag { |
| 115 | kReplayFlag_ClipChildren = 0x1 |
| 116 | }; |
| 117 | |
John Reck | 443a714 | 2014-09-04 17:40:05 -0700 | [diff] [blame] | 118 | void debugDumpLayers(const char* prefix); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 119 | |
John Reck | 51f2d60 | 2016-04-06 07:50:47 -0700 | [diff] [blame] | 120 | ANDROID_API void setStagingDisplayList(DisplayList* newData, TreeObserver* observer); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 121 | |
| 122 | void computeOrdering(); |
Chris Craik | b265e2c | 2014-03-27 15:50:09 -0700 | [diff] [blame] | 123 | |
Chris Craik | 80d4902 | 2014-06-20 15:03:43 -0700 | [diff] [blame] | 124 | void defer(DeferStateStruct& deferStruct, const int level); |
| 125 | void replay(ReplayStateStruct& replayStruct, const int level); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 126 | |
Chris Craik | 91eff22 | 2016-02-22 13:39:33 -0800 | [diff] [blame] | 127 | #if HWUI_NEW_OPS |
| 128 | ANDROID_API void output(uint32_t level = 0, const char* label = "Root"); |
| 129 | #else |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 130 | ANDROID_API void output(uint32_t level = 1); |
Chris Craik | 91eff22 | 2016-02-22 13:39:33 -0800 | [diff] [blame] | 131 | #endif |
John Reck | fe5e7b7 | 2014-05-23 17:42:28 -0700 | [diff] [blame] | 132 | ANDROID_API int getDebugSize(); |
John Reck | e248bd1 | 2015-08-05 13:53:53 -0700 | [diff] [blame] | 133 | void copyTo(proto::RenderNode* node); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 134 | |
| 135 | bool isRenderable() const { |
Chris Craik | 003cc3d | 2015-10-16 10:24:55 -0700 | [diff] [blame] | 136 | return mDisplayList && !mDisplayList->isEmpty(); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 137 | } |
| 138 | |
John Reck | a447d29 | 2014-06-11 18:39:44 -0700 | [diff] [blame] | 139 | bool hasProjectionReceiver() const { |
Chris Craik | 003cc3d | 2015-10-16 10:24:55 -0700 | [diff] [blame] | 140 | return mDisplayList && mDisplayList->projectionReceiveIndex >= 0; |
John Reck | a447d29 | 2014-06-11 18:39:44 -0700 | [diff] [blame] | 141 | } |
| 142 | |
Chris Craik | defb7f3 | 2014-04-08 18:17:07 -0700 | [diff] [blame] | 143 | const char* getName() const { |
| 144 | return mName.string(); |
| 145 | } |
| 146 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 147 | void setName(const char* name) { |
| 148 | if (name) { |
| 149 | char* lastPeriod = strrchr(name, '.'); |
| 150 | if (lastPeriod) { |
| 151 | mName.setTo(lastPeriod + 1); |
| 152 | } else { |
| 153 | mName.setTo(name); |
| 154 | } |
| 155 | } |
| 156 | } |
| 157 | |
John Reck | 44b49f0 | 2016-03-25 14:29:48 -0700 | [diff] [blame] | 158 | VirtualLightRefBase* getUserContext() const { |
| 159 | return mUserContext.get(); |
| 160 | } |
| 161 | |
| 162 | void setUserContext(VirtualLightRefBase* context) { |
| 163 | mUserContext = context; |
| 164 | } |
| 165 | |
John Reck | ff941dc | 2014-05-14 16:34:14 -0700 | [diff] [blame] | 166 | bool isPropertyFieldDirty(DirtyPropertyMask field) const { |
| 167 | return mDirtyPropertyFields & field; |
| 168 | } |
| 169 | |
| 170 | void setPropertyFieldsDirty(uint32_t fields) { |
| 171 | mDirtyPropertyFields |= fields; |
| 172 | } |
| 173 | |
John Reck | e4267ea | 2014-06-03 15:53:15 -0700 | [diff] [blame] | 174 | const RenderProperties& properties() const { |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 175 | return mProperties; |
| 176 | } |
| 177 | |
John Reck | 52244ff | 2014-05-01 21:27:37 -0700 | [diff] [blame] | 178 | RenderProperties& animatorProperties() { |
| 179 | return mProperties; |
| 180 | } |
| 181 | |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 182 | const RenderProperties& stagingProperties() { |
| 183 | return mStagingProperties; |
| 184 | } |
| 185 | |
| 186 | RenderProperties& mutateStagingProperties() { |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 187 | return mStagingProperties; |
| 188 | } |
| 189 | |
Chris Craik | 76caecf | 2015-11-02 19:17:45 -0800 | [diff] [blame] | 190 | int getWidth() const { |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 191 | return properties().getWidth(); |
| 192 | } |
| 193 | |
Chris Craik | 76caecf | 2015-11-02 19:17:45 -0800 | [diff] [blame] | 194 | int getHeight() const { |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 195 | return properties().getHeight(); |
| 196 | } |
| 197 | |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 198 | ANDROID_API virtual void prepareTree(TreeInfo& info); |
John Reck | 44b49f0 | 2016-03-25 14:29:48 -0700 | [diff] [blame] | 199 | void destroyHardwareResources(TreeObserver* observer); |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 200 | |
| 201 | // UI thread only! |
John Reck | 68bfe0a | 2014-06-24 15:34:58 -0700 | [diff] [blame] | 202 | ANDROID_API void addAnimator(const sp<BaseRenderNodeAnimator>& animator); |
Doris Liu | 8b08320 | 2016-02-19 21:46:06 +0000 | [diff] [blame] | 203 | void removeAnimator(const sp<BaseRenderNodeAnimator>& animator); |
| 204 | |
| 205 | // This can only happen during pushStaging() |
| 206 | void onAnimatorTargetChanged(BaseRenderNodeAnimator* animator) { |
| 207 | mAnimatorManager.onAnimatorTargetChanged(animator); |
| 208 | } |
John Reck | 668f0e3 | 2014-03-26 15:10:40 -0700 | [diff] [blame] | 209 | |
John Reck | 119907c | 2014-08-14 09:02:01 -0700 | [diff] [blame] | 210 | AnimatorManager& animators() { return mAnimatorManager; } |
| 211 | |
Chris Craik | 69e5adf | 2014-08-14 13:34:01 -0700 | [diff] [blame] | 212 | void applyViewPropertyTransforms(mat4& matrix, bool true3dTransform = false) const; |
| 213 | |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 214 | bool nothingToDraw() const { |
| 215 | const Outline& outline = properties().getOutline(); |
Chris Craik | 003cc3d | 2015-10-16 10:24:55 -0700 | [diff] [blame] | 216 | return mDisplayList == nullptr |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 217 | || properties().getAlpha() <= 0 |
| 218 | || (outline.getShouldClip() && outline.isEmpty()) |
| 219 | || properties().getScaleX() == 0 |
| 220 | || properties().getScaleY() == 0; |
| 221 | } |
| 222 | |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 223 | const DisplayList* getDisplayList() const { |
| 224 | return mDisplayList; |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 225 | } |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 226 | #if HWUI_NEW_OPS |
| 227 | OffscreenBuffer* getLayer() const { return mLayer; } |
| 228 | OffscreenBuffer** getLayerHandle() { return &mLayer; } // ugh... |
| 229 | #endif |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 230 | |
John Reck | f648108 | 2016-02-02 15:18:23 -0800 | [diff] [blame] | 231 | class ANDROID_API PositionListener { |
| 232 | public: |
| 233 | virtual ~PositionListener() {} |
| 234 | virtual void onPositionUpdated(RenderNode& node, const TreeInfo& info) = 0; |
| 235 | }; |
| 236 | |
| 237 | // Note this is not thread safe, this needs to be called |
| 238 | // before the RenderNode is used for drawing. |
| 239 | // RenderNode takes ownership of the pointer |
| 240 | ANDROID_API void setPositionListener(PositionListener* listener) { |
| 241 | mPositionListener.reset(listener); |
| 242 | } |
| 243 | |
John Reck | 44b49f0 | 2016-03-25 14:29:48 -0700 | [diff] [blame] | 244 | // This is only modified in MODE_FULL, so it can be safely accessed |
| 245 | // on the UI thread. |
| 246 | ANDROID_API bool hasParents() { |
| 247 | return mParentCount; |
| 248 | } |
| 249 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 250 | private: |
Chris Craik | a7090e0 | 2014-06-20 16:01:00 -0700 | [diff] [blame] | 251 | typedef key_value_pair_t<float, DrawRenderNodeOp*> ZDrawRenderNodeOpPair; |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 252 | |
John Reck | 272a685 | 2015-07-29 16:48:58 -0700 | [diff] [blame] | 253 | static size_t findNonNegativeIndex(const std::vector<ZDrawRenderNodeOpPair>& nodes) { |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 254 | for (size_t i = 0; i < nodes.size(); i++) { |
| 255 | if (nodes[i].key >= 0.0f) return i; |
| 256 | } |
| 257 | return nodes.size(); |
| 258 | } |
| 259 | |
Chris Craik | b9ce116d | 2015-08-20 15:14:06 -0700 | [diff] [blame] | 260 | enum class ChildrenSelectMode { |
| 261 | NegativeZChildren, |
| 262 | PositiveZChildren |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 263 | }; |
| 264 | |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 265 | void computeOrderingImpl(renderNodeOp_t* opState, |
| 266 | std::vector<renderNodeOp_t*>* compositedChildrenOfProjectionSurface, |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 267 | const mat4* transformFromProjectionSurface); |
| 268 | |
| 269 | template <class T> |
Chris Craik | b265e2c | 2014-03-27 15:50:09 -0700 | [diff] [blame] | 270 | inline void setViewProperties(OpenGLRenderer& renderer, T& handler); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 271 | |
Chris Craik | 003cc3d | 2015-10-16 10:24:55 -0700 | [diff] [blame] | 272 | void buildZSortedChildList(const DisplayList::Chunk& chunk, |
John Reck | 272a685 | 2015-07-29 16:48:58 -0700 | [diff] [blame] | 273 | std::vector<ZDrawRenderNodeOpPair>& zTranslatedNodes); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 274 | |
Chris Craik | b265e2c | 2014-03-27 15:50:09 -0700 | [diff] [blame] | 275 | template<class T> |
| 276 | inline void issueDrawShadowOperation(const Matrix4& transformFromParent, T& handler); |
| 277 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 278 | template <class T> |
Chris Craik | c3e75f9 | 2014-08-27 15:34:52 -0700 | [diff] [blame] | 279 | inline void issueOperationsOf3dChildren(ChildrenSelectMode mode, |
John Reck | 272a685 | 2015-07-29 16:48:58 -0700 | [diff] [blame] | 280 | const Matrix4& initialTransform, const std::vector<ZDrawRenderNodeOpPair>& zTranslatedNodes, |
Chris Craik | 80d4902 | 2014-06-20 15:03:43 -0700 | [diff] [blame] | 281 | OpenGLRenderer& renderer, T& handler); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 282 | |
| 283 | template <class T> |
Chris Craik | b265e2c | 2014-03-27 15:50:09 -0700 | [diff] [blame] | 284 | inline void issueOperationsOfProjectedChildren(OpenGLRenderer& renderer, T& handler); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 285 | |
Chris Craik | b265e2c | 2014-03-27 15:50:09 -0700 | [diff] [blame] | 286 | /** |
| 287 | * Issue the RenderNode's operations into a handler, recursing for subtrees through |
Chris Craik | a7090e0 | 2014-06-20 16:01:00 -0700 | [diff] [blame] | 288 | * DrawRenderNodeOp's defer() or replay() methods |
Chris Craik | b265e2c | 2014-03-27 15:50:09 -0700 | [diff] [blame] | 289 | */ |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 290 | template <class T> |
Chris Craik | b265e2c | 2014-03-27 15:50:09 -0700 | [diff] [blame] | 291 | inline void issueOperations(OpenGLRenderer& renderer, T& handler); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 292 | |
| 293 | class TextContainer { |
| 294 | public: |
| 295 | size_t length() const { |
| 296 | return mByteLength; |
| 297 | } |
| 298 | |
| 299 | const char* text() const { |
| 300 | return (const char*) mText; |
| 301 | } |
| 302 | |
| 303 | size_t mByteLength; |
| 304 | const char* mText; |
| 305 | }; |
| 306 | |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 307 | |
| 308 | void syncProperties(); |
John Reck | 44b49f0 | 2016-03-25 14:29:48 -0700 | [diff] [blame] | 309 | void syncDisplayList(TreeObserver* observer); |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 310 | |
Chris Craik | a766cb2 | 2015-06-08 16:49:43 -0700 | [diff] [blame] | 311 | void prepareTreeImpl(TreeInfo& info, bool functorsNeedLayer); |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 312 | void pushStagingPropertiesChanges(TreeInfo& info); |
| 313 | void pushStagingDisplayListChanges(TreeInfo& info); |
Chris Craik | 003cc3d | 2015-10-16 10:24:55 -0700 | [diff] [blame] | 314 | void prepareSubTree(TreeInfo& info, bool functorsNeedLayer, DisplayList* subtree); |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 315 | #if !HWUI_NEW_OPS |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 316 | void applyLayerPropertiesToLayer(TreeInfo& info); |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 317 | #endif |
John Reck | a7c2ea2 | 2014-08-08 13:21:00 -0700 | [diff] [blame] | 318 | void prepareLayer(TreeInfo& info, uint32_t dirtyMask); |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 319 | void pushLayerUpdate(TreeInfo& info); |
John Reck | 44b49f0 | 2016-03-25 14:29:48 -0700 | [diff] [blame] | 320 | void deleteDisplayList(TreeObserver* observer); |
John Reck | 0a97330 | 2014-07-16 13:29:45 -0700 | [diff] [blame] | 321 | void damageSelf(TreeInfo& info); |
John Reck | dcba672 | 2014-07-08 13:59:49 -0700 | [diff] [blame] | 322 | |
| 323 | void incParentRefCount() { mParentCount++; } |
John Reck | 44b49f0 | 2016-03-25 14:29:48 -0700 | [diff] [blame] | 324 | void decParentRefCount(TreeObserver* observer); |
John Reck | 8de65a8 | 2014-04-09 15:23:38 -0700 | [diff] [blame] | 325 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 326 | String8 mName; |
John Reck | 44b49f0 | 2016-03-25 14:29:48 -0700 | [diff] [blame] | 327 | sp<VirtualLightRefBase> mUserContext; |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 328 | |
John Reck | ff941dc | 2014-05-14 16:34:14 -0700 | [diff] [blame] | 329 | uint32_t mDirtyPropertyFields; |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 330 | RenderProperties mProperties; |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 331 | RenderProperties mStagingProperties; |
| 332 | |
Chris Craik | 003cc3d | 2015-10-16 10:24:55 -0700 | [diff] [blame] | 333 | bool mNeedsDisplayListSync; |
| 334 | // WARNING: Do not delete this directly, you must go through deleteDisplayList()! |
| 335 | DisplayList* mDisplayList; |
| 336 | DisplayList* mStagingDisplayList; |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 337 | |
John Reck | 68bfe0a | 2014-06-24 15:34:58 -0700 | [diff] [blame] | 338 | friend class AnimatorManager; |
| 339 | AnimatorManager mAnimatorManager; |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 340 | |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 341 | // Owned by RT. Lifecycle is managed by prepareTree(), with the exception |
| 342 | // being in ~RenderNode() which may happen on any thread. |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 343 | layer_t* mLayer = nullptr; |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 344 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 345 | /** |
| 346 | * Draw time state - these properties are only set and used during rendering |
| 347 | */ |
| 348 | |
| 349 | // for projection surfaces, contains a list of all children items |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 350 | std::vector<renderNodeOp_t*> mProjectedNodes; |
John Reck | dcba672 | 2014-07-08 13:59:49 -0700 | [diff] [blame] | 351 | |
| 352 | // How many references our parent(s) have to us. Typically this should alternate |
| 353 | // between 2 and 1 (when a staging push happens we inc first then dec) |
| 354 | // When this hits 0 we are no longer in the tree, so any hardware resources |
| 355 | // (specifically Layers) should be released. |
| 356 | // This is *NOT* thread-safe, and should therefore only be tracking |
Chris Craik | 003cc3d | 2015-10-16 10:24:55 -0700 | [diff] [blame] | 357 | // mDisplayList, not mStagingDisplayList. |
John Reck | dcba672 | 2014-07-08 13:59:49 -0700 | [diff] [blame] | 358 | uint32_t mParentCount; |
John Reck | f648108 | 2016-02-02 15:18:23 -0800 | [diff] [blame] | 359 | |
| 360 | std::unique_ptr<PositionListener> mPositionListener; |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 361 | }; // class RenderNode |
| 362 | |
| 363 | } /* namespace uirenderer */ |
| 364 | } /* namespace android */ |
| 365 | |
| 366 | #endif /* RENDERNODE_H */ |