selaura proxy

Author: notchyves

CMakeLists.txt

@@ -49,6 +49,7 @@ add_compile_definitions(
 
 add_subdirectory(include)
 add_subdirectory(src)
+add_subdirectory(src-proxy)
 add_subdirectory(test)
 
 if (MSVC)

src-proxy/CMakeLists.txt

@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 3.28)
+project(selaura_proxy LANGUAGES CXX)
+
+add_library(selaura_proxy SHARED
+        main_win_uwp.cpp
+)
+
+target_include_directories(selaura_proxy PRIVATE
+        ${CMAKE_SOURCE_DIR}/src
+)
+
+target_link_libraries(selaura_proxy PRIVATE
+        runtimeobject.lib
+)

src-proxy/main_win_uwp.cpp

@@ -0,0 +1,142 @@
+#include "main_win_uwp.hpp"
+
+#include <filesystem>
+#include <functional>
+#include <print>
+#include <thread>
+
+#include <winrt/windows.applicationmodel.h>
+#include <winrt/windows.foundation.h>
+#include <winrt/windows.storage.h>
+
+#include <runtime.hpp>
+
+std::thread::id mc_thread_id;
+HANDLE mc_thread_handle = nullptr;
+
+DWORD WINAPI SelauraRuntimeLoaderProc() {
+    AllocConsole();
+
+    AttachConsole(GetCurrentProcessId());
+    SetConsoleTitleA("Selaura Client Console");
+
+    FILE* fp;
+    freopen_s(&fp, "CONOUT$", "w", stdout);
+    freopen_s(&fp, "CONOUT$", "w", stderr);
+    freopen_s(&fp, "CONIN$", "r", stdin);
+
+    std::println("[Selaura Runtime Loader] Thread ID: {}, Thread Handle: {}", mc_thread_id, mc_thread_handle);
+    std::println("[Selaura Runtime Loader] Press Numpad1 to End");
+
+    auto winrt_folder = winrt::Windows::Storage::ApplicationData::Current().RoamingFolder();
+    auto folder = std::filesystem::path(winrt::to_string(winrt_folder.Path())) / "Selaura";
+
+    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
+    if (hOut != INVALID_HANDLE_VALUE) {
+        DWORD mode = 0;
+        if (GetConsoleMode(hOut, &mode)) {
+            SetConsoleMode(hOut, mode | 0x0004);
+        }
+    }
+
+    const auto runtime_path = folder / "selaura_runtime.dll";
+    if (!std::filesystem::exists(runtime_path)) {
+        std::println("\x1b[91m[Selaura Runtime Loader] ERROR: '{}' not found. The runtime is required.\x1b[0m",
+                     runtime_path.string());
+    } else {
+        std::function<void(selaura::runtime*)> load_mods = [=](selaura::runtime* rt) {
+            // To load mods we need LoadLibrary, and other Windows-specific
+            // functions, and this will be called in the runtime. However,
+            // due to the goal of cross-platform, the function must be
+            // created here, and then further passed to the runtime as an
+            // argument in the Init function.
+            std::filesystem::path mods_folder = folder/ "mods";
+
+            if (!std::filesystem::exists(mods_folder)) {
+                std::filesystem::create_directory(mods_folder);
+                return;
+            }
+
+            int plugins_loaded = 0;
+
+            using init_fn = void(*)(selaura::runtime*);
+            std::vector<init_fn> init_fn_list = {};
+
+            for (const auto& entry : std::filesystem::directory_iterator(mods_folder)) {
+                if (!entry.is_regular_file()) continue;
+                const auto& path = entry.path();
+                if (path.extension() == ".dll") {
+                    HMODULE mod = LoadLibraryExW(entry.path().c_str(), nullptr, DONT_RESOLVE_DLL_REFERENCES);
+                    if (mod) {
+                        FreeLibrary(mod);
+                        mod = LoadLibraryW(entry.path().c_str());
+                    }
+
+                    auto init = reinterpret_cast<init_fn>(GetProcAddress(mod, "SelauraPluginInit"));
+                    init_fn_list.push_back(init);
+
+                    if (mod) {
+                        plugins_loaded++;
+                        std::println("[Selaura Plugin Loader] Loaded: {}", path.filename().string());
+                    } else {
+                        std::println("[Selaura Plugin Loader] Failed to load: {} (Error {})",
+                                     path.filename().string(), GetLastError());
+                    }
+                }
+            }
+
+            std::println("[Selaura Plugin Loader] Loaded {} plugin(s).", plugins_loaded);
+
+            for (auto fn : init_fn_list) {
+                fn(rt);
+            }
+        };
+
+        SuspendThread(mc_thread_handle);
+
+        auto* ctx = new selaura::runtime_context;
+        ctx->thread_id = mc_thread_id;
+
+        const winrt::Windows::ApplicationModel::Package pkg = winrt::Windows::ApplicationModel::Package::Current();
+        ctx->version_major = pkg.Id().Version().Major;
+        ctx->version_minor = pkg.Id().Version().Minor;
+        ctx->version_build = pkg.Id().Version().Build;
+        ctx->version_revision = pkg.Id().Version().Revision;
+
+        HMODULE mod = LoadLibraryExW((folder / "selaura_runtime.dll").c_str(), nullptr, 0);
+        using runtime_init_fn = void(*)(selaura::runtime_context*, std::function<void(selaura::runtime*)>);
+        auto runtime_init = reinterpret_cast<runtime_init_fn>(GetProcAddress(mod, "SelauraRuntimeInit"));
+        runtime_init(ctx, load_mods);
+
+        ResumeThread(mc_thread_handle);
+    }
+
+    while (true) {
+        Sleep(10);
+        if (GetAsyncKeyState(VK_NUMPAD1)) break;
+    }
+
+    fclose(fp);
+    FreeConsole();
+
+    ExitProcess(0);
+
+    return 0;
+}
+
+BOOL APIENTRY DllMain(HINSTANCE, DWORD fdwReason, LPVOID) {
+    // This DLL is the Selaura Runtime Loader, which is injected
+    // immediately as the game loads by replacing the dxgi.dll.
+    // This is why in the headers it exports the necessary
+    // functions used in that library, so it can be loaded as it
+    // is essential to the game's startup.
+
+    if (fdwReason == DLL_PROCESS_ATTACH) {
+        mc_thread_id = std::this_thread::get_id();
+        mc_thread_handle = OpenThread(THREAD_ALL_ACCESS, FALSE, GetCurrentThreadId());
+
+        CreateThread(nullptr, 0, (LPTHREAD_START_ROUTINE)SelauraRuntimeLoaderProc, nullptr, 0, nullptr);
+    }
+
+    return TRUE;
+}

src/loader/main_win.hpp src-proxy/main_win_uwp.hppsrc/loader/main_win.hpp renamed to src-proxy/main_win_uwp.hpp

@@ -1,9 +1,6 @@
 #pragma once
 #include <Windows.h>
 
-// this is because selaura_client.dll is embedded into minecraft as dxgi.dll
-// therefore, it needs to still have the necessary inside of dxgi
-// or the game will not open.
 #pragma comment(linker, "/export:ApplyCompatResolutionQuirking=c:\\windows\\system32\\dxgi.ApplyCompatResolutionQuirking,@1")
 #pragma comment(linker, "/export:CompatString=c:\\windows\\system32\\dxgi.CompatString,@2")
 #pragma comment(linker, "/export:CompatValue=c:\\windows\\system32\\dxgi.CompatValue,@3")
@@ -24,4 +21,4 @@
 #pragma comment(linker, "/export:SetAppCompatStringPointer=c:\\windows\\system32\\dxgi.SetAppCompatStringPointer,@8")
 #pragma comment(linker, "/export:UpdateHMDEmulationStatus=c:\\windows\\system32\\dxgi.UpdateHMDEmulationStatus,@9")
 
-BOOL APIENTRY DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID);
+BOOL APIENTRY DllMain(HINSTANCE, DWORD fdwReason, LPVOID);

src/CMakeLists.txt

@@ -2,8 +2,8 @@ cmake_minimum_required(VERSION 3.28)
 project(selaura_client LANGUAGES CXX)
 
 add_library(selaura_client SHARED
-        loader/main_win.cpp
-        loader/runtime.cpp
+        main.cpp
+        runtime.cpp
         hooks/hooks.cpp
 )
 

src/loader/context.hpp src/context.hppsrc/loader/context.hpp renamed to src/context.hpp

@@ -3,7 +3,7 @@
 #include <libhat/scanner.hpp>
 #include <print>
 
-#include <loader/runtime.hpp>
+#include <../runtime.hpp>
 
 
 #include <api/mc/world/Minecraft.hpp>

src/hooks/hooks.cpp

@@ -0,0 +1,18 @@
+#ifdef _WIN32
+#include <Windows.h>
+
+BOOL APIENTRY DllMain(HINSTANCE, DWORD, LPVOID) {
+    return TRUE;
+}
+#endif
+
+#include <api/imports.hpp>
+#include <print>
+#include "runtime.hpp"
+
+SELAURA_API void SelauraRuntimeInit(selaura::runtime_context* ctx, std::function<void(selaura::runtime*)> load_mods) {
+    selaura::runtime_instance = std::make_unique<selaura::runtime>(*ctx);
+    selaura::runtime_instance->start();
+
+    load_mods(selaura::runtime_instance.get());
+}