test with ecs source and target drag drops

- unsafe because of entity reference
- unsafe because of unsafe code lol
- fixes in parent/child system

Nerfed.Editor/Components/HierachyComponents.cs

@@ -0,0 +1,6 @@
+namespace Nerfed.Editor.Components;
+
+public readonly record struct SelectedInHierachy;
+public readonly record struct ClickedInHierachy;
+public readonly record struct PayloadSourceInHierachy;
+public readonly record struct PayloadTargetInHierachy;

Nerfed.Editor/Components/SelectedInHierachy.cs

@@ -1,4 +0,0 @@
-namespace Nerfed.Editor.Components;
-
-public readonly record struct SelectedInHierachy;
-public readonly record struct ClickedInHierarchy;

Nerfed.Editor/Nerfed.Editor.csproj

@@ -9,6 +9,7 @@
         <IsPackable>false</IsPackable>
         <Configurations>Debug;Test;Release</Configurations>
         <Platforms>x64</Platforms>
+        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     </PropertyGroup>
 
     <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">

Nerfed.Editor/Program.cs

@@ -31,6 +31,7 @@ private static void HandleOnInitialize()
         editorSystems.Add(new EditorHierarchyWindow(world));
 
         Entity ent1 = world.CreateEntity("parent");
+        world.Set(ent1, new Root());
         world.Set(ent1, new LocalTransform(new Vector3(1, 0, 0), Quaternion.Identity, Vector3.One));
 
         Entity ent2 = world.CreateEntity("child");

Nerfed.Editor/Systems/EditorHierarchyWindow.cs

@@ -1,7 +1,9 @@
 using ImGuiNET;
 using MoonTools.ECS;
 using Nerfed.Editor.Components;
+using Nerfed.Runtime;
 using Nerfed.Runtime.Components;
+using Nerfed.Runtime.Util;
 
 namespace Nerfed.Editor.Systems
 {
@@ -10,15 +12,16 @@ internal class EditorHierarchyWindow : MoonTools.ECS.DebugSystem
     {
         private const ImGuiTreeNodeFlags baseFlags = ImGuiTreeNodeFlags.OpenOnArrow | ImGuiTreeNodeFlags.OpenOnDoubleClick | ImGuiTreeNodeFlags.SpanAvailWidth;
 
-        private readonly Filter rootEntitiesWithTransformFilter;
+        //private readonly Filter rootEntitiesWithTransformFilter;
         //private readonly Filter rootEntitiesFilterBroken;
         private readonly Filter rootEntitiesFilter;
 
         private readonly EditorHierachySelectionSystem hierachySelectionSystem;
+        private readonly EditorHierachyDragAndDropSystem hierachyDragAndDropSystem;
 
         public EditorHierarchyWindow(World world) : base(world)
         {
-            rootEntitiesWithTransformFilter = FilterBuilder.Include<LocalTransform>().Exclude<Child>().Build();
+            //rootEntitiesWithTransformFilter = FilterBuilder.Include<LocalTransform>().Exclude<Child>().Build();
 
             // TODO: this doesn't work.
             //rootEntitiesFilterBroken = FilterBuilder.Exclude<Child>().Build();
@@ -31,6 +34,7 @@ public EditorHierarchyWindow(World world) : base(world)
             // Or a EditorComponent, just a component that always gets added when in editor mode.
 
             hierachySelectionSystem = new EditorHierachySelectionSystem(world);
+            hierachyDragAndDropSystem = new EditorHierachyDragAndDropSystem(world);
         }
 
         public override void Update(TimeSpan delta)
@@ -42,10 +46,28 @@ public override void Update(TimeSpan delta)
 
             if (ImGui.TreeNodeEx("World", flags))
             {
-                foreach (Entity entity in rootEntitiesWithTransformFilter.Entities)
+                //if (ImGui.BeginDragDropTarget())
-                {
+                //{
-                    DrawEntityAndChildren(entity);
+                //    unsafe
-                }
+                //    {
+                //        ImGuiPayloadPtr payload = ImGui.AcceptDragDropPayload($"{nameof(EditorHierarchyWindow)}");
+                //        if (payload.NativePtr != null)
+                //        {
+                //            Entity* data = (Entity*)payload.Data;
+                //            Entity child = data[0];
+
+                //            Log.Info($"Dropped {child.ID}");
+
+                //            Transform.RemoveParent(World, child);
+                //        }
+                //    }
+                //    ImGui.EndDragDropTarget();
+                //}
+
+                //foreach (Entity entity in rootEntitiesWithTransformFilter.Entities)
+                //{
+                //    DrawEntityAndChildren(entity);
+                //}
 
                 foreach (Entity entity in rootEntitiesFilter.Entities)
                 {
@@ -58,6 +80,7 @@ public override void Update(TimeSpan delta)
             ImGui.End();
 
             hierachySelectionSystem.Update(delta);
+            hierachyDragAndDropSystem.Update(delta);
         }
 
         private void DrawEntityAndChildren(in Entity entity)
@@ -76,9 +99,54 @@ private void DrawEntityAndChildren(in Entity entity)
 
             if (ImGui.TreeNodeEx($"{entity.ID} | {GetTag(entity)}", flags))
             {
+                // Selection.
                 if (ImGui.IsItemClicked() && !ImGui.IsItemToggledOpen())
                 {
-                    World.Set(entity, new ClickedInHierarchy());
+                    World.Set(entity, new ClickedInHierachy());
+                }
+
+                // Drag and drop.
+                if (ImGui.BeginDragDropSource())
+                {
+                    ImGui.SetDragDropPayload($"{nameof(EditorHierarchyWindow)}", nint.Zero, 0);
+                    Set(entity, new PayloadSourceInHierachy());
+                    Log.Info($"SetSource {entity.ID}");
+
+                    //unsafe
+                    //{
+                    //    fixed (Entity* payload = &entity)
+                    //    {
+                    //        ImGui.SetDragDropPayload($"{nameof(EditorHierarchyWindow)}", (IntPtr)payload, (uint)sizeof(Entity));
+                    //    }
+                    //}
+
+                    ImGui.EndDragDropSource();
+                }
+
+                if (ImGui.BeginDragDropTarget())
+                {
+                    ImGuiPayloadPtr payload = ImGui.AcceptDragDropPayload($"{nameof(EditorHierarchyWindow)}");
+                    unsafe
+                    {
+                        if (payload.NativePtr != null)
+                        {
+                            Log.Info($"SetTarget {entity.ID}");
+                            Set(entity, new PayloadTargetInHierachy());
+                        }
+                    }
+                    //unsafe
+                    //{
+                    //    ImGuiPayloadPtr payload = ImGui.AcceptDragDropPayload($"{nameof(EditorHierarchyWindow)}");
+                    //    if (payload.NativePtr != null)
+                    //    {
+                    //        Entity ent = *(Entity*)payload.Data;
+
+                    //        Log.Info($"Dropped {ent.ID}");
+
+                    //        Transform.SetParent(World, ent, entity);
+                    //    }
+                    //}
+                    ImGui.EndDragDropTarget();
                 }
 
                 ReverseSpanEnumerator<Entity> childEntities = World.InRelations<ChildParentRelation>(entity);
@@ -100,7 +168,7 @@ private class EditorHierachySelectionSystem : MoonTools.ECS.System
             public EditorHierachySelectionSystem(World world) : base(world)
             {
                 selectedEntities = FilterBuilder.Include<SelectedInHierachy>().Build();
-                clickedEntities = FilterBuilder.Include<ClickedInHierarchy>().Build();
+                clickedEntities = FilterBuilder.Include<ClickedInHierachy>().Build();
             }
 
             public override void Update(TimeSpan delta)
@@ -128,7 +196,55 @@ public override void Update(TimeSpan delta)
                         Set(entity, new SelectedInHierachy());
                     }
 
-                    Remove<ClickedInHierarchy>(entity);
+                    Remove<ClickedInHierachy>(entity);
+                }
+            }
+        }
+
+        private class EditorHierachyDragAndDropSystem : MoonTools.ECS.System
+        {
+            private readonly Filter sourceEntities;
+            private readonly Filter targetEntities;
+
+            public EditorHierachyDragAndDropSystem(World world) : base(world)
+            {
+                sourceEntities = FilterBuilder.Include<PayloadSourceInHierachy>().Build();
+                targetEntities = FilterBuilder.Include<PayloadTargetInHierachy>().Build();
+            }
+
+            public override void Update(TimeSpan delta)
+            {
+                if (!targetEntities.Empty)
+                {
+                    Entity target = GetSingletonEntity<PayloadTargetInHierachy>();
+
+                    foreach (Entity source in sourceEntities.Entities)
+                    {
+                        Transform.SetParent(World, source, target);
+                    }
+                }
+
+                bool clear = false;
+                unsafe
+                {
+                    ImGuiPayloadPtr payload = ImGui.GetDragDropPayload();
+                    if (payload.NativePtr == null)
+                    {
+                        clear = true;
+                    }
+                }
+
+                if (clear)
+                {
+                    foreach (Entity source in targetEntities.Entities)
+                    {
+                        Remove<PayloadTargetInHierachy>(source);
+                    }
+
+                    foreach (Entity source in sourceEntities.Entities)
+                    {
+                        Remove<PayloadSourceInHierachy>(source);
+                    }
                 }
             }
         }

Nerfed.Runtime/Systems/LocalToWorldSystem.cs

@@ -45,7 +45,7 @@ private void UpdateWorldTransform(in Entity entity, Matrix4x4 localToWorldMatrix
                 LocalToWorld localToWorld = new(localToWorldMatrix);
                 Set(entity, localToWorld);
 
-                Log.Info($"Entity {entity} | local position {localTransform.position} | world position {localToWorldMatrix.Translation}");
+                //Log.Info($"Entity {entity} | local position {localTransform.position} | world position {localToWorldMatrix.Translation}");
             }
 
             ReverseSpanEnumerator<Entity> childEntities = World.OutRelations<ChildParentRelation>(entity);

Nerfed.Runtime/Util/Transform.cs

@@ -28,10 +28,7 @@ public static Matrix4x4 TRS(in this LocalTransform localTransform)
         // Relation goes from child to parent.
         public static void SetParent(in World world, in Entity child, in Entity parent)
         {
-            if (world.Related<ChildParentRelation>(parent, child))
+            RemoveParent(world, child);
-            {
-                RemoveParent(world, parent);
-            }
 
             world.Relate(child, parent, new ChildParentRelation());
             world.Set(child, new Child());
@@ -47,8 +44,10 @@ public static void RemoveParent(in World world, in Entity child)
                 return;
             }
 
+            Entity parent = world.OutRelationSingleton<ChildParentRelation>(child);
+
             // TODO: Check if Unrelate all also unrelates incomming relations..?
-            world.UnrelateAll<ChildParentRelation>(child);
+            world.Unrelate<ChildParentRelation>(child, parent);
             world.Remove<Child>(child);
             world.Set(child, new Root());
         }