Move GraphicsConfig back to ultramodern

ultramodern/include/ultramodern/config.hpp

@@ -0,0 +1,135 @@
+#ifndef __CONFIG_HPP__
+#define __CONFIG_HPP__
+
+#include <string>
+#include <optional>
+
+#include "json/json.hpp"
+
+namespace ultramodern {
+    namespace renderer {
+        enum class Resolution {
+            Original,
+            Original2x,
+            Auto,
+            OptionCount
+        };
+        enum class WindowMode {
+            Windowed,
+            Fullscreen,
+            OptionCount
+        };
+        enum class HUDRatioMode {
+            Original,
+            Clamp16x9,
+            Full,
+            OptionCount
+        };
+        enum class GraphicsApi {
+            Auto,
+            D3D12,
+            Vulkan,
+            OptionCount
+        };
+        enum class AspectRatio {
+            Original,
+            Expand,
+            Manual,
+            OptionCount
+        };
+        enum class Antialiasing {
+            None,
+            MSAA2X,
+            MSAA4X,
+            MSAA8X,
+            OptionCount
+        };
+        enum class RefreshRate {
+            Original,
+            Display,
+            Manual,
+            OptionCount
+        };
+        enum class HighPrecisionFramebuffer {
+            Auto,
+            On,
+            Off,
+            OptionCount
+        };
+
+        class GraphicsConfig {
+        public:
+            bool developer_mode;
+            Resolution res_option;
+            WindowMode wm_option;
+            HUDRatioMode hr_option;
+            GraphicsApi api_option;
+            AspectRatio ar_option;
+            Antialiasing msaa_option;
+            RefreshRate rr_option;
+            HighPrecisionFramebuffer hpfb_option;
+            int rr_manual_value;
+            int ds_option;
+
+            virtual ~GraphicsConfig();
+
+            virtual std::string get_graphics_api_name() const;
+            virtual std::optional<uint32_t> get_target_framerate(uint32_t original) const;
+
+            auto operator<=>(const GraphicsConfig& rhs) const = default;
+        };
+
+        const GraphicsConfig& get_graphics_config();
+        void set_graphics_config(const GraphicsConfig& new_config);
+
+        NLOHMANN_JSON_SERIALIZE_ENUM(ultramodern::renderer::Resolution, {
+            {ultramodern::renderer::Resolution::Original, "Original"},
+            {ultramodern::renderer::Resolution::Original2x, "Original2x"},
+            {ultramodern::renderer::Resolution::Auto, "Auto"},
+        });
+
+        NLOHMANN_JSON_SERIALIZE_ENUM(ultramodern::renderer::WindowMode, {
+            {ultramodern::renderer::WindowMode::Windowed, "Windowed"},
+            {ultramodern::renderer::WindowMode::Fullscreen, "Fullscreen"}
+        });
+
+        NLOHMANN_JSON_SERIALIZE_ENUM(ultramodern::renderer::HUDRatioMode, {
+            {ultramodern::renderer::HUDRatioMode::Original, "Original"},
+            {ultramodern::renderer::HUDRatioMode::Clamp16x9, "Clamp16x9"},
+            {ultramodern::renderer::HUDRatioMode::Full, "Full"},
+        });
+
+        NLOHMANN_JSON_SERIALIZE_ENUM(ultramodern::renderer::GraphicsApi, {
+            {ultramodern::renderer::GraphicsApi::Auto, "Auto"},
+            {ultramodern::renderer::GraphicsApi::D3D12, "D3D12"},
+            {ultramodern::renderer::GraphicsApi::Vulkan, "Vulkan"},
+        });
+
+        NLOHMANN_JSON_SERIALIZE_ENUM(ultramodern::renderer::AspectRatio, {
+            {ultramodern::renderer::AspectRatio::Original, "Original"},
+            {ultramodern::renderer::AspectRatio::Expand, "Expand"},
+            {ultramodern::renderer::AspectRatio::Manual, "Manual"},
+        });
+
+        NLOHMANN_JSON_SERIALIZE_ENUM(ultramodern::renderer::Antialiasing, {
+            {ultramodern::renderer::Antialiasing::None, "None"},
+            {ultramodern::renderer::Antialiasing::MSAA2X, "MSAA2X"},
+            {ultramodern::renderer::Antialiasing::MSAA4X, "MSAA4X"},
+            {ultramodern::renderer::Antialiasing::MSAA8X, "MSAA8X"},
+        });
+
+        NLOHMANN_JSON_SERIALIZE_ENUM(ultramodern::renderer::RefreshRate, {
+            {ultramodern::renderer::RefreshRate::Original, "Original"},
+            {ultramodern::renderer::RefreshRate::Display, "Display"},
+            {ultramodern::renderer::RefreshRate::Manual, "Manual"},
+        });
+
+        NLOHMANN_JSON_SERIALIZE_ENUM(ultramodern::renderer::HighPrecisionFramebuffer, {
+            {ultramodern::renderer::HighPrecisionFramebuffer::Auto, "Auto"},
+            {ultramodern::renderer::HighPrecisionFramebuffer::On, "On"},
+            {ultramodern::renderer::HighPrecisionFramebuffer::Off, "Off"},
+        });
+    }
+}
+
+#endif

ultramodern/include/ultramodern/renderer_wrapper.hpp

@@ -7,6 +7,7 @@
 #include <span>
 
 #include "ultra64.h"
+#include "config.hpp"
 
 namespace ultramodern {
 
@@ -14,20 +15,6 @@ namespace ultramodern {
     struct WindowHandle;
 
     namespace renderer {
-        class GraphicsConfig {
-            public:
-                bool developer_mode;
-
-                virtual ~GraphicsConfig() = default;
-
-                virtual std::string get_graphics_api_name() const = 0;
-                virtual std::optional<uint32_t> get_target_framerate(uint32_t original) const = 0;
-
-        		auto operator<=>(const GraphicsConfig& rhs) const = default;
-
-                virtual bool is_equal(const GraphicsConfig& rhs) const = 0;
-        };
-
         enum class SetupResult {
             Success,
             DynamicLibrariesNotFound,
@@ -43,7 +30,7 @@ namespace ultramodern {
                 virtual bool valid() = 0;
                 virtual SetupResult get_setup_result() const { return setup_result; }
 
-                virtual void update_config(const GraphicsConfig* old_config, const GraphicsConfig* new_config) = 0;
+                virtual void update_config(const GraphicsConfig& old_config, const GraphicsConfig& new_config) = 0;
 
                 virtual void enable_instant_present() = 0;
                 virtual void send_dl(const OSTask* task) = 0;
@@ -66,10 +53,6 @@ namespace ultramodern {
         void set_callbacks(const callbacks_t& callbacks);
 
         std::unique_ptr<RendererContext> create_render_context(uint8_t* rdram, WindowHandle window_handle, bool developer_mode);
-
-
-        void set_graphics_config(std::unique_ptr<const GraphicsConfig>&& config);
-        const GraphicsConfig* get_graphics_config();
     }
 }
 

ultramodern/src/events.cpp

@@ -227,7 +227,7 @@ std::atomic_uint32_t display_refresh_rate = 60;
 std::atomic<float> resolution_scale = 1.0f;
 
 uint32_t ultramodern::get_target_framerate(uint32_t original) {
-    auto maybe_framerate = ultramodern::renderer::get_graphics_config()->get_target_framerate(original);
+    auto maybe_framerate = ultramodern::renderer::get_graphics_config().get_target_framerate(original);
 
     if (maybe_framerate.has_value()) {
         return maybe_framerate.value();
@@ -262,7 +262,7 @@ void gfx_thread_func(uint8_t* rdram, moodycamel::LightweightSemaphore* thread_re
 
     auto old_config = ultramodern::renderer::get_graphics_config();
 
-    auto renderer_context = ultramodern::renderer::create_render_context(rdram, window_handle, ultramodern::renderer::get_graphics_config()->developer_mode);
+    auto renderer_context = ultramodern::renderer::create_render_context(rdram, window_handle, ultramodern::renderer::get_graphics_config().developer_mode);
 
     if (!renderer_context->valid()) {
         renderer_setup_result.store(renderer_context->get_setup_result());
@@ -312,7 +312,7 @@ void gfx_thread_func(uint8_t* rdram, moodycamel::LightweightSemaphore* thread_re
             }
             else if (const auto* config_action = std::get_if<UpdateConfigAction>(&action)) {
                 auto new_config = ultramodern::renderer::get_graphics_config();
-                if (!new_config->is_equal(*old_config)) {
+                if (old_config != new_config) {
                     renderer_context->update_config(old_config, new_config);
                     old_config = new_config;
                 }
@@ -521,10 +521,10 @@ void ultramodern::init_events(RDRAM_ARG ultramodern::WindowHandle window_handle)
                 show_renderer_error("Failed to load dynamic libraries. Make sure the DLLs are next to the recomp executable.");
                 break;
             case ultramodern::renderer::SetupResult::InvalidGraphicsAPI:
-                show_renderer_error(ultramodern::renderer::get_graphics_config()->get_graphics_api_name() + " is not supported on this platform. Please select a different graphics API.");
+                show_renderer_error(ultramodern::renderer::get_graphics_config().get_graphics_api_name() + " is not supported on this platform. Please select a different graphics API.");
                 break;
             case ultramodern::renderer::SetupResult::GraphicsAPINotFound:
-                show_renderer_error("Unable to initialize " + ultramodern::renderer::get_graphics_config()->get_graphics_api_name() + "." + driver_os_suffix);
+                show_renderer_error("Unable to initialize " + ultramodern::renderer::get_graphics_config().get_graphics_api_name() + "." + driver_os_suffix);
                 break;
             case ultramodern::renderer::SetupResult::GraphicsDeviceNotFound:
                 show_renderer_error("Unable to find compatible graphics device." + driver_os_suffix);

ultramodern/src/renderer_wrapper.cpp

@@ -21,22 +21,56 @@ std::unique_ptr<ultramodern::renderer::RendererContext> ultramodern::renderer::c
 }
 
 
-static std::unique_ptr<const ultramodern::renderer::GraphicsConfig> graphic_config{};
+static ultramodern::renderer::GraphicsConfig graphic_config{};
 static std::mutex graphic_config_mutex;
 
-void ultramodern::renderer::set_graphics_config(std::unique_ptr<const GraphicsConfig>&& config) {
+void ultramodern::renderer::set_graphics_config(const GraphicsConfig& config) {
     std::lock_guard<std::mutex> lock(graphic_config_mutex);
-    graphic_config.swap(config);
+    graphic_config = config;
     ultramodern::trigger_config_action();
 }
 
-const ultramodern::renderer::GraphicsConfig* ultramodern::renderer::get_graphics_config() {
+const ultramodern::renderer::GraphicsConfig& ultramodern::renderer::get_graphics_config() {
     std::lock_guard<std::mutex> lock(graphic_config_mutex);
-    auto ptr = graphic_config.get();
+    return graphic_config;
-    if (ptr == nullptr) {
+}
-        error_handling::message_box("[Error] The graphic configuration was not registered");
+
-        // TODO: should we make a macro for this?
+ultramodern::renderer::GraphicsConfig::~GraphicsConfig() = default;
-        error_handling::quick_exit(__FILE__, __LINE__, __func__);
+
-    }
+std::string ultramodern::renderer::GraphicsConfig::get_graphics_api_name() const {
-    return ptr;
+    ultramodern::renderer::GraphicsApi api = api_option;
+
+    if (api == ultramodern::renderer::GraphicsApi::Auto) {
+#if defined(_WIN32)
+        api = ultramodern::renderer::GraphicsApi::D3D12;
+#elif defined(__gnu_linux__)
+        api = ultramodern::renderer::GraphicsApi::Vulkan;
+#elif defined(__APPLE__)
+        // TODO: Add MoltenVK option for Mac?
+        api = ultramodern::renderer::GraphicsApi::Vulkan;
+#else
+        static_assert(false && "Unimplemented")
+#endif
+    }
+
+    switch (api) {
+        case ultramodern::renderer::GraphicsApi::D3D12:
+            return "D3D12";
+        case ultramodern::renderer::GraphicsApi::Vulkan:
+            return "Vulkan";
+        default:
+            return "[Unknown graphics API]";
+    }
+}
+
+std::optional<uint32_t> ultramodern::renderer::GraphicsConfig::get_target_framerate(uint32_t original) const {
+    switch (rr_option) {
+    default:
+    case ultramodern::renderer::RefreshRate::Original:
+        return original;
+    case ultramodern::renderer::RefreshRate::Manual:
+        return rr_manual_value;
+    case ultramodern::renderer::RefreshRate::Display:
+        return {};
+    }
 }

ultramodern/src/ultrainit.cpp

@@ -11,12 +11,12 @@ void ultramodern::set_callbacks(
     const error_handling::callbacks_t& error_handling_callbacks
 ) {
     ultramodern::rsp::set_callbacks(rsp_callbacks);
+    ultramodern::renderer::set_callbacks(renderer_callbacks);
     ultramodern::set_audio_callbacks(audio_callbacks);
     ultramodern::input::set_callbacks(input_callbacks);
     (void)gfx_callbacks; // nothing yet
     ultramodern::events::set_callbacks(thread_callbacks);
     ultramodern::error_handling::set_callbacks(error_handling_callbacks);
-    ultramodern::renderer::set_callbacks(renderer_callbacks);
 }
 
 void ultramodern::preinit(RDRAM_ARG ultramodern::WindowHandle window_handle) {