public void update(AssetUpdate data, int workers, Ref <float> progress, ILog log)
{
process(
data, workers,
pathToGuid: pathToGuid, parents: parents, children: children,
progress: progress, log: log
);
}
static void initTasks()
{
enabledSubscription = enabled.subscribe(NoOpDisposableTracker.instance, b => {
if (b)
{
refsOpt = Option <AssetReferences> .None;
processFiles(AssetUpdate.fromAllAssets(AssetDatabase.GetAllAssetPaths().ToImmutableList()));
}
});
}
public static AssetReferences a(
AssetUpdate data, int workers, Ref <float> progress, ILog log
)
{
var refs = new AssetReferences();
process(
data, workers,
pathToGuid: refs.pathToGuid, parents: refs.parents, children: refs.children,
progress: progress, log: log
);
return(refs);
}
static void process(AssetUpdate data, ILog log)
{
try {
processing = true;
needsRepaint = true;
refsOpt.voidFold(
() => refsOpt = AssetReferences.a(data, Environment.ProcessorCount, progress, log).some(),
refs => refs.update(data, Environment.ProcessorCount, progress, log)
);
}
finally {
processing = false;
}
}
public static void processFiles(AssetUpdate data)
{
if (!enabled.value)
{
return;
}
var log = Log.@default;
worker.EnqueueItem(() => {
try {
process(data, log);
}
catch (Exception e) {
log.error(e);
}
});
}
static void OnPostprocessAllAssets(
string[] importedAssets, string[] deletedAssets, string[] movedAssets,
string[] movedFromAssetPaths
)
{
if (!AssetReferencesWindow.enabled.value)
{
return;
}
var data = new AssetUpdate(
importedAssets.ToImmutableList(),
deletedAssets.ToImmutableList(),
movedFromAssetPaths.zip(movedAssets).Select(t => new AssetUpdate.Move(t._1, t._2)).ToImmutableList()
);
AssetReferencesWindow.processFiles(data);
}
static void process(
AssetUpdate data, int workers,
Dictionary <string, string> pathToGuid,
Dictionary <string, HashSet <string> > parents,
Dictionary <string, HashSet <string> > children,
Ref <float> progress, ILog log
)
{
progress.value = 0;
Func <string, bool> predicate = p =>
p.EndsWithFast(".asset") ||
p.EndsWithFast(".prefab") ||
p.EndsWithFast(".unity") ||
p.EndsWithFast(".mat");
var assets = data.filter(predicate, _ => predicate(_.fromPath));
var firstScan = children.isEmpty() && parents.isEmpty();
var updatedChildren =
firstScan
? children
: new Dictionary <string, HashSet <string> >();
var progressIdx = 0;
Action updateProgress = () => progress.value = (float)progressIdx / assets.totalAssets;
var addedPool = new PCQueue(workers);
foreach (var added in assets.newAssets)
{
updateProgress();
addedPool.EnqueueItem(() => {
parseFile(pathToGuid, log, added, updatedChildren);
lock (data) {
progressIdx++;
updateProgress();
}
});
}
// Block until parallel part is done.
addedPool.Shutdown(waitForWorkers: true);
foreach (var deleted in assets.deletedAssets)
{
updateProgress();
if (pathToGuid.ContainsKey(deleted))
{
updatedChildren.getOrUpdate(pathToGuid[deleted], () => new HashSet <string>());
pathToGuid.Remove(deleted);
}
progressIdx++;
}
foreach (var moved in assets.movedAssets)
{
updateProgress();
foreach (var guid in pathToGuid.getAndRemove(moved.fromPath))
{
pathToGuid[moved.toPath] = guid;
}
progressIdx++;
}
updateProgress();
if (!firstScan)
{
foreach (var parent in updatedChildren.Keys)
{
if (children.ContainsKey(parent))
{
var set = children[parent];
foreach (var child in set)
{
parents[child].Remove(parent);
}
children.Remove(parent);
}
}
}
addParents(parents, updatedChildren);
if (!firstScan)
{
foreach (var kv in updatedChildren)
{
if (kv.Value.Count > 0)
{
children.Add(kv.Key, kv.Value);
}
}
}
}
