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

Compare commits

base: max:project
Branches Tags
max:main max:ecs-test max:project max:ImGui max:NerfedIcon
..
compare: max:86b54e15215e143a15a2aa6ee787c66e50b30f90
Branches Tags
max:ecs-test max:main max:project max:ImGui max:NerfedIcon

7 Commits
project ... 86b54e1521

Author SHA1 Message Date
max
86b54e1521 test with ecs source and target drag drops 2024-10-15 23:15:35 +02:00
max
ba88432e77 unsafe drag drop test 
- unsafe because of entity reference
- unsafe because of unsafe code lol
- fixes in parent/child system
 2024-10-15 22:29:19 +02:00
max
5cc876fce9 tree hierachy and selection test 2024-10-15 21:47:23 +02:00
max
91b4f5fafb hierachy and parent child system updates 
- started working on an editor hierarchy window
- testing filters
- testing parent child relations without system
- testing root component
- thinking about how to get all entities that are not a child, but also don't have an other identifying component
 2024-10-15 00:41:45 +02:00
max
0d14a32726 added idenentity transform 2024-10-13 01:20:23 +02:00
max
b3adef3a40 Naming, comments and local to world update 2024-10-13 01:05:46 +02:00
max
30deeca452 ecs and tranforms 
added the moonworks ecs library.
testing it by setting up a transform and parent system.
 2024-10-13 00:08:01 +02:00
31 changed files with 591 additions and 960 deletions
Expand all files Collapse all files

3
.gitmodules vendored
View File

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

64
Nerfed.Compiler/AssemblyDefinition.cs
View File

@ -1,64 +0,0 @@
using System.Text.Json;
using System.Text.Json.Serialization;
namespace Nerfed.Compiler;
public class AssemblyDefinition
{
public string Name { get; set; }
public string Guid { get; set; }
//public bool IsEditor { get; set; }
// Add platform stuff here..?
// Add dll's here..?
// Add dependencies here..?
public static bool Create(string assemblyDefinitionFilePath, string name, out AssemblyDefinition assemblyDefinition)
{
assemblyDefinition = null;
if (File.Exists(assemblyDefinitionFilePath))
{
Console.WriteLine($"ERROR: File already exists!");
return false;
}
// Create project file.
assemblyDefinition = new AssemblyDefinition
{
Name = name,
Guid = System.Guid.NewGuid().ToString("B").ToUpper(),
};
Save(assemblyDefinition, assemblyDefinitionFilePath);
return true;
}
public static bool Save(AssemblyDefinition assemblyDefinition, string assemblyDefinitionFilePath)
{
string jsonString = JsonSerializer.Serialize(assemblyDefinition, AssemblyDefinitionContext.Default.AssemblyDefinition);
File.WriteAllText(assemblyDefinitionFilePath, jsonString);
return true;
}
public static bool Open(string assemblyDefinitionFilePath, out AssemblyDefinition assemblyDefinition)
{
string jsonString = File.ReadAllText(assemblyDefinitionFilePath);
assemblyDefinition = JsonSerializer.Deserialize(jsonString, AssemblyDefinitionContext.Default.AssemblyDefinition);
if (assemblyDefinition == null)
{
Console.WriteLine($"ERROR: Could not open {typeof(AssemblyDefinition)}.");
return false;
}
return true;
}
}
[JsonSerializable(typeof(AssemblyDefinition))]
public partial class AssemblyDefinitionContext : JsonSerializerContext
{
}

82
Nerfed.Compiler/Compiler.cs
View File

@ -1,82 +0,0 @@
using System.Diagnostics;
using System.Runtime.InteropServices;
namespace Nerfed.Compiler;
public static class Compiler
{
public static bool Compile(string projectFilePath, string configuration = "Debug")
{
string projectDirectory = Path.GetDirectoryName(projectFilePath);
if (!File.Exists(projectFilePath))
{
Console.WriteLine($"ERROR: Project file not found at {projectDirectory}.");
return false;
}
if (!Project.Open(projectFilePath, out Project project))
{
return false;
}
// TODO: Check project version, to make sure we can compile it or something...
// Generate solution.
Generator.GenerateSolution(projectDirectory, project, out string solutionFilePath);
// Compile solution.
ProcessStartInfo processInfo = new()
{
WorkingDirectory = Path.GetDirectoryName(solutionFilePath),
CreateNoWindow = true,
UseShellExecute = false,
RedirectStandardError = true,
RedirectStandardOutput = true,
};
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
processInfo.FileName = "/bin/bash";
processInfo.Arguments = $"-c \"dotnet build '{Path.GetFileName(solutionFilePath)}'\"" + (string.IsNullOrWhiteSpace(configuration) ? $" --configuration {configuration}" : "");
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
processInfo.FileName = "cmd.exe";
processInfo.Arguments = $"/c dotnet build \"{Path.GetFileName(solutionFilePath)}\"" + (string.IsNullOrWhiteSpace(configuration) ? $" --configuration {configuration}" : "");
}
else
{
Console.WriteLine($"ERROR: Platform not supported!");
return false;
}
Process process = Process.Start(processInfo) ?? throw new Exception();
process.OutputDataReceived += (sender, dataArgs) => {
string data = dataArgs.Data;
if (data is null)
{
return;
}
Console.WriteLine(data);
};
process.BeginOutputReadLine();
process.BeginErrorReadLine();
process.ErrorDataReceived += (sender, dataArgs) => {
if (dataArgs.Data is not null)
{
Console.WriteLine(dataArgs.Data);
}
};
process.WaitForExit();
int exitCode = process.ExitCode;
process.Close();
return true;
}
}

161
Nerfed.Compiler/Generator.cs
View File

@ -1,161 +0,0 @@
using System.Reflection;
using System.Text;
using System.Text.Json;
namespace Nerfed.Compiler;
public static class Generator
{
public const string AssemblyDefinitionExtensionName = ".asmdef";
public const string CSProjectExtensionName = ".csproj";
public const string SolutionExtensionName = ".sln";
public static void GenerateSolution(string projectDirectory, Project project, out string solutionFilePath)
{
// Clear files.
ClearCSProjectFiles(projectDirectory);
// Generate projects.
string[] assemblyDefinitionFilePaths = Directory.GetFiles(projectDirectory, AssemblyDefinitionExtensionName, SearchOption.AllDirectories);
foreach (string assemblyDefinitionFilePath in assemblyDefinitionFilePaths)
{
GenerateCSProject(assemblyDefinitionFilePath, projectDirectory, out string csProjectFilePath);
}
// Generate solution.
string[] csProjectPaths = Directory.GetFiles(projectDirectory, $"*{CSProjectExtensionName}", SearchOption.TopDirectoryOnly);
string[] csProjectGuids = new string[csProjectPaths.Length];
for (int i = 0; i < csProjectPaths.Length; i++)
{
csProjectGuids[i] = Guid.NewGuid().ToString("B").ToUpper();
}
StringBuilder content = new StringBuilder();
// Write the solution file header
content.AppendLine("Microsoft Visual Studio Solution File, Format Version 12.00");
content.AppendLine("# Visual Studio Version 17");
content.AppendLine("VisualStudioVersion = 17.10.35013.160");
content.AppendLine("MinimumVisualStudioVersion = 10.0.40219.1");
// Add each project to the solution file
for (int i = 0; i < csProjectPaths.Length; i++)
{
string csProjectPath = csProjectPaths[i];
string csProjectGuid = csProjectGuids[i];
string csProjectName = Path.GetFileNameWithoutExtension(csProjectPath);
string csProjectRelativePath = Path.GetRelativePath(projectDirectory, csProjectPath);
// FAE04EC0-301F-11D3-BF4B-00C04F79EFBC for C# projects.
content.AppendLine($"Project(\"{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}\") = \"{csProjectName}\", \"{csProjectRelativePath}\", \"{csProjectGuid}\"");
content.AppendLine("EndProject");
}
// Add global sections (these can be extended as needed)
content.AppendLine("Global");
content.AppendLine(" GlobalSection(SolutionConfigurationPlatforms) = preSolution");
content.AppendLine(" Test|x64 = Test|x64");
content.AppendLine(" Release|x64 = Release|x64");
content.AppendLine(" Debug|x64 = Debug|x64");
content.AppendLine(" EndGlobalSection");
content.AppendLine(" GlobalSection(ProjectConfigurationPlatforms) = postSolution");
for (int i = 0; i < csProjectPaths.Length; i++)
{
string projectGuid = csProjectGuids[i];
content.AppendLine($" {projectGuid}.Test|x64.ActiveCfg = Test|x64");
content.AppendLine($" {projectGuid}.Test|x64.Build.0 = Test|x64");
content.AppendLine($" {projectGuid}.Release|x64.ActiveCfg = Release|x64");
content.AppendLine($" {projectGuid}.Release|x64.Build.0 = Release|x64");
content.AppendLine($" {projectGuid}.Debug|x64.ActiveCfg = Debug|x64");
content.AppendLine($" {projectGuid}.Debug|x64.Build.0 = Debug|x64");
}
content.AppendLine(" EndGlobalSection");
content.AppendLine(" GlobalSection(SolutionProperties) = preSolution");
content.AppendLine(" HideSolutionNode = FALSE");
content.AppendLine(" EndGlobalSection");
content.AppendLine("EndGlobal");
// Write the solution file content to disk
string solutionName = project.Name + SolutionExtensionName;
solutionFilePath = Path.Combine(projectDirectory, solutionName);
File.WriteAllText(solutionFilePath, content.ToString());
}
private static bool GenerateCSProject(string assemblyDefinitionFilePath, string projectPath, out string csProjectFilePath)
{
if (!File.Exists(assemblyDefinitionFilePath))
{
csProjectFilePath = string.Empty;
return false;
}
string jsonString = File.ReadAllText(assemblyDefinitionFilePath);
AssemblyDefinition assemblyDefinition = JsonSerializer.Deserialize(jsonString, AssemblyDefinitionContext.Default.AssemblyDefinition);
Assembly[] loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
Assembly runtimeAssembly = loadedAssemblies.FirstOrDefault(assembly => assembly.GetName().Name == "Nerfed.Runtime") ?? throw new Exception("Failed to find Runtime Assembly!");
// TODO: get all dependencies.
// TODO: properly get assemblies.
StringBuilder content = new StringBuilder();
content.AppendLine("<Project Sdk=\"Microsoft.NET.Sdk\">");
content.AppendLine(" <PropertyGroup>");
content.AppendLine(" <TargetFramework>net8.0</TargetFramework>");
content.AppendLine(" <ImplicitUsings>enable</ImplicitUsings>");
content.AppendLine(" <Nullable>disable</Nullable>");
content.AppendLine(" <PublishAot>true</PublishAot>");
content.AppendLine(" <InvariantGlobalization>true</InvariantGlobalization>");
content.AppendLine(" <AllowUnsafeBlocks>true</AllowUnsafeBlocks>");
content.AppendLine(" <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>");
content.AppendLine(" <IsPackable>false</IsPackable>");
content.AppendLine(" <Configurations>Debug;Test;Release</Configurations>");
content.AppendLine(" <Platforms>x64</Platforms>");
content.AppendLine(" </PropertyGroup>");
content.AppendLine(" <PropertyGroup Condition=\" '$(Configuration)|$(Platform)' == 'Debug|x64' \">");
content.AppendLine(" <DefineConstants>TRACE;LOG_INFO;PROFILING</DefineConstants>");
content.AppendLine(" </PropertyGroup>");
content.AppendLine(" <PropertyGroup Condition=\" '$(Configuration)|$(Platform)' == 'Test|x64' \">");
content.AppendLine(" <DefineConstants>TRACE;LOG_ERROR;PROFILING</DefineConstants>");
content.AppendLine(" <Optimize>true</Optimize>");
content.AppendLine(" </PropertyGroup>");
content.AppendLine(" <PropertyGroup Condition=\" '$(Configuration)|$(Platform)' == 'Release|x64' \">");
content.AppendLine(" <DefineConstants>TRACE;LOG_ERROR</DefineConstants>");
content.AppendLine(" <Optimize>true</Optimize>");
content.AppendLine(" </PropertyGroup>");
content.AppendLine(" <ItemGroup>");
content.AppendLine($" <Compile Include=\"{assemblyDefinitionFilePath}/**/*.cs\"/>");
content.AppendLine(" </ItemGroup>");
content.AppendLine(" <ItemGroup>");
content.AppendLine(" <Reference Include=\"Nerfed.Runtime\">");
content.AppendLine($" <HintPath>{runtimeAssembly.Location}</HintPath>");
content.AppendLine(" <Private>false</Private>");
content.AppendLine(" </Reference>");
content.AppendLine(" </ItemGroup>");
content.AppendLine("</Project>");
string csProjectName = assemblyDefinition.Name + CSProjectExtensionName;
csProjectFilePath = Path.Combine(projectPath, csProjectName);
File.WriteAllText(csProjectFilePath, content.ToString());
return true;
}
private static void ClearCSProjectFiles(string projectPath)
{
string[] csProjectFiles = Directory.GetFiles(projectPath, $"*{CSProjectExtensionName}", SearchOption.TopDirectoryOnly);
foreach (string csProjectFile in csProjectFiles)
{
File.Delete(csProjectFile);
}
}
}

26
Nerfed.Compiler/Nerfed.Compiler.csproj
View File

@ -1,26 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>disable</Nullable>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<IsPackable>false</IsPackable>
<Configurations>Debug;Test;Release</Configurations>
<Platforms>x64</Platforms>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
<Optimize>false</Optimize>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Test|x64' ">
<Optimize>true</Optimize>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
<Optimize>true</Optimize>
</PropertyGroup>
</Project>

15
Nerfed.Compiler/Program.cs
View File

@ -1,15 +0,0 @@
namespace Nerfed.Compiler;
public class Program
{
internal static void Main(string[] args)
{
if (args.Length != 2)
{
Console.WriteLine("projectFilePath, configuration (Debug, Test, Release)");
return;
}
Compiler.Compile(args[0], args[1]);
}
}

50
Nerfed.Compiler/Project.cs
View File

@ -1,50 +0,0 @@
using System.Text.Json;
using System.Text.Json.Serialization;
namespace Nerfed.Compiler;
public class Project
{
public string Name { get; set; }
public static bool Create(string path, string name, out Project project)
{
// Create project file.
project = new Project
{
Name = name,
};
Save(project, path);
return true;
}
public static bool Save(Project project, string projectFilePath)
{
string jsonString = JsonSerializer.Serialize(project, ProjectContext.Default.Project);
File.WriteAllText(projectFilePath, jsonString);
return true;
}
public static bool Open(string path, out Project project)
{
string jsonString = File.ReadAllText(path);
project = JsonSerializer.Deserialize(jsonString, ProjectContext.Default.Project);
if (project == null)
{
Console.WriteLine($"ERROR: Could not open {typeof(Project)}.");
return false;
}
return true;
}
}
[JsonSerializable(typeof(Project))]
public partial class ProjectContext : JsonSerializerContext
{
}

6
Nerfed.Editor/Components/HierachyComponents.cs Normal file
View File

@ -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;

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

@ -1,5 +1,4 @@
using ImGuiNET;
using Nerfed.Editor.Project;
using Nerfed.Runtime;
using Nerfed.Runtime.Graphics;
using Nerfed.Runtime.Gui;
@ -57,7 +56,6 @@ namespace Nerfed.Editor
}
ImGui.EndMenu();
}
ImGui.EndMainMenuBar();
}
}
@ -69,7 +67,10 @@ namespace Nerfed.Editor
ImGui.ShowDemoWindow();
EditorProjectGui.OnGui();
foreach (MoonTools.ECS.System system in Program.editorSystems)
{
system.Update(Engine.Timestep);
}
}
}
}

2
Nerfed.Editor/Nerfed.Editor.csproj
View File

@ -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' ">
@ -23,7 +24,6 @@
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\Nerfed.Compiler\Nerfed.Compiler.csproj" />
<ProjectReference Include="..\Nerfed.Runtime\Nerfed.Runtime.csproj" />
</ItemGroup>

40
Nerfed.Editor/Program.cs
View File

@ -1,9 +1,19 @@
using Nerfed.Runtime;
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;
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;
@ -16,6 +26,27 @@ internal class Program
private static void HandleOnInitialize()
{
//systems.Add(new ParentSystem(world));
systems.Add(new LocalToWorldSystem(world));
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");
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");
// Open project.
// Setip EditorGui.
EditorGui.Initialize();
@ -23,11 +54,18 @@ internal class Program
private static void HandleOnUpdate()
{
foreach (MoonTools.ECS.System system in systems)
{
system.Update(Engine.Timestep);
}
// Editor Update.
EditorGui.Update();
// Try Catch UserCode Update.
world.FinishUpdate();
}
private static void HandleOnRender()

8
Nerfed.Editor/Project/EditorAssemblyLoadContext.cs
View File

@ -1,8 +0,0 @@
using System.Runtime.Loader;
namespace Nerfed.Editor.Project;
internal class EditorAssemblyLoadContext : AssemblyLoadContext
{
public EditorAssemblyLoadContext() : base(isCollectible: true) { }
}

124
Nerfed.Editor/Project/EditorAssemblyLoader.cs
View File

@ -1,124 +0,0 @@
using Nerfed.Runtime;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
namespace Nerfed.Editor.Project;
// https://github.com/godotengine/godot/blob/master/modules/mono/glue/GodotSharp/GodotPlugins/Main.c
// https://gitlab.com/robertk92/assemblyreloadtest/-/blob/main/AppContextTest/Program.cs
internal static class EditorAssemblyLoader
{
internal sealed class EditorAssemblyLoadContextWrapper
{
private EditorAssemblyLoadContext assemblyLoadContext;
private readonly WeakReference weakReference;
private EditorAssemblyLoadContextWrapper(EditorAssemblyLoadContext assemblyLoadContext, WeakReference weakReference)
{
this.assemblyLoadContext = assemblyLoadContext;
this.weakReference = weakReference;
}
public bool IsCollectible
{
[MethodImpl(MethodImplOptions.NoInlining)]
// If assemblyLoadContext is null we already started unloading, so it was collectible.
get => assemblyLoadContext?.IsCollectible ?? true;
}
public bool IsAlive
{
[MethodImpl(MethodImplOptions.NoInlining)]
get => weakReference.IsAlive;
}
[MethodImpl(MethodImplOptions.NoInlining)]
public static (Assembly, EditorAssemblyLoadContextWrapper) CreateAndLoad(AssemblyName assemblyName)
{
EditorAssemblyLoadContext context = new EditorAssemblyLoadContext();
WeakReference reference = new WeakReference(context, trackResurrection: true);
EditorAssemblyLoadContextWrapper wrapper = new EditorAssemblyLoadContextWrapper(context, reference);
Assembly assembly = context.LoadFromAssemblyName(assemblyName);
return (assembly, wrapper);
}
[MethodImpl(MethodImplOptions.NoInlining)]
public static (Assembly, EditorAssemblyLoadContextWrapper) CreateAndLoad(string assemblyPath)
{
EditorAssemblyLoadContext context = new EditorAssemblyLoadContext();
WeakReference reference = new WeakReference(context, trackResurrection: true);
EditorAssemblyLoadContextWrapper wrapper = new EditorAssemblyLoadContextWrapper(context, reference);
Assembly assembly = context.LoadFromAssemblyPath(assemblyPath);
return (assembly, wrapper);
}
[MethodImpl(MethodImplOptions.NoInlining)]
internal void Unload()
{
assemblyLoadContext?.Unload();
assemblyLoadContext = null;
}
}
internal static (Assembly, EditorAssemblyLoadContextWrapper) Load(string assemblyFilePath)
{
string assemblyFileName = Path.GetFileNameWithoutExtension(assemblyFilePath);
AssemblyName assemblyName = new AssemblyName(assemblyFileName);
return EditorAssemblyLoadContextWrapper.CreateAndLoad(assemblyName);
}
internal static (Assembly, EditorAssemblyLoadContextWrapper) LoadFromPath(string assemblyFilePath)
{
return EditorAssemblyLoadContextWrapper.CreateAndLoad(assemblyFilePath);
}
internal static bool Unload(EditorAssemblyLoadContextWrapper assemblyLoadContextWrapper)
{
if (assemblyLoadContextWrapper == null)
{
return true;
}
if (!assemblyLoadContextWrapper.IsCollectible)
{
Log.Error($"{assemblyLoadContextWrapper} is not collectable!");
return false;
}
assemblyLoadContextWrapper.Unload();
GC.Collect();
GC.WaitForPendingFinalizers();
TimeSpan timeout = TimeSpan.FromSeconds(30);
Stopwatch stopwatch = Stopwatch.StartNew();
while (assemblyLoadContextWrapper.IsAlive)
{
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
GC.WaitForPendingFinalizers();
if (!assemblyLoadContextWrapper.IsAlive)
{
break;
}
if (stopwatch.Elapsed.TotalSeconds % 10 == 0)
{
Log.Info("Tring to unload assembly...");
}
if (stopwatch.Elapsed >= timeout)
{
Log.Error("Failed to unload assembly!");
return false;
}
}
return true;
}
}

173
Nerfed.Editor/Project/EditorProject.cs
View File

@ -1,173 +0,0 @@
using Nerfed.Runtime;
namespace Nerfed.Editor.Project;
internal static class EditorProject
{
internal static Compiler.Project Project { get; private set; } = null;
internal static string ProjectFilePath { get; private set; } = string.Empty;
internal static string ProjectSolutionFilePath { get; private set; } = string.Empty;
internal static string ProjectDirectory { get; private set; } = string.Empty;
internal static string ProjectContentDirectory { get; private set; } = string.Empty;
internal static string ProjectTempDirectory { get; private set; } = string.Empty;
private static readonly List<(string, EditorAssemblyLoader.EditorAssemblyLoadContextWrapper)> editorAssemblyLoadContextWrappers = [];
internal static bool Create(string projectFilePath, string projectName)
{
Close();
if (!Compiler.Project.Create(projectFilePath, projectName, out Compiler.Project project))
{
return false;
}
Open(projectFilePath);
Log.Info($"Succesfully created project.");
return true;
}
internal static bool Open(string projectFilePath)
{
Close();
if(!Compiler.Project.Open(projectFilePath, out Compiler.Project project))
{
return false;
}
Project = project;
ProjectFilePath = projectFilePath;
ProjectDirectory = Path.GetDirectoryName(projectFilePath);
string projectSolutionFilePath = Path.Combine(ProjectDirectory, Project.Name + Compiler.Generator.SolutionExtensionName);
if (File.Exists(projectSolutionFilePath))
{
ProjectSolutionFilePath = projectSolutionFilePath;
}
SetupDefaultFolders();
Compile();
Log.Info($"Opened project: {project.Name}");
return true;
}
internal static void Close()
{
Project = null;
ProjectFilePath = string.Empty;
ProjectSolutionFilePath = string.Empty;
ProjectDirectory = string.Empty;
ProjectContentDirectory = string.Empty;
ProjectTempDirectory = string.Empty;
}
internal static bool Save()
{
if(Project == null)
{
return false;
}
return Compiler.Project.Save(Project, ProjectFilePath);
}
internal static void Compile()
{
if(Project == null)
{
return;
}
UnloadAssemblies();
Compiler.Compiler.Compile(ProjectFilePath, "Debug");
LoadAssemblies();
}
internal static void GenerateSolution()
{
if(Project == null)
{
return;
}
Compiler.Generator.GenerateSolution(ProjectDirectory, Project, out string solutionFilePath);
ProjectSolutionFilePath = solutionFilePath;
}
private static void SetupDefaultFolders()
{
if (Project == null || ProjectDirectory == null)
{
return;
}
string contentDirectory = Path.Combine(ProjectDirectory, "Content");
if (!Directory.Exists(contentDirectory))
{
Directory.CreateDirectory(contentDirectory);
}
ProjectContentDirectory = contentDirectory;
string scriptsDirectory = Path.Combine(ProjectContentDirectory, "Scripts");
if (!Directory.Exists(scriptsDirectory))
{
Directory.CreateDirectory(scriptsDirectory);
}
string scriptsRuntimePath = Path.Combine(scriptsDirectory, "Runtime");
if (!Directory.Exists(scriptsRuntimePath))
{
Directory.CreateDirectory(scriptsRuntimePath);
}
// Test create csproject.
string gameplayRuntimeFilePath = Path.Combine(scriptsRuntimePath, Compiler.Generator.AssemblyDefinitionExtensionName);
if (!File.Exists(gameplayRuntimeFilePath))
{
Compiler.AssemblyDefinition.Create(gameplayRuntimeFilePath, "Gameplay", out Compiler.AssemblyDefinition project);
}
string tempDirectory = Path.Combine(ProjectDirectory, "Temp");
if (!Directory.Exists(tempDirectory))
{
Directory.CreateDirectory(tempDirectory);
}
ProjectTempDirectory = tempDirectory;
}
private static void LoadAssemblies()
{
string[] assemblies = Directory.GetFiles(Path.Combine(ProjectDirectory, "bin"), "*.dll", SearchOption.AllDirectories);
foreach (string assembly in assemblies)
{
(System.Reflection.Assembly, EditorAssemblyLoader.EditorAssemblyLoadContextWrapper) a = EditorAssemblyLoader.LoadFromPath(assembly);
string name = a.Item1.GetName().Name;
editorAssemblyLoadContextWrappers.Add((name, a.Item2));
Log.Info($"loaded {name}");
}
Nerfed.Runtime.Generator.Hook.InvokeHooks();
}
private static void UnloadAssemblies()
{
for (int i = editorAssemblyLoadContextWrappers.Count - 1; i >= 0; i--)
{
(string, EditorAssemblyLoader.EditorAssemblyLoadContextWrapper) a = editorAssemblyLoadContextWrappers[i];
if (EditorAssemblyLoader.Unload(a.Item2))
{
Log.Info($"Unloaded {a.Item1}");
editorAssemblyLoadContextWrappers.RemoveAt(i);
}
else
{
Log.Error($"Could not unload {a.Item1}");
}
}
}
}

67
Nerfed.Editor/Project/EditorProjectGui.cs
View File

@ -1,67 +0,0 @@
using ImGuiNET;
namespace Nerfed.Editor.Project;
internal static class EditorProjectGui
{
private static string projectDirectory = string.Empty;
private static string projectName = string.Empty;
private static string projectFilePath = string.Empty;
internal static void OnGui()
{
ImGui.Begin("Project");
ImGui.BeginGroup();
ImGui.InputText("Project Directory", ref projectDirectory, 512);
ImGui.InputText("Project Name", ref projectName, 512);
string newProjectFilePath = Path.Combine(projectDirectory, ".project");
ImGui.Text(newProjectFilePath);
if (ImGui.Button("Create Project"))
{
EditorProject.Create(newProjectFilePath, projectName);
}
ImGui.EndGroup();
ImGui.BeginGroup();
ImGui.InputText("Project File Path", ref projectFilePath, 512);
if (ImGui.Button("Open Project"))
{
EditorProject.Open(projectFilePath);
}
ImGui.Text("Loaded project: ");
if(EditorProject.Project != null)
{
ImGui.Text(EditorProject.Project.Name);
ImGui.Text(EditorProject.ProjectFilePath);
ImGui.Text(EditorProject.ProjectSolutionFilePath);
ImGui.Text(EditorProject.ProjectDirectory);
ImGui.Text(EditorProject.ProjectContentDirectory);
ImGui.Text(EditorProject.ProjectTempDirectory);
}
else
{
ImGui.Text("None");
}
ImGui.EndGroup();
ImGui.BeginGroup();
if (ImGui.Button("Generate Solution"))
{
EditorProject.GenerateSolution();
}
if (ImGui.Button("Compile"))
{
EditorProject.Compile();
}
ImGui.EndGroup();
ImGui.End();
}
}

252
Nerfed.Editor/Systems/EditorHierarchyWindow.cs Normal file
View File

@ -0,0 +1,252 @@
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.DebugSystem
{
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;
private readonly EditorHierachyDragAndDropSystem hierachyDragAndDropSystem;
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);
hierachyDragAndDropSystem = new EditorHierachyDragAndDropSystem(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);
hierachyDragAndDropSystem.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))
{
// Selection.
if (ImGui.IsItemClicked() && !ImGui.IsItemToggledOpen())
{
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);
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);
}
}
}
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);
}
}
}
}
}
}

91
Nerfed.Runtime.Generator/HookSourceGenerator.cs
View File

@ -1,91 +0,0 @@
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Nerfed.Runtime.Generator
{
[Generator]
public class HookSourceGenerator : ISourceGenerator
{
public void Execute(GeneratorExecutionContext context)
{
// Ensure the syntax receiver is not null and is of the expected type
if (context.SyntaxReceiver is not HookSyntaxReceiver syntaxReceiver)
return;
// Check if we have collected any hook methods
List<MethodDeclarationSyntax> hookMethods = syntaxReceiver.HookMethods;
if (hookMethods == null || !hookMethods.Any())
return;
StringBuilder codeBuilder = new StringBuilder();
codeBuilder.AppendLine("using System;");
codeBuilder.AppendLine("");
codeBuilder.AppendLine("namespace Nerfed.Runtime.Generator;");
codeBuilder.AppendLine("");
codeBuilder.AppendLine($"// Generated by {typeof(HookSourceGenerator)}");
codeBuilder.AppendLine("public static class Hook");
codeBuilder.AppendLine("{");
codeBuilder.AppendLine(" public static void InvokeHooks()");
codeBuilder.AppendLine(" {");
foreach (MethodDeclarationSyntax method in hookMethods)
{
SemanticModel model = context.Compilation.GetSemanticModel(method.SyntaxTree);
if (model.GetDeclaredSymbol(method) is not IMethodSymbol methodSymbol)
{
continue;
}
if (methodSymbol.DeclaredAccessibility != Accessibility.Public || !methodSymbol.IsStatic)
{
continue;
}
codeBuilder.AppendLine($" {methodSymbol.ContainingType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)}.{methodSymbol.Name}();");
}
codeBuilder.AppendLine(" }");
codeBuilder.AppendLine("}");
// Add the generated code to the compilation
context.AddSource("Hook.g.cs", codeBuilder.ToString());
}
public void Initialize(GeneratorInitializationContext context)
{
context.RegisterForSyntaxNotifications(() => new HookSyntaxReceiver());
}
public class HookSyntaxReceiver : ISyntaxReceiver
{
public List<MethodDeclarationSyntax> HookMethods { get; } = new List<MethodDeclarationSyntax>();
public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
{
// Check if the node is a method declaration
if (syntaxNode is MethodDeclarationSyntax methodDeclaration)
{
// Ensure the method declaration has attribute lists
if (methodDeclaration.AttributeLists.Count == 0)
return;
// Check if the method has the Hook attribute
bool hasHookAttribute = methodDeclaration.AttributeLists
.SelectMany(attrList => attrList.Attributes)
.Any(attr => attr.Name.ToString() == "Hook");
if (hasHookAttribute)
{
HookMethods.Add(methodDeclaration);
}
}
}
}
}
}

33
Nerfed.Runtime.Generator/Nerfed.Runtime.Generator.csproj
View File

@ -1,33 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>netstandard2.0</TargetFramework>
<LangVersion>latest</LangVersion>
<EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
<Configurations>Debug;Test;Release</Configurations>
<Platforms>x64</Platforms>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>
<PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.11.0"/>
</ItemGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
<DefineConstants>TRACE;LOG_INFO;PROFILING</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Test|x64' ">
<DefineConstants>TRACE;LOG_ERROR;PROFILING</DefineConstants>
<Optimize>true</Optimize>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
<DefineConstants>TRACE;LOG_ERROR</DefineConstants>
<Optimize>true</Optimize>
</PropertyGroup>
</Project>

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

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

20
Nerfed.Runtime/Components/LocalTransform.cs Normal file
View File

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

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

@ -0,0 +1,11 @@
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 Normal file
View File

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

1
Nerfed.Runtime/Engine.cs
View File

@ -72,7 +72,6 @@ public static class Engine
AudioDevice = new AudioDevice();
OnInitialize?.Invoke();
Nerfed.Runtime.Generator.Hook.InvokeHooks();
while (!quit)
{

7
Nerfed.Runtime/Hook/HookAttribute.cs
View File

@ -1,7 +0,0 @@
namespace Nerfed.Runtime.Hook
{
[AttributeUsage(AttributeTargets.Method, Inherited = false)]
public class HookAttribute : Attribute
{
}
}

11
Nerfed.Runtime/Hook/HookTest.cs
View File

@ -1,11 +0,0 @@
namespace Nerfed.Runtime.Hook
{
public static class HookTest
{
[Hook]
public static void Test()
{
Log.Info("Hook!");
}
}
}

1
Nerfed.Runtime/Libraries/ECS Submodule

Submodule Nerfed.Runtime/Libraries/ECS added at 76b18a6ba9

8
Nerfed.Runtime/Nerfed.Runtime.csproj
View File

@ -11,7 +11,6 @@
<IsPackable>false</IsPackable>
<Configurations>Debug;Test;Release</Configurations>
<Platforms>x64</Platforms>
<EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
</PropertyGroup>
<PropertyGroup>
@ -33,6 +32,7 @@
</PropertyGroup>
<ItemGroup>
<Compile Include="Libraries\ECS\src\**\*.cs" />
<Compile Include="Libraries\SDL2CS\src\SDL2.cs" />
<Compile Include="Libraries\RefreshCS\RefreshCS.cs" />
<Compile Include="Libraries\FAudio\csharp\FAudio.cs" />
@ -41,10 +41,4 @@
<Compile Include="Libraries\ImGui.NET\src\ImGui.NET\**\*.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Nerfed.Runtime.Generator\Nerfed.Runtime.Generator.csproj"
OutputItemType="Analyzer"
ReferenceOutputAssembly="false" />
</ItemGroup>
</Project>

58
Nerfed.Runtime/Systems/LocalToWorldSystem.cs Normal file
View File

@ -0,0 +1,58 @@
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 Filter rootEntitiesFilter;
public LocalToWorldSystem(World world) : base(world)
{
rootEntitiesFilter = FilterBuilder.Include<LocalTransform>().Exclude<Child>().Build();
}
public override void Update(TimeSpan delta)
{
Matrix4x4 rootMatrix = Matrix4x4.Identity;
foreach (Entity entity in rootEntitiesFilter.Entities)
{
UpdateWorldTransform(entity, rootMatrix);
}
}
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);
//Log.Info($"Entity {entity} | local position {localTransform.position} | world position {localToWorldMatrix.Translation}");
}
ReverseSpanEnumerator<Entity> childEntities = World.OutRelations<ChildParentRelation>(entity);
foreach (Entity childEntity in childEntities)
{
UpdateWorldTransform(childEntity, localToWorldMatrix);
}
}
}
}

67
Nerfed.Runtime/Systems/ParentSystem.cs Normal file
View File

@ -0,0 +1,67 @@
using MoonTools.ECS;
using Nerfed.Runtime.Components;
namespace Nerfed.Runtime.Systems
{
//public class ParentSystem : MoonTools.ECS.System
//{
// private readonly Filter parentsAddedFilter;
// private readonly Filter parentsRemovedFilter;
// private readonly Filter parentsFilter;
// public ParentSystem(World world) : base(world)
// {
// parentsAddedFilter = FilterBuilder.Include<Parent>().Exclude<PreviousParent>().Build();
// parentsRemovedFilter = FilterBuilder.Include<PreviousParent>().Exclude<Parent>().Build();
// parentsFilter = FilterBuilder.Include<Parent>().Include<PreviousParent>().Build();
// }
// public override void Update(TimeSpan delta)
// {
// // Update removed parents.
// foreach (Entity entity in parentsRemovedFilter.Entities)
// {
// // Do stuff here to update/remove child relations etc.
// //PreviousParent previousParent = Get<PreviousParent>(entity);
// //World.Unrelate<ChildParentRelation>(previousParent.parentEntity, entity);
// Remove<PreviousParent>(entity);
// }
// // Update added parents.
// foreach (Entity entity in parentsAddedFilter.Entities)
// {
// Parent parent = Get<Parent>(entity);
// if (Has<Parent>(parent.parentEntity) && Get<Parent>(parent.parentEntity).parentEntity == entity)
// {
// Log.Warning($"Entity {entity} cannot be a parent of entity {parent.parentEntity}, because {parent.parentEntity} is the parent of {entity}");
// Remove<Parent>(entity);
// continue;
// }
// PreviousParent previousParent = new(parent.parentEntity);
// Set(entity, previousParent);
// World.Relate(parent.parentEntity, entity, new ChildParentRelation());
// }
// // Update relations if the parent has changed.
// foreach (Entity entity in parentsFilter.Entities)
// {
// Parent parent = Get<Parent>(entity);
// PreviousParent previousParent = Get<PreviousParent>(entity);
// if(parent.parentEntity != previousParent.parentEntity)
// {
// World.Unrelate<ChildParentRelation>(previousParent.parentEntity, entity);
// Set(entity, new PreviousParent(parent.parentEntity));
// World.Relate(parent.parentEntity, entity, new ChildParentRelation());
// }
// }
// // TODO:
// // What if an parent entity gets destroyed?
// // How does the child know if the parent is in valid. Also we need to remove the parent component.
// // Maybe if we also relate the other way around child -> parent via relations, and the relation is gone that means the parent is gone so we should remove the component.
// }
//}
}

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

@ -0,0 +1,99 @@
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);
}
}
}
}

52
Nerfed.sln
View File

@ -5,54 +5,38 @@ VisualStudioVersion = 17.10.35013.160
MinimumVisualStudioVersion = 10.0.40219.1
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Nerfed.Runtime", "Nerfed.Runtime\Nerfed.Runtime.csproj", "{98E09BAF-587F-4238-89BD-7693C036C233}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Nerfed.Builder", "Nerfed.Builder\Nerfed.Builder.csproj", "{1B88DE56-2AD8-441E-9B10-073AA43840BF}"
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Nerfed.Builder", "Nerfed.Builder\Nerfed.Builder.csproj", "{1B88DE56-2AD8-441E-9B10-073AA43840BF}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Nerfed.Editor", "Nerfed.Editor\Nerfed.Editor.csproj", "{FF7D032D-7F0B-4700-A818-0606D66AECF8}"
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Nerfed.Editor", "Nerfed.Editor\Nerfed.Editor.csproj", "{FF7D032D-7F0B-4700-A818-0606D66AECF8}"
ProjectSection(ProjectDependencies) = postProject
{1B88DE56-2AD8-441E-9B10-073AA43840BF} = {1B88DE56-2AD8-441E-9B10-073AA43840BF}
EndProjectSection
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Nerfed.Compiler", "Nerfed.Compiler\Nerfed.Compiler.csproj", "{3DFEB8A4-5354-41EA-A249-27ADC7F666CF}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Nerfed.Runtime.Generator", "Nerfed.Runtime.Generator\Nerfed.Runtime.Generator.csproj", "{8743FDEF-4FF6-48F9-9F64-7BDEC543C105}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|x64 = Debug|x64
Release|x64 = Release|x64
Test|x64 = Test|x64
Release|x64 = Release|x64
Debug|x64 = Debug|x64
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{98E09BAF-587F-4238-89BD-7693C036C233}.Debug|x64.ActiveCfg = Debug|x64
{98E09BAF-587F-4238-89BD-7693C036C233}.Debug|x64.Build.0 = Debug|x64
{98E09BAF-587F-4238-89BD-7693C036C233}.Release|x64.ActiveCfg = Release|x64
{98E09BAF-587F-4238-89BD-7693C036C233}.Release|x64.Build.0 = Release|x64
{98E09BAF-587F-4238-89BD-7693C036C233}.Test|x64.ActiveCfg = Test|x64
{98E09BAF-587F-4238-89BD-7693C036C233}.Test|x64.Build.0 = Test|x64
{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Debug|x64.ActiveCfg = Debug|x64
{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Debug|x64.Build.0 = Debug|x64
{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Release|x64.ActiveCfg = Release|x64
{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Release|x64.Build.0 = Release|x64
{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Test|x64.ActiveCfg = Test|x64
{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Test|x64.Build.0 = Test|x64
{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Debug|x64.ActiveCfg = Debug|x64
{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Debug|x64.Build.0 = Debug|x64
{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Release|x64.ActiveCfg = Release|x64
{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Release|x64.Build.0 = Release|x64
{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Release|x64.ActiveCfg = Release|x64
{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Release|x64.Build.0 = Release|x64
{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Debug|x64.ActiveCfg = Debug|x64
{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Debug|x64.Build.0 = Debug|x64
{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Test|x64.ActiveCfg = Test|x64
{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Test|x64.Build.0 = Test|x64
{3DFEB8A4-5354-41EA-A249-27ADC7F666CF}.Debug|x64.ActiveCfg = Debug|x64
{3DFEB8A4-5354-41EA-A249-27ADC7F666CF}.Debug|x64.Build.0 = Debug|x64
{3DFEB8A4-5354-41EA-A249-27ADC7F666CF}.Release|x64.ActiveCfg = Release|x64
{3DFEB8A4-5354-41EA-A249-27ADC7F666CF}.Release|x64.Build.0 = Release|x64
{3DFEB8A4-5354-41EA-A249-27ADC7F666CF}.Test|x64.ActiveCfg = Test|x64
{3DFEB8A4-5354-41EA-A249-27ADC7F666CF}.Test|x64.Build.0 = Test|x64
{8743FDEF-4FF6-48F9-9F64-7BDEC543C105}.Debug|x64.ActiveCfg = Debug|x64
{8743FDEF-4FF6-48F9-9F64-7BDEC543C105}.Debug|x64.Build.0 = Debug|x64
{8743FDEF-4FF6-48F9-9F64-7BDEC543C105}.Release|x64.ActiveCfg = Release|x64
{8743FDEF-4FF6-48F9-9F64-7BDEC543C105}.Release|x64.Build.0 = Release|x64
{8743FDEF-4FF6-48F9-9F64-7BDEC543C105}.Test|x64.ActiveCfg = Test|x64
{8743FDEF-4FF6-48F9-9F64-7BDEC543C105}.Test|x64.Build.0 = Test|x64
{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Release|x64.ActiveCfg = Release|x64
{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Release|x64.Build.0 = Release|x64
{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Debug|x64.ActiveCfg = Debug|x64
{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Debug|x64.Build.0 = Debug|x64
{98E09BAF-587F-4238-89BD-7693C036C233}.Test|x64.ActiveCfg = Test|x64
{98E09BAF-587F-4238-89BD-7693C036C233}.Test|x64.Build.0 = Test|x64
{98E09BAF-587F-4238-89BD-7693C036C233}.Release|x64.ActiveCfg = Release|x64
{98E09BAF-587F-4238-89BD-7693C036C233}.Release|x64.Build.0 = Release|x64
{98E09BAF-587F-4238-89BD-7693C036C233}.Debug|x64.ActiveCfg = Debug|x64
{98E09BAF-587F-4238-89BD-7693C036C233}.Debug|x64.Build.0 = Debug|x64
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE