diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 392f769..f0484a1 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -66,6 +66,12 @@ jobs: run: cmake --build build --config Release --parallel 2 - name: Run synthetic tests and report data tests as skipped run: ctest --test-dir build -C Release --output-on-failure --output-junit test-results.xml + - name: Windows Server launcher with WARP software graphics + if: runner.os == 'Windows' + env: + SDL_VIDEODRIVER: windows + OPENBMH_RML_DRIVER: warp + run: build/launcher_gui_smoke.exe - name: Package products and licenses run: python3 tools/package/make_package.py --build build --out dist --platform ${{ matrix.platform }} - name: Package corresponding source and pinned dependencies diff --git a/.github/workflows/editor.yml b/.github/workflows/editor.yml index e82cc25..f99ceb5 100644 --- a/.github/workflows/editor.yml +++ b/.github/workflows/editor.yml @@ -49,7 +49,7 @@ jobs: if [[ "$RUNNER_OS" == "macOS" ]]; then args+=(-DCMAKE_OSX_ARCHITECTURES=arm64 -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0); fi cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release -DOPENBMH_BUILD_EDITOR=ON -DBMH_DATA= "${args[@]}" - name: Build editor and synthetic tests - run: cmake --build build --target openbmh_editor editor_core_tests editor_comparison_tests editor_regulations_tests --parallel 2 + run: cmake --build build --target openbmh_editor launcher_gui_smoke editor_core_tests editor_comparison_tests editor_regulations_tests --parallel 2 - name: Native editor core and MCP tests run: ctest --test-dir build -C Release -R "^editor_(core_tests|comparison_tests|regulations_tests|version)$" --output-on-failure --output-junit editor-tests.xml - name: Linux native GUI smoke @@ -57,6 +57,10 @@ jobs: run: | xvfb-run -a -s '-screen 0 1600x1000x24' python3 tests/editor_gui_smoke.py build/OpenBMHEditor xvfb-run -a -s '-screen 0 1600x1000x24' build/OpenBMHEditor --demo --page players --settings build/test-options.json --screenshot build/editor.png --quit-after-ms 1800 + xvfb-run -a -s '-screen 0 1600x1000x24' python3 tests/editor_startup_smoke.py build/OpenBMHEditor --launcher build/launcher_gui_smoke + - name: Windows Server native GUI and WARP fallback + if: runner.os == 'Windows' + run: python3 tests/editor_startup_smoke.py build/OpenBMHEditor.exe --launcher build/launcher_gui_smoke.exe - name: Package editor shell: bash run: | diff --git a/CMakeLists.txt b/CMakeLists.txt index ef2db6e..f3bac51 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,6 +1,6 @@ # SPDX-License-Identifier: GPL-3.0-only cmake_minimum_required(VERSION 3.24) -project(OpenBMH VERSION 0.2.0 LANGUAGES CXX C) +project(OpenBMH VERSION 0.2.1 LANGUAGES CXX C) if(APPLE) enable_language(OBJC OBJCXX) set(CMAKE_OBJCXX_STANDARD 20) diff --git a/README.md b/README.md index 3ba6d58..2b97712 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,8 @@ # OpenBMH -The separate [OpenBMH Editor 0.5.2](docs/EDITOR.md) uses native RmlUI, +The separate [OpenBMH Editor 0.5.3](docs/EDITOR.md) uses native RmlUI, supports German/English, three themes, image editing and a local MCP server. -Download its own `editor-v0.5.2` release or build with +Download its own `editor-v0.5.3` release or build with `-DOPENBMH_BUILD_EDITOR=ON`. Edited worlds are independent of the Classic runtime. A modern and faithful open source rebuild of the *Bundesliga Manager Hattrick* engine. @@ -36,7 +36,7 @@ For direct startup or the console: Both frontends use native content and saves. Use **Add** to migrate older files rather than passing an original executable or `.FBM` to the running game. The starting year changes the Classic year display; original weekday and scheduling rules are preserved. Modern worlds are reserved for a later version. -The launcher uses SDL2, RmlUI and OpenGL 3.3 (macOS: OpenGL 4.1); keep its `assets` directory next to the executable. Folder selection uses the operating system's dialog. See the [0.2 migration contract](docs/formats/obw/runtime-0.2.md) for compatibility and validation limits. Platform builds and automated tests are separate from human interactive acceptance on Windows and macOS. +The launcher uses SDL2 and RmlUI, with Direct3D 11 and automatic WARP software fallback on Windows, OpenGL 3.3 on Linux and OpenGL 4.1 on macOS; keep its `assets` directory next to the executable. Folder selection uses the operating system's dialog. See the [0.2 migration contract](docs/formats/obw/runtime-0.2.md) for compatibility and validation limits. Platform builds and automated tests are separate from human interactive acceptance on Windows and macOS. ## Features and direction diff --git a/docs/EDITOR.md b/docs/EDITOR.md index ebe9a8f..b483098 100644 --- a/docs/EDITOR.md +++ b/docs/EDITOR.md @@ -1,10 +1,23 @@ -# OpenBMH Editor 0.5.2 +# OpenBMH Editor 0.5.3 -Der eigenständige, native Editor verwendet **RmlUI, SDL2 und OpenGL**. Er bearbeitet Startdatenbanken, keine laufenden Spielstände. Das Spiel und seine Classic-Prüfung bleiben unverändert. Editor 0.5.2 hat eine eigene Versionsreihe und den Release-Tag `editor-v0.5.2`; die Spielversion ist 0.2.0. +Der eigenständige, native Editor verwendet **RmlUI, SDL2 und OpenGL**. Er bearbeitet Startdatenbanken, keine laufenden Spielstände. Das Spiel und seine Classic-Prüfung bleiben unverändert. Editor 0.5.3 hat eine eigene Versionsreihe und den Release-Tag `editor-v0.5.3`; die Spielversion ist 0.2.1. + +## Windows-Start und Diagnose + +Windows verwendet Direct3D 11 und wechselt bei fehlender Hardware automatisch auf +den integrierten WARP-Renderer. Der Editor und der Spiel-Launcher benötigen dort +keinen OpenGL-Treiber. Dieser Start wird auch mit erzwungenem WARP auf Windows +Server 2022 geprüft. Zum gezielten Testen lässt sich `OPENBMH_RML_DRIVER=warp` +setzen; die normale Auswahl erfolgt automatisch. + +Startfehler erscheinen in einem nativen Dialog und werden zusätzlich unter +`%LOCALAPPDATA%\OpenBMH\OpenBMHEditor-startup.log` protokolliert. Bei einem +Aufruf aus PowerShell/CMD kann auch stderr umgeleitet werden. Headless- und +MCP-Aufrufe zeigen keinen modalen Fehlerdialog und behalten ihre Prozesscodes. ## Starten und Daten öffnen -Das vollständige Paket `OpenBMHEditor-0.5.2-.zip` entpacken und `OpenBMHEditor.exe` (Windows) beziehungsweise `OpenBMHEditor` (Linux/macOS) starten. `assets/editor` muss beim Programm bleiben. Auf macOS kann die unsignierte Anwendung über **Rechtsklick → Öffnen** gestartet werden. Eine Signatur/Notarisierung ist nicht Bestandteil dieser Version. `OpenBMHEditor --version` zeigt die Editorversion ohne Grafikstart. +Das vollständige Paket `OpenBMHEditor-0.5.3-.zip` entpacken und `OpenBMHEditor.exe` (Windows) beziehungsweise `OpenBMHEditor` (Linux/macOS) starten. `assets/editor` muss beim Programm bleiben. Auf macOS kann die unsignierte Anwendung über **Rechtsklick → Öffnen** gestartet werden. Eine Signatur/Notarisierung ist nicht Bestandteil dieser Version. `OpenBMHEditor --version` zeigt die Editorversion ohne Grafikstart. **Öffnen** bietet OBW-Dateien und entpackte Welten an. **BMH / FLTD importieren** liest einen Ordner mit einer unterstützten BMH- oder Football-Limited-Installation durch den bestehenden Konverter. Das Original wird nicht überschrieben. Eine bestehende Classic-OBW wird zunächst überprüft und dann in eine bearbeitbare Editorwelt übernommen. @@ -84,7 +97,7 @@ Das sind keine heutigen UEFA-Regeln und kein neuer Saison-Simulator. ## Kompilieren -Voraussetzungen entsprechen dem Hauptprojekt: C++20-Compiler, Git, CMake ≥ 3.24 und Ninja. Windows: Visual Studio 2022 C++ Build Tools / x64 Native Tools Prompt; macOS ARM: Xcode Command Line Tools, CMake und Ninja; Linux: GTK3-, X11- und OpenGL-Entwicklungspakete wie im Haupt-README. Die Grafikausgabe benötigt OpenGL 3.3, auf macOS OpenGL 4.1. +Voraussetzungen entsprechen dem Hauptprojekt: C++20-Compiler, Git, CMake ≥ 3.24 und Ninja. Windows: Visual Studio 2022 C++ Build Tools / x64 Native Tools Prompt; macOS ARM: Xcode Command Line Tools, CMake und Ninja; Linux: GTK3-, X11- und OpenGL-Entwicklungspakete wie im Haupt-README. Windows nutzt Direct3D 11 mit automatischem WARP-Software-Fallback; Linux benötigt OpenGL 3.3, macOS OpenGL 4.1. ```sh cmake -S . -B build-editor -G Ninja -DCMAKE_BUILD_TYPE=Release -DOPENBMH_BUILD_EDITOR=ON @@ -118,4 +131,4 @@ The editor retains full squads, original image data, source claims and unknown e In **Options**, switch the interface to **English**, choose one of the three themes, and enable/disable the integrated local MCP server. **Copy connection** provides the authenticated configuration. The server defaults to loopback port 8765; use port 0 for a free port. GUI and MCP share the same world, validation and undo history. It supports MCP Streamable HTTP 2025-11-25/2025-06-18 and optional stdio mode. Use `expected_revision` for concurrent edits. -Build with the three commands above, including `-DOPENBMH_BUILD_EDITOR=ON`. The native application requires OpenGL 3.3 (macOS 4.1) and the platform development dependencies documented in the main README. Editor 0.5.2 is unsigned and does not bundle any real-world dataset or proprietary game assets. +Build with the three commands above, including `-DOPENBMH_BUILD_EDITOR=ON`. Windows uses Direct3D 11 with automatic WARP software fallback. Linux requires OpenGL 3.3; macOS requires OpenGL 4.1, plus the documented platform development dependencies. Editor 0.5.3 is unsigned and does not bundle any real-world dataset or proprietary game assets. diff --git a/docs/architecture.md b/docs/architecture.md index 534f34c..0f4e2b7 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -57,8 +57,11 @@ of `OpenBMH`, keeping edition-specific process globals isolated. Portable mod co personal files have independent lifetimes. See [runtime-0.2](formats/obw/runtime-0.2.md). The launcher layout and theme live in `assets/launcher/launcher.rml` and `theme.rcss`. -They share the same RmlUI core, FreeType font engine and upstream SDL2/OpenGL renderer -on all desktop platforms. The C++ view translates events into the existing launcher +They share the same RmlUI core, FreeType font engine and SDL2 platform layer. +Windows uses the pinned upstream Direct3D 11 renderer with hardware-to-WARP +fallback, while Linux/macOS keep the upstream OpenGL renderer. Both the editor +and launcher share window/device lifetime, resizing and capture through +`src/launch/rml_video.*`. The C++ view translates events into the existing launcher interface; it does not own conversion rules or mod storage. This presentation layer can be reused by future modern screens. Classic game screens retain their current UI. The operating system supplies the folder picker through nativefiledialog-extended. diff --git a/docs/release/0.2/RELEASE_NOTES.md b/docs/release/0.2/RELEASE_NOTES.md index 0eb6d2a..c487b80 100644 --- a/docs/release/0.2/RELEASE_NOTES.md +++ b/docs/release/0.2/RELEASE_NOTES.md @@ -1,5 +1,14 @@ -# OpenBMH v0.2.0 +# OpenBMH v0.2.1 + +Fixes the launcher startup on Windows Server / Remote Desktop and computers +without an OpenGL 3.3 driver. The Windows RmlUI launcher uses Direct3D 11, with +automatic WARP software fallback; Linux and macOS keep their existing OpenGL +renderer. Launch errors use a native Windows dialog and a diagnostic log under +`%LOCALAPPDATA%/OpenBMH/OpenBMH-startup.log`. Game rules, saves and OBW content +remain compatible with 0.2.0. + +## Version 0.2.0 Version 0.2 makes the original-style game independent of the original installation after import. It supports Bundesliga Manager Hattrick and Football Limited Classic diff --git a/docs/release/editor-0.5/RELEASE_NOTES.md b/docs/release/editor-0.5/RELEASE_NOTES.md index f89bee5..8ed4f76 100644 --- a/docs/release/editor-0.5/RELEASE_NOTES.md +++ b/docs/release/editor-0.5/RELEASE_NOTES.md @@ -1,5 +1,19 @@ -# OpenBMH Editor 0.5.2 +# OpenBMH Editor 0.5.3 + +Fixes the Windows graphical startup on machines without an OpenGL 3.3 driver, +including Windows Server / Remote Desktop. The editor and game launcher use the +pinned RmlUI Direct3D 11 renderer with automatic WARP software fallback. No +additional graphics runtime download is needed on the supported Windows systems. +Linux/macOS retain their existing OpenGL rendering. + +Windows startup failures now produce a native dialog and a log in +`%LOCALAPPDATA%/OpenBMH/OpenBMHEditor-startup.log`. Console redirection is +retained and headless/MCP errors remain nonmodal. Native GUI startup, screenshots, +Unicode paths and the actual launcher are now tested on Windows Server 2022 +with WARP forced, in addition to the existing core/MCP tests. + +## Editor 0.5.2 Adds **Regulations / Regelwerk**, a read-only view of game and league rules. Inspect promotion/relegation places and destinations, playoff conditions, diff --git a/src/app/main.cpp b/src/app/main.cpp index ca78d32..1c13443 100644 --- a/src/app/main.cpp +++ b/src/app/main.cpp @@ -31,6 +31,7 @@ #include "launch/file_dialog.hpp" #include "launch/game_data.hpp" #include "launch/launcher.hpp" +#include "launch/rml_video.hpp" #include "content/package.hpp" #include "version.hpp" #include "app/live_matchday_events.hpp" @@ -75,8 +76,7 @@ using namespace bmh; // Why the game cannot start: a message box, and the same text on stderr. static void show_start_error(const std::string& text) { - std::fprintf(stderr, "%s\n", text.c_str()); - SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "OpenBMH", text.c_str(), nullptr); + rml::report_start_error("OpenBMH", text); } // Reattach the native editor when an in-game filename field takes focus. Cocoa @@ -91,26 +91,8 @@ static void focus_filename_input(SDL_Renderer* renderer) { SDL_StartTextInput(); } -#ifdef _WIN32 -// The game is a Windows GUI program (no console window on double-click). Started from a -// console, it writes --version, --help and start errors there (kernel32 AttachConsole). -extern "C" __declspec(dllimport) int __stdcall AttachConsole(unsigned long process_id); -static void attach_parent_console() { - // (an output redirected to a file or pipe stays there; a GUI program without one has no - // valid stream, fileno < 0) - const bool out_free = _fileno(stdout) < 0, err_free = _fileno(stderr) < 0; - if ((out_free || err_free) && AttachConsole(static_cast(-1))) { // ATTACH_PARENT_PROCESS - std::FILE* f = nullptr; - if (out_free) freopen_s(&f, "CONOUT$", "w", stdout); - if (err_free) freopen_s(&f, "CONOUT$", "w", stderr); - } -} -#else -static void attach_parent_console() {} -#endif - int main(int argc, char** argv) { - attach_parent_console(); + rml::attach_parent_console(); const std::vector args = launch::utf8_arguments(argc, argv); // (file names beyond the code page) fs::path data, save_directory; uint32_t seed = uint32_t(std::chrono::system_clock::now().time_since_epoch().count()); diff --git a/src/editor/CMakeLists.txt b/src/editor/CMakeLists.txt index c444ca5..9f94ecd 100644 --- a/src/editor/CMakeLists.txt +++ b/src/editor/CMakeLists.txt @@ -1,6 +1,6 @@ # SPDX-License-Identifier: GPL-3.0-only include(FetchContent) -set(OPENBMH_EDITOR_VERSION "0.5.2") +set(OPENBMH_EDITOR_VERSION "0.5.3") file(WRITE "${CMAKE_BINARY_DIR}/editor-version.json" "{\"version\": \"${OPENBMH_EDITOR_VERSION}\"}\n") set(JSON_BuildTests OFF CACHE BOOL "" FORCE) FetchContent_Declare(editor_json GIT_REPOSITORY https://github.com/nlohmann/json.git diff --git a/src/editor/main.cpp b/src/editor/main.cpp index 294a150..5113e7e 100644 --- a/src/editor/main.cpp +++ b/src/editor/main.cpp @@ -1,6 +1,7 @@ // SPDX-License-Identifier: GPL-3.0-only #include "editor/ui.hpp" #include "editor/version.hpp" +#include "launch/rml_video.hpp" #include #include #include @@ -14,7 +15,14 @@ void stop(int) { stopped = true; } } // namespace int main(int argc, char **argv) { using namespace bmh::editor; + bmh::rml::attach_parent_console(); std::string language = "de"; + bool graphical = true; + for (int i = 1; i < argc; ++i) + if (std::string_view(argv[i]) == "--headless" || std::string_view(argv[i]) == "--serve" || + std::string_view(argv[i]) == "--stdio-mcp" || std::string_view(argv[i]) == "--version" || + std::string_view(argv[i]) == "--help") + graphical = false; try { bool headless = false, serve = false, stdio = false, demo = false, blank = false, validate = false, print = false; @@ -153,10 +161,12 @@ int main(int argc, char **argv) { } return has_errors ? 2 : 0; } catch (const Error &e) { - std::cerr << Json{{"error", e.code}, {"message", tr(language, e.code)}, {"details", e.details}}.dump() << '\n'; + const auto message = + Json{{"error", e.code}, {"message", tr(language, e.code)}, {"details", e.details}}.dump(); + bmh::rml::report_start_error("OpenBMHEditor", message, graphical); return 1; } catch (const std::exception &e) { - std::cerr << tr(language, "error") << ": " << e.what() << '\n'; + bmh::rml::report_start_error("OpenBMHEditor", tr(language, "error") + ": " + e.what(), graphical); return 1; } } diff --git a/src/editor/options.cpp b/src/editor/options.cpp index 5afd697..e8da8a0 100644 --- a/src/editor/options.cpp +++ b/src/editor/options.cpp @@ -4,7 +4,9 @@ #include #include #ifdef _WIN32 +#ifndef NOMINMAX #define NOMINMAX +#endif #include #else #include @@ -268,8 +270,7 @@ std::string tr(const std::string &language, const std::string &key) { "Drag a rectangle on the image or enter crop values. Without cropping, " "the original resolution is retained."}}, {"video_failed", - {"Die Grafikausgabe benötigt OpenGL 3.3 (macOS: 4.1).", - "The interface requires OpenGL 3.3 (macOS: 4.1)."}}, + {"Die Grafikausgabe konnte nicht initialisiert werden.", "Graphics initialization failed."}}, {"ui_assets_missing", {"Editor-Oberfläche fehlt. Bitte das vollständige Paket entpacken.", "Editor interface files are missing. Please extract the complete " diff --git a/src/editor/ui.cpp b/src/editor/ui.cpp index cdf33c9..787ee0a 100644 --- a/src/editor/ui.cpp +++ b/src/editor/ui.cpp @@ -3,11 +3,11 @@ #include "editor/images.hpp" #include "editor/version.hpp" #include "launch/rml_path.hpp" +#include "launch/rml_video.hpp" #include #include #include #include -#include #include #include #include @@ -31,58 +31,13 @@ std::string button(const std::string &action, const std::string &label, const st return ""; } -struct Video { - SDL_Window *window = nullptr; - SDL_GLContext gl = nullptr; - bool loader = false; - Video() { - if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS | SDL_INIT_TIMER) != 0) - throw Error("video_failed"); - SDL_SetHint(SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, "1"); - SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); -#ifdef __APPLE__ - SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG); - SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4); - SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1); -#else - SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3); - SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3); -#endif - SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); - window = - SDL_CreateWindow("OpenBMH Editor", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1440, 900, - SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_HIDDEN); - if (!window) - throw Error("video_failed"); - SDL_SetWindowMinimumSize(window, 1080, 720); - gl = SDL_GL_CreateContext(window); - if (!gl) - throw Error("video_failed"); - SDL_GL_MakeCurrent(window, gl); - SDL_GL_SetSwapInterval(1); - std::string error; - if (!RmlGL3::Initialize(&error)) - throw Error("video_failed", {{"detail", error}}); - loader = true; - SDL_StartTextInput(); - } - ~Video() { - if (loader) - RmlGL3::Shutdown(); - if (gl) - SDL_GL_DeleteContext(gl); - if (window) - SDL_DestroyWindow(window); - SDL_Quit(); - } -}; -class Renderer final : public RenderInterface_GL3 { +class Renderer final : public bmh::rml::Renderer { public: Session &session; std::map> memory; std::map logical; uint64_t serial = 0; - explicit Renderer(Session &s) : session(s) {} + Renderer(Session &s, bmh::rml::Video &video) : bmh::rml::Renderer(video), session(s) {} std::string asset(const std::string &key) { auto token = "world-image-" + std::to_string(serial++) + ".png"; logical[token] = key; @@ -101,7 +56,7 @@ class Renderer final : public RenderInterface_GL3 { Rml::TextureHandle LoadTexture(Rml::Vector2i &dimensions, const Rml::String &source) override { const auto token = utf8(path(source).filename()); if (!memory.contains(token) && !logical.contains(token)) - return RenderInterface_GL3::LoadTexture(dimensions, source); + return bmh::rml::Renderer::LoadTexture(dimensions, source); try { auto value = memory.contains(token) ? memory.at(token) : session.asset_bytes(logical.at(token)); auto raster = images::decode(value.first, value.second, token.starts_with("icon-") ? 64 : 512); @@ -129,7 +84,7 @@ class EditorUi final : public Rml::EventListener { Options &options_; McpServer &server_; UiConfig config_; - Video video_; + bmh::rml::Video video_{"OpenBMH Editor", 1440, 900, 1080, 720}; bmh::rml::AssetFiles files_; SystemInterface_SDL system_{video_.window}; Renderer renderer_; @@ -299,7 +254,7 @@ class EditorUi final : public Rml::EventListener { void resize() { int w, h, pw, ph; SDL_GetWindowSize(video_.window, &w, &h); - SDL_GL_GetDrawableSize(video_.window, &pw, &ph); + video_.drawable_size(pw, ph); if (!w || !h) return; renderer_.SetViewport(pw, ph); @@ -1775,23 +1730,16 @@ class EditorUi final : public Rml::EventListener { if (config_.screenshot.empty()) return; int w, h; - SDL_GL_GetDrawableSize(video_.window, &w, &h); - images::Raster raster{w, h, std::vector(size_t(w) * h * 4)}; - using ReadPixels = void (*)(int, int, int, int, unsigned, unsigned, void *); - auto read = reinterpret_cast(SDL_GL_GetProcAddress("glReadPixels")); - if (!read) - throw Error("video_failed"); - read(0, 0, w, h, 0x1908 /* RGBA */, 0x1401 /* UNSIGNED_BYTE */, raster.pixels.data()); - for (int y = 0; y < h / 2; ++y) - for (int x = 0; x < w * 4; ++x) - std::swap(raster.pixels[size_t(y) * w * 4 + x], raster.pixels[size_t(h - y - 1) * w * 4 + x]); + auto pixels = video_.capture(w, h); + images::Raster raster{w, h, std::move(pixels)}; write_atomic(config_.screenshot, images::encode_png(raster)); config_.screenshot.clear(); } public: EditorUi(Session &s, Options &o, McpServer &server, UiConfig config) - : session_(s), options_(o), server_(server), config_(std::move(config)), renderer_(s) { + : session_(s), options_(o), server_(server), config_(std::move(config)), renderer_(s, video_) { + SDL_StartTextInput(); page_ = config_.page; Rml::SetSystemInterface(&system_); Rml::SetFileInterface(&files_); @@ -1801,10 +1749,11 @@ class EditorUi final : public Rml::EventListener { if (!initialized_) throw Error("video_failed"); for (auto weight : {"Regular", "Bold"}) - if (!Rml::LoadFontFace(utf8(config_.assets / (std::string("LatoLatin-") + weight + ".ttf")))) + if (!Rml::LoadFontFace( + bmh::rml::asset_path(config_.assets / (std::string("LatoLatin-") + weight + ".ttf")))) throw Error("ui_assets_missing"); context_ = Rml::CreateContext("editor", {1440, 900}); - doc_ = context_->LoadDocument(utf8(config_.assets / "editor.rml")); + doc_ = context_->LoadDocument(bmh::rml::asset_path(config_.assets / "editor.rml")); if (!doc_) throw Error("ui_assets_missing"); for (auto event : {"click", "change", "mousedown", "mouseup", "mousemove"}) @@ -1915,7 +1864,7 @@ class EditorUi final : public Rml::EventListener { ime_.HandleEdit(event.edit); int w, h, pw, ph; SDL_GetWindowSize(video_.window, &w, &h); - SDL_GL_GetDrawableSize(video_.window, &pw, &ph); + video_.drawable_size(pw, ph); if (w && h) { if (event.type == SDL_MOUSEMOTION) { event.motion.x = int(double(event.motion.x) * pw / w); @@ -1978,7 +1927,7 @@ class EditorUi final : public Rml::EventListener { auto elapsed = std::chrono::duration_cast(now - start_).count(); if (!busy_ && elapsed > 1200 && !config_.screenshot.empty()) screenshot(); - SDL_GL_SwapWindow(video_.window); + video_.present(); SDL_Delay(10); if (config_.quit_after_ms > 0 && elapsed >= config_.quit_after_ms) closed_ = true; diff --git a/src/import/CMakeLists.txt b/src/import/CMakeLists.txt index 2e2361a..d7eca6e 100644 --- a/src/import/CMakeLists.txt +++ b/src/import/CMakeLists.txt @@ -33,6 +33,9 @@ target_link_libraries(bmh_launcher PUBLIC bmh_content) include(../launch/rmlui.cmake) target_sources(bmh_launcher PRIVATE ../launch/launcher_rmlui.cpp) target_link_libraries(bmh_launcher PRIVATE bmh_rmlui nfd) +add_executable(launcher_gui_smoke ../../tests/launcher_gui_smoke.cpp) +target_link_libraries(launcher_gui_smoke PRIVATE bmh_launcher bmh_rmlui) +set_target_properties(launcher_gui_smoke PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}") add_executable(launcher_document_tests ../../tests/launcher_document_tests.cpp) target_include_directories(launcher_document_tests PRIVATE ..) target_link_libraries(launcher_document_tests PRIVATE RmlUi::Core) diff --git a/src/launch/launcher_rmlui.cpp b/src/launch/launcher_rmlui.cpp index 80603a7..1711e1c 100644 --- a/src/launch/launcher_rmlui.cpp +++ b/src/launch/launcher_rmlui.cpp @@ -1,18 +1,18 @@ // SPDX-License-Identifier: GPL-3.0-only -#include "launch/launcher_ui.hpp" -#include "launch/rml_path.hpp" #include "launch/archive.hpp" +#include "launch/launcher_ui.hpp" #include "launch/process.hpp" +#include "launch/rml_path.hpp" +#include "launch/rml_video.hpp" #include "version.hpp" #include #include #include #include -#include -#include #include #include #include +#include #include namespace bmh::launch { @@ -41,9 +41,6 @@ std::string escape(std::string_view value) { } return result; } -[[noreturn]] void sdl_error(const char *operation) { - throw std::runtime_error(std::string(operation) + ": " + SDL_GetError()); -} int modifiers(Uint16 state) { int result = 0; if (state & KMOD_CTRL) @@ -65,62 +62,11 @@ int modifiers(Uint16 state) { result |= Rml::Input::KM_NUMLOCK; return result; } -struct Video { - SDL_Window *window = nullptr; - SDL_GLContext gl = nullptr; - bool loader = false; - Video() { - try { - if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS | SDL_INIT_TIMER) != 0) - sdl_error("Launcher video initialization"); - SDL_SetHint(SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, "1"); - SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); -#ifdef __APPLE__ - SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG); - SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4); - SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1); -#else - SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3); - SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3); -#endif - SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); - window = SDL_CreateWindow("OpenBMH", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1100, 688, - SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI | - SDL_WINDOW_HIDDEN); - if (!window) - sdl_error("Launcher window"); - SDL_SetWindowMinimumSize(window, 800, 540); - gl = SDL_GL_CreateContext(window); - if (!gl) - sdl_error("Launcher requires OpenGL 3.3 (macOS: 4.1)"); - SDL_GL_MakeCurrent(window, gl); - SDL_GL_SetSwapInterval(1); - std::string error; - if (!RmlGL3::Initialize(&error)) - throw std::runtime_error("Launcher graphics initialization: " + error); - loader = true; - SDL_StopTextInput(); - } catch (...) { - close(); - throw; - } - } - void close() { - if (loader) - RmlGL3::Shutdown(); - if (gl) - SDL_GL_DeleteContext(gl); - if (window) - SDL_DestroyWindow(window); - SDL_QuitSubSystem(SDL_INIT_VIDEO | SDL_INIT_EVENTS | SDL_INIT_TIMER); - } - ~Video() { close(); } -}; class RmlLauncher final : public LauncherUI, public Rml::EventListener { - Video video_; + rml::Video video_{"OpenBMH", 1100, 688, 800, 540}; rml::AssetFiles files_; SystemInterface_SDL system_{video_.window}; - RenderInterface_GL3 renderer_; + rml::Renderer renderer_{video_}; TextInputMethodEditor_SDL ime_; Rml::Context *context_ = nullptr; Rml::ElementDocument *document_ = nullptr; @@ -165,7 +111,7 @@ class RmlLauncher final : public LauncherUI, public Rml::EventListener { void resize() { int w = 0, h = 0, pixels_w = 0, pixels_h = 0; SDL_GetWindowSize(video_.window, &w, &h); - SDL_GL_GetDrawableSize(video_.window, &pixels_w, &pixels_h); + video_.drawable_size(pixels_w, pixels_h); if (w <= 0 || h <= 0 || pixels_w <= 0 || pixels_h <= 0) return; renderer_.SetViewport(pixels_w, pixels_h); @@ -350,7 +296,7 @@ class RmlLauncher final : public LauncherUI, public Rml::EventListener { // SDL2 reports mouse coordinates in window units on Retina/HiDPI. int w = 0, h = 0, pw = 0, ph = 0; SDL_GetWindowSize(video_.window, &w, &h); - SDL_GL_GetDrawableSize(video_.window, &pw, &ph); + video_.drawable_size(pw, ph); if (w > 0 && h > 0) { if (event.type == SDL_MOUSEMOTION) { event.motion.x = int(double(event.motion.x) * pw / w); @@ -377,7 +323,7 @@ class RmlLauncher final : public LauncherUI, public Rml::EventListener { renderer_.Clear(); context_->Render(); renderer_.EndFrame(); - SDL_GL_SwapWindow(video_.window); + video_.present(); dirty_ = false; } } @@ -390,8 +336,9 @@ class RmlLauncher final : public LauncherUI, public Rml::EventListener { public: RmlLauncher() { + SDL_StopTextInput(); if (!renderer_) - throw std::runtime_error("RmlUI could not create the OpenGL renderer"); + throw std::runtime_error("RmlUI could not create the graphics renderer"); try { Rml::SetSystemInterface(&system_); Rml::SetFileInterface(&files_); diff --git a/src/launch/rml_video.cpp b/src/launch/rml_video.cpp new file mode 100644 index 0000000..a73d6e2 --- /dev/null +++ b/src/launch/rml_video.cpp @@ -0,0 +1,233 @@ +// SPDX-License-Identifier: GPL-3.0-only +#include "launch/rml_video.hpp" +#include +#include +#include +#include +#include +#include +#include +#include +#ifdef _WIN32 +#include +#endif + +namespace bmh::rml { +namespace { +[[noreturn]] void sdl_error(const char *operation) { + throw std::runtime_error(std::string(operation) + ": " + SDL_GetError()); +} +#ifdef _WIN32 +void check(HRESULT result, const char *operation) { + if (FAILED(result)) { + char code[24]; + std::snprintf(code, sizeof(code), "0x%08lX", static_cast(result)); + throw std::runtime_error(std::string(operation) + ": " + code); + } +} +std::wstring wide(const std::string &text) { + const int length = MultiByteToWideChar(CP_UTF8, 0, text.data(), int(text.size()), nullptr, 0); + std::wstring result(size_t(length), L' '); + MultiByteToWideChar(CP_UTF8, 0, text.data(), int(text.size()), result.data(), length); + return result; +} +#endif +} // namespace + +Video::Video(const char *title, int width, int height, int minimum_width, int minimum_height) { + try { + if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS | SDL_INIT_TIMER) != 0) + sdl_error("Video initialization"); + SDL_SetHint(SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, "1"); + Uint32 flags = SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_HIDDEN; +#ifndef _WIN32 + flags |= SDL_WINDOW_OPENGL; + SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); +#ifdef __APPLE__ + SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG); + SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4); + SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1); +#else + SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3); + SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3); +#endif + SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); +#endif + window = + SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, flags); + if (!window) + sdl_error("Window creation"); + SDL_SetWindowMinimumSize(window, minimum_width, minimum_height); +#ifdef _WIN32 + SDL_SysWMinfo info{}; + SDL_VERSION(&info.version); + if (!SDL_GetWindowWMInfo(window, &info)) + sdl_error("Native window handle"); + DXGI_SWAP_CHAIN_DESC desc{}; + desc.BufferCount = 2; + desc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; + desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + desc.OutputWindow = info.info.win.window; + desc.SampleDesc.Count = 1; + desc.Windowed = TRUE; + desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD; + const D3D_FEATURE_LEVEL levels[] = {D3D_FEATURE_LEVEL_11_0}; + auto create = [&](D3D_DRIVER_TYPE driver) { + return D3D11CreateDeviceAndSwapChain(nullptr, driver, nullptr, 0, levels, 1, D3D11_SDK_VERSION, + &desc, swapchain_.ReleaseAndGetAddressOf(), + device_.ReleaseAndGetAddressOf(), nullptr, + context_.ReleaseAndGetAddressOf()); + }; + const auto mode = std::getenv("OPENBMH_RML_DRIVER"); + const bool force_warp = mode && std::string_view(mode) == "warp"; + HRESULT result = force_warp ? E_FAIL : create(D3D_DRIVER_TYPE_HARDWARE); + bool software = false; + if (FAILED(result)) { + result = create(D3D_DRIVER_TYPE_WARP); + software = true; + } + check(result, "Direct3D 11 initialization (hardware and WARP)"); + // Upstream's full-featured renderer requires the 11.1 runtime interfaces. + Microsoft::WRL::ComPtr device1; + Microsoft::WRL::ComPtr context1; + check(device_.As(&device1), "Direct3D 11.1 device"); + check(context_.As(&context1), "Direct3D 11.1 context"); + std::fprintf(stderr, "RmlUI renderer: Direct3D 11 (%s)\n", software ? "WARP software" : "hardware"); + int pw, ph; + drawable_size(pw, ph); + resize(pw, ph); +#else + gl_ = SDL_GL_CreateContext(window); + if (!gl_) + sdl_error("OpenGL 3.3 initialization (macOS: 4.1)"); + if (SDL_GL_MakeCurrent(window, gl_) != 0) + sdl_error("OpenGL context activation"); + SDL_GL_SetSwapInterval(1); + std::string error; + if (!RmlGL3::Initialize(&error)) + throw std::runtime_error("OpenGL renderer initialization: " + error); + loader_ = true; +#endif + } catch (...) { + close(); + throw; + } +} +Video::~Video() { close(); } +void Video::close() noexcept { +#ifdef _WIN32 + if (context_) + context_->ClearState(); + target_.Reset(); + swapchain_.Reset(); + context_.Reset(); + device_.Reset(); +#else + if (loader_) + RmlGL3::Shutdown(); + if (gl_) + SDL_GL_DeleteContext(gl_); +#endif + if (window) + SDL_DestroyWindow(window); + SDL_QuitSubSystem(SDL_INIT_VIDEO | SDL_INIT_EVENTS | SDL_INIT_TIMER); +} +void Video::drawable_size(int &width, int &height) const { +#ifdef _WIN32 + SDL_GetWindowSizeInPixels(window, &width, &height); +#else + SDL_GL_GetDrawableSize(window, &width, &height); +#endif +} +#ifdef _WIN32 +void Video::resize(int width, int height) { + if (width < 1 || height < 1 || (width == width_ && height == height_ && target_)) + return; + context_->OMSetRenderTargets(0, nullptr, nullptr); + target_.Reset(); + check(swapchain_->ResizeBuffers(0, UINT(width), UINT(height), DXGI_FORMAT_UNKNOWN, 0), + "Swapchain resize"); + Microsoft::WRL::ComPtr buffer; + check(swapchain_->GetBuffer(0, IID_PPV_ARGS(&buffer)), "Swapchain buffer"); + check(device_->CreateRenderTargetView(buffer.Get(), nullptr, &target_), "Render target"); + width_ = width; + height_ = height; +} +#endif +void Video::present() { +#ifdef _WIN32 + check(swapchain_->Present(1, 0), "Direct3D presentation"); +#else + SDL_GL_SwapWindow(window); +#endif +} +std::vector Video::capture(int &width, int &height) { + drawable_size(width, height); + std::vector pixels(size_t(width) * size_t(height) * 4); +#ifdef _WIN32 + Microsoft::WRL::ComPtr buffer, staging; + check(swapchain_->GetBuffer(0, IID_PPV_ARGS(&buffer)), "Screenshot buffer"); + D3D11_TEXTURE2D_DESC desc{}; + buffer->GetDesc(&desc); + desc.Usage = D3D11_USAGE_STAGING; + desc.BindFlags = 0; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; + desc.MiscFlags = 0; + check(device_->CreateTexture2D(&desc, nullptr, &staging), "Screenshot staging texture"); + context_->CopyResource(staging.Get(), buffer.Get()); + D3D11_MAPPED_SUBRESOURCE data{}; + check(context_->Map(staging.Get(), 0, D3D11_MAP_READ, 0, &data), "Screenshot readback"); + for (int row = 0; row < height; ++row) + std::memcpy(pixels.data() + size_t(row) * width * 4, + static_cast(data.pData) + size_t(row) * data.RowPitch, + size_t(width) * 4); + context_->Unmap(staging.Get(), 0); +#else + using ReadPixels = void (*)(int, int, int, int, unsigned, unsigned, void *); + auto read = reinterpret_cast(SDL_GL_GetProcAddress("glReadPixels")); + if (!read) + sdl_error("Screenshot readback"); + read(0, 0, width, height, 0x1908, 0x1401, pixels.data()); + for (int row = 0; row < height / 2; ++row) + for (int col = 0; col < width * 4; ++col) + std::swap(pixels[size_t(row) * width * 4 + col], + pixels[size_t(height - row - 1) * width * 4 + col]); +#endif + return pixels; +} +void report_start_error(const char *product, const std::string &message, bool dialog) noexcept { + std::fprintf(stderr, "%s: %s\n", product, message.c_str()); +#ifdef _WIN32 + try { + wchar_t directory[32768]{}; + const auto length = GetEnvironmentVariableW(L"LOCALAPPDATA", directory, 32768); + auto root = (length > 0 && length < 32768 ? std::filesystem::path(directory) + : std::filesystem::temp_directory_path()) / + L"OpenBMH"; + std::filesystem::create_directories(root); + std::ofstream log(root / (std::string(product) + "-startup.log"), std::ios::app); + log << message << '\n'; + if (dialog && !std::getenv("OPENBMH_NO_ERROR_DIALOG")) + MessageBoxW(nullptr, wide(message).c_str(), wide(product).c_str(), MB_OK | MB_ICONERROR); + } catch (...) { + if (dialog && !std::getenv("OPENBMH_NO_ERROR_DIALOG")) + MessageBoxW(nullptr, L"The application could not start.", L"OpenBMH", MB_OK | MB_ICONERROR); + } +#else + if (dialog && !std::getenv("OPENBMH_NO_ERROR_DIALOG")) + SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, product, message.c_str(), nullptr); +#endif +} +void attach_parent_console() noexcept { +#ifdef _WIN32 + const bool out_free = _fileno(stdout) < 0, err_free = _fileno(stderr) < 0; + if ((out_free || err_free) && AttachConsole(ATTACH_PARENT_PROCESS)) { + FILE *stream = nullptr; + if (out_free) + freopen_s(&stream, "CONOUT$", "w", stdout); + if (err_free) + freopen_s(&stream, "CONOUT$", "w", stderr); + } +#endif +} +} // namespace bmh::rml diff --git a/src/launch/rml_video.hpp b/src/launch/rml_video.hpp new file mode 100644 index 0000000..a45f7e6 --- /dev/null +++ b/src/launch/rml_video.hpp @@ -0,0 +1,74 @@ +// SPDX-License-Identifier: GPL-3.0-only +#pragma once +#include +#include +#include +#include +#ifdef _WIN32 +#ifndef NOMINMAX +#define NOMINMAX +#endif +#include +#include +#else +#include +#endif + +namespace bmh::rml { +// The native Windows renderer needs no OpenGL ICD in a Remote Desktop session. +// The device falls back to Microsoft's built-in WARP when hardware is absent. +class Video { + public: + SDL_Window *window = nullptr; + Video(const char *title, int width, int height, int minimum_width, int minimum_height); + ~Video(); + Video(const Video &) = delete; + Video &operator=(const Video &) = delete; + void drawable_size(int &width, int &height) const; + void present(); + // RGBA rows in top-to-bottom order, independent of the graphics API. + std::vector capture(int &width, int &height); +#ifdef _WIN32 + ID3D11Device *device() const { return device_.Get(); } + ID3D11RenderTargetView *target() const { return target_.Get(); } + void resize(int width, int height); +#endif + private: + void close() noexcept; +#ifdef _WIN32 + Microsoft::WRL::ComPtr device_; + Microsoft::WRL::ComPtr context_; + Microsoft::WRL::ComPtr swapchain_; + Microsoft::WRL::ComPtr target_; + int width_ = 0, height_ = 0; +#else + SDL_GLContext gl_ = nullptr; + bool loader_ = false; +#endif +}; + +#ifdef _WIN32 +class Renderer : public RenderInterface_DX11 { + Video &video_; + + public: + explicit Renderer(Video &video) : RenderInterface_DX11(video.device()), video_(video) {} + void SetViewport(int width, int height) { + video_.resize(width, height); + RenderInterface_DX11::SetViewport(width, height); + } + void Clear() { RenderInterface_DX11::Clear(video_.target()); } + void EndFrame() { RenderInterface_DX11::EndFrame(video_.target()); } + explicit operator bool() const { return video_.device() != nullptr; } +}; +#else +class Renderer : public RenderInterface_GL3 { + public: + explicit Renderer(Video &) {} +}; +#endif +// Also used before SDL initialization, so an unavailable graphics driver cannot +// prevent reporting the actual startup error. No preferences or tokens are logged. +void report_start_error(const char *product, const std::string &message, bool dialog = true) noexcept; +void attach_parent_console() noexcept; +} // namespace bmh::rml diff --git a/src/launch/rmlui.cmake b/src/launch/rmlui.cmake index 303cabc..ea73323 100644 --- a/src/launch/rmlui.cmake +++ b/src/launch/rmlui.cmake @@ -22,8 +22,15 @@ FetchContent_Declare(rmlui FetchContent_MakeAvailable(rmlui) add_library(bmh_rmlui STATIC ${rmlui_SOURCE_DIR}/Backends/RmlUi_Platform_SDL.cpp - ${rmlui_SOURCE_DIR}/Backends/RmlUi_Renderer_GL3.cpp) -target_include_directories(bmh_rmlui PUBLIC ${rmlui_SOURCE_DIR}/Backends) + ${CMAKE_SOURCE_DIR}/src/launch/rml_video.cpp) +if(WIN32) + target_sources(bmh_rmlui PRIVATE ${rmlui_SOURCE_DIR}/Backends/RmlUi_Renderer_DX11.cpp) + target_link_libraries(bmh_rmlui PUBLIC d3d11 dxgi d3dcompiler) + target_compile_definitions(bmh_rmlui PUBLIC NUM_MSAA_SAMPLES=1 NOMINMAX) +else() + target_sources(bmh_rmlui PRIVATE ${rmlui_SOURCE_DIR}/Backends/RmlUi_Renderer_GL3.cpp) +endif() +target_include_directories(bmh_rmlui PUBLIC ${rmlui_SOURCE_DIR}/Backends ${CMAKE_SOURCE_DIR}/src) target_compile_definitions(bmh_rmlui PUBLIC RMLUI_SDL_VERSION_MAJOR=2 RMLUI_NUM_MSAA_SAMPLES=0) target_link_libraries(bmh_rmlui PUBLIC RmlUi::Core ${BMH_SDL_TARGET} PRIVATE ${CMAKE_DL_LIBS}) diff --git a/tests/editor_startup_smoke.py b/tests/editor_startup_smoke.py new file mode 100644 index 0000000..f055a3e --- /dev/null +++ b/tests/editor_startup_smoke.py @@ -0,0 +1,72 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: GPL-3.0-only +"""Native graphics startup, including Windows Server/WARP and missing assets. + +Use an actual display (Xvfb on Linux). Never reads a user profile or game data. +Optionally opens the actual launcher UI too. Windows CI runs on Server 2022. +""" +import argparse +import json +import os +from pathlib import Path +import shutil +import struct +import subprocess +import tempfile + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('editor', type=Path) + parser.add_argument('--launcher', type=Path) + args = parser.parse_args() + # Non-ASCII + spaces exercise UTF-8 native loading and RmlUI URL paths. + with tempfile.TemporaryDirectory(prefix='OpenBMH Pr\u00fcfung ') as temporary: + root = Path(temporary) + executable = args.editor.resolve() + env = {**os.environ, 'OPENBMH_RML_DRIVER': 'warp', 'OPENBMH_NO_ERROR_DIALOG': '1', + 'LIBGL_ALWAYS_SOFTWARE': '1', 'SDL_AUDIODRIVER': 'dummy'} + if os.name == 'nt': + env['SDL_VIDEODRIVER'] = 'windows' + # Copy the GUI and its own assets, rather than finding files via cwd. + installed = root / 'Programme'; installed.mkdir() + exe = installed / executable.name + shutil.copy2(executable, exe) + shutil.copytree(executable.parent / 'assets/editor', installed / 'assets/editor') + for dll in executable.parent.glob('*.dll'): + shutil.copy2(dll, installed / dll.name) + settings = root / 'settings.json' + settings.write_text(json.dumps({'language': 'de', 'theme': 'midnight', 'mcp_enabled': False})) + for name, options in [('first-start', []), ('demo', ['--demo', '--page', 'regulations'])]: + screenshot = root / (name + '.png') + result = subprocess.run([str(exe), '--settings', str(settings), '--quit-after-ms', '1800', + '--screenshot', str(screenshot), *options], + cwd=root, env=env, capture_output=True, timeout=35) + assert result.returncode == 0, (name, result.returncode, result.stderr.decode(errors='replace')) + image = screenshot.read_bytes() + assert image[:8] == b'\x89PNG\r\n\x1a\n' and len(image) > 15000, name + width, height = struct.unpack_from('>II', image, 16) + assert width >= 1080 and height >= 720, (width, height) + if os.name == 'nt': + assert b'Direct3D 11 (WARP software)' in result.stderr, result.stderr + result = subprocess.run([str(exe), '--settings', str(settings), '--assets', str(root / 'missing-assets')], + cwd=root, env=env, capture_output=True, timeout=20) + assert result.returncode == 1 and b'ui_assets_missing' in result.stderr, result.stderr + # Also render and close the real launcher, without needing installed mods. + if args.launcher: + original = args.launcher.resolve() + launcher = installed / original.name + shutil.copy2(original, launcher) + shutil.copytree(original.parent / 'assets/launcher', installed / 'assets/launcher') + for dll in original.parent.glob('*.dll'): + shutil.copy2(dll, installed / dll.name) + result = subprocess.run([str(launcher)], cwd=root, env=env, capture_output=True, timeout=25) + assert result.returncode == 0, result.stderr + assert b'Native launcher rendered' in result.stdout, result.stdout + if os.name == 'nt': + assert b'Direct3D 11 (WARP software)' in result.stderr, result.stderr + print('Native first start, demo, Unicode asset paths, failure reporting and launcher startup passed') + + +if __name__ == '__main__': + main() diff --git a/tests/launcher_gui_smoke.cpp b/tests/launcher_gui_smoke.cpp new file mode 100644 index 0000000..51dcf72 --- /dev/null +++ b/tests/launcher_gui_smoke.cpp @@ -0,0 +1,33 @@ +// SPDX-License-Identifier: GPL-3.0-only +#include "launch/launcher_ui.hpp" +#include +#include +#include + +// Run explicitly on a real display (Windows CI also forces the WARP device), +// outside the dummy-video CTest suite. This constructs the actual launcher UI. +int main(int, char **) { + try { + auto ui = bmh::launch::make_launcher_ui(); + const auto timer = SDL_AddTimer( + 1600, + [](Uint32, void *) -> Uint32 { + SDL_Event event{}; + event.type = SDL_QUIT; + SDL_PushEvent(&event); + return 0; + }, + nullptr); + if (!timer) + throw std::runtime_error(SDL_GetError()); + const auto result = ui->next({}); + SDL_RemoveTimer(timer); + if (result.action != bmh::launch::LauncherAction::end) + return 1; + std::puts("Native launcher rendered and exited successfully"); + return 0; + } catch (const std::exception &error) { + std::fprintf(stderr, "%s\n", error.what()); + return 1; + } +}