public void GetDependenciesForId(string assetId, List <Dependency> dependencies) { Progress.IncreaseProgress(); string fileId = NodeDependencyLookupUtility.GetGuidFromAssetId(assetId); dependencies.Add(new Dependency(fileId, ResolvedType, "File", new [] { new PathSegment("File", PathSegmentType.Property) })); }
public bool NeedsUpdate(ProgressBase progress) { string[] assetIds = NodeDependencyLookupUtility.GetAllAssetPathes(progress, true); long[] timeStampsForFiles = NodeDependencyLookupUtility.GetTimeStampsForFiles(assetIds); return(GetNeedsUpdate(assetIds, timeStampsForFiles)); }
private void GetDependenciesForAssetsInResolver(HashSet <string> changedAssets, IAssetDependencyResolver resolver, Dictionary <string, FileToAssetNode> resultList, ProgressBase progress) { string resolverId = resolver.GetId(); foreach (string assetId in changedAssets) { string fileId = NodeDependencyLookupUtility.GetGuidFromAssetId(assetId); if (!resultList.ContainsKey(fileId)) { resultList.Add(fileId, new FileToAssetNode { FileId = fileId }); } FileToAssetNode fileToAssetNode = resultList[fileId]; AssetNode assetNode = fileToAssetNode.GetAssetNode(assetId); List <Dependency> dependencies = new List <Dependency>(); resolver.GetDependenciesForId(assetId, dependencies); AssetNode.ResolverData resolverData = assetNode.GetResolverData(resolverId); resolverData.Dependencies = dependencies; fileToAssetNode.GetResolverTimeStamp(resolverId).TimeStamp = NodeDependencyLookupUtility.GetTimeStampForFileId(fileId); } }
private FileToAssetsMapping[] GetDependenciesForAssets(FileToAssetsMapping[] fileToAssetsMappings, CreatedDependencyCache createdDependencyCache, ProgressBase progress) { string[] pathes = NodeDependencyLookupUtility.GetAllAssetPathes(progress, true); long[] timestamps = NodeDependencyLookupUtility.GetTimeStampsForFiles(pathes); List <AssetResolverData> data = new List <AssetResolverData>(); foreach (CreatedResolver resolverUsage in createdDependencyCache.ResolverUsages) { if (!(resolverUsage.Resolver is IAssetToFileDependencyResolver)) { continue; } IAssetToFileDependencyResolver resolver = (IAssetToFileDependencyResolver)resolverUsage.Resolver; HashSet <string> changedAssets = GetChangedAssetIds(pathes, timestamps, fileToAssetsMappings); data.Add(new AssetResolverData { ChangedAssets = changedAssets, Resolver = resolver }); resolver.Initialize(this, changedAssets, progress); } Dictionary <string, FileToAssetsMapping> nodeDict = RelationLookup.RelationLookupBuilder.ConvertToDictionary(fileToAssetsMappings); foreach (AssetResolverData resolverData in data) { GetDependenciesForAssetsInResolver(resolverData.ChangedAssets, resolverData.Resolver as IAssetToFileDependencyResolver, nodeDict, progress); } return(nodeDict.Values.ToArray()); }
public List <Dependency> GetDependenciesForId(string id) { if (NodeDependencyLookupUtility.IsResolverActive(_createdDependencyCache, AssetToFileDependencyResolver.Id, ConnectionType)) { return(_fileNodesDict[id].Dependencies); } return(new List <Dependency>()); }
public Node GetNode(string id, string type) { string key = NodeDependencyLookupUtility.GetNodeKey(id, type); if (_lookup.ContainsKey(key)) { return(_lookup[key]); } return(null); }
private void AddPrefabAsDependency(string id, Object obj, Stack <PathSegment> stack) { Object correspondingObjectFromSource = PrefabUtility.GetCorrespondingObjectFromSource(obj); string assetId = NodeDependencyLookupUtility.GetAssetIdForAsset(correspondingObjectFromSource); string assetPath = AssetDatabase.GetAssetPath(correspondingObjectFromSource); string guid = AssetDatabase.AssetPathToGUID(assetPath); if (guid != NodeDependencyLookupUtility.GetGuidFromAssetId(id)) { AddDependency(id, new Dependency(assetId, ConnectionType, NodeType, stack.ToArray())); } }
public void Initialize(AssetDependencyCache cache, HashSet <string> changedAssets, ProgressBase progress) { TraverserSubSystem.Clear(); foreach (string assetId in changedAssets) { string guid = NodeDependencyLookupUtility.GetGuidFromAssetId(assetId); if (!_inValidGuids.Contains(guid)) { cache._hierarchyTraverser.AddAssetId(assetId, TraverserSubSystem); } } }
private static Node GetOrCreateNode(string id, string type, Dictionary <string, Node> nodeDictionary) { string key = NodeDependencyLookupUtility.GetNodeKey(id, type); if (!nodeDictionary.ContainsKey(key)) { nodeDictionary.Add(key, new Node { Id = id, Type = type }); } return(nodeDictionary[key]); }
private HashSet <string> GetChangedAssetIdsForResolver(IAssetDependencyResolver resolver, string[] pathes, long[] timestamps, FileToAssetNode[] fileToAssetNodes) { HashSet <string> result = new HashSet <string>(); Dictionary <string, FileToAssetNode> list = RelationLookup.RelationLookupBuilder.ConvertToDictionary(fileToAssetNodes); string id = resolver.GetId(); string progressBarTitle = $"AssetDependencyCache: {id}"; float lastDisplayedPercentage = 0; for (int i = 0; i < pathes.Length; ++i) { float progressPercentage = (float)i / pathes.Length; if (progressPercentage - lastDisplayedPercentage > 0.01f) { EditorUtility.DisplayProgressBar(progressBarTitle, $"Finding changed assets {result.Count}", (float)i / pathes.Length); lastDisplayedPercentage = progressPercentage; } string path = pathes[i]; string guid = AssetDatabase.AssetPathToGUID(path); if (!resolver.IsGuidValid(guid)) { continue; } if (list.ContainsKey(guid)) { FileToAssetNode fileToAssetNode = list[guid]; foreach (AssetNode assetNode in fileToAssetNode.AssetNodes) { assetNode.Existing = true; } if (fileToAssetNode.GetResolverTimeStamp(id).TimeStamp != timestamps[i]) { NodeDependencyLookupUtility.AddAssetsToList(result, path); } } else { NodeDependencyLookupUtility.AddAssetsToList(result, path); } } return(result); }
public override Result GetDependency(Type objType, object obj, SerializedProperty property, string propertyPath, SerializedPropertyType type, Stack <PathSegment> stack) { if (type != SerializedPropertyType.ObjectReference) { return(null); } var value = property.objectReferenceValue; if (value == null) { return(null); } string assetPath = AssetDatabase.GetAssetPath(value); if (string.IsNullOrEmpty(assetPath)) { return(null); } if (ExcludedProperties.Contains(propertyPath)) { return(null); } if (ExcludedDependencies.Contains(Path.GetFileName(assetPath))) { return(null); } string assetId = NodeDependencyLookupUtility.GetAssetIdForAsset(value); string guid = NodeDependencyLookupUtility.GetGuidFromAssetId(assetId); if (!(guid.StartsWith("0000000") || value is ScriptableObject || AssetDatabase.IsSubAsset(value) || AssetDatabase.IsMainAsset(value))) { return(null); } return(new Result { Id = assetId, ConnectionType = ConnectionType, NodeType = NodeType }); }
public void Search() { for (int i = 0; i < 128; ++i) { ReflectionStack[i] = new ReflectionStackItem(); } foreach (var pair in m_assetIdToResolver) { Object asset = NodeDependencyLookupUtility.GetAssetById(pair.Key); if (asset == null) { continue; } Progress.IncreaseProgress(); Progress.UpdateProgress("SerializedPropertySearcher", asset.name); Traverse(pair.Key, NodeDependencyLookupUtility.GetAssetById(pair.Key), new Stack <PathSegment>()); } }
private HashSet <string> GetChangedAssetIds(string[] pathes, long[] timestamps, FileToAssetsMapping[] fileToAssetMappings) { HashSet <string> result = new HashSet <string>(); Dictionary <string, FileToAssetsMapping> list = RelationLookup.RelationLookupBuilder.ConvertToDictionary(fileToAssetMappings); float lastDisplayedPercentage = 0; for (int i = 0; i < pathes.Length; ++i) { float progressPercentage = (float)i / pathes.Length; if (progressPercentage - lastDisplayedPercentage > 0.01f) { EditorUtility.DisplayProgressBar("AssetToFileDependencyCache", $"Finding changed assets {result.Count}", (float)i / pathes.Length); lastDisplayedPercentage = progressPercentage; } string path = pathes[i]; string guid = AssetDatabase.AssetPathToGUID(path); if (list.ContainsKey(guid)) { FileToAssetsMapping fileToAssetsMapping = list[guid]; fileToAssetsMapping.SetExisting(); long timeStamp = timestamps[i]; if (fileToAssetsMapping.Timestamp != timeStamp) { NodeDependencyLookupUtility.AddAssetsToList(result, path); } } else { NodeDependencyLookupUtility.AddAssetsToList(result, path); } } return(result); }
private FileToAssetNode[] GetDependenciesForAssets(FileToAssetNode[] fileToAssetNodes, CreatedDependencyCache createdDependencyCache, ProgressBase progress) { string[] pathes = NodeDependencyLookupUtility.GetAllAssetPathes(progress, true); long[] timestamps = NodeDependencyLookupUtility.GetTimeStampsForFiles(pathes); List <AssetResolverData> data = new List <AssetResolverData>(); _hierarchyTraverser.Clear(); foreach (CreatedResolver resolverUsage in createdDependencyCache.ResolverUsages) { if (!(resolverUsage.Resolver is IAssetDependencyResolver)) { continue; } IAssetDependencyResolver resolver = (IAssetDependencyResolver)resolverUsage.Resolver; HashSet <string> changedAssets = GetChangedAssetIdsForResolver(resolver, pathes, timestamps, _fileToAssetNodes); data.Add(new AssetResolverData { ChangedAssets = changedAssets, Resolver = resolver }); resolver.Initialize(this, changedAssets, progress); } // Execute the searcher for all registered subsystems here to find hierarchy and property pathes _hierarchyTraverser.Initialize(progress); _hierarchyTraverser.Search(); Dictionary <string, FileToAssetNode> nodeDict = RelationLookup.RelationLookupBuilder.ConvertToDictionary(fileToAssetNodes); foreach (AssetResolverData resolverData in data) { GetDependenciesForAssetsInResolver(resolverData.ChangedAssets, resolverData.Resolver as IAssetDependencyResolver, nodeDict, progress); } return(nodeDict.Values.ToArray()); }
public void UpdateFromDefinition(ResolverUsageDefinitionList definitionList) { ResetCacheUsages(); foreach (ResolverUsageDefinitionList.Entry entry in definitionList.CacheUsages) { string cacheTypeFullName = entry.CacheType.FullName; if (!CreatedCaches.ContainsKey(cacheTypeFullName)) { IDependencyCache cache = NodeDependencyLookupUtility.InstantiateClass <IDependencyCache>(entry.CacheType); CreatedDependencyCache createdCache = new CreatedDependencyCache(cache); CreatedCaches.Add(cacheTypeFullName, createdCache); } CreatedCaches[cacheTypeFullName].AddResolver(entry.ResolverType, entry.ConnectionTypes); } ConnectionTypeLookup = new ConnectionTypeLookup(GetCaches()); NodeHandlerLookup = NodeDependencyLookupUtility.BuildNodeHandlerLookup(); }
public void AddResolver(Type resolverType, List <string> connectionTypes) { string resolverTypeFullName = resolverType.FullName; if (!CreatedResolvers.ContainsKey(resolverTypeFullName)) { IDependencyResolver dependencyResolver = NodeDependencyLookupUtility.InstantiateClass <IDependencyResolver>(resolverType); CreatedResolver resolver = new CreatedResolver(dependencyResolver); CreatedResolvers.Add(resolverTypeFullName, resolver); } CreatedResolver createdResolver = CreatedResolvers[resolverTypeFullName]; string[] collection = connectionTypes != null?connectionTypes.ToArray() : createdResolver.Resolver.GetConnectionTypes(); createdResolver.ConnectionTypes = new HashSet <string>(collection); ResolverUsages.Add(createdResolver); ResolverUsagesLookup.Add(createdResolver.Resolver.GetId(), createdResolver); createdResolver.IsActive = true; }
private void GetDependenciesForAssetsInResolver(HashSet <string> changedAssets, IAssetToFileDependencyResolver resolver, Dictionary <string, FileToAssetsMapping> resultList, ProgressBase progress) { foreach (string assetId in changedAssets) { string fileId = NodeDependencyLookupUtility.GetGuidFromAssetId(assetId); if (!resultList.ContainsKey(fileId)) { resultList.Add(fileId, new FileToAssetsMapping { FileId = fileId }); } FileToAssetsMapping fileToAssetsMapping = resultList[fileId]; FileToAssetMappingNode fileToAssetMappingNode = fileToAssetsMapping.GetFileNode(assetId); fileToAssetMappingNode.Dependencies.Clear(); resolver.GetDependenciesForId(assetId, fileToAssetMappingNode.Dependencies); fileToAssetsMapping.Timestamp = NodeDependencyLookupUtility.GetTimeStampForFileId(fileId); } }
public bool NeedsUpdate(ProgressBase progress) { string[] assetIds = NodeDependencyLookupUtility.GetAllAssetPathes(progress, true); long[] timeStampsForFiles = NodeDependencyLookupUtility.GetTimeStampsForFiles(assetIds); foreach (CreatedResolver resolverUsage in _createdDependencyCache.ResolverUsages) { IAssetDependencyResolver assetDependencyResolver = resolverUsage.Resolver as IAssetDependencyResolver; assetDependencyResolver.SetValidGUIDs(); } foreach (CreatedResolver resolverUsage in _createdDependencyCache.ResolverUsages) { IAssetDependencyResolver assetDependencyResolver = resolverUsage.Resolver as IAssetDependencyResolver; if (CheckNeedsUpdateForResolver(assetDependencyResolver, assetIds, timeStampsForFiles, _fileToAssetNodes)) { return(true); } } return(false); }
public int GetOwnFileSize(string id, string type, NodeDependencyLookupContext stateContext) { return(NodeDependencyLookupUtility.GetPackedAssetSize(id)); }