[Windows] Improve build environment detection, add support for Windows on ARM.

core/config/engine.cpp

@@ -191,11 +191,11 @@ String Engine::get_architecture_name() const {
 #elif defined(__i386) || defined(__i386__) || defined(_M_IX86)
 	return "x86_32";
 
-#elif defined(__aarch64__) || defined(_M_ARM64)
+#elif defined(__aarch64__) || defined(_M_ARM64) || defined(_M_ARM64EC)
 	return "arm64";
 
-#elif defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7S__)
-	return "armv7";
+#elif defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7S__) || defined(_M_ARM)
+	return "arm32";
 
 #elif defined(__riscv)
 #if __riscv_xlen == 8

modules/raycast/config.py

@@ -1,5 +1,8 @@
 def can_build(env, platform):
     # Depends on Embree library, which only supports x86_64 and arm64.
+    if platform == "windows":
+        return env["arch"] == "x86_64"  # TODO build for Windows on ARM
+
     return env["arch"] in ["x86_64", "arm64"]
 
 

platform/windows/crash_handler_windows.cpp

@@ -173,10 +173,18 @@ DWORD CrashHandlerException(EXCEPTION_POINTERS *ep) {
 	frame.AddrStack.Mode = AddrModeFlat;
 	frame.AddrFrame.Mode = AddrModeFlat;
 
-#ifdef _M_X64
+#if defined(_M_X64)
 	frame.AddrPC.Offset = context->Rip;
 	frame.AddrStack.Offset = context->Rsp;
 	frame.AddrFrame.Offset = context->Rbp;
+#elif defined(_M_ARM64) || defined(_M_ARM64EC)
+	frame.AddrPC.Offset = context->Pc;
+	frame.AddrStack.Offset = context->Sp;
+	frame.AddrFrame.Offset = context->Fp;
+#elif defined(_M_ARM)
+	frame.AddrPC.Offset = context->Pc;
+	frame.AddrStack.Offset = context->Sp;
+	frame.AddrFrame.Offset = context->R11;
 #else
 	frame.AddrPC.Offset = context->Eip;
 	frame.AddrStack.Offset = context->Esp;

platform/windows/detect.py

@@ -1,5 +1,7 @@
 import methods
 import os
+import subprocess
+import sys
 from platform_methods import detect_arch
 
 # To match other platforms
@@ -14,6 +16,38 @@ def get_name():
     return "Windows"
 
 
+def try_cmd(test, prefix, arch):
+    if arch:
+        try:
+            out = subprocess.Popen(
+                get_mingw_bin_prefix(prefix, arch) + test,
+                shell=True,
+                stderr=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+            )
+            out.communicate()
+            if out.returncode == 0:
+                return True
+        except Exception:
+            pass
+    else:
+        for a in ["x86_64", "x86_32", "arm64", "arm32"]:
+            try:
+                out = subprocess.Popen(
+                    get_mingw_bin_prefix(prefix, a) + test,
+                    shell=True,
+                    stderr=subprocess.PIPE,
+                    stdout=subprocess.PIPE,
+                )
+                out.communicate()
+                if out.returncode == 0:
+                    return True
+            except Exception:
+                pass
+
+    return False
+
+
 def can_build():
     if os.name == "nt":
         # Building natively on Windows
@@ -21,7 +55,7 @@ def can_build():
         if os.getenv("VCINSTALLDIR"):  # MSVC, manual setup
             return True
 
-        # Otherwise, let SCons find MSVC if installed, or else Mingw.
+        # Otherwise, let SCons find MSVC if installed, or else MinGW.
         # Since we're just returning True here, if there's no compiler
         # installed, we'll get errors when it tries to build with the
         # null compiler.
@@ -29,47 +63,132 @@ def can_build():
 
     if os.name == "posix":
         # Cross-compiling with MinGW-w64 (old MinGW32 is not supported)
-        mingw32 = "i686-w64-mingw32-"
-        mingw64 = "x86_64-w64-mingw32-"
+        prefix = os.getenv("MINGW_PREFIX", "")
 
-        if os.getenv("MINGW32_PREFIX"):
-            mingw32 = os.getenv("MINGW32_PREFIX")
-        if os.getenv("MINGW64_PREFIX"):
-            mingw64 = os.getenv("MINGW64_PREFIX")
-
-        test = "gcc --version > /dev/null 2>&1"
-        if os.system(mingw64 + test) == 0 or os.system(mingw32 + test) == 0:
+        if try_cmd("gcc --version", prefix, "") or try_cmd("clang --version", prefix, ""):
             return True
 
     return False
 
 
+def get_mingw_bin_prefix(prefix, arch):
+    if not prefix:
+        mingw_bin_prefix = ""
+    elif prefix[-1] != "/":
+        mingw_bin_prefix = prefix + "/bin/"
+    else:
+        mingw_bin_prefix = prefix + "bin/"
+
+    if arch == "x86_64":
+        mingw_bin_prefix += "x86_64-w64-mingw32-"
+    elif arch == "x86_32":
+        mingw_bin_prefix += "i686-w64-mingw32-"
+    elif arch == "arm32":
+        mingw_bin_prefix += "armv7-w64-mingw32-"
+    elif arch == "arm64":
+        mingw_bin_prefix += "aarch64-w64-mingw32-"
+
+    return mingw_bin_prefix
+
+
+def detect_build_env_arch():
+    msvc_target_aliases = {
+        "amd64": "x86_64",
+        "i386": "x86_32",
+        "i486": "x86_32",
+        "i586": "x86_32",
+        "i686": "x86_32",
+        "x86": "x86_32",
+        "x64": "x86_64",
+        "x86_64": "x86_64",
+        "arm": "arm32",
+        "arm64": "arm64",
+        "aarch64": "arm64",
+    }
+    if os.getenv("VCINSTALLDIR") or os.getenv("VCTOOLSINSTALLDIR"):
+        if os.getenv("Platform"):
+            msvc_arch = os.getenv("Platform").lower()
+            if msvc_arch in msvc_target_aliases.keys():
+                return msvc_target_aliases[msvc_arch]
+
+        if os.getenv("VSCMD_ARG_TGT_ARCH"):
+            msvc_arch = os.getenv("VSCMD_ARG_TGT_ARCH").lower()
+            if msvc_arch in msvc_target_aliases.keys():
+                return msvc_target_aliases[msvc_arch]
+
+        # Pre VS 2017 checks.
+        if os.getenv("VCINSTALLDIR"):
+            PATH = os.getenv("PATH").upper()
+            VCINSTALLDIR = os.getenv("VCINSTALLDIR").upper()
+            path_arch = {
+                "BIN\\x86_ARM;": "arm32",
+                "BIN\\amd64_ARM;": "arm32",
+                "BIN\\x86_ARM64;": "arm64",
+                "BIN\\amd64_ARM64;": "arm64",
+                "BIN\\x86_amd64;": "a86_64",
+                "BIN\\amd64;": "x86_64",
+                "BIN\\amd64_x86;": "x86_32",
+                "BIN;": "x86_32",
+            }
+            for path, arch in path_arch.items():
+                final_path = VCINSTALLDIR + path
+                if final_path in PATH:
+                    return arch
+
+        # VS 2017 and newer.
+        if os.getenv("VCTOOLSINSTALLDIR"):
+            host_path_index = os.getenv("PATH").upper().find(os.getenv("VCTOOLSINSTALLDIR").upper() + "BIN\\HOST")
+            if host_path_index > -1:
+                first_path_arch = os.getenv("PATH").split(";")[0].rsplit("\\", 1)[-1].lower()
+                return msvc_target_aliases[first_path_arch]
+
+    msys_target_aliases = {
+        "mingw32": "x86_32",
+        "mingw64": "x86_64",
+        "ucrt64": "x86_64",
+        "clang64": "x86_64",
+        "clang32": "x86_32",
+        "clangarm64": "arm64",
+    }
+    if os.getenv("MSYSTEM"):
+        msys_arch = os.getenv("MSYSTEM").lower()
+        if msys_arch in msys_target_aliases.keys():
+            return msys_target_aliases[msys_arch]
+
+    return ""
+
+
 def get_opts():
     from SCons.Variables import BoolVariable, EnumVariable
 
-    # TODO: These shouldn't be hard-coded for x86.
-    mingw32 = ""
-    mingw64 = ""
-    if os.name == "posix":
-        mingw32 = "i686-w64-mingw32-"
-        mingw64 = "x86_64-w64-mingw32-"
-
-    if os.getenv("MINGW32_PREFIX"):
-        mingw32 = os.getenv("MINGW32_PREFIX")
-    if os.getenv("MINGW64_PREFIX"):
-        mingw64 = os.getenv("MINGW64_PREFIX")
+    mingw = os.getenv("MINGW_PREFIX", "")
 
     return [
-        ("mingw_prefix_32", "MinGW prefix (Win32)", mingw32),
-        ("mingw_prefix_64", "MinGW prefix (Win64)", mingw64),
+        ("mingw_prefix", "MinGW prefix", mingw),
         # Targeted Windows version: 7 (and later), minimum supported version
         # XP support dropped after EOL due to missing API for IPv6 and other issues
         # Vista support dropped after EOL due to GH-10243
-        ("target_win_version", "Targeted Windows version, >= 0x0601 (Windows 7)", "0x0601"),
-        BoolVariable("debug_symbols", "Add debugging symbols to release/release_debug builds", True),
+        (
+            "target_win_version",
+            "Targeted Windows version, >= 0x0601 (Windows 7)",
+            "0x0601",
+        ),
+        BoolVariable(
+            "debug_symbols",
+            "Add debugging symbols to release/release_debug builds",
+            True,
+        ),
         EnumVariable("windows_subsystem", "Windows subsystem", "gui", ("gui", "console")),
-        BoolVariable("separate_debug_symbols", "Create a separate file containing debugging symbols", False),
-        ("msvc_version", "MSVC version to use. Ignored if VCINSTALLDIR is set in shell env.", None),
+        BoolVariable(
+            "separate_debug_symbols",
+            "Create a separate file containing debugging symbols",
+            False,
+        ),
+        (
+            "msvc_version",
+            "MSVC version to use. Ignored if VCINSTALLDIR is set in shell env.",
+            None,
+        ),
         BoolVariable("use_mingw", "Use the Mingw compiler, even if MSVC is installed.", False),
         BoolVariable("use_llvm", "Use the LLVM compiler", False),
         BoolVariable("use_thinlto", "Use ThinLTO", False),
@@ -79,73 +198,63 @@ def get_opts():
 
 
 def get_flags():
+    arch = detect_build_env_arch() or detect_arch()
+
     return [
-        ("arch", detect_arch()),
+        ("arch", arch),
     ]
 
 
 def build_res_file(target, source, env):
-    # TODO: This shouldn't be hard-coded for x86.
-    if env["arch"] == "x86_32":
-        cmdbase = env["mingw_prefix_32"]
-    else:
-        cmdbase = env["mingw_prefix_64"]
-    cmdbase = cmdbase + "windres --include-dir . "
-    import subprocess
+    arch_aliases = {
+        "x86_32": "pe-i386",
+        "x86_64": "pe-x86-64",
+        "arm32": "armv7-w64-mingw32",
+        "arm64": "aarch64-w64-mingw32",
+    }
+    cmdbase = "windres --include-dir . --target=" + arch_aliases[env["arch"]]
+
+    mingw_bin_prefix = get_mingw_bin_prefix(env["mingw_prefix"], env["arch"])
 
     for x in range(len(source)):
-        cmd = cmdbase + "-i " + str(source[x]) + " -o " + str(target[x])
+        ok = True
+        # Try prefixed executable (MinGW on Linux).
+        cmd = mingw_bin_prefix + cmdbase + " -i " + str(source[x]) + " -o " + str(target[x])
         try:
             out = subprocess.Popen(cmd, shell=True, stderr=subprocess.PIPE).communicate()
             if len(out[1]):
-                return 1
+                ok = False
         except Exception:
-            return 1
+            ok = False
+
+        # Try generic executable (MSYS2).
+        if not ok:
+            cmd = cmdbase + " -i " + str(source[x]) + " -o " + str(target[x])
+            try:
+                out = subprocess.Popen(cmd, shell=True, stderr=subprocess.PIPE).communicate()
+                if len(out[1]):
+                    return -1
+            except Exception:
+                return -1
+
     return 0
 
 
 def setup_msvc_manual(env):
-    # FIXME: This is super hacky, and probably obsolete.
-    # Won't work with detect_arch() used for `arch` by default.
+    """Running from VCVARS environment"""
 
-    """Set up env to use MSVC manually, using VCINSTALLDIR"""
-    if env["arch"] != "auto":
+    env_arch = detect_build_env_arch()
+    if env["arch"] != env_arch:
         print(
             """
-            Arch argument is not supported for MSVC manual configuration (VCINSTALLDIR configured).
-            Architecture depends on the Native/Cross Compile Tools Prompt/Developer Console (or Visual Studio settings) that is being used to run SCons.
-            As a consequence, the arch argument is disabled. Run scons again without arch argument (example: scons p=windows)
-            and SCons will attempt to detect what MSVC compiler will be executed and inform you.
+            Arch argument (%s) is not matching Native/Cross Compile Tools Prompt/Developer Console (or Visual Studio settings) that is being used to run SCons (%s).
+            Run SCons again without arch argument (example: scons p=windows) and SCons will attempt to detect what MSVC compiler will be executed and inform you.
             """
+            % (env["arch"], env_arch)
         )
-        raise SCons.Errors.UserError("Arch argument should not be used when using VCINSTALLDIR")
-
-    # Force ARCH arg
-    # (Actually msys2 mingw can support 64-bit, we could detect that)
-    # TODO: This is wrong, but not sure what to do about it.
-    # We want to determine the arch and bitness in the SConstruct only.
-    # We can check if it's correct in here, but if it's not, it should
-    # just fail with an error message instead of trying to force it.
-
-    # find compiler manually
-    compiler_version_str = methods.detect_visual_c_compiler_version(env["ENV"])
-    print("Found MSVC compiler: " + compiler_version_str)
-
-    # If building for 64bit architecture, disable assembly optimisations for 32 bit builds (theora as of writing)... vc compiler for 64bit can not compile _asm
-    if compiler_version_str == "amd64" or compiler_version_str == "x86_amd64":
-        env["arch"] = "x86_64"
-        env["x86_libtheora_opt_vc"] = False
-        print("Compiled program architecture will be a 64 bit executable (forcing arch=x86_64).")
-    elif compiler_version_str == "x86" or compiler_version_str == "amd64_x86":
-        env["arch"] = "x86_32"
-        env["x86_libtheora_opt_vc"] = True
-        print("Compiled program architecture will be a 32 bit executable (forcing arch=x86_32).")
-    else:
-        print(
-            "Failed to manually detect MSVC compiler architecture version.\n"
-            "You should check your settings/compilation setup, or avoid setting VCINSTALLDIR."
-        )
-        sys.exit()
+        sys.exit(200)
+
+    print("Found MSVC, arch %s" % (env_arch))
 
 
 def setup_msvc_auto(env):
@@ -179,23 +288,50 @@ def setup_msvc_auto(env):
         env["MSVC_VERSION"] = env["msvc_version"]
     env.Tool("msvc")
     env.Tool("mssdk")  # we want the MS SDK
+
     # Note: actual compiler version can be found in env['MSVC_VERSION'], e.g. "14.1" for VS2015
-    print("Found MSVC version %s, arch %s" % (env["MSVC_VERSION"], env["TARGET_ARCH"]))
-    if env["arch"] == "x86_32":
-        env["x86_libtheora_opt_vc"] = False
+    print("Found MSVC version %s, arch %s" % (env["MSVC_VERSION"], env["arch"]))
 
 
 def setup_mingw(env):
     """Set up env for use with mingw"""
-    # Nothing to do here
-    print("Using MinGW")
+
+    env_arch = detect_build_env_arch()
+    if os.getenv("MSYSTEM") == "MSYS":
+        print(
+            """
+            Running from base MSYS2 console/environment, use target specific environment instead (e.g., mingw32, mingw64, clang32, clang64).
+            """
+        )
+        sys.exit(201)
+
+    if env_arch != "" and env["arch"] != env_arch:
+        print(
+            """
+            Arch argument (%s) is not matching MSYS2 console/environment that is being used to run SCons (%s).
+            Run SCons again without arch argument (example: scons p=windows) and SCons will attempt to detect what MSYS2 compiler will be executed and inform you.
+            """
+            % (env["arch"], env_arch)
+        )
+        sys.exit(202)
+
+    if not try_cmd("gcc --version", env["mingw_prefix"], env["arch"]) and not try_cmd(
+        "clang --version", env["mingw_prefix"], env["arch"]
+    ):
+        print(
+            """
+            No valid compilers found, use MINGW_PREFIX environment variable to set MinGW path.
+            """
+        )
+        sys.exit(202)
+
+    print("Using MinGW, arch %s" % (env["arch"]))
 
 
-def configure_msvc(env, manual_msvc_config):
+def configure_msvc(env, vcvars_msvc_config):
     """Configure env to work with MSVC"""
 
     # Build type
-
     if env["target"] == "release":
         if env["optimize"] == "speed":  # optimize for speed (default)
             env.Append(CCFLAGS=["/O2"])
@@ -235,6 +371,9 @@ def configure_msvc(env, manual_msvc_config):
     else:
         env.AppendUnique(CCFLAGS=["/MD"])
 
+    if env["arch"] == "x86_32":
+        env["x86_libtheora_opt_vc"] = True
+
     env.AppendUnique(CCFLAGS=["/Gd", "/GR", "/nologo"])
     env.AppendUnique(CCFLAGS=["/utf-8"])  # Force to use Unicode encoding.
     env.AppendUnique(CXXFLAGS=["/TP"])  # assume all sources are C++
@@ -243,7 +382,7 @@ def configure_msvc(env, manual_msvc_config):
     # for notes on why this shouldn't be enabled for gcc
     env.AppendUnique(CCFLAGS=["/bigobj"])
 
-    if manual_msvc_config:  # should be automatic if SCons found it
+    if vcvars_msvc_config:  # should be automatic if SCons found it
         if os.getenv("WindowsSdkDir") is not None:
             env.Prepend(CPPPATH=[os.getenv("WindowsSdkDir") + "/Include"])
         else:
@@ -302,7 +441,7 @@ def configure_msvc(env, manual_msvc_config):
 
     env.Append(LINKFLAGS=[p + env["LIBSUFFIX"] for p in LIBS])
 
-    if manual_msvc_config:
+    if vcvars_msvc_config:
         if os.getenv("WindowsSdkDir") is not None:
             env.Append(LIBPATH=[os.getenv("WindowsSdkDir") + "/Lib"])
         else:
@@ -318,7 +457,7 @@ def configure_msvc(env, manual_msvc_config):
         else:
             env.AppendUnique(LINKFLAGS=["/LTCG"])
 
-    if manual_msvc_config:
+    if vcvars_msvc_config:
         env.Prepend(CPPPATH=[p for p in os.getenv("INCLUDE").split(";")])
         env.Append(LIBPATH=[p for p in os.getenv("LIB").split(";")])
 
@@ -342,6 +481,12 @@ def configure_mingw(env):
 
     ## Build type
 
+    if not env["use_llvm"] and not try_cmd("gcc --version", env["mingw_prefix"], env["arch"]):
+        env["use_llvm"] = True
+
+    if env["use_llvm"] and not try_cmd("clang --version", env["mingw_prefix"], env["arch"]):
+        env["use_llvm"] = False
+
     if env["target"] == "release":
         env.Append(CCFLAGS=["-msse2"])
 
@@ -383,36 +528,39 @@ def configure_mingw(env):
     if os.name != "nt":
         env["PROGSUFFIX"] = env["PROGSUFFIX"] + ".exe"  # for linux cross-compilation
 
-    mingw_prefix = ""
-
-    # TODO: This doesn't seem to be working, or maybe I just have
-    # MinGW set up incorrectly. It always gives me x86_64 builds,
-    # even though arch == "x86_32" and the file name has x86_32 in it.
     if env["arch"] == "x86_32":
         if env["use_static_cpp"]:
             env.Append(LINKFLAGS=["-static"])
             env.Append(LINKFLAGS=["-static-libgcc"])
             env.Append(LINKFLAGS=["-static-libstdc++"])
-        mingw_prefix = env["mingw_prefix_32"]
     else:
         if env["use_static_cpp"]:
             env.Append(LINKFLAGS=["-static"])
-        mingw_prefix = env["mingw_prefix_64"]
+
+    if env["arch"] in ["x86_32", "x86_64"]:
+        env["x86_libtheora_opt_gcc"] = True
+
+    mingw_bin_prefix = get_mingw_bin_prefix(env["mingw_prefix"], env["arch"])
 
     if env["use_llvm"]:
-        env["CC"] = mingw_prefix + "clang"
-        env["CXX"] = mingw_prefix + "clang++"
-        env["AS"] = mingw_prefix + "as"
-        env["AR"] = mingw_prefix + "ar"
-        env["RANLIB"] = mingw_prefix + "ranlib"
+        env["CC"] = mingw_bin_prefix + "clang"
+        env["CXX"] = mingw_bin_prefix + "clang++"
+        if try_cmd("as --version", env["mingw_prefix"], env["arch"]):
+            env["AS"] = mingw_bin_prefix + "as"
+        if try_cmd("ar --version", env["mingw_prefix"], env["arch"]):
+            env["AR"] = mingw_bin_prefix + "ar"
+        if try_cmd("ranlib --version", env["mingw_prefix"], env["arch"]):
+            env["RANLIB"] = mingw_bin_prefix + "ranlib"
+        env.extra_suffix = ".llvm" + env.extra_suffix
     else:
-        env["CC"] = mingw_prefix + "gcc"
-        env["CXX"] = mingw_prefix + "g++"
-        env["AS"] = mingw_prefix + "as"
-        env["AR"] = mingw_prefix + "gcc-ar"
-        env["RANLIB"] = mingw_prefix + "gcc-ranlib"
-
-    env["x86_libtheora_opt_gcc"] = True
+        env["CC"] = mingw_bin_prefix + "gcc"
+        env["CXX"] = mingw_bin_prefix + "g++"
+        if try_cmd("as --version", env["mingw_prefix"], env["arch"]):
+            env["AS"] = mingw_bin_prefix + "as"
+        if try_cmd("gcc-ar --version", env["mingw_prefix"], env["arch"]):
+            env["AR"] = mingw_bin_prefix + "gcc-ar"
+        if try_cmd("gcc-ranlib --version", env["mingw_prefix"], env["arch"]):
+            env["RANLIB"] = mingw_bin_prefix + "gcc-ranlib"
 
     if env["use_lto"]:
         if not env["use_llvm"] and env.GetOption("num_jobs") > 1:
@@ -430,10 +578,16 @@ def configure_mingw(env):
 
     ## Compile flags
 
-    env.Append(CCFLAGS=["-mwindows"])
+    if not env["use_llvm"]:
+        env.Append(CCFLAGS=["-mwindows"])
 
     env.Append(CPPDEFINES=["WINDOWS_ENABLED", "WASAPI_ENABLED", "WINMIDI_ENABLED"])
-    env.Append(CPPDEFINES=[("WINVER", env["target_win_version"]), ("_WIN32_WINNT", env["target_win_version"])])
+    env.Append(
+        CPPDEFINES=[
+            ("WINVER", env["target_win_version"]),
+            ("_WIN32_WINNT", env["target_win_version"]),
+        ]
+    )
     env.Append(
         LIBS=[
             "mingw32",
@@ -492,22 +646,21 @@ def configure(env):
         env["ENV"]["TMP"] = os.environ["TMP"]
 
     # First figure out which compiler, version, and target arch we're using
-    if os.getenv("VCINSTALLDIR") and not env["use_mingw"]:
-        # Manual setup of MSVC
+    if os.getenv("VCINSTALLDIR") and detect_build_env_arch() and not env["use_mingw"]:
         setup_msvc_manual(env)
         env.msvc = True
-        manual_msvc_config = True
+        vcvars_msvc_config = True
     elif env.get("MSVC_VERSION", "") and not env["use_mingw"]:
         setup_msvc_auto(env)
         env.msvc = True
-        manual_msvc_config = False
+        vcvars_msvc_config = False
     else:
         setup_mingw(env)
         env.msvc = False
 
     # Now set compiler/linker flags
     if env.msvc:
-        configure_msvc(env, manual_msvc_config)
+        configure_msvc(env, vcvars_msvc_config)
 
     else:  # MinGW
         configure_mingw(env)

platform/windows/export/export_plugin.cpp

@@ -123,7 +123,7 @@ bool EditorExportPlatformWindows::get_export_option_visibility(const EditorExpor
 
 void EditorExportPlatformWindows::get_export_options(List<ExportOption> *r_options) {
 	EditorExportPlatformPC::get_export_options(r_options);
-	r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "binary_format/architecture", PROPERTY_HINT_ENUM, "x86_64,x86_32"), "x86_64"));
+	r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "binary_format/architecture", PROPERTY_HINT_ENUM, "x86_64,x86_32,arm64"), "x86_64"));
 
 	r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "codesign/enable"), false));
 	r_options->push_back(ExportOption(PropertyInfo(Variant::INT, "codesign/identity_type", PROPERTY_HINT_ENUM, "Select automatically,Use PKCS12 file (specify *.PFX/*.P12 file),Use certificate store (specify SHA1 hash)"), 0));

thirdparty/README.md

@@ -345,6 +345,9 @@ File extracted from upstream release tarball:
 - Added 2 files `godot_core_mbedtls_platform.c` and `godot_core_mbedtls_config.h`
   providing configuration for light bundling with core.
 
+Some changes have been made in order to fix Windows on ARM build errors.
+They are marked with `// -- GODOT start --` and `// -- GODOT end --`
+
 
 ## meshoptimizer
 
@@ -375,6 +378,9 @@ Files extracted from upstream repository:
 - `minimp3_ex.h`
 - `LICENSE`
 
+Some changes have been made in order to fix Windows on ARM build errors.
+They are marked with `// -- GODOT start --` and `// -- GODOT end --`
+
 
 ## miniupnpc
 

thirdparty/mbedtls/library/timing.c

@@ -195,8 +195,10 @@ unsigned long mbedtls_timing_hardclock( void )
 #endif /* !HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&
           __GNUC__ && __ia64__ */
 
-#if !defined(HAVE_HARDCLOCK) && defined(_MSC_VER) && \
+// -- GODOT start --
+#if !defined(HAVE_HARDCLOCK) && defined(_WIN32) && \
     !defined(EFIX64) && !defined(EFI32)
+// -- GODOT end --
 
 #define HAVE_HARDCLOCK
 

thirdparty/minimp3/minimp3.h

@@ -1566,7 +1566,18 @@ static void mp3d_synth(float *xl, mp3d_sample_t *dstl, int nch, float *lins)
 
 #else /* MINIMP3_FLOAT_OUTPUT */
 
+// -- GODOT start --
+#if defined(_MSC_VER) && (defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_ARM))
+            static f4 g_scale;
+            g_scale = vsetq_lane_f32(1.0f/32768.0f, g_scale, 0);
+            g_scale = vsetq_lane_f32(1.0f/32768.0f, g_scale, 1);
+            g_scale = vsetq_lane_f32(1.0f/32768.0f, g_scale, 2);
+            g_scale = vsetq_lane_f32(1.0f/32768.0f, g_scale, 3);
+#else
             static const f4 g_scale = { 1.0f/32768.0f, 1.0f/32768.0f, 1.0f/32768.0f, 1.0f/32768.0f };
+#endif
+// -- GODOT end --
+
             a = VMUL(a, g_scale);
             b = VMUL(b, g_scale);
 #if HAVE_SSE
@@ -1813,7 +1824,19 @@ void mp3dec_f32_to_s16(const float *in, int16_t *out, int num_samples)
     int aligned_count = num_samples & ~7;
     for(; i < aligned_count; i += 8)
     {
+
+// -- GODOT start --
+#if defined(_MSC_VER) && (defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_ARM))
+            static f4 g_scale;
+            g_scale = vsetq_lane_f32(32768.0f, g_scale, 0);
+            g_scale = vsetq_lane_f32(32768.0f, g_scale, 1);
+            g_scale = vsetq_lane_f32(32768.0f, g_scale, 2);
+            g_scale = vsetq_lane_f32(32768.0f, g_scale, 3);
+#else
         static const f4 g_scale = { 32768.0f, 32768.0f, 32768.0f, 32768.0f };
+#endif
+// -- GODOT end --
+
         f4 a = VMUL(VLD(&in[i  ]), g_scale);
         f4 b = VMUL(VLD(&in[i+4]), g_scale);
 #if HAVE_SSE