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());
 }