Fixed cross shader types connections

src/PixiEditor.ChangeableDocument/Changeables/Graph/FuncInputProperty.cs

@@ -48,8 +48,12 @@ public class FuncInputProperty<T> : InputProperty<Func<FuncContext, T>>, IFuncIn
             ConversionTable.TryConvert(delegateToCast.DynamicInvoke(f), targetType, out var result);
             if (isShaderExpression)
             {
-                var toReturn = Activator.CreateInstance(typeof(T), ""); 
-                ((ShaderExpressionVariable)toReturn).SetConstantValue(result, ConversionTable.Convert);
+                var toReturn = Activator.CreateInstance(typeof(T), "");
+                if (result != null)
+                {
+                    ((ShaderExpressionVariable)toReturn).SetConstantValue(result, ConversionTable.Convert);
+                }
+
                 return (T)toReturn;
             }
             

src/PixiEditor.ChangeableDocument/Changeables/Graph/Nodes/CombineSeparate/SeparateVecINode.cs

@@ -1,5 +1,6 @@
 using PixiEditor.ChangeableDocument.Rendering;
 using PixiEditor.DrawingApi.Core;
+using PixiEditor.DrawingApi.Core.Shaders.Generation.Expressions;
 using PixiEditor.Numerics;
 
 namespace PixiEditor.ChangeableDocument.Changeables.Graph.Nodes.CombineSeparate;
@@ -7,19 +8,19 @@ namespace PixiEditor.ChangeableDocument.Changeables.Graph.Nodes.CombineSeparate;
 [NodeInfo("SeparateVecI")]
 public class SeparateVecINode : Node
 {
-    public FuncInputProperty<VecI> Vector { get; }
+    public FuncInputProperty<Int2> Vector { get; }
     
-    public FuncOutputProperty<int> X { get; }
+    public FuncOutputProperty<Int1> X { get; }
     
-    public FuncOutputProperty<int> Y { get; }
+    public FuncOutputProperty<Int1> Y { get; }
     
     public override string DisplayName { get; set; } = "SEPARATE_VECI_NODE";
 
     public SeparateVecINode()
     {
-        X = CreateFuncOutput("X", "X", ctx => Vector.Value(ctx).X);
-        Y = CreateFuncOutput("Y", "Y", ctx => Vector.Value(ctx).Y);
-        Vector = CreateFuncInput("Vector", "VECTOR", new VecI(0, 0));
+        X = CreateFuncOutput<Int1>("X", "X", ctx => Vector.Value(ctx).X);
+        Y = CreateFuncOutput<Int1>("Y", "Y", ctx => Vector.Value(ctx).Y);
+        Vector = CreateFuncInput<Int2>("Vector", "VECTOR", new VecI(0, 0));
     }
 
     protected override Texture? OnExecute(RenderingContext context)

src/PixiEditor.ChangeableDocument/Changeables/Graph/Nodes/ModifyImageRightNode.cs

@@ -80,7 +80,7 @@ public class ModifyImageRightNode : Node, IPairNodeEnd
             if (Coordinate.Connection != null)
             {
                 var coordinate = Coordinate.Value(context);
-                if (string.IsNullOrEmpty(coordinate.UniformName))
+                if (string.IsNullOrEmpty(coordinate.VariableName))
                 {
                     builder.SetConstant(context.Position, coordinate);
                 }
@@ -92,8 +92,8 @@ public class ModifyImageRightNode : Node, IPairNodeEnd
             else
             {
                 var constCoords = Coordinate.NonOverridenValue(FuncContext.NoContext);
-                constCoords.UniformName = "constCords";
-                builder.AddUniform(constCoords.UniformName, constCoords.ConstantValue);
+                constCoords.VariableName = "constCords";
+                builder.AddUniform(constCoords.VariableName, constCoords.ConstantValue);
                 builder.Set(context.Position, constCoords);
             }
 
@@ -104,8 +104,8 @@ public class ModifyImageRightNode : Node, IPairNodeEnd
             else
             {
                 Half4 color = Color.NonOverridenValue(FuncContext.NoContext);
-                color.UniformName = "color";
-                builder.AddUniform(color.UniformName, color.ConstantValue);
+                color.VariableName = "color";
+                builder.AddUniform(color.VariableName, color.ConstantValue);
                 builder.ReturnVar(color);
             }
 

src/PixiEditor.ChangeableDocument/Changes/NodeGraph/ConnectProperties_Change.cs

@@ -2,6 +2,7 @@
 using PixiEditor.ChangeableDocument.Changeables.Graph.Interfaces;
 using PixiEditor.ChangeableDocument.Changeables.Graph.Nodes;
 using PixiEditor.ChangeableDocument.ChangeInfos.NodeGraph;
+using PixiEditor.DrawingApi.Core.Shaders.Generation;
 
 namespace PixiEditor.ChangeableDocument.Changes.NodeGraph;
 
@@ -40,9 +41,9 @@ internal class ConnectProperties_Change : Change
         {
             return false;
         }
-        
+
         bool canConnect = CheckTypeCompatibility(inputProp, outputProp);
-        
+
         if (!canConnect)
         {
             return false;
@@ -53,7 +54,8 @@ internal class ConnectProperties_Change : Change
         return true;
     }
 
-    public override OneOf<None, IChangeInfo, List<IChangeInfo>> Apply(Document target, bool firstApply, out bool ignoreInUndo)
+    public override OneOf<None, IChangeInfo, List<IChangeInfo>> Apply(Document target, bool firstApply,
+        out bool ignoreInUndo)
     {
         Node inputNode = target.FindNode(InputNodeId);
         Node outputNode = target.FindNode(OutputNodeId);
@@ -77,16 +79,13 @@ internal class ConnectProperties_Change : Change
         OutputProperty outputProp = outputNode.GetOutputProperty(OutputProperty);
 
         outputProp.DisconnectFrom(inputProp);
-        
+
         ConnectProperty_ChangeInfo change = new(null, InputNodeId, null, InputProperty);
-        
+
         inputProp.Connection = originalConnection;
 
-        List<IChangeInfo> changes = new()
-        {
-            change,
-        };
-        
+        List<IChangeInfo> changes = new() { change, };
+
         if (originalConnection != null)
         {
             ConnectProperty_ChangeInfo oldConnection = new(originalConnection.Node.Id, InputNodeId,
@@ -97,12 +96,17 @@ internal class ConnectProperties_Change : Change
 
         return changes;
     }
-    
+
     private static bool CheckTypeCompatibility(InputProperty input, OutputProperty output)
     {
         if (input.ValueType != output.ValueType)
         {
-            if(ConversionTable.TryConvert(output.Value, input.ValueType, out _))
+            if (IsCrossExpression(output.Value, input.ValueType))
+            {
+                return true;
+            }
+
+            if (ConversionTable.TryConvert(output.Value, input.ValueType, out _))
             {
                 return true;
             }
@@ -112,4 +116,14 @@ internal class ConnectProperties_Change : Change
 
         return true;
     }
+
+    private static bool IsCrossExpression(object first, Type secondType)
+    {
+        if (first is Delegate func && func.Method.ReturnType.IsAssignableTo(typeof(ShaderExpressionVariable)))
+        {
+            return secondType.IsAssignableTo(typeof(Delegate));
+        }
+        
+        return false;
+    }
 }

src/PixiEditor.ChangeableDocument/Changes/NodeGraph/ConversionTable.cs

@@ -51,11 +51,6 @@ public static class ConversionTable
         {
             try
             {
-                if (IsCrossExpression(func.Method, targetType))
-                {
-                    //TODO
-                }
-
                 var actualArg = func.DynamicInvoke(FuncContext.NoContext);
                 return TryConvert(actualArg, targetType, out result);
             }
@@ -105,12 +100,6 @@ public static class ConversionTable
 
         throw new InvalidCastException($"Cannot convert {arg.GetType()} to {targetType}");
     }
-    
-    private static bool IsCrossExpression(MethodInfo method, Type targetType)
-    {
-        return method.ReturnType.IsAssignableTo(typeof(ShaderExpressionVariable))
-               && targetType.IsAssignableTo(typeof(Delegate));
-    }
 
     private static int DoubleToInt(double d)
     {

src/PixiEditor.DrawingApi.Core/Shaders/Generation/Expressions/Float2.cs

@@ -18,7 +18,7 @@ public class Float2(string name) : ShaderExpressionVariable<VecD>(name)
     {
         get
         {
-            return new Float1($"{UniformName}.x") { ConstantValue = ConstantValue.X };
+            return new Float1($"{VariableName}.x") { ConstantValue = ConstantValue.X };
         }
     }
     
@@ -26,7 +26,7 @@ public class Float2(string name) : ShaderExpressionVariable<VecD>(name)
     {
         get
         {
-            return new Float1($"{UniformName}.y") { ConstantValue = ConstantValue.Y };
+            return new Float1($"{VariableName}.y") { ConstantValue = ConstantValue.Y };
         }
     }
     

src/PixiEditor.DrawingApi.Core/Shaders/Generation/Expressions/Half4.cs

@@ -6,10 +6,10 @@ public class Half4(string name) : ShaderExpressionVariable<Color>(name)
 {
     public override string ConstantValueString => $"half4({ConstantValue.R}, {ConstantValue.G}, {ConstantValue.B}, {ConstantValue.A})";
     
-    public Float1 R => new Float1($"{UniformName}.r") { ConstantValue = ConstantValue.R };
-    public Float1 G => new Float1($"{UniformName}.g") { ConstantValue = ConstantValue.G };
-    public Float1 B => new Float1($"{UniformName}.b") { ConstantValue = ConstantValue.B };
-    public Float1 A => new Float1($"{UniformName}.a") { ConstantValue = ConstantValue.A };
+    public Float1 R => new Float1($"{VariableName}.r") { ConstantValue = ConstantValue.R };
+    public Float1 G => new Float1($"{VariableName}.g") { ConstantValue = ConstantValue.G };
+    public Float1 B => new Float1($"{VariableName}.b") { ConstantValue = ConstantValue.B };
+    public Float1 A => new Float1($"{VariableName}.a") { ConstantValue = ConstantValue.A };
     
     public static implicit operator Half4(Color value) => new Half4("") { ConstantValue = value };
     public static explicit operator Color(Half4 value) => value.ConstantValue;

src/PixiEditor.DrawingApi.Core/Shaders/Generation/Expressions/Int2.cs

@@ -5,7 +5,17 @@ namespace PixiEditor.DrawingApi.Core.Shaders.Generation.Expressions;
 public class Int2(string name) : ShaderExpressionVariable<VecI>(name)
 {
     public override string ConstantValueString => $"int2({ConstantValue.X}, {ConstantValue.Y})";
-    
+
+    public Int1 X
+    {
+        get => new Int1($"{VariableName}.x");
+    }
+
+    public Int1 Y
+    {
+        get => new Int1($"{VariableName}.y");
+    }
+
     public static implicit operator Int2(VecI value) => new Int2("") { ConstantValue = value };
     public static explicit operator VecI(Int2 value) => value.ConstantValue;
 }

src/PixiEditor.DrawingApi.Core/Shaders/Generation/ShaderBuilder.cs

@@ -63,13 +63,13 @@ public class ShaderBuilder
         string resultName = $"color_{GetUniqueNameNumber()}";
         Half4 result = new Half4(resultName);
         _variables.Add(result);
-        _bodyBuilder.AppendLine($"half4 {resultName} = sample({texName.UniformName}, {pos.UniformName});");
+        _bodyBuilder.AppendLine($"half4 {resultName} = sample({texName.VariableName}, {pos.VariableName});");
         return result;
     }
 
     public void ReturnVar(Half4 colorValue)
     {
-        _bodyBuilder.AppendLine($"return {colorValue.UniformName};");
+        _bodyBuilder.AppendLine($"return {colorValue.VariableName};");
     }
 
     public void ReturnConst(Half4 colorValue)
@@ -94,17 +94,17 @@ public class ShaderBuilder
 
     public void Set<T>(T contextPosition, T coordinateValue) where T : ShaderExpressionVariable
     {
-        if (contextPosition.UniformName == coordinateValue.UniformName)
+        if (contextPosition.VariableName == coordinateValue.VariableName)
         {
             return;
         }
 
-        _bodyBuilder.AppendLine($"{contextPosition.UniformName} = {coordinateValue.UniformName};");
+        _bodyBuilder.AppendLine($"{contextPosition.VariableName} = {coordinateValue.VariableName};");
     }
 
     public void SetConstant<T>(T contextPosition, T constantValueVar) where T : ShaderExpressionVariable
     {
-        _bodyBuilder.AppendLine($"{contextPosition.UniformName} = {constantValueVar.ConstantValueString};");
+        _bodyBuilder.AppendLine($"{contextPosition.VariableName} = {constantValueVar.ConstantValueString};");
     }
 
     public Float2 ConstructFloat2(Expression x, Expression y)

src/PixiEditor.DrawingApi.Core/Shaders/Generation/ShaderExpressionVariable.cs

@@ -5,12 +5,12 @@ namespace PixiEditor.DrawingApi.Core.Shaders.Generation;
 
 public abstract class ShaderExpressionVariable(string name) : Expression
 {
-    public string UniformName { get; set; } = name;
+    public string VariableName { get; set; } = name;
     public abstract string ConstantValueString { get; }
 
     public override string ToString()
     {
-        return UniformName;
+        return VariableName;
     }
 
     public override string ExpressionValue => VarOrConst();
@@ -19,7 +19,7 @@ public abstract class ShaderExpressionVariable(string name) : Expression
     
     public string VarOrConst()
     {
-        return string.IsNullOrEmpty(UniformName) ? ConstantValueString : UniformName;
+        return string.IsNullOrEmpty(VariableName) ? ConstantValueString : VariableName;
     }
 }