public override void Prepare(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output)
{
// BundleBuilder do nothing without incoming connections
if (incoming == null)
{
return;
}
if (string.IsNullOrEmpty(m_buildLocations[target]))
{
throw new NodeException("You must set build location.", node);
}
if (string.IsNullOrEmpty(m_playerName[target]))
{
throw new NodeException("You must set player name.", node);
}
}
/**
* Build is called when Unity builds assets with AssetBundle Graph.
*/
public override void Build(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output outputFunc,
Action <Model.NodeData, string, float> progressFunc)
{
List <Dictionary <string, List <AssetReference> > > groups = new List <Dictionary <string, List <AssetReference> > >();
foreach (var assetGroups in incoming)
{
groups.Add(assetGroups.assetGroups);
}
var jsonSerializer = new JsonSerializer(new JsonSerializerSettings {
Formatting = Formatting.Indented
}, Encoding.UTF8);
var path = PrepareOutputDirectory(target, node, false, true);
File.WriteAllText(path + _fileName[target] + ".json", jsonSerializer.SerializeString(groups));
}
public override void Prepare(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output)
{
CheckAndCorrectPath(target);
ValidateLoadPath(
m_loadPath[target],
GetLoaderFullLoadPath(target),
() => {
//can be empty
//throw new NodeException(node.Name + ": Load Path is empty.", node);
},
() => {
throw new NodeException(node.Name + ": Directory not found: " + GetLoaderFullLoadPath(target), node);
}
);
Load(target, node, connectionsToOutput, Output);
}
/**
* Prepare is called whenever graph needs update.
*/
public override void Prepare(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output)
{
if (Output == null)
{
return;
}
_inputDir[target] = PrepareOutputDirectory(target, node, true);
if (!File.Exists(_inputDir[target] + _fileName[target] + ".json"))
{
throw new FileNotFoundException();
}
var destination = (connectionsToOutput == null || !connectionsToOutput.Any()) ? null : connectionsToOutput.First();
var loadedData = ParceFile(target);
Output(destination, loadedData.First());
}
public override void Prepare(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output)
{
if (string.IsNullOrEmpty(m_srcPath [target]))
{
throw new NodeException(node.Name + ":Mirror Directory can not set project directory as source.", node.Id);
}
if (string.IsNullOrEmpty(m_dstPath [target]))
{
throw new NodeException(node.Name + ":Mirror Directory can not set project directory as destination.", node.Id);
}
if (!Directory.Exists(GetNormalizedPath(m_srcPath [target])))
{
throw new NodeException(node.Name + ":Source Directory does not exist. Path:" + m_srcPath[target], node.Id);
}
// MirrorDirectory does not add, filter or change structure of group, so just pass given group of assets
if (Output != null)
{
var dst = (connectionsToOutput == null || !connectionsToOutput.Any())?
null : connectionsToOutput.First();
if (incoming != null)
{
foreach (var ag in incoming)
{
Output(dst, ag.assetGroups);
}
}
else
{
Output(dst, new Dictionary <string, List <AssetReference> >());
}
}
}
public override void Build(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output,
Action <Model.NodeData, string, float> progressFunc)
{
if (incoming != null)
{
foreach (var ag in incoming)
{
foreach (var groupName in ag.assetGroups.Keys)
{
var labels = m_label.Replace("*", groupName).Split(',').Select(s => s.Trim()).Where(s => !string.IsNullOrEmpty(s)).Distinct();
if (labels.Any())
{
var assets = ag.assetGroups [groupName];
foreach (var a in assets)
{
var o = AssetDatabase.LoadMainAssetAtPath(a.importFrom);
if (m_overwriteLabels)
{
AssetDatabase.SetLabels(o, labels.ToArray());
}
else
{
var currentLabels = AssetDatabase.GetLabels(o);
var combined = labels.ToList();
combined.AddRange(currentLabels);
AssetDatabase.SetLabels(o, combined.Distinct().ToArray());
}
}
}
}
}
}
}
public override void Prepare(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output)
{
ValidateExportPath(
m_exportPath[target],
GetExportPath(m_exportPath[target]),
() =>
{
throw new NodeException("Export Path is empty.", "Set valid export path from inspector.", node);
},
() =>
{
if (m_exportOption[target] == (int)ExportOption.ErrorIfNoExportDirectoryFound)
{
throw new NodeException("Directory set to Export Path does not exist. Path:" + m_exportPath[target],
"Create exporting directory or set valid export path from inspector.", node);
}
}
);
}
/**
* Perform Run or Setup from parent of given terminal node recursively.
*/
private void DoNodeOperation(
BuildTarget target,
Model.NodeData currentNodeData,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output outputFunc,
bool isActualRun,
Action <Model.NodeData, string, float> updateHandler)
{
try {
if (updateHandler != null)
{
updateHandler(currentNodeData, "Starting...", 0f);
}
if (isActualRun)
{
currentNodeData.Operation.Object.Build(target, currentNodeData, incoming, connectionsToOutput, outputFunc, updateHandler);
}
else
{
currentNodeData.Operation.Object.Prepare(target, currentNodeData, incoming, connectionsToOutput, outputFunc);
}
if (updateHandler != null)
{
updateHandler(currentNodeData, "Completed.", 1f);
}
} catch (NodeException e) {
m_nodeExceptions.Add(e);
}
// Minimize impact of errors happened during node operation
catch (Exception e) {
m_nodeExceptions.Add(new NodeException(string.Format("{0}:{1} (See Console for detail)", e.GetType().ToString(), e.Message), currentNodeData.Id));
LogUtility.Logger.LogException(e);
}
}
public override void Prepare(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output)
{
ValidateModifier(node, target, incoming,
(Type expectedType, Type foundType, AssetReference foundAsset) => {
throw new NodeException(string.Format("{3} :Modifier expect {0}, but different type of incoming asset is found({1} {2})",
expectedType.FullName, foundType.FullName, foundAsset.fileNameAndExtension, node.Name), node.Id);
},
() => {
throw new NodeException(node.Name + " :Modifier is not configured. Please configure from Inspector.", node.Id);
},
() => {
throw new NodeException(node.Name + " :Failed to create Modifier from settings. Please fix settings from Inspector.", node.Id);
},
(Type expectedType, Type incomingType) => {
throw new NodeException(string.Format("{0} :Incoming asset type is does not match with this Modifier (Expected type:{1}, Incoming type:{2}).",
node.Name, (expectedType != null)?expectedType.FullName:"null", (incomingType != null)?incomingType.FullName:"null"), node.Id);
}
);
if (incoming != null && Output != null)
{
// Modifier does not add, filter or change structure of group, so just pass given group of assets
var dst = (connectionsToOutput == null || !connectionsToOutput.Any())?
null : connectionsToOutput.First();
foreach (var ag in incoming)
{
Output(dst, ag.assetGroups);
}
}
}
void Load(BuildTarget target,
Model.NodeData node,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output)
{
if (connectionsToOutput == null || Output == null)
{
return;
}
if (m_lastImportedAssets == null)
{
m_lastImportedAssets = new List <AssetReference> ();
}
var output = new Dictionary <string, List <AssetReference> > {
{ "0", m_lastImportedAssets }
};
var dst = (connectionsToOutput == null || !connectionsToOutput.Any())?
null : connectionsToOutput.First();
Output(dst, output);
}
/**
* Build is called when Unity builds assets with AssetBundle Graph.
*/
public override void Build(BuildTarget target,
Model.NodeData nodeData,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output outputFunc,
Action <Model.NodeData, string, float> progressFunc)
{
if (incoming != null)
{
AssetGroupStructures expected = null;
if (!string.IsNullOrEmpty(m_result[target]))
{
expected = JsonUtility.FromJson <AssetGroupStructures>(m_result[target]);
}
if (expected == null)
{
throw new NodeException("Retrieving reference data failed.", "Please recreate regression reference data from Inspector.", nodeData);
}
m_current = CreateASG(incoming);
ValidateASG(nodeData, expected, m_current);
}
}
public override void Prepare(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output)
{
if (connectionsToOutput == null || Output == null)
{
return;
}
var outputDict = new Dictionary <string, List <AssetReference> >();
if (incoming != null)
{
int i = 0;
foreach (var ag in incoming)
{
foreach (var assets in ag.assetGroups.Values)
{
foreach (var a in assets)
{
var key = i.ToString();
outputDict[key] = new List <AssetReference>();
outputDict [key].Add(a);
++i;
}
}
}
}
var dst = (connectionsToOutput == null || !connectionsToOutput.Any())?
null : connectionsToOutput.First();
Output(dst, outputDict);
}
public override void Build(BuildTarget buildTarget, NodeData nodeData, IEnumerable <PerformGraph.AssetGroups> incoming, IEnumerable <ConnectionData> connectionsToOutput, PerformGraph.Output outputFunc,
Action <NodeData, string, float> progressFunc)
{
#region 保存AssetTypeConfig
var asetTypePath = string.Format("{0}/{1}/{2}", BuildingCtx.BuildParams.OutputPath, BApplication.GetPlatformPath(buildTarget), BResources.ART_ASSET_TYPES_PATH);
//数据结构保存
AssetTypeConfig at = new AssetTypeConfig()
{
AssetTypeList = BuildingCtx.AssetTypeList,
};
var csv = CsvSerializer.SerializeToString(at);
FileHelper.WriteAllText(asetTypePath, csv);
Debug.LogFormat("AssetType写入到:{0} \n{1}", asetTypePath, csv);
#endregion
//BD生命周期触发
BDFrameworkPipelineHelper.OnBeginBuildAssetBundle(BuildingCtx);
}
public override void Prepare(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output)
{
Action <Type, Type, AssetReference> multipleAssetTypeFound = (Type expectedType, Type foundType, AssetReference foundAsset) => {
throw new NodeException(string.Format("{3} :ImportSetting expect {0}, but different type of incoming asset is found({1} {2})",
expectedType.FullName, foundType.FullName, foundAsset.fileNameAndExtension, node.Name), node.Id);
};
Action <Type> unsupportedType = (Type unsupported) => {
throw new NodeException(string.Format("{0} :Incoming asset type is not supported by ImportSetting (Incoming type:{1}). Perhaps you want to use Modifier instead?",
node.Name, (unsupported != null)?unsupported.FullName:"null"), node.Id);
};
Action <Type, Type> incomingTypeMismatch = (Type expectedType, Type incomingType) => {
throw new NodeException(string.Format("{0} :Incoming asset type is does not match with this ImportSetting (Expected type:{1}, Incoming type:{2}).",
node.Name, (expectedType != null)?expectedType.FullName:"null", (incomingType != null)?incomingType.FullName:"null"), node.Id);
};
Action customConfigIsNull = () => {
throw new NodeException(string.Format("{0} :You must select custom setting asset.", node.Name), node.Id);
};
Action <ConfigStatus> errorInConfig = (ConfigStatus _) => {
var firstAsset = TypeUtility.GetFirstIncomingAsset(incoming);
if (firstAsset != null)
{
// give a try first in sampling file
var configFilePath = FileUtility.GetImportSettingTemplateFilePath(firstAsset);
SaveSampleFile(node, configFilePath);
ValidateInputSetting(node, target, incoming, multipleAssetTypeFound, unsupportedType, incomingTypeMismatch, (ConfigStatus eType) => {
if (eType == ConfigStatus.NoSampleFound)
{
throw new NodeException(node.Name + " :ImportSetting has no sampling file. Please configure it from Inspector.", node.Id);
}
if (eType == ConfigStatus.TooManySamplesFound)
{
throw new NodeException(node.Name + " :ImportSetting has too many sampling file. Please fix it from Inspector.", node.Id);
}
}, customConfigIsNull);
}
};
ValidateInputSetting(node, target, incoming, multipleAssetTypeFound, unsupportedType, incomingTypeMismatch, errorInConfig, customConfigIsNull);
// ImportSettings does not add, filter or change structure of group, so just pass given group of assets
if (Output != null)
{
var dst = (connectionsToOutput == null || !connectionsToOutput.Any())?
null : connectionsToOutput.First();
if (incoming != null)
{
foreach (var ag in incoming)
{
Output(dst, ag.assetGroups);
}
}
else
{
Output(dst, new Dictionary <string, List <AssetReference> >());
}
}
}
/// <summary>
/// 预览结果 编辑器连线数据，但是build模式也会执行
/// 这里只建议设置BuildingCtx的ab颗粒度
/// </summary>
/// <param name="target"></param>
/// <param name="nodeData"></param>
/// <param name="incoming"></param>
/// <param name="connectionsToOutput"></param>
/// <param name="outputFunc"></param>
public override void Prepare(BuildTarget target, NodeData nodeData, IEnumerable <PerformGraph.AssetGroups> incoming, IEnumerable <ConnectionData> connectionsToOutput, PerformGraph.Output outputFunc)
{
//检测混淆
StopwatchTools.Begin();
if (BuildingCtx == null)
{
BuildingCtx = new AssetBundleBuildingContext();
}
BuildingCtx.BuildParams.BuildTarget = target;
//设置所有节点参数请求,依次传参
Debug.Log("【初始化框架资源环境】配置:\n" + JsonMapper.ToJson(BuildingCtx.BuildParams));
var outMap = new Dictionary <string, List <AssetReference> >();
//预览模式
if ((AssetGraphWindowsModeEnum)this.AssetGraphWindowsMode == AssetGraphWindowsModeEnum.预览节点模式 || BuildingCtx.BuildParams.IsBuilding)
{
//创建构建上下文信息
GenBuildingCtx();
//输出
outMap = new Dictionary <string, List <AssetReference> >()
{
{ nameof(FloderType.Runtime), BuildingCtx.RuntimeAssetsList.ToList() }, //传递新容器
{ nameof(FloderType.Depend), BuildingCtx.DependAssetList.ToList() }
};
}
else if ((AssetGraphWindowsModeEnum)this.AssetGraphWindowsMode == AssetGraphWindowsModeEnum.配置节点模式)
{
//输出
outMap = new Dictionary <string, List <AssetReference> >()
{
{ nameof(FloderType.Runtime), new List <AssetReference>() }, //传递新容器
{ nameof(FloderType.Depend), new List <AssetReference>() }
};
}
StopwatchTools.End("【初始化框架资源环境】");
var output = connectionsToOutput?.FirstOrDefault();
if (output != null)
{
outputFunc(output, outMap);
//
}
}
public override void Build(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output,
Action <Model.NodeData, string, float> progressFunc)
{
if (incoming == null)
{
return;
}
var modifier = m_instance.Get <IModifier>(target);
UnityEngine.Assertions.Assert.IsNotNull(modifier);
bool isAnyAssetModified = false;
foreach (var ag in incoming)
{
foreach (var assets in ag.assetGroups.Values)
{
foreach (var asset in assets)
{
if (modifier.IsModified(asset.allData))
{
modifier.Modify(asset.allData);
asset.SetDirty();
isAnyAssetModified = true;
// apply asset setting changes to AssetDatabase.
if (asset.isSceneAsset)
{
if (!EditorSceneManager.SaveScene(asset.scene))
{
throw new NodeException(node.Name + " :Failed to save modified scene:" + asset.importFrom, node.Id);
}
}
else
{
AssetDatabase.SaveAssets();
}
}
asset.ReleaseData();
}
}
}
if (isAnyAssetModified)
{
AssetDatabase.Refresh();
}
if (incoming != null && Output != null)
{
// Modifier does not add, filter or change structure of group, so just pass given group of assets
var dst = (connectionsToOutput == null || !connectionsToOutput.Any())?
null : connectionsToOutput.First();
foreach (var ag in incoming)
{
Output(dst, ag.assetGroups);
}
}
}
public override void Prepare(BuildTarget target, NodeData nodeData, IEnumerable <PerformGraph.AssetGroups> incoming, IEnumerable <ConnectionData> connectionsToOutput, PerformGraph.Output outputFunc)
{
if (outputFunc != null)
{
var destination = connectionsToOutput == null || !connectionsToOutput.Any() ? null : connectionsToOutput.First();
if (incoming != null)
{
var dependencyCollector = new Dictionary <string, List <AssetReference> >();
// build dependency map
foreach (var ag in incoming)
{
foreach (var key in ag.assetGroups.Keys)
{
var assets = ag.assetGroups[key];
foreach (var a in assets)
{
CollectDependencies(key, new[]
{
a.importFrom
}, ref dependencyCollector);
}
}
}
var result = new Dictionary <string, List <AssetReference> >();
foreach (var ag in incoming)
{
foreach (var assetGroup in ag.assetGroups)
{
result.Add(assetGroup.Key, assetGroup.Value);
}
}
foreach (var pair in dependencyCollector)
{
if (!result.ContainsKey(pair.Key))
{
result.Add(pair.Key, new List <AssetReference>());
}
result[pair.Key].AddRange(pair.Value);
}
outputFunc(destination, result);
}
else
{
outputFunc(destination, new Dictionary <string, List <AssetReference> >());
}
}
}
public override void Prepare(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output)
{
int groupCount = 0;
if (incoming != null)
{
var groupNames = new List <string>();
foreach (var ag in incoming)
{
foreach (var groupKey in ag.assetGroups.Keys)
{
if (!groupNames.Contains(groupKey))
{
groupNames.Add(groupKey);
}
}
}
groupCount = groupNames.Count;
}
ValidateBundleNameTemplate(
m_bundleNameTemplate[target],
m_useGroupAsVariants,
groupCount,
() => {
throw new NodeException("Bundle Name Template is empty.",
"Set valid bundle name template from inspector.", node);
},
() => {
throw new NodeException("Bundle Name Template can not contain '" + Model.Settings.KEYWORD_WILDCARD.ToString()
+ "' when group name is used for variants.",
"Set valid bundle name without '" + Model.Settings.KEYWORD_WILDCARD.ToString() + "' from inspector.", node);
},
() => {
throw new NodeException("Bundle Name Template must contain '" + Model.Settings.KEYWORD_WILDCARD.ToString()
+ "' when group name is not used for variants and expecting multiple incoming groups.",
"Set valid bundle name without '" + Model.Settings.KEYWORD_WILDCARD.ToString() + "' from inspector.", node);
}
);
var variantNames = m_variants.Select(v => v.Name).ToList();
foreach (var variant in m_variants)
{
ValidateVariantName(variant.Name, variantNames,
() => {
throw new NodeException("Variant name is empty.", "Set valid variant name from inspector.", node);
},
() => {
throw new NodeException("Variant name cannot contain whitespace \"" + variant.Name + "\".", "Remove whitespace from variant name.", node);
},
() => {
throw new NodeException("Variant name already exists \"" + variant.Name + "\".", "Avoid variant name collision.", node);
});
}
if (incoming != null)
{
/**
* Check if incoming asset has valid import path
*/
var invalids = new List <AssetReference>();
foreach (var ag in incoming)
{
foreach (var groupKey in ag.assetGroups.Keys)
{
ag.assetGroups[groupKey].ForEach(a => { if (string.IsNullOrEmpty(a.importFrom))
{
invalids.Add(a);
}
});
}
}
if (invalids.Any())
{
throw new NodeException(
"Invalid files are found. Following files need to be imported to put into asset bundle: " +
string.Join(", ", invalids.Select(a => a.absolutePath).ToArray()), "Import these files before building asset bundles.", node);
}
}
Dictionary <string, List <AssetReference> > output = null;
if (Output != null)
{
output = new Dictionary <string, List <AssetReference> >();
}
if (incoming != null)
{
Dictionary <string, List <string> > variantsInfo = new Dictionary <string, List <string> > ();
var buildMap = AssetBundleBuildMap.GetBuildMap();
buildMap.ClearFromId(node.Id);
foreach (var ag in incoming)
{
string variantName = null;
if (!m_useGroupAsVariants)
{
var currentVariant = m_variants.Find(v => v.ConnectionPointId == ag.connection.ToNodeConnectionPointId);
variantName = (currentVariant == null) ? null : currentVariant.Name;
}
// set configured assets in bundle name
foreach (var groupKey in ag.assetGroups.Keys)
{
if (m_useGroupAsVariants)
{
variantName = groupKey;
}
var bundleName = GetBundleName(target, node, groupKey);
var assets = ag.assetGroups[groupKey];
ConfigureAssetBundleSettings(variantName, assets);
if (!string.IsNullOrEmpty(variantName))
{
if (!variantsInfo.ContainsKey(bundleName))
{
variantsInfo [bundleName] = new List <string> ();
}
variantsInfo [bundleName].Add(variantName.ToLower());
}
if (output != null)
{
if (!output.ContainsKey(bundleName))
{
output[bundleName] = new List <AssetReference>();
}
output[bundleName].AddRange(assets);
}
var bundleConfig = buildMap.GetAssetBundleWithNameAndVariant(node.Id, bundleName, variantName);
bundleConfig.AddAssets(node.Id, assets.Select(a => a.importFrom));
}
}
if (output != null)
{
ValidateVariantsProperlyConfiguired(node, output, variantsInfo);
}
}
if (Output != null)
{
var dst = (connectionsToOutput == null || !connectionsToOutput.Any())?
null : connectionsToOutput.First();
Output(dst, output);
}
}
public override void Build(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output,
Action <Model.NodeData, string, float> progressFunc)
{
if (incoming == null)
{
return;
}
var dstPath = GetDestinationPath(m_destinationPath[target]);
if (m_destinationOption[target] == (int)DestinationDirectoryOption.DeleteAndRecreateExportDirectory)
{
if (Directory.Exists(dstPath))
{
FileUtility.DeleteDirectory(dstPath, true);
}
}
if (m_destinationOption[target] != (int)DestinationDirectoryOption.ErrorIfNoExportDirectoryFound)
{
if (!Directory.Exists(dstPath))
{
Directory.CreateDirectory(dstPath);
}
}
var opTypeName = m_operationType == FileOperationType.Copy ? "Copy" : "Move";
var isDestinationWithinProject = dstPath.StartsWith(Application.dataPath);
var projectPathLength = Directory.GetParent(Application.dataPath).ToString().Length + 1;
foreach (var ag in incoming)
{
foreach (var groupKey in ag.assetGroups.Keys)
{
var inputSources = ag.assetGroups[groupKey];
foreach (var source in inputSources)
{
var destination = FileUtility.PathCombine(dstPath, GetReducedPath(source));
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))
{
continue;
}
try
{
progressFunc?.Invoke(node, $"{opTypeName} {source.fileNameAndExtension}", 0.5f);
if (m_operationType == FileOperationType.Copy)
{
if (source.isProjectAsset && isDestinationWithinProject)
{
var relativePath = destination.Substring(projectPathLength);
AssetDatabase.CopyAsset(source.importFrom, relativePath);
}
else
{
File.Copy(source.importFrom, destination);
}
}
else
{
if (source.isProjectAsset && isDestinationWithinProject)
{
var relativePath = destination.Substring(projectPathLength);
AssetDatabase.MoveAsset(source.importFrom, relativePath);
}
else
{
File.Move(source.importFrom, destination);
}
}
}
catch (Exception)
{
// ignored
}
}
}
}
}
public override void Prepare(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output)
{
ValidatePrefabBuilder(node, target, incoming,
() => {
throw new NodeException(node.Name + " :PrefabBuilder is not configured. Please configure from Inspector.", node.Id);
},
() => {
throw new NodeException(node.Name + " :Failed to create PrefabBuilder from settings. Please fix settings from Inspector.", node.Id);
},
(string groupKey) => {
throw new NodeException(string.Format("{0} :Can not create prefab with incoming assets for group {1}.", node.Name, groupKey), node.Id);
},
(AssetReference badAsset) => {
throw new NodeException(string.Format("{0} :Can not import incoming asset {1}.", node.Name, badAsset.fileNameAndExtension), node.Id);
}
);
if (incoming == null)
{
return;
}
var builder = m_instance.Get <IPrefabBuilder>(target);
UnityEngine.Assertions.Assert.IsNotNull(builder);
var prefabOutputDir = FileUtility.EnsurePrefabBuilderCacheDirExists(target, node);
Dictionary <string, List <AssetReference> > output = null;
if (Output != null)
{
output = new Dictionary <string, List <AssetReference> >();
}
var aggregatedGroups = new Dictionary <string, List <AssetReference> >();
foreach (var ag in incoming)
{
foreach (var key in ag.assetGroups.Keys)
{
if (!aggregatedGroups.ContainsKey(key))
{
aggregatedGroups[key] = new List <AssetReference>();
}
aggregatedGroups[key].AddRange(ag.assetGroups[key].AsEnumerable());
}
}
foreach (var key in aggregatedGroups.Keys)
{
var assets = aggregatedGroups[key];
var thresold = PrefabBuilderUtility.GetPrefabBuilderAssetThreshold(m_instance.ClassName);
if (thresold < assets.Count)
{
var guiName = PrefabBuilderUtility.GetPrefabBuilderGUIName(m_instance.ClassName);
throw new NodeException(string.Format("{0} :Too many assets passed to {1} for group:{2}. {3}'s threshold is set to {4}",
node.Name, guiName, key, guiName, thresold), node.Id);
}
List <UnityEngine.Object> allAssets = LoadAllAssets(assets);
var prefabFileName = builder.CanCreatePrefab(key, allAssets);
if (output != null && prefabFileName != null)
{
output[key] = new List <AssetReference> ()
{
AssetReferenceDatabase.GetPrefabReference(FileUtility.PathCombine(prefabOutputDir, prefabFileName + ".prefab"))
};
}
UnloadAllAssets(assets);
}
if (Output != null)
{
var dst = (connectionsToOutput == null || !connectionsToOutput.Any())?
null : connectionsToOutput.First();
Output(dst, output);
}
}
public override void Build(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output,
Action <Model.NodeData, string, float> progressFunc)
{
if (incoming == null)
{
return;
}
if (!Directory.Exists(m_buildLocations[target]))
{
Directory.CreateDirectory(m_buildLocations[target]);
}
var sceneGUIDs = m_scenes[target].Split(',');
string manifestPath = string.Empty;
foreach (var ag in incoming)
{
foreach (var assets in ag.assetGroups.Values)
{
var manifestBundle = assets.Where(a => a.assetType == typeof(AssetBundleManifestReference));
if (manifestBundle.Any())
{
manifestPath = manifestBundle.First().importFrom;
}
}
}
BuildPlayerOptions opt = new BuildPlayerOptions
{
options = (BuildOptions)m_buildOptions[target],
locationPathName = m_buildLocations[target] + "/" + m_playerName[target],
assetBundleManifestPath = manifestPath,
scenes = sceneGUIDs.Select(AssetDatabase.GUIDToAssetPath).Where(path => !string.IsNullOrEmpty(path) && !path.Contains("__DELETED_GUID_Trash")).ToArray(),
target = target,
targetGroup = BuildTargetUtility.TargetToGroup(target)
};
var report = BuildPipeline.BuildPlayer(opt);
var summary = report.summary;
switch (summary.result)
{
case BuildResult.Failed:
throw new NodeException(
$"Player build failed. ({summary.totalErrors} errors)",
summary.ToString(), node);
case BuildResult.Cancelled:
LogUtility.Logger.Log(LogUtility.kTag, "Player build cancelled.");
break;
case BuildResult.Unknown:
throw new NodeException(
"Player build ended with Unknown state.",
summary.ToString(), node);
}
}
public override void Prepare(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output)
{
ValidateAssetGenerator(node, target, incoming,
() => {
throw new NodeException("AssetGenerator is not specified.", "Select generator from inspector.", node);
},
() => {
throw new NodeException("Failed to create AssetGenerator from settings.", "Fix AssetGenerator settings from inspector", node);
},
(AssetReference badAsset) => {
throw new NodeException($"Generator not create asset from source : Source: {badAsset.importFrom}",
"Remove source asset from node input.", node);
},
(AssetReference badAsset) => {
throw new NodeException($"Can not import incoming asset {badAsset.fileNameAndExtension}.",
"Remove source asset from node input.", node);
}
);
if (incoming == null)
{
return;
}
if (connectionsToOutput == null || Output == null)
{
return;
}
var allOutput = new Dictionary <string, Dictionary <string, List <AssetReference> > >();
foreach (var outPoints in node.OutputPoints)
{
allOutput[outPoints.Id] = new Dictionary <string, List <AssetReference> >();
}
var defaultOutputCond = connectionsToOutput.Where(c => c.FromNodeConnectionPointId == m_defaultOutputPointId);
Model.ConnectionData defaultOutput = null;
if (defaultOutputCond.Any())
{
defaultOutput = defaultOutputCond.First();
}
foreach (var ag in incoming)
{
if (defaultOutput != null)
{
Output(defaultOutput, ag.assetGroups);
}
foreach (var groupKey in ag.assetGroups.Keys)
{
foreach (var a in ag.assetGroups[groupKey])
{
foreach (var entry in m_entries)
{
var assetOutputDir = PrepareOutputDirectory(target, node, a);
var generator = entry.m_instance.Get <IAssetGenerator>(target);
UnityEngine.Assertions.Assert.IsNotNull(generator);
var newItem = FileUtility.PathCombine(assetOutputDir, GetGeneratorIdForSubPath(target, entry), a.fileName + generator.GetAssetExtension(a));
var output = allOutput[entry.m_id];
if (!output.ContainsKey(groupKey))
{
output[groupKey] = new List <AssetReference>();
}
output[groupKey].Add(AssetReferenceDatabase.GetReferenceWithType(newItem, generator.GetAssetType(a)));
}
}
}
}
foreach (var dst in connectionsToOutput)
{
if (allOutput.ContainsKey(dst.FromNodeConnectionPointId))
{
Output(dst, allOutput[dst.FromNodeConnectionPointId]);
}
}
}
/**
* Prepare is called whenever graph needs update.
*/
public override void Prepare(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output)
{
if (string.IsNullOrEmpty(m_bundleNameTemplate))
{
throw new NodeException("Bundle Name Template is empty.", "Set valid bundle name template.", node);
}
if (m_groupExtractedAssets[target] != 0)
{
if (m_groupSizeByte[target] < 0)
{
throw new NodeException("Invalid size. Size property must be a positive number.", "Set valid size.", node);
}
}
// Pass incoming assets straight to Output
if (Output != null)
{
var destination = (connectionsToOutput == null || !connectionsToOutput.Any()) ? null : connectionsToOutput.First();
if (incoming == null)
{
// Overwrite output with empty Dictionary when no there is incoming asset
Output(destination, new Dictionary <string, System.Collections.Generic.List <AssetReference> >());
return;
}
var buildMap = AssetBundleBuildMap.GetBuildMap();
buildMap.ClearFromId(node.Id);
var dependencyCollector = new Dictionary <string, System.Collections.Generic.List <string> >(); // [asset path:group name]
var sharedDependency = new Dictionary <string, System.Collections.Generic.List <AssetReference> >();
var groupNameMap = new Dictionary <string, string>();
// build dependency map
foreach (var ag in incoming)
{
foreach (var key in ag.assetGroups.Keys)
{
var assets = ag.assetGroups[key];
foreach (var a in assets)
{
CollectDependencies(key, new string[] { a.importFrom }, ref dependencyCollector);
}
}
}
foreach (var entry in dependencyCollector)
{
if (entry.Value != null && entry.Value.Count > 1)
{
var joinedName = string.Join("-", entry.Value.ToArray());
if (!groupNameMap.ContainsKey(joinedName))
{
var count = groupNameMap.Count;
var newName = m_bundleNameTemplate.Replace("*", count.ToString());
if (newName == m_bundleNameTemplate)
{
newName = m_bundleNameTemplate + count.ToString();
}
groupNameMap.Add(joinedName, newName);
}
var groupName = groupNameMap[joinedName];
if (!sharedDependency.ContainsKey(groupName))
{
sharedDependency[groupName] = new System.Collections.Generic.List <AssetReference>();
}
sharedDependency[groupName].Add(AssetReference.CreateReference(entry.Key));
}
}
if (sharedDependency.Keys.Count == 0)
{
foreach (var ag in incoming)
{
Output(destination, ag.assetGroups);
}
}
// subgroup shared dependency bundles by size
if (m_groupExtractedAssets[target] != 0)
{
System.Collections.Generic.List <string> devidingBundleNames = new System.Collections.Generic.List <string>(sharedDependency.Keys);
long szGroup = m_groupSizeByte[target] * 1000;
foreach (var bundleName in devidingBundleNames)
{
var assets = sharedDependency[bundleName];
int groupCount = 0;
long szGroupCount = 0;
foreach (var a in assets)
{
var subGroupName = string.Format("{0}_{1}", bundleName, groupCount);
if (!sharedDependency.ContainsKey(subGroupName))
{
sharedDependency[subGroupName] = new System.Collections.Generic.List <AssetReference>();
}
sharedDependency[subGroupName].Add(a);
szGroupCount += GetSizeOfAsset(a, (GroupingType)m_groupingType[target]);
if (szGroupCount >= szGroup)
{
szGroupCount = 0;
++groupCount;
}
}
sharedDependency.Remove(bundleName);
}
}
foreach (var bundleName in sharedDependency.Keys)
{
var bundleConfig = buildMap.GetAssetBundleWithNameAndVariant(node.Id, bundleName, string.Empty);
bundleConfig.AddAssets(node.Id, sharedDependency[bundleName].Select(a => a.importFrom));
}
//remove doubles
foreach (var shDep in sharedDependency)
{
foreach (var assetReference in shDep.Value)
{
foreach (var ag in incoming)
{
foreach (var agAssetGroup in ag.assetGroups)
{
List <AssetReference> toDel = new List <AssetReference>();
foreach (var incomingAssetReference in agAssetGroup.Value)
{
if (incomingAssetReference.path == assetReference.path &&
incomingAssetReference.fileNameAndExtension == assetReference.fileNameAndExtension)
{
toDel.Add(incomingAssetReference);
Debug.LogWarning("Found duplicate " + incomingAssetReference.fileNameAndExtension);
}
}
foreach (var reference in toDel)
{
agAssetGroup.Value.Remove(reference);
Debug.LogWarning("Removed duplicate " + reference.fileNameAndExtension);
}
}
}
}
}
foreach (var ag in incoming)
{
Output(destination, new Dictionary <string, System.Collections.Generic.List <AssetReference> >(ag.assetGroups));
}
Output(destination, sharedDependency);
}
}
/// <summary>
/// 刷新节点渲染
/// </summary>
#endregion
/// <summary>
/// 预览结果 编辑器连线数据，但是build模式也会执行
/// 这里只建议设置BuildingCtx的ab颗粒度
/// </summary>
/// <param name="target"></param>
/// <param name="nodeData"></param>
/// <param name="incoming"></param>
/// <param name="connectionsToOutput"></param>
/// <param name="outputFunc"></param>
public override void Prepare(BuildTarget target, NodeData nodeData, IEnumerable <PerformGraph.AssetGroups> incoming, IEnumerable <ConnectionData> connectionsToOutput, PerformGraph.Output outputFunc)
{
Debug.Log("prepare:" + this.GetType().Name + "-" + DateTime.Now.ToLongTimeString());
if (incoming == null)
{
return;
}
this.BuildingCtx = BDFrameworkAssetsEnv.BuildingCtx;
//prepare传入的资源
this.InitOutputNode(incoming);
var assetsList = GraphNodeHelper.GetAllComingAssets(incoming);
//初始化输出列表
var allOutMap = new Dictionary <string, List <AssetReference> >();
foreach (var group in this.groupFilterPathDataList)
{
if (!string.IsNullOrEmpty(group.GroupPath))
{
allOutMap[group.GroupPath] = new List <AssetReference>();
}
}
//遍历输出
foreach (var ar in assetsList)
{
foreach (var gp in groupFilterPathDataList)
{
if (ar.importFrom.StartsWith(gp.GroupPath, StringComparison.OrdinalIgnoreCase))
{
//添加
allOutMap[gp.GroupPath].Add(ar);
break;
}
}
}
//每个节点输出
if (connectionsToOutput != null)
{
foreach (var outputNode in connectionsToOutput)
{
var groupFilter = this.groupFilterPathDataList.FirstOrDefault((gf) => gf.OutputNodeId == outputNode.FromNodeConnectionPointId);
if (groupFilter != null)
{
var kv = new Dictionary <string, List <AssetReference> >()
{
{ groupFilter.GroupPath, allOutMap[groupFilter.GroupPath] }
};
outputFunc(outputNode, kv);
}
}
}
}
public override void Build(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output,
Action <Model.NodeData, string, float> progressFunc)
{
if (incoming == null)
{
return;
}
bool isAnyAssetGenerated = false;
foreach (var entry in m_entries)
{
var generator = entry.m_instance.Get <IAssetGenerator>(target);
UnityEngine.Assertions.Assert.IsNotNull(generator);
foreach (var ag in incoming)
{
foreach (var assets in ag.assetGroups.Values)
{
foreach (var a in assets)
{
var assetOutputDir = PrepareOutputDirectory(target, node, a);
var assetSaveDir = FileUtility.PathCombine(assetOutputDir, GetGeneratorIdForSubPath(target, entry));
var assetSavePath = FileUtility.PathCombine(assetSaveDir, a.fileName + generator.GetAssetExtension(a));
if (!File.Exists(assetSavePath) || AssetGenerateInfo.DoesAssetNeedRegenerate(entry, node, target, a))
{
if (!Directory.Exists(assetSaveDir))
{
Directory.CreateDirectory(assetSaveDir);
}
if (!generator.GenerateAsset(a, assetSavePath))
{
throw new AssetGraphException(
$"{node.Name} :Failed to generate asset for {entry.m_name}");
}
if (!File.Exists(assetSavePath))
{
throw new AssetGraphException(
$"{node.Name} :{entry.m_name} returned success, but generated asset not found.");
}
AssetProcessEventRecord.GetRecord().LogModify(AssetDatabase.AssetPathToGUID(assetSavePath));
isAnyAssetGenerated = true;
LogUtility.Logger.LogFormat(LogType.Log, "{0} is (re)generating Asset:{1} with {2}({3})", node.Name, assetSavePath,
AssetGeneratorUtility.GetGUIName(entry.m_instance.ClassName),
AssetGeneratorUtility.GetVersion(entry.m_instance.ClassName));
if (progressFunc != null)
{
progressFunc(node, $"Creating {assetSavePath}", 0.5f);
}
AssetGenerateInfo.SaveAssetGenerateInfo(entry, node, target, a);
}
}
}
}
}
if (isAnyAssetGenerated)
{
AssetDatabase.Refresh();
}
}
public override void Prepare(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output)
{
// BundleBuilder do nothing without incoming connections
if (incoming == null)
{
return;
}
var bundleOutputDir = PrepareOutputDirectory(target, node, false, true);
var bundleNames = incoming.SelectMany(v => v.assetGroups.Keys).Distinct().ToList();
var bundleVariants = new Dictionary <string, List <string> >();
// get all variant name for bundles
foreach (var ag in incoming)
{
foreach (var name in ag.assetGroups.Keys)
{
if (!bundleVariants.ContainsKey(name))
{
bundleVariants[name] = new List <string>();
}
var assets = ag.assetGroups[name];
foreach (var a in assets)
{
var variantName = a.variantName;
if (!bundleVariants[name].Contains(variantName))
{
bundleVariants[name].Add(variantName);
}
}
}
}
// add manifest file
var manifestName = GetManifestName(target, node, true);
bundleNames.Add(manifestName);
bundleVariants[manifestName] = new List <string>()
{
""
};
if (connectionsToOutput != null && Output != null)
{
UnityEngine.Assertions.Assert.IsTrue(connectionsToOutput.Any());
var outputDict = new Dictionary <string, List <AssetReference> >();
outputDict[key] = new List <AssetReference>();
foreach (var name in bundleNames)
{
foreach (var v in bundleVariants[name])
{
string bundleName = (string.IsNullOrEmpty(v))? name : name + "." + v;
AssetReference bundle = AssetReferenceDatabase.GetAssetBundleReference(FileUtility.PathCombine(bundleOutputDir, bundleName));
AssetReference manifest = AssetReferenceDatabase.GetAssetBundleReference(FileUtility.PathCombine(bundleOutputDir, bundleName + Model.Settings.MANIFEST_FOOTER));
outputDict[key].Add(bundle);
outputDict[key].Add(manifest);
}
}
var dst = (connectionsToOutput == null || !connectionsToOutput.Any())?
null : connectionsToOutput.First();
Output(dst, outputDict);
}
}
public override void Build(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output,
Action <Model.NodeData, string, float> progressFunc)
{
if (incoming == null)
{
return;
}
var modifier = m_instance.Get <IModifier>(target);
UnityEngine.Assertions.Assert.IsNotNull(modifier);
Type targetType = ModifierUtility.GetModifierTargetType(m_instance.ClassName);
bool isAnyAssetModified = false;
var aggregatedGroups = new Dictionary <string, List <AssetReference> >();
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());
}
}
foreach (var assets in aggregatedGroups.Values)
{
foreach (var asset in assets)
{
if (asset.assetType == targetType)
{
if (modifier.IsModified(asset.allData, assets))
{
modifier.Modify(asset.allData, assets);
asset.SetDirty();
AssetProcessEventRecord.GetRecord().LogModify(asset);
isAnyAssetModified = true;
// apply asset setting changes to AssetDatabase.
if (asset.isSceneAsset)
{
if (!EditorSceneManager.SaveScene(asset.scene))
{
throw new NodeException("Failed to save modified scene:" + asset.importFrom, "See console for details.", node);
}
}
else
{
AssetDatabase.SaveAssets();
}
}
asset.ReleaseData();
}
}
}
if (isAnyAssetModified)
{
AssetDatabase.Refresh();
}
if (incoming != null && Output != null)
{
// Modifier does not add, filter or change structure of group, so just pass given group of assets
var dst = (connectionsToOutput == null || !connectionsToOutput.Any())?
null : connectionsToOutput.First();
Output(dst, aggregatedGroups);
}
}
public override void Build(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output,
Action <Model.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 = PrepareOutputDirectory(target, node, true, true);
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];
List <AssetImporterSetting> importerSetting = null;
if (!m_overwriteImporterSetting)
{
importerSetting = new List <AssetImporterSetting> ();
}
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();
/**
* WORKAROND: This will be unnecessary in future version
* Unity currently have issue in configuring variant assets using AssetBundleBuild[] that
* internal identifier does not match properly unless you configure value in AssetImporter.
*/
if (!string.IsNullOrEmpty(v))
{
foreach (var path in bundleBuild[bbIndex].assetNames)
{
AssetImporter importer = AssetImporter.GetAtPath(path);
if (importer.assetBundleName != name || importer.assetBundleVariant != v)
{
if (!m_overwriteImporterSetting)
{
importerSetting.Add(new AssetImporterSetting(importer));
}
importer.SetAssetBundleNameAndVariant(name, v);
importer.SaveAndReimport();
}
}
}
++bbIndex;
}
}
if (progressFunc != null)
{
progressFunc(node, "Building Asset Bundles...", 0.7f);
}
AssetBundleManifest m = BuildPipeline.BuildAssetBundles(bundleOutputDir, bundleBuild, (BuildAssetBundleOptions)m_enabledBundleOptions[target], target);
var output = new Dictionary <string, List <AssetReference> >();
output[key] = new List <AssetReference>();
var manifestName = GetManifestName(target, node, false);
if (!string.IsNullOrEmpty(m_manifestName [target]))
{
var projectPath = Directory.GetParent(Application.dataPath).ToString();
var finalManifestName = GetManifestName(target, node, true);
if (finalManifestName != manifestName)
{
var from = FileUtility.PathCombine(projectPath, bundleOutputDir, manifestName);
var to = FileUtility.PathCombine(projectPath, bundleOutputDir, finalManifestName);
var fromPaths = new string[] { from, from + ".manifest" };
var toPaths = new string[] { to, to + ".manifest" };
for (var i = 0; i < fromPaths.Length; ++i)
{
if (File.Exists(toPaths[i]))
{
File.Delete(toPaths[i]);
}
if (File.Exists(fromPaths[i]))
{
File.Move(fromPaths[i], toPaths[i]);
}
else
{
Debug.LogError("File " + fromPaths[i] + " does not exists! Wanted to copy to " + toPaths[i]);
}
}
manifestName = finalManifestName;
}
}
var generatedFiles = FileUtility.GetAllFilePathsInFolder(bundleOutputDir);
// add manifest file
bundleVariants.Add(manifestName.ToLower(), new List <string> {
null
});
foreach (var path in generatedFiles)
{
var fileName = path.Substring(bundleOutputDir.Length + 1);
if (IsFileIntendedItem(fileName, bundleVariants))
{
if (fileName == manifestName)
{
output[key].Add(AssetReferenceDatabase.GetAssetBundleManifestReference(path));
}
else
{
output[key].Add(AssetReferenceDatabase.GetAssetBundleReference(path));
}
}
}
if (Output != null)
{
var dst = (connectionsToOutput == null || !connectionsToOutput.Any())?
null : connectionsToOutput.First();
Output(dst, output);
}
if (importerSetting != null)
{
importerSetting.ForEach(i => i.WriteBack());
}
AssetBundleBuildReport.AddBuildReport(new AssetBundleBuildReport(node, m, manifestName, bundleBuild, output[key], aggregatedGroups, bundleVariants));
}
public override void Build(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output,
Action <Model.NodeData, string, float> progressFunc)
{
if (incoming == null)
{
return;
}
var builder = m_instance.Get <IPrefabBuilder>(target);
UnityEngine.Assertions.Assert.IsNotNull(builder);
var prefabOutputDir = FileUtility.EnsurePrefabBuilderCacheDirExists(target, node);
Dictionary <string, List <AssetReference> > output = null;
if (Output != null)
{
output = new Dictionary <string, List <AssetReference> >();
}
var aggregatedGroups = new Dictionary <string, List <AssetReference> >();
foreach (var ag in incoming)
{
foreach (var key in ag.assetGroups.Keys)
{
if (!aggregatedGroups.ContainsKey(key))
{
aggregatedGroups[key] = new List <AssetReference>();
}
aggregatedGroups[key].AddRange(ag.assetGroups[key].AsEnumerable());
}
}
foreach (var key in aggregatedGroups.Keys)
{
var assets = aggregatedGroups[key];
var allAssets = LoadAllAssets(assets);
var prefabFileName = builder.CanCreatePrefab(key, allAssets);
var prefabSavePath = FileUtility.PathCombine(prefabOutputDir, prefabFileName + ".prefab");
if (!Directory.Exists(Path.GetDirectoryName(prefabSavePath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(prefabSavePath));
}
if (PrefabBuildInfo.DoesPrefabNeedRebuilding(this, node, target, key, assets))
{
UnityEngine.GameObject obj = builder.CreatePrefab(key, allAssets);
if (obj == null)
{
throw new AssetBundleGraphException(string.Format("{0} :PrefabBuilder {1} returned null in CreatePrefab() [groupKey:{2}]",
node.Name, builder.GetType().FullName, key));
}
LogUtility.Logger.LogFormat(LogType.Log, "{0} is (re)creating Prefab:{1} with {2}({3})", node.Name, prefabFileName,
PrefabBuilderUtility.GetPrefabBuilderGUIName(m_instance.ClassName),
PrefabBuilderUtility.GetPrefabBuilderVersion(m_instance.ClassName));
if (progressFunc != null)
{
progressFunc(node, string.Format("Creating {0}", prefabFileName), 0.5f);
}
PrefabUtility.CreatePrefab(prefabSavePath, obj, m_replacePrefabOptions);
PrefabBuildInfo.SavePrefabBuildInfo(this, node, target, key, assets);
GameObject.DestroyImmediate(obj);
}
UnloadAllAssets(assets);
if (output != null)
{
output[key] = new List <AssetReference> ()
{
AssetReferenceDatabase.GetPrefabReference(prefabSavePath)
};
}
}
if (Output != null)
{
var dst = (connectionsToOutput == null || !connectionsToOutput.Any())?
null : connectionsToOutput.First();
Output(dst, output);
}
}
public override void Build(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output,
Action <Model.NodeData, string, float> progressFunc)
{
var aaSettings = AddressableAssetSettingsDefaultObject.GetSettings(false);
var registeredLabels = new List <string>();
if (incoming != null)
{
foreach (var ag in incoming)
{
foreach (var groupName in ag.assetGroups.Keys)
{
var labels = m_label.Replace("*", groupName).Split(',').Select(s => s.Trim()).Where(s => !string.IsNullOrEmpty(s)).Distinct();
if (labels.Any() || m_overwriteLabels)
{
var assets = ag.assetGroups [groupName];
foreach (var a in assets)
{
var entry = aaSettings.FindAssetEntry(a.assetDatabaseId);
if (entry == null)
{
continue;
}
if (m_overwriteLabels)
{
var removingLabelEnum = entry.labels.Except(labels);
if (removingLabelEnum.Any())
{
var removingLabels = removingLabelEnum.ToList();
foreach (var removingLabel in removingLabels)
{
entry.SetLabel(removingLabel, false);
}
}
}
var addingLabelEnum = labels.Except(entry.labels);
if (addingLabelEnum.Any())
{
var addingLabels = addingLabelEnum.ToList();
foreach (var addingLabel in addingLabels)
{
if (!registeredLabels.Contains(addingLabel))
{
aaSettings.AddLabel(addingLabel);
registeredLabels.Add(addingLabel);
}
entry.SetLabel(addingLabel, true);
}
}
}
}
}
}
}
if (Output != null)
{
var dst = (connectionsToOutput == null || !connectionsToOutput.Any())?
null : connectionsToOutput.First();
if (incoming != null)
{
foreach (var ag in incoming)
{
Output(dst, ag.assetGroups);
}
}
else
{
Output(dst, new Dictionary <string, List <AssetReference> >());
}
}
}
