Editor/ShaderGraphPlus/Nodes/Channel.cs

Editor shader graph node implementations for channel operations. Defines ComponentMask, SplitVector, CombineVector, SwizzleVector, and AppendVector nodes that build HLSL expressions for masking, splitting, combining, swizzling and appending vector components in the shader graph editor.

Reflection
namespace ShaderGraphPlus.Nodes;

public enum SwizzleChannel
{
	Red = 0,
	Green = 1,
	Blue = 2,
	Alpha = 3,
}

[Title( "Component Mask" ), Category( "Channel" ), Icon( "theater_comedy" )]
public sealed class ComponentMask : ShaderNodePlus
{
	[JsonIgnore, Hide, Browsable( false )]
	public override Color NodeTitleColor => ShaderGraphPlusTheme.NodeHeaderColors.ChannelNode;

	[Hide]
	public override string Title
	{
		get
		{
			List<string> components = new List<string>();

			if ( R && _showR ) components.Add( "R" );
			if ( G && _showG ) components.Add( "G" );
			if ( B && _showB ) components.Add( "B" );
			if ( A && _showA ) components.Add( "A" );

			var suffix = components.Count > 0 ? $"{string.Join( " ", components )}" : "";

			return !string.IsNullOrWhiteSpace( suffix ) ? $"{DisplayInfo.For( this ).Name} ( {suffix} )" : DisplayInfo.For( this ).Name;
		}
	}

	[Input, Hide]
	public NodeInput Input { get; set; }

	[ShowIf( nameof( _showR ), true )]
	public bool R { get; set; } = true;

	[ShowIf( nameof( _showG ), true )]
	public bool G { get; set; } = true;

	[ShowIf( nameof( _showB ), true )]
	public bool B { get; set; } = true;

	[ShowIf( nameof( _showA ), true )]
	public bool A { get; set; } = true;

	[Hide, JsonIgnore]
	private bool _showR = false;
	[Hide, JsonIgnore]
	private bool _showG = false;
	[Hide, JsonIgnore]
	private bool _showB = false;
	[Hide, JsonIgnore]
	private bool _showA = false;

	[Output, Hide]
	public NodeResult.Func Result => ( GraphCompiler compiler ) =>
	{
		var result = compiler.Result( Input );

		if ( !result.IsValid )
		{
			(_showR, _showG, _showB, _showA) = (true, true, true, true);

			return new NodeResult( ResultType.Float, "0.0f" );
		}
		else
		{

			if ( result.ResultType != ResultType.Float && result.ResultType != ResultType.Vector2 &&
				result.ResultType != ResultType.Vector3 && result.ResultType != ResultType.Vector4 )
			{
				HasError = true;
				return NodeResult.Error( $"Cannot mask ResultType \"{result.ResultType}\"" );
			}

			HasError = false;

			var resultType = ResultType.Float;
			var components = string.Empty;

			switch ( result.Components )
			{
				case 1:
					(_showR, _showG, _showB, _showA) = (false, false, false, false);

					break;
				case 2:
					(_showR, _showG, _showB, _showA) = (true, true, false, false);

					if ( R ) components += "x";
					if ( G ) components += "y";
					break;

				case 3:
					(_showR, _showG, _showB, _showA) = (true, true, true, false);

					if ( R ) components += "x";
					if ( G ) components += "y";
					if ( B ) components += "z";
					break;

				case 4:
					(_showR, _showG, _showB, _showA) = (true, true, true, true);

					if ( R ) components += "x";
					if ( G ) components += "y";
					if ( B ) components += "z";
					if ( A ) components += "w";
					break;
			}

			// result.ResultType was a float. So there is nothing to Mask.
			if ( result.ResultType == ResultType.Float )
			{
				return new NodeResult( ResultType.Float, $"{result}" );
			}

			//if ( components == string.Empty )
			//{
			//	return new NodeResult( ResultType.Float, "0.0f" );
			//}

			if ( components.Length == 1 ) resultType = ResultType.Float;
			if ( components.Length == 2 ) resultType = ResultType.Vector2;
			if ( components.Length == 3 ) resultType = ResultType.Vector3;
			if ( components.Length == 4 ) resultType = ResultType.Vector4;

			return new NodeResult( resultType, $"{result}.{components}" );
		}
	};
}

/// <summary>
/// Split value into individual components
/// </summary>
[Title( "Split" ), Category( "Channel" ), Icon( "call_split" )]
public sealed class SplitVector : ShaderNodePlus
{
	[JsonIgnore, Hide, Browsable( false )]
	public override Color NodeTitleColor => ShaderGraphPlusTheme.NodeHeaderColors.ChannelNode;

	[Input, Hide]
	public NodeInput Input { get; set; }

	[Output( typeof( float ) ), Hide]
	public NodeResult.Func X => ( GraphCompiler compiler ) =>
	{
		var result = compiler.Result( Input );
		if ( result.IsValid && result.Components > 0 ) return new NodeResult( ResultType.Float, $"{result}.x" );
		return new NodeResult( ResultType.Float, "0.0f" );
	};

	[Output( typeof( float ) ), Hide]
	public NodeResult.Func Y => ( GraphCompiler compiler ) =>
	{
		var result = compiler.Result( Input );
		if ( result.IsValid && result.Components > 1 ) return new NodeResult( ResultType.Float, $"{result}.y" );
		return new NodeResult( ResultType.Float, "0.0f" );
	};

	[Output( typeof( float ) ), Hide]
	public NodeResult.Func Z => ( GraphCompiler compiler ) =>
	{
		var result = compiler.Result( Input );
		if ( result.IsValid && result.Components > 2 ) return new NodeResult( ResultType.Float, $"{result}.z" );
		return new NodeResult( ResultType.Float, "0.0f" );
	};

	[Output( typeof( float ) ), Hide]
	public NodeResult.Func W => ( GraphCompiler compiler ) =>
	{
		var result = compiler.Result( Input );
		if ( result.IsValid && result.Components > 3 ) return new NodeResult( ResultType.Float, $"{result}.w" );
		return new NodeResult( ResultType.Float, "0.0f" );
	};
}

/// <summary>
/// Combine input values into 3 separate vectors
/// </summary>
[Title( "Combine" ), Category( "Channel" ), Icon( "call_merge" )]
public sealed class CombineVector : ShaderNodePlus
{
	[JsonIgnore, Hide, Browsable( false )]
	public override Color NodeTitleColor => ShaderGraphPlusTheme.NodeHeaderColors.ChannelNode;

	[Input( typeof( float ) )]
	[Hide]
	public NodeInput X { get; set; }

	[Input( typeof( float ) )]
	[Hide]
	public NodeInput Y { get; set; }

	[Input( typeof( float ) )]
	[Hide]
	public NodeInput Z { get; set; }

	[Input( typeof( float ) )]
	[Hide]
	public NodeInput W { get; set; }

	public float DefaultX { get; set; } = 0.0f;
	public float DefaultY { get; set; } = 0.0f;
	public float DefaultZ { get; set; } = 0.0f;
	public float DefaultW { get; set; } = 0.0f;

	[Output( typeof( Vector4 ) )]
	[Hide]
	public NodeResult.Func XYZW => ( GraphCompiler compiler ) =>
	{
		var x = compiler.ResultOrDefault( X, DefaultX ).Cast( 1 );
		var y = compiler.ResultOrDefault( Y, DefaultY ).Cast( 1 );
		var z = compiler.ResultOrDefault( Z, DefaultZ ).Cast( 1 );
		var w = compiler.ResultOrDefault( W, DefaultW ).Cast( 1 );

		return new NodeResult( ResultType.Vector4, $"float4( {x}, {y}, {z}, {w} )" );
	};

	[Output( typeof( Vector3 ) )]
	[Hide]
	public NodeResult.Func XYZ => ( GraphCompiler compiler ) =>
	{
		var x = compiler.ResultOrDefault( X, DefaultX ).Cast( 1 );
		var y = compiler.ResultOrDefault( Y, DefaultY ).Cast( 1 );
		var z = compiler.ResultOrDefault( Z, DefaultZ ).Cast( 1 );

		return new NodeResult( ResultType.Vector3, $"float3( {x}, {y}, {z} )" );
	};

	[Output( typeof( Vector2 ) )]
	[Hide]
	public NodeResult.Func XY => ( GraphCompiler compiler ) =>
	{
		var x = compiler.ResultOrDefault( X, DefaultX ).Cast( 1 );
		var y = compiler.ResultOrDefault( Y, DefaultY ).Cast( 1 );

		return new NodeResult( ResultType.Vector2, $"float2( {x}, {y})" );
	};
}

/// <summary>
/// Swap components of a color around
/// </summary>
[Title( "Swizzle" ), Category( "Channel" ), Icon( "swap_horiz" )]
public sealed class SwizzleVector : ShaderNodePlus
{
	[JsonIgnore, Hide, Browsable( false )]
	public override Color NodeTitleColor => ShaderGraphPlusTheme.NodeHeaderColors.ChannelNode;

	[Input( typeof( Vector4 ) ), Hide]
	public NodeInput Input { get; set; }

	[InputDefault( nameof( Input ) )]
	public Vector4 DefaultSwizzle { get; set; } = new Vector4( 1, 0, 1, 1 );

	public SwizzleChannel RedOut { get; set; } = SwizzleChannel.Red;
	public SwizzleChannel GreenOut { get; set; } = SwizzleChannel.Green;
	public SwizzleChannel BlueOut { get; set; } = SwizzleChannel.Blue;
	public SwizzleChannel AlphaOut { get; set; } = SwizzleChannel.Alpha;

	private static char SwizzleToChannel( SwizzleChannel channel )
	{
		return channel switch
		{
			SwizzleChannel.Green => 'y',
			SwizzleChannel.Blue => 'z',
			SwizzleChannel.Alpha => 'w',
			_ => 'x',
		};
	}

	[Output( typeof( Vector4 ) ), Hide]
	public NodeResult.Func Output => ( GraphCompiler compiler ) =>
	{
		var input = compiler.ResultOrDefault( Input, DefaultSwizzle );

		if ( !input.IsValid )
		{
			return NodeResult.MissingInput( nameof( Input ) );
		}

		var swizzle = $".";
		swizzle += SwizzleToChannel( RedOut );
		swizzle += SwizzleToChannel( GreenOut );
		swizzle += SwizzleToChannel( BlueOut );
		swizzle += SwizzleToChannel( AlphaOut );

		return new NodeResult( ResultType.Vector4, $"{input.Cast( 4 )}{swizzle}" );
	};
}

/// <summary>
/// Append constants to change number of channels
/// </summary>
[Title( "Append" ), Category( "Channel" ), Icon( "control_point" )]
public sealed class AppendVector : ShaderNodePlus
{
	[JsonIgnore, Hide, Browsable( false )]
	public override Color NodeTitleColor => ShaderGraphPlusTheme.NodeHeaderColors.ChannelNode;

	[Input, Hide]
	public NodeInput A { get; set; }

	[Input, Hide]
	public NodeInput B { get; set; }

	[Output, Hide]
	public NodeResult.Func Output => ( GraphCompiler compiler ) =>
	{
		var resultA = compiler.ResultOrDefault( A, 0.0f );
		var resultB = compiler.ResultOrDefault( B, 0.0f );

		var components = resultB.Components + resultA.Components;
		if ( components < 1 || components > 4 )
			return NodeResult.Error( $"Can't append {resultB.TypeName} to {resultA.TypeName}" );

		ResultType resultType = components switch
		{
			2 => ResultType.Vector2,
			3 => ResultType.Vector3,
			4 => ResultType.Vector4,
			_ => throw new NotImplementedException(),
		};

		return new NodeResult( resultType, $"float{components}( {resultA}, {resultB} )" );
	};
}