MacOS build working.

.github/workflows/engine-build.yml

@@ -91,6 +91,10 @@ jobs:
           cp thirdparty/miniaudio/LICENSE artifact/OpenTS_THIRD_PARTY_LICENSES/miniaudio.txt
           cp thirdparty/licenses/stb-vorbis.txt artifact/OpenTS_THIRD_PARTY_LICENSES/stb-vorbis.txt
           cp thirdparty/licenses/lzo.txt artifact/OpenTS_THIRD_PARTY_LICENSES/lzo.txt
+          cp thirdparty/RmlUi/LICENSE.txt artifact/OpenTS_THIRD_PARTY_LICENSES/rmlui.txt
+          cp thirdparty/freetype/docs/FTL.TXT artifact/OpenTS_THIRD_PARTY_LICENSES/freetype.txt
+          cp thirdparty/licenses/zlib.txt artifact/OpenTS_THIRD_PARTY_LICENSES/zlib.txt
+          cp thirdparty/imgui/LICENSE.txt artifact/OpenTS_THIRD_PARTY_LICENSES/dear-imgui.txt
           cat thirdparty/licenses/khronos-vulkan-notice.txt \
               thirdparty/bgfx.cmake/bimg/3rdparty/astc-encoder/LICENSE.txt \
               > artifact/OpenTS_THIRD_PARTY_LICENSES/khronos-vulkan.txt

.gitmodules

@@ -4,3 +4,15 @@
 [submodule "thirdparty/miniaudio"]
 	path = thirdparty/miniaudio
 	url = https://github.com/mackron/miniaudio.git
+[submodule "thirdparty/SDL"]
+	path = thirdparty/SDL
+	url = https://github.com/libsdl-org/SDL.git
+[submodule "thirdparty/RmlUi"]
+	path = thirdparty/RmlUi
+	url = https://github.com/mikke89/RmlUi.git
+[submodule "thirdparty/freetype"]
+	path = thirdparty/freetype
+	url = https://github.com/freetype/freetype.git
+[submodule "thirdparty/imgui"]
+	path = thirdparty/imgui
+	url = https://github.com/ocornut/imgui.git

CMakeLists.txt

@@ -13,6 +13,7 @@ option(OPENTS_OFFICIAL_BUILD "Build as an official release of the declared versi
 
 option(OPENTS_EXPERIMENTAL_CLANG_CL "Build with clang-cl using the MSVC ABI" OFF)
 option(OPENTS_EXPERIMENTAL_X64 "Configure an unsupported 64-bit Windows build" OFF)
+option(OPENTS_EXPERIMENTAL_NATIVE "Configure a native build for the host platform" OFF)
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang"
    AND CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
@@ -34,14 +35,24 @@ elseif(MSVC)
             "writes are not interchangeable with a supported 32-bit build's, and nothing in "
             "the version stamp distinguishes them.")
     endif()
+elseif(OPENTS_EXPERIMENTAL_NATIVE)
+    message(STATUS "OpenTS: configuring an unsupported native build for the host platform.")
+
+    # The tree declares imports and exports with __declspec throughout, which clang only
+    # accepts with the Microsoft extensions enabled.
+    add_compile_options(-fms-extensions)
 else()
     message(FATAL_ERROR
         "OpenTS requires the Visual Studio 2022 MSVC toolchain. "
         "For the unsupported clang-cl experiment, configure with "
-        "-DCMAKE_TOOLCHAIN_FILE=cmake/toolchains/clang-cl-msvc.cmake.")
+        "-DCMAKE_TOOLCHAIN_FILE=cmake/toolchains/clang-cl-msvc.cmake. "
+        "For the unsupported native build, configure with "
+        "-DOPENTS_EXPERIMENTAL_NATIVE=ON.")
 endif()
 
-enable_language(RC)
+if(WIN32)
+    enable_language(RC)
+endif()
 
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
@@ -83,6 +94,11 @@ add_custom_target(OpenTSBuildStamp ALL
 )
 
 add_subdirectory(thirdparty)
+
+if(NOT WIN32)
+    add_subdirectory(platform)
+endif()
+
 add_subdirectory(code)
 add_subdirectory(code/language)
 

README.md

@@ -15,6 +15,10 @@ OpenTS is a community-led, open-source reconstruction of *Command & Conquer:
 Tiberian Sun*. Instead of patching or extending the retail executable, it
 rebuilds the engine as a standalone program.
 
+This fork carries a native Apple Silicon macOS build of that engine. See
+[Running on macOS](#running-on-macos) for the data script, the build and how to
+start it. Everything below describes OpenTS itself and applies here too.
+
 OpenTS gives equal weight to two goals: maintaining a playable engine and
 providing a capable platform for modding and engine development. Work on one
 goal should not come at the expense of the other.
@@ -70,6 +74,59 @@ UTF-8 code page, which needs Windows 10 version 1903 or newer. Older Windows
 keeps its own code page, so game text still shows, but a path or file name
 holding a character that code page lacks may fail.
 
+## Running on macOS
+
+This fork builds and runs the engine natively on Apple Silicon. The game data
+still comes from a copy of Tiberian Sun you own.
+
+Install the tools:
+
+```bash
+brew install cmake ninja
+brew install --cask steamcmd
+```
+
+Fetch the game data from your own Steam account:
+
+```bash
+./scripts/get-assets.sh <your_steam_username>
+```
+
+The script downloads app 2229880 into `Run/`, skips the Windows executables the
+engine replaces, and checks that the archives startup needs actually arrived.
+Steam Guard prompts for a code on first login. **Quit the Steam desktop client
+first**: steamcmd shares its data directory, and a running client holds a lock
+that makes steamcmd hang after "Verifying installation..." with no error. Set
+`OPENTS_GAME_DIR` to put the data somewhere other than `Run/`.
+
+Build the engine:
+
+```bash
+git submodule update --init --recursive
+cmake -S . -B build/native -G Ninja \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DOPENTS_EXPERIMENTAL_NATIVE=ON
+cmake --build build/native --target OpenTS
+```
+
+Build the `OpenTS` target rather than everything: the C++ test harnesses pass
+MSVC-only flags and link `kernel32`, so they do not configure here.
+
+Run it:
+
+```bash
+build/native/bin/Game -DATADIR=Run -USERDIR=build/native/user
+```
+
+`-USERDIR` is where saves, `SUN.INI` and logs are written, so pointing it at a
+scratch directory leaves an existing install untouched. Full screen is a
+setting in the display options screen.
+
+Windows supplies the window, message loop and cursor itself; every other
+platform gets them from `platform/win32compat`, which serves the Win32 surface
+the engine is written against out of [SDL](https://github.com/libsdl-org/SDL).
+[Building OpenTS](docs/BUILDING.md) covers the build in full.
+
 ## Documentation
 
 The [OpenTS manual](https://opents-developers.github.io/OpenTS/) documents

THIRD_PARTY_NOTICES.md

@@ -16,6 +16,10 @@ remains under its own license and copyright notices.
 | [miniaudio](https://github.com/mackron/miniaudio)                  | Audio device output, resampling, and WAV, FLAC, and MP3 decoding | MIT-0 or Unlicense |
 | [stb_vorbis](https://github.com/nothings/stb)                      | Ogg Vorbis decoding, bundled with miniaudio | MIT or Unlicense |
 | [LZO](https://www.oberhumer.com/opensource/lzo/)                   | LZO1X compression for maps, saves, and network blocks | GPL-2.0-or-later |
+| [RmlUi](https://github.com/mikke89/RmlUi)                          | User interface documents, styling, and layout | MIT          |
+| [FreeType](https://freetype.org/)                                  | Glyph rasterization for the RmlUi font engine | FTL          |
+| [zlib](https://zlib.net/)                                          | Compressed font stream support, bundled with FreeType | zlib         |
+| [Dear ImGui](https://github.com/ocornut/imgui)                     | Developer tooling on the UI shell         | MIT          |
 
 The source checkout keeps the license texts under `thirdparty/`. Binary
 packages reproduce the license texts for the components used by OpenTS under

cmake/StringTable.cmake

@@ -0,0 +1,183 @@
+# Builds the portable string table from the Windows resource script.
+#
+# The resource script is the only place the strings live, and only the RC compiler turns it
+# into a module resource. A host without an RC compiler still needs the same strings, so this
+# script reads the STRINGTABLE blocks out of the script, resolves each symbolic identifier
+# through the header the script itself includes, and writes a flat data file the game reads
+# at runtime. The Windows build is untouched and keeps using the compiled resource.
+#
+# Run with:
+#   cmake -DRC_FILE=<language.rc> -DHEADER_FILE=<language.h> -DOUTPUT=<file> -P StringTable.cmake
+#
+# NAME_TABLE names a second output, the table that turns a string's symbolic name back into
+# its identifier. UI documents reference a string by name, and this keeps the resource script
+# the only place a name and a number are paired.
+#
+# Encoding: the resource script carries "#pragma code_page(65001)", so its bytes are already
+# UTF-8 and are copied through unchanged. The data file is UTF-8 for the same reason.
+
+if(NOT DEFINED RC_FILE OR NOT DEFINED HEADER_FILE)
+    message(FATAL_ERROR "StringTable.cmake needs RC_FILE and HEADER_FILE")
+endif()
+
+if(NOT DEFINED OUTPUT AND NOT DEFINED NAME_TABLE)
+    message(FATAL_ERROR "StringTable.cmake needs OUTPUT, NAME_TABLE, or both")
+endif()
+
+# A semicolon separates list elements everywhere in this language, and at least one string
+# contains one. It is carried as a marker through every step that treats text as a list and
+# put back only when the record is written. No string contains "@", which is what makes the
+# marker safe to pick.
+set(SEMICOLON_MARK "@OPENTS_SEMI@")
+set(BACKSLASH_MARK "@OPENTS_BSLASH@")
+
+# ---------------------------------------------------------------------------------------------
+# The identifiers. The resource script names its strings symbolically and the header gives each
+# name its number.
+# ---------------------------------------------------------------------------------------------
+
+file(READ "${HEADER_FILE}" HEADER_TEXT)
+string(REGEX MATCHALL "#define[ \t]+[A-Za-z_][A-Za-z0-9_]*[ \t]+[0-9]+" HEADER_DEFINES "${HEADER_TEXT}")
+
+foreach(define IN LISTS HEADER_DEFINES)
+    string(REGEX MATCH "#define[ \t]+([A-Za-z_][A-Za-z0-9_]*)[ \t]+([0-9]+)" ignored "${define}")
+    set("ID_${CMAKE_MATCH_1}" "${CMAKE_MATCH_2}")
+endforeach()
+
+list(LENGTH HEADER_DEFINES DEFINE_COUNT)
+
+# ---------------------------------------------------------------------------------------------
+# The strings. Only the STRINGTABLE blocks are read; the dialog templates in the same script
+# hold quoted text that is not a string resource.
+# ---------------------------------------------------------------------------------------------
+
+file(READ "${RC_FILE}" RC_TEXT)
+string(REPLACE ";" "${SEMICOLON_MARK}" RC_TEXT "${RC_TEXT}")
+string(REPLACE "\r" "" RC_TEXT "${RC_TEXT}")
+string(REPLACE "\n" ";" RC_LINES "${RC_TEXT}")
+
+set(IN_TABLE FALSE)
+set(IN_BODY FALSE)
+set(PENDING_NAME "")
+set(RECORD_COUNT 0)
+set(RECORDS "")
+set(NAMES "")
+set(MISSING "")
+
+foreach(line IN LISTS RC_LINES)
+    if(NOT IN_TABLE)
+        if(line MATCHES "^STRINGTABLE([ \t]|$)")
+            set(IN_TABLE TRUE)
+        endif()
+        continue()
+    endif()
+
+    if(NOT IN_BODY)
+        if(line MATCHES "^BEGIN[ \t]*$")
+            set(IN_BODY TRUE)
+        endif()
+        continue()
+    endif()
+
+    if(line MATCHES "^END[ \t]*$")
+        set(IN_TABLE FALSE)
+        set(IN_BODY FALSE)
+        set(PENDING_NAME "")
+        continue()
+    endif()
+
+    set(name "")
+    set(raw "")
+    set(have_string FALSE)
+
+    if(line MATCHES "^[ \t]*([A-Za-z_][A-Za-z0-9_]*)[ \t]+\"(.*)\"[ \t]*$")
+        set(name "${CMAKE_MATCH_1}")
+        set(raw "${CMAKE_MATCH_2}")
+        set(have_string TRUE)
+    elseif(line MATCHES "^[ \t]*([A-Za-z_][A-Za-z0-9_]*)[ \t]*$")
+        set(PENDING_NAME "${CMAKE_MATCH_1}")
+        continue()
+    elseif(line MATCHES "^[ \t]*\"(.*)\"[ \t]*$")
+        set(name "${PENDING_NAME}")
+        set(raw "${CMAKE_MATCH_1}")
+        set(have_string TRUE)
+        set(PENDING_NAME "")
+    elseif(line MATCHES "^[ \t]*$")
+        continue()
+    else()
+        message(FATAL_ERROR "StringTable.cmake did not understand a STRINGTABLE line: ${line}")
+    endif()
+
+    if(NOT have_string)
+        continue()
+    endif()
+
+    if(name STREQUAL "")
+        message(FATAL_ERROR "StringTable.cmake found a string with no identifier: ${line}")
+    endif()
+
+    if(NOT DEFINED "ID_${name}")
+        list(APPEND MISSING "${name}")
+        continue()
+    endif()
+
+    # The escapes the resource compiler understands, in the order that keeps an escaped
+    # backslash from being read twice.
+    string(REPLACE "\\\\" "${BACKSLASH_MARK}" raw "${raw}")
+    string(REPLACE "\\n" "\n" raw "${raw}")
+    string(REPLACE "\\r" "\r" raw "${raw}")
+    string(REPLACE "\\t" "\t" raw "${raw}")
+    string(REPLACE "\\\"" "\"" raw "${raw}")
+    string(REPLACE "\"\"" "\"" raw "${raw}")
+    string(REPLACE "${BACKSLASH_MARK}" "\\" raw "${raw}")
+    string(REPLACE "${SEMICOLON_MARK}" ";" raw "${raw}")
+
+    string(LENGTH "${raw}" length)
+
+    # Length-prefixed, so a string that contains a newline needs no escaping of its own.
+    string(APPEND RECORDS "${ID_${name}} ${length}\n${raw}\n")
+    string(APPEND NAMES "OPENTS_STRING_NAME(\"${name}\", ${ID_${name}})\n")
+    math(EXPR RECORD_COUNT "${RECORD_COUNT} + 1")
+endforeach()
+
+if(IN_TABLE)
+    message(FATAL_ERROR "StringTable.cmake reached the end of ${RC_FILE} inside a STRINGTABLE")
+endif()
+
+if(MISSING)
+    list(REMOVE_DUPLICATES MISSING)
+    string(REPLACE ";" ", " MISSING_TEXT "${MISSING}")
+    message(FATAL_ERROR "StringTable.cmake found no identifier in ${HEADER_FILE} for: ${MISSING_TEXT}")
+endif()
+
+if(RECORD_COUNT EQUAL 0)
+    message(FATAL_ERROR "StringTable.cmake found no strings in ${RC_FILE}")
+endif()
+
+if(DEFINED OUTPUT)
+    get_filename_component(OUTPUT_DIR "${OUTPUT}" DIRECTORY)
+    if(OUTPUT_DIR)
+        file(MAKE_DIRECTORY "${OUTPUT_DIR}")
+    endif()
+
+    file(WRITE "${OUTPUT}" "OPENTS-STRINGS 1\n${RECORD_COUNT}\n${RECORDS}")
+
+    message(STATUS "String table: ${RECORD_COUNT} strings from ${DEFINE_COUNT} identifiers -> ${OUTPUT}")
+endif()
+
+# The name table is a list of invocations rather than a declaration, so the including file
+# decides what a pair becomes and the header carries no storage of its own.
+if(DEFINED NAME_TABLE)
+    get_filename_component(NAME_TABLE_DIR "${NAME_TABLE}" DIRECTORY)
+    if(NAME_TABLE_DIR)
+        file(MAKE_DIRECTORY "${NAME_TABLE_DIR}")
+    endif()
+
+    file(WRITE "${NAME_TABLE}"
+        "// Generated from language.rc by cmake/StringTable.cmake. Do not edit.\n"
+        "// Each line pairs a string resource's symbolic name with its identifier.\n"
+        "\n"
+        "${NAMES}")
+
+    message(STATUS "String names: ${RECORD_COUNT} names -> ${NAME_TABLE}")
+endif()