private Hash128 CalculateInputHash(IWriteOperation operation, List <WriteCommand> dependencies, BuildSettings settings, BuildUsageTagGlobal globalUsage, BuildUsageTagSet buildUsage)
{
if (!UseCache)
{
return(new Hash128());
}
var empty = new GUID();
var assets = new HashSet <GUID>();
var assetHashes = new List <Hash128>();
foreach (var objectId in operation.command.serializeObjects)
{
var guid = objectId.serializationObject.guid;
if (guid == empty || !assets.Add(guid))
{
continue;
}
var path = AssetDatabase.GUIDToAssetPath(guid.ToString());
assetHashes.Add(AssetDatabase.GetAssetDependencyHash(path));
}
var sceneOp = operation as SceneDataWriteOperation;
if (sceneOp != null)
{
assetHashes.Add(HashingMethods.CalculateFileMD5Hash(sceneOp.processedScene));
}
return(HashingMethods.CalculateMD5Hash(Version, operation, assetHashes, dependencies, globalUsage, buildUsage, settings));
}
public Hash128 CalculateInputHash(BuildCommandSet commands, BuildSettings settings)
{
// TODO: Figure out if explicitAssets hash is not enough and we need use assetBundleObjects instead
var assetHashes = new List <string>();
if (!commands.commands.IsNullOrEmpty())
{
for (var i = 0; i < commands.commands.Length; i++)
{
if (commands.commands[i].explicitAssets.IsNullOrEmpty())
{
continue;
}
for (var k = 0; k < commands.commands[i].explicitAssets.Length; k++)
{
// TODO: Create GUIDToAssetPath that takes GUID struct
var path = AssetDatabase.GUIDToAssetPath(commands.commands[i].explicitAssets[k].asset.ToString());
var hash = AssetDatabase.GetAssetDependencyHash(path);
// TODO: Figure out a way to not create a string for every hash.
assetHashes.Add(hash.ToString());
}
}
}
return(HashingMethods.CalculateMD5Hash(Version, commands, settings.target, settings.group, settings.editorBundles, assetHashes));
}
public Hash128 CalculateInputHash(BuildInput input, BuildTarget target)
{
var assetHashes = new List <string>();
if (!input.definitions.IsNullOrEmpty())
{
for (var i = 0; i < input.definitions.Length; i++)
{
if (input.definitions[i].explicitAssets.IsNullOrEmpty())
{
continue;
}
for (var k = 0; k < input.definitions[i].explicitAssets.Length; k++)
{
// TODO: Create GUIDToAssetPath that takes GUID struct
var path = AssetDatabase.GUIDToAssetPath(input.definitions[i].explicitAssets[k].asset.ToString());
var hash = AssetDatabase.GetAssetDependencyHash(path);
// TODO: Figure out a way to not create a string for every hash.
assetHashes.Add(hash.ToString());
}
}
}
return(HashingMethods.CalculateMD5Hash(Version, input, target, assetHashes));
}
private Hash128 CalculateInputHash(BuildDependencyInformation buildInfo)
{
if (!UseCache)
{
return(new Hash128());
}
return(HashingMethods.CalculateMD5Hash(Version, buildInfo.assetLoadInfo, buildInfo.assetToBundles, buildInfo.bundleToAssets, buildInfo.sceneUsageTags));
}
private Hash128 CalculateInputHash(BuildDependencyInfo input)
{
if (!UseCache)
{
return(new Hash128());
}
return(HashingMethods.CalculateMD5Hash(Version, input));
}
private Hash128 CalculateInputHash(AssetBundleBuild[] input)
{
if (!UseCache)
{
return(new Hash128());
}
return(HashingMethods.CalculateMD5Hash(Version, input));
}
public Hash128 CalculateInputHash(BuildCommandSet commands, BuildOutput output, uint[] crcs, string outputFolder)
{
if (!UseCache)
{
return(new Hash128());
}
return(HashingMethods.CalculateMD5Hash(Version, commands, output, crcs));
}
private Hash128 CalculateInputHash(AssetInfoMap assetLoadInfo, SpriteRefMap spriteRefCount)
{
if (!UseCache)
{
return(new Hash128());
}
return(HashingMethods.CalculateMD5Hash(Version, assetLoadInfo, spriteRefCount));
}
private Hash128 CalculateInputHash(List <ResourceFile> resourceFiles, BuildCompression compression)
{
if (!UseCache)
{
return(new Hash128());
}
var fileHashes = new List <string>();
foreach (var file in resourceFiles)
{
fileHashes.Add(HashingMethods.CalculateFileMD5Hash(file.fileName).ToString());
}
return(HashingMethods.CalculateMD5Hash(Version, fileHashes, compression));
}
private Hash128 CalculateInputHash(GUID asset, BuildSettings settings)
{
if (!UseCache)
{
return(new Hash128());
}
var path = AssetDatabase.GUIDToAssetPath(asset.ToString());
var assetHash = AssetDatabase.GetAssetDependencyHash(path).ToString();
var dependencies = AssetDatabase.GetDependencies(path);
var dependencyHashes = new string[dependencies.Length];
for (var i = 0; i < dependencies.Length; ++i)
{
dependencyHashes[i] = AssetDatabase.GetAssetDependencyHash(dependencies[i]).ToString();
}
return(HashingMethods.CalculateMD5Hash(Version, assetHash, dependencyHashes, settings));
}
private Hash128 CalculateInputHash(WriteCommand command, BuildSettings settings)
{
if (!UseCache)
{
return(new Hash128());
}
// NOTE: correct hash should be based off command, dependencies (internal name), settings, and asset hashes, (and usage tags, NYI)
// NOTE: This hashing method assumes we use a deterministic method to generate all serializationIndex
var dependencies = m_NameToDependencies[command.assetBundleName];
var assetHashes = new List <string>();
foreach (var objectID in command.assetBundleObjects)
{
assetHashes.Add(m_AssetToHash[objectID.serializationObject.guid]);
}
return(HashingMethods.CalculateMD5Hash(Version, command, dependencies, assetHashes, settings));
}
private Hash128 CalculateInputHash(BuildInput.AddressableAsset[] input)
{
return(HashingMethods.CalculateMD5Hash(Version, input));
}
public Hash128 CalculateInputHash(BuildCommandSet input)
{
return(HashingMethods.CalculateMD5Hash(Version, input));
}
public override BuildPipelineCodes Convert(BuildDependencyInfo input, BuildSettings settings, bool aggressive, out BuildDependencyInfo output)
{
StartProgressBar("Generated shared object bundles", 3);
Hash128 hash = CalculateInputHash(input);
if (UseCache && BuildCache.TryLoadCachedResults(hash, out output))
{
EndProgressBar();
return(BuildPipelineCodes.SuccessCached);
}
// Mutating the input
output = input;
if (!UpdateProgressBar("Generate lookup of all objects"))
{
EndProgressBar();
return(BuildPipelineCodes.Canceled);
}
// Generate mapping of each object to the bundles it would be used by
var objectToBundles = new Dictionary <ObjectIdentifier, HashSet <string> >();
var objectToAssets = new Dictionary <ObjectIdentifier, HashSet <GUID> >();
foreach (var asset in input.assetInfo.Values)
{
var dependencies = input.assetToBundles[asset.asset];
if (aggressive && !asset.includedObjects.IsNullOrEmpty())
{
for (int i = 1; i < asset.includedObjects.Count; ++i)
{
var objectID = asset.includedObjects[i];
HashSet <string> bundles;
objectToBundles.GetOrAdd(objectID, out bundles);
bundles.Add(dependencies[0]);
HashSet <GUID> assets;
objectToAssets.GetOrAdd(objectID, out assets);
assets.Add(asset.asset);
}
}
foreach (var referenceID in asset.referencedObjects)
{
if (!aggressive && input.assetToBundles.ContainsKey(referenceID.guid))
{
continue;
}
if (referenceID.filePath == BuildWriteProcessor.kUnityDefaultResourcePath)
{
continue;
}
HashSet <string> bundles;
objectToBundles.GetOrAdd(referenceID, out bundles);
bundles.Add(dependencies[0]);
HashSet <GUID> assets;
objectToAssets.GetOrAdd(referenceID, out assets);
assets.Add(asset.asset);
}
}
if (!UpdateProgressBar("Finding set of reused objects"))
{
EndProgressBar();
return(BuildPipelineCodes.Canceled);
}
// Generate the set of reused objects
var hashToObjects = new Dictionary <Hash128, List <ObjectIdentifier> >();
foreach (var objectPair in objectToBundles)
{
if (objectPair.Value.Count <= 1)
{
continue;
}
var bundleHash = HashingMethods.CalculateMD5Hash(objectPair.Value.ToArray());
List <ObjectIdentifier> objectIDs;
hashToObjects.GetOrAdd(bundleHash, out objectIDs);
objectIDs.Add(objectPair.Key);
}
if (!UpdateProgressBar("Creating shared object bundles"))
{
EndProgressBar();
return(BuildPipelineCodes.Canceled);
}
// Generate Shared Bundles
foreach (var hashPair in hashToObjects)
{
// Generate Dependency Information for virtual asset
var assetInfo = new AssetLoadInfo();
assetInfo.asset = new GUID(hashPair.Key.ToString());
assetInfo.address = hashPair.Key.ToString();
assetInfo.includedObjects = hashPair.Value.ToList();
assetInfo.referencedObjects = new List <ObjectIdentifier>();
assetInfo.includedObjects.Sort((x, y) => { if (x < y)
{
return(-1);
}
if (x > y)
{
return(1);
}
return(0); });
// Add new AssetLoadInfo for virtual asset
output.assetInfo.Add(assetInfo.asset, assetInfo);
var assetBundles = new List <string>();
assetBundles.Add(assetInfo.address);
// Add new bundle as dependency[0] for virtual asset
output.assetToBundles.Add(assetInfo.asset, assetBundles);
var bundleAssets = new List <GUID>();
bundleAssets.Add(assetInfo.asset);
// Add virtual asset to the list of assets for new bundle
output.bundleToAssets.Add(assetInfo.address, bundleAssets);
// Add virtual asset to lookup
output.virtualAssets.Add(assetInfo.asset);
foreach (var objectID in assetInfo.includedObjects)
{
// Add objects in virtual asset to lookup
output.objectToVirtualAsset.Add(objectID, assetInfo.asset);
var assets = objectToAssets[objectID];
foreach (var asset in assets)
{
if (!output.assetToBundles.TryGetValue(asset, out assetBundles))
{
continue;
}
if (assetBundles.Contains(assetInfo.address))
{
continue;
}
// Add new bundle as dependency to assets referencing virtual asset objects
assetBundles.Add(assetInfo.address);
}
}
}
// Generate Shared Bundle Build Dependencies
foreach (var virtualAsset in output.virtualAssets)
{
var assetInfo = output.assetInfo[virtualAsset];
var dependencies = output.assetToBundles[virtualAsset];
var references = BundleBuildInterface.GetPlayerDependenciesForObjects(assetInfo.includedObjects.ToArray(), settings.target, settings.typeDB);
foreach (var reference in references)
{
GUID dependency;
List <string> bundles;
string depStr = "";
// If the reference is to an object in a virtual asset, no major checks, just add it as a dependency
if (output.objectToVirtualAsset.TryGetValue(reference, out dependency))
{
if (dependency == virtualAsset)
{
continue;
}
depStr = dependency.ToString();
}
// Otherwise if this reference is part of an asset assigned to a bundle, then set the bundle as a dependency to the virtual asset
else if (output.assetToBundles.TryGetValue(reference.guid, out bundles))
{
if (bundles.IsNullOrEmpty())
{
continue;
}
depStr = bundles[0];
}
if (dependencies.Contains(depStr))
{
continue;
}
dependencies.Add(depStr);
}
}
if (UseCache && !BuildCache.SaveCachedResults(hash, output))
{
BuildLogger.LogWarning("Unable to cache SharedObjectProcessor results.");
}
if (!EndProgressBar())
{
return(BuildPipelineCodes.Canceled);
}
return(BuildPipelineCodes.Success);
}
private Hash128 CalculateInputHash(BuildOutput output, BuildCompression compression)
{
// TODO: may need to use the resource files as a hash input
return(HashingMethods.CalculateMD5Hash(Version, output, compression));
}
