Fix backend compiling/loading mechanism

9 files changed, 222 insertions, 139 deletions

diff --git a/.clang-format b/.clang-format
index 2ba3906..a7c56d4 100644
--- a/.clang-format
+++ b/.clang-format
@@ -65,6 +65,8 @@ Cpp11BracedListStyle: false
 IncludeCategories:
   - Regex:           '".*"'
     Priority:        1
+  - Regex:           '^<glad/glad.h>'
+    Priority:        1
   - Regex:           '^<.*\.h>'
     Priority:        2
   - Regex:           '^<.*'
diff --git a/3rdparty/imgui/CMakeLists.txt b/3rdparty/imgui/CMakeLists.txt
index 3382d72..7f66b97 100644
--- a/3rdparty/imgui/CMakeLists.txt
+++ b/3rdparty/imgui/CMakeLists.txt
@@ -10,73 +10,13 @@ set(IMGUI_SOURCES
 	imstb_rectpack.h
 	imstb_textedit.h
 	imstb_truetype.h
-
-	# Since we only use GLFW to manage windows, application can't be built without GLFW
-	backend/imgui_impl_glfw.h
-	backend/imgui_impl_glfw.cpp
 )
 
-option(IMGUI_INCLUDE_OPENGL2_BACKEND ON)
-if(IMGUI_INCLUDE_OPENGL2_BACKEND)
-	message("ImGui: - building with OpenGL2 backend")
-	list(APPEND IMGUI_SOURCES
-		backend/imgui_impl_opengl2.h
-		backend/imgui_impl_opengl2.cpp
-	)
-endif()
-
-option(IMGUI_INCLUDE_OPENGL3_BACKEND ON)
-if(IMGUI_INCLUDE_OPENGL3_BACKEND)
-	message("ImGui: - building with OpenGL3 backend")
-	list(APPEND IMGUI_SOURCES
-		backend/imgui_impl_opengl3.h
-		backend/imgui_impl_opengl3.cpp
-	)
-endif()
-
-option(IMGUI_INCLUDE_VULKAN_BACKEND ON)
-if(IMGUI_INCLUDE_VULKAN_BACKEND)
-	message("ImGui: - building with Vulkan backend")
-	list(APPEND IMGUI_SOURCES
-		backend/imgui_impl_vulkan.h
-		backend/imgui_impl_vulkan.cpp
-	)
-endif()
-
-if(WIN32)
-	option(IMGUI_INCLUDE_DX11_BACKEND ON)
-	if(IMGUI_INCLUDE_DX11_BACKEND)
-		message("ImGui: - building with DirectX11 backend")
-		list(APPEND IMGUI_SOURCES
-		backend/imgui_impl_dx11.h
-		backend/imgui_impl_dx11.cpp
-		)
-	endif()
-
-	option(IMGUI_INCLUDE_DX12_BACKEND ON)
-	if(IMGUI_INCLUDE_DX12_BACKEND)
-		message("ImGui: - building with DirectX12 backend")
-		list(APPEND IMGUI_SOURCES
-		backend/imgui_impl_dx12.h
-		backend/imgui_impl_dx12.cpp
-		)
-	endif()
-elseif(APPLE)
-	option(IMGUI_INCLUDE_METAL_BACKEND ON)
-	if(IMGUI_INCLUDE_METAL_BACKEND)
-		message("ImGui: - building with Metal backend")
-		list(APPEND IMGUI_SOURCES
-			backend/imgui_impl_metal.h
-			backend/imgui_impl_metal.mm
-		)
-	endif()
-endif()
+# We don't build the files in backend/ because they are included by various entrypoint implementations
+# depending on build flags. Technically it is possible to write then here too, but doing so would require repeating
+# the build flags twice both in here and in core/CMakeLists.txt
 
 add_library(imgui ${IMGUI_SOURCES})
-target_compile_definitions(imgui
-PRIVATE
-	IMGUI_IMPL_OPENGL_LOADER_GLAD=1
-)
 target_include_directories(imgui
 PRIVATE
 	${CMAKE_SOURCE_DIR}/3rdparty/imgui
diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
index 0eb4900..a8386b2 100644
--- a/core/CMakeLists.txt
+++ b/core/CMakeLists.txt
@@ -1,7 +1,19 @@
+# We use a custom flag instead of letting user set CMAKE_UNITY_BUILD because we don't want stuff in 3rdparty to be built with unity build
+# (they may not support them, and configuring each is very time consuming)
 option(BUILD_CORE_WITH_UNITY_BUILD OFF)
 option(BUILD_CORE_MAIN "Whether to compile the main executable or not." ON)
 option(BUILD_CORE_TESTS "Whether to compile the tests executable or not." OFF)
 
+option(BUILD_CORE_WITH_OPENGL2_BACKEND ON)
+option(BUILD_CORE_WITH_OPENGL3_BACKEND ON)
+option(BUILD_CORE_WITH_VULKAN_BACKEND ON)
+if(WIN32)
+	option(BUILD_CORE_WITH_DX11_BACKEND ON)
+	option(BUILD_CORE_WITH_DX12_BACKEND ON)
+elseif(APPLE)
+	option(BUILD_CORE_WITH_METAL_BACKEND ON)
+endif()
+
 function(add_source_group GROUP_NAME GROUP_SOURCES)
 	set(${GROUP_NAME} ${GROUP_SOURCES})
 	set_source_files_properties(${GROUP_SOURCES}
@@ -28,6 +40,19 @@ set(ENTRYPOINT_MODULE_SOURCES
 	src/Entrypoint/Metal.mm
 )
 
+# macro(option_with_message OPTION_NAME DEFAULT_VALUE MESSAGE)
+# 	option(${OPTION_NAME} ${DEFAULT_VALUE})
+# 	if(${OPTION_NAME})
+# 		message(${MESSAGE})
+# 	endif()
+# endmacro()
+# option_with_message(BUILD_CORE_WITH_OPENGL2_BACKEND ON "Building with OpenGL2 backend")
+# option_with_message(BUILD_CORE_WITH_OPENGL3_BACKEND ON "Building with OpenGL3 backend")
+# option_with_message(BUILD_CORE_WITH_VULKAN_BACKEND ON "Building with Vulkan backend")
+# option_with_message(BUILD_CORE_WITH_DX11_BACKEND ON "Building with DirectX11 backend")
+# option_with_message(BUILD_CORE_WITH_DX12_BACKEND ON "Building with DirectX12 backend")
+# option_with_message(BUILD_CORE_WITH_METAL_BACKEND ON "Building with Metal backend")
+
 add_source_group(UI_MODULE_SOURCES
 	src/UI/Export.hpp
 	src/UI/Export.cpp
@@ -91,14 +116,50 @@ function(add_executable_variant TARGET_NAME)
 		PLATFORM_WIN32=$<BOOL:${WIN32}>
 		PLATFORM_MACOS=$<BOOL:${APPLE}>
 		PLATFORM_LINUX=$<BOOL:${LINUX}>
-		IMGUI_INCLUDE_OPENGL2_BACKEND=$<BOOL:${IMGUI_INCLUDE_OPENGL2_BACKEND}>
-		IMGUI_INCLUDE_OPENGL3_BACKEND=$<BOOL:${IMGUI_INCLUDE_OPENGL3_BACKEND}>
-		IMGUI_INCLUDE_VULKAN_BACKEND=$<BOOL:${IMGUI_INCLUDE_VULKAN_BACKEND}>
-		IMGUI_INCLUDE_DX11_BACKEND=$<BOOL:${IMGUI_INCLUDE_DX11_BACKEND}>
-		IMGUI_INCLUDE_DX12_BACKEND=$<BOOL:${IMGUI_INCLUDE_DX12_BACKEND}>
-		IMGUI_INCLUDE_METAL_BACKEND=$<BOOL:${IMGUI_INCLUDE_METAL_BACKEND}>
 	)
 
+	if(WIN32)
+		message("CpltCore: - building with DirectX11 backend ${BUILD_CORE_WITH_DX11_BACKEND}")
+		message("CpltCore: - building with DirectX12 backend ${BUILD_CORE_WITH_DX12_BACKEND}")
+		target_compile_definitions(${TARGET_NAME}
+		PRIVATE
+			BUILD_CORE_WITH_DX11_BACKEND=$<BOOL:${BUILD_CORE_WITH_DX11_BACKEND}>
+			BUILD_CORE_WITH_DX12_BACKEND=$<BOOL:${BUILD_CORE_WITH_DX12_BACKEND}>
+		)
+	else()
+		target_compile_definitions(${TARGET_NAME}
+		PRIVATE
+			BUILD_CORE_WITH_DX11_BACKEND=0
+			BUILD_CORE_WITH_DX12_BACKEND=0
+		)
+	endif()
+
+	if(APPLE)
+		message("CpltCore: - building with Metal backend ${BUILD_CORE_WITH_METAL_BACKEND}")
+		target_compile_definitions(${TARGET_NAME}
+		PRIVATE
+			BUILD_CORE_WITH_METAL_BACKEND=$<BOOL:${BUILD_CORE_WITH_METAL_BACKEND}>
+		)
+	else()
+		target_compile_definitions(${TARGET_NAME}
+		PRIVATE
+			BUILD_CORE_WITH_METAL_BACKEND=0
+		)
+	endif()
+
+	if(NOT APPLE)
+		message("CpltCore: - building with OpenGL2 backend ${BUILD_CORE_WITH_OPENGL2_BACKEND}")
+		message("CpltCore: - building with OpenGL3 backend ${BUILD_CORE_WITH_OPENGL3_BACKEND}")
+		message("CpltCore: - building with Vulkan backend ${BUILD_CORE_WITH_VULKAN_BACKEND}")
+		target_compile_definitions(${TARGET_NAME}
+		PRIVATE
+			BUILD_CORE_WITH_OPENGL2_BACKEND=$<BOOL:${BUILD_CORE_WITH_OPENGL2_BACKEND}>
+			BUILD_CORE_WITH_OPENGL3_BACKEND=$<BOOL:${BUILD_CORE_WITH_OPENGL3_BACKEND}>
+			BUILD_CORE_WITH_VULKAN_BACKEND=$<BOOL:${BUILD_CORE_WITH_VULKAN_BACKEND}>
+		)
+	endif()
+
+	# Platform specific dependencies for Utils/Dialog, not covered by conan
 	if(APPLE)
 		target_link_libraries(${TARGET_NAME} PUBLIC ${COCOA_LIBRARY})
 	elseif(LINUX)
@@ -106,8 +167,8 @@ function(add_executable_variant TARGET_NAME)
 		target_include_directories(${TARGET_NAME} PRIVATE ${GTK3_INCLUDE_DIRS})
 	endif()
 
-	# No console window when targetting windows
 	if(WIN32)
+		# No console window when targetting windows
 		if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
 			# Supposedly the flag -mwindows would automatically make the executable use GUI subsystem
 			# But, when subsystem is set to GUI, linker will only search WinMain and wWinMain but not the standard main (it seems like)
diff --git a/core/src/Entrypoint/Common.cpp b/core/src/Entrypoint/Common.cpp
index 62baf9d..c949830 100644
--- a/core/src/Entrypoint/Common.cpp
+++ b/core/src/Entrypoint/Common.cpp
@@ -1,11 +1,14 @@
 #include "Common.hpp"
 
+#include <backend/imgui_impl_glfw.h>
 #include <iostream>
 
+#include <backend/imgui_impl_glfw.cpp>
+
 GLFWwindow* RenderingBackend::GetWindow() const {
-    return mWindow;
+	return mWindow;
 }
 
 void RenderingBackend::GlfwErrorCallback(int error, const char* message) {
-    std::cerr << "GLFW Error " << error << ": " << message << "\n";
+	std::cerr << "GLFW Error " << error << ": " << message << "\n";
 }
diff --git a/core/src/Entrypoint/Common.hpp b/core/src/Entrypoint/Common.hpp
index 2a4dcbf..216c885 100644
--- a/core/src/Entrypoint/Common.hpp
+++ b/core/src/Entrypoint/Common.hpp
@@ -1,7 +1,6 @@
 #pragma once
 
 #include <glad/glad.h>
- 
 #include <GLFW/glfw3.h>
 
 class RenderingBackend {
diff --git a/core/src/Entrypoint/OpenGL2.cpp b/core/src/Entrypoint/OpenGL2.cpp
index de13a02..216399e 100644
--- a/core/src/Entrypoint/OpenGL2.cpp
+++ b/core/src/Entrypoint/OpenGL2.cpp
@@ -1,15 +1,17 @@
 #include "OpenGL2.hpp"
 
-#include <glad/glad.h>
+#if BUILD_CORE_WITH_OPENGL2_BACKEND
+#	include <glad/glad.h>
+#	include <GLFW/glfw3.h>
+#	include <backend/imgui_impl_glfw.h>
+#	include <backend/imgui_impl_opengl2.h>
+#	include <imgui.h>
+#	include <stdexcept>
 
-#include <GLFW/glfw3.h>
-#include <backend/imgui_impl_glfw.h>
-#include <backend/imgui_impl_opengl2.h>
-#include <imgui.h>
-#include <stdexcept>
+#	define IMGUI_IMPL_OPENGL_LOADER_GLAD
+#	include <backend/imgui_impl_opengl2.cpp>
 
 OpenGL2Backend::OpenGL2Backend() {
-#if IMGUI_INCLUDE_OPENGL2_BACKEND
 	glfwSetErrorCallback(GlfwErrorCallback);
 	if (!glfwInit()) {
 		throw std::runtime_error("Failed to initialize GLFW.");
@@ -31,9 +33,6 @@ OpenGL2Backend::OpenGL2Backend() {
 
 	ImGui_ImplGlfw_InitForOpenGL(mWindow, true);
 	ImGui_ImplOpenGL2_Init();
-#else
-	throw std::runtime_error("Backend opengl2 is not available in this build.\n");
-#endif
 }
 
 OpenGL2Backend::~OpenGL2Backend() {
@@ -68,3 +67,21 @@ void OpenGL2Backend::EndFrame() {
 	glfwMakeContextCurrent(mWindow);
 	glfwSwapBuffers(mWindow);
 }
+
+#else // ^^ BUILD_CORE_WITH_OPENGL2_BACKEND | !BUILD_CORE_WITH_OPENGL2_BACKEND vv
+#	include <stdexcept>
+
+OpenGL2Backend::OpenGL2Backend() {
+	throw std::runtime_error("Backend opengl2 is not available in this build.\n");
+}
+
+OpenGL2Backend::~OpenGL2Backend() {
+}
+
+void OpenGL2Backend::BeginFrame() {
+}
+
+void OpenGL2Backend::EndFrame() {
+}
+
+#endif
diff --git a/core/src/Entrypoint/OpenGL3.cpp b/core/src/Entrypoint/OpenGL3.cpp
index c1f66d5..7d5cae1 100644
--- a/core/src/Entrypoint/OpenGL3.cpp
+++ b/core/src/Entrypoint/OpenGL3.cpp
@@ -1,15 +1,17 @@
 #include "OpenGL3.hpp"
 
-#include <glad/glad.h>
+#if BUILD_CORE_WITH_OPENGL3_BACKEND
+#	include <glad/glad.h>
+#	include <GLFW/glfw3.h>
+#	include <backend/imgui_impl_glfw.h>
+#	include <backend/imgui_impl_opengl3.h>
+#	include <imgui.h>
+#	include <stdexcept>
 
-#include <GLFW/glfw3.h>
-#include <backend/imgui_impl_glfw.h>
-#include <backend/imgui_impl_opengl3.h>
-#include <imgui.h>
-#include <stdexcept>
+#	define IMGUI_IMPL_OPENGL_LOADER_GLAD
+#	include <backend/imgui_impl_opengl3.cpp>
 
 OpenGL3Backend::OpenGL3Backend() {
-#if IMGUI_INCLUDE_OPENGL3_BACKEND
 	glfwSetErrorCallback(GlfwErrorCallback);
 	if (!glfwInit()) {
 		throw std::runtime_error("Failed to initialize GLFW.");
@@ -47,9 +49,6 @@ OpenGL3Backend::OpenGL3Backend() {
 
 	ImGui_ImplGlfw_InitForOpenGL(mWindow, true);
 	ImGui_ImplOpenGL3_Init(glslVersion);
-#else
-	throw std::runtime_error("Backend opengl3 is not available in this build.\n");
-#endif
 }
 
 OpenGL3Backend::~OpenGL3Backend() {
@@ -83,3 +82,21 @@ void OpenGL3Backend::EndFrame() {
 
 	glfwSwapBuffers(mWindow);
 }
+
+#else // ^^ BUILD_CORE_WITH_OPENGL3_BACKEND | !BUILD_CORE_WITH_OPENGL3_BACKEND vv
+#	include <stdexcept>
+
+OpenGL3Backend::OpenGL3Backend() {
+	throw std::runtime_error("Backend opengl3 is not available in this build.\n");
+}
+
+OpenGL3Backend::~OpenGL3Backend() {
+}
+
+void OpenGL3Backend::BeginFrame() {
+}
+
+void OpenGL3Backend::EndFrame() {
+}
+
+#endif
diff --git a/core/src/Entrypoint/OpenGL3.hpp b/core/src/Entrypoint/OpenGL3.hpp
index 29086a2..52978fa 100644
--- a/core/src/Entrypoint/OpenGL3.hpp
+++ b/core/src/Entrypoint/OpenGL3.hpp
@@ -3,7 +3,6 @@
 #include "Entrypoint/Common.hpp"
 
 #include <glad/glad.h>
-
 #include <GLFW/glfw3.h>
 
 class OpenGL3Backend : public RenderingBackend {
diff --git a/core/src/Entrypoint/main.cpp b/core/src/Entrypoint/main.cpp
index 3adf757..b82214d 100644
--- a/core/src/Entrypoint/main.cpp
+++ b/core/src/Entrypoint/main.cpp
@@ -13,9 +13,98 @@
 #include <argparse/argparse.hpp>
 #include <iostream>
 #include <memory>
+#include <stdexcept>
 #include <string>
+#include <string_view>
 
 using namespace std::literals::string_literals;
+using namespace std::literals::string_view_literals;
+
+static std::unique_ptr<RenderingBackend> CreateDefaultBackend() {
+#if PLATFORM_WIN32
+#	if BUILD_CORE_WITH_DX12_BACKEND
+	try {
+		auto backend = std::make_unique<DirectX12Backend>();
+		return backend;
+	} catch (const std::exception&) {
+	}
+#	elif BUILD_CORE_WITH_DX11_BACKEND
+	try {
+		auto backend = std::make_unique<DirectX11Backend>();
+		return backend;
+	} catch (const std::exception&) {
+	}
+#	elif BUILD_CORE_WITH_VULKAN_BACKEND
+	try {
+		auto backend = std::make_unique<VulkanBackend>();
+		return backend;
+	} catch (const std::exception&) {
+	}
+#	elif BUILD_CORE_WITH_OPENGL3_BACKEND
+	try {
+		auto backend = std::make_unique<OpenGL3Backend>();
+		return backend;
+	} catch (const std::exception&) {
+	}
+#	elif BUILD_CORE_WITH_OPENGL2_BACKEND
+	try {
+		auto backend = std::make_unique<OpenGL2Backend>();
+		return backend;
+	} catch (const std::exception&) {
+	}
+#	endif
+#elif PLATFORM_MACOS
+	// We currently only support using metal on macos
+	backend = std::make_unique<MetalBackend>();
+#elif PLATFORM_LINUX
+#	if BUILD_CORE_WITH_VULKAN_BACKEND
+	try {
+		auto backend = std::make_unique<VulkanBackend>();
+		return backend;
+	} catch (const std::exception&) {
+	}
+#	elif BUILD_CORE_WITH_OPENGL3_BACKEND
+	try {
+		auto backend = std::make_unique<OpenGL3Backend>();
+		return backend;
+	} catch (const std::exception&) {
+	}
+#	elif BUILD_CORE_WITH_OPENGL2_BACKEND
+	try {
+		auto backend = std::make_unique<OpenGL2Backend>();
+		return backend;
+	} catch (const std::exception&) {
+	}
+#	endif
+#endif
+
+	return nullptr;
+}
+
+static std::unique_ptr<RenderingBackend> CreateBackend(std::string_view option) {
+	if (option == "default") {
+		return CreateDefaultBackend();
+	} else if (option == "opengl2") {
+		return std::make_unique<OpenGL2Backend>();
+	} else if (option == "opengl3") {
+		return std::make_unique<OpenGL3Backend>();
+	} else if (option == "vulkan") {
+		return std::make_unique<VulkanBackend>();
+	} else if (option == "dx11") {
+		return std::make_unique<DirectX11Backend>();
+	} else if (option == "dx12") {
+		return std::make_unique<DirectX12Backend>();
+	} else if (option == "metal") {
+		return std::make_unique<MetalBackend>();
+	} else {
+		std::string message;
+		message += "Unknown backend '";
+		message += option;
+		message += "'.\n";
+		throw std::runtime_error(message);
+		return nullptr;
+	}
+}
 
 int main(int argc, char* argv[]) {
 	argparse::ArgumentParser parser;
@@ -31,59 +120,15 @@ int main(int argc, char* argv[]) {
 		return -1;
 	}
 
-	std::unique_ptr<RenderingBackend> backend;
 	auto backendOption = parser.get<std::string>("--rendering-backend");
-	if (backendOption == "default") {
-		// TODO better api selection mechanism, use lower tier if higher tier is unavilable instead of bailing
-#if PLATFORM_WIN32
-#	if IMGUI_INCLUDE_DX12_BACKEND
-		backend = std::make_unique<DirectX12Backend>();
-#	elif IMGUI_INCLUDE_DX11_BACKEND
-		backend = std::make_unique<DirectX11Backend>();
-#	elif IMGUI_INCLUDE_VULKAN_BACKEND
-		backend = std::make_unique<VulkanBackend>();
-#	elif IMGUI_INCLUDE_OPENGL3_BACKEND
-		backend = std::make_unique<OpenGL3Backend>();
-#	elif IMGUI_INCLUDE_OPENGL2_BACKEND
-		backend = std::make_unique<OpenGL2Backend>();
-#	endif
-#elif PLATFORM_MACOS
-		backend = std::make_unique<MetalBackend>();
-#elif PLATFORM_LINUX
-#	if IMGUI_INCLUDE_VULKAN_BACKEND
-		backend = std::make_unique<VulkanBackend>();
-// #	elif IMGUI_INCLUDE_OPENGL3_BACKEND
-// 		backend = std::make_unique<OpenGL3Backend>();
-#	elif IMGUI_INCLUDE_OPENGL2_BACKEND
-		backend = std::make_unique<OpenGL2Backend>();
-#	endif
-#endif
-	} else if (backendOption == "opengl2") {
-		backend = std::make_unique<OpenGL2Backend>();
-	} else if (backendOption == "opengl3") {
-		backend = std::make_unique<OpenGL3Backend>();
-	} else if (backendOption == "vulkan") {
-		backend = std::make_unique<VulkanBackend>();
-	} else if (backendOption == "dx11") {
-		backend = std::make_unique<DirectX11Backend>();
-	} else if (backendOption == "dx12") {
-		backend = std::make_unique<DirectX12Backend>();
-	} else if (backendOption == "metal") {
-		backend = std::make_unique<MetalBackend>();
-	} else {
-		std::cout << "Unknown backend '" << backendOption << "'.\n";
-		return -1;
-	}
+	auto backend = CreateBackend(backendOption);
 
 	auto& io = ImGui::GetIO();
 	io.Fonts->AddFontFromFileTTF("fonts/NotoSansSC-Regular.otf", 18, nullptr, io.Fonts->GetGlyphRangesChineseSimplifiedCommon());
 
 	auto window = backend->GetWindow();
-	bool showDemo = true;
 	while (!glfwWindowShouldClose(window)) {
 		backend->BeginFrame();
-		if (showDemo)
-			ImGui::ShowDemoWindow(&showDemo);
 		backend->EndFrame();
 	}