Merge branch 'new-cmodel' of ssh://git.axiodl.com:6431/AxioDL/metaforce into new-cmodel

Runtime/CMain.cpp

@@ -168,6 +168,7 @@ private:
   bool m_firstFrame = true;
   bool m_fullscreenToggleRequested = false;
   bool m_quitRequested = false;
+  bool m_lAltHeld = false;
   using delta_clock = std::chrono::high_resolution_clock;
   delta_clock::time_point m_prevFrameTime;
 
@@ -186,33 +187,8 @@ public:
   void onAppLaunched(const AuroraInfo& info) noexcept {
     initialize();
 
-    std::string_view backend;
+    VISetWindowTitle(
-    switch (info.backend) {
+        fmt::format(FMT_STRING("Metaforce {} [{}]"), METAFORCE_WC_DESCRIBE, backend_name(info.backend)).c_str());
-    case BACKEND_D3D12:
-      backend = "D3D12"sv;
-      break;
-    case BACKEND_METAL:
-      backend = "Metal"sv;
-      break;
-    case BACKEND_VULKAN:
-      backend = "Vulkan"sv;
-      break;
-    case BACKEND_OPENGL:
-      backend = "OpenGL"sv;
-      break;
-    case BACKEND_OPENGLES:
-      backend = "OpenGL ES"sv;
-      break;
-    case BACKEND_WEBGPU:
-      backend = "WebGPU"sv;
-      break;
-    case BACKEND_NULL:
-      backend = "Null"sv;
-      break;
-    default:
-      break;
-    }
-    VISetWindowTitle(fmt::format(FMT_STRING("Metaforce {} [{}]"), METAFORCE_WC_DESCRIBE, backend).c_str());
 
     m_voiceEngine = boo::NewAudioVoiceEngine("metaforce", "Metaforce");
     m_voiceEngine->setVolume(0.7f);
@@ -245,10 +221,17 @@ public:
   void onSdlEvent(const SDL_Event& event) noexcept {
     switch (event.type) {
     case SDL_KEYDOWN:
+      m_lAltHeld = event.key.keysym.sym == SDLK_LALT;
       // Toggle fullscreen on ALT+ENTER
       if (event.key.keysym.sym == SDLK_RETURN && (event.key.keysym.mod & KMOD_ALT) != 0u && event.key.repeat == 0u) {
         m_cvarCommons.m_fullscreen->fromBoolean(!m_cvarCommons.m_fullscreen->toBoolean());
       }
+      break;
+    case SDL_KEYUP:
+      if (m_lAltHeld && event.key.keysym.sym == SDLK_LALT) {
+        m_imGuiConsole.ToggleVisible();
+        m_lAltHeld = false;
+      }
     }
   }
 
@@ -449,8 +432,6 @@ static bool IsClientLoggingEnabled(int argc, char** argv) {
 #endif
 }
 
-static void SetupLogging() {}
-
 static std::unique_ptr<metaforce::Application> g_app;
 static SDL_Window* g_window;
 static bool g_paused;
@@ -539,7 +520,7 @@ int main(int argc, char** argv) {
     const AuroraConfig config{
         .appName = "Metaforce",
         .configPath = configPath.c_str(),
-        // .desiredBackend = TODO
+        .desiredBackend = metaforce::backend_from_string(cvarCmns.getGraphicsApi()),
         .msaa = cvarCmns.getSamples(),
         .maxTextureAnisotropy = static_cast<uint16_t>(cvarCmns.getAnisotropy()),
         .startFullscreen = cvarCmns.getFullscreen(),
@@ -554,7 +535,7 @@ int main(int argc, char** argv) {
     g_app->onImGuiAddTextures();
     g_app->onAppLaunched(info);
     g_app->onAppWindowResized(info.windowSize);
-    while (true) {
+    while (!cvarMgr.restartRequired()) {
       const auto* event = aurora_update();
       bool exiting = false;
       while (event != nullptr && event->type != AURORA_NONE) {

Runtime/Graphics/CGraphicsPalette.cpp

@@ -19,6 +19,12 @@ CGraphicsPalette::CGraphicsPalette(CInputStream& in) : x0_fmt(EPaletteFormat(in.
   // DCFlushRange(xc_entries.get(), x8_entryCount * 2);
 }
 
+CGraphicsPalette::~CGraphicsPalette() {
+#ifdef AURORA
+  GXDestroyTlutObj(&x10_tlutObj);
+#endif
+}
+
 void CGraphicsPalette::Load() {
   GXLoadTlut(&x10_tlutObj, GX_TLUT0);
   x4_frameLoaded = sCurrentFrameCount;

Runtime/Graphics/CGraphicsPalette.hpp

@@ -27,6 +27,7 @@ class CGraphicsPalette {
 public:
   explicit CGraphicsPalette(EPaletteFormat fmt, int count);
   explicit CGraphicsPalette(CInputStream& in);
+  ~CGraphicsPalette();
 
   u16* Lock() {
     x1c_locked = true;

Runtime/ImGuiConsole.cpp

@@ -1301,6 +1301,12 @@ void ImGuiConsole::ShowAppMainMenuBar(bool canInspect, bool preLaunch) {
   }
 }
 
+void ImGuiConsole::ToggleVisible() {
+  if (g_Main != nullptr) {
+    m_isVisible ^= 1;
+  }
+}
+
 void ImGuiConsole::PreUpdate() {
   OPTICK_EVENT();
   bool preLaunch = g_Main == nullptr;
@@ -1332,7 +1338,7 @@ void ImGuiConsole::PreUpdate() {
   }
   if (!preLaunch && !m_isLaunchInitialized) {
     if (m_developer) {
-      m_toasts.emplace_back("Press ` to toggle menu"s, 5.f);
+      m_toasts.emplace_back("Press Left Alt to toggle menu"s, 5.f);
     }
     m_isLaunchInitialized = true;
   }
@@ -1342,9 +1348,6 @@ void ImGuiConsole::PreUpdate() {
   }
 
   if (!preLaunch) {
-    if (ImGui::IsKeyReleased(ImGuiKey_GraveAccent)) {
-      m_isVisible ^= 1;
-    }
     if (m_stepFrame) {
       g_Main->SetPaused(true);
       m_stepFrame = false;
@@ -1892,28 +1895,27 @@ void ImGuiConsole::ShowPreLaunchSettingsWindow() {
   if (ImGui::Begin("Settings", &m_showPreLaunchSettingsWindow, ImGuiWindowFlags_AlwaysAutoResize)) {
     if (ImGui::BeginTabBar("Settings")) {
       if (ImGui::BeginTabItem("Graphics")) {
-        // TODO
+        size_t backendCount = 0;
-        //        static auto AvailableBackends = aurora::get_available_backends();
+        const auto* backends = aurora_get_available_backends(&backendCount);
-        //        ImGuiStringViewText(fmt::format(FMT_STRING("Current backend: {}"), aurora::get_backend_string()));
+        ImGuiStringViewText(fmt::format(FMT_STRING("Current backend: {}"), backend_name(aurora_get_backend())));
-        //        auto desiredBackend = static_cast<int>(aurora::Backend::Invalid);
+        auto desiredBackend = static_cast<int>(BACKEND_AUTO);
-        //        if (auto* cvar = m_cvarMgr.findCVar("graphicsApi")) {
+        if (auto* cvar = m_cvarMgr.findCVar("graphicsApi")) {
-        //          bool valid = false;
+          bool valid = false;
-        //          const auto name = cvar->toLiteral(&valid);
+          const auto name = cvar->toLiteral(&valid);
-        //          if (valid) {
+          if (valid) {
-        //            desiredBackend = static_cast<int>(aurora::backend_from_string(name));
+            desiredBackend = static_cast<int>(backend_from_string(name));
-        //          }
+          }
-        //        }
+        }
-        //        bool modified = false;
+        bool modified = false;
-        //        modified = ImGui::RadioButton("Auto", &desiredBackend, static_cast<int>(aurora::Backend::Invalid));
+        modified = ImGui::RadioButton("Auto", &desiredBackend, static_cast<int>(BACKEND_AUTO));
-        //        for (const auto& item : AvailableBackends) {
+        for (size_t i = 0; i < backendCount; ++i, ++backends) {
-        //          modified = ImGui::RadioButton(magic_enum::enum_name(item).data(), &desiredBackend,
+          const auto backend = *backends;
-        //          static_cast<int>(item)) ||
+          modified =
-        //                     modified;
+              ImGui::RadioButton(backend_name(backend).data(), &desiredBackend, static_cast<int>(backend)) || modified;
-        //        }
+        }
-        //        if (modified) {
+        if (modified) {
-        //          m_cvarCommons.m_graphicsApi->fromLiteral(
+          m_cvarCommons.m_graphicsApi->fromLiteral(backend_to_string(static_cast<AuroraBackend>(desiredBackend)));
-        //              aurora::backend_to_string(static_cast<aurora::Backend>(desiredBackend)));
+        }
-        //        }
         ImGuiCVarCheckbox(m_cvarMgr, "fullscreen", "Fullscreen");
         ImGui::EndTabItem();
       }
@@ -1934,4 +1936,78 @@ void ImGuiConsole::ShowPreLaunchSettingsWindow() {
   }
   ImGui::End();
 }
+
+static bool eq(std::string_view a, std::string_view b) {
+  if (a.size() != b.size()) {
+    return false;
+  }
+  return std::equal(a.begin(), a.end(), b.begin(), b.end(), [](char a, char b) { return tolower(a) == b; });
+}
+
+AuroraBackend backend_from_string(const std::string& str) {
+  if (eq(str, "d3d12"sv) || eq(str, "d3d"sv)) {
+    return BACKEND_D3D12;
+  }
+  if (eq(str, "metal"sv)) {
+    return BACKEND_METAL;
+  }
+  if (eq(str, "vulkan"sv) || eq(str, "vk"sv)) {
+    return BACKEND_VULKAN;
+  }
+  if (eq(str, "opengl"sv) || eq(str, "gl"sv)) {
+    return BACKEND_OPENGL;
+  }
+  if (eq(str, "opengles"sv) || eq(str, "gles"sv)) {
+    return BACKEND_OPENGLES;
+  }
+  if (eq(str, "webgpu"sv) || eq(str, "wgpu"sv)) {
+    return BACKEND_WEBGPU;
+  }
+  if (eq(str, "null"sv) || eq(str, "none"sv)) {
+    return BACKEND_NULL;
+  }
+  return BACKEND_AUTO;
+}
+
+std::string_view backend_to_string(AuroraBackend backend) {
+  switch (backend) {
+  default:
+    return "auto"sv;
+  case BACKEND_D3D12:
+    return "d3d12"sv;
+  case BACKEND_METAL:
+    return "metal"sv;
+  case BACKEND_VULKAN:
+    return "vulkan"sv;
+  case BACKEND_OPENGL:
+    return "opengl"sv;
+  case BACKEND_OPENGLES:
+    return "opengles"sv;
+  case BACKEND_WEBGPU:
+    return "webgpu"sv;
+  case BACKEND_NULL:
+    return "null"sv;
+  }
+}
+
+std::string_view backend_name(AuroraBackend backend) {
+  switch (backend) {
+  default:
+    return "Auto"sv;
+  case BACKEND_D3D12:
+    return "D3D12"sv;
+  case BACKEND_METAL:
+    return "Metal"sv;
+  case BACKEND_VULKAN:
+    return "Vulkan"sv;
+  case BACKEND_OPENGL:
+    return "OpenGL"sv;
+  case BACKEND_OPENGLES:
+    return "OpenGL ES"sv;
+  case BACKEND_WEBGPU:
+    return "WebGPU"sv;
+  case BACKEND_NULL:
+    return "Null"sv;
+  }
+}
 } // namespace metaforce

Runtime/ImGuiConsole.hpp

@@ -61,6 +61,7 @@ public:
 
   void ControllerAdded(uint32_t idx);
   void ControllerRemoved(uint32_t idx);
+  void ToggleVisible();
 
   std::optional<std::string> m_errorString;
   std::optional<std::string> m_gameDiscSelected;
@@ -159,4 +160,8 @@ private:
   void ShowPipelineProgress();
   void ShowPreLaunchSettingsWindow();
 };
+
+AuroraBackend backend_from_string(const std::string& str);
+std::string_view backend_to_string(AuroraBackend backend);
+std::string_view backend_name(AuroraBackend backend);
 } // namespace metaforce