#6107: Associate a LayerManager instance with a scene (root) node at …

…construction time

This removes the (wrong) direct reference the GlobalSceneGraph to update the nodes

include/ilayer.h

@@ -237,9 +237,12 @@ class ILayerModule :
 	public RegisterableModule
 {
 public:
-	virtual ~ILayerModule() {}
+    ~ILayerModule() override {}
 
-	virtual ILayerManager::Ptr createLayerManager() = 0;
+    /**
+     * Creates a new layer manager instance associated to the given scene (root) node
+     */
+    virtual ILayerManager::Ptr createLayerManager(INode& rootNode) = 0;
 };
 
 } // namespace scene

libs/scene/BasicRootNode.h

@@ -39,7 +39,7 @@ class BasicRootNode final :
         _targetManager = GlobalEntityModule().createTargetManager();
         _selectionGroupManager = GlobalSelectionGroupModule().createSelectionGroupManager();
         _selectionSetManager = GlobalSelectionSetModule().createSelectionSetManager();
-        _layerManager = GlobalLayerModule().createLayerManager();
+        _layerManager = GlobalLayerModule().createLayerManager(*this);
         _undoSystem = GlobalUndoSystemFactory().createUndoSystem();
     }
 

libs/scene/Traverse.cpp

@@ -1,5 +1,6 @@
 #include "Traverse.h"
 
+#include "iscenegraph.h"
 #include "scenelib.h"
 #include "ibrush.h"
 #include "ipatch.h"

libs/scenelib.h

@@ -2,7 +2,6 @@
 
 #include "inode.h"
 #include "ilayer.h"
-#include "iscenegraph.h"
 #include "iselectable.h"
 #include "ipatch.h"
 #include "ibrush.h"
@@ -144,27 +143,25 @@ class UpdateNodeVisibilityWalker :
     public NodeVisitor
 {
     std::stack<bool> _visibilityStack;
+    ILayerManager& _layerManager;
 
-    scene::IMapRootNodePtr _root;
 public:
-    UpdateNodeVisibilityWalker(const scene::IMapRootNodePtr& root) :
-        _root(root)
-    {
-        assert(_root);
-    }
+    UpdateNodeVisibilityWalker(ILayerManager& layerManager) :
+        _layerManager(layerManager)
+    {}
 
-    bool pre(const INodePtr& node) 
+    bool pre(const INodePtr& node) override
     {
         // Update the node visibility and store the result
-        bool nodeIsVisible = _root->getLayerManager().updateNodeVisibility(node);
+        bool nodeIsVisible = _layerManager.updateNodeVisibility(node);
 
         // Add a new element for this level
         _visibilityStack.push(nodeIsVisible);
 
         return true;
     }
 
-    void post(const INodePtr& node) 
+    void post(const INodePtr& node) override
     {
         // Is this child visible?
         bool childIsVisible = _visibilityStack.top();
@@ -207,7 +204,7 @@ inline void addNodeToContainer(const INodePtr& node, const INodePtr& container)
     if (rootNode)
     {
         // Ensure that worldspawn is visible
-        UpdateNodeVisibilityWalker walker(rootNode);
+        UpdateNodeVisibilityWalker walker(rootNode->getLayerManager());
         container->traverse(walker);
     }
 }

radiantcore/layers/LayerManager.cpp

@@ -24,7 +24,8 @@ namespace
 	constexpr int NO_PARENT_ID = -1;
 }
 
-LayerManager::LayerManager() :
+LayerManager::LayerManager(INode& rootNode) :
+    _rootNode(rootNode),
 	_activeLayer(DEFAULT_LAYER)
 {
 	// Create the "master" layer with ID DEFAULT_LAYER
@@ -104,7 +105,7 @@ void LayerManager::deleteLayer(const std::string& name)
 
 	// Remove all nodes from this layer first, but don't de-select them yet
 	RemoveFromLayerWalker walker(layerID);
-	GlobalSceneGraph().root()->traverse(walker);
+	_rootNode.traverse(walker);
 
 	// Remove the layer
 	_layers.erase(layerID);
@@ -273,8 +274,8 @@ bool LayerManager::setLayerVisibilityRecursively(int layerId, bool visible)
 
 void LayerManager::updateSceneGraphVisibility()
 {
-	UpdateNodeVisibilityWalker walker(GlobalSceneGraph().root());
-	GlobalSceneGraph().root()->traverseChildren(walker);
+	UpdateNodeVisibilityWalker walker(*this);
+	_rootNode.traverseChildren(walker);
 
 	// Redraw
 	SceneChangeNotify();
@@ -337,7 +338,7 @@ void LayerManager::removeSelectionFromLayer(int layerID)
 	onNodeMembershipChanged();
 }
 
-bool LayerManager::updateNodeVisibility(const scene::INodePtr& node)
+bool LayerManager::updateNodeVisibility(const INodePtr& node)
 {
     if (!node->supportsStateFlag(Node::eLayered))
     {
@@ -378,11 +379,7 @@ bool LayerManager::updateNodeVisibility(const scene::INodePtr& node)
 void LayerManager::setSelected(int layerID, bool selected)
 {
 	SetLayerSelectedWalker walker(layerID, selected);
-
-    if (GlobalSceneGraph().root())
-    {
-        GlobalSceneGraph().root()->traverseChildren(walker);
-    }
+    _rootNode.traverseChildren(walker);
 }
 
 int LayerManager::getParentLayer(int layerId)

radiantcore/layers/LayerManager.h

@@ -11,6 +11,8 @@ class LayerManager :
 	public ILayerManager
 {
 private:
+    INode& _rootNode;
+
     // The list of named layers, indexed by an integer ID
     std::map<int, std::string> _layers;
 
@@ -31,7 +33,7 @@ class LayerManager :
 	sigc::signal<void> _nodeMembershipChangedSignal;
 
 public:
-	LayerManager();
+	LayerManager(INode& rootNode);
 
 	/**
 	 * greebo: Creates a new layer with the given name.

radiantcore/layers/LayerModule.cpp

@@ -100,9 +100,9 @@ class LayerModule :
 		);
 	}
 
-	ILayerManager::Ptr createLayerManager() override
+	ILayerManager::Ptr createLayerManager(INode& rootNode) override
 	{
-		return std::make_shared<LayerManager>();
+		return std::make_shared<LayerManager>(rootNode);
 	}
 
 private:

radiantcore/layers/RemoveFromLayerWalker.h

@@ -1,42 +1,44 @@
-#ifndef REMOVEFROMLAYERWALKER_H_
-#define REMOVEFROMLAYERWALKER_H_
+#pragma once
 
 #include "ilayer.h"
 
-namespace scene {
+namespace scene
+{
 
 class RemoveFromLayerWalker :
     public selection::SelectionSystem::Visitor,
-	public NodeVisitor
+    public NodeVisitor
 {
+private:
 	int _layer;
 
 public:
 	/**
-	 * Pass the ID of the layer the items should be removed from.
+	 * Pass the ID of the layer the nodes should be removed from
 	 */
 	RemoveFromLayerWalker(int layer) :
 		_layer(layer)
 	{}
 
 	// SelectionSystem::Visitor
-	void visit(const INodePtr& node) const {
+	void visit(const INodePtr& node) const override
+    {
 		// Remove the node from this layer
 		node->removeFromLayer(_layer);
 
-		if (Node_isEntity(node)) {
+		if (Node_isEntity(node))
+        {
 			// We have an entity, traverse all children too
 			node->traverseChildren(const_cast<RemoveFromLayerWalker&>(*this));
 		}
 	}
 
 	// scene::NodeVisitor
-	bool pre(const INodePtr& node) {
+	bool pre(const INodePtr& node) override
+    {
 		node->removeFromLayer(_layer);
 		return true;
 	}
 };
 
-} // namespace scene
-
-#endif /* REMOVEFROMLAYERWALKER_H_ */
+} // namespace

radiantcore/map/RootNode.cpp

@@ -24,7 +24,7 @@ RootNode::RootNode(const std::string& name) :
 	_selectionSetManager = GlobalSelectionSetModule().createSelectionSetManager();
 	assert(_selectionSetManager);
 
-	_layerManager = GlobalLayerModule().createLayerManager();
+	_layerManager = GlobalLayerModule().createLayerManager(*this);
 	assert(_layerManager);
 
     _undoSystem = GlobalUndoSystemFactory().createUndoSystem();

radiantcore/selection/algorithm/Group.cpp

@@ -93,7 +93,7 @@ void ParentPrimitivesToEntityWalker::reparent()
 		<< " primitives." << std::endl;
 
 	// Update parent node/subgraph visibility after reparenting
-	scene::UpdateNodeVisibilityWalker updater(_parent->getRootNode());
+	scene::UpdateNodeVisibilityWalker updater(_parent->getRootNode()->getLayerManager());
 
 	// Update the new parent too
 	_parent->traverse(updater);

radiantcore/selection/algorithm/Transformation.cpp

@@ -200,7 +200,7 @@ class SelectionCloner :
 
 			// Cloned child nodes are assigned the layers of the source nodes
 			// update the layer visibility flags using the layer manager of the source tree
-			scene::UpdateNodeVisibilityWalker visibilityUpdater(node->getRootNode());
+			scene::UpdateNodeVisibilityWalker visibilityUpdater(node->getRootNode()->getLayerManager());
 			clone->traverse(visibilityUpdater);
 		}
 	}