static void CommandLineBuildAndroid()
{
Debug.Log("Command line build Android version\n------------------\n------------------");
string[] scenes = UnityBuild_HelperMethods.GetBuildScenes();
string path = "D:/Unity Projects/Publishing files/AutomatedUnityBuilds/GameyFire.apk";
EditorUserBuildSettings.SetBuildLocation(BuildTarget.Android, path);
if (scenes == null || scenes.Length == 0 || path == null)
{
return;
}
Debug.Log(string.Format("Path: \"{0}\"", path));
for (int i = 0; i < scenes.Length; ++i)
{
Debug.Log(string.Format("Scene[{0}]: \"{1}\"", i, scenes[i]));
}
//Debug.Log(string.Format("Creating Directory \"{0}\" if it does not exist", path));
//(new FileInfo(path)).Directory.Create();
Debug.Log(string.Format("Switching Build Target to {0}", "Android"));
EditorUserBuildSettings.SwitchActiveBuildTarget(BuildTarget.Android);
Debug.Log("Starting Android Build!");
BuildPipeline.BuildPlayer(scenes, EditorUserBuildSettings.GetBuildLocation(BuildTarget.Android), BuildTarget.Android, BuildOptions.None);
}
public virtual string GetBuiltNameForTarget(BuildTarget NewTarget)
{
string BuiltName = "";
bool bAndroid = false;
if (NewTarget == BuildTarget.Android)
{
BuiltName = GetParamOrConfigString("BuiltAndroidName");
bAndroid = true;
}
if (BuiltName == "")
{
BuiltName = Path.GetFileName(EditorUserBuildSettings.GetBuildLocation(NewTarget));
}
if (BuiltName == "")
{
if (bAndroid)
{
BuiltName = "Android";
}
}
if (!BuiltName.EndsWith(".apk"))
{
BuiltName += ".apk";
}
return(BuiltName);
}
static BuildPlayerOptions GetBuildPlayerOptions(
bool askForLocation = false,
BuildPlayerOptions defaultOptions = new BuildPlayerOptions())
{
// Fake BuildLocation path to prevent Unity exception
var activeBuildTarget = EditorUserBuildSettings.activeBuildTarget;
var buildLocation = EditorUserBuildSettings.GetBuildLocation(activeBuildTarget);
// Making sure that current BuildLocation is valid, otherwise create new proper one.
// New created location will be like: .../<ProjectRoot>/Builds/<BuildTarget>
switch (InternalEditorUtility.BuildCanBeAppended(activeBuildTarget, buildLocation))
{
case CanAppendBuild.No:
case CanAppendBuild.Unsupported:
var newBuildLocation = CombinePaths(DefaultBuildLocation, "build");
EditorUserBuildSettings.SetBuildLocation(activeBuildTarget, newBuildLocation);
break;
}
// Get static internal "GetBuildPlayerOptionsInternal" method and invoke it
var method = typeof(BuildPlayerWindow.DefaultBuildMethods).GetMethod(
"GetBuildPlayerOptionsInternal",
BindingFlags.NonPublic | BindingFlags.Static);
return((BuildPlayerOptions)method.Invoke(
null,
new object[] { askForLocation, defaultOptions }));
}
// workaround for https://issuetracker.unity3d.com/issues/plugins-not-copied-to-the-standalone-plugin-folder-when-they-are-marked-to-be-included-in-build
private static void CopyPluginsForStandaloneBuildIfRequired(BuildTarget buildTarget)
{
if (PlatformHelpers.IsStandaloneOSX(buildTarget))
{
const string pluginBundle = "StreamAlpha.bundle";
foreach (var pluginImporter in PluginImporter.GetImporters(buildTarget))
{
if (pluginImporter.assetPath.EndsWith(pluginBundle))
{
var appDirectory = EditorUserBuildSettings.GetBuildLocation(buildTarget);
var destination = Path.Combine(appDirectory, Path.Combine("Contents/Plugins/", pluginBundle));
var source = pluginImporter.assetPath;
bool shouldCopy = !Directory.Exists(destination) ||
GetLastSourceWriteTimeUtc(source) > GetLastSourceWriteTimeUtc(destination);
if (shouldCopy)
{
CopyDirectoryRecursive(source, destination);
}
}
}
}
}
/// <summary>
/// TODO: remove this once all the bugs are worked out. This saves us a little
/// time by avoiding having to run the full Unity build every time we want to
/// validate the post process.
/// </summary>
private static void ShowRerunButton()
{
// Displaying the current build location serves as a reminder to the user what is going on.
var currentBuildLocation = EditorUserBuildSettings.GetBuildLocation(BuildTarget.iOS);
bool hasBuildLocation = !string.IsNullOrEmpty(currentBuildLocation);
if (hasBuildLocation)
{
currentBuildLocation = PathExt.Abs2Rel(currentBuildLocation);
}
else
{
currentBuildLocation = "<N/A>";
}
GUILayout.Label(
string.Format(
"Current Build Location: {0}",
currentBuildLocation));
if (hasBuildLocation && GUILayout.Button("Run post-build process"))
{
OnPostBuild(BuildTarget.iOS, currentBuildLocation);
}
else
{
GUILayout.Label("Please run build process for iOS.");
}
}
/// <summary>
/// Show a dialog to let the user pick a build location.
/// </summary>
/// <remarks>
/// Based on BuildPlayerWindow.PickBuildLocation in private Unity engine code.
/// </remarks>
static string PickBuildLocation(BuildTarget target)
{
var buildLocation = EditorUserBuildSettings.GetBuildLocation(target);
if (target == BuildTarget.Android && EditorUserBuildSettings.exportAsGoogleAndroidProject)
{
var location = EditorUtility.SaveFolderPanel("Export Google Android Project", buildLocation, "");
return(location);
}
string directory = "", filename = "";
if (!string.IsNullOrEmpty(buildLocation))
{
directory = Path.GetDirectoryName(buildLocation);
filename = Path.GetFileName(buildLocation);
}
// Call internal method:
// string SaveBuildPanel(BuildTarget target, string title, string directory, string defaultName, string extension, out bool updateExistingBuild)
var method = typeof(EditorUtility).GetMethod("SaveBuildPanel", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
if (method == null)
{
Debug.LogError("Could no find SaveBuildPanel method on EditorUtility class.");
return(null);
}
var args = new object[] { target, "Build " + target, directory, filename, "", null };
var path = (string)method.Invoke(null, args);
return(path);
}
public void Load()
{
// Define 'BUILD_PIPELINE_IOS_UNITY_DEFAULT' if you want to set a build location as same as default of Unity Editor
// But it's buggy because the native doesn't generate the new folder to put a build.
#if BUILD_PIPELINE_IOS_UNITY_DEFAULT
buildPath = PlayerPrefs.GetString(PREFS_SETTINGS_BUILD_PATH, EditorUserBuildSettings.GetBuildLocation(BuildTarget.iOS));
#else
buildPath = PlayerPrefs.GetString(PREFS_SETTINGS_BUILD_PATH, string.Empty);
#endif
nameFormat = PlayerPrefs.GetString(PREFS_SETTINGS_NAME_FORMAT, "{package}_{date}");
dateTimeFormat = PlayerPrefs.GetString(PREFS_SETTINGS_DATE_TIME_FORMAT, "yyyyMMddHHmmss");
createNewFolder = PlayerPrefs.GetString(PREFS_SETTINGS_CREATE_NEW_FOLDER, bool.TrueString) == bool.TrueString;
setURLSchemes = PlayerPrefs.GetString(PREFS_SETTINGS_SET_URL_SCHEMES, bool.FalseString) == bool.TrueString;
if (PlayerPrefs.HasKey(PREFS_SETTINGS_URL_SCHEMES))
{
string str = PlayerPrefs.GetString(PREFS_SETTINGS_URL_SCHEMES, string.Empty);
if (str != null && str.Length > 0)
{
urlSchemes = str.Split('|');
}
else
{
urlSchemes = new string[0];
}
}
else
{
urlSchemes = new string[0];
}
buildOptions = (BuildOptions)PlayerPrefs.GetInt(PREFS_SETTINGS_BUILD_OPTIONS, 0);
}
public void Load()
{
// Define 'BUILD_PIPELINE_ANDROID_UNITY_DEFAULT' if you want to set a build location as same as default of Unity Editor
// But it's buggy because it will include default file name too.
#if BUILD_PIPELINE_ANDROID_UNITY_DEFAULT
buildPath = PlayerPrefs.GetString(PREFS_SETTINGS_BUILD_PATH, EditorUserBuildSettings.GetBuildLocation(BuildTarget.Android));
#else
buildPath = PlayerPrefs.GetString(PREFS_SETTINGS_BUILD_PATH, string.Empty);
#endif
nameFormat = PlayerPrefs.GetString(PREFS_SETTINGS_NAME_FORMAT, "{package}_{date}");
dateTimeFormat = PlayerPrefs.GetString(PREFS_SETTINGS_DATE_TIME_FORMAT, "yyyyMMddHHmmss");
incrementBundle = PlayerPrefs.GetString(PREFS_SETTINGS_INCREMENT_BUNDLE, bool.FalseString) == bool.TrueString;
buildOptions = (BuildOptions)PlayerPrefs.GetInt(PREFS_SETTINGS_BUILD_OPTIONS, 0);
useKeystore = PlayerPrefs.GetString(PREFS_SETTINGS_USE_KEYSTORE, bool.FalseString) == bool.TrueString;
keystoreName = PlayerPrefs.GetString(PREFS_SETTINGS_KEYSTORE_NAME, PlayerSettings.Android.keystoreName);
keyaliasName = PlayerPrefs.GetString(PREFS_SETTINGS_KEYALIAS_NAME, string.Empty);
var keystorePassEncoded = PlayerPrefs.GetString(PREFS_SETTINGS_KEYSTORE_PASS, string.Empty);
if (!string.IsNullOrEmpty(keystorePassEncoded))
{
keystorePass = Encoding.ASCII.GetString(Convert.FromBase64String(keystorePassEncoded));
}
var keyaliasPassEncoded = PlayerPrefs.GetString(PREFS_SETTINGS_KEYALIAS_PASS, string.Empty);
if (!string.IsNullOrEmpty(keyaliasPassEncoded))
{
keyaliasPass = Encoding.ASCII.GetString(Convert.FromBase64String(keyaliasPassEncoded));
}
}
//
// Opens the jsgz and/or the js file in the current webgl build folder
// and inserts devicePixelRatio accordingly to add support for retina/hdpi
//
//[MenuItem("Hbx/WebGL Tools/Retina Fix Release Build", false, 11)]
public static void RetinaFixReleaseBuild(string buildOverridePath = "")
{
UnityEngine.Debug.Log("WebGLRetinaTools: Fix release build started.");
// get path of the last webgl build or use over ride path
string webglBuildPath = string.IsNullOrEmpty(buildOverridePath) ? EditorUserBuildSettings.GetBuildLocation(BuildTarget.WebGL) : buildOverridePath;
string releaseFolderPath = Path.Combine(webglBuildPath, RelFolder);
if (string.IsNullOrEmpty(releaseFolderPath))
{
UnityEngine.Debug.LogError("WebGLRetinaTools: WebGL build path is empty, have you created a release WebGL build yet?");
return;
}
// check there is a release folder
if (!Directory.Exists(releaseFolderPath))
{
UnityEngine.Debug.LogError("WebGLRetinaTools: Couldn't find Release folder for WebGL build at path:\n" + releaseFolderPath);
return;
}
// find source files in release folder and fix
string[] sourceFiles = FindSourceFilesInBuildFolder(releaseFolderPath);
foreach (string sourceFile in sourceFiles)
{
FixSourceFile(sourceFile, true);
}
UnityEngine.Debug.Log("WebGLRetinaTools: Fixed " + sourceFiles.Length + " release source files.");
EditorUtility.ClearProgressBar();
}
private static void OpenBuildData()
{
string fullPathOfExe = EditorUserBuildSettings.GetBuildLocation(EditorUserBuildSettings.activeBuildTarget);
string appDirectory = Path.GetDirectoryName(fullPathOfExe);
string dataPath = $"{appDirectory}/{Path.GetFileNameWithoutExtension(fullPathOfExe)}_Data";
Process.Start(dataPath);
}
private void OnEnable()
{
outputPath = EditorUserBuildSettings.GetBuildLocation(BuildTarget.StandaloneWindows64);
if (string.IsNullOrEmpty(outputPath))
{
outputPath = Path.GetFullPath(Path.Combine(Application.dataPath, "../Build/Were.Wolf.exe"));
}
}
public void OnProcessScene(UnityEngine.SceneManagement.Scene scene)
{
string path = EditorUserBuildSettings.GetBuildLocation(EditorUserBuildSettings.activeBuildTarget);
int last_slash = path.LastIndexOf('/');
string pointCloudDirectory = path.Substring(0, last_slash + 1);
foreach (var gameObject in scene.GetRootGameObjects())
{
PlayableDirector director = gameObject.GetComponent <PlayableDirector>();
if (director != null)
{
if (director.playableAsset != null)
{
TimelineAsset timeline = (TimelineAsset)director.playableAsset;
foreach (var track in timeline.GetOutputTracks())
{
foreach (var clip in track.GetClips())
{
if (clip.asset.GetType() == typeof(PointCloudClip))
{
uint clip_start_frame = (uint)clip.clipIn * 30;
uint clip_duration_in_frames = (uint)clip.duration * 30;
uint clip_end_frame = clip_start_frame + clip_duration_in_frames;
string[] files = new string[0];
PointCloudClip pcc = (PointCloudClip)clip.asset;
if (Directory.Exists(pcc.template.PointCloudDirectory.Substring(1)))
{
files = Directory.GetFiles(pcc.template.PointCloudDirectory.Substring(1));
}
foreach (var file in files)
{
Directory.CreateDirectory(pointCloudDirectory + pcc.template.PointCloudDirectory);
int last_dot_in_filename = file.LastIndexOf('.');
int last_slash_in_filename = file.LastIndexOf('\\');
int no_length = last_dot_in_filename - last_slash_in_filename - 1;
uint file_no = UInt32.Parse(file.Substring(last_slash_in_filename + 1, no_length));
if (file_no >= clip_start_frame &&
file_no <= clip_end_frame)
{
if (!File.Exists(pointCloudDirectory + '/' + file))
{
File.Copy(file, pointCloudDirectory + '/' + file);
}
}
}
}
}
}
}
}
}
}
public static void BuildProject()
{
bool abortBuild = false;
if (System.IO.Directory.Exists(Application.dataPath + "/Scripts/Profiler") &&
!System.IO.Directory.Exists(Application.dataPath + "/Editor/Profiler"))
{
System.IO.Directory.Move(Application.dataPath + "/Scripts/Profiler", Application.dataPath + "/Editor/Profiler");
}
if (System.IO.Directory.Exists(Application.dataPath + "/Scripts/Profiler.meta") &&
!System.IO.Directory.Exists(Application.dataPath + "/Editor/Profiler.meta"))
{
System.IO.File.Move(Application.dataPath + "/Scripts/Profiler.meta", Application.dataPath + "/Editor/Profiler.meta");
}
AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate);
string[] scenes = new string[EditorBuildSettings.scenes.Length];
for (int i = 0; i < scenes.Length; ++i)
{
scenes[i] = EditorBuildSettings.scenes[i].path;
}
#if UNITY_ANDROID
EditorUserBuildSettings.appendProject = false;
string savePath = EditorUtility.SaveFilePanel("Build " + BuildTarget.Android,
EditorUserBuildSettings.GetBuildLocation(BuildTarget.Android), "", "apk");
if (savePath.Length != 0)
{
// Reset build location and name
// string dir = System.IO.Path.GetDirectoryName(savePath);
EditorUserBuildSettings.SetBuildLocation(BuildTarget.Android, savePath);
}
else
{
abortBuild = true;
}
#else
EditorUserBuildSettings.appendProject = true;
#endif
if (!abortBuild)
{
UpdateBuildNumber();
BuildPipeline.BuildPlayer(scenes, EditorUserBuildSettings.GetBuildLocation(EditorUserBuildSettings.activeBuildTarget),
EditorUserBuildSettings.activeBuildTarget, BuildOptions.AcceptExternalModificationsToPlayer);
}
//TODO: this is project specific. We should find a way to externalize it from this generic build tool.
System.IO.Directory.Move(Application.dataPath + "/Editor/Profiler", Application.dataPath + "/Scripts/Profiler");
System.IO.File.Move(Application.dataPath + "/Editor/Profiler.meta", Application.dataPath + "/Scripts/Profiler.meta");
AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate);
}
public Params()
{
Target = BuildUtils.SelectedBuildTarget;
BuildOptions buildOptions = BuildOptions.None;
if (!UnityEditorInternal.InternalEditorUtility.inBatchMode)
{
if (EditorUserBuildSettings.allowDebugging)
{
buildOptions |= BuildOptions.AllowDebugging;
}
if (EditorUserBuildSettings.development)
{
buildOptions |= BuildOptions.Development;
}
if (EditorUserBuildSettings.appendProject)
{
buildOptions |= BuildOptions.AcceptExternalModificationsToPlayer;
}
if (EditorUserBuildSettings.symlinkLibraries)
{
buildOptions |= BuildOptions.SymlinkLibraries;
}
if (EditorUserBuildSettings.connectProfiler)
{
buildOptions |= BuildOptions.ConnectWithProfiler;
}
if (EditorUserBuildSettings.installInBuildFolder)
{
buildOptions |= BuildOptions.InstallInBuildFolder;
}
if (EditorUserBuildSettings.webPlayerOfflineDeployment)
{
buildOptions |= BuildOptions.WebPlayerOfflineDeployment;
}
AndroidSubtarget = EditorUserBuildSettings.androidBuildSubtarget;
}
Options = buildOptions;
string buildLocation = EditorUserBuildSettings.GetBuildLocation(Target);
if (!string.IsNullOrEmpty(buildLocation))
{
Location = buildLocation;
}
}
public static void PerformDefaultBuildContext()
{
BuildTarget defaultTarget = new BuildTarget();
defaultTarget.name = "Default";
defaultTarget.target = EditorUserBuildSettings.activeBuildTarget;
defaultTarget.targetGroup = EditorUserBuildSettings.selectedBuildTargetGroup;
defaultTarget.options = BuildOptions.None;
defaultTarget.outputDirectory = EditorUserBuildSettings.GetBuildLocation(defaultTarget.target);
Builder.BuildTarget(defaultTarget);
}
static void BuildAssetBundlesForBuild()
{
string assetBundleDirectory = EditorUserBuildSettings.GetBuildLocation(EditorUserBuildSettings.activeBuildTarget).Replace(".exe", "_Data/StreamingAssets");
if (!Directory.Exists(assetBundleDirectory))
{
UnityEngine.Debug.LogError("Can not find Build you need to build at least once ");
return;
}
BuildAllAssetBundles(assetBundleDirectory);
}
static void MakeBuild()
{
BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions();
buildPlayerOptions.scenes = GetAllScenes();
buildPlayerOptions.locationPathName =
EditorUserBuildSettings.GetBuildLocation(EditorUserBuildSettings.activeBuildTarget);
buildPlayerOptions.target = EditorUserBuildSettings.activeBuildTarget;
buildPlayerOptions.options = BuildOptions.None;
BuildPipeline.BuildPlayer(buildPlayerOptions);
}
public static BuildPlayerOptions GetCurrentBuildPlayerOptions(BuildTarget target, string[] arguments)
{
var targetGroup = BuildPipeline.GetBuildTargetGroup(target);
var options = new BuildPlayerOptions
{
target = target,
targetGroup = targetGroup,
locationPathName = EditorUserBuildSettings.GetBuildLocation(target),
};
return(UpdateBuildPlayerOptions(options, arguments, false));
}
public static void RunBuild()
{
try
{
string path = EditorUserBuildSettings.GetBuildLocation(EditorUserBuildSettings.activeBuildTarget);
System.Diagnostics.Process.Start(path);
}
catch
{
Debug.LogError("Any build found, you need to build at least once");
}
}
private static void GetBuildLocation(EditorPluginModel model)
{
var path = EditorUserBuildSettings.GetBuildLocation(EditorUserBuildSettings.selectedStandaloneTarget);
if (PluginSettings.SystemInfoRiderPlugin.operatingSystemFamily == OperatingSystemFamilyRider.MacOSX)
{
path = Path.Combine(Path.Combine(Path.Combine(path, "Contents"), "MacOS"), PlayerSettings.productName);
}
if (!string.IsNullOrEmpty(path) && File.Exists(path))
{
model.BuildLocation.Value = path;
}
}
static void Build(bool autorun)
{
if (!Application.HasProLicense())
{
Debug.LogError("PRO license needed to run Multires tool");
return;
}
// Get build path
string buildPath = EditorUserBuildSettings.GetBuildLocation(EditorUserBuildSettings.activeBuildTarget);
if (buildPath.Length == 0)
{
Debug.LogError("Build path not set.");
return;
}
// Get scenes
List <string> sceneList = new List <string>();
EditorBuildSettingsScene[] selectedScenes = EditorBuildSettings.scenes;
foreach (EditorBuildSettingsScene scene in selectedScenes)
{
if (scene.enabled)
{
sceneList.Add(scene.path);
}
}
GameObject[] objects = FindObjectsOfType <GameObject>();
Multires._bDisableUpdate = true;
PreparePrefabs();
RemoveSpriteReferences(objects);
BuildPipeline.BuildPlayer(
sceneList.ToArray(),
buildPath,
EditorUserBuildSettings.activeBuildTarget, autorun ? BuildOptions.AutoRunPlayer : BuildOptions.None
);
Debug.Log("Post build");
ResetReferences(FindObjectsOfType <GameObject>());
ResetPrefabsReferences();
Multires._bDisableUpdate = false;
}
static string GetBuildLocation(BuildTarget buildTarget)
{
string[] args = System.Environment.GetCommandLineArgs();
int indexOfBuildLocation = System.Array.IndexOf(args, BUILD_LOCATION);
if (indexOfBuildLocation >= 0)
{
indexOfBuildLocation++;
Debug.Log(string.Format("Build Location for {0} set to {1}", buildTarget.ToString(), args[indexOfBuildLocation]));
return(args[indexOfBuildLocation]);
}
else
{
Debug.Log(string.Format("Build Location for {0} not set. Defaulting to {1}", buildTarget.ToString(),
EditorUserBuildSettings.GetBuildLocation(buildTarget)));
return(EditorUserBuildSettings.GetBuildLocation(buildTarget));
}
}
static string GetBuildLocation(BuildTarget buildTarget, string defaultLocation)
{
var args = Environment.GetCommandLineArgs();
var indexOfBuildLocation = Array.IndexOf(args, ArgsBuildLocation);
if (indexOfBuildLocation >= 0)
{
indexOfBuildLocation++;
Debug.Log(string.Format("Build Location for {0} set to {1}", buildTarget, args[indexOfBuildLocation]));
return(args[indexOfBuildLocation]);
}
var location = EditorUserBuildSettings.GetBuildLocation(buildTarget);
location = defaultLocation.Length != 0 ? defaultLocation : location;
Debug.Log(string.Format("Build Location for {0} not set. Defaulting to {1}", buildTarget, location));
return(location);
}
public static void AfterBuildIsDone(BuildTarget target, string pathToBuiltProject)
{
if (Application.isEditor)
{
if (showOptions)
{
devTracker.history.Add(System.DateTime.Now.ToString() +
"\nVersion: " + devTracker.version +
"\nIteration " + devTracker.build.ToString() + "\nDescription:\n" +
devTracker.description + "\n" +
EditorUserBuildSettings.GetBuildLocation(EditorUserBuildSettings.activeBuildTarget));
bundleVersionCounter = 0;
bundleCodeWentUp = false;
showOptions = false;
EditorUtility.SetDirty(devTracker);
}
}
}
public void Load()
{
// Define 'BUILD_PIPELINE_WEBGL_UNITY_DEFAULT' if you want to set a build location as same as default of Unity Editor
// But it's buggy because the native doesn't generate the new folder to put a build.
#if BUILD_PIPELINE_WEBGL_UNITY_DEFAULT
buildPath = PlayerPrefs.GetString(PREFS_SETTINGS_BUILD_PATH, EditorUserBuildSettings.GetBuildLocation(BuildTarget.WebGL));
#else
buildPath = PlayerPrefs.GetString(PREFS_SETTINGS_BUILD_PATH, string.Empty);
#endif
nameFormat = PlayerPrefs.GetString(PREFS_SETTINGS_NAME_FORMAT, "{package}_{date}");
dateTimeFormat = PlayerPrefs.GetString(PREFS_SETTINGS_DATE_TIME_FORMAT, "yyyyMMddHHmmss");
stripMobileWarning = PlayerPrefs.GetString(PREFS_SETTINGS_STRIP_MOBILE_WARNING, bool.FalseString) == bool.TrueString;
createNewFolder = PlayerPrefs.GetString(PREFS_SETTINGS_CREATE_NEW_FOLDER, bool.TrueString) == bool.TrueString;
linkerTarget = (WebGLLinkerTarget)PlayerPrefs.GetInt(PREFS_SETTINGS_LINKER_TARGET, (int)PlayerSettings.WebGL.linkerTarget);
memorySize = PlayerPrefs.GetInt(PREFS_SETTINGS_MEMORY_SIZE, PlayerSettings.WebGL.memorySize);
compressionFormat = (WebGLCompressionFormat)PlayerPrefs.GetInt(PREFS_SETTINGS_COMPRESSION_FORMAT, (int)PlayerSettings.WebGL.compressionFormat);
wasmStreaming = PlayerPrefs.GetString(PREFS_SETTINGS_WASM_STREAMING, PlayerSettings.WebGL.wasmStreaming ? bool.TrueString : bool.FalseString) == bool.TrueString;
buildOptions = (BuildOptions)PlayerPrefs.GetInt(PREFS_SETTINGS_BUILD_OPTIONS, 0);
}
public static void Build()
{
LanguageFixPreprocessBuild.FixLanguage();
string bundleVersion = PlayerSettings.bundleVersion;
AssetDatabaseHelper.CreateFolderRecursive("/Assets/Fort/Resources");
string path = Path.Combine(Application.dataPath, "Fort/Resources/Version.txt");
using (StreamWriter writer = new StreamWriter(path))
{
writer.Write(bundleVersion);
}
AssetDatabase.Refresh();
BuildPipeline.BuildPlayer(EditorBuildSettings.scenes.Select(scene => scene.path).ToArray(), EditorUserBuildSettings.GetBuildLocation(EditorUserBuildSettings.activeBuildTarget), EditorUserBuildSettings.activeBuildTarget, BuildOptions.None);
string buildLocation = EditorUserBuildSettings.GetBuildLocation(EditorUserBuildSettings.activeBuildTarget);
string argument = "/select, \"" + buildLocation.Replace("/", "\\") + "\"";
Process.Start("explorer.exe", argument);
}
private string PickBuildLocation()
{
var target = EditorUserBuildSettings.activeBuildTarget;
var targetGroup = BuildPipeline.GetBuildTargetGroup(target);
var lastLocation = EditorUserBuildSettings.GetBuildLocation(target);
var extension = PostprocessBuildPlayer.GetExtensionForBuildTarget(targetGroup, target, BuildOptions.None);
var defaultName = FileUtil.GetLastPathNameComponent(lastLocation);
lastLocation = string.IsNullOrEmpty(lastLocation) ? string.Empty : Path.GetDirectoryName(lastLocation);
bool updateExistingBuild;
var location = EditorUtility.SaveBuildPanel(target, $"{GetBuildText()} {target}", lastLocation, defaultName, extension,
out updateExistingBuild);
if (!string.IsNullOrEmpty(location))
{
EditorUserBuildSettings.SetBuildLocation(target, location);
}
return(location);
}
static void SetiOSBuildPath()
{
#if UNITY_IOS
AdjustEditor.iOSBuildPath = EditorUtility.OpenFolderPanel(
title: "iOs build path",
folder: EditorUserBuildSettings.GetBuildLocation(BuildTarget.iPhone),
defaultName: "");
if (AdjustEditor.iOSBuildPath == "")
{
UnityEngine.Debug.Log("iOS build path reset to default path");
}
else
{
UnityEngine.Debug.Log(string.Format("iOS build path: {0}", AdjustEditor.iOSBuildPath));
}
#else
EditorUtility.DisplayDialog("Adjust", "Option only valid for the Android platform.", "OK");
#endif
}
void DoBuild()
{
// Update latest version's date/time to reflect build
build.CurrentVersion.date = DateTime.Now;
Save();
string buildLocation = EditorUserBuildSettings.GetBuildLocation(EditorUserBuildSettings.activeBuildTarget);
if (!string.IsNullOrEmpty(buildLocation))
{
// string[] dlls = Directory.GetFiles("Assets/Plugins", "*.dll");
// foreach (string dll in dlls)
// File.Copy(dll, Path.GetDirectoryName(buildLocation) + "/" + Path.GetFileName(dll), true);
BuildPipeline.BuildPlayer(
EditorBuildSettings.scenes.Where(scene => scene.enabled).Select(scene => scene.path).ToArray(),
buildLocation,
EditorUserBuildSettings.activeBuildTarget,
BuildOptions.ShowBuiltPlayer);
File.WriteAllText(buildLocation + "/ReleaseNotes.txt", GetReleaseNotes());
}
}
/// <summary>
/// Generates path to builds. Has 2 options:
/// <list type="bullet">
/// <item>
/// <description>If result path is the file: <br/><![CDATA[
/// <builds_root>/<product_name> <version>[.<target>]/<product_name>[.<specifyName>].<extension>
/// ]]> <br/> e.g. <b>/Builds/my_app 2.1.234/my_app.exe</b> or<br/>
/// <b>/Builds/my_app 2.1.234.Android/my_app.ARMv7.apk</b>
/// </description>
/// </item>
/// <item>
/// <description>If result path is the directory: <br/><![CDATA[
/// <builds_root>/<product_name> <version>[.<target>][.<specifyName>]
/// ]]> <br/> e.g. <b>/Builds/my_app 2.1.234.iOS</b>
/// </description>
/// </item>
/// </list> Where <i>builds_root</i> - build location defined in Unity Build Settings window,
/// <i>product_name</i> - Product name from Player Settings,
/// <i>product_name</i> - file extension depending on the target.
/// If user not define build location for current target, folder panel will open.
/// </summary>
/// <param name="target">Target of build</param>
/// <param name="version">Version of build</param>
/// <param name="specifyTarget">Default is <i>true</i>. If <i>true</i> then
/// name of target will be present in the returned path.</param>
/// <param name="specifyName">Optional</param>
/// <returns>Generated path to builds</returns>
/// <exception cref="OperationCanceledException">User closed folder panel.</exception>
public static string GetBuildPath(BuildTarget target, string version, bool specifyTarget = true, string specifyName = null)
{
var pathBuild = EditorUserBuildSettings.GetBuildLocation(target);
var fileExtension = BuildLocationFileExtension(target);
if (string.IsNullOrEmpty(pathBuild))
{
var title = string.Format("Select folder for {0} builds for this project", target);
pathBuild = EditorUtility.OpenFolderPanel(title, "", "");
if (pathBuild == null)
{
throw new OperationCanceledException("User cancel build");
}
if (fileExtension != null)
{
pathBuild += "/" + PlayerSettings.productName + fileExtension;
}
EditorUserBuildSettings.SetBuildLocation(target, pathBuild);
}
var targetStr = specifyTarget ? "." + BuiltTargetToPrettyString(target) : "";
var specifyExt = string.IsNullOrEmpty(specifyName) ? "" : "." + specifyName;
if (fileExtension != null)
{
var pathSeparators = new char[] { '/', '\\' };
var subLength = Math.Min(Math.Max(0, pathBuild.LastIndexOfAny(pathSeparators)), pathBuild.Length);
pathBuild = pathBuild.Substring(0, subLength).TrimEnd(pathSeparators);
return(string.Format("{0}/{1} {2}{3}/{1}{4}{5}",
pathBuild, PlayerSettings.productName, version, targetStr, specifyExt, fileExtension));
}
else
{
return(string.Format("{0}/{1} {2}{3}{4}",
pathBuild, PlayerSettings.productName, version, targetStr, specifyExt));
}
}
