Builder.cs

using System;
using System.Collections.Generic;
using System.IO;
using UnityEditor;
using UnityEditor.Build;
using UnityEditor.Build.Reporting;
using UnityEngine;

public class Builder
{
    public static void BuildIl2CPPPlayer(BuildTarget target, BuildTargetGroup group, BuildOptions buildOptions,
        string defaultBuildPath = "./Builds/")
    {
        Debug.Log("Builder: Starting to build");

        Debug.Log("Builder: Parsing command line arguments");
        var args = CommandLineArguments.Parse();
        ValidateArguments(args, defaultBuildPath);

        Debug.Log($"Builder: Starting build. Output will be '{args["buildPath"]}'.");

        // Make sure the configuration is right.
        EditorUserBuildSettings.selectedBuildTargetGroup = group;
        EditorUserBuildSettings.development = false;
        EditorUserBuildSettings.allowDebugging = false;
        PlayerSettings.SetScriptingBackend(NamedBuildTarget.FromBuildTargetGroup(group), ScriptingImplementation.IL2CPP);
        // Making sure that the app keeps on running in the background. Linux CI is very unhappy with coroutines otherwise.
        PlayerSettings.runInBackground = true;

        DisableUnityAudio();
        DisableProgressiveLightMapper();

        Debug.Log("Builder: Setting IL2CPP generation to OptimizeSpeed");
#if UNITY_2022_1_OR_NEWER
        PlayerSettings.SetIl2CppCodeGeneration(NamedBuildTarget.FromBuildTargetGroup(group), UnityEditor.Build.Il2CppCodeGeneration.OptimizeSpeed);
#elif UNITY_2021_2_OR_NEWER
        EditorUserBuildSettings.il2CppCodeGeneration = UnityEditor.Build.Il2CppCodeGeneration.OptimizeSpeed;
#endif

        Debug.Log("Builder: Configuring code stripping level");
#if UNITY_6000_0_OR_NEWER
        PlayerSettings.SetManagedStrippingLevel(NamedBuildTarget.FromBuildTargetGroup(group), ManagedStrippingLevel.High);
#else
        PlayerSettings.SetManagedStrippingLevel(NamedBuildTarget.FromBuildTargetGroup(group), ManagedStrippingLevel.Low);
#endif

        Debug.Log("Builder: Updating BuildPlayerOptions");
        var buildPlayerOptions = new BuildPlayerOptions
        {
            locationPathName = args["buildPath"],
            target = target,
            targetGroup = group,
            options = buildOptions
        };

        Debug.Log("Builder: Disabling optimizations to reduce build time");
        // TODO Linux fails with `free(): invalid pointer` in the test, after everything seems to have shut down.
        if (target != BuildTarget.StandaloneLinux64)
        {
            PlayerSettings.SetIl2CppCompilerConfiguration(NamedBuildTarget.FromBuildTargetGroup(group), Il2CppCompilerConfiguration.Debug);
        }

        if (target == BuildTarget.Android)
        {
            Debug.Log("Builder: Setting application identifier");
            PlayerSettings.SetApplicationIdentifier(NamedBuildTarget.Android, "io.sentry.unity.integrationtest");

            // Android does not support appending builds. We make sure the directory is clean
            var outputDir = Path.GetDirectoryName(args["buildPath"]);
            if (Directory.Exists(outputDir))
            {
                Debug.Log("Builder: Cleaning the buildPath");
                Directory.Delete(outputDir, true);
            }

            Debug.Log($"Builder: Creating output directory at '{outputDir}'");
            Directory.CreateDirectory(outputDir);

            Debug.Log("Builder: Enabling minify");
            PlayerSettings.Android.minifyDebug = PlayerSettings.Android.minifyRelease = true;

#if UNITY_6000_0_OR_NEWER
            // X86_64 has been deprecated and was removed with 6.5
            Debug.Log("Builder: Setting target architecture to ARM64");
            PlayerSettings.Android.targetArchitectures = AndroidArchitecture.ARM64;
#endif
        }

        Debug.Log("Builder: Checking for Test scene");
        if (File.Exists("Assets/Scenes/Test.unity"))
        {
            Debug.Log("Builder: Adding Test.unity to scenes");
            buildPlayerOptions.scenes = new[] { "Assets/Scenes/Test.unity" };
        }

        Debug.Log("Builder: Starting build");
        var report = BuildPipeline.BuildPlayer(buildPlayerOptions);
        var summary = report.summary;

        Debug.Log("Builder: Build result at outputPath: " + summary.outputPath);

        switch (summary.result)
        {
            case BuildResult.Succeeded:
                Debug.Log($"Builder: Build succeeded: {summary.totalSize} bytes");
                break;
            default:
                Debug.Log($"Builder: Build result: {summary.result} with {summary.totalErrors}" + $" error{(summary.totalErrors > 1 ? "s" : "")}.");
                throw new Exception("Build failed, see details above.");
        }

        if (summary.totalWarnings > 0)
        {
            Debug.Log($"Builder: Build succeeded with {summary.totalWarnings} warning{(summary.totalWarnings > 1 ? "s" : "")}.");
        }
    }

    [MenuItem("Tools/Builder/Windows")]
    public static void BuildWindowsIl2CPPPlayer()
    {
        Debug.Log("Builder: Building Windows IL2CPP Player");
        BuildIl2CPPPlayer(BuildTarget.StandaloneWindows64, BuildTargetGroup.Standalone, BuildOptions.StrictMode,
            defaultBuildPath: "./Builds/Windows/test.exe");
    }

    [MenuItem("Tools/Builder/macOS")]
    public static void BuildMacIl2CPPPlayer()
    {
        Debug.Log("Builder: Building macOS IL2CPP Player");
        BuildIl2CPPPlayer(BuildTarget.StandaloneOSX, BuildTargetGroup.Standalone, BuildOptions.StrictMode,
            defaultBuildPath: "./Builds/macOS/test.app");
    }

    [MenuItem("Tools/Builder/Linux")]
    public static void BuildLinuxIl2CPPPlayer()
    {
        Debug.Log("Builder: Building Linux IL2CPP Player");
        PlayerSettings.SetUseDefaultGraphicsAPIs(BuildTarget.StandaloneLinux64, false);
        PlayerSettings.SetGraphicsAPIs(BuildTarget.StandaloneLinux64, new[] { UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore });
        PlayerSettings.gpuSkinning = false;
        PlayerSettings.graphicsJobs = false;
        BuildIl2CPPPlayer(BuildTarget.StandaloneLinux64, BuildTargetGroup.Standalone, BuildOptions.StrictMode,
            defaultBuildPath: "./Builds/Linux/test");
    }

    [MenuItem("Tools/Builder/Android")]
    public static void BuildAndroidIl2CPPPlayer()
    {
        Debug.Log("Builder: Building Android IL2CPP Player");

        // Force OpenGLES3 to avoid Vulkan issues with the Android emulator in CI.
        // The emulator's swiftshader Vulkan implementation doesn't fully support Unity's
        // Vulkan usage, causing "Processed some Vulkan packets without process resources
        // created" warnings and SIGSEGV crashes in libvulkan_enc.so.
        PlayerSettings.SetUseDefaultGraphicsAPIs(BuildTarget.Android, false);
        PlayerSettings.SetGraphicsAPIs(BuildTarget.Android, new[] { UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3 });

#if UNITY_2021_2_OR_NEWER && !UNITY_6000_0_OR_NEWER
        // Clean Android gradle cache to force regeneration of gradle files
        // This prevents Unity from reusing gradle files that may contain Sentry symbol upload tasks from previous builds
        var androidGradlePath = Path.Combine(Directory.GetCurrentDirectory(), "Library/Bee/Android");
        if (Directory.Exists(androidGradlePath))
        {
            Debug.Log($"Builder: Cleaning Android gradle cache at '{androidGradlePath}'");
            Directory.Delete(androidGradlePath, true);
        }
#endif

        BuildIl2CPPPlayer(BuildTarget.Android, BuildTargetGroup.Android, BuildOptions.StrictMode,
            defaultBuildPath: "./Builds/Android/test.apk");
    }

    [MenuItem("Tools/Builder/Android Project")]
    public static void BuildAndroidIl2CPPProject()
    {
        Debug.Log("Builder: Building Android IL2CPP Project");
        EditorUserBuildSettings.exportAsGoogleAndroidProject = true;
        BuildIl2CPPPlayer(BuildTarget.Android, BuildTargetGroup.Android, BuildOptions.AcceptExternalModificationsToPlayer,
            defaultBuildPath: "./Builds/AndroidProject/");
    }

    [MenuItem("Tools/Builder/iOS")]
    public static void BuildIOSProject()
    {
        Debug.Log("Builder: Building iOS Project");
        BuildIl2CPPPlayer(BuildTarget.iOS, BuildTargetGroup.iOS, BuildOptions.StrictMode,
            defaultBuildPath: "./Builds/iOS/");
    }

    [MenuItem("Tools/Builder/WebGL")]
    public static void BuildWebGLPlayer()
    {
        Debug.Log("Builder: Building WebGL Player");
        PlayerSettings.WebGL.compressionFormat = WebGLCompressionFormat.Brotli;
        BuildIl2CPPPlayer(BuildTarget.WebGL, BuildTargetGroup.WebGL, BuildOptions.StrictMode,
            defaultBuildPath: "./Builds/WebGL/");
    }

    [MenuItem("Tools/Builder/Switch")]
    public static void BuildSwitchIL2CPPPlayer()
    {
        Debug.Log("Builder: Building Switch IL2CPP Player");
        ConsoleBuildProfiles.SetSwitchCreateNspRomFile();
        BuildIl2CPPPlayer(BuildTarget.Switch, BuildTargetGroup.Switch, BuildOptions.StrictMode,
            defaultBuildPath: "./Builds/Switch/test.nsp");
    }

    [MenuItem("Tools/Builder/Xbox Series X|S")]
    public static void BuildXSXIL2CPPPlayer()
    {
        Debug.Log("Builder: Building Xbox Series X|S IL2CPP Player");
        ConsoleBuildProfiles.SetXboxSubtargetToMaster();
        BuildIl2CPPPlayer(BuildTarget.GameCoreXboxSeries, BuildTargetGroup.GameCoreXboxSeries, BuildOptions.StrictMode,
            defaultBuildPath: "./Builds/GameCoreXboxSeries/test");
    }

    [MenuItem("Tools/Builder/Xbox One")]
    public static void BuildXB1IL2CPPPlayer()
    {
        Debug.Log("Builder: Building Xbox One IL2CPP Player");
        ConsoleBuildProfiles.SetXboxSubtargetToMaster();
        BuildIl2CPPPlayer(BuildTarget.GameCoreXboxOne, BuildTargetGroup.GameCoreXboxOne, BuildOptions.StrictMode,
            defaultBuildPath: "./Builds/GameCoreXboxOne/test");
    }

    [MenuItem("Tools/Builder/PS5")]
    public static void BuildPS5IL2CPPPlayer()
    {
        Debug.Log("Builder: Building PS5 IL2CPP Player");
        ConsoleBuildProfiles.SetPS5BuildTypeToPackage();
        BuildIl2CPPPlayer(BuildTarget.PS5, BuildTargetGroup.PS5, BuildOptions.StrictMode,
            defaultBuildPath: "./Builds/PS5/");
    }

    private static void ValidateArguments(Dictionary<string, string> args, string defaultBuildPath)
    {
        Debug.Log("Builder: Validating command line arguments");
        if (!args.ContainsKey("buildPath") || string.IsNullOrWhiteSpace(args["buildPath"]))
        {
            args["buildPath"] = defaultBuildPath;
            Debug.Log($"Builder: No '-buildPath' provided, defaulting to '{defaultBuildPath}'");
        }
    }

    // Audio created issues, especially for iOS simulator so we disable it.
    private static void DisableUnityAudio()
    {
        var audioManager = AssetDatabase.LoadAllAssetsAtPath("ProjectSettings/AudioManager.asset")[0];
        var serializedManager = new SerializedObject(audioManager);
        var prop = serializedManager.FindProperty("m_DisableAudio");
        prop.boolValue = true;
        serializedManager.ApplyModifiedProperties();
    }

    // The Progressive Lightmapper does not work on silicone CPUs and there is no GPU in CI
    private static void DisableProgressiveLightMapper()
    {
#if UNITY_2021_1_OR_NEWER
        Lightmapping.lightingSettings = new LightingSettings
        {
            bakedGI = false,
            realtimeGI = false
        };
#endif
    }
}