[qt_common] update translations

Signed-off-by: crueter <crueter@eden-emu.dev>

.ci/linux/build.sh

@@ -96,7 +96,6 @@ cmake .. -G Ninja \
     -DUSE_DISCORD_PRESENCE=ON \
     -DCMAKE_CXX_FLAGS="$ARCH_FLAGS" \
     -DCMAKE_C_FLAGS="$ARCH_FLAGS" \
-    -DYUZU_USE_BUNDLED_VCPKG=OFF \
     -DYUZU_USE_BUNDLED_QT=OFF \
     -DYUZU_USE_BUNDLED_SDL2=OFF \
     -DYUZU_USE_EXTERNAL_SDL2=ON \

.ci/windows/build.sh

@@ -43,17 +43,16 @@ export EXTRA_CMAKE_FLAGS=("${EXTRA_CMAKE_FLAGS[@]}" $@)
 mkdir -p build && cd build
 cmake .. -G Ninja \
     -DCMAKE_BUILD_TYPE="$BUILD_TYPE" \
-	-DENABLE_QT_TRANSLATION=ON \
+    -DENABLE_QT_TRANSLATION=ON \
     -DUSE_DISCORD_PRESENCE=ON \
-    -DYUZU_USE_BUNDLED_SDL2=OFF \
-    -DYUZU_USE_EXTERNAL_SDL2=ON \
+    -DYUZU_USE_BUNDLED_SDL2=ON \
     -DYUZU_TESTS=OFF \
     -DYUZU_CMD=OFF \
     -DYUZU_ROOM_STANDALONE=OFF \
     -DYUZU_USE_QT_MULTIMEDIA=$MULTIMEDIA \
     -DYUZU_USE_QT_WEB_ENGINE=$WEBENGINE \
     -DYUZU_ENABLE_LTO=ON \
-	  "${EXTRA_CMAKE_FLAGS[@]}"
+    "${EXTRA_CMAKE_FLAGS[@]}"
 
 ninja
 

.ci/windows/install-vulkan-sdk.ps1

@@ -4,7 +4,7 @@
 $ErrorActionPreference = "Stop"
 
 $VulkanSDKVer = "1.4.321.1"
-$ExeFile = "VulkanSDK-$VulkanSDKVer-Installer.exe"
+$ExeFile = "vulkansdk-windows-X64-$VulkanSDKVer.exe"
 $Uri = "https://sdk.lunarg.com/sdk/download/$VulkanSDKVer/windows/$ExeFile"
 $Destination = "./$ExeFile"
 
@@ -30,4 +30,4 @@ echo "Finished installing Vulkan SDK $VulkanSDKVer"
 if ("$env:GITHUB_ACTIONS" -eq "true") {
     echo "VULKAN_SDK=$VULKAN_SDK" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
     echo "$VULKAN_SDK/Bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-}
+}

.ci/windows/package.sh

@@ -3,11 +3,16 @@ GITREV=$(git show -s --format='%h')
 
 ZIP_NAME="Eden-Windows-${ARCH}-${GITDATE}-${GITREV}.zip"
 
-mkdir -p artifacts
-mkdir -p pack
+ARTIFACTS_DIR="artifacts"
+PKG_DIR="build/pkg"
 
-cp -r build/pkg/* pack
+mkdir -p "$ARTIFACTS_DIR"
 
-cp LICENSE* README* pack/
+TMP_DIR=$(mktemp -d)
 
-7z a -tzip artifacts/$ZIP_NAME pack/*
+cp -r "$PKG_DIR"/* "$TMP_DIR"/
+cp LICENSE* README* "$TMP_DIR"/
+
+7z a -tzip "$ARTIFACTS_DIR/$ZIP_NAME" "$TMP_DIR"/*
+
+rm -rf "$TMP_DIR"

.gitignore

@@ -52,3 +52,4 @@ Thumbs.db
 eden-windows-msvc
 artifacts
 *.AppImage*
+/install*

.patch/cpp-jwt/0001-no-install.patch

@@ -0,0 +1,47 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 8c1761f..52c4ca4 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -69,42 +69,3 @@ endif()
+ if(CPP_JWT_BUILD_EXAMPLES)
+   add_subdirectory(examples)
+ endif()
+-
+-# ##############################################################################
+-# INSTALL
+-# ##############################################################################
+-
+-include(GNUInstallDirs)
+-include(CMakePackageConfigHelpers)
+-set(CPP_JWT_CONFIG_INSTALL_DIR ${CMAKE_INSTALL_DATADIR}/cmake/${PROJECT_NAME})
+-
+-install(TARGETS ${PROJECT_NAME} EXPORT ${PROJECT_NAME}Targets)
+-install(
+-  EXPORT ${PROJECT_NAME}Targets
+-  DESTINATION ${CPP_JWT_CONFIG_INSTALL_DIR}
+-  NAMESPACE ${PROJECT_NAME}::
+-  COMPONENT dev)
+-configure_package_config_file(cmake/Config.cmake.in ${PROJECT_NAME}Config.cmake
+-                              INSTALL_DESTINATION ${CPP_JWT_CONFIG_INSTALL_DIR}
+-                              NO_SET_AND_CHECK_MACRO)
+-write_basic_package_version_file(${PROJECT_NAME}ConfigVersion.cmake
+-                                 COMPATIBILITY SameMajorVersion
+-                                 ARCH_INDEPENDENT)
+-install(
+-  FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
+-        ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
+-  DESTINATION ${CPP_JWT_CONFIG_INSTALL_DIR}
+-  COMPONENT dev)
+-
+-if(NOT CPP_JWT_USE_VENDORED_NLOHMANN_JSON)
+-  set(CPP_JWT_VENDORED_NLOHMANN_JSON_INSTALL_PATTERN PATTERN "json" EXCLUDE)
+-endif()
+-install(
+-  DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/jwt/
+-  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/jwt
+-  COMPONENT dev
+-  FILES_MATCHING
+-  PATTERN "*.hpp"
+-  PATTERN "*.ipp"
+-  PATTERN "test" EXCLUDE
+-  ${CPP_JWT_VENDORED_NLOHMANN_JSON_INSTALL_PATTERN})

.patch/cpp-jwt/0002-missing-decl.patch

@@ -0,0 +1,13 @@
+diff --git a/include/jwt/algorithm.hpp b/include/jwt/algorithm.hpp
+index 0e3b843..1156e6a 100644
+--- a/include/jwt/algorithm.hpp
++++ b/include/jwt/algorithm.hpp
+@@ -64,6 +64,8 @@ using verify_func_t = verify_result_t (*) (const jwt::string_view key,
+                                            const jwt::string_view head,
+                                            const jwt::string_view jwt_sign);
+ 
++verify_result_t is_secret_a_public_key(const jwt::string_view secret);
++
+ namespace algo {
+ 
+ //Me: TODO: All these can be done using code generaion.

.reuse/dep5

@@ -128,10 +128,6 @@ Copyright: 2020-2021 Its-Rei <kupfel@gmail.com>
            2020-2021 yuzu Emulator Project
 License: GPL-2.0-or-later
 
-Files: vcpkg.json
-Copyright: 2022 yuzu Emulator Project
-License: GPL-3.0-or-later
-
 Files: .github/ISSUE_TEMPLATE/*
 Copyright: 2022 yuzu Emulator Project
 License: GPL-2.0-or-later

CMakeLists.txt

@@ -5,8 +5,29 @@ cmake_minimum_required(VERSION 3.22)
 
 project(yuzu)
 
+if (${CMAKE_SYSTEM_NAME} STREQUAL "SunOS")
+    set(PLATFORM_SUN ON)
+elseif (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
+    set(PLATFORM_FREEBSD ON)
+elseif (${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD")
+    set(PLATFORM_OPENBSD ON)
+elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+    set(PLATFORM_LINUX ON)
+endif()
+
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules")
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/cmake-modules")
+if (PLATFORM_SUN)
+    # Terrific Solaris pkg shenanigans
+    list(APPEND CMAKE_PREFIX_PATH "/usr/lib/qt/6.6/lib/amd64/cmake")
+    list(APPEND CMAKE_MODULE_PATH "/usr/lib/qt/6.6/lib/amd64/cmake")
+    # For some mighty reason, doing a normal release build sometimes may not trigger
+    # the proper -O3 switch to materialize
+    if (CMAKE_BUILD_TYPE MATCHES "Release")
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O3")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
+    endif()
+endif()
 
 set(CPM_SOURCE_CACHE ${CMAKE_SOURCE_DIR}/.cache/cpm)
 
@@ -19,27 +40,22 @@ if (MSVC)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX-")
 endif()
 
-if (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
+if (PLATFORM_FREEBSD)
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L/usr/local/lib")
 endif()
 
-# Check if SDL2::SDL2 target exists; if not, create an alias
-if (TARGET SDL2::SDL2-static)
-    add_library(SDL2::SDL2 ALIAS SDL2::SDL2-static)
-elseif (TARGET SDL2::SDL2-shared)
-    add_library(SDL2::SDL2 ALIAS SDL2::SDL2-shared)
-endif()
-
 # Set bundled sdl2/qt as dependent options.
 # On Linux system SDL2 is likely to be lacking HIDAPI support which have drawbacks but is needed for SDL motion
-option(ENABLE_SDL2 "Enable the SDL2 frontend" ON)
-CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" ON "ENABLE_SDL2;MSVC" OFF)
-if (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
-    CMAKE_DEPENDENT_OPTION(YUZU_USE_EXTERNAL_SDL2 "Compile external SDL2" OFF "ENABLE_SDL2;NOT MSVC" OFF)
-else()
-    CMAKE_DEPENDENT_OPTION(YUZU_USE_EXTERNAL_SDL2 "Compile external SDL2" ON "ENABLE_SDL2;NOT MSVC" OFF)
+CMAKE_DEPENDENT_OPTION(ENABLE_SDL2 "Enable the SDL2 frontend" ON "NOT ANDROID" OFF)
+
+set(EXT_DEFAULT ON)
+
+if (PLATFORM_FREEBSD)
+    set(EXT_DEFAULT OFF)
 endif()
 
+CMAKE_DEPENDENT_OPTION(YUZU_USE_EXTERNAL_SDL2 "Compile external SDL2" ${EXT_DEFAULT} "ENABLE_SDL2;NOT MSVC" OFF)
+
 cmake_dependent_option(ENABLE_LIBUSB "Enable the use of LibUSB" ON "NOT ANDROID" OFF)
 
 option(ENABLE_OPENGL "Enable OpenGL" ON)
@@ -51,36 +67,15 @@ option(ENABLE_QT_UPDATE_CHECKER "Enable update checker for the Qt frontend" OFF)
 
 CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" "${MSVC}" "ENABLE_QT" OFF)
 
+option(YUZU_USE_CPM "Use CPM to fetch Eden dependencies if needed" ON)
+
 option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)
 option(ENABLE_WIFI_SCAN "Enable WiFi scanning" OFF)
 
-if (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
-    option(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" OFF)
-else()
-    option(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" ON)
-endif()
-
-if (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
-    option(YUZU_USE_EXTERNAL_VULKAN_HEADERS "Use Vulkan-Headers from externals" OFF)
-else()
-    option(YUZU_USE_EXTERNAL_VULKAN_HEADERS "Use Vulkan-Headers from externals" ON)
-endif()
-
-if (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
-    option(YUZU_USE_EXTERNAL_VULKAN_UTILITY_LIBRARIES "Use Vulkan-Utility-Libraries from externals" OFF)
-else()
-    option(YUZU_USE_EXTERNAL_VULKAN_UTILITY_LIBRARIES "Use Vulkan-Utility-Libraries from externals" ON)
-endif()
-
-if (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
-    option(YUZU_USE_EXTERNAL_VULKAN_SPIRV_TOOLS "Use SPIRV-Tools from externals" OFF)
-else()
-    option(YUZU_USE_EXTERNAL_VULKAN_SPIRV_TOOLS "Use SPIRV-Tools from externals" ON)
-endif()
-
-option(YUZU_USE_SYSTEM_OPUS "Use the system Opus library if available" ON)
-
-option(YUZU_USE_SYSTEM_HTTPLIB "Use the system cpp-httplib if available" ON)
+option(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" ${EXT_DEFAULT})
+option(YUZU_USE_EXTERNAL_VULKAN_HEADERS "Use Vulkan-Headers from externals" ${EXT_DEFAULT})
+option(YUZU_USE_EXTERNAL_VULKAN_UTILITY_LIBRARIES "Use Vulkan-Utility-Libraries from externals" ${EXT_DEFAULT})
+option(YUZU_USE_EXTERNAL_VULKAN_SPIRV_TOOLS "Use SPIRV-Tools from externals" ${EXT_DEFAULT})
 
 option(YUZU_USE_QT_MULTIMEDIA "Use QtMultimedia for Camera" OFF)
 
@@ -90,22 +85,22 @@ set(YUZU_QT_MIRROR "" CACHE STRING "What mirror to use for downloading the bundl
 
 option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)
 
-option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)
+CMAKE_DEPENDENT_OPTION(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF "ENABLE_QT" OFF)
 
 option(ENABLE_MICROPROFILE "Enables microprofile capabilities" OFF)
 
 option(YUZU_TESTS "Compile tests" "${BUILD_TESTING}")
 
-if (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
-    option(YUZU_USE_PRECOMPILED_HEADERS "Use precompiled headers" OFF)
-else()
-    option(YUZU_USE_PRECOMPILED_HEADERS "Use precompiled headers" ON)
-endif()
+option(YUZU_USE_PRECOMPILED_HEADERS "Use precompiled headers" ${EXT_DEFAULT})
 
 option(YUZU_DOWNLOAD_ANDROID_VVL "Download validation layer binary for android" ON)
 
 option(FORCE_DOWNLOAD_WIN_BUNDLES "Forcefully download bundled Windows dependencies (useful for CI)" OFF)
 
+if (YUZU_USE_CPM AND ENABLE_SDL2)
+    option(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 build" "${MSVC}")
+endif()
+
 CMAKE_DEPENDENT_OPTION(YUZU_ROOM "Enable dedicated room functionality" ON "NOT ANDROID" OFF)
 
 CMAKE_DEPENDENT_OPTION(YUZU_ROOM_STANDALONE "Enable standalone room executable" ON "YUZU_ROOM" OFF)
@@ -114,13 +109,7 @@ CMAKE_DEPENDENT_OPTION(YUZU_CMD "Compile the eden-cli executable" ON "NOT ANDROI
 
 CMAKE_DEPENDENT_OPTION(YUZU_CRASH_DUMPS "Compile crash dump (Minidump) support" OFF "WIN32 OR LINUX" OFF)
 
-option(YUZU_USE_BUNDLED_VCPKG "Use vcpkg for yuzu dependencies" "${MSVC}")
-
-if (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
-    option(YUZU_CHECK_SUBMODULES "Check if submodules are present" OFF)
-else()
-    option(YUZU_CHECK_SUBMODULES "Check if submodules are present" ON)
-endif()
+option(YUZU_CHECK_SUBMODULES "Check if submodules are present" ${EXT_DEFAULT})
 
 option(YUZU_ENABLE_LTO "Enable link-time optimization" OFF)
 
@@ -133,12 +122,7 @@ CMAKE_DEPENDENT_OPTION(YUZU_USE_FASTER_LD "Check if a faster linker is available
 CMAKE_DEPENDENT_OPTION(USE_SYSTEM_MOLTENVK "Use the system MoltenVK lib (instead of the bundled one)" OFF "APPLE" OFF)
 
 set(DEFAULT_ENABLE_OPENSSL ON)
-if (ANDROID OR WIN32 OR APPLE OR ${CMAKE_SYSTEM_NAME} STREQUAL "SunOS")
-    set(DEFAULT_ENABLE_OPENSSL OFF)
-endif()
-option(ENABLE_OPENSSL "Enable OpenSSL backend for ISslConnection" ${DEFAULT_ENABLE_OPENSSL})
-
-if (ANDROID OR WIN32 OR APPLE)
+if (ANDROID OR WIN32 OR APPLE OR PLATFORM_SUN)
     # - Windows defaults to the Schannel backend.
     # - macOS defaults to the SecureTransport backend.
     # - Android currently has no SSL backend as the NDK doesn't include any SSL
@@ -147,8 +131,17 @@ if (ANDROID OR WIN32 OR APPLE)
     # your own copy of it.
     set(DEFAULT_ENABLE_OPENSSL OFF)
 endif()
+
+if (ENABLE_WEB_SERVICE)
+    set(DEFAULT_ENABLE_OPENSSL ON)
+endif()
+
 option(ENABLE_OPENSSL "Enable OpenSSL backend for ISslConnection" ${DEFAULT_ENABLE_OPENSSL})
 
+if (ENABLE_OPENSSL)
+    CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_OPENSSL "Download bundled OpenSSL build" "${MSVC}" "NOT ANDROID" ON)
+endif()
+
 if (ANDROID AND YUZU_DOWNLOAD_ANDROID_VVL)
     set(vvl_version "sdk-1.3.261.1")
     set(vvl_zip_file "${CMAKE_BINARY_DIR}/externals/vvl-android.zip")
@@ -172,67 +165,6 @@ if (ANDROID)
     set(CMAKE_POLICY_VERSION_MINIMUM 3.5) # Workaround for Oboe
 endif()
 
-if (YUZU_USE_BUNDLED_VCPKG)
-    if (ANDROID)
-        set(ENV{ANDROID_NDK_HOME} "${ANDROID_NDK}")
-        list(APPEND VCPKG_MANIFEST_FEATURES "android")
-
-        if (CMAKE_ANDROID_ARCH_ABI STREQUAL "arm64-v8a")
-            set(VCPKG_TARGET_TRIPLET "arm64-android")
-            # this is to avoid CMake using the host pkg-config to find the host
-            # libraries when building for Android targets
-            set(PKG_CONFIG_EXECUTABLE "aarch64-none-linux-android-pkg-config" CACHE FILEPATH "" FORCE)
-        elseif (CMAKE_ANDROID_ARCH_ABI STREQUAL "x86_64")
-            set(VCPKG_TARGET_TRIPLET "x64-android")
-            set(PKG_CONFIG_EXECUTABLE "x86_64-none-linux-android-pkg-config" CACHE FILEPATH "" FORCE)
-        else()
-            message(FATAL_ERROR "Unsupported Android architecture ${CMAKE_ANDROID_ARCH_ABI}")
-        endif()
-    endif()
-
-    if (MSVC)
-        set(VCPKG_DOWNLOADS_PATH ${PROJECT_SOURCE_DIR}/externals/vcpkg/downloads)
-        set(NASM_VERSION "2.16.01")
-        set(NASM_DESTINATION_PATH ${VCPKG_DOWNLOADS_PATH}/nasm-${NASM_VERSION}-win64.zip)
-        set(NASM_DOWNLOAD_URL "https://github.com/eden-emulator/ext-windows-bin/raw/master/nasm/nasm-${NASM_VERSION}-win64.zip")
-
-        if (NOT EXISTS ${NASM_DESTINATION_PATH})
-            file(DOWNLOAD ${NASM_DOWNLOAD_URL} ${NASM_DESTINATION_PATH} SHOW_PROGRESS STATUS NASM_STATUS)
-
-            if (NOT NASM_STATUS EQUAL 0)
-                # Warn and not fail since vcpkg is supposed to download this package for us in the first place
-                message(WARNING "External nasm vcpkg package download from ${NASM_DOWNLOAD_URL} failed with status ${NASM_STATUS}")
-            endif()
-        endif()
-    endif()
-
-    if (YUZU_TESTS)
-        list(APPEND VCPKG_MANIFEST_FEATURES "yuzu-tests")
-    endif()
-    if (ENABLE_WEB_SERVICE)
-        list(APPEND VCPKG_MANIFEST_FEATURES "web-service")
-    endif()
-    if (ANDROID)
-        list(APPEND VCPKG_MANIFEST_FEATURES "android")
-    endif()
-
-    include(CPM)
-    set(CPM_USE_LOCAL_PACKAGES OFF)
-
-    CPMAddPackage(
-        DOWNLOAD_ONLY YES
-        GIT_REPOSITORY "https://github.com/microsoft/vcpkg.git"
-        GIT_TAG "ea2a964f93"
-        CUSTOM_CACHE_KEY "ea2a"
-    )
-
-    include(${vcpkg_SOURCE_DIR}/scripts/buildsystems/vcpkg.cmake)
-elseif(NOT "$ENV{VCPKG_TOOLCHAIN_FILE}" STREQUAL "")
-    # Disable manifest mode (use vcpkg classic mode) when using a custom vcpkg installation
-    option(VCPKG_MANIFEST_MODE "")
-    include("$ENV{VCPKG_TOOLCHAIN_FILE}")
-endif()
-
 if (YUZU_USE_PRECOMPILED_HEADERS)
     if (MSVC AND CCACHE)
         # buildcache does not properly cache PCH files, leading to compilation errors.
@@ -242,12 +174,12 @@ if (YUZU_USE_PRECOMPILED_HEADERS)
         set(YUZU_USE_PRECOMPILED_HEADERS OFF CACHE BOOL "" FORCE)
     endif()
 endif()
+
 if (YUZU_USE_PRECOMPILED_HEADERS)
     message(STATUS "Using Precompiled Headers.")
     set(CMAKE_PCH_INSTANTIATE_TEMPLATES ON)
 endif()
 
-
 # Default to a Release build
 get_property(IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
 if (NOT IS_MULTI_CONFIG AND NOT CMAKE_BUILD_TYPE)
@@ -277,26 +209,55 @@ function(check_submodules_present)
             message(FATAL_ERROR "Git submodule ${module} not found. "
                 "Please run: \ngit submodule update --init --recursive")
         endif()
+        if (EXISTS "${PROJECT_SOURCE_DIR}/${module}/.git")
+            set(SUBMODULE_DIR "${PROJECT_SOURCE_DIR}/${module}")
+
+            execute_process(
+                COMMAND git rev-parse --short=10 HEAD
+                WORKING_DIRECTORY ${SUBMODULE_DIR}
+                OUTPUT_VARIABLE SUBMODULE_SHA
+            )
+
+            # would probably be better to do string parsing, but whatever
+            execute_process(
+                COMMAND git remote get-url origin
+                WORKING_DIRECTORY ${SUBMODULE_DIR}
+                OUTPUT_VARIABLE SUBMODULE_URL
+            )
+
+            string(REGEX REPLACE "\n|\r" "" SUBMODULE_SHA ${SUBMODULE_SHA})
+            string(REGEX REPLACE "\n|\r|\\.git" "" SUBMODULE_URL ${SUBMODULE_URL})
+
+            get_filename_component(SUBMODULE_NAME ${SUBMODULE_DIR} NAME)
+
+            set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_NAMES ${SUBMODULE_NAME})
+            set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_SHAS ${SUBMODULE_SHA})
+            set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_URLS ${SUBMODULE_URL})
+        endif()
     endforeach()
 endfunction()
 
 if(EXISTS ${PROJECT_SOURCE_DIR}/.gitmodules AND YUZU_CHECK_SUBMODULES)
     check_submodules_present()
 endif()
+
 configure_file(${PROJECT_SOURCE_DIR}/dist/compatibility_list/compatibility_list.qrc
     ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
     COPYONLY)
+
 if (EXISTS ${PROJECT_SOURCE_DIR}/dist/compatibility_list/compatibility_list.json)
     configure_file("${PROJECT_SOURCE_DIR}/dist/compatibility_list/compatibility_list.json"
         "${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json"
         COPYONLY)
 endif()
+
 if (ENABLE_COMPATIBILITY_LIST_DOWNLOAD AND NOT EXISTS ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
     message(STATUS "Downloading compatibility list for yuzu...")
     file(DOWNLOAD
         https://api.yuzu-emu.org/gamedb/
         "${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json" SHOW_PROGRESS)
 endif()
+
 if (NOT EXISTS ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
     file(WRITE ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json "")
 endif()
@@ -340,13 +301,20 @@ if (NOT DEFINED ARCHITECTURE)
     set(ARCHITECTURE_GENERIC 1)
     add_definitions(-DARCHITECTURE_GENERIC=1)
 endif()
+
 message(STATUS "Target architecture: ${ARCHITECTURE}")
 
+if (MSVC AND ARCHITECTURE_x86)
+    message(FATAL_ERROR "Attempting to build with the x86 environment is not supported. \
+        This can typically happen if you used the Developer Command Prompt from the start menu;\
+        instead, run vcvars64.bat directly, located at C:/Program Files/Microsoft Visual Studio/2022/Community/VC/Auxiliary/Build/vcvars64.bat")
+endif()
+
 if (UNIX)
     add_definitions(-DYUZU_UNIX=1)
 endif()
 
-if (ARCHITECTURE_arm64 AND (ANDROID OR APPLE OR ${CMAKE_SYSTEM_NAME} STREQUAL "Linux"))
+if (ARCHITECTURE_arm64 AND (ANDROID OR PLATFORM_LINUX))
     set(HAS_NCE 1)
     add_definitions(-DHAS_NCE=1)
 endif()
@@ -356,7 +324,7 @@ if (YUZU_ROOM)
 endif()
 
 # Build/optimization presets
-if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+if (PLATFORM_LINUX)
     if (ARCHITECTURE_x86_64)
         set(YUZU_BUILD_PRESET "custom" CACHE STRING "Build preset to use. One of: custom, generic, v3, zen2, zen4, native")
         if (${YUZU_BUILD_PRESET} STREQUAL "generic")
@@ -402,73 +370,207 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
 # System imported libraries
 # =======================================================================
 
-# Enforce the search mode of non-required packages for better and shorter failure messages
-# TODO(crueter): some of these should be converted to CPM
-find_package(enet 1.3 MODULE)
-find_package(fmt 8 REQUIRED)
-find_package(LLVM MODULE COMPONENTS Demangle)
-find_package(lz4 REQUIRED)
-find_package(nlohmann_json 3.8 REQUIRED)
-find_package(RenderDoc MODULE)
-find_package(SimpleIni MODULE)
-find_package(stb MODULE)
-find_package(ZLIB 1.2 REQUIRED)
-find_package(zstd 1.5 REQUIRED)
+include(CPMUtil)
 
-# TODO(crueter): Work around this
-if (NOT YUZU_USE_EXTERNAL_VULKAN_SPIRV_TOOLS)
-    find_package(PkgConfig REQUIRED)
-    pkg_check_modules(SPIRV-Tools REQUIRED SPIRV-Tools)
+# openssl funniness
+if (ENABLE_OPENSSL)
+    if (YUZU_USE_BUNDLED_OPENSSL)
+        AddJsonPackage(openssl)
+    endif()
+
+    find_package(OpenSSL 1.1.1 REQUIRED)
+endif()
+
+if (YUZU_USE_CPM)
+    message(STATUS "Fetching needed dependencies with CPM")
+
+    set(BUILD_SHARED_LIBS OFF)
+    set(BUILD_TESTING OFF)
+
+    # TODO(crueter): renderdoc?
+
+    # boost
+    set(BOOST_INCLUDE_LIBRARIES algorithm icl pool container heap asio headers process filesystem crc variant)
+    AddJsonPackage(boost)
+
+    # really annoying thing where boost::headers doesn't work with cpm
+    # TODO(crueter) investigate
+    set(BOOST_NO_HEADERS ${Boost_ADDED})
+
+    if (Boost_ADDED)
+        if (MSVC OR ANDROID)
+            add_compile_definitions(YUZU_BOOST_v1)
+        else()
+            message(WARNING "Using bundled Boost on a non-MSVC or Android system is not recommended. You are strongly encouraged to install Boost through your system's package manager.")
+        endif()
+
+        if (NOT MSVC)
+            # boost sucks
+            # Solaris (and probably other NIXes) need explicit pthread definition
+            if (PLATFORM_SUN)
+                set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthreads")
+                set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pthreads")
+            endif()
+
+            target_compile_options(boost_heap INTERFACE -Wno-shadow)
+            target_compile_options(boost_icl INTERFACE -Wno-shadow)
+            target_compile_options(boost_asio INTERFACE -Wno-conversion -Wno-implicit-fallthrough)
+        endif()
+    endif()
+
+    # fmt
+    AddJsonPackage(fmt)
+
+    # lz4
+    AddJsonPackage(lz4)
+
+    if (lz4_ADDED)
+        add_library(lz4::lz4 ALIAS lz4_static)
+    endif()
+
+    # nlohmann
+    AddJsonPackage(nlohmann)
+
+    # zlib
+    AddJsonPackage(zlib)
+
+    if (ZLIB_ADDED)
+        add_library(ZLIB::ZLIB ALIAS zlibstatic)
+    endif()
+
+    # zstd
+    AddJsonPackage(zstd)
+
+    if (zstd_ADDED)
+        add_library(zstd::zstd ALIAS libzstd_static)
+    endif()
+
+    # Catch2
+    if (YUZU_TESTS OR DYNARMIC_TESTS)
+        AddJsonPackage(catch2)
+    endif()
+
+    # ENet
+    AddJsonPackage(enet)
+
+    if (enet_ADDED)
+        target_include_directories(enet INTERFACE ${enet_SOURCE_DIR}/include)
+    endif()
+
+    # Opus
+    AddJsonPackage(opus)
+else()
+    # Enforce the search mode of non-required packages for better and shorter failure messages
+    find_package(fmt 8 REQUIRED)
+    find_package(LLVM MODULE COMPONENTS Demangle)
+    find_package(nlohmann_json 3.8 REQUIRED)
+    find_package(lz4 REQUIRED)
+    find_package(RenderDoc MODULE)
+    find_package(stb MODULE)
+    find_package(enet 1.3 MODULE REQUIRED)
+    find_package(Opus 1.3 MODULE REQUIRED)
+    find_package(ZLIB 1.2 REQUIRED)
+    find_package(zstd 1.5 REQUIRED MODULE)
+
+    if (YUZU_TESTS)
+        find_package(Catch2 3.0.1 REQUIRED)
+    endif()
+
+    if (CMAKE_SYSTEM_NAME STREQUAL "Linux" OR ANDROID)
+        find_package(gamemode 1.7 MODULE)
+    endif()
+
+    if (ENABLE_OPENSSL)
+        find_package(OpenSSL 1.1.1 REQUIRED)
+    endif()
+endif()
+
+if(NOT TARGET Boost::headers)
+    AddJsonPackage(boost_headers)
 endif()
 
 if (ENABLE_LIBUSB)
-    if (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
+    if (PLATFORM_FREEBSD)
         find_package(libusb MODULE)
     else()
         find_package(libusb 1.0.24 MODULE)
     endif()
 endif()
 
-if (YUZU_TESTS)
-    find_package(Catch2 3.0.1 REQUIRED)
+# DiscordRPC
+if (USE_DISCORD_PRESENCE)
+    AddJsonPackage(discord-rpc)
+
+    target_include_directories(discord-rpc INTERFACE ${discord-rpc_SOURCE_DIR}/include)
+    add_library(DiscordRPC::discord-rpc ALIAS discord-rpc)
 endif()
 
-if(ENABLE_OPENSSL)
-    find_package(OpenSSL 1.1.1 REQUIRED)
-endif()
+# SimpleIni
+AddJsonPackage(simpleini)
 
-if (CMAKE_SYSTEM_NAME STREQUAL "Linux" OR ANDROID)
-    find_package(gamemode 1.7 MODULE)
+# Most linux distros don't package cubeb, so enable regardless of cpm settings
+if(ENABLE_CUBEB)
+    AddJsonPackage(cubeb)
+
+    if (cubeb_ADDED)
+        if (NOT MSVC)
+            if (TARGET speex)
+                target_compile_options(speex PRIVATE -Wno-sign-compare)
+            endif()
+
+            set_target_properties(cubeb PROPERTIES COMPILE_OPTIONS "")
+            target_compile_options(cubeb INTERFACE
+                -Wno-implicit-const-int-float-conversion
+                -Wno-shadow
+                -Wno-missing-declarations
+                -Wno-return-type
+                -Wno-uninitialized
+            )
+        else()
+            target_compile_options(cubeb PRIVATE
+                /wd4456
+                /wd4458
+            )
+        endif()
+    endif()
 endif()
 
 # find SDL2 exports a bunch of variables that are needed, so its easier to do this outside of the YUZU_find_package
-# TODO(crueter): combine this all with CPM.
 if (ENABLE_SDL2)
-    if (YUZU_USE_BUNDLED_SDL2)
-        # Detect toolchain and platform
-        if ((MSVC_VERSION GREATER_EQUAL 1920) AND ARCHITECTURE_x86_64)
-            set(SDL2_VER "SDL2-2.32.8")
-        else()
-            message(FATAL_ERROR "No bundled SDL2 binaries for your toolchain. Disable YUZU_USE_BUNDLED_SDL2 and provide your own.")
-        endif()
-
-        if (DEFINED SDL2_VER)
-            download_bundled_external("sdl2/" ${SDL2_VER} "sdl2-bundled" SDL2_PREFIX)
-        endif()
-
-        set(SDL2_FOUND YES)
-        set(SDL2_INCLUDE_DIR "${SDL2_PREFIX}/include" CACHE PATH "Path to SDL2 headers")
-        set(SDL2_LIBRARY "${SDL2_PREFIX}/lib/x64/SDL2.lib" CACHE PATH "Path to SDL2 library")
-        set(SDL2_DLL_DIR "${SDL2_PREFIX}/lib/x64/" CACHE PATH "Path to SDL2.dll")
-
-        add_library(SDL2::SDL2 INTERFACE IMPORTED)
-        target_link_libraries(SDL2::SDL2 INTERFACE "${SDL2_LIBRARY}")
-        target_include_directories(SDL2::SDL2 INTERFACE "${SDL2_INCLUDE_DIR}")
-    elseif (YUZU_USE_EXTERNAL_SDL2)
+    if (YUZU_USE_EXTERNAL_SDL2)
         message(STATUS "Using SDL2 from externals.")
-    else()
-        find_package(SDL2 2.26.4 REQUIRED)
+        if (NOT WIN32)
+            # Yuzu itself needs: Atomic Audio Events Joystick Haptic Sensor Threads Timers
+            # Since 2.0.18 Atomic+Threads required for HIDAPI/libusb (see https://github.com/libsdl-org/SDL/issues/5095)
+            # Yuzu-cmd also needs: Video (depends on Loadso/Dlopen)
+            # CPUinfo also required for SDL Audio, at least until 2.28.0 (see https://github.com/libsdl-org/SDL/issues/7809)
+            set(SDL_UNUSED_SUBSYSTEMS
+                File Filesystem
+                Locale Power Render)
+            foreach(_SUB ${SDL_UNUSED_SUBSYSTEMS})
+              string(TOUPPER ${_SUB} _OPT)
+              set(SDL_${_OPT} OFF)
+            endforeach()
+
+            set(HIDAPI ON)
+        endif()
+
+        if (APPLE)
+            set(SDL_FILE ON)
+        endif()
+
+        if ("${YUZU_SYSTEM_PROFILE}" STREQUAL "steamdeck")
+            set(SDL_PIPEWIRE OFF) # build errors out with this on
+            AddJsonPackage("sdl2_steamdeck")
+        else()
+            AddJsonPackage("sdl2_generic")
+        endif()
+    elseif (YUZU_USE_BUNDLED_SDL2)
+        message(STATUS "Using bundled SDL2")
+        AddJsonPackage(sdl2)
     endif()
+
+    find_package(SDL2 2.26.4 REQUIRED)
 endif()
 
 # List of all FFmpeg components required
@@ -498,6 +600,24 @@ endfunction()
 
 add_subdirectory(externals)
 
+# pass targets from externals
+find_package(VulkanHeaders)
+find_package(VulkanUtilityLibraries)
+find_package(VulkanMemoryAllocator)
+find_package(SPIRV-Tools)
+
+if (ENABLE_WEB_SERVICE)
+    find_package(httplib)
+endif()
+
+if (ENABLE_WEB_SERVICE OR ENABLE_QT_UPDATE_CHECKER)
+    find_package(cpp-jwt)
+endif()
+
+if (ENABLE_SDL2)
+    find_package(SDL2)
+endif()
+
 if (ENABLE_QT)
     if (YUZU_USE_BUNDLED_QT)
         download_qt(6.8.3)
@@ -515,8 +635,10 @@ if (ENABLE_QT)
         find_package(Qt6 REQUIRED COMPONENTS Multimedia)
     endif()
 
-    if (UNIX AND NOT APPLE)
-        find_package(Qt6 REQUIRED COMPONENTS DBus GuiPrivate)
+    if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
+        find_package(Qt6 REQUIRED COMPONENTS DBus OPTIONAL_COMPONENTS GuiPrivate)
+    elseif (UNIX AND NOT APPLE)
+        find_package(Qt6 REQUIRED COMPONENTS DBus Gui)
     endif()
 
     if (ENABLE_QT_TRANSLATION)
@@ -545,7 +667,7 @@ endif()
 function(set_yuzu_qt_components)
     # Best practice is to ask for all components at once, so they are from the same version
     set(YUZU_QT_COMPONENTS2 Core Widgets Concurrent)
-    if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+    if (PLATFORM_LINUX)
         list(APPEND YUZU_QT_COMPONENTS2 DBus)
     endif()
     if (YUZU_USE_QT_MULTIMEDIA)
@@ -572,6 +694,11 @@ if (NOT YUZU_USE_BUNDLED_FFMPEG)
     # Use system installed FFmpeg
     #find_package(FFmpeg 4.3 REQUIRED QUIET COMPONENTS ${FFmpeg_COMPONENTS})
     find_package(FFmpeg REQUIRED QUIET COMPONENTS ${FFmpeg_COMPONENTS})
+
+    # TODO(crueter): Version
+    set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_NAMES FFmpeg)
+    set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_SHAS "unknown (system)")
+    set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_URLS "https://github.com/FFmpeg/FFmpeg")
 endif()
 
 if(ENABLE_QT)
@@ -584,7 +711,7 @@ endif()
 
 if (WIN32 AND YUZU_CRASH_DUMPS)
     set(BREAKPAD_VER "breakpad-c89f9dd")
-    download_bundled_external("breakpad/" ${BREAKPAD_VER} "breakpad-win" BREAKPAD_PREFIX)
+    download_bundled_external("breakpad/" ${BREAKPAD_VER} "breakpad-win" BREAKPAD_PREFIX "c89f9dd")
 
     set(BREAKPAD_CLIENT_INCLUDE_DIR "${BREAKPAD_PREFIX}/include")
     set(BREAKPAD_CLIENT_LIBRARY "${BREAKPAD_PREFIX}/lib/libbreakpad_client.lib")
@@ -722,7 +849,6 @@ else()
     set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT yuzu-cmd)
 endif()
 
-
 # Installation instructions
 # =========================
 

CMakeModules/CPMUtil.cmake

@@ -0,0 +1,592 @@
+# SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+# SPDX-FileCopyrightText: Copyright 2025 crueter
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+# Created-By: crueter
+# Docs will come at a later date, mostly this is to just reduce boilerplate
+# and some cmake magic to allow for runtime viewing of dependency versions
+
+# Future crueter: Wow this was a lie and a half, at this point I might as well make my own CPN
+# haha just kidding... unless?
+
+if (MSVC OR ANDROID)
+    set(BUNDLED_DEFAULT OFF)
+else()
+    set(BUNDLED_DEFAULT ON)
+endif()
+
+option(CPMUTIL_FORCE_BUNDLED
+    "Force bundled packages for all CPM depdendencies" ${BUNDLED_DEFAULT})
+
+option(CPMUTIL_FORCE_SYSTEM
+    "Force system packages for all CPM dependencies (NOT RECOMMENDED)" OFF)
+
+cmake_minimum_required(VERSION 3.22)
+include(CPM)
+
+# TODO(crueter): Better solution for separate cpmfiles e.g. per-directory
+set(CPMUTIL_JSON_FILE "${CMAKE_CURRENT_SOURCE_DIR}/cpmfile.json" CACHE STRING "Location of cpmfile.json")
+
+if (EXISTS ${CPMUTIL_JSON_FILE})
+    file(READ ${CPMUTIL_JSON_FILE} CPMFILE_CONTENT)
+else()
+    message(WARNING "[CPMUtil] cpmfile ${CPMUTIL_JSON_FILE} does not exist, AddJsonPackage will be a no-op")
+endif()
+
+# utility
+function(cpm_utils_message level name message)
+    message(${level} "[CPMUtil] ${name}: ${message}")
+endfunction()
+
+# utility
+function(array_to_list array length out)
+    math(EXPR range "${length} - 1")
+
+    foreach(IDX RANGE ${range})
+        string(JSON _element GET "${array}" "${IDX}")
+
+        list(APPEND NEW_LIST ${_element})
+    endforeach()
+
+    set("${out}" "${NEW_LIST}" PARENT_SCOPE)
+endfunction()
+
+# utility
+function(get_json_element object out member default)
+    string(JSON out_type ERROR_VARIABLE err TYPE "${object}" ${member})
+
+    if (err)
+        set("${out}" "${default}" PARENT_SCOPE)
+        return()
+    endif()
+
+    string(JSON outvar GET "${object}" ${member})
+
+    if (out_type STREQUAL "ARRAY")
+        string(JSON _len LENGTH "${object}" ${member})
+        # array_to_list("${outvar}" ${_len} outvar)
+        set("${out}_LENGTH" "${_len}" PARENT_SCOPE)
+    endif()
+
+    set("${out}" "${outvar}" PARENT_SCOPE)
+endfunction()
+
+# Kinda cancerous but whatever
+function(AddJsonPackage)
+    set(oneValueArgs
+        NAME
+
+        # these are overrides that can be generated at runtime, so can be defined separately from the json
+        DOWNLOAD_ONLY
+        SYSTEM_PACKAGE
+        BUNDLED_PACKAGE
+    )
+
+    set(multiValueArgs OPTIONS)
+
+    cmake_parse_arguments(JSON "" "${oneValueArgs}" "${multiValueArgs}"
+                          "${ARGN}")
+
+    list(LENGTH ARGN argnLength)
+    # single name argument
+    if(argnLength EQUAL 1)
+        set(JSON_NAME "${ARGV0}")
+    endif()
+
+    if (NOT DEFINED CPMFILE_CONTENT)
+        cpm_utils_message(WARNING ${name} "No cpmfile, AddJsonPackage is a no-op")
+        return()
+    endif()
+
+    if (NOT DEFINED JSON_NAME)
+        cpm_utils_message(FATAL_ERROR "json package" "No name specified")
+    endif()
+
+    string(JSON object ERROR_VARIABLE err GET "${CPMFILE_CONTENT}" "${JSON_NAME}")
+
+    if (err)
+        cpm_utils_message(FATAL_ERROR ${JSON_NAME} "Not found in cpmfile")
+    endif()
+
+    get_json_element("${object}" package package ${JSON_NAME})
+    get_json_element("${object}" repo repo "")
+    get_json_element("${object}" ci ci OFF)
+    get_json_element("${object}" version version "")
+
+    if (ci)
+        get_json_element("${object}" name name "${JSON_NAME}")
+        get_json_element("${object}" extension extension "tar.zst")
+        get_json_element("${object}" min_version min_version "")
+        get_json_element("${object}" cmake_filename cmake_filename "")
+        get_json_element("${object}" raw_disabled disabled_platforms "")
+
+        if (raw_disabled)
+            array_to_list("${raw_disabled}" ${raw_disabled_LENGTH} disabled_platforms)
+        else()
+            set(disabled_platforms "")
+        endif()
+
+        AddCIPackage(
+            VERSION ${version}
+            NAME ${name}
+            REPO ${repo}
+            PACKAGE ${package}
+            EXTENSION ${extension}
+            MIN_VERSION ${min_version}
+            DISABLED_PLATFORMS ${disabled_platforms}
+            CMAKE_FILENAME ${cmake_filename}
+        )
+        return()
+    endif()
+
+    get_json_element("${object}" hash hash "")
+    get_json_element("${object}" sha sha "")
+    get_json_element("${object}" url url "")
+    get_json_element("${object}" key key "")
+    get_json_element("${object}" tag tag "")
+    get_json_element("${object}" artifact artifact "")
+    get_json_element("${object}" git_version git_version "")
+    get_json_element("${object}" source_subdir source_subdir "")
+    get_json_element("${object}" bundled bundled "unset")
+    get_json_element("${object}" find_args find_args "")
+    get_json_element("${object}" raw_patches patches "")
+
+    # format patchdir
+    if (raw_patches)
+        math(EXPR range "${raw_patches_LENGTH} - 1")
+
+        foreach(IDX RANGE ${range})
+            string(JSON _patch GET "${raw_patches}" "${IDX}")
+
+            set(full_patch "${CMAKE_SOURCE_DIR}/.patch/${JSON_NAME}/${_patch}")
+            if (NOT EXISTS ${full_patch})
+                cpm_utils_message(FATAL_ERROR ${JSON_NAME} "specifies patch ${full_patch} which does not exist")
+            endif()
+
+            list(APPEND patches "${full_patch}")
+        endforeach()
+    endif()
+    # end format patchdir
+
+    # options
+    get_json_element("${object}" raw_options options "")
+
+    if (raw_options)
+        array_to_list("${raw_options}" ${raw_options_LENGTH} options)
+    endif()
+
+    set(options ${options} ${JSON_OPTIONS})
+
+    # end options
+
+    # system/bundled
+    if (bundled STREQUAL "unset" AND DEFINED JSON_BUNDLED_PACKAGE)
+        set(bundled ${JSON_BUNDLED_PACKAGE})
+    else()
+        set(bundled ON)
+    endif()
+
+    AddPackage(
+        NAME "${package}"
+        VERSION "${version}"
+        URL "${url}"
+        HASH "${hash}"
+        SHA "${sha}"
+        REPO "${repo}"
+        KEY "${key}"
+        PATCHES "${patches}"
+        OPTIONS "${options}"
+        FIND_PACKAGE_ARGUMENTS "${find_args}"
+        BUNDLED_PACKAGE "${bundled}"
+        SOURCE_SUBDIR "${source_subdir}"
+
+        GIT_VERSION ${git_version}
+        ARTIFACT ${artifact}
+        TAG ${tag}
+    )
+
+    # pass stuff to parent scope
+    set(${package}_ADDED "${${package}_ADDED}"
+        PARENT_SCOPE)
+    set(${package}_SOURCE_DIR "${${package}_SOURCE_DIR}"
+        PARENT_SCOPE)
+    set(${package}_BINARY_DIR "${${package}_BINARY_DIR}"
+        PARENT_SCOPE)
+
+endfunction()
+
+function(AddPackage)
+    cpm_set_policies()
+
+    # TODO(crueter): docs, git clone
+
+    #[[
+        URL configurations, descending order of precedence:
+        - URL [+ GIT_URL] -> bare URL fetch
+        - REPO + TAG + ARTIFACT -> github release artifact
+        - REPO + TAG -> github release archive
+        - REPO + SHA -> github commit archive
+        - REPO + BRANCH -> github branch
+
+        Hash configurations, descending order of precedence:
+        - HASH -> bare sha512sum
+        - HASH_SUFFIX -> hash grabbed from the URL + this suffix
+        - HASH_URL -> hash grabbed from a URL
+          * technically this is unsafe since a hacker can attack that url
+
+        NOTE: hash algo defaults to sha512
+    #]]
+    set(oneValueArgs
+        NAME
+        VERSION
+        GIT_VERSION
+
+        REPO
+        TAG
+        ARTIFACT
+        SHA
+        BRANCH
+
+        HASH
+        HASH_SUFFIX
+        HASH_URL
+        HASH_ALGO
+
+        URL
+        GIT_URL
+
+        KEY
+        BUNDLED_PACKAGE
+    )
+
+    set(multiValueArgs OPTIONS PATCHES)
+
+    cmake_parse_arguments(PKG_ARGS "" "${oneValueArgs}" "${multiValueArgs}"
+                          "${ARGN}")
+
+    if (NOT DEFINED PKG_ARGS_NAME)
+        cpm_utils_message(FATAL_ERROR "package" "No package name defined")
+    endif()
+
+    option(${PKG_ARGS_NAME}_FORCE_SYSTEM "Force the system package for ${PKG_ARGS_NAME}")
+    option(${PKG_ARGS_NAME}_FORCE_BUNDLED "Force the bundled package for ${PKG_ARGS_NAME}")
+
+    if (DEFINED PKG_ARGS_URL)
+        set(pkg_url ${PKG_ARGS_URL})
+
+        if (DEFINED PKG_ARGS_REPO)
+            set(pkg_git_url https://github.com/${PKG_ARGS_REPO})
+        else()
+            if (DEFINED PKG_ARGS_GIT_URL)
+                set(pkg_git_url ${PKG_ARGS_GIT_URL})
+            else()
+                set(pkg_git_url ${pkg_url})
+            endif()
+        endif()
+    elseif (DEFINED PKG_ARGS_REPO)
+        set(pkg_git_url https://github.com/${PKG_ARGS_REPO})
+
+        if (DEFINED PKG_ARGS_TAG)
+            set(pkg_key ${PKG_ARGS_TAG})
+
+            if(DEFINED PKG_ARGS_ARTIFACT)
+                set(pkg_url
+                    ${pkg_git_url}/releases/download/${PKG_ARGS_TAG}/${PKG_ARGS_ARTIFACT})
+            else()
+                set(pkg_url
+                    ${pkg_git_url}/archive/refs/tags/${PKG_ARGS_TAG}.tar.gz)
+            endif()
+        elseif (DEFINED PKG_ARGS_SHA)
+            set(pkg_url "${pkg_git_url}/archive/${PKG_ARGS_SHA}.zip")
+        else()
+            if (DEFINED PKG_ARGS_BRANCH)
+                set(PKG_BRANCH ${PKG_ARGS_BRANCH})
+            else()
+                cpm_utils_message(WARNING ${PKG_ARGS_NAME}
+                            "REPO defined but no TAG, SHA, BRANCH, or URL specified, defaulting to master")
+                set(PKG_BRANCH master)
+            endif()
+
+            set(pkg_url ${pkg_git_url}/archive/refs/heads/${PKG_BRANCH}.zip)
+        endif()
+    else()
+        cpm_utils_message(FATAL_ERROR ${PKG_ARGS_NAME} "No URL or repository defined")
+    endif()
+
+    cpm_utils_message(STATUS ${PKG_ARGS_NAME} "Download URL is ${pkg_url}")
+
+    if (DEFINED PKG_ARGS_GIT_VERSION)
+        set(git_version ${PKG_ARGS_GIT_VERSION})
+    elseif(DEFINED PKG_ARGS_VERSION)
+        set(git_version ${PKG_ARGS_VERSION})
+    endif()
+
+    if (NOT DEFINED PKG_ARGS_KEY)
+        if (DEFINED PKG_ARGS_SHA)
+            string(SUBSTRING ${PKG_ARGS_SHA} 0 4 pkg_key)
+            cpm_utils_message(DEBUG ${PKG_ARGS_NAME}
+                        "No custom key defined, using ${pkg_key} from sha")
+        elseif (DEFINED git_version)
+            set(pkg_key ${git_version})
+            cpm_utils_message(DEBUG ${PKG_ARGS_NAME}
+                        "No custom key defined, using ${pkg_key}")
+        elseif (DEFINED PKG_ARGS_TAG)
+            set(pkg_key ${PKG_ARGS_TAG})
+            cpm_utils_message(DEBUG ${PKG_ARGS_NAME}
+                        "No custom key defined, using ${pkg_key}")
+        else()
+            cpm_utils_message(WARNING ${PKG_ARGS_NAME}
+                        "Could not determine cache key, using CPM defaults")
+        endif()
+    else()
+        set(pkg_key ${PKG_ARGS_KEY})
+    endif()
+
+    if (DEFINED PKG_ARGS_HASH_ALGO)
+        set(hash_algo ${PKG_ARGS_HASH_ALGO})
+    else()
+        set(hash_algo SHA512)
+    endif()
+
+    if (DEFINED PKG_ARGS_HASH)
+        set(pkg_hash "${hash_algo}=${PKG_ARGS_HASH}")
+    elseif (DEFINED PKG_ARGS_HASH_SUFFIX)
+        # funny sanity check
+        string(TOLOWER ${hash_algo} hash_algo_lower)
+        string(TOLOWER ${PKG_ARGS_HASH_SUFFIX} suffix_lower)
+        if (NOT ${suffix_lower} MATCHES ${hash_algo_lower})
+            cpm_utils_message(WARNING
+                        "Hash algorithm and hash suffix do not match, errors may occur")
+        endif()
+
+        set(hash_url ${pkg_url}.${PKG_ARGS_HASH_SUFFIX})
+    elseif (DEFINED PKG_ARGS_HASH_URL)
+        set(hash_url ${PKG_ARGS_HASH_URL})
+    else()
+        cpm_utils_message(WARNING ${PKG_ARGS_NAME}
+                    "No hash or hash URL found")
+    endif()
+
+    if (DEFINED hash_url)
+        set(outfile ${CMAKE_CURRENT_BINARY_DIR}/${PKG_ARGS_NAME}.hash)
+
+        # TODO(crueter): This is kind of a bad solution
+        # because "technically" the hash is invalidated each week
+        # but it works for now kjsdnfkjdnfjksdn
+        string(TOLOWER ${PKG_ARGS_NAME} lowername)
+        if (NOT EXISTS ${outfile} AND NOT EXISTS ${CPM_SOURCE_CACHE}/${lowername}/${pkg_key})
+            file(DOWNLOAD ${hash_url} ${outfile})
+        endif()
+
+        if (EXISTS ${outfile})
+            file(READ ${outfile} pkg_hash_tmp)
+        endif()
+
+        if (DEFINED ${pkg_hash_tmp})
+            set(pkg_hash "${hash_algo}=${pkg_hash_tmp}")
+        endif()
+    endif()
+
+    macro(set_precedence local force)
+        set(CPM_USE_LOCAL_PACKAGES ${local})
+        set(CPM_LOCAL_PACKAGES_ONLY ${force})
+    endmacro()
+
+    #[[
+        Precedence:
+        - package_FORCE_SYSTEM
+        - package_FORCE_BUNDLED
+        - CPMUTIL_FORCE_SYSTEM
+        - CPMUTIL_FORCE_BUNDLED
+        - BUNDLED_PACKAGE
+        - default to allow local
+    ]]#
+    if (${PKG_ARGS_NAME}_FORCE_SYSTEM)
+        set_precedence(ON ON)
+    elseif (${PKG_ARGS_NAME}_FORCE_BUNDLED)
+        set_precedence(OFF OFF)
+    elseif (CPMUTIL_FORCE_SYSTEM)
+        set_precedence(ON ON)
+    elseif(NOT CPMUTIL_FORCE_BUNDLED)
+        set_precedence(OFF OFF)
+    elseif (DEFINED PKG_ARGS_BUNDLED_PACKAGE)
+        if (PKG_ARGS_BUNDLED_PACKAGE)
+            set(local OFF)
+        else()
+            set(local ON)
+        endif()
+
+        set_precedence(${local} OFF)
+    else()
+        set_precedence(ON OFF)
+    endif()
+
+    CPMAddPackage(
+        NAME ${PKG_ARGS_NAME}
+        VERSION ${PKG_ARGS_VERSION}
+        URL ${pkg_url}
+        URL_HASH ${pkg_hash}
+        CUSTOM_CACHE_KEY ${pkg_key}
+        DOWNLOAD_ONLY ${PKG_ARGS_DOWNLOAD_ONLY}
+        FIND_PACKAGE_ARGUMENTS ${PKG_ARGS_FIND_PACKAGE_ARGUMENTS}
+
+        OPTIONS ${PKG_ARGS_OPTIONS}
+        PATCHES ${PKG_ARGS_PATCHES}
+        EXCLUDE_FROM_ALL ON
+
+        ${PKG_ARGS_UNPARSED_ARGUMENTS}
+    )
+
+    set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_NAMES ${PKG_ARGS_NAME})
+    set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_URLS ${pkg_git_url})
+
+    if (${PKG_ARGS_NAME}_ADDED)
+        if (DEFINED PKG_ARGS_SHA)
+            set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_SHAS
+                         ${PKG_ARGS_SHA})
+        elseif(DEFINED git_version)
+            set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_SHAS
+                         ${git_version})
+        elseif (DEFINED PKG_ARGS_TAG)
+            set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_SHAS
+                         ${PKG_ARGS_TAG})
+        else()
+            cpm_utils_message(WARNING ${PKG_ARGS_NAME}
+                        "Package has no specified sha, tag, or version")
+            set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_SHAS "unknown")
+        endif()
+    else()
+        if (DEFINED CPM_PACKAGE_${PKG_ARGS_NAME}_VERSION AND NOT
+            "${CPM_PACKAGE_${PKG_ARGS_NAME}_VERSION}" STREQUAL "")
+            set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_SHAS
+                         "${CPM_PACKAGE_${PKG_ARGS_NAME}_VERSION} (system)")
+        else()
+            set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_SHAS
+                         "unknown (system)")
+        endif()
+    endif()
+
+    # pass stuff to parent scope
+    set(${PKG_ARGS_NAME}_ADDED "${${PKG_ARGS_NAME}_ADDED}"
+        PARENT_SCOPE)
+    set(${PKG_ARGS_NAME}_SOURCE_DIR "${${PKG_ARGS_NAME}_SOURCE_DIR}"
+        PARENT_SCOPE)
+    set(${PKG_ARGS_NAME}_BINARY_DIR "${${PKG_ARGS_NAME}_BINARY_DIR}"
+        PARENT_SCOPE)
+
+endfunction()
+
+function(add_ci_package key)
+    set(ARTIFACT ${ARTIFACT_NAME}-${key}-${ARTIFACT_VERSION}.${ARTIFACT_EXT})
+
+    AddPackage(
+        NAME ${ARTIFACT_PACKAGE}
+        REPO ${ARTIFACT_REPO}
+        TAG v${ARTIFACT_VERSION}
+        VERSION ${ARTIFACT_VERSION}
+        ARTIFACT ${ARTIFACT}
+
+        KEY ${key}
+        HASH_SUFFIX sha512sum
+        BUNDLED_PACKAGE ON
+    )
+
+    set(ARTIFACT_DIR ${${ARTIFACT_PACKAGE}_SOURCE_DIR} PARENT_SCOPE)
+endfunction()
+
+# name is the artifact name, package is for find_package override
+function(AddCIPackage)
+    set(oneValueArgs
+        VERSION
+        NAME
+        REPO
+        PACKAGE
+        EXTENSION
+        MIN_VERSION
+        DISABLED_PLATFORMS
+        CMAKE_FILENAME
+    )
+
+    cmake_parse_arguments(PKG_ARGS "" "${oneValueArgs}" "" ${ARGN})
+
+    if(NOT DEFINED PKG_ARGS_VERSION)
+        message(FATAL_ERROR "[CPMUtil] VERSION is required")
+    endif()
+    if(NOT DEFINED PKG_ARGS_NAME)
+        message(FATAL_ERROR "[CPMUtil] NAME is required")
+    endif()
+    if(NOT DEFINED PKG_ARGS_REPO)
+        message(FATAL_ERROR "[CPMUtil] REPO is required")
+    endif()
+    if(NOT DEFINED PKG_ARGS_PACKAGE)
+        message(FATAL_ERROR "[CPMUtil] PACKAGE is required")
+    endif()
+
+    if (NOT DEFINED PKG_ARGS_CMAKE_FILENAME)
+        set(ARTIFACT_CMAKE ${PKG_ARGS_NAME})
+    else()
+        set(ARTIFACT_CMAKE ${PKG_ARGS_CMAKE_FILENAME})
+    endif()
+
+    if(NOT DEFINED PKG_ARGS_EXTENSION)
+        set(ARTIFACT_EXT "tar.zst")
+    else()
+        set(ARTIFACT_EXT ${PKG_ARGS_EXTENSION})
+    endif()
+
+    if (DEFINED PKG_ARGS_MIN_VERSION)
+        set(ARTIFACT_MIN_VERSION ${PKG_ARGS_MIN_VERSION})
+    endif()
+
+    if (DEFINED PKG_ARGS_DISABLED_PLATFORMS)
+        set(DISABLED_PLATFORMS ${PKG_ARGS_DISABLED_PLATFORMS})
+    endif()
+
+    # this is mildly annoying
+    set(ARTIFACT_VERSION ${PKG_ARGS_VERSION})
+    set(ARTIFACT_NAME ${PKG_ARGS_NAME})
+    set(ARTIFACT_REPO ${PKG_ARGS_REPO})
+    set(ARTIFACT_PACKAGE ${PKG_ARGS_PACKAGE})
+
+    if ((MSVC AND ARCHITECTURE_x86_64) AND NOT "windows-amd64" IN_LIST DISABLED_PLATFORMS)
+        add_ci_package(windows-amd64)
+    endif()
+
+    if ((MSVC AND ARCHITECTURE_arm64) AND NOT "windows-arm64" IN_LIST DISABLED_PLATFORMS)
+        add_ci_package(windows-arm64)
+    endif()
+
+    if (ANDROID AND NOT "android" IN_LIST DISABLED_PLATFORMS)
+        add_ci_package(android)
+    endif()
+
+    if(PLATFORM_SUN AND NOT "solaris" IN_LIST DISABLED_PLATFORMS)
+        add_ci_package(solaris)
+    endif()
+
+    if(PLATFORM_FREEBSD AND NOT "freebsd" IN_LIST DISABLED_PLATFORMS)
+        add_ci_package(freebsd)
+    endif()
+
+    if((PLATFORM_LINUX AND ARCHITECTURE_x86_64) AND NOT "linux" IN_LIST DISABLED_PLATFORMS)
+        add_ci_package(linux)
+    endif()
+
+    if((PLATFORM_LINUX AND ARCHITECTURE_arm64) AND NOT "linux-aarch64" IN_LIST DISABLED_PLATFORMS)
+        add_ci_package(linux-aarch64)
+    endif()
+
+    if (DEFINED ARTIFACT_DIR)
+        include(${ARTIFACT_DIR}/${ARTIFACT_CMAKE}.cmake)
+
+        set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_NAMES ${ARTIFACT_NAME})
+        set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_URLS "https://github.com/${ARTIFACT_REPO}") # TODO(crueter) other hosts?
+        set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_SHAS ${ARTIFACT_VERSION})
+
+        set(${ARTIFACT_PACKAGE}_ADDED TRUE PARENT_SCOPE)
+    else()
+        find_package(${ARTIFACT_PACKAGE} ${ARTIFACT_MIN_VERSION} REQUIRED)
+    endif()
+endfunction()

CMakeModules/CopyYuzuQt6Deps.cmake

@@ -63,6 +63,4 @@ function(copy_yuzu_Qt6_deps target_dir)
     else()
         # Update for non-MSVC platforms if needed
     endif()
-    # Fixes dark mode being forced automatically even when light theme is set in app settings.
-	file(WRITE "${CMAKE_BINARY_DIR}/bin/${CMAKE_BUILD_TYPE}/qt.conf" "[Platforms]\nWindowsArguments = darkmode=0")
 endfunction(copy_yuzu_Qt6_deps)

CMakeModules/DownloadExternals.cmake

@@ -6,7 +6,7 @@
 #   remote_path: path to the file to download, relative to the remote repository root
 #   prefix_var: name of a variable which will be set with the path to the extracted contents
 set(CURRENT_MODULE_DIR ${CMAKE_CURRENT_LIST_DIR})
-function(download_bundled_external remote_path lib_name cpm_key prefix_var)
+function(download_bundled_external remote_path lib_name cpm_key prefix_var version)
     set(package_base_url "https://github.com/eden-emulator/")
     set(package_repo "no_platform")
     set(package_extension "no_platform")
@@ -29,13 +29,15 @@ function(download_bundled_external remote_path lib_name cpm_key prefix_var)
     set(package_url "${package_base_url}${package_repo}")
     set(full_url ${package_url}${remote_path}${lib_name}${package_extension})
 
-    set(CPM_USE_LOCAL_PACKAGES OFF)
-
-    CPMAddPackage(
+    # TODO(crueter): DELETE THIS ENTIRELY, GLORY BE TO THE CI!
+    AddPackage(
         NAME ${cpm_key}
+        VERSION ${version}
         URL ${full_url}
         DOWNLOAD_ONLY YES
-        CUSTOM_CACHE_KEY ${CACHE_KEY}
+        KEY ${CACHE_KEY}
+        BUNDLED_PACKAGE ON
+        # TODO(crueter): hash
     )
 
     set(${prefix_var} "${${cpm_key}_SOURCE_DIR}" PARENT_SCOPE)
@@ -46,11 +48,8 @@ function(download_win_archives)
     set(FORCE_WIN_ARCHIVES ON)
     set(FFmpeg_EXT_NAME "ffmpeg-7.1.1")
 
-    download_bundled_external("ffmpeg/" ${FFmpeg_EXT_NAME} "ffmpeg-bundled" "")
+    download_bundled_external("ffmpeg/" ${FFmpeg_EXT_NAME} "ffmpeg-bundled" "" 7.1.1)
 
-    # TODO(crueter): separate handling for arm64
-    set(SDL2_VER "SDL2-2.32.8")
-    download_bundled_external("sdl2/" ${SDL2_VER} "sdl2-bundled" "")
     set(FORCE_WIN_ARCHIVES OFF)
 endfunction()
 

CMakeModules/FindSPIRV-Tools.cmake

@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: 2022 yuzu Emulator Project
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+include(FindPackageHandleStandardArgs)
+
+find_package(PkgConfig QUIET)
+pkg_search_module(SPIRV-Tools QUIET IMPORTED_TARGET SPIRV-Tools)
+find_package_handle_standard_args(SPIRV-Tools
+    REQUIRED_VARS SPIRV-Tools_LINK_LIBRARIES
+    VERSION_VAR SPIRV-Tools_VERSION
+)
+
+if (SPIRV-Tools_FOUND AND NOT TARGET SPIRV-Tools::SPIRV-Tools)
+    if (TARGET SPIRV-Tools)
+        add_library(SPIRV-Tools::SPIRV-Tools ALIAS SPIRV-Tools)
+    else()
+        add_library(SPIRV-Tools::SPIRV-Tools ALIAS PkgConfig::SPIRV-Tools)
+    endif()
+endif()

CMakeModules/Findzstd.cmake

@@ -3,17 +3,12 @@
 
 include(FindPackageHandleStandardArgs)
 
-find_package(zstd QUIET CONFIG)
-if (zstd_CONSIDERED_CONFIGS)
-    find_package_handle_standard_args(zstd CONFIG_MODE)
-else()
-    find_package(PkgConfig QUIET)
-    pkg_search_module(ZSTD QUIET IMPORTED_TARGET libzstd)
-    find_package_handle_standard_args(zstd
-        REQUIRED_VARS ZSTD_LINK_LIBRARIES
-        VERSION_VAR ZSTD_VERSION
-    )
-endif()
+find_package(PkgConfig QUIET)
+pkg_search_module(ZSTD QUIET IMPORTED_TARGET libzstd)
+find_package_handle_standard_args(zstd
+    REQUIRED_VARS ZSTD_LINK_LIBRARIES
+    VERSION_VAR ZSTD_VERSION
+)
 
 if (zstd_FOUND AND NOT TARGET zstd::zstd)
     if (TARGET zstd::libzstd_shared)

CMakeModules/GenerateDepHashes.cmake

@@ -0,0 +1,21 @@
+# SPDX-FileCopyrightText: 2025 Eden Emulator Project
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+get_property(NAMES GLOBAL PROPERTY CPM_PACKAGE_NAMES)
+get_property(SHAS GLOBAL PROPERTY CPM_PACKAGE_SHAS)
+get_property(URLS GLOBAL PROPERTY CPM_PACKAGE_URLS)
+
+list(LENGTH NAMES DEPS_LENGTH)
+
+list(JOIN NAMES "\",\n\t\"" DEP_NAME_DIRTY)
+set(DEP_NAMES "\t\"${DEP_NAME_DIRTY}\"")
+
+list(JOIN SHAS "\",\n\t\"" DEP_SHAS_DIRTY)
+set(DEP_SHAS "\t\"${DEP_SHAS_DIRTY}\"")
+
+list(JOIN URLS "\",\n\t\"" DEP_URLS_DIRTY)
+set(DEP_URLS "\t\"${DEP_URLS_DIRTY}\"")
+
+configure_file(dep_hashes.h.in dep_hashes.h @ONLY)
+target_sources(common PUBLIC ${CMAKE_CURRENT_BINARY_DIR}/dep_hashes.h)
+target_include_directories(common PUBLIC ${CMAKE_CURRENT_BINARY_DIR})

README.md

@@ -51,6 +51,7 @@ Check out our [website](https://eden-emu.dev) for the latest news on exciting fe
 ## Development
 
 Most of the development happens on our Git server. It is also where [our central repository](https://git.eden-emu.dev/eden-emu/eden) is hosted. For development discussions, please join us on [Discord](https://discord.gg/kXAmGCXBGD) or [Revolt](https://rvlt.gg/qKgFEAbH).
+You can also follow us on [X (Twitter)](https://x.com/edenemuofficial) for updates and announcements.
 
 If you would like to contribute, we are open to new developers and pull requests. Please ensure that your work is of a high standard and properly documented. You can also contact any of the developers on Discord or Revolt to learn more about the current state of the emulator.
 

cpmfile.json

@@ -0,0 +1,147 @@
+{
+    "openssl": {
+        "ci": true,
+        "package": "OpenSSL",
+        "name": "openssl",
+        "repo": "crueter-ci/OpenSSL",
+        "version": "3.5.2",
+        "min_version": "1.1.1"
+    },
+    "boost": {
+        "package": "Boost",
+        "repo": "boostorg/boost",
+        "tag": "boost-1.88.0",
+        "artifact": "boost-1.88.0-cmake.7z",
+        "hash": "e5b049e5b61964480ca816395f63f95621e66cb9bcf616a8b10e441e0e69f129e22443acb11e77bc1e8170f8e4171b9b7719891efc43699782bfcd4b3a365f01",
+        "git_version": "1.88.0",
+        "version": "1.57"
+    },
+    "fmt": {
+        "repo": "fmtlib/fmt",
+        "sha": "40626af88b",
+        "hash": "d59f06c24339f223de4ec2afeba1c67b5835a0f350a1ffa86242a72fc3e616a6b8b21798355428d4200c75287308b66634619ffa0b52ba5bd74cc01772ea1a8a",
+        "version": "8",
+        "options": [
+            "FMT_INSTALL OFF"
+        ]
+    },
+    "lz4": {
+        "name": "lz4",
+        "repo": "lz4/lz4",
+        "sha": "ebb370ca83",
+        "hash": "43600e87b35256005c0f2498fa56a77de6783937ba4cfce38c099f27c03188d097863e8a50c5779ca0a7c63c29c4f7ed0ae526ec798c1fd2e3736861b62e0a37",
+        "source_subdir": "build/cmake"
+    },
+    "nlohmann": {
+        "package": "nlohmann_json",
+        "repo": "nlohmann/json",
+        "sha": "55f93686c0",
+        "hash": "b739749b066800e21154506ea150d2c5cbce8a45344177f46f884547a1399d26753166fd0df8135269ce28cf223552b1b65cd625b88c844d54753f2434900486",
+        "version": "3.8"
+    },
+    "zlib": {
+        "package": "ZLIB",
+        "repo": "madler/zlib",
+        "sha": "51b7f2abda",
+        "hash": "16eaf1f3752489d12fd9ce30f7b5f7cbd5cb8ff53d617005a9847ae72d937f65e01e68be747f62d7ac19fd0c9aeba9956e60f16d6b465c5fdc2f3d08b4db2e6c",
+        "version": "1.2",
+        "options": [
+            "ZLIB_BUILD_SHARED OFF",
+            "ZLIB_INSTALL OFF"
+        ]
+    },
+    "zstd": {
+        "repo": "facebook/zstd",
+        "sha": "f8745da6ff",
+        "hash": "3037007f990040fe32573b46f9bef8762fd5dbeeb07ffffcbfeba51ec98167edae39bb9c87f9299efcd61c4e467c5e84f7c19f0df7799bc1fc04864a278792ee",
+        "version": "1.5",
+        "source_subdir": "build/cmake",
+        "find_args": "MODULE",
+        "options": [
+            "ZSTD_BUILD_SHARED OFF"
+        ]
+    },
+    "catch2": {
+        "package": "Catch2",
+        "repo": "catchorg/Catch2",
+        "sha": "644821ce28",
+        "hash": "f8795f98acf2c02c0db8e734cc866d5caebab4b4a306e93598b97cb3c0c728dafe8283dce27ffe8d42460e5ae7302f3f32e7e274a7f991b73511ac88eef21b1f",
+        "version": "3.0.1"
+    },
+    "enet": {
+        "repo": "lsalzman/enet",
+        "sha": "2662c0de09",
+        "hash": "3de1beb4fa3d6b1e03eda8dd1e7580694f854af3ed3975dcdabfdcdf76b97f322b9734d35ea7f185855bb490d957842b938b26da4dd2dfded509390f8d2794dd",
+        "version": "1.3",
+        "find_args": "MODULE"
+    },
+    "opus": {
+        "package": "Opus",
+        "repo": "xiph/opus",
+        "sha": "5ded705cf4",
+        "hash": "0dc89e58ddda1f3bc6a7037963994770c5806c10e66f5cc55c59286fc76d0544fe4eca7626772b888fd719f434bc8a92f792bdb350c807968b2ac14cfc04b203",
+        "version": "1.3",
+        "find_args": "MODULE",
+        "options": [
+            "OPUS_BUILD_TESTING OFF",
+            "OPUS_BUILD_PROGRAMS OFF",
+            "OPUS_INSTALL_PKG_CONFIG_MODULE OFF",
+            "OPUS_INSTALL_CMAKE_CONFIG_MODULE OFF"
+        ]
+    },
+    "cubeb": {
+        "repo": "mozilla/cubeb",
+        "sha": "fa02160712",
+        "hash": "82d808356752e4064de48c8fecbe7856715ade1e76b53937116bf07129fc1cc5b3de5e4b408de3cd000187ba8dc32ca4109661cb7e0355a52e54bd81b9be1c61",
+        "find_args": "CONFIG",
+        "options": [
+            "USE_SANITIZERS OFF",
+            "BUILD_TESTS OFF",
+            "BUILD_TOOLS OFF",
+            "BUNDLE_SPEEX ON"
+        ]
+    },
+    "boost_headers": {
+        "repo": "boostorg/headers",
+        "sha": "0456900fad",
+        "hash": "50cd75dcdfc5f082225cdace058f47b4fb114a47585f7aee1d22236a910a80b667186254c214fa2fcebac67ae6d37ba4b6e695e1faea8affd6fd42a03cf996e3",
+        "bundled": true
+    },
+    "discord-rpc": {
+        "repo": "eden-emulator/discord-rpc",
+        "sha": "1cf7772bb6",
+        "hash": "e9b35e6f2c075823257bcd59f06fe7bb2ccce1976f44818d2e28810435ef79c712a3c4f20f40da41f691342a4058cf86b078eb7f9d9e4dae83c0547c21ec4f97"
+    },
+    "simpleini": {
+        "package": "SimpleIni",
+        "repo": "brofield/simpleini",
+        "sha": "09c21bda1d",
+        "hash": "99779ca9b6e040d36558cadf484f9ffdab5b47bcc8fc72e4d33639d1d60c0ceb4410d335ba445d72a4324e455167fd6769d99b459943aa135bec085dff2d4b7c",
+        "find_args": "MODULE"
+    },
+    "sdl2_generic": {
+        "package": "SDL2",
+        "repo": "libsdl-org/SDL",
+        "sha": "54772f345a",
+        "hash": "2a68a0e01c390043aa9d9df63d8a20a52076c88bb460ac4e0f33194ca7d9bc8fadbbcc04e7506872ac4b6354a73fbc267c036f82200da59465789b87c7d9e3a4",
+        "key": "generic",
+        "bundled": true
+    },
+    "sdl2_steamdeck": {
+        "package": "SDL2",
+        "repo": "libsdl-org/SDL",
+        "sha": "cc016b0046",
+        "hash": "34d5ef58da6a4f9efa6689c82f67badcbd741f5a4f562a9c2c30828fa839830fb07681c5dc6a7851520e261c8405a416ac0a2c2513b51984fb3b4fa4dcb3e20b",
+        "key": "steamdeck",
+        "bundled": true
+    },
+    "sdl2": {
+        "ci": true,
+        "package": "SDL2",
+        "name": "SDL2",
+        "repo": "crueter-ci/SDL2",
+        "version": "2.32.8",
+        "min_version": "2.26.4",
+        "cmake_filename": "sdl2"
+    }
+}

dist/qt_themes/default/style.qss

@@ -95,6 +95,60 @@ QPushButton#button_reset_defaults {
     padding: 4px 8px;
 }
 
+/* QGroupBox --------------------------------------------------------------
+
+https://doc.qt.io/qt-5/stylesheet-examples.html#customizing-qgroupbox
+
+--------------------------------------------------------------------------- */
+QGroupBox {
+  border: 1px solid #32414B;
+  border-radius: 4px;
+  margin-top: 20px;
+  padding: 2px;
+}
+
+QGroupBox::title {
+  subcontrol-origin: margin;
+  subcontrol-position: top left;
+  padding-left: 3px;
+  padding-right: 5px;
+  padding-top: 2px;
+}
+
+QGroupBox::indicator {
+  margin-left: 2px;
+  height: 16px;
+  width: 16px;
+}
+
+QGroupBox::indicator:unchecked {
+  border: none;
+  image: url(":/qss_icons/rc/checkbox_unchecked.png");
+}
+
+QGroupBox::indicator:unchecked:hover, QGroupBox::indicator:unchecked:focus, QGroupBox::indicator:unchecked:pressed {
+  border: none;
+  image: url(":/qss_icons/rc/checkbox_unchecked_focus.png");
+}
+
+QGroupBox::indicator:unchecked:disabled {
+  image: url(":/qss_icons/rc/checkbox_unchecked_disabled.png");
+}
+
+QGroupBox::indicator:checked {
+  border: none;
+  image: url(":/qss_icons/rc/checkbox_checked.png");
+}
+
+QGroupBox::indicator:checked:hover, QGroupBox::indicator:checked:focus, QGroupBox::indicator:checked:pressed {
+  border: none;
+  image: url(":/qss_icons/rc/checkbox_checked_focus.png");
+}
+
+QGroupBox::indicator:checked:disabled {
+  image: url(":/qss_icons/rc/checkbox_checked_disabled.png");
+}
+
 QWidget#bottomPerGameInput,
 QWidget#topControllerApplet,
 QWidget#bottomControllerApplet,

dist/qt_themes/default_dark/style.qss

@@ -697,3 +697,29 @@ QDialog#QtSoftwareKeyboardDialog QPushButton#button_space:disabled,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_space_shift:disabled {
     image: url(:/overlay/osk_button_Y_disabled.png);
 }
+
+/* QGroupBox --------------------------------------------------------------
+
+https://doc.qt.io/qt-5/stylesheet-examples.html#customizing-qgroupbox
+
+--------------------------------------------------------------------------- */
+QGroupBox {
+  border: 1px solid #32414B;
+  border-radius: 4px;
+  margin-top: 22px;
+  padding: 2px;
+}
+
+QGroupBox::title {
+  subcontrol-origin: margin;
+  subcontrol-position: top left;
+  padding-left: 10px;
+  padding-right: 10px;
+  padding-top: 2px;
+}
+
+QGroupBox::indicator {
+  margin-left: 2px;
+  height: 16px;
+  width: 16px;
+}

dist/qt_themes/qdarkstyle/style.qss

@@ -307,7 +307,7 @@ QAbstractItemView QLineEdit {
 QGroupBox {
     border: 1px solid #54575B;
     border-radius: 2px;
-    margin-top: 12px;
+    margin-top: 20px;
     padding-top: 2px;
 }
 

dist/qt_themes/qdarkstyle_midnight_blue/style.qss

@@ -235,10 +235,9 @@ https://doc.qt.io/qt-5/stylesheet-examples.html#customizing-qgroupbox
 
 --------------------------------------------------------------------------- */
 QGroupBox {
-  font-weight: bold;
   border: 1px solid #32414B;
   border-radius: 4px;
-  margin-top: 12px;
+  margin-top: 20px;
   padding: 2px;
 }
 

docs/CPM.md

@@ -0,0 +1,252 @@
+# CPM
+
+CPM (CMake Package Manager) is the preferred method of managing dependencies within Eden.
+
+Global Options:
+
+- `YUZU_USE_CPM` is set by default on MSVC and Android. Other platforms should use this if certain "required" system dependencies (e.g. OpenSSL) are broken or missing
+  * If this is `OFF`, required system dependencies will be searched via `find_package`, although certain externals use CPM regardless.
+- `CPMUTIL_FORCE_SYSTEM` (default `OFF`): Require all CPM dependencies to use system packages. NOT RECOMMENDED!
+  * Many packages, e.g. mcl, sirit, xbyak, discord-rpc, are not generally available as a system package.
+  * You may optionally override these (see CPMUtil section)
+- `CPMUTIL_FORCE_BUNDLED` (default `ON` on MSVC and Android, `OFF` elsewhere): Require all CPM dependencies to use bundled packages.
+
+## CPMUtil
+
+CPMUtil is a wrapper around CPM that aims to reduce boilerplate and add useful utility functions to make dependency management a piece of cake.
+
+### AddPackage
+
+`AddPackage` is the core of the CPMUtil wrapper, and is generally the lowest level you will need to go when dealing with dependencies.
+
+**Identification/Fetching**
+
+- `NAME` (required): The package name (must be the same as the `find_package` name if applicable)
+- `VERSION`: The minimum version of this package that can be used on the system
+- `GIT_VERSION`: The version found within git, only used for identification
+- `URL`: The URL to fetch.
+- `REPO`: The GitHub repo to use (`owner/repo`).
+  * Only GitHub is supported for now, though other platforms will see support at some point
+- `TAG`: The tag to fetch, if applicable.
+- `ARTIFACT`: The name of the artifact, if applicable.
+- `SHA`: Commit sha to fetch, if applicable.
+- `BRANCH`: Branch to fetch, if applicable.
+
+The following configurations are supported, in descending order of precedence:
+
+- `URL`: Bare URL download, useful for custom artifacts
+  * If this is set, `GIT_URL` or `REPO` should be set to allow the dependency viewer to link to the project's Git repository.
+  * If this is NOT set, `REPO` must be defined.
+- `REPO + TAG + ARTIFACT`: GitHub release artifact
+  * The final download URL will be `https://github.com/${REPO}/releases/download/${TAG}/${ARTIFACT}`
+  * Useful for prebuilt libraries and prefetched archives
+- `REPO + TAG`: GitHub tag archive
+  * The final download URL will be `https://github.com/${REPO}/archive/refs/tags/${TAG}.tar.gz`
+  * Useful for pinning to a specific tag, better for build identification
+- `REPO + SHA`: GitHub commit archive
+  * The final download URL will be `https://github.com/${REPO}/archive/${SHA}.zip`
+  * Useful for pinning to a specific commit
+- `REPO + BRANCH`: GitHub branch archive
+  * The final download URL will be `https://github.com/${REPO}/archive/refs/heads/${BRANCH}.zip`
+  * Generally not recommended unless the branch is frozen
+- `REPO`: GitHub master archive
+  * The final download URL will be `https://github.com/${REPO}/archive/refs/heads/master.zip`
+  * Generally not recommended unless the project is dead
+
+**Hashing**
+
+Hashing is used for verifying downloads. It's highly recommended to use these.
+
+- `HASH_ALGO` (default `SHA512`): Hash algorithm to use
+
+Hashing strategies, descending order of precedence:
+
+- `HASH`: Bare hash verification, useful for static downloads e.g. commit archives
+- `HASH_SUFFIX`: Download the hash as `${DOWNLOAD_URL}.${HASH_SUFFIX}`
+  * The downloaded hash *must* match the hash algorithm and contain nothing but the hash; no filenames or extra content.
+- `HASH_URL`: Download the hash from a separate URL
+
+**Additional Options**
+
+- `KEY`: Custom cache key to use (stored as `.cache/cpm/${packagename_lower}/${key}`)
+  * Default is based on, in descending order of precedence:
+    - First 4 characters of the sha
+    - `GIT_VERSION`, or `VERSION` if not specified
+    - Tag
+    - Otherwise, CPM defaults will be used. This is not recommended as it doesn't produce reproducible caches
+- `DOWNLOAD_ONLY`: Whether or not to configure the downloaded package via CMake
+  * Useful to turn `OFF` if the project doesn't use CMake
+- `SOURCE_SUBDIR`: Subdirectory of the project containing a CMakeLists.txt file
+- `FIND_PACKAGE_ARGUMENTS`: Arguments to pass to the `find_package` call
+- `BUNDLED_PACKAGE`: Set to `ON` to force the usage of a bundled package
+- `OPTIONS`: Options to pass to the configuration of the package
+- `PATCHES`: Patches to apply to the package, stored in `.patch/${packagename_lower}/0001-patch-name.patch` and so on
+- Other arguments can be passed to CPM as well
+
+**Extra Variables**
+
+For each added package, users may additionally force usage of the system/bundled package.
+
+- `${package}_FORCE_SYSTEM`: Require the package to be installed on the system
+- `${package}_FORCE_BUNDLED`: Force the package to be fetched and use the bundled version
+
+**Bundled/System Switching**
+
+Descending order of precedence:
+- If `${package}_FORCE_SYSTEM` is true, requires the package to be on the system
+- If `${package}_FORCE_BUNDLED` is true, forcefully uses the bundled package
+- If `CPMUTIL_FORCE_SYSTEM` is true, requires the package to be on the system
+- If `CPMUTIL_FORCE_BUNDLED` is true, forcefully uses the bundled package
+- If the `BUNDLED_PACKAGE` argument is true, forcefully uses the bundled package
+- Otherwise, CPM will search for the package first, and if not found, will use the bundled package
+
+**Identification**
+
+All dependencies must be identifiable in some way for usage in the dependency viewer. Lists are provided in descending order of precedence.
+
+URLs:
+
+- `GIT_URL`
+- `REPO` as a GitHub repository
+- `URL`
+
+Versions (bundled):
+
+- `SHA`
+- `GIT_VERSION`
+- `VERSION`
+- `TAG`
+- "unknown"
+
+If the package is a system package, AddPackage will attempt to determine the package version and append ` (system)` to the identifier. Otherwise, it will be marked as `unknown (system)`
+
+### AddCIPackage
+
+Adds a package that follows crueter's CI repository spec.
+
+- `VERSION` (required): The version to get (the tag will be `v${VERSION}`)
+- `NAME` (required): Name used within the artifacts
+- `REPO` (required): CI repository, e.g. `crueter-ci/OpenSSL`
+- `PACKAGE` (required): `find_package` package name
+- `EXTENSION`: Artifact extension (default `tar.zst`)
+- `MIN_VERSION`: Minimum version for `find_package`. Only used if platform does not support this package as a bundled artifact
+- `DISABLED_PLATFORMS`: List of platforms that lack artifacts for this package. One of:
+  * `windows-amd64`
+  * `windows-arm64`
+  * `android`
+  * `solaris`
+  * `freebsd`
+  * `linux`
+  * `linux-aarch64`
+- `CMAKE_FILENAME`: Custom CMake filename, relative to the package root (default `${PACKAGE_ROOT}/${NAME}.cmake`)
+
+### AddJsonPackage
+
+This is the recommended method of usage for CPMUtil. In each directory that utilizes `CPMUtil`, there must be a `cpmfile.json` that defines dependencies in a similar manner to the individual calls.
+
+The cpmfile is an object of objects, with each sub-object being named according to the package's identifier, e.g. `openssl`, which can then be fetched with `AddJsonPackage(<identifier>)`. Options are designed to map closely to the argument names, and are always strings unless otherwise specified.
+
+- `package` -> `NAME` (`PACKAGE` for CI), defaults to the object key
+- `repo` -> `REPO`
+- `version` -> `VERSION`
+- `ci` (bool)
+
+If `ci` is `false`:
+
+- `hash` -> `HASH`
+- `sha` -> `SHA`
+- `tag` -> `TAG`
+- `artifact` -> `ARTIFACT`
+- `git_version` -> `GIT_VERSION`
+- `source_subdir` -> `SOURCE_SUBDIR`
+- `bundled` -> `BUNDLED_PACKAGE`
+- `find_args` -> `FIND_PACKAGE_ARGUMENTS`
+- `patches` -> `PATCHES` (array)
+- `options` -> `OPTIONS` (array)
+
+Other arguments aren't currently supported. If you wish to add them, see the `AddJsonPackage` function in `CMakeModules/CPMUtil.cmake`.
+
+If `ci` is `true`:
+
+- `name` -> `NAME`, defaults to the object key
+- `extension` -> `EXTENSION`, defaults to `tar.zst`
+- `min_version` -> `MIN_VERSION`
+- `cmake_filename` -> `CMAKE_FILENAME`
+- `extension` -> `EXTENSION`
+
+### Examples
+
+In order: OpenSSL CI, Boost (tag + artifact), discord-rpc (sha + options + patches), Opus (options + find_args)
+
+```json
+{
+    "openssl": {
+        "ci": true,
+        "package": "OpenSSL",
+        "name": "openssl",
+        "repo": "crueter-ci/OpenSSL",
+        "version": "3.5.2",
+        "min_version": "1.1.1"
+    },
+    "boost": {
+        "package": "Boost",
+        "repo": "boostorg/boost",
+        "tag": "boost-1.88.0",
+        "artifact": "boost-1.88.0-cmake.7z",
+        "hash": "e5b049e5b61964480ca816395f63f95621e66cb9bcf616a8b10e441e0e69f129e22443acb11e77bc1e8170f8e4171b9b7719891efc43699782bfcd4b3a365f01",
+        "git_version": "1.88.0",
+        "version": "1.57"
+    },
+    "opus": {
+        "package": "Opus",
+        "repo": "xiph/opus",
+        "sha": "5ded705cf4",
+        "hash": "0dc89e58ddda1f3bc6a7037963994770c5806c10e66f5cc55c59286fc76d0544fe4eca7626772b888fd719f434bc8a92f792bdb350c807968b2ac14cfc04b203",
+        "version": "1.3",
+        "find_args": "MODULE",
+        "options": [
+            "OPUS_BUILD_TESTING OFF",
+            "OPUS_BUILD_PROGRAMS OFF",
+            "OPUS_INSTALL_PKG_CONFIG_MODULE OFF",
+            "OPUS_INSTALL_CMAKE_CONFIG_MODULE OFF"
+        ]
+    },
+    "discord-rpc": {
+        "repo": "discord/discord-rpc",
+        "sha": "963aa9f3e5",
+        "hash": "386e1344e9a666d730f2d335ee3aef1fd05b1039febefd51aa751b705009cc764411397f3ca08dffd46205c72f75b235c870c737b2091a4ed0c3b061f5919bde",
+        "options": [
+            "BUILD_EXAMPLES OFF"
+        ],
+        "patches": [
+            "0001-cmake-version.patch",
+            "0002-no-clang-format.patch",
+            "0003-fix-cpp17.patch"
+        ]
+    },
+}
+```
+
+### Inclusion
+
+To include CPMUtil:
+
+```cmake
+set(CPMUTIL_JSON_FILE ${CMAKE_CURRENT_SOURCE_DIR}/cpmfile.json)
+include(CPMUtil)
+```
+
+You may omit the first line if you are not utilizing cpmfile.
+
+## Prefetching
+
+- To prefetch a CPM dependency (requires cpmfile):
+  * `tools/cpm-fetch.sh <packages>`
+- To prefetch all CPM dependencies:
+  * `tools/cpm-fetch-all.sh`
+
+Currently, `cpm-fetch.sh` defines the following directories for cpmfiles:
+
+`externals src/yuzu/externals externals/ffmpeg src/dynarmic/externals externals/nx_tzdb`
+
+Whenever you add a new cpmfile, update the script accordingly

docs/Development.md

@@ -1,12 +1,22 @@
 # Development
 
-* **Windows**: [Windows Building Guide](./docs/build/Windows.md)
-* **Linux**: [Linux Building Guide](./docs/build/Linux.md)
-* **Android**: [Android Building Guide](./docs/build/Android.md)
-* **Solaris**: [Solaris Building Guide](./docs/build/Solaris.md)
-* **FreeBSD**: [FreeBSD Building Guide](./docs/build/FreeBSD.md)
-* **macOS**: [macOS Building Guide](./docs/build/macOS.md)
+* **Windows**: [Windows Building Guide](./build/Windows.md)
+* **Linux**: [Linux Building Guide](./build/Linux.md)
+* **Android**: [Android Building Guide](./build/Android.md)
+* **Solaris**: [Solaris Building Guide](./build/Solaris.md)
+* **FreeBSD**: [FreeBSD Building Guide](./build/FreeBSD.md)
+* **macOS**: [macOS Building Guide](./build/macOS.md)
 
+# CPM
+
+CPM (CMake Package Manager) is the preferred method of managing dependencies within Eden. Documentation on adding dependencies/using CPMUtil is in the works.
+
+Notes:
+- `YUZU_USE_CPM` is set by default on MSVC and Android. Other platforms should use this if certain "required" system dependencies (e.g. OpenSSL) are broken or missing
+- `CPMUTIL_DEFAULT_SYSTEM` can be set to `OFF` to force the usage of bundled dependencies. This can marginally decrease the final package size.
+- When adding new prebuilt dependencies a la OpenSSL, SDL2, or FFmpeg, there *must* be a CMake option made available to forcefully download this bundle. See the OpenSSL implementation in the root CMakeLists for an example.
+  * This is necessary to allow for creation of fully-qualified source packs that allow for offline builds after download (some package managers and distros enforce this)
+	
 # Guidelines
 
 ## License Headers
@@ -76,9 +86,16 @@ cmake --build /tmp/ramdisk -- -j32
 sudo umount /tmp/ramdisk
 ```
 
-# How to test JIT
+## Debugging (host code)
 
-## gdb
+Ignoring SIGSEGV when debugging in host:
+
+- **gdb**: `handle all nostop pass`.
+- **lldb**: `pro hand -p true -s false -n false SIGSEGV`.
+
+## Debugging (guest code)
+
+### gdb
 
 Run `./build/bin/eden-cli -c <path to your config file (see logs where you run eden normally to see where it is)> -d -g <path to game>`
 
@@ -87,7 +104,7 @@ Then type `target remote localhost:1234` and type `c` (for continue) - and then
 
 ### gdb cheatsheet
 
-- `mo <cmd>`: Monitor commands, `get info`, `get fastmem` and `get mappings` are available.
+- `mo <cmd>`: Monitor commands, `get info`, `get fastmem` and `get mappings` are available. Type `mo help` for more info.
 - `detach`: Detach from remote (i.e restarting the emulator).
 - `c`: Continue
 - `p <expr>`: Print variable, `p/x <expr>` for hexadecimal.
@@ -104,12 +121,13 @@ Then type `target remote localhost:1234` and type `c` (for continue) - and then
 - `br <expr>`: Set breakpoint at `<expr>`.
 - `delete`: Deletes all breakpoints.
 - `catch throw`: Breakpoint at throw. Can also use `br __cxa_throw`
+- `br _mesa_error`: Break on mesa errors (set environment variable `MESA_DEBUG=1` beforehand), see [MESA_DEBUG](https://mesa-docs.readthedocs.io/en/latest/debugging.html).
 
 Expressions can be `variable_names` or `1234` (numbers) or `*var` (dereference of a pointer) or `*(1 + var)` (computed expression).
 
 For more information type `info gdb` and read [the man page](https://man7.org/linux/man-pages/man1/gdb.1.html).
 
-## Bisecting older commits
+# Bisecting older commits
 
 Since going into the past can be tricky (especially due to the dependencies from the project being lost thru time). This should "restore" the URLs for the respective submodules.
 

docs/build/FreeBSD.md

@@ -1,12 +1,13 @@
 ## One word of caution before proceeding.
+
 This is not the usual or preferred way to build programs on FreeBSD.
-As of writing there is no official fresh port available for eden-emu, but it is in the works.
-After it is available you can find a link to the eden-emu fresh port here and on Escarys github repo.
-See this build as an App Image alternative for FreeBSD.
+As of writing there is no official fresh port available for Eden, but it is in the works.
+After it is available you can find a link to the eden-emu fresh port here and on Escary's github repo.
+See this build as an AppImage alternative for FreeBSD.
 
 ## Dependencies.
 Before we start we need some dependencies.
-These dependencies are generally needed to build eden-emu on FreeBSD.
+These dependencies are generally needed to build Eden on FreeBSD.
 
 ```
 devel/cmake
@@ -56,8 +57,6 @@ Change into that build directory:
 cd build
 ```
 
-Now choose one option either 1 or 2, but not both as one option overwrites the other.
-
 #### 1. Building in Release Mode (usually preferred and the most performant choice):
 ```sh
 cmake .. -GNinja -DYUZU_TESTS=OFF
@@ -81,3 +80,6 @@ OR
 ```sh
 doas -- ninja install
 ```
+
+## OpenSSL
+The available OpenSSL port (3.0.17) is out-of-date, and using a bundled static library instead is recommended; to do so, add `-DYUZU_USE_CPM=ON` to your CMake configure command.

docs/build/Linux.md

@@ -10,31 +10,34 @@ The following are handled by Eden's externals:
 
   * [FFmpeg](https://ffmpeg.org/)
   * [SDL2](https://www.libsdl.org/download-2.0.php) 2.0.18+
-  * [opus](https://opus-codec.org/downloads/)
+  * [opus](https://opus-codec.org/downloads/) 1.3+
   
-All other dependencies will be downloaded by [vcpkg](https://vcpkg.io/) if needed:
+All other dependencies will be downloaded and built by [CPM](https://github.com/cpm-cmake/CPM.cmake/) if `YUZU_USE_CPM` is on, but will always use system dependencies if available:
 
   * [Boost](https://www.boost.org/users/download/) 1.79.0+
   * [Catch2](https://github.com/catchorg/Catch2) 2.13.7 - 2.13.9
   * [fmt](https://fmt.dev/) 8.0.1+
   * [lz4](http://www.lz4.org) 1.8+
   * [nlohmann_json](https://github.com/nlohmann/json) 3.8+
-  * [OpenSSL](https://www.openssl.org/source/)
+  * [OpenSSL](https://www.openssl.org/source/) 1.1.1+
   * [ZLIB](https://www.zlib.net/) 1.2+
   * [zstd](https://facebook.github.io/zstd/) 1.5+
+  * [enet](http://enet.bespin.org/) 1.3+
+  * [cubeb](https://github.com/mozilla/cubeb)
+  * [SimpleIni](https://github.com/brofield/simpleini)
 
-If an ARM64 build is intended, export `VCPKG_FORCE_SYSTEM_BINARIES=1`.
+Certain other dependencies (httplib, jwt, sirit, etc.) will be fetched by CPM regardless. System packages *can* be used for these libraries but this is generally not recommended.
 
 Dependencies are listed here as commands that can be copied/pasted. Of course, they should be inspected before being run.
 
 - Arch / Manjaro:
-  - `sudo pacman -Syu --needed base-devel boost catch2 cmake ffmpeg fmt git glslang libzip lz4 mbedtls ninja nlohmann-json openssl opus qt6-base qt6-multimedia sdl2 zlib zstd zip unzip`
+  - `sudo pacman -Syu --needed base-devel boost catch2 cmake enet ffmpeg fmt git glslang libzip lz4 mbedtls ninja nlohmann-json openssl opus qt6-base qt6-multimedia sdl2 zlib zstd zip unzip`
   - Building with QT Web Engine requires `qt6-webengine` as well.
   - Proper wayland support requires `qt6-wayland`
   - GCC 11 or later is required.
   
 - Ubuntu / Linux Mint / Debian:
-  - `sudo apt-get install autoconf cmake g++ gcc git glslang-tools libasound2 libboost-context-dev libglu1-mesa-dev libhidapi-dev libpulse-dev libtool libudev-dev libxcb-icccm4 libxcb-image0 libxcb-keysyms1 libxcb-render-util0 libxcb-xinerama0 libxcb-xkb1 libxext-dev libxkbcommon-x11-0 mesa-common-dev nasm ninja-build qt6-base-private-dev libmbedtls-dev catch2 libfmt-dev liblz4-dev nlohmann-json3-dev libzstd-dev libssl-dev libavfilter-dev libavcodec-dev libswscale-dev pkg-config zlib1g-dev`
+  - `sudo apt-get install autoconf cmake g++ gcc git glslang-tools libasound2 libboost-context-dev libglu1-mesa-dev libhidapi-dev libpulse-dev libtool libudev-dev libxcb-icccm4 libxcb-image0 libxcb-keysyms1 libxcb-render-util0 libxcb-xinerama0 libxcb-xkb1 libxext-dev libxkbcommon-x11-0 mesa-common-dev nasm ninja-build qt6-base-private-dev libmbedtls-dev catch2 libfmt-dev liblz4-dev nlohmann-json3-dev libzstd-dev libssl-dev libavfilter-dev libavcodec-dev libswscale-dev pkg-config zlib1g-dev libva-dev libvdpau-dev`
   - Ubuntu 22.04, Linux Mint 20, or Debian 12 or later is required.
   - Users need to manually specify building with QT Web Engine enabled.  This is done using the parameter `-DYUZU_USE_QT_WEB_ENGINE=ON` when running CMake.
   - Users need to manually disable building SDL2 from externals if they intend to use the version provided by their system by adding the parameters `-DYUZU_USE_EXTERNAL_SDL2=OFF`

docs/build/Solaris.md

@@ -8,73 +8,12 @@ Run the usual update + install of essential toolings: `sudo pkg update && sudo p
 - **gcc**: `sudo pkg install developer/gcc-14`.
 - **clang**: Version 20 is broken, use `sudo pkg install developer/clang-19`.
 
-Then install the libraies: `sudo pkg install qt6 boost glslang libzip library/lz4 nlohmann-json openssl opus sdl2 zlib compress/zstd unzip pkg-config nasm autoconf mesa library/libdrm header-drm`.
-
-fmtlib is not available on repositories and has to be manually built:
-```sh
-git clone --recurisve --depth=1 https://github.com/fmtlib/fmt.git
-cd fmt
-cmake -DCMAKE_BUILD_TYPE=Release -B build
-cmake --build build
-sudo cmake --install build
-```
-
-pkg lz4 doesn't provide a proper CMakeFile to find the library, has to also be manually built:
-```sh
-git clone --depth=1 https://github.com/lz4/lz4.git
-cd lz4
-gmake
-sudo gmake install
-```
-
-Same goes for zstd:
-```sh
-git clone --depth=1 https://github.com/facebook/zstd.git
-cd zstd
-cmake -DCMAKE_BUILD_TYPE=Release -B build0 -S build/cmake
-cmake --build build0
-cd build0
-sudo gmake install
-```
-
-pkg SDL2 is also not nice to work with on CMake, save yourself some pain and compile it yourself:
-```sh
-git clone --depth=1 --branch=release-2.32.8 https://github.com/libsdl-org/SDL
-cmake -DCMAKE_BUILD_TYPE=Release -B build
-cmake --build build
-sudo cmake --install build
-```
-
-Audio is broken in OpenIndiana [see this issue](https://github.com/libsdl-org/SDL/issues/13405), go into `SDL/CMakeLists.txt` and comment out lines 1468:
-```diff
-+#        set(SDL_AUDIO_DRIVER_SUNAUDIO 1)
-+#        file(GLOB SUN_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/sun/*.c)
-+#        list(APPEND SOURCE_FILES ${SUN_AUDIO_SOURCES})
-+#        set(HAVE_SDL_AUDIO TRUE)
-```
-For Solaris this issue does not exist - however PulseAudio crashes on Solaris - so use a different backend.
-
----
-
-### Build preparations:  
-Run the following command to clone eden with git:
-```sh
-git clone --recursive https://git.eden-emu.dev/eden-emu/eden
-```
-You usually want to add the `--recursive` parameter as it also takes care of the external dependencies for you.
-
-Now change into the eden directory and create a build directory there:
-```sh
-cd eden
-mkdir build
-```
-
-Change into that build directory: `cd build`
-
-Now choose one option either 1 or 2, but not both as one option overwrites the other.
+Then install the libraies: `sudo pkg install qt6 boost glslang libzip library/lz4 nlohmann-json openssl opus sdl2 zlib compress/zstd unzip pkg-config nasm autoconf mesa library/libdrm header-drm developer/fmt`.
 
 ### Building
 
+Clone eden with git `git clone --recursive https://git.eden-emu.dev/eden-emu/eden`
+
 ```sh
 # Needed for some dependencies that call cc directly (tz)
 echo '#!/bin/sh' >cc
@@ -83,12 +22,30 @@ chmod +x cc
 export PATH="$PATH:$PWD"
 ```
 
-- **Configure**: `cmake -B build -DYUZU_TESTS=OFF -DYUZU_USE_BUNDLED_SDL2=OFF -DYUZU_USE_EXTERNAL_SDL2=OFF -DYUZU_USE_LLVM_DEMANGLE=OFF -DYUZU_USE_QT_MULTIMEDIA=OFF -DYUZU_USE_QT_WEB_ENGINE=OFF -DYUZU_USE_BUNDLED_VCPKG=OFF -DYUZU_USE_BUNDLED_QT=OFF -DENABLE_QT=OFF -DSDL_AUDIO=OFF -DENABLE_WEB_SERVICE=OFF -DENABLE_QT_UPDATE_CHECKER=OFF`.
+Patch for FFmpeg:
+```sh
+sed -i 's/ make / gmake /' externals/ffmpeg/CMakeFiles/ffmpeg-build.dir/build.make
+```
+
+- **Configure**: `cmake -B build -DYUZU_USE_CPM=ON -DCMAKE_CXX_FLAGS="-I/usr/include/SDL2" -DCMAKE_C_FLAGS="-I/usr/include/SDL2"`.
 - **Build**: `cmake --build build`.
 - **Installing**: `sudo cmake --install build`.
 
+### Running
+
+Default Mesa is a bit outdated, the following environment variables should be set for a smoother experience:
+```sh
+export MESA_GL_VERSION_OVERRIDE=4.6
+export MESA_GLSL_VERSION_OVERRIDE=460
+export MESA_EXTENSION_MAX_YEAR=2025
+export MESA_DEBUG=1
+export MESA_VK_VERSION_OVERRIDE=1.3
+# Only if nvidia/intel drm drivers cause crashes, will severely hinder performance
+export LIBGL_ALWAYS_SOFTWARE=1
+```
+
 ### Notes
 
 - Modify the generated ffmpeg.make (in build dir) if using multiple threads (base system `make` doesn't use `-j4`, so change for `gmake`).
 - If using OpenIndiana, due to a bug in SDL2 cmake configuration; Audio driver defaults to SunOS `<sys/audioio.h>`, which does not exist on OpenIndiana.
-- Enabling OpenSSL requires compiling OpenSSL manually instead of using the provided one from repositores.
+- System OpenSSL generally does not work. Instead, use `-DYUZU_USE_CPM=ON` to use a bundled static OpenSSL, or build a system dependency from source.

docs/build/Windows.md

@@ -47,8 +47,6 @@ On Windows, all library dependencies are automatically included within the `exte
 
   * *(Note: If you used GitHub's own app to clone, run `git submodule update --init --recursive` to get the remaining dependencies)*
 
-* If you get an error about missing packages, enable `YUZU_USE_BUNDLED_VCPKG`, and then click Configure again.
-
   * *(You may also want to disable `YUZU_TESTS` in this case since Catch2 is not yet supported with this.)*
 
   ![13](https://user-images.githubusercontent.com/22451773/180585999-07316d6e-9751-4d11-b957-1cf57cd7cd58.png)
@@ -99,7 +97,7 @@ On Windows, all library dependencies are automatically included within the `exte
 
 ```bash
 mkdir build && cd build
-cmake -G "MSYS Makefiles" -DYUZU_USE_BUNDLED_VCPKG=ON -DYUZU_TESTS=OFF ..
+cmake -G "MSYS Makefiles" -DYUZU_TESTS=OFF ..
 make -j$(nproc)
 # test eden out with
 ./bin/eden.exe

externals/CMakeLists.txt

@@ -4,8 +4,12 @@
 # SPDX-FileCopyrightText: 2016 Citra Emulator Project
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-# cpm
-include(CPM)
+# TODO(crueter): A lot of this should be moved to the root.
+# otherwise we have to do weird shenanigans with library linking and stuff
+
+# Explicitly include CPMUtil here since we have a separate cpmfile for externals
+set(CPMUTIL_JSON_FILE ${CMAKE_CURRENT_SOURCE_DIR}/cpmfile.json)
+include(CPMUtil)
 
 # Explicitly declare this option here to propagate to the oaknut CPM call
 option(DYNARMIC_TESTS "Build tests" ${BUILD_TESTING})
@@ -29,35 +33,17 @@ endif()
 
 # Xbyak (also used by Dynarmic, so needs to be added first)
 if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
-    set(CPM_USE_LOCAL_PACKAGES OFF)
-
-    if ("${CMAKE_SYSTEM_NAME}" STREQUAL "SunOS")
-        # Fix regset.h collisions
-        set(XBYAK_HASH 51f507b0b3)
-        set(XBYAK_SHA512SUM 4a29a3c2f97f7d5adf667a21a008be03c951fb6696b0d7ba27e7e4afa037bc76eb5e059bb84860e01baf741d4d3ac851b840cd54c99d038812fbe0f1fa6d38a4)
+    if (PLATFORM_SUN)
+        AddJsonPackage(xbyak_sun)
     else()
-        set(XBYAK_HASH 4e44f4614d)
-        set(XBYAK_SHA512SUM 5824e92159e07fa36a774aedd3b3ef3541d0241371d522cffa4ab3e1f215fa5097b1b77865b47b2481376c704fa079875557ea463ca63d0a7fd6a8a20a589e70)
+        AddJsonPackage(xbyak)
     endif()
-
-    CPMAddPackage(
-        NAME xbyak
-        URL "https://github.com/Lizzie841/xbyak/archive/${XBYAK_HASH}.zip"
-        URL_HASH SHA512=${XBYAK_SHA512SUM}
-        CUSTOM_CACHE_KEY ${XBYAK_HASH}
-    )
 endif()
 
 # Oaknut (also used by Dynarmic, so needs to be added first)
 if (ARCHITECTURE_arm64 OR DYNARMIC_TESTS)
-    CPMAddPackage(
-        NAME oaknut
-        VERSION 2.0.1
-        URL "https://github.com/merryhime/oaknut/archive/94c726ce03.zip"
-        URL_HASH SHA512=d8d082242fa1881abce3c82f8dafa002c4e561e66a69e7fc038af67faa5eff2630f082d3d19579c88c4c9f9488e54552accc8cb90e7ce743efe043b6230c08ac
-        CUSTOM_CACHE_KEY "94c7"
-    )
-    endif()
+    AddJsonPackage(oaknut)
+endif()
 
 # getopt
 if (MSVC)
@@ -68,17 +54,7 @@ endif()
 add_subdirectory(glad)
 
 # mbedtls
-# TODO(crueter): test local mbedtls
-set(CPM_USE_LOCAL_PACKAGES ON)
-
-CPMAddPackage(
-    NAME mbedtls
-    URL "https://github.com/Mbed-TLS/mbedtls/archive/8c88150ca1.zip"
-    URL_HASH SHA512=769ad1e94c570671071e1f2a5c0f1027e0bf6bcdd1a80ea8ac970f2c86bc45ce4e31aa88d6d8110fc1bed1de81c48bc624df1b38a26f8b340a44e109d784a966
-    PATCHES
-        ${CMAKE_SOURCE_DIR}/.patch/mbedtls/0001-cmake-version.patch
-    CUSTOM_CACHE_KEY "8c88"
-)
+AddJsonPackage(mbedtls)
 
 if (mbedtls_ADDED)
     target_include_directories(mbedtls PUBLIC ${mbedtls_SOURCE_DIR}/include)
@@ -95,186 +71,39 @@ if (ENABLE_LIBUSB AND NOT TARGET libusb::usb)
     add_subdirectory(libusb)
 endif()
 
-# SDL2
-if (YUZU_USE_EXTERNAL_SDL2)
-    if (NOT WIN32)
-        # Yuzu itself needs: Atomic Audio Events Joystick Haptic Sensor Threads Timers
-        # Since 2.0.18 Atomic+Threads required for HIDAPI/libusb (see https://github.com/libsdl-org/SDL/issues/5095)
-        # Yuzu-cmd also needs: Video (depends on Loadso/Dlopen)
-        # CPUinfo also required for SDL Audio, at least until 2.28.0 (see https://github.com/libsdl-org/SDL/issues/7809)
-        set(SDL_UNUSED_SUBSYSTEMS
-            File Filesystem
-            Locale Power Render)
-        foreach(_SUB ${SDL_UNUSED_SUBSYSTEMS})
-          string(TOUPPER ${_SUB} _OPT)
-          set(SDL_${_OPT} OFF)
-        endforeach()
-
-        set(HIDAPI ON)
-    endif()
-    if (APPLE)
-        set(SDL_FILE ON)
-    endif()
-
-    include(CPM)
-    set(CPM_USE_LOCAL_PACKAGES OFF)
-
-    if ("${YUZU_SYSTEM_PROFILE}" STREQUAL "steamdeck")
-        set(SDL_HASH cc016b0046)
-        set(SDL_PIPEWIRE OFF) # build errors out with this on
-        set(SDL_SHA512SUM 34d5ef58da6a4f9efa6689c82f67badcbd741f5a4f562a9c2c30828fa839830fb07681c5dc6a7851520e261c8405a416ac0a2c2513b51984fb3b4fa4dcb3e20b)
-    elseif ("${CMAKE_SYSTEM_NAME}" STREQUAL "SunOS")
-        set(SDL_HASH d310b5679f)
-        set(SDL_SHA512SUM cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e)
-    else()
-        set(SDL_HASH 2e4c12cd2c)
-        set(SDL_SHA512SUM d95af47f469a312876f8ab361074a1e7b8083db19935a102d9c6e5887ace6008e64475a8c54b00164b40cad86492bb1b2366084efdd0b2555e5fea6d9c5da80e)
-    endif()
-
-    CPMAddPackage(
-        NAME SDL2
-        URL "https://github.com/libsdl-org/SDL/archive/${SDL_HASH}.zip"
-        URL_HASH SHA512=${SDL_SHA512SUM}
-        CUSTOM_CACHE_KEY "${YUZU_SYSTEM_PROFILE}"
-    )
-endif()
-
-# ENet
-if (NOT TARGET enet::enet)
-    add_subdirectory(enet)
-    target_include_directories(enet INTERFACE ./enet/include)
-    add_library(enet::enet ALIAS enet)
-endif()
-
-# TODO(crueter): Create a common CPMUtil.cmake that does this for me
-set(CPM_USE_LOCAL_PACKAGES ON)
-
-CPMAddPackage(
-    NAME cubeb
-    URL "https://github.com/mozilla/cubeb/archive/fa02160712.zip"
-    FIND_PACKAGE_ARGUMENTS "CONFIG" # not sure this works outside of gentoo
-    OPTIONS
-        "USE_SANITIZERS OFF"
-        "BUILD_TESTS OFF"
-        "BUILD_TOOLS OFF"
-    CUSTOM_CACHE_KEY "fa02"
-)
-
-if (cubeb_ADDED)
-    if (NOT MSVC)
-        if (TARGET speex)
-            target_compile_options(speex PRIVATE -Wno-sign-compare)
-        endif()
-
-        set_target_properties(cubeb PROPERTIES COMPILE_OPTIONS "")
-        target_compile_options(cubeb INTERFACE
-            -Wno-implicit-const-int-float-conversion
-            -Wno-shadow
-            -Wno-missing-declarations
-            -Wno-return-type
-            -Wno-maybe-uninitialized
-        )
-    else()
-        target_compile_options(cubeb PRIVATE
-            /wd4456
-            /wd4458
-        )
-    endif()
-endif()
-
-# DiscordRPC
-if (USE_DISCORD_PRESENCE)
-    set(CPM_USE_LOCAL_PACKAGES OFF)
-
-    CPMAddPackage(
-        NAME discord-rpc
-        URL "https://github.com/discord/discord-rpc/archive/963aa9f3e5.zip"
-        URL_HASH SHA512=386e1344e9a666d730f2d335ee3aef1fd05b1039febefd51aa751b705009cc764411397f3ca08dffd46205c72f75b235c870c737b2091a4ed0c3b061f5919bde
-        OPTIONS
-            "BUILD_EXAMPLES OFF"
-        PATCHES
-            ${CMAKE_SOURCE_DIR}/.patch/discord-rpc/0001-cmake-version.patch
-            ${CMAKE_SOURCE_DIR}/.patch/discord-rpc/0002-no-clang-format.patch
-            ${CMAKE_SOURCE_DIR}/.patch/discord-rpc/0003-fix-cpp17.patch
-        CUSTOM_CACHE_KEY "963a"
-    )
-
-    target_include_directories(discord-rpc INTERFACE ${discord-rpc_SOURCE_DIR}/include)
-    add_library(DiscordRPC::discord-rpc ALIAS discord-rpc)
-endif()
-
 # Sirit
 # TODO(crueter): spirv-tools doesn't work w/ system
-set(CPM_USE_LOCAL_PACKAGES OFF)
+set(SPIRV_WERROR OFF)
+AddJsonPackage(spirv-headers)
 
-CPMAddPackage(
-    NAME SPIRV-Headers
-    URL "https://github.com/KhronosGroup/SPIRV-Headers/archive/4e209d3d7e.zip"
-    URL_HASH SHA512=f48bbe18341ed55ea0fe280dbbbc0a44bf222278de6e716e143ca1e95ca320b06d4d23d6583fbf8d03e1428f3dac8fa00e5b82ddcd6b425e6236d85af09550a4
-    CUSTOM_CACHE_KEY "4e20"
-)
+AddJsonPackage(sirit)
 
-set(CPM_USE_LOCAL_PACKAGES ON)
-
-CPMAddPackage(
-    NAME sirit
-    URL "https://github.com/raphaelthegreat/sirit/archive/51fcf9720f.zip"
-    URL_HASH SHA512=a8f98ea0c51763b89924d836ad482ebdfe9130251cf4e14733ccaacc885ae8cc4c8b03d1dc43e8861609e5f7929c16f935879c1f6bf61866fd75077954774394
-    OPTIONS
-        "SIRIT_USE_SYSTEM_SPIRV_HEADERS ON"
-    CUSTOM_CACHE_KEY "51fc"
-)
+if(MSVC AND USE_CCACHE AND sirit_ADDED)
+    get_target_property(_opts sirit COMPILE_OPTIONS)
+    list(FILTER _opts EXCLUDE REGEX "/Zi")
+    list(APPEND _opts "/Z7")
+    set_target_properties(sirit PROPERTIES COMPILE_OPTIONS "${_opts}")
+endif()
 
 # httplib
-if ((ENABLE_WEB_SERVICE OR ENABLE_QT_UPDATE_CHECKER))
-    set(CPM_USE_LOCAL_PACKAGES ${YUZU_USE_SYSTEM_HTTPLIB})
-
-    # TODO(crueter): fix local package (gentoo?)
-    CPMAddPackage(
-        NAME httplib
-        VERSION 0.12
-        URL "https://github.com/yhirose/cpp-httplib/archive/a609330e4c.zip"
-        URL_HASH SHA512=dd3fd0572f8367d8549e1319fd98368b3e75801a293b0c3ac9b4adb806473a4506a484b3d389dc5bee5acc460cb90af7a20e5df705a1696b56496b30b9ce7ed2
-        FIND_PACKAGE_ARGUMENTS "MODULE"
-        OPTIONS
-            "HTTPLIB_REQUIRE_OPENSSL ON"
-        CUSTOM_CACHE_KEY "a609"
-    )
+if (ENABLE_WEB_SERVICE OR ENABLE_QT_UPDATE_CHECKER)
+    AddJsonPackage(httplib)
 endif()
 
 # cpp-jwt
 if (ENABLE_WEB_SERVICE)
-    set(CPM_USE_LOCAL_PACKAGES OFF)
-
-    CPMAddPackage(
-        NAME cpp-jwt
-        VERSION 1.4
-        URL "https://github.com/arun11299/cpp-jwt/archive/10ef5735d8.zip"
-        URL_HASH SHA512=ebba3d26b33a3b0aa909f475e099594560edbce10ecd03e76d7fea68549a28713ea606d363808f88a5495b62c54c3cdb7e47aee2d946eceabd36e310479dadb7
-        FIND_PACKAGE_ARGUMENTS "CONFIG"
-        OPTIONS
-            "CPP_JWT_BUILD_EXAMPLES OFF"
-            "CPP_JWT_BUILD_TESTS OFF"
-            "CPP_JWT_USE_VENDORED_NLOHMANN_JSON OFF"
-        CUSTOM_CACHE_KEY "10ef"
-    )
+    AddJsonPackage(cpp-jwt)
 endif()
 
-# Opus
-set(CPM_USE_LOCAL_PACKAGES ${YUZU_USE_SYSTEM_OPUS})
-
-CPMAddPackage(
-    NAME Opus
-    VERSION 1.3
-    URL "https://github.com/xiph/opus/archive/5ded705cf4.zip"
-    URL_HASH SHA512=0dc89e58ddda1f3bc6a7037963994770c5806c10e66f5cc55c59286fc76d0544fe4eca7626772b888fd719f434bc8a92f792bdb350c807968b2ac14cfc04b203
-    FIND_PACKAGE_ARGUMENTS "MODULE"
+# unordered_dense
+AddPackage(
+    NAME unordered_dense
+    REPO "Lizzie841/unordered_dense"
+    SHA e59d30b7b1
+    HASH 71eff7bd9ba4b9226967bacd56a8ff000946f8813167cb5664bb01e96fb79e4e220684d824fe9c59c4d1cc98c606f13aff05b7940a1ed8ab3c95d6974ee34fa0
+    FIND_PACKAGE_ARGUMENTS "CONFIG"
     OPTIONS
-        "OPUS_BUILD_TESTING OFF"
-        "OPUS_BUILD_PROGRAMS OFF"
-        "OPUS_INSTALL_PKG_CONFIG_MODULE OFF"
-        "OPUS_INSTALL_CMAKE_CONFIG_MODULE OFF"
-    CUSTOM_CACHE_KEY "5ded"
+        "UNORDERED_DENSE_INSTALL OFF"
 )
 
 # FFMpeg
@@ -287,77 +116,36 @@ if (YUZU_USE_BUNDLED_FFMPEG)
 endif()
 
 # Vulkan-Headers
-if (YUZU_USE_EXTERNAL_VULKAN_HEADERS)
-    set(CPM_USE_LOCAL_PACKAGES OFF)
-else()
-    set(CPM_USE_LOCAL_PACKAGES ON)
-endif()
 
-# TODO(crueter): System vk-headers are too new for externals vk-util
+# TODO(crueter): Vk1.4 impl
 
-CPMAddPackage(
-    NAME VulkanHeaders
-    VERSION 1.3.274
-    URL "https://github.com/KhronosGroup/Vulkan-Headers/archive/89268a6d17.zip"
-    URL_HASH SHA512=3ab349f74298ba72cafb8561015690c0674d428a09fb91ccd3cd3daca83650d190d46d33fd97b0a8fd4223fe6df2bcabae89136fbbf7c0bfeb8776f9448304c8
-    CUSTOM_CACHE_KEY "8926"
+AddJsonPackage(
+    NAME vulkan-headers
+    BUNDLED_PACKAGE ${YUZU_USE_EXTERNAL_VULKAN_HEADERS}
 )
 
 # Vulkan-Utility-Libraries
-if (YUZU_USE_EXTERNAL_VULKAN_UTILITY_LIBRARIES)
-    set(CPM_USE_LOCAL_PACKAGES OFF)
-else()
-    set(CPM_USE_LOCAL_PACKAGES ON)
-endif()
-
-CPMAddPackage(
-    NAME VulkanUtilityLibraries
-    URL "https://github.com/KhronosGroup/Vulkan-Utility-Libraries/archive/df2e358152.zip"
-    URL_HASH SHA512=3e468c3d9ff93f6d418d71e5527abe0a12c8c7ab5b0b52278bbbee4d02bb87e99073906729b727e0147242b7e3fd5dedf68b803f1878cb4c0e4f730bc2238d79
-    CUSTOM_CACHE_KEY "df2e"
+AddJsonPackage(
+    NAME vulkan-utility-libraries
+    BUNDLED_PACKAGE ${YUZU_USE_EXTERNAL_VULKAN_UTILITY_LIBRARIES}
 )
 
-set(VulkanUtilityLibraries_SOURCE_DIR "${VulkanUtilityLibraries_SOURCE_DIR}" PARENT_SCOPE)
-set(VulkanUtilityLibraries_ADDED "${VulkanUtilityLibraries_ADDED}" PARENT_SCOPE)
-
-# SPIRV-Tools
-if (YUZU_USE_EXTERNAL_VULKAN_SPIRV_TOOLS)
-    CPMAddPackage(
-        NAME SPIRV-Tools
-        URL "https://github.com/KhronosGroup/SPIRV-Tools/archive/40eb301f32.zip"
-        URL_HASH SHA512=58d0fb1047d69373cf24c73e6f78c73a72a6cca3b4df1d9f083b9dcc0962745ef154abf3dbe9b3623b835be20c6ec769431cf11733349f45e7568b3525f707aa
-        OPTIONS
-            "SPIRV_SKIP_EXECUTABLES ON"
-        CUSTOM_CACHE_KEY "40eb"
-    )
-endif()
-
-# Boost headers
-set(CPM_USE_LOCAL_PACKAGES OFF)
-
-CPMAddPackage(
-    NAME boost_headers
-    URL "https://github.com/boostorg/headers/archive/0456900fad.zip"
-    URL_HASH SHA512=50cd75dcdfc5f082225cdace058f47b4fb114a47585f7aee1d22236a910a80b667186254c214fa2fcebac67ae6d37ba4b6e695e1faea8affd6fd42a03cf996e3
-    CUSTOM_CACHE_KEY "0456"
+# SPIRV Tools
+AddJsonPackage(
+    NAME spirv-tools
+    BUNDLED_PACKAGE ${YUZU_USE_EXTERNAL_VULKAN_SPIRV_TOOLS}
 )
 
+if (SPIRV-Tools_ADDED)
+    add_library(SPIRV-Tools::SPIRV-Tools ALIAS SPIRV-Tools-static)
+    target_link_libraries(SPIRV-Tools-static PRIVATE SPIRV-Tools-opt SPIRV-Tools-link)
+endif()
+
 # TZDB (Time Zone Database)
 add_subdirectory(nx_tzdb)
 
 # VMA
-set(CPM_USE_LOCAL_PACKAGES ON)
-
-CPMAddPackage(
-    NAME VulkanMemoryAllocator
-    URL "https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator/archive/1076b348ab.zip"
-    URL_HASH SHA512=a46b44e4286d08cffda058e856c47f44c7fed3da55fe9555976eb3907fdcc20ead0b1860b0c38319cda01dbf9b1aa5d4b4038c7f1f8fbd97283d837fa9af9772
-    FIND_PACKAGE_ARGUMENTS "CONFIG"
-    CUSTOM_CACHE_KEY "1076"
-)
-
-set(VulkanMemoryAllocator_SOURCE_DIR "${VulkanMemoryAllocator_SOURCE_DIR}" PARENT_SCOPE)
-set(VulkanMemoryAllocator_ADDED "${VulkanMemoryAllocator_ADDED}" PARENT_SCOPE)
+AddJsonPackage(vulkan-memory-allocator)
 
 if (NOT TARGET LLVM::Demangle)
     add_library(demangle demangle/ItaniumDemangle.cpp)
@@ -387,19 +175,8 @@ if (NOT TARGET RenderDoc::API)
     add_library(RenderDoc::API ALIAS renderdoc)
 endif()
 
-if (ANDROID)
-    if (ARCHITECTURE_arm64)
-        set(CPM_USE_LOCAL_PACKAGES OFF)
-
-        CPMAddPackage(
-            NAME libadrenotools
-            URL "https://github.com/bylaws/libadrenotools/archive/8fae8ce254.zip"
-            URL_HASH SHA512=c74fa855f0edebbf25c9bce40b00966daa2447bfc5e15f0cf1a95f86cbf70fc6b02590707edbde16328a0a2a4fb9a1fc419d2dfc22a4a4150971be91892d4edb
-            PATCHES
-                ${CMAKE_SOURCE_DIR}/.patch/libadrenotools/0001-linkerns-cpm.patch
-            CUSTOM_CACHE_KEY "8fae"
-        )
-    endif()
+if (ANDROID AND ARCHITECTURE_arm64)
+    AddJsonPackage(libadrenotools)
 endif()
 
 if (UNIX AND NOT APPLE AND NOT TARGET gamemode::headers)
@@ -422,13 +199,13 @@ if (YUZU_CRASH_DUMPS AND NOT TARGET libbreakpad_client)
         _CRT_NONSTDC_NO_DEPRECATE
     )
 
-    set(CPM_USE_LOCAL_PACKAGES OFF)
-    CPMAddPackage(
+    # TODO
+    AddPackage(
         NAME breakpad
-        URL "https://github.com/google/breakpad/archive/f80f288803.zip"
-        URL_HASH SHA512=4a87ee88cea99bd633d52a5b00135a649f1475e3b65db325a6df9c804ab82b054ad7e62419b35f6e22cc5dfbbb569214041d7ad5d10fab10106e700bb5050e1d
+        URL "google/breakpad"
+        SHA f80f288803
+        HASH 4a87ee88cea99bd633d52a5b00135a649f1475e3b65db325a6df9c804ab82b054ad7e62419b35f6e22cc5dfbbb569214041d7ad5d10fab10106e700bb5050e1d
         DOWNLOAD_ONLY YES
-        CUSTOM_CACHE_KEY "f80f"
     )
 
     # libbreakpad
@@ -517,26 +294,13 @@ if (YUZU_CRASH_DUMPS AND NOT TARGET libbreakpad_client)
             ${breakpad_SOURCE_DIR}/src/common/linux/memory_mapped_file.cc
             ${breakpad_SOURCE_DIR}/src/common/linux/safe_readlink.cc
             ${breakpad_SOURCE_DIR}/src/tools/linux/dump_syms/dump_syms.cc)
-        target_link_libraries(dump_syms PRIVATE libbreakpad_client ZLIB::ZLIB)
+        target_link_libraries(dump_syms PRIVATE libbreakpad_client)
     endif()
 endif()
 
-# SimpleIni
-if (NOT TARGET SimpleIni::SimpleIni)
-    add_subdirectory(simpleini)
-endif()
-
 # oboe
 if (ANDROID)
-    set(CPM_USE_LOCAL_PACKAGES ON)
-    CPMAddPackage(
-        NAME oboe
-        URL "https://github.com/google/oboe/archive/2bc873e53c.zip"
-        URL_HASH SHA512=02329058a7f9cf7d5039afaae5ab170d9f42f60f4c01e21eaf4f46073886922b057a9ae30eeac040b3ac182f51b9c1bfe9fe1050a2c9f6ce567a1a9a0ec2c768
-        OPTIONS
-            "SPIRV_SKIP_EXECUTABLES ON"
-        CUSTOM_CACHE_KEY "2bc8"
-    )
+    AddJsonPackage(oboe)
 
     add_library(oboe::oboe ALIAS oboe)
 endif()

externals/cpmfile.json

@@ -0,0 +1,109 @@
+{
+    "mbedtls": {
+        "repo": "Mbed-TLS/mbedtls",
+        "sha": "8c88150ca1",
+        "hash": "769ad1e94c570671071e1f2a5c0f1027e0bf6bcdd1a80ea8ac970f2c86bc45ce4e31aa88d6d8110fc1bed1de81c48bc624df1b38a26f8b340a44e109d784a966",
+        "patches": [
+            "0001-cmake-version.patch"
+        ]
+    },
+    "spirv-headers": {
+        "package": "SPIRV-Headers",
+        "repo": "KhronosGroup/SPIRV-Headers",
+        "sha": "4e209d3d7e",
+        "hash": "f48bbe18341ed55ea0fe280dbbbc0a44bf222278de6e716e143ca1e95ca320b06d4d23d6583fbf8d03e1428f3dac8fa00e5b82ddcd6b425e6236d85af09550a4"
+    },
+    "sirit": {
+        "repo": "eden-emulator/sirit",
+        "sha": "db1f1e8ab5",
+        "hash": "73eb3a042848c63a10656545797e85f40d142009dfb7827384548a385e1e28e1ac72f42b25924ce530d58275f8638554281e884d72f9c7aaf4ed08690a414b05",
+        "options": [
+            "SIRIT_USE_SYSTEM_SPIRV_HEADERS ON"
+        ]
+    },
+    "httplib": {
+        "repo": "yhirose/cpp-httplib",
+        "sha": "a609330e4c",
+        "hash": "dd3fd0572f8367d8549e1319fd98368b3e75801a293b0c3ac9b4adb806473a4506a484b3d389dc5bee5acc460cb90af7a20e5df705a1696b56496b30b9ce7ed2"
+    },
+    "cpp-jwt": {
+        "version": "1.4",
+        "repo": "arun11299/cpp-jwt",
+        "sha": "a54fa08a3b",
+        "hash": "a90f7e594ada0c7e49d5ff9211c71097534e7742a8e44bf0851b0362642a7271d53f5d83d04eeaae2bad17ef3f35e09e6818434d8eaefa038f3d1f7359d0969a",
+        "find_args": "CONFIG",
+        "options": [
+            "CPP_JWT_BUILD_EXAMPLES OFF",
+            "CPP_JWT_BUILD_TESTS OFF",
+            "CPP_JWT_USE_VENDORED_NLOHMANN_JSON OFF"
+        ],
+        "patches": [
+            "0001-no-install.patch",
+            "0002-missing-decl.patch"
+        ]
+    },
+    "vulkan-headers": {
+        "package": "VulkanHeaders",
+        "version": "1.3.274",
+        "repo": "KhronosGroup/Vulkan-Headers",
+        "sha": "89268a6d17",
+        "hash": "3ab349f74298ba72cafb8561015690c0674d428a09fb91ccd3cd3daca83650d190d46d33fd97b0a8fd4223fe6df2bcabae89136fbbf7c0bfeb8776f9448304c8"
+    },
+    "vulkan-utility-libraries": {
+        "package": "VulkanUtilityLibraries",
+        "repo": "KhronosGroup/Vulkan-Utility-Libraries",
+        "sha": "df2e358152",
+        "hash": "3e468c3d9ff93f6d418d71e5527abe0a12c8c7ab5b0b52278bbbee4d02bb87e99073906729b727e0147242b7e3fd5dedf68b803f1878cb4c0e4f730bc2238d79"
+    },
+    "vulkan-memory-allocator": {
+        "package": "VulkanMemoryAllocator",
+        "repo": "GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator",
+        "sha": "1076b348ab",
+        "hash": "a46b44e4286d08cffda058e856c47f44c7fed3da55fe9555976eb3907fdcc20ead0b1860b0c38319cda01dbf9b1aa5d4b4038c7f1f8fbd97283d837fa9af9772",
+        "find_args": "CONFIG"
+    },
+    "spirv-tools": {
+        "package": "SPIRV-Tools",
+        "repo": "KhronosGroup/SPIRV-Tools",
+        "sha": "40eb301f32",
+        "hash": "58d0fb1047d69373cf24c73e6f78c73a72a6cca3b4df1d9f083b9dcc0962745ef154abf3dbe9b3623b835be20c6ec769431cf11733349f45e7568b3525f707aa",
+        "find_args": "MODULE",
+        "options": [
+            "SPIRV_SKIP_EXECUTABLES ON"
+        ]
+    },
+    "xbyak_sun": {
+        "package": "xbyak",
+        "repo": "Lizzie841/xbyak",
+        "sha": "51f507b0b3",
+        "hash": "4a29a3c2f97f7d5adf667a21a008be03c951fb6696b0d7ba27e7e4afa037bc76eb5e059bb84860e01baf741d4d3ac851b840cd54c99d038812fbe0f1fa6d38a4",
+        "bundled": true
+    },
+    "xbyak": {
+        "package": "xbyak",
+        "repo": "Lizzie841/xbyak",
+        "sha": "4e44f4614d",
+        "hash": "5824e92159e07fa36a774aedd3b3ef3541d0241371d522cffa4ab3e1f215fa5097b1b77865b47b2481376c704fa079875557ea463ca63d0a7fd6a8a20a589e70",
+        "bundled": true
+    },
+    "oaknut": {
+        "version": "2.0.1",
+        "repo": "merryhime/oaknut",
+        "sha": "94c726ce03",
+        "hash": "d8d082242fa1881abce3c82f8dafa002c4e561e66a69e7fc038af67faa5eff2630f082d3d19579c88c4c9f9488e54552accc8cb90e7ce743efe043b6230c08ac"
+    },
+    "libadrenotools": {
+        "repo": "bylaws/libadrenotools",
+        "sha": "8fae8ce254",
+        "hash": "c74fa855f0edebbf25c9bce40b00966daa2447bfc5e15f0cf1a95f86cbf70fc6b02590707edbde16328a0a2a4fb9a1fc419d2dfc22a4a4150971be91892d4edb",
+        "patches": [
+            "0001-linkerns-cpm.patch"
+        ]
+    },
+    "oboe": {
+        "repo": "google/oboe",
+        "sha": "2bc873e53c",
+        "hash": "02329058a7f9cf7d5039afaae5ab170d9f42f60f4c01e21eaf4f46073886922b057a9ae30eeac040b3ac182f51b9c1bfe9fe1050a2c9f6ce567a1a9a0ec2c768",
+        "bundled": true
+    }
+}

externals/enet/.github/workflows/cmake.yml

@@ -1,21 +0,0 @@
-on: [push, pull_request]
-
-name: CMake
-
-jobs:
-  cmake-build:
-    name: CMake ${{ matrix.os }} ${{ matrix.build_type }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: ["ubuntu-latest", "windows-latest", "macos-latest"]
-        build_type: ["Debug", "Release"]
-    steps:
-    - uses: actions/checkout@v3
-
-    - name: Configure CMake
-      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
-
-    - name: Build
-      run: cmake --build ${{github.workspace}}/build --config ${{ matrix.build_type }}      

externals/enet/.gitignore

@@ -1,70 +0,0 @@
-# Potential build directories
-[Aa][Rr][Mm]/
-[Aa][Rr][Mm]64/
-[Bb]in/
-[Dd]ebug/
-[Dd]ebugPublic/
-[Ll]og/
-[Ll]ogs/
-[Oo]bj/
-[Rr]elease/
-[Rr]eleases/
-[Ww][Ii][Nn]32/
-bld/
-build/
-builds/
-out/
-x64/
-x86/
-
-# VS 
-.vs/
-.vscode/
-!.vscode/extensions.json
-!.vscode/launch.json
-!.vscode/settings.json
-!.vscode/tasks.json
-
-# CMake
-_deps
-CMakeCache.txt
-CMakeFiles
-CMakeLists.txt.user
-CMakeScripts
-CMakeUserPresets.json
-CTestTestfile.cmake
-cmake_install.cmake
-compile_commands.json
-install_manifest.txt
-
-# Prerequisites
-*.d
-
-# Object files
-*.o
-*.ko
-*.obj
-*.elf
-
-# Linker output
-*.ilk
-*.map
-*.exp
-
-# Libraries
-*.lib
-*.a
-*.la
-*.lo
-
-# Shared objects
-*.dll
-*.so
-*.so.*
-*.dylib
-
-# Debug files
-*.dSYM/
-*.su
-*.idb
-*.pdb

externals/enet/CMakeLists.txt

@@ -1,109 +0,0 @@
-cmake_minimum_required(VERSION 2.8.12...3.20)
-
-project(enet)
-
-# The "configure" step.
-include(CheckFunctionExists)
-include(CheckStructHasMember)
-include(CheckTypeSize)
-check_function_exists("fcntl" HAS_FCNTL)
-check_function_exists("poll" HAS_POLL)
-check_function_exists("getaddrinfo" HAS_GETADDRINFO)
-check_function_exists("getnameinfo" HAS_GETNAMEINFO)
-check_function_exists("gethostbyname_r" HAS_GETHOSTBYNAME_R)
-check_function_exists("gethostbyaddr_r" HAS_GETHOSTBYADDR_R)
-check_function_exists("inet_pton" HAS_INET_PTON)
-check_function_exists("inet_ntop" HAS_INET_NTOP)
-check_struct_has_member("struct msghdr" "msg_flags" "sys/types.h;sys/socket.h" HAS_MSGHDR_FLAGS)
-set(CMAKE_EXTRA_INCLUDE_FILES "sys/types.h" "sys/socket.h")
-check_type_size("socklen_t" HAS_SOCKLEN_T BUILTIN_TYPES_ONLY)
-unset(CMAKE_EXTRA_INCLUDE_FILES)
-if(MSVC)
-	add_definitions(-W3)
-else()
-	add_definitions(-Wno-error)
-endif()
-
-if(HAS_FCNTL)
-    add_definitions(-DHAS_FCNTL=1)
-endif()
-if(HAS_POLL)
-    add_definitions(-DHAS_POLL=1)
-endif()
-if(HAS_GETNAMEINFO)
-    add_definitions(-DHAS_GETNAMEINFO=1)
-endif()
-if(HAS_GETADDRINFO)
-    add_definitions(-DHAS_GETADDRINFO=1)
-endif()
-if(HAS_GETHOSTBYNAME_R)
-    add_definitions(-DHAS_GETHOSTBYNAME_R=1)
-endif()
-if(HAS_GETHOSTBYADDR_R)
-    add_definitions(-DHAS_GETHOSTBYADDR_R=1)
-endif()
-if(HAS_INET_PTON)
-    add_definitions(-DHAS_INET_PTON=1)
-endif()
-if(HAS_INET_NTOP)
-    add_definitions(-DHAS_INET_NTOP=1)
-endif()
-if(HAS_MSGHDR_FLAGS)
-    add_definitions(-DHAS_MSGHDR_FLAGS=1)
-endif()
-if(HAS_SOCKLEN_T)
-    add_definitions(-DHAS_SOCKLEN_T=1)
-endif()
-
-include_directories(${PROJECT_SOURCE_DIR}/include)
-
-set(INCLUDE_FILES_PREFIX include/enet)
-set(INCLUDE_FILES
-    ${INCLUDE_FILES_PREFIX}/callbacks.h
-    ${INCLUDE_FILES_PREFIX}/enet.h
-    ${INCLUDE_FILES_PREFIX}/list.h
-    ${INCLUDE_FILES_PREFIX}/protocol.h
-    ${INCLUDE_FILES_PREFIX}/time.h
-    ${INCLUDE_FILES_PREFIX}/types.h
-    ${INCLUDE_FILES_PREFIX}/unix.h
-    ${INCLUDE_FILES_PREFIX}/utility.h
-    ${INCLUDE_FILES_PREFIX}/win32.h
-)
-
-set(SOURCE_FILES
-    callbacks.c
-    compress.c
-    host.c
-    list.c
-    packet.c
-    peer.c
-    protocol.c
-    unix.c
-    win32.c)
-
-source_group(include FILES ${INCLUDE_FILES})
-source_group(source FILES ${SOURCE_FILES})
-
-if(WIN32 AND BUILD_SHARED_LIBS AND (MSVC OR CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
-    add_definitions(-DENET_DLL=1)
-    add_definitions(-DENET_BUILDING_LIB)
-endif()
-
-add_library(enet
-    ${INCLUDE_FILES}
-    ${SOURCE_FILES}
-)
-
-if (WIN32)
-    target_link_libraries(enet winmm ws2_32)
-endif()
-
-include(GNUInstallDirs)
-install(TARGETS enet
-    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-)
-install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/enet
-    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
-)

externals/enet/ChangeLog

@@ -1,209 +0,0 @@
-ENet 1.3.18 (April 14, 2024):
-
-* Packet sending performance improvements
-* MTU negotiation fixes
-* Checksum alignment fix
-* No more dynamic initialization of checksum table
-* ENET_SOCKOPT_TTL
-* Other miscellaneous small improvements
-
-ENet 1.3.17 (November 15, 2020):
-
-* fixes for sender getting too far ahead of receiver that can cause instability with reliable packets
-
-ENet 1.3.16 (September 8, 2020):
-
-* fix bug in unreliable fragment queuing
-* use single output queue for reliable and unreliable packets for saner ordering
-* revert experimental throttle changes that were less stable than prior algorithm
-
-ENet 1.3.15 (April 20, 2020):
-
-* quicker RTT initialization
-* use fractional precision for RTT calculations
-* fixes for packet throttle with low RTT variance
-* miscellaneous socket bug fixes
-
-ENet 1.3.14 (January 27, 2019):
-
-* bug fix for enet_peer_disconnect_later()
-* use getaddrinfo and getnameinfo where available
-* miscellaneous cleanups
-
-ENet 1.3.13 (April 30, 2015):
-
-* miscellaneous bug fixes
-* added premake and cmake support
-* miscellaneous documentation cleanups
-
-ENet 1.3.12 (April 24, 2014):
-
-* added maximumPacketSize and maximumWaitingData fields to ENetHost to limit the amount of 
-data waiting to be delivered on a peer (beware that the default maximumPacketSize is
-32MB and should be set higher if desired as should maximumWaitingData)
-
-ENet 1.3.11 (December 26, 2013):
-
-* allow an ENetHost to connect to itself
-* fixed possible bug with disconnect notifications during connect attempts
-* fixed some preprocessor definition bugs
-
-ENet 1.3.10 (October 23, 2013);
-
-* doubled maximum reliable window size
-* fixed RCVTIMEO/SNDTIMEO socket options and also added NODELAY
-
-ENet 1.3.9 (August 19, 2013):
-
-* added duplicatePeers option to ENetHost which can limit the number of peers from duplicate IPs
-* added enet_socket_get_option() and ENET_SOCKOPT_ERROR
-* added enet_host_random_seed() platform stub
-
-ENet 1.3.8 (June 2, 2013):
-
-* added enet_linked_version() for checking the linked version 
-* added enet_socket_get_address() for querying the local address of a socket
-* silenced some debugging prints unless ENET_DEBUG is defined during compilation
-* handle EINTR in enet_socket_wait() so that enet_host_service() doesn't propagate errors from signals
-* optimized enet_host_bandwidth_throttle() to be less expensive for large numbers of peers
-
-ENet 1.3.7 (March 6, 2013):
-
-* added ENET_PACKET_FLAG_SENT to indicate that a packet is being freed because it has been sent
-* added userData field to ENetPacket
-* changed how random seed is generated on Windows to avoid import warnings
-* fixed case where disconnects could be generated with no preceding connect event
-
-ENet 1.3.6 (December 11, 2012):
-
-* added support for intercept callback in ENetHost that can be used to process raw packets before ENet
-* added enet_socket_shutdown() for issuing shutdown on a socket
-* fixed enet_socket_connect() to not error on non-blocking connects
-* fixed bug in MTU negotiation during connections
- 
-ENet 1.3.5 (July 31, 2012):
-
-* fixed bug in unreliable packet fragment queuing
-
-ENet 1.3.4 (May 29, 2012):
-
-* added enet_peer_ping_interval() for configuring per-peer ping intervals
-* added enet_peer_timeout() for configuring per-peer timeouts
-* added protocol packet size limits
-
-ENet 1.3.3 (June 28, 2011):
-
-* fixed bug with simultaneous disconnects not dispatching events
-
-ENet 1.3.2 (May 31, 2011):
-
-* added support for unreliable packet fragmenting via the packet flag
-ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT
-* fixed regression in unreliable packet queuing
-* added check against received port to limit some forms of IP-spoofing
-
-ENet 1.3.1 (February 10, 2011):
-
-* fixed bug in tracking of reliable data in transit
-* reliable data window size now scales with the throttle
-* fixed bug in fragment length calculation when checksums are used
-
-ENet 1.3.0 (June 5, 2010):
-
-* enet_host_create() now requires the channel limit to be specified as
-a parameter
-* enet_host_connect() now accepts a data parameter which is supplied 
-to the receiving receiving host in the event data field for a connect event
-* added an adaptive order-2 PPM range coder as a built-in compressor option
-which can be set with enet_host_compress_with_range_coder()
-* added support for packet compression configurable with a callback
-* improved session number handling to not rely on the packet checksum
-field, saving 4 bytes per packet unless the checksum option is used
-* removed the dependence on the rand callback for session number handling
-
-Caveats: This version is not protocol compatible with the 1.2 series or 
-earlier. The enet_host_connect and enet_host_create API functions require
-supplying additional parameters.
-
-ENet 1.2.5 (June 28, 2011):
-
-* fixed bug with simultaneous disconnects not dispatching events
-
-ENet 1.2.4 (May 31, 2011):
-
-* fixed regression in unreliable packet queuing
-* added check against received port to limit some forms of IP-spoofing
-
-ENet 1.2.3 (February 10, 2011):
-
-* fixed bug in tracking reliable data in transit
-
-ENet 1.2.2 (June 5, 2010):
-
-* checksum functionality is now enabled by setting a checksum callback
-inside ENetHost instead of being a configure script option
-* added totalSentData, totalSentPackets, totalReceivedData, and
-totalReceivedPackets counters inside ENetHost for getting usage
-statistics
-* added enet_host_channel_limit() for limiting the maximum number of
-channels allowed by connected peers
-* now uses dispatch queues for event dispatch rather than potentially
-unscalable array walking
-* added no_memory callback that is called when a malloc attempt fails,
-such that if no_memory returns rather than aborts (the default behavior),
-then the error is propagated to the return value of the API calls
-* now uses packed attribute for protocol structures on platforms with 
-strange alignment rules
-* improved autoconf build system contributed by Nathan Brink allowing 
-for easier building as a shared library
-
-Caveats: If you were using the compile-time option that enabled checksums,
-make sure to set the checksum callback inside ENetHost to enet_crc32 to
-regain the old behavior. The ENetCallbacks structure has added new fields,
-so make sure to clear the structure to zero before use if 
-using enet_initialize_with_callbacks().
-
-ENet 1.2.1 (November 12, 2009):
-
-* fixed bug that could cause disconnect events to be dropped
-* added thin wrapper around select() for portable usage
-* added ENET_SOCKOPT_REUSEADDR socket option
-* factored enet_socket_bind()/enet_socket_listen() out of enet_socket_create()
-* added contributed Code::Blocks build file
-
-ENet 1.2 (February 12, 2008):
-
-* fixed bug in VERIFY_CONNECT acknowledgement that could cause connect
-attempts to occasionally timeout
-* fixed acknowledgements to check both the outgoing and sent queues
-when removing acknowledged packets
-* fixed accidental bit rot in the MSVC project file
-* revised sequence number overflow handling to address some possible
-disconnect bugs
-* added enet_host_check_events() for getting only local queued events
-* factored out socket option setting into enet_socket_set_option() so
-that socket options are now set separately from enet_socket_create()
-
-Caveats: While this release is superficially protocol compatible with 1.1,
-differences in the sequence number overflow handling can potentially cause
-random disconnects.
-
-ENet 1.1 (June 6, 2007):
-
-* optional CRC32 just in case someone needs a stronger checksum than UDP 
-provides (--enable-crc32 configure option)
-* the size of packet headers are half the size they used to be (so less 
-overhead when sending small packets)
-* enet_peer_disconnect_later() that waits till all queued outgoing 
-packets get sent before issuing an actual disconnect
-* freeCallback field in individual packets for notification of when a 
-packet is about to be freed
-* ENET_PACKET_FLAG_NO_ALLOCATE for supplying pre-allocated data to a 
-packet (can be used in concert with freeCallback to support some custom 
-allocation schemes that the normal memory allocation callbacks would 
-normally not allow)
-* enet_address_get_host_ip() for printing address numbers
-* promoted the enet_socket_*() functions to be part of the API now
-* a few stability/crash fixes
-
-

externals/enet/DoxygenLayout.xml

@@ -1,191 +0,0 @@
-<doxygenlayout version="1.0">
-  <!-- Generated by doxygen 1.8.6 -->
-  <!-- Navigation index tabs for HTML output -->
-  <navindex>
-    <tab type="mainpage" visible="yes" title="Home"/>
-    <tab type="user" visible="yes" title="Features" url="@ref Features" />
-    <tab type="user" visible="yes" title="Downloads" url="@ref Downloads" />
-    <tab type="user" visible="yes" title="Installation" url="@ref Installation" />
-    <tab type="user" visible="yes" title="Tutorial" url="@ref Tutorial" />
-    <tab type="user" visible="yes" title="Mailing List" url="@ref MailingList" />
-    <tab type="user" visible="yes" title="IRC Channel" url="@ref IRCChannel" />
-    <tab type="user" visible="yes" title="FAQ" url="@ref FAQ" />
-    <tab type="user" visible="yes" title="License" url="@ref License" />
-    <tab type="usergroup" visible="yes" title="Documentation" briefdescription="Documentation">
-        <tab type="modules" visible="yes" title="Functions" intro=""/>
-        <tab type="classlist" visible="yes" title="Data Structures" intro=""/>
-        <tab type="filelist" visible="yes" title="Files" intro=""/>
-        <tab type="globals" visible="yes" title="" intro=""/>
-    </tab>
-  </navindex>
-
-  <!-- Layout definition for a class page -->
-  <class>
-    <briefdescription visible="yes"/>
-    <includes visible="$SHOW_INCLUDE_FILES"/>
-    <inheritancegraph visible="$CLASS_GRAPH"/>
-    <collaborationgraph visible="$COLLABORATION_GRAPH"/>
-    <memberdecl>
-      <nestedclasses visible="yes" title=""/>
-      <publictypes title=""/>
-      <services title=""/>
-      <interfaces title=""/>
-      <publicslots title=""/>
-      <signals title=""/>
-      <publicmethods title=""/>
-      <publicstaticmethods title=""/>
-      <publicattributes title=""/>
-      <publicstaticattributes title=""/>
-      <protectedtypes title=""/>
-      <protectedslots title=""/>
-      <protectedmethods title=""/>
-      <protectedstaticmethods title=""/>
-      <protectedattributes title=""/>
-      <protectedstaticattributes title=""/>
-      <packagetypes title=""/>
-      <packagemethods title=""/>
-      <packagestaticmethods title=""/>
-      <packageattributes title=""/>
-      <packagestaticattributes title=""/>
-      <properties title=""/>
-      <events title=""/>
-      <privatetypes title=""/>
-      <privateslots title=""/>
-      <privatemethods title=""/>
-      <privatestaticmethods title=""/>
-      <privateattributes title=""/>
-      <privatestaticattributes title=""/>
-      <friends title=""/>
-      <related title="" subtitle=""/>
-      <membergroups visible="yes"/>
-    </memberdecl>
-    <detaileddescription title=""/>
-    <memberdef>
-      <inlineclasses title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <services title=""/>
-      <interfaces title=""/>
-      <constructors title=""/>
-      <functions title=""/>
-      <related title=""/>
-      <variables title=""/>
-      <properties title=""/>
-      <events title=""/>
-    </memberdef>
-    <allmemberslink visible="yes"/>
-    <usedfiles visible="$SHOW_USED_FILES"/>
-    <authorsection visible="yes"/>
-  </class>
-
-  <!-- Layout definition for a namespace page -->
-  <namespace>
-    <briefdescription visible="yes"/>
-    <memberdecl>
-      <nestednamespaces visible="yes" title=""/>
-      <constantgroups visible="yes" title=""/>
-      <classes visible="yes" title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <functions title=""/>
-      <variables title=""/>
-      <membergroups visible="yes"/>
-    </memberdecl>
-    <detaileddescription title=""/>
-    <memberdef>
-      <inlineclasses title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <functions title=""/>
-      <variables title=""/>
-    </memberdef>
-    <authorsection visible="yes"/>
-  </namespace>
-
-  <!-- Layout definition for a file page -->
-  <file>
-    <briefdescription visible="yes"/>
-    <includes visible="$SHOW_INCLUDE_FILES"/>
-    <includegraph visible="$INCLUDE_GRAPH"/>
-    <includedbygraph visible="$INCLUDED_BY_GRAPH"/>
-    <sourcelink visible="yes"/>
-    <memberdecl>
-      <classes visible="yes" title=""/>
-      <namespaces visible="yes" title=""/>
-      <constantgroups visible="yes" title=""/>
-      <defines title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <functions title=""/>
-      <variables title=""/>
-      <membergroups visible="yes"/>
-    </memberdecl>
-    <detaileddescription title=""/>
-    <memberdef>
-      <inlineclasses title=""/>
-      <defines title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <functions title=""/>
-      <variables title=""/>
-    </memberdef>
-    <authorsection/>
-  </file>
-
-  <!-- Layout definition for a group page -->
-  <group>
-    <briefdescription visible="yes"/>
-    <groupgraph visible="$GROUP_GRAPHS"/>
-    <memberdecl>
-      <nestedgroups visible="yes" title=""/>
-      <dirs visible="yes" title=""/>
-      <files visible="yes" title=""/>
-      <namespaces visible="yes" title=""/>
-      <classes visible="yes" title=""/>
-      <defines title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <enumvalues title=""/>
-      <functions title=""/>
-      <variables title=""/>
-      <signals title=""/>
-      <publicslots title=""/>
-      <protectedslots title=""/>
-      <privateslots title=""/>
-      <events title=""/>
-      <properties title=""/>
-      <friends title=""/>
-      <membergroups visible="yes"/>
-    </memberdecl>
-    <detaileddescription title=""/>
-    <memberdef>
-      <pagedocs/>
-      <inlineclasses title=""/>
-      <defines title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <enumvalues title=""/>
-      <functions title=""/>
-      <variables title=""/>
-      <signals title=""/>
-      <publicslots title=""/>
-      <protectedslots title=""/>
-      <privateslots title=""/>
-      <events title=""/>
-      <properties title=""/>
-      <friends title=""/>
-    </memberdef>
-    <authorsection visible="yes"/>
-  </group>
-
-  <!-- Layout definition for a directory page -->
-  <directory>
-    <briefdescription visible="yes"/>
-    <directorygraph visible="yes"/>
-    <memberdecl>
-      <dirs visible="yes"/>
-      <files visible="yes"/>
-    </memberdecl>
-    <detaileddescription title=""/>
-  </directory>
-</doxygenlayout>

externals/enet/LICENSE

@@ -1,7 +0,0 @@
-Copyright (c) 2002-2024 Lee Salzman
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

externals/enet/Makefile.am

@@ -1,22 +0,0 @@
-pkgconfigdir = $(libdir)/pkgconfig
-nodist_pkgconfig_DATA = libenet.pc
-
-enetincludedir=$(includedir)/enet
-enetinclude_HEADERS = \
-	include/enet/callbacks.h \
-	include/enet/enet.h \
-	include/enet/list.h \
-	include/enet/protocol.h \
-	include/enet/time.h \
-	include/enet/types.h \
-	include/enet/unix.h \
-	include/enet/utility.h \
-	include/enet/win32.h
-
-lib_LTLIBRARIES = libenet.la
-libenet_la_SOURCES = callbacks.c compress.c host.c list.c packet.c peer.c protocol.c unix.c win32.c
-# see info '(libtool) Updating version info' before making a release
-libenet_la_LDFLAGS = $(AM_LDFLAGS) -version-info 7:6:0
-AM_CPPFLAGS = -I$(top_srcdir)/include
-
-ACLOCAL_AMFLAGS = -Im4

externals/enet/README

@@ -1,15 +0,0 @@
-Please visit the ENet homepage at http://sauerbraten.org/enet/ for installation
-and usage instructions.
-
-If you obtained this package from github, the quick description on how to build
-is:
-
-# Generate the build system.
-
-autoreconf -vfi
-
-# Compile and install the library.
-
-./configure && make && make install
-
-

externals/enet/callbacks.c

@@ -1,53 +0,0 @@
-/** 
- @file callbacks.c
- @brief ENet callback functions
-*/
-#define ENET_BUILDING_LIB 1
-#include "enet/enet.h"
-
-static ENetCallbacks callbacks = { malloc, free, abort };
-
-int
-enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits)
-{
-   if (version < ENET_VERSION_CREATE (1, 3, 0))
-     return -1;
-
-   if (inits -> malloc != NULL || inits -> free != NULL)
-   {
-      if (inits -> malloc == NULL || inits -> free == NULL)
-        return -1;
-
-      callbacks.malloc = inits -> malloc;
-      callbacks.free = inits -> free;
-   }
-      
-   if (inits -> no_memory != NULL)
-     callbacks.no_memory = inits -> no_memory;
-
-   return enet_initialize ();
-}
-
-ENetVersion
-enet_linked_version (void)
-{
-    return ENET_VERSION;
-}
-           
-void *
-enet_malloc (size_t size)
-{
-   void * memory = callbacks.malloc (size);
-
-   if (memory == NULL)
-     callbacks.no_memory ();
-
-   return memory;
-}
-
-void
-enet_free (void * memory)
-{
-   callbacks.free (memory);
-}
-

externals/enet/compress.c

@@ -1,654 +0,0 @@
-/** 
- @file compress.c
- @brief An adaptive order-2 PPM range coder
-*/
-#define ENET_BUILDING_LIB 1
-#include <string.h>
-#include "enet/enet.h"
-
-typedef struct _ENetSymbol
-{
-    /* binary indexed tree of symbols */
-    enet_uint8 value;
-    enet_uint8 count;
-    enet_uint16 under;
-    enet_uint16 left, right;
-
-    /* context defined by this symbol */
-    enet_uint16 symbols;
-    enet_uint16 escapes;
-    enet_uint16 total;
-    enet_uint16 parent; 
-} ENetSymbol;
-
-/* adaptation constants tuned aggressively for small packet sizes rather than large file compression */
-enum
-{
-    ENET_RANGE_CODER_TOP    = 1<<24,
-    ENET_RANGE_CODER_BOTTOM = 1<<16,
-
-    ENET_CONTEXT_SYMBOL_DELTA = 3,
-    ENET_CONTEXT_SYMBOL_MINIMUM = 1,
-    ENET_CONTEXT_ESCAPE_MINIMUM = 1,
-
-    ENET_SUBCONTEXT_ORDER = 2,
-    ENET_SUBCONTEXT_SYMBOL_DELTA = 2,
-    ENET_SUBCONTEXT_ESCAPE_DELTA = 5
-};
-
-/* context exclusion roughly halves compression speed, so disable for now */
-#undef ENET_CONTEXT_EXCLUSION
-
-typedef struct _ENetRangeCoder
-{
-    /* only allocate enough symbols for reasonable MTUs, would need to be larger for large file compression */
-    ENetSymbol symbols[4096];
-} ENetRangeCoder;
-
-void *
-enet_range_coder_create (void)
-{
-    ENetRangeCoder * rangeCoder = (ENetRangeCoder *) enet_malloc (sizeof (ENetRangeCoder));
-    if (rangeCoder == NULL)
-      return NULL;
-
-    return rangeCoder;
-}
-
-void
-enet_range_coder_destroy (void * context)
-{
-    ENetRangeCoder * rangeCoder = (ENetRangeCoder *) context;
-    if (rangeCoder == NULL)
-      return;
-
-    enet_free (rangeCoder);
-}
-
-#define ENET_SYMBOL_CREATE(symbol, value_, count_) \
-{ \
-    symbol = & rangeCoder -> symbols [nextSymbol ++]; \
-    symbol -> value = value_; \
-    symbol -> count = count_; \
-    symbol -> under = count_; \
-    symbol -> left = 0; \
-    symbol -> right = 0; \
-    symbol -> symbols = 0; \
-    symbol -> escapes = 0; \
-    symbol -> total = 0; \
-    symbol -> parent = 0; \
-}
-
-#define ENET_CONTEXT_CREATE(context, escapes_, minimum) \
-{ \
-    ENET_SYMBOL_CREATE (context, 0, 0); \
-    (context) -> escapes = escapes_; \
-    (context) -> total = escapes_ + 256*minimum; \
-    (context) -> symbols = 0; \
-}
-
-static enet_uint16
-enet_symbol_rescale (ENetSymbol * symbol)
-{
-    enet_uint16 total = 0;
-    for (;;)
-    {
-        symbol -> count -= symbol->count >> 1;
-        symbol -> under = symbol -> count;
-        if (symbol -> left)
-          symbol -> under += enet_symbol_rescale (symbol + symbol -> left);
-        total += symbol -> under;
-        if (! symbol -> right) break;
-        symbol += symbol -> right;
-    } 
-    return total;
-}
-
-#define ENET_CONTEXT_RESCALE(context, minimum) \
-{ \
-    (context) -> total = (context) -> symbols ? enet_symbol_rescale ((context) + (context) -> symbols) : 0; \
-    (context) -> escapes -= (context) -> escapes >> 1; \
-    (context) -> total += (context) -> escapes + 256*minimum; \
-}
-
-#define ENET_RANGE_CODER_OUTPUT(value) \
-{ \
-    if (outData >= outEnd) \
-      return 0; \
-    * outData ++ = value; \
-}
-
-#define ENET_RANGE_CODER_ENCODE(under, count, total) \
-{ \
-    encodeRange /= (total); \
-    encodeLow += (under) * encodeRange; \
-    encodeRange *= (count); \
-    for (;;) \
-    { \
-        if((encodeLow ^ (encodeLow + encodeRange)) >= ENET_RANGE_CODER_TOP) \
-        { \
-            if(encodeRange >= ENET_RANGE_CODER_BOTTOM) break; \
-            encodeRange = -encodeLow & (ENET_RANGE_CODER_BOTTOM - 1); \
-        } \
-        ENET_RANGE_CODER_OUTPUT (encodeLow >> 24); \
-        encodeRange <<= 8; \
-        encodeLow <<= 8; \
-    } \
-}
-
-#define ENET_RANGE_CODER_FLUSH \
-{ \
-    while (encodeLow) \
-    { \
-        ENET_RANGE_CODER_OUTPUT (encodeLow >> 24); \
-        encodeLow <<= 8; \
-    } \
-}
-
-#define ENET_RANGE_CODER_FREE_SYMBOLS \
-{ \
-    if (nextSymbol >= sizeof (rangeCoder -> symbols) / sizeof (ENetSymbol) - ENET_SUBCONTEXT_ORDER ) \
-    { \
-        nextSymbol = 0; \
-        ENET_CONTEXT_CREATE (root, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM); \
-        predicted = 0; \
-        order = 0; \
-    } \
-}
-
-#define ENET_CONTEXT_ENCODE(context, symbol_, value_, under_, count_, update, minimum) \
-{ \
-    under_ = value*minimum; \
-    count_ = minimum; \
-    if (! (context) -> symbols) \
-    { \
-        ENET_SYMBOL_CREATE (symbol_, value_, update); \
-        (context) -> symbols = symbol_ - (context); \
-    } \
-    else \
-    { \
-        ENetSymbol * node = (context) + (context) -> symbols; \
-        for (;;) \
-        { \
-            if (value_ < node -> value) \
-            { \
-                node -> under += update; \
-                if (node -> left) { node += node -> left; continue; } \
-                ENET_SYMBOL_CREATE (symbol_, value_, update); \
-                node -> left = symbol_ - node; \
-            } \
-            else \
-            if (value_ > node -> value) \
-            { \
-                under_ += node -> under; \
-                if (node -> right) { node += node -> right; continue; } \
-                ENET_SYMBOL_CREATE (symbol_, value_, update); \
-                node -> right = symbol_ - node; \
-            } \
-            else \
-            { \
-                count_ += node -> count; \
-                under_ += node -> under - node -> count; \
-                node -> under += update; \
-                node -> count += update; \
-                symbol_ = node; \
-            } \
-            break; \
-        } \
-    } \
-}
-
-#ifdef ENET_CONTEXT_EXCLUSION
-static const ENetSymbol emptyContext = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-
-#define ENET_CONTEXT_WALK(context, body) \
-{ \
-    const ENetSymbol * node = (context) + (context) -> symbols; \
-    const ENetSymbol * stack [256]; \
-    size_t stackSize = 0; \
-    while (node -> left) \
-    { \
-        stack [stackSize ++] = node; \
-        node += node -> left; \
-    } \
-    for (;;) \
-    { \
-        body; \
-        if (node -> right) \
-        { \
-            node += node -> right; \
-            while (node -> left) \
-            { \
-                stack [stackSize ++] = node; \
-                node += node -> left; \
-            } \
-        } \
-        else \
-        if (stackSize <= 0) \
-            break; \
-        else \
-            node = stack [-- stackSize]; \
-    } \
-}
-
-#define ENET_CONTEXT_ENCODE_EXCLUDE(context, value_, under, total, minimum) \
-ENET_CONTEXT_WALK(context, { \
-    if (node -> value != value_) \
-    { \
-        enet_uint16 parentCount = rangeCoder -> symbols [node -> parent].count + minimum; \
-        if (node -> value < value_) \
-          under -= parentCount; \
-        total -= parentCount; \
-    } \
-})
-#endif
-
-size_t
-enet_range_coder_compress (void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit)
-{
-    ENetRangeCoder * rangeCoder = (ENetRangeCoder *) context;
-    enet_uint8 * outStart = outData, * outEnd = & outData [outLimit];
-    const enet_uint8 * inData, * inEnd;
-    enet_uint32 encodeLow = 0, encodeRange = ~0;
-    ENetSymbol * root;
-    enet_uint16 predicted = 0;
-    size_t order = 0, nextSymbol = 0;
-
-    if (rangeCoder == NULL || inBufferCount <= 0 || inLimit <= 0)
-      return 0;
-
-    inData = (const enet_uint8 *) inBuffers -> data;
-    inEnd = & inData [inBuffers -> dataLength];
-    inBuffers ++;
-    inBufferCount --;
-
-    ENET_CONTEXT_CREATE (root, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM);
-
-    for (;;)
-    {
-        ENetSymbol * subcontext, * symbol;
-#ifdef ENET_CONTEXT_EXCLUSION
-        const ENetSymbol * childContext = & emptyContext;
-#endif
-        enet_uint8 value;
-        enet_uint16 count, under, * parent = & predicted, total;
-        if (inData >= inEnd)
-        {
-            if (inBufferCount <= 0)
-              break;
-            inData = (const enet_uint8 *) inBuffers -> data;
-            inEnd = & inData [inBuffers -> dataLength];
-            inBuffers ++;
-            inBufferCount --;
-        }
-        value = * inData ++;
-    
-        for (subcontext = & rangeCoder -> symbols [predicted]; 
-             subcontext != root; 
-#ifdef ENET_CONTEXT_EXCLUSION
-             childContext = subcontext, 
-#endif
-                subcontext = & rangeCoder -> symbols [subcontext -> parent])
-        {
-            ENET_CONTEXT_ENCODE (subcontext, symbol, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA, 0);
-            * parent = symbol - rangeCoder -> symbols;
-            parent = & symbol -> parent;
-            total = subcontext -> total;
-#ifdef ENET_CONTEXT_EXCLUSION
-            if (childContext -> total > ENET_SUBCONTEXT_SYMBOL_DELTA + ENET_SUBCONTEXT_ESCAPE_DELTA)
-              ENET_CONTEXT_ENCODE_EXCLUDE (childContext, value, under, total, 0);
-#endif
-            if (count > 0)
-            {
-                ENET_RANGE_CODER_ENCODE (subcontext -> escapes + under, count, total);
-            }
-            else
-            {
-                if (subcontext -> escapes > 0 && subcontext -> escapes < total) 
-                    ENET_RANGE_CODER_ENCODE (0, subcontext -> escapes, total); 
-                subcontext -> escapes += ENET_SUBCONTEXT_ESCAPE_DELTA;
-                subcontext -> total += ENET_SUBCONTEXT_ESCAPE_DELTA;
-            }
-            subcontext -> total += ENET_SUBCONTEXT_SYMBOL_DELTA;
-            if (count > 0xFF - 2*ENET_SUBCONTEXT_SYMBOL_DELTA || subcontext -> total > ENET_RANGE_CODER_BOTTOM - 0x100)
-              ENET_CONTEXT_RESCALE (subcontext, 0);
-            if (count > 0) goto nextInput;
-        }
-
-        ENET_CONTEXT_ENCODE (root, symbol, value, under, count, ENET_CONTEXT_SYMBOL_DELTA, ENET_CONTEXT_SYMBOL_MINIMUM);
-        * parent = symbol - rangeCoder -> symbols;
-        parent = & symbol -> parent;
-        total = root -> total;
-#ifdef ENET_CONTEXT_EXCLUSION
-        if (childContext -> total > ENET_SUBCONTEXT_SYMBOL_DELTA + ENET_SUBCONTEXT_ESCAPE_DELTA)
-          ENET_CONTEXT_ENCODE_EXCLUDE (childContext, value, under, total, ENET_CONTEXT_SYMBOL_MINIMUM); 
-#endif
-        ENET_RANGE_CODER_ENCODE (root -> escapes + under, count, total);
-        root -> total += ENET_CONTEXT_SYMBOL_DELTA; 
-        if (count > 0xFF - 2*ENET_CONTEXT_SYMBOL_DELTA + ENET_CONTEXT_SYMBOL_MINIMUM || root -> total > ENET_RANGE_CODER_BOTTOM - 0x100)
-          ENET_CONTEXT_RESCALE (root, ENET_CONTEXT_SYMBOL_MINIMUM);
-
-    nextInput:
-        if (order >= ENET_SUBCONTEXT_ORDER) 
-          predicted = rangeCoder -> symbols [predicted].parent;
-        else 
-          order ++;
-        ENET_RANGE_CODER_FREE_SYMBOLS;
-    }
-
-    ENET_RANGE_CODER_FLUSH;
-
-    return (size_t) (outData - outStart);
-}
-
-#define ENET_RANGE_CODER_SEED \
-{ \
-    if (inData < inEnd) decodeCode |= * inData ++ << 24; \
-    if (inData < inEnd) decodeCode |= * inData ++ << 16; \
-    if (inData < inEnd) decodeCode |= * inData ++ << 8; \
-    if (inData < inEnd) decodeCode |= * inData ++; \
-}
-
-#define ENET_RANGE_CODER_READ(total) ((decodeCode - decodeLow) / (decodeRange /= (total)))
-
-#define ENET_RANGE_CODER_DECODE(under, count, total) \
-{ \
-    decodeLow += (under) * decodeRange; \
-    decodeRange *= (count); \
-    for (;;) \
-    { \
-        if((decodeLow ^ (decodeLow + decodeRange)) >= ENET_RANGE_CODER_TOP) \
-        { \
-            if(decodeRange >= ENET_RANGE_CODER_BOTTOM) break; \
-            decodeRange = -decodeLow & (ENET_RANGE_CODER_BOTTOM - 1); \
-        } \
-        decodeCode <<= 8; \
-        if (inData < inEnd) \
-          decodeCode |= * inData ++; \
-        decodeRange <<= 8; \
-        decodeLow <<= 8; \
-    } \
-}
-
-#define ENET_CONTEXT_DECODE(context, symbol_, code, value_, under_, count_, update, minimum, createRoot, visitNode, createRight, createLeft) \
-{ \
-    under_ = 0; \
-    count_ = minimum; \
-    if (! (context) -> symbols) \
-    { \
-        createRoot; \
-    } \
-    else \
-    { \
-        ENetSymbol * node = (context) + (context) -> symbols; \
-        for (;;) \
-        { \
-            enet_uint16 after = under_ + node -> under + (node -> value + 1)*minimum, before = node -> count + minimum; \
-            visitNode; \
-            if (code >= after) \
-            { \
-                under_ += node -> under; \
-                if (node -> right) { node += node -> right; continue; } \
-                createRight; \
-            } \
-            else \
-            if (code < after - before) \
-            { \
-                node -> under += update; \
-                if (node -> left) { node += node -> left; continue; } \
-                createLeft; \
-            } \
-            else \
-            { \
-                value_ = node -> value; \
-                count_ += node -> count; \
-                under_ = after - before; \
-                node -> under += update; \
-                node -> count += update; \
-                symbol_ = node; \
-            } \
-            break; \
-        } \
-    } \
-}
-
-#define ENET_CONTEXT_TRY_DECODE(context, symbol_, code, value_, under_, count_, update, minimum, exclude) \
-ENET_CONTEXT_DECODE (context, symbol_, code, value_, under_, count_, update, minimum, return 0, exclude (node -> value, after, before), return 0, return 0)
-
-#define ENET_CONTEXT_ROOT_DECODE(context, symbol_, code, value_, under_, count_, update, minimum, exclude) \
-ENET_CONTEXT_DECODE (context, symbol_, code, value_, under_, count_, update, minimum, \
-    { \
-        value_ = code / minimum; \
-        under_ = code - code%minimum; \
-        ENET_SYMBOL_CREATE (symbol_, value_, update); \
-        (context) -> symbols = symbol_ - (context); \
-    }, \
-    exclude (node -> value, after, before), \
-    { \
-        value_ = node->value + 1 + (code - after)/minimum; \
-        under_ = code - (code - after)%minimum; \
-        ENET_SYMBOL_CREATE (symbol_, value_, update); \
-        node -> right = symbol_ - node; \
-    }, \
-    { \
-        value_ = node->value - 1 - (after - before - code - 1)/minimum; \
-        under_ = code - (after - before - code - 1)%minimum; \
-        ENET_SYMBOL_CREATE (symbol_, value_, update); \
-        node -> left = symbol_ - node; \
-    }) \
-
-#ifdef ENET_CONTEXT_EXCLUSION
-typedef struct _ENetExclude
-{
-    enet_uint8 value;
-    enet_uint16 under;
-} ENetExclude;
-
-#define ENET_CONTEXT_DECODE_EXCLUDE(context, total, minimum) \
-{ \
-    enet_uint16 under = 0; \
-    nextExclude = excludes; \
-    ENET_CONTEXT_WALK (context, { \
-        under += rangeCoder -> symbols [node -> parent].count + minimum; \
-        nextExclude -> value = node -> value; \
-        nextExclude -> under = under; \
-        nextExclude ++; \
-    }); \
-    total -= under; \
-}
-
-#define ENET_CONTEXT_EXCLUDED(value_, after, before) \
-{ \
-    size_t low = 0, high = nextExclude - excludes; \
-    for(;;) \
-    { \
-        size_t mid = (low + high) >> 1; \
-        const ENetExclude * exclude = & excludes [mid]; \
-        if (value_ < exclude -> value) \
-        { \
-            if (low + 1 < high) \
-            { \
-                high = mid; \
-                continue; \
-            } \
-            if (exclude > excludes) \
-              after -= exclude [-1].under; \
-        } \
-        else \
-        { \
-            if (value_ > exclude -> value) \
-            { \
-                if (low + 1 < high) \
-                { \
-                    low = mid; \
-                    continue; \
-                } \
-            } \
-            else \
-              before = 0; \
-            after -= exclude -> under; \
-        } \
-        break; \
-    } \
-}
-#endif
-
-#define ENET_CONTEXT_NOT_EXCLUDED(value_, after, before)
-
-size_t
-enet_range_coder_decompress (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit)
-{
-    ENetRangeCoder * rangeCoder = (ENetRangeCoder *) context;
-    enet_uint8 * outStart = outData, * outEnd = & outData [outLimit];
-    const enet_uint8 * inEnd = & inData [inLimit];
-    enet_uint32 decodeLow = 0, decodeCode = 0, decodeRange = ~0;
-    ENetSymbol * root;
-    enet_uint16 predicted = 0;
-    size_t order = 0, nextSymbol = 0;
-#ifdef ENET_CONTEXT_EXCLUSION
-    ENetExclude excludes [256];
-    ENetExclude * nextExclude = excludes;
-#endif
-  
-    if (rangeCoder == NULL || inLimit <= 0)
-      return 0;
-
-    ENET_CONTEXT_CREATE (root, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM);
-
-    ENET_RANGE_CODER_SEED;
-
-    for (;;)
-    {
-        ENetSymbol * subcontext, * symbol, * patch;
-#ifdef ENET_CONTEXT_EXCLUSION
-        const ENetSymbol * childContext = & emptyContext;
-#endif
-        enet_uint8 value = 0;
-        enet_uint16 code, under, count, bottom, * parent = & predicted, total;
-
-        for (subcontext = & rangeCoder -> symbols [predicted];
-             subcontext != root;
-#ifdef ENET_CONTEXT_EXCLUSION
-             childContext = subcontext, 
-#endif
-                subcontext = & rangeCoder -> symbols [subcontext -> parent])
-        {
-            if (subcontext -> escapes <= 0)
-              continue;
-            total = subcontext -> total;
-#ifdef ENET_CONTEXT_EXCLUSION
-            if (childContext -> total > 0) 
-              ENET_CONTEXT_DECODE_EXCLUDE (childContext, total, 0); 
-#endif
-            if (subcontext -> escapes >= total)
-              continue;
-            code = ENET_RANGE_CODER_READ (total);
-            if (code < subcontext -> escapes) 
-            {
-                ENET_RANGE_CODER_DECODE (0, subcontext -> escapes, total); 
-                continue;
-            }
-            code -= subcontext -> escapes;
-#ifdef ENET_CONTEXT_EXCLUSION
-            if (childContext -> total > 0)
-            {
-                ENET_CONTEXT_TRY_DECODE (subcontext, symbol, code, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA, 0, ENET_CONTEXT_EXCLUDED); 
-            }
-            else
-#endif
-            {
-                ENET_CONTEXT_TRY_DECODE (subcontext, symbol, code, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA, 0, ENET_CONTEXT_NOT_EXCLUDED); 
-            }
-            bottom = symbol - rangeCoder -> symbols;
-            ENET_RANGE_CODER_DECODE (subcontext -> escapes + under, count, total);
-            subcontext -> total += ENET_SUBCONTEXT_SYMBOL_DELTA;
-            if (count > 0xFF - 2*ENET_SUBCONTEXT_SYMBOL_DELTA || subcontext -> total > ENET_RANGE_CODER_BOTTOM - 0x100)
-              ENET_CONTEXT_RESCALE (subcontext, 0);
-            goto patchContexts;
-        }
-
-        total = root -> total;
-#ifdef ENET_CONTEXT_EXCLUSION
-        if (childContext -> total > 0)
-          ENET_CONTEXT_DECODE_EXCLUDE (childContext, total, ENET_CONTEXT_SYMBOL_MINIMUM);  
-#endif
-        code = ENET_RANGE_CODER_READ (total);
-        if (code < root -> escapes)
-        {
-            ENET_RANGE_CODER_DECODE (0, root -> escapes, total);
-            break;
-        }
-        code -= root -> escapes;
-#ifdef ENET_CONTEXT_EXCLUSION
-        if (childContext -> total > 0)
-        {
-            ENET_CONTEXT_ROOT_DECODE (root, symbol, code, value, under, count, ENET_CONTEXT_SYMBOL_DELTA, ENET_CONTEXT_SYMBOL_MINIMUM, ENET_CONTEXT_EXCLUDED); 
-        }
-        else
-#endif
-        {
-            ENET_CONTEXT_ROOT_DECODE (root, symbol, code, value, under, count, ENET_CONTEXT_SYMBOL_DELTA, ENET_CONTEXT_SYMBOL_MINIMUM, ENET_CONTEXT_NOT_EXCLUDED); 
-        }
-        bottom = symbol - rangeCoder -> symbols;
-        ENET_RANGE_CODER_DECODE (root -> escapes + under, count, total);
-        root -> total += ENET_CONTEXT_SYMBOL_DELTA;
-        if (count > 0xFF - 2*ENET_CONTEXT_SYMBOL_DELTA + ENET_CONTEXT_SYMBOL_MINIMUM || root -> total > ENET_RANGE_CODER_BOTTOM - 0x100)
-          ENET_CONTEXT_RESCALE (root, ENET_CONTEXT_SYMBOL_MINIMUM);
-
-    patchContexts:
-        for (patch = & rangeCoder -> symbols [predicted];
-             patch != subcontext;
-             patch = & rangeCoder -> symbols [patch -> parent])
-        {
-            ENET_CONTEXT_ENCODE (patch, symbol, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA, 0);
-            * parent = symbol - rangeCoder -> symbols;
-            parent = & symbol -> parent;
-            if (count <= 0)
-            {
-                patch -> escapes += ENET_SUBCONTEXT_ESCAPE_DELTA;
-                patch -> total += ENET_SUBCONTEXT_ESCAPE_DELTA;
-            }
-            patch -> total += ENET_SUBCONTEXT_SYMBOL_DELTA; 
-            if (count > 0xFF - 2*ENET_SUBCONTEXT_SYMBOL_DELTA || patch -> total > ENET_RANGE_CODER_BOTTOM - 0x100)
-              ENET_CONTEXT_RESCALE (patch, 0);
-        }
-        * parent = bottom;
-
-        ENET_RANGE_CODER_OUTPUT (value);
-
-        if (order >= ENET_SUBCONTEXT_ORDER)
-          predicted = rangeCoder -> symbols [predicted].parent;
-        else
-          order ++;
-        ENET_RANGE_CODER_FREE_SYMBOLS;
-    }
-                        
-    return (size_t) (outData - outStart);
-}
-
-/** @defgroup host ENet host functions
-    @{
-*/
-
-/** Sets the packet compressor the host should use to the default range coder.
-    @param host host to enable the range coder for
-    @returns 0 on success, < 0 on failure
-*/
-int
-enet_host_compress_with_range_coder (ENetHost * host)
-{
-    ENetCompressor compressor;
-    memset (& compressor, 0, sizeof (compressor));
-    compressor.context = enet_range_coder_create();
-    if (compressor.context == NULL)
-      return -1;
-    compressor.compress = enet_range_coder_compress;
-    compressor.decompress = enet_range_coder_decompress;
-    compressor.destroy = enet_range_coder_destroy;
-    enet_host_compress (host, & compressor);
-    return 0;
-}
-    
-/** @} */
-    
-     

externals/enet/configure.ac

@@ -1,28 +0,0 @@
-AC_INIT([libenet], [1.3.18])
-AC_CONFIG_SRCDIR([include/enet/enet.h])
-AM_INIT_AUTOMAKE([foreign])
-
-AC_CONFIG_MACRO_DIR([m4])
-
-AC_PROG_CC
-AC_PROG_LIBTOOL
-
-AC_CHECK_FUNC(getaddrinfo, [AC_DEFINE(HAS_GETADDRINFO)])
-AC_CHECK_FUNC(getnameinfo, [AC_DEFINE(HAS_GETNAMEINFO)])
-AC_CHECK_FUNC(gethostbyaddr_r, [AC_DEFINE(HAS_GETHOSTBYADDR_R)])
-AC_CHECK_FUNC(gethostbyname_r, [AC_DEFINE(HAS_GETHOSTBYNAME_R)])
-AC_CHECK_FUNC(poll, [AC_DEFINE(HAS_POLL)])
-AC_CHECK_FUNC(fcntl, [AC_DEFINE(HAS_FCNTL)])
-AC_CHECK_FUNC(inet_pton, [AC_DEFINE(HAS_INET_PTON)])
-AC_CHECK_FUNC(inet_ntop, [AC_DEFINE(HAS_INET_NTOP)])
-
-AC_CHECK_MEMBER(struct msghdr.msg_flags, [AC_DEFINE(HAS_MSGHDR_FLAGS)], , [#include <sys/socket.h>])
-
-AC_CHECK_TYPE(socklen_t, [AC_DEFINE(HAS_SOCKLEN_T)], , 
-              #include <sys/types.h>
-              #include <sys/socket.h>
-)
-
-AC_CONFIG_FILES([Makefile
-	libenet.pc])
-AC_OUTPUT

externals/enet/docs/FAQ.dox

@@ -1,24 +0,0 @@
-/**
- @page FAQ Frequently Answered Questions
-
-@section Q1 Is ENet thread-safe?
-
-ENet does not use any significant global variables, the vast majority
-of state is encapsulated in the ENetHost structure.  As such, as long
-as the application guards access to this structure, then ENet should
-operate fine in a multi-threaded environment.
-   
-@section Q2 Isn't ENet just re-inventing TCP?!  What's the point?
-
-In a perfect world, that would be true.  But as many have found, using
-TCP either in lieu of or in conjunction with UDP can lead to all kinds
-of nightmares.  TCP is a good, solid protocol, however it simply isn't
-up to the task of real-time games.  Too much of TCP's implementation
-dictates a policy that isn't practical for games.  If you want to use
-TCP, then do so -- this library is for people that either don't want
-to use TCP or have tried and ended up being discouraged with the
-performance.
-
-*/
-
-

externals/enet/docs/design.dox

@@ -1,126 +0,0 @@
-/**
-@page Features Features and Architecture
-
-ENet evolved specifically as a UDP networking layer for the
-multiplayer first person shooter Cube. Cube necessitated low latency
-communication with data sent out very frequently, so TCP was an
-unsuitable choice due to its high latency and stream orientation. UDP,
-however, lacks many sometimes necessary features from TCP such as
-reliability, sequencing, unrestricted packet sizes, and connection
-management. So UDP by itself was not suitable as a network protocol
-either. No suitable freely available networking libraries existed at
-the time of ENet's creation to fill this niche.
-
-UDP and TCP could have been used together in Cube to benefit somewhat
-from both of their features, however, the resulting combinations of
-protocols still leaves much to be desired. TCP lacks multiple streams
-of communication without resorting to opening many sockets and
-complicates delineation of packets due to its buffering behavior. UDP
-lacks sequencing, connection management, management of bandwidth
-resources, and imposes limitations on the size of packets. A
-significant investment is required to integrate these two protocols,
-and the end result is worse off in features and performance than the
-uniform protocol presented by ENet.
-
-ENet thus attempts to address these issues and provide a single,
-uniform protocol layered over UDP to the developer with the best
-features of UDP and TCP as well as some useful features neither
-provide, with a much cleaner integration than any resulting from a
-mixture of UDP and TCP.
-
-@section CM Connection Management
-
-ENet provides a simple connection interface over which to communicate
-with a foreign host. The liveness of the connection is actively
-monitored by pinging the foreign host at frequent intervals, and also
-monitors the network conditions from the local host to the foreign
-host such as the mean round trip time and packet loss in this fashion.
-
-@section Sequencing Sequencing
-    
-Rather than a single byte stream that complicates the delineation of
-packets, ENet presents connections as multiple, properly sequenced
-packet streams that simplify the transfer of various types of data.
-
-ENet provides sequencing for all packets by assigning to each sent
-packet a sequence number that is incremented as packets are sent. ENet
-guarantees that no packet with a higher sequence number will be
-delivered before a packet with a lower sequence number, thus ensuring
-packets are delivered exactly in the order they are sent.
-
-For unreliable packets, ENet will simply discard the lower sequence
-number packet if a packet with a higher sequence number has already
-been delivered. This allows the packets to be dispatched immediately
-as they arrive, and reduce latency of unreliable packets to an
-absolute minimum.  For reliable packets, if a higher sequence number
-packet arrives, but the preceding packets in the sequence have not yet
-arrived, ENet will stall delivery of the higher sequence number
-packets until its predecessors have arrived.
-
-@section Channels Channels
-
-Since ENet will stall delivery of reliable packets to ensure proper
-sequencing, and consequently any packets of higher sequence number
-whether reliable or unreliable, in the event the reliable packet's
-predecessors have not yet arrived, this can introduce latency into the
-delivery of other packets which may not need to be as strictly ordered
-with respect to the packet that stalled their delivery.
-
-To combat this latency and reduce the ordering restrictions on
-packets, ENet provides multiple channels of communication over a given
-connection.  Each channel is independently sequenced, and so the
-delivery status of a packet in one channel will not stall the delivery
-of other packets in another channel.
-
-@section Reliability Reliability
-
-ENet provides optional reliability of packet delivery by ensuring the
-foreign host acknowledges receipt of all reliable packets. ENet will
-attempt to resend the packet up to a reasonable amount of times, if no
-acknowledgement of the packet's receipt happens within a specified
-timeout. Retry timeouts are progressive and become more lenient with
-every failed attempt to allow for temporary turbulence in network
-conditions.
-
-@section FaR Fragmentation and Reassembly
-
-ENet will send and deliver packets regardless of size. Large packets
-are fragmented into many smaller packets of suitable size, and
-reassembled on the foreign host to recover the original packet for
-delivery. The process is entirely transparent to the developer.
-
-@section Aggregation Aggregation
-
-ENet aggregates all protocol commands, including acknowledgements and
-packet transfer, into larger protocol packets to ensure the proper
-utilization of the connection and to limit the opportunities for
-packet loss that might otherwise result in further delivery latency.
-
-@section Adaptability Adaptability
-
-ENet provides an in-flight data window for reliable packets to ensure
-connections are not overwhelmed by volumes of packets. It also
-provides a static bandwidth allocation mechanism to ensure the total
-volume of packets sent and received to a host don't exceed the host's
-capabilities. Further, ENet also provides a dynamic throttle that
-responds to deviations from normal network connections to rectify
-various types of network congestion by further limiting the volume of
-packets sent.
-
-@section Portability Portability
-    
-ENet works on Windows and any other Unix or Unix-like platform
-providing a BSD sockets interface. The library has a small and stable
-code base that can easily be extended to support other platforms and
-integrates easily.  ENet makes no assumptions about the underlying
-platform's endianess or word size.
-
-@section Freedom Freedom
-
-ENet demands no royalties and doesn't carry a viral license that would
-restrict you in how you might use it in your programs. ENet is
-licensed under a short-and-sweet MIT-style license, which gives you
-the freedom to do anything you want with it (well, almost anything).
-
-*/
-

externals/enet/docs/install.dox

@@ -1,63 +0,0 @@
-/**
-@page Installation Installation
-
-ENet should be trivially simple to integrate with most applications.
-First, make sure you download the latest source distribution at @ref Downloads.
-
-@section Unix Unix-like Operating Systems
-
-If you are using an ENet release, then you should simply be able to build it
-by doing the following:
-
-./configure && make && make install
-
-If you obtained the package from github, you must have automake and autoconf
-available to generate the build system first by doing the following command
-before using the above mentioned build procedure:
-
-autoreconf -vfi
-
-
-@subsection SolarisBSD Solaris and BSD
-
-When building ENet under Solaris, you must specify the -lsocket and
--lnsl parameters to your compiler to ensure that the sockets library
-is linked in.
-
-@section Windows Microsoft Windows
-
-You may simply use the included "enet.lib" or "enet64.lib" static libraries. 
-However, if you wish to build the library yourself, then the following
-instructions apply:
-
-There is an included MSVC 6 project (enet.dsp) which you may use to
-build a suitable library file. Alternatively, you may simply drag all 
-the ENet source files into your main project.
-
-You will have to link to the Winsock2 libraries, so make sure to add
-ws2_32.lib and winmm.lib to your library list (Project Settings | Link |
-Object/library modules).
-
-@subsection enet.dsp Building with the included enet.dsp
-
-Load the included enet.dsp. MSVC may ask you to convert it if you
-are on a newer version of MSVC - just allow the conversion and save
-the resulting project as "enet" or similar. After you build this
-project, it will output an "enet.lib" file to either the "Debug/"
-or "Release/" directory, depending on which configuration you have
-selected to build. By default, it should produce "Debug/enet.lib".
-
-You may then copy the resulting "enet.lib" file and the header files
-found in the "include/" directory to your other projects and add it to 
-their library lists. Make sure to also link against "ws2_32.lib" and
-"winmm.lib" as described above.
-
-@subsection DLL DLL
-
-If you wish to build ENet as a DLL you must first define ENET_DLL
-within the project (Project Settings | C/C++ | Preprocessor |
-Preprocessor definitions) or, more invasively, simply define ENET_DLL
-at the top of enet.h.
-
-*/
-

externals/enet/docs/license.dox

@@ -1,26 +0,0 @@
-/**
- @page License License
- 
-Copyright (c) 2002-2024 Lee Salzman
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-*/
-

externals/enet/docs/mainpage.dox

@@ -1,59 +0,0 @@
-/** @mainpage ENet
-
-ENet's purpose is to provide a relatively thin, simple and robust
-network communication layer on top of UDP (User Datagram Protocol).
-The primary feature it provides is optional reliable, in-order
-delivery of packets.
-
-ENet omits certain higher level networking features such as authentication, 
-lobbying, server discovery, encryption, or other similar tasks that are
-particularly application specific so that the library remains flexible,
-portable, and easily embeddable.
-
-@ref Features
-
-@ref Downloads
-
-@ref Installation
-
-@ref Tutorial
-
-@ref MailingList
-
-@ref IRCChannel
-
-@ref FAQ
-
-@ref License
-
-<a class="el" href="usergroup0.html">Documentation</a>
-
- */
-
-/**
-@page Downloads Downloads
-
-You can retrieve the source to ENet by downloading it in either .tar.gz form
-or accessing the github distribution directly.
-
-The most recent stable release (1.3.18) can be downloaded <a class="el" href="download/enet-1.3.18.tar.gz">here</a>.
-The last release that is protocol compatible with the 1.2 series or earlier (1.2.5) can be downloaded <a class="el" href="download/enet-1.2.5.tar.gz">here</a>. 
-
-You can find the most recent ENet source at <a class="el" href="https://github.com/lsalzman/enet">the github repository</a>.
-
-*/
-
-/**
-@page MailingList Mailing List
-
-The <a class="el" href="http://lists.cubik.org/mailman/listinfo/enet-discuss">enet-discuss</a> list is for discussion of ENet, including bug reports or feature requests.
-
-*/
-
-/**
-@page IRCChannel IRC Channel
-
-Join the \#enet channel on the <a class="el" href="https://libera.chat">Libera Chat IRC network (irc.libera.chat)</a> for real-time discussion about the ENet library.
-
-*/
-

externals/enet/docs/tutorial.dox

@@ -1,366 +0,0 @@
-/**
-@page Tutorial Tutorial
-
-@ref Initialization
-
-@ref CreateServer
-
-@ref CreateClient
-
-@ref ManageHost
-
-@ref SendingPacket
-
-@ref Disconnecting
-
-@ref Connecting
-
-@section Initialization Initialization
-
-You should include the file <enet/enet.h> when using ENet. Do not
-include <enet.h> without the directory prefix, as this may cause
-file name conflicts on some systems.
-
-Before using ENet, you must call enet_initialize() to initialize the
-library. Upon program exit, you should call enet_deinitialize() so
-that the library may clean up any used resources.
-
-@code
-#include <enet/enet.h>
-
-int 
-main (int argc, char ** argv) 
-{
-    if (enet_initialize () != 0)
-    {
-        fprintf (stderr, "An error occurred while initializing ENet.\n");
-        return EXIT_FAILURE;
-    }
-    atexit (enet_deinitialize);
-    ...
-    ...
-    ...
-}
-@endcode
-        
-@section CreateServer Creating an ENet server
-
-Servers in ENet are constructed with enet_host_create(). You must
-specify an address on which to receive data and new connections, as
-well as the maximum allowable numbers of connected peers. You may
-optionally specify the incoming and outgoing bandwidth of the server
-in bytes per second so that ENet may try to statically manage
-bandwidth resources among connected peers in addition to its dynamic
-throttling algorithm; specifying 0 for these two options will cause
-ENet to rely entirely upon its dynamic throttling algorithm to manage
-bandwidth.
-
-When done with a host, the host may be destroyed with
-enet_host_destroy().  All connected peers to the host will be reset,
-and the resources used by the host will be freed.
-
-@code
-    ENetAddress address;
-    ENetHost * server;
-
-    /* Bind the server to the default localhost.     */
-    /* A specific host address can be specified by   */
-    /* enet_address_set_host (& address, "x.x.x.x"); */
-
-    address.host = ENET_HOST_ANY;
-    /* Bind the server to port 1234. */
-    address.port = 1234;
-
-    server = enet_host_create (& address /* the address to bind the server host to */, 
-                                 32      /* allow up to 32 clients and/or outgoing connections */,
-                                  2      /* allow up to 2 channels to be used, 0 and 1 */,
-                                  0      /* assume any amount of incoming bandwidth */,
-                                  0      /* assume any amount of outgoing bandwidth */);
-    if (server == NULL)
-    {
-        fprintf (stderr, 
-                 "An error occurred while trying to create an ENet server host.\n");
-        exit (EXIT_FAILURE);
-    }
-    ...
-    ...
-    ...
-    enet_host_destroy(server);
-@endcode
-
-@section CreateClient Creating an ENet client
-
-Clients in ENet are similarly constructed with enet_host_create() when
-no address is specified to bind the host to. Bandwidth may be
-specified for the client host as in the above example. The peer count
-controls the maximum number of connections to other server hosts that
-may be simultaneously open.
-
-@code
-    ENetHost * client;
-
-    client = enet_host_create (NULL /* create a client host */,
-                1 /* only allow 1 outgoing connection */,
-                2 /* allow up 2 channels to be used, 0 and 1 */,
-                0 /* assume any amount of incoming bandwidth */,
-                0 /* assume any amount of outgoing bandwidth */);
-
-    if (client == NULL)
-    {
-        fprintf (stderr, 
-                 "An error occurred while trying to create an ENet client host.\n");
-        exit (EXIT_FAILURE);
-    }
-    ...
-    ...
-    ...
-    enet_host_destroy(client);
-@endcode
-
-@section ManageHost Managing an ENet host
-
-ENet uses a polled event model to notify the programmer of significant
-events. ENet hosts are polled for events with enet_host_service(),
-where an optional timeout value in milliseconds may be specified to
-control how long ENet will poll; if a timeout of 0 is specified,
-enet_host_service() will return immediately if there are no events to
-dispatch. enet_host_service() will return 1 if an event was dispatched
-within the specified timeout.
-
-Beware that most processing of the network with the ENet stack is done 
-inside enet_host_service(). Both hosts that make up the sides of a connection 
-must regularly call this function to ensure packets are actually sent and
-received. A common symptom of not actively calling enet_host_service()
-on both ends is that one side receives events while the other does not.
-The best way to schedule this activity to ensure adequate service is, for
-example, to call enet_host_service() with a 0 timeout (meaning non-blocking)
-at the beginning of every frame in a game loop.
-
-Currently there are only four types of significant events in ENet:
-
-An event of type ENET_EVENT_TYPE_NONE is returned if no event occurred
-within the specified time limit. enet_host_service() will return 0
-with this event.
-
-An event of type ENET_EVENT_TYPE_CONNECT is returned when either a new client
-host has connected to the server host or when an attempt to establish a 
-connection with a foreign host has succeeded. Only the "peer" field of the 
-event structure is valid for this event and contains the newly connected peer.
-
-An event of type ENET_EVENT_TYPE_RECEIVE is returned when a packet is received
-from a connected peer. The "peer" field contains the peer the packet was 
-received from, "channelID" is the channel on which the packet was sent, and 
-"packet" is the packet that was sent. The packet contained in the "packet" 
-field must be destroyed with enet_packet_destroy() when you are done 
-inspecting its contents.
-
-An event of type ENET_EVENT_TYPE_DISCONNECT is returned when a connected peer
-has either explicitly disconnected or timed out. Only the "peer" field of the
-event structure is valid for this event and contains the peer that 
-disconnected. Only the "data" field of the peer is still valid on a 
-disconnect event and must be explicitly reset.
-
-@code
-    ENetEvent event;
-    
-    /* Wait up to 1000 milliseconds for an event. */
-    while (enet_host_service (client, & event, 1000) > 0)
-    {
-        switch (event.type)
-        {
-        case ENET_EVENT_TYPE_CONNECT:
-            printf ("A new client connected from %x:%u.\n", 
-                    event.peer -> address.host,
-                    event.peer -> address.port);
-
-            /* Store any relevant client information here. */
-            event.peer -> data = "Client information";
-
-            break;
-
-        case ENET_EVENT_TYPE_RECEIVE:
-            printf ("A packet of length %u containing %s was received from %s on channel %u.\n",
-                    event.packet -> dataLength,
-                    event.packet -> data,
-                    event.peer -> data,
-                    event.channelID);
-
-            /* Clean up the packet now that we're done using it. */
-            enet_packet_destroy (event.packet);
-            
-            break;
-           
-        case ENET_EVENT_TYPE_DISCONNECT:
-            printf ("%s disconnected.\n", event.peer -> data);
-
-            /* Reset the peer's client information. */
-
-            event.peer -> data = NULL;
-        }
-    }
-    ...
-    ...
-    ...
-@endcode
-
-@section SendingPacket Sending a packet to an ENet peer
-
-Packets in ENet are created with enet_packet_create(), where the size
-of the packet must be specified. Optionally, initial data may be
-specified to copy into the packet.
-
-Certain flags may also be supplied to enet_packet_create() to control
-various packet features:
-
-ENET_PACKET_FLAG_RELIABLE specifies that the packet must use reliable
-delivery.  A reliable packet is guaranteed to be delivered, and a
-number of retry attempts will be made until an acknowledgement is
-received from the foreign host the packet is sent to. If a certain
-number of retry attempts is reached without any acknowledgement, ENet
-will assume the peer has disconnected and forcefully reset the
-connection. If this flag is not specified, the packet is assumed an
-unreliable packet, and no retry attempts will be made nor
-acknowledgements generated.
-
-A packet may be resized (extended or truncated) with
-enet_packet_resize().
-
-A packet is sent to a foreign host with
-enet_peer_send(). enet_peer_send() accepts a channel id over which to
-send the packet to a given peer. Once the packet is handed over to
-ENet with enet_peer_send(), ENet will handle its deallocation and
-enet_packet_destroy() should not be used upon it.
-
-One may also use enet_host_broadcast() to send a packet to all
-connected peers on a given host over a specified channel id, as with
-enet_peer_send().
-
-Queued packets will be sent on a call to enet_host_service().
-Alternatively, enet_host_flush() will send out queued packets without
-dispatching any events.
-
-@code
-    /* Create a reliable packet of size 7 containing "packet\0" */
-    ENetPacket * packet = enet_packet_create ("packet", 
-                                              strlen ("packet") + 1, 
-                                              ENET_PACKET_FLAG_RELIABLE);
-
-    /* Extend the packet so and append the string "foo", so it now */
-    /* contains "packetfoo\0"                                      */
-    enet_packet_resize (packet, strlen ("packetfoo") + 1);
-    strcpy (& packet -> data [strlen ("packet")], "foo");
-    
-    /* Send the packet to the peer over channel id 0. */
-    /* One could also broadcast the packet by         */
-    /* enet_host_broadcast (host, 0, packet);         */
-    enet_peer_send (peer, 0, packet);
-    ...
-    ...
-    ...
-    /* One could just use enet_host_service() instead. */
-    enet_host_flush (host);
-@endcode
-
-@section Disconnecting Disconnecting an ENet peer
-
-Peers may be gently disconnected with enet_peer_disconnect(). A
-disconnect request will be sent to the foreign host, and ENet will
-wait for an acknowledgement from the foreign host before finally
-disconnecting. An event of type ENET_EVENT_TYPE_DISCONNECT will be
-generated once the disconnection succeeds. Normally timeouts apply to
-the disconnect acknowledgement, and so if no acknowledgement is
-received after a length of time the peer will be forcefully
-disconnected.
-
-enet_peer_reset() will forcefully disconnect a peer. The foreign host
-will get no notification of a disconnect and will time out on the
-foreign host. No event is generated.
-
-@code
-    ENetEvent event;
-    
-    enet_peer_disconnect (peer, 0);
-
-    /* Allow up to 3 seconds for the disconnect to succeed
-     * and drop any packets received packets.
-     */
-    while (enet_host_service (client, & event, 3000) > 0)
-    {
-        switch (event.type)
-        {
-        case ENET_EVENT_TYPE_RECEIVE:
-            enet_packet_destroy (event.packet);
-            break;
-
-        case ENET_EVENT_TYPE_DISCONNECT:
-            puts ("Disconnection succeeded.");
-            return;
-        ...
-        ...
-        ...
-        }
-    }
-    
-    /* We've arrived here, so the disconnect attempt didn't */
-    /* succeed yet.  Force the connection down.             */
-    enet_peer_reset (peer);
-    ...
-    ...
-    ...
-@endcode
-
-@section Connecting Connecting to an ENet host
-
-A connection to a foreign host is initiated with enet_host_connect().
-It accepts the address of a foreign host to connect to, and the number
-of channels that should be allocated for communication. If N channels
-are allocated for use, their channel ids will be numbered 0 through
-N-1.  A peer representing the connection attempt is returned, or NULL
-if there were no available peers over which to initiate the
-connection. When the connection attempt succeeds, an event of type
-ENET_EVENT_TYPE_CONNECT will be generated. If the connection attempt
-times out or otherwise fails, an event of type
-ENET_EVENT_TYPE_DISCONNECT will be generated.
-
-@code
-    ENetAddress address;
-    ENetEvent event;
-    ENetPeer *peer;
-
-    /* Connect to some.server.net:1234. */
-    enet_address_set_host (& address, "some.server.net");
-    address.port = 1234;
-
-    /* Initiate the connection, allocating the two channels 0 and 1. */
-    peer = enet_host_connect (client, & address, 2, 0);    
-    
-    if (peer == NULL)
-    {
-       fprintf (stderr, 
-                "No available peers for initiating an ENet connection.\n");
-       exit (EXIT_FAILURE);
-    }
-    
-    /* Wait up to 5 seconds for the connection attempt to succeed. */
-    if (enet_host_service (client, & event, 5000) > 0 &&
-        event.type == ENET_EVENT_TYPE_CONNECT)
-    {
-        puts ("Connection to some.server.net:1234 succeeded.");
-        ...
-        ...
-        ...
-    }
-    else
-    {
-        /* Either the 5 seconds are up or a disconnect event was */
-        /* received. Reset the peer in the event the 5 seconds   */
-        /* had run out without any significant event.            */
-        enet_peer_reset (peer);
-
-        puts ("Connection to some.server.net:1234 failed.");
-    }
-    ...
-    ...
-    ...
-@endcode
-*/

externals/enet/enet.dsp

@@ -1,168 +0,0 @@
-# Microsoft Developer Studio Project File - Name="enet" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Static Library" 0x0104
-
-CFG=enet - Win32 Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE 
-!MESSAGE NMAKE /f "enet.mak".
-!MESSAGE 
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE 
-!MESSAGE NMAKE /f "enet.mak" CFG="enet - Win32 Debug"
-!MESSAGE 
-!MESSAGE Possible choices for configuration are:
-!MESSAGE 
-!MESSAGE "enet - Win32 Release" (based on "Win32 (x86) Static Library")
-!MESSAGE "enet - Win32 Debug" (based on "Win32 (x86) Static Library")
-!MESSAGE 
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-RSC=rc.exe
-
-!IF  "$(CFG)" == "enet - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Target_Dir ""
-MTL=midl.exe
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /W3 /O2 /I "include" /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /FD /c
-# SUBTRACT CPP /YX
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo
-
-!ELSEIF  "$(CFG)" == "enet - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Target_Dir ""
-MTL=midl.exe
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /G6 /MTd /W3 /ZI /Od /I "include" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /FR /FD /GZ /c
-# SUBTRACT CPP /YX
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo
-
-!ENDIF 
-
-# Begin Target
-
-# Name "enet - Win32 Release"
-# Name "enet - Win32 Debug"
-# Begin Group "Source Files"
-
-# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
-# Begin Source File
-
-SOURCE=.\host.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\list.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\callbacks.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\compress.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\packet.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\peer.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\protocol.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\unix.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\win32.c
-# End Source File
-# End Group
-# Begin Group "Header Files"
-
-# PROP Default_Filter "h;hpp;hxx;hm;inl"
-# Begin Source File
-
-SOURCE=.\include\enet\enet.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\include\enet\list.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\include\enet\callbacks.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\include\enet\protocol.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\include\enet\time.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\include\enet\types.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\include\enet\unix.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\include\enet\utility.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\include\enet\win32.h
-# End Source File
-# End Group
-# End Target
-# End Project

externals/enet/enet_dll.cbp

@@ -1,86 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
-<CodeBlocks_project_file>
-	<FileVersion major="1" minor="6" />
-	<Project>
-		<Option title="enet_dll" />
-		<Option pch_mode="2" />
-		<Option compiler="gcc" />
-		<Build>
-			<Target title="Debug">
-				<Option output="bin\Debug\libenet" prefix_auto="1" extension_auto="1" />
-				<Option object_output="obj\Debug\" />
-				<Option type="3" />
-				<Option compiler="gcc" />
-				<Option createDefFile="1" />
-				<Option createStaticLib="1" />
-				<Compiler>
-					<Add option="-g" />
-				</Compiler>
-			</Target>
-			<Target title="Release">
-				<Option output="bin\Release\libenet" prefix_auto="1" extension_auto="1" />
-				<Option object_output="obj\Release\" />
-				<Option type="3" />
-				<Option compiler="gcc" />
-				<Option createDefFile="1" />
-				<Option createStaticLib="1" />
-				<Compiler>
-					<Add option="-O2" />
-				</Compiler>
-				<Linker>
-					<Add option="-s" />
-				</Linker>
-			</Target>
-		</Build>
-		<Compiler>
-			<Add option="-Wall" />
-			<Add option="-DENET_DLL" />
-			<Add directory="include" />
-		</Compiler>
-		<Linker>
-			<Add library="ws2_32" />
-			<Add library="Winmm" />
-		</Linker>
-		<Unit filename="callbacks.c">
-			<Option compilerVar="CC" />
-		</Unit>
-		<Unit filename="compress.c">
-			<Option compilerVar="CC" />
-		</Unit>
-		<Unit filename="host.c">
-			<Option compilerVar="CC" />
-		</Unit>
-		<Unit filename="include\enet\callbacks.h" />
-		<Unit filename="include\enet\enet.h" />
-		<Unit filename="include\enet\list.h" />
-		<Unit filename="include\enet\protocol.h" />
-		<Unit filename="include\enet\time.h" />
-		<Unit filename="include\enet\types.h" />
-		<Unit filename="include\enet\unix.h" />
-		<Unit filename="include\enet\utility.h" />
-		<Unit filename="include\enet\win32.h" />
-		<Unit filename="list.c">
-			<Option compilerVar="CC" />
-		</Unit>
-		<Unit filename="packet.c">
-			<Option compilerVar="CC" />
-		</Unit>
-		<Unit filename="peer.c">
-			<Option compilerVar="CC" />
-		</Unit>
-		<Unit filename="protocol.c">
-			<Option compilerVar="CC" />
-		</Unit>
-		<Unit filename="unix.c">
-			<Option compilerVar="CC" />
-		</Unit>
-		<Unit filename="win32.c">
-			<Option compilerVar="CC" />
-		</Unit>
-		<Extensions>
-			<code_completion />
-			<envvars />
-			<debugger />
-		</Extensions>
-	</Project>
-</CodeBlocks_project_file>

externals/enet/host.c

@@ -1,503 +0,0 @@
-/** 
- @file host.c
- @brief ENet host management functions
-*/
-#define ENET_BUILDING_LIB 1
-#include <string.h>
-#include "enet/enet.h"
-
-/** @defgroup host ENet host functions
-    @{
-*/
-
-/** Creates a host for communicating to peers.  
-
-    @param address   the address at which other peers may connect to this host.  If NULL, then no peers may connect to the host.
-    @param peerCount the maximum number of peers that should be allocated for the host.
-    @param channelLimit the maximum number of channels allowed; if 0, then this is equivalent to ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT
-    @param incomingBandwidth downstream bandwidth of the host in bytes/second; if 0, ENet will assume unlimited bandwidth.
-    @param outgoingBandwidth upstream bandwidth of the host in bytes/second; if 0, ENet will assume unlimited bandwidth.
-
-    @returns the host on success and NULL on failure
-
-    @remarks ENet will strategically drop packets on specific sides of a connection between hosts
-    to ensure the host's bandwidth is not overwhelmed.  The bandwidth parameters also determine
-    the window size of a connection which limits the amount of reliable packets that may be in transit
-    at any given time.
-*/
-ENetHost *
-enet_host_create (const ENetAddress * address, size_t peerCount, size_t channelLimit, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth)
-{
-    ENetHost * host;
-    ENetPeer * currentPeer;
-
-    if (peerCount > ENET_PROTOCOL_MAXIMUM_PEER_ID)
-      return NULL;
-
-    host = (ENetHost *) enet_malloc (sizeof (ENetHost));
-    if (host == NULL)
-      return NULL;
-    memset (host, 0, sizeof (ENetHost));
-
-    host -> peers = (ENetPeer *) enet_malloc (peerCount * sizeof (ENetPeer));
-    if (host -> peers == NULL)
-    {
-       enet_free (host);
-
-       return NULL;
-    }
-    memset (host -> peers, 0, peerCount * sizeof (ENetPeer));
-
-    host -> socket = enet_socket_create (ENET_SOCKET_TYPE_DATAGRAM);
-    if (host -> socket == ENET_SOCKET_NULL || (address != NULL && enet_socket_bind (host -> socket, address) < 0))
-    {
-       if (host -> socket != ENET_SOCKET_NULL)
-         enet_socket_destroy (host -> socket);
-
-       enet_free (host -> peers);
-       enet_free (host);
-
-       return NULL;
-    }
-
-    enet_socket_set_option (host -> socket, ENET_SOCKOPT_NONBLOCK, 1);
-    enet_socket_set_option (host -> socket, ENET_SOCKOPT_BROADCAST, 1);
-    enet_socket_set_option (host -> socket, ENET_SOCKOPT_RCVBUF, ENET_HOST_RECEIVE_BUFFER_SIZE);
-    enet_socket_set_option (host -> socket, ENET_SOCKOPT_SNDBUF, ENET_HOST_SEND_BUFFER_SIZE);
-
-    if (address != NULL && enet_socket_get_address (host -> socket, & host -> address) < 0)   
-      host -> address = * address;
-
-    if (! channelLimit || channelLimit > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
-      channelLimit = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
-    else
-    if (channelLimit < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT)
-      channelLimit = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;
-
-    host -> randomSeed = (enet_uint32) (size_t) host;
-    host -> randomSeed += enet_host_random_seed ();
-    host -> randomSeed = (host -> randomSeed << 16) | (host -> randomSeed >> 16);
-    host -> channelLimit = channelLimit;
-    host -> incomingBandwidth = incomingBandwidth;
-    host -> outgoingBandwidth = outgoingBandwidth;
-    host -> bandwidthThrottleEpoch = 0;
-    host -> recalculateBandwidthLimits = 0;
-    host -> mtu = ENET_HOST_DEFAULT_MTU;
-    host -> peerCount = peerCount;
-    host -> commandCount = 0;
-    host -> bufferCount = 0;
-    host -> checksum = NULL;
-    host -> receivedAddress.host = ENET_HOST_ANY;
-    host -> receivedAddress.port = 0;
-    host -> receivedData = NULL;
-    host -> receivedDataLength = 0;
-     
-    host -> totalSentData = 0;
-    host -> totalSentPackets = 0;
-    host -> totalReceivedData = 0;
-    host -> totalReceivedPackets = 0;
-    host -> totalQueued = 0;
-
-    host -> connectedPeers = 0;
-    host -> bandwidthLimitedPeers = 0;
-    host -> duplicatePeers = ENET_PROTOCOL_MAXIMUM_PEER_ID;
-    host -> maximumPacketSize = ENET_HOST_DEFAULT_MAXIMUM_PACKET_SIZE;
-    host -> maximumWaitingData = ENET_HOST_DEFAULT_MAXIMUM_WAITING_DATA;
-
-    host -> compressor.context = NULL;
-    host -> compressor.compress = NULL;
-    host -> compressor.decompress = NULL;
-    host -> compressor.destroy = NULL;
-
-    host -> intercept = NULL;
-
-    enet_list_clear (& host -> dispatchQueue);
-
-    for (currentPeer = host -> peers;
-         currentPeer < & host -> peers [host -> peerCount];
-         ++ currentPeer)
-    {
-       currentPeer -> host = host;
-       currentPeer -> incomingPeerID = currentPeer - host -> peers;
-       currentPeer -> outgoingSessionID = currentPeer -> incomingSessionID = 0xFF;
-       currentPeer -> data = NULL;
-
-       enet_list_clear (& currentPeer -> acknowledgements);
-       enet_list_clear (& currentPeer -> sentReliableCommands);
-       enet_list_clear (& currentPeer -> outgoingCommands);
-       enet_list_clear (& currentPeer -> outgoingSendReliableCommands);
-       enet_list_clear (& currentPeer -> dispatchedCommands);
-
-       enet_peer_reset (currentPeer);
-    }
-
-    return host;
-}
-
-/** Destroys the host and all resources associated with it.
-    @param host pointer to the host to destroy
-*/
-void
-enet_host_destroy (ENetHost * host)
-{
-    ENetPeer * currentPeer;
-
-    if (host == NULL)
-      return;
-
-    enet_socket_destroy (host -> socket);
-
-    for (currentPeer = host -> peers;
-         currentPeer < & host -> peers [host -> peerCount];
-         ++ currentPeer)
-    {
-       enet_peer_reset (currentPeer);
-    }
-
-    if (host -> compressor.context != NULL && host -> compressor.destroy)
-      (* host -> compressor.destroy) (host -> compressor.context);
-
-    enet_free (host -> peers);
-    enet_free (host);
-}
-
-enet_uint32
-enet_host_random (ENetHost * host)
-{
-    /* Mulberry32 by Tommy Ettinger */
-    enet_uint32 n = (host -> randomSeed += 0x6D2B79F5U);
-    n = (n ^ (n >> 15)) * (n | 1U);
-    n ^= n + (n ^ (n >> 7)) * (n | 61U);
-    return n ^ (n >> 14);
-}
-
-/** Initiates a connection to a foreign host.
-    @param host host seeking the connection
-    @param address destination for the connection
-    @param channelCount number of channels to allocate
-    @param data user data supplied to the receiving host 
-    @returns a peer representing the foreign host on success, NULL on failure
-    @remarks The peer returned will have not completed the connection until enet_host_service()
-    notifies of an ENET_EVENT_TYPE_CONNECT event for the peer.
-*/
-ENetPeer *
-enet_host_connect (ENetHost * host, const ENetAddress * address, size_t channelCount, enet_uint32 data)
-{
-    ENetPeer * currentPeer;
-    ENetChannel * channel;
-    ENetProtocol command;
-
-    if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT)
-      channelCount = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;
-    else
-    if (channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
-      channelCount = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
-
-    for (currentPeer = host -> peers;
-         currentPeer < & host -> peers [host -> peerCount];
-         ++ currentPeer)
-    {
-       if (currentPeer -> state == ENET_PEER_STATE_DISCONNECTED)
-         break;
-    }
-
-    if (currentPeer >= & host -> peers [host -> peerCount])
-      return NULL;
-
-    currentPeer -> channels = (ENetChannel *) enet_malloc (channelCount * sizeof (ENetChannel));
-    if (currentPeer -> channels == NULL)
-      return NULL;
-    currentPeer -> channelCount = channelCount;
-    currentPeer -> state = ENET_PEER_STATE_CONNECTING;
-    currentPeer -> address = * address;
-    currentPeer -> connectID = enet_host_random (host);
-    currentPeer -> mtu = host -> mtu;
-
-    if (host -> outgoingBandwidth == 0)
-      currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    else
-      currentPeer -> windowSize = (host -> outgoingBandwidth /
-                                    ENET_PEER_WINDOW_SIZE_SCALE) * 
-                                      ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-
-    if (currentPeer -> windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)
-      currentPeer -> windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    else
-    if (currentPeer -> windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)
-      currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-         
-    for (channel = currentPeer -> channels;
-         channel < & currentPeer -> channels [channelCount];
-         ++ channel)
-    {
-        channel -> outgoingReliableSequenceNumber = 0;
-        channel -> outgoingUnreliableSequenceNumber = 0;
-        channel -> incomingReliableSequenceNumber = 0;
-        channel -> incomingUnreliableSequenceNumber = 0;
-
-        enet_list_clear (& channel -> incomingReliableCommands);
-        enet_list_clear (& channel -> incomingUnreliableCommands);
-
-        channel -> usedReliableWindows = 0;
-        memset (channel -> reliableWindows, 0, sizeof (channel -> reliableWindows));
-    }
-        
-    command.header.command = ENET_PROTOCOL_COMMAND_CONNECT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-    command.header.channelID = 0xFF;
-    command.connect.outgoingPeerID = ENET_HOST_TO_NET_16 (currentPeer -> incomingPeerID);
-    command.connect.incomingSessionID = currentPeer -> incomingSessionID;
-    command.connect.outgoingSessionID = currentPeer -> outgoingSessionID;
-    command.connect.mtu = ENET_HOST_TO_NET_32 (currentPeer -> mtu);
-    command.connect.windowSize = ENET_HOST_TO_NET_32 (currentPeer -> windowSize);
-    command.connect.channelCount = ENET_HOST_TO_NET_32 (channelCount);
-    command.connect.incomingBandwidth = ENET_HOST_TO_NET_32 (host -> incomingBandwidth);
-    command.connect.outgoingBandwidth = ENET_HOST_TO_NET_32 (host -> outgoingBandwidth);
-    command.connect.packetThrottleInterval = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleInterval);
-    command.connect.packetThrottleAcceleration = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleAcceleration);
-    command.connect.packetThrottleDeceleration = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleDeceleration);
-    command.connect.connectID = currentPeer -> connectID;
-    command.connect.data = ENET_HOST_TO_NET_32 (data);
- 
-    enet_peer_queue_outgoing_command (currentPeer, & command, NULL, 0, 0);
-
-    return currentPeer;
-}
-
-/** Queues a packet to be sent to all peers associated with the host.
-    @param host host on which to broadcast the packet
-    @param channelID channel on which to broadcast
-    @param packet packet to broadcast
-*/
-void
-enet_host_broadcast (ENetHost * host, enet_uint8 channelID, ENetPacket * packet)
-{
-    ENetPeer * currentPeer;
-
-    for (currentPeer = host -> peers;
-         currentPeer < & host -> peers [host -> peerCount];
-         ++ currentPeer)
-    {
-       if (currentPeer -> state != ENET_PEER_STATE_CONNECTED)
-         continue;
-
-       enet_peer_send (currentPeer, channelID, packet);
-    }
-
-    if (packet -> referenceCount == 0)
-      enet_packet_destroy (packet);
-}
-
-/** Sets the packet compressor the host should use to compress and decompress packets.
-    @param host host to enable or disable compression for
-    @param compressor callbacks for for the packet compressor; if NULL, then compression is disabled
-*/
-void
-enet_host_compress (ENetHost * host, const ENetCompressor * compressor)
-{
-    if (host -> compressor.context != NULL && host -> compressor.destroy)
-      (* host -> compressor.destroy) (host -> compressor.context);
-
-    if (compressor)
-      host -> compressor = * compressor;
-    else
-      host -> compressor.context = NULL;
-}
-
-/** Limits the maximum allowed channels of future incoming connections.
-    @param host host to limit
-    @param channelLimit the maximum number of channels allowed; if 0, then this is equivalent to ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT
-*/
-void
-enet_host_channel_limit (ENetHost * host, size_t channelLimit)
-{
-    if (! channelLimit || channelLimit > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
-      channelLimit = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
-    else
-    if (channelLimit < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT)
-      channelLimit = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;
-
-    host -> channelLimit = channelLimit;
-}
-
-
-/** Adjusts the bandwidth limits of a host.
-    @param host host to adjust
-    @param incomingBandwidth new incoming bandwidth
-    @param outgoingBandwidth new outgoing bandwidth
-    @remarks the incoming and outgoing bandwidth parameters are identical in function to those
-    specified in enet_host_create().
-*/
-void
-enet_host_bandwidth_limit (ENetHost * host, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth)
-{
-    host -> incomingBandwidth = incomingBandwidth;
-    host -> outgoingBandwidth = outgoingBandwidth;
-    host -> recalculateBandwidthLimits = 1;
-}
-
-void
-enet_host_bandwidth_throttle (ENetHost * host)
-{
-    enet_uint32 timeCurrent = enet_time_get (),
-           elapsedTime = timeCurrent - host -> bandwidthThrottleEpoch,
-           peersRemaining = (enet_uint32) host -> connectedPeers,
-           dataTotal = ~0,
-           bandwidth = ~0,
-           throttle = 0,
-           bandwidthLimit = 0;
-    int needsAdjustment = host -> bandwidthLimitedPeers > 0 ? 1 : 0;
-    ENetPeer * peer;
-    ENetProtocol command;
-
-    if (elapsedTime < ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL)
-      return;
-
-    host -> bandwidthThrottleEpoch = timeCurrent;
-
-    if (peersRemaining == 0)
-      return;
-
-    if (host -> outgoingBandwidth != 0)
-    {
-        dataTotal = 0;
-        bandwidth = (host -> outgoingBandwidth * elapsedTime) / 1000;
-
-        for (peer = host -> peers;
-             peer < & host -> peers [host -> peerCount];
-            ++ peer)
-        {
-            if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
-              continue;
-
-            dataTotal += peer -> outgoingDataTotal;
-        }
-    }
-
-    while (peersRemaining > 0 && needsAdjustment != 0)
-    {
-        needsAdjustment = 0;
-        
-        if (dataTotal <= bandwidth)
-          throttle = ENET_PEER_PACKET_THROTTLE_SCALE;
-        else
-          throttle = (bandwidth * ENET_PEER_PACKET_THROTTLE_SCALE) / dataTotal;
-
-        for (peer = host -> peers;
-             peer < & host -> peers [host -> peerCount];
-             ++ peer)
-        {
-            enet_uint32 peerBandwidth;
-            
-            if ((peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) ||
-                peer -> incomingBandwidth == 0 ||
-                peer -> outgoingBandwidthThrottleEpoch == timeCurrent)
-              continue;
-
-            peerBandwidth = (peer -> incomingBandwidth * elapsedTime) / 1000;
-            if ((throttle * peer -> outgoingDataTotal) / ENET_PEER_PACKET_THROTTLE_SCALE <= peerBandwidth)
-              continue;
-
-            peer -> packetThrottleLimit = (peerBandwidth * 
-                                            ENET_PEER_PACKET_THROTTLE_SCALE) / peer -> outgoingDataTotal;
-            
-            if (peer -> packetThrottleLimit == 0)
-              peer -> packetThrottleLimit = 1;
-            
-            if (peer -> packetThrottle > peer -> packetThrottleLimit)
-              peer -> packetThrottle = peer -> packetThrottleLimit;
-
-            peer -> outgoingBandwidthThrottleEpoch = timeCurrent;
-
-            peer -> incomingDataTotal = 0;
-            peer -> outgoingDataTotal = 0;
-
-            needsAdjustment = 1;
-            -- peersRemaining;
-            bandwidth -= peerBandwidth;
-            dataTotal -= peerBandwidth;
-        }
-    }
-
-    if (peersRemaining > 0)
-    {
-        if (dataTotal <= bandwidth)
-          throttle = ENET_PEER_PACKET_THROTTLE_SCALE;
-        else
-          throttle = (bandwidth * ENET_PEER_PACKET_THROTTLE_SCALE) / dataTotal;
-
-        for (peer = host -> peers;
-             peer < & host -> peers [host -> peerCount];
-             ++ peer)
-        {
-            if ((peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) ||
-                peer -> outgoingBandwidthThrottleEpoch == timeCurrent)
-              continue;
-
-            peer -> packetThrottleLimit = throttle;
-
-            if (peer -> packetThrottle > peer -> packetThrottleLimit)
-              peer -> packetThrottle = peer -> packetThrottleLimit;
-
-            peer -> incomingDataTotal = 0;
-            peer -> outgoingDataTotal = 0;
-        }
-    }
-
-    if (host -> recalculateBandwidthLimits)
-    {
-       host -> recalculateBandwidthLimits = 0;
-
-       peersRemaining = (enet_uint32) host -> connectedPeers;
-       bandwidth = host -> incomingBandwidth;
-       needsAdjustment = 1;
-
-       if (bandwidth == 0)
-         bandwidthLimit = 0;
-       else
-       while (peersRemaining > 0 && needsAdjustment != 0)
-       {
-           needsAdjustment = 0;
-           bandwidthLimit = bandwidth / peersRemaining;
-
-           for (peer = host -> peers;
-                peer < & host -> peers [host -> peerCount];
-                ++ peer)
-           {
-               if ((peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) ||
-                   peer -> incomingBandwidthThrottleEpoch == timeCurrent)
-                 continue;
-
-               if (peer -> outgoingBandwidth > 0 &&
-                   peer -> outgoingBandwidth >= bandwidthLimit)
-                 continue;
-
-               peer -> incomingBandwidthThrottleEpoch = timeCurrent;
- 
-               needsAdjustment = 1;
-               -- peersRemaining;
-               bandwidth -= peer -> outgoingBandwidth;
-           }
-       }
-
-       for (peer = host -> peers;
-            peer < & host -> peers [host -> peerCount];
-            ++ peer)
-       {
-           if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
-             continue;
-
-           command.header.command = ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-           command.header.channelID = 0xFF;
-           command.bandwidthLimit.outgoingBandwidth = ENET_HOST_TO_NET_32 (host -> outgoingBandwidth);
-
-           if (peer -> incomingBandwidthThrottleEpoch == timeCurrent)
-             command.bandwidthLimit.incomingBandwidth = ENET_HOST_TO_NET_32 (peer -> outgoingBandwidth);
-           else
-             command.bandwidthLimit.incomingBandwidth = ENET_HOST_TO_NET_32 (bandwidthLimit);
-
-           enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0);
-       } 
-    }
-}
-    
-/** @} */

externals/enet/include/enet/callbacks.h

@@ -1,37 +0,0 @@
-/** 
- @file  callbacks.h
- @brief ENet callbacks
-*/
-#ifndef __ENET_CALLBACKS_H__
-#define __ENET_CALLBACKS_H__
-
-#include <stdlib.h>
-
-typedef struct _ENetCallbacks
-{
-    void * (ENET_CALLBACK * malloc) (size_t size);
-    void (ENET_CALLBACK * free) (void * memory);
-    void (ENET_CALLBACK * no_memory) (void);
-} ENetCallbacks;
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-/** @defgroup callbacks ENet internal callbacks
-    @{
-    @ingroup private
-*/
-
-extern void * enet_malloc (size_t);
-extern void   enet_free (void *);
-
-/** @} */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __ENET_CALLBACKS_H__ */
-

externals/enet/include/enet/enet.h

@@ -1,615 +0,0 @@
-/** 
- @file  enet.h
- @brief ENet public header file
-*/
-#ifndef __ENET_ENET_H__
-#define __ENET_ENET_H__
-
-#include <stdlib.h>
-
-#ifdef _WIN32
-#include "enet/win32.h"
-#else
-#include "enet/unix.h"
-#endif
-
-#include "enet/types.h"
-#include "enet/protocol.h"
-#include "enet/list.h"
-#include "enet/callbacks.h"
-
-#define ENET_VERSION_MAJOR 1
-#define ENET_VERSION_MINOR 3
-#define ENET_VERSION_PATCH 18
-#define ENET_VERSION_CREATE(major, minor, patch) (((major)<<16) | ((minor)<<8) | (patch))
-#define ENET_VERSION_GET_MAJOR(version) (((version)>>16)&0xFF)
-#define ENET_VERSION_GET_MINOR(version) (((version)>>8)&0xFF)
-#define ENET_VERSION_GET_PATCH(version) ((version)&0xFF)
-#define ENET_VERSION ENET_VERSION_CREATE(ENET_VERSION_MAJOR, ENET_VERSION_MINOR, ENET_VERSION_PATCH)
-
-typedef enet_uint32 ENetVersion;
-
-struct _ENetHost;
-struct _ENetEvent;
-struct _ENetPacket;
-
-typedef enum _ENetSocketType
-{
-   ENET_SOCKET_TYPE_STREAM   = 1,
-   ENET_SOCKET_TYPE_DATAGRAM = 2
-} ENetSocketType;
-
-typedef enum _ENetSocketWait
-{
-   ENET_SOCKET_WAIT_NONE      = 0,
-   ENET_SOCKET_WAIT_SEND      = (1 << 0),
-   ENET_SOCKET_WAIT_RECEIVE   = (1 << 1),
-   ENET_SOCKET_WAIT_INTERRUPT = (1 << 2)
-} ENetSocketWait;
-
-typedef enum _ENetSocketOption
-{
-   ENET_SOCKOPT_NONBLOCK  = 1,
-   ENET_SOCKOPT_BROADCAST = 2,
-   ENET_SOCKOPT_RCVBUF    = 3,
-   ENET_SOCKOPT_SNDBUF    = 4,
-   ENET_SOCKOPT_REUSEADDR = 5,
-   ENET_SOCKOPT_RCVTIMEO  = 6,
-   ENET_SOCKOPT_SNDTIMEO  = 7,
-   ENET_SOCKOPT_ERROR     = 8,
-   ENET_SOCKOPT_NODELAY   = 9,
-   ENET_SOCKOPT_TTL       = 10
-} ENetSocketOption;
-
-typedef enum _ENetSocketShutdown
-{
-    ENET_SOCKET_SHUTDOWN_READ       = 0,
-    ENET_SOCKET_SHUTDOWN_WRITE      = 1,
-    ENET_SOCKET_SHUTDOWN_READ_WRITE = 2
-} ENetSocketShutdown;
-
-#define ENET_HOST_ANY       0
-#define ENET_HOST_BROADCAST 0xFFFFFFFFU
-#define ENET_PORT_ANY       0
-
-/**
- * Portable internet address structure. 
- *
- * The host must be specified in network byte-order, and the port must be in host 
- * byte-order. The constant ENET_HOST_ANY may be used to specify the default 
- * server host. The constant ENET_HOST_BROADCAST may be used to specify the
- * broadcast address (255.255.255.255).  This makes sense for enet_host_connect,
- * but not for enet_host_create.  Once a server responds to a broadcast, the
- * address is updated from ENET_HOST_BROADCAST to the server's actual IP address.
- */
-typedef struct _ENetAddress
-{
-   enet_uint32 host;
-   enet_uint16 port;
-} ENetAddress;
-
-/**
- * Packet flag bit constants.
- *
- * The host must be specified in network byte-order, and the port must be in
- * host byte-order. The constant ENET_HOST_ANY may be used to specify the
- * default server host.
- 
-   @sa ENetPacket
-*/
-typedef enum _ENetPacketFlag
-{
-   /** packet must be received by the target peer and resend attempts should be
-     * made until the packet is delivered */
-   ENET_PACKET_FLAG_RELIABLE    = (1 << 0),
-   /** packet will not be sequenced with other packets
-     */
-   ENET_PACKET_FLAG_UNSEQUENCED = (1 << 1),
-   /** packet will not allocate data, and user must supply it instead */
-   ENET_PACKET_FLAG_NO_ALLOCATE = (1 << 2),
-   /** packet will be fragmented using unreliable (instead of reliable) sends
-     * if it exceeds the MTU */
-   ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT = (1 << 3),
-
-   /** whether the packet has been sent from all queues it has been entered into */
-   ENET_PACKET_FLAG_SENT = (1<<8)
-} ENetPacketFlag;
-
-typedef void (ENET_CALLBACK * ENetPacketFreeCallback) (struct _ENetPacket *);
-
-/**
- * ENet packet structure.
- *
- * An ENet data packet that may be sent to or received from a peer. The shown 
- * fields should only be read and never modified. The data field contains the 
- * allocated data for the packet. The dataLength fields specifies the length 
- * of the allocated data.  The flags field is either 0 (specifying no flags), 
- * or a bitwise-or of any combination of the following flags:
- *
- *    ENET_PACKET_FLAG_RELIABLE - packet must be received by the target peer
- *    and resend attempts should be made until the packet is delivered
- *
- *    ENET_PACKET_FLAG_UNSEQUENCED - packet will not be sequenced with other packets 
- *    (not supported for reliable packets)
- *
- *    ENET_PACKET_FLAG_NO_ALLOCATE - packet will not allocate data, and user must supply it instead
- *
- *    ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT - packet will be fragmented using unreliable
- *    (instead of reliable) sends if it exceeds the MTU
- *
- *    ENET_PACKET_FLAG_SENT - whether the packet has been sent from all queues it has been entered into
-   @sa ENetPacketFlag
- */
-typedef struct _ENetPacket
-{
-   size_t                   referenceCount;  /**< internal use only */
-   enet_uint32              flags;           /**< bitwise-or of ENetPacketFlag constants */
-   enet_uint8 *             data;            /**< allocated data for packet */
-   size_t                   dataLength;      /**< length of data */
-   ENetPacketFreeCallback   freeCallback;    /**< function to be called when the packet is no longer in use */
-   void *                   userData;        /**< application private data, may be freely modified */
-} ENetPacket;
-
-typedef struct _ENetAcknowledgement
-{
-   ENetListNode acknowledgementList;
-   enet_uint32  sentTime;
-   ENetProtocol command;
-} ENetAcknowledgement;
-
-typedef struct _ENetOutgoingCommand
-{
-   ENetListNode outgoingCommandList;
-   enet_uint16  reliableSequenceNumber;
-   enet_uint16  unreliableSequenceNumber;
-   enet_uint32  sentTime;
-   enet_uint32  roundTripTimeout;
-   enet_uint32  queueTime;
-   enet_uint32  fragmentOffset;
-   enet_uint16  fragmentLength;
-   enet_uint16  sendAttempts;
-   ENetProtocol command;
-   ENetPacket * packet;
-} ENetOutgoingCommand;
-
-typedef struct _ENetIncomingCommand
-{  
-   ENetListNode     incomingCommandList;
-   enet_uint16      reliableSequenceNumber;
-   enet_uint16      unreliableSequenceNumber;
-   ENetProtocol     command;
-   enet_uint32      fragmentCount;
-   enet_uint32      fragmentsRemaining;
-   enet_uint32 *    fragments;
-   ENetPacket *     packet;
-} ENetIncomingCommand;
-
-typedef enum _ENetPeerState
-{
-   ENET_PEER_STATE_DISCONNECTED                = 0,
-   ENET_PEER_STATE_CONNECTING                  = 1,
-   ENET_PEER_STATE_ACKNOWLEDGING_CONNECT       = 2,
-   ENET_PEER_STATE_CONNECTION_PENDING          = 3,
-   ENET_PEER_STATE_CONNECTION_SUCCEEDED        = 4,
-   ENET_PEER_STATE_CONNECTED                   = 5,
-   ENET_PEER_STATE_DISCONNECT_LATER            = 6,
-   ENET_PEER_STATE_DISCONNECTING               = 7,
-   ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT    = 8,
-   ENET_PEER_STATE_ZOMBIE                      = 9 
-} ENetPeerState;
-
-#ifndef ENET_BUFFER_MAXIMUM
-#define ENET_BUFFER_MAXIMUM (1 + 2 * ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS)
-#endif
-
-enum
-{
-   ENET_HOST_RECEIVE_BUFFER_SIZE          = 256 * 1024,
-   ENET_HOST_SEND_BUFFER_SIZE             = 256 * 1024,
-   ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL  = 1000,
-   ENET_HOST_DEFAULT_MTU                  = 1392,
-   ENET_HOST_DEFAULT_MAXIMUM_PACKET_SIZE  = 32 * 1024 * 1024,
-   ENET_HOST_DEFAULT_MAXIMUM_WAITING_DATA = 32 * 1024 * 1024,
-
-   ENET_PEER_DEFAULT_ROUND_TRIP_TIME      = 500,
-   ENET_PEER_DEFAULT_PACKET_THROTTLE      = 32,
-   ENET_PEER_PACKET_THROTTLE_SCALE        = 32,
-   ENET_PEER_PACKET_THROTTLE_COUNTER      = 7, 
-   ENET_PEER_PACKET_THROTTLE_ACCELERATION = 2,
-   ENET_PEER_PACKET_THROTTLE_DECELERATION = 2,
-   ENET_PEER_PACKET_THROTTLE_INTERVAL     = 5000,
-   ENET_PEER_PACKET_LOSS_SCALE            = (1 << 16),
-   ENET_PEER_PACKET_LOSS_INTERVAL         = 10000,
-   ENET_PEER_WINDOW_SIZE_SCALE            = 64 * 1024,
-   ENET_PEER_TIMEOUT_LIMIT                = 32,
-   ENET_PEER_TIMEOUT_MINIMUM              = 5000,
-   ENET_PEER_TIMEOUT_MAXIMUM              = 30000,
-   ENET_PEER_PING_INTERVAL                = 500,
-   ENET_PEER_UNSEQUENCED_WINDOWS          = 64,
-   ENET_PEER_UNSEQUENCED_WINDOW_SIZE      = 1024,
-   ENET_PEER_FREE_UNSEQUENCED_WINDOWS     = 32,
-   ENET_PEER_RELIABLE_WINDOWS             = 16,
-   ENET_PEER_RELIABLE_WINDOW_SIZE         = 0x1000,
-   ENET_PEER_FREE_RELIABLE_WINDOWS        = 8
-};
-
-typedef struct _ENetChannel
-{
-   enet_uint16  outgoingReliableSequenceNumber;
-   enet_uint16  outgoingUnreliableSequenceNumber;
-   enet_uint16  usedReliableWindows;
-   enet_uint16  reliableWindows [ENET_PEER_RELIABLE_WINDOWS];
-   enet_uint16  incomingReliableSequenceNumber;
-   enet_uint16  incomingUnreliableSequenceNumber;
-   ENetList     incomingReliableCommands;
-   ENetList     incomingUnreliableCommands;
-} ENetChannel;
-
-typedef enum _ENetPeerFlag
-{
-   ENET_PEER_FLAG_NEEDS_DISPATCH   = (1 << 0),
-   ENET_PEER_FLAG_CONTINUE_SENDING = (1 << 1)
-} ENetPeerFlag;
-
-/**
- * An ENet peer which data packets may be sent or received from. 
- *
- * No fields should be modified unless otherwise specified. 
- */
-typedef struct _ENetPeer
-{ 
-   ENetListNode  dispatchList;
-   struct _ENetHost * host;
-   enet_uint16   outgoingPeerID;
-   enet_uint16   incomingPeerID;
-   enet_uint32   connectID;
-   enet_uint8    outgoingSessionID;
-   enet_uint8    incomingSessionID;
-   ENetAddress   address;            /**< Internet address of the peer */
-   void *        data;               /**< Application private data, may be freely modified */
-   ENetPeerState state;
-   ENetChannel * channels;
-   size_t        channelCount;       /**< Number of channels allocated for communication with peer */
-   enet_uint32   incomingBandwidth;  /**< Downstream bandwidth of the client in bytes/second */
-   enet_uint32   outgoingBandwidth;  /**< Upstream bandwidth of the client in bytes/second */
-   enet_uint32   incomingBandwidthThrottleEpoch;
-   enet_uint32   outgoingBandwidthThrottleEpoch;
-   enet_uint32   incomingDataTotal;
-   enet_uint32   outgoingDataTotal;
-   enet_uint32   lastSendTime;
-   enet_uint32   lastReceiveTime;
-   enet_uint32   nextTimeout;
-   enet_uint32   earliestTimeout;
-   enet_uint32   packetLossEpoch;
-   enet_uint32   packetsSent;
-   enet_uint32   packetsLost;
-   enet_uint32   packetLoss;          /**< mean packet loss of reliable packets as a ratio with respect to the constant ENET_PEER_PACKET_LOSS_SCALE */
-   enet_uint32   packetLossVariance;
-   enet_uint32   packetThrottle;
-   enet_uint32   packetThrottleLimit;
-   enet_uint32   packetThrottleCounter;
-   enet_uint32   packetThrottleEpoch;
-   enet_uint32   packetThrottleAcceleration;
-   enet_uint32   packetThrottleDeceleration;
-   enet_uint32   packetThrottleInterval;
-   enet_uint32   pingInterval;
-   enet_uint32   timeoutLimit;
-   enet_uint32   timeoutMinimum;
-   enet_uint32   timeoutMaximum;
-   enet_uint32   lastRoundTripTime;
-   enet_uint32   lowestRoundTripTime;
-   enet_uint32   lastRoundTripTimeVariance;
-   enet_uint32   highestRoundTripTimeVariance;
-   enet_uint32   roundTripTime;            /**< mean round trip time (RTT), in milliseconds, between sending a reliable packet and receiving its acknowledgement */
-   enet_uint32   roundTripTimeVariance;
-   enet_uint32   mtu;
-   enet_uint32   windowSize;
-   enet_uint32   reliableDataInTransit;
-   enet_uint16   outgoingReliableSequenceNumber;
-   ENetList      acknowledgements;
-   ENetList      sentReliableCommands;
-   ENetList      outgoingSendReliableCommands;
-   ENetList      outgoingCommands;
-   ENetList      dispatchedCommands;
-   enet_uint16   flags;
-   enet_uint16   reserved;
-   enet_uint16   incomingUnsequencedGroup;
-   enet_uint16   outgoingUnsequencedGroup;
-   enet_uint32   unsequencedWindow [ENET_PEER_UNSEQUENCED_WINDOW_SIZE / 32]; 
-   enet_uint32   eventData;
-   size_t        totalWaitingData;
-} ENetPeer;
-
-/** An ENet packet compressor for compressing UDP packets before socket sends or receives.
- */
-typedef struct _ENetCompressor
-{
-   /** Context data for the compressor. Must be non-NULL. */
-   void * context;
-   /** Compresses from inBuffers[0:inBufferCount-1], containing inLimit bytes, to outData, outputting at most outLimit bytes. Should return 0 on failure. */
-   size_t (ENET_CALLBACK * compress) (void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit);
-   /** Decompresses from inData, containing inLimit bytes, to outData, outputting at most outLimit bytes. Should return 0 on failure. */
-   size_t (ENET_CALLBACK * decompress) (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit);
-   /** Destroys the context when compression is disabled or the host is destroyed. May be NULL. */
-   void (ENET_CALLBACK * destroy) (void * context);
-} ENetCompressor;
-
-/** Callback that computes the checksum of the data held in buffers[0:bufferCount-1] */
-typedef enet_uint32 (ENET_CALLBACK * ENetChecksumCallback) (const ENetBuffer * buffers, size_t bufferCount);
-
-/** Callback for intercepting received raw UDP packets. Should return 1 to intercept, 0 to ignore, or -1 to propagate an error. */
-typedef int (ENET_CALLBACK * ENetInterceptCallback) (struct _ENetHost * host, struct _ENetEvent * event);
- 
-/** An ENet host for communicating with peers.
-  *
-  * No fields should be modified unless otherwise stated.
-
-    @sa enet_host_create()
-    @sa enet_host_destroy()
-    @sa enet_host_connect()
-    @sa enet_host_service()
-    @sa enet_host_flush()
-    @sa enet_host_broadcast()
-    @sa enet_host_compress()
-    @sa enet_host_compress_with_range_coder()
-    @sa enet_host_channel_limit()
-    @sa enet_host_bandwidth_limit()
-    @sa enet_host_bandwidth_throttle()
-  */
-typedef struct _ENetHost
-{
-   ENetSocket           socket;
-   ENetAddress          address;                     /**< Internet address of the host */
-   enet_uint32          incomingBandwidth;           /**< downstream bandwidth of the host */
-   enet_uint32          outgoingBandwidth;           /**< upstream bandwidth of the host */
-   enet_uint32          bandwidthThrottleEpoch;
-   enet_uint32          mtu;
-   enet_uint32          randomSeed;
-   int                  recalculateBandwidthLimits;
-   ENetPeer *           peers;                       /**< array of peers allocated for this host */
-   size_t               peerCount;                   /**< number of peers allocated for this host */
-   size_t               channelLimit;                /**< maximum number of channels allowed for connected peers */
-   enet_uint32          serviceTime;
-   ENetList             dispatchQueue;
-   enet_uint32          totalQueued;
-   size_t               packetSize;
-   enet_uint16          headerFlags;
-   ENetProtocol         commands [ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS];
-   size_t               commandCount;
-   ENetBuffer           buffers [ENET_BUFFER_MAXIMUM];
-   size_t               bufferCount;
-   ENetChecksumCallback checksum;                    /**< callback the user can set to enable packet checksums for this host */
-   ENetCompressor       compressor;
-   enet_uint8           packetData [2][ENET_PROTOCOL_MAXIMUM_MTU];
-   ENetAddress          receivedAddress;
-   enet_uint8 *         receivedData;
-   size_t               receivedDataLength;
-   enet_uint32          totalSentData;               /**< total data sent, user should reset to 0 as needed to prevent overflow */
-   enet_uint32          totalSentPackets;            /**< total UDP packets sent, user should reset to 0 as needed to prevent overflow */
-   enet_uint32          totalReceivedData;           /**< total data received, user should reset to 0 as needed to prevent overflow */
-   enet_uint32          totalReceivedPackets;        /**< total UDP packets received, user should reset to 0 as needed to prevent overflow */
-   ENetInterceptCallback intercept;                  /**< callback the user can set to intercept received raw UDP packets */
-   size_t               connectedPeers;
-   size_t               bandwidthLimitedPeers;
-   size_t               duplicatePeers;              /**< optional number of allowed peers from duplicate IPs, defaults to ENET_PROTOCOL_MAXIMUM_PEER_ID */
-   size_t               maximumPacketSize;           /**< the maximum allowable packet size that may be sent or received on a peer */
-   size_t               maximumWaitingData;          /**< the maximum aggregate amount of buffer space a peer may use waiting for packets to be delivered */
-} ENetHost;
-
-/**
- * An ENet event type, as specified in @ref ENetEvent.
- */
-typedef enum _ENetEventType
-{
-   /** no event occurred within the specified time limit */
-   ENET_EVENT_TYPE_NONE       = 0,  
-
-   /** a connection request initiated by enet_host_connect has completed.  
-     * The peer field contains the peer which successfully connected. 
-     */
-   ENET_EVENT_TYPE_CONNECT    = 1,  
-
-   /** a peer has disconnected.  This event is generated on a successful 
-     * completion of a disconnect initiated by enet_peer_disconnect, if 
-     * a peer has timed out, or if a connection request intialized by 
-     * enet_host_connect has timed out.  The peer field contains the peer 
-     * which disconnected. The data field contains user supplied data 
-     * describing the disconnection, or 0, if none is available.
-     */
-   ENET_EVENT_TYPE_DISCONNECT = 2,  
-
-   /** a packet has been received from a peer.  The peer field specifies the
-     * peer which sent the packet.  The channelID field specifies the channel
-     * number upon which the packet was received.  The packet field contains
-     * the packet that was received; this packet must be destroyed with
-     * enet_packet_destroy after use.
-     */
-   ENET_EVENT_TYPE_RECEIVE    = 3
-} ENetEventType;
-
-/**
- * An ENet event as returned by enet_host_service().
-   
-   @sa enet_host_service
- */
-typedef struct _ENetEvent 
-{
-   ENetEventType        type;      /**< type of the event */
-   ENetPeer *           peer;      /**< peer that generated a connect, disconnect or receive event */
-   enet_uint8           channelID; /**< channel on the peer that generated the event, if appropriate */
-   enet_uint32          data;      /**< data associated with the event, if appropriate */
-   ENetPacket *         packet;    /**< packet associated with the event, if appropriate */
-} ENetEvent;
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-/** @defgroup global ENet global functions
-    @{ 
-*/
-
-/** 
-  Initializes ENet globally.  Must be called prior to using any functions in
-  ENet.
-  @returns 0 on success, < 0 on failure
-*/
-ENET_API int enet_initialize (void);
-
-/** 
-  Initializes ENet globally and supplies user-overridden callbacks. Must be called prior to using any functions in ENet. Do not use enet_initialize() if you use this variant. Make sure the ENetCallbacks structure is zeroed out so that any additional callbacks added in future versions will be properly ignored.
-
-  @param version the constant ENET_VERSION should be supplied so ENet knows which version of ENetCallbacks struct to use
-  @param inits user-overridden callbacks where any NULL callbacks will use ENet's defaults
-  @returns 0 on success, < 0 on failure
-*/
-ENET_API int enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits);
-
-/** 
-  Shuts down ENet globally.  Should be called when a program that has
-  initialized ENet exits.
-*/
-ENET_API void enet_deinitialize (void);
-
-/**
-  Gives the linked version of the ENet library.
-  @returns the version number 
-*/
-ENET_API ENetVersion enet_linked_version (void);
-
-/** @} */
-
-/** @defgroup private ENet private implementation functions */
-
-/**
-  Returns the wall-time in milliseconds.  Its initial value is unspecified
-  unless otherwise set.
-  */
-ENET_API enet_uint32 enet_time_get (void);
-/**
-  Sets the current wall-time in milliseconds.
-  */
-ENET_API void enet_time_set (enet_uint32);
-
-/** @defgroup socket ENet socket functions
-    @{
-*/
-ENET_API ENetSocket enet_socket_create (ENetSocketType);
-ENET_API int        enet_socket_bind (ENetSocket, const ENetAddress *);
-ENET_API int        enet_socket_get_address (ENetSocket, ENetAddress *);
-ENET_API int        enet_socket_listen (ENetSocket, int);
-ENET_API ENetSocket enet_socket_accept (ENetSocket, ENetAddress *);
-ENET_API int        enet_socket_connect (ENetSocket, const ENetAddress *);
-ENET_API int        enet_socket_send (ENetSocket, const ENetAddress *, const ENetBuffer *, size_t);
-ENET_API int        enet_socket_receive (ENetSocket, ENetAddress *, ENetBuffer *, size_t);
-ENET_API int        enet_socket_wait (ENetSocket, enet_uint32 *, enet_uint32);
-ENET_API int        enet_socket_set_option (ENetSocket, ENetSocketOption, int);
-ENET_API int        enet_socket_get_option (ENetSocket, ENetSocketOption, int *);
-ENET_API int        enet_socket_shutdown (ENetSocket, ENetSocketShutdown);
-ENET_API void       enet_socket_destroy (ENetSocket);
-ENET_API int        enet_socketset_select (ENetSocket, ENetSocketSet *, ENetSocketSet *, enet_uint32);
-
-/** @} */
-
-/** @defgroup Address ENet address functions
-    @{
-*/
-
-/** Attempts to parse the printable form of the IP address in the parameter hostName
-    and sets the host field in the address parameter if successful.
-    @param address destination to store the parsed IP address
-    @param hostName IP address to parse
-    @retval 0 on success
-    @retval < 0 on failure
-    @returns the address of the given hostName in address on success
-*/
-ENET_API int enet_address_set_host_ip (ENetAddress * address, const char * hostName);
-
-/** Attempts to resolve the host named by the parameter hostName and sets
-    the host field in the address parameter if successful.
-    @param address destination to store resolved address
-    @param hostName host name to lookup
-    @retval 0 on success
-    @retval < 0 on failure
-    @returns the address of the given hostName in address on success
-*/
-ENET_API int enet_address_set_host (ENetAddress * address, const char * hostName);
-
-/** Gives the printable form of the IP address specified in the address parameter.
-    @param address    address printed
-    @param hostName   destination for name, must not be NULL
-    @param nameLength maximum length of hostName.
-    @returns the null-terminated name of the host in hostName on success
-    @retval 0 on success
-    @retval < 0 on failure
-*/
-ENET_API int enet_address_get_host_ip (const ENetAddress * address, char * hostName, size_t nameLength);
-
-/** Attempts to do a reverse lookup of the host field in the address parameter.
-    @param address    address used for reverse lookup
-    @param hostName   destination for name, must not be NULL
-    @param nameLength maximum length of hostName.
-    @returns the null-terminated name of the host in hostName on success
-    @retval 0 on success
-    @retval < 0 on failure
-*/
-ENET_API int enet_address_get_host (const ENetAddress * address, char * hostName, size_t nameLength);
-
-/** @} */
-
-ENET_API ENetPacket * enet_packet_create (const void *, size_t, enet_uint32);
-ENET_API void         enet_packet_destroy (ENetPacket *);
-ENET_API int          enet_packet_resize  (ENetPacket *, size_t);
-ENET_API enet_uint32  enet_crc32 (const ENetBuffer *, size_t);
-                
-ENET_API ENetHost * enet_host_create (const ENetAddress *, size_t, size_t, enet_uint32, enet_uint32);
-ENET_API void       enet_host_destroy (ENetHost *);
-ENET_API ENetPeer * enet_host_connect (ENetHost *, const ENetAddress *, size_t, enet_uint32);
-ENET_API int        enet_host_check_events (ENetHost *, ENetEvent *);
-ENET_API int        enet_host_service (ENetHost *, ENetEvent *, enet_uint32);
-ENET_API void       enet_host_flush (ENetHost *);
-ENET_API void       enet_host_broadcast (ENetHost *, enet_uint8, ENetPacket *);
-ENET_API void       enet_host_compress (ENetHost *, const ENetCompressor *);
-ENET_API int        enet_host_compress_with_range_coder (ENetHost * host);
-ENET_API void       enet_host_channel_limit (ENetHost *, size_t);
-ENET_API void       enet_host_bandwidth_limit (ENetHost *, enet_uint32, enet_uint32);
-extern   void       enet_host_bandwidth_throttle (ENetHost *);
-extern  enet_uint32 enet_host_random_seed (void);
-extern  enet_uint32 enet_host_random (ENetHost *);
-
-ENET_API int                 enet_peer_send (ENetPeer *, enet_uint8, ENetPacket *);
-ENET_API ENetPacket *        enet_peer_receive (ENetPeer *, enet_uint8 * channelID);
-ENET_API void                enet_peer_ping (ENetPeer *);
-ENET_API void                enet_peer_ping_interval (ENetPeer *, enet_uint32);
-ENET_API void                enet_peer_timeout (ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
-ENET_API void                enet_peer_reset (ENetPeer *);
-ENET_API void                enet_peer_disconnect (ENetPeer *, enet_uint32);
-ENET_API void                enet_peer_disconnect_now (ENetPeer *, enet_uint32);
-ENET_API void                enet_peer_disconnect_later (ENetPeer *, enet_uint32);
-ENET_API void                enet_peer_throttle_configure (ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
-extern int                   enet_peer_throttle (ENetPeer *, enet_uint32);
-extern void                  enet_peer_reset_queues (ENetPeer *);
-extern int                   enet_peer_has_outgoing_commands (ENetPeer *);
-extern void                  enet_peer_setup_outgoing_command (ENetPeer *, ENetOutgoingCommand *);
-extern ENetOutgoingCommand * enet_peer_queue_outgoing_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32, enet_uint16);
-extern ENetIncomingCommand * enet_peer_queue_incoming_command (ENetPeer *, const ENetProtocol *, const void *, size_t, enet_uint32, enet_uint32);
-extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint16);
-extern void                  enet_peer_dispatch_incoming_unreliable_commands (ENetPeer *, ENetChannel *, ENetIncomingCommand *);
-extern void                  enet_peer_dispatch_incoming_reliable_commands (ENetPeer *, ENetChannel *, ENetIncomingCommand *);
-extern void                  enet_peer_on_connect (ENetPeer *);
-extern void                  enet_peer_on_disconnect (ENetPeer *);
-
-ENET_API void * enet_range_coder_create (void);
-ENET_API void   enet_range_coder_destroy (void *);
-ENET_API size_t enet_range_coder_compress (void *, const ENetBuffer *, size_t, size_t, enet_uint8 *, size_t);
-ENET_API size_t enet_range_coder_decompress (void *, const enet_uint8 *, size_t, enet_uint8 *, size_t);
-   
-extern size_t enet_protocol_command_size (enet_uint8);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __ENET_ENET_H__ */
-

externals/enet/include/enet/list.h

@@ -1,52 +0,0 @@
-/** 
- @file  list.h
- @brief ENet list management 
-*/
-#ifndef __ENET_LIST_H__
-#define __ENET_LIST_H__
-
-#include <stdlib.h>
-
-typedef struct _ENetListNode
-{
-   struct _ENetListNode * next;
-   struct _ENetListNode * previous;
-} ENetListNode;
-
-typedef ENetListNode * ENetListIterator;
-
-typedef struct _ENetList
-{
-   ENetListNode sentinel;
-} ENetList;
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-extern void enet_list_clear (ENetList *);
-
-extern ENetListIterator enet_list_insert (ENetListIterator, void *);
-extern void * enet_list_remove (ENetListIterator);
-extern ENetListIterator enet_list_move (ENetListIterator, void *, void *);
-
-extern size_t enet_list_size (ENetList *);
-
-#ifdef __cplusplus
-}
-#endif
-
-#define enet_list_begin(list) ((list) -> sentinel.next)
-#define enet_list_end(list) (& (list) -> sentinel)
-
-#define enet_list_empty(list) (enet_list_begin (list) == enet_list_end (list))
-
-#define enet_list_next(iterator) ((iterator) -> next)
-#define enet_list_previous(iterator) ((iterator) -> previous)
-
-#define enet_list_front(list) ((void *) (list) -> sentinel.next)
-#define enet_list_back(list) ((void *) (list) -> sentinel.previous)
-
-#endif /* __ENET_LIST_H__ */
-

externals/enet/include/enet/protocol.h

@@ -1,198 +0,0 @@
-/** 
- @file  protocol.h
- @brief ENet protocol
-*/
-#ifndef __ENET_PROTOCOL_H__
-#define __ENET_PROTOCOL_H__
-
-#include "enet/types.h"
-
-enum
-{
-   ENET_PROTOCOL_MINIMUM_MTU             = 576,
-   ENET_PROTOCOL_MAXIMUM_MTU             = 4096,
-   ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS = 32,
-   ENET_PROTOCOL_MINIMUM_WINDOW_SIZE     = 4096,
-   ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE     = 65536,
-   ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT   = 1,
-   ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT   = 255,
-   ENET_PROTOCOL_MAXIMUM_PEER_ID         = 0xFFF,
-   ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT  = 1024 * 1024
-};
-
-typedef enum _ENetProtocolCommand
-{
-   ENET_PROTOCOL_COMMAND_NONE               = 0,
-   ENET_PROTOCOL_COMMAND_ACKNOWLEDGE        = 1,
-   ENET_PROTOCOL_COMMAND_CONNECT            = 2,
-   ENET_PROTOCOL_COMMAND_VERIFY_CONNECT     = 3,
-   ENET_PROTOCOL_COMMAND_DISCONNECT         = 4,
-   ENET_PROTOCOL_COMMAND_PING               = 5,
-   ENET_PROTOCOL_COMMAND_SEND_RELIABLE      = 6,
-   ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE    = 7,
-   ENET_PROTOCOL_COMMAND_SEND_FRAGMENT      = 8,
-   ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED   = 9,
-   ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT    = 10,
-   ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE = 11,
-   ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT = 12,
-   ENET_PROTOCOL_COMMAND_COUNT              = 13,
-
-   ENET_PROTOCOL_COMMAND_MASK               = 0x0F
-} ENetProtocolCommand;
-
-typedef enum _ENetProtocolFlag
-{
-   ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE = (1 << 7),
-   ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED = (1 << 6),
-
-   ENET_PROTOCOL_HEADER_FLAG_COMPRESSED = (1 << 14),
-   ENET_PROTOCOL_HEADER_FLAG_SENT_TIME  = (1 << 15),
-   ENET_PROTOCOL_HEADER_FLAG_MASK       = ENET_PROTOCOL_HEADER_FLAG_COMPRESSED | ENET_PROTOCOL_HEADER_FLAG_SENT_TIME,
-
-   ENET_PROTOCOL_HEADER_SESSION_MASK    = (3 << 12),
-   ENET_PROTOCOL_HEADER_SESSION_SHIFT   = 12
-} ENetProtocolFlag;
-
-#ifdef _MSC_VER
-#pragma pack(push, 1)
-#define ENET_PACKED
-#elif defined(__GNUC__) || defined(__clang__)
-#define ENET_PACKED __attribute__ ((packed))
-#else
-#define ENET_PACKED
-#endif
-
-typedef struct _ENetProtocolHeader
-{
-   enet_uint16 peerID;
-   enet_uint16 sentTime;
-} ENET_PACKED ENetProtocolHeader;
-
-typedef struct _ENetProtocolCommandHeader
-{
-   enet_uint8 command;
-   enet_uint8 channelID;
-   enet_uint16 reliableSequenceNumber;
-} ENET_PACKED ENetProtocolCommandHeader;
-
-typedef struct _ENetProtocolAcknowledge
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 receivedReliableSequenceNumber;
-   enet_uint16 receivedSentTime;
-} ENET_PACKED ENetProtocolAcknowledge;
-
-typedef struct _ENetProtocolConnect
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 outgoingPeerID;
-   enet_uint8  incomingSessionID;
-   enet_uint8  outgoingSessionID;
-   enet_uint32 mtu;
-   enet_uint32 windowSize;
-   enet_uint32 channelCount;
-   enet_uint32 incomingBandwidth;
-   enet_uint32 outgoingBandwidth;
-   enet_uint32 packetThrottleInterval;
-   enet_uint32 packetThrottleAcceleration;
-   enet_uint32 packetThrottleDeceleration;
-   enet_uint32 connectID;
-   enet_uint32 data;
-} ENET_PACKED ENetProtocolConnect;
-
-typedef struct _ENetProtocolVerifyConnect
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 outgoingPeerID;
-   enet_uint8  incomingSessionID;
-   enet_uint8  outgoingSessionID;
-   enet_uint32 mtu;
-   enet_uint32 windowSize;
-   enet_uint32 channelCount;
-   enet_uint32 incomingBandwidth;
-   enet_uint32 outgoingBandwidth;
-   enet_uint32 packetThrottleInterval;
-   enet_uint32 packetThrottleAcceleration;
-   enet_uint32 packetThrottleDeceleration;
-   enet_uint32 connectID;
-} ENET_PACKED ENetProtocolVerifyConnect;
-
-typedef struct _ENetProtocolBandwidthLimit
-{
-   ENetProtocolCommandHeader header;
-   enet_uint32 incomingBandwidth;
-   enet_uint32 outgoingBandwidth;
-} ENET_PACKED ENetProtocolBandwidthLimit;
-
-typedef struct _ENetProtocolThrottleConfigure
-{
-   ENetProtocolCommandHeader header;
-   enet_uint32 packetThrottleInterval;
-   enet_uint32 packetThrottleAcceleration;
-   enet_uint32 packetThrottleDeceleration;
-} ENET_PACKED ENetProtocolThrottleConfigure;
-
-typedef struct _ENetProtocolDisconnect
-{
-   ENetProtocolCommandHeader header;
-   enet_uint32 data;
-} ENET_PACKED ENetProtocolDisconnect;
-
-typedef struct _ENetProtocolPing
-{
-   ENetProtocolCommandHeader header;
-} ENET_PACKED ENetProtocolPing;
-
-typedef struct _ENetProtocolSendReliable
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 dataLength;
-} ENET_PACKED ENetProtocolSendReliable;
-
-typedef struct _ENetProtocolSendUnreliable
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 unreliableSequenceNumber;
-   enet_uint16 dataLength;
-} ENET_PACKED ENetProtocolSendUnreliable;
-
-typedef struct _ENetProtocolSendUnsequenced
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 unsequencedGroup;
-   enet_uint16 dataLength;
-} ENET_PACKED ENetProtocolSendUnsequenced;
-
-typedef struct _ENetProtocolSendFragment
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 startSequenceNumber;
-   enet_uint16 dataLength;
-   enet_uint32 fragmentCount;
-   enet_uint32 fragmentNumber;
-   enet_uint32 totalLength;
-   enet_uint32 fragmentOffset;
-} ENET_PACKED ENetProtocolSendFragment;
-
-typedef union _ENetProtocol
-{
-   ENetProtocolCommandHeader header;
-   ENetProtocolAcknowledge acknowledge;
-   ENetProtocolConnect connect;
-   ENetProtocolVerifyConnect verifyConnect;
-   ENetProtocolDisconnect disconnect;
-   ENetProtocolPing ping;
-   ENetProtocolSendReliable sendReliable;
-   ENetProtocolSendUnreliable sendUnreliable;
-   ENetProtocolSendUnsequenced sendUnsequenced;
-   ENetProtocolSendFragment sendFragment;
-   ENetProtocolBandwidthLimit bandwidthLimit;
-   ENetProtocolThrottleConfigure throttleConfigure;
-} ENET_PACKED ENetProtocol;
-
-#ifdef _MSC_VER
-#pragma pack(pop)
-#endif
-
-#endif /* __ENET_PROTOCOL_H__ */
-

externals/enet/include/enet/time.h

@@ -1,18 +0,0 @@
-/** 
- @file  time.h
- @brief ENet time constants and macros
-*/
-#ifndef __ENET_TIME_H__
-#define __ENET_TIME_H__
-
-#define ENET_TIME_OVERFLOW 86400000
-
-#define ENET_TIME_LESS(a, b) ((a) - (b) >= ENET_TIME_OVERFLOW)
-#define ENET_TIME_GREATER(a, b) ((b) - (a) >= ENET_TIME_OVERFLOW)
-#define ENET_TIME_LESS_EQUAL(a, b) (! ENET_TIME_GREATER (a, b))
-#define ENET_TIME_GREATER_EQUAL(a, b) (! ENET_TIME_LESS (a, b))
-
-#define ENET_TIME_DIFFERENCE(a, b) ((a) - (b) >= ENET_TIME_OVERFLOW ? (b) - (a) : (a) - (b))
-
-#endif /* __ENET_TIME_H__ */
-

externals/enet/include/enet/types.h

@@ -1,13 +0,0 @@
-/** 
- @file  types.h
- @brief type definitions for ENet
-*/
-#ifndef __ENET_TYPES_H__
-#define __ENET_TYPES_H__
-
-typedef unsigned char enet_uint8;       /**< unsigned 8-bit type  */
-typedef unsigned short enet_uint16;     /**< unsigned 16-bit type */
-typedef unsigned int enet_uint32;      /**< unsigned 32-bit type */
-
-#endif /* __ENET_TYPES_H__ */
-

externals/enet/include/enet/unix.h

@@ -1,48 +0,0 @@
-/** 
- @file  unix.h
- @brief ENet Unix header
-*/
-#ifndef __ENET_UNIX_H__
-#define __ENET_UNIX_H__
-
-#include <stdlib.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <arpa/inet.h>
-#include <netinet/in.h>
-#include <unistd.h>
-
-#ifdef MSG_MAXIOVLEN
-#define ENET_BUFFER_MAXIMUM MSG_MAXIOVLEN
-#endif
-
-typedef int ENetSocket;
-
-#define ENET_SOCKET_NULL -1
-
-#define ENET_HOST_TO_NET_16(value) (htons (value)) /**< macro that converts host to net byte-order of a 16-bit value */
-#define ENET_HOST_TO_NET_32(value) (htonl (value)) /**< macro that converts host to net byte-order of a 32-bit value */
-
-#define ENET_NET_TO_HOST_16(value) (ntohs (value)) /**< macro that converts net to host byte-order of a 16-bit value */
-#define ENET_NET_TO_HOST_32(value) (ntohl (value)) /**< macro that converts net to host byte-order of a 32-bit value */
-
-typedef struct
-{
-    void * data;
-    size_t dataLength;
-} ENetBuffer;
-
-#define ENET_CALLBACK
-
-#define ENET_API extern
-
-typedef fd_set ENetSocketSet;
-
-#define ENET_SOCKETSET_EMPTY(sockset)          FD_ZERO (& (sockset))
-#define ENET_SOCKETSET_ADD(sockset, socket)    FD_SET (socket, & (sockset))
-#define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLR (socket, & (sockset))
-#define ENET_SOCKETSET_CHECK(sockset, socket)  FD_ISSET (socket, & (sockset))
-    
-#endif /* __ENET_UNIX_H__ */
-

externals/enet/include/enet/utility.h

@@ -1,13 +0,0 @@
-/** 
- @file  utility.h
- @brief ENet utility header
-*/
-#ifndef __ENET_UTILITY_H__
-#define __ENET_UTILITY_H__
-
-#define ENET_MAX(x, y) ((x) > (y) ? (x) : (y))
-#define ENET_MIN(x, y) ((x) < (y) ? (x) : (y))
-#define ENET_DIFFERENCE(x, y) ((x) < (y) ? (y) - (x) : (x) - (y))
-
-#endif /* __ENET_UTILITY_H__ */
-

externals/enet/include/enet/win32.h

@@ -1,63 +0,0 @@
-/** 
- @file  win32.h
- @brief ENet Win32 header
-*/
-#ifndef __ENET_WIN32_H__
-#define __ENET_WIN32_H__
-
-#ifdef _MSC_VER
-#ifdef ENET_BUILDING_LIB
-#pragma warning (disable: 4267) // size_t to int conversion
-#pragma warning (disable: 4244) // 64bit to 32bit int
-#pragma warning (disable: 4018) // signed/unsigned mismatch
-#pragma warning (disable: 4146) // unary minus operator applied to unsigned type
-#ifndef _CRT_SECURE_NO_DEPRECATE
-#define _CRT_SECURE_NO_DEPRECATE
-#endif
-#ifndef _CRT_SECURE_NO_WARNINGS
-#define _CRT_SECURE_NO_WARNINGS
-#endif
-#endif
-#endif
-
-#include <stdlib.h>
-#include <winsock2.h>
-
-typedef SOCKET ENetSocket;
-
-#define ENET_SOCKET_NULL INVALID_SOCKET
-
-#define ENET_HOST_TO_NET_16(value) (htons (value))
-#define ENET_HOST_TO_NET_32(value) (htonl (value))
-
-#define ENET_NET_TO_HOST_16(value) (ntohs (value))
-#define ENET_NET_TO_HOST_32(value) (ntohl (value))
-
-typedef struct
-{
-    size_t dataLength;
-    void * data;
-} ENetBuffer;
-
-#define ENET_CALLBACK __cdecl
-
-#ifdef ENET_DLL
-#ifdef ENET_BUILDING_LIB
-#define ENET_API __declspec( dllexport )
-#else
-#define ENET_API __declspec( dllimport )
-#endif /* ENET_BUILDING_LIB */
-#else /* !ENET_DLL */
-#define ENET_API extern
-#endif /* ENET_DLL */
-
-typedef fd_set ENetSocketSet;
-
-#define ENET_SOCKETSET_EMPTY(sockset)          FD_ZERO (& (sockset))
-#define ENET_SOCKETSET_ADD(sockset, socket)    FD_SET (socket, & (sockset))
-#define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLR (socket, & (sockset))
-#define ENET_SOCKETSET_CHECK(sockset, socket)  FD_ISSET (socket, & (sockset))
-
-#endif /* __ENET_WIN32_H__ */
-
-

externals/enet/libenet.pc.in

@@ -1,10 +0,0 @@
-prefix=@prefix@
-exec_prefix=@exec_prefix@
-libdir=@libdir@
-includedir=@includedir@
-
-Name: @PACKAGE_NAME@
-Description: Low-latency UDP networking library supporting optional reliability
-Version: @PACKAGE_VERSION@
-Cflags: -I${includedir}
-Libs: -L${libdir} -lenet

externals/enet/list.c

@@ -1,75 +0,0 @@
-/** 
- @file list.c
- @brief ENet linked list functions
-*/
-#define ENET_BUILDING_LIB 1
-#include "enet/enet.h"
-
-/** 
-    @defgroup list ENet linked list utility functions
-    @ingroup private
-    @{
-*/
-void
-enet_list_clear (ENetList * list)
-{
-   list -> sentinel.next = & list -> sentinel;
-   list -> sentinel.previous = & list -> sentinel;
-}
-
-ENetListIterator
-enet_list_insert (ENetListIterator position, void * data)
-{
-   ENetListIterator result = (ENetListIterator) data;
-
-   result -> previous = position -> previous;
-   result -> next = position;
-
-   result -> previous -> next = result;
-   position -> previous = result;
-
-   return result;
-}
-
-void *
-enet_list_remove (ENetListIterator position)
-{
-   position -> previous -> next = position -> next;
-   position -> next -> previous = position -> previous;
-
-   return position;
-}
-
-ENetListIterator
-enet_list_move (ENetListIterator position, void * dataFirst, void * dataLast)
-{
-   ENetListIterator first = (ENetListIterator) dataFirst,
-                    last = (ENetListIterator) dataLast;
-
-   first -> previous -> next = last -> next;
-   last -> next -> previous = first -> previous;
-
-   first -> previous = position -> previous;
-   last -> next = position;
-
-   first -> previous -> next = first;
-   position -> previous = last;
-    
-   return first;
-}
-
-size_t
-enet_list_size (ENetList * list)
-{
-   size_t size = 0;
-   ENetListIterator position;
-
-   for (position = enet_list_begin (list);
-        position != enet_list_end (list);
-        position = enet_list_next (position))
-     ++ size;
-   
-   return size;
-}
-
-/** @} */

externals/enet/packet.c

@@ -1,163 +0,0 @@
-/** 
- @file  packet.c
- @brief ENet packet management functions
-*/
-#include <string.h>
-#define ENET_BUILDING_LIB 1
-#include "enet/enet.h"
-
-/** @defgroup Packet ENet packet functions 
-    @{ 
-*/
-
-/** Creates a packet that may be sent to a peer.
-    @param data         initial contents of the packet's data; the packet's data will remain uninitialized if data is NULL.
-    @param dataLength   size of the data allocated for this packet
-    @param flags        flags for this packet as described for the ENetPacket structure.
-    @returns the packet on success, NULL on failure
-*/
-ENetPacket *
-enet_packet_create (const void * data, size_t dataLength, enet_uint32 flags)
-{
-    ENetPacket * packet = (ENetPacket *) enet_malloc (sizeof (ENetPacket));
-    if (packet == NULL)
-      return NULL;
-
-    if (flags & ENET_PACKET_FLAG_NO_ALLOCATE)
-      packet -> data = (enet_uint8 *) data;
-    else
-    if (dataLength <= 0)
-      packet -> data = NULL;
-    else
-    {
-       packet -> data = (enet_uint8 *) enet_malloc (dataLength);
-       if (packet -> data == NULL)
-       {
-          enet_free (packet);
-          return NULL;
-       }
-
-       if (data != NULL)
-         memcpy (packet -> data, data, dataLength);
-    }
-
-    packet -> referenceCount = 0;
-    packet -> flags = flags;
-    packet -> dataLength = dataLength;
-    packet -> freeCallback = NULL;
-    packet -> userData = NULL;
-
-    return packet;
-}
-
-/** Destroys the packet and deallocates its data.
-    @param packet packet to be destroyed
-*/
-void
-enet_packet_destroy (ENetPacket * packet)
-{
-    if (packet == NULL)
-      return;
-
-    if (packet -> freeCallback != NULL)
-      (* packet -> freeCallback) (packet);
-    if (! (packet -> flags & ENET_PACKET_FLAG_NO_ALLOCATE) &&
-        packet -> data != NULL)
-      enet_free (packet -> data);
-    enet_free (packet);
-}
-
-/** Attempts to resize the data in the packet to length specified in the 
-    dataLength parameter 
-    @param packet packet to resize
-    @param dataLength new size for the packet data
-    @returns 0 on success, < 0 on failure
-*/
-int
-enet_packet_resize (ENetPacket * packet, size_t dataLength)
-{
-    enet_uint8 * newData;
-   
-    if (dataLength <= packet -> dataLength || (packet -> flags & ENET_PACKET_FLAG_NO_ALLOCATE))
-    {
-       packet -> dataLength = dataLength;
-
-       return 0;
-    }
-
-    newData = (enet_uint8 *) enet_malloc (dataLength);
-    if (newData == NULL)
-      return -1;
-
-    if (packet -> data != NULL)
-    {
-       if (packet -> dataLength > 0)
-         memcpy (newData, packet -> data, packet -> dataLength);
-
-       enet_free (packet -> data);
-    }
-
-    packet -> data = newData;
-    packet -> dataLength = dataLength;
-
-    return 0;
-}
-
-static const enet_uint32 crcTable [256] =
-{
-    0,          0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
-    0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
-    0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
-    0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
-    0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
-    0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
-    0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
-    0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
-    0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
-    0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
-    0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
-    0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
-    0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
-    0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
-    0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
-    0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
-    0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
-    0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
-    0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
-    0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
-    0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
-    0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
-    0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
-    0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
-    0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x5005713,
-    0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0xBDBDF21,
-    0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
-    0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
-    0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
-    0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
-    0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
-    0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
-};
-
-enet_uint32
-enet_crc32 (const ENetBuffer * buffers, size_t bufferCount)
-{
-    enet_uint32 crc = 0xFFFFFFFF;
-
-    while (bufferCount -- > 0)
-    {
-        const enet_uint8 * data = (const enet_uint8 *) buffers -> data,
-                         * dataEnd = & data [buffers -> dataLength];
-
-        while (data < dataEnd)
-        {
-            crc = (crc >> 8) ^ crcTable [(crc & 0xFF) ^ *data++];
-        }
-
-        ++ buffers;
-    }
-
-    return ENET_HOST_TO_NET_32 (~ crc);
-}
-
-/** @} */

externals/enet/premake4.lua

@@ -1,59 +0,0 @@
-solution "enet"
-	configurations { "Debug", "Release" }
-	platforms { "x32", "x64" }
-
-	project "enet_static"
-		kind "StaticLib"
-		language "C"
-		
-		files { "*.c" }
-		
-		includedirs { "include/" }
-		
-		configuration "Debug"
-			targetsuffix "d"
-			
-			defines({ "DEBUG" })
-
-			flags { "Symbols" }
-		
-		configuration "Release"
-			defines({ "NDEBUG" })
-
-			flags { "Optimize" }
-			
-		configuration { "Debug", "x64" }
-			targetsuffix "64d"
-			
-		configuration { "Release", "x64" }
-			targetsuffix "64"
-
-	project "enet"
-		kind "SharedLib"
-		language "C"
-		
-		files { "*.c" }
-		
-		includedirs { "include/" }
-		
-		defines({"ENET_DLL=1" })
-		
-		configuration "Debug"
-			targetsuffix "d"
-			
-			defines({ "DEBUG" })
-
-			flags { "Symbols" }
-		
-		configuration "Release"
-			defines({ "NDEBUG" })
-
-			flags { "Optimize" }
-			
-		configuration { "Debug", "x64" }
-			targetsuffix "64d"
-			
-		configuration { "Release", "x64" }
-			targetsuffix "64"
-
-		

externals/enet/unix.c

@@ -1,630 +0,0 @@
-/** 
- @file  unix.c
- @brief ENet Unix system specific functions
-*/
-#ifndef _WIN32
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/ioctl.h>
-#include <sys/time.h>
-#include <netinet/tcp.h>
-#include <netdb.h>
-#include <unistd.h>
-#include <string.h>
-#include <errno.h>
-#include <time.h>
-
-#define ENET_BUILDING_LIB 1
-#include "enet/enet.h"
-
-#ifdef __APPLE__
-#ifdef HAS_POLL
-#undef HAS_POLL
-#endif
-#ifndef HAS_FCNTL
-#define HAS_FCNTL 1
-#endif
-#ifndef HAS_INET_PTON
-#define HAS_INET_PTON 1
-#endif
-#ifndef HAS_INET_NTOP
-#define HAS_INET_NTOP 1
-#endif
-#ifndef HAS_MSGHDR_FLAGS
-#define HAS_MSGHDR_FLAGS 1
-#endif
-#ifndef HAS_SOCKLEN_T
-#define HAS_SOCKLEN_T 1
-#endif
-#ifndef HAS_GETADDRINFO
-#define HAS_GETADDRINFO 1
-#endif
-#ifndef HAS_GETNAMEINFO
-#define HAS_GETNAMEINFO 1
-#endif
-#endif
-
-#ifdef HAS_FCNTL
-#include <fcntl.h>
-#endif
-
-#ifdef HAS_POLL
-#include <poll.h>
-#endif
-
-#if !defined(HAS_SOCKLEN_T) && !defined(__socklen_t_defined)
-typedef int socklen_t;
-#endif
-
-#ifndef MSG_NOSIGNAL
-#define MSG_NOSIGNAL 0
-#endif
-
-static enet_uint32 timeBase = 0;
-
-int
-enet_initialize (void)
-{
-    return 0;
-}
-
-void
-enet_deinitialize (void)
-{
-}
-
-enet_uint32
-enet_host_random_seed (void)
-{
-    return (enet_uint32) time (NULL);
-}
-
-enet_uint32
-enet_time_get (void)
-{
-    struct timeval timeVal;
-
-    gettimeofday (& timeVal, NULL);
-
-    return timeVal.tv_sec * 1000 + timeVal.tv_usec / 1000 - timeBase;
-}
-
-void
-enet_time_set (enet_uint32 newTimeBase)
-{
-    struct timeval timeVal;
-
-    gettimeofday (& timeVal, NULL);
-    
-    timeBase = timeVal.tv_sec * 1000 + timeVal.tv_usec / 1000 - newTimeBase;
-}
-
-int
-enet_address_set_host_ip (ENetAddress * address, const char * name)
-{
-#ifdef HAS_INET_PTON
-    if (! inet_pton (AF_INET, name, & address -> host))
-#else
-    if (! inet_aton (name, (struct in_addr *) & address -> host))
-#endif
-        return -1;
-
-    return 0;
-}
-
-int
-enet_address_set_host (ENetAddress * address, const char * name)
-{
-#ifdef HAS_GETADDRINFO
-    struct addrinfo hints, * resultList = NULL, * result = NULL;
-
-    memset (& hints, 0, sizeof (hints));
-    hints.ai_family = AF_INET;
-
-    if (getaddrinfo (name, NULL, NULL, & resultList) != 0)
-      return -1;
-
-    for (result = resultList; result != NULL; result = result -> ai_next)
-    {
-        if (result -> ai_family == AF_INET && result -> ai_addr != NULL && result -> ai_addrlen >= sizeof (struct sockaddr_in))
-        {
-            struct sockaddr_in * sin = (struct sockaddr_in *) result -> ai_addr;
-
-            address -> host = sin -> sin_addr.s_addr;
-
-            freeaddrinfo (resultList);
-
-            return 0;
-        }
-    }
-
-    if (resultList != NULL)
-      freeaddrinfo (resultList);
-#else
-    struct hostent * hostEntry = NULL;
-#ifdef HAS_GETHOSTBYNAME_R
-    struct hostent hostData;
-    char buffer [2048];
-    int errnum;
-
-#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) || defined(__GNU__)
-    gethostbyname_r (name, & hostData, buffer, sizeof (buffer), & hostEntry, & errnum);
-#else
-    hostEntry = gethostbyname_r (name, & hostData, buffer, sizeof (buffer), & errnum);
-#endif
-#else
-    hostEntry = gethostbyname (name);
-#endif
-
-    if (hostEntry != NULL && hostEntry -> h_addrtype == AF_INET)
-    {
-        address -> host = * (enet_uint32 *) hostEntry -> h_addr_list [0];
-
-        return 0;
-    }
-#endif
-
-    return enet_address_set_host_ip (address, name);
-}
-
-int
-enet_address_get_host_ip (const ENetAddress * address, char * name, size_t nameLength)
-{
-#ifdef HAS_INET_NTOP
-    if (inet_ntop (AF_INET, & address -> host, name, nameLength) == NULL)
-#else
-    char * addr = inet_ntoa (* (struct in_addr *) & address -> host);
-    if (addr != NULL)
-    {
-        size_t addrLen = strlen(addr);
-        if (addrLen >= nameLength)
-          return -1;
-        memcpy (name, addr, addrLen + 1);
-    } 
-    else
-#endif
-        return -1;
-    return 0;
-}
-
-int
-enet_address_get_host (const ENetAddress * address, char * name, size_t nameLength)
-{
-#ifdef HAS_GETNAMEINFO
-    struct sockaddr_in sin;
-    int err;
-
-    memset (& sin, 0, sizeof (struct sockaddr_in));
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-    sin.sin_addr.s_addr = address -> host;
-
-    err = getnameinfo ((struct sockaddr *) & sin, sizeof (sin), name, nameLength, NULL, 0, NI_NAMEREQD);
-    if (! err)
-    {
-        if (name != NULL && nameLength > 0 && ! memchr (name, '\0', nameLength))
-          return -1;
-        return 0;
-    }
-    if (err != EAI_NONAME)
-      return -1;
-#else
-    struct in_addr in;
-    struct hostent * hostEntry = NULL;
-#ifdef HAS_GETHOSTBYADDR_R
-    struct hostent hostData;
-    char buffer [2048];
-    int errnum;
-
-    in.s_addr = address -> host;
-
-#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) || defined(__GNU__)
-    gethostbyaddr_r ((char *) & in, sizeof (struct in_addr), AF_INET, & hostData, buffer, sizeof (buffer), & hostEntry, & errnum);
-#else
-    hostEntry = gethostbyaddr_r ((char *) & in, sizeof (struct in_addr), AF_INET, & hostData, buffer, sizeof (buffer), & errnum);
-#endif
-#else
-    in.s_addr = address -> host;
-
-    hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET);
-#endif
-
-    if (hostEntry != NULL)
-    {
-       size_t hostLen = strlen (hostEntry -> h_name);
-       if (hostLen >= nameLength)
-         return -1;
-       memcpy (name, hostEntry -> h_name, hostLen + 1);
-       return 0;
-    }
-#endif
-
-    return enet_address_get_host_ip (address, name, nameLength);
-}
-
-int
-enet_socket_bind (ENetSocket socket, const ENetAddress * address)
-{
-    struct sockaddr_in sin;
-
-    memset (& sin, 0, sizeof (struct sockaddr_in));
-
-    sin.sin_family = AF_INET;
-
-    if (address != NULL)
-    {
-       sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-       sin.sin_addr.s_addr = address -> host;
-    }
-    else
-    {
-       sin.sin_port = 0;
-       sin.sin_addr.s_addr = INADDR_ANY;
-    }
-
-    return bind (socket,
-                 (struct sockaddr *) & sin,
-                 sizeof (struct sockaddr_in)); 
-}
-
-int
-enet_socket_get_address (ENetSocket socket, ENetAddress * address)
-{
-    struct sockaddr_in sin;
-    socklen_t sinLength = sizeof (struct sockaddr_in);
-
-    if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1)
-      return -1;
-
-    address -> host = (enet_uint32) sin.sin_addr.s_addr;
-    address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
-
-    return 0;
-}
-
-int 
-enet_socket_listen (ENetSocket socket, int backlog)
-{
-    return listen (socket, backlog < 0 ? SOMAXCONN : backlog);
-}
-
-ENetSocket
-enet_socket_create (ENetSocketType type)
-{
-    return socket (PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
-}
-
-int
-enet_socket_set_option (ENetSocket socket, ENetSocketOption option, int value)
-{
-    int result = -1;
-    switch (option)
-    {
-        case ENET_SOCKOPT_NONBLOCK:
-#ifdef HAS_FCNTL
-            result = fcntl (socket, F_SETFL, (value ? O_NONBLOCK : 0) | (fcntl (socket, F_GETFL) & ~O_NONBLOCK));
-#else
-            result = ioctl (socket, FIONBIO, & value);
-#endif
-            break;
-
-        case ENET_SOCKOPT_BROADCAST:
-            result = setsockopt (socket, SOL_SOCKET, SO_BROADCAST, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_REUSEADDR:
-            result = setsockopt (socket, SOL_SOCKET, SO_REUSEADDR, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_RCVBUF:
-            result = setsockopt (socket, SOL_SOCKET, SO_RCVBUF, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_SNDBUF:
-            result = setsockopt (socket, SOL_SOCKET, SO_SNDBUF, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_RCVTIMEO:
-        {
-            struct timeval timeVal;
-            timeVal.tv_sec = value / 1000;
-            timeVal.tv_usec = (value % 1000) * 1000;
-            result = setsockopt (socket, SOL_SOCKET, SO_RCVTIMEO, (char *) & timeVal, sizeof (struct timeval));
-            break;
-        }
-
-        case ENET_SOCKOPT_SNDTIMEO:
-        {
-            struct timeval timeVal;
-            timeVal.tv_sec = value / 1000;
-            timeVal.tv_usec = (value % 1000) * 1000;
-            result = setsockopt (socket, SOL_SOCKET, SO_SNDTIMEO, (char *) & timeVal, sizeof (struct timeval));
-            break;
-        }
-
-        case ENET_SOCKOPT_NODELAY:
-            result = setsockopt (socket, IPPROTO_TCP, TCP_NODELAY, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_TTL:
-            result = setsockopt (socket, IPPROTO_IP, IP_TTL, (char *) & value, sizeof (int));
-            break;
-
-        default:
-            break;
-    }
-    return result == -1 ? -1 : 0;
-}
-
-int
-enet_socket_get_option (ENetSocket socket, ENetSocketOption option, int * value)
-{
-    int result = -1;
-    socklen_t len;
-    switch (option)
-    {
-        case ENET_SOCKOPT_ERROR:
-            len = sizeof (int);
-            result = getsockopt (socket, SOL_SOCKET, SO_ERROR, value, & len);
-            break;
-
-        case ENET_SOCKOPT_TTL:
-            len = sizeof (int);
-            result = getsockopt (socket, IPPROTO_IP, IP_TTL, (char *) value, & len);
-            break;
-
-        default:
-            break;
-    }
-    return result == -1 ? -1 : 0;
-}
-
-int
-enet_socket_connect (ENetSocket socket, const ENetAddress * address)
-{
-    struct sockaddr_in sin;
-    int result;
-
-    memset (& sin, 0, sizeof (struct sockaddr_in));
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-    sin.sin_addr.s_addr = address -> host;
-
-    result = connect (socket, (struct sockaddr *) & sin, sizeof (struct sockaddr_in));
-    if (result == -1 && errno == EINPROGRESS)
-      return 0;
-
-    return result;
-}
-
-ENetSocket
-enet_socket_accept (ENetSocket socket, ENetAddress * address)
-{
-    int result;
-    struct sockaddr_in sin;
-    socklen_t sinLength = sizeof (struct sockaddr_in);
-
-    result = accept (socket, 
-                     address != NULL ? (struct sockaddr *) & sin : NULL, 
-                     address != NULL ? & sinLength : NULL);
-    
-    if (result == -1)
-      return ENET_SOCKET_NULL;
-
-    if (address != NULL)
-    {
-        address -> host = (enet_uint32) sin.sin_addr.s_addr;
-        address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
-    }
-
-    return result;
-} 
-    
-int
-enet_socket_shutdown (ENetSocket socket, ENetSocketShutdown how)
-{
-    return shutdown (socket, (int) how);
-}
-
-void
-enet_socket_destroy (ENetSocket socket)
-{
-    if (socket != -1)
-      close (socket);
-}
-
-int
-enet_socket_send (ENetSocket socket,
-                  const ENetAddress * address,
-                  const ENetBuffer * buffers,
-                  size_t bufferCount)
-{
-    struct msghdr msgHdr;
-    struct sockaddr_in sin;
-    int sentLength;
-
-    memset (& msgHdr, 0, sizeof (struct msghdr));
-
-    if (address != NULL)
-    {
-        memset (& sin, 0, sizeof (struct sockaddr_in));
-
-        sin.sin_family = AF_INET;
-        sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-        sin.sin_addr.s_addr = address -> host;
-
-        msgHdr.msg_name = & sin;
-        msgHdr.msg_namelen = sizeof (struct sockaddr_in);
-    }
-
-    msgHdr.msg_iov = (struct iovec *) buffers;
-    msgHdr.msg_iovlen = bufferCount;
-
-    sentLength = sendmsg (socket, & msgHdr, MSG_NOSIGNAL);
-    
-    if (sentLength == -1)
-    {
-       if (errno == EWOULDBLOCK)
-         return 0;
-
-       return -1;
-    }
-
-    return sentLength;
-}
-
-int
-enet_socket_receive (ENetSocket socket,
-                     ENetAddress * address,
-                     ENetBuffer * buffers,
-                     size_t bufferCount)
-{
-    struct msghdr msgHdr;
-    struct sockaddr_in sin;
-    int recvLength;
-
-    memset (& msgHdr, 0, sizeof (struct msghdr));
-
-    if (address != NULL)
-    {
-        msgHdr.msg_name = & sin;
-        msgHdr.msg_namelen = sizeof (struct sockaddr_in);
-    }
-
-    msgHdr.msg_iov = (struct iovec *) buffers;
-    msgHdr.msg_iovlen = bufferCount;
-
-    recvLength = recvmsg (socket, & msgHdr, MSG_NOSIGNAL);
-
-    if (recvLength == -1)
-    {
-        switch (errno)
-        {
-            case EWOULDBLOCK:
-                return 0;
-            case EINTR:
-            case EMSGSIZE:
-                return -2;
-            default:
-                return -1;
-        }
-    }
-
-#ifdef HAS_MSGHDR_FLAGS
-    if (msgHdr.msg_flags & MSG_TRUNC)
-      return -2;
-#endif
-
-    if (address != NULL)
-    {
-        address -> host = (enet_uint32) sin.sin_addr.s_addr;
-        address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
-    }
-
-    return recvLength;
-}
-
-int
-enet_socketset_select (ENetSocket maxSocket, ENetSocketSet * readSet, ENetSocketSet * writeSet, enet_uint32 timeout)
-{
-    struct timeval timeVal;
-
-    timeVal.tv_sec = timeout / 1000;
-    timeVal.tv_usec = (timeout % 1000) * 1000;
-
-    return select (maxSocket + 1, readSet, writeSet, NULL, & timeVal);
-}
-
-int
-enet_socket_wait (ENetSocket socket, enet_uint32 * condition, enet_uint32 timeout)
-{
-#ifdef HAS_POLL
-    struct pollfd pollSocket;
-    int pollCount;
-    
-    pollSocket.fd = socket;
-    pollSocket.events = 0;
-
-    if (* condition & ENET_SOCKET_WAIT_SEND)
-      pollSocket.events |= POLLOUT;
-
-    if (* condition & ENET_SOCKET_WAIT_RECEIVE)
-      pollSocket.events |= POLLIN;
-
-    pollCount = poll (& pollSocket, 1, timeout);
-
-    if (pollCount < 0)
-    {
-        if (errno == EINTR && * condition & ENET_SOCKET_WAIT_INTERRUPT)
-        {
-            * condition = ENET_SOCKET_WAIT_INTERRUPT;
-
-            return 0;
-        }
-
-        return -1;
-    }
-
-    * condition = ENET_SOCKET_WAIT_NONE;
-
-    if (pollCount == 0)
-      return 0;
-
-    if (pollSocket.revents & POLLOUT)
-      * condition |= ENET_SOCKET_WAIT_SEND;
-    
-    if (pollSocket.revents & POLLIN)
-      * condition |= ENET_SOCKET_WAIT_RECEIVE;
-
-    return 0;
-#else
-    fd_set readSet, writeSet;
-    struct timeval timeVal;
-    int selectCount;
-
-    timeVal.tv_sec = timeout / 1000;
-    timeVal.tv_usec = (timeout % 1000) * 1000;
-
-    FD_ZERO (& readSet);
-    FD_ZERO (& writeSet);
-
-    if (* condition & ENET_SOCKET_WAIT_SEND)
-      FD_SET (socket, & writeSet);
-
-    if (* condition & ENET_SOCKET_WAIT_RECEIVE)
-      FD_SET (socket, & readSet);
-
-    selectCount = select (socket + 1, & readSet, & writeSet, NULL, & timeVal);
-
-    if (selectCount < 0)
-    {
-        if (errno == EINTR && * condition & ENET_SOCKET_WAIT_INTERRUPT)
-        {
-            * condition = ENET_SOCKET_WAIT_INTERRUPT;
-
-            return 0;
-        }
-      
-        return -1;
-    }
-
-    * condition = ENET_SOCKET_WAIT_NONE;
-
-    if (selectCount == 0)
-      return 0;
-
-    if (FD_ISSET (socket, & writeSet))
-      * condition |= ENET_SOCKET_WAIT_SEND;
-
-    if (FD_ISSET (socket, & readSet))
-      * condition |= ENET_SOCKET_WAIT_RECEIVE;
-
-    return 0;
-#endif
-}
-
-#endif
-

externals/enet/win32.c

@@ -1,455 +0,0 @@
-/** 
- @file  win32.c
- @brief ENet Win32 system specific functions
-*/
-#ifdef _WIN32
-
-#define ENET_BUILDING_LIB 1
-#include "enet/enet.h"
-#include <windows.h>
-#include <mmsystem.h>
-#include <ws2tcpip.h>
-
-static enet_uint32 timeBase = 0;
-
-int
-enet_initialize (void)
-{
-    WORD versionRequested = MAKEWORD (1, 1);
-    WSADATA wsaData;
-   
-    if (WSAStartup (versionRequested, & wsaData))
-       return -1;
-
-    if (LOBYTE (wsaData.wVersion) != 1||
-        HIBYTE (wsaData.wVersion) != 1)
-    {
-       WSACleanup ();
-       
-       return -1;
-    }
-
-    timeBeginPeriod (1);
-
-    return 0;
-}
-
-void
-enet_deinitialize (void)
-{
-    timeEndPeriod (1);
-
-    WSACleanup ();
-}
-
-enet_uint32
-enet_host_random_seed (void)
-{
-    return (enet_uint32) timeGetTime ();
-}
-
-enet_uint32
-enet_time_get (void)
-{
-    return (enet_uint32) timeGetTime () - timeBase;
-}
-
-void
-enet_time_set (enet_uint32 newTimeBase)
-{
-    timeBase = (enet_uint32) timeGetTime () - newTimeBase;
-}
-
-int
-enet_address_set_host_ip (ENetAddress * address, const char * name)
-{
-    enet_uint8 vals [4] = { 0, 0, 0, 0 };
-    int i;
-
-    for (i = 0; i < 4; ++ i)
-    {
-        const char * next = name + 1;
-        if (* name != '0')
-        {
-            long val = strtol (name, (char **) & next, 10);
-            if (val < 0 || val > 255 || next == name || next - name > 3)
-              return -1;
-            vals [i] = (enet_uint8) val;
-        }
-
-        if (* next != (i < 3 ? '.' : '\0'))
-          return -1;
-        name = next + 1;
-    }
-
-    memcpy (& address -> host, vals, sizeof (enet_uint32));
-    return 0;
-}
-
-int
-enet_address_set_host (ENetAddress * address, const char * name)
-{
-    struct hostent * hostEntry;
-
-    hostEntry = gethostbyname (name);
-    if (hostEntry == NULL ||
-        hostEntry -> h_addrtype != AF_INET)
-      return enet_address_set_host_ip (address, name);
-
-    address -> host = * (enet_uint32 *) hostEntry -> h_addr_list [0];
-
-    return 0;
-}
-
-int
-enet_address_get_host_ip (const ENetAddress * address, char * name, size_t nameLength)
-{
-    char * addr = inet_ntoa (* (struct in_addr *) & address -> host);
-    if (addr == NULL)
-        return -1;
-    else
-    {
-        size_t addrLen = strlen(addr);
-        if (addrLen >= nameLength)
-          return -1;
-        memcpy (name, addr, addrLen + 1);
-    }
-    return 0;
-}
-
-int
-enet_address_get_host (const ENetAddress * address, char * name, size_t nameLength)
-{
-    struct in_addr in;
-    struct hostent * hostEntry;
- 
-    in.s_addr = address -> host;
-    
-    hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET);
-    if (hostEntry == NULL)
-      return enet_address_get_host_ip (address, name, nameLength);
-    else
-    {
-       size_t hostLen = strlen (hostEntry -> h_name);
-       if (hostLen >= nameLength)
-         return -1;
-       memcpy (name, hostEntry -> h_name, hostLen + 1);
-    }
-
-    return 0;
-}
-
-int
-enet_socket_bind (ENetSocket socket, const ENetAddress * address)
-{
-    struct sockaddr_in sin;
-
-    memset (& sin, 0, sizeof (struct sockaddr_in));
-
-    sin.sin_family = AF_INET;
-
-    if (address != NULL)
-    {
-       sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-       sin.sin_addr.s_addr = address -> host;
-    }
-    else
-    {
-       sin.sin_port = 0;
-       sin.sin_addr.s_addr = INADDR_ANY;
-    }
-
-    return bind (socket,
-                 (struct sockaddr *) & sin,
-                 sizeof (struct sockaddr_in)) == SOCKET_ERROR ? -1 : 0;
-}
-
-int
-enet_socket_get_address (ENetSocket socket, ENetAddress * address)
-{
-    struct sockaddr_in sin;
-    int sinLength = sizeof (struct sockaddr_in);
-
-    if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1)
-      return -1;
-
-    address -> host = (enet_uint32) sin.sin_addr.s_addr;
-    address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
-
-    return 0;
-}
-
-int
-enet_socket_listen (ENetSocket socket, int backlog)
-{
-    return listen (socket, backlog < 0 ? SOMAXCONN : backlog) == SOCKET_ERROR ? -1 : 0;
-}
-
-ENetSocket
-enet_socket_create (ENetSocketType type)
-{
-    return socket (PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
-}
-
-int
-enet_socket_set_option (ENetSocket socket, ENetSocketOption option, int value)
-{
-    int result = SOCKET_ERROR;
-    switch (option)
-    {
-        case ENET_SOCKOPT_NONBLOCK:
-        {
-            u_long nonBlocking = (u_long) value;
-            result = ioctlsocket (socket, FIONBIO, & nonBlocking);
-            break;
-        }
-
-        case ENET_SOCKOPT_BROADCAST:
-            result = setsockopt (socket, SOL_SOCKET, SO_BROADCAST, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_REUSEADDR:
-            result = setsockopt (socket, SOL_SOCKET, SO_REUSEADDR, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_RCVBUF:
-            result = setsockopt (socket, SOL_SOCKET, SO_RCVBUF, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_SNDBUF:
-            result = setsockopt (socket, SOL_SOCKET, SO_SNDBUF, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_RCVTIMEO:
-            result = setsockopt (socket, SOL_SOCKET, SO_RCVTIMEO, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_SNDTIMEO:
-            result = setsockopt (socket, SOL_SOCKET, SO_SNDTIMEO, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_NODELAY:
-            result = setsockopt (socket, IPPROTO_TCP, TCP_NODELAY, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_TTL:
-            result = setsockopt (socket, IPPROTO_IP, IP_TTL, (char *) & value, sizeof (int));
-            break;
-
-        default:
-            break;
-    }
-    return result == SOCKET_ERROR ? -1 : 0;
-}
-
-int
-enet_socket_get_option (ENetSocket socket, ENetSocketOption option, int * value)
-{
-    int result = SOCKET_ERROR, len;
-    switch (option)
-    {
-        case ENET_SOCKOPT_ERROR:
-            len = sizeof(int);
-            result = getsockopt (socket, SOL_SOCKET, SO_ERROR, (char *) value, & len);
-            break;
-
-        case ENET_SOCKOPT_TTL:
-            len = sizeof(int);
-            result = getsockopt (socket, IPPROTO_IP, IP_TTL, (char *) value, & len);
-            break;
-
-        default:
-            break;
-    }
-    return result == SOCKET_ERROR ? -1 : 0;
-}
-
-int
-enet_socket_connect (ENetSocket socket, const ENetAddress * address)
-{
-    struct sockaddr_in sin;
-    int result;
-
-    memset (& sin, 0, sizeof (struct sockaddr_in));
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-    sin.sin_addr.s_addr = address -> host;
-
-    result = connect (socket, (struct sockaddr *) & sin, sizeof (struct sockaddr_in));
-    if (result == SOCKET_ERROR && WSAGetLastError () != WSAEWOULDBLOCK)
-      return -1;
-
-    return 0;
-}
-
-ENetSocket
-enet_socket_accept (ENetSocket socket, ENetAddress * address)
-{
-    SOCKET result;
-    struct sockaddr_in sin;
-    int sinLength = sizeof (struct sockaddr_in);
-
-    result = accept (socket, 
-                     address != NULL ? (struct sockaddr *) & sin : NULL, 
-                     address != NULL ? & sinLength : NULL);
-
-    if (result == INVALID_SOCKET)
-      return ENET_SOCKET_NULL;
-
-    if (address != NULL)
-    {
-        address -> host = (enet_uint32) sin.sin_addr.s_addr;
-        address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
-    }
-
-    return result;
-}
-
-int
-enet_socket_shutdown (ENetSocket socket, ENetSocketShutdown how)
-{
-    return shutdown (socket, (int) how) == SOCKET_ERROR ? -1 : 0;
-}
-
-void
-enet_socket_destroy (ENetSocket socket)
-{
-    if (socket != INVALID_SOCKET)
-      closesocket (socket);
-}
-
-int
-enet_socket_send (ENetSocket socket,
-                  const ENetAddress * address,
-                  const ENetBuffer * buffers,
-                  size_t bufferCount)
-{
-    struct sockaddr_in sin;
-    DWORD sentLength = 0;
-
-    if (address != NULL)
-    {
-        memset (& sin, 0, sizeof (struct sockaddr_in));
-
-        sin.sin_family = AF_INET;
-        sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-        sin.sin_addr.s_addr = address -> host;
-    }
-
-    if (WSASendTo (socket, 
-                   (LPWSABUF) buffers,
-                   (DWORD) bufferCount,
-                   & sentLength,
-                   0,
-                   address != NULL ? (struct sockaddr *) & sin : NULL,
-                   address != NULL ? sizeof (struct sockaddr_in) : 0,
-                   NULL,
-                   NULL) == SOCKET_ERROR)
-    {
-       if (WSAGetLastError () == WSAEWOULDBLOCK)
-         return 0;
-
-       return -1;
-    }
-
-    return (int) sentLength;
-}
-
-int
-enet_socket_receive (ENetSocket socket,
-                     ENetAddress * address,
-                     ENetBuffer * buffers,
-                     size_t bufferCount)
-{
-    INT sinLength = sizeof (struct sockaddr_in);
-    DWORD flags = 0,
-          recvLength = 0;
-    struct sockaddr_in sin;
-
-    if (WSARecvFrom (socket,
-                     (LPWSABUF) buffers,
-                     (DWORD) bufferCount,
-                     & recvLength,
-                     & flags,
-                     address != NULL ? (struct sockaddr *) & sin : NULL,
-                     address != NULL ? & sinLength : NULL,
-                     NULL,
-                     NULL) == SOCKET_ERROR)
-    {
-       switch (WSAGetLastError ())
-       {
-       case WSAEWOULDBLOCK:
-       case WSAECONNRESET:
-          return 0;
-       case WSAEINTR:
-       case WSAEMSGSIZE:
-          return -2;
-       default:
-          return -1;
-       }
-    }
-
-    if (flags & MSG_PARTIAL)
-      return -2;
-
-    if (address != NULL)
-    {
-        address -> host = (enet_uint32) sin.sin_addr.s_addr;
-        address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
-    }
-
-    return (int) recvLength;
-}
-
-int
-enet_socketset_select (ENetSocket maxSocket, ENetSocketSet * readSet, ENetSocketSet * writeSet, enet_uint32 timeout)
-{
-    struct timeval timeVal;
-
-    timeVal.tv_sec = timeout / 1000;
-    timeVal.tv_usec = (timeout % 1000) * 1000;
-
-    return select (maxSocket + 1, readSet, writeSet, NULL, & timeVal);
-}
-
-int
-enet_socket_wait (ENetSocket socket, enet_uint32 * condition, enet_uint32 timeout)
-{
-    fd_set readSet, writeSet;
-    struct timeval timeVal;
-    int selectCount;
-    
-    timeVal.tv_sec = timeout / 1000;
-    timeVal.tv_usec = (timeout % 1000) * 1000;
-    
-    FD_ZERO (& readSet);
-    FD_ZERO (& writeSet);
-
-    if (* condition & ENET_SOCKET_WAIT_SEND)
-      FD_SET (socket, & writeSet);
-
-    if (* condition & ENET_SOCKET_WAIT_RECEIVE)
-      FD_SET (socket, & readSet);
-
-    selectCount = select (socket + 1, & readSet, & writeSet, NULL, & timeVal);
-
-    if (selectCount < 0)
-      return -1;
-
-    * condition = ENET_SOCKET_WAIT_NONE;
-
-    if (selectCount == 0)
-      return 0;
-
-    if (FD_ISSET (socket, & writeSet))
-      * condition |= ENET_SOCKET_WAIT_SEND;
-    
-    if (FD_ISSET (socket, & readSet))
-      * condition |= ENET_SOCKET_WAIT_RECEIVE;
-
-    return 0;
-} 
-
-#endif
-

externals/ffmpeg/CMakeLists.txt

@@ -1,6 +1,10 @@
 # SPDX-FileCopyrightText: 2021 yuzu Emulator Project
 # SPDX-License-Identifier: GPL-2.0-or-later
 
+# Explicitly include CPMUtil here since we have a separate cpmfile for ffmpeg
+set(CPMUTIL_JSON_FILE ${CMAKE_CURRENT_SOURCE_DIR}/cpmfile.json)
+include(CPMUtil)
+
 if (NOT WIN32 AND NOT ANDROID)
     # Build FFmpeg from externals
     message(STATUS "Using FFmpeg from externals")
@@ -19,15 +23,7 @@ if (NOT WIN32 AND NOT ANDROID)
         message(FATAL_ERROR "Required program `autoconf` not found.")
     endif()
 
-    include(CPM)
-    set(CPM_USE_LOCAL_PACKAGES OFF)
-
-    CPMAddPackage(
-        NAME ffmpeg
-        URL "https://github.com/FFmpeg/FFmpeg/archive/c2184b65d2.zip"
-        URL_HASH SHA512=2a89d664119debbb3c006ab1c48d5d7f26e889f4a65ad2e25c8b0503308295123d5a9c5c78bf683aef5ff09acef8c3fc2837f22d3e8c611528b933bf03bcdd97
-        CUSTOM_CACHE_KEY "c218"
-    )
+    AddJsonPackage(ffmpeg)
 
     set(FFmpeg_PREFIX ${ffmpeg_SOURCE_DIR})
     set(FFmpeg_BUILD_DIR ${ffmpeg_BINARY_DIR})
@@ -67,32 +63,44 @@ if (NOT WIN32 AND NOT ANDROID)
     set(FFmpeg_HWACCEL_INCLUDE_DIRS)
     set(FFmpeg_HWACCEL_LDFLAGS)
 
-    if(LIBVA_FOUND)
+    # In Solaris needs explicit linking for ffmpeg which links to /lib/amd64/libX11.so
+    if(PLATFORM_SUN)
+        list(APPEND FFmpeg_HWACCEL_LIBRARIES
+            X11
+            "/usr/lib/xorg/amd64/libdrm.so")
+    else()
         pkg_check_modules(LIBDRM libdrm REQUIRED)
+        list(APPEND FFmpeg_HWACCEL_LIBRARIES
+            ${LIBDRM_LIBRARIES})
+        list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
+            ${LIBDRM_INCLUDE_DIRS})
+    endif()
+    list(APPEND FFmpeg_HWACCEL_FLAGS
+        --enable-libdrm)
+
+    if(LIBVA_FOUND)
         find_package(X11 REQUIRED)
         pkg_check_modules(LIBVA-DRM libva-drm REQUIRED)
         pkg_check_modules(LIBVA-X11 libva-x11 REQUIRED)
         list(APPEND FFmpeg_HWACCEL_LIBRARIES
-            ${LIBDRM_LIBRARIES}
             ${X11_LIBRARIES}
             ${LIBVA-DRM_LIBRARIES}
             ${LIBVA-X11_LIBRARIES}
             ${LIBVA_LIBRARIES})
-        set(FFmpeg_HWACCEL_FLAGS
+        list(APPEND FFmpeg_HWACCEL_FLAGS
             --enable-hwaccel=h264_vaapi
             --enable-hwaccel=vp8_vaapi
-            --enable-hwaccel=vp9_vaapi
-            --enable-libdrm)
+            --enable-hwaccel=vp9_vaapi)
         list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
-            ${LIBDRM_INCLUDE_DIRS}
             ${X11_INCLUDE_DIRS}
             ${LIBVA-DRM_INCLUDE_DIRS}
             ${LIBVA-X11_INCLUDE_DIRS}
             ${LIBVA_INCLUDE_DIRS}
         )
-        message(STATUS "VA-API found")
+        message(STATUS "ffmpeg: va-api libraries version ${LIBVA_VERSION} found")
     else()
-        set(FFmpeg_HWACCEL_FLAGS --disable-vaapi)
+        list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
+        message(WARNING "ffmpeg: libva-dev not found, disabling Video Aceleraion API (VA-API)...")
     endif()
 
     if (FFNVCODEC_FOUND)
@@ -107,7 +115,7 @@ if (NOT WIN32 AND NOT ANDROID)
         list(APPEND FFmpeg_HWACCEL_LIBRARIES ${FFNVCODEC_LIBRARIES})
         list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${FFNVCODEC_INCLUDE_DIRS})
         list(APPEND FFmpeg_HWACCEL_LDFLAGS ${FFNVCODEC_LDFLAGS})
-        message(STATUS "ffnvcodec libraries version ${FFNVCODEC_VERSION} found")
+        message(STATUS "ffmpeg: ffnvcodec libraries version ${FFNVCODEC_VERSION} found")
         # ffnvenc could load CUDA libraries at the runtime using dlopen/dlsym or LoadLibrary/GetProcAddress
         # here we handle the hard-linking senario where CUDA is linked during compilation
         if (CUDA_FOUND)
@@ -116,7 +124,7 @@ if (NOT WIN32 AND NOT ANDROID)
             list(APPEND FFmpeg_HWACCEL_LIBRARIES ${CUDA_LIBRARIES})
             list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${CUDA_INCLUDE_DIRS})
             list(APPEND FFmpeg_HWACCEL_LDFLAGS ${CUDA_LDFLAGS})
-            message(STATUS "CUDA libraries found, hard-linking will be performed")
+            message(STATUS "ffmpeg: CUDA libraries found, hard-linking will be performed")
         endif(CUDA_FOUND)
     endif()
 
@@ -129,9 +137,10 @@ if (NOT WIN32 AND NOT ANDROID)
         list(APPEND FFmpeg_HWACCEL_LIBRARIES ${VDPAU_LIBRARIES})
         list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${VDPAU_INCLUDE_DIRS})
         list(APPEND FFmpeg_HWACCEL_LDFLAGS ${VDPAU_LDFLAGS})
-        message(STATUS "vdpau libraries version ${VDPAU_VERSION} found")
+        message(STATUS "ffmpeg: vdpau libraries version ${VDPAU_VERSION} found")
     else()
         list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vdpau)
+        message(WARNING "ffmpeg: libvdpau-dev not found, disabling Video Decode and Presentation API for Unix (VDPAU)...")
     endif()
 
     find_program(BASH_PROGRAM bash REQUIRED)
@@ -243,7 +252,7 @@ elseif(ANDROID)
         message(FATAL_ERROR "Unsupported architecture for Android FFmpeg")
     endif()
 
-    download_bundled_external("ffmpeg/" ${FFmpeg_EXT_NAME} "ffmpeg-bundled" FFmpeg_PATH)
+    download_bundled_external("ffmpeg/" ${FFmpeg_EXT_NAME} "ffmpeg-bundled" FFmpeg_PATH 7.1.1)
     set(FFmpeg_FOUND YES)
     set(FFmpeg_INCLUDE_DIR "${FFmpeg_PATH}/include" CACHE PATH "Path to FFmpeg headers" FORCE)
     set(FFmpeg_LIBRARY_DIR "${FFmpeg_PATH}/lib" CACHE PATH "Path to FFmpeg library directory" FORCE)
@@ -268,7 +277,7 @@ elseif(WIN32)
     # Use yuzu FFmpeg binaries
     set(FFmpeg_EXT_NAME "ffmpeg-7.1.1")
 
-    download_bundled_external("ffmpeg/" ${FFmpeg_EXT_NAME} "ffmpeg-bundled" FFmpeg_PATH)
+    download_bundled_external("ffmpeg/" ${FFmpeg_EXT_NAME} "ffmpeg-bundled" FFmpeg_PATH 7.1.1)
     set(FFmpeg_FOUND YES)
     set(FFmpeg_INCLUDE_DIR "${FFmpeg_PATH}/include" CACHE PATH "Path to FFmpeg headers" FORCE)
     set(FFmpeg_LIBRARY_DIR "${FFmpeg_PATH}/bin" CACHE PATH "Path to FFmpeg library directory" FORCE)

externals/ffmpeg/cpmfile.json

@@ -0,0 +1,8 @@
+{
+    "ffmpeg": {
+        "repo": "FFmpeg/FFmpeg",
+        "sha": "c2184b65d2",
+        "hash": "2a89d664119debbb3c006ab1c48d5d7f26e889f4a65ad2e25c8b0503308295123d5a9c5c78bf683aef5ff09acef8c3fc2837f22d3e8c611528b933bf03bcdd97",
+        "bundled": true
+    }
+}

externals/nx_tzdb/CMakeLists.txt

@@ -1,6 +1,13 @@
+# SPDX-FileCopyrightText: 2025 Eden Emulator Project
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 # SPDX-FileCopyrightText: 2023 yuzu Emulator Project
 # SPDX-License-Identifier: GPL-2.0-or-later
 
+# Explicitly include CPMUtil here since we have a separate cpmfile for nx_tzdb
+set(CPMUTIL_JSON_FILE ${CMAKE_CURRENT_SOURCE_DIR}/cpmfile.json)
+include(CPMUtil)
+
 set(NX_TZDB_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/include")
 
 add_library(nx_tzdb INTERFACE)
@@ -11,33 +18,38 @@ find_program(DATE_PROG date)
 
 set(CAN_BUILD_NX_TZDB true)
 
-if (NOT GIT)
-    set(CAN_BUILD_NX_TZDB false)
-endif()
-if (NOT GNU_MAKE)
-    set(CAN_BUILD_NX_TZDB false)
-endif()
-if (NOT DATE_PROG)
-    set(CAN_BUILD_NX_TZDB false)
-endif()
-if (CMAKE_SYSTEM_NAME STREQUAL "Windows" OR ANDROID)
+if (NOT (GIT AND GNU_MAKE AND DATE_PROG) OR CMAKE_SYSTEM_NAME STREQUAL "Windows" OR ANDROID)
     # tzdb_to_nx currently requires a posix-compliant host
     # MinGW and Android are handled here due to the executable format being different from the host system
     # TODO (lat9nq): cross-compiling support
+
     set(CAN_BUILD_NX_TZDB false)
 endif()
 
-set(NX_TZDB_VERSION "250725")
-set(NX_TZDB_ARCHIVE "${CPM_SOURCE_CACHE}/nx_tzdb/${NX_TZDB_VERSION}.zip")
+if (CAN_BUILD_NX_TZDB AND NOT YUZU_DOWNLOAD_TIME_ZONE_DATA)
+    message(FATAL_ERROR "Building tzdb is currently unsupported. Check back later.")
+    add_subdirectory(tzdb_to_nx)
+    add_dependencies(nx_tzdb x80e)
 
-set(NX_TZDB_ROMFS_DIR "${CPM_SOURCE_CACHE}/nx_tzdb/tz")
+    set(NX_TZDB_BASE_DIR "${NX_TZDB_DIR}")
+    set(NX_TZDB_TZ_DIR "${NX_TZDB_BASE_DIR}/zoneinfo")
+endif()
+
+# TODO(crueter): This is a terrible solution, but MSVC fails to link without it
+# Need to investigate further but I still can't reproduce...
+if (MSVC)
+    set(NX_TZDB_VERSION "250725")
+    set(NX_TZDB_ARCHIVE "${CPM_SOURCE_CACHE}/nx_tzdb/${NX_TZDB_VERSION}.zip")
+
+    set(NX_TZDB_BASE_DIR "${CPM_SOURCE_CACHE}/nx_tzdb/tz")
+    set(NX_TZDB_TZ_DIR "${NX_TZDB_BASE_DIR}/zoneinfo")
 
-if ((NOT CAN_BUILD_NX_TZDB OR YUZU_DOWNLOAD_TIME_ZONE_DATA) AND NOT EXISTS ${NX_TZDB_ROMFS_DIR})
     set(NX_TZDB_DOWNLOAD_URL "https://github.com/crueter/tzdb_to_nx/releases/download/${NX_TZDB_VERSION}/${NX_TZDB_VERSION}.zip")
 
     message(STATUS "Downloading time zone data from ${NX_TZDB_DOWNLOAD_URL}...")
     file(DOWNLOAD ${NX_TZDB_DOWNLOAD_URL} ${NX_TZDB_ARCHIVE}
         STATUS NX_TZDB_DOWNLOAD_STATUS)
+
     list(GET NX_TZDB_DOWNLOAD_STATUS 0 NX_TZDB_DOWNLOAD_STATUS_CODE)
     if (NOT NX_TZDB_DOWNLOAD_STATUS_CODE EQUAL 0)
         message(FATAL_ERROR "Time zone data download failed (status code ${NX_TZDB_DOWNLOAD_STATUS_CODE})")
@@ -47,13 +59,17 @@ if ((NOT CAN_BUILD_NX_TZDB OR YUZU_DOWNLOAD_TIME_ZONE_DATA) AND NOT EXISTS ${NX_
         INPUT
             ${NX_TZDB_ARCHIVE}
         DESTINATION
-            ${NX_TZDB_ROMFS_DIR})
-elseif (CAN_BUILD_NX_TZDB AND NOT YUZU_DOWNLOAD_TIME_ZONE_DATA)
-    # TODO(crueter): this sucked to do with cpm, see if i can get it to work again
-    add_subdirectory(tzdb_to_nx)
-    add_dependencies(nx_tzdb x80e)
+            ${NX_TZDB_BASE_DIR})
+else()
+    message(STATUS "Downloading time zone data...")
+    AddJsonPackage(tzdb)
 
-    set(NX_TZDB_ROMFS_DIR "${NX_TZDB_DIR}")
+    target_include_directories(nx_tzdb
+        INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include
+        INTERFACE ${NX_TZDB_INCLUDE_DIR})
+
+    set(NX_TZDB_BASE_DIR "${CPM_SOURCE_CACHE}/nx_tzdb")
+    set(NX_TZDB_TZ_DIR "${nx_tzdb_SOURCE_DIR}")
 endif()
 
 target_include_directories(nx_tzdb
@@ -78,25 +94,25 @@ function(CreateHeader ZONE_PATH HEADER_NAME)
     target_sources(nx_tzdb PRIVATE ${HEADER_PATH})
 endfunction()
 
-CreateHeader(${NX_TZDB_ROMFS_DIR} base)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo zoneinfo)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Africa africa)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/America america)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/America/Argentina america_argentina)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/America/Indiana america_indiana)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/America/Kentucky america_kentucky)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/America/North_Dakota america_north_dakota)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Antarctica antarctica)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Arctic arctic)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Asia asia)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Atlantic atlantic)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Australia australia)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Brazil brazil)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Canada canada)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Chile chile)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Etc etc)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Europe europe)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Indian indian)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Mexico mexico)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Pacific pacific)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/US us)
+CreateHeader(${NX_TZDB_BASE_DIR} base)
+CreateHeader(${NX_TZDB_TZ_DIR} zoneinfo)
+CreateHeader(${NX_TZDB_TZ_DIR}/Africa africa)
+CreateHeader(${NX_TZDB_TZ_DIR}/America america)
+CreateHeader(${NX_TZDB_TZ_DIR}/America/Argentina america_argentina)
+CreateHeader(${NX_TZDB_TZ_DIR}/America/Indiana america_indiana)
+CreateHeader(${NX_TZDB_TZ_DIR}/America/Kentucky america_kentucky)
+CreateHeader(${NX_TZDB_TZ_DIR}/America/North_Dakota america_north_dakota)
+CreateHeader(${NX_TZDB_TZ_DIR}/Antarctica antarctica)
+CreateHeader(${NX_TZDB_TZ_DIR}/Arctic arctic)
+CreateHeader(${NX_TZDB_TZ_DIR}/Asia asia)
+CreateHeader(${NX_TZDB_TZ_DIR}/Atlantic atlantic)
+CreateHeader(${NX_TZDB_TZ_DIR}/Australia australia)
+CreateHeader(${NX_TZDB_TZ_DIR}/Brazil brazil)
+CreateHeader(${NX_TZDB_TZ_DIR}/Canada canada)
+CreateHeader(${NX_TZDB_TZ_DIR}/Chile chile)
+CreateHeader(${NX_TZDB_TZ_DIR}/Etc etc)
+CreateHeader(${NX_TZDB_TZ_DIR}/Europe europe)
+CreateHeader(${NX_TZDB_TZ_DIR}/Indian indian)
+CreateHeader(${NX_TZDB_TZ_DIR}/Mexico mexico)
+CreateHeader(${NX_TZDB_TZ_DIR}/Pacific pacific)
+CreateHeader(${NX_TZDB_TZ_DIR}/US us)

externals/nx_tzdb/cpmfile.json

@@ -0,0 +1,8 @@
+{
+    "tzdb": {
+        "package": "nx_tzdb",
+        "url": "https://github.com/crueter/tzdb_to_nx/releases/download/250725/250725.zip",
+        "hash": "8f60b4b29f285e39c0443f3d5572a73780f3dbfcfd5b35004451fadad77f3a215b2e2aa8d0fffe7e348e2a7b0660882b35228b6178dda8804a14ce44509fd2ca",
+        "version": "250725"
+    }
+}

externals/simpleini/.github/workflows/build-and-test.yml

@@ -1,61 +0,0 @@
-name: Build and Test
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  Windows:
-    runs-on: windows-latest
-    steps:
-    - uses: actions/checkout@v3
-    - uses: microsoft/setup-msbuild@v2
-    - name: Build
-      run: |
-        nuget restore vcproj\SimpleIni.sln
-        msbuild vcproj\SimpleIni.sln /p:Configuration=Release
-    - name: Run tests
-      run: |
-        cd tests
-        ..\vcproj\x64\Release\tests.exe
-
-
-  Ubuntu:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Install requirements
-      run: sudo apt install libgtest-dev cmake
-    - uses: actions/checkout@v3
-    - run: make all && make test
-
-    - name: test with CMake (-DSIMPLEINI_USE_SYSTEM_GTEST=OFF)
-      run: |
-        cmake . -B build -DSIMPLEINI_USE_SYSTEM_GTEST=OFF
-        cmake --build build
-        ctest --verbose --test-dir build
-    - name: test with CMake (-DSIMPLEINI_USE_SYSTEM_GTEST=ON)
-      run: |
-        cmake . -B build-system-gtest -DSIMPLEINI_USE_SYSTEM_GTEST=ON
-        cmake --build build-system-gtest
-        ctest --verbose --test-dir build-system-gtest
-
-  MacOS:
-    runs-on: macos-latest
-    steps:
-    - name: Install requirements
-      run: brew install googletest cmake
-    - uses: actions/checkout@v3
-    - run: make all && make test
-
-    - name: test with CMake (-DSIMPLEINI_USE_SYSTEM_GTEST=OFF)
-      run: |
-        cmake . -B build -DSIMPLEINI_USE_SYSTEM_GTEST=OFF
-        cmake --build build
-        ctest --verbose --test-dir build
-    - name: test with CMake (-DSIMPLEINI_USE_SYSTEM_GTEST=ON)
-      run: |
-        cmake . -B build-system-gtest -DSIMPLEINI_USE_SYSTEM_GTEST=ON
-        cmake --build build-system-gtest
-        ctest --verbose --test-dir build-system-gtest

externals/simpleini/.github/workflows/build-doxygen.yml

@@ -1,24 +0,0 @@
-name: Build Doxygen Docs
-
-on:
-  workflow_run:
-    workflows: ["Build and Test"]
-    types:
-      - completed
-
-jobs:
-  deploy:
-    if: ${{ github.event.workflow_run.conclusion == 'success' }}
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout code
-      uses: actions/checkout@v2
-    - name: Install Doxygen
-      run: sudo apt-get update && sudo apt-get install -y doxygen graphviz
-    - name: Generate Doxygen Documentation
-      run: doxygen Doxyfile
-    - name: Deploy to GitHub Pages
-      uses: peaceiris/actions-gh-pages@v3
-      with:
-        github_token: ${{ secrets.GITHUB_TOKEN }}
-        publish_dir: ./docs/html

externals/simpleini/.github/workflows/codeql.yml

@@ -1,37 +0,0 @@
-name: "CodeQL"
-
-on: workflow_dispatch
-#on:
-#  push:
-#    branches: [ "master" ]
-#  pull_request:
-#    branches: [ "master" ]
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'cpp' ]
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v3
-
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
-      with:
-        languages: ${{ matrix.language }}
-
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v2
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2

externals/simpleini/.gitignore

@@ -1,365 +0,0 @@
-## Ignore Visual Studio temporary files, build results, and
-## files generated by popular Visual Studio add-ons.
-##
-## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
-
-docs
-
-
-# User-specific files
-*.rsuser
-*.suo
-*.user
-*.userosscache
-*.sln.docstates
-
-# User-specific files (MonoDevelop/Xamarin Studio)
-*.userprefs
-
-# Mono auto generated files
-mono_crash.*
-
-# Build results
-[Dd]ebug/
-[Dd]ebugPublic/
-[Rr]elease/
-[Rr]eleases/
-x64/
-x86/
-[Ww][Ii][Nn]32/
-[Aa][Rr][Mm]/
-[Aa][Rr][Mm]64/
-bld/
-[Bb]in/
-[Oo]bj/
-[Ll]og/
-[Ll]ogs/
-build/
-build-system-gtest/
-
-# Visual Studio 2015/2017 cache/options directory
-.vs/
-# Uncomment if you have tasks that create the project's static files in wwwroot
-#wwwroot/
-
-# Visual Studio 2017 auto generated files
-Generated\ Files/
-
-# MSTest test Results
-[Tt]est[Rr]esult*/
-[Bb]uild[Ll]og.*
-
-# NUnit
-*.VisualState.xml
-TestResult.xml
-nunit-*.xml
-
-# Build Results of an ATL Project
-[Dd]ebugPS/
-[Rr]eleasePS/
-dlldata.c
-
-# Benchmark Results
-BenchmarkDotNet.Artifacts/
-
-# .NET Core
-project.lock.json
-project.fragment.lock.json
-artifacts/
-
-# ASP.NET Scaffolding
-ScaffoldingReadMe.txt
-
-# StyleCop
-StyleCopReport.xml
-
-# Files built by Visual Studio
-*_i.c
-*_p.c
-*_h.h
-*.ilk
-*.meta
-*.obj
-*.iobj
-*.pch
-*.pdb
-*.ipdb
-*.pgc
-*.pgd
-*.rsp
-*.sbr
-*.tlb
-*.tli
-*.tlh
-*.tmp
-*.tmp_proj
-*_wpftmp.csproj
-*.log
-*.vspscc
-*.vssscc
-.builds
-*.pidb
-*.svclog
-*.scc
-
-# Chutzpah Test files
-_Chutzpah*
-
-# Visual C++ cache files
-ipch/
-*.aps
-*.ncb
-*.opendb
-*.opensdf
-*.sdf
-*.cachefile
-*.VC.db
-*.VC.VC.opendb
-
-# Visual Studio profiler
-*.psess
-*.vsp
-*.vspx
-*.sap
-
-# Visual Studio Trace Files
-*.e2e
-
-# TFS 2012 Local Workspace
-$tf/
-
-# Guidance Automation Toolkit
-*.gpState
-
-# ReSharper is a .NET coding add-in
-_ReSharper*/
-*.[Rr]e[Ss]harper
-*.DotSettings.user
-
-# TeamCity is a build add-in
-_TeamCity*
-
-# DotCover is a Code Coverage Tool
-*.dotCover
-
-# AxoCover is a Code Coverage Tool
-.axoCover/*
-!.axoCover/settings.json
-
-# Coverlet is a free, cross platform Code Coverage Tool
-coverage*[.json, .xml, .info]
-
-# Visual Studio code coverage results
-*.coverage
-*.coveragexml
-
-# NCrunch
-_NCrunch_*
-.*crunch*.local.xml
-nCrunchTemp_*
-
-# MightyMoose
-*.mm.*
-AutoTest.Net/
-
-# Web workbench (sass)
-.sass-cache/
-
-# Installshield output folder
-[Ee]xpress/
-
-# DocProject is a documentation generator add-in
-DocProject/buildhelp/
-DocProject/Help/*.HxT
-DocProject/Help/*.HxC
-DocProject/Help/*.hhc
-DocProject/Help/*.hhk
-DocProject/Help/*.hhp
-DocProject/Help/Html2
-DocProject/Help/html
-
-# Click-Once directory
-publish/
-
-# Publish Web Output
-*.[Pp]ublish.xml
-*.azurePubxml
-# Note: Comment the next line if you want to checkin your web deploy settings,
-# but database connection strings (with potential passwords) will be unencrypted
-*.pubxml
-*.publishproj
-
-# Microsoft Azure Web App publish settings. Comment the next line if you want to
-# checkin your Azure Web App publish settings, but sensitive information contained
-# in these scripts will be unencrypted
-PublishScripts/
-
-# NuGet Packages
-*.nupkg
-# NuGet Symbol Packages
-*.snupkg
-# The packages folder can be ignored because of Package Restore
-**/[Pp]ackages/*
-# except build/, which is used as an MSBuild target.
-!**/[Pp]ackages/build/
-# Uncomment if necessary however generally it will be regenerated when needed
-#!**/[Pp]ackages/repositories.config
-# NuGet v3's project.json files produces more ignorable files
-*.nuget.props
-*.nuget.targets
-
-# Microsoft Azure Build Output
-csx/
-*.build.csdef
-
-# Microsoft Azure Emulator
-ecf/
-rcf/
-
-# Windows Store app package directories and files
-AppPackages/
-BundleArtifacts/
-Package.StoreAssociation.xml
-_pkginfo.txt
-*.appx
-*.appxbundle
-*.appxupload
-
-# Visual Studio cache files
-# files ending in .cache can be ignored
-*.[Cc]ache
-# but keep track of directories ending in .cache
-!?*.[Cc]ache/
-
-# Others
-ClientBin/
-~$*
-*~
-*.dbmdl
-*.dbproj.schemaview
-*.jfm
-*.pfx
-*.publishsettings
-orleans.codegen.cs
-
-# Including strong name files can present a security risk
-# (https://github.com/github/gitignore/pull/2483#issue-259490424)
-#*.snk
-
-# Since there are multiple workflows, uncomment next line to ignore bower_components
-# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
-#bower_components/
-
-# RIA/Silverlight projects
-Generated_Code/
-
-# Backup & report files from converting an old project file
-# to a newer Visual Studio version. Backup files are not needed,
-# because we have git ;-)
-_UpgradeReport_Files/
-Backup*/
-UpgradeLog*.XML
-UpgradeLog*.htm
-ServiceFabricBackup/
-*.rptproj.bak
-
-# SQL Server files
-*.mdf
-*.ldf
-*.ndf
-
-# Business Intelligence projects
-*.rdl.data
-*.bim.layout
-*.bim_*.settings
-*.rptproj.rsuser
-*- [Bb]ackup.rdl
-*- [Bb]ackup ([0-9]).rdl
-*- [Bb]ackup ([0-9][0-9]).rdl
-
-# Microsoft Fakes
-FakesAssemblies/
-
-# GhostDoc plugin setting file
-*.GhostDoc.xml
-
-# Node.js Tools for Visual Studio
-.ntvs_analysis.dat
-node_modules/
-
-# Visual Studio 6 build log
-*.plg
-
-# Visual Studio 6 workspace options file
-*.opt
-
-# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
-*.vbw
-
-# Visual Studio LightSwitch build output
-**/*.HTMLClient/GeneratedArtifacts
-**/*.DesktopClient/GeneratedArtifacts
-**/*.DesktopClient/ModelManifest.xml
-**/*.Server/GeneratedArtifacts
-**/*.Server/ModelManifest.xml
-_Pvt_Extensions
-
-# Paket dependency manager
-.paket/paket.exe
-paket-files/
-
-# FAKE - F# Make
-.fake/
-
-# CodeRush personal settings
-.cr/personal
-
-# Python Tools for Visual Studio (PTVS)
-__pycache__/
-*.pyc
-
-# Cake - Uncomment if you are using it
-# tools/**
-# !tools/packages.config
-
-# Tabs Studio
-*.tss
-
-# Telerik's JustMock configuration file
-*.jmconfig
-
-# BizTalk build output
-*.btp.cs
-*.btm.cs
-*.odx.cs
-*.xsd.cs
-
-# OpenCover UI analysis results
-OpenCover/
-
-# Azure Stream Analytics local run output
-ASALocalRun/
-
-# MSBuild Binary and Structured Log
-*.binlog
-
-# NVidia Nsight GPU debugger configuration file
-*.nvuser
-
-# MFractors (Xamarin productivity tool) working folder
-.mfractor/
-
-# Local History for Visual Studio
-.localhistory/
-
-# BeatPulse healthcheck temp database
-healthchecksdb
-
-# Backup folder for Package Reference Convert tool in Visual Studio 2017
-MigrationBackup/
-
-# Ionide (cross platform F# VS Code tools) working folder
-.ionide/
-
-# Fody - auto-generated XML schema
-FodyWeavers.xsd

externals/simpleini/CMakeLists.txt

@@ -1,66 +0,0 @@
-cmake_minimum_required(VERSION 3.14)
-
-project(
-	SimpleIni
-	VERSION 4.22
-	DESCRIPTION "Cross-platform C++ library providing a simple API to read and write INI-style configuration files"
-	LANGUAGES CXX
-)
-
-option(SIMPLEINI_USE_SYSTEM_GTEST "Use system GoogleTest dependency" OFF)
-
-# disable in-source builds
-if(CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)
-	message(FATAL_ERROR "In-source builds are not allowed, use cmake -S . -B build.")
-endif()
-
-
-# Define library paths and include directories
-set(EXPORT_NAMESPACE "${PROJECT_NAME}::")
-set(HEADERS SimpleIni.h)
-
-add_library(${PROJECT_NAME} INTERFACE)
-add_library(${EXPORT_NAMESPACE}${PROJECT_NAME} ALIAS ${PROJECT_NAME})
-
-include(GNUInstallDirs)
-
-include(CMakePackageConfigHelpers)
-write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
-	VERSION ${PROJECT_VERSION}
-	COMPATIBILITY SameMajorVersion
-)
-configure_package_config_file(${PROJECT_NAME}Config.cmake.in
-	${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
-	INSTALL_DESTINATION ${CMAKE_INSTALL_DATADIR}/cmake/${PROJECT_NAME}
-)
-
-install(FILES SimpleIni.h
-	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
-)
-
-install(TARGETS ${PROJECT_NAME}
-	EXPORT ${PROJECT_NAME}Targets
-)
-
-install(FILES
-		${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
-		${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
-	DESTINATION ${CMAKE_INSTALL_DATADIR}/cmake/${PROJECT_NAME}
-)
-install(EXPORT ${PROJECT_NAME}Targets
-	DESTINATION ${CMAKE_INSTALL_DATADIR}/cmake/${PROJECT_NAME}
-	NAMESPACE ${EXPORT_NAMESPACE}
-)
-
-target_include_directories(${PROJECT_NAME} INTERFACE
-	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-	$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-)
-
-# only build tests when top level and testing enabled
-if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
-	include(CTest)
-	if(BUILD_TESTING)
-		add_subdirectory(tests)
-	endif()
-endif()

externals/simpleini/ConvertUTF.c

@@ -1,578 +0,0 @@
-/*
- * https://web.archive.org/web/20090529064329/http://www.unicode.org:80/Public/PROGRAMS/CVTUTF/
- *
- * Copyright 2001-2004 Unicode, Inc.
- *
- * Disclaimer
- *
- * This source code is provided as is by Unicode, Inc. No claims are
- * made as to fitness for any particular purpose. No warranties of any
- * kind are expressed or implied. The recipient agrees to determine
- * applicability of information provided. If this file has been
- * purchased on magnetic or optical media from Unicode, Inc., the
- * sole remedy for any claim will be exchange of defective media
- * within 90 days of receipt.
- *
- * Limitations on Rights to Redistribute This Code
- *
- * Unicode, Inc. hereby grants the right to freely use the information
- * supplied in this file in the creation of products supporting the
- * Unicode Standard, and to make copies of this file in any form
- * for internal or external distribution as long as this notice
- * remains attached.
- */
-
- /* ---------------------------------------------------------------------
-
-	 Conversions between UTF32, UTF-16, and UTF-8. Source code file.
-	 Author: Mark E. Davis, 1994.
-	 Rev History: Rick McGowan, fixes & updates May 2001.
-	 Sept 2001: fixed const & error conditions per
-	 mods suggested by S. Parent & A. Lillich.
-	 June 2002: Tim Dodd added detection and handling of incomplete
-	 source sequences, enhanced error detection, added casts
-	 to eliminate compiler warnings.
-	 July 2003: slight mods to back out aggressive FFFE detection.
-	 Jan 2004: updated switches in from-UTF8 conversions.
-	 Oct 2004: updated to use UNI_MAX_LEGAL_UTF32 in UTF-32 conversions.
-
-	 See the header file "ConvertUTF.h" for complete documentation.
-
- ------------------------------------------------------------------------ */
-
-
-#include "ConvertUTF.h"
-#ifdef CVTUTF_DEBUG
-#include <stdio.h>
-#endif
-
-static const int halfShift = 10; /* used for shifting by 10 bits */
-
-static const UTF32 halfBase = 0x0010000UL;
-static const UTF32 halfMask = 0x3FFUL;
-
-#define UNI_SUR_HIGH_START  (UTF32)0xD800
-#define UNI_SUR_HIGH_END    (UTF32)0xDBFF
-#define UNI_SUR_LOW_START   (UTF32)0xDC00
-#define UNI_SUR_LOW_END     (UTF32)0xDFFF
-#define false	   0
-#define true	    1
-
-/* --------------------------------------------------------------------- */
-
-ConversionResult ConvertUTF32toUTF16(
-	const UTF32** sourceStart, const UTF32* sourceEnd,
-	UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) {
-	ConversionResult result = conversionOK;
-	const UTF32* source = *sourceStart;
-	UTF16* target = *targetStart;
-	while (source < sourceEnd) {
-		UTF32 ch;
-		if (target >= targetEnd) {
-			result = targetExhausted; break;
-		}
-		ch = *source++;
-		if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
-			/* UTF-16 surrogate values are illegal in UTF-32; 0xffff or 0xfffe are both reserved values */
-			if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
-				if (flags == strictConversion) {
-					--source; /* return to the illegal value itself */
-					result = sourceIllegal;
-					break;
-				}
-				else {
-					*target++ = UNI_REPLACEMENT_CHAR;
-				}
-			}
-			else {
-				*target++ = (UTF16)ch; /* normal case */
-			}
-		}
-		else if (ch > UNI_MAX_LEGAL_UTF32) {
-			if (flags == strictConversion) {
-				result = sourceIllegal;
-			}
-			else {
-				*target++ = UNI_REPLACEMENT_CHAR;
-			}
-		}
-		else {
-			/* target is a character in range 0xFFFF - 0x10FFFF. */
-			if (target + 1 >= targetEnd) {
-				--source; /* Back up source pointer! */
-				result = targetExhausted; break;
-			}
-			ch -= halfBase;
-			*target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
-			*target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
-		}
-	}
-	*sourceStart = source;
-	*targetStart = target;
-	return result;
-}
-
-/* --------------------------------------------------------------------- */
-
-ConversionResult ConvertUTF16toUTF32(
-	const UTF16** sourceStart, const UTF16* sourceEnd,
-	UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) {
-	ConversionResult result = conversionOK;
-	const UTF16* source = *sourceStart;
-	UTF32* target = *targetStart;
-	UTF32 ch, ch2;
-	while (source < sourceEnd) {
-		const UTF16* oldSource = source; /*  In case we have to back up because of target overflow. */
-		ch = *source++;
-		/* If we have a surrogate pair, convert to UTF32 first. */
-		if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
-			/* If the 16 bits following the high surrogate are in the source buffer... */
-			if (source < sourceEnd) {
-				ch2 = *source;
-				/* If it's a low surrogate, convert to UTF32. */
-				if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
-					ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
-						+ (ch2 - UNI_SUR_LOW_START) + halfBase;
-					++source;
-				}
-				else if (flags == strictConversion) { /* it's an unpaired high surrogate */
-					--source; /* return to the illegal value itself */
-					result = sourceIllegal;
-					break;
-				}
-			}
-			else { /* We don't have the 16 bits following the high surrogate. */
-				--source; /* return to the high surrogate */
-				result = sourceExhausted;
-				break;
-			}
-		}
-		else if (flags == strictConversion) {
-			/* UTF-16 surrogate values are illegal in UTF-32 */
-			if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
-				--source; /* return to the illegal value itself */
-				result = sourceIllegal;
-				break;
-			}
-		}
-		if (target >= targetEnd) {
-			source = oldSource; /* Back up source pointer! */
-			result = targetExhausted; break;
-		}
-		*target++ = ch;
-	}
-	*sourceStart = source;
-	*targetStart = target;
-#ifdef CVTUTF_DEBUG
-	if (result == sourceIllegal) {
-		fprintf(stderr, "ConvertUTF16toUTF32 illegal seq 0x%04x,%04x\n", ch, ch2);
-		fflush(stderr);
-	}
-#endif
-	return result;
-}
-
-/* --------------------------------------------------------------------- */
-
-/*
- * Index into the table below with the first byte of a UTF-8 sequence to
- * get the number of trailing bytes that are supposed to follow it.
- * Note that *legal* UTF-8 values can't have 4 or 5-bytes. The table is
- * left as-is for anyone who may want to do such conversion, which was
- * allowed in earlier algorithms.
- */
-static const char trailingBytesForUTF8[256] = {
-	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-	2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
-};
-
-/*
- * Magic values subtracted from a buffer value during UTF8 conversion.
- * This table contains as many values as there might be trailing bytes
- * in a UTF-8 sequence.
- */
-static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL,
-			 0x03C82080UL, 0xFA082080UL, 0x82082080UL };
-
-/*
- * Once the bits are split out into bytes of UTF-8, this is a mask OR-ed
- * into the first byte, depending on how many bytes follow.  There are
- * as many entries in this table as there are UTF-8 sequence types.
- * (I.e., one byte sequence, two byte... etc.). Remember that sequencs
- * for *legal* UTF-8 will be 4 or fewer bytes total.
- */
-static const UTF8 firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
-
-/* --------------------------------------------------------------------- */
-
-/* The interface converts a whole buffer to avoid function-call overhead.
- * Constants have been gathered. Loops & conditionals have been removed as
- * much as possible for efficiency, in favor of drop-through switches.
- * (See "Note A" at the bottom of the file for equivalent code.)
- * If your compiler supports it, the "isLegalUTF8" call can be turned
- * into an inline function.
- */
-
- /* --------------------------------------------------------------------- */
-
-ConversionResult ConvertUTF16toUTF8(
-	const UTF16** sourceStart, const UTF16* sourceEnd,
-	UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
-	ConversionResult result = conversionOK;
-	const UTF16* source = *sourceStart;
-	UTF8* target = *targetStart;
-	while (source < sourceEnd) {
-		UTF32 ch;
-		unsigned short bytesToWrite = 0;
-		const UTF32 byteMask = 0xBF;
-		const UTF32 byteMark = 0x80;
-		const UTF16* oldSource = source; /* In case we have to back up because of target overflow. */
-		ch = *source++;
-		/* If we have a surrogate pair, convert to UTF32 first. */
-		if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
-			/* If the 16 bits following the high surrogate are in the source buffer... */
-			if (source < sourceEnd) {
-				UTF32 ch2 = *source;
-				/* If it's a low surrogate, convert to UTF32. */
-				if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
-					ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
-						+ (ch2 - UNI_SUR_LOW_START) + halfBase;
-					++source;
-				}
-				else if (flags == strictConversion) { /* it's an unpaired high surrogate */
-					--source; /* return to the illegal value itself */
-					result = sourceIllegal;
-					break;
-				}
-			}
-			else { /* We don't have the 16 bits following the high surrogate. */
-				--source; /* return to the high surrogate */
-				result = sourceExhausted;
-				break;
-			}
-		}
-		else if (flags == strictConversion) {
-			/* UTF-16 surrogate values are illegal in UTF-32 */
-			if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
-				--source; /* return to the illegal value itself */
-				result = sourceIllegal;
-				break;
-			}
-		}
-		/* Figure out how many bytes the result will require */
-		if (ch < (UTF32)0x80) {
-			bytesToWrite = 1;
-		}
-		else if (ch < (UTF32)0x800) {
-			bytesToWrite = 2;
-		}
-		else if (ch < (UTF32)0x10000) {
-			bytesToWrite = 3;
-		}
-		else if (ch < (UTF32)0x110000) {
-			bytesToWrite = 4;
-		}
-		else {
-			bytesToWrite = 3;
-			ch = UNI_REPLACEMENT_CHAR;
-		}
-
-		target += bytesToWrite;
-		if (target > targetEnd) {
-			source = oldSource; /* Back up source pointer! */
-			target -= bytesToWrite; result = targetExhausted; break;
-		}
-		switch (bytesToWrite) { /* note: everything falls through. */
-		case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
-		case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
-		case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
-		case 1: *--target = (UTF8)(ch | firstByteMark[bytesToWrite]);
-		}
-		target += bytesToWrite;
-	}
-	*sourceStart = source;
-	*targetStart = target;
-	return result;
-}
-
-/* --------------------------------------------------------------------- */
-
-/*
- * Utility routine to tell whether a sequence of bytes is legal UTF-8.
- * This must be called with the length pre-determined by the first byte.
- * If not calling this from ConvertUTF8to*, then the length can be set by:
- *  length = trailingBytesForUTF8[*source]+1;
- * and the sequence is illegal right away if there aren't that many bytes
- * available.
- * If presented with a length > 4, this returns false.  The Unicode
- * definition of UTF-8 goes up to 4-byte sequences.
- */
-
-static Boolean isLegalUTF8(const UTF8* source, int length) {
-	UTF8 a;
-	const UTF8* srcptr = source + length;
-	switch (length) {
-	default: return false;
-		/* Everything else falls through when "true"... */
-	case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
-	case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
-	case 2: if ((a = (*--srcptr)) > 0xBF) return false;
-
-		switch (*source) {
-			/* no fall-through in this inner switch */
-		case 0xE0: if (a < 0xA0) return false; break;
-		case 0xED: if (a > 0x9F) return false; break;
-		case 0xF0: if (a < 0x90) return false; break;
-		case 0xF4: if (a > 0x8F) return false; break;
-		default:   if (a < 0x80) return false;
-		}
-
-	case 1: if (*source >= 0x80 && *source < 0xC2) return false;
-	}
-	if (*source > 0xF4) return false;
-	return true;
-}
-
-/* --------------------------------------------------------------------- */
-
-/*
- * Exported function to return whether a UTF-8 sequence is legal or not.
- * This is not used here; it's just exported.
- */
-Boolean isLegalUTF8Sequence(const UTF8* source, const UTF8* sourceEnd) {
-	int length = trailingBytesForUTF8[*source] + 1;
-	if (source + length > sourceEnd) {
-		return false;
-	}
-	return isLegalUTF8(source, length);
-}
-
-/* --------------------------------------------------------------------- */
-
-ConversionResult ConvertUTF8toUTF16(
-	const UTF8** sourceStart, const UTF8* sourceEnd,
-	UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) {
-	ConversionResult result = conversionOK;
-	const UTF8* source = *sourceStart;
-	UTF16* target = *targetStart;
-	while (source < sourceEnd) {
-		UTF32 ch = 0;
-		unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
-		if (source + extraBytesToRead >= sourceEnd) {
-			result = sourceExhausted; break;
-		}
-		/* Do this check whether lenient or strict */
-		if (!isLegalUTF8(source, extraBytesToRead + 1)) {
-			result = sourceIllegal;
-			break;
-		}
-		/*
-		 * The cases all fall through. See "Note A" below.
-		 */
-		switch (extraBytesToRead) {
-		case 5: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */
-		case 4: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */
-		case 3: ch += *source++; ch <<= 6;
-		case 2: ch += *source++; ch <<= 6;
-		case 1: ch += *source++; ch <<= 6;
-		case 0: ch += *source++;
-		}
-		ch -= offsetsFromUTF8[extraBytesToRead];
-
-		if (target >= targetEnd) {
-			source -= (extraBytesToRead + 1); /* Back up source pointer! */
-			result = targetExhausted; break;
-		}
-		if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
-			/* UTF-16 surrogate values are illegal in UTF-32 */
-			if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
-				if (flags == strictConversion) {
-					source -= (extraBytesToRead + 1); /* return to the illegal value itself */
-					result = sourceIllegal;
-					break;
-				}
-				else {
-					*target++ = UNI_REPLACEMENT_CHAR;
-				}
-			}
-			else {
-				*target++ = (UTF16)ch; /* normal case */
-			}
-		}
-		else if (ch > UNI_MAX_UTF16) {
-			if (flags == strictConversion) {
-				result = sourceIllegal;
-				source -= (extraBytesToRead + 1); /* return to the start */
-				break; /* Bail out; shouldn't continue */
-			}
-			else {
-				*target++ = UNI_REPLACEMENT_CHAR;
-			}
-		}
-		else {
-			/* target is a character in range 0xFFFF - 0x10FFFF. */
-			if (target + 1 >= targetEnd) {
-				source -= (extraBytesToRead + 1); /* Back up source pointer! */
-				result = targetExhausted; break;
-			}
-			ch -= halfBase;
-			*target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
-			*target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
-		}
-	}
-	*sourceStart = source;
-	*targetStart = target;
-	return result;
-}
-
-/* --------------------------------------------------------------------- */
-
-ConversionResult ConvertUTF32toUTF8(
-	const UTF32** sourceStart, const UTF32* sourceEnd,
-	UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
-	ConversionResult result = conversionOK;
-	const UTF32* source = *sourceStart;
-	UTF8* target = *targetStart;
-	while (source < sourceEnd) {
-		UTF32 ch;
-		unsigned short bytesToWrite = 0;
-		const UTF32 byteMask = 0xBF;
-		const UTF32 byteMark = 0x80;
-		ch = *source++;
-		if (flags == strictConversion) {
-			/* UTF-16 surrogate values are illegal in UTF-32 */
-			if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
-				--source; /* return to the illegal value itself */
-				result = sourceIllegal;
-				break;
-			}
-		}
-		/*
-		 * Figure out how many bytes the result will require. Turn any
-		 * illegally large UTF32 things (> Plane 17) into replacement chars.
-		 */
-		if (ch < (UTF32)0x80) {
-			bytesToWrite = 1;
-		}
-		else if (ch < (UTF32)0x800) {
-			bytesToWrite = 2;
-		}
-		else if (ch < (UTF32)0x10000) {
-			bytesToWrite = 3;
-		}
-		else if (ch <= UNI_MAX_LEGAL_UTF32) {
-			bytesToWrite = 4;
-		}
-		else {
-			bytesToWrite = 3;
-			ch = UNI_REPLACEMENT_CHAR;
-			result = sourceIllegal;
-		}
-
-		target += bytesToWrite;
-		if (target > targetEnd) {
-			--source; /* Back up source pointer! */
-			target -= bytesToWrite; result = targetExhausted; break;
-		}
-		switch (bytesToWrite) { /* note: everything falls through. */
-		case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
-		case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
-		case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
-		case 1: *--target = (UTF8)(ch | firstByteMark[bytesToWrite]);
-		}
-		target += bytesToWrite;
-	}
-	*sourceStart = source;
-	*targetStart = target;
-	return result;
-}
-
-/* --------------------------------------------------------------------- */
-
-ConversionResult ConvertUTF8toUTF32(
-	const UTF8** sourceStart, const UTF8* sourceEnd,
-	UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) {
-	ConversionResult result = conversionOK;
-	const UTF8* source = *sourceStart;
-	UTF32* target = *targetStart;
-	while (source < sourceEnd) {
-		UTF32 ch = 0;
-		unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
-		if (source + extraBytesToRead >= sourceEnd) {
-			result = sourceExhausted; break;
-		}
-		/* Do this check whether lenient or strict */
-		if (!isLegalUTF8(source, extraBytesToRead + 1)) {
-			result = sourceIllegal;
-			break;
-		}
-		/*
-		 * The cases all fall through. See "Note A" below.
-		 */
-		switch (extraBytesToRead) {
-		case 5: ch += *source++; ch <<= 6;
-		case 4: ch += *source++; ch <<= 6;
-		case 3: ch += *source++; ch <<= 6;
-		case 2: ch += *source++; ch <<= 6;
-		case 1: ch += *source++; ch <<= 6;
-		case 0: ch += *source++;
-		}
-		ch -= offsetsFromUTF8[extraBytesToRead];
-
-		if (target >= targetEnd) {
-			source -= (extraBytesToRead + 1); /* Back up the source pointer! */
-			result = targetExhausted; break;
-		}
-		if (ch <= UNI_MAX_LEGAL_UTF32) {
-			/*
-			 * UTF-16 surrogate values are illegal in UTF-32, and anything
-			 * over Plane 17 (> 0x10FFFF) is illegal.
-			 */
-			if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
-				if (flags == strictConversion) {
-					source -= (extraBytesToRead + 1); /* return to the illegal value itself */
-					result = sourceIllegal;
-					break;
-				}
-				else {
-					*target++ = UNI_REPLACEMENT_CHAR;
-				}
-			}
-			else {
-				*target++ = ch;
-			}
-		}
-		else { /* i.e., ch > UNI_MAX_LEGAL_UTF32 */
-			result = sourceIllegal;
-			*target++ = UNI_REPLACEMENT_CHAR;
-		}
-	}
-	*sourceStart = source;
-	*targetStart = target;
-	return result;
-}
-
-/* ---------------------------------------------------------------------
-
-	Note A.
-	The fall-through switches in UTF-8 reading code save a
-	temp variable, some decrements & conditionals.  The switches
-	are equivalent to the following loop:
-	{
-		int tmpBytesToRead = extraBytesToRead+1;
-		do {
-		ch += *source++;
-		--tmpBytesToRead;
-		if (tmpBytesToRead) ch <<= 6;
-		} while (tmpBytesToRead > 0);
-	}
-	In UTF-8 writing code, the switches on "bytesToWrite" are
-	similarly unrolled loops.
-
-   --------------------------------------------------------------------- */

externals/simpleini/ConvertUTF.h

@@ -1,151 +0,0 @@
-/*
- * https://web.archive.org/web/20090529064329/http://www.unicode.org:80/Public/PROGRAMS/CVTUTF/
- *
- * Copyright 2001-2004 Unicode, Inc.
- *
- * Disclaimer
- *
- * This source code is provided as is by Unicode, Inc. No claims are
- * made as to fitness for any particular purpose. No warranties of any
- * kind are expressed or implied. The recipient agrees to determine
- * applicability of information provided. If this file has been
- * purchased on magnetic or optical media from Unicode, Inc., the
- * sole remedy for any claim will be exchange of defective media
- * within 90 days of receipt.
- *
- * Limitations on Rights to Redistribute This Code
- *
- * Unicode, Inc. hereby grants the right to freely use the information
- * supplied in this file in the creation of products supporting the
- * Unicode Standard, and to make copies of this file in any form
- * for internal or external distribution as long as this notice
- * remains attached.
- */
-
- /* ---------------------------------------------------------------------
-
-     Conversions between UTF32, UTF-16, and UTF-8.  Header file.
-
-     Several funtions are included here, forming a complete set of
-     conversions between the three formats.  UTF-7 is not included
-     here, but is handled in a separate source file.
-
-     Each of these routines takes pointers to input buffers and output
-     buffers.  The input buffers are const.
-
-     Each routine converts the text between *sourceStart and sourceEnd,
-     putting the result into the buffer between *targetStart and
-     targetEnd. Note: the end pointers are *after* the last item: e.g.
-     *(sourceEnd - 1) is the last item.
-
-     The return result indicates whether the conversion was successful,
-     and if not, whether the problem was in the source or target buffers.
-     (Only the first encountered problem is indicated.)
-
-     After the conversion, *sourceStart and *targetStart are both
-     updated to point to the end of last text successfully converted in
-     the respective buffers.
-
-     Input parameters:
-     sourceStart - pointer to a pointer to the source buffer.
-         The contents of this are modified on return so that
-         it points at the next thing to be converted.
-     targetStart - similarly, pointer to pointer to the target buffer.
-     sourceEnd, targetEnd - respectively pointers to the ends of the
-         two buffers, for overflow checking only.
-
-     These conversion functions take a ConversionFlags argument. When this
-     flag is set to strict, both irregular sequences and isolated surrogates
-     will cause an error.  When the flag is set to lenient, both irregular
-     sequences and isolated surrogates are converted.
-
-     Whether the flag is strict or lenient, all illegal sequences will cause
-     an error return. This includes sequences such as: <F4 90 80 80>, <C0 80>,
-     or <A0> in UTF-8, and values above 0x10FFFF in UTF-32. Conformant code
-     must check for illegal sequences.
-
-     When the flag is set to lenient, characters over 0x10FFFF are converted
-     to the replacement character; otherwise (when the flag is set to strict)
-     they constitute an error.
-
-     Output parameters:
-     The value "sourceIllegal" is returned from some routines if the input
-     sequence is malformed.  When "sourceIllegal" is returned, the source
-     value will point to the illegal value that caused the problem. E.g.,
-     in UTF-8 when a sequence is malformed, it points to the start of the
-     malformed sequence.
-
-     Author: Mark E. Davis, 1994.
-     Rev History: Rick McGowan, fixes & updates May 2001.
-          Fixes & updates, Sept 2001.
-
- ------------------------------------------------------------------------ */
-
- /* ---------------------------------------------------------------------
-     The following 4 definitions are compiler-specific.
-     The C standard does not guarantee that wchar_t has at least
-     16 bits, so wchar_t is no less portable than unsigned short!
-     All should be unsigned values to avoid sign extension during
-     bit mask & shift operations.
- ------------------------------------------------------------------------ */
-
-typedef unsigned long	UTF32;	/* at least 32 bits */
-typedef unsigned short	UTF16;	/* at least 16 bits */
-typedef unsigned char	UTF8;	/* typically 8 bits */
-typedef unsigned char	Boolean; /* 0 or 1 */
-
-/* Some fundamental constants */
-#define UNI_REPLACEMENT_CHAR (UTF32)0x0000FFFD
-#define UNI_MAX_BMP (UTF32)0x0000FFFF
-#define UNI_MAX_UTF16 (UTF32)0x0010FFFF
-#define UNI_MAX_UTF32 (UTF32)0x7FFFFFFF
-#define UNI_MAX_LEGAL_UTF32 (UTF32)0x0010FFFF
-
-typedef enum {
-    conversionOK, 		/* conversion successful */
-    sourceExhausted,	/* partial character in source, but hit end */
-    targetExhausted,	/* insuff. room in target for conversion */
-    sourceIllegal		/* source sequence is illegal/malformed */
-} ConversionResult;
-
-typedef enum {
-    strictConversion = 0,
-    lenientConversion
-} ConversionFlags;
-
-/* This is for C++ and does no harm in C */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-    ConversionResult ConvertUTF8toUTF16(
-        const UTF8** sourceStart, const UTF8* sourceEnd,
-        UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
-
-    ConversionResult ConvertUTF16toUTF8(
-        const UTF16** sourceStart, const UTF16* sourceEnd,
-        UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
-
-    ConversionResult ConvertUTF8toUTF32(
-        const UTF8** sourceStart, const UTF8* sourceEnd,
-        UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
-
-    ConversionResult ConvertUTF32toUTF8(
-        const UTF32** sourceStart, const UTF32* sourceEnd,
-        UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
-
-    ConversionResult ConvertUTF16toUTF32(
-        const UTF16** sourceStart, const UTF16* sourceEnd,
-        UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
-
-    ConversionResult ConvertUTF32toUTF16(
-        const UTF32** sourceStart, const UTF32* sourceEnd,
-        UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
-
-    Boolean isLegalUTF8Sequence(const UTF8* source, const UTF8* sourceEnd);
-
-#ifdef __cplusplus
-}
-#endif
-
-/* --------------------------------------------------------------------- */

externals/simpleini/ConvertUTF_readme.txt

@@ -1,43 +0,0 @@
-https://web.archive.org/web/20090529064329/http://www.unicode.org:80/Public/PROGRAMS/CVTUTF/
-
-The accompanying C source code file "ConvertUTF.c" and the associated header
-file "ConvertUTF.h" provide for conversion between various transformation
-formats of Unicode characters.  The following conversions are supported:
-
-	UTF-32 to UTF-16
-	UTF-32 to UTF-8
-	UTF-16 to UTF-32
-	UTF-16 to UTF-8
-	UTF-8 to UTF-16
-	UTF-8 to UTF-32
-
-In addition, there is a test harness which runs various tests.
-
-The files "CVTUTF7.C" and "CVTUTF7.H" are for archival and historical purposes
-only. They have not been updated to Unicode 3.0 or later and should be
-considered obsolescent. "CVTUTF7.C" contains two functions that can convert
-between UCS2 (i.e., the BMP characters only) and UTF-7. Surrogates are
-not supported, the code has not been tested, and should be considered
-unsuitable for general purpose use.
-
-Please submit any bug reports about these programs here:
-
-	http://www.unicode.org/unicode/reporting.html
-
-Version 1.0: initial version.
-
-Version 1.1: corrected some minor problems; added stricter checks.
-
-Version 1.2: corrected switch statements associated with "extraBytesToRead"
-	in 4 & 5 byte cases, in functions for conversion from UTF8.
-	Note: formally, the 4 & 5 byte cases are illegal in the latest
-	UTF8, but the table and this code has always catered for those,
-	cases since at one time they were legal.
-
-Version 1.3: Updated UTF-8 legality check;
-	updated to use UNI_MAX_LEGAL_UTF32 in UTF-32 conversions
-	Updated UTF-8 legality tests in harness.c
- 
-
-Last update: October 19, 2004
-

externals/simpleini/LICENCE.txt

@@ -1,20 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2006-2024 Brodie Thiesfield
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

externals/simpleini/Makefile

@@ -1,18 +0,0 @@
-# This makefile is just to build the automatic test harness
-# To use SimpleIni, just include SimpleIni.h header file 
-
-PREFIX?=	/usr/local
-
-TOPTARGETS := all clean test
-
-SUBDIRS := tests
-
-$(TOPTARGETS): $(SUBDIRS)
-$(SUBDIRS):
-	$(MAKE) -C $@ $(MAKECMDGOALS)
-
-.PHONY: $(TOPTARGETS) $(SUBDIRS)
-
-install:
-	mkdir -p $(DESTDIR)$(PREFIX)/include/
-	install -C -m 644 SimpleIni.h $(DESTDIR)$(PREFIX)/include/

externals/simpleini/README.md

@@ -1,199 +0,0 @@
-simpleini
-=========
-
-![Latest Test Results](https://github.com/brofield/simpleini/actions/workflows/build-and-test.yml/badge.svg)
- 
-A cross-platform library that provides a simple API to read and write INI-style configuration files. It supports data files in ASCII, MBCS and Unicode. It is designed explicitly to be portable to any platform and has been tested on Windows, WinCE and Linux. Released as open-source and free using the MIT licence.
-
-[Full documentation](https://brofield.github.io/simpleini/)
-
-# Feature Summary
-
-- MIT Licence allows free use in all software (including GPL and commercial)
-- multi-platform: Windows (from 95 to 11, CE), Linux, MacOS
-- loading and saving of INI-style configuration files
-- configuration files can have any newline format on all platforms
-- liberal acceptance of file format
-  * key/values with no section, keys with no value
-  * removal of whitespace around sections, keys and values
-- support for multi-line values (values with embedded newline characters)
-- optional support for multiple keys with the same name
-- optional case-insensitive sections and keys (for ASCII characters only)
-- saves files with sections and keys in the same order as they were loaded
-- preserves comments on the file, section and keys where possible
-- supports both char or wchar_t programming interfaces
-- supports both MBCS (system locale) and UTF-8 file encodings
-- supports ICU as conversion library on all platforms
-- system locale does not need to be UTF-8 on Linux/Unix to load UTF-8 file
-- support for non-ASCII characters in section, keys, values and comments
-- support for non-standard character types or file encodings via user-written converter classes
-- support for adding/modifying values programmatically
-- should compile with no warnings in most compilers
-
-# Documentation
-
-Full documentation of the interface is available in doxygen format. See [latest documentation here](https://brofield.github.io/simpleini/).
-
-# Examples
-
-These snippets are included with the distribution in the automatic tests as ts-snippets.cpp.
-
-### SIMPLE USAGE
-
-```c++
-	// simple demonstration
-
-	CSimpleIniA ini;
-	ini.SetUnicode();
-
-	SI_Error rc = ini.LoadFile("example.ini");
-	if (rc < 0) { /* handle error */ };
-	ASSERT_EQ(rc, SI_OK);
-
-	const char* pv;
-	pv = ini.GetValue("section", "key", "default");
-	ASSERT_STREQ(pv, "value");
-
-	ini.SetValue("section", "key", "newvalue");
-
-	pv = ini.GetValue("section", "key", "default");
-	ASSERT_STREQ(pv, "newvalue");
-```
-
-### LOADING DATA
-
-```c++
-	// load from a data file
-	CSimpleIniA ini;
-	SI_Error rc = ini.LoadFile("example.ini");
-	if (rc < 0) { /* handle error */ };
-	ASSERT_EQ(rc, SI_OK);
-
-	// load from a string
-	const std::string example = "[section]\nkey = value\n";
-	CSimpleIniA ini;
-	SI_Error rc = ini.LoadData(example);
-	if (rc < 0) { /* handle error */ };
-	ASSERT_EQ(rc, SI_OK);
-```
-
-### GETTING SECTIONS AND KEYS
-
-```c++
-	// get all sections
-	CSimpleIniA::TNamesDepend sections;
-	ini.GetAllSections(sections);
-
-	// get all keys in a section
-	CSimpleIniA::TNamesDepend keys;
-	ini.GetAllKeys("section1", keys);
-```
-
-### GETTING VALUES
-
-```c++
-	// get the value of a key that doesn't exist
-	const char* pv;
-	pv = ini.GetValue("section1", "key99");
-	ASSERT_EQ(pv, nullptr);
-
-	// get the value of a key that does exist
-	pv = ini.GetValue("section1", "key1");
-	ASSERT_STREQ(pv, "value1");
-
-	// get the value of a key which may have multiple 
-	// values. If hasMultiple is true, then there are
-	// multiple values and just one value has been returned
-	bool hasMulti;
-	pv = ini.GetValue("section1", "key1", nullptr, &hasMulti);
-	ASSERT_STREQ(pv, "value1");
-	ASSERT_EQ(hasMulti, false);
-
-	pv = ini.GetValue("section1", "key2", nullptr, &hasMulti);
-	ASSERT_STREQ(pv, "value2.1");
-	ASSERT_EQ(hasMulti, true);
-
-	// get all values of a key with multiple values
-	CSimpleIniA::TNamesDepend values;
-	ini.GetAllValues("section1", "key2", values);
-
-	// sort the values into a known order, in this case we want
-	// the original load order
-	values.sort(CSimpleIniA::Entry::LoadOrder());
-
-	// output all of the items
-	CSimpleIniA::TNamesDepend::const_iterator it;
-	for (it = values.begin(); it != values.end(); ++it) {
-		printf("value = '%s'\n", it->pItem);
-	}
-```
-
-### MODIFYING DATA
-
-```c++
-	// add a new section 
-	rc = ini.SetValue("section1", nullptr, nullptr);
-	if (rc < 0) { /* handle error */ };
-	ASSERT_EQ(rc, SI_INSERTED); 
-
-	// not an error to add one that already exists
-	rc = ini.SetValue("section1", nullptr, nullptr);
-	if (rc < 0) { /* handle error */ };
-	ASSERT_EQ(rc, SI_UPDATED);
-
-	// get the value of a key that doesn't exist
-	const char* pv;
-	pv = ini.GetValue("section2", "key1", "default-value");
-	ASSERT_STREQ(pv, "default-value");
-
-	// adding a key (the section will be added if needed)
-	rc = ini.SetValue("section2", "key1", "value1");
-	if (rc < 0) { /* handle error */ };
-	ASSERT_EQ(rc, SI_INSERTED);
-
-	// ensure it is set to expected value
-	pv = ini.GetValue("section2", "key1", nullptr);
-	ASSERT_STREQ(pv, "value1");
-
-	// change the value of a key
-	rc = ini.SetValue("section2", "key1", "value2");
-	if (rc < 0) { /* handle error */ };
-	ASSERT_EQ(rc, SI_UPDATED);
-
-	// ensure it is set to expected value
-	pv = ini.GetValue("section2", "key1", nullptr);
-	ASSERT_STREQ(pv, "value2");
-```
-
-### DELETING DATA
-
-```c++
-	// deleting a key from a section. Optionally the entire
-	// section may be deleted if it is now empty.
-	bool done, deleteSectionIfEmpty = true;
-	done = ini.Delete("section1", "key1", deleteSectionIfEmpty);
-	ASSERT_EQ(done, true);
-	done = ini.Delete("section1", "key1");
-	ASSERT_EQ(done, false);
-
-	// deleting an entire section and all keys in it
-	done = ini.Delete("section2", nullptr);
-	ASSERT_EQ(done, true);
-	done = ini.Delete("section2", nullptr);
-	ASSERT_EQ(done, false);
-```
-
-### SAVING DATA
-
-```c++
-	// save the data to a string
-	std::string data;
-	rc = ini.Save(data);
-	if (rc < 0) { /* handle error */ };
-	ASSERT_EQ(rc, SI_OK);
-
-	// save the data back to the file
-	rc = ini.SaveFile("example2.ini");
-	if (rc < 0) { /* handle error */ };
-	ASSERT_EQ(rc, SI_OK);
-```

externals/simpleini/SimpleIniConfig.cmake.in

@@ -1,8 +0,0 @@
-@PACKAGE_INIT@
-
-# prevent repeatedly including the targets
-if(NOT TARGET @PROJECT_NAME@::@PROJECT_NAME@)
-    include(${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake)
-endif()
-
-message(STATUS "Found @PROJECT_NAME@, version: ${@PROJECT_NAME@_VERSION}")

externals/simpleini/other/package.cmd

@@ -1,26 +0,0 @@
-set VERSION=4.15
-
-set SEVENZIP="C:\Program Files\7-Zip\7z.exe"
-
-FOR /F "tokens=*" %%G IN ('DIR /AD /B /S Debug*') DO (
-    DEL /S /Q "%%G"
-    RD "%%G"
-)
-FOR /F "tokens=*" %%G IN ('DIR /AD /B /S Release*') DO (
-    DEL /S /Q "%%G"
-    RD "%%G"
-)
-DEL /Q "SimpleIni.ncb"
-ATTRIB -H "SimpleIni.suo"
-DEL /Q "SimpleIni.suo"
-DEL /Q "SimpleIni.opt"
-DEL /Q testsi-out*.ini
-DEL /Q test1-blah.ini
-DEL /Q test1-output.ini
-START "Generate documentation" /WAIT "C:\Program Files (x86)\doxygen\bin\doxygen.exe" SimpleIni.doxy
-cd ..
-del simpleini-%VERSION%.zip
-%SEVENZIP% a -tzip -r- -x!simpleini\.svn simpleini-%VERSION%.zip simpleini\*
-del simpleini-doc.zip
-%SEVENZIP% a -tzip -r simpleini-doc.zip simpleini-doc\*
-cd simpleini

externals/simpleini/release.txt

@@ -1,6 +0,0 @@
-Making a release:
-* update version number in SimpleIni.h
-* update version number in CMakeLists.txt
-* check-in all files
-* make a release "v4.22" etc creating a matching tag
-

externals/simpleini/tests/.gitignore

@@ -1,5 +0,0 @@
-example2.ini
-
-tests
-*.o
-

externals/simpleini/tests/CMakeLists.txt

@@ -1,30 +0,0 @@
-if(SIMPLEINI_USE_SYSTEM_GTEST)
-	find_package(GTest REQUIRED)
-else()
-	include(FetchContent)
-	FetchContent_Declare(
-		googletest
-		DOWNLOAD_EXTRACT_TIMESTAMP ON
-		URL https://github.com/google/googletest/archive/refs/tags/v1.14.0.zip
-		URL_HASH SHA1=0ac421f2ec11af38b0fff0f1992184032731a8bc
-		)
-	FetchContent_MakeAvailable(googletest)
-endif()
-
-add_executable(tests
-	ts-bugfix.cpp
-	ts-noconvert.cpp
-	ts-quotes.cpp
-	ts-roundtrip.cpp
-	ts-snippets.cpp
-	ts-utf8.cpp)
-
-add_test(NAME tests COMMAND tests)
-target_link_libraries(tests PRIVATE ${PROJECT_NAME} GTest::gtest_main)
-
-add_custom_command(
-	TARGET tests POST_BUILD
-	COMMAND ${CMAKE_COMMAND} -E copy
-		${CMAKE_CURRENT_SOURCE_DIR}/example.ini
-		${CMAKE_CURRENT_SOURCE_DIR}/tests.ini
-		${CMAKE_CURRENT_BINARY_DIR})

externals/simpleini/tests/Makefile

@@ -1,21 +0,0 @@
-CXX?=g++
-CXXFLAGS+=-Wall -std=c++14 `pkg-config --cflags gtest_main`
-LDFLAGS+=`pkg-config --libs gtest_main`
-
-OBJS=ts-roundtrip.o ts-snippets.o ts-utf8.o ts-bugfix.o ts-quotes.o ts-noconvert.o
-
-BIN=./tests
-
-all: $(BIN)
-
-$(BIN): $(OBJS)
-	$(CXX) -o $(BIN) $(OBJS) $(LDFLAGS)
-
-clean:
-	rm -f core $(OBJS) $(BIN)
-
-test: $(BIN)
-	$(BIN)
-
-$(OBJS): ../SimpleIni.h
-

externals/simpleini/tests/example.ini

@@ -1,2 +0,0 @@
-[section]
-key = value

externals/simpleini/tests/old/test.cmd

@@ -1,24 +0,0 @@
-@echo off
-
-Debug\testsi.exe -u -m -l test1-input.ini > test1-blah.ini
-fc test1-expected.ini test1-output.ini
-if errorlevel 1 goto error
-
-"Debug Unicode\testsi.exe" -u -m -l test1-input.ini > test1-blah.ini
-fc test1-expected.ini test1-output.ini
-if errorlevel 1 goto error
-
-Release\testsi.exe -u -m -l test1-input.ini > test1-blah.ini
-fc test1-expected.ini test1-output.ini
-if errorlevel 1 goto error
-
-"Release Unicode\testsi.exe" -u -m -l test1-input.ini > test1-blah.ini
-fc test1-expected.ini test1-output.ini
-if errorlevel 1 goto error
-
-exit /b 0
-
-:error
-echo Failed during test run. Output file doesn't match expected file.
-pause
-exit /b 1

externals/simpleini/tests/old/test1-expected.ini

@@ -1,85 +0,0 @@
-; testsi-UTF8-std.ini : standard UTF-8 test file for SimpleIni automated testing
-;
-; The number after a section or key is the order that it is defined in this file
-; to make it easier to see if it has been written out correctly. This file should
-; be loaded with Unicode / MultiKey / MultiLine turned on.
-
-
-
-; This comment should be joined on to the one below it about the key
-; with no section.
-
-; Key with no section
-lonely-key = nosection
-another = nosection either
-
-; This key has no value
-empty = 
-
-
-; This should be joined with the comment below about japanese.
-; Another line which will be un-indented. 
-
-; This is a section of keys showing the word Japanese in different syllabies.
-[ordered-1]
-a-1 = blah
-
-; this is in kanji
-japanese-2 = 日本語
-
-; this is in hiragana
-japanese-3 = にほんご
-
-; this is in katakana
-japanese-4 = ニホンゴ
-
-; this is in romaji
-japanese-5 = nihongo
-
-; kanji as the key
-日本語-6 = japanese
-
-
-[multi-2]
-
-; value a
-test = a
-
-; value b
-test = b
-
-; value c
-test = c
-
-; value d
-test = d
-
-
-[multiline-3]
-
-; This is obviously a multi-line entry
-multiline-1 = <<<END_OF_TEXT
-
-This is a multi-line comment. It
-will continue until we have the word MULTI
-on a line by itself.
-
-日本語も。
-
-END_OF_TEXT
-
-; This looks like multi-line, but because the newline following the last
-; line is discarded, it will be converted into a single line entry.
-another-2 = This is not a multiline entry.
-
-; If you wanted a multiline entry with a single line, you need to add 
-; an extra line to it.
-another-3 = <<<END_OF_TEXT
-This is a multiline entry.
-
-END_OF_TEXT
-
-
-[integer]
-dec = 42
-hex = 0x2a

externals/simpleini/tests/old/test1-input.ini

@@ -1,76 +0,0 @@
-; testsi-UTF8-std.ini : standard UTF-8 test file for SimpleIni automated testing
-;
-; The number after a section or key is the order that it is defined in this file
-; to make it easier to see if it has been written out correctly. This file should
-; be loaded with Unicode / MultiKey / MultiLine turned on.
-
-; This comment should be joined on to the one below it about the key
-; with no section.
-  
-; Key with no section
-lonely-key = nosection
-another = nosection either
-
-; This key has no value
-empty = 
-
-; This should be joined with the comment below about japanese.
-   ; Another line which will be un-indented. 
-   
-; This is a section of keys showing the word Japanese in different syllabies.
-[ordered-1]
-a-1 = blah
-
-; this is in kanji
-japanese-2 = 日本語
-
-; this is in hiragana
-japanese-3 = にほんご
-
-; this is in katakana
-japanese-4 = ニホンゴ
-
-; this is in romaji
-japanese-5 = nihongo
-
-; kanji as the key
-日本語-6 = japanese
-
-[multi-2]
-; value a
-test = a
-; value b
-test = b
-; value c
-test = c
-; value d
-test = d
-
-[multiline-3]
-; This is obviously a multi-line entry
-multiline-1 = <<<MULTI
-
-This is a multi-line comment. It
-will continue until we have the word MULTI
-on a line by itself.
-
-日本語も。
-
-MULTI
-
-; This looks like multi-line, but because the newline following the last
-; line is discarded, it will be converted into a single line entry.
-another-2 = <<<MULTI
-This is not a multiline entry.
-MULTI
-
-; If you wanted a multiline entry with a single line, you need to add 
-; an extra line to it.
-another-3 = <<<MULTI
-This is a multiline entry.
-
-MULTI
-
-[integer]
-dec = 42
-hex = 0x2a

externals/simpleini/tests/old/test1.cpp

@@ -1,166 +0,0 @@
-// File:    test1.cpp
-// Library: SimpleIni
-// Author:  Brodie Thiesfield <code@jellycan.com>
-// Source:  http://code.jellycan.com/simpleini/
-//
-// Automated testing for SimpleIni streams
-
-#ifdef _WIN32
-# pragma warning(disable: 4786)
-#endif
-
-#ifdef _WIN32
-# include <windows.h>
-# define DELETE_FILE DeleteFileA
-#else
-# include <unistd.h>
-# define DELETE_FILE unlink
-#endif
-#include <fstream>
-
-#define SI_SUPPORT_IOSTREAMS
-#include "SimpleIni.h"
-
-class Test
-{
-    std::string m_strTest;
-
-public:
-    Test(const char * a_pszName)
-        : m_strTest(a_pszName)
-    {
-        printf("%s: test starting\n", m_strTest.c_str());
-    }
-
-    bool Success()
-    {
-        printf("%s: test succeeded\n", m_strTest.c_str());
-        return false;
-    }
-
-    bool Failure(const char * pszReason)
-    {
-        printf("%s: test FAILED (%s)\n", m_strTest.c_str(), pszReason);
-        return false;
-    }
-};
-
-bool FileComparisonTest(const char * a_pszFile1, const char * a_pszFile2) {
-    // ensure that the two files are the same
-    try {
-        std::string strFile1, strFile2;
-
-        char szBuf[1024];
-        FILE * fp = NULL;
-
-#if __STDC_WANT_SECURE_LIB__
-		fopen_s(&fp, a_pszFile1, "rb");
-#else
-		fp = fopen(a_pszFile1, "rb");
-#endif
-        if (!fp) throw false;
-        while (!feof(fp)) {
-            size_t n = fread(szBuf, 1, sizeof(szBuf), fp);
-            strFile1.append(szBuf, n);
-        }
-        fclose(fp);
-
-		fp = NULL;
-#if __STDC_WANT_SECURE_LIB__
-		fopen_s(&fp, a_pszFile2, "rb");
-#else
-		fp = fopen(a_pszFile2, "rb");
-#endif
-        if (!fp) throw false;
-        while (!feof(fp)) {
-            size_t n = fread(szBuf, 1, sizeof(szBuf), fp);
-            strFile2.append(szBuf, n);
-        }
-        fclose(fp);
-
-        if (strFile1 != strFile2) throw false;
-    }
-    catch (...) {
-        return false;
-    }
-
-    return true;
-}
-
-bool FileLoadTest(const char * a_pszFile1, const char * a_pszFile2) {
-    // ensure that the two files load into simpleini the same
-    CSimpleIniA ini(true, true, true);
-    bool b;
-    try {
-        ini.Reset();
-        if (ini.LoadFile(a_pszFile1) < 0) throw "Load failed for file 1";
-        if (ini.SaveFile("test1.ini") < 0) throw "Save failed for file 1";
-
-        ini.Reset();
-        if (ini.LoadFile(a_pszFile2) < 0) throw "Load failed for file 2";
-        if (ini.SaveFile("test2.ini") < 0) throw "Save failed for file 2";
-
-        b = FileComparisonTest("test1.ini", "test2.ini");
-        DELETE_FILE("test1.ini");
-        DELETE_FILE("test2.ini");
-        if (!b) throw "File comparison failed in FileLoadTest";
-    }
-    catch (...) {
-        return false;
-    }
-
-    return true;
-}
-
-bool TestStreams()
-{
-    const char * rgszTestFile[3] = {
-        "test1-input.ini",
-        "test1-output.ini",
-        "test1-expected.ini"
-    };
-
-    Test oTest("TestStreams");
-
-    CSimpleIniW ini;
-    ini.SetUnicode(true);
-    ini.SetMultiKey(true);
-    ini.SetMultiLine(true);
-
-    // load the file
-    try {
-        std::ifstream instream;
-        instream.open(rgszTestFile[0], std::ifstream::in | std::ifstream::binary);
-        if (ini.LoadData(instream) < 0) throw false;
-        instream.close();
-    }
-    catch (...) {
-        return oTest.Failure("Failed to load file");
-    }
-
-    // standard contents test
-    //if (!StandardContentsTest(ini, oTest)) {
-    //    return false;
-    //}
-
-    // save the file
-    try {
-        std::ofstream outfile;
-        outfile.open(rgszTestFile[1], std::ofstream::out | std::ofstream::binary);
-        if (ini.Save(outfile, true) < 0) throw false;
-        outfile.close();
-    }
-    catch (...) {
-        return oTest.Failure("Failed to save file");
-    }
-
-    // file comparison test
-    if (!FileComparisonTest(rgszTestFile[1], rgszTestFile[2])) {
-        return oTest.Failure("Failed file comparison");
-    }
-    if (!FileLoadTest(rgszTestFile[1], rgszTestFile[2])) {
-        return oTest.Failure("Failed file load comparison");
-    }
-
-    return oTest.Success();
-}

externals/simpleini/tests/old/testsi-EUCJP.ini

@@ -1,52 +0,0 @@
-; test file for SimpleIni
-
-nosection=ok
-NOSECTION=still ok
-  whitespace  =  ok
-  
-[standard]
-foo=foo1
-standard-1=foo
-日本語=ok1
-
-[Standard]
-Foo=foo2
-standard-2=foo
-日本語=ok2
-
- [  Whitespace  ]
-    
-a=  
-
-[  whitespace in section name  ]
-  whitespace   in   key name    =     whitespace in value   name     
-  
-; comments
-  ; more  comments
-  
-invalid
-=invalid
-====invalid
-
-[Japanese]
-nihongo = 日本語
-日本語  = 日本語
-
-[日本語]
-nihongo = 日本語
-日本語  = 日本語
-
-[]
-more=no section name
-
-
-
-[MultiLine]
-single = This is a single line.
-multi  = <<<MULTI
-
-This is a multi-line value. It continues until the MULTI tag is found 
-on a line by itself with no whitespace before or after it. This value 
-will be returned to the user with all newlines and whitespace.
-
-MULTI

externals/simpleini/tests/old/testsi-SJIS.ini

@@ -1,51 +0,0 @@
-; test file for SimpleIni
-
-nosection=ok
-NOSECTION=still ok
-  whitespace  =  ok
-  
-[standard]
-foo=foo1
-standard-1=foo
-日本語=ok1
-
-[Standard]
-Foo=foo2
-standard-2=foo
-日本語=ok2
-
- [  Whitespace  ]
-    
-a=  
-
-[  whitespace in section name  ]
-  whitespace   in   key name    =     whitespace in value   name     
-  
-; comments
-  ; more  comments
-  
-invalid
-=invalid
-====invalid
-
-[Japanese]
-nihongo = 日本語
-日本語  = 日本語
-
-[日本語]
-nihongo = 日本語
-日本語  = 日本語
-
-[]
-more=no section name
-
-
-[MultiLine]
-single = This is a single line.
-multi  = <<<MULTI
-
-This is a multi-line value. It continues until the MULTI tag is found 
-on a line by itself with no whitespace before or after it. This value 
-will be returned to the user with all newlines and whitespace.
-
-MULTI