Merge pull request #2 from peeweek/refactor/release-oop

Road to 2.0.0

CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 2.0.0
+
+Minimal version is now 2020.3
+
+Major refactor and going out of preview
+
+* Reworked UI and simplified workflow
+* Better handling of Run on editor platforms (if can't run, then open explorer)
+* Added BuildProcessor script API that can handle processing before/after build
+
 ## 1.3.0-preview
 
 Minimal version is now 2019.3

Editor/Assets/BuildProcessor.cs

@@ -0,0 +1,24 @@
+using UnityEngine;
+using System;
+
+namespace BuildFrontend
+{
+    public abstract class BuildProcessor: ScriptableObject
+    {
+        public abstract bool OnPreProcess(BuildTemplate template, bool wantRun);
+        public abstract bool OnPostProcess(BuildTemplate template, bool wantRun);
+    }
+
+    public class BuildProcessorException: Exception
+    {
+        public BuildProcessor processor;
+        public BuildTemplate template;
+        public BuildProcessorException(BuildProcessor p, BuildTemplate t)
+        {
+            processor = p;
+            template = t;
+        }
+    }
+}
+
+

Editor/Assets/BuildProfile.cs

@@ -1,12 +1,14 @@
-using System.Collections;
-using System.Collections.Generic;
 using UnityEngine;
 using UnityEditor;
-using UnityEditor.Build.Reporting;
 
-public class BuildProfile : BuildFrontendAssetBase
+namespace BuildFrontend
 {
-    [Header("Build Profile")]
-    public bool DevPlayer;
-    public BuildTarget Target;
+    public class BuildProfile : BuildFrontendAssetBase
+    {
+        [Header("Build Profile")]
+        public bool DevPlayer;
+        public BuildTarget Target;
+    }
+
 }
+

Editor/Assets/BuildProfileAssetFactory.cs

@@ -1,13 +1,13 @@
 using UnityEngine;
-using UnityEditor.Callbacks;
+using UnityEditor;
 using UnityEditor.ProjectWindowCallback;
 using System.IO;
 
-namespace UnityEditor.VFXToolbox.ImageSequencer
+namespace BuildFrontend
 {
     internal class BuildProfileAssetFactory
     {
-        [MenuItem("Assets/Create/Build/Build Profile", priority = BuildFrontend.CreateAssetMenuPriority)]
+        [MenuItem("Assets/Create/Build Frontend/Build Profile", priority = BuildFrontend.CreateAssetMenuPriority)]
         private static void MenuCreatePostProcessingProfile()
         {
             var icon = EditorGUIUtility.FindTexture("BuildProfile");

Editor/Assets/BuildTemplate.cs

@@ -4,108 +4,203 @@
 using UnityEditor.Build.Reporting;
 using System.Diagnostics;
 using Debug = UnityEngine.Debug;
+using System.IO;
 
-public class BuildTemplate : BuildFrontendAssetBase
+namespace BuildFrontend
 {
-    public bool BuildEnabled
+    public class BuildTemplate : BuildFrontendAssetBase
     {
-        get { return EditorPrefs.GetBool(preferenceName, true); }
-        set { EditorPrefs.SetBool(preferenceName, value); }
-    }
+        public bool BuildEnabled
+        {
+            get { return EditorPrefs.GetBool(preferenceName, true); }
+            set { EditorPrefs.SetBool(preferenceName, value); }
+        }
 
-    string preferenceName
-    {
-        get { return $"BuildFrontend.{AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(this))}.Enabled"; }
-    }
+        string preferenceName
+        {
+            get { return $"BuildFrontend.{AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(this))}.Enabled"; }
+        }
 
-    [Header("Build Template")]
-    public string BuildPath;
-    public string ExecutableName;
-    public bool CleanupBeforeBuild = true;
-    public string RunWithArguments;
+        [Header("Configuration")]
+        public BuildProfile Profile;
+        public SceneList SceneList;
 
-    public BuildProfile Profile;
-    public SceneList SceneList;
+        [Header("Output Options")]
+        public string BuildPath;
+        public string ExecutableName;
 
-    protected override void Awake()
-    {
-        base.Awake();
 
-        if (BuildPath == null)
-            BuildPath = "Build/";
-    }
+        [Header("Build/Run Options")]
+        public bool CleanupBeforeBuild = true;
+        public bool OpenInExplorer = false;
+        public string RunWithArguments;
+        public BuildProcessor[] processors;
 
-    public BuildReport DoBuild(bool run = false)
-    {
-        BuildReport report = null;
+        protected override void Awake()
+        {
+            base.Awake();
 
-        if (BuildEnabled)
+            if (BuildPath == null)
+                BuildPath = "Build/";
+        }
+
+        public BuildReport DoBuild(bool run = false)
         {
-            try
+            BuildReport report = null;
+
+            if (BuildEnabled)
             {
-                EditorUtility.DisplayProgressBar("Build Frontend", $"Building player : {name}", 0.0f);
+                try
+                {
+                    if(processors != null)
+                    {
+                        foreach(var processor in processors)
+                        {
+                            if (processor == null)
+                                continue;
+
+                            EditorUtility.DisplayProgressBar("Build Frontend", $"Pre-Processing : {processor.name}", 0.0f);
+                            if(!processor.OnPreProcess(this, run))
+                            {
+                                throw new BuildProcessorException(processor, this);
+                            }
+                        }
+                    }
 
-                BuildOptions options = BuildOptions.None;
+                    EditorUtility.DisplayProgressBar("Build Frontend", $"Building player : {name}", 0.0f);
 
-                if (Profile.DevPlayer)
-                    options |= BuildOptions.Development;
+                    BuildOptions options = BuildOptions.None;
 
-                if(CleanupBeforeBuild && System.IO.Directory.Exists(BuildPath))
-                {
-                    EditorUtility.DisplayProgressBar("Build Frontend", $"Cleaning up folder : {BuildPath}", 0.05f);
-                    System.IO.Directory.Delete(BuildPath, true);
-                    System.IO.Directory.CreateDirectory(BuildPath);
-                }
+                    if (Profile.DevPlayer)
+                        options |= BuildOptions.Development;
 
-                report = BuildPipeline.BuildPlayer(SceneList.scenePaths, BuildPath + ExecutableName, Profile.Target, options);
-                if (run)
-                {
-                    if (
-                        report.summary.result == BuildResult.Succeeded ||
-                        EditorUtility.DisplayDialog("Run Failed Build", "The build has failed or has been canceled, do you want to attempt to run previous build instead?", "Yes", "No")
-                      )
+                    if (CleanupBeforeBuild && System.IO.Directory.Exists(BuildPath))
                     {
-                        RunBuild();
+                        EditorUtility.DisplayProgressBar("Build Frontend", $"Cleaning up folder : {BuildPath}", 0.05f);
+                        System.IO.Directory.Delete(BuildPath, true);
+                        System.IO.Directory.CreateDirectory(BuildPath);
                     }
+
+                    report = BuildPipeline.BuildPlayer(SceneList.scenePaths, BuildPath + ExecutableName, Profile.Target, options);
+
+                    if (processors != null)
+                    {
+                        foreach (var processor in processors)
+                        {
+                            if (processor == null)
+                                continue;
+
+                            EditorUtility.DisplayProgressBar("Build Frontend", $"Post-Processing : {processor.name}", 0.0f);
+                            if (!processor.OnPostProcess(this, run))
+                            {
+                                throw new BuildProcessorException(processor, this);
+                            }
+                        }
+                    }
+
+                    if (run)
+                    {
+                        if (
+                            report.summary.result == BuildResult.Succeeded ||
+                            EditorUtility.DisplayDialog("Run Failed Build", "The build has failed or has been canceled, do you want to attempt to run previous build instead?", "Yes", "No")
+                          )
+                        {
+                            RunBuild();
+                        }
+                    }
+
+
+
+
+                }
+                catch (Exception e)
+                {
+                    Debug.LogException(e, this);
+                }
+                finally
+                {
+                    EditorUtility.ClearProgressBar();
                 }
             }
-            catch(Exception e)
+            else
             {
-                Debug.LogException(e, this);
+                Debug.LogWarning("Build is disabled");
             }
-            finally
+
+            return report;
+        }
+
+        public string buildFullPath => Path.GetFullPath(Path.Combine(Path.Combine(Application.dataPath, ".."), BuildPath));
+
+        public bool foundBuildExecutable
+        {
+            get
             {
-                EditorUtility.ClearProgressBar();
+                return File.Exists(Path.Combine(buildFullPath + ExecutableName));
             }
         }
-        else
+
+        public bool canRunFromEditor
         {
-            Debug.LogWarning("Build is disabled");
+            get
+            {
+#if UNITY_EDITOR_WIN
+                return Profile.Target == BuildTarget.StandaloneWindows64 || Profile.Target == BuildTarget.StandaloneWindows;
+#elif UNITY_EDITOR_OSX
+                return Profile.Target == BuildTarget.StandaloneOSX;
+#elif UNITY_EDITOR_LINUX
+                return Profile.Target == BuildTarget.StandaloneLinux64;
+#else
+                return false;
+#endif         
+            }
         }
 
-        return report;
-    }
-
-    public bool canRunBuild
-    {
-        get
+        public void RunBuild()
         {
-            return System.IO.File.Exists(Application.dataPath + "/../" + BuildPath + ExecutableName);
-        }
-    }
+            bool canRun = Profile != null && !OpenInExplorer && canRunFromEditor;
 
-    public void RunBuild()
-    {
-        ProcessStartInfo info = new ProcessStartInfo();
-        string path = Application.dataPath + "/../" + BuildPath;
-        info.FileName = path + ExecutableName;
-        info.Arguments = RunWithArguments;
-        info.WorkingDirectory = path;
-        info.UseShellExecute = false;
+            string path = buildFullPath;
+
+            if (canRun)
+            {
+                ProcessStartInfo info = new ProcessStartInfo();
+                info.FileName = path + ExecutableName;
+                info.Arguments = RunWithArguments;
+                info.WorkingDirectory = path;
+                info.UseShellExecute = false;
+
+                EditorUtility.DisplayProgressBar("Build Frontend", $"Running Player : {info.FileName}", 1.0f);
+                Process process = Process.Start(info);
+                EditorUtility.ClearProgressBar();
+            }
+            else
+            {
+                ProcessStartInfo info = new ProcessStartInfo();
+                path = $"\"{path}\"";
+
+#if UNITY_EDITOR_WIN
+                info.FileName = "explorer.exe";
+                path = path.Replace("/", "\\");
+                info.Arguments = $"/root,{path}";
+#elif UNITY_EDITOR_OSX
+                info.FileName = "open";
+                path = path.Replace("\\", "/");
+                info.Arguments = $"{path}";
+#elif UNITY_EDITOR_LINUX
+                info.FileName = "nautilus";
+                path = path.Replace("\\", "/");
+                info.Arguments = $"{path}";
+#else
+                return;
+#endif
+
+                Process process = Process.Start(info);
+            }
 
-        EditorUtility.DisplayProgressBar("Build Frontend",$"Running Player : {info.FileName}", 1.0f);
 
-        Process process = Process.Start(info);
-
+
+        }
     }
+
 }

Editor/Assets/BuildTemplateAssetFactory.cs

@@ -1,13 +1,13 @@
 using UnityEngine;
-using UnityEditor.Callbacks;
+using UnityEditor;
 using UnityEditor.ProjectWindowCallback;
 using System.IO;
 
-namespace UnityEditor.VFXToolbox.ImageSequencer
+namespace BuildFrontend
 {
     internal class BuildTemplateAssetFactory
     {
-        [MenuItem("Assets/Create/Build/Build Template", priority = BuildFrontend.CreateAssetMenuPriority)]
+        [MenuItem("Assets/Create/Build Frontend/Build Template", priority = BuildFrontend.CreateAssetMenuPriority)]
         private static void MenuCreatePostProcessingProfile()
         {
             var icon = EditorGUIUtility.FindTexture("BuildTemplate");