1 /* 2 * Copyright (c) 2021-2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 #ifndef RENDER_SERVICE_CLIENT_CORE_UI_RS_NODE_H 16 #define RENDER_SERVICE_CLIENT_CORE_UI_RS_NODE_H 17 18 #include <optional> 19 #include <unordered_map> 20 21 #include "animation/rs_animation_timing_curve.h" 22 #include "animation/rs_animation_timing_protocol.h" 23 #include "animation/rs_motion_path_option.h" 24 #include "animation/rs_particle_params.h" 25 #include "animation/rs_symbol_node_config.h" 26 #include "animation/rs_transition_effect.h" 27 #include "command/rs_animation_command.h" 28 #include "common/rs_vector2.h" 29 #include "common/rs_vector4.h" 30 #include "modifier/rs_modifier_extractor.h" 31 #include "modifier/rs_modifier_type.h" 32 #include "modifier/rs_showing_properties_freezer.h" 33 #include "pipeline/rs_recording_canvas.h" 34 #include "property/rs_properties.h" 35 #include "render/rs_mask.h" 36 #include "render/rs_path.h" 37 #include "ui_effect/effect/include/background_color_effect_para.h" 38 #include "ui_effect/effect/include/visual_effect.h" 39 #include "ui_effect/filter/include/filter.h" 40 #include "ui_effect/filter/include/filter_pixel_stretch_para.h" 41 #include "ui_effect/filter/include/filter_blur_para.h" 42 #include "ui_effect/filter/include/filter_water_ripple_para.h" 43 #include "ui_effect/filter/include/filter_fly_out_para.h" 44 #include "ui_effect/filter/include/filter_distort_para.h" 45 #include "transaction/rs_transaction_handler.h" 46 #include "transaction/rs_sync_transaction_handler.h" 47 #include "recording/recording_canvas.h" 48 49 namespace OHOS { 50 namespace Rosen { 51 using DrawFunc = std::function<void(std::shared_ptr<Drawing::Canvas>)>; 52 using PropertyCallback = std::function<void()>; 53 using BoundsChangedCallback = std::function<void (const Rosen::Vector4f&)>; 54 using ExportTypeChangedCallback = std::function<void(bool)>; 55 using DrawNodeChangeCallback = std::function<void(std::shared_ptr<RSNode> rsNode, bool isPositionZ)>; 56 class RSAnimation; 57 class RSCommand; 58 class RSImplicitAnimParam; 59 class RSImplicitAnimator; 60 class RSModifier; 61 class RSObjAbsGeometry; 62 class RSUIContext; 63 64 class RSC_EXPORT RSNode : public std::enable_shared_from_this<RSNode> { 65 public: 66 using WeakPtr = std::weak_ptr<RSNode>; 67 using SharedPtr = std::shared_ptr<RSNode>; 68 static inline constexpr RSUINodeType Type = RSUINodeType::RS_NODE; GetType()69 virtual RSUINodeType GetType() const 70 { 71 return Type; 72 } 73 74 RSNode(const RSNode&) = delete; 75 RSNode(const RSNode&&) = delete; 76 RSNode& operator=(const RSNode&) = delete; 77 RSNode& operator=(const RSNode&&) = delete; 78 virtual ~RSNode(); 79 80 // this id is ONLY used in hierarchy operation commands, this may differ from id_ when the node is a proxy node. GetHierarchyCommandNodeId()81 virtual NodeId GetHierarchyCommandNodeId() const 82 { 83 return id_; 84 } 85 86 virtual void AddChild(SharedPtr child, int index = -1); 87 void MoveChild(SharedPtr child, int index); 88 virtual void RemoveChild(SharedPtr child); 89 void RemoveChildByNodeId(NodeId childId); 90 void RemoveFromTree(); 91 virtual void ClearChildren(); GetChildren()92 const std::vector<NodeId>& GetChildren() const 93 { 94 return children_; 95 } 96 // ONLY support index in [0, childrenTotal) or index = -1, otherwise return std::nullopt 97 const std::optional<NodeId> GetChildIdByIndex(int index) const; 98 99 // Add/RemoveCrossParentChild only used as: the child is under multiple parents(e.g. a window cross multi-screens) 100 void AddCrossParentChild(SharedPtr child, int index); 101 void RemoveCrossParentChild(SharedPtr child, NodeId newParentId); 102 void SetIsCrossNode(bool isCrossNode); 103 104 // PC extend screen use this 105 void AddCrossScreenChild(SharedPtr child, int index, bool autoClearCloneNode = false); 106 void RemoveCrossScreenChild(SharedPtr child); 107 GetId()108 NodeId GetId() const 109 { 110 return id_; 111 } 112 GetFollowType()113 virtual FollowType GetFollowType() const 114 { 115 return FollowType::NONE; 116 } 117 118 bool IsInstanceOf(RSUINodeType type) const; 119 template<typename T> 120 RSC_EXPORT bool IsInstanceOf() const; 121 122 // type-safe reinterpret_cast 123 template<typename T> ReinterpretCast(const std::shared_ptr<RSNode> & node)124 static std::shared_ptr<T> ReinterpretCast(const std::shared_ptr<RSNode>& node) 125 { 126 return node ? node->ReinterpretCastTo<T>() : nullptr; 127 } 128 template<typename T> ReinterpretCastTo()129 std::shared_ptr<T> ReinterpretCastTo() 130 { 131 return (IsInstanceOf<T>()) ? std::static_pointer_cast<T>(shared_from_this()) : nullptr; 132 } 133 template<typename T> ReinterpretCastTo()134 std::shared_ptr<const T> ReinterpretCastTo() const 135 { 136 return (IsInstanceOf<T>()) ? std::static_pointer_cast<const T>(shared_from_this()) : nullptr; 137 } 138 139 void DumpTree(int depth, std::string& out) const; 140 virtual void Dump(std::string& out) const; 141 142 virtual std::string DumpNode(int depth) const; 143 SharedPtr GetParent(); 144 SetId(const NodeId & id)145 void SetId(const NodeId& id) 146 { 147 id_ = id; 148 } 149 150 bool IsUniRenderEnabled() const; 151 bool IsRenderServiceNode() const; 152 void SetTakeSurfaceForUIFlag(); 153 154 static std::vector<std::shared_ptr<RSAnimation>> Animate(const RSAnimationTimingProtocol& timingProtocol, 155 const RSAnimationTimingCurve& timingCurve, const PropertyCallback& callback, 156 const std::function<void()>& finishCallback = nullptr, const std::function<void()>& repeatCallback = nullptr); 157 158 static std::vector<std::shared_ptr<RSAnimation>> AnimateWithCurrentOptions( 159 const PropertyCallback& callback, const std::function<void()>& finishCallback, bool timingSensitive = true); 160 static std::vector<std::shared_ptr<RSAnimation>> AnimateWithCurrentCallback( 161 const RSAnimationTimingProtocol& timingProtocol, const RSAnimationTimingCurve& timingCurve, 162 const PropertyCallback& callback); 163 164 static void RegisterTransitionPair(NodeId inNodeId, NodeId outNodeId, const bool isInSameWindow); 165 static void UnregisterTransitionPair(NodeId inNodeId, NodeId outNodeId); 166 167 static void OpenImplicitAnimation(const RSAnimationTimingProtocol& timingProtocol, 168 const RSAnimationTimingCurve& timingCurve, const std::function<void()>& finishCallback = nullptr); 169 static std::vector<std::shared_ptr<RSAnimation>> CloseImplicitAnimation(); 170 static bool CloseImplicitCancelAnimation(); 171 static bool IsImplicitAnimationOpen(); 172 173 static void ExecuteWithoutAnimation(const PropertyCallback& callback, 174 const std::shared_ptr<RSUIContext> rsUIContext = nullptr, 175 std::shared_ptr<RSImplicitAnimator> implicitAnimator = nullptr); 176 177 static void AddKeyFrame( 178 float fraction, const RSAnimationTimingCurve& timingCurve, const PropertyCallback& callback); 179 static void AddKeyFrame(float fraction, const PropertyCallback& callback); 180 static void AddDurationKeyFrame( 181 int duration, const RSAnimationTimingCurve& timingCurve, const PropertyCallback& callback); 182 183 // multi-instance 184 static std::vector<std::shared_ptr<RSAnimation>> Animate(const std::shared_ptr<RSUIContext> rsUIContext, 185 const RSAnimationTimingProtocol& timingProtocol, 186 const RSAnimationTimingCurve& timingCurve, const PropertyCallback& callback, 187 const std::function<void()>& finishCallback = nullptr, const std::function<void()>& repeatCallback = nullptr); 188 static std::vector<std::shared_ptr<RSAnimation>> AnimateWithCurrentOptions( 189 const std::shared_ptr<RSUIContext> rsUIContext, const PropertyCallback& callback, 190 const std::function<void()>& finishCallback, bool timingSensitive = true); 191 static std::vector<std::shared_ptr<RSAnimation>> AnimateWithCurrentCallback( 192 const std::shared_ptr<RSUIContext> rsUIContext, const RSAnimationTimingProtocol& timingProtocol, 193 const RSAnimationTimingCurve& timingCurve, const PropertyCallback& callback); 194 195 static void RegisterTransitionPair(const std::shared_ptr<RSUIContext> rsUIContext, 196 NodeId inNodeId, NodeId outNodeId, const bool isInSameWindow); 197 static void UnregisterTransitionPair(const std::shared_ptr<RSUIContext> rsUIContext, 198 NodeId inNodeId, NodeId outNodeId); 199 200 static void OpenImplicitAnimation(const std::shared_ptr<RSUIContext> rsUIContext, 201 const RSAnimationTimingProtocol& timingProtocol, const RSAnimationTimingCurve& timingCurve, 202 const std::function<void()>& finishCallback = nullptr); 203 static std::vector<std::shared_ptr<RSAnimation>> CloseImplicitAnimation( 204 const std::shared_ptr<RSUIContext> rsUIContext); 205 static bool CloseImplicitCancelAnimation(const std::shared_ptr<RSUIContext> rsUIContext); 206 static bool IsImplicitAnimationOpen(const std::shared_ptr<RSUIContext> rsUIContext); 207 static void AddKeyFrame(const std::shared_ptr<RSUIContext> rsUIContext, float fraction, 208 const RSAnimationTimingCurve& timingCurve, const PropertyCallback& callback); 209 static void AddKeyFrame( 210 const std::shared_ptr<RSUIContext> rsUIContext, float fraction, const PropertyCallback& callback); 211 static void AddDurationKeyFrame(const std::shared_ptr<RSUIContext> rsUIContext, int duration, 212 const RSAnimationTimingCurve& timingCurve, const PropertyCallback& callback); 213 void NotifyTransition(const std::shared_ptr<const RSTransitionEffect>& effect, bool isTransitionIn); 214 215 void AddAnimation(const std::shared_ptr<RSAnimation>& animation, bool isStartAnimation = true); 216 void RemoveAllAnimations(); 217 void RemoveAnimation(const std::shared_ptr<RSAnimation>& animation); 218 void SetMotionPathOption(const std::shared_ptr<RSMotionPathOption>& motionPathOption); 219 const std::shared_ptr<RSMotionPathOption> GetMotionPathOption() const; 220 DrawOnNode(RSModifierType type,DrawFunc func)221 virtual void DrawOnNode(RSModifierType type, DrawFunc func) {} // [PLANNING]: support SurfaceNode 222 223 const RSModifierExtractor& GetStagingProperties() const; 224 const RSShowingPropertiesFreezer& GetShowingProperties() const; 225 226 template<typename ModifierName, typename PropertyName, typename T> 227 void SetProperty(RSModifierType modifierType, T value); 228 229 virtual void SetBounds(const Vector4f& bounds); 230 virtual void SetBounds(float positionX, float positionY, float width, float height); 231 virtual void SetBoundsWidth(float width); 232 virtual void SetBoundsHeight(float height); 233 234 virtual void SetFrame(const Vector4f& frame); 235 virtual void SetFrame(float positionX, float positionY, float width, float height); 236 virtual void SetFramePositionX(float positionX); 237 virtual void SetFramePositionY(float positionY); 238 239 // The property is valid only for CanvasNode and SurfaceNode in uniRender. 240 virtual void SetFreeze(bool isFreeze); 241 void SetNodeName(const std::string& nodeName); 242 243 void SetSandBox(std::optional<Vector2f> parentPosition); 244 245 void SetPositionZ(float positionZ); 246 void SetPositionZApplicableCamera3D(bool isApplicable); 247 248 void SetPivot(const Vector2f& pivot); 249 void SetPivot(float pivotX, float pivotY); 250 void SetPivotX(float pivotX); 251 void SetPivotY(float pivotY); 252 void SetPivotZ(float pivotZ); 253 254 void SetCornerRadius(float cornerRadius); 255 void SetCornerRadius(const Vector4f& cornerRadius); 256 257 void SetRotation(const Quaternion& quaternion); 258 void SetRotation(float degreeX, float degreeY, float degreeZ); 259 void SetRotation(float degree); 260 void SetRotationX(float degree); 261 void SetRotationY(float degree); 262 void SetCameraDistance(float cameraDistance); 263 264 void SetTranslate(const Vector2f& translate); 265 void SetTranslate(float translateX, float translateY, float translateZ); 266 void SetTranslateX(float translate); 267 void SetTranslateY(float translate); 268 void SetTranslateZ(float translate); 269 270 void SetScale(float scale); 271 void SetScale(float scaleX, float scaleY); 272 void SetScale(const Vector2f& scale); 273 void SetScaleX(float scaleX); 274 void SetScaleY(float scaleY); 275 void SetScaleZ(const float& scaleZ); 276 277 void SetSkew(float skew); 278 void SetSkew(float skewX, float skewY); 279 void SetSkew(float skewX, float skewY, float skewZ); 280 void SetSkew(const Vector3f& skew); 281 void SetSkewX(float skewX); 282 void SetSkewY(float skewY); 283 void SetSkewZ(float skewZ); 284 285 void SetPersp(float persp); 286 void SetPersp(float perspX, float perspY); 287 void SetPersp(float perspX, float perspY, float perspZ, float perspW); 288 void SetPersp(const Vector4f& persp); 289 void SetPerspX(float perspX); 290 void SetPerspY(float perspY); 291 void SetPerspZ(float perspZ); 292 void SetPerspW(float perspW); 293 294 void SetAlpha(float alpha); 295 void SetAlphaOffscreen(bool alphaOffscreen); 296 297 void SetEnvForegroundColor(uint32_t colorValue); 298 void SetEnvForegroundColorStrategy(ForegroundColorStrategyType colorType); 299 void SetParticleParams( 300 std::vector<ParticleParams>& particleParams, const std::function<void()>& finishCallback = nullptr); 301 void SetEmitterUpdater(const std::vector<std::shared_ptr<EmitterUpdater>>& para); 302 void SetParticleNoiseFields(const std::shared_ptr<ParticleNoiseFields>& para); 303 void SetForegroundColor(uint32_t colorValue); 304 void SetBackgroundColor(uint32_t colorValue); 305 void SetBackgroundShader(const std::shared_ptr<RSShader>& shader); 306 void SetBackgroundShaderProgress(const float& process); 307 308 void SetBgImage(const std::shared_ptr<RSImage>& image); 309 void SetBgImageInnerRect(const Vector4f& innerRect); 310 void SetBgImageSize(float width, float height); 311 void SetBgImageWidth(float width); 312 void SetBgImageHeight(float height); 313 void SetBgImagePosition(float positionX, float positionY); 314 void SetBgImagePositionX(float positionX); 315 void SetBgImagePositionY(float positionY); 316 317 void SetBorderColor(uint32_t colorValue); 318 void SetBorderColor(uint32_t left, uint32_t top, uint32_t right, uint32_t bottom); 319 void SetBorderColor(const Vector4<Color>& color); 320 void SetBorderWidth(float width); 321 void SetBorderWidth(float left, float top, float right, float bottom); 322 void SetBorderWidth(const Vector4f& width); 323 void SetBorderStyle(uint32_t styleValue); 324 void SetBorderStyle(uint32_t left, uint32_t top, uint32_t right, uint32_t bottom); 325 void SetBorderStyle(const Vector4<BorderStyle>& style); 326 void SetBorderDashWidth(const Vector4f& dashWidth); 327 void SetBorderDashGap(const Vector4f& dashGap); 328 void SetOuterBorderColor(const Vector4<Color>& color); 329 void SetOuterBorderWidth(const Vector4f& width); 330 void SetOuterBorderStyle(const Vector4<BorderStyle>& style); 331 void SetOuterBorderRadius(const Vector4f& radius); 332 void SetOutlineColor(const Vector4<Color>& color); 333 void SetOutlineWidth(const Vector4f& width); 334 void SetOutlineStyle(const Vector4<BorderStyle>& style); 335 void SetOutlineDashWidth(const Vector4f& dashWidth); 336 void SetOutlineDashGap(const Vector4f& dashGap); 337 void SetOutlineRadius(const Vector4f& radius); 338 339 // UIEffect 340 void SetUIBackgroundFilter(const OHOS::Rosen::Filter* backgroundFilter); 341 void SetUICompositingFilter(const OHOS::Rosen::Filter* compositingFilter); 342 void SetUIForegroundFilter(const OHOS::Rosen::Filter* foregroundFilter); 343 void SetVisualEffect(const VisualEffect* visualEffect); 344 345 void SetForegroundEffectRadius(const float blurRadius); 346 void SetForegroundEffectDisableSystemAdaptation(bool disableSystemAdaptation); 347 void SetBackgroundFilter(const std::shared_ptr<RSFilter>& backgroundFilter); 348 void SetFilter(const std::shared_ptr<RSFilter>& filter); 349 void SetLinearGradientBlurPara(const std::shared_ptr<RSLinearGradientBlurPara>& para); 350 void SetMotionBlurPara(const float radius, const Vector2f& anchor); 351 void SetMagnifierParams(const std::shared_ptr<RSMagnifierParams>& para); 352 void SetDynamicLightUpRate(const float rate); 353 void SetDynamicLightUpDegree(const float lightUpDegree); 354 void SetDynamicDimDegree(const float dimDegree); 355 void SetBlender(const Blender* blender); 356 void SetFgBrightnessParams(const RSDynamicBrightnessPara& params); 357 void SetFgBrightnessRates(const Vector4f& rates); 358 void SetFgBrightnessSaturation(const float& saturation); 359 void SetFgBrightnessPosCoeff(const Vector4f& coeff); 360 void SetFgBrightnessNegCoeff(const Vector4f& coeff); 361 void SetFgBrightnessFract(const float& fract); 362 void SetBgBrightnessParams(const RSDynamicBrightnessPara& params); 363 void SetBgBrightnessRates(const Vector4f& rates); 364 void SetBgBrightnessSaturation(const float& saturation); 365 void SetBgBrightnessPosCoeff(const Vector4f& coeff); 366 void SetBgBrightnessNegCoeff(const Vector4f& coeff); 367 void SetBgBrightnessFract(const float& fract); 368 void SetGreyCoef(const Vector2f greyCoef); 369 void SetCompositingFilter(const std::shared_ptr<RSFilter>& compositingFilter); 370 371 void SetShadowColor(uint32_t colorValue); 372 void SetShadowOffset(float offsetX, float offsetY); 373 void SetShadowOffsetX(float offsetX); 374 void SetShadowOffsetY(float offsetY); 375 void SetShadowAlpha(float alpha); 376 void SetShadowElevation(float elevation); 377 void SetShadowRadius(float radius); 378 void SetShadowPath(const std::shared_ptr<RSPath>& shadowPath); 379 void SetShadowMask(bool shadowMask); 380 void SetShadowIsFilled(bool shadowIsFilled); 381 void SetShadowColorStrategy(int shadowColorStrategy); 382 383 void SetFrameGravity(Gravity gravity); 384 385 void SetClipRRect(const Vector4f& clipRect, const Vector4f& clipRadius); 386 void SetClipRRect(const std::shared_ptr<RRect>& rrect); 387 void SetClipBounds(const std::shared_ptr<RSPath>& clipToBounds); 388 void SetClipToBounds(bool clipToBounds); 389 void SetClipToFrame(bool clipToFrame); 390 void SetCustomClipToFrame(const Vector4f& clipRect); 391 void SetHDRBrightness(const float& hdrBrightness); 392 393 void SetVisible(bool visible); 394 void SetMask(const std::shared_ptr<RSMask>& mask); 395 void SetSpherizeDegree(float spherizeDegree); 396 void SetLightUpEffectDegree(float LightUpEffectDegree); 397 398 void SetAttractionEffect(float fraction, const Vector2f& destinationPoint); 399 void SetAttractionEffectFraction(float fraction); 400 void SetAttractionEffectDstPoint(Vector2f destinationPoint); 401 402 void SetPixelStretch(const Vector4f& stretchSize, Drawing::TileMode stretchTileMode = Drawing::TileMode::CLAMP); 403 void SetPixelStretchPercent(const Vector4f& stretchPercent, 404 Drawing::TileMode stretchTileMode = Drawing::TileMode::CLAMP); 405 406 void SetWaterRippleParams(const RSWaterRipplePara& params, float progress); 407 void SetFlyOutParams(const RSFlyOutPara& params, float degree); 408 409 void SetDistortionK(const float distortionK); 410 411 void SetPaintOrder(bool drawContentLast); 412 SetTransitionEffect(const std::shared_ptr<const RSTransitionEffect> & effect)413 void SetTransitionEffect(const std::shared_ptr<const RSTransitionEffect>& effect) 414 { 415 transitionEffect_ = effect; 416 } 417 418 void SetUseEffect(bool useEffect); 419 void SetUseEffectType(UseEffectType useEffectType); 420 421 void SetUseShadowBatching(bool useShadowBatching); 422 423 void SetColorBlendMode(RSColorBlendMode colorBlendMode); 424 425 void SetColorBlendApplyType(RSColorBlendApplyType colorBlendApplyType); 426 427 // driven render was shelved, functions will be deleted soon [start] MarkDrivenRender(bool flag)428 void MarkDrivenRender(bool flag) {} MarkDrivenRenderItemIndex(int index)429 void MarkDrivenRenderItemIndex(int index) {} MarkDrivenRenderFramePaintState(bool flag)430 void MarkDrivenRenderFramePaintState(bool flag) {} MarkContentChanged(bool isChanged)431 void MarkContentChanged(bool isChanged) {} 432 // driven render was shelved, functions will be deleted soon [end] 433 434 void AddModifier(const std::shared_ptr<RSModifier> modifier); 435 void RemoveModifier(const std::shared_ptr<RSModifier> modifier); 436 437 void SetIsCustomTextType(bool isCustomTextType); 438 439 bool GetIsCustomTextType(); 440 441 void SetIsCustomTypeface(bool isCustomTypeface); 442 443 bool GetIsCustomTypeface(); 444 445 void SetDrawRegion(std::shared_ptr<RectF> rect); 446 447 // Mark preferentially draw node and childrens 448 void MarkNodeGroup(bool isNodeGroup, bool isForced = true, bool includeProperty = false); 449 450 // Mark opinc node 451 void MarkSuggestOpincNode(bool isOpincNode, bool isNeedCalculate = false); 452 // will be abandoned 453 void MarkUifirstNode(bool isUifirstNode); 454 // Mark uifirst leash node 455 void MarkUifirstNode(bool isForceFlag, bool isUifirstEnable); 456 457 void SetUIFirstSwitch(RSUIFirstSwitch uiFirstSwitch); 458 459 void MarkNodeSingleFrameComposer(bool isNodeSingleFrameComposer); 460 461 void SetGrayScale(float grayScale); 462 463 void SetLightIntensity(float lightIntensity); 464 465 void SetLightColor(uint32_t lightColorValue); 466 467 void SetLightPosition(const Vector4f& lightPosition); 468 469 void SetLightPosition(float positionX, float positionY, float positionZ); 470 471 void SetIlluminatedBorderWidth(float illuminatedBorderWidth); 472 473 void SetIlluminatedType(uint32_t illuminatedType); 474 475 void SetBloom(float bloomIntensity); 476 477 void SetBrightness(float brightness); 478 479 void SetContrast(float contrast); 480 481 void SetSaturate(float saturate); 482 483 void SetSepia(float sepia); 484 485 void SetInvert(float invert); 486 487 void SetAiInvert(const Vector4f& aiInvert); 488 489 void SetSystemBarEffect(); 490 491 void SetHueRotate(float hueRotate); 492 493 void SetColorBlend(uint32_t colorValue); 494 495 int32_t CalcExpectedFrameRate(const std::string& scene, float speed); 496 497 void SetOutOfParent(OutOfParentType outOfParent); 498 499 void SetFrameNodeInfo(int32_t id, std::string tag); 500 501 virtual void SetTextureExport(bool isTextureExportNode); 502 503 void SyncTextureExport(bool isTextureExportNode); 504 505 int32_t GetFrameNodeId(); 506 507 std::string GetFrameNodeTag(); 508 SetBoundsChangedCallback(BoundsChangedCallback callback)509 virtual void SetBoundsChangedCallback(BoundsChangedCallback callback){}; IsTextureExportNode()510 bool IsTextureExportNode() const 511 { 512 return isTextureExportNode_; 513 } 514 GetAnimationsCount()515 size_t GetAnimationsCount() const 516 { 517 return animations_.size(); 518 } 519 void SetExportTypeChangedCallback(ExportTypeChangedCallback callback); 520 521 bool IsGeometryDirty() const; 522 bool IsAppearanceDirty() const; 523 void MarkDirty(NodeDirtyType type, bool isDirty); 524 525 float GetGlobalPositionX() const; 526 float GetGlobalPositionY() const; 527 528 std::shared_ptr<RSObjAbsGeometry> GetLocalGeometry() const; 529 std::shared_ptr<RSObjAbsGeometry> GetGlobalGeometry() const; 530 void UpdateLocalGeometry(); 531 void UpdateGlobalGeometry(const std::shared_ptr<RSObjAbsGeometry>& parentGlobalGeometry); 532 533 std::mutex childrenNodeLock_; // lock for map operation 534 // key: symbolSpanID, value:nodeid and symbol animation node list 535 std::unordered_map<uint64_t, std::unordered_map<NodeId, SharedPtr>> canvasNodesListMap_; 536 537 // key: status : 0 invalid, 1 appear, value:symbol node animation config 538 std::array<std::vector<OHOS::Rosen::AnimationNodeConfig>, 2> replaceNodesSwapArr_; 539 540 void SetInstanceId(int32_t instanceId); GetInstanceId()541 int32_t GetInstanceId() const 542 { 543 return instanceId_; 544 } 545 GetNodeName()546 const std::string GetNodeName() const 547 { 548 return nodeName_; 549 } 550 551 static DrawNodeChangeCallback drawNodeChangeCallback_; 552 static void SetDrawNodeChangeCallback(DrawNodeChangeCallback callback); 553 bool GetIsDrawn(); 554 void SetDrawNode(); 555 GetRSUIContext()556 std::shared_ptr<RSUIContext> GetRSUIContext() 557 { 558 return rsUIContext_.lock(); 559 } 560 void SetRSUIContext(std::shared_ptr<RSUIContext> rsUIContext); 561 562 void SetSkipCheckInMultiInstance(bool isSkipCheckInMultiInstance); 563 protected: 564 explicit RSNode( 565 bool isRenderServiceNode, bool isTextureExportNode = false, std::shared_ptr<RSUIContext> rsUIContext = nullptr); 566 explicit RSNode(bool isRenderServiceNode, NodeId id, bool isTextureExportNode = false, 567 std::shared_ptr<RSUIContext> rsUIContext = nullptr); 568 569 bool isRenderServiceNode_; 570 bool isTextureExportNode_ = false; 571 bool skipDestroyCommandInDestructor_ = false; 572 ExportTypeChangedCallback exportTypeChangedCallback_ = nullptr; 573 574 // Used for same layer rendering, to determine whether RT or RS generates renderNode when the type of node switches 575 bool hasCreateRenderNodeInRT_ = false; 576 bool hasCreateRenderNodeInRS_ = false; 577 578 bool drawContentLast_ = false; 579 580 virtual void OnAddChildren(); 581 virtual void OnRemoveChildren(); 582 NeedForcedSendToRemote()583 virtual bool NeedForcedSendToRemote() const 584 { 585 return false; 586 } 587 588 void DoFlushModifier(); 589 590 std::vector<PropertyId> GetModifierIds() const; 591 bool isCustomTextType_ = false; 592 bool isCustomTypeface_ = false; 593 GetPropertyMutex()594 std::recursive_mutex& GetPropertyMutex() const 595 { 596 return propertyMutex_; 597 } 598 bool CheckMultiThreadAccess(const std::string& func) const; RegisterNodeMap()599 virtual void RegisterNodeMap() {} 600 std::shared_ptr<RSTransactionHandler> GetRSTransaction() const; 601 bool AddCommand(std::unique_ptr<RSCommand>& command, bool isRenderServiceCommand = false, 602 FollowType followType = FollowType::NONE, NodeId nodeId = 0) const; 603 604 private: 605 static NodeId GenerateId(); 606 static void InitUniRenderEnabled(); 607 NodeId id_; 608 NodeId parent_ = 0; 609 int32_t instanceId_ = INSTANCE_ID_UNDEFINED; 610 int32_t frameNodeId_ = -1; 611 std::string frameNodeTag_; 612 std::string nodeName_ = ""; 613 std::vector<NodeId> children_; 614 void SetParent(NodeId parent); 615 void RemoveChildById(NodeId childId); CreateRenderNodeForTextureExportSwitch()616 virtual void CreateRenderNodeForTextureExportSwitch() {}; 617 618 void SetBackgroundBlurRadius(float radius); 619 void SetBackgroundBlurSaturation(float saturation); 620 void SetBackgroundBlurBrightness(float brightness); 621 void SetBackgroundBlurMaskColor(Color maskColor); 622 void SetBackgroundBlurColorMode(int colorMode); 623 void SetBackgroundBlurRadiusX(float blurRadiusX); 624 void SetBackgroundBlurRadiusY(float blurRadiusY); 625 626 void SetForegroundBlurRadius(float radius); 627 void SetForegroundBlurSaturation(float saturation); 628 void SetForegroundBlurBrightness(float brightness); 629 void SetForegroundBlurMaskColor(Color maskColor); 630 void SetForegroundBlurColorMode(int colorMode); 631 void SetForegroundBlurRadiusX(float blurRadiusX); 632 void SetForegroundBlurRadiusY(float blurRadiusY); 633 634 bool AnimationCallback(AnimationId animationId, AnimationCallbackEvent event); 635 bool HasPropertyAnimation(const PropertyId& id); 636 std::vector<AnimationId> GetAnimationByPropertyId(const PropertyId& id); 637 bool FallbackAnimationsToContext(); 638 void FallbackAnimationsToRoot(); 639 void AddAnimationInner(const std::shared_ptr<RSAnimation>& animation); 640 void FinishAnimationByProperty(const PropertyId& id); 641 void RemoveAnimationInner(const std::shared_ptr<RSAnimation>& animation); 642 void CancelAnimationByProperty(const PropertyId& id, const bool needForceSync = false); 643 const std::shared_ptr<RSModifier> GetModifier(const PropertyId& propertyId); OnBoundsSizeChanged()644 virtual void OnBoundsSizeChanged() const {}; 645 void UpdateModifierMotionPathOption(); 646 void MarkAllExtendModifierDirty(); 647 void ResetExtendModifierDirty(); 648 void SetParticleDrawRegion(std::vector<ParticleParams>& particleParams); 649 650 // Planning: refactor RSUIAnimationManager and remove this method 651 void ClearAllModifiers(); 652 653 uint32_t dirtyType_ = static_cast<uint32_t>(NodeDirtyType::NOT_DIRTY); 654 655 std::shared_ptr<RSObjAbsGeometry> localGeometry_; 656 std::shared_ptr<RSObjAbsGeometry> globalGeometry_; 657 658 float globalPositionX_ = 0.f; 659 float globalPositionY_ = 0.f; 660 661 bool extendModifierIsDirty_ { false }; 662 663 bool isNodeGroup_ = false; 664 665 bool isNodeSingleFrameComposer_ = false; 666 667 bool isSuggestOpincNode_ = false; 668 bool isDrawNode_ = false; 669 670 bool isUifirstNode_ = true; 671 bool isForceFlag_ = false; 672 bool isUifirstEnable_ = false; 673 bool isSkipCheckInMultiInstance_ = false; 674 RSUIFirstSwitch uiFirstSwitch_ = RSUIFirstSwitch::NONE; 675 std::weak_ptr<RSUIContext> rsUIContext_; 676 677 RSModifierExtractor stagingPropertiesExtractor_; 678 RSShowingPropertiesFreezer showingPropertiesFreezer_; 679 std::map<PropertyId, std::shared_ptr<RSModifier>> modifiers_; 680 std::map<uint16_t, std::shared_ptr<RSModifier>> modifiersTypeMap_; 681 std::map<RSModifierType, std::shared_ptr<RSModifier>> propertyModifiers_; 682 std::shared_ptr<RectF> drawRegion_; 683 OutOfParentType outOfParent_ = OutOfParentType::UNKNOWN; 684 685 std::unordered_map<AnimationId, std::shared_ptr<RSAnimation>> animations_; 686 std::unordered_map<PropertyId, uint32_t> animatingPropertyNum_; 687 std::shared_ptr<RSMotionPathOption> motionPathOption_; 688 std::shared_ptr<const RSTransitionEffect> transitionEffect_; 689 690 std::recursive_mutex animationMutex_; 691 mutable std::recursive_mutex propertyMutex_; 692 693 friend class RSUIDirector; 694 friend class RSTransition; 695 friend class RSSpringAnimation; 696 friend class RSShowingPropertiesFreezer; 697 friend class RSPropertyBase; 698 friend class RSPropertyAnimation; 699 friend class RSPathAnimation; 700 friend class RSModifierExtractor; 701 friend class RSModifier; 702 friend class RSKeyframeAnimation; 703 friend class RSInterpolatingSpringAnimation; 704 friend class RSImplicitCancelAnimationParam; 705 friend class RSImplicitAnimator; 706 friend class RSGeometryTransModifier; 707 friend class RSExtendedModifier; 708 friend class RSCurveAnimation; 709 friend class RSAnimation; 710 template<typename T> 711 friend class RSProperty; 712 template<typename T> 713 friend class RSAnimatableProperty; 714 friend class RSInteractiveImplictAnimator; 715 }; 716 // backward compatibility 717 using RSBaseNode = RSNode; 718 } // namespace Rosen 719 } // namespace OHOS 720 721 #endif // RENDER_SERVICE_CLIENT_CORE_UI_RS_NODE_H 722