An editor-side JSON upgrader for ShaderGraphPlus that migrates shader graph parameter data to version 10, adding parameter grouping and converting legacy parameter and node arrays into new structures including group metadata and parameter ordering.
using System.Text.Json.Nodes;
namespace ShaderGraphPlus;
file struct ParameterEntry : IValid
{
public BlackboardParameter Parameter { get; internal set; }
public GroupData GroupData { get; internal set; }
public int OrderInRoot { get; internal set; }
public bool Grouped { get; internal set; }
public Guid LegacyGroupReference { get; internal set; }
public bool IsValid => Parameter != null;
public ParameterEntry( BlackboardParameter parameter, int orderInRoot, bool grouped, Guid legacyGroupReference )
{
Parameter = parameter;
OrderInRoot = orderInRoot;
Grouped = grouped;
LegacyGroupReference = legacyGroupReference;
}
public ParameterEntry( GroupData groupData, int orderInRoot, bool grouped )
{
Parameter = null;
GroupData = groupData;
OrderInRoot = orderInRoot;
Grouped = grouped;
LegacyGroupReference = Guid.Empty;
}
}
file struct GroupDataEntry
{
public GroupData GroupData { get; set; }
public int Priority { get; set; }
public GroupDataEntry( GroupData groupData, int priority )
{
GroupData = groupData;
Priority = priority;
}
}
public partial class ShaderGraphPlus
{
/// <summary>
/// Changes : <br/>
/// - Add parameter grouping.
/// </summary>
[SGPJsonUpgrader( typeof( ShaderGraphPlus ), 10 )]
internal static void Upgrader_v10( JsonObject obj )
{
var groups = new Dictionary<string, GroupDataEntry>();
var updatedParameters = new List<ParameterEntry>();
var registeredCategoryNames = new List<string>();
static int GetUIGroupOrder( JsonNode node, string uiKeyName )
{
if ( node[uiKeyName] is not JsonNode uiNode )
return -1;
if ( uiNode["Priority"] is JsonValue priorityValue )
{
return priorityValue.GetValue<int>();
}
return -1;
}
static UIGroup GetUIGroup( JsonNode node, string uiKeyName )
{
if ( node[uiKeyName] is not JsonNode uiNode )
return default;
if ( uiNode["PrimaryGroup"] is JsonNode primaryGroupNode )
{
return JsonSerializer.Deserialize<UIGroup>( primaryGroupNode, SerializerOptions() );
}
return default;
}
void AddToGroup( BlackboardParameter parameter, int parameterPriorityInGroup, UIGroup primaryGroup )
{
if ( !string.IsNullOrWhiteSpace( primaryGroup.Name ) )
{
Guid legacyGroupReference = Guid.Empty;
if ( !registeredCategoryNames.Contains( primaryGroup.Name ) )
{
var newGroupData = new GroupData
{
Name = $"{primaryGroup.Name}"
};
newGroupData.ParameterReferences.Add( parameter.Identifier );
if ( parameter is IGroupableBlackboardParameter groupableParameter )
{
groupableParameter.Group = newGroupData.Name;
}
if ( !groups.ContainsKey( newGroupData.Name ) )
{
groups.Add( newGroupData.Name, new( newGroupData, primaryGroup.Priority ) );
}
legacyGroupReference = newGroupData.Identifier;
registeredCategoryNames.Add( primaryGroup.Name );
}
else
{
if ( groups.TryGetValue( primaryGroup.Name, out var existingEntry ) )
{
if ( !existingEntry.GroupData.ParameterReferences.Contains( parameter.Identifier ) )
{
existingEntry.GroupData.ParameterReferences.Add( parameter.Identifier );
}
groups[primaryGroup.Name] = existingEntry;
if ( parameter is IGroupableBlackboardParameter groupableParameter )
{
groupableParameter.Group = existingEntry.GroupData.Name;
}
legacyGroupReference = existingEntry.GroupData.Identifier;
}
}
if ( !updatedParameters.Any( x => x.Parameter.Name == parameter.Name ) )
{
updatedParameters.Add( new ParameterEntry( parameter, 0, true, legacyGroupReference ) );
}
}
else
{
if ( !updatedParameters.Any( x => x.Parameter.Name == parameter.Name ) )
{
// Shove all non-grouped parameters after the grouped parameters.
updatedParameters.Add( new ParameterEntry( parameter, updatedParameters.Count(), false, Guid.Empty ) );
}
}
}
if ( obj[JsonKeys.ParameterArray] is not JsonArray oldParameterArray )
throw new Exception( $"Cannot find jsonArray \'{JsonKeys.ParameterArray}\'" );
if ( obj[JsonKeys.NodeArray] is not JsonArray oldNodeArray )
throw new Exception( $"Cannot find jsonArray \'{JsonKeys.NodeArray}\'" );
var isSubgraph = CheckIfSubgraph( obj );
//
// Upgrade Parameters
//
var newParameterArray = new JsonArray();
foreach ( var jsonNode in oldParameterArray )
{
if ( jsonNode[JsonKeys.Class] is not JsonValue classValue )
continue;
var typeName = classValue.GetValue<string>();
var typeDesc = EditorTypeLibrary.GetType<BlackboardParameter>( typeName );
var type = new ClassBlackboardParameterType( typeDesc );
var newParameterObj = jsonNode.DeepClone().AsObject();
BlackboardParameter parameter = null;
if ( typeDesc != null )
{
parameter = EditorTypeLibrary.Create<BlackboardParameter>( typeName );
DeserializeObject( parameter, JsonSerializer.Deserialize<JsonElement>( jsonNode ), SerializerOptions() );
if ( !typeDesc.TargetType.IsAssignableTo( typeof( IBlackboardSubgraphParameter ) ) && typeDesc.TargetType.IsAssignableTo( typeof( IGroupableBlackboardParameter ) ) )
{
var parameterPriorityInGroup = 0;
var primaryGroup = new UIGroup();
if ( typeDesc.TargetType.IsAssignableTo( typeof( IBlackboardMaterialParameter ) ) )
{
parameterPriorityInGroup = GetUIGroupOrder( jsonNode, "UI" );
primaryGroup = GetUIGroup( jsonNode, "UI" );
}
else if ( typeDesc.TargetType.IsAssignableTo( typeof( BlackboardTextureMaterialParameter ) ) )
{
parameterPriorityInGroup = GetUIGroupOrder( jsonNode, "Value" );
primaryGroup = GetUIGroup( jsonNode, "Value" );
}
if ( parameterPriorityInGroup == -1 )
{
parameterPriorityInGroup = 0;
}
AddToGroup( parameter, parameterPriorityInGroup, primaryGroup );
}
else
{
var portOrder = 0;
if ( jsonNode["PortOrder"] is JsonValue portOrderValue )
{
portOrder = portOrderValue.GetValue<int>();
}
updatedParameters.Add( new ParameterEntry( parameter, portOrder, false, Guid.Empty ) );
}
}
}
foreach ( var parameter in updatedParameters.OrderBy( x => x.OrderInRoot ) )
{
var parameterType = parameter.Parameter.GetType();
var parameterObject = new JsonObject { { JsonKeys.Class, parameterType.Name }, { "GroupReference", parameter.LegacyGroupReference } };
SerializeObject( parameter.Parameter, parameterObject, SerializerOptions() );
newParameterArray.Add( parameterObject );
}
obj.Remove( JsonKeys.ParameterArray );
obj.Add( JsonKeys.ParameterArray, newParameterArray );
var legacyCategoryDataArray = new JsonArray();
// Sort the categories
var sortedGroups = groups.Values.OrderBy( x => x.Priority ).ToList();
for ( int i = 0; i < sortedGroups.Count; i++ )
{
sortedGroups[i] = sortedGroups[i] with { Priority = i };
}
foreach ( var sortedGroup in sortedGroups )
{
var type = sortedGroup.GetType();
var groupDataObject = new JsonObject { { JsonKeys.Class, type.Name } };
SerializeObject( sortedGroup, groupDataObject, SerializerOptions() );
legacyCategoryDataArray.Add( groupDataObject );
}
obj.Add( JsonKeys.OldGroupDataArray, legacyCategoryDataArray );
}
}