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