move to own git serverHEADmaster

1 files changed, 952 insertions, 0 deletions

diff --git a/vcpkg/scripts/buildsystems/vcpkg.cmake b/vcpkg/scripts/buildsystems/vcpkg.cmake
new file mode 100644
index 0000000..38f87f9
--- /dev/null
+++ b/vcpkg/scripts/buildsystems/vcpkg.cmake
@@ -0,0 +1,952 @@
+# Mark variables as used so cmake doesn't complain about them
+mark_as_advanced(CMAKE_TOOLCHAIN_FILE)
+
+# NOTE: to figure out what cmake versions are required for different things,
+# grep for `CMake 3`. All version requirement comments should follow that format.
+
+# Attention: Changes to this file do not affect ABI hashing.
+
+#[===[.md:
+# z_vcpkg_add_fatal_error
+Add a fatal error.
+
+```cmake
+z_vcpkg_add_fatal_error(<message>...)
+```
+
+We use this system, instead of `message(FATAL_ERROR)`,
+since cmake prints a lot of nonsense if the toolchain errors out before it's found the build tools.
+
+This `Z_VCPKG_HAS_FATAL_ERROR` must be checked before any filesystem operations are done,
+since otherwise you might be doing something with bad variables set up.
+#]===]
+# this is defined above everything else so that it can be used.
+set(Z_VCPKG_FATAL_ERROR)
+set(Z_VCPKG_HAS_FATAL_ERROR OFF)
+function(z_vcpkg_add_fatal_error ERROR)
+    if(NOT Z_VCPKG_HAS_FATAL_ERROR)
+        set(Z_VCPKG_HAS_FATAL_ERROR ON PARENT_SCOPE)
+        set(Z_VCPKG_FATAL_ERROR "${ERROR}" PARENT_SCOPE)
+    else()
+        string(APPEND Z_VCPKG_FATAL_ERROR "\n${ERROR}")
+    endif()
+endfunction()
+
+set(Z_VCPKG_CMAKE_REQUIRED_MINIMUM_VERSION "3.7.2")
+if(CMAKE_VERSION VERSION_LESS Z_VCPKG_CMAKE_REQUIRED_MINIMUM_VERSION)
+    message(FATAL_ERROR "vcpkg.cmake requires at least CMake ${Z_VCPKG_CMAKE_REQUIRED_MINIMUM_VERSION}.")
+endif()
+cmake_policy(PUSH)
+cmake_policy(VERSION 3.16)
+
+include(CMakeDependentOption)
+
+# VCPKG toolchain options.
+option(VCPKG_VERBOSE "Enables messages from the VCPKG toolchain for debugging purposes." OFF)
+mark_as_advanced(VCPKG_VERBOSE)
+
+option(VCPKG_APPLOCAL_DEPS "Automatically copy dependencies into the output directory for executables." ON)
+option(X_VCPKG_APPLOCAL_DEPS_SERIALIZED "(experimental) Add USES_TERMINAL to VCPKG_APPLOCAL_DEPS to force serialization." OFF)
+
+# requires CMake 3.14
+option(X_VCPKG_APPLOCAL_DEPS_INSTALL "(experimental) Automatically copy dependencies into the install target directory for executables. Requires CMake 3.14." OFF)
+option(VCPKG_PREFER_SYSTEM_LIBS "Appends the vcpkg paths to CMAKE_PREFIX_PATH, CMAKE_LIBRARY_PATH and CMAKE_FIND_ROOT_PATH so that vcpkg libraries/packages are found after toolchain/system libraries/packages." OFF)
+if(VCPKG_PREFER_SYSTEM_LIBS)
+    message(WARNING "VCPKG_PREFER_SYSTEM_LIBS has been deprecated. Use empty overlay ports instead.")
+endif()
+
+# Manifest options and settings
+set(Z_VCPKG_MANIFEST_DIR_INITIAL_VALUE "${VCPKG_MANIFEST_DIR}")
+if(NOT DEFINED VCPKG_MANIFEST_DIR)
+    if(EXISTS "${CMAKE_SOURCE_DIR}/vcpkg.json")
+        set(Z_VCPKG_MANIFEST_DIR_INITIAL_VALUE "${CMAKE_SOURCE_DIR}")
+    endif()
+endif()
+set(VCPKG_MANIFEST_DIR "${Z_VCPKG_MANIFEST_DIR_INITIAL_VALUE}"
+    CACHE PATH "The path to the vcpkg manifest directory." FORCE)
+
+if(DEFINED VCPKG_MANIFEST_DIR AND NOT VCPKG_MANIFEST_DIR STREQUAL "")
+    set(Z_VCPKG_HAS_MANIFEST_DIR ON)
+else()
+    set(Z_VCPKG_HAS_MANIFEST_DIR OFF)
+endif()
+
+option(VCPKG_MANIFEST_MODE "Use manifest mode, as opposed to classic mode." "${Z_VCPKG_HAS_MANIFEST_DIR}")
+
+if(VCPKG_MANIFEST_MODE AND NOT Z_VCPKG_HAS_MANIFEST_DIR)
+    z_vcpkg_add_fatal_error(
+"vcpkg manifest mode was enabled, but we couldn't find a manifest file (vcpkg.json)
+in the current source directory (${CMAKE_CURRENT_SOURCE_DIR}).
+Please add a manifest, or disable manifests by turning off VCPKG_MANIFEST_MODE."
+    )
+endif()
+
+if(NOT DEFINED CACHE{Z_VCPKG_CHECK_MANIFEST_MODE})
+    set(Z_VCPKG_CHECK_MANIFEST_MODE "${VCPKG_MANIFEST_MODE}"
+        CACHE INTERNAL "Making sure VCPKG_MANIFEST_MODE doesn't change")
+endif()
+
+if(NOT VCPKG_MANIFEST_MODE AND Z_VCPKG_CHECK_MANIFEST_MODE)
+    z_vcpkg_add_fatal_error([[
+vcpkg manifest mode was disabled for a build directory where it was initially enabled.
+This is not supported. Please delete the build directory and reconfigure.
+]])
+elseif(VCPKG_MANIFEST_MODE AND NOT Z_VCPKG_CHECK_MANIFEST_MODE)
+    z_vcpkg_add_fatal_error([[
+vcpkg manifest mode was enabled for a build directory where it was initially disabled.
+This is not supported. Please delete the build directory and reconfigure.
+]])
+endif()
+
+CMAKE_DEPENDENT_OPTION(VCPKG_MANIFEST_INSTALL [[
+Install the dependencies listed in your manifest:
+    If this is off, you will have to manually install your dependencies.
+    See https://github.com/microsoft/vcpkg/tree/master/docs/specifications/manifests.md for more info.
+]]
+    ON
+    "VCPKG_MANIFEST_MODE"
+    OFF)
+
+if(VCPKG_MANIFEST_INSTALL)
+    set(VCPKG_BOOTSTRAP_OPTIONS "${VCPKG_BOOTSTRAP_OPTIONS}" CACHE STRING "Additional options to bootstrap vcpkg" FORCE)
+    set(VCPKG_OVERLAY_PORTS "${VCPKG_OVERLAY_PORTS}" CACHE STRING "Overlay ports to use for vcpkg install in manifest mode" FORCE)
+    set(VCPKG_OVERLAY_TRIPLETS "${VCPKG_OVERLAY_TRIPLETS}" CACHE STRING "Overlay triplets to use for vcpkg install in manifest mode" FORCE)
+    set(VCPKG_INSTALL_OPTIONS "${VCPKG_INSTALL_OPTIONS}" CACHE STRING "Additional install options to pass to vcpkg" FORCE)
+    set(Z_VCPKG_UNUSED VCPKG_BOOTSTRAP_OPTIONS)
+    set(Z_VCPKG_UNUSED VCPKG_OVERLAY_PORTS)
+    set(Z_VCPKG_UNUSED VCPKG_OVERLAY_TRIPLETS)
+    set(Z_VCPKG_UNUSED VCPKG_INSTALL_OPTIONS)
+endif()
+
+# CMake helper utilities
+
+#[===[.md:
+# z_vcpkg_function_arguments
+
+Get a list of the arguments which were passed in.
+Unlike `ARGV`, which is simply the arguments joined with `;`,
+so that `(A B)` is not distinguishable from `("A;B")`,
+this macro gives `"A;B"` for the first argument list,
+and `"A\;B"` for the second.
+
+```cmake
+z_vcpkg_function_arguments(<out-var> [<N>])
+```
+
+`z_vcpkg_function_arguments` gets the arguments between `ARGV<N>` and the last argument.
+`<N>` defaults to `0`, so that all arguments are taken.
+
+## Example:
+```cmake
+function(foo_replacement)
+    z_vcpkg_function_arguments(ARGS)
+    foo(${ARGS})
+    ...
+endfunction()
+```
+#]===]
+
+# NOTE: this function definition is copied directly from scripts/cmake/z_vcpkg_function_arguments.cmake
+# do not make changes here without making the same change there.
+macro(z_vcpkg_function_arguments OUT_VAR)
+    if("${ARGC}" EQUAL "1")
+        set(z_vcpkg_function_arguments_FIRST_ARG "0")
+    elseif("${ARGC}" EQUAL "2")
+        set(z_vcpkg_function_arguments_FIRST_ARG "${ARGV1}")
+    else()
+        # vcpkg bug
+        message(FATAL_ERROR "z_vcpkg_function_arguments: invalid arguments (${ARGV})")
+    endif()
+
+    set("${OUT_VAR}" "")
+
+    # this allows us to get the value of the enclosing function's ARGC
+    set(z_vcpkg_function_arguments_ARGC_NAME "ARGC")
+    set(z_vcpkg_function_arguments_ARGC "${${z_vcpkg_function_arguments_ARGC_NAME}}")
+
+    math(EXPR z_vcpkg_function_arguments_LAST_ARG "${z_vcpkg_function_arguments_ARGC} - 1")
+    if(z_vcpkg_function_arguments_LAST_ARG GREATER_EQUAL z_vcpkg_function_arguments_FIRST_ARG)
+        foreach(z_vcpkg_function_arguments_N RANGE "${z_vcpkg_function_arguments_FIRST_ARG}" "${z_vcpkg_function_arguments_LAST_ARG}")
+            string(REPLACE ";" "\\;" z_vcpkg_function_arguments_ESCAPED_ARG "${ARGV${z_vcpkg_function_arguments_N}}")
+            # adds an extra `;` on the first time through
+            set("${OUT_VAR}" "${${OUT_VAR}};${z_vcpkg_function_arguments_ESCAPED_ARG}")
+        endforeach()
+        # remove leading `;`
+        string(SUBSTRING "${${OUT_VAR}}" "1" "-1" "${OUT_VAR}")
+    endif()
+endmacro()
+
+#[===[.md:
+# z_vcpkg_set_powershell_path
+
+Gets either the path to powershell or powershell core,
+and places it in the variable Z_VCPKG_POWERSHELL_PATH.
+#]===]
+function(z_vcpkg_set_powershell_path)
+    # Attempt to use pwsh if it is present; otherwise use powershell
+    if(NOT DEFINED Z_VCPKG_POWERSHELL_PATH)
+        find_program(Z_VCPKG_PWSH_PATH pwsh)
+        if(Z_VCPKG_PWSH_PATH)
+            set(Z_VCPKG_POWERSHELL_PATH "${Z_VCPKG_PWSH_PATH}" CACHE INTERNAL "The path to the PowerShell implementation to use.")
+        else()
+            message(DEBUG "vcpkg: Could not find PowerShell Core; falling back to PowerShell")
+            find_program(Z_VCPKG_BUILTIN_POWERSHELL_PATH powershell)
+            if(Z_VCPKG_BUILTIN_POWERSHELL_PATH)
+                set(Z_VCPKG_POWERSHELL_PATH "${Z_VCPKG_BUILTIN_POWERSHELL_PATH}" CACHE INTERNAL "The path to the PowerShell implementation to use.")
+            else()
+                message(WARNING "vcpkg: Could not find PowerShell; using static string 'powershell.exe'")
+                set(Z_VCPKG_POWERSHELL_PATH "powershell.exe" CACHE INTERNAL "The path to the PowerShell implementation to use.")
+            endif()
+        endif()
+    endif() # Z_VCPKG_POWERSHELL_PATH
+endfunction()
+
+
+# Determine whether the toolchain is loaded during a try-compile configuration
+get_property(Z_VCPKG_CMAKE_IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE)
+
+if(VCPKG_CHAINLOAD_TOOLCHAIN_FILE)
+    include("${VCPKG_CHAINLOAD_TOOLCHAIN_FILE}")
+endif()
+
+if(VCPKG_TOOLCHAIN)
+    cmake_policy(POP)
+    return()
+endif()
+
+#If CMake does not have a mapping for MinSizeRel and RelWithDebInfo in imported targets
+#it will map those configuration to the first valid configuration in CMAKE_CONFIGURATION_TYPES or the targets IMPORTED_CONFIGURATIONS.
+#In most cases this is the debug configuration which is wrong.
+if(NOT DEFINED CMAKE_MAP_IMPORTED_CONFIG_MINSIZEREL)
+    set(CMAKE_MAP_IMPORTED_CONFIG_MINSIZEREL "MinSizeRel;Release;None;")
+    if(VCPKG_VERBOSE)
+        message(STATUS "VCPKG-Info: CMAKE_MAP_IMPORTED_CONFIG_MINSIZEREL set to MinSizeRel;Release;None;")
+    endif()
+endif()
+if(NOT DEFINED CMAKE_MAP_IMPORTED_CONFIG_RELWITHDEBINFO)
+    set(CMAKE_MAP_IMPORTED_CONFIG_RELWITHDEBINFO "RelWithDebInfo;Release;None;")
+    if(VCPKG_VERBOSE)
+        message(STATUS "VCPKG-Info: CMAKE_MAP_IMPORTED_CONFIG_RELWITHDEBINFO set to RelWithDebInfo;Release;None;")
+    endif()
+endif()
+
+if(VCPKG_TARGET_TRIPLET)
+    # This is required since a user might do: 'set(VCPKG_TARGET_TRIPLET somevalue)' [no CACHE] before the first project() call
+    # Latter within the toolchain file we do: 'set(VCPKG_TARGET_TRIPLET somevalue CACHE STRING "")' which
+    # will otherwise override the user setting of VCPKG_TARGET_TRIPLET in the current scope of the toolchain since the CACHE value
+    # did not exist previously. Since the value is newly created CMake will use the CACHE value within this scope since it is the more
+    # recently created value in directory scope. This 'strange' behaviour only happens on the very first configure call since subsequent
+    # configure call will see the user value as the more recent value. The same logic must be applied to all cache values within this file!
+    # The FORCE keyword is required to ALWAYS lift the user provided/previously set value into a CACHE value.
+    set(VCPKG_TARGET_TRIPLET "${VCPKG_TARGET_TRIPLET}" CACHE STRING "Vcpkg target triplet (ex. x86-windows)" FORCE)
+elseif(CMAKE_GENERATOR_PLATFORM MATCHES "^[Ww][Ii][Nn]32$")
+    set(Z_VCPKG_TARGET_TRIPLET_ARCH x86)
+elseif(CMAKE_GENERATOR_PLATFORM MATCHES "^[Xx]64$")
+    set(Z_VCPKG_TARGET_TRIPLET_ARCH x64)
+elseif(CMAKE_GENERATOR_PLATFORM MATCHES "^[Aa][Rr][Mm]$")
+    set(Z_VCPKG_TARGET_TRIPLET_ARCH arm)
+elseif(CMAKE_GENERATOR_PLATFORM MATCHES "^[Aa][Rr][Mm]64$")
+    set(Z_VCPKG_TARGET_TRIPLET_ARCH arm64)
+else()
+    if(CMAKE_GENERATOR STREQUAL "Visual Studio 14 2015 Win64")
+        set(Z_VCPKG_TARGET_TRIPLET_ARCH x64)
+    elseif(CMAKE_GENERATOR STREQUAL "Visual Studio 14 2015 ARM")
+        set(Z_VCPKG_TARGET_TRIPLET_ARCH arm)
+    elseif(CMAKE_GENERATOR STREQUAL "Visual Studio 14 2015")
+        set(Z_VCPKG_TARGET_TRIPLET_ARCH x86)
+    elseif(CMAKE_GENERATOR STREQUAL "Visual Studio 15 2017 Win64")
+        set(Z_VCPKG_TARGET_TRIPLET_ARCH x64)
+    elseif(CMAKE_GENERATOR STREQUAL "Visual Studio 15 2017 ARM")
+        set(Z_VCPKG_TARGET_TRIPLET_ARCH arm)
+    elseif(CMAKE_GENERATOR STREQUAL "Visual Studio 15 2017")
+        set(Z_VCPKG_TARGET_TRIPLET_ARCH x86)
+    elseif(CMAKE_GENERATOR STREQUAL "Visual Studio 16 2019" AND CMAKE_VS_PLATFORM_NAME_DEFAULT STREQUAL "ARM64")
+        set(Z_VCPKG_TARGET_TRIPLET_ARCH arm64)
+    elseif(CMAKE_GENERATOR STREQUAL "Visual Studio 16 2019")
+        set(Z_VCPKG_TARGET_TRIPLET_ARCH x64)
+    elseif(CMAKE_GENERATOR STREQUAL "Visual Studio 17 2022" AND CMAKE_VS_PLATFORM_NAME_DEFAULT STREQUAL "ARM64")
+        set(Z_VCPKG_TARGET_TRIPLET_ARCH arm64)
+    elseif(CMAKE_GENERATOR STREQUAL "Visual Studio 17 2022")
+        set(Z_VCPKG_TARGET_TRIPLET_ARCH x64)
+    elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin" AND DEFINED CMAKE_OSX_ARCHITECTURES)
+        list(LENGTH CMAKE_OSX_ARCHITECTURES Z_VCPKG_OSX_ARCH_COUNT)
+        if(Z_VCPKG_OSX_ARCH_COUNT EQUAL "0")
+            message(WARNING "Unable to determine target architecture. "
+                            "Consider providing a value for the CMAKE_OSX_ARCHITECTURES cache variable. "
+                            "Continuing without vcpkg.")
+            set(VCPKG_TOOLCHAIN ON)
+            cmake_policy(POP)
+            return()
+        endif()
+
+        if(Z_VCPKG_OSX_ARCH_COUNT GREATER "1")
+            message(WARNING "Detected more than one target architecture. Using the first one.")
+        endif()
+        list(GET CMAKE_OSX_ARCHITECTURES "0" Z_VCPKG_OSX_TARGET_ARCH)
+        if(Z_VCPKG_OSX_TARGET_ARCH STREQUAL "arm64")
+            set(Z_VCPKG_TARGET_TRIPLET_ARCH arm64)
+        elseif(Z_VCPKG_OSX_TARGET_ARCH STREQUAL "arm64s")
+            set(Z_VCPKG_TARGET_TRIPLET_ARCH arm64s)
+        elseif(Z_VCPKG_OSX_TARGET_ARCH STREQUAL "armv7s")
+            set(Z_VCPKG_TARGET_TRIPLET_ARCH armv7s)
+        elseif(Z_VCPKG_OSX_TARGET_ARCH STREQUAL "armv7")
+            set(Z_VCPKG_TARGET_TRIPLET_ARCH arm)
+        elseif(Z_VCPKG_OSX_TARGET_ARCH STREQUAL "x86_64")
+            set(Z_VCPKG_TARGET_TRIPLET_ARCH x64)
+        elseif(Z_VCPKG_OSX_TARGET_ARCH STREQUAL "i386")
+            set(Z_VCPKG_TARGET_TRIPLET_ARCH x86)
+        else()
+            message(WARNING "Unable to determine target architecture, continuing without vcpkg.")
+            set(VCPKG_TOOLCHAIN ON)
+            cmake_policy(POP)
+            return()
+        endif()
+    else()
+        find_program(Z_VCPKG_CL cl)
+        if(Z_VCPKG_CL MATCHES "amd64/cl.exe$" OR Z_VCPKG_CL MATCHES "x64/cl.exe$")
+            set(Z_VCPKG_TARGET_TRIPLET_ARCH x64)
+        elseif(Z_VCPKG_CL MATCHES "arm/cl.exe$")
+            set(Z_VCPKG_TARGET_TRIPLET_ARCH arm)
+        elseif(Z_VCPKG_CL MATCHES "arm64/cl.exe$")
+            set(Z_VCPKG_TARGET_TRIPLET_ARCH arm64)
+        elseif(Z_VCPKG_CL MATCHES "bin/cl.exe$" OR Z_VCPKG_CL MATCHES "x86/cl.exe$")
+            set(Z_VCPKG_TARGET_TRIPLET_ARCH x86)
+        elseif(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "x86_64" OR
+               CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "AMD64" OR
+               CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "amd64")
+            set(Z_VCPKG_TARGET_TRIPLET_ARCH x64)
+        elseif(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "s390x")
+            set(Z_VCPKG_TARGET_TRIPLET_ARCH s390x)
+        elseif(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "ppc64le")
+            set(Z_VCPKG_TARGET_TRIPLET_ARCH ppc64le)
+        elseif(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "armv7l")
+            set(Z_VCPKG_TARGET_TRIPLET_ARCH arm)
+        elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64|ARM64)$")
+            set(Z_VCPKG_TARGET_TRIPLET_ARCH arm64)
+	elseif(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "riscv32")
+	    set(Z_VCPKG_TARGET_TRIPLET_ARCH riscv32)
+	elseif(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "riscv64")
+	    set(Z_VCPKG_TARGET_TRIPLET_ARCH riscv64)
+        elseif(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "loongarch32")
+            set(Z_VCPKG_TARGET_TRIPLET_ARCH loongarch32)
+        elseif(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "loongarch64")
+            set(Z_VCPKG_TARGET_TRIPLET_ARCH loongarch64)
+        else()
+            if(Z_VCPKG_CMAKE_IN_TRY_COMPILE)
+                message(STATUS "Unable to determine target architecture, continuing without vcpkg.")
+            else()
+                message(WARNING "Unable to determine target architecture, continuing without vcpkg.")
+            endif()
+            set(VCPKG_TOOLCHAIN ON)
+            cmake_policy(POP)
+            return()
+        endif()
+    endif()
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "WindowsStore" OR CMAKE_SYSTEM_NAME STREQUAL "WindowsPhone")
+    set(Z_VCPKG_TARGET_TRIPLET_PLAT uwp)
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux" OR (NOT CMAKE_SYSTEM_NAME AND CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux"))
+    set(Z_VCPKG_TARGET_TRIPLET_PLAT linux)
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin" OR (NOT CMAKE_SYSTEM_NAME AND CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin"))
+    set(Z_VCPKG_TARGET_TRIPLET_PLAT osx)
+elseif(CMAKE_SYSTEM_NAME STREQUAL "iOS")
+    set(Z_VCPKG_TARGET_TRIPLET_PLAT ios)
+elseif(CMAKE_SYSTEM_NAME STREQUAL "watchOS")
+    set(Z_VCPKG_TARGET_TRIPLET_PLAT watchos)
+elseif(CMAKE_SYSTEM_NAME STREQUAL "tvOS")
+    set(Z_VCPKG_TARGET_TRIPLET_PLAT tvos)
+elseif(CMAKE_SYSTEM_NAME STREQUAL "visionOS")
+    set(Z_VCPKG_TARGET_TRIPLET_PLAT visionos)
+elseif(MINGW)
+    set(Z_VCPKG_TARGET_TRIPLET_PLAT mingw-dynamic)
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows" OR (NOT CMAKE_SYSTEM_NAME AND CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows"))
+    if(XBOX_CONSOLE_TARGET STREQUAL "scarlett")
+        set(Z_VCPKG_TARGET_TRIPLET_PLAT xbox-scarlett)
+    elseif(XBOX_CONSOLE_TARGET STREQUAL "xboxone")
+        set(Z_VCPKG_TARGET_TRIPLET_PLAT xbox-xboxone)
+    else()
+        set(Z_VCPKG_TARGET_TRIPLET_PLAT windows)
+    endif()
+elseif(CMAKE_SYSTEM_NAME STREQUAL "FreeBSD" OR (NOT CMAKE_SYSTEM_NAME AND CMAKE_HOST_SYSTEM_NAME STREQUAL "FreeBSD"))
+    set(Z_VCPKG_TARGET_TRIPLET_PLAT freebsd)
+elseif(CMAKE_SYSTEM_NAME STREQUAL "OpenBSD" OR (NOT CMAKE_SYSTEM_NAME AND CMAKE_HOST_SYSTEM_NAME STREQUAL "OpenBSD"))
+    set(Z_VCPKG_TARGET_TRIPLET_PLAT openbsd)
+elseif(CMAKE_SYSTEM_NAME STREQUAL "NetBSD" OR (NOT CMAKE_SYSTEM_NAME AND CMAKE_HOST_SYSTEM_NAME STREQUAL "NetBSD"))
+    set(Z_VCPKG_TARGET_TRIPLET_PLAT netbsd)
+elseif(CMAKE_SYSTEM_NAME STREQUAL "SunOS" OR (NOT CMAKE_SYSTEM_NAME AND CMAKE_HOST_SYSTEM_NAME STREQUAL "SunOS"))
+    set(Z_VCPKG_TARGET_TRIPLET_PLAT solaris)
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Android" OR (NOT CMAKE_SYSTEM_NAME AND CMAKE_HOST_SYSTEM_NAME STREQUAL "Android"))
+    set(Z_VCPKG_TARGET_TRIPLET_PLAT android)
+endif()
+
+if(EMSCRIPTEN)
+    set(Z_VCPKG_TARGET_TRIPLET_ARCH wasm32)
+    set(Z_VCPKG_TARGET_TRIPLET_PLAT emscripten)
+endif()
+
+set(VCPKG_TARGET_TRIPLET "${Z_VCPKG_TARGET_TRIPLET_ARCH}-${Z_VCPKG_TARGET_TRIPLET_PLAT}" CACHE STRING "Vcpkg target triplet (ex. x86-windows)")
+set(Z_VCPKG_TOOLCHAIN_DIR "${CMAKE_CURRENT_LIST_DIR}")
+
+# Detect .vcpkg-root to figure VCPKG_ROOT_DIR
+set(Z_VCPKG_ROOT_DIR_CANDIDATE "${CMAKE_CURRENT_LIST_DIR}")
+while(NOT DEFINED Z_VCPKG_ROOT_DIR)
+    if(EXISTS "${Z_VCPKG_ROOT_DIR_CANDIDATE}/.vcpkg-root")
+        set(Z_VCPKG_ROOT_DIR "${Z_VCPKG_ROOT_DIR_CANDIDATE}" CACHE INTERNAL "Vcpkg root directory")
+    elseif(IS_DIRECTORY "${Z_VCPKG_ROOT_DIR_CANDIDATE}")
+        get_filename_component(Z_VCPKG_ROOT_DIR_TEMP "${Z_VCPKG_ROOT_DIR_CANDIDATE}" DIRECTORY)
+        if(Z_VCPKG_ROOT_DIR_TEMP STREQUAL Z_VCPKG_ROOT_DIR_CANDIDATE)
+            break() # If unchanged, we have reached the root of the drive without finding vcpkg.
+        endif()
+        SET(Z_VCPKG_ROOT_DIR_CANDIDATE "${Z_VCPKG_ROOT_DIR_TEMP}")
+        unset(Z_VCPKG_ROOT_DIR_TEMP)
+    else()
+        break()
+    endif()
+endwhile()
+unset(Z_VCPKG_ROOT_DIR_CANDIDATE)
+
+if(NOT Z_VCPKG_ROOT_DIR)
+    z_vcpkg_add_fatal_error("Could not find .vcpkg-root")
+endif()
+
+if(DEFINED VCPKG_INSTALLED_DIR)
+    set(Z_VCPKG_INSTALLED_DIR_INITIAL_VALUE "${VCPKG_INSTALLED_DIR}")
+elseif(DEFINED _VCPKG_INSTALLED_DIR)
+    set(Z_VCPKG_INSTALLED_DIR_INITIAL_VALUE "${_VCPKG_INSTALLED_DIR}")
+elseif(VCPKG_MANIFEST_MODE)
+    set(Z_VCPKG_INSTALLED_DIR_INITIAL_VALUE "${CMAKE_BINARY_DIR}/vcpkg_installed")
+else()
+    set(Z_VCPKG_INSTALLED_DIR_INITIAL_VALUE "${Z_VCPKG_ROOT_DIR}/installed")
+endif()
+
+set(VCPKG_INSTALLED_DIR "${Z_VCPKG_INSTALLED_DIR_INITIAL_VALUE}"
+    CACHE PATH
+    "The directory which contains the installed libraries for each triplet" FORCE)
+set(_VCPKG_INSTALLED_DIR "${VCPKG_INSTALLED_DIR}"
+    CACHE PATH
+    "The directory which contains the installed libraries for each triplet" FORCE)
+
+function(z_vcpkg_add_vcpkg_to_cmake_path list suffix)
+    set(vcpkg_paths
+        "${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}${suffix}"
+        "${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/debug${suffix}"
+    )
+    if(NOT DEFINED CMAKE_BUILD_TYPE OR CMAKE_BUILD_TYPE MATCHES "^[Dd][Ee][Bb][Uu][Gg]$")
+        list(REVERSE vcpkg_paths) # Debug build: Put Debug paths before Release paths.
+    endif()
+    if(VCPKG_PREFER_SYSTEM_LIBS)
+        list(APPEND "${list}" "${vcpkg_paths}")
+    else()
+        list(INSERT "${list}" "0" "${vcpkg_paths}") # CMake 3.15 is required for list(PREPEND ...).
+    endif()
+    set("${list}" "${${list}}" PARENT_SCOPE)
+endfunction()
+z_vcpkg_add_vcpkg_to_cmake_path(CMAKE_PREFIX_PATH "")
+z_vcpkg_add_vcpkg_to_cmake_path(CMAKE_LIBRARY_PATH "/lib/manual-link")
+z_vcpkg_add_vcpkg_to_cmake_path(CMAKE_FIND_ROOT_PATH "")
+
+if(NOT VCPKG_PREFER_SYSTEM_LIBS)
+    set(CMAKE_FIND_FRAMEWORK "LAST") # we assume that frameworks are usually system-wide libs, not vcpkg-built
+    set(CMAKE_FIND_APPBUNDLE "LAST") # we assume that appbundles are usually system-wide libs, not vcpkg-built
+endif()
+
+# If one CMAKE_FIND_ROOT_PATH_MODE_* variables is set to ONLY, to  make sure that ${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}
+# and ${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/debug are searched, it is not sufficient to just add them to CMAKE_FIND_ROOT_PATH,
+# as CMAKE_FIND_ROOT_PATH specify "one or more directories to be prepended to all other search directories", so to make sure that
+# the libraries are searched as they are, it is necessary to add "/" to the CMAKE_PREFIX_PATH
+if(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE STREQUAL "ONLY" OR
+   CMAKE_FIND_ROOT_PATH_MODE_LIBRARY STREQUAL "ONLY" OR
+   CMAKE_FIND_ROOT_PATH_MODE_PACKAGE STREQUAL "ONLY")
+   list(APPEND CMAKE_PREFIX_PATH "/")
+endif()
+
+set(VCPKG_CMAKE_FIND_ROOT_PATH "${CMAKE_FIND_ROOT_PATH}")
+
+# CMAKE_EXECUTABLE_SUFFIX is not yet defined
+if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
+    set(Z_VCPKG_EXECUTABLE "${Z_VCPKG_ROOT_DIR}/vcpkg.exe")
+    set(Z_VCPKG_BOOTSTRAP_SCRIPT "${Z_VCPKG_ROOT_DIR}/bootstrap-vcpkg.bat")
+else()
+    set(Z_VCPKG_EXECUTABLE "${Z_VCPKG_ROOT_DIR}/vcpkg")
+    set(Z_VCPKG_BOOTSTRAP_SCRIPT "${Z_VCPKG_ROOT_DIR}/bootstrap-vcpkg.sh")
+endif()
+
+if(VCPKG_MANIFEST_MODE AND VCPKG_MANIFEST_INSTALL AND NOT Z_VCPKG_CMAKE_IN_TRY_COMPILE AND NOT Z_VCPKG_HAS_FATAL_ERROR)
+    if(NOT EXISTS "${Z_VCPKG_EXECUTABLE}" AND NOT Z_VCPKG_HAS_FATAL_ERROR)
+        message(STATUS "Bootstrapping vcpkg before install")
+
+        set(Z_VCPKG_BOOTSTRAP_LOG "${CMAKE_BINARY_DIR}/vcpkg-bootstrap.log")
+        file(TO_NATIVE_PATH "${Z_VCPKG_BOOTSTRAP_LOG}" Z_NATIVE_VCPKG_BOOTSTRAP_LOG)
+        execute_process(
+            COMMAND "${Z_VCPKG_BOOTSTRAP_SCRIPT}" ${VCPKG_BOOTSTRAP_OPTIONS}
+            OUTPUT_FILE "${Z_VCPKG_BOOTSTRAP_LOG}"
+            ERROR_FILE "${Z_VCPKG_BOOTSTRAP_LOG}"
+            RESULT_VARIABLE Z_VCPKG_BOOTSTRAP_RESULT)
+
+        if(Z_VCPKG_BOOTSTRAP_RESULT EQUAL "0")
+            message(STATUS "Bootstrapping vcpkg before install - done")
+        else()
+            message(STATUS "Bootstrapping vcpkg before install - failed")
+            z_vcpkg_add_fatal_error("vcpkg install failed. See logs for more information: ${Z_NATIVE_VCPKG_BOOTSTRAP_LOG}")
+        endif()
+    endif()
+
+    if(NOT Z_VCPKG_HAS_FATAL_ERROR)
+        message(STATUS "Running vcpkg install")
+
+        set(Z_VCPKG_ADDITIONAL_MANIFEST_PARAMS)
+
+        if(DEFINED VCPKG_HOST_TRIPLET AND NOT VCPKG_HOST_TRIPLET STREQUAL "")
+            list(APPEND Z_VCPKG_ADDITIONAL_MANIFEST_PARAMS "--host-triplet=${VCPKG_HOST_TRIPLET}")
+        endif()
+
+        if(VCPKG_OVERLAY_PORTS)
+            foreach(Z_VCPKG_OVERLAY_PORT IN LISTS VCPKG_OVERLAY_PORTS)
+                list(APPEND Z_VCPKG_ADDITIONAL_MANIFEST_PARAMS "--overlay-ports=${Z_VCPKG_OVERLAY_PORT}")
+            endforeach()
+        endif()
+        if(VCPKG_OVERLAY_TRIPLETS)
+            foreach(Z_VCPKG_OVERLAY_TRIPLET IN LISTS VCPKG_OVERLAY_TRIPLETS)
+                list(APPEND Z_VCPKG_ADDITIONAL_MANIFEST_PARAMS "--overlay-triplets=${Z_VCPKG_OVERLAY_TRIPLET}")
+            endforeach()
+        endif()
+
+        if(DEFINED VCPKG_FEATURE_FLAGS OR DEFINED CACHE{VCPKG_FEATURE_FLAGS})
+            list(JOIN VCPKG_FEATURE_FLAGS "," Z_VCPKG_FEATURE_FLAGS)
+            set(Z_VCPKG_FEATURE_FLAGS "--feature-flags=${Z_VCPKG_FEATURE_FLAGS}")
+        endif()
+
+        foreach(Z_VCPKG_FEATURE IN LISTS VCPKG_MANIFEST_FEATURES)
+            list(APPEND Z_VCPKG_ADDITIONAL_MANIFEST_PARAMS "--x-feature=${Z_VCPKG_FEATURE}")
+        endforeach()
+
+        if(VCPKG_MANIFEST_NO_DEFAULT_FEATURES)
+            list(APPEND Z_VCPKG_ADDITIONAL_MANIFEST_PARAMS "--x-no-default-features")
+        endif()
+
+        if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18")
+            set(Z_VCPKG_MANIFEST_INSTALL_ECHO_PARAMS ECHO_OUTPUT_VARIABLE ECHO_ERROR_VARIABLE)
+        else()
+            set(Z_VCPKG_MANIFEST_INSTALL_ECHO_PARAMS)
+        endif()
+
+        execute_process(
+            COMMAND "${Z_VCPKG_EXECUTABLE}" install
+                --triplet "${VCPKG_TARGET_TRIPLET}"
+                --vcpkg-root "${Z_VCPKG_ROOT_DIR}"
+                "--x-wait-for-lock"
+                "--x-manifest-root=${VCPKG_MANIFEST_DIR}"
+                "--x-install-root=${_VCPKG_INSTALLED_DIR}"
+                ${Z_VCPKG_FEATURE_FLAGS}
+                ${Z_VCPKG_ADDITIONAL_MANIFEST_PARAMS}
+                ${VCPKG_INSTALL_OPTIONS}
+            OUTPUT_VARIABLE Z_VCPKG_MANIFEST_INSTALL_LOGTEXT
+            ERROR_VARIABLE Z_VCPKG_MANIFEST_INSTALL_LOGTEXT
+            RESULT_VARIABLE Z_VCPKG_MANIFEST_INSTALL_RESULT
+            ${Z_VCPKG_MANIFEST_INSTALL_ECHO_PARAMS}
+        )
+
+        set(Z_VCPKG_MANIFEST_INSTALL_LOGFILE "${CMAKE_BINARY_DIR}/vcpkg-manifest-install.log")
+        file(TO_NATIVE_PATH "${Z_VCPKG_MANIFEST_INSTALL_LOGFILE}" Z_NATIVE_VCPKG_MANIFEST_INSTALL_LOGFILE)
+        file(WRITE "${Z_VCPKG_MANIFEST_INSTALL_LOGFILE}" "${Z_VCPKG_MANIFEST_INSTALL_LOGTEXT}")
+
+        if(Z_VCPKG_MANIFEST_INSTALL_RESULT EQUAL "0")
+            message(STATUS "Running vcpkg install - done")
+            set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS
+                "${VCPKG_MANIFEST_DIR}/vcpkg.json")
+            if(EXISTS "${VCPKG_MANIFEST_DIR}/vcpkg-configuration.json")
+                set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS
+                    "${VCPKG_MANIFEST_DIR}/vcpkg-configuration.json")
+            endif()
+        else()
+            message(STATUS "Running vcpkg install - failed")
+            z_vcpkg_add_fatal_error("vcpkg install failed. See logs for more information: ${Z_NATIVE_VCPKG_MANIFEST_INSTALL_LOGFILE}")
+        endif()
+    endif()
+endif()
+
+option(VCPKG_SETUP_CMAKE_PROGRAM_PATH  "Enable the setup of CMAKE_PROGRAM_PATH to vcpkg paths" ON)
+set(VCPKG_CAN_USE_HOST_TOOLS OFF)
+if(DEFINED VCPKG_HOST_TRIPLET AND NOT VCPKG_HOST_TRIPLET STREQUAL "")
+    set(VCPKG_CAN_USE_HOST_TOOLS ON)
+endif()
+cmake_dependent_option(VCPKG_USE_HOST_TOOLS "Setup CMAKE_PROGRAM_PATH to use host tools" ON "VCPKG_CAN_USE_HOST_TOOLS" OFF)
+unset(VCPKG_CAN_USE_HOST_TOOLS)
+
+if(VCPKG_SETUP_CMAKE_PROGRAM_PATH)
+    set(tools_base_path "${VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/tools")
+    if(VCPKG_USE_HOST_TOOLS)
+        set(tools_base_path "${VCPKG_INSTALLED_DIR}/${VCPKG_HOST_TRIPLET}/tools")
+    endif()
+    list(APPEND CMAKE_PROGRAM_PATH "${tools_base_path}")
+    file(GLOB Z_VCPKG_TOOLS_DIRS LIST_DIRECTORIES true "${tools_base_path}/*")
+    file(GLOB Z_VCPKG_TOOLS_FILES LIST_DIRECTORIES false "${tools_base_path}/*")
+    file(GLOB Z_VCPKG_TOOLS_DIRS_BIN LIST_DIRECTORIES true "${tools_base_path}/*/bin")
+    file(GLOB Z_VCPKG_TOOLS_FILES_BIN LIST_DIRECTORIES false "${tools_base_path}/*/bin")
+    list(REMOVE_ITEM Z_VCPKG_TOOLS_DIRS ${Z_VCPKG_TOOLS_FILES} "") # need at least one item for REMOVE_ITEM if CMake <= 3.19
+    list(REMOVE_ITEM Z_VCPKG_TOOLS_DIRS_BIN ${Z_VCPKG_TOOLS_FILES_BIN} "")
+    string(REPLACE "/bin" "" Z_VCPKG_TOOLS_DIRS_TO_REMOVE "${Z_VCPKG_TOOLS_DIRS_BIN}")
+    list(REMOVE_ITEM Z_VCPKG_TOOLS_DIRS ${Z_VCPKG_TOOLS_DIRS_TO_REMOVE} "")
+    list(APPEND Z_VCPKG_TOOLS_DIRS ${Z_VCPKG_TOOLS_DIRS_BIN})
+    foreach(Z_VCPKG_TOOLS_DIR IN LISTS Z_VCPKG_TOOLS_DIRS)
+        list(APPEND CMAKE_PROGRAM_PATH "${Z_VCPKG_TOOLS_DIR}")
+    endforeach()
+    unset(Z_VCPKG_TOOLS_DIR)
+    unset(Z_VCPKG_TOOLS_DIRS)
+    unset(Z_VCPKG_TOOLS_FILES)
+    unset(Z_VCPKG_TOOLS_DIRS_BIN)
+    unset(Z_VCPKG_TOOLS_FILES_BIN)
+    unset(Z_VCPKG_TOOLS_DIRS_TO_REMOVE)
+    unset(tools_base_path)
+endif()
+
+cmake_policy(POP)
+
+function(add_executable)
+    z_vcpkg_function_arguments(ARGS)
+    _add_executable(${ARGS})
+    set(target_name "${ARGV0}")
+
+    list(FIND ARGV "IMPORTED" IMPORTED_IDX)
+    list(FIND ARGV "ALIAS" ALIAS_IDX)
+    list(FIND ARGV "MACOSX_BUNDLE" MACOSX_BUNDLE_IDX)
+    if(IMPORTED_IDX EQUAL "-1" AND ALIAS_IDX EQUAL "-1")
+        if(VCPKG_APPLOCAL_DEPS)
+            if(Z_VCPKG_TARGET_TRIPLET_PLAT MATCHES "windows|uwp|xbox")
+                z_vcpkg_set_powershell_path()
+                set(EXTRA_OPTIONS "")
+                if(X_VCPKG_APPLOCAL_DEPS_SERIALIZED)
+                    set(EXTRA_OPTIONS USES_TERMINAL)
+                endif()
+                add_custom_command(TARGET "${target_name}" POST_BUILD
+                    COMMAND "${Z_VCPKG_POWERSHELL_PATH}" -noprofile -executionpolicy Bypass -file "${Z_VCPKG_TOOLCHAIN_DIR}/msbuild/applocal.ps1"
+                        -targetBinary "$<TARGET_FILE:${target_name}>"
+                        -installedDir "${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}$<$<CONFIG:Debug>:/debug>/bin"
+                        -OutVariable out
+                    VERBATIM
+                    ${EXTRA_OPTIONS}
+                )
+            elseif(Z_VCPKG_TARGET_TRIPLET_PLAT MATCHES "osx")
+                if(NOT MACOSX_BUNDLE_IDX EQUAL "-1")
+                    find_package(Python COMPONENTS Interpreter)
+                    add_custom_command(TARGET "${target_name}" POST_BUILD
+                        COMMAND "${Python_EXECUTABLE}" "${Z_VCPKG_TOOLCHAIN_DIR}/osx/applocal.py"
+                            "$<TARGET_FILE:${target_name}>"
+                            "${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}$<$<CONFIG:Debug>:/debug>"
+                        VERBATIM
+                    )
+                endif()
+            endif()
+        endif()
+        set_target_properties("${target_name}" PROPERTIES VS_USER_PROPS do_not_import_user.props)
+        set_target_properties("${target_name}" PROPERTIES VS_GLOBAL_VcpkgEnabled false)
+    endif()
+endfunction()
+
+function(add_library)
+    z_vcpkg_function_arguments(ARGS)
+    _add_library(${ARGS})
+    set(target_name "${ARGV0}")
+
+    list(FIND ARGS "IMPORTED" IMPORTED_IDX)
+    list(FIND ARGS "INTERFACE" INTERFACE_IDX)
+    list(FIND ARGS "ALIAS" ALIAS_IDX)
+    if(IMPORTED_IDX EQUAL "-1" AND INTERFACE_IDX EQUAL "-1" AND ALIAS_IDX EQUAL "-1")
+        get_target_property(IS_LIBRARY_SHARED "${target_name}" TYPE)
+        if(VCPKG_APPLOCAL_DEPS AND Z_VCPKG_TARGET_TRIPLET_PLAT MATCHES "windows|uwp|xbox" AND (IS_LIBRARY_SHARED STREQUAL "SHARED_LIBRARY" OR IS_LIBRARY_SHARED STREQUAL "MODULE_LIBRARY"))
+            z_vcpkg_set_powershell_path()
+            add_custom_command(TARGET "${target_name}" POST_BUILD
+                COMMAND "${Z_VCPKG_POWERSHELL_PATH}" -noprofile -executionpolicy Bypass -file "${Z_VCPKG_TOOLCHAIN_DIR}/msbuild/applocal.ps1"
+                    -targetBinary "$<TARGET_FILE:${target_name}>"
+                    -installedDir "${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}$<$<CONFIG:Debug>:/debug>/bin"
+                    -OutVariable out
+                    VERBATIM
+            )
+        endif()
+        set_target_properties("${target_name}" PROPERTIES VS_USER_PROPS do_not_import_user.props)
+        set_target_properties("${target_name}" PROPERTIES VS_GLOBAL_VcpkgEnabled false)
+    endif()
+endfunction()
+
+# This is an experimental function to enable applocal install of dependencies as part of the `make install` process
+# Arguments:
+#   TARGETS - a list of installed targets to have dependencies copied for
+#   DESTINATION - the runtime directory for those targets (usually `bin`)
+#   COMPONENT - the component this install command belongs to (optional)
+#
+# Note that this function requires CMake 3.14 for policy CMP0087
+function(x_vcpkg_install_local_dependencies)
+    if(CMAKE_VERSION VERSION_LESS "3.14")
+        message(FATAL_ERROR "x_vcpkg_install_local_dependencies and X_VCPKG_APPLOCAL_DEPS_INSTALL require at least CMake 3.14
+(current version: ${CMAKE_VERSION})"
+        )
+    endif()
+
+    cmake_parse_arguments(PARSE_ARGV "0" arg
+        ""
+        "DESTINATION;COMPONENT"
+        "TARGETS"
+    )
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+    if(NOT DEFINED arg_DESTINATION)
+        message(FATAL_ERROR "DESTINATION must be specified")
+    endif()
+
+    if(Z_VCPKG_TARGET_TRIPLET_PLAT MATCHES "^(windows|uwp|xbox-.*)$")
+        # Install CODE|SCRIPT allow the use of generator expressions
+        cmake_policy(SET CMP0087 NEW) # CMake 3.14
+
+        z_vcpkg_set_powershell_path()
+        if(NOT IS_ABSOLUTE "${arg_DESTINATION}")
+            set(arg_DESTINATION "\${CMAKE_INSTALL_PREFIX}/${arg_DESTINATION}")
+        endif()
+
+        set(component_param "")
+        if(DEFINED arg_COMPONENT)
+            set(component_param COMPONENT "${arg_COMPONENT}")
+        endif()
+
+        set(allowed_target_types MODULE_LIBRARY SHARED_LIBRARY EXECUTABLE)
+        foreach(target IN LISTS arg_TARGETS)
+            get_target_property(target_type "${target}" TYPE)
+            if(target_type IN_LIST allowed_target_types)
+                install(CODE "message(\"-- Installing app dependencies for ${target}...\")
+                    execute_process(COMMAND \"${Z_VCPKG_POWERSHELL_PATH}\" -noprofile -executionpolicy Bypass -file \"${Z_VCPKG_TOOLCHAIN_DIR}/msbuild/applocal.ps1\"
+                        -targetBinary \"${arg_DESTINATION}/$<TARGET_FILE_NAME:${target}>\"
+                        -installedDir \"${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}$<$<CONFIG:Debug>:/debug>/bin\"
+                        -OutVariable out)"
+                    ${component_param}
+                )
+            endif()
+        endforeach()
+    endif()
+endfunction()
+
+if(X_VCPKG_APPLOCAL_DEPS_INSTALL)
+    function(install)
+        z_vcpkg_function_arguments(ARGS)
+        _install(${ARGS})
+
+        if(ARGV0 STREQUAL "TARGETS")
+            # Will contain the list of targets
+            set(parsed_targets "")
+
+            # Destination - [RUNTIME] DESTINATION argument overrides this
+            set(destination "bin")
+
+            set(component_param "")
+
+            # Parse arguments given to the install function to find targets and (runtime) destination
+            set(modifier "") # Modifier for the command in the argument
+            set(last_command "") # Last command we found to process
+            foreach(arg IN LISTS ARGS)
+                if(arg MATCHES "^(ARCHIVE|LIBRARY|RUNTIME|OBJECTS|FRAMEWORK|BUNDLE|PRIVATE_HEADER|PUBLIC_HEADER|RESOURCE|INCLUDES)$")
+                    set(modifier "${arg}")
+                    continue()
+                endif()
+                if(arg MATCHES "^(TARGETS|DESTINATION|PERMISSIONS|CONFIGURATIONS|COMPONENT|NAMELINK_COMPONENT|OPTIONAL|EXCLUDE_FROM_ALL|NAMELINK_ONLY|NAMELINK_SKIP|EXPORT|FILE_SET)$")
+                    set(last_command "${arg}")
+                    continue()
+                endif()
+
+                if(last_command STREQUAL "TARGETS")
+                    list(APPEND parsed_targets "${arg}")
+                endif()
+
+                if(last_command STREQUAL "DESTINATION" AND (modifier STREQUAL "" OR modifier STREQUAL "RUNTIME"))
+                    set(destination "${arg}")
+                endif()
+                if(last_command STREQUAL "COMPONENT" AND (modifier STREQUAL "" OR modifier STREQUAL "RUNTIME"))
+                    set(component_param "COMPONENT" "${arg}")
+                endif()
+            endforeach()
+
+            x_vcpkg_install_local_dependencies(
+                TARGETS ${parsed_targets}
+                DESTINATION "${destination}"
+                ${component_param}
+            )
+        endif()
+    endfunction()
+endif()
+
+option(VCPKG_TRACE_FIND_PACKAGE "Trace calls to find_package()" OFF)
+if(NOT DEFINED VCPKG_OVERRIDE_FIND_PACKAGE_NAME)
+    set(VCPKG_OVERRIDE_FIND_PACKAGE_NAME find_package)
+endif()
+# NOTE: this is not a function, which means that arguments _are not_ perfectly forwarded
+# this is fine for `find_package`, since there are no usecases for `;` in arguments,
+# so perfect forwarding is not important
+set(z_vcpkg_find_package_backup_id "0")
+macro("${VCPKG_OVERRIDE_FIND_PACKAGE_NAME}" z_vcpkg_find_package_package_name)
+    if(VCPKG_TRACE_FIND_PACKAGE)
+        string(REPEAT "  " "${z_vcpkg_find_package_backup_id}" z_vcpkg_find_package_indent)
+        string(JOIN " " z_vcpkg_find_package_argn ${ARGN})
+        message(STATUS "${z_vcpkg_find_package_indent}find_package(${z_vcpkg_find_package_package_name} ${z_vcpkg_find_package_argn})")
+        unset(z_vcpkg_find_package_argn)
+        unset(z_vcpkg_find_package_indent)
+    endif()
+
+    math(EXPR z_vcpkg_find_package_backup_id "${z_vcpkg_find_package_backup_id} + 1")
+    set(z_vcpkg_find_package_package_name "${z_vcpkg_find_package_package_name}")
+    set(z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_ARGN "${ARGN}")
+    set(z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_backup_vars "")
+
+    if(z_vcpkg_find_package_backup_id EQUAL "1")
+        # This is the top-level find_package call
+        if("${VCPKG_LOCK_FIND_PACKAGE_${z_vcpkg_find_package_package_name}}")
+            # Avoid CMake warning when both REQUIRED and CMAKE_REQUIRE_FIND_PACKAGE_<Pkg> are used
+            if(NOT "REQUIRED" IN_LIST "z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_ARGN")
+                list(APPEND "z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_backup_vars" "CMAKE_REQUIRE_FIND_PACKAGE_${z_vcpkg_find_package_package_name}")
+                if(DEFINED "CMAKE_REQUIRE_FIND_PACKAGE_${z_vcpkg_find_package_package_name}")
+                    set("z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_backup_CMAKE_REQUIRE_FIND_PACKAGE_${z_vcpkg_find_package_package_name}" "${CMAKE_REQUIRE_FIND_PACKAGE_${z_vcpkg_find_package_package_name}}")
+                endif()
+                set("CMAKE_REQUIRE_FIND_PACKAGE_${z_vcpkg_find_package_package_name}" 1)
+            endif()
+            if(VCPKG_TRACE_FIND_PACKAGE)
+                message(STATUS "  (required by VCPKG_LOCK_FIND_PACKAGE_${z_vcpkg_find_package_package_name}=${VCPKG_LOCK_FIND_PACKAGE_${z_vcpkg_find_package_package_name}})")
+            endif()
+        elseif(DEFINED "VCPKG_LOCK_FIND_PACKAGE_${z_vcpkg_find_package_package_name}")
+            list(APPEND "z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_backup_vars" "CMAKE_DISABLE_FIND_PACKAGE_${z_vcpkg_find_package_package_name}")
+            if(DEFINED "CMAKE_DISABLE_FIND_PACKAGE_${z_vcpkg_find_package_package_name}")
+                set("z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_backup_CMAKE_DISABLE_FIND_PACKAGE_${z_vcpkg_find_package_package_name}" "${CMAKE_DISABLE_FIND_PACKAGE_${z_vcpkg_find_package_package_name}}")
+            endif()
+            # We don't need to worry about clearing this for transitive users because
+            # once this top level find_package is disabled, we immediately will return
+            # not found and not try to visit transitive dependencies in the first place.
+            set("CMAKE_DISABLE_FIND_PACKAGE_${z_vcpkg_find_package_package_name}" 1)
+            if(VCPKG_TRACE_FIND_PACKAGE)
+                message(STATUS "  (disabled by VCPKG_LOCK_FIND_PACKAGE_${z_vcpkg_find_package_package_name}=${VCPKG_LOCK_FIND_PACKAGE_${z_vcpkg_find_package_package_name}})")
+            endif()
+        elseif(VCPKG_TRACE_FIND_PACKAGE)
+            message(STATUS "  (could be controlled by VCPKG_LOCK_FIND_PACKAGE_${z_vcpkg_find_package_package_name})")
+        endif()
+    endif()
+
+    # Workaround to set the ROOT_PATH until upstream CMake stops overriding
+    # the ROOT_PATH at apple OS initialization phase.
+    # See https://gitlab.kitware.com/cmake/cmake/merge_requests/3273
+    # Fixed in CMake 3.15
+    if(CMAKE_SYSTEM_NAME STREQUAL "iOS" OR CMAKE_SYSTEM_NAME STREQUAL "watchOS" OR CMAKE_SYSTEM_NAME STREQUAL "tvOS" OR CMAKE_SYSTEM_NAME STREQUAL "visionOS")
+        list(APPEND z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_backup_vars "CMAKE_FIND_ROOT_PATH")
+        if(DEFINED CMAKE_FIND_ROOT_PATH)
+            set(z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_backup_CMAKE_FIND_ROOT_PATH "${CMAKE_FIND_ROOT_PATH}")
+        endif()
+        list(APPEND CMAKE_FIND_ROOT_PATH "${VCPKG_CMAKE_FIND_ROOT_PATH}")
+    endif()
+
+    string(TOLOWER "${z_vcpkg_find_package_package_name}" z_vcpkg_find_package_lowercase_package_name)
+    set(z_vcpkg_find_package_vcpkg_cmake_wrapper_path
+        "${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/share/${z_vcpkg_find_package_lowercase_package_name}/vcpkg-cmake-wrapper.cmake")
+    if(CMAKE_DISABLE_FIND_PACKAGE_${z_vcpkg_find_package_package_name})
+        # Skip wrappers, fail if REQUIRED.
+        _find_package("${z_vcpkg_find_package_package_name}" ${z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_ARGN})
+    elseif(EXISTS "${z_vcpkg_find_package_vcpkg_cmake_wrapper_path}")
+        if(VCPKG_TRACE_FIND_PACKAGE)
+            string(REPEAT "  " "${z_vcpkg_find_package_backup_id}" z_vcpkg_find_package_indent)
+            message(STATUS "${z_vcpkg_find_package_indent}using share/${z_vcpkg_find_package_lowercase_package_name}/vcpkg-cmake-wrapper.cmake")
+            unset(z_vcpkg_find_package_indent)
+        endif()
+        list(APPEND z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_backup_vars "ARGS")
+        if(DEFINED ARGS)
+            set(z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_backup_ARGS "${ARGS}")
+        endif()
+        set(ARGS "${z_vcpkg_find_package_package_name};${z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_ARGN}")
+        include("${z_vcpkg_find_package_vcpkg_cmake_wrapper_path}")
+    elseif(z_vcpkg_find_package_package_name STREQUAL "Boost" AND EXISTS "${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/include/boost")
+        # Checking for the boost headers disables this wrapper unless the user has installed at least one boost library
+        # these intentionally are not backed up
+        set(Boost_USE_STATIC_LIBS OFF)
+        set(Boost_USE_MULTITHREADED ON)
+        set(Boost_NO_BOOST_CMAKE ON)
+        set(Boost_USE_STATIC_RUNTIME)
+        unset(Boost_USE_STATIC_RUNTIME CACHE)
+        if(CMAKE_VS_PLATFORM_TOOLSET STREQUAL "v120")
+            set(Boost_COMPILER "-vc120")
+        else()
+            set(Boost_COMPILER "-vc140")
+        endif()
+        _find_package("${z_vcpkg_find_package_package_name}" ${z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_ARGN})
+    elseif(z_vcpkg_find_package_package_name STREQUAL "ICU" AND EXISTS "${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/include/unicode/utf.h")
+        list(FIND z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_ARGN "COMPONENTS" z_vcpkg_find_package_COMPONENTS_IDX)
+        if(NOT z_vcpkg_find_package_COMPONENTS_IDX EQUAL "-1")
+            _find_package("${z_vcpkg_find_package_package_name}" ${z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_ARGN} COMPONENTS data)
+        else()
+            _find_package("${z_vcpkg_find_package_package_name}" ${z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_ARGN})
+        endif()
+    elseif(z_vcpkg_find_package_package_name STREQUAL "GSL" AND EXISTS "${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/include/gsl")
+        _find_package("${z_vcpkg_find_package_package_name}" ${z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_ARGN})
+        if(GSL_FOUND AND TARGET GSL::gsl)
+            set_property( TARGET GSL::gslcblas APPEND PROPERTY IMPORTED_CONFIGURATIONS Release )
+            set_property( TARGET GSL::gsl APPEND PROPERTY IMPORTED_CONFIGURATIONS Release )
+            if( EXISTS "${GSL_LIBRARY_DEBUG}" AND EXISTS "${GSL_CBLAS_LIBRARY_DEBUG}")
+                set_property( TARGET GSL::gsl APPEND PROPERTY IMPORTED_CONFIGURATIONS Debug )
+                set_target_properties( GSL::gsl PROPERTIES IMPORTED_LOCATION_DEBUG "${GSL_LIBRARY_DEBUG}" )
+                set_property( TARGET GSL::gslcblas APPEND PROPERTY IMPORTED_CONFIGURATIONS Debug )
+                set_target_properties( GSL::gslcblas PROPERTIES IMPORTED_LOCATION_DEBUG "${GSL_CBLAS_LIBRARY_DEBUG}" )
+            endif()
+        endif()
+    elseif("${z_vcpkg_find_package_package_name}" STREQUAL "CURL" AND EXISTS "${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/include/curl")
+        _find_package("${z_vcpkg_find_package_package_name}" ${z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_ARGN})
+        if(CURL_FOUND)
+            if(EXISTS "${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/lib/nghttp2.lib")
+                list(APPEND CURL_LIBRARIES
+                    "debug" "${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/debug/lib/nghttp2.lib"
+                    "optimized" "${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/lib/nghttp2.lib")
+            endif()
+        endif()
+    elseif("${z_vcpkg_find_package_lowercase_package_name}" STREQUAL "grpc" AND EXISTS "${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/share/grpc")
+        _find_package(gRPC ${z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_ARGN})
+    else()
+        _find_package("${z_vcpkg_find_package_package_name}" ${z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_ARGN})
+    endif()
+    # Do not use z_vcpkg_find_package_package_name beyond this point since it might have changed!
+    # Only variables using z_vcpkg_find_package_backup_id can used correctly below!
+    foreach(z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_backup_var IN LISTS z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_backup_vars)
+        if(DEFINED z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_backup_${z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_backup_var})
+            set("${z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_backup_var}" "${z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_backup_${z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_backup_var}}")
+        else()
+            unset("${z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_backup_var}")
+        endif()
+        unset("z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_backup_${z_vcpkg_find_package_${z_vcpkg_find_package_backup_id}_backup_var}")
+    endforeach()
+    math(EXPR z_vcpkg_find_package_backup_id "${z_vcpkg_find_package_backup_id} - 1")
+    if(z_vcpkg_find_package_backup_id LESS "0")
+        message(FATAL_ERROR "[vcpkg]: find_package ended with z_vcpkg_find_package_backup_id being less than 0! This is a logical error and should never happen. Please provide a cmake trace log via cmake cmd line option '--trace-expand'!")
+    endif()
+endmacro()
+
+cmake_policy(PUSH)
+cmake_policy(VERSION 3.16)
+
+set(VCPKG_TOOLCHAIN ON)
+set(Z_VCPKG_UNUSED "${CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION}")
+set(Z_VCPKG_UNUSED "${CMAKE_EXPORT_NO_PACKAGE_REGISTRY}")
+set(Z_VCPKG_UNUSED "${CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY}")
+set(Z_VCPKG_UNUSED "${CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY}")
+set(Z_VCPKG_UNUSED "${CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP}")
+
+# Propagate these values to try-compile configurations so the triplet and toolchain load
+if(NOT Z_VCPKG_CMAKE_IN_TRY_COMPILE)
+    list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES
+        VCPKG_TARGET_TRIPLET
+        VCPKG_TARGET_ARCHITECTURE
+        VCPKG_HOST_TRIPLET
+        VCPKG_INSTALLED_DIR
+        VCPKG_PREFER_SYSTEM_LIBS
+        # VCPKG_APPLOCAL_DEPS # This should be off within try_compile!
+        VCPKG_CHAINLOAD_TOOLCHAIN_FILE
+        Z_VCPKG_ROOT_DIR
+    )
+else()
+    set(VCPKG_APPLOCAL_DEPS OFF)
+endif()
+
+if(Z_VCPKG_HAS_FATAL_ERROR)
+    message(FATAL_ERROR "${Z_VCPKG_FATAL_ERROR}")
+endif()
+
+cmake_policy(POP)