/// <summary>
/// Run a clean build before export.
/// </summary>
static public void PreExport()
{
Debug.Log("BuildAddressablesProcessor.PreExport start");
AddressableAssetSettings.CleanPlayerContent();
AddressableAssetSettings.BuildPlayerContent();
Debug.Log("BuildAddressablesProcessor.PreExport done");
}
public static void BuildContent()
{
CreateVersionBuild.CreateVersion();
SetDataBuilder();
AddressableAssetSettings.CleanPlayerContent(AddressableAssetSettingsDefaultObject.Settings.ActivePlayerDataBuilder);
AddressableAssetSettings.BuildPlayerContent();
}
public static void CleanAll()
{
var remoteBuildPath = Application.dataPath + "/../" + AddressableAssetSettingsDefaultObject.Settings.RemoteCatalogBuildPath.GetValue(AddressableAssetSettingsDefaultObject.Settings);
if (Directory.Exists(remoteBuildPath))
{
Directory.Delete(remoteBuildPath, true);
}
if (Directory.Exists(toLuaDir))
{
Directory.Delete(toLuaDir, true);
}
if (Directory.Exists(ProtoConst.protoDir))
{
Directory.Delete(ProtoConst.protoDir, true);
}
foreach (var dataBuilder in AddressableAssetSettingsDefaultObject.Settings.DataBuilders)
{
AddressableAssetSettings.CleanPlayerContent(dataBuilder as IDataBuilder);
}
CleanCache();
}
/// <summary>
/// Run a clean build before export.
/// </summary>
//[MenuItem("Addressables/Shortcuts/Build Addressables")] //uncomment for a shortcut to building addressables
static public void PreExport()
{
Debug.Log("Building Addressables...");
AddressableAssetSettings.CleanPlayerContent(
AddressableAssetSettingsDefaultObject.Settings.ActivePlayerDataBuilder);
AddressableAssetSettings.BuildPlayerContent();
Debug.Log("Finished building addressables.");
}
private void BuildAddressables()
{
Debug.Log("Building addressables...");
AddressableAssetSettings.CleanPlayerContent(
AddressableAssetSettingsDefaultObject.Settings.ActivePlayerDataBuilder);
AddressableAssetSettings.BuildPlayerContent();
Debug.Log("Addressable build complete!");
}
static async void BuildAddressables()
{
UnityEngine.Debug.Log("Cleaning addressables...");
AddressableAssetSettings.CleanPlayerContent(AddressableAssetSettingsDefaultObject.Settings.ActivePlayerDataBuilder);
UnityEngine.Debug.Log("Building addressables...");
AddressableAssetSettings.BuildPlayerContent();
UnityEngine.Debug.Log("Addressables built for current platform.");
}
public static void BuildBundle()
{
AddressablesBundleBuildScript.CreatConfig();
AddressableAssetSettings.CleanPlayerContent();
BuildCache.PurgeCache(false);
AddressableAssetSettingsDefaultObject.Settings.ActivePlayerDataBuilderIndex = 3;
AddressableAssetSettings.BuildPlayerContent();
}
public void ConfigureForBuildAndBuild()
{
ConfigureForBuild();
AddressableAssetSettings.CleanPlayerContent();
AddressableAssetSettings.BuildPlayerContent();
Debug.LogWarning($"Rebuilt addressables");
}
/// <summary>
/// Run a clean build before export.
/// </summary>
private static void PreExport()
{
Debug.Log("BuildAddressablesProcessor.PreExport start");
AddressableAssetSettings.CleanPlayerContent(AddressableAssetSettingsDefaultObject.Settings
.ActivePlayerDataBuilder);
AddressableAssetSettings.BuildPlayerContent();
Debug.Log("BuildAddressablesProcessor.PreExport done");
}
public static void AutoGroupBuild()
{
AddressableAssetSettings.CleanPlayerContent();
//DeleteCurGroup();
string sourcePath = Application.dataPath;
DirectoryInfo srcDir = new DirectoryInfo(sourcePath);
//IOHelper.GetAssetFiles(srcDir.FullName);
assetDic.Clear();
groupAssets.Clear();
CreatGroupAuto(srcDir.FullName);
var setting = AddressableAssetSettingsDefaultObject.Settings;
foreach (KeyValuePair <string, string> kvp in assetDic)
{
Debug.Log(kvp.Key + " / " + kvp.Value);
var guid = AssetDatabase.AssetPathToGUID(kvp.Value);
string str = kvp.Value;
var groupName = str;
int i1 = str.IndexOf('\\');
if (i1 > 0)
{
groupName = str.Remove(0, i1 + 1);
int i2 = groupName.IndexOf('\\');
if (i2 > 0)
{
groupName = groupName.Substring(0, i2);
}
}
//Debug.Log(groupName);
AddressableAssetGroup group = setting.FindGroup(groupName);
if (group == null)
{
if (groupName == "Prefabs")
{
group = setting.CreateGroup(groupName, false, false, false,
new List <AddressableAssetGroupSchema> {
setting.DefaultGroup.Schemas[0], setting.DefaultGroup.Schemas[1]
});
}
else
{
group = setting.CreateGroup(groupName, false, false, false,
new List <AddressableAssetGroupSchema> {
setting.DefaultGroup.Schemas[0], setting.DefaultGroup.Schemas[1]
});
}
groupAssets.Add(group);
}
//var assetRef = setting.CreateAssetReference(guid);
var entry = setting.CreateOrMoveEntry(guid, group);
//entry.SetAddress(kvp.Key);
//entry.SetLabel("LD",true);
}
AssetDatabase.Refresh();
//AddressableAssetSettings.BuildPlayerContent();
}
public static void BuildProject()
{
// Gather values from args
var options = ArgumentsParser.GetValidatedOptions();
// Gather values from project
var scenes = EditorBuildSettings.scenes.Where(scene => scene.enabled).Select(s => s.path).ToArray();
// Get all buildOptions from options
BuildOptions buildOptions = BuildOptions.None;
foreach (string buildOptionString in Enum.GetNames(typeof(BuildOptions)))
{
if (options.ContainsKey(buildOptionString))
{
BuildOptions buildOptionEnum = (BuildOptions)Enum.Parse(typeof(BuildOptions), buildOptionString);
buildOptions |= buildOptionEnum;
}
}
// Define BuildPlayer Options
var buildPlayerOptions = new BuildPlayerOptions {
scenes = scenes,
locationPathName = options["customBuildPath"],
target = (BuildTarget)Enum.Parse(typeof(BuildTarget), options["buildTarget"]),
options = buildOptions
};
// Set version for this build
VersionApplicator.SetVersion(options["buildVersion"]);
VersionApplicator.SetAndroidVersionCode(options["androidVersionCode"]);
// Apply Android settings
if (buildPlayerOptions.target == BuildTarget.Android)
{
AndroidSettings.Apply(options);
}
// Execute default AddressableAsset content build, if the package is installed
#if USE_ADDRESSABLES
AddressableAssetSettings.CleanPlayerContent();
AddressableAssetSettings.BuildPlayerContent();
#endif
// Perform build
BuildReport buildReport = BuildPipeline.BuildPlayer(buildPlayerOptions);
// Summary
BuildSummary summary = buildReport.summary;
StdOutReporter.ReportSummary(summary);
// Result
BuildResult result = summary.result;
StdOutReporter.ExitWithResult(result);
}
private void Build()
{
PlayerSettings.Android.keystorePass = keystorePass;
PlayerSettings.Android.keyaliasName = keyaliasName;
PlayerSettings.Android.keyaliasPass = keyaliasPass;
if (useAddressables)
{
if (clearAddressables)
{
AddressableAssetSettings.CleanPlayerContent(
AddressableAssetSettingsDefaultObject.Settings.ActivePlayerDataBuilder);
}
AddressableAssetSettings.BuildPlayerContent();
}
EditorUserBuildSettings.buildAppBundle = buildAppBundle;
if (!buildAppBundle)
{
PlayerSettings.Android.useAPKExpansionFiles = splitApplicationBinary;
}
// Get filename.
List <string> scenes = new List <string>();
foreach (EditorBuildSettingsScene scene in EditorBuildSettings.scenes)
{
if (scene.enabled)
{
scenes.Add(scene.path);
}
}
//string[] levels = new string[] { "Assets/_GUDE_SCENES/InitialScene.unity", "Assets/_GUDE_SCENES/WebLoader.unity", "Assets/_GUDE_SCENES/Story_For_Test.unity", "Assets/_GUDE_SCENES/Story_For_Game.unity" };
string fileName = $"Builds/Gude_{PlayerSettings.Android.bundleVersionCode.ToString()}_{(isDevelopmentBuild ? "dev" : "prod")}.{(buildAppBundle?"aab":"apk")}";
BuildOptions options = BuildOptions.None;
if (runAfterBuild)
{
options |= BuildOptions.AutoRunPlayer;
}
if (isDevelopmentBuild)
{
options |= BuildOptions.Development;
options |= BuildOptions.ConnectWithProfiler;
options |= BuildOptions.AllowDebugging;
options |= BuildOptions.EnableDeepProfilingSupport;
}
// Build player.
BuildPipeline.BuildPlayer(scenes.ToArray(), fileName, BuildTarget.Android, options);
PlayerSettings.bundleVersion = currentVersion + "." + PlayerSettings.Android.bundleVersionCode.ToString();
if (!isDevelopmentBuild)
{
PlayerSettings.Android.bundleVersionCode += 1;
}
}
public static void Clean()
{
if (Directory.Exists(SERVER_DATA_DIR))
{
Directory.Delete(SERVER_DATA_DIR, true);
Debug.Log("Delete " + SERVER_DATA_DIR);
}
else
{
Debug.Log("Not Found " + SERVER_DATA_DIR);
}
AddressableAssetSettings.CleanPlayerContent();
}
static void BuildWithProfile(BuildTargetGroup buildGroup, BuildTarget buildTarget)
{
var aas = AssetDatabase.LoadAssetAtPath <AddressableAssetSettings>("Assets/AddressableAssetsData/AddressableAssetSettings.asset");
Debug.Log("AddressableAssetSettings Loading:" + aas);
if (aas != null)
{
var settings = aas.profileSettings;
aas.activeProfileId = settings.GetProfileId(buildTarget.ToString());
}
EditorUserBuildSettings.SwitchActiveBuildTarget(buildGroup, buildTarget);
AddressableAssetSettings.CleanPlayerContent();
AddressableAssetSettings.BuildPlayerContent();
Debug.Log(buildTarget + " Built");
}
public static void Build(BuildSetup buildSetup)
{
var defaultScenes = ScenesUtils.getDefaultScenesAsArray();
string path = buildSetup.rootDirectory;
var playerSettingsSnapshot = new PlayerSettingsSnapshot();
var setupList = buildSetup.entriesList;
for (var i = 0; i < setupList.Count; i++)
{
var setup = setupList[i];
if (setup.enabled)
{
var target = setup.target;
var targetGroup = BuildPipeline.GetBuildTargetGroup(target);
playerSettingsSnapshot.takeSnapshot(targetGroup);
PlayerSettings.SetScriptingBackend(targetGroup, setup.scriptingBackend);
PlayerSettings.SetScriptingDefineSymbolsForGroup(targetGroup, setup.scriptingDefineSymbols);
#if UNITY_2018_3_OR_NEWER
PlayerSettings.SetManagedStrippingLevel(targetGroup, setup.strippingLevel);
#endif
#if UNITY_2017_2_OR_NEWER
if (VRUtils.targetGroupSupportsVirtualReality(targetGroup))
{
PlayerSettings.SetVirtualRealitySupported(targetGroup, setup.supportsVR);
if (setup.supportsVR)
{
var vrSdks = VRUtils.getSelectedVRSdksFromFlags(targetGroup, setup.vrSdkFlags);
PlayerSettings.SetVirtualRealitySDKs(targetGroup, vrSdks);
}
}
else
{
PlayerSettings.SetVirtualRealitySupported(targetGroup, false);
}
#endif
if (target == BuildTarget.Android)
{
#if UNITY_2017_4_OR_NEWER
EditorUserBuildSettings.buildAppBundle = setup.androidAppBundle;
PlayerSettings.Android.targetArchitectures = setup.androidArchitecture;
#endif
}
if (target == BuildTarget.PS4)
{
EditorUserBuildSettings.ps4HardwareTarget = setup.ps4HardwareTarget;
EditorUserBuildSettings.ps4BuildSubtarget = setup.ps4BuildSubtarget;
}
#if ADDRESSABLES
if (setup.rebuildAddressables)
{
AddressableAssetSettings.CleanPlayerContent(AddressableAssetSettingsDefaultObject.Settings.ActivePlayerDataBuilder);
AddressableAssetSettings.BuildPlayerContent();
}
#endif
var buildPlayerOptions = BuildUtils.getBuildPlayerOptionsFromBuildSetupEntry(setup, path, defaultScenes);
#if UNITY_2018_1_OR_NEWER
BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions);
BuildSummary buildSummary = report.summary;
var success = (buildSummary.result == BuildResult.Succeeded);
UnityEngine.Debug.Log("Build " + setup.buildName + " ended with Status: " + buildSummary.result);
#else
var result = BuildPipeline.BuildPlayer(buildPlayerOptions);
var success = string.IsNullOrEmpty(result);
UnityEngine.Debug.Log("Build " + setup.buildName + " ended with Success: " + success);
#endif
// Revert group build player settings after building
playerSettingsSnapshot.applySnapshot();
if (!success && buildSetup.abortBatchOnFailure)
{
UnityEngine.Debug.LogError("Failure - Aborting remaining builds from batch");
break;
}
}
else
{
UnityEngine.Debug.Log("Skipping Build " + setup.buildName);
}
}
}
void OnCleanAddressables(object builder)
{
AddressableAssetSettings.CleanPlayerContent(builder as IDataBuilder);
}
public static IEnumerator PackageWorlds(int packageMode, int releaseChannel, bool allWorlds, bool allTargets, bool force = false, bool linuxOnly = false)
{
uploadPossible = false;
packagingInProgress = true;
packagingSuccessful = false;
try
{
string[] worldsToBuild = allWorlds ? GetWorldPaths() : GetWorldsToBuild(packageMode);
if (worldsToBuild.Length == 0)
{
yield break;
}
string resultFolder = Application.dataPath + "/../traVRsal/";
BuildTarget mainTarget = linuxOnly || Application.platform == RuntimePlatform.LinuxEditor ? BuildTarget.StandaloneLinux64 : BuildTarget.StandaloneWindows64;
CreateLockFile();
ConvertTileMaps();
CreateAddressableSettings(!allTargets, releaseChannel);
EditorUserBuildSettings.androidBuildSubtarget = MobileTextureSubtarget.ASTC;
EditorUserBuildSettings.selectedStandaloneTarget = mainTarget;
PlayerSettings.SetScriptingBackend(BuildTargetGroup.Standalone, ScriptingImplementation.Mono2x); // Linux can only be built with Mono on Windows
AddressableAssetSettings.CleanPlayerContent();
AssetDatabase.SaveAssets();
if (Directory.Exists(GetServerDataPath()) && (packageMode == 0 || allWorlds))
{
Directory.Delete(GetServerDataPath(), true);
}
// set build targets
List <Tuple <BuildTargetGroup, BuildTarget> > targets = new List <Tuple <BuildTargetGroup, BuildTarget> >();
if (allTargets)
{
targets.Add(new Tuple <BuildTargetGroup, BuildTarget>(BuildTargetGroup.Android, BuildTarget.Android));
// set windows/linux last so that we can continue with editor iterations normally right afterwards
if (Application.platform == RuntimePlatform.LinuxEditor)
{
targets.Add(new Tuple <BuildTargetGroup, BuildTarget>(BuildTargetGroup.Standalone, BuildTarget.StandaloneWindows64));
targets.Add(new Tuple <BuildTargetGroup, BuildTarget>(BuildTargetGroup.Standalone, BuildTarget.StandaloneLinux64));
}
else
{
if (linuxSupport)
{
targets.Add(new Tuple <BuildTargetGroup, BuildTarget>(BuildTargetGroup.Standalone, BuildTarget.StandaloneLinux64));
}
targets.Add(new Tuple <BuildTargetGroup, BuildTarget>(BuildTargetGroup.Standalone, BuildTarget.StandaloneWindows64));
}
}
else
{
targets.Add(new Tuple <BuildTargetGroup, BuildTarget>(BuildTargetGroup.Standalone, mainTarget));
}
// update world content
foreach (string dir in worldsToBuild)
{
string worldName = Path.GetFileName(dir);
if (!UpdateWorldData(worldName))
{
yield break;
}
}
// iterate over all supported platforms
foreach (Tuple <BuildTargetGroup, BuildTarget> target in targets)
{
EditorUserBuildSettings.SwitchActiveBuildTarget(target.Item1, target.Item2);
// build each world individually
AddressableAssetSettings settings = AddressableAssetSettingsDefaultObject.GetSettings(true);
foreach (string dir in worldsToBuild)
{
string worldName = Path.GetFileName(dir);
string serverDir = GetServerDataPath() + "/Worlds/" + Path.GetFileName(dir);
if (!allTargets && Directory.Exists(resultFolder + worldName))
{
Directory.Delete(resultFolder + worldName, true);
}
if (packageMode == 1 && !allWorlds && Directory.Exists(serverDir))
{
Directory.Delete(serverDir, true);
}
settings.activeProfileId = settings.profileSettings.GetProfileId(worldName);
settings.groups.ForEach(group =>
{
if (group.ReadOnly)
{
return;
}
group.GetSchema <BundledAssetGroupSchema>().IncludeInBuild = group.name == worldName;
// default group ensures there is no accidental local default group resulting in local paths being baked into addressable for shaders
if (group.name == worldName && group.CanBeSetAsDefault())
{
settings.DefaultGroup = group;
}
});
BundledAssetGroupSchema schema = settings.groups.First(group => @group.name == worldName).GetSchema <BundledAssetGroupSchema>();
settings.RemoteCatalogBuildPath = schema.BuildPath;
settings.RemoteCatalogLoadPath = schema.LoadPath;
settings.ShaderBundleCustomNaming = worldName;
AddressableAssetSettings.BuildPlayerContent();
}
}
CreateAddressableSettings(!allTargets, releaseChannel); // do again to have clean build state, as some settings were messed with while building
RenameCatalogs();
packagingSuccessful = true;
}
catch (Exception e)
{
packagingInProgress = false;
EditorUtility.DisplayDialog("Error", $"Packaging could not be completed. Error: {e.Message}", "Close");
yield break;
}
if (dirWatcher != null)
{
dirWatcher.ClearAffected(); // only do at end, since during build might cause false positives
}
else
{
CreateDirWatcher(); // can happen after initial project creation
}
RemoveLockFile();
packagingInProgress = false;
Debug.Log("Packaging completed successfully.");
}
static void Build(Action behaviour)
{
// Check error
if (exportTo == ExportTo.Project && !Directory.Exists(Path.Combine(projectPath, "Assets/StreamingAssets")))
{
Debug.LogError("Cannot deploy to project dir as the folder doesn't seem to be an Unity project");
return;
}
if (exportTo == ExportTo.Game)
{
bool gameSupported = false;
foreach (string supportedGame in Enum.GetNames(typeof(SupportedGame)))
{
if (File.Exists(Path.Combine(gamePath, supportedGame + ".exe")))
{
gameSupported = true;
gameName = (SupportedGame)Enum.Parse(typeof(SupportedGame), supportedGame);
}
}
if (!gameSupported)
{
Debug.LogError("Target game not supported!");
return;
}
}
#if PrivateSDK
if (exportTo == ExportTo.Android)
{
string adbPath = Path.Combine(EditorPrefs.GetString("AndroidSdkRoot"), "platform-tools", "adb.exe");
if (!EditorPrefs.HasKey("AndroidSdkRoot") || !File.Exists(adbPath))
{
Debug.LogError("Android SDK is not installed!");
Debug.LogError("Path not found " + adbPath);
return;
}
}
#endif
// Configure stereo rendering
if (EditorUserBuildSettings.activeBuildTarget == BuildTarget.Android)
{
PlayerSettings.stereoRenderingPath = StereoRenderingPath.SinglePass;
}
if (EditorUserBuildSettings.activeBuildTarget == BuildTarget.StandaloneWindows || EditorUserBuildSettings.activeBuildTarget == BuildTarget.StandaloneWindows64)
{
PlayerSettings.stereoRenderingPath = StereoRenderingPath.Instancing;
}
// Configure addressable groups
if (AddressableAssetSettingsDefaultObject.Settings != null)
{
foreach (AddressableAssetGroup group in AddressableAssetSettingsDefaultObject.Settings.groups)
{
BundledAssetGroupSchema bundledAssetGroupSchema = group.GetSchema <BundledAssetGroupSchema>();
if (bundledAssetGroupSchema != null)
{
if (group.Default)
{
bundledAssetGroupSchema.BuildPath.SetVariableByName(AddressableAssetSettingsDefaultObject.Settings, "LocalBuildPath");
bundledAssetGroupSchema.LoadPath.SetVariableByName(AddressableAssetSettingsDefaultObject.Settings, "LocalLoadPath");
}
bundledAssetGroupSchema.BundleNaming = BundledAssetGroupSchema.BundleNamingStyle.NoHash;
bundledAssetGroupSchema.BundleNaming = BundledAssetGroupSchema.BundleNamingStyle.NoHash;
AddressableAssetSettingsDefaultObject.Settings.profileSettings.SetValue(group.Settings.activeProfileId, "LocalBuildPath", "[ThunderRoad.ModBuilder.buildPath]");
AddressableAssetSettingsDefaultObject.Settings.profileSettings.SetValue(group.Settings.activeProfileId, "LocalLoadPath", (toDefault ? "{ThunderRoad.FileManager.aaDefaultPath}/" : "{ThunderRoad.FileManager.aaModPath}/") + exportFolderName);
// Set builtin shader to export folder name to avoid duplicates
AddressableAssetSettingsDefaultObject.Settings.ShaderBundleNaming = UnityEditor.AddressableAssets.Build.ShaderBundleNaming.Custom;
AddressableAssetSettingsDefaultObject.Settings.ShaderBundleCustomNaming = exportFolderName;
AddressableAssetSettingsDefaultObject.Settings.BuildRemoteCatalog = true;
/* TODO: OBB support (zip file uncompressed and adb push to obb folder)
* AddressableAssetSettingsDefaultObject.Settings.profileSettings.SetValue(group.Settings.activeProfileId, "LocalLoadPath", "{ThunderRoad.FileManager.obbPath}/" + exportFolderName + "{ThunderRoad.FileManager.obbPathEnd}");
*/
}
}
}
AssetDatabase.Refresh();
AssetDatabase.SaveAssets();
// Build
if (behaviour == Action.BuildAndExport || behaviour == Action.BuildOnly)
{
Debug.Log("Build path is: " + buildPath);
if (OnBuildEvent != null)
{
OnBuildEvent.Invoke(EventTime.OnStart);
}
// Clean build path
if (Directory.Exists(buildPath))
{
foreach (string filePath in Directory.GetFiles(buildPath, "*.*", SearchOption.AllDirectories))
{
File.Delete(filePath);
}
}
BuildCache.PurgeCache(true);
AddressableAssetSettings.CleanPlayerContent();
AddressableAssetSettings.CleanPlayerContent(AddressableAssetSettingsDefaultObject.Settings.ActivePlayerDataBuilder);
AddressableAssetSettings.BuildPlayerContent();
Debug.Log("Build done");
if (OnBuildEvent != null)
{
OnBuildEvent.Invoke(EventTime.OnEnd);
}
}
// Export
if (behaviour == Action.BuildAndExport || behaviour == Action.ExportOnly)
{
if (exportTo == ExportTo.Game || exportTo == ExportTo.Project)
{
// Get paths
string buildFullPath = Path.Combine(Directory.GetCurrentDirectory(), buildPath);
string catalogFullPath = Path.Combine(Directory.GetCurrentDirectory(), catalogPath);
string destinationAssetsPath = "";
string destinationCatalogPath = "";
if (exportTo == ExportTo.Project)
{
destinationAssetsPath = Path.Combine(projectPath, buildPath);
destinationCatalogPath = Path.Combine(projectPath, catalogPath);
}
else if (exportTo == ExportTo.Game)
{
if (toDefault)
{
destinationAssetsPath = destinationCatalogPath = Path.Combine(gamePath, gameName + "_Data/StreamingAssets/Default", exportFolderName);
}
else
{
destinationAssetsPath = destinationCatalogPath = Path.Combine(gamePath, gameName + "_Data/StreamingAssets/Mods", exportFolderName);
}
}
// Create folders if needed
if (!File.Exists(destinationAssetsPath))
{
Directory.CreateDirectory(destinationAssetsPath);
}
if (!File.Exists(destinationCatalogPath))
{
Directory.CreateDirectory(destinationCatalogPath);
}
// Clean destination path
if (cleanDestination)
{
foreach (string filePath in Directory.GetFiles(destinationAssetsPath, "*.*", SearchOption.AllDirectories))
{
File.Delete(filePath);
}
if (exportTo == ExportTo.Game)
{
foreach (string filePath in Directory.GetFiles(destinationCatalogPath, "*.*", SearchOption.AllDirectories))
{
File.Delete(filePath);
}
}
}
else
{
foreach (string filePath in Directory.GetFiles(destinationAssetsPath, "catalog_*.json", SearchOption.AllDirectories))
{
File.Delete(filePath);
}
foreach (string filePath in Directory.GetFiles(destinationAssetsPath, "catalog_*.hash", SearchOption.AllDirectories))
{
File.Delete(filePath);
}
if (exportTo == ExportTo.Game)
{
foreach (string filePath in Directory.GetFiles(destinationCatalogPath, "catalog_*.json", SearchOption.AllDirectories))
{
File.Delete(filePath);
}
foreach (string filePath in Directory.GetFiles(destinationCatalogPath, "catalog_*.hash", SearchOption.AllDirectories))
{
File.Delete(filePath);
}
}
}
// Copy addressable assets to destination path
CopyDirectory(buildFullPath, destinationAssetsPath);
Debug.Log("Copied addressable asset folder " + buildFullPath + " to " + destinationAssetsPath);
if (exportTo == ExportTo.Game)
{
// Copy json catalog to destination path
CopyDirectory(catalogFullPath, destinationCatalogPath);
Debug.Log("Copied catalog folder " + catalogFullPath + " to " + destinationCatalogPath);
// Copy plugin dll if any
string dllPath = Path.Combine("BuildStaging", "Plugins", exportFolderName) + "/bin/Release/netstandard2.0/" + exportFolderName + ".dll";
if (File.Exists(dllPath))
{
File.Copy(dllPath, destinationCatalogPath + "/" + exportFolderName + ".dll", true);
Debug.Log("Copied dll " + dllPath + " to " + destinationCatalogPath);
}
}
}
if ((exportTo == ExportTo.Game) && runGameAfterBuild)
{
System.Diagnostics.Process process = new System.Diagnostics.Process();
process.StartInfo.FileName = Path.Combine(gamePath, gameName + ".exe");
process.StartInfo.Arguments = runGameArguments;
process.Start();
Debug.Log("Start game: " + process.StartInfo.FileName + " " + process.StartInfo.Arguments);
}
#if PrivateSDK
if (exportTo == ExportTo.Android)
{
string buildFullPath = Path.Combine(Directory.GetCurrentDirectory(), "BuildStaging", "AddressableAssets", "Android");
System.Diagnostics.Process process = new System.Diagnostics.Process();
process.StartInfo.FileName = GetAdbPath();
string destinationPath = "/sdcard/Android/data/com.Warpfrog." + gameName + "/files/mods/" + exportFolderName;
process.StartInfo.Arguments = "push " + buildFullPath + "/. " + destinationPath;
// for default: obb : /sdcard/Android/obb/" + PlayerSettings.applicationIdentifier + "/main.1.com.Warpfrog.BladeAndSorcery.obb");
process.Start();
process.WaitForExit();
Debug.Log(GetAdbPath() + " " + process.StartInfo.Arguments);
if (runGameAfterBuild)
{
process = new System.Diagnostics.Process();
process.StartInfo.FileName = GetAdbPath();
process.StartInfo.Arguments = "shell am start -n " + PlayerSettings.applicationIdentifier + "/com.unity3d.player.UnityPlayerActivity";
process.Start();
Debug.Log("Start game: " + process.StartInfo.FileName + " " + process.StartInfo.Arguments);
}
}
#endif
Debug.Log("Export done");
}
// The end
System.Media.SystemSounds.Asterisk.Play();
}
public void OnPreprocessBuild(BuildTarget target, string path)
{
AddressableAssetSettings.CleanPlayerContent(AddressableAssetSettingsDefaultObject.Settings.ActivePlayerDataBuilder);
AddressableAssetSettings.BuildPlayerContent();
var Gamedata = AssetDatabase.LoadAssetAtPath <GameObject>(
"Assets/Prefabs/SceneConstruction/NestedManagers/GameData.prefab");
if (Gamedata.GetComponent <GameData>().DevBuild == false)
{
return;
}
EditorUtility.SetDirty(Gamedata);
AssetDatabase.SaveAssets();
var paths = GetCataloguePath();
foreach (var addpath in paths)
{
var flip = new FileInfo(addpath);
var towork = flip.Directory;
// var endpath = Application.dataPath.Remove(Application.dataPath.IndexOf("/Assets"));
// endpath = endpath + towork;
var DD = towork;
var newendpath = Application.streamingAssetsPath + "/AddressableCatalogues/" + flip.Directory.Parent.Name + "/";
var newDD = new DirectoryInfo(newendpath);
Directory.CreateDirectory(newendpath);
CopyFilesRecursively(DD, newDD);
//Logger.Log(newendpath);
var Files = System.IO.Directory.GetFiles(flip.Directory.ToString());
string FoundFile = "";
foreach (var File in Files)
{
//Logger.Log(File);
if (File.EndsWith(".json"))
{
if (FoundFile != "")
{
Logger.LogError("two catalogues present please only ensure one", Category.Addressables);
}
FoundFile = File;
}
}
if (File.Exists(newendpath + Path.GetFileName(FoundFile)))
{
File.Delete(newendpath + Path.GetFileName(FoundFile));
}
if (File.Exists(newendpath + Path.GetFileName(FoundFile).Replace(".json", ".hash")))
{
File.Delete(newendpath + Path.GetFileName(FoundFile).Replace(".json", ".hash"));
}
var Stringtime = DateTime.Now.Ticks.ToString();
System.IO.File.Copy(FoundFile, newendpath + Stringtime + ".json");
System.IO.File.Copy(FoundFile.Replace(".json", ".hash"), (newendpath + Stringtime + ".hash"));
JObject o1 = JObject.Parse(File.ReadAllText((@newendpath + Stringtime + ".json".Replace("/", @"\"))));
var IDs = (JArray)o1["m_InternalIds"];
for (int i = 0; i < IDs.Count; i++)
{
var newID = IDs[i].ToString();
newID = newID.Replace("AddressablePackingProjects/" + flip.Directory.Parent.Name + "/ServerData/",
"unitystation_Data/StreamingAssets/AddressableCatalogues/" + flip.Directory.Parent.Name + "/");
newID = newID.Replace(@"AddressablePackingProjects\" + flip.Directory.Parent.Name + @"\ServerData\",
"unitystation_Data/StreamingAssets/AddressableCatalogues/" + flip.Directory.Parent.Name + "/");
//Assets < Editor, build > unitystation_Data
//Check cache in app data if changes aren't applying
IDs[i] = newID;
}
File.WriteAllText(newendpath + Stringtime + ".json",
Newtonsoft.Json.JsonConvert.SerializeObject(o1, Newtonsoft.Json.Formatting.None));
}
// var ff = new Dictionary<string,string>();
// var nice = ff["STOP"].Length;
}
public static void rebuildAddressableAssets()
{
AddressableAssetSettings.CleanPlayerContent();
AddressableAssetSettings.BuildPlayerContent();
}
public override void OnGUI()
{
if (!isReadly)
{
return;
}
#region 版本号
version = EditorGUILayout.TextField("App Version：", version);
GUILayout.Space(15);
#endregion
#region 版本设置
devDefineSymbols = EditorGUILayout.TextField("DevDefineSymbols", devDefineSymbols);
DevIdentifier = EditorGUILayout.TextField("DevIdentifier", DevIdentifier);
GUILayout.Space(5);
debugDefineSymbols = EditorGUILayout.TextField("TestDefineSymbols", debugDefineSymbols);
DebugIdentifier = EditorGUILayout.TextField("TestIdentifier", DebugIdentifier);
GUILayout.Space(5);
releaseDefineSymbols = EditorGUILayout.TextField("ReleaseDefineSymbols", releaseDefineSymbols);
ReleaseIdentifier = EditorGUILayout.TextField("ReleaseIdentifier", ReleaseIdentifier);
GUILayout.Space(5);
if (GUILayout.Button("保存信息", GUILayout.Height(30)))
{
if (!ES3.Load <string>("DevDefineSymbols").Equals(devDefineSymbols))
{
ES3.Save <string>("DevDefineSymbols", devDefineSymbols);
}
if (!ES3.Load <string>("DebugDefineSymbols").Equals(debugDefineSymbols))
{
ES3.Save <string>("DebugDefineSymbols", debugDefineSymbols);
}
if (!ES3.Load <string>("ReleaseDefineSymbols").Equals(releaseDefineSymbols))
{
ES3.Save <string>("ReleaseDefineSymbols", releaseDefineSymbols);
}
}
GUILayout.Space(15);
var curSymbol = PlayerSettings.GetScriptingDefineSymbolsForGroup(buildTarget);
if (curSelect == -1)
{
if (curSymbol.IndexOf("Dev", 0, curSymbol.Length, StringComparison.Ordinal) == -1 &&
curSymbol.IndexOf("Debug", 0, curSymbol.Length, StringComparison.Ordinal) == -1)
{
//正式版本
curSelect = 0;
#if UNITY_EDITOR_OSX
PlayerSettings.bundleIdentifier = ReleaseIdentifier;
#else
PlayerSettings.applicationIdentifier = ReleaseIdentifier;
#endif
}
else
{
if (curSymbol.IndexOf("Debug", 0, curSymbol.Length, StringComparison.Ordinal) == -1)
{
//开发版本
curSelect = 1;
PlayerSettings.applicationIdentifier = DevIdentifier;
}
else
{
//测试版本
curSelect = 2;
#if UNITY_EDITOR_OSX
PlayerSettings.bundleIdentifier = DebugIdentifier;
#else
PlayerSettings.applicationIdentifier = DebugIdentifier;
#endif
}
}
}
selectChannelEnvIndex = GUILayout.SelectionGrid(curSelect, versionList, 10);
if (selectChannelEnvIndex != curSelect)
{
curSelect = selectChannelEnvIndex;
switch (curSelect)
{
case 0:
//TODO 可以根据平台添加东西
curSymbol = releaseDefineSymbols;
#if UNITY_EDITOR_OSX
PlayerSettings.bundleIdentifier = ReleaseIdentifier;
#else
PlayerSettings.applicationIdentifier = ReleaseIdentifier;
#endif
break;
case 1:
curSymbol = devDefineSymbols;
break;
case 2:
curSymbol = debugDefineSymbols;
#if UNITY_EDITOR_OSX
PlayerSettings.bundleIdentifier = DebugIdentifier;
#else
PlayerSettings.applicationIdentifier = DebugIdentifier;
#endif
break;
}
}
PlayerSettings.SetScriptingDefineSymbolsForGroup(buildTarget, curSymbol);
GUILayout.Space(10);
#endregion
#region 资源包模式设定
#endregion
#region 生成完整资源包
if (GUILayout.Button("生成完整资源包 ", GUILayout.Height(30)))
{
AssetDatabase.Refresh();
AddressableAssetSettings.CleanPlayerContent();
AddressableAssetSettings.CleanPlayerContent(AddressableAssetSettingsDefaultObject.Settings.ActivePlayerDataBuilder);
if (version.Length == 0 || version.Equals("0.0.0"))
{
EditorUtility.DisplayDialog(" Error ！！", " 请修改版本为有效数字", "确定");
}
else
{
AddressableAssetSettings.BuildPlayerContent();
}
}
GUILayout.Space(15);
#endregion
#region 生成补丁包
if (GUILayout.Button("生成补丁包 ", GUILayout.Height(30)))
{
AssetDatabase.Refresh();
//TODO
}
GUILayout.Space(15);
#endregion
#region 生成安装包
if (GUILayout.Button("生成安装包 ", GUILayout.Height(30)))
{
switch (EditorUserBuildSettings.activeBuildTarget)
{
case BuildTarget.StandaloneWindows:
appName = $"RunGameWin32.exe";
BuildPipeline.BuildPlayer(
levels,
ParentPath(),
BuildTarget.StandaloneWindows,
BuildOptions.ShowBuiltPlayer | BuildOptions.Development);
break;
case BuildTarget.StandaloneWindows64:
appName = $"RunGameWin64.exe";
BuildPipeline.BuildPlayer(
levels,
ParentPath(),
BuildTarget.StandaloneWindows64,
BuildOptions.ShowBuiltPlayer | BuildOptions.Development);
break;
case BuildTarget.Android:
appName = $"RunGameAndroid.apk";
BuildPipeline.BuildPlayer(
levels,
ParentPath(),
BuildTarget.Android,
BuildOptions.ShowBuiltPlayer);
break;
case BuildTarget.iOS:
#if UNITY_EDITOR_OSX
appName = $"RunGameAndroid.apk";?
BuildPipeline.BuildPlayer(levels, GetPath() + $"{GetPath()}/Win64/", BuildTarget.iOS,
BuildOptions.CompressWithLz4 | BuildOptions.ShowBuiltPlayer);
#endif
break;
}
}
private static void BuildPlayerHandler(BuildPlayerOptions buildPlayerOptions)
{
AddressableAssetSettings.CleanPlayerContent();
AddressableAssetSettings.BuildPlayerContent();
BuildPlayerWindow.DefaultBuildMethods.BuildPlayer(buildPlayerOptions);
}
/// <summary>
/// Run a clean build before export.
/// </summary>
public static void BuildAdressables()
{
AddressableAssetSettings.CleanPlayerContent(AddressableAssetSettingsDefaultObject.Settings.ActivePlayerDataBuilder);
AddressableAssetSettings.BuildPlayerContent();
}
public static void CleanPlayerContent(IDataBuilder builder)
{
AddressableAssetSettings.CleanPlayerContent(builder);
}
public static void CleanDefaultContextBuilder()
{
AddressableAssetSettings.CleanPlayerContent(null);
}
public static void CleanContent()
{
AddressableAssetSettings.CleanPlayerContent();
}
private IEnumerator PackageLevels(bool allLevels, bool allTargets)
{
uploadPossible = false;
packagingInProgress = true;
packagingSuccessful = false;
try
{
string[] levelsToBuild = allLevels ? GetLevelPaths() : GetLevelsToBuild();
if (levelsToBuild.Length == 0)
{
yield break;
}
CreateLockFile();
ConvertTileMaps();
CreateAddressableSettings(!allTargets);
EditorUserBuildSettings.androidBuildSubtarget = MobileTextureSubtarget.Generic; // FIXME: ASTC resulting in pink shaders as of 2019.4+
EditorUserBuildSettings.selectedStandaloneTarget = BuildTarget.StandaloneWindows64;
AddressableAssetSettings.CleanPlayerContent();
if (Directory.Exists(GetServerDataPath()) && (packageMode == 0 || allLevels))
{
Directory.Delete(GetServerDataPath(), true);
}
// set build targets
List <BuildTarget> targets = new List <BuildTarget>();
if (!debugMode)
{
targets.Add(BuildTarget.Android);
}
targets.Add(BuildTarget.StandaloneWindows64); // set windows last so that we can continue with editor iterations normally right afterwards
// build each level individually
AddressableAssetSettings settings = AddressableAssetSettingsDefaultObject.GetSettings(true);
foreach (string dir in levelsToBuild)
{
string levelName = Path.GetFileName(dir);
string serverDir = GetServerDataPath() + "/Levels/" + Path.GetFileName(dir);
if (packageMode == 1 && !allLevels && Directory.Exists(serverDir))
{
Directory.Delete(serverDir, true);
}
settings.activeProfileId = settings.profileSettings.GetProfileId(levelName);
settings.groups.ForEach(group =>
{
if (group.ReadOnly)
{
return;
}
group.GetSchema <BundledAssetGroupSchema>().IncludeInBuild = group.name == levelName;
});
BundledAssetGroupSchema schema = settings.groups.Where(group => group.name == levelName).First().GetSchema <BundledAssetGroupSchema>();
settings.RemoteCatalogBuildPath = schema.BuildPath;
settings.RemoteCatalogLoadPath = schema.LoadPath;
if (allTargets)
{
// iterate over all supported platforms
foreach (BuildTarget target in targets)
{
EditorUserBuildSettings.SwitchActiveBuildTarget(target);
AddressableAssetSettings.BuildPlayerContent();
}
}
else
{
// build only for currently active target
AddressableAssetSettings.BuildPlayerContent();
}
}
CreateAddressableSettings(!allTargets); // do again to have clean build state, as some settings were messed with while building
RenameCatalogs();
packagingSuccessful = true;
}
catch (Exception e)
{
packagingInProgress = false;
EditorUtility.DisplayDialog("Error", "Packaging could not be completed. Error: " + e.Message, "Close");
yield break;
}
dirWatcher.ClearAffected(); // only do at end, since during build might cause false positives
RemoveLockFile();
packagingInProgress = false;
Debug.Log("Packaging completed successfully.");
}
private static void BuildPlayer(BuildPlayerOptions buildPlayerOptions)
{
AddressableAssetSettings.CleanPlayerContent();
AddressableAssetSettings.BuildPlayerContent();
BuildPipeline.BuildPlayer(buildPlayerOptions);
}
public static bool Build(string target, string versionName, bool isClearStreamingAssetsFolder, bool isCopyToStreamingAssetsFolder, bool isBuildAssets, bool isBuildExecutor)
{
if (AddressableAssetSettingsDefaultObject.Settings == null)
{
EditorWindow.GetWindow <AddressableAssetsEditorWindow>().ShowNotification(new UnityEngine.GUIContent("请先通过\nWindow/Asset Management/Addressables/Groups\n打开面板\n并创建基础资源！"));
return(false);
}
AddressableAssetSettings settings = AssetDatabase.LoadAssetAtPath <AddressableAssetSettings>($"{AddressableAssetSettingsDefaultObject.kDefaultConfigFolder}/{AddressableAssetSettingsDefaultObject.kDefaultConfigAssetName}.asset");
//if (settings.profileSettings.GetVariableNames().Contains(kStreamingLoadPath))
//{
// settings.profileSettings.SetValue(settings.profileSettings.GetProfileId("Default"), kStreamingLoadPath, "{UnityEngine.Application.streamingAssetsPath}/[BuildTarget]");
//}
//else
//{
// settings.profileSettings.CreateValue(kStreamingLoadPath, "{UnityEngine.Application.streamingAssetsPath}/[BuildTarget]");
//}
if (bundleNamingPropertyInfo == null)
{
bundleNamingPropertyInfo = typeof(BundledAssetGroupSchema).GetProperty("BundleNaming", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
}
//更新Group模板的发布路径和加载路径
UpdateGroupTemplateBuildAndLoadPath(settings, $"{settings.GroupTemplateFolder}/Packed Assets.asset");
UpdateGroupBuildAndLoadPath(settings, $"{settings.GroupFolder}/Default Local Group.asset");
//清除旧有资源
CleanGroup(settings);
//自动生成Group
List <AddressableAssetGroupSchema> schemas = AssetDatabase.LoadAssetAtPath <AddressableAssetGroupTemplate>($"{settings.GroupTemplateFolder}/Packed Assets.asset").SchemaObjects;
string[] directories = Directory.GetDirectories($"{UnityEngine.Application.dataPath}/AddressableAssets/");
//string remoteBuildPath = $"./{settings.profileSettings.GetValueByName(settings.profileSettings.GetProfileId("Default"), AddressableAssetSettings.kRemoteBuildPath).Replace("[BuildTarget]", UnityEditor.EditorUserBuildSettings.activeBuildTarget.ToString())}";
//string localBuildPath = $"./{settings.profileSettings.GetValueByName(settings.profileSettings.GetProfileId("Default"), AddressableAssetSettings.kLocalBuildPath).Replace("[UnityEngine.AddressableAssets.Addressables.BuildPath]", UnityEngine.AddressableAssets.Addressables.BuildPath).Replace("[BuildTarget]", UnityEditor.EditorUserBuildSettings.activeBuildTarget.ToString())}";
string buildPath = $"./{UnityEngine.AddressableAssets.Addressables.BuildPath}";
tempAddress = string.Empty;
foreach (string folderPath in directories)
{
if (folderPath.Substring(folderPath.LastIndexOf('/') + 1).StartsWith("~"))
{
continue;
}
BuildGroup(folderPath, settings, schemas);
}
//生成资源地址
GenerateAddress(settings);
//打包资源
if (isBuildAssets)
{
FileHelper.CleanDirectory("Assets/ServerData/");
AddressableAssetSettings.CleanPlayerContent();
AddressableAssetSettings.BuildPlayerContent();
if (!Directory.Exists(UnityEngine.Application.streamingAssetsPath))
{
Directory.CreateDirectory(UnityEngine.Application.streamingAssetsPath);
}
//复制打包资源到服务器资源文件夹
FileHelper.CopyDirectory(buildPath.Substring(0, buildPath.IndexOf("aa")), $"../Release/{UnityEditor.EditorUserBuildSettings.activeBuildTarget}/{versionName}/");
AssetDatabase.Refresh();
}
if (isBuildExecutor)
{
string[] levels =
{
"Assets/Scenes/Init.unity",
};
DirectoryInfo directoryInfo = new System.IO.DirectoryInfo($"{relativeDirPrefix}/{UnityEditor.EditorUserBuildSettings.activeBuildTarget}/发布文件/{PlayerSettings.productName}_{UnityEngine.SystemInfo.deviceName}_{System.DateTime.Now.ToString("yyyyMMddmmHHss")}/");
if (!directoryInfo.Exists)
{
directoryInfo.Create();
}
Log.Info("开始打包可执行文件...");
BuildPipeline.BuildPlayer(levels, $"{directoryInfo.FullName}{PlayerSettings.productName}.exe", EditorUserBuildSettings.activeBuildTarget, BuildOptions.None);
Log.Info("可执行文件打包完成.");
AssetDatabase.Refresh();
System.Diagnostics.Process process = new System.Diagnostics.Process();
process.StartInfo.FileName = "explorer";
process.StartInfo.Arguments = @"/e /root," + directoryInfo.FullName;
process.Start();
}
Log.Info("完成");
return(true);
}
public static void CleanPlayerContent()
{
AddressableAssetSettings.CleanPlayerContent();
UnityEditor.Build.Pipeline.Utilities.BuildCache.PurgeCache(false);
}
