Add experimental Android app shell

Author: encounter

CMakePresets.json

@@ -279,6 +279,45 @@
         }
       }
     },
+    {
+      "name": "android-base",
+      "hidden": true,
+      "generator": "Ninja",
+      "binaryDir": "${sourceDir}/build/${presetName}",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "RelWithDebInfo",
+        "CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install",
+        "CMAKE_TOOLCHAIN_FILE": "$env{ANDROID_HOME}/ndk/$env{ANDROID_NDK_VERSION}/build/cmake/android.toolchain.cmake",
+        "ANDROID_PLATFORM": "android-24"
+      },
+      "vendor": {
+        "microsoft.com/VisualStudioSettings/CMake/1.0": {
+          "hostOS": [
+            "Linux"
+          ]
+        }
+      }
+    },
+    {
+      "name": "android-arm64",
+      "displayName": "Android (arm64-v8a)",
+      "inherits": [
+        "android-base"
+      ],
+      "cacheVariables": {
+        "ANDROID_ABI": "arm64-v8a"
+      }
+    },
+    {
+      "name": "android-x86_64",
+      "displayName": "Android (x86_64)",
+      "inherits": [
+        "android-base"
+      ],
+      "cacheVariables": {
+        "ANDROID_ABI": "x86_64"
+      }
+    },
     {
       "name": "x-linux-ci",
       "hidden": true,
@@ -396,6 +435,24 @@
         "metaforce"
       ]
     },
+    {
+      "name": "android-arm64",
+      "configurePreset": "android-arm64",
+      "description": "Android arm64-v8a release build with debug info",
+      "displayName": "Android arm64-v8a RelWithDebInfo",
+      "targets": [
+        "metaforce"
+      ]
+    },
+    {
+      "name": "android-x86_64",
+      "configurePreset": "android-x86_64",
+      "description": "Android x86_64 release build with debug info",
+      "displayName": "Android x86_64 RelWithDebInfo",
+      "targets": [
+        "metaforce"
+      ]
+    },
     {
       "name": "windows-msvc-debug",
       "configurePreset": "windows-msvc-debug",

Runtime/CDvdFile.cpp

@@ -2,13 +2,15 @@
 
 // #include <optick.h>
 
+#include <SDL3/SDL_error.h>
 #include <SDL3/SDL_iostream.h>
 
 #include <cstring>
 #include <limits>
 #include <new>
 
 #include "Runtime/CDvdRequest.hpp"
+#include "Runtime/Logging.hpp"
 #include "Runtime/CStopwatch.hpp"
 
 namespace metaforce {
@@ -99,10 +101,9 @@ class CFileDvdRequest : public IDvdRequest {
   ESeekOrigin m_whence;
   int m_offset;
 
-
   bool m_cancel = false;
   bool m_complete = false;
-  
+
   std::function<void(u32)> m_callback;
 
 public:
@@ -185,6 +186,7 @@ class CFileDvdRequest : public IDvdRequest {
 
 std::vector<std::shared_ptr<IDvdRequest>> CDvdFile::m_RequestQueue;
 std::string CDvdFile::m_rootDirectory;
+std::string CDvdFile::m_lastError;
 std::unique_ptr<u8[]> CDvdFile::m_dolBuf;
 size_t CDvdFile::m_dolBufLen = 0;
 
@@ -369,16 +371,21 @@ bool CDvdFile::LoadDolBuf() {
 
 bool CDvdFile::Initialize(const std::string_view& path) {
   Shutdown();
+  m_lastError.clear();
 
   std::string pathStr(path);
   SDL_IOStream* io = SDL_IOFromFile(pathStr.c_str(), "rb");
   if (io == nullptr) {
+    m_lastError = std::string{"SDL_IOFromFile failed: "} + SDL_GetError();
+    spdlog::error("{} (path: '{}')", m_lastError, pathStr);
     return false;
   }
 
   auto* streamCtx = new (std::nothrow) SDLDiscStreamCtx{io};
   if (streamCtx == nullptr) {
     SDL_CloseIO(io);
+    m_lastError = "Failed to allocate SDL disc stream context";
+    spdlog::error("{} (path: '{}')", m_lastError, pathStr);
     return false;
   }
 
@@ -394,7 +401,12 @@ bool CDvdFile::Initialize(const std::string_view& path) {
   };
   const NodResult discResult = nod_disc_open_stream(&stream, &discOpts, &discRaw);
   if (discResult != NOD_RESULT_OK || discRaw == nullptr) {
-    sdlStreamClose(streamCtx);
+    const char* nodError = nod_error_message();
+    m_lastError = fmt::format("nod_disc_open_stream failed ({}){}", int(discResult),
+                              nodError != nullptr && nodError[0] != '\0' ? fmt::format(": {}", nodError) : "");
+    spdlog::error("{} (path: '{}')", m_lastError, pathStr);
+    // Ownership of streamCtx is transferred to nod_disc_open_stream.
+    // FfiDiscStream drops and invokes close() on failure paths.
     return false;
   }
   m_DvdRoot = NodHandleUnique(discRaw, nod_free);
@@ -403,12 +415,24 @@ bool CDvdFile::Initialize(const std::string_view& path) {
   const NodResult partitionResult =
       nod_disc_open_partition_kind(m_DvdRoot.get(), NOD_PARTITION_KIND_DATA, nullptr, &partitionRaw);
   if (partitionResult != NOD_RESULT_OK || partitionRaw == nullptr) {
+    const char* nodError = nod_error_message();
+    m_lastError = fmt::format("nod_disc_open_partition_kind(data) failed ({}){}", int(partitionResult),
+                              nodError != nullptr && nodError[0] != '\0' ? fmt::format(": {}", nodError) : "");
+    spdlog::error("{} (path: '{}')", m_lastError, pathStr);
     Shutdown();
     return false;
   }
   m_DataPartition = NodHandleUnique(partitionRaw, nod_free);
 
-  if (!BuildFileEntries() || !LoadDolBuf()) {
+  if (!BuildFileEntries()) {
+    m_lastError = "Failed to read disc file-system table";
+    spdlog::error("{} (path: '{}')", m_lastError, pathStr);
+    Shutdown();
+    return false;
+  }
+  if (!LoadDolBuf()) {
+    m_lastError = "Failed to load raw DOL data from disc";
+    spdlog::error("{} (path: '{}')", m_lastError, pathStr);
     Shutdown();
     return false;
   }

Runtime/CDvdFile.hpp

@@ -46,6 +46,7 @@ class CDvdFile {
 
   static std::vector<std::shared_ptr<IDvdRequest>> m_RequestQueue;
   static std::string m_rootDirectory;
+  static std::string m_lastError;
   static std::unique_ptr<u8[]> m_dolBuf;
   static size_t m_dolBufLen;
 
@@ -61,6 +62,7 @@ class CDvdFile {
 
 public:
   static bool Initialize(const std::string_view& path);
+  static std::string_view GetLastError() { return m_lastError; }
   static SDiscInfo DiscInfo();
   static void SetRootDirectory(const std::string_view& rootDir);
   static void Shutdown();

Runtime/CMain.cpp

@@ -2,6 +2,7 @@
 #include <string_view>
 #include <numeric>
 #include <iostream>
+#include <vector>
 
 #include "ImGuiEngine.hpp"
 #include "Runtime/Graphics/CGraphics.hpp"
@@ -32,7 +33,11 @@
 #include <aurora/event.h>
 #include <aurora/main.h>
 #include <dolphin/vi.h>
+#include <SDL3/SDL_log.h>
 #include <SDL3/SDL_messagebox.h>
+#if defined(ANDROID)
+#include <spdlog/sinks/android_sink.h>
+#endif
 #include "Runtime/Graphics/CTexture.hpp"
 
 using namespace std::literals;
@@ -202,10 +207,10 @@ struct Application {
 #if TARGET_OS_IOS || TARGET_OS_TV
     m_deferredProject = std::string{m_fileMgr.getStoreRoot()} + "game.iso";
 #else
-    bool inArg = false;
     for (int i = 1; i < m_argc; ++i) {
       std::string arg = m_argv[i];
-      if (m_deferredProject.empty() && !arg.starts_with('-') && !arg.starts_with('+') && CBasics::IsDir(arg.c_str()))
+      if (m_deferredProject.empty() && !arg.starts_with('-') && !arg.starts_with('+') &&
+          (CBasics::IsDir(arg.c_str()) || CBasics::IsFile(arg.c_str())))
         m_deferredProject = arg;
       else if (arg == "--no-sound") {
         // m_voiceEngine->setVolume(0.f);
@@ -261,8 +266,17 @@ struct Application {
         m_projectInitialized = true;
         m_cvarCommons.m_lastDiscPath->fromLiteral(m_deferredProject);
       } else {
-        spdlog::error("Failed to open disc image '{}'", m_deferredProject);
-        m_imGuiConsole.m_errorString = fmt::format("Failed to open disc image '{}'", m_deferredProject);
+        const std::string_view dvdErr = CDvdFile::GetLastError();
+        if (dvdErr.empty()) {
+          spdlog::error("Failed to open disc image '{}'", m_deferredProject);
+          m_imGuiConsole.m_errorString = fmt::format("Failed to open disc image '{}'", m_deferredProject);
+        } else {
+          spdlog::error("Failed to open disc image '{}': {}", m_deferredProject, dvdErr);
+          m_imGuiConsole.m_errorString = fmt::format("Failed to open disc image '{}': {}", m_deferredProject, dvdErr);
+        }
+        if (m_deferredProject.starts_with("content://")) {
+          m_cvarCommons.m_lastDiscPath->fromLiteral(""sv);
+        }
       }
       m_deferredProject.clear();
     }
@@ -437,6 +451,20 @@ static void SetupBasics() {
     exit(1);
   }
 
+#if defined(ANDROID)
+  {
+    std::vector<spdlog::sink_ptr> sinks;
+    if (auto defaultLogger = spdlog::default_logger(); defaultLogger != nullptr) {
+      sinks = defaultLogger->sinks();
+    }
+    sinks.emplace_back(std::make_shared<spdlog::sinks::android_sink_mt>("Metaforce"));
+    auto logger = std::make_shared<spdlog::logger>("metaforce-android", sinks.begin(), sinks.end());
+    logger->set_level(spdlog::level::trace);
+    logger->flush_on(spdlog::level::warn);
+    spdlog::set_default_logger(std::move(logger));
+  }
+#endif
+
 #if SENTRY_ENABLED
   std::string cacheDir{metaforce::FileStoreManager::instance()->getStoreRoot()};
   logvisor::RegisterSentry("metaforce", METAFORCE_WC_DESCRIBE, cacheDir.c_str());

Runtime/CMakeLists.txt

@@ -214,17 +214,32 @@ if (WIN32)
     endif ()
 elseif (APPLE)
     # nothing
-elseif (UNIX)
+elseif (UNIX AND NOT ANDROID)
     set(PLAT_LIBS rt)
 endif ()
 
-add_executable(metaforce WIN32 CMain.cpp ${PLAT_SRCS}
-    ImGuiConsole.hpp ImGuiConsole.cpp
-    ImGuiControllerConfig.hpp ImGuiControllerConfig.cpp
-    ImGuiEntitySupport.hpp ImGuiEntitySupport.cpp)
+if (ANDROID)
+    add_library(metaforce SHARED CMain.cpp ${PLAT_SRCS}
+        ImGuiConsole.hpp ImGuiConsole.cpp
+        ImGuiControllerConfig.hpp ImGuiControllerConfig.cpp
+        ImGuiEntitySupport.hpp ImGuiEntitySupport.cpp)
+    set_target_properties(metaforce PROPERTIES
+        OUTPUT_NAME main
+        LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/Binaries)
+else ()
+    add_executable(metaforce WIN32 CMain.cpp ${PLAT_SRCS}
+        ImGuiConsole.hpp ImGuiConsole.cpp
+        ImGuiControllerConfig.hpp ImGuiControllerConfig.cpp
+        ImGuiEntitySupport.hpp ImGuiEntitySupport.cpp)
+endif ()
 # RUNTIME_LIBRARIES repeated here for link ordering
 target_link_libraries(metaforce PUBLIC RuntimeCommon RuntimeCommonB ${RUNTIME_LIBRARIES} ${PLAT_LIBS} aurora::main)
 target_compile_definitions(metaforce PUBLIC "-DMETAFORCE_TARGET_BYTE_ORDER=__BYTE_ORDER__")
+if (ANDROID)
+    # SDLActivity loads SDL_main via dlsym on Android. Since aurora::main is a static
+    # archive, force an undefined reference so the linker keeps the SDL_main object.
+    target_link_options(metaforce PRIVATE "-Wl,-u,SDL_main")
+endif ()
 if (WIN32)
     target_link_options(metaforce PRIVATE /ENTRY:wWinMainCRTStartup)
 endif ()

Runtime/Graphics/CGraphics.cpp

@@ -513,15 +513,15 @@ void CGraphics::FlushProjection() {
   float left = mProj.GetLeft();
   float top = mProj.GetTop();
   float bottom = mProj.GetBottom();
-  float near = mProj.GetNear();
-  float far = mProj.GetFar();
+  float nearPlane = mProj.GetNear();
+  float farPlane = mProj.GetFar();
   if (mProj.IsPerspective()) {
     Mtx44 mtx;
-    MTXFrustum(mtx, top, bottom, left, right, near, far);
+    MTXFrustum(mtx, top, bottom, left, right, nearPlane, farPlane);
     GXSetProjection(mtx, GX_PERSPECTIVE);
   } else {
     Mtx44 mtx;
-    MTXOrtho(mtx, top, bottom, left, right, near, far);
+    MTXOrtho(mtx, top, bottom, left, right, nearPlane, farPlane);
     GXSetProjection(mtx, GX_ORTHOGRAPHIC);
   }
 }
@@ -638,9 +638,9 @@ void CGraphics::SetScissor(int left, int bottom, int width, int height) {
   GXSetScissor(left, mRenderModeObj.efbHeight - (bottom + height), width, height);
 }
 
-void CGraphics::SetDepthRange(float near, float far) {
-  mDepthNear = near;
-  mDepthFar = far;
+void CGraphics::SetDepthRange(float nearPlane, float farPlane) {
+  mDepthNear = nearPlane;
+  mDepthFar = farPlane;
   GXSetViewport(static_cast<float>(mViewport.mLeft), static_cast<float>(mViewport.mTop),
                 static_cast<float>(mViewport.mWidth), static_cast<float>(mViewport.mHeight), mDepthNear, mDepthFar);
 }

Runtime/Graphics/CGraphics.hpp

@@ -191,8 +191,14 @@ class CGraphics {
 
   class CProjectionState {
   public:
-    CProjectionState(bool persp, float left, float right, float top, float bottom, float near, float far)
-    : x0_persp(persp), x4_left(left), x8_right(right), xc_top(top), x10_bottom(bottom), x14_near(near), x18_far(far) {}
+    CProjectionState(bool persp, float left, float right, float top, float bottom, float nearPlane, float farPlane)
+    : x0_persp(persp)
+    , x4_left(left)
+    , x8_right(right)
+    , xc_top(top)
+    , x10_bottom(bottom)
+    , x14_near(nearPlane)
+    , x18_far(farPlane) {}
 
     bool IsPerspective() const { return x0_persp; }
     float GetLeft() const { return x4_left; }
@@ -359,7 +365,7 @@ class CGraphics {
   static void SetViewportResolution(const zeus::CVector2i& res);
   static void SetViewport(int leftOff, int bottomOff, int width, int height);
   static void SetScissor(int leftOff, int bottomOff, int width, int height);
-  static void SetDepthRange(float near, float far);
+  static void SetDepthRange(float nearPlane, float farPlane);
   static void SetIdentityViewPointMatrix();
   static void SetIdentityModelMatrix();
   static void ClearBackAndDepthBuffers();

Runtime/ImGuiConsole.cpp

@@ -729,7 +729,10 @@ void ImGuiConsole::ShowAboutWindow(bool preLaunch) {
     }
     if (m_errorString) {
       ImGui::PushStyleColor(ImGuiCol_Text, ImVec4{0.77f, 0.12f, 0.23f, 1.f});
-      ImGuiTextCenter(*m_errorString);
+      ImGui::NewLine();
+      ImGui::PushTextWrapPos(0.f);
+      ImGuiStringViewText(*m_errorString);
+      ImGui::PopTextWrapPos();
       ImGui::PopStyleColor();
       ImGui::Dummy(padding);
     }

android/.gitignore

@@ -0,0 +1,5 @@
+.gradle/
+build/
+app/build/
+local.properties
+app/src/main/jniLibs/*/*.so