Editor/ShaderGraphPlus/ShaderGraphPlus.cs

Editor asset class for a shader graph editor. Defines enums and the ShaderGraphPlus graph type with node/parameter/group management, serialization hooks, validation of shader type capabilities, and helper methods for unique naming and ordering. Also declares a subgraph asset type.

File Access
using Editor;
using ShaderGraphPlus.Internal.JsonConvert;
using ShaderGraphPlus.Nodes;

using static Editor.SceneViewportWidget;
using static ShaderGraphPlus.ShaderGraphPlusGlobals;
using static ShaderGraphPlus.ShaderTemplate;

namespace ShaderGraphPlus;

public enum BlendMode
{
	[Icon( "circle" )]
	Opaque,
	[Icon( "radio_button_unchecked" )]
	Masked,
	[Icon( "blur_on" )]
	Translucent,
	/*
	[Icon( "tune" )]
	Dynamic,
	*/
}

public enum ShadingModel
{
	/// <summary>
	/// Default Valve lighting model
	/// </summary>
	[Icon( "tungsten" )]
	Lit,
	/// <summary>
	/// No Lighting model
	/// </summary>
	[Icon( "brightness_3" )]
	Unlit,
}

public enum ShaderDomain
{
	[Icon( "view_in_ar" )]
	Surface,
	[Icon( "nights_stay" )]
	Sky,
	[Icon( "desktop_windows" )]
	PostProcess,
}

public enum RenderFace
{
	/// <summary>
	/// Render only the front faces
	/// </summary>
	[Icon( "visibility" )]
	Front,
	/// <summary>
	/// Render only the back faces
	/// </summary>
	[Icon( "visibility_off" )]
	Back,
	/// <summary>
	/// Render both the front and back faces
	/// </summary>
	[Icon( "visibility_off" )]
	Both,
}

public class PreviewSettings
{
	/// <summary>
	/// Current viewmode of the preview veiwport
	/// </summary>
	public ViewMode ViewMode { get; set; } = ViewMode.Perspective;

	public bool RenderBackfaces { get; set; } = false;

	/// <summary>
	/// If true we'll render shadows
	/// </summary>
	public bool EnableShadows { get; set; } = true;

	/// <summary>
	/// If true we'll show the ground plane
	/// </summary>
	public bool ShowGround { get; set; } = false;

	/// <summary>
	/// If true we'll show the shybox
	/// </summary>
	public bool ShowSkybox { get; set; } = true;

	/// <summary>
	/// Color of the background when the skybox is not being drawn
	/// </summary>
	public Color BackgroundColor { get; set; } = Color.Black;

	/// <summary>
	/// Color tint of the model in the preview
	/// </summary>
	public Color Tint { get; set; } = Color.White;
}

[JsonConverter( typeof( ShaderGraphPlusConverter ) )]
[AssetType( Name = ShaderGraphPlusGlobals.AssetTypeName, Extension = ShaderGraphPlusGlobals.AssetTypeExtension, Flags = AssetTypeFlags.NoEmbedding ), Icon( "account_tree" )]
public partial class ShaderGraphPlus : IBlackboardNodeGraph
{
	[Hide]
	public int Version => 12;

	[Hide, JsonIgnore]
	public IEnumerable<BaseNodePlus> Nodes => _nodes.Values;

	[Hide, JsonIgnore]
	private readonly Dictionary<string, BaseNodePlus> _nodes = new();

	[Hide, JsonIgnore]
	IEnumerable<IGraphNode> INodeGraph.Nodes => Nodes;

	[Hide, JsonIgnore]
	public IEnumerable<BlackboardParameter> Parameters => _parameters.Values;

	[Hide, JsonIgnore]
	private readonly OrderedDictionary<Guid, BlackboardParameter> _parameters = new();

	[Hide, JsonIgnore]
	IEnumerable<IBlackboardParameter> IBlackboardNodeGraph.Parameters => Parameters;

	[Hide, JsonIgnore]
	public IEnumerable<GroupData> GroupData => _groupData.Values;

	[Hide, JsonIgnore]
	private readonly OrderedDictionary<Guid, GroupData> _groupData = new();

	[Hide]
	public bool IsSubgraph { get; set; }

	[Hide]
	public string Path { get; set; }

	[Hide]
	public string Model { get; set; }

	/// <summary>
	/// The name of the Node when used in ShaderGraph or when graph is not a subgraph the asset name
	/// </summary>
	[ShowIf( nameof( IsSubgraph ), true )]
	public string Title { get; set; }

	public string Description { get; set; }

	/// <summary>
	/// The category of the Node when browsing the Node Library (optional)
	/// </summary>
	[ShowIf( nameof( AddToNodeLibrary ), true )]
	public string Category { get; set; }

	[IconName, ShowIf( nameof( IsSubgraph ), true )]
	public string Icon { get; set; }

	/// <summary>
	/// Whether or not this Node should appear when browsing the Node Library.
	/// Otherwise can only be referenced by dragging the Subgraph asset into the graph.
	/// </summary>
	[ShowIf( nameof( IsSubgraph ), true )]
	public bool AddToNodeLibrary { get; set; }

	[Hide]
	public bool HasTemplate => !string.IsNullOrWhiteSpace( ShaderType ) && ShaderType.EndsWith( ShaderGraphPlusGlobals.ShaderTemplateAssetTypeExtension );

	[Hide]
	public bool HasNoTemplate => !HasTemplate;

	[Hide]
	private bool ShowShadingModel => Domain == ShaderDomain.Surface && HasNoTemplate;

	[Hide]
	private bool ShowRenderFace => Domain == ShaderDomain.Surface && (ShaderTypeInfo.HasSupport( SupportsAllRenderFace ));

	[Hide]
	private bool ShowBlendMode => Domain == ShaderDomain.Surface;

	[Editor( ControlWidgetCustomEditors.ShaderTypeDropdownEditor )]
	public string ShaderType { get; set; } = ShaderTemplateSurface.ShaderTypeInfo.Title;

	[Hide]
	public ShaderDomain Domain => ShaderTypeInfo.IsValid ? ShaderTypeInfo.Domian : ShaderDomain.Surface;

	[ShowIf( nameof( ShowBlendMode ), true )]
	public BlendMode BlendMode { get; set; }

	[ShowIf( nameof( ShowShadingModel ), true )]
	public ShadingModel ShadingModel { get; set; }

	[ShowIf( nameof( ShowRenderFace ), true )]
	public RenderFace RenderFace { get; set; }

	[Hide]
	public PreviewSettings PreviewSettings { get; set; } = new();

	[Hide, JsonIgnore]
	public ShaderTypeInfo ShaderTypeInfo { get; set; } = new();

	public ShaderGraphPlus()
	{
	}

	/// <summary>
	/// Validates settings to what is supported by the current <see cref="ShaderTypeInfo"/>
	/// </summary>
	public void ValidateShaderTypeInfo()
	{
		// Auto-correct BlendMode if current is not supported
		bool currentBlendModeSupported = BlendMode switch
		{
			BlendMode.Opaque => ShaderTypeInfo.HasSupport( SupportsOpaqueBlend ),
			BlendMode.Masked => ShaderTypeInfo.HasSupport( SupportsMaskedBlend ),
			BlendMode.Translucent => ShaderTypeInfo.HasSupport( SupportsTranslucentBlend ),
			_ => false
		};

		if ( !currentBlendModeSupported )
		{
			if ( !ShaderTypeInfo.HasSupport( SupportsOpaqueBlend ) && !ShaderTypeInfo.HasSupport( SupportsMaskedBlend ) && !ShaderTypeInfo.HasSupport( SupportsTranslucentBlend ) )
			{
				BlendMode = BlendMode.Opaque; // Fallback to Opaque blend mode.
			}
			else
			{
				// Find the first supported blend mode
				if ( ShaderTypeInfo.HasSupport( SupportsOpaqueBlend ) ) BlendMode = BlendMode.Opaque;
				else if ( ShaderTypeInfo.HasSupport( SupportsMaskedBlend ) ) BlendMode = BlendMode.Masked;
				else if ( ShaderTypeInfo.HasSupport( SupportsTranslucentBlend ) ) BlendMode = BlendMode.Translucent;
			}
		}

		// Auto-correct ShadingModel if current is not supported
		bool currentShadingModelSupported = ShadingModel switch
		{
			ShadingModel.Lit => ShaderTypeInfo.HasSupport( SupportsLitShading ),
			ShadingModel.Unlit => ShaderTypeInfo.HasSupport( SupportsUnlitShading ),
			_ => false
		};

		if ( !currentShadingModelSupported )
		{
			// Find the first supported shading model
			if ( ShaderTypeInfo.HasSupport( SupportsLitShading ) ) ShadingModel = ShadingModel.Lit;
			else if ( ShaderTypeInfo.HasSupport( SupportsUnlitShading ) ) ShadingModel = ShadingModel.Unlit;
		}

		if ( HasTemplate )
		{
			if ( !ShaderTypeInfo.HasSupport( SupportsAllRenderFace ) )
			{
				// Ensure template culling mode
				if ( ShaderTypeInfo.HasSupport( SupportsRenderFaceFront ) )
				{
					RenderFace = RenderFace.Front;
				}
				else if ( ShaderTypeInfo.HasSupport( SupportsRenderFaceBack ) )
				{
					RenderFace = RenderFace.Back;
				}
				else if ( ShaderTypeInfo.HasSupport( SupportsRenderFaceBoth ) )
				{
					RenderFace = RenderFace.Both;
				}
				else
				{
					RenderFace = RenderFace.Front; // Fallback to backface culling.
				}
			}
		}
	}

	public bool ContainsNode( string id )
	{
		if ( _nodes.ContainsKey( id ) ) return true;
		return false;
	}

	public bool ContainsParameter( Guid id )
	{
		if ( _parameters.ContainsKey( id ) ) return true;
		return false;
	}

	public void AddNode( BaseNodePlus node )
	{
		node.Graph = this;
		_nodes.Add( node.Identifier, node );
	}

	public void AddParameter( IBlackboardParameter parameter )
	{
		AddParameter( (BlackboardParameter)parameter );
	}

	public void AddParameter( BlackboardParameter parameter, int index = -1 )
	{
		parameter.Graph = this;

		if ( index <= -1 )
		{
			_parameters.Add( parameter.Identifier, parameter );
		}
		else
		{
			_parameters.Insert( index, parameter.Identifier, parameter );
		}
	}

	public void AddGroupData( GroupData groupData, int index = -1 )
	{
		groupData.Graph = this;

		if ( index < -1 )
		{
			throw new IndexOutOfRangeException( $"Invalid Index '{index}' " );
		}

		if ( index != -1 )
		{
			if ( index > _groupData.Count )
			{
				_groupData.Add( groupData.Identifier, groupData );
			}
			else
			{
				_groupData.Insert( index, groupData.Identifier, groupData );
			}
		}
		else
		{
			_groupData.Add( groupData.Identifier, groupData );
		}
	}

	public void RemoveNode( BaseNodePlus node )
	{
		if ( node.Graph != this )
			return;

		//SGPLogger.Info( $"Removing node with id : {node.Identifier}");

		_nodes.Remove( node.Identifier );
	}

	public void RemoveParameter( BlackboardParameter parameter )
	{
		if ( parameter.Graph != this )
			return;

		RemoveParameter( parameter.Identifier );
	}

	public void RemoveParameter( Guid identifier )
	{
		_parameters.Remove( identifier );
	}

	public void RemoveGroupData( GroupData groupData )
	{
		if ( groupData.Graph != this )
			return;

		_groupData.Remove( groupData.Identifier );
	}

	public BaseNodePlus FindNode( string name )
	{
		_nodes.TryGetValue( name, out var node );
		return node;
	}

	public BlackboardParameter FindParameter( Guid identifier )
	{
		_parameters.TryGetValue( identifier, out var parameter );
		return parameter;
	}

	public BlackboardParameter FindParameter( string name )
	{
		var parameter = _parameters.Values.FirstOrDefault( x => x.Name == name );
		return parameter;
	}

	public bool HasParameterWithName( string name )
	{
		return _parameters.Any( x => string.Equals( x.Value.Name, name, StringComparison.CurrentCultureIgnoreCase ) );
	}

	public bool TryFindParameter( Guid identifier, out BlackboardParameter parameter )
	{
		return _parameters.TryGetValue( identifier, out parameter );
	}

	public bool TryFindParameter( string name, out BlackboardParameter parameter )
	{
		parameter = _parameters.Values.FirstOrDefault( x => x.Name == name );

		return parameter != null;
	}

	public T FindParameter<T>( Guid identifier ) where T : BlackboardParameter
	{
		_parameters.TryGetValue( identifier, out var parameter );
		return (T)parameter;
	}

	public T FindParameter<T>( string name ) where T : BlackboardParameter
	{
		var parameter = _parameters.Values.OfType<T>().FirstOrDefault( x => x.Name == name );
		return parameter;
	}

	public bool TryFindParameter<T>( Guid identifier, out T parameter ) where T : BlackboardParameter
	{
		parameter = FindParameter<T>( identifier );

		return parameter != null;
	}

	public bool TryFindParameter<T>( string name, out T parameter ) where T : BlackboardParameter
	{
		parameter = FindParameter<T>( name );

		return parameter != null;
	}

	public GroupData FindGroupData( string name )
	{
		var groupData = _groupData.FirstOrDefault( x => x.Value.Name.Equals( name, StringComparison.OrdinalIgnoreCase ) ).Value;

		return groupData ?? null;
	}

	public bool HasGroupDataWithName( string name )
	{
		return _groupData.Any( x => x.Value.Name.Equals( name, StringComparison.OrdinalIgnoreCase ) );
	}

	public bool TryFindGroupData( Guid identifier, out GroupData groupData )
	{
		groupData = null;

		if ( _groupData.TryGetValue( identifier, out var foundGroupData ) )
		{
			groupData = foundGroupData;

			return true;
		}

		return false;
	}

	public bool TryFindGroupData( string name, out GroupData groupData )
	{
		groupData = _groupData.FirstOrDefault( x => x.Value.Name.Equals( name, StringComparison.OrdinalIgnoreCase ) ).Value;

		return groupData != null;
	}

	public int GetParameterIndex( BlackboardParameter parameter )
	{
		var index = _parameters.IndexOf( parameter.Identifier );

		return index != -1 ? index : 0;
	}

	public int GetGroupDataIndex( string name )
	{
		var groupData = FindGroupData( name );
		var index = _groupData.IndexOf( groupData.Identifier );

		if ( index != -1 )
		{
			return index;
		}

		return 0;
	}

	public int GetGroupDataIndex( GroupData groupData )
	{
		var index = _groupData.IndexOf( groupData.Identifier );

		return index != -1 ? index : 0;
	}

	public int GetParameterIndexInGroup( string parameterGroupName, Guid parameterReference )
	{
		parameterGroupName = string.IsNullOrWhiteSpace( parameterGroupName ) ? "General" : parameterGroupName;

		if ( TryFindGroupData( parameterGroupName, out var groupData ) )
		{
			return groupData.ParameterReferences.IndexOf( parameterReference );
		}

		return 0;
	}

	/// <summary>
	/// A parameter name not taken yet - the name itself, or "name 1", "name 2"...
	/// </summary>
	public string UniqueParameterName( string baseName )
	{
		var names = Parameters.Select( p => p.Name )
			.ToHashSet( StringComparer.OrdinalIgnoreCase );

		if ( !names.Contains( baseName ) )
			return baseName;

		for ( var i = 1; ; i++ )
		{
			if ( !names.Contains( $"{baseName}{i}" ) )
				return $"{baseName}{i}";
		}
	}


	/// <summary>
	/// A group name not taken yet - the name itself, or "name 1", "name 2"...
	/// </summary>
	public string UniqueGroupName( string baseName )
	{
		var names = GroupData.Select( g => g.Name )
			.ToHashSet( StringComparer.OrdinalIgnoreCase );

		if ( !names.Contains( baseName ) )
			return baseName;

		for ( var i = 1; ; i++ )
		{
			if ( !names.Contains( $"{baseName}{i}" ) )
				return $"{baseName}{i}";
		}
	}

	public bool ReOrderParameter( Guid identifier, int newIndex )
	{
		if ( !TryFindParameter( identifier, out var parameter ) )
			return false;

		return ReOrderParameter( parameter, newIndex );
	}

	public bool ReOrderParameter( BlackboardParameter parameter, int newIndex )
	{
		if ( parameter.Graph != this )
			return false;

		if ( newIndex < -1 )
		{
			throw new IndexOutOfRangeException( $"Invalid newIndex '{newIndex}'" );
		}

		_parameters.Remove( parameter.Identifier );

		if ( newIndex > _parameters.Count )
		{
			_parameters.Add( parameter.Identifier, parameter );
		}
		else
		{
			_parameters.Insert( newIndex, parameter.Identifier, parameter );
		}

		return true;
	}

	public bool ReOrderGroup( string groupName, int newIndex )
	{
		return TryFindGroupData( groupName, out var group ) && ReOrderGroup( group, newIndex );
	}

	public bool ReOrderGroup( GroupData groupData, int newIndex )
	{
		if ( groupData.Graph != this )
		{
			SGPLogger.Error( $"Wrong Graph!!!" );
			return false;
		}

		if ( newIndex < -1 )
		{
			throw new IndexOutOfRangeException( $"Invalid newIndex '{newIndex}'" );
		}

		_groupData.Remove( groupData.Identifier );

		if ( newIndex > _groupData.Count )
		{
			_groupData.Add( groupData.Identifier, groupData );
		}
		else
		{
			_groupData.Insert( newIndex, groupData.Identifier, groupData );
		}

		return true;
	}

	public void UpdateParameter( IBlackboardParameter parameter )
	{
		var blackboardParameter = parameter as BlackboardParameter;
		if ( blackboardParameter.Graph != this )
			return;

		_parameters[parameter.Identifier] = blackboardParameter;
	}

	public void UpdateParameterValue( Guid identifier, object value )
	{
		if ( !_parameters.ContainsKey( identifier ) )
			throw new Exception( $"There is no parameter with the identifier : {identifier}" );

		_parameters[identifier].SetValue( value );
	}

	public void ClearNodes()
	{
		_nodes.Clear();
	}

	public void ClearParameters()
	{
		_parameters.Clear();
	}

	public void ClearGroupData()
	{
		_groupData.Clear();
	}

	string INodeGraph.SerializeNodes( IEnumerable<IGraphNode> nodes )
	{
		return SerializeNodes( nodes.Cast<BaseNodePlus>() );
	}

	IEnumerable<IGraphNode> INodeGraph.DeserializeNodes( string serialized )
	{
		return DeserializeNodes( serialized );
	}

	string IBlackboardNodeGraph.SerializeParameters( IEnumerable<IBlackboardParameter> parameters )
	{
		return SerializeParameters( parameters.Cast<BlackboardParameter>() );
	}

	IEnumerable<IBlackboardParameter> IBlackboardNodeGraph.DeserializeParameters( string serialized )
	{
		return DeserializeParameters( serialized );
	}

	void INodeGraph.AddNode( IGraphNode node )
	{
		AddNode( (BaseNodePlus)node );
	}

	void INodeGraph.RemoveNode( IGraphNode node )
	{
		RemoveNode( (BaseNodePlus)node );
	}

	void IBlackboardNodeGraph.AddParameter( IBlackboardParameter parameter )
	{
		AddParameter( (BlackboardParameter)parameter );
	}

	void IBlackboardNodeGraph.RemoveParameter( IBlackboardParameter parameter )
	{
		RemoveParameter( (BlackboardParameter)parameter );
	}

	IBlackboardParameter IBlackboardNodeGraph.FindParameter( Guid identifier )
	{
		return FindParameter( identifier );
	}

	internal NamedRerouteDeclarationNode FindNamedRerouteDeclarationNode( string name )
	{
		var node = Nodes.OfType<NamedRerouteDeclarationNode>().Where( x => x.Name == name ).FirstOrDefault();

		if ( node != null )
		{
			return node;
		}

		SGPLogger.Error( $"Could not find NamedReroute \"{name}\"" );

		return null;
	}
}

[AssetType( Name = ShaderGraphPlusGlobals.SubgraphAssetTypeName, Extension = ShaderGraphPlusGlobals.SubgraphAssetTypeExtension, Flags = AssetTypeFlags.NoEmbedding )]
public sealed partial class ShaderGraphPlusSubgraph : ShaderGraphPlus
{
}