Misaki/GhostEngine
2
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update scene graph

Browse Source
This commit is contained in:
Misaki
2026-01-26 13:59:33 +09:00
parent 06a150b899
commit 8df0b46960
18 changed files with 144 additions and 1602 deletions
Download Patch File Download Diff File Expand all files Collapse all files

193
Ghost.Engine/Systems/HierarchyUtility.cs
View File

@@ -1,193 +0,0 @@
using Ghost.Entities;
using Ghost.Engine.Components;
namespace Ghost.Engine.Systems;
/// <summary>
/// Provides utility methods for working with entity hierarchies.
/// </summary>
public static class HierarchyUtility
{
/// <summary>
/// Sets the parent of an entity, updating the Hierarchy component accordingly.
/// </summary>
/// <param name="world">The world containing the entities.</param>
/// <param name="child">The child entity.</param>
/// <param name="parent">The parent entity, or Entity.Invalid to make the entity a root.</param>
public static void SetParent(World world, Entity child, Entity parent)
{
if (!world.EntityManager.HasComponent<Hierarchy>(child))
{
world.EntityManager.AddComponent(child, Hierarchy.Root);
}
ref var childHierarchy = ref world.EntityManager.GetComponent<Hierarchy>(child);
// Remove from old parent's children list
if (childHierarchy.parent.IsValid)
{
RemoveFromSiblingList(world, child, childHierarchy.parent);
}
// Set new parent
childHierarchy.parent = parent;
if (parent.IsValid)
{
if (!world.EntityManager.HasComponent<Hierarchy>(parent))
{
world.EntityManager.AddComponent(parent, Hierarchy.Root);
}
ref var parentHierarchy = ref world.EntityManager.GetComponent<Hierarchy>(parent);
// Add to parent's children list
childHierarchy.nextSibling = parentHierarchy.firstChild;
parentHierarchy.firstChild = child;
}
else
{
childHierarchy.nextSibling = Entity.Invalid;
}
}
/// <summary>
/// Gets the parent of an entity.
/// </summary>
/// <param name="world">The world containing the entity.</param>
/// <param name="entity">The entity to get the parent of.</param>
/// <returns>The parent entity, or Entity.Invalid if the entity has no parent.</returns>
public static Entity GetParent(World world, Entity entity)
{
if (!world.EntityManager.HasComponent<Hierarchy>(entity))
{
return Entity.Invalid;
}
ref var hierarchy = ref world.EntityManager.GetComponent<Hierarchy>(entity);
return hierarchy.parent;
}
/// <summary>
/// Gets all children of an entity.
/// </summary>
/// <param name="world">The world containing the entity.</param>
/// <param name="parent">The parent entity.</param>
/// <param name="children">Span to store the children.</param>
/// <returns>The number of children written to the span.</returns>
public static int GetChildren(World world, Entity parent, Span<Entity> children)
{
if (!world.EntityManager.HasComponent<Hierarchy>(parent))
{
return 0;
}
ref var hierarchy = ref world.EntityManager.GetComponent<Hierarchy>(parent);
var currentChild = hierarchy.firstChild;
var count = 0;
while (currentChild.IsValid && count < children.Length)
{
children[count++] = currentChild;
if (world.EntityManager.HasComponent<Hierarchy>(currentChild))
{
ref var childHierarchy = ref world.EntityManager.GetComponent<Hierarchy>(currentChild);
currentChild = childHierarchy.nextSibling;
}
else
{
break;
}
}
return count;
}
/// <summary>
/// Gets all descendants of an entity (children, grandchildren, etc.) in depth-first order.
/// </summary>
/// <param name="world">The world containing the entity.</param>
/// <param name="root">The root entity.</param>
/// <param name="descendants">List to store the descendants.</param>
public static void GetDescendants(World world, Entity root, List<Entity> descendants)
{
Span<Entity> children = stackalloc Entity[32];
var childCount = GetChildren(world, root, children);
for (int i = 0; i < childCount; i++)
{
var child = children[i];
descendants.Add(child);
GetDescendants(world, child, descendants);
}
}
/// <summary>
/// Removes a child from its parent's sibling list.
/// </summary>
private static void RemoveFromSiblingList(World world, Entity child, Entity parent)
{
if (!world.EntityManager.HasComponent<Hierarchy>(parent))
{
return;
}
ref var parentHierarchy = ref world.EntityManager.GetComponent<Hierarchy>(parent);
ref var childHierarchy = ref world.EntityManager.GetComponent<Hierarchy>(child);
// If child is the first child
if (parentHierarchy.firstChild.Equals(child))
{
parentHierarchy.firstChild = childHierarchy.nextSibling;
childHierarchy.nextSibling = Entity.Invalid;
return;
}
// Find the previous sibling
var currentSibling = parentHierarchy.firstChild;
while (currentSibling.IsValid)
{
if (!world.EntityManager.HasComponent<Hierarchy>(currentSibling))
{
break;
}
ref var siblingHierarchy = ref world.EntityManager.GetComponent<Hierarchy>(currentSibling);
if (siblingHierarchy.nextSibling.Equals(child))
{
siblingHierarchy.nextSibling = childHierarchy.nextSibling;
childHierarchy.nextSibling = Entity.Invalid;
return;
}
currentSibling = siblingHierarchy.nextSibling;
}
}
/// <summary>
/// Checks if an entity is an ancestor of another entity.
/// </summary>
/// <param name="world">The world containing the entities.</param>
/// <param name="potentialAncestor">The potential ancestor entity.</param>
/// <param name="descendant">The descendant entity.</param>
/// <returns>True if potentialAncestor is an ancestor of descendant, false otherwise.</returns>
public static bool IsAncestor(World world, Entity potentialAncestor, Entity descendant)
{
var current = GetParent(world, descendant);
while (current.IsValid)
{
if (current.Equals(potentialAncestor))
{
return true;
}
current = GetParent(world, current);
}
return false;
}
}