public static AssetBundleBuildCommandSet GenerateAssetBuildInstructionSet(AssetBundleBuildInput buildInput)
{
AssetBundleBuildCommandSet cmdSet = new AssetBundleBuildCommandSet();
cmdSet.commands = new AssetBundleBuildCommandSet.Command[buildInput.bundles.Length];
List <HashSet <ObjectIdentifier> > objectReferences = new List <HashSet <ObjectIdentifier> >();
for (int i = 0; i < buildInput.bundles.Length; i++)
{
cmdSet.commands[i].input = buildInput.bundles[i];
HashSet <ObjectIdentifier> objects = new HashSet <ObjectIdentifier>();
foreach (var asset in buildInput.bundles[i].assets)
{
foreach (var o in GetObjectIdentifiersInAsset(asset))
{
objects.Add(o);
foreach (var d in GetPlayerDependenciesForObject(o))
{
objects.Add(d);
}
}
}
objectReferences.Add(objects);
}
//stripping - this is REALLY bad... O^4 complexity...
List <ObjectIdentifier> toRemove = new List <ObjectIdentifier>();
for (int i = 0; i < objectReferences.Count; i++)
{
var refs = objectReferences[i];
//strip here
foreach (var o in refs)
{
for (int bi = 0; bi > cmdSet.commands.Length; bi++)
{
if (bi == i)
{
continue;
}
var bc = cmdSet.commands[bi];
if (bc.input.assets.Contains(o.guid))
{
toRemove.Add(o);
}
}
}
foreach (var r in toRemove)
{
refs.Remove(r);
}
cmdSet.commands[i].objectsToBeWritten = refs.ToArray();
}
return(cmdSet);
}
private static void DebugPrintCommandSet(ref AssetBundleBuildCommandSet commandSet)
{
var msg = "";
if (commandSet.commands != null)
{
foreach (var bundle in commandSet.commands)
{
msg += string.Format("{0}\n", bundle.assetBundleName);
if (bundle.explicitAssets != null)
{
foreach (var asset in bundle.explicitAssets)
{
msg += string.Format("\t{0}\n", asset.asset);
if (asset.includedObjects != null)
{
foreach (var obj in asset.includedObjects)
{
msg += string.Format("\t\t{0}\n", obj);
}
}
msg += "\t\t------------------------------\n";
if (asset.referencedObjects != null)
{
foreach (var obj in asset.referencedObjects)
{
msg += string.Format("\t\t{0}\n", obj);
}
}
}
}
if (bundle.assetBundleObjects != null)
{
foreach (var obj in bundle.assetBundleObjects)
{
msg += string.Format("\t{0}\n", obj);
}
}
if (bundle.assetBundleDependencies != null)
{
foreach (var dependency in bundle.assetBundleDependencies)
{
msg += string.Format("\t{0}\n", dependency);
}
}
}
}
UnityEngine.Debug.Log(msg);
}
public static AssetBundleBuildCommandSet GenerateAssetBundleBuildCommandSet(AssetBundleBuildInput input, AssetBundleBuildSettings settings)
{
// Create commands array matching the size of the input
var commandSet = new AssetBundleBuildCommandSet();
commandSet.commands = new AssetBundleBuildCommandSet.Command[input.definitions.Length];
for (var i = 0; i < input.definitions.Length; ++i)
{
var definition = input.definitions[i];
// Populate each command from asset bundle definition
var command = new AssetBundleBuildCommandSet.Command();
command.assetBundleName = definition.assetBundleName;
command.explicitAssets = new AssetBundleBuildCommandSet.AssetLoadInfo[definition.explicitAssets.Length];
// Fill out asset load info and references for each asset in the definition
var allObjects = new HashSet <ObjectIdentifier>();
for (var j = 0; j < definition.explicitAssets.Length; ++j)
{
var explicitAsset = new AssetBundleBuildCommandSet.AssetLoadInfo();
explicitAsset.asset = definition.explicitAssets[j];
explicitAsset.includedObjects = AssetBundleBuildInterface.GetObjectIdentifiersInAsset(definition.explicitAssets[j]);
explicitAsset.referencedObjects = AssetBundleBuildInterface.GetPlayerDependenciesForObjects(explicitAsset.includedObjects);
command.explicitAssets[j] = explicitAsset;
allObjects.UnionWith(explicitAsset.includedObjects);
allObjects.UnionWith(explicitAsset.referencedObjects);
}
command.assetBundleObjects = allObjects.ToArray();
commandSet.commands[i] = command;
}
// TODO: Debug printing
//DebugPrintCommandSet(ref commandSet);
// At this point, We have generated fully self contained asset bundles with 0 dependencies.
// Default implementation is to reduce duplication of objects by declaring dependencies to other asset
// bundles if that other asset bundle has an explicit asset declared that contains the objects needed
// We also remove any built in unity objects as they are built with the player (We may want to change this part in the future)
CalculateAssetBundleBuildDependencies(ref commandSet);
// Note: I may, or may not feel dirty doing mutable things to what otherwise should be immutable struct
// TODO: Debug printing
//DebugPrintCommandSet(ref commandSet);
return(commandSet);
}
public static void CalculateAssetBundleBuildDependencies(ref AssetBundleBuildCommandSet commandSet)
{
// Dictionary for quick included asset lookup
var assetToBundleMap = new Dictionary <GUID, string>();
for (var i = 0; i < commandSet.commands.Length; ++i)
{
var bundle = commandSet.commands[i];
foreach (var asset in bundle.explicitAssets)
{
assetToBundleMap.Add(asset.asset, commandSet.commands[i].assetBundleName);
}
}
for (var i = 0; i < commandSet.commands.Length; ++i)
{
CalculateAssetBundleDependencies(ref commandSet.commands[i], assetToBundleMap);
}
}
public static AssetBundleBuildOutput ExecuteAssetBuildCommandSet(AssetBundleBuildCommandSet set)
{
//TODO: C++
return(new AssetBundleBuildOutput());
}