Merge pull request #1287 from EOS-Contrib/ARM64

Support for windows ARM64

Author: DanF-ApexSystems

Assets/Plugins/Source/Editor/Build/BuildRunner.cs

@@ -74,8 +74,9 @@ public void OnPreprocessBuild(BuildReport report)
             // Run the static builder's prebuild.
             s_builder?.PreBuild(report);
 
-#if !DISABLESTEAMWORKS
+#if !DISABLESTEAMWORKS && !EOS_PLATFORM_WINDOWS_ARM64
             // If we're using Steamworks, then look at the user's Steam configuration file
+            // (Steamworks does not ship Windows ARM64 binaries, so it is gated off there.)
             // If the "steamApiInterfaceVersionsArray" is empty, try to set it for the user
             SteamConfig config = Config.Get<SteamConfig>();
             if (config != null && (config.steamApiInterfaceVersionsArray == null || config.steamApiInterfaceVersionsArray.Count == 0))

Assets/Plugins/Source/Editor/Build/PlatformSpecificBuilder.cs

@@ -99,10 +99,7 @@ protected PlatformSpecificBuilder(string nativeCodeOutputDirectory, params Build
         /// <param name="report">The prebuild report.</param>
         public void OnPreprocessBuild(BuildReport report)
         {
-            // If the platform being built is one of the platforms that this
-            // builder builds to, then set this as the builder with the
-            // BuildRunner.
-            if (_buildTargets.Contains(report.summary.platform))
+            if (ShouldHandle(report))
             {
                 // Note that in this context, despite being within an abstract
                 // class, the most derived instance will be returned when
@@ -111,6 +108,19 @@ public void OnPreprocessBuild(BuildReport report)
             }
         }
 
+        /// <summary>
+        /// Determines whether this builder should handle the indicated build.
+        /// Default implementation matches by BuildTarget. Override for
+        /// finer-grained dispatch (e.g. architecture sub-options on Windows
+        /// where x64 and ARM64 share BuildTarget.StandaloneWindows64).
+        /// </summary>
+        /// <param name="report">The build report being processed.</param>
+        /// <returns>True if this builder is responsible for this build.</returns>
+        protected virtual bool ShouldHandle(BuildReport report)
+        {
+            return _buildTargets.Contains(report.summary.platform);
+        }
+
         /// <summary>
         /// Adds a mapping of solution file to expected binary file output.
         /// </summary>
@@ -167,7 +177,7 @@ public virtual void BuildNativeCode()
             // via UPM.
             if (_projectFileToBinaryFilesMap.Keys.All(File.Exists))
             {
-                BuildUtility.BuildNativeBinaries(_projectFileToBinaryFilesMap, _nativeCodeOutputDirectory, true);
+                BuildUtility.BuildNativeBinaries(_projectFileToBinaryFilesMap, _nativeCodeOutputDirectory, true, GetPlatformString());
             }
             else
             {

Assets/Plugins/Source/Editor/EditorWindows/CheckDeploymentWindow.cs

@@ -40,6 +40,7 @@ public class CheckDeploymentWindow : EOSEditorWindow
         private const string WindowsPluginDirectory = "Assets/Plugins/Windows";
         private const string EOSWindows64DllFile = "x64/EOSSDK-Win64-Shipping.dll";
         private const string EOSWindows32DllFile = "x86/EOSSDK-Win32-Shipping.dll";
+        private const string EOSWindowsARM64DllFile = "ARM64/EOSSDK-Win64-Shippingarm64.dll";
 
         private string content;
         private string currentPath;
@@ -84,6 +85,11 @@ protected override void RenderWindow()
                 LoadDLLFile(Path.Combine(FileSystemUtility.GetProjectPath(), WindowsPluginDirectory, EOSWindows64DllFile));
             }
 
+            if (GUILayout.Button(EOSWindowsARM64DllFile))
+            {
+                LoadDLLFile(Path.Combine(FileSystemUtility.GetProjectPath(), WindowsPluginDirectory, EOSWindowsARM64DllFile));
+            }
+
             if (!string.IsNullOrWhiteSpace(currentPath))
             {
                 scrollPosition = GUILayout.BeginScrollView(scrollPosition, GUILayout.MaxHeight(Screen.height));

Assets/Plugins/Source/Editor/Platforms/Windows/WindowsBuilder.cs

@@ -30,31 +30,288 @@ namespace PlayEveryWare.EpicOnlineServices.Editor.Build
 #endif
     using Config;
     using Config = EpicOnlineServices.Config;
+    using System;
     using System.IO;
     using UnityEditor;
     using UnityEditor.Build;
     using UnityEditor.Build.Reporting;
     using UnityEngine;
+    using Utility;
 
     /// <summary>
-    /// WindowsBuilder for 64-bit deployment.
+    /// Scripting define set when targeting the Windows ARM64 architecture sub-option
+    /// of <see cref="BuildTarget.StandaloneWindows64"/>. Unity does not provide a built-in
+    /// scripting define to distinguish ARM64 from x64 on Standalone Windows, so this
+    /// project-local symbol is auto-managed by the Windows builders during preprocess.
+    ///
+    /// IMPORTANT: scripting defines set during build preprocess only affect the *next*
+    /// build's script compilation, not the current one. Switching between x64 and ARM64
+    /// for Windows builds requires running the menu item under "EOS Plugin/Advanced/Windows
+    /// ARM64..." once before the first build, or running a build twice (the first to set
+    /// the define, the second to compile against it).
+    /// </summary>
+    internal static class WindowsArm64Define
+    {
+        public const string Symbol = "EOS_PLATFORM_WINDOWS_ARM64";
+        internal const string Architecture = "ARM64";
+
+#if UNITY_6000_0_OR_NEWER
+        /// <summary>
+        /// True when the active Standalone build is configured to produce ARM64 binaries.
+        /// Uses <see cref="PlayerSettings.GetArchitecture"/> which returns 1 for ARM64 on
+        /// the Standalone Windows target in Unity 6. Falls back to the scripting define as
+        /// a manual escape hatch if the API throws.
+        /// </summary>
+        public static bool IsArm64Active()
+        {
+            // Guard: only meaningful when actively building for Windows 64-bit.
+            // Also protects against Apple Silicon Macs where BuildTargetGroup.Standalone
+            // architecture would otherwise reflect the host Mac architecture.
+            if (EditorUserBuildSettings.activeBuildTarget != BuildTarget.StandaloneWindows64)
+            {
+                return false;
+            }
+
+            try
+            {
+                // The "Architecture" dropdown in the Build Settings window is stored as a
+                // platform setting, not in PlayerSettings. "ARM64" is set when the user
+                // selects "ARM 64-bit"; the field is empty or "x64" for Intel 64-bit.
+                string arch = EditorUserBuildSettings.GetPlatformSettings(
+                    BuildPipeline.GetBuildTargetName(BuildTarget.StandaloneWindows64),
+                    "Architecture");
+                if (!string.IsNullOrEmpty(arch))
+                {
+                    return string.Equals(arch, Architecture, System.StringComparison.OrdinalIgnoreCase);
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogWarning($"EOS Plugin: Could not read ARM64 architecture setting: {ex.Message}");
+            }
+
+            // Manual escape hatch: respect the scripting define if the user set it explicitly.
+            try
+            {
+                NamedBuildTarget named = NamedBuildTarget.FromBuildTargetGroup(BuildTargetGroup.Standalone);
+                string defines = PlayerSettings.GetScriptingDefineSymbols(named);
+                return !string.IsNullOrEmpty(defines)
+                    && Array.IndexOf(defines.Split(';'), Symbol) >= 0;
+            }
+            catch (Exception ex)
+            {
+                Debug.LogWarning($"EOS Plugin: Could not read scripting defines: {ex.Message}");
+                return false;
+            }
+        }
+#else
+        public static bool IsArm64Active() => false;
+#endif
+
+        /// <summary>
+        /// Returns true if <see cref="Symbol"/> is currently present in the Standalone
+        /// scripting defines, regardless of the active build target or architecture setting.
+        /// Used to detect define/architecture mismatches before a build compiles scripts.
+        /// </summary>
+        public static bool IsDefineSet()
+        {
+            try
+            {
+                NamedBuildTarget named = NamedBuildTarget.FromBuildTargetGroup(BuildTargetGroup.Standalone);
+                string defines = PlayerSettings.GetScriptingDefineSymbols(named);
+                return !string.IsNullOrEmpty(defines)
+                    && Array.IndexOf(defines.Split(';'), Symbol) >= 0;
+            }
+            catch (Exception ex)
+            {
+                Debug.LogWarning($"EOS Plugin: Could not read scripting defines: {ex.Message}");
+                return false;
+            }
+        }
+
+#if UNITY_6000_0_OR_NEWER
+        [InitializeOnLoad]
+        private static class BuildGuard
+        {
+            static BuildGuard()
+            {
+                // Intercept the Build button BEFORE Unity compiles scripts, so any define
+                // change takes effect in the same compilation rather than requiring a second build.
+                BuildPlayerWindow.RegisterBuildPlayerHandler(OnBuildPlayer);
+            }
+
+            private static void OnBuildPlayer(BuildPlayerOptions options)
+            {
+                if (options.target == BuildTarget.StandaloneWindows64)
+                {
+                    bool wantsArm64  = IsArm64Active();
+                    bool defineIsSet = IsDefineSet();
+
+                    if (wantsArm64 && !defineIsSet)
+                    {
+                        ScriptingDefineUtility.AddDefine(BuildTarget.StandaloneWindows64, Symbol);
+                        EditorUtility.DisplayDialog(
+                            "EOS Plugin — Windows ARM64",
+                            $"The scripting define '{Symbol}' was missing and has been added.\n\n" +
+                            "Scripts are recompiling. Please click Build again once compilation finishes.",
+                            "OK");
+                        return;
+                    }
+
+                    if (!wantsArm64 && defineIsSet)
+                    {
+                        ScriptingDefineUtility.RemoveDefine(BuildTarget.StandaloneWindows64, Symbol);
+                        EditorUtility.DisplayDialog(
+                            "EOS Plugin — Windows x64",
+                            $"The scripting define '{Symbol}' was left over from a previous ARM64 build and has been removed.\n\n" +
+                            "Scripts are recompiling. Please click Build again once compilation finishes.",
+                            "OK");
+                        return;
+                    }
+                }
+
+                BuildPlayerWindow.DefaultBuildMethods.BuildPlayer(options);
+            }
+        }
+#endif
+
+#if UNITY_6000_0_OR_NEWER
+        /// <summary>
+        /// Manually enables the ARM64 scripting define. Use this as a workaround before
+        /// the first ARM64 build to ensure scripts compile with ARM64 support on the first
+        /// attempt, without needing to build twice.
+        /// </summary>
+        [MenuItem("EOS Plugin/Advanced/Windows ARM64/Enable scripting define")]
+        private static void EnableArm64Define()
+        {
+            ScriptingDefineUtility.AddDefine(BuildTarget.StandaloneWindows64, Symbol);
+            UnityEngine.Debug.Log($"Scripting define '{Symbol}' enabled for Standalone Windows. Build for ARM64 architecture to produce ARM64 binaries.");
+        }
+
+        /// <summary>
+        /// Manually disables the ARM64 scripting define. Use this as a workaround before
+        /// switching back to an x64 build to ensure scripts compile without ARM64 support
+        /// on the first attempt, without needing to build twice.
+        /// </summary>
+        [MenuItem("EOS Plugin/Advanced/Windows ARM64/Disable scripting define")]
+        private static void DisableArm64Define()
+        {
+            ScriptingDefineUtility.RemoveDefine(BuildTarget.StandaloneWindows64, Symbol);
+            UnityEngine.Debug.Log($"Scripting define '{Symbol}' disabled for Standalone Windows. Subsequent builds will produce x64 binaries.");
+        }
+#endif
+    }
+
+    /// <summary>
+    /// WindowsBuilder for 64-bit (x86_64) deployment.
     /// </summary>
     public class WindowsBuilder64 : WindowsBuilder
     {
-        public WindowsBuilder64() : base("Plugins/Windows/x64", BuildTarget.StandaloneWindows64)
+        private const string PlatformId = "x64";
+
+        public WindowsBuilder64() : base($"Plugins/Windows/{PlatformId}", BuildTarget.StandaloneWindows64)
+        {
+            AddProjectFileToBinaryMapping(
+                "DynamicLibraryLoaderHelper/DynamicLibraryLoaderHelper.sln",
+                $"DynamicLibraryLoaderHelper-{PlatformId}.dll",
+                $"GfxPluginNativeRender-{PlatformId}.dll");
+        }
+
+        public override string GetPlatformString()
+        {
+            return PlatformId;
+        }
+
+        protected override bool ShouldHandle(BuildReport report)
+        {
+            // StandaloneWindows64 covers both x64 and ARM64 in Unity 6; only handle x64 here.
+            if (!base.ShouldHandle(report))
+            {
+                return false;
+            }
+            return !WindowsArm64Define.IsArm64Active();
+        }
+
+        public override void PreBuild(BuildReport report)
+        {
+#if UNITY_6000_0_OR_NEWER
+            Debug.Log(WindowsArm64Define.IsArm64Active()
+                ? "Targeting Windows ARM64"
+                : "Targeting Windows x64 (Intel/AMD)");
+#endif
+            // Safety net for scripted/CI builds that bypass RegisterBuildPlayerHandler.
+            if (WindowsArm64Define.IsDefineSet())
+            {
+                ScriptingDefineUtility.RemoveDefine(BuildTarget.StandaloneWindows64, WindowsArm64Define.Symbol);
+                throw new BuildFailedException(
+                    $"Scripting define '{WindowsArm64Define.Symbol}' was active from a previous ARM64 build. " +
+                    "It has been removed. Please rebuild to compile with Windows x64 support.");
+            }
+
+            base.PreBuild(report);
+        }
+    }
+
+#if UNITY_6000_0_OR_NEWER
+    /// <summary>
+    /// WindowsBuilder for ARM64 deployment. Available in Unity 6000.0+ where
+    /// Standalone Windows ARM64 is supported as an architecture sub-option of
+    /// <see cref="BuildTarget.StandaloneWindows64"/>. Steam features are unavailable
+    /// on this architecture (no Steam binaries ship for Windows ARM64).
+    /// </summary>
+    public class WindowsBuilderArm64 : WindowsBuilder
+    {
+        private const string PlatformId = WindowsArm64Define.Architecture;
+
+        public WindowsBuilderArm64() : base($"Plugins/Windows/{PlatformId}", BuildTarget.StandaloneWindows64)
         {
             AddProjectFileToBinaryMapping(
                 "DynamicLibraryLoaderHelper/DynamicLibraryLoaderHelper.sln",
-                "DynamicLibraryLoaderHelper-x64.dll",
-                "GfxPluginNativeRender-x64.dll");
+                $"DynamicLibraryLoaderHelper-{PlatformId}.dll",
+                $"GfxPluginNativeRender-{PlatformId}.dll");
+        }
+
+        public override string GetPlatformString()
+        {
+            return PlatformId;
+        }
+
+        protected override bool ShouldHandle(BuildReport report)
+        {
+            if (!base.ShouldHandle(report))
+            {
+                return false;
+            }
+            return WindowsArm64Define.IsArm64Active();
+        }
+
+        public override void PreBuild(BuildReport report)
+        {
+            Debug.Log(WindowsArm64Define.IsArm64Active()
+                ? "Targeting Windows ARM64"
+                : "Targeting Windows x64 (Intel/AMD)");
+
+            // Safety net for scripted/CI builds that bypass RegisterBuildPlayerHandler.
+            if (!WindowsArm64Define.IsDefineSet())
+            {
+                ScriptingDefineUtility.AddDefine(BuildTarget.StandaloneWindows64, WindowsArm64Define.Symbol);
+                throw new BuildFailedException(
+                    $"Scripting define '{WindowsArm64Define.Symbol}' was not set before this build. " +
+                    "It has been added. Please rebuild to compile with Windows ARM64 support.");
+            }
+
+            base.PreBuild(report);
         }
     }
+#endif
 
     /// <summary>
     /// WindowsBuilder for 32-bit deployment.
     /// </summary>
     public class WindowsBuilder32 : WindowsBuilder
     {
+        private const string PlatformId = "Win32";
+
         public WindowsBuilder32() : base("Plugins/Windows/x86", BuildTarget.StandaloneWindows)
         {
             // TODO: These libraries do not appear to be building properly - and the process
@@ -65,6 +322,11 @@ public WindowsBuilder32() : base("Plugins/Windows/x86", BuildTarget.StandaloneWi
                 "DynamicLibraryLoaderHelper-x86.dll",
                 "GfxPluginNativeRender-x86.dll");
         }
+
+        public override string GetPlatformString()
+        {
+            return PlatformId;
+        }
     }
 
     /// <summary>