RenderNode.h revision b565df13a9e5c7b1d7d93bdfa4a793752d66d3cc
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#include <SkCamera.h> 20#include <SkMatrix.h> 21 22#include <utils/LinearAllocator.h> 23#include <utils/RefBase.h> 24#include <utils/String8.h> 25 26#include <cutils/compiler.h> 27 28#include <androidfw/ResourceTypes.h> 29 30#include "AnimatorManager.h" 31#include "Debug.h" 32#include "DisplayList.h" 33#include "Matrix.h" 34#include "RenderProperties.h" 35 36#include <vector> 37 38class SkBitmap; 39class SkPaint; 40class SkPath; 41class SkRegion; 42 43namespace android { 44namespace uirenderer { 45 46class CanvasState; 47class DisplayListOp; 48class DisplayListCanvas; 49class OpenGLRenderer; 50class Rect; 51class Layer; 52class SkiaShader; 53 54class ClipRectOp; 55class SaveLayerOp; 56class SaveOp; 57class RestoreToCountOp; 58class DrawRenderNodeOp; 59class TreeInfo; 60 61namespace proto { 62class RenderNode; 63} 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 DisplayListCanvas (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 */ 77class RenderNode : public VirtualLightRefBase { 78friend class TestUtils; // allow TestUtils to access syncDisplayList / syncProperties 79public: 80 enum DirtyPropertyMask { 81 GENERIC = 1 << 1, 82 TRANSLATION_X = 1 << 2, 83 TRANSLATION_Y = 1 << 3, 84 TRANSLATION_Z = 1 << 4, 85 SCALE_X = 1 << 5, 86 SCALE_Y = 1 << 6, 87 ROTATION = 1 << 7, 88 ROTATION_X = 1 << 8, 89 ROTATION_Y = 1 << 9, 90 X = 1 << 10, 91 Y = 1 << 11, 92 Z = 1 << 12, 93 ALPHA = 1 << 13, 94 DISPLAY_LIST = 1 << 14, 95 }; 96 97 ANDROID_API RenderNode(); 98 ANDROID_API virtual ~RenderNode(); 99 100 // See flags defined in DisplayList.java 101 enum ReplayFlag { 102 kReplayFlag_ClipChildren = 0x1 103 }; 104 105 void debugDumpLayers(const char* prefix); 106 107 ANDROID_API void setStagingDisplayList(DisplayListData* newData); 108 109 void computeOrdering(); 110 111 void defer(DeferStateStruct& deferStruct, const int level); 112 void replay(ReplayStateStruct& replayStruct, const int level); 113 114 ANDROID_API void output(uint32_t level = 1); 115 ANDROID_API int getDebugSize(); 116 void copyTo(proto::RenderNode* node); 117 118 bool isRenderable() const { 119 return mDisplayListData && !mDisplayListData->isEmpty(); 120 } 121 122 bool hasProjectionReceiver() const { 123 return mDisplayListData && mDisplayListData->projectionReceiveIndex >= 0; 124 } 125 126 const char* getName() const { 127 return mName.string(); 128 } 129 130 void setName(const char* name) { 131 if (name) { 132 char* lastPeriod = strrchr(name, '.'); 133 if (lastPeriod) { 134 mName.setTo(lastPeriod + 1); 135 } else { 136 mName.setTo(name); 137 } 138 } 139 } 140 141 bool isPropertyFieldDirty(DirtyPropertyMask field) const { 142 return mDirtyPropertyFields & field; 143 } 144 145 void setPropertyFieldsDirty(uint32_t fields) { 146 mDirtyPropertyFields |= fields; 147 } 148 149 const RenderProperties& properties() const { 150 return mProperties; 151 } 152 153 RenderProperties& animatorProperties() { 154 return mProperties; 155 } 156 157 const RenderProperties& stagingProperties() { 158 return mStagingProperties; 159 } 160 161 RenderProperties& mutateStagingProperties() { 162 return mStagingProperties; 163 } 164 165 int getWidth() { 166 return properties().getWidth(); 167 } 168 169 int getHeight() { 170 return properties().getHeight(); 171 } 172 173 ANDROID_API virtual void prepareTree(TreeInfo& info); 174 void destroyHardwareResources(); 175 176 // UI thread only! 177 ANDROID_API void addAnimator(const sp<BaseRenderNodeAnimator>& animator); 178 179 AnimatorManager& animators() { return mAnimatorManager; } 180 181 // Returns false if the properties dictate the subtree contained in this RenderNode won't render 182 bool applyViewProperties(CanvasState& canvasState) const; 183 184 void applyViewPropertyTransforms(mat4& matrix, bool true3dTransform = false) const; 185 186 bool nothingToDraw() const { 187 const Outline& outline = properties().getOutline(); 188 return mDisplayListData == nullptr 189 || properties().getAlpha() <= 0 190 || (outline.getShouldClip() && outline.isEmpty()) 191 || properties().getScaleX() == 0 192 || properties().getScaleY() == 0; 193 } 194 195 // Only call if RenderNode has DisplayListData... 196 const DisplayListData& getDisplayListData() const { 197 return *mDisplayListData; 198 } 199 200private: 201 typedef key_value_pair_t<float, DrawRenderNodeOp*> ZDrawRenderNodeOpPair; 202 203 static size_t findNonNegativeIndex(const std::vector<ZDrawRenderNodeOpPair>& nodes) { 204 for (size_t i = 0; i < nodes.size(); i++) { 205 if (nodes[i].key >= 0.0f) return i; 206 } 207 return nodes.size(); 208 } 209 210 enum class ChildrenSelectMode { 211 NegativeZChildren, 212 PositiveZChildren 213 }; 214 215 void computeOrderingImpl(DrawRenderNodeOp* opState, 216 std::vector<DrawRenderNodeOp*>* compositedChildrenOfProjectionSurface, 217 const mat4* transformFromProjectionSurface); 218 219 template <class T> 220 inline void setViewProperties(OpenGLRenderer& renderer, T& handler); 221 222 void buildZSortedChildList(const DisplayListData::Chunk& chunk, 223 std::vector<ZDrawRenderNodeOpPair>& zTranslatedNodes); 224 225 template<class T> 226 inline void issueDrawShadowOperation(const Matrix4& transformFromParent, T& handler); 227 228 template <class T> 229 inline void issueOperationsOf3dChildren(ChildrenSelectMode mode, 230 const Matrix4& initialTransform, const std::vector<ZDrawRenderNodeOpPair>& zTranslatedNodes, 231 OpenGLRenderer& renderer, T& handler); 232 233 template <class T> 234 inline void issueOperationsOfProjectedChildren(OpenGLRenderer& renderer, T& handler); 235 236 /** 237 * Issue the RenderNode's operations into a handler, recursing for subtrees through 238 * DrawRenderNodeOp's defer() or replay() methods 239 */ 240 template <class T> 241 inline void issueOperations(OpenGLRenderer& renderer, T& handler); 242 243 class TextContainer { 244 public: 245 size_t length() const { 246 return mByteLength; 247 } 248 249 const char* text() const { 250 return (const char*) mText; 251 } 252 253 size_t mByteLength; 254 const char* mText; 255 }; 256 257 258 void syncProperties(); 259 void syncDisplayList(); 260 261 void prepareTreeImpl(TreeInfo& info, bool functorsNeedLayer); 262 void pushStagingPropertiesChanges(TreeInfo& info); 263 void pushStagingDisplayListChanges(TreeInfo& info); 264 void prepareSubTree(TreeInfo& info, bool functorsNeedLayer, DisplayListData* subtree); 265 void applyLayerPropertiesToLayer(TreeInfo& info); 266 void prepareLayer(TreeInfo& info, uint32_t dirtyMask); 267 void pushLayerUpdate(TreeInfo& info); 268 void deleteDisplayListData(); 269 void damageSelf(TreeInfo& info); 270 271 void incParentRefCount() { mParentCount++; } 272 void decParentRefCount(); 273 274 String8 mName; 275 276 uint32_t mDirtyPropertyFields; 277 RenderProperties mProperties; 278 RenderProperties mStagingProperties; 279 280 bool mNeedsDisplayListDataSync; 281 // WARNING: Do not delete this directly, you must go through deleteDisplayListData()! 282 DisplayListData* mDisplayListData; 283 DisplayListData* mStagingDisplayListData; 284 285 friend class AnimatorManager; 286 AnimatorManager mAnimatorManager; 287 288 // Owned by RT. Lifecycle is managed by prepareTree(), with the exception 289 // being in ~RenderNode() which may happen on any thread. 290 Layer* mLayer; 291 292 /** 293 * Draw time state - these properties are only set and used during rendering 294 */ 295 296 // for projection surfaces, contains a list of all children items 297 std::vector<DrawRenderNodeOp*> mProjectedNodes; 298 299 // How many references our parent(s) have to us. Typically this should alternate 300 // between 2 and 1 (when a staging push happens we inc first then dec) 301 // When this hits 0 we are no longer in the tree, so any hardware resources 302 // (specifically Layers) should be released. 303 // This is *NOT* thread-safe, and should therefore only be tracking 304 // mDisplayListData, not mStagingDisplayListData. 305 uint32_t mParentCount; 306}; // class RenderNode 307 308} /* namespace uirenderer */ 309} /* namespace android */ 310 311#endif /* RENDERNODE_H */ 312