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