/// <summary>
/// 差异化缓存xml
/// </summary>
static void MakeCacheData()
{
mStringBuilder.Remove(0, mStringBuilder.Length);
StringBuilder("<root version='", mVersion, "'>");
var count = tempBuilds.Count;
Debug.Log(" MakeCacheData count " + count);
foreach (var key in tempBuilds.Keys)
{
var build = tempBuilds[key];
StringBuilder("<asset name='", build.assetBundleName.ToLower(), "'>");
foreach (var abName in build.assetNames)
{
var guid = AssetDatabase.AssetPathToGUID(abName);
var hash = AssetDatabase.GetAssetDependencyHash(abName).ToString();
StringBuilder("<sub guid='", guid, "' hash='", hash, "'/>");
}
StringBuilder("</asset>");
}
StringBuilder("</root>");
XmlDocument xml = new XmlDocument();
xml.LoadXml(mStringBuilder.ToString());
xml.Save(Application.persistentDataPath + "/" + GetPlatformFloder() + "_AssetBundleCache.xml");
// xml.Save(m_RootDirectory + "/AssetBundleCache.xml");
}
static bool GetAssetState(GUID asset, out AssetState assetState)
{
assetState = new AssetState();
if (asset.Empty())
{
return(false);
}
var path = AssetDatabase.GUIDToAssetPath(asset.ToString());
if (string.IsNullOrEmpty(path))
{
return(false);
}
var hash = AssetDatabase.GetAssetDependencyHash(path);
if (!hash.isValid)
{
return(false);
}
assetState.guid = asset;
assetState.hash = hash;
return(true);
}
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(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));
}
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));
}
private void CacheDataForCommandSet(BuildCommandSet commandSet)
{
if (!UseCache)
{
return;
}
m_NameToDependencies.Clear();
m_AssetToHash.Clear();
// Generate data needed for cache hash generation
foreach (var command in commandSet.commands)
{
var dependencies = new List <string>();
m_NameToDependencies[command.assetBundleName] = dependencies;
dependencies.Add(command.assetBundleName);
foreach (var dependency in command.assetBundleDependencies)
{
dependencies.Add(dependency);
}
foreach (var objectID in command.assetBundleObjects)
{
if (m_AssetToHash.ContainsKey(objectID.serializationObject.guid))
{
continue;
}
var path = AssetDatabase.GUIDToAssetPath(objectID.serializationObject.guid.ToString());
m_AssetToHash[objectID.serializationObject.guid] = AssetDatabase.GetAssetDependencyHash(path).ToString();
}
}
}
bool CheckAssetDirty(BuildDataInputFile file)
{
NPath path = file.path;
if (!path.Exists())
{
Console.WriteLine($"Rebuilding Data files because {path} is dirty (deleted)");
return(true);
}
string contentHash = "";
if (path.Extension == "cs")
{
var monoScript = AssetDatabase.LoadAssetAtPath <MonoScript>(path.ToString());
if (monoScript != null)
{
contentHash = monoScript.GetPropertiesHashString(buildOptions.HasFlag(BuildOptions.Development));
}
}
else
{
contentHash = AssetDatabase.GetAssetDependencyHash(file.path).ToString();
}
if (contentHash != file.contentHash)
{
Console.WriteLine($"Rebuilding Data files because {path} is dirty (hash)");
return(true);
}
return(false);
}
internal AssetDependencies Get(string path, string guid)
{
_used.Add(guid);
if (_dict.TryGetValue(guid, out var res))
{
var assetDependencyHash = AssetDatabase.GetAssetDependencyHash(path);
if (assetDependencyHash.isValid && res.DependencyHash == assetDependencyHash)
{
return(res);
}
res = HashByPath();
_dict[guid] = res;
return(res);
}
res = HashByPath();
_dict.Add(guid, res);
return(res);
AssetDependencies HashByPath()
{
var dependencyPaths = AssetDatabase.GetDependencies(path, true);
var guids = dependencyPaths.Select(AssetDatabase.AssetPathToGUID).ToArray();
return(new AssetDependencies {
DependencyGuids = guids,
DependencyHash = AssetDatabase.GetAssetDependencyHash(path),
});
}
}
/// <inheritdoc />
public CacheEntry GetCacheEntry(GUID asset, int version = 1)
{
CacheEntry entry;
KeyValuePair <GUID, int> key = new KeyValuePair <GUID, int>(asset, version);
if (m_GuidToHash.TryGetValue(key, out entry))
{
return(entry);
}
entry = new CacheEntry {
Guid = asset, Version = version
};
string path = AssetDatabase.GUIDToAssetPath(asset.ToString());
entry.Type = CacheEntry.EntryType.Asset;
if (path.Equals(CommonStrings.UnityBuiltInExtraPath, StringComparison.OrdinalIgnoreCase) || path.Equals(CommonStrings.UnityDefaultResourcePath, StringComparison.OrdinalIgnoreCase))
{
entry.Hash = HashingMethods.Calculate(Application.unityVersion, path).ToHash128();
}
else
{
entry.Hash = AssetDatabase.GetAssetDependencyHash(path);
if (!entry.Hash.isValid)
{
entry.Hash = HashingMethods.CalculateFile(path).ToHash128();
}
}
entry.Hash = HashingMethods.Calculate(entry.Hash, entry.Version).ToHash128();
m_GuidToHash[key] = entry;
return(entry);
}
//生成并加入引用信息
private void ImportAsset(string path)
{
//通过path获取guid进行储存
string guid = AssetDatabase.AssetPathToGUID(path);
//获取该资源的最后修改时间，用于之后的修改判断
Hash128 assetDependencyHash = AssetDatabase.GetAssetDependencyHash(path);
//如果assetDict没包含该guid或包含了修改时间不一样则需要更新
if (!assetDict.ContainsKey(guid) || assetDict[guid].assetDependencyHash != assetDependencyHash)
{
//将每个资源的直接依赖资源转化为guid进行储存
var guids = AssetDatabase.GetDependencies(path, false).
Select(p => AssetDatabase.AssetPathToGUID(p)).
ToList();
//生成asset依赖信息，被引用需要在所有的asset依赖信息生成完后才能生成
AssetDescription ad = new AssetDescription();
ad.name = Path.GetFileNameWithoutExtension(path);
ad.path = path;
ad.assetDependencyHash = assetDependencyHash;
ad.dependencies = guids;
if (assetDict.ContainsKey(guid))
{
assetDict[guid] = ad;
}
else
{
assetDict.Add(guid, ad);
}
}
}
public static void AddDeps(string assetPath, string[] deps)
{
if (!s_Inited)
{
Debug.LogWarning("CacheManager don't init. please call CacheManager.Open()");
return;
}
Hash128 hash128 = AssetDatabase.GetAssetDependencyHash(assetPath);
DepCacheData data;
if (!s_ABDepCacheMap.TryGetValue(assetPath, out data))
{
data = new DepCacheData();
data.assetPath = assetPath;
data.hash128 = hash128;
data.depsPath = deps;
s_ABDepCacheMap.Add(assetPath, data);
s_Dirty = true;
}
else
{
//更新hash128以及依赖deps;
data.hash128 = hash128;
data.depsPath = deps;
}
}
public static Hash128 GetAssetDependencyHash(GUID guid)
{
#if UNITY_2020_2_OR_NEWER
return(AssetDatabase.GetAssetDependencyHash(guid));
#else
return(AssetDatabase.GetAssetDependencyHash(AssetDatabase.GUIDToAssetPath(guid.ToString())));
#endif
}
private static AssetDependencies RebuildCache(string path)
{
var dependencyPaths = AssetDatabase.GetDependencies(path, true);
var guids = dependencyPaths.Select(p => AssetDatabase.AssetPathToGUID(p)).ToArray();
return(new AssetDependencies
{
DependencyGuids = guids,
DependencyHash = AssetDatabase.GetAssetDependencyHash(path),
});
}
public void Verify( string path )
{
string hash = AssetDatabase.GetAssetDependencyHash( path ).ToString();
if( this.hash != hash )
{
this.hash = hash;
Refresh( path );
}
verified = true;
}
IEnumerable <int> AssetWasUpdated()
{
for (int i = 0; i < targets.Length; i++)
{
var importer = targets[i] as AssetImporter;
// check for AssetImporter being null as it may have been destroyed when closing...
if (importer != null && m_AssetHashes[i] != AssetDatabase.GetAssetDependencyHash(importer.assetPath))
{
yield return(i);
}
}
}
static CACHE FetchDependCache(string pathName, bool recursive)
{
CACHE cache = null;
Hash128 depHash = AssetDatabase.GetAssetDependencyHash(pathName);
//memory
if (cacheInMemory.TryGetValue(depHash, out cache) && cache.dependencyHash == depHash)
{
return(cache);
}
else
{
cache = null;
}
//disk
string cacheFile = CalcCacheFileName(depHash);
cache = ReadCache(cacheFile);
if (cache != null && cache.dependencyHash == depHash)
{
cacheInMemory[depHash] = cache;
return(cache);
}
else
{
cache = null;
}
//rebuild
if (cache == null)
{
cache = new CACHE();
cache.dependencyHash = depHash;
cache.depends = AssetDatabase.GetDependencies(pathName, false);
WriteCache(cacheFile, cache);
cacheInMemory[depHash] = cache;
if (recursive)
{
foreach (var dep in AssetDatabase.GetDependencies(pathName, true))
{
if (dep == pathName)
{
continue;
}
FetchDependCache(dep, false);
}
}
}
return(cache);
}
void GetAssetHashes(HashSet <Hash128> hashes, GUID g, List <ObjectIdentifier> referencedObjects, bool useCache)
{
if (useCache)
{
hashes.Add(m_Cache.GetCacheEntry(g, Version).Hash);
foreach (var reference in referencedObjects)
{
hashes.Add(m_Cache.GetCacheEntry(reference).Hash);
}
}
else
{
hashes.Add(AssetDatabase.GetAssetDependencyHash(AssetDatabase.GUIDToAssetPath(g.ToString())));
}
}
private CollectionData GetOrCreateDependData(string assetPath)
{
var assetPathLow = assetPath.ToLower();
if (!_data.ContainsKey(assetPathLow))
{
var index = GetAndTryAddAssetPath(assetPath);
var depData = new CollectionData();
depData.assetPathIndex = index;
depData.assetDependencyHash = AssetDatabase.GetAssetDependencyHash(assetPath).ToString();
_data.Add(assetPathLow, depData);
}
return(_data[assetPathLow]);
}
public bool CheckForChanges(bool forceCheck = false, bool forceChange = false)
{
if ((ContainerGraph.ParentWindow.CheckFunctions || forceCheck || forceChange) && m_function != null)
{
//string newCheckSum = LastLine( m_function.FunctionInfo );
string newCheckSum = AssetDatabase.GetAssetDependencyHash(AssetDatabase.GetAssetPath(m_function)).ToString();
if (!m_functionCheckSum.Equals(newCheckSum) || forceChange)
{
m_functionCheckSum = newCheckSum;
ContainerGraph.OnDuplicateEvent += DuplicateMe;
return(true);
}
}
return(false);
}
public BuildDataInputFile(NPath npath, bool developmentBuild)
{
path = npath.ToString();
if (npath.HasExtension("cs"))
{
var monoScript = AssetDatabase.LoadAssetAtPath <MonoScript>(path);
if (monoScript != null)
{
contentHash = monoScript.GetPropertiesHashString(developmentBuild);
}
}
else
{
contentHash = AssetDatabase.GetAssetDependencyHash(npath.ToString()).ToString();
}
}
public void UpdateRelation(string srcPath)
{
var srcPathLow = srcPath.ToLower();
if (_data.TryGetValue(srcPathLow, out var srcDepData))
{
var oldHashCode = srcDepData.assetDependencyHash;
var newHashCode = AssetDatabase.GetAssetDependencyHash(srcPath).ToString();
if (string.Compare(oldHashCode, newHashCode) == 0)
{
return;
}
if (string.Compare(newHashCode, EMPTY_CODE) == 0)
{
RemoveRelation(srcPath);
return;
}
else
{
//更新
var srcPathIndex = _strIndex[srcPathLow];
srcDepData.referencePath.Remove(srcPath);
srcDepData.referencesPathIndex.Remove(srcPathIndex);
srcDepData.dependsPath.Clear();
srcDepData.dependsPathIndex.Clear();
var dependencies = AssetDatabase.GetDependencies(srcPath);
foreach (var depPath in dependencies)
{
var depPathIndex = GetAndTryAddAssetPath(depPath);
var refDepData = GetOrCreateDependData(depPath);
srcDepData.dependsPath.Add(depPath);
srcDepData.dependsPathIndex.Add(depPathIndex);
refDepData.referencePath.Add(srcPath);
refDepData.referencesPathIndex.Add(srcPathIndex);
}
}
}
else
{
AddRelation(srcPath);
}
}
public void AddItem(string assetPath)
{
if (Directory.Exists(assetPath))
{
return;
}
if (!File.Exists(assetPath))
{
return;
}
var guid = AssetDatabase.AssetPathToGUID(assetPath);
var hash = AssetDatabase.GetAssetDependencyHash(assetPath);
var libPath =
new[] { projectRoot, "Library", "metadata", guid.Substring(0, 2), guid }
.Aggregate(string.Empty, Path.Combine);
if (!File.Exists(libPath))
{
Debug.Log("Cannot find Library representation for GUID " + guid);
return;
}
var files = new List <Transaction.FileInfo>
{
new Transaction.FileInfo(TYPE_ASSET, libPath, ToUnixTime(File.GetLastWriteTime(libPath)))
};
var infoLibPath = libPath + ".info";
if (File.Exists(infoLibPath))
{
files.Add(new Transaction.FileInfo(TYPE_INFO, infoLibPath, ToUnixTime(File.GetLastWriteTime(infoLibPath))));
}
var resLibPath = libPath + ".resource";
if (File.Exists(resLibPath))
{
files.Add(new Transaction.FileInfo(TYPE_RESOURCE, resLibPath, ToUnixTime(File.GetLastWriteTime(resLibPath))));
}
m_transactionList.Add(new Transaction(assetPath, guid, hash, files.ToArray()));
}
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));
}
/// <summary>
/// アセットバンドルのハッシュ
/// </summary>
private Hash128 CalcBundleHash(IBundleFileManifest data)
{
// 持ってるアセット
var assets = data.Assets;
// assetのhash一覧
var hashList = new List <Hash128>(assets.Length);
foreach (var asset in assets)
{
var hash = AssetDatabase.GetAssetDependencyHash(asset);
hashList.Add(hash);
}
// 結合して1個のhashにする
var hashBytes = hashList.CombineHashBytes();
return(FsUtillity.ComputeHash(hashBytes));
}
void UpdateInvalidReferences()
{
foreach (var o in targets)
{
var instanceID = o.GetInstanceID();
if (s_References.ContainsKey(instanceID))
{
var presetHash = s_References[instanceID].presetHash;
var currentHash = AssetDatabase.GetAssetDependencyHash(AssetDatabase.GetAssetOrScenePath(o));
// The asset changed on disk. Update the reference.
if (presetHash != currentHash)
{
s_References[instanceID].presetHash = currentHash;
s_References[instanceID].reference = (o as Preset)?.GetReferenceObject();
}
}
}
}
// Token: 0x06000129 RID: 297 RVA: 0x00009EA8 File Offset: 0x000080A8
public bool TryGetEntry(string assetguid, out T model, bool checkTimeStamp)
{
model = default(T);
if (!this._lut.TryGetValue(assetguid, out model))
{
return(false);
}
if (checkTimeStamp)
{
string text = AssetDatabase.GUIDToAssetPath(assetguid);
Hash128 assetDependencyHash = AssetDatabase.GetAssetDependencyHash(text);
Hash128 hash = Hash128.Parse(model.GetAssetHash());
if (assetDependencyHash != hash)
{
this._lut.Remove(assetguid);
return(false);
}
}
return(true);
}
public static List <string> GetReverseDependencies(string[] paths, string[] searchPaths = null)
{
var includeList = new HashSet <string>();
var stopWatch = new Stopwatch();
stopWatch.Start();
foreach (var guid in AssetDatabase.FindAssets(RevertDependenciesSearch, searchPaths))
{
var filePath = AssetDatabase.GUIDToAssetPath(guid);
var hash = AssetDatabase.GetAssetDependencyHash(filePath);
AssetDependence assetDepend;
if (!AssetDependenceDict.TryGetValue(filePath, out assetDepend))
{
assetDepend = new AssetDependence();
AssetDependenceDict[filePath] = assetDepend;
}
if (assetDepend.Hash != hash)
{
assetDepend.Hash = hash;
assetDepend.Dependencies = AssetDatabase.GetDependencies(filePath, false);
}
var dependencies = assetDepend.Dependencies;
foreach (var dependence in dependencies)
{
if (paths.Any(dependence.Contains))
{
includeList.Add(filePath);
break;
}
}
}
stopWatch.Stop();
UnityEngine.Debug.Log(String.Format("反向查找依赖耗时：{0}", stopWatch.Elapsed.Seconds));
return(includeList.ToList());
}
static void RebuildDependCache(bool force)
{
foreach (var obj in Selection.objects)
{
string asset = AssetDatabase.GetAssetPath(obj);
if (string.IsNullOrEmpty(asset))
{
return;
}
Stopwatch sw = Stopwatch.StartNew();
Hash128 depHash = AssetDatabase.GetAssetDependencyHash(asset);
string cacheFile = CalcCacheFileName(depHash);
if (force)
{
FileUtil.DeleteFileOrDirectory(cacheFile);
}
FetchDependCache(asset, true);
UnityEngine.Debug.LogFormat("rebuild depend cache {0}, use time:{1}", asset, sw.ElapsedMilliseconds / 1000f);
}
}
internal AssetDependencies Get(string path, string guid)
{
AssetDependencies res;
if (Dict.TryGetValue(guid, out res))
{
var assetDependencyHash = AssetDatabase.GetAssetDependencyHash(path);
if (!assetDependencyHash.isValid || res.DependencyHash == assetDependencyHash)
{
return(res);
}
res = RebuildCache(path);
Dict[guid] = res;
return(res);
}
res = RebuildCache(path);
Dict.Add(guid, res);
return(res);
}
public void AddRelation(string srcPath)
{
if (!IsPathEligible(srcPath))
{
return;
}
var srcHashCode = AssetDatabase.GetAssetDependencyHash(srcPath).ToString();
if (string.Compare(srcHashCode, EMPTY_CODE) == 0)
{
return;
}
var dependencies = AssetDatabase.GetDependencies(srcPath);
var srcPathIndex = GetAndTryAddAssetPath(srcPath);
var srcDepData = GetOrCreateDependData(srcPath);
foreach (var depPath in dependencies)
{
if (!IsPathEligible(depPath))
{
continue;
}
var depHashCode = AssetDatabase.GetAssetDependencyHash(depPath).ToString();
if (string.Compare(depHashCode, EMPTY_CODE) == 0)
{
continue;
}
var depPathIndex = GetAndTryAddAssetPath(depPath);
var refDepData = GetOrCreateDependData(depPath);
srcDepData.dependsPath.Add(depPath);
srcDepData.dependsPathIndex.Add(depPathIndex);
refDepData.referencePath.Add(srcPath);
refDepData.referencesPathIndex.Add(srcPathIndex);
}
}
