1 /* 2 * Copyright (c) 2022-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_CORE_PIPELINE_RS_UNI_RENDER_VISITOR_H 16 #define RENDER_SERVICE_CORE_PIPELINE_RS_UNI_RENDER_VISITOR_H 17 18 #include <cstdint> 19 #include <list> 20 #include <memory> 21 #include <mutex> 22 #include <parameters.h> 23 #include <set> 24 25 #include "rs_base_render_engine.h" 26 #include "system/rs_system_parameters.h" 27 28 #include "params/rs_render_thread_params.h" 29 #include "pipeline/round_corner_display/rs_rcd_render_manager.h" 30 #include "pipeline/rs_dirty_region_manager.h" 31 #include "pipeline/rs_main_thread.h" 32 #include "pipeline/rs_uni_hwc_prevalidate_util.h" 33 #include "platform/ohos/overdraw/rs_overdraw_controller.h" 34 #include "screen_manager/rs_screen_manager.h" 35 #include "visitor/rs_node_visitor.h" 36 37 namespace OHOS { 38 namespace Rosen { 39 class RSPaintFilterCanvas; 40 class RSUniRenderVisitor : public RSNodeVisitor { 41 public: 42 using SurfaceDirtyMgrPair = std::pair<std::shared_ptr<RSSurfaceRenderNode>, std::shared_ptr<RSSurfaceRenderNode>>; 43 RSUniRenderVisitor(); 44 explicit RSUniRenderVisitor(const RSUniRenderVisitor& visitor); 45 ~RSUniRenderVisitor() override; 46 47 // To prepare nodes between displayRenderNode and app nodes. 48 void QuickPrepareEffectRenderNode(RSEffectRenderNode& node) override; 49 void QuickPrepareCanvasRenderNode(RSCanvasRenderNode& node) override; 50 void QuickPrepareDisplayRenderNode(RSDisplayRenderNode& node) override; 51 void QuickPrepareSurfaceRenderNode(RSSurfaceRenderNode& node) override; 52 void QuickPrepareChildren(RSRenderNode& node) override; 53 PrepareChildren(RSRenderNode & node)54 void PrepareChildren(RSRenderNode& node) override {}; PrepareCanvasRenderNode(RSCanvasRenderNode & node)55 void PrepareCanvasRenderNode(RSCanvasRenderNode& node) override {}; PrepareDisplayRenderNode(RSDisplayRenderNode & node)56 void PrepareDisplayRenderNode(RSDisplayRenderNode& node) override {}; PrepareProxyRenderNode(RSProxyRenderNode & node)57 void PrepareProxyRenderNode(RSProxyRenderNode& node) override {}; 58 // prepareroot also used for quickprepare 59 void PrepareRootRenderNode(RSRootRenderNode& node) override; PrepareSurfaceRenderNode(RSSurfaceRenderNode & node)60 void PrepareSurfaceRenderNode(RSSurfaceRenderNode& node) override {}; PrepareEffectRenderNode(RSEffectRenderNode & node)61 void PrepareEffectRenderNode(RSEffectRenderNode& node) override {}; 62 ProcessChildren(RSRenderNode & node)63 void ProcessChildren(RSRenderNode& node) override {}; ProcessCanvasRenderNode(RSCanvasRenderNode & node)64 void ProcessCanvasRenderNode(RSCanvasRenderNode& node) override {}; ProcessDisplayRenderNode(RSDisplayRenderNode & node)65 void ProcessDisplayRenderNode(RSDisplayRenderNode& node) override {}; ProcessProxyRenderNode(RSProxyRenderNode & node)66 void ProcessProxyRenderNode(RSProxyRenderNode& node) override {}; ProcessRootRenderNode(RSRootRenderNode & node)67 void ProcessRootRenderNode(RSRootRenderNode& node) override {}; ProcessSurfaceRenderNode(RSSurfaceRenderNode & node)68 void ProcessSurfaceRenderNode(RSSurfaceRenderNode& node) override {}; ProcessEffectRenderNode(RSEffectRenderNode & node)69 void ProcessEffectRenderNode(RSEffectRenderNode& node) override {}; 70 SetProcessorRenderEngine(std::shared_ptr<RSBaseRenderEngine> renderEngine)71 void SetProcessorRenderEngine(std::shared_ptr<RSBaseRenderEngine> renderEngine) 72 { 73 renderEngine_ = renderEngine; 74 } 75 SetAnimateState(bool doAnimate)76 void SetAnimateState(bool doAnimate) 77 { 78 doAnimate_ = doAnimate; 79 } 80 SetDirtyFlag(bool isDirty)81 void SetDirtyFlag(bool isDirty) 82 { 83 isDirty_ = isDirty; 84 } 85 SetFocusedNodeId(uint64_t nodeId,uint64_t leashId)86 void SetFocusedNodeId(uint64_t nodeId, uint64_t leashId) 87 { 88 currentFocusedNodeId_ = nodeId; 89 focusedLeashWindowId_ = leashId; 90 } 91 SetSubThreadConfig(uint32_t threadIndex)92 void SetSubThreadConfig(uint32_t threadIndex) 93 { 94 isSubThread_ = true; 95 isHardwareForcedDisabled_ = true; 96 threadIndex_ = threadIndex; 97 } 98 GetAnimateState()99 bool GetAnimateState() const 100 { 101 return doAnimate_; 102 } 103 MarkHardwareForcedDisabled()104 void MarkHardwareForcedDisabled() 105 { 106 isHardwareForcedDisabled_ = true; 107 } 108 109 void SetUniRenderThreadParam(std::unique_ptr<RSRenderThreadParams>& renderThreadParams); 110 GetIsPartialRenderEnabled()111 bool GetIsPartialRenderEnabled() const 112 { 113 return isPartialRenderEnabled_; 114 } GetIsOpDropped()115 bool GetIsOpDropped() const 116 { 117 return isOpDropped_; 118 } GetIsRegionDebugEnabled()119 bool GetIsRegionDebugEnabled() const 120 { 121 return isRegionDebugEnabled_; 122 } 123 // Use in vulkan parallel rendering GetColorGamut()124 GraphicColorGamut GetColorGamut() const 125 { 126 return newColorSpace_; 127 } 128 129 void SetAppWindowNum(uint32_t num); 130 SetScreenInfo(ScreenInfo screenInfo)131 void SetScreenInfo(ScreenInfo screenInfo) 132 { 133 screenInfo_ = screenInfo; 134 } 135 136 // Use in updating hwcnode hardware state with background alpha 137 void UpdateHardwareStateByHwcNodeBackgroundAlpha(const std::vector<std::weak_ptr<RSSurfaceRenderNode>>& hwcNodes); 138 139 bool IsNodeAboveInsideOfNodeBelow(const RectI& rectAbove, std::list<RectI>& hwcNodeRectList); 140 // Use end 141 142 void SurfaceOcclusionCallbackToWMS(); 143 144 static void ClearRenderGroupCache(); 145 146 using RenderParam = std::tuple<std::shared_ptr<RSRenderNode>, RSPaintFilterCanvas::CanvasStatus>; 147 private: 148 /* Prepare relevant calculation */ 149 // considering occlusion info for app surface as well as widget 150 bool IsSubTreeOccluded(RSRenderNode& node) const; 151 // restore node's flag and filter dirty collection 152 void PostPrepare(RSRenderNode& node, bool subTreeSkipped = false); 153 void UpdateNodeVisibleRegion(RSSurfaceRenderNode& node); 154 void CalculateOcclusion(RSSurfaceRenderNode& node); 155 156 void CheckFilterCacheNeedForceClearOrSave(RSRenderNode& node); 157 void UpdateOccludedStatusWithFilterNode(std::shared_ptr<RSSurfaceRenderNode>& surfaceNode) const; 158 void PartialRenderOptionInit(); 159 RSVisibleLevel GetRegionVisibleLevel(const Occlusion::Region& visibleRegion, 160 const Occlusion::Region& selfDrawRegion); 161 void UpdateSurfaceOcclusionInfo(); 162 enum class RSPaintStyle { 163 FILL, 164 STROKE 165 }; 166 167 bool InitDisplayInfo(RSDisplayRenderNode& node); 168 169 bool BeforeUpdateSurfaceDirtyCalc(RSSurfaceRenderNode& node); 170 bool NeedPrepareChindrenInReverseOrder(RSRenderNode& node) const; 171 bool IsLeashAndHasMainSubNode(RSRenderNode& node) const; 172 bool AfterUpdateSurfaceDirtyCalc(RSSurfaceRenderNode& node); 173 void UpdateLeashWindowVisibleRegionEmpty(RSSurfaceRenderNode& node); 174 void UpdateSurfaceRenderNodeRotate(RSSurfaceRenderNode& node); 175 void UpdateSurfaceDirtyAndGlobalDirty(); 176 // should ensure that the surface size of dirty region manager has been set 177 void ResetDisplayDirtyRegion(); 178 bool CheckScreenPowerChange() const; 179 bool CheckColorFilterChange() const; 180 bool CheckCurtainScreenUsingStatusChange() const; 181 bool CheckLuminanceStatusChange(); 182 bool IsFirstFrameOfPartialRender() const; 183 bool IsFirstFrameOfOverdrawSwitch() const; 184 bool IsFirstFrameOfDrawingCacheDfxSwitch() const; 185 bool IsWatermarkFlagChanged() const; 186 void UpdateDisplayZoomState(); 187 void CollectFilterInfoAndUpdateDirty(RSRenderNode& node, 188 RSDirtyRegionManager& dirtyManager, const RectI& globalFilterRect); 189 RectI GetVisibleEffectDirty(RSRenderNode& node) const; 190 191 void UpdateHwcNodeEnableByGlobalFilter(std::shared_ptr<RSSurfaceRenderNode>& node); 192 void UpdateHwcNodeEnableByGlobalCleanFilter(const std::vector<std::pair<NodeId, RectI>>& cleanFilter, 193 RSSurfaceRenderNode& hwcNodePtr); 194 void UpdateHwcNodeEnableByFilterRect( 195 std::shared_ptr<RSSurfaceRenderNode>& node, const RectI& filterRect, bool isReverseOrder = false); 196 void CalcHwcNodeEnableByFilterRect( 197 std::shared_ptr<RSSurfaceRenderNode>& node, const RectI& filterRect, bool isReverseOrder = false); 198 // This function is used for solving display problems caused by dirty blurfilter node half-obscured. 199 void UpdateDisplayDirtyAndExtendVisibleRegion(); 200 // This function is used to update global dirty and visibleRegion 201 // by processing dirty blurfilter node obscured. 202 void ProcessFilterNodeObscured(std::shared_ptr<RSSurfaceRenderNode>& surfaceNode, 203 Occlusion::Region& extendRegion, const RSRenderNodeMap& nodeMap); 204 void UpdateHwcNodeEnableByBackgroundAlpha(RSSurfaceRenderNode& node); 205 void UpdateHwcNodeEnableBySrcRect(RSSurfaceRenderNode& node); 206 void UpdateHwcNodeEnableByBufferSize(RSSurfaceRenderNode& node); 207 void UpdateHwcNodeInfoForAppNode(RSSurfaceRenderNode& node); 208 void UpdateSrcRect(RSSurfaceRenderNode& node, 209 const Drawing::Matrix& absMatrix, const RectI& clipRect); 210 void UpdateDstRect(RSSurfaceRenderNode& node, const RectI& absRect, const RectI& clipRect); 211 void UpdateHwcNodeProperty(std::shared_ptr<RSSurfaceRenderNode> hwcNode); 212 void UpdateHwcNodeByTransform(RSSurfaceRenderNode& node); 213 void UpdateHwcNodeEnableByRotateAndAlpha(std::shared_ptr<RSSurfaceRenderNode>& node); 214 void ProcessAncoNode(std::shared_ptr<RSSurfaceRenderNode>& hwcNodePtr); 215 void InitAncoStatus(); 216 void UpdateAncoNodeHWCDisabledState(); 217 void UpdateHwcNodeEnableByHwcNodeBelowSelfInApp(std::vector<RectI>& hwcRects, 218 std::shared_ptr<RSSurfaceRenderNode>& hwcNode); 219 void UpdateChildHwcNodeEnableByHwcNodeBelow(std::vector<RectI>& hwcRects, 220 std::shared_ptr<RSSurfaceRenderNode>& appNode); 221 void UpdateHwcNodeEnableByHwcNodeBelowSelf(std::vector<RectI>& hwcRects, 222 std::shared_ptr<RSSurfaceRenderNode>& hwcNode, bool isIntersectWithRoundCorner); 223 void UpdateHwcNodeDirtyRegionAndCreateLayer(std::shared_ptr<RSSurfaceRenderNode>& node); 224 void AllSurfacesDrawnInUniRender(const std::vector<std::weak_ptr<RSSurfaceRenderNode>>& hwcNodes); 225 void UpdatePointWindowDirtyStatus(std::shared_ptr<RSSurfaceRenderNode>& pointWindow); 226 void UpdateTopLayersDirtyStatus(const std::vector<std::shared_ptr<RSSurfaceRenderNode>>& topLayers); 227 void UpdateCornerRadiusInfoForDRM(std::shared_ptr<RSSurfaceRenderNode> hwcNode, std::vector<RectI>& hwcRects); 228 bool CheckIfRoundCornerIntersectDRM(const float& ratio, std::vector<float>& ratioVector, 229 const Vector4f& instanceCornerRadius, const RectI& instanceAbsRect, const RectI& hwcAbsRect); 230 void UpdateHwcNodeEnable(); 231 void UpdateHwcNodeEnableByNodeBelow(); 232 void PrevalidateHwcNode(); 233 234 // use in QuickPrepareSurfaceRenderNode, update SurfaceRenderNode's uiFirst status 235 void PrepareForUIFirstNode(RSSurfaceRenderNode& node); 236 237 void UpdateHwcNodeDirtyRegionForApp(std::shared_ptr<RSSurfaceRenderNode>& appNode, 238 std::shared_ptr<RSSurfaceRenderNode>& hwcNode); 239 240 void UpdatePrepareClip(RSRenderNode& node); 241 242 void CheckMergeDisplayDirtyByTransparent(RSSurfaceRenderNode& surfaceNode) const; 243 void CheckMergeDisplayDirtyByZorderChanged(RSSurfaceRenderNode& surfaceNode) const; 244 void CheckMergeDisplayDirtyByPosChanged(RSSurfaceRenderNode& surfaceNode) const; 245 void CheckMergeDisplayDirtyByShadowChanged(RSSurfaceRenderNode& surfaceNode) const; 246 void CheckMergeDisplayDirtyBySurfaceChanged() const; 247 void CheckMergeDisplayDirtyByAttractionChanged(RSSurfaceRenderNode& surfaceNode) const; 248 void CheckMergeSurfaceDirtysForDisplay(std::shared_ptr<RSSurfaceRenderNode>& surfaceNode) const; 249 void CheckMergeDisplayDirtyByTransparentRegions(RSSurfaceRenderNode& surfaceNode) const; 250 void CheckMergeFilterDirtyByIntersectWithDirty(OcclusionRectISet& filterSet, bool isGlobalDirty); 251 252 void CheckMergeDisplayDirtyByTransparentFilter(std::shared_ptr<RSSurfaceRenderNode>& surfaceNode, 253 Occlusion::Region& accumulatedDirtyRegion); 254 void CheckMergeGlobalFilterForDisplay(Occlusion::Region& accumulatedDirtyRegion); 255 void CheckMergeDebugRectforRefreshRate(std::vector<RSBaseRenderNode::SharedPtr>& surfaces); 256 257 // merge last childRect as dirty if any child has been removed 258 void MergeRemovedChildDirtyRegion(RSRenderNode& node, bool needMap = false); 259 // Reset curSurface info as upper surfaceParent in case surfaceParent has multi children 260 void ResetCurSurfaceInfoAsUpperSurfaceParent(RSSurfaceRenderNode& node); 261 262 void CheckColorSpace(RSSurfaceRenderNode& node); 263 void CheckColorSpaceWithSelfDrawingNode(RSSurfaceRenderNode& node); 264 void UpdateColorSpaceAfterHwcCalc(RSDisplayRenderNode& node); 265 void HandleColorGamuts(RSDisplayRenderNode& node, const sptr<RSScreenManager>& screenManager); 266 void CheckPixelFormat(RSSurfaceRenderNode& node); 267 void HandlePixelFormat(RSDisplayRenderNode& node, const sptr<RSScreenManager>& screenManager); 268 bool IsHardwareComposerEnabled(); 269 270 void UpdateSecuritySkipAndProtectedLayersRecord(RSSurfaceRenderNode& node); 271 272 void SendRcdMessage(RSDisplayRenderNode& node); 273 ForcePrepareSubTree()274 bool ForcePrepareSubTree() 275 { 276 return curSurfaceNode_ && curSurfaceNode_->GetNeedCollectHwcNode(); 277 } 278 IsValidInVirtualScreen(const RSSurfaceRenderNode & node)279 inline bool IsValidInVirtualScreen(const RSSurfaceRenderNode& node) const 280 { 281 if (node.GetSkipLayer() || node.GetSecurityLayer() || 282 node.GetProtectedLayer() || node.GetSnapshotSkipLayer()) { 283 return false; // surface is special layer 284 } 285 if (!allWhiteList_.empty() || allBlackList_.count(node.GetId()) != 0) { 286 return false; // white list is not empty, or surface is in black list 287 } 288 return true; 289 } 290 291 void UpdateRotationStatusForEffectNode(RSEffectRenderNode& node); 292 void CheckFilterNodeInSkippedSubTreeNeedClearCache(const RSRenderNode& node, RSDirtyRegionManager& dirtyManager); 293 void UpdateHwcNodeRectInSkippedSubTree(const RSRenderNode& node); 294 void UpdateSubSurfaceNodeRectInSkippedSubTree(const RSRenderNode& rootNode); 295 void CollectOcclusionInfoForWMS(RSSurfaceRenderNode& node); 296 void CollectEffectInfo(RSRenderNode& node); 297 298 void UpdateVirtualScreenSecurityExemption(RSDisplayRenderNode& node); 299 300 /* Check whether gpu overdraw buffer feature can be enabled on the RenderNode 301 * 1. is leash window 302 * 2. window has scale, radius, no transparency and no animation 303 * 3. find the child background node, which is no transparency and completely filling the window 304 */ 305 void CheckIsGpuOverDrawBufferOptimizeNode(RSSurfaceRenderNode& node); 306 307 void MarkBlurIntersectWithDRM(std::shared_ptr<RSRenderNode> node) const; 308 309 void TryNotifyUIBufferAvailable(); 310 311 // Used for closing HDR in PC multidisplay becauseof performance and open when singledisplay 312 void SetHdrWhenMultiDisplayChangeInPC(); 313 314 // record DRM nodes 315 std::vector<std::weak_ptr<RSSurfaceRenderNode>> drmNodes_; 316 sptr<RSScreenManager> screenManager_; 317 ScreenInfo screenInfo_; 318 RectI screenRect_; 319 std::unordered_set<NodeId> allBlackList_; // The collection of blacklist for all screens 320 std::unordered_set<NodeId> allWhiteList_; // The collection of whitelist for all screens 321 std::shared_ptr<RSDirtyRegionManager> curSurfaceDirtyManager_; 322 std::shared_ptr<RSSurfaceRenderNode> curSurfaceNode_; 323 std::stack<std::shared_ptr<RSDirtyRegionManager>> surfaceDirtyManager_; 324 std::stack<std::shared_ptr<RSSurfaceRenderNode>> surfaceNode_; 325 float curAlpha_ = 1.f; 326 Vector4f curCornerRadius_{ 0.f, 0.f, 0.f, 0.f }; 327 bool dirtyFlag_ { false }; 328 Drawing::Rect boundsRect_ {}; 329 Gravity frameGravity_ = Gravity::DEFAULT; 330 331 int32_t offsetX_ { 0 }; 332 int32_t offsetY_ { 0 }; 333 Drawing::Matrix parentSurfaceNodeMatrix_; 334 335 ScreenId currentVisitDisplay_ = INVALID_SCREEN_ID; 336 std::map<ScreenId, bool> displayHasSecSurface_; 337 std::map<ScreenId, bool> displayHasSkipSurface_; 338 std::map<ScreenId, bool> displayHasSnapshotSkipSurface_; 339 std::map<ScreenId, bool> displayHasProtectedSurface_; 340 std::map<ScreenId, bool> displaySpecailSurfaceChanged_; 341 std::map<ScreenId, bool> hasCaptureWindow_; 342 343 bool hasFingerprint_ = false; 344 bool hasUniRenderHdrSurface_ = false; 345 346 std::shared_ptr<RSBaseRenderEngine> renderEngine_; 347 348 std::shared_ptr<RSDirtyRegionManager> curDisplayDirtyManager_; 349 std::shared_ptr<RSDisplayRenderNode> curDisplayNode_; 350 bool doAnimate_ = false; 351 bool isSurfaceRotationChanged_ = false; 352 bool isPartialRenderEnabled_ = false; 353 bool isCompleteRenderEnabled_ = false; 354 bool isOpDropped_ = false; 355 bool isDirtyRegionDfxEnabled_ = false; // dirtyRegion DFX visualization 356 bool isTargetDirtyRegionDfxEnabled_ = false; 357 bool isOpaqueRegionDfxEnabled_ = false; 358 bool isVisibleRegionDfxEnabled_ = false; 359 bool isAllSurfaceVisibleDebugEnabled_ = false; 360 bool isDisplayDirtyDfxEnabled_ = false; 361 bool isCanvasNodeSkipDfxEnabled_ = false; 362 bool isVirtualDirtyEnabled_ = false; 363 bool isVirtualDirtyDfxEnabled_ = false; 364 bool isExpandScreenDirtyEnabled_ = false; 365 bool hasMirrorDisplay_ = false; 366 // if display node has skip layer except capsule window 367 bool hasSkipLayer_ = false; 368 bool isOcclusionEnabled_ = false; 369 bool isSkipCanvasNodeOutOfScreen_ = false; 370 bool isScreenRotationAnimating_ = false; 371 bool displayNodeRotationChanged_ = false; 372 std::vector<std::string> dfxTargetSurfaceNames_; 373 PartialRenderType partialRenderType_; 374 DirtyRegionDebugType dirtyRegionDebugType_; 375 SurfaceRegionDebugType surfaceRegionDebugType_; 376 bool isRegionDebugEnabled_ = false; 377 bool isDirty_ = false; 378 // added for judge if drawing cache changes 379 bool isDrawingCacheEnabled_ = false; 380 // opinc feature 381 bool autoCacheEnable_ = false; 382 bool unchangeMarkEnable_ = false; 383 bool unchangeMarkInApp_ = false; 384 385 GraphicColorGamut newColorSpace_ = GraphicColorGamut::GRAPHIC_COLOR_GAMUT_SRGB; 386 GraphicPixelFormat newPixelFormat_ = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888; 387 uint64_t currentFocusedNodeId_ = 0; 388 uint64_t focusedLeashWindowId_ = 0; 389 390 bool isSubThread_ = false; 391 bool isUIFirstDebugEnable_ = false; 392 bool ancestorNodeHasAnimation_ = false; 393 bool hasAccumulatedClip_ = false; 394 uint32_t threadIndex_ = UNI_MAIN_THREAD_INDEX; 395 396 bool isPrevalidateHwcNodeEnable_ = false; 397 398 RectI prepareClipRect_{0, 0, 0, 0}; // renderNode clip rect used in Prepare 399 400 float globalZOrder_ = 0.0f; 401 bool isHardwareForcedDisabled_ = false; // indicates if hardware composer is totally disabled 402 std::vector<NodeId> uiBufferAvailableId_; 403 std::vector<std::shared_ptr<RSSurfaceRenderNode>> hardwareEnabledNodes_; 404 // vector of all app window nodes with surfaceView, sorted by zOrder 405 std::vector<std::shared_ptr<RSSurfaceRenderNode>> appWindowNodesInZOrder_; 406 // vector of hardwareEnabled nodes above displayNodeSurface like pointer window 407 std::vector<std::shared_ptr<RSSurfaceRenderNode>> hardwareEnabledTopNodes_; 408 // vector of Appwindow nodes ids not contain subAppWindow nodes ids in current frame 409 std::queue<NodeId> curMainAndLeashWindowNodesIds_; 410 // vector of Appwindow nodes ids not contain subAppWindow nodes ids in last frame 411 static inline std::queue<NodeId> preMainAndLeashWindowNodesIds_; 412 // vector of current dsiplaynode mainwindow surface visible info 413 VisibleData dstCurVisVec_; 414 // vector of current frame mainwindow surface visible info 415 VisibleData allDstCurVisVec_; 416 // vector of last frame mainwindow surface visible info 417 static inline VisibleData allLastVisVec_; 418 std::mutex occlusionMutex_; 419 float localZOrder_ = 0.0f; // local zOrder for surfaceView under same app window node 420 421 static void ProcessUnpairedSharedTransitionNode(); 422 423 uint32_t appWindowNum_ = 0; 424 // variable for occlusion 425 bool needRecalculateOcclusion_ = false; 426 Occlusion::Region accumulatedOcclusionRegion_; 427 Occlusion::Region occlusionRegionWithoutSkipLayer_; 428 429 bool curDirty_ = false; 430 // to record and pass container node dirty to leash node. 431 bool curContainerDirty_ = false; 432 433 // record nodes in surface which has filter may influence globalDirty 434 OcclusionRectISet globalFilter_; 435 // record filter in current surface when there is no below dirty 436 OcclusionRectISet curSurfaceNoBelowDirtyFilter_; 437 // record container nodes which need filter 438 FilterRectISet containerFilter_; 439 // record nodes which has transparent clean filter 440 std::unordered_map<NodeId, std::vector<std::pair<NodeId, RectI>>> transparentCleanFilter_; 441 // record nodes which has transparent dirty filter 442 std::unordered_map<NodeId, std::vector<std::pair<NodeId, RectI>>> transparentDirtyFilter_; 443 444 std::vector<RectI> globalFilterRects_; 445 std::vector<RectI> globalSurfaceBounds_; 446 // visible filter in transparent surface or display must prepare 447 bool filterInGlobal_ = true; 448 bool needRequestNextVsync_ = true; 449 450 NodeId FindInstanceChildOfDisplay(std::shared_ptr<RSRenderNode> node); 451 452 void UpdateSurfaceRenderNodeScale(RSSurfaceRenderNode& node); 453 454 // use for hardware compose disabled reason collection 455 HwcDisabledReasonCollection& hwcDisabledReasonCollection_ = HwcDisabledReasonCollection::GetInstance(); 456 457 bool zoomStateChange_ = false; 458 459 // anco RSSurfaceNode process 460 bool ancoHasGpu_ = false; 461 std::unordered_set<std::shared_ptr<RSSurfaceRenderNode>> ancoNodes_; 462 463 // used in uifirst for checking whether leashwindow or its parent should paint or not 464 bool globalShouldPaint_ = true; 465 }; 466 } // namespace Rosen 467 } // namespace OHOS 468 469 #endif // RENDER_SERVICE_CORE_PIPELINE_RS_UNI_RENDER_VISITOR_H 470