max/Nerfed
1
0
Fork 0
Code Issues 7 Pull Requests Actions Packages Projects 2 Releases Wiki Activity

Compare commits

base: max:5eaf3547dcf56630d5a4088a4c2f42971cbbee41
Branches Tags
max:main
max:ecs-test
max:project
max:ImGui
max:NerfedIcon
..
compare: max:6f505f34a985b493ab16957ed49f036699ba9b11
Branches Tags
max:ecs-test
max:main
max:project
max:ImGui
max:NerfedIcon

No commits in common. "5eaf3547dcf56630d5a4088a4c2f42971cbbee41" and "6f505f34a985b493ab16957ed49f036699ba9b11" have entirely different histories.
5eaf3547dc ... 6f505f34a9

24 changed files with 19 additions and 1329 deletions
Show Stats Expand all files Collapse all files

3
.gitmodules vendored
View File

@ -16,6 +16,3 @@
[submodule "Nerfed.Runtime/Libraries/ImGui.NET"]
path = Nerfed.Runtime/Libraries/ImGui.NET
url = https://github.com/ImGuiNET/ImGui.NET.git
[submodule "Nerfed.Runtime/Libraries/MoonTools.ECS"]
path = Nerfed.Runtime/Libraries/MoonTools.ECS
url = https://github.com/MoonsideGames/MoonTools.ECS.git

1
.idea/.idea.Nerfed/.idea/vcs.xml
View File

@ -4,7 +4,6 @@
<mapping directory="" vcs="Git" />
<mapping directory="$PROJECT_DIR$/Nerfed.Runtime/Libraries/FAudio" vcs="Git" />
<mapping directory="$PROJECT_DIR$/Nerfed.Runtime/Libraries/ImGui.NET" vcs="Git" />
<mapping directory="$PROJECT_DIR$/Nerfed.Runtime/Libraries/MoonTools.ECS" vcs="Git" />
<mapping directory="$PROJECT_DIR$/Nerfed.Runtime/Libraries/RefreshCS" vcs="Git" />
<mapping directory="$PROJECT_DIR$/Nerfed.Runtime/Libraries/SDL2CS" vcs="Git" />
<mapping directory="$PROJECT_DIR$/Nerfed.Runtime/Libraries/WellspringCS" vcs="Git" />

4
Nerfed.Editor/Components/HierachyComponents.cs
View File

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

6
Nerfed.Editor/Editor/EditorGui.cs
View File

@ -66,12 +66,6 @@ private static void HandleOnGui()
UpdateDock();
ImGui.ShowDemoWindow();
foreach (MoonTools.ECS.System system in Program.editorSystems)
{
using ProfilerScope scope = new(system.GetType().Name);
system.Update(Engine.Timestep);
}
}
}
}

1
Nerfed.Editor/Nerfed.Editor.csproj
View File

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

69
Nerfed.Editor/Program.cs
View File

@ -1,19 +1,9 @@
using MoonTools.ECS;
using Nerfed.Editor.Systems;
using Nerfed.Runtime;
using Nerfed.Runtime.Components;
using Nerfed.Runtime.Systems;
using Nerfed.Runtime.Util;
using System.Numerics;
using Nerfed.Runtime;
namespace Nerfed.Editor;
internal class Program
{
private static readonly World world = new World();
private static List<MoonTools.ECS.System> systems = new List<MoonTools.ECS.System>();
public static List<MoonTools.ECS.System> editorSystems = new List<MoonTools.ECS.System>();
private static void Main(string[] args)
{
Engine.OnInitialize += HandleOnInitialize;
@ -26,79 +16,24 @@ private static void Main(string[] args)
private static void HandleOnInitialize()
{
//systems.Add(new ParentSystem(world));
systems.Add(new LocalToWorldSystem(world));
editorSystems.Add(new EditorProfilerWindow(world));
editorSystems.Add(new EditorHierarchyWindow(world));
#if DEBUG
editorSystems.Add(new EditorInspectorWindow(world));
#endif
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");
world.Set(ent2, new LocalTransform(new Vector3(0, 1, 0), Quaternion.Identity, Vector3.One));
Transform.SetParent(world, ent2, ent1);
Entity ent3 = world.CreateEntity("entity3");
world.Set(ent3, new Root());
Transform.SetParent(world, ent3, ent2);
Entity ent4 = world.CreateEntity("entity4");
world.Set(ent4, new Root());
Entity ent5 = world.CreateBaseEntity("entity5");
for (int i = 0; i < 256; i++)
{
Entity newEnt = world.CreateBaseEntity();
world.Set(newEnt, new LocalTransform(new Vector3(i, i, i), Quaternion.Identity, Vector3.One));
Entity parent = newEnt;
for (int j = 0; j < 2; j++) {
Entity newChildEnt = world.CreateEntity();
world.Set(newChildEnt, new LocalTransform(new Vector3(i + j * i, i - j * i, j - i * i), Quaternion.Identity, Vector3.One));
Transform.SetParent(world, newChildEnt, parent);
parent = newChildEnt;
}
}
// Open project.
// Setip EditorGui.
EditorGui.Initialize();
}
private static void HandleOnUpdate()
{
foreach (MoonTools.ECS.System system in systems)
{
using ProfilerScope scope = new(system.GetType().Name);
system.Update(Engine.Timestep);
}
using (new ProfilerScope("EditorGui.Update"))
{
// Editor Update.
EditorGui.Update();
}
// Try Catch UserCode Update.
using (new ProfilerScope("world.FinishUpdate"))
{
world.FinishUpdate();
}
}
private static void HandleOnRender()
{
using (new ProfilerScope("EditorGui.Render"))
{
EditorGui.Render();
}
}
private static void HandleOnQuit()
{

190
Nerfed.Editor/Systems/EditorHierarchyWindow.cs
View File

@ -1,190 +0,0 @@
using ImGuiNET;
using MoonTools.ECS;
using Nerfed.Editor.Components;
using Nerfed.Runtime;
using Nerfed.Runtime.Components;
using Nerfed.Runtime.Util;
namespace Nerfed.Editor.Systems
{
// Window that draws entities.
internal class EditorHierarchyWindow : MoonTools.ECS.System
{
private const ImGuiTreeNodeFlags baseFlags = ImGuiTreeNodeFlags.OpenOnArrow | ImGuiTreeNodeFlags.OpenOnDoubleClick | ImGuiTreeNodeFlags.SpanAvailWidth;
//private readonly Filter rootEntitiesWithTransformFilter;
//private readonly Filter rootEntitiesFilterBroken;
private readonly Filter rootEntitiesFilter;
private readonly EditorHierachySelectionSystem hierachySelectionSystem;
public EditorHierarchyWindow(World world) : base(world)
{
//rootEntitiesWithTransformFilter = FilterBuilder.Include<LocalTransform>().Exclude<Child>().Build();
// TODO: this doesn't work.
//rootEntitiesFilterBroken = FilterBuilder.Exclude<Child>().Build();
// Maybe the parent/child functions should add a root component when not being a child.
rootEntitiesFilter = FilterBuilder.Include<Root>().Build();
// Maybe instead of a root, if we need a component that is always on an entity and has some use we could create something like a VersionComponent which only hold an int.
// The version would update each time something changes on the entity.
// Or a EditorComponent, just a component that always gets added when in editor mode.
hierachySelectionSystem = new EditorHierachySelectionSystem(world);
}
public override void Update(TimeSpan delta)
{
ImGui.Begin("Hierarchy");
ImGuiTreeNodeFlags flags = baseFlags;
flags |= ImGuiTreeNodeFlags.DefaultOpen;
if (ImGui.TreeNodeEx("World", flags))
{
if (ImGui.BeginDragDropTarget())
{
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)
{
DrawEntityAndChildren(entity);
}
ImGui.TreePop();
}
ImGui.End();
hierachySelectionSystem.Update(delta);
}
private void DrawEntityAndChildren(in Entity entity)
{
ImGuiTreeNodeFlags flags = baseFlags;
if (!World.HasInRelation<ChildParentRelation>(entity))
{
flags |= ImGuiTreeNodeFlags.Leaf;
}
if (World.Has<SelectedInHierachy>(entity))
{
flags |= ImGuiTreeNodeFlags.Selected;
}
if (ImGui.TreeNodeEx($"{entity.ID} | {GetTag(entity)}", flags))
{
// TODO: fix selection, look at ImGui 1.91, https://github.com/ocornut/imgui/wiki/Multi-Select
// Selection.
if (ImGui.IsItemClicked() && !ImGui.IsItemToggledOpen())
{
World.Set(entity, new ClickedInHierachy());
}
// Drag and drop.
if (ImGui.BeginDragDropSource())
{
unsafe
{
fixed (Entity* payload = &entity)
{
ImGui.SetDragDropPayload($"{nameof(EditorHierarchyWindow)}", (IntPtr)payload, (uint)sizeof(Entity));
}
}
ImGui.EndDragDropSource();
}
if (ImGui.BeginDragDropTarget())
{
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();
}
// Draw children.
ReverseSpanEnumerator<Entity> childEntities = World.InRelations<ChildParentRelation>(entity);
foreach (Entity childEntity in childEntities)
{
DrawEntityAndChildren(childEntity);
}
ImGui.TreePop();
}
}
// System for handling the selected entities in the hierachy.
private class EditorHierachySelectionSystem : MoonTools.ECS.System
{
private readonly Filter selectedEntities;
private readonly Filter clickedEntities;
public EditorHierachySelectionSystem(World world) : base(world)
{
selectedEntities = FilterBuilder.Include<SelectedInHierachy>().Build();
clickedEntities = FilterBuilder.Include<ClickedInHierachy>().Build();
}
public override void Update(TimeSpan delta)
{
ImGuiIOPtr io = ImGui.GetIO();
if (!clickedEntities.Empty && !io.KeyCtrl)
{
foreach (Entity entity in selectedEntities.Entities)
{
Remove<SelectedInHierachy>(entity);
}
}
foreach (Entity entity in clickedEntities.Entities)
{
// Unselect.
if (Has<SelectedInHierachy>(entity))
{
Remove<SelectedInHierachy>(entity);
}
// Select.
else
{
Set(entity, new SelectedInHierachy());
}
Remove<ClickedInHierachy>(entity);
}
}
}
}
}

100
Nerfed.Editor/Systems/EditorInspectorWindow.cs
View File

@ -1,100 +0,0 @@
using System.Numerics;
using ImGuiNET;
using MoonTools.ECS;
using Nerfed.Editor.Components;
using Nerfed.Runtime.Serialization;
#if DEBUG
namespace Nerfed.Editor.Systems
{
// Window that draws entities.
internal class EditorInspectorWindow : MoonTools.ECS.DebugSystem
{
private readonly Filter selectedEntityFilter;
public EditorInspectorWindow(World world) : base(world)
{
selectedEntityFilter = FilterBuilder.Include<SelectedInHierachy>().Build();
}
public override void Update(TimeSpan delta)
{
ImGui.Begin("Inspector");
foreach (Entity entity in selectedEntityFilter.Entities)
{
DrawEntityComponents(entity);
}
ImGui.End();
}
private void DrawEntityComponents(Entity entity)
{
World.ComponentTypeEnumerator componentTypes = World.Debug_GetAllComponentTypes(entity);
// Add button of all types that we can add. Also filter out types we already have.
List<Type> componentTypesToAdd = ComponentHelper.AddComponentByType.Keys.ToList();
foreach (Type componentType in componentTypes)
{
componentTypesToAdd.Remove(componentType);
}
const string popupId = "AddComponentPopup";
if (ImGui.Button("Add Component"))
{
ImGui.OpenPopup(popupId);
}
if (ImGui.BeginPopup(popupId))
{
foreach (Type componentType in componentTypesToAdd)
{
if (ImGui.Selectable(componentType.Name))
{
if (ComponentHelper.AddComponentByType.TryGetValue(componentType, out Action<World, Entity> componentSetter))
{
componentSetter.Invoke(World, entity);
}
}
}
ImGui.EndPopup();
}
ImGui.Dummy(new Vector2(16, 16));
ImGui.Text("ComponentInspectorByType");
foreach (Type componentType in componentTypes)
{
if (ComponentHelper.ComponentInspectorByType.TryGetValue(componentType, out Action<World, Entity> componentInspector))
{
componentInspector(World, entity);
}
else if (ComponentHelper.GetComponentByType.TryGetValue(componentType, out Func<World, Entity, ValueType> componentGetter))
{
ValueType component = componentGetter.Invoke(World, entity);
ImGui.Text(component.ToString());
}
else
{
ImGui.Text(componentType.Name);
}
ImGui.Separator();
}
ImGui.Dummy(new Vector2(16, 16));
// ImGui.Text("Reflection");
// foreach (Type component in componentTypes)
// {
// System.Reflection.MethodInfo getMethodInfo = typeof(World).GetMethod("Get");
// System.Reflection.MethodInfo getComponentMethod = getMethodInfo.MakeGenericMethod(component);
// object result = getComponentMethod.Invoke(World, [entity]);
//
// // process here
// ImGui.Text(result.ToString());
// }
}
}
}
#endif

204
Nerfed.Editor/Systems/EditorProfilerWindow.cs
View File

@ -1,204 +0,0 @@
using ImGuiNET;
using MoonTools.ECS;
using Nerfed.Runtime;
namespace Nerfed.Editor.Systems
{
internal class EditorProfilerWindow : MoonTools.ECS.System
{
const ImGuiTableFlags tableFlags = ImGuiTableFlags.Resizable | ImGuiTableFlags.BordersOuter | ImGuiTableFlags.NoBordersInBody | ImGuiTableFlags.ScrollY | ImGuiTableFlags.ScrollX;
const ImGuiTreeNodeFlags treeNodeFlags = ImGuiTreeNodeFlags.SpanAllColumns;
const ImGuiTreeNodeFlags treeNodeLeafFlags = ImGuiTreeNodeFlags.SpanAllColumns | ImGuiTreeNodeFlags.Leaf | ImGuiTreeNodeFlags.NoTreePushOnOpen;
private int selectedFrame = 0;
private int previousSelectedFrame = -1;
private IOrderedEnumerable<KeyValuePair<string, (double ms, uint calls)>> orderedCombinedData = null;
public EditorProfilerWindow(World world) : base(world)
{
}
public override void Update(TimeSpan delta)
{
if (Profiler.Frames.Count <= 0)
{
return;
}
ImGui.Begin("Profiler");
ImGui.BeginChild("Toolbar", new System.Numerics.Vector2(0, 0), ImGuiChildFlags.AutoResizeY);
if (ImGui.RadioButton("Recording", Profiler.IsRecording))
{
Profiler.SetActive(!Profiler.IsRecording);
}
ImGui.SameLine();
if (Profiler.IsRecording)
{
// Select last frame when recording to see latest frame data.
selectedFrame = Profiler.Frames.Count - 1;
}
if (ImGui.SliderInt(string.Empty, ref selectedFrame, 0, Profiler.Frames.Count - 1))
{
// Stop recording when browsing frames.
Profiler.SetActive(false);
}
Profiler.Frame frame = Profiler.Frames.ElementAt(selectedFrame);
double ms = frame.ElapsedMilliseconds();
double s = 1000;
ImGui.Text($"Frame: {frame.FrameCount} ({ms:0.000} ms | {(s / ms):0} fps)");
ImGui.EndChild();
if (!Profiler.IsRecording) {
if (previousSelectedFrame != selectedFrame)
{
previousSelectedFrame = selectedFrame;
orderedCombinedData = CalculateCombinedData(frame);
}
DrawFlameGraph(frame);
DrawHierachy(frame);
ImGui.SameLine();
DrawCombined(orderedCombinedData);
}
ImGui.End();
}
private static void DrawHierachy(Profiler.Frame frame)
{
if(frame == null)
{
return;
}
ImGui.BeginChild("Hierachy", new System.Numerics.Vector2(150, 0), ImGuiChildFlags.ResizeX);
if (ImGui.BeginTable("ProfilerData", 3, tableFlags, new System.Numerics.Vector2(0, 0)))
{
ImGui.TableSetupColumn("name", ImGuiTableColumnFlags.WidthStretch, 0.8f, 0);
ImGui.TableSetupColumn("thread", ImGuiTableColumnFlags.WidthStretch, 0.2f, 1);
ImGui.TableSetupColumn("ms", ImGuiTableColumnFlags.WidthStretch, 0.2f, 1);
ImGui.TableSetupScrollFreeze(0, 1); // Make row always visible
ImGui.TableHeadersRow();
foreach (Profiler.ScopeNode node in frame.RootNodes)
{
DrawHierachyNode(node);
}
ImGui.EndTable();
}
ImGui.EndChild();
}
private static void DrawHierachyNode(Profiler.ScopeNode node)
{
ImGui.TableNextRow();
ImGui.TableNextColumn();
bool isOpen = false;
bool isLeaf = node.Children.Count == 0;
if (isLeaf) {
ImGui.TreeNodeEx(node.Label, treeNodeLeafFlags);
}
else
{
isOpen = ImGui.TreeNodeEx(node.Label, treeNodeFlags);
}
ImGui.TableNextColumn();
ImGui.Text($"{node.ManagedThreadId}");
ImGui.TableNextColumn();
ImGui.Text($"{node.ElapsedMilliseconds():0.000}");
if (isOpen)
{
for (int i = 0; i < node.Children.Count; i++)
{
DrawHierachyNode(node.Children[i]);
}
ImGui.TreePop();
}
}
private static void DrawCombined(in IOrderedEnumerable<KeyValuePair<string, (double ms, uint calls)>> orderedCombinedData)
{
if(orderedCombinedData == null)
{
return;
}
ImGui.BeginChild("Combined", new System.Numerics.Vector2(0, 0));
if (ImGui.BeginTable("ProfilerCombinedData", 3, tableFlags, new System.Numerics.Vector2(0, 0)))
{
ImGui.TableSetupColumn("name", ImGuiTableColumnFlags.WidthStretch, 0.6f, 0);
ImGui.TableSetupColumn("ms", ImGuiTableColumnFlags.WidthStretch, 0.2f, 1);
ImGui.TableSetupColumn("calls", ImGuiTableColumnFlags.WidthStretch, 0.2f, 2);
ImGui.TableSetupScrollFreeze(0, 1); // Make row always visible
ImGui.TableHeadersRow();
foreach (KeyValuePair<string, (double ms, uint calls)> combinedData in orderedCombinedData)
{
ImGui.TableNextRow();
ImGui.TableNextColumn();
ImGui.Text($"{combinedData.Key}");
ImGui.TableNextColumn();
ImGui.Text($"{combinedData.Value.ms:0.000}");
ImGui.TableNextColumn();
ImGui.Text($"{combinedData.Value.calls}");
}
ImGui.EndTable();
}
ImGui.EndChild();
}
private static IOrderedEnumerable<KeyValuePair<string, (double ms, uint calls)>> CalculateCombinedData(Profiler.Frame frame)
{
Dictionary<string, (double ms, uint calls)> combinedRecordData = new Dictionary<string, (double ms, uint calls)>(128);
foreach (Profiler.ScopeNode node in frame.RootNodes)
{
CalculateCombinedData(node, in combinedRecordData);
}
return combinedRecordData.OrderByDescending(x => x.Value.ms);
}
private static void CalculateCombinedData(Profiler.ScopeNode node, in Dictionary<string, (double ms, uint calls)> combinedRecordData)
{
if (combinedRecordData.TryGetValue(node.Label, out (double ms, uint calls) combined))
{
combinedRecordData[node.Label] = (combined.ms + node.ElapsedMilliseconds(), combined.calls + 1);
}
else
{
combinedRecordData.Add(node.Label, (node.ElapsedMilliseconds(), 1));
}
for (int i = 0; i < node.Children.Count; i++)
{
CalculateCombinedData(node.Children[i], combinedRecordData);
}
}
private static void DrawFlameGraph(Profiler.Frame frame)
{
if (frame == null)
{
return;
}
ProfilerVisualizer.RenderFlameGraph(frame);
}
}
}

6
Nerfed.Runtime/Components/LocalToWorld.cs
View File

@ -1,6 +0,0 @@
using System.Numerics;
namespace Nerfed.Runtime.Components
{
public readonly record struct LocalToWorld(Matrix4x4 localToWorldMatrix);
}

9
Nerfed.Runtime/Components/LocalTransform.cs
View File

@ -1,9 +0,0 @@
using System.Numerics;
namespace Nerfed.Runtime.Components
{
public readonly record struct LocalTransform(Vector3 position, Quaternion rotation, Vector3 scale)
{
public static readonly LocalTransform Identity = new(Vector3.Zero, Quaternion.Identity, Vector3.One);
}
}

11
Nerfed.Runtime/Components/Parent.cs
View File

@ -1,11 +0,0 @@
using MoonTools.ECS;
namespace Nerfed.Runtime.Components
{
public readonly record struct Root;
//public readonly record struct Parent;
//public readonly record struct PreviousParent;
public readonly record struct Child;
// Describes a relation from the child to the parent.
public readonly record struct ChildParentRelation;
}

4
Nerfed.Runtime/Components/Test.cs
View File

@ -1,4 +0,0 @@
namespace Nerfed.Runtime.Components
{
public readonly record struct Test();
}

14
Nerfed.Runtime/Engine.cs
View File

@ -111,14 +111,10 @@ public static void Quit()
private static void Tick()
{
Profiler.BeginFrame();
AdvanceElapsedTime();
if (framerateCapped)
{
Profiler.BeginSample("framerateCapped");
/* We want to wait until the framerate cap,
* but we don't want to oversleep. Requesting repeated 1ms sleeps and
* seeing how long we actually slept for lets us estimate the worst case
@ -141,8 +137,6 @@ private static void Tick()
Thread.SpinWait(1);
AdvanceElapsedTime();
}
Profiler.EndSample();
}
// Do not let any step take longer than our maximum.
@ -155,7 +149,6 @@ private static void Tick()
{
while (accumulatedUpdateTime >= Timestep)
{
Profiler.BeginSample("Update");
Keyboard.Update();
Mouse.Update();
GamePad.Update();
@ -163,26 +156,19 @@ private static void Tick()
ProcessSDLEvents();
// Tick game here...
Profiler.BeginSample("OnUpdate");
OnUpdate?.Invoke();
Profiler.EndSample();
AudioDevice.WakeThread();
accumulatedUpdateTime -= Timestep;
Profiler.EndSample();
}
double alpha = accumulatedUpdateTime / Timestep;
// Render here..
Profiler.BeginSample("OnRender");
OnRender?.Invoke();
Profiler.EndSample();
accumulatedDrawTime -= framerateCapTimeSpan;
}
Profiler.EndFrame();
}
private static TimeSpan AdvanceElapsedTime()

1
Nerfed.Runtime/Libraries/MoonTools.ECS

@ -1 +0,0 @@
Subproject commit 76b18a6ba9a33f5a93022390be7ed805f9f722e8

13
Nerfed.Runtime/Nerfed.Runtime.csproj
View File

@ -32,13 +32,12 @@
</PropertyGroup>
<ItemGroup>
<Compile Include="Libraries\FAudio\csharp\FAudio.cs" />
<Compile Include="Libraries\ImGui.NET\src\ImGui.NET\**\*.cs" />
<Compile Include="Libraries\MoonTools.ECS\src\**\*.cs" />
<Compile Include="Libraries\RefreshCS\RefreshCS.cs" />
<Compile Include="Libraries\SDL2CS\src\SDL2.cs" />
<Compile Include="Libraries\WellspringCS\WellspringCS.cs" />
<Compile Include="Libraries\dav1dfile\csharp\dav1dfile.cs" />
<Compile Include="Libraries\SDL2CS\src\SDL2.cs"/>
<Compile Include="Libraries\RefreshCS\RefreshCS.cs"/>
<Compile Include="Libraries\FAudio\csharp\FAudio.cs"/>
<Compile Include="Libraries\WellspringCS\WellspringCS.cs"/>
<Compile Include="Libraries\dav1dfile\csharp\dav1dfile.cs"/>
<Compile Include="Libraries\ImGui.NET\src\ImGui.NET\**\*.cs"/>
</ItemGroup>
</Project>

153
Nerfed.Runtime/Profiler.cs
View File

@ -1,166 +1,29 @@
using System.Collections.Concurrent;
using System.Diagnostics;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
namespace Nerfed.Runtime;
public struct ProfilerScope : IDisposable
{
public ProfilerScope(string label)
{
public ProfilerScope(string label) {
Profiler.BeginSample(label);
}
public void Dispose()
{
public void Dispose() {
Profiler.EndSample();
}
}
public static class Profiler
{
public class Frame(uint frameCount)
{
public uint FrameCount { get; } = frameCount;
public long StartTime { get; } = Stopwatch.GetTimestamp();
public long EndTime { get; private set; }
[Conditional("PROFILING")]
public static void BeginSample(string label) {
// Use a concurrent list to collect all thread root nodes per frame.
public ConcurrentBag<ScopeNode> RootNodes = new ConcurrentBag<ScopeNode>();
internal void End()
{
EndTime = Stopwatch.GetTimestamp();
}
public double ElapsedMilliseconds()
{
long elapsedTicks = EndTime - StartTime;
return ((double)(elapsedTicks * 1000)) / Stopwatch.Frequency;
}
}
public class ScopeNode(string label)
{
public string Label { get; } = label;
public long StartTime { get; private set; } = Stopwatch.GetTimestamp(); // Start time in ticks
public long EndTime { get; private set; }
public int ManagedThreadId { get; } = Environment.CurrentManagedThreadId;
public List<ScopeNode> Children { get; } = new List<ScopeNode>();
internal void End()
{
EndTime = Stopwatch.GetTimestamp(); // End time in ticks
}
public double ElapsedMilliseconds()
{
return ((double)(EndTime - StartTime)) * 1000 / Stopwatch.Frequency; // Convert ticks to ms
}
// Add a child node (used for nested scopes)
internal ScopeNode AddChild(string label)
{
ScopeNode child = new ScopeNode(label);
Children.Add(child);
return child;
}
}
private const int maxFrames = 128;
public static bool IsRecording { get; private set; } = true;
// Store only the last x amount of frames in memory.
public static readonly BoundedQueue<Frame> Frames = new(maxFrames);
// Use ThreadLocal to store a stack of ScopeNodes per thread and enable tracking of thread-local values.
private static readonly ThreadLocal<Stack<ScopeNode>> threadLocalScopes = new ThreadLocal<Stack<ScopeNode>>(() => new Stack<ScopeNode>(), true);
private static Frame currentFrame = null;
private static uint frameCount = 0;
public static void SetActive(bool isRecording)
{
IsRecording = isRecording;
}
[Conditional("PROFILING")]
public static void BeginFrame()
{
if (!IsRecording)
{
return;
}
public static void EndSample() {
currentFrame = new Frame(frameCount);
}
[Conditional("PROFILING")]
public static void EndFrame()
{
if (!IsRecording)
{
return;
}
foreach (Stack<ScopeNode> scopes in threadLocalScopes.Values)
{
if (scopes.Count > 0)
{
// Pop the left over root nodes.
ScopeNode currentScope = scopes.Pop();
currentScope.End();
}
// Clean up the thread-local stack to ensure it's empty for the next frame.
scopes.Clear();
}
currentFrame.End();
Frames.Enqueue(currentFrame);
frameCount++;
}
[Conditional("PROFILING")]
public static void BeginSample(string label)
{
if (!IsRecording)
{
return;
}
Stack<ScopeNode> scopes = threadLocalScopes.Value; // Get the stack for the current thread
if (scopes.Count == 0)
{
// First scope for this thread (new root for this thread)
ScopeNode rootScopeNode = new ScopeNode($"Thread-{Environment.CurrentManagedThreadId}");
scopes.Push(rootScopeNode);
currentFrame.RootNodes.Add(rootScopeNode); // Add root node to the frame list
}
// Create a new child under the current top of the stack
ScopeNode newScope = scopes.Peek().AddChild(label);
scopes.Push(newScope); // Push new scope to the thread's stack
}
[Conditional("PROFILING")]
public static void EndSample()
{
if (!IsRecording)
{
return;
}
Stack<ScopeNode> scopes = threadLocalScopes.Value;
if (scopes.Count > 0)
{
// Only pop if this is not the root node.
//ScopeNode currentScope = scopes.Count > 1 ? scopes.Pop() : scopes.Peek();
ScopeNode currentScope = scopes.Pop();
currentScope.End();
}
}
}

156
Nerfed.Runtime/ProfilerVisualizer.cs
View File

@ -1,156 +0,0 @@
using ImGuiNET;
using System.Numerics;
namespace Nerfed.Runtime;
public static class ProfilerVisualizer
{
private const float barHeight = 20f;
private const float barPadding = 2f;
// Render the flame graph across multiple threads
public static void RenderFlameGraph(Profiler.Frame frame)
{
if (frame == null) return;
if (frame.RootNodes == null) return;
// Calculate the total timeline duration (max end time across all nodes)
double totalDuration = frame.EndTime - frame.StartTime;
double startTime = frame.StartTime;
// Precompute the maximum depth for each thread's call stack
Dictionary<int, int> threadMaxDepths = new Dictionary<int, int>();
foreach (IGrouping<int, Profiler.ScopeNode> threadGroup in frame.RootNodes.GroupBy(node => node.ManagedThreadId))
{
int maxDepth = 0;
foreach (Profiler.ScopeNode rootNode in threadGroup)
{
maxDepth = Math.Max(maxDepth, GetMaxDepth(rootNode, 0));
}
threadMaxDepths[threadGroup.Key] = maxDepth;
}
// Start a child window to support scrolling
ImGui.BeginChild("FlameGraph", new Vector2(0, 64), ImGuiChildFlags.Border | ImGuiChildFlags.ResizeY, ImGuiWindowFlags.HorizontalScrollbar | ImGuiWindowFlags.AlwaysVerticalScrollbar);
ImDrawListPtr drawList = ImGui.GetWindowDrawList();
Vector2 windowPos = ImGui.GetCursorScreenPos();
// Sort nodes by ThreadID, ensuring main thread (Thread ID 1) is on top
IOrderedEnumerable<IGrouping<int, Profiler.ScopeNode>> threadGroups = frame.RootNodes.GroupBy(node => node.ManagedThreadId).OrderBy(g => g.Key);
// Initial Y position for drawing
float baseY = windowPos.Y;
bool alternate = false;
float contentWidth = ImGui.GetContentRegionAvail().X;
// Draw each thread's flame graph row by row
foreach (IGrouping<int, Profiler.ScopeNode> threadGroup in threadGroups)
{
int threadId = threadGroup.Key;
// Compute the base Y position for this thread
float threadBaseY = baseY;
// Calculate the maximum height for this thread's flame graph
float threadHeight = (threadMaxDepths[threadId] + 1) * (barHeight + barPadding);
// Draw the alternating background for each thread row
uint backgroundColor = ImGui.ColorConvertFloat4ToU32(alternate ? new Vector4(0.2f, 0.2f, 0.2f, 1f) : new Vector4(0.1f, 0.1f, 0.1f, 1f));
drawList.AddRectFilled(new Vector2(windowPos.X, threadBaseY), new Vector2(windowPos.X + contentWidth, threadBaseY + threadHeight), backgroundColor);
alternate = !alternate;
// Draw each root node in the group (one per thread)
foreach (Profiler.ScopeNode rootNode in threadGroup)
{
RenderNode(drawList, rootNode, startTime, totalDuration, windowPos.X, threadBaseY, 0, contentWidth, false);
}
// Move to the next thread's row (max depth * height per level)
baseY += (threadMaxDepths[threadId] + 1) * (barHeight + barPadding);
}
// Ensure that ImGui knows the size of the content.
ImGui.Dummy(new Vector2(contentWidth, baseY));
ImGui.EndChild();
}
private static void RenderNode(ImDrawListPtr drawList, Profiler.ScopeNode node, double startTime, double totalDuration, float startX, float baseY, int depth, float contentWidth, bool alternate)
{
if (node == null) return;
double nodeStartTime = node.StartTime - startTime;
double nodeEndTime = node.EndTime - startTime;
double nodeDuration = nodeEndTime - nodeStartTime;
// Calculate the position and width of the bar based on time
float xPos = (float)(startX + (nodeStartTime / totalDuration) * contentWidth);
float width = (float)((nodeDuration / totalDuration) * contentWidth);
// Calculate the Y position based on depth
float yPos = baseY + (depth * (barHeight + barPadding)) + (barPadding * 0.5f);
// Define the rectangle bounds for the node
Vector2 min = new Vector2(xPos, yPos);
Vector2 max = new Vector2(xPos + width, yPos + barHeight);
// Define color.
Vector4 barColor = alternate ? new Vector4(0.4f, 0.6f, 0.9f, 1f) : new Vector4(0.4f, 0.5f, 0.8f, 1f);
Vector4 textColor = new Vector4(1f, 1f, 1f, 1f);
if (depth != 0)
{
// Draw the bar for the node (colored based on thread depth)
drawList.AddRectFilled(min, max, ImGui.ColorConvertFloat4ToU32(barColor));
// Draw the label if it fits inside the bar
string label = $"{node.Label} ({node.ElapsedMilliseconds():0.000} ms)";
if (width > ImGui.CalcTextSize(label).X)
{
drawList.AddText(new Vector2(xPos + barPadding, yPos + barPadding), ImGui.ColorConvertFloat4ToU32(textColor), label);
}
// Add tooltip on hover
if (ImGui.IsMouseHoveringRect(min, max))
{
// Show tooltip when hovering over the node
ImGui.BeginTooltip();
ImGui.Text($"{node.Label}");
ImGui.Text($"{node.ElapsedMilliseconds():0.000} ms");
ImGui.Text($"{node.ManagedThreadId}");
ImGui.EndTooltip();
}
}
else
{
// Aka root node.
string label = $"{node.Label}";
drawList.AddText(new Vector2(startX + barPadding, yPos + barPadding), ImGui.ColorConvertFloat4ToU32(textColor), label);
}
// Draw each child node under this node
foreach (Profiler.ScopeNode child in node.Children)
{
alternate = !alternate;
RenderNode(drawList, child, startTime, totalDuration, startX, baseY, depth + 1, contentWidth, alternate);
}
}
// Recursive function to calculate the maximum depth of the node tree
private static int GetMaxDepth(Profiler.ScopeNode node, int currentDepth)
{
if (node.Children == null || node.Children.Count == 0)
{
return currentDepth;
}
int maxDepth = currentDepth;
foreach (Profiler.ScopeNode child in node.Children)
{
maxDepth = Math.Max(maxDepth, GetMaxDepth(child, currentDepth + 1));
}
return maxDepth;
}
}

68
Nerfed.Runtime/Serialization/ComponentHelper.cs
View File

@ -1,68 +0,0 @@
using System.Numerics;
using ImGuiNET;
using MoonTools.ECS;
using Nerfed.Runtime.Components;
namespace Nerfed.Runtime.Serialization;
public static class ComponentHelper
{
// Auto generate this.
public static readonly Dictionary<Type, Func<World, Entity, ValueType>> GetComponentByType = new()
{
{ typeof(LocalTransform), (world, entity) => world.Get<LocalTransform>(entity) },
{ typeof(Root), (world, entity) => world.Get<Root>(entity) },
};
// Auto generate this.
public static readonly Dictionary<Type, Action<World, Entity, ValueType>> SetComponentByType = new()
{
{ typeof(LocalTransform), (world, entity, component) => world.Set(entity, (LocalTransform)component) },
{ typeof(Root), (world, entity, component) => world.Set(entity, (Root)component) },
};
// Auto generate this, but it should only contain user assignable components (so something like 'root' should be excluded).
// Maybe use an attribute for this.
public static readonly Dictionary<Type, Action<World, Entity>> AddComponentByType = new()
{
{ typeof(LocalTransform), (world, entity) => world.Set(entity, LocalTransform.Identity) },
};
// Auto generate this, but also keep the option for 'custom inspectors'.
// Maybe via attribute?
public static readonly Dictionary<Type, Action<World, Entity>> ComponentInspectorByType = new()
{
{
typeof(LocalTransform), (world, entity) =>
{
(Vector3 position, Quaternion rotation, Vector3 scale) = world.Get<LocalTransform>(entity);
Vector3 eulerAngles = MathEx.ToEulerAngles(rotation);
eulerAngles = new Vector3(float.RadiansToDegrees(eulerAngles.X), float.RadiansToDegrees(eulerAngles.Y), float.RadiansToDegrees(eulerAngles.Z));
bool isDirty = false;
ImGui.BeginGroup();
ImGui.Text($"{nameof(LocalTransform)}");
isDirty |= ImGui.DragFloat3("Position", ref position, 0.2f, float.MinValue, float.MaxValue /*, "%f0 m" */); // TODO: right format.
isDirty |= ImGui.DragFloat3("Rotation", ref eulerAngles);
isDirty |= ImGui.DragFloat3("Scale", ref scale);
ImGui.EndGroup();
if (!isDirty)
{
return;
}
eulerAngles = new Vector3(float.DegreesToRadians(eulerAngles.X), float.DegreesToRadians(eulerAngles.Y), float.DegreesToRadians(eulerAngles.Z));
world.Set(entity, new LocalTransform(position, MathEx.ToQuaternion(eulerAngles), scale));
}
},
{
typeof(Root), (world, entity) =>
{
ImGui.BeginGroup();
ImGui.Text($"{nameof(Root)}");
ImGui.EndGroup();
}
},
};
}

95
Nerfed.Runtime/Systems/LocalToWorldSystem.cs
View File

@ -1,95 +0,0 @@
using MoonTools.ECS;
using Nerfed.Runtime.Components;
using Nerfed.Runtime.Util;
using System.Numerics;
// TODO:
// Explore if having a WorldTransform and LocalTransfom component each holding position, rotation, scale values and the matricies is useful.
// Often you need to either get or set these values.
// If so, we probably need a utility funciton to do so. Since changing these values means that we need to update all the related data + children as well.
// TODO:
// When modifying transform all the children need to be updated as well.
namespace Nerfed.Runtime.Systems
{
public class LocalToWorldSystem : MoonTools.ECS.System
{
private readonly bool useParallelFor = true; // When having a low amount of transforms or when in debug mode this might be slower.
private readonly Filter rootEntitiesFilter;
private readonly Filter entitiesWithoutLocalToWorldFilter;
private readonly Action<int> updateWorldTransform;
public LocalToWorldSystem(World world) : base(world)
{
rootEntitiesFilter = FilterBuilder.Include<LocalTransform>().Exclude<Child>().Build();
if (useParallelFor)
{
entitiesWithoutLocalToWorldFilter = FilterBuilder.Include<LocalTransform>().Exclude<LocalToWorld>().Build();
updateWorldTransform = UpdateWorldTransformByIndex;
}
}
public override void Update(TimeSpan delta)
{
if (rootEntitiesFilter.Empty)
{
return;
}
if (useParallelFor)
{
Profiler.BeginSample("ParallelFor.LocalToWorldCheck");
// This check is needed because some entities might not have a LocalToWorld component yet.
// Adding this during the loop will break.
foreach (Entity entity in entitiesWithoutLocalToWorldFilter.Entities) {
Set(entity, new LocalToWorld(Matrix4x4.Identity));
}
Profiler.EndSample();
Profiler.BeginSample("ParallelFor.LocalToWorldUpdate");
// This should only be used when the filter doesn't change by executing these functions!
// So no entity deletion or setting/removing of components used by the filters in this loop.
Parallel.For(0, rootEntitiesFilter.Count, updateWorldTransform);
Profiler.EndSample();
}
else
{
foreach (Entity entity in rootEntitiesFilter.Entities)
{
Profiler.BeginSample("UpdateWorldTransform");
UpdateWorldTransform(entity, Matrix4x4.Identity);
Profiler.EndSample();
}
}
}
private void UpdateWorldTransformByIndex(int entityFilterIndex)
{
Profiler.BeginSample("UpdateWorldTransformByIndex");
Entity entity = rootEntitiesFilter.NthEntity(entityFilterIndex);
UpdateWorldTransform(entity, Matrix4x4.Identity);
Profiler.EndSample();
}
private void UpdateWorldTransform(in Entity entity, Matrix4x4 localToWorldMatrix)
{
// TODO: Only update dirty transforms.
// If a parent is dirty all the children need to update their localToWorld matrix.
// How do we check if something is dirty? How do we know if a LocalTransform has been changed?
if (Has<LocalTransform>(entity))
{
LocalTransform localTransform = Get<LocalTransform>(entity);
localToWorldMatrix = Matrix4x4.Multiply(localToWorldMatrix, localTransform.TRS());
LocalToWorld localToWorld = new(localToWorldMatrix);
Set(entity, localToWorld);
}
ReverseSpanEnumerator<Entity> childEntities = World.InRelations<ChildParentRelation>(entity);
foreach (Entity childEntity in childEntities)
{
UpdateWorldTransform(childEntity, localToWorldMatrix);
}
}
}
}

73
Nerfed.Runtime/Util/BoundedQueue.cs
View File

@ -1,73 +0,0 @@
using System.Collections;
namespace Nerfed.Runtime;
public class BoundedQueue<T> : IEnumerable<T>, ICollection, IReadOnlyCollection<T>
{
private readonly Queue<T> queue = null;
private readonly int maxSize = 10;
private T lastAddedElement;
public BoundedQueue(int maxSize)
{
this.maxSize = maxSize;
queue = new Queue<T>(maxSize);
}
public void Enqueue(T item)
{
queue.Enqueue(item);
if (queue.Count > maxSize)
{
queue.Dequeue(); // Remove the oldest element
}
lastAddedElement = item;
}
public T Dequeue()
{
return queue.Dequeue();
}
public T Peek()
{
return queue.Peek();
}
public T LastAddedElement()
{
return lastAddedElement;
}
public void Clear()
{
queue.Clear();
}
public bool Contains(T item)
{
return queue.Contains(item);
}
public IEnumerator<T> GetEnumerator()
{
return queue.GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return queue.GetEnumerator();
}
public void CopyTo(Array array, int index)
{
((ICollection)queue).CopyTo(array, index);
}
public int Count => queue.Count;
public int Capacity => maxSize;
public bool IsSynchronized => ((ICollection)queue).IsSynchronized;
public object SyncRoot => ((ICollection)queue).SyncRoot;
int IReadOnlyCollection<T>.Count => queue.Count;
}

49
Nerfed.Runtime/Util/MathEx.cs
View File

@ -1,5 +1,3 @@
using System.Numerics;
namespace Nerfed.Runtime;
public static class MathEx
@ -19,51 +17,4 @@ public static float Denormalize(float value, float newMin, float newMax) {
public static float Remap(float value, float oldMin, float oldMax, float newMin, float newMax) {
return (value - oldMin) / (oldMax - oldMin) * (newMax - newMin) + newMin;
}
// https://stackoverflow.com/questions/70462758/c-sharp-how-to-convert-quaternions-to-euler-angles-xyz
public static Quaternion ToQuaternion(Vector3 v)
{
float cy = (float)Math.Cos(v.Z * 0.5);
float sy = (float)Math.Sin(v.Z * 0.5);
float cp = (float)Math.Cos(v.Y * 0.5);
float sp = (float)Math.Sin(v.Y * 0.5);
float cr = (float)Math.Cos(v.X * 0.5);
float sr = (float)Math.Sin(v.X * 0.5);
return new Quaternion
{
W = (cr * cp * cy + sr * sp * sy),
X = (sr * cp * cy - cr * sp * sy),
Y = (cr * sp * cy + sr * cp * sy),
Z = (cr * cp * sy - sr * sp * cy),
};
}
public static Vector3 ToEulerAngles(Quaternion q)
{
Vector3 angles = new();
// roll / x
double sinrCosp = 2 * (q.W * q.X + q.Y * q.Z);
double cosrCosp = 1 - 2 * (q.X * q.X + q.Y * q.Y);
angles.X = (float)Math.Atan2(sinrCosp, cosrCosp);
// pitch / y
double sinp = 2 * (q.W * q.Y - q.Z * q.X);
if (Math.Abs(sinp) >= 1)
{
angles.Y = (float)Math.CopySign(Math.PI / 2, sinp);
}
else
{
angles.Y = (float)Math.Asin(sinp);
}
// yaw / z
double sinyCosp = 2 * (q.W * q.Z + q.X * q.Y);
double cosyCosp = 1 - 2 * (q.Y * q.Y + q.Z * q.Z);
angles.Z = (float)Math.Atan2(sinyCosp, cosyCosp);
return angles;
}
}

13
Nerfed.Runtime/Util/RandomId.cs
View File

@ -1,13 +0,0 @@
using System.Security.Cryptography;
namespace Nerfed.Runtime.Util;
public static class RandomId
{
public static uint GenerateSecureRandomUInt()
{
byte[] buffer = new byte[4];
RandomNumberGenerator.Fill(buffer);
return BitConverter.ToUInt32(buffer, 0);
}
}

99
Nerfed.Runtime/Util/Transform.cs
View File

@ -1,99 +0,0 @@
using MoonTools.ECS;
using Nerfed.Runtime.Components;
using System.Collections.Generic;
using System.Numerics;
namespace Nerfed.Runtime.Util
{
// https://github.com/needle-mirror/com.unity.entities/blob/master/Unity.Transforms/TransformHelpers.cs
public static class Transform
{
public static Vector3 Forward(in this Matrix4x4 matrix) => new Vector3(matrix.M31, matrix.M32, matrix.M33);
public static Vector3 Back(in this Matrix4x4 matrix) => -matrix.Forward();
public static Vector3 Up(in this Matrix4x4 matrix) => new Vector3(matrix.M21, matrix.M22, matrix.M23);
public static Vector3 Down(in this Matrix4x4 matrix) => -matrix.Up();
public static Vector3 Right(in this Matrix4x4 matrix) => new Vector3(matrix.M11, matrix.M12, matrix.M13);
public static Vector3 Left(in this Matrix4x4 matrix) => -matrix.Right();
//public static Vector3 Translation(in this Matrix4x4 matrix) => new Vector3();
//public static Quaternion Rotation(in this Matrix4x4 matrix) => new Quaternion();
public static Matrix4x4 TRS(in this LocalTransform localTransform)
{
return Matrix4x4.CreateScale(localTransform.scale) *
Matrix4x4.CreateFromQuaternion(localTransform.rotation) *
Matrix4x4.CreateTranslation(localTransform.position);
}
// Sets the parent child relation and adds a child component.
// Relation goes from child to parent.
public static void SetParent(in World world, in Entity child, in Entity parent)
{
RemoveParent(world, child);
world.Relate(child, parent, new ChildParentRelation());
world.Set(child, new Child());
world.Remove<Root>(child);
return;
}
// Removes any parent child relation ship, thus making it a 'root' object.
public static void RemoveParent(in World world, in Entity child)
{
if (!world.HasOutRelation<ChildParentRelation>(child))
{
return;
}
Entity parent = world.OutRelationSingleton<ChildParentRelation>(child);
// TODO: Check if Unrelate all also unrelates incomming relations..?
world.Unrelate<ChildParentRelation>(child, parent);
world.Remove<Child>(child);
world.Set(child, new Root());
}
public static Entity CreateBaseEntity(this World world, string tag = "")
{
Entity entity = world.CreateEntity(tag);
world.Set(entity, new Root());
return entity;
}
// Force update the transform data of an entity (and children).
// Useful for when you need precise up to date transform data.
public static void ForceUpdateLocalToWorld(in World world, in Entity entity)
{
Matrix4x4 parentLocalToWorldMatrix = Matrix4x4.Identity;
if (world.HasOutRelation<ChildParentRelation>(entity)) {
Entity parent = world.OutRelationSingleton<ChildParentRelation>(entity);
if (world.Has<LocalToWorld>(parent))
{
parentLocalToWorldMatrix = world.Get<LocalToWorld>(parent).localToWorldMatrix;
}
}
ForceUpdateLocalToWorld(world, entity, parentLocalToWorldMatrix);
}
private static void ForceUpdateLocalToWorld(in World world, in Entity entity, Matrix4x4 localToWorldMatrix)
{
if (world.Has<LocalTransform>(entity))
{
LocalTransform localTransform = world.Get<LocalTransform>(entity);
localToWorldMatrix = Matrix4x4.Multiply(localToWorldMatrix, localTransform.TRS());
LocalToWorld localToWorld = new(localToWorldMatrix);
world.Set(entity, localToWorld);
Log.Info($"Entity {entity} | local position {localTransform.position} | world position {localToWorldMatrix.Translation}");
}
ReverseSpanEnumerator<Entity> childEntities = world.InRelations<ChildParentRelation>(entity);
foreach (Entity childEntity in childEntities)
{
ForceUpdateLocalToWorld(world, childEntity, localToWorldMatrix);
}
}
}
}