Include protected node objects when creating node priority map for event dispatcher.

Author: rh101

core/2d/CCNode.cpp

@@ -1164,6 +1164,49 @@ void Node::resetChild(Node* child, bool cleanup)
     child->setParent(nullptr);
 }
 
+void Node::fillGlobalZNodeMap(std::unordered_map<float, std::vector<Node*>>& map,
+                              const std::function<bool(Node*)>& addNodePredicate)
+{
+    sortAllChildren();
+
+    int i                    = 0;
+    const auto childrenCount = _children.size();
+
+    if (childrenCount > 0)
+    {
+        Node* child = nullptr;
+        // visit children zOrder < 0
+        for (; i < childrenCount; i++)
+        {
+            child = _children.at(i);
+
+            if (child && child->getLocalZOrder() < 0)
+                child->fillGlobalZNodeMap(map, addNodePredicate);
+            else
+                break;
+        }
+
+        if (addNodePredicate(this))
+        {
+            map[this->getGlobalZOrder()].emplace_back(this);
+        }
+
+        for (; i < childrenCount; i++)
+        {
+            child = _children.at(i);
+            if (child)
+                child->fillGlobalZNodeMap(map, addNodePredicate);
+        }
+    }
+    else
+    {
+        if (addNodePredicate(this))
+        {
+            map[this->getGlobalZOrder()].emplace_back(this);
+        }
+    }
+}
+
 void Node::detachChild(Node* child, ssize_t childIndex, bool cleanup)
 {
     if (_childrenIndexer)

core/2d/CCNode.h

@@ -1839,6 +1839,14 @@ class AX_DLL Node : public Ref
      */
     void resetChild(Node* child, bool cleanup);
 
+
+    /*
+     * Adds child nodes to an unordered map based on their global Z values and a predicate to
+     * decide if those nodes should be added
+     */
+    virtual void fillGlobalZNodeMap(std::unordered_map<float, std::vector<Node*>>& map,
+                                const std::function<bool(Node*)>& addNodePredicate);
+
     // Nodes should be created using create();
     Node();
     virtual ~Node();

core/2d/CCProtectedNode.cpp

@@ -439,4 +439,67 @@ void ProtectedNode::setGlobalZOrder(float globalZOrder)
         child->setGlobalZOrder(globalZOrder);
 }
 
+void ProtectedNode::fillGlobalZNodeMap(std::unordered_map<float, std::vector<Node*>>& map,
+                                       const std::function<bool(Node*)>& nodeTest)
+{
+    sortAllChildren();
+    sortAllProtectedChildren();
+
+    const auto childrenCount          = _children.size();
+    const auto protectedChildrenCount = _protectedChildren.size();
+
+    if (childrenCount > 0 || protectedChildrenCount > 0)
+    {
+        Node* child = nullptr;
+        // visit children zOrder < 0
+        int childIndex     = 0;
+        int protectedIndex = 0;
+        for (; childIndex < childrenCount; childIndex++)
+        {
+            child = _children.at(childIndex);
+
+            if (child && child->getLocalZOrder() < 0)
+                child->fillGlobalZNodeMap(map, nodeTest);
+            else
+                break;
+        }
+
+        for (; protectedIndex < protectedChildrenCount; protectedIndex++)
+        {
+            child = _protectedChildren.at(protectedIndex);
+
+            if (child && child->getLocalZOrder() < 0)
+                child->fillGlobalZNodeMap(map, nodeTest);
+            else
+                break;
+        }
+
+        if (nodeTest(this))
+        {
+            map[this->getGlobalZOrder()].emplace_back(this);
+        }
+
+        for (; childIndex < childrenCount; childIndex++)
+        {
+            child = _children.at(childIndex);
+            if (child)
+                child->fillGlobalZNodeMap(map, nodeTest);
+        }
+
+        for (; protectedIndex < protectedChildrenCount; protectedIndex++)
+        {
+            child = _protectedChildren.at(protectedIndex);
+            if (child)
+                child->fillGlobalZNodeMap(map, nodeTest);
+        }
+    }
+    else
+    {
+        if (nodeTest(this))
+        {
+            map[this->getGlobalZOrder()].emplace_back(this);
+        }
+    }
+}
+
 NS_AX_END

core/2d/CCProtectedNode.h

@@ -188,6 +188,10 @@ class AX_DLL ProtectedNode : public Node
     virtual void disableCascadeOpacity() override;
     virtual void setCameraMask(unsigned short mask, bool applyChildren = true) override;
     virtual void setGlobalZOrder(float globalZOrder) override;
+
+    void fillGlobalZNodeMap(std::unordered_map<float, std::vector<Node*>>& map,
+                        const std::function<bool(Node*)>& addNodePredicate) override;
+
     ProtectedNode();
     virtual ~ProtectedNode();
 

core/base/CCEventDispatcher.cpp

@@ -211,72 +211,31 @@ EventDispatcher::~EventDispatcher()
     removeAllEventListeners();
 }
 
-void EventDispatcher::visitTarget(Node* node, bool isRootNode)
+void EventDispatcher::fillNodePriorityMap(Node* rootNode)
 {
-    node->sortAllChildren();
+    rootNode->fillGlobalZNodeMap(
+        _globalZOrderNodeMap, [this](Node* n) -> bool { return _nodeListenersMap.find(n) != _nodeListenersMap.end(); });
 
-    int i          = 0;
-    auto& children = node->getChildren();
+    std::vector<float> globalZOrders;
+    globalZOrders.reserve(_globalZOrderNodeMap.size());
 
-    auto childrenCount = children.size();
-
-    if (childrenCount > 0)
+    for (const auto& e : _globalZOrderNodeMap)
     {
-        Node* child = nullptr;
-        // visit children zOrder < 0
-        for (; i < childrenCount; i++)
-        {
-            child = children.at(i);
+        globalZOrders.emplace_back(e.first);
+    }
 
-            if (child && child->getLocalZOrder() < 0)
-                visitTarget(child, false);
-            else
-                break;
-        }
+    std::stable_sort(globalZOrders.begin(), globalZOrders.end(),
+                     [](const float a, const float b) { return a < b; });
 
-        if (_nodeListenersMap.find(node) != _nodeListenersMap.end())
-        {
-            _globalZOrderNodeMap[node->getGlobalZOrder()].emplace_back(node);
-        }
-
-        for (; i < childrenCount; i++)
-        {
-            child = children.at(i);
-            if (child)
-                visitTarget(child, false);
-        }
-    }
-    else
+    for (const auto& globalZ : globalZOrders)
     {
-        if (_nodeListenersMap.find(node) != _nodeListenersMap.end())
+        for (const auto& n : _globalZOrderNodeMap[globalZ])
         {
-            _globalZOrderNodeMap[node->getGlobalZOrder()].emplace_back(node);
+            _nodePriorityMap[n] = ++_nodePriorityIndex;
         }
     }
 
-    if (isRootNode)
-    {
-        std::vector<float> globalZOrders;
-        globalZOrders.reserve(_globalZOrderNodeMap.size());
-
-        for (const auto& e : _globalZOrderNodeMap)
-        {
-            globalZOrders.emplace_back(e.first);
-        }
-
-        std::stable_sort(globalZOrders.begin(), globalZOrders.end(),
-                         [](const float a, const float b) { return a < b; });
-
-        for (const auto& globalZ : globalZOrders)
-        {
-            for (const auto& n : _globalZOrderNodeMap[globalZ])
-            {
-                _nodePriorityMap[n] = ++_nodePriorityIndex;
-            }
-        }
-
-        _globalZOrderNodeMap.clear();
-    }
+    _globalZOrderNodeMap.clear();
 }
 
 void EventDispatcher::pauseEventListenersForTarget(Node* target, bool recursive /* = false */)
@@ -1317,7 +1276,7 @@ void EventDispatcher::sortEventListenersOfSceneGraphPriority(std::string_view li
     _nodePriorityIndex = 0;
     _nodePriorityMap.clear();
 
-    visitTarget(rootNode, true);
+    fillNodePriorityMap(rootNode);
 
     // After sort: priority < 0, > 0
     std::stable_sort(sceneGraphListeners->begin(), sceneGraphListeners->end(),

core/base/CCEventDispatcher.h

@@ -315,7 +315,7 @@ class AX_DLL EventDispatcher : public Ref
 
     /** Walks though scene graph to get the draw order for each node, it's called before sorting event listener with
      * scene graph priority */
-    void visitTarget(Node* node, bool isRootNode);
+    void fillNodePriorityMap(Node* rootNode);
 
     /** Remove all listeners in _toRemoveListeners list and cleanup */
     void cleanToRemovedListeners();