[VFX] Fix ConstructMatrix serialization issue + add symetrical SplitMatrix operator

- Fixes https://jira.unity3d.com/browse/UUM-57915
- Add a settings to select between row and column
- Add symetrical operator SplitMatrix

Another possible way to have done it would have been through expandable slots but it lacks the row/colum selection and would have been a bit hacky as not handled directly by our system. A proxy struct would have been needed to do it right but it seems more involved/risky.

Here the solution chosen is consistent with how Shader Graph is doing it.

Author: julienf-unity

Packages/com.unity.visualeffectgraph/Editor/Expressions/VFXExpressionTransform.cs

@@ -465,22 +465,22 @@ public override string GetCodeString(string[] parents)
         }
     }
 
-    class VFXExpressionVector3sToMatrix : VFXExpression
+    class VFXExpressionRowToMatrix : VFXExpression
     {
-        public VFXExpressionVector3sToMatrix() : this(new VFXExpression[] { new VFXValue<Vector3>(Vector3.right), new VFXValue<Vector3>(Vector3.up), new VFXValue<Vector3>(Vector3.forward), VFXValue<Vector3>.Default }
+        public VFXExpressionRowToMatrix() : this(new VFXExpression[] { new VFXValue<Vector4>(new Vector4(1, 0, 0, 0)), new VFXValue<Vector4>(new Vector4(0, 1, 0, 0)), new VFXValue<Vector4>(new Vector4(0, 0, 1, 0)), new VFXValue<Vector4>(new Vector4(0, 0, 0, 1)) }
         )
         {
         }
 
-        public VFXExpressionVector3sToMatrix(params VFXExpression[] parents) : base(VFXExpression.Flags.None, parents)
+        public VFXExpressionRowToMatrix(params VFXExpression[] parents) : base(VFXExpression.Flags.None, parents)
         {
         }
 
         public override VFXExpressionOperation operation
         {
             get
             {
-                return VFXExpressionOperation.Vector3sToMatrix;
+                return VFXExpressionOperation.RowToMatrix;
             }
         }
 
@@ -491,42 +491,42 @@ sealed protected override VFXExpression Evaluate(VFXExpression[] constParents)
             var zReduce = constParents[2];
             var wReduce = constParents[3];
 
-            var x = xReduce.Get<Vector3>();
-            var y = yReduce.Get<Vector3>();
-            var z = zReduce.Get<Vector3>();
-            var w = wReduce.Get<Vector3>();
+            var x = xReduce.Get<Vector4>();
+            var y = yReduce.Get<Vector4>();
+            var z = zReduce.Get<Vector4>();
+            var w = wReduce.Get<Vector4>();
 
             Matrix4x4 matrix = new Matrix4x4();
-            matrix.SetColumn(0, new Vector4(x.x, x.y, x.z, 0.0f));
-            matrix.SetColumn(1, new Vector4(y.x, y.y, y.z, 0.0f));
-            matrix.SetColumn(2, new Vector4(z.x, z.y, z.z, 0.0f));
-            matrix.SetColumn(3, new Vector4(w.x, w.y, w.z, 1.0f));
+            matrix.SetRow(0, x);
+            matrix.SetRow(1, y);
+            matrix.SetRow(2, z);
+            matrix.SetRow(3, w);
 
             return VFXValue.Constant(matrix);
         }
 
         public override string GetCodeString(string[] parents)
         {
-            return string.Format("VFXCreateMatrixFromColumns(float4({0}, 0.0), float4({1}, 0.0), float4({2}, 0.0), float4({3}, 1.0));", parents[0], parents[1], parents[2], parents[3]);
+            return string.Format("VFXCreateMatrixFromRows({0}, {1}, {2}, {3});", parents[0], parents[1], parents[2], parents[3]);
         }
     }
 
-    class VFXExpressionVector4sToMatrix : VFXExpression
+    class VFXExpressionColumnToMatrix : VFXExpression
     {
-        public VFXExpressionVector4sToMatrix() : this(new VFXExpression[] { new VFXValue<Vector4>(new Vector4(1, 0, 0, 0)), new VFXValue<Vector4>(new Vector4(0, 1, 0, 0)), new VFXValue<Vector4>(new Vector4(0, 0, 1, 0)), new VFXValue<Vector4>(new Vector4(0, 0, 0, 1)) }
+        public VFXExpressionColumnToMatrix() : this(new VFXExpression[] { new VFXValue<Vector4>(new Vector4(1, 0, 0, 0)), new VFXValue<Vector4>(new Vector4(0, 1, 0, 0)), new VFXValue<Vector4>(new Vector4(0, 0, 1, 0)), new VFXValue<Vector4>(new Vector4(0, 0, 0, 1)) }
         )
         {
         }
 
-        public VFXExpressionVector4sToMatrix(params VFXExpression[] parents) : base(VFXExpression.Flags.None, parents)
+        public VFXExpressionColumnToMatrix(params VFXExpression[] parents) : base(VFXExpression.Flags.None, parents)
         {
         }
 
         public override VFXExpressionOperation operation
         {
             get
             {
-                return VFXExpressionOperation.Vector4sToMatrix;
+                return VFXExpressionOperation.ColumnToMatrix;
             }
         }
 
@@ -557,25 +557,80 @@ public override string GetCodeString(string[] parents)
         }
     }
 
-    class VFXExpressionMatrixToVector3s : VFXExpression
+    class VFXExpressionAxisToMatrix : VFXExpression
+    {
+        public VFXExpressionAxisToMatrix() : this(new VFXExpression[] { new VFXValue<Vector3>(Vector3.right), new VFXValue<Vector3>(Vector3.up), new VFXValue<Vector3>(Vector3.forward), VFXValue<Vector3>.Default }
+        )
+        {
+        }
+
+        public VFXExpressionAxisToMatrix(params VFXExpression[] parents) : base(VFXExpression.Flags.None, parents)
+        {
+        }
+
+        public override VFXExpressionOperation operation
+        {
+            get
+            {
+                return VFXExpressionOperation.AxisToMatrix;
+            }
+        }
+
+        sealed protected override VFXExpression Evaluate(VFXExpression[] constParents)
+        {
+            var xReduce = constParents[0];
+            var yReduce = constParents[1];
+            var zReduce = constParents[2];
+            var wReduce = constParents[3];
+
+            var x = xReduce.Get<Vector3>();
+            var y = yReduce.Get<Vector3>();
+            var z = zReduce.Get<Vector3>();
+            var w = wReduce.Get<Vector3>();
+
+            Matrix4x4 matrix = new Matrix4x4();
+            matrix.SetColumn(0, new Vector4(x.x, x.y, x.z, 0.0f));
+            matrix.SetColumn(1, new Vector4(y.x, y.y, y.z, 0.0f));
+            matrix.SetColumn(2, new Vector4(z.x, z.y, z.z, 0.0f));
+            matrix.SetColumn(3, new Vector4(w.x, w.y, w.z, 1.0f));
+
+            return VFXValue.Constant(matrix);
+        }
+
+        public override string GetCodeString(string[] parents)
+        {
+            return string.Format("VFXCreateMatrixFromColumns(float4({0}, 0.0), float4({1}, 0.0), float4({2}, 0.0), float4({3}, 1.0));", parents[0], parents[1], parents[2], parents[3]);
+        }
+    }
+
+    class VFXExpressionMatrixToRow : VFXExpression
     {
-        public VFXExpressionMatrixToVector3s() : this(new VFXExpression[] { VFXValue<Matrix4x4>.Default, VFXValue.Constant<int>(0) } // TODO row index should not be an expression!
+        public VFXExpressionMatrixToRow() : this(new VFXExpression[] { VFXValue<Matrix4x4>.Default, VFXValue.Constant<int>(0) }
         )
         {
         }
 
-        public VFXExpressionMatrixToVector3s(params VFXExpression[] parents) : base(VFXExpression.Flags.None, parents)
+        public VFXExpressionMatrixToRow(params VFXExpression[] parents) : base(VFXExpression.Flags.None, parents)
         {
         }
 
         public override VFXExpressionOperation operation
         {
             get
             {
-                return VFXExpressionOperation.MatrixToVector3s;
+                return VFXExpressionOperation.MatrixToRow;
             }
         }
 
+        protected sealed override VFXExpression Reduce(VFXExpression[] reducedParents)
+        {
+            var parent = reducedParents[0];
+            if (parent is VFXExpressionRowToMatrix && reducedParents[1].Is(Flags.Constant))
+                return parent.parents[reducedParents[1].Get<int>()];
+
+            return base.Reduce(reducedParents);
+        }
+
         sealed protected override VFXExpression Evaluate(VFXExpression[] constParents)
         {
             var matReduce = constParents[0];
@@ -584,34 +639,43 @@ sealed protected override VFXExpression Evaluate(VFXExpression[] constParents)
             var mat = matReduce.Get<Matrix4x4>();
             var axis = axisReduce.Get<int>();
 
-            return VFXValue.Constant<Vector3>(mat.GetColumn(axis));
+            return VFXValue.Constant(mat.GetRow(axis));
         }
 
         public override string GetCodeString(string[] parents)
         {
-            return string.Format("VFXGetColumnFromMatrix({0}, {1}).xyz", parents[0], parents[1]);
+            return string.Format("VFXGetRowFromMatrix({0}, {1})", parents[0], parents[1]);
         }
     }
 
-    class VFXExpressionMatrixToVector4s : VFXExpression
+    class VFXExpressionMatrixToColumn : VFXExpression
     {
-        public VFXExpressionMatrixToVector4s() : this(new VFXExpression[] { VFXValue<Matrix4x4>.Default, VFXValue.Constant<int>(0) } // TODO row index should not be an expression!
+        public VFXExpressionMatrixToColumn() : this(new VFXExpression[] { VFXValue<Matrix4x4>.Default, VFXValue.Constant<int>(0) }
         )
         {
         }
 
-        public VFXExpressionMatrixToVector4s(params VFXExpression[] parents) : base(VFXExpression.Flags.None, parents)
+        public VFXExpressionMatrixToColumn(params VFXExpression[] parents) : base(VFXExpression.Flags.None, parents)
         {
         }
 
         public override VFXExpressionOperation operation
         {
             get
             {
-                return VFXExpressionOperation.MatrixToVector4s;
+                return VFXExpressionOperation.MatrixToColumn;
             }
         }
 
+        protected sealed override VFXExpression Reduce(VFXExpression[] reducedParents)
+        {
+            var parent = reducedParents[0];
+            if (parent is VFXExpressionColumnToMatrix && reducedParents[1].Is(Flags.Constant))
+                return parent.parents[reducedParents[1].Get<int>()];
+
+            return base.Reduce(reducedParents);
+        }
+
         sealed protected override VFXExpression Evaluate(VFXExpression[] constParents)
         {
             var matReduce = constParents[0];
@@ -628,4 +692,50 @@ public override string GetCodeString(string[] parents)
             return string.Format("VFXGetColumnFromMatrix({0}, {1})", parents[0], parents[1]);
         }
     }
+
+    class VFXExpressionMatrixToAxis : VFXExpression
+    {
+        public VFXExpressionMatrixToAxis() : this(new VFXExpression[] { VFXValue<Matrix4x4>.Default, VFXValue.Constant<int>(0) }
+        )
+        {
+        }
+
+        public VFXExpressionMatrixToAxis(params VFXExpression[] parents) : base(VFXExpression.Flags.None, parents)
+        {
+        }
+
+        public override VFXExpressionOperation operation
+        {
+            get
+            {
+                return VFXExpressionOperation.MatrixToAxis;
+            }
+        }
+
+        protected sealed override VFXExpression Reduce(VFXExpression[] reducedParents)
+        {
+            var parent = reducedParents[0];
+            if (parent is VFXExpressionAxisToMatrix && reducedParents[1].Is(Flags.Constant))
+                return parent.parents[reducedParents[1].Get<int>()];
+
+            return base.Reduce(reducedParents);
+        }
+
+        sealed protected override VFXExpression Evaluate(VFXExpression[] constParents)
+        {
+            var matReduce = constParents[0];
+            var axisReduce = constParents[1];
+
+            var mat = matReduce.Get<Matrix4x4>();
+            var axis = axisReduce.Get<int>();
+
+            Vector4 c = mat.GetColumn(axis);
+            return VFXValue.Constant(new Vector3(c.x, c.y, c.z));
+        }
+
+        public override string GetCodeString(string[] parents)
+        {
+            return string.Format("VFXGetColumnFromMatrix({0}, {1}).xyz", parents[0], parents[1]);
+        }
+    }
 }

Packages/com.unity.visualeffectgraph/Editor/Models/Blocks/Implementations/Position/PositionMesh.cs

@@ -280,10 +280,10 @@ public override IEnumerable<VFXNamedExpression> parameters
                 {
                     var sourceTransform = sampling[0];
 
-                    var i = new VFXExpressionMatrixToVector3s(sourceTransform, VFXValue.Constant(0));
-                    var j = new VFXExpressionMatrixToVector3s(sourceTransform, VFXValue.Constant(1));
-                    var k = new VFXExpressionMatrixToVector3s(sourceTransform, VFXValue.Constant(2));
-                    var p = new VFXExpressionMatrixToVector3s(sourceTransform, VFXValue.Constant(3));
+                    var i = new VFXExpressionMatrixToAxis(sourceTransform, VFXValue.Constant(0));
+                    var j = new VFXExpressionMatrixToAxis(sourceTransform, VFXValue.Constant(1));
+                    var k = new VFXExpressionMatrixToAxis(sourceTransform, VFXValue.Constant(2));
+                    var p = new VFXExpressionMatrixToAxis(sourceTransform, VFXValue.Constant(3));
 
                     yield return new VFXNamedExpression(i, "readAxisX");
                     yield return new VFXNamedExpression(j, "readAxisY");

Packages/com.unity.visualeffectgraph/Editor/Models/Operators/Implementations/ConstructMatrix.cs

@@ -4,34 +4,46 @@ namespace UnityEditor.VFX.Operator
 {
     [VFXHelpURL("Operator-ConstructMatrix")]
     [VFXInfo(name = "Construct Matrix", category = "Math/Vector")]
-    class MatrixFromVector4 : VFXOperator
+    class ConstructMatrix : VFXOperator
     {
+        public enum Order
+        {
+            Row,
+            Column,
+        }
+
+        [VFXSetting, Tooltip("Specifies the order of the vectors, either row or column")]
+        public Order order = Order.Column;
+
         public class InputProperties
         {
-            [Tooltip("The first column of the matrix to construct.")]
-            public Vector4 c0 = new Vector4(1, 0, 0, 0);
-            [Tooltip("The second column of the matrix to construct.")]
-            public Vector4 c1 = new Vector4(0, 1, 0, 0);
-            [Tooltip("The third column of the matrix to construct.")]
-            public Vector4 c2 = new Vector4(0, 0, 1, 0);
-            [Tooltip("The fourth column of the matrix to construct.")]
-            public Vector4 c3 = new Vector4(0, 0, 0, 1);
+            [Tooltip("The first vector of the matrix to construct.")]
+            public Vector4 m0 = new Vector4(1, 0, 0, 0);
+            [Tooltip("The second vector of the matrix to construct.")]
+            public Vector4 m1 = new Vector4(0, 1, 0, 0);
+            [Tooltip("The third vector of the matrix to construct.")]
+            public Vector4 m2 = new Vector4(0, 0, 1, 0);
+            [Tooltip("The fourth vector of the matrix to construct.")]
+            public Vector4 m3 = new Vector4(0, 0, 0, 1);
         }
         public class OutputProperties
         {
             public Matrix4x4 m = Matrix4x4.identity;
         }
+
         override public string name { get { return "Construct Matrix"; } }
 
         override protected VFXExpression[] BuildExpression(VFXExpression[] inputExpression)
         {
-            VFXExpression c0 = inputExpression[0];
-            VFXExpression c1 = inputExpression[1];
-            VFXExpression c2 = inputExpression[2];
-            VFXExpression c3 = inputExpression[3];
+            VFXExpression m0 = inputExpression[0];
+            VFXExpression m1 = inputExpression[1];
+            VFXExpression m2 = inputExpression[2];
+            VFXExpression m3 = inputExpression[3];
 
-            VFXExpression matrix = new VFXExpressionVector4sToMatrix(c0, c1, c2, c3);
-            return new[] { matrix };
+            if (order == Order.Row)
+                return new[] { new VFXExpressionRowToMatrix(m0, m1, m2, m3) };
+            else
+                return new[] { new VFXExpressionColumnToMatrix(m0, m1, m2, m3) };
         }
     }
 }

Packages/com.unity.visualeffectgraph/Editor/Models/Operators/Implementations/LookAt.cs

@@ -36,7 +36,7 @@ protected override VFXExpression[] BuildExpression(VFXExpression[] inputExpressi
             VFXExpression x = VFXOperatorUtility.Normalize(VFXOperatorUtility.Cross(up, z));
             VFXExpression y = VFXOperatorUtility.Cross(z, x);
 
-            VFXExpression matrix = new VFXExpressionVector3sToMatrix(x, y, z, from);
+            VFXExpression matrix = new VFXExpressionAxisToMatrix(x, y, z, from);
             return new[] { matrix };
         }
 

Packages/com.unity.visualeffectgraph/Editor/Models/Operators/Implementations/SampleMesh.cs

@@ -586,7 +586,7 @@ private static VFXExpression ComputeVertexAttribute(IEnumerable<VFXExpression> s
 
                 //insure tangent orthonormal with normal (cross of normalized input, not need to renormalize)
                 tangent = VFXOperatorUtility.Cross(bitangent, normal);
-                sampled = new VFXExpressionVector3sToMatrix(bitangent, normal, tangent, position);
+                sampled = new VFXExpressionAxisToMatrix(bitangent, normal, tangent, position);
             }
             else if (currentAttribute == VertexAttributeFlag.Velocity)
             {