.ci/cmake/toolchains/aarch64-w64-mingw32.cmake

@@ -0,0 +1,14 @@
+SET(CMAKE_SYSTEM_NAME "Windows")
+SET(CMAKE_SYSTEM_PROCESSOR "ARM64")
+if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
+    set(CMAKE_CROSSCOMPILING OFF CACHE BOOL "")
+endif()
+
+set(_WZ_MINGW_TRIPLET_PREFIX "aarch64")
+
+find_program(CMAKE_C_COMPILER "${_WZ_MINGW_TRIPLET_PREFIX}-w64-mingw32-gcc")
+find_program(CMAKE_CXX_COMPILER "${_WZ_MINGW_TRIPLET_PREFIX}-w64-mingw32-g++")
+find_program(CMAKE_RC_COMPILER "${_WZ_MINGW_TRIPLET_PREFIX}-w64-mingw32-windres")
+if(NOT CMAKE_RC_COMPILER)
+    find_program(CMAKE_RC_COMPILER "windres")
+endif()

.ci/cmake/toolchains/i686-w64-mingw32.cmake

@@ -0,0 +1,14 @@
+SET(CMAKE_SYSTEM_NAME "Windows")
+SET(CMAKE_SYSTEM_PROCESSOR "X86")
+if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
+    set(CMAKE_CROSSCOMPILING OFF CACHE BOOL "")
+endif()
+
+set(_WZ_MINGW_TRIPLET_PREFIX "i686")
+
+find_program(CMAKE_C_COMPILER "${_WZ_MINGW_TRIPLET_PREFIX}-w64-mingw32-gcc")
+find_program(CMAKE_CXX_COMPILER "${_WZ_MINGW_TRIPLET_PREFIX}-w64-mingw32-g++")
+find_program(CMAKE_RC_COMPILER "${_WZ_MINGW_TRIPLET_PREFIX}-w64-mingw32-windres")
+if(NOT CMAKE_RC_COMPILER)
+    find_program(CMAKE_RC_COMPILER "windres")
+endif()

.ci/cmake/toolchains/m32-cross-linux.cmake

@@ -0,0 +1,25 @@
+# Toolchain for cross-compiling i686 (32-bit) on 64-bit Linux
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR "i686")
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m32" CACHE STRING "C compiler flags" FORCE)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m32" CACHE STRING "C++ compiler flags" FORCE)
+
+set(LIB32 "/usr/lib") # Fedora
+
+set(CMAKE_FIND_ROOT_PATH "${LIB32}" CACHE STRING "Find root path" FORCE)
+
+#set(CMAKE_LIBRARY_PATH "${LIB32}" CACHE STRING "Library search path" FORCE)
+
+set(CMAKE_EXE_LINKER_FLAGS "-m32 -L${LIB32}" CACHE STRING "Executable linker flags" FORCE)
+set(CMAKE_SHARED_LINKER_FLAGS "-m32 -L${LIB32}" CACHE STRING "Shared library linker flags" FORCE)
+set(CMAKE_MODULE_LINKER_FLAGS "-m32 -L${LIB32}" CACHE STRING "Module linker flags" FORCE)
+
+# Point pkgconfig at 32-bit .pc files first, falling back to regular system .pc files
+if(EXISTS "${LIB32}/pkgconfig")
+	set(ENV{PKG_CONFIG_LIBDIR} "${LIB32}/pkgconfig:/usr/share/pkgconfig:/usr/lib/pkgconfig:/usr/lib64/pkgconfig")
+endif()
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE BOTH)

.ci/cmake/toolchains/wasm32-emscripten.cmake

@@ -0,0 +1,33 @@
+# Toolchain for compiling for Emscripten
+
+# Note:
+# This is a bit of a hack.
+# We actually want to use the Emscripten.cmake toolchain provided by Emscripten...
+# However we also want to override and enable pthreads for everything
+
+if(NOT DEFINED ENV{EMSCRIPTEN_ROOT})
+   find_path(EMSCRIPTEN_ROOT "emcc")
+else()
+   set(EMSCRIPTEN_ROOT "$ENV{EMSCRIPTEN_ROOT}")
+endif()
+
+if(NOT EMSCRIPTEN_ROOT)
+   if(NOT DEFINED ENV{EMSDK})
+      message(FATAL_ERROR "The emcc compiler not found in PATH")
+   endif()
+   set(EMSCRIPTEN_ROOT "$ENV{EMSDK}/upstream/emscripten")
+endif()
+
+if(NOT EXISTS "${EMSCRIPTEN_ROOT}/cmake/Modules/Platform/Emscripten.cmake")
+   message(FATAL_ERROR "Emscripten.cmake toolchain file not found")
+endif()
+
+include("${EMSCRIPTEN_ROOT}/cmake/Modules/Platform/Emscripten.cmake")
+
+# Always enable PThreads
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -s USE_PTHREADS=1 -s USE_SDL=0")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -s USE_PTHREADS=1 -s USE_SDL=0")
+
+# Enable optimizations for release builds
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O2")
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O2")

.ci/cmake/toolchains/x86_64-w64-mingw32.cmake

@@ -0,0 +1,14 @@
+SET(CMAKE_SYSTEM_NAME "Windows")
+SET(CMAKE_SYSTEM_PROCESSOR "AMD64")
+if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
+    set(CMAKE_CROSSCOMPILING OFF CACHE BOOL "")
+endif()
+
+set(_WZ_MINGW_TRIPLET_PREFIX "x86_64")
+
+find_program(CMAKE_C_COMPILER "${_WZ_MINGW_TRIPLET_PREFIX}-w64-mingw32-gcc")
+find_program(CMAKE_CXX_COMPILER "${_WZ_MINGW_TRIPLET_PREFIX}-w64-mingw32-g++")
+find_program(CMAKE_RC_COMPILER "${_WZ_MINGW_TRIPLET_PREFIX}-w64-mingw32-windres")
+if(NOT CMAKE_RC_COMPILER)
+    find_program(CMAKE_RC_COMPILER "windres")
+endif()

.ci/flatpak/Toolchain-cross-arch.cmake.in

@@ -0,0 +1,24 @@
+# Toolchain for cross-compiling
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR "@WZ_CROSS_COMPILE_TARGET_ARCH@")
+
+# Specify the cross compiler
+set(CMAKE_C_COMPILER "@WZ_CROSS_COMPILE_TARGET_ARCH@-unknown-linux-gnu-gcc")
+set(CMAKE_CXX_COMPILER "@WZ_CROSS_COMPILE_TARGET_ARCH@-unknown-linux-gnu-g++")
+
+# Target search paths
+set(CMAKE_FIND_ROOT_PATH "/app;/usr/lib/@WZ_CROSS_COMPILE_TARGET_ARCH@-linux-gnu;/usr/include/@WZ_CROSS_COMPILE_TARGET_ARCH@-linux-gnu" CACHE STRING "Find root path" FORCE)
+
+# Search for programs in the build host directories
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+
+# Search for libraries and headers in the target directories
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE BOTH)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+
+# Point pkgconfig at target arch .pc files first, falling back to regular system .pc files
+if(EXISTS "/usr/lib/@WZ_CROSS_COMPILE_TARGET_ARCH@-linux-gnu/pkgconfig")
+	set(ENV{PKG_CONFIG_LIBDIR} "/usr/lib/@WZ_CROSS_COMPILE_TARGET_ARCH@-linux-gnu/pkgconfig")
+endif()

.ci/flatpak/build.sh

@@ -0,0 +1,108 @@
+#!/bin/bash
+# This requires a bunch of environment variables to be set. See the CI workflow
+
+USE_BUILDER_FLATPAK=true
+
+if [ "${USE_BUILDER_FLATPAK}" = true ]; then
+  FLATPAK_BUILDER_CMD="flatpak run --filesystem=/tmp org.flatpak.Builder"
+  FLATPAK_CMD="flatpak run --filesystem=/tmp --command=flatpak org.flatpak.Builder"
+  OSTREE_CMD="flatpak run --filesystem=/tmp --command=ostree org.flatpak.Builder"
+  APPSTREAMCLI_CMD="flatpak run --filesystem=/tmp --command=appstreamcli org.flatpak.Builder"
+else
+  FLATPAK_BUILDER_CMD="flatpak-builder"
+  FLATPAK_CMD="flatpak"
+  OSTREE_CMD="ostree"
+  APPSTREAMCLI_CMD="appstreamcli"
+fi
+
+echo "::group::flatpak-builder --version"
+${FLATPAK_BUILDER_CMD} --version
+echo "::endgroup::"
+echo "::group::flatpak --version"
+${FLATPAK_CMD} --version
+echo "::endgroup::"
+echo "::group::ostree --version"
+${OSTREE_CMD} --version
+echo "::endgroup::"
+echo "::group::appstreamcli --version"
+${APPSTREAMCLI_CMD} --version
+echo "::endgroup::"
+
+echo "::group::flatpak-builder"
+${FLATPAK_BUILDER_CMD} --repo=${WZ_FLATPAK_LOCAL_REPO_NAME} --disable-rofiles-fuse --force-clean --default-branch=${WZ_FLATPAK_BRANCH} --mirror-screenshots-url=${WZ_FLATPAK_MIRROR_SCREENSHOTS_URL} "${WZ_FLATPAK_BUILD_DIR}" ${WZ_FLATPAK_MANIFEST_PATH}
+echo "::endgroup::"
+
+if [[ "$WZ_FLATPAK_TARGET_ARCH" != "$WZ_FLATPAK_BUILD_ARCH" ]]; then
+  SRC_LOCAL_REPO_NAME="${WZ_FLATPAK_LOCAL_REPO_NAME}"
+
+  # Create a new repository containing the commits for the cross target arch
+  echo "::group::Creating new local repo for target arch: ${WZ_FLATPAK_LOCAL_REPO_NAME}"
+  WZ_FLATPAK_LOCAL_REPO_NAME="${WZ_FLATPAK_TARGET_ARCH}-repo"
+  ${OSTREE_CMD} init --mode archive-z2 --repo=${WZ_FLATPAK_LOCAL_REPO_NAME}
+  echo "::endgroup::"
+
+  echo "::group::Rename commits to new target arch repo"
+  for i in app/${WZ_FLATPAK_APPID} \
+           runtime/${WZ_FLATPAK_APPID}.Debug
+  do
+     # Rename the commits to target arch
+     echo "Processing: --src-ref=${i}/${WZ_FLATPAK_BUILD_ARCH}/${WZ_FLATPAK_BRANCH}"
+     ${FLATPAK_CMD} build-commit-from --src-ref=${i}/${WZ_FLATPAK_BUILD_ARCH}/${WZ_FLATPAK_BRANCH} --src-repo=${SRC_LOCAL_REPO_NAME} \
+        ${WZ_FLATPAK_LOCAL_REPO_NAME} ${i}/${WZ_FLATPAK_TARGET_ARCH}/${WZ_FLATPAK_BRANCH}
+  done
+  echo "::endgroup::"
+fi
+
+echo "::group::flatpak build-bundle"
+${FLATPAK_CMD} build-bundle --arch=${WZ_FLATPAK_TARGET_ARCH} ${WZ_FLATPAK_LOCAL_REPO_NAME} "${WZ_FLATPAK_BUNDLE}" --runtime-repo=https://flathub.org/repo/flathub.flatpakrepo ${WZ_FLATPAK_APPID} ${WZ_FLATPAK_BRANCH}
+echo "::endgroup::"
+
+echo "Generated .flatpak: \"${WZ_FLATPAK_BUNDLE}\""
+echo "  -> SHA512: $(sha512sum "${WZ_FLATPAK_BUNDLE}")"
+echo "  -> Size (bytes): $(stat -c %s "${WZ_FLATPAK_BUNDLE}")"
+
+WZ_FLATPAK_BUILD_PATH="${WZ_FLATPAK_BUILD_DIR}/files/share"
+
+WZ_FLATPAK_APPSTREAM_PATH="${WZ_FLATPAK_BUILD_PATH}/metainfo/${WZ_FLATPAK_APPID}.metainfo.xml"
+if [ ! -f "${WZ_FLATPAK_APPSTREAM_PATH}" ]; then
+  # try the old path?
+  WZ_FLATPAK_APPSTREAM_PATH="${WZ_FLATPAK_BUILD_PATH}/appdata/${WZ_FLATPAK_APPID}.appdata.xml"
+fi
+
+if [ -f "${WZ_FLATPAK_APPSTREAM_PATH}" ]; then
+  echo "::group::Validating appstream"
+  echo "appstreamcli validate ${WZ_FLATPAK_APPSTREAM_PATH}"
+  ${APPSTREAMCLI_CMD} validate "${WZ_FLATPAK_APPSTREAM_PATH}"
+  echo "::endgroup::"
+else
+  echo "::warning ::Could not find appstream file to validate?"
+fi
+
+echo "::group::Verify icon and metadata in app-info"
+test -f "${WZ_FLATPAK_BUILD_PATH}/app-info/icons/flatpak/128x128/${WZ_FLATPAK_APPID}.png" || { echo "Missing 128x128 icon in app-info" ; exit 1; }
+test -f "${WZ_FLATPAK_BUILD_PATH}/app-info/xmls/${WZ_FLATPAK_APPID}.xml.gz" || { echo "Missing ${WZ_FLATPAK_APPID}.xml.gz in app-info" ; exit 1; }
+echo "::endgroup::"
+
+echo "::group::Check screenshots"
+if [ ! -d "${WZ_FLATPAK_BUILD_PATH}/app-info/media" ]; then
+  echo "::notice ::Screenshots not mirrored by flatpak-builder?"
+else
+  echo "Found screenshots:"
+  find "${WZ_FLATPAK_BUILD_PATH}/app-info/media" -type f
+fi
+echo "::endgroup::"
+
+echo "::group::Commit screenshots to the OSTree repository --branch=screenshots/${WZ_FLATPAK_TARGET_ARCH}"
+if [ -d "${WZ_FLATPAK_BUILD_PATH}/app-info/media" ]; then
+  ${OSTREE_CMD} commit --repo=${WZ_FLATPAK_LOCAL_REPO_NAME} --canonical-permissions --branch=screenshots/${WZ_FLATPAK_TARGET_ARCH} "${WZ_FLATPAK_BUILD_PATH}/app-info/media"
+else
+  echo "::warning ::Screenshots not added to OSTree repository"
+fi
+echo "::endgroup::"
+
+# Output final WZ_FLATPAK_LOCAL_REPO_NAME in GitHub Actions
+if [ "${GITHUB_ACTIONS}" == "true" ]; then
+  echo "Running on GitHub Actions - outputting final WZ_FLATPAK_LOCAL_REPO_NAME"
+  echo "WZ_FLATPAK_LOCAL_REPO_NAME=${WZ_FLATPAK_LOCAL_REPO_NAME}"
+  echo "WZ_FLATPAK_LOCAL_REPO_NAME=${WZ_FLATPAK_LOCAL_REPO_NAME}" >> $GITHUB_OUTPUT
+fi

.ci/flatpak/generate_flatpak_config.cmake

@@ -0,0 +1,148 @@
+cmake_minimum_required(VERSION 3.5...3.24)
+
+# Automatically generate a Flatpak manifest from the template file
+#
+# Required input defines:
+# - TEMPLATE_FILE: the full filename + path for the input net.wz2100.wz2100.yaml.in template file
+# - OUTPUT_FILE: the full filename + path for the output net.wz2100.wz2100.yaml file
+# - PROJECT_ROOT: the path the project root (${PROJECT_SOURCE_DIR})
+#
+# And also, these input defines:
+# - WZ_OUTPUT_NAME_SUFFIX: The desired suffix to apply to the app id in the manifest (should match the main build)
+#
+# If cross-compiling, specify:
+# - WZ_CROSS_COMPILE_TARGET_ARCH: <aarch64, etc>
+#
+
+if(NOT DEFINED TEMPLATE_FILE OR "${TEMPLATE_FILE}" STREQUAL "")
+	message( FATAL_ERROR "Missing required input define: TEMPLATE_FILE" )
+endif()
+if(NOT DEFINED OUTPUT_FILE OR "${OUTPUT_FILE}" STREQUAL "")
+	message( FATAL_ERROR "Missing required input define: OUTPUT_FILE" )
+endif()
+if(NOT DEFINED PROJECT_ROOT OR "${PROJECT_ROOT}" STREQUAL "")
+	message( FATAL_ERROR "Missing required input define: PROJECT_ROOT" )
+endif()
+
+if(NOT DEFINED WZ_OUTPUT_NAME_SUFFIX)
+	message( FATAL_ERROR "Missing expected input define: WZ_OUTPUT_NAME_SUFFIX" )
+endif()
+if (DEFINED WZ_CROSS_COMPILE_TARGET_ARCH)
+	message( STATUS "WZ_CROSS_COMPILE_TARGET_ARCH detected - configuring for cross-compile to: ${WZ_CROSS_COMPILE_TARGET_ARCH}" )
+endif()
+
+get_filename_component(_input_dir "${TEMPLATE_FILE}" DIRECTORY)
+get_filename_component(_output_dir "${OUTPUT_FILE}" DIRECTORY)
+
+##################################
+# Handling cross-compilation
+
+if (DEFINED WZ_CROSS_COMPILE_TARGET_ARCH)
+
+	if (NOT WZ_CROSS_COMPILE_TARGET_ARCH MATCHES "^(aarch64)$") # update when new target arch is needed, ensure the anchor is defined in net.wz2100.wz2100.yaml.in
+		message( FATAL_ERROR "Target arch is not yet supported in the template: ${WZ_CROSS_COMPILE_TARGET_ARCH}" )
+	endif()
+
+	# Runtime target arch suffix
+	set(WZ_RUNTIME_SUFFIX "/${WZ_CROSS_COMPILE_TARGET_ARCH}")
+
+	# SDK extensions
+	set(WZ_CROSS_COMPILE_SDK_EXTENSIONS "sdk-extensions:\n\
+# We need to ensure the toolchain is available\n\
+- org.freedesktop.Sdk.Extension.toolchain-${WZ_CROSS_COMPILE_TARGET_ARCH}\n\
+# As well as the target SDK\n\
+- org.freedesktop.Sdk.Compat.${WZ_CROSS_COMPILE_TARGET_ARCH}\n")
+
+	# Cross files setup module
+	set(WZ_CROSS_FILES_SETUP "- name: cross-files-setup\n\
+    buildsystem: simple\n\
+    cleanup:\n\
+      - '*'\n\
+    build-commands:\n\
+      - mkdir -p /app/etc/wz-config/\n\
+      - install -Dm644 Toolchain-cross-arch.cmake /app/etc/wz-config/Toolchain-cross-arch.cmake\n\
+      - install -Dm644 meson-cross-file.txt /app/etc/wz-config/meson-cross-file.txt\n\
+    sources:\n\
+      - type: file\n\
+        path: ../../.ci/flatpak/Toolchain-cross-arch.cmake\n\
+      - type: file\n\
+        path: ../../.ci/flatpak/meson-cross-file.txt\n\
+")
+
+	# Configure CMake cross-compile toolchain
+	configure_file("${_input_dir}/Toolchain-cross-arch.cmake.in" "${_output_dir}/Toolchain-cross-arch.cmake" @ONLY)
+	set(WZ_CMAKE_CROSS_CONFIG_OPTIONS "- -DCMAKE_TOOLCHAIN_FILE=/app/etc/wz-config/Toolchain-cross-arch.cmake")
+
+	# Construct simple meson cross-compile file
+	configure_file("${_input_dir}/meson-cross-file.txt.in" "${_output_dir}/meson-cross-file.txt" @ONLY)
+	set(WZ_MESON_CROSS_CONFIG_OPTIONS "- --cross-file=/app/etc/wz-config/meson-cross-file.txt")
+
+	# Autotools just requires a config option
+	set(WZ_AUTOTOOLS_CROSS_CONFIG_OPTIONS "- --host=${WZ_CROSS_COMPILE_TARGET_ARCH}-unknown-linux-gnu")
+
+	# Set the build-options anchor tag
+	set(WZ_CROSS_BUILD_OPTIONS "build-options: *compat-${WZ_CROSS_COMPILE_TARGET_ARCH}-build-options")
+
+else()
+	unset(WZ_RUNTIME_SUFFIX)
+	unset(WZ_CROSS_COMPILE_SDK_EXTENSIONS)
+	unset(WZ_CROSS_FILES_SETUP)
+	set(WZ_CMAKE_CROSS_CONFIG_OPTIONS "# No cross build options")
+	set(WZ_MESON_CROSS_CONFIG_OPTIONS "# No cross build options")
+	set(WZ_AUTOTOOLS_CROSS_CONFIG_OPTIONS "# No cross build options")
+	set(WZ_CROSS_BUILD_OPTIONS "# No cross build options")
+endif()
+
+##################################
+# Handle sentry-native
+
+# Get the source URL AND SHA512 from a data file
+set(_sentry_dl_data_file "${PROJECT_ROOT}/.sentrynative")
+file(STRINGS "${_sentry_dl_data_file}" _sentry_native_url_info ENCODING UTF-8)
+while(_sentry_native_url_info)
+	list(POP_FRONT _sentry_native_url_info LINE)
+	if (LINE MATCHES "^URL=(.*)")
+		set(WZ_SENTRY_NATIVE_URL "${CMAKE_MATCH_1}")
+	endif()
+	if (LINE MATCHES "^SHA512=(.*)")
+		set(WZ_SENTRY_NATIVE_SHA512 "${CMAKE_MATCH_1}")
+	endif()
+endwhile()
+unset(_sentry_native_url_info)
+if(NOT DEFINED WZ_SENTRY_NATIVE_URL OR NOT DEFINED WZ_SENTRY_NATIVE_SHA512)
+	message(FATAL_ERROR "Failed to load URL and hash from: ${_sentry_dl_data_file}")
+endif()
+unset(_sentry_dl_data_file)
+
+##################################
+# Handle prebuilt-texture-packages
+
+include("${PROJECT_ROOT}/data/WZPrebuiltPackages.cmake")
+
+##################################
+# Debug output
+
+execute_process(COMMAND ${CMAKE_COMMAND} -E echo "++TEMPLATE_FILE: ${TEMPLATE_FILE}")
+execute_process(COMMAND ${CMAKE_COMMAND} -E echo "++OUTPUT_FILE: ${OUTPUT_FILE}")
+
+execute_process(COMMAND ${CMAKE_COMMAND} -E echo "++WZ_OUTPUT_NAME_SUFFIX: ${WZ_OUTPUT_NAME_SUFFIX}")
+if (DEFINED WZ_CROSS_COMPILE_TARGET_ARCH)
+	execute_process(COMMAND ${CMAKE_COMMAND} -E echo "++WZ_CROSS_COMPILE_TARGET_ARCH: ${WZ_CROSS_COMPILE_TARGET_ARCH}")
+	execute_process(COMMAND ${CMAKE_COMMAND} -E echo "++WZ_CROSS_COMPILE_SDK_EXTENSIONS: ${WZ_CROSS_COMPILE_SDK_EXTENSIONS}")
+	execute_process(COMMAND ${CMAKE_COMMAND} -E echo "++WZ_CMAKE_CROSS_CONFIG_OPTIONS: ${WZ_CMAKE_CROSS_CONFIG_OPTIONS}")
+	execute_process(COMMAND ${CMAKE_COMMAND} -E echo "++WZ_MESON_CROSS_CONFIG_OPTIONS: ${WZ_MESON_CROSS_CONFIG_OPTIONS}")
+	execute_process(COMMAND ${CMAKE_COMMAND} -E echo "++WZ_AUTOTOOLS_CROSS_CONFIG_OPTIONS: ${WZ_AUTOTOOLS_CROSS_CONFIG_OPTIONS}")
+	execute_process(COMMAND ${CMAKE_COMMAND} -E echo "++WZ_CROSS_BUILD_OPTIONS: ${WZ_CROSS_BUILD_OPTIONS}")
+endif()
+
+execute_process(COMMAND ${CMAKE_COMMAND} -E echo "++WZ_SENTRY_NATIVE_URL: ${WZ_SENTRY_NATIVE_URL}")
+execute_process(COMMAND ${CMAKE_COMMAND} -E echo "++WZ_SENTRY_NATIVE_SHA512: ${WZ_SENTRY_NATIVE_SHA512}")
+
+##################################
+# Output configured file based on the template
+
+if(NOT EXISTS "${TEMPLATE_FILE}")
+	message( FATAL_ERROR "Input TEMPLATE_FILE does not exist: \"${TEMPLATE_FILE}\"" )
+endif()
+configure_file("${TEMPLATE_FILE}" "${OUTPUT_FILE}" @ONLY)
+