/**
* Execute Run operations using current graph
*/
public void Perform(
BuildTarget target,
bool isRun,
bool forceVisitAll,
Action <NodeData, string, float> updateHandler)
{
LogUtility.Logger.Log(LogType.Log, (isRun) ? "---Build BEGIN---" : "---Setup BEGIN---");
m_isBuilding = true;
if (isRun)
{
AssetBundleBuildReport.ClearReports();
}
var saveData = SaveData.Data;
foreach (var e in m_nodeExceptions)
{
var errorNode = saveData.Nodes.Find(n => n.Id == e.Id);
// errorNode may not be found if user delete it on graph
if (errorNode != null)
{
LogUtility.Logger.LogFormat(LogType.Log, "[Perform] {0} is marked to revisit due to last error", errorNode.Name);
errorNode.NeedsRevisit = true;
}
}
m_nodeExceptions.Clear();
m_lastTarget = target;
PerformGraph oldGraph = m_performGraph[gIndex];
gIndex = (gIndex + 1) % 2;
PerformGraph newGraph = m_performGraph[gIndex];
newGraph.BuildGraphFromSaveData(target, oldGraph);
PerformGraph.Perform performFunc =
(NodeData data,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <ConnectionData> connectionsToOutput,
PerformGraph.Output outputFunc) =>
{
DoNodeOperation(target, data, incoming, connectionsToOutput, outputFunc, isRun, updateHandler);
};
newGraph.VisitAll(performFunc, forceVisitAll);
if (isRun && m_nodeExceptions.Count == 0)
{
Postprocess();
}
m_isBuilding = false;
LogUtility.Logger.Log(LogType.Log, (isRun) ? "---Build END---" : "---Setup END---");
}
public void Run(BuildTarget target,
NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <ConnectionData> connectionsToOutput,
PerformGraph.Output Output,
Action <NodeData, string, float> progressFunc)
{
if (incoming == null)
{
return;
}
var aggregatedGroups = new Dictionary <string, List <AssetReference> >();
aggregatedGroups[key] = new List <AssetReference>();
if (progressFunc != null)
{
progressFunc(node, "Collecting all inputs...", 0f);
}
foreach (var ag in incoming)
{
foreach (var name in ag.assetGroups.Keys)
{
if (!aggregatedGroups.ContainsKey(name))
{
aggregatedGroups[name] = new List <AssetReference>();
}
aggregatedGroups[name].AddRange(ag.assetGroups[name].AsEnumerable());
}
}
var bundleOutputDir = FileUtility.EnsureAssetBundleCacheDirExists(target, node);
var bundleNames = aggregatedGroups.Keys.ToList();
var bundleVariants = new Dictionary <string, List <string> >();
if (progressFunc != null)
{
progressFunc(node, "Building bundle variants map...", 0.2f);
}
// get all variant name for bundles
foreach (var name in aggregatedGroups.Keys)
{
if (!bundleVariants.ContainsKey(name))
{
bundleVariants[name] = new List <string>();
}
var assets = aggregatedGroups[name];
foreach (var a in assets)
{
var variantName = a.variantName;
if (!bundleVariants[name].Contains(variantName))
{
bundleVariants[name].Add(variantName);
}
}
}
int validNames = 0;
foreach (var name in bundleNames)
{
var assets = aggregatedGroups[name];
// we do not build bundle without any asset
if (assets.Count > 0)
{
validNames += bundleVariants[name].Count;
}
}
AssetBundleBuild[] bundleBuild = new AssetBundleBuild[validNames];
int bbIndex = 0;
foreach (var name in bundleNames)
{
foreach (var v in bundleVariants[name])
{
var assets = aggregatedGroups[name];
if (assets.Count <= 0)
{
continue;
}
bundleBuild[bbIndex].assetBundleName = name;
bundleBuild[bbIndex].assetBundleVariant = v;
bundleBuild[bbIndex].assetNames = assets.Where(x => x.variantName == v).Select(x => x.importFrom).ToArray();
++bbIndex;
}
}
if (progressFunc != null)
{
progressFunc(node, "Building Asset Bundles...", 0.7f);
}
AssetBundleManifest m = BuildPipeline.BuildAssetBundles(bundleOutputDir, bundleBuild, (BuildAssetBundleOptions)node.BundleBuilderBundleOptions[target], target);
var output = new Dictionary <string, List <AssetReference> >();
output[key] = new List <AssetReference>();
var generatedFiles = FileUtility.GetAllFilePathsInFolder(bundleOutputDir);
// add manifest file
bundleVariants.Add(BuildTargetUtility.TargetToAssetBundlePlatformName(target).ToLower(), new List <string> {
null
});
foreach (var path in generatedFiles)
{
var fileName = path.Substring(bundleOutputDir.Length + 1);
if (IsFileIntendedItem(fileName, bundleVariants))
{
output[key].Add(AssetReferenceDatabase.GetAssetBundleReference(path));
}
}
if (Output != null)
{
var dst = (connectionsToOutput == null || !connectionsToOutput.Any())?
null : connectionsToOutput.First();
Output(dst, output);
}
AssetBundleBuildReport.AddBuildReport(new AssetBundleBuildReport(node, m, bundleBuild, output[key], aggregatedGroups, bundleVariants));
}
static public void AddBuildReport(AssetBundleBuildReport r)
{
Manager.BuildReports.Add(r);
}
private void Export(BuildTarget target,
NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <ConnectionData> connectionsToOutput,
Action <NodeData, string, float> progressFunc)
{
if (incoming == null)
{
return;
}
var exportPath = FileUtility.GetPathWithProjectPath(node.ExporterExportPath[target]);
if (node.ExporterExportOption[target] == (int)ExporterExportOption.DeleteAndRecreateExportDirectory)
{
if (Directory.Exists(exportPath))
{
Directory.Delete(exportPath, true);
}
}
if (node.ExporterExportOption[target] != (int)ExporterExportOption.ErrorIfNoExportDirectoryFound)
{
if (!Directory.Exists(exportPath))
{
Directory.CreateDirectory(exportPath);
}
}
var report = new ExportReport(node);
foreach (var ag in incoming)
{
foreach (var groupKey in ag.assetGroups.Keys)
{
var inputSources = ag.assetGroups[groupKey];
foreach (var source in inputSources)
{
var destinationSourcePath = source.importFrom;
// in bundleBulider, use platform-package folder for export destination.
if (destinationSourcePath.StartsWith(AssetBundleGraphSettings.BUNDLEBUILDER_CACHE_PLACE))
{
var depth = AssetBundleGraphSettings.BUNDLEBUILDER_CACHE_PLACE.Split(AssetBundleGraphSettings.UNITY_FOLDER_SEPARATOR).Length + 1;
var splitted = destinationSourcePath.Split(AssetBundleGraphSettings.UNITY_FOLDER_SEPARATOR);
var reducedArray = new string[splitted.Length - depth];
Array.Copy(splitted, depth, reducedArray, 0, reducedArray.Length);
var fromDepthToEnd = string.Join(AssetBundleGraphSettings.UNITY_FOLDER_SEPARATOR.ToString(), reducedArray);
destinationSourcePath = fromDepthToEnd;
}
var destination = FileUtility.PathCombine(exportPath, destinationSourcePath);
var parentDir = Directory.GetParent(destination).ToString();
if (!Directory.Exists(parentDir))
{
Directory.CreateDirectory(parentDir);
}
if (File.Exists(destination))
{
File.Delete(destination);
}
if (string.IsNullOrEmpty(source.importFrom))
{
report.AddErrorEntry(source.absolutePath, destination, "Source Asset import path is empty; given asset is not imported by Unity.");
continue;
}
try {
if (progressFunc != null)
{
progressFunc(node, string.Format("Copying {0}", source.fileNameAndExtension), 0.5f);
}
File.Copy(source.importFrom, destination);
report.AddExportedEntry(source.importFrom, destination);
} catch (Exception e) {
report.AddErrorEntry(source.importFrom, destination, e.Message);
}
source.exportTo = destination;
}
}
}
AssetBundleBuildReport.AddExportReport(report);
}