public bool Convert(BuildOutput output, BuildCompression compression, string outputFolder, out uint[] crc, bool useCache = true)
{
// If enabled, try loading from cache
var hash = CalculateInputHash(output, compression);
if (useCache && LoadFromCache(hash, outputFolder, out crc))
{
return(true);
}
// Convert inputs
// TODO: Validate compression settings
crc = new uint[output.results.Length];
// TODO: Prepare settings.outputFolder
Directory.CreateDirectory(outputFolder);
for (var i = 0; i < output.results.Length; i++)
{
var filePath = string.Format("{0}/{1}", outputFolder, output.results[i].assetBundleName);
crc[i] = BuildInterface.ArchiveAndCompress(output.results[i].resourceFiles, filePath, compression);
}
// Cache results
if (useCache)
{
SaveToCache(hash, output, crc, outputFolder);
}
return(true);
}
public static void BuildAssetBundles()
{
var outputPath = bundleBuildPath;
if (!Directory.Exists(outputPath))
{
Directory.CreateDirectory(outputPath);
}
var results = CompileScripts();
var settings = new BuildSettings();
settings.target = EditorUserBuildSettings.activeBuildTarget;
settings.group = EditorUserBuildSettings.selectedBuildTargetGroup;
settings.typeDB = results.typeDB;
settings.outputFolder = outputPath;
SetupAssetVariantMapsAsset();
var input = BuildInterface.GenerateBuildInput();
BuildInput addressableInput;
AddressableAssetSettings.GetDefault().GenerateBuildInput(out addressableInput);
//input = addressableInput.Merge(input);
BuildCommandSet commands;
if (AssetBundleBuildPipeline.GenerateCommandSet(settings, input, out commands))
{
BuildOutput output;
if (AssetBundleBuildPipeline.ExecuteCommandSet(settings, commands, out output))
{
var bundlesToCopy = new List <string>(output.results.Select(x => x.assetBundleName));
CopyBundlesToStreamingAssets(bundlesToCopy);
CreateContentCatalog(commands);
}
}
}
public bool Convert(BuildCommandSet commands, BuildSettings settings, out BuildOutput output, bool useCache = true)
{
// If enabled, try loading from cache
var hash = CalculateInputHash(commands, settings);
if (useCache && LoadFromCache(hash, settings.outputFolder, out output))
{
return(true);
}
// Convert inputs
foreach (var bundle in commands.commands)
{
// TODO: Reduce copying of value tyeps
if (ValidateCommand(bundle))
{
continue;
}
output = new BuildOutput();
return(false);
}
// TODO: Validate settings
// TODO: Prepare settings.outputFolder
Directory.CreateDirectory(settings.outputFolder);
output = BuildInterface.WriteResourceFiles(commands, settings);
// Cache results
if (useCache)
{
SaveToCache(hash, output, settings.outputFolder);
}
// TODO: Change this return based on if WriteResourceFiles was successful or not - Need public BuildReporting
return(true);
}
public bool Convert(BuildInput input, BuildTarget target, out BuildCommandSet output, bool useCache = true)
{
// If enabled, try loading from cache
var hash = CalculateInputHash(input, target);
if (useCache && LoadFromCache(hash, out output))
{
return(true);
}
// Convert inputs
output = new BuildCommandSet();
if (input.definitions.IsNullOrEmpty())
{
return(false);
}
var o = -1;
output.commands = new BuildCommandSet.Command[input.definitions.Length];
for (var i = 0; i < input.definitions.Length; i++)
{
// If this definition has no assets, it's empty and we don't want to write anything out
if (input.definitions[i].explicitAssets.IsNullOrEmpty())
{
BuildLogger.LogError("Asset bundle '{0}' does not have any explicit assets defined.", input.definitions[i].assetBundleName);
continue;
}
o++;
var allObjectIDs = new HashSet <ObjectIdentifier>();
output.commands[o].assetBundleName = input.definitions[i].assetBundleName;
output.commands[o].explicitAssets = new BuildCommandSet.AssetLoadInfo[input.definitions[i].explicitAssets.Length];
for (var j = 0; j < input.definitions[i].explicitAssets.Length; j++)
{
output.commands[o].explicitAssets[j].asset = input.definitions[i].explicitAssets[j].asset;
output.commands[o].explicitAssets[j].address = string.IsNullOrEmpty(input.definitions[i].explicitAssets[j].address) ?
AssetDatabase.GUIDToAssetPath(input.definitions[i].explicitAssets[j].asset.ToString()) : input.definitions[i].explicitAssets[j].address;
output.commands[o].explicitAssets[j].includedObjects = BuildInterface.GetPlayerObjectIdentifiersInAsset(input.definitions[i].explicitAssets[j].asset, target);
output.commands[o].explicitAssets[j].referencedObjects = BuildInterface.GetPlayerDependenciesForObjects(output.commands[i].explicitAssets[j].includedObjects, target);
allObjectIDs.UnionWith(output.commands[i].explicitAssets[j].includedObjects);
allObjectIDs.UnionWith(output.commands[i].explicitAssets[j].referencedObjects);
}
var k = 0;
output.commands[o].assetBundleObjects = new BuildCommandSet.SerializationInfo[allObjectIDs.Count];
foreach (var objectID in allObjectIDs)
{
output.commands[o].assetBundleObjects[k].serializationObject = objectID;
output.commands[o].assetBundleObjects[k].serializationIndex = CalculateSerializationIndexFromObjectIdentifier(objectID);
k++;
}
// Sorting is unneccessary - just makes it more human readable
Array.Sort(output.commands[o].assetBundleObjects, kCompareer);
}
Array.Resize(ref output.commands, o + 1);
// Cache results
if (useCache)
{
SaveToCache(hash, output);
}
return(true);
}
/****************************************************
* Input
* *************************************************/
void Update()
{
//toggle contruction mode
if (Input.GetKeyDown(toggleKey) && isActive)
{
Toggle();
}
//place the object
if (canPlace)
{
InventoryManager ivty = InventoryManager.Instance;
BuildInterface build = BuildInterface.Instance;
//bool canBuild = true;
//for (int i = 0; i < build.buildingList[build.currentBuildIndex].buildReqInfos.Count; i++)
//{
// int itemId = build.buildingList[build.currentBuildIndex].buildReqInfos[i].itemId;
// int itemAmount = build.buildingList[build.currentBuildIndex].buildReqInfos[i].itemAmount;
// if (ivty.CheckItemNumInBag(itemId)<itemAmount)
// {
// canBuild = false;
// }
//}
if (build.BuildReqCheck())
{
if (Input.GetKeyDown(placeKey))
{
if (mouseIsNotOnUI && isOnBuildNode)
{
PlaceGhostObject();
build.RemoveReqItemsFromBag();
AudManager.Instance.PlaySFX(3);
}
else if (!isOnBuildNode && build.buildMode == BuildInterface.BuildMode.BUILD)
{
AudManager.Instance.PlaySFX(0);
PlayerInterface.Instance.PrintMsg("You have to build on a node from other factories or resources", Color.red);
}
}
if (!faceMe)
{
if (!useContinuousRotation)
{
if (Input.GetKeyDown(positiveRotateKey))
{
AddRotation(+1, snapRotationAngle); // positive rotation
}
if (Input.GetKeyDown(negativeRotateKey))
{
AddRotation(-1, snapRotationAngle); // negative rotation
}
}
else
{
if (Input.GetKey(positiveRotateKey))
{
AddRotation(+1, continuousRotationSpeed * Time.deltaTime); // positive rotation
}
if (Input.GetKey(negativeRotateKey))
{
AddRotation(-1, continuousRotationSpeed * Time.deltaTime); // negative rotation
}
}
}
}
else
{
PlayerInterface.Instance.PrintMsg("You don't have enough material!", Color.red);
}
}
}
public static void BuildAssetBundles()
{
var buildTimer = new Stopwatch();
buildTimer.Start();
var input = BuildInterface.GenerateBuildInput();
var settings = GenerateBuildSettings();
var compression = BuildCompression.DefaultUncompressed;
// Rebuild sprite atlas cache for correct dependency calculation & writting
Packer.RebuildAtlasCacheIfNeeded(settings.target, true, Packer.Execution.Normal);
// Generate command set
BuildCommandSet commands;
var packer = new Unity5Packer();
if (!packer.Convert(input, settings.target, out commands))
{
return;
}
//DebugPrintCommandSet(ref commands);
// Calculate dependencies
BuildCommandSet depCommands;
var dependencyCalculator = new Unity5DependencyCalculator();
if (!dependencyCalculator.Convert(commands, out depCommands))
{
return;
}
DebugPrintCommandSet(ref depCommands);
// TODO: implement incremental building when LLAPI supports it
// Write out resource files
BuildOutput output;
var resourceWriter = new ResourceWriter();
if (!resourceWriter.Convert(depCommands, settings, out output))
{
return;
}
// Archive and compress resource files
uint[] crc;
var archiveWriter = new ArchiveWriter();
if (!archiveWriter.Convert(output, compression, settings.outputFolder, out crc))
{
return;
}
// Generate Unity5 compatible manifest files
string[] manifestfiles;
var manifestWriter = new Unity5ManifestWriter();
if (!manifestWriter.Convert(depCommands, output, crc, settings.outputFolder, out manifestfiles))
{
return;
}
buildTimer.Stop();
BuildLogger.Log("Build Asset Bundles complete in: {0:c}", buildTimer.Elapsed);
}
