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