Simplify SceneGraph. Do not need an Id to identify nodes nor a table to lookup packed nodes from sparse id table

engine/SceneGraph.cpp

@@ -25,85 +25,63 @@ OTHER DEALINGS IN THE SOFTWARE.
 */
 
 #include "SceneGraph.h"
-#include "Device.h"
-#include "DebugRenderer.h"
 #include "Quat.h"
+#include "Allocator.h"
 
 namespace crown
 {
 
 //-----------------------------------------------------------------------------
 SceneGraph::SceneGraph()
-	: m_world_poses(m_allocator)
-	, m_local_poses(m_allocator)
-	, m_parents(m_allocator)
+	: m_world_poses(default_allocator())
+	, m_local_poses(default_allocator())
+	, m_parents(default_allocator())
 {
 }
 
 //-----------------------------------------------------------------------------
-NodeId SceneGraph::create_node(const Vec3& pos, const Quat& rot)
+int32_t SceneGraph::create_node(int32_t parent, const Vec3& pos, const Quat& rot)
 {
-	const NodeId node = m_nodes.create();
-
 	Mat4 pose(rot, pos);
 
-	if (m_world_poses.size() <= node.index)
-	{
-		m_world_poses.push_back(pose);
-		m_local_poses.push_back(pose);
-		m_parents.push_back(-1);
-		m_sparse_to_packed[node.index] = m_world_poses.size() - 1;
-	}
-	else
-	{
-		m_world_poses[node.index] = pose;
-		m_local_poses[node.index] = pose;
-		m_parents[node.index] = -1;
-		m_sparse_to_packed[node.index] = node.index;
-	}
+	m_world_poses.push_back(pose);
+	m_local_poses.push_back(pose);
+	m_parents.push_back(parent);
 
-	return node;
+	return m_local_poses.size() - 1;
 }
 
 //-----------------------------------------------------------------------------
-void SceneGraph::destroy_node(NodeId id)
+void SceneGraph::destroy_node(int32_t id)
 {
 	(void)id;
 }
 
 //-----------------------------------------------------------------------------
-void SceneGraph::link(NodeId child, NodeId parent)
+void SceneGraph::link(int32_t child, int32_t parent)
 {
-	CE_ASSERT(m_nodes.has(child), "Child node does not exist");
-	CE_ASSERT(m_nodes.has(parent), "Parent node does not exist");
-
-	m_parents[m_sparse_to_packed[child.index]] = m_sparse_to_packed[parent.index];
+	m_parents[child] = parent;
 }
 
 //-----------------------------------------------------------------------------
-void SceneGraph::unlink(NodeId child)
+void SceneGraph::unlink(int32_t child)
 {
-	CE_ASSERT(m_nodes.has(child), "Node does not exist");
-
-	m_local_poses[m_sparse_to_packed[child.index]] = m_world_poses[m_sparse_to_packed[child.index]];
-	m_parents[m_sparse_to_packed[child.index]] = -1;
+	// Copy world pose before unlinking from parent
+	m_local_poses[child] = m_world_poses[m_parents[child]];
+	m_parents[child] = -1;
 }
 
 //-----------------------------------------------------------------------------
-void SceneGraph::set_local_position(NodeId node, const Vec3& pos)
+void SceneGraph::set_local_position(int32_t node, const Vec3& pos)
 {
-	CE_ASSERT(m_nodes.has(node), "Node does not exist");
-
-	Mat4& local_pose = m_local_poses[m_sparse_to_packed[node.index]];
+	Mat4& local_pose = m_local_poses[node];
 	local_pose.set_translation(pos);
 }
 
 //-----------------------------------------------------------------------------
-void SceneGraph::set_local_rotation(NodeId node, const Quat& rot)
+void SceneGraph::set_local_rotation(int32_t node, const Quat& rot)
 {
-	CE_ASSERT(m_nodes.has(node), "Node does not exist");
-
-	Mat4& local_pose = m_local_poses[m_sparse_to_packed[node.index]];
+	Mat4& local_pose = m_local_poses[node];
 
 	Vec3 local_translation = local_pose.translation();
 	local_pose = rot.to_mat4();
@@ -111,59 +89,45 @@ void SceneGraph::set_local_rotation(NodeId node, const Quat& rot)
 }
 
 //-----------------------------------------------------------------------------
-void SceneGraph::set_local_pose(NodeId node, const Mat4& pose)
+void SceneGraph::set_local_pose(int32_t node, const Mat4& pose)
 {
-	CE_ASSERT(m_nodes.has(node), "Node does not exist");
-
-	m_local_poses[m_sparse_to_packed[node.index]] = pose;
+	m_local_poses[node] = pose;
 }
 
 //-----------------------------------------------------------------------------
-Vec3 SceneGraph::local_position(NodeId node) const
+Vec3 SceneGraph::local_position(int32_t node) const
 {
-	CE_ASSERT(m_nodes.has(node), "Node does not exist");
-
-	return m_local_poses[m_sparse_to_packed[node.index]].translation();
+	return m_local_poses[node].translation();
 }
 
 //-----------------------------------------------------------------------------
-Quat SceneGraph::local_rotation(NodeId node) const
+Quat SceneGraph::local_rotation(int32_t /*node*/) const
 {
-	CE_ASSERT(m_nodes.has(node), "Node does not exist");
-
 	return Quat(Vec3(1, 0, 0), 0.0f);
 }
 
 //-----------------------------------------------------------------------------
-Mat4 SceneGraph::local_pose(NodeId node) const
+Mat4 SceneGraph::local_pose(int32_t node) const
 {
-	CE_ASSERT(m_nodes.has(node), "Node does not exist");
-
-	return m_local_poses[m_sparse_to_packed[node.index]];
+	return m_local_poses[node];
 }
 
 //-----------------------------------------------------------------------------
-Vec3 SceneGraph::world_position(NodeId node) const
+Vec3 SceneGraph::world_position(int32_t node) const
 {
-	CE_ASSERT(m_nodes.has(node), "Node does not exist");
-
-	return m_world_poses[m_sparse_to_packed[node.index]].translation();
+	return m_world_poses[node].translation();
 }
 
 //-----------------------------------------------------------------------------
-Quat SceneGraph::world_rotation(NodeId node) const
+Quat SceneGraph::world_rotation(int32_t /*node*/) const
 {
-	CE_ASSERT(m_nodes.has(node), "Node does not exist");
-
 	return Quat(Vec3(1, 0, 0), 0.0f);
 }
 
 //-----------------------------------------------------------------------------
-Mat4 SceneGraph::world_pose(NodeId node) const
+Mat4 SceneGraph::world_pose(int32_t node) const
 {
-	CE_ASSERT(m_nodes.has(node), "Node does not exist");
-
-	return m_world_poses[m_sparse_to_packed[node.index]];
+	return m_world_poses[node];
 }
 
 //-----------------------------------------------------------------------------
@@ -180,12 +144,6 @@ void SceneGraph::update()
 			m_world_poses[i] = m_local_poses[m_parents[i]] * m_local_poses[i];
 		}
 	}
-
-	// Draw debug
-	for (uint32_t i = 0; i < m_world_poses.size(); i++)
-	{
-		device()->debug_renderer()->add_pose(m_world_poses[i], true);
-	}
 }
 
 } // namespace crown

engine/SceneGraph.h

@@ -29,52 +29,35 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "Types.h"
 #include "Mat4.h"
 #include "List.h"
-#include "IdTable.h"
-#include "HeapAllocator.h"
 
 namespace crown
 {
 
-#define MAX_NODES 1024
-typedef Id NodeId;
-
-class SceneGraph
+struct SceneGraph
 {
-public:
-
 					SceneGraph();
+	int32_t			create_node(int32_t parent, const Vec3& pos, const Quat& rot);
+	void			destroy_node(int32_t id);
 
-	NodeId			create_node(const Vec3& pos, const Quat& rot);
-	void			destroy_node(NodeId id);
-
-	void			link(NodeId child, NodeId parent);
-	void			unlink(NodeId child);
+	void			link(int32_t child, int32_t parent);
+	void			unlink(int32_t child);
 
-	void			set_local_position(NodeId node, const Vec3& pos);
-	void			set_local_rotation(NodeId node, const Quat& rot);
-	void			set_local_pose(NodeId node, const Mat4& pose);
+	void			set_local_position(int32_t node, const Vec3& pos);
+	void			set_local_rotation(int32_t node, const Quat& rot);
+	void			set_local_pose(int32_t node, const Mat4& pose);
 
-	Vec3			local_position(NodeId node) const;
-	Quat			local_rotation(NodeId node) const;
-	Mat4			local_pose(NodeId node) const;
+	Vec3			local_position(int32_t node) const;
+	Quat			local_rotation(int32_t node) const;
+	Mat4			local_pose(int32_t node) const;
 
-	Vec3			world_position(NodeId node) const;
-	Quat			world_rotation(NodeId node) const;
-	Mat4			world_pose(NodeId node) const;
+	Vec3			world_position(int32_t node) const;
+	Quat			world_rotation(int32_t node) const;
+	Mat4			world_pose(int32_t node) const;
 
 	void			update();
 
-private:
-
-	HeapAllocator	m_allocator;
-
-	// Sparse table of nodes
-	IdTable<MAX_NODES> m_nodes;
-
-	// Conversion from sparse table to packed array
-	uint32_t		m_sparse_to_packed[MAX_NODES];
+public:
 
-	// Packed arrays of transforms
 	List<Mat4>		m_world_poses;
 	List<Mat4>		m_local_poses;
 	List<int32_t>	m_parents;