Modernize the usage of variants

ultramodern/events.cpp

@@ -10,7 +10,7 @@
 #include <cstring>
 
 #include "blockingconcurrentqueue.h"
-
+#include "utils.hpp"
 #include "ultra64.h"
 #include "ultramodern.hpp"
 #include "config.hpp"
@@ -328,8 +328,8 @@ void gfx_thread_func(uint8_t* rdram, moodycamel::LightweightSemaphore* thread_re
         // Try to pull an action from the queue
         Action action;
         if (events_context.action_queue.wait_dequeue_timed(action, 1ms)) {
-            // Determine the action type and act on it
-            if (const auto* task_action = std::get_if<SpTaskAction>(&action)) {
+            match(action, 
+                [&](const SpTaskAction& action){
                     // Turn on instant present if the game has been started and it hasn't been turned on yet.
                     if (ultramodern::is_game_started() && !enabled_instant_present) {
                         rt64.enable_instant_present();
@@ -346,23 +346,26 @@ void gfx_thread_func(uint8_t* rdram, moodycamel::LightweightSemaphore* thread_re
                     rt64.send_dl(&task_action->task);
                     auto rt64_end = std::chrono::high_resolution_clock::now();
                     dp_complete();
-                // printf("RT64 ProcessDList time: %d us\n", static_cast<u32>(std::chrono::duration_cast<std::chrono::microseconds>(rt64_end - rt64_start).count()));
-            }
-            else if (const auto* swap_action = std::get_if<SwapBuffersAction>(&action)) {
+                },
+                [&](const SwapBuffersAction &action)
+                {
                     events_context.vi.current_buffer = events_context.vi.next_buffer;
                     rt64.update_screen(swap_action->origin);
                     display_refresh_rate = rt64.get_display_framerate();
-            }
-            else if (const auto* config_action = std::get_if<UpdateConfigAction>(&action)) {
+                },
+                [&](const UpdateConfigAction &action)
+                {
                     ultramodern::GraphicsConfig new_config = cur_config;
-                if (old_config != new_config) {
+                    if (old_config == new_config) return; 
+
                     rt64.update_config(old_config, new_config);
                     old_config = new_config;
-                }
-            }
-            else if (const auto* load_shader_cache_action = std::get_if<LoadShaderCacheAction>(&action)) {
+                },
+                [&](const LoadShaderCacheAction &action)
+                {
                     rt64.load_shader_cache(load_shader_cache_action->data);
                 }
+            );
         }
     }
     // TODO move recomp code out of ultramodern.

ultramodern/timer.cpp

@@ -3,6 +3,7 @@
 #include <set>
 #include "blockingconcurrentqueue.h"
 
+#include "utils.hpp"
 #include "ultra64.h"
 #include "ultramodern.hpp"
 
@@ -87,12 +88,16 @@ void timer_thread(RDRAM_ARG1) {
     
     // Lambda to process a timer action to handle adding and removing timers
     auto process_timer_action = [&](const Action& action) {
-        // Determine the action type and act on it
-        if (const auto* add_action = std::get_if<AddTimerAction>(&action)) {
-            active_timers.insert(add_action->timer);
-        } else if (const auto* remove_action = std::get_if<RemoveTimerAction>(&action)) {
-            active_timers.erase(remove_action->timer);
+        match(action, 
+            [&active_timers](const AddTimerAction& action)
+            {
+                active_timers.insert(action->timer);
+            },
+            [&active_timers](const RemoveTimerAction& action)
+            {
+                active_timers.erase(action->timer);
             }
+        );
     };
 
     while (true) {

ultramodern/utils.hpp

@@ -0,0 +1,12 @@
+#include <variant>
+
+template<class... Ts> 
+struct overloaded : Ts... 
+{ 
+    using Ts::operator()...; 
+};
+
+template<class T, class... Ts>
+auto match(const T& event, Ts&&... args){
+    return std::visit(overloaded{std::forward<Ts>(args)...}, event);
+}