private static void ValidateASG(Model.NodeData node, AssetGroupStructures expected, AssetGroupStructures actual)
{
AssertNode(node, expected.incoming.Count, actual.incoming.Count, "Incoming data count is changed.");
for (int i = 0; i < actual.incoming.Count; ++i)
{
var sExpected = expected.incoming[i];
var sActual = actual.incoming[i];
AssertNode(node, sExpected.groups.Count, sActual.groups.Count, "Group count is changed.");
AssertNode(node, sExpected.connectionId, sActual.connectionId, "ConnectionId is changed.");
for (int j = 0; j < sExpected.groups.Count; ++j)
{
var gExpected = sExpected.groups[j];
var gActual = sActual.groups[j];
AssertNode(node, gExpected.name, gActual.name, "Group name is changed.");
AssertNode(node, gExpected.entires.Count, gActual.entires.Count, "Group entry count is changed for " + gExpected.name);
for (int k = 0; k < gExpected.entires.Count; ++k)
{
var eExpected = gExpected.entires[k];
var eActual = gActual.entires[k];
AssertNode(node, eExpected.importFrom, eActual.importFrom, "Asset path is changed.");
AssertNode(node, eExpected.assetType, eActual.assetType, "Asset type is changed for " + eExpected.importFrom);
AssertNode(node, eExpected.importerType, eActual.importerType, "Importer type is changed for " + eExpected.importFrom);
}
}
}
}
/**
* Prepare is called whenever graph needs update.
*/
public override void Prepare(BuildTarget target,
Model.NodeData node,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output Output)
{
if (incoming != null)
{
m_current = CreateASG(incoming);
}
// Pass incoming assets straight to Output
if (Output != null)
{
var destination = (connectionsToOutput == null || !connectionsToOutput.Any())?
null : connectionsToOutput.First();
if (incoming != null)
{
foreach (var ag in incoming)
{
Output(destination, ag.assetGroups);
}
}
else
{
// Overwrite output with empty Dictionary when there is no incoming asset
Output(destination, new Dictionary <string, List <AssetReference> >());
}
}
}
private static AssetGroupStructures CreateASG(IEnumerable <PerformGraph.AssetGroups> incoming)
{
var asg = new AssetGroupStructures();
foreach (var g in incoming)
{
var s = new AssetGroupStructures.Structure(g.connection.Id);
asg.incoming.Add(s);
foreach (var key in g.assetGroups.Keys)
{
var group = new AssetGroupStructures.Group(key);
s.groups.Add(group);
foreach (var a in g.assetGroups[key])
{
group.entires.Add(new AssetGroupStructures.Entry(a.importFrom,
a.assetType == null ? string.Empty: a.assetType.FullName,
a.importerType == null ? string.Empty: a.importerType.FullName));
}
group.entires.Sort((x, y) => EditorUtility.NaturalCompare(x.importFrom, y.importFrom));
}
s.groups.Sort((x, y) => EditorUtility.NaturalCompare(x.name, y.name));
}
asg.incoming.Sort((x, y) => EditorUtility.NaturalCompare(x.connectionId, y.connectionId));
return(asg);
}
/**
* Build is called when Unity builds assets with AssetBundle Graph.
*/
public override void Build(BuildTarget target,
Model.NodeData nodeData,
IEnumerable <PerformGraph.AssetGroups> incoming,
IEnumerable <Model.ConnectionData> connectionsToOutput,
PerformGraph.Output outputFunc,
Action <Model.NodeData, string, float> progressFunc)
{
if (incoming != null)
{
AssetGroupStructures expected = null;
if (!string.IsNullOrEmpty(m_result[target]))
{
expected = JsonUtility.FromJson <AssetGroupStructures>(m_result[target]);
}
if (expected == null)
{
throw new NodeException("Retrieving reference data failed.", "Please recreate regression reference data from Inspector.", nodeData);
}
m_current = CreateASG(incoming);
ValidateASG(nodeData, expected, m_current);
}
}
