feature: export Runtime to Distribution

.github/workflows/main.yml

@@ -83,7 +83,7 @@ jobs:
           $editorItems = @(
             "imgui.ini",
             "App.lsettings",
-            "SandboxProject",
+            "LuxSampleProject",
             "Resources",
             "mono"
           )

.gitignore

@@ -13,6 +13,7 @@ Intermediates/
 **.vcxproj.filters
 **.vcxproj.user
 **.csproj
+**.csproj.user
 
 # Directories
 scripts/__pycache__
@@ -25,8 +26,11 @@ Sandbox/Resources/Cache
 Core/vendor/GLAD
 Core/vendor/NFD-Extended
 Core/vendor/tracy
-Editor/SandboxProject/Assets/Scripts/Binaries
+Editor/LuxSampleProject/Assets/Scripts/Binaries
 Editor/Resources/Cache
 Lux.slnx
-Editor/SandboxProject/Assets/Cache/Thumbnails
-Editor/SandboxProject/Assets/AssetRegistry.lzr
+Editor/LuxSampleProject/Assets/Cache/Thumbnails
+Editor/LuxSampleProject/Assets/AssetRegistry.lzr
+*.lap
+*.aps
+*.slnx

Core/Source/Lux/Asset/MeshSerializer.cpp

@@ -1,13 +1,16 @@
 #include "lpch.h"
 #include "MeshSerializer.h"
 
-#include "AssimpMeshImporter.h"
 #include "MeshRuntimeSerializer.h"
 
 #include "Lux/Asset/AssetManager.h"
 #include "Lux/Project/Project.h"
 #include "Lux/Renderer/Mesh.h"
 
+#ifndef LUX_DIST
+#include "AssimpMeshImporter.h"
+#endif
+
 #include <fstream>
 #include <sstream>
 
@@ -148,6 +151,10 @@ namespace Lux
 
 	bool MeshSourceSerializer::TryLoadData(const AssetMetadata& metadata, Ref<Asset>& asset) const
 	{
+#ifdef LUX_DIST
+		LUX_CORE_ERROR("MeshSourceSerializer cannot import source meshes in Dist builds: {}", metadata.FilePath.string());
+		return false;
+#else
 		AssimpMeshImporter importer(Project::GetEditorAssetManager()->GetFileSystemPath(metadata));
 		Ref<MeshSource> meshSource = importer.ImportToMeshSource();
 		if (!meshSource)
@@ -156,6 +163,7 @@ namespace Lux
 		meshSource->Handle = metadata.Handle;
 		asset = meshSource;
 		return true;
+#endif
 	}
 
 	bool MeshSourceSerializer::SerializeToAssetPack(AssetHandle handle, FileStreamWriter& stream, AssetSerializationInfo& outInfo) const

Core/Source/Lux/Asset/TextureSerializer.cpp

@@ -6,6 +6,7 @@
 #include "Lux/Renderer/SceneEnvironment.h"
 #include "Lux/Serialization/TextureRuntimeSerializer.h"
 #include "Lux/Project/Project.h"
+#include "Lux/Utilities/FileSystem.h"
 
 #include <filesystem>
 
@@ -88,12 +89,17 @@ namespace Lux
 
 		if (AssetManager::GetAssetType(handle) == AssetType::EnvMap)
 		{
-			Ref<Environment> environment = AssetManager::GetAsset<Environment>(handle);
-			if (!environment || !environment->RadianceMap || !environment->IrradianceMap)
+			auto assetManager = Project::GetEditorAssetManager();
+			if (!assetManager)
 				return false;
 
-			TextureRuntimeSerializer::SerializeToFile(environment->RadianceMap, stream);
-			TextureRuntimeSerializer::SerializeToFile(environment->IrradianceMap, stream);
+			const AssetMetadata metadata = assetManager->GetMetadata(handle);
+			Buffer sourceBuffer = FileSystem::ReadBytes(assetManager->GetFileSystemPath(metadata));
+			if (!sourceBuffer)
+				return false;
+
+			stream.WriteBuffer(sourceBuffer);
+			sourceBuffer.Release();
 			outInfo.Size = stream.GetStreamPosition() - outInfo.Offset;
 			return true;
 		}
@@ -113,8 +119,24 @@ namespace Lux
 		const AssetType assetType = (AssetType)assetInfo.Type;
 		if (assetType == AssetType::EnvMap)
 		{
-			Ref<TextureCube> radiance = TextureRuntimeSerializer::DeserializeTextureCube(stream);
-			Ref<TextureCube> irradiance = TextureRuntimeSerializer::DeserializeTextureCube(stream);
+			Buffer sourceBuffer;
+			stream.ReadBuffer(sourceBuffer);
+			if (!sourceBuffer)
+				return nullptr;
+
+			TextureSpecification equirectSpec;
+			equirectSpec.DebugName = "PackedEnvEquirect";
+			equirectSpec.FlipVertically = false;
+			equirectSpec.Width = (uint32_t)sourceBuffer.Size;
+			equirectSpec.Height = 0;
+
+			Ref<Texture2D> equirectTexture = Texture2D::Create(equirectSpec, sourceBuffer);
+			sourceBuffer.Release();
+
+			if (!equirectTexture || !equirectTexture->Loaded())
+				return nullptr;
+
+			auto [radiance, irradiance] = Renderer::CreateEnvironmentMap(equirectTexture);
 			if (!radiance || !irradiance)
 				return nullptr;
 

Core/Source/Lux/Core/Application.cpp

@@ -88,6 +88,7 @@ namespace Lux {
 		else
 			m_Window->CenterWindow();
 		m_Window->SetResizable(specification.Resizable);
+		m_Window->Show();
 
 		if (m_Specification.EnableImGui)
 		{

Core/Source/Lux/Core/Window.cpp

@@ -513,6 +513,11 @@ namespace Lux {
 		glfwSetWindowPos(m_WindowHandle, x, y);
 	}
 
+	void Window::Show()
+	{
+		glfwShowWindow(m_WindowHandle);
+	}
+
 	void Window::SetTitle(const std::string& title)
 	{
 		m_Data.Title = title;

Core/Source/Lux/Core/Window.h

@@ -57,6 +57,7 @@ namespace Lux {
 
 		virtual void Maximize();
 		virtual void CenterWindow();
+		virtual void Show();
 
 		virtual const std::string& GetTitle() const { return m_Data.Title; }
 		virtual void SetTitle(const std::string& title);

Core/Source/Lux/Project/Project.cpp

@@ -8,6 +8,27 @@
 
 namespace Lux
 {
+	const char* RuntimeExportTargetToString(RuntimeExportTarget target)
+	{
+		switch (target)
+		{
+			case RuntimeExportTarget::Debug: return "Debug";
+			case RuntimeExportTarget::Release: return "Release";
+			case RuntimeExportTarget::Dist: return "Dist";
+		}
+
+		return "Release";
+	}
+
+	RuntimeExportTarget RuntimeExportTargetFromString(std::string_view value)
+	{
+		if (value == "Debug" || value == "0")
+			return RuntimeExportTarget::Debug;
+		if (value == "Dist" || value == "2")
+			return RuntimeExportTarget::Dist;
+		return RuntimeExportTarget::Release;
+	}
+
 	std::filesystem::path Project::GetAssetAbsolutePath(const std::filesystem::path& path) const
 	{
 		return GetAssetDirectory() / path;
@@ -50,6 +71,15 @@ namespace Lux
 				s_ActiveProject->m_Config.StartScene = startSceneMetadata.FilePath.generic_string();
 		}
 
+		if (!s_ActiveProject->m_Config.RuntimeExport.IconPath.empty())
+			s_ActiveProject->m_Config.RuntimeExport.IconHandle = GetEditorAssetManager()->GetAssetHandleFromFilePath(s_ActiveProject->m_Config.RuntimeExport.IconPath);
+		else if (s_ActiveProject->m_Config.RuntimeExport.IconHandle)
+		{
+			AssetMetadata iconMetadata = GetEditorAssetManager()->GetMetadata(s_ActiveProject->m_Config.RuntimeExport.IconHandle);
+			if (iconMetadata.IsValid())
+				s_ActiveProject->m_Config.RuntimeExport.IconPath = iconMetadata.FilePath.generic_string();
+		}
+
 		if (!AudioEngine::HasInitializedEngine())
 		{
 			AudioEngine::Init();
@@ -66,13 +96,31 @@ namespace Lux
 		}
 
 		s_ActiveProject = project;
+		if (AudioEngine::HasInitializedEngine())
+		{
+			AudioEngine::Shutdown();
+			AudioEngine::SetInitalizedEngine(false);
+		}
+
 		if (!s_ActiveProject)
 			return;
 
+		if (s_ActiveProject->m_ProjectDirectory.empty())
+			s_ActiveProject->m_ProjectDirectory = s_ActiveProject->m_Config.ProjectDirectory;
+		if (s_ActiveProject->m_ProjectFilePath.empty() && !s_ActiveProject->m_ProjectDirectory.empty())
+			s_ActiveProject->m_ProjectFilePath = s_ActiveProject->m_ProjectDirectory / s_ActiveProject->m_Config.ProjectFileName;
+
 		s_ActiveProject->m_Config.ProjectDirectory = s_ActiveProject->m_ProjectDirectory;
 		s_ActiveProject->m_Config.ProjectFileName = s_ActiveProject->m_ProjectFilePath.filename().string();
+
 		s_AssetManager = Ref<RuntimeAssetManager>::Create();
 		GetRuntimeAssetManager()->SetAssetPack(assetPack);
+
+		if (!AudioEngine::HasInitializedEngine())
+		{
+			AudioEngine::Init();
+			AudioEngine::SetInitalizedEngine(true);
+		}
 	}
 
 	Ref<Project> Project::New()
@@ -83,6 +131,23 @@ namespace Lux
 		return s_ActiveProject;
 	}
 
+	Ref<Project> Project::LoadRuntime(const std::filesystem::path& path, Ref<AssetPack> assetPack)
+	{
+		Ref<Project> project = Ref<Project>::Create();
+
+		ProjectSerializer serializer(project);
+		if (!serializer.DeserializeRuntime(path))
+			return nullptr;
+
+		project->m_ProjectFilePath = path.lexically_normal();
+		project->m_ProjectDirectory = path.parent_path();
+		project->m_Config.ProjectDirectory = project->m_ProjectDirectory;
+		project->m_Config.ProjectFileName = project->m_ProjectFilePath.filename().string();
+
+		SetActiveRuntime(project, assetPack);
+		return s_ActiveProject;
+	}
+
 	Ref<Project> Project::Load(const std::filesystem::path& path)
 	{
 		Ref<Project> project = Ref<Project>::Create();
@@ -106,6 +171,9 @@ namespace Lux
 		if (!s_ActiveProject->m_Config.StartScene.empty() && GetEditorAssetManager())
 			s_ActiveProject->m_Config.StartSceneHandle = GetEditorAssetManager()->GetAssetHandleFromFilePath(s_ActiveProject->m_Config.StartScene);
 
+		if (!s_ActiveProject->m_Config.RuntimeExport.IconPath.empty() && GetEditorAssetManager())
+			s_ActiveProject->m_Config.RuntimeExport.IconHandle = GetEditorAssetManager()->GetAssetHandleFromFilePath(s_ActiveProject->m_Config.RuntimeExport.IconPath);
+
 		if (s_ActiveProject->m_Config.DefaultNamespace.empty())
 			s_ActiveProject->m_Config.DefaultNamespace = s_ActiveProject->m_Config.Name;
 
@@ -132,5 +200,8 @@ namespace Lux
 
 		if (m_Config.ScriptModulePath.empty())
 			m_Config.ScriptModulePath = std::filesystem::path("Scripts/Binaries") / (m_Config.Name + ".dll");
+
+		if (m_Config.RuntimeExport.GameName.empty())
+			m_Config.RuntimeExport.GameName = m_Config.Name;
 	}
 }

Core/Source/Lux/Project/Project.h

@@ -26,6 +26,16 @@ namespace Lux
 		CaptureToFile = 1
 	};
 
+	enum class RuntimeExportTarget : uint8_t
+	{
+		Debug = 0,
+		Release = 1,
+		Dist = 2
+	};
+
+	const char* RuntimeExportTargetToString(RuntimeExportTarget target);
+	RuntimeExportTarget RuntimeExportTargetFromString(std::string_view value);
+
 	struct ProjectAudioSettings
 	{
 		double FileStreamingDurationThreshold = 1.0;
@@ -110,6 +120,18 @@ namespace Lux
 		float SSRDepthTolerance = 0.8f;
 	};
 
+	struct ProjectRuntimeExportSettings
+	{
+		std::string GameName;
+		uint32_t WindowWidth = 1920;
+		uint32_t WindowHeight = 1080;
+		bool Fullscreen = false;
+		bool VSync = true;
+		std::filesystem::path IconPath;
+		AssetHandle IconHandle = 0;
+		RuntimeExportTarget TargetConfig = RuntimeExportTarget::Release;
+	};
+
 	struct ProjectConfig
 	{
 		std::string Name = "Untitled";
@@ -137,6 +159,7 @@ namespace Lux
 		ProjectAudioSettings Audio;
 		ProjectPhysicsSettings Physics;
 		ProjectSceneRendererSettings SceneRenderer;
+		ProjectRuntimeExportSettings RuntimeExport;
 	};
 
 	class Project : public RefCounted
@@ -291,6 +314,7 @@ namespace Lux
 
 		static Ref<Project> New();
 		static Ref<Project> Load(const std::filesystem::path& path);
+		static Ref<Project> LoadRuntime(const std::filesystem::path& path, Ref<AssetPack> assetPack);
 		static bool SaveActive(const std::filesystem::path& path);
 
 	private:

Core/Source/Lux/Project/ProjectRuntimeFormat.h

@@ -11,7 +11,7 @@ namespace Lux
 		struct FileHeader
 		{
 			char Header[4] = { 'L', 'P', 'R', 'J' };
-			uint32_t Version = 8;
+			uint32_t Version = 9;
 		};
 
 		struct Audio