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     const std::unordered_set<NodeId> GetCurrentBlackList() const;
149     /* Prepare relevant calculation */
150     // considering occlusion info for app surface as well as widget
151     bool IsSubTreeOccluded(RSRenderNode& node) const;
152     // restore node's flag and filter dirty collection
153     void PostPrepare(RSRenderNode& node, bool subTreeSkipped = false);
154     void UpdateNodeVisibleRegion(RSSurfaceRenderNode& node);
155     void CalculateOcclusion(RSSurfaceRenderNode& node);
156 
157     void CheckFilterCacheNeedForceClearOrSave(RSRenderNode& node);
158     void UpdateOccludedStatusWithFilterNode(std::shared_ptr<RSSurfaceRenderNode>& surfaceNode) const;
159     void PartialRenderOptionInit();
160     RSVisibleLevel GetRegionVisibleLevel(const Occlusion::Region& visibleRegion,
161         const Occlusion::Region& selfDrawRegion);
162     void UpdateSurfaceOcclusionInfo();
163     enum class RSPaintStyle {
164         FILL,
165         STROKE
166     };
167 
168     bool InitDisplayInfo(RSDisplayRenderNode& node);
169 
170     bool BeforeUpdateSurfaceDirtyCalc(RSSurfaceRenderNode& node);
171     bool NeedPrepareChindrenInReverseOrder(RSRenderNode& node) const;
172     bool IsLeashAndHasMainSubNode(RSRenderNode& node) const;
173     bool AfterUpdateSurfaceDirtyCalc(RSSurfaceRenderNode& node);
174     void UpdateLeashWindowVisibleRegionEmpty(RSSurfaceRenderNode& node);
175     void UpdateSurfaceRenderNodeRotate(RSSurfaceRenderNode& node);
176     void UpdateSurfaceDirtyAndGlobalDirty();
177     // should ensure that the surface size of dirty region manager has been set
178     void ResetDisplayDirtyRegion();
179     bool CheckScreenPowerChange() const;
180     bool CheckColorFilterChange() const;
181     bool CheckCurtainScreenUsingStatusChange() const;
182     bool CheckLuminanceStatusChange();
183     bool IsFirstFrameOfPartialRender() const;
184     bool IsFirstFrameOfOverdrawSwitch() const;
185     bool IsFirstFrameOfDrawingCacheDfxSwitch() const;
186     bool IsWatermarkFlagChanged() const;
187     void UpdateDisplayZoomState();
188     void CollectFilterInfoAndUpdateDirty(RSRenderNode& node,
189         RSDirtyRegionManager& dirtyManager, const RectI& globalFilterRect);
190     RectI GetVisibleEffectDirty(RSRenderNode& node) const;
191 
192     void UpdateHwcNodeEnableByGlobalFilter(std::shared_ptr<RSSurfaceRenderNode>& node);
193     void UpdateHwcNodeEnableByGlobalCleanFilter(const std::vector<std::pair<NodeId, RectI>>& cleanFilter,
194         RSSurfaceRenderNode& hwcNodePtr);
195     void UpdateHwcNodeEnableByFilterRect(
196         std::shared_ptr<RSSurfaceRenderNode>& node, const RectI& filterRect, bool isReverseOrder = false);
197     void CalcHwcNodeEnableByFilterRect(
198         std::shared_ptr<RSSurfaceRenderNode>& node, const RectI& filterRect, bool isReverseOrder = false);
199     // This function is used for solving display problems caused by dirty blurfilter node half-obscured.
200     void UpdateDisplayDirtyAndExtendVisibleRegion();
201     // This function is used to update global dirty and visibleRegion
202     // by processing dirty blurfilter node obscured.
203     void ProcessFilterNodeObscured(std::shared_ptr<RSSurfaceRenderNode>& surfaceNode,
204         Occlusion::Region& extendRegion, const RSRenderNodeMap& nodeMap);
205     void UpdateHwcNodeEnableByBackgroundAlpha(RSSurfaceRenderNode& node);
206     void UpdateHwcNodeEnableBySrcRect(RSSurfaceRenderNode& node);
207     void UpdateHwcNodeEnableByBufferSize(RSSurfaceRenderNode& node);
208     void UpdateHwcNodeInfoForAppNode(RSSurfaceRenderNode& node);
209     void UpdateSrcRect(RSSurfaceRenderNode& node,
210         const Drawing::Matrix& absMatrix, const RectI& clipRect);
211     void UpdateDstRect(RSSurfaceRenderNode& node, const RectI& absRect, const RectI& clipRect);
212     void UpdateHwcNodeProperty(std::shared_ptr<RSSurfaceRenderNode> hwcNode);
213     void UpdateHwcNodeByTransform(RSSurfaceRenderNode& node);
214     void UpdateHwcNodeEnableByRotateAndAlpha(std::shared_ptr<RSSurfaceRenderNode>& node);
215     void ProcessAncoNode(std::shared_ptr<RSSurfaceRenderNode>& hwcNodePtr);
216     void InitAncoStatus();
217     void UpdateAncoNodeHWCDisabledState();
218     void UpdateHwcNodeEnableByHwcNodeBelowSelfInApp(std::vector<RectI>& hwcRects,
219         std::shared_ptr<RSSurfaceRenderNode>& hwcNode);
220     void UpdateChildHwcNodeEnableByHwcNodeBelow(std::vector<RectI>& hwcRects,
221         std::shared_ptr<RSSurfaceRenderNode>& appNode);
222     void UpdateHwcNodeEnableByHwcNodeBelowSelf(std::vector<RectI>& hwcRects,
223         std::shared_ptr<RSSurfaceRenderNode>& hwcNode, bool isIntersectWithRoundCorner);
224     void UpdateHwcNodeDirtyRegionAndCreateLayer(std::shared_ptr<RSSurfaceRenderNode>& node);
225     void AllSurfacesDrawnInUniRender(const std::vector<std::weak_ptr<RSSurfaceRenderNode>>& hwcNodes);
226     void UpdatePointWindowDirtyStatus(std::shared_ptr<RSSurfaceRenderNode>& pointWindow);
227     void UpdateTopLayersDirtyStatus(const std::vector<std::shared_ptr<RSSurfaceRenderNode>>& topLayers);
228     void UpdateCornerRadiusInfoForDRM(std::shared_ptr<RSSurfaceRenderNode> hwcNode, std::vector<RectI>& hwcRects);
229     bool CheckIfRoundCornerIntersectDRM(const float& ratio, std::vector<float>& ratioVector,
230         const Vector4f& instanceCornerRadius, const RectI& instanceAbsRect, const RectI& hwcAbsRect);
231     void UpdateHwcNodeEnable();
232     void UpdateHwcNodeEnableByNodeBelow();
233     void PrevalidateHwcNode();
234 
235     // use in QuickPrepareSurfaceRenderNode, update SurfaceRenderNode's uiFirst status
236     void PrepareForUIFirstNode(RSSurfaceRenderNode& node);
237 
238     void UpdateHwcNodeDirtyRegionForApp(std::shared_ptr<RSSurfaceRenderNode>& appNode,
239         std::shared_ptr<RSSurfaceRenderNode>& hwcNode);
240 
241     void UpdatePrepareClip(RSRenderNode& node);
242 
243     void CheckMergeDisplayDirtyByTransparent(RSSurfaceRenderNode& surfaceNode) const;
244     void CheckMergeDisplayDirtyByZorderChanged(RSSurfaceRenderNode& surfaceNode) const;
245     void CheckMergeDisplayDirtyByPosChanged(RSSurfaceRenderNode& surfaceNode) const;
246     void CheckMergeDisplayDirtyByShadowChanged(RSSurfaceRenderNode& surfaceNode) const;
247     void CheckMergeDisplayDirtyBySurfaceChanged() const;
248     void CheckMergeDisplayDirtyByAttractionChanged(RSSurfaceRenderNode& surfaceNode) const;
249     void CheckMergeSurfaceDirtysForDisplay(std::shared_ptr<RSSurfaceRenderNode>& surfaceNode) const;
250     void CheckMergeDisplayDirtyByTransparentRegions(RSSurfaceRenderNode& surfaceNode) const;
251     void CheckMergeFilterDirtyByIntersectWithDirty(OcclusionRectISet& filterSet, bool isGlobalDirty);
252 
253     void CheckMergeDisplayDirtyByTransparentFilter(std::shared_ptr<RSSurfaceRenderNode>& surfaceNode,
254         Occlusion::Region& accumulatedDirtyRegion);
255     void CheckMergeGlobalFilterForDisplay(Occlusion::Region& accumulatedDirtyRegion);
256     void CheckMergeDebugRectforRefreshRate(std::vector<RSBaseRenderNode::SharedPtr>& surfaces);
257 
258     // merge last childRect as dirty if any child has been removed
259     void MergeRemovedChildDirtyRegion(RSRenderNode& node, bool needMap = false);
260     // Reset curSurface info as upper surfaceParent in case surfaceParent has multi children
261     void ResetCurSurfaceInfoAsUpperSurfaceParent(RSSurfaceRenderNode& node);
262 
263     void CheckColorSpace(RSSurfaceRenderNode& node);
264     void CheckColorSpaceWithSelfDrawingNode(RSSurfaceRenderNode& node);
265     void UpdateColorSpaceAfterHwcCalc(RSDisplayRenderNode& node);
266     void HandleColorGamuts(RSDisplayRenderNode& node, const sptr<RSScreenManager>& screenManager);
267     void CheckPixelFormat(RSSurfaceRenderNode& node);
268     void HandlePixelFormat(RSDisplayRenderNode& node, const sptr<RSScreenManager>& screenManager);
269     bool IsHardwareComposerEnabled();
270 
271     void UpdateSecuritySkipAndProtectedLayersRecord(RSSurfaceRenderNode& node);
272 
273     void SendRcdMessage(RSDisplayRenderNode& node);
274 
ForcePrepareSubTree()275     bool ForcePrepareSubTree()
276     {
277         return curSurfaceNode_ && curSurfaceNode_->GetNeedCollectHwcNode();
278     }
IsValidInVirtualScreen(RSSurfaceRenderNode & node)279     bool IsValidInVirtualScreen(RSSurfaceRenderNode& node) const
280     {
281         return !node.GetSkipLayer() && !node.GetSecurityLayer() && (screenInfo_.whiteList.empty() ||
282             screenInfo_.whiteList.find(node.GetId()) != screenInfo_.whiteList.end());
283     }
284     void UpdateRotationStatusForEffectNode(RSEffectRenderNode& node);
285     void CheckFilterNodeInSkippedSubTreeNeedClearCache(const RSRenderNode& node, RSDirtyRegionManager& dirtyManager);
286     void UpdateHwcNodeRectInSkippedSubTree(const RSRenderNode& node);
287     void UpdateSubSurfaceNodeRectInSkippedSubTree(const RSRenderNode& rootNode);
288     void CollectOcclusionInfoForWMS(RSSurfaceRenderNode& node);
289     void CollectEffectInfo(RSRenderNode& node);
290 
291     void UpdateVirtualScreenSecurityExemption(RSDisplayRenderNode& node);
292 
293     /* Check whether gpu overdraw buffer feature can be enabled on the RenderNode
294      * 1. is leash window
295      * 2. window has scale, radius, no transparency and no animation
296      * 3. find the child background node, which is no transparency and completely filling the window
297      */
298     void CheckIsGpuOverDrawBufferOptimizeNode(RSSurfaceRenderNode& node);
299 
300     void MarkBlurIntersectWithDRM(std::shared_ptr<RSRenderNode> node) const;
301 
302     // Used for closing HDR in PC multidisplay becauseof performance and open when singledisplay
303     void SetHdrWhenMultiDisplayChangeInPC();
304 
305     // record DRM nodes
306     std::vector<std::weak_ptr<RSSurfaceRenderNode>> drmNodes_;
307     sptr<RSScreenManager> screenManager_;
308     ScreenInfo screenInfo_;
309     RectI screenRect_;
310     std::shared_ptr<RSDirtyRegionManager> curSurfaceDirtyManager_;
311     std::shared_ptr<RSSurfaceRenderNode> curSurfaceNode_;
312     std::stack<std::shared_ptr<RSDirtyRegionManager>> surfaceDirtyManager_;
313     std::stack<std::shared_ptr<RSSurfaceRenderNode>> surfaceNode_;
314     float curAlpha_ = 1.f;
315     Vector4f curCornerRadius_{ 0.f, 0.f, 0.f, 0.f };
316     bool dirtyFlag_ { false };
317     Drawing::Rect boundsRect_ {};
318     Gravity frameGravity_ = Gravity::DEFAULT;
319 
320     int32_t offsetX_ { 0 };
321     int32_t offsetY_ { 0 };
322     Drawing::Matrix parentSurfaceNodeMatrix_;
323 
324     ScreenId currentVisitDisplay_ = INVALID_SCREEN_ID;
325     std::map<ScreenId, bool> displayHasSecSurface_;
326     std::map<ScreenId, bool> displayHasSkipSurface_;
327     std::map<ScreenId, bool> displayHasProtectedSurface_;
328     std::map<ScreenId, bool> displaySpecailSurfaceChanged_;
329     std::map<ScreenId, bool> hasCaptureWindow_;
330 
331     bool hasFingerprint_ = false;
332     bool hasUniRenderHdrSurface_ = false;
333 
334     std::shared_ptr<RSBaseRenderEngine> renderEngine_;
335 
336     std::shared_ptr<RSDirtyRegionManager> curDisplayDirtyManager_;
337     std::shared_ptr<RSDisplayRenderNode> curDisplayNode_;
338     bool doAnimate_ = false;
339     bool isSurfaceRotationChanged_ = false;
340     bool isPartialRenderEnabled_ = false;
341     bool isCompleteRenderEnabled_ = false;
342     bool isOpDropped_ = false;
343     bool isDirtyRegionDfxEnabled_ = false; // dirtyRegion DFX visualization
344     bool isTargetDirtyRegionDfxEnabled_ = false;
345     bool isOpaqueRegionDfxEnabled_ = false;
346     bool isVisibleRegionDfxEnabled_ = false;
347     bool isAllSurfaceVisibleDebugEnabled_ = false;
348     bool isDisplayDirtyDfxEnabled_ = false;
349     bool isCanvasNodeSkipDfxEnabled_ = false;
350     bool isVirtualDirtyEnabled_ = false;
351     bool isVirtualDirtyDfxEnabled_ = false;
352     bool isExpandScreenDirtyEnabled_ = false;
353     bool hasMirrorDisplay_ = false;
354     // if display node has skip layer except capsule window
355     bool hasSkipLayer_ = false;
356     bool isOcclusionEnabled_ = false;
357     bool isSkipCanvasNodeOutOfScreen_ = false;
358     bool isScreenRotationAnimating_ = false;
359     bool displayNodeRotationChanged_ = false;
360     std::vector<std::string> dfxTargetSurfaceNames_;
361     PartialRenderType partialRenderType_;
362     DirtyRegionDebugType dirtyRegionDebugType_;
363     SurfaceRegionDebugType surfaceRegionDebugType_;
364     bool isRegionDebugEnabled_ = false;
365     bool isDirty_ = false;
366     // added for judge if drawing cache changes
367     bool isDrawingCacheEnabled_ = false;
368     // opinc feature
369     bool autoCacheEnable_ = false;
370     bool unchangeMarkEnable_ = false;
371     bool unchangeMarkInApp_ = false;
372 
373     GraphicColorGamut newColorSpace_ = GraphicColorGamut::GRAPHIC_COLOR_GAMUT_SRGB;
374     GraphicPixelFormat newPixelFormat_ = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888;
375     uint64_t currentFocusedNodeId_ = 0;
376     uint64_t focusedLeashWindowId_ = 0;
377 
378     bool isSubThread_ = false;
379     bool isUIFirstDebugEnable_ = false;
380     bool ancestorNodeHasAnimation_ = false;
381     bool hasAccumulatedClip_ = false;
382     uint32_t threadIndex_ = UNI_MAIN_THREAD_INDEX;
383 
384     bool isPrevalidateHwcNodeEnable_ = false;
385 
386     RectI prepareClipRect_{0, 0, 0, 0}; // renderNode clip rect used in Prepare
387 
388     float globalZOrder_ = 0.0f;
389     bool isHardwareForcedDisabled_ = false; // indicates if hardware composer is totally disabled
390     std::vector<std::shared_ptr<RSSurfaceRenderNode>> hardwareEnabledNodes_;
391     // vector of all app window nodes with surfaceView, sorted by zOrder
392     std::vector<std::shared_ptr<RSSurfaceRenderNode>> appWindowNodesInZOrder_;
393     // vector of hardwareEnabled nodes above displayNodeSurface like pointer window
394     std::vector<std::shared_ptr<RSSurfaceRenderNode>> hardwareEnabledTopNodes_;
395     // vector of Appwindow nodes ids not contain subAppWindow nodes ids in current frame
396     std::queue<NodeId> curMainAndLeashWindowNodesIds_;
397     // vector of Appwindow nodes ids not contain subAppWindow nodes ids in last frame
398     static inline std::queue<NodeId> preMainAndLeashWindowNodesIds_;
399     // vector of current dsiplaynode mainwindow surface visible info
400     VisibleData dstCurVisVec_;
401     // vector of current frame mainwindow surface visible info
402     VisibleData allDstCurVisVec_;
403     // vector of last frame mainwindow surface visible info
404     static inline VisibleData allLastVisVec_;
405     std::mutex occlusionMutex_;
406     float localZOrder_ = 0.0f; // local zOrder for surfaceView under same app window node
407 
408     static void ProcessUnpairedSharedTransitionNode();
409 
410     uint32_t appWindowNum_ = 0;
411     // variable for occlusion
412     bool needRecalculateOcclusion_ = false;
413     Occlusion::Region accumulatedOcclusionRegion_;
414     Occlusion::Region occlusionRegionWithoutSkipLayer_;
415 
416     bool curDirty_ = false;
417     // to record and pass container node dirty to leash node.
418     bool curContainerDirty_ = false;
419 
420     // record nodes in surface which has filter may influence globalDirty
421     OcclusionRectISet globalFilter_;
422     // record filter in current surface when there is no below dirty
423     OcclusionRectISet curSurfaceNoBelowDirtyFilter_;
424     // record container nodes which need filter
425     FilterRectISet containerFilter_;
426     // record nodes which has transparent clean filter
427     std::unordered_map<NodeId, std::vector<std::pair<NodeId, RectI>>> transparentCleanFilter_;
428     // record nodes which has transparent dirty filter
429     std::unordered_map<NodeId, std::vector<std::pair<NodeId, RectI>>> transparentDirtyFilter_;
430 
431     std::vector<RectI> globalFilterRects_;
432     std::vector<RectI> globalSurfaceBounds_;
433     // visible filter in transparent surface or display must prepare
434     bool filterInGlobal_ = true;
435     bool needRequestNextVsync_ = true;
436 
437     NodeId FindInstanceChildOfDisplay(std::shared_ptr<RSRenderNode> node);
438 
439     void UpdateSurfaceRenderNodeScale(RSSurfaceRenderNode& node);
440 
441     // use for hardware compose disabled reason collection
442     HwcDisabledReasonCollection& hwcDisabledReasonCollection_ = HwcDisabledReasonCollection::GetInstance();
443 
444     bool zoomStateChange_ = false;
445 
446     // anco RSSurfaceNode process
447     bool ancoHasGpu_ = false;
448     std::unordered_set<std::shared_ptr<RSSurfaceRenderNode>> ancoNodes_;
449 };
450 } // namespace Rosen
451 } // namespace OHOS
452 
453 #endif // RENDER_SERVICE_CORE_PIPELINE_RS_UNI_RENDER_VISITOR_H
454