editor project

yes

Nerfed.Compiler/Compiler.cs

@@ -53,6 +53,7 @@ public static bool Compile(string projectFilePath, string configuration = "Debug
         }
         else
         {
+            Console.WriteLine($"ERROR: Platform not supported!");
             return false;
         }
 

Nerfed.Compiler/Project.cs

@@ -9,8 +9,6 @@ public class Project
 
     public static bool Create(string path, string name, out Project project)
     {
-        project = null;
-
         // Create project file.
         project = new Project
         {

Nerfed.Editor/Nerfed.Editor.csproj

@@ -23,6 +23,7 @@
     </PropertyGroup>
     
     <ItemGroup>
+        <ProjectReference Include="..\Nerfed.Compiler\Nerfed.Compiler.csproj" />
         <ProjectReference Include="..\Nerfed.Runtime\Nerfed.Runtime.csproj" />
     </ItemGroup>
 

Nerfed.Editor/Project/Project.cs

@@ -1,53 +1,25 @@
 using Nerfed.Runtime;
-using System.Reflection;
-using System.Text.Json;
 
 namespace Nerfed.Editor.Project;
 
-public class ProjectConfig
+internal static class EditorProject
 {
-    public string Name { get; set; }
+    internal static Compiler.Project Project { get; private set; }
-    public uint Version { get; set; }
+    internal static string ProjectFilePath { get; private set; }
-    public string RuntimeProject { get; set; }
+    internal static string ProjectSolutionFilePath { get; private set; }
-}
+    internal static string ProjectPath { get; private set; }
+    internal static string ProjectContentPath { get; private set; }
+    internal static string ProjectTempPath { get; private set; }
 
-internal static class Project
+    internal static bool Create(string projectFilePath, string projectName)
-{
-    private const string projectFileName = ".project";
-
-    internal static ProjectConfig LoadedConfig { get; private set; }
-    internal static string ProjectDirectory { get; private set; }
-    internal static string ProjectContentDirectory { get; private set; }
-    internal static string ProjectTempDirectory { get; private set; }
-
-    internal static bool Create(string path, string projectName)
     {
-        // Check if folder is empty.
+        Close();
-        if (!Directory.Exists(path))
-        {
-            Directory.CreateDirectory(path);
-        }
 
-        if(Directory.GetFiles(path).Length != 0)
+        if (!Compiler.Project.Create(projectFilePath, projectName, out Compiler.Project project))
         {
-            Log.Error($"Directory {path} is not empty!");
             return false;
         }
 
-        // Create project file.
-        ProjectConfig projectConfig = new ProjectConfig
-        {
-            Name = projectName,
-            Version = /*Nerfed.Runtime.Verion*/ 1,
-        };
-
-        // Create solution.
-        GenerateSolution(path, projectConfig);
-
-        string projectFilePath = Path.Combine(path, projectFileName);
-        SaveProject(projectFilePath, projectConfig);
-
-        // Open the project.
         Open(projectFilePath);
 
         Log.Info($"Succesfully created project.");
@@ -56,180 +28,80 @@ internal static bool Create(string path, string projectName)
 
     internal static bool Open(string path)
     {
-        string projectFilePath = path;
+        Close();
 
-        if (!File.Exists(projectFilePath)) {
+        if(!Compiler.Project.Open(path, out Compiler.Project project))
-            projectFilePath = Path.Combine(path, projectFileName);
-            if (!File.Exists(projectFilePath))
-            {
-                Log.Error($"Project file not found at {path} or {projectFilePath}");
-                return false;
-            }
-        }
-
-        // Load from file.
-        string jsonString = File.ReadAllText(projectFilePath);
-        ProjectConfig projectConfig = JsonSerializer.Deserialize<ProjectConfig>(jsonString);
-
-        // Check version.
-        if(projectConfig.Version != /*Nerfed.Runtime.Verion*/ 1)
         {
-            Log.Error($"Project runtime version does not match editor runtime verion!");
             return false;
         }
 
-        LoadedConfig = projectConfig;
+        Project = project;
-        SetupDefaultFolders(Path.GetDirectoryName(projectFilePath));
+        ProjectFilePath = path;
-        Log.Info($"Opened project: {projectConfig.Name}");
+        ProjectPath = Path.GetDirectoryName(path);
+        
+        SetupDefaultFolders();
+        Compile();
+
+        Log.Info($"Opened project: {project.Name}");
 
         return true;
     }
 
-    internal static bool SaveProject(string path, ProjectConfig projectConfig)
+    internal static void Close()
     {
-        JsonSerializerOptions options = new JsonSerializerOptions(JsonSerializerOptions.Default)
+        Project = null;
+        ProjectFilePath = string.Empty;
+        ProjectSolutionFilePath = string.Empty;
+        ProjectPath = string.Empty;
+        ProjectContentPath = string.Empty;
+        ProjectTempPath = string.Empty;
+    }
+
+    internal static bool Save()
+    {
+        if(Project == null)
         {
-            WriteIndented = true,
+            return false;
-        };
+        }
 
-        string jsonString = JsonSerializer.Serialize(projectConfig, options);
+        return Compiler.Project.Save(Project, ProjectFilePath);
-
-        File.WriteAllText(path, jsonString);
-
-        return true;
     }
 
-    // Compile the project using the builder.
+    internal static void Compile()
-    internal static bool CompileProject()
     {
-        //GenerateSolution();
+        if(Project == null)
-        //dotnet build <sln>
+        {
+            return;
+        }
 
-        return false;
+        Nerfed.Compiler.Compiler.Compile(ProjectFilePath, "Debug");
     }
 
-    private static void GenerateSolution(string path, ProjectConfig projectConfig)
+    internal static void GenerateSolution()
     {
-        GenerateCSProjectFiles(path, projectConfig);
+        if(Project == null)
+        {
+            return;
+        }
 
-        Log.Info("Generating solution file");
+        Nerfed.Compiler.Compiler.GenerateSolution(ProjectPath, Project, out string solutionFilePath);
-        string solution =
+        ProjectSolutionFilePath = solutionFilePath;
-$@"
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 17
-VisualStudioVersion = 17.10.35013.160
-MinimumVisualStudioVersion = 10.0.40219.1
-Project(""{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}"") = ""{projectConfig.Name}.Runtime"", ""{projectConfig.Name}.Runtime.csproj"", ""{{B04FAEF8-7D91-43A9-81C5-4BD3217B0C23}}""
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Test|x64 = Test|x64
-		Release|x64 = Release|x64
-		Debug|x64 = Debug|x64
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{{B04FAEF8-7D91-43A9-81C5-4BD3217B0C23}}.Test|x64.ActiveCfg = Test|x64
-		{{B04FAEF8-7D91-43A9-81C5-4BD3217B0C23}}.Test|x64.Build.0 = Test|x64
-		{{B04FAEF8-7D91-43A9-81C5-4BD3217B0C23}}.Release|x64.ActiveCfg = Release|x64
-		{{B04FAEF8-7D91-43A9-81C5-4BD3217B0C23}}.Release|x64.Build.0 = Release|x64
-		{{B04FAEF8-7D91-43A9-81C5-4BD3217B0C23}}.Debug|x64.ActiveCfg = Debug|x64
-		{{B04FAEF8-7D91-43A9-81C5-4BD3217B0C23}}.Debug|x64.Build.0 = Debug|x64
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {{117DD74B-A4DC-48CE-B782-C7AE565A9270}}
-	EndGlobalSection
-EndGlobal
-";
-
-        string solutionName = projectConfig.Name + ".sln";
-        string filePath = Path.Combine(path, solutionName);
-
-        File.WriteAllText(filePath, solution);
     }
 
-    // Inspirered by https://github.com/ProwlEngine/Prowl/blob/main/Prowl.Editor/Project.cs
+    private static void SetupDefaultFolders()
-    // Maybe the builder should do this?
-    // When compiling the 'runtimeAssembly.Location' needs to be updated to where ever the one is that is being used.
-    private static void GenerateCSProjectFiles(string path, ProjectConfig projectConfig)
     {
-        Log.Info("Generating CS project files");
+        if (Project == null || ProjectPath == null)
+        {
+            return;
+        }
 
-        Assembly[] loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
+        string contentPath = Path.Combine(ProjectPath, "Content");
-        Assembly runtimeAssembly = loadedAssemblies.FirstOrDefault(assembly => assembly.GetName().Name == "Nerfed.Runtime") ?? throw new Exception("Failed to find Runtime Assembly!");
-
-        string propertyGroup =
-$@"
-    <PropertyGroup>
-        <TargetFramework>net8.0</TargetFramework>
-        <ImplicitUsings>enable</ImplicitUsings>
-        <Nullable>disable</Nullable>
-        <PublishAot>true</PublishAot>
-        <InvariantGlobalization>true</InvariantGlobalization>
-        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-        <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
-        <IsPackable>false</IsPackable>
-        <Configurations>Debug;Test;Release</Configurations>
-        <Platforms>x64</Platforms>
-    </PropertyGroup>
-
-    <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>
-";
-
-        string runtimeProject =
-$@"
-<Project Sdk=""Microsoft.NET.Sdk"">
-    {propertyGroup}
-    
-	<ItemGroup>
-		<Compile Include=""/Content/Scripts/Runtime/**/*.cs""/>
-	</ItemGroup>
-
-    <ItemGroup>
-        <Reference Include=""Nerfed.Runtime"">
-            <HintPath>{runtimeAssembly.Location}</HintPath>
-            <Private>false</Private>
-        </Reference>
-    </ItemGroup>
-</Project>
-";
-
-        string runtimeProjectName = projectConfig.Name + ".Runtime.csproj";
-        string filePath = Path.Combine(path, runtimeProjectName);
-
-        File.WriteAllText(filePath, runtimeProject);
-
-        projectConfig.RuntimeProject = runtimeProjectName;
-        Log.Info($"Generated runtime at {filePath}");
-
-        // TODO: Editor project.
-    }
-
-    private static void SetupDefaultFolders(string path)
-    {
-        ProjectDirectory = path;
-
-        string contentPath = Path.Combine(path, "Content");
         if (!Directory.Exists(contentPath))
         {
             Directory.CreateDirectory(contentPath);
         }
-        ProjectContentDirectory = contentPath;
+        ProjectContentPath = contentPath;
-        string scriptsPath = Path.Combine(ProjectContentDirectory, "Scripts");
+        string scriptsPath = Path.Combine(ProjectContentPath, "Scripts");
         if (!Directory.Exists(scriptsPath))
         {
             Directory.CreateDirectory(scriptsPath);
@@ -240,11 +112,11 @@ private static void SetupDefaultFolders(string path)
             Directory.CreateDirectory(scriptsRuntimePath);
         }
 
-        string tempPath = Path.Combine(path, "Temp");
+        string tempPath = Path.Combine(ProjectPath, "Temp");
         if (!Directory.Exists(tempPath))
         {
             Directory.CreateDirectory(tempPath);
         }
-        ProjectTempDirectory = tempPath;
+        ProjectTempPath = tempPath;
     }
 }

Nerfed.Editor/Project/ProjectGui.cs

@@ -4,38 +4,64 @@ namespace Nerfed.Editor.Project
 {
     internal static class ProjectGui
     {
-        private static string projectDirectory = string.Empty;
+        private static string projectPath = 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 Path", ref projectPath, 512);
             ImGui.InputText("Project Name", ref projectName, 512);
 
+            string newProjectFilePath = Path.Combine(projectPath, ".project");
+            ImGui.Text(newProjectFilePath);
+
             if (ImGui.Button("Create Project"))
             {
-                Project.Create(projectDirectory, projectName);
+                EditorProject.Create(newProjectFilePath, projectName);
             }
 
-            if(ImGui.Button("Open Project"))
+            ImGui.EndGroup();
+            ImGui.BeginGroup();
+
+            ImGui.InputText("Project File Path", ref projectFilePath, 512);
+            if (ImGui.Button("Open Project"))
             {
-                Project.Open(projectDirectory);
+                EditorProject.Open(projectFilePath);
             }
 
             ImGui.Text("Loaded project: ");
-            if(Project.LoadedConfig != null)
+            if(EditorProject.Project != null)
             {
-                ImGui.Text(Project.LoadedConfig.Name);
+                ImGui.Text(EditorProject.Project.Name);
-                ImGui.Text(Project.LoadedConfig.Version.ToString());
+                ImGui.Text(EditorProject.ProjectFilePath);
-                ImGui.Text(Project.LoadedConfig.RuntimeProject);
+                ImGui.Text(EditorProject.ProjectSolutionFilePath);
+                ImGui.Text(EditorProject.ProjectPath);
+                ImGui.Text(EditorProject.ProjectContentPath);
+                ImGui.Text(EditorProject.ProjectTempPath);
             }
             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();
         }
     }