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 | |
| 19 | #ifndef LOG_TAG |
| 20 | #define LOG_TAG "OpenGLRenderer" |
| 21 | #endif |
| 22 | |
| 23 | #include <SkCamera.h> |
| 24 | #include <SkMatrix.h> |
| 25 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 26 | #include <utils/LinearAllocator.h> |
| 27 | #include <utils/RefBase.h> |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 28 | #include <utils/String8.h> |
| 29 | #include <utils/Vector.h> |
| 30 | |
| 31 | #include <cutils/compiler.h> |
| 32 | |
| 33 | #include <androidfw/ResourceTypes.h> |
| 34 | |
John Reck | 68bfe0a | 2014-06-24 15:34:58 -0700 | [diff] [blame] | 35 | #include "AnimatorManager.h" |
John Reck | a447d29 | 2014-06-11 18:39:44 -0700 | [diff] [blame] | 36 | #include "DamageAccumulator.h" |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 37 | #include "Debug.h" |
| 38 | #include "Matrix.h" |
| 39 | #include "DeferredDisplayList.h" |
| 40 | #include "DisplayList.h" |
| 41 | #include "RenderProperties.h" |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 42 | #include "TreeInfo.h" |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 43 | |
| 44 | class SkBitmap; |
| 45 | class SkPaint; |
| 46 | class SkPath; |
| 47 | class SkRegion; |
| 48 | |
| 49 | namespace android { |
| 50 | namespace uirenderer { |
| 51 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 52 | class DisplayListOp; |
| 53 | class DisplayListRenderer; |
| 54 | class OpenGLRenderer; |
| 55 | class Rect; |
| 56 | class Layer; |
| 57 | class SkiaShader; |
| 58 | |
| 59 | class ClipRectOp; |
| 60 | class SaveLayerOp; |
| 61 | class SaveOp; |
| 62 | class RestoreToCountOp; |
Chris Craik | a7090e0 | 2014-06-20 16:01:00 -0700 | [diff] [blame] | 63 | class DrawRenderNodeOp; |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 64 | |
| 65 | /** |
| 66 | * Primary class for storing recorded canvas commands, as well as per-View/ViewGroup display properties. |
| 67 | * |
| 68 | * Recording of canvas commands is somewhat similar to SkPicture, except the canvas-recording |
| 69 | * functionality is split between DisplayListRenderer (which manages the recording), DisplayListData |
| 70 | * (which holds the actual data), and DisplayList (which holds properties and performs playback onto |
| 71 | * a renderer). |
| 72 | * |
| 73 | * Note that DisplayListData is swapped out from beneath an individual DisplayList when a view's |
| 74 | * recorded stream of canvas operations is refreshed. The DisplayList (and its properties) stay |
| 75 | * attached. |
| 76 | */ |
John Reck | 087bc0c | 2014-04-04 16:20:08 -0700 | [diff] [blame] | 77 | class RenderNode : public VirtualLightRefBase { |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 78 | public: |
John Reck | ff941dc | 2014-05-14 16:34:14 -0700 | [diff] [blame] | 79 | enum DirtyPropertyMask { |
| 80 | GENERIC = 1 << 1, |
| 81 | TRANSLATION_X = 1 << 2, |
| 82 | TRANSLATION_Y = 1 << 3, |
| 83 | TRANSLATION_Z = 1 << 4, |
| 84 | SCALE_X = 1 << 5, |
| 85 | SCALE_Y = 1 << 6, |
| 86 | ROTATION = 1 << 7, |
| 87 | ROTATION_X = 1 << 8, |
| 88 | ROTATION_Y = 1 << 9, |
| 89 | X = 1 << 10, |
| 90 | Y = 1 << 11, |
| 91 | Z = 1 << 12, |
| 92 | ALPHA = 1 << 13, |
John Reck | a7c2ea2 | 2014-08-08 13:21:00 -0700 | [diff] [blame] | 93 | DISPLAY_LIST = 1 << 14, |
John Reck | ff941dc | 2014-05-14 16:34:14 -0700 | [diff] [blame] | 94 | }; |
| 95 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 96 | ANDROID_API RenderNode(); |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 97 | ANDROID_API virtual ~RenderNode(); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 98 | |
| 99 | // See flags defined in DisplayList.java |
| 100 | enum ReplayFlag { |
| 101 | kReplayFlag_ClipChildren = 0x1 |
| 102 | }; |
| 103 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 104 | ANDROID_API static void outputLogBuffer(int fd); |
John Reck | 443a714 | 2014-09-04 17:40:05 -0700 | [diff] [blame] | 105 | void debugDumpLayers(const char* prefix); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 106 | |
John Reck | 8de65a8 | 2014-04-09 15:23:38 -0700 | [diff] [blame] | 107 | ANDROID_API void setStagingDisplayList(DisplayListData* newData); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 108 | |
| 109 | void computeOrdering(); |
Chris Craik | b265e2c | 2014-03-27 15:50:09 -0700 | [diff] [blame] | 110 | |
Chris Craik | 80d4902 | 2014-06-20 15:03:43 -0700 | [diff] [blame] | 111 | void defer(DeferStateStruct& deferStruct, const int level); |
| 112 | void replay(ReplayStateStruct& replayStruct, const int level); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 113 | |
| 114 | ANDROID_API void output(uint32_t level = 1); |
John Reck | fe5e7b7 | 2014-05-23 17:42:28 -0700 | [diff] [blame] | 115 | ANDROID_API int getDebugSize(); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 116 | |
| 117 | bool isRenderable() const { |
Chris Craik | 8afd0f2 | 2014-08-21 17:41:57 -0700 | [diff] [blame] | 118 | return mDisplayListData && !mDisplayListData->isEmpty(); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 119 | } |
| 120 | |
John Reck | a447d29 | 2014-06-11 18:39:44 -0700 | [diff] [blame] | 121 | bool hasProjectionReceiver() const { |
| 122 | return mDisplayListData && mDisplayListData->projectionReceiveIndex >= 0; |
| 123 | } |
| 124 | |
Chris Craik | defb7f3 | 2014-04-08 18:17:07 -0700 | [diff] [blame] | 125 | const char* getName() const { |
| 126 | return mName.string(); |
| 127 | } |
| 128 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 129 | void setName(const char* name) { |
| 130 | if (name) { |
| 131 | char* lastPeriod = strrchr(name, '.'); |
| 132 | if (lastPeriod) { |
| 133 | mName.setTo(lastPeriod + 1); |
| 134 | } else { |
| 135 | mName.setTo(name); |
| 136 | } |
| 137 | } |
| 138 | } |
| 139 | |
John Reck | ff941dc | 2014-05-14 16:34:14 -0700 | [diff] [blame] | 140 | bool isPropertyFieldDirty(DirtyPropertyMask field) const { |
| 141 | return mDirtyPropertyFields & field; |
| 142 | } |
| 143 | |
| 144 | void setPropertyFieldsDirty(uint32_t fields) { |
| 145 | mDirtyPropertyFields |= fields; |
| 146 | } |
| 147 | |
John Reck | e4267ea | 2014-06-03 15:53:15 -0700 | [diff] [blame] | 148 | const RenderProperties& properties() const { |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 149 | return mProperties; |
| 150 | } |
| 151 | |
John Reck | 52244ff | 2014-05-01 21:27:37 -0700 | [diff] [blame] | 152 | RenderProperties& animatorProperties() { |
| 153 | return mProperties; |
| 154 | } |
| 155 | |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 156 | const RenderProperties& stagingProperties() { |
| 157 | return mStagingProperties; |
| 158 | } |
| 159 | |
| 160 | RenderProperties& mutateStagingProperties() { |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 161 | return mStagingProperties; |
| 162 | } |
| 163 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 164 | int getWidth() { |
| 165 | return properties().getWidth(); |
| 166 | } |
| 167 | |
| 168 | int getHeight() { |
| 169 | return properties().getHeight(); |
| 170 | } |
| 171 | |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 172 | ANDROID_API virtual void prepareTree(TreeInfo& info); |
John Reck | dcba672 | 2014-07-08 13:59:49 -0700 | [diff] [blame] | 173 | void destroyHardwareResources(); |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 174 | |
| 175 | // UI thread only! |
John Reck | 68bfe0a | 2014-06-24 15:34:58 -0700 | [diff] [blame] | 176 | ANDROID_API void addAnimator(const sp<BaseRenderNodeAnimator>& animator); |
John Reck | 668f0e3 | 2014-03-26 15:10:40 -0700 | [diff] [blame] | 177 | |
John Reck | 119907c | 2014-08-14 09:02:01 -0700 | [diff] [blame] | 178 | AnimatorManager& animators() { return mAnimatorManager; } |
| 179 | |
Chris Craik | 69e5adf | 2014-08-14 13:34:01 -0700 | [diff] [blame] | 180 | void applyViewPropertyTransforms(mat4& matrix, bool true3dTransform = false) const; |
| 181 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 182 | private: |
Chris Craik | a7090e0 | 2014-06-20 16:01:00 -0700 | [diff] [blame] | 183 | typedef key_value_pair_t<float, DrawRenderNodeOp*> ZDrawRenderNodeOpPair; |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 184 | |
Chris Craik | a7090e0 | 2014-06-20 16:01:00 -0700 | [diff] [blame] | 185 | static size_t findNonNegativeIndex(const Vector<ZDrawRenderNodeOpPair>& nodes) { |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 186 | for (size_t i = 0; i < nodes.size(); i++) { |
| 187 | if (nodes[i].key >= 0.0f) return i; |
| 188 | } |
| 189 | return nodes.size(); |
| 190 | } |
| 191 | |
| 192 | enum ChildrenSelectMode { |
| 193 | kNegativeZChildren, |
| 194 | kPositiveZChildren |
| 195 | }; |
| 196 | |
Chris Craik | a7090e0 | 2014-06-20 16:01:00 -0700 | [diff] [blame] | 197 | void computeOrderingImpl(DrawRenderNodeOp* opState, |
Chris Craik | 3f085429 | 2014-04-15 16:18:08 -0700 | [diff] [blame] | 198 | const SkPath* outlineOfProjectionSurface, |
Chris Craik | a7090e0 | 2014-06-20 16:01:00 -0700 | [diff] [blame] | 199 | Vector<DrawRenderNodeOp*>* compositedChildrenOfProjectionSurface, |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 200 | const mat4* transformFromProjectionSurface); |
| 201 | |
| 202 | template <class T> |
Chris Craik | b265e2c | 2014-03-27 15:50:09 -0700 | [diff] [blame] | 203 | inline void setViewProperties(OpenGLRenderer& renderer, T& handler); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 204 | |
Chris Craik | 8afd0f2 | 2014-08-21 17:41:57 -0700 | [diff] [blame] | 205 | void buildZSortedChildList(const DisplayListData::Chunk& chunk, |
| 206 | Vector<ZDrawRenderNodeOpPair>& zTranslatedNodes); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 207 | |
Chris Craik | b265e2c | 2014-03-27 15:50:09 -0700 | [diff] [blame] | 208 | template<class T> |
| 209 | inline void issueDrawShadowOperation(const Matrix4& transformFromParent, T& handler); |
| 210 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 211 | template <class T> |
Chris Craik | c3e75f9 | 2014-08-27 15:34:52 -0700 | [diff] [blame] | 212 | inline void issueOperationsOf3dChildren(ChildrenSelectMode mode, |
| 213 | const Matrix4& initialTransform, const Vector<ZDrawRenderNodeOpPair>& zTranslatedNodes, |
Chris Craik | 80d4902 | 2014-06-20 15:03:43 -0700 | [diff] [blame] | 214 | OpenGLRenderer& renderer, T& handler); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 215 | |
| 216 | template <class T> |
Chris Craik | b265e2c | 2014-03-27 15:50:09 -0700 | [diff] [blame] | 217 | inline void issueOperationsOfProjectedChildren(OpenGLRenderer& renderer, T& handler); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 218 | |
Chris Craik | b265e2c | 2014-03-27 15:50:09 -0700 | [diff] [blame] | 219 | /** |
| 220 | * Issue the RenderNode's operations into a handler, recursing for subtrees through |
Chris Craik | a7090e0 | 2014-06-20 16:01:00 -0700 | [diff] [blame] | 221 | * DrawRenderNodeOp's defer() or replay() methods |
Chris Craik | b265e2c | 2014-03-27 15:50:09 -0700 | [diff] [blame] | 222 | */ |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 223 | template <class T> |
Chris Craik | b265e2c | 2014-03-27 15:50:09 -0700 | [diff] [blame] | 224 | inline void issueOperations(OpenGLRenderer& renderer, T& handler); |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 225 | |
| 226 | class TextContainer { |
| 227 | public: |
| 228 | size_t length() const { |
| 229 | return mByteLength; |
| 230 | } |
| 231 | |
| 232 | const char* text() const { |
| 233 | return (const char*) mText; |
| 234 | } |
| 235 | |
| 236 | size_t mByteLength; |
| 237 | const char* mText; |
| 238 | }; |
| 239 | |
John Reck | f4198b7 | 2014-04-09 17:00:04 -0700 | [diff] [blame] | 240 | void prepareTreeImpl(TreeInfo& info); |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 241 | void pushStagingPropertiesChanges(TreeInfo& info); |
| 242 | void pushStagingDisplayListChanges(TreeInfo& info); |
John Reck | f4198b7 | 2014-04-09 17:00:04 -0700 | [diff] [blame] | 243 | void prepareSubTree(TreeInfo& info, DisplayListData* subtree); |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 244 | void applyLayerPropertiesToLayer(TreeInfo& info); |
John Reck | a7c2ea2 | 2014-08-08 13:21:00 -0700 | [diff] [blame] | 245 | void prepareLayer(TreeInfo& info, uint32_t dirtyMask); |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 246 | void pushLayerUpdate(TreeInfo& info); |
John Reck | dcba672 | 2014-07-08 13:59:49 -0700 | [diff] [blame] | 247 | void deleteDisplayListData(); |
John Reck | 0a97330 | 2014-07-16 13:29:45 -0700 | [diff] [blame] | 248 | void damageSelf(TreeInfo& info); |
John Reck | dcba672 | 2014-07-08 13:59:49 -0700 | [diff] [blame] | 249 | |
| 250 | void incParentRefCount() { mParentCount++; } |
| 251 | void decParentRefCount(); |
John Reck | 8de65a8 | 2014-04-09 15:23:38 -0700 | [diff] [blame] | 252 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 253 | String8 mName; |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 254 | |
John Reck | ff941dc | 2014-05-14 16:34:14 -0700 | [diff] [blame] | 255 | uint32_t mDirtyPropertyFields; |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 256 | RenderProperties mProperties; |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 257 | RenderProperties mStagingProperties; |
| 258 | |
John Reck | 8de65a8 | 2014-04-09 15:23:38 -0700 | [diff] [blame] | 259 | bool mNeedsDisplayListDataSync; |
John Reck | dcba672 | 2014-07-08 13:59:49 -0700 | [diff] [blame] | 260 | // WARNING: Do not delete this directly, you must go through deleteDisplayListData()! |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 261 | DisplayListData* mDisplayListData; |
John Reck | 8de65a8 | 2014-04-09 15:23:38 -0700 | [diff] [blame] | 262 | DisplayListData* mStagingDisplayListData; |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 263 | |
John Reck | 68bfe0a | 2014-06-24 15:34:58 -0700 | [diff] [blame] | 264 | friend class AnimatorManager; |
| 265 | AnimatorManager mAnimatorManager; |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 266 | |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 267 | // Owned by RT. Lifecycle is managed by prepareTree(), with the exception |
| 268 | // being in ~RenderNode() which may happen on any thread. |
| 269 | Layer* mLayer; |
| 270 | |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 271 | /** |
| 272 | * Draw time state - these properties are only set and used during rendering |
| 273 | */ |
| 274 | |
| 275 | // for projection surfaces, contains a list of all children items |
Chris Craik | a7090e0 | 2014-06-20 16:01:00 -0700 | [diff] [blame] | 276 | Vector<DrawRenderNodeOp*> mProjectedNodes; |
John Reck | dcba672 | 2014-07-08 13:59:49 -0700 | [diff] [blame] | 277 | |
| 278 | // How many references our parent(s) have to us. Typically this should alternate |
| 279 | // between 2 and 1 (when a staging push happens we inc first then dec) |
| 280 | // When this hits 0 we are no longer in the tree, so any hardware resources |
| 281 | // (specifically Layers) should be released. |
| 282 | // This is *NOT* thread-safe, and should therefore only be tracking |
| 283 | // mDisplayListData, not mStagingDisplayListData. |
| 284 | uint32_t mParentCount; |
John Reck | 113e082 | 2014-03-18 09:22:59 -0700 | [diff] [blame] | 285 | }; // class RenderNode |
| 286 | |
| 287 | } /* namespace uirenderer */ |
| 288 | } /* namespace android */ |
| 289 | |
| 290 | #endif /* RENDERNODE_H */ |