public override bool OnAssetsReimported(
Model.NodeData nodeData,
AssetReferenceStreamManager streamManager,
BuildTarget target,
AssetPostprocessorContext ctx,
bool isBuilding)
{
var samplingDirectoryPath = FileUtility.PathCombine(Model.Settings.Path.SavedSettingsPath, "ImportSettings", nodeData.Id);
foreach (var importedAsset in ctx.ImportedAssets)
{
if (importedAsset.importFrom.StartsWith(samplingDirectoryPath))
{
return(true);
}
// Test this later
// if (m_customSettingAssetGuid != null) {
// if(imported.StartsWith(AssetDatabase.GUIDToAssetPath(m_customSettingAssetGuid))) {
// return true;
// }
// }
}
return(false);
}
private void DoPostprocessWithContext(AssetPostprocessorContext ctx)
{
m_contexts.Push(ctx);
NotifyAssetPostprocessorGraphs(ctx);
AssetGraphEditorWindow.NotifyAssetsReimportedToAllWindows(ctx);
m_contexts.Pop();
}
public void OnAssetsReimported(AssetPostprocessorContext ctx)
{
// ignore asset reimport event during build
if (m_isBuilding)
{
return;
}
if (m_targetGraph.Nodes == null)
{
return;
}
bool isAnyNodeAffected = false;
foreach (var n in m_targetGraph.Nodes)
{
bool affected = n.Operation.Object.OnAssetsReimported(n, m_streamManager, m_lastTarget, ctx, false);
if (affected)
{
n.NeedsRevisit = true;
}
isAnyNodeAffected |= affected;
}
if (isAnyNodeAffected)
{
Perform(m_lastTarget, false, false, false, null);
}
}
/// <summary>
/// OnAssetsReimported() is called when there are changes of assets during editing graph.
/// </summary>
/// <param name="nodeData">NodeGUI instance for this node.</param>
/// <param name="streamManager">Manager instance to retrieve graph's incoming/outgoing group.</param>
/// <param name="target">Target platform.</param>
/// <param name="ctx">Reimport context.</param>
public virtual bool OnAssetsReimported(
Model.NodeData nodeData,
AssetReferenceStreamManager streamManager,
BuildTarget target,
AssetPostprocessorContext ctx,
bool isBuilding)
{
return(false);
}
public override bool OnAssetsReimported(
Model.NodeData nodeData,
AssetReferenceStreamManager streamManager,
BuildTarget target,
AssetPostprocessorContext ctx,
bool isBuilding)
{
if (isBuilding && !m_respondToAssetChange)
{
return(false);
}
CheckAndCorrectPath(target);
var loadPath = GetLoadPath(target);
foreach (var asset in ctx.ImportedAssets)
{
if (asset.importFrom.StartsWith(loadPath))
{
return(true);
}
}
foreach (var asset in ctx.MovedAssets)
{
if (asset.importFrom.StartsWith(loadPath))
{
return(true);
}
}
foreach (var path in ctx.MovedFromAssetPaths)
{
if (path.StartsWith(loadPath))
{
return(true);
}
}
foreach (var path in ctx.DeletedAssetPaths)
{
if (path.StartsWith(loadPath))
{
return(true);
}
}
return(false);
}
public override bool OnAssetsReimported(
Model.NodeData nodeData,
AssetReferenceStreamManager streamManager,
BuildTarget target,
AssetPostprocessorContext ctx,
bool isBuilding)
{
if (isBuilding && !m_respondToAssetChange)
{
return(false);
}
if (m_searchFilter == null)
{
return(false);
}
var cond = m_searchFilter[target];
var guids = AssetDatabase.FindAssets(cond);
if (guids.Length == 0)
{
return(false);
}
List <string> reimportedAssetGuids = new List <string> ();
foreach (var a in ctx.ImportedAssets)
{
reimportedAssetGuids.Add(a.assetDatabaseId);
}
foreach (var a in ctx.MovedAssets)
{
reimportedAssetGuids.Add(a.assetDatabaseId);
}
foreach (var guid in guids)
{
if (reimportedAssetGuids.Contains(guid))
{
return(true);
}
}
return(false);
}
public override bool OnAssetsReimported(
Model.NodeData nodeData,
AssetReferenceStreamManager streamManager,
BuildTarget target,
AssetPostprocessorContext ctx,
bool isBuilding)
{
if (m_lastImportedAssets == null)
{
m_lastImportedAssets = new List <AssetReference> ();
}
m_lastImportedAssets.Clear();
m_lastImportedAssets.AddRange(ctx.ImportedAssets);
m_lastImportedAssets.AddRange(ctx.MovedAssets);
return(true);
}
private void HandleAllAssets(string[] importedAssets,
string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
{
for (int i = 0; i < movedFromAssetPaths.Length; i++)
{
if (movedFromAssetPaths[i] == DataModel.Version2.Settings.Path.BasePath)
{
DataModel.Version2.Settings.Path.ResetBasePath(movedAssets[i]);
}
}
foreach (string str in importedAssets)
{
AssetReferenceDatabase.GetReference(str).InvalidateTypeCache();
}
foreach (string str in deletedAssets)
{
AssetReferenceDatabase.DeleteReference(str);
}
for (int i = 0; i < movedAssets.Length; i++)
{
AssetReferenceDatabase.MoveReference(movedFromAssetPaths[i], movedAssets[i]);
}
var ctx = new AssetPostprocessorContext(importedAssets, deletedAssets, movedAssets, movedFromAssetPaths, m_contexts);
if (!ctx.HasValidAssetToPostprocess())
{
return;
}
// if modification happens inside graph, record it.
if (m_controllers.Count > 0)
{
m_ppQueue.Enqueue(ctx);
return;
}
DoPostprocessWithContext(ctx);
}
public void AddModifiedAsset(AssetReference a)
{
AssetPostprocessorContext ctx = null;
if (m_contexts.Count == 0)
{
ctx = new AssetPostprocessorContext();
m_contexts.Push(ctx);
}
else
{
ctx = m_contexts.Peek();
}
if (!ctx.ImportedAssets.Contains(a))
{
ctx.ImportedAssets.Add(a);
}
AssetProcessEventRecord.GetRecord().LogModify(a.assetDatabaseId);
}
public void PushContext(AssetPostprocessorContext c)
{
m_contexts.Push(c);
}
private void NotifyAssetPostprocessorGraphs(AssetPostprocessorContext ctx)
{
var guids = AssetDatabase.FindAssets(Model.Settings.GRAPH_SEARCH_CONDITION);
var executingGraphs = new List <Model.ConfigGraph> ();
foreach (var guid in guids)
{
string path = AssetDatabase.GUIDToAssetPath(guid);
var graph = AssetDatabase.LoadAssetAtPath <Model.ConfigGraph>(path);
if (graph != null && graph.UseAsAssetPostprocessor)
{
bool isAnyNodeAffected = false;
foreach (var n in graph.Nodes)
{
isAnyNodeAffected |= n.Operation.Object.OnAssetsReimported(n, null, EditorUserBuildSettings.activeBuildTarget, ctx, true);
}
if (isAnyNodeAffected)
{
executingGraphs.Add(graph);
}
}
}
if (executingGraphs.Count > 0)
{
if (executingGraphs.Count > 1)
{
executingGraphs.Sort((l, r) => l.ExecuteOrderPriority - r.ExecuteOrderPriority);
}
float currentCount = 0f;
float totalCount = (float)executingGraphs.Sum(g => g.Nodes.Count);
Model.NodeData lastNode = null;
float graphStartTime = Time.realtimeSinceStartup;
bool progressbarDisplayed = false;
float progressBarShowDelaySec = 0.3f;
Action <Model.NodeData, string, float> updateHandler = (node, message, progress) => {
if (lastNode != node)
{
// do not add count on first node visit to
// calcurate percantage correctly
if (lastNode != null)
{
++currentCount;
}
lastNode = node;
if (!progressbarDisplayed)
{
if (Time.realtimeSinceStartup - graphStartTime > progressBarShowDelaySec)
{
progressbarDisplayed = true;
}
}
}
if (progressbarDisplayed)
{
var graphName = GetCurrentGraphController().TargetGraph.GetGraphName();
float currentNodeProgress = progress * (1.0f / totalCount);
float currentTotalProgress = (currentCount / totalCount) + currentNodeProgress;
string title = string.Format("Building {2}[{0}/{1}]", currentCount, totalCount, graphName);
string info = $"Processing {node.Name}:{message}";
EditorUtility.DisplayProgressBar(title, info, currentTotalProgress);
}
};
foreach (var g in executingGraphs)
{
AssetGraphUtility.ExecuteGraph(g, false, updateHandler);
}
if (progressbarDisplayed)
{
EditorUtility.ClearProgressBar();
}
AssetDatabase.Refresh();
}
}
