[VFX] Fix Position Box with Zero Scale

About UUM-62355, the Position Box has been migrated with this PR: https://github.cds.internal.unity3d.com/unity/unity/pull/40039
Since the normal/axis are aligned with the box, we can skip the scale if possible (aka the transform comes from a Translation/Rotation/Scale):

https://media.github.cds.internal.unity3d.com/user/42/files/a979c270-ce82-4537-af32-d4ff6f0e5df3

⚠️ If we are computing the box in other way, the scale won't be skipped and it still leads to invalid axis but it's an really rare case:

https://media.github.cds.internal.unity3d.com/user/42/files/1aaaa3b8-d983-41fb-bb9c-5ce0222dfa1b


About UUM-67233, the Position On SDF was incomplete:
- The applyOrientation wasn't tested leading to compilation failure
- The blending mode wasn't taken into account (Position Add/Mul/Blend, ...)
- The axisX/Y/Z was never wrote, I made them consistent with the sphere orientation (see below)

https://media.github.cds.internal.unity3d.com/user/42/files/43efeee4-0756-408f-9d46-5a3f0e6836f6

Author: PaulDemeulenaere

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

@@ -86,8 +86,35 @@ public override IEnumerable<VFXNamedExpression> GetParameters(PositionShape posi
                 boxSize = VFXOperatorUtility.OneExpression[VFXValueType.Float3];
             }
 
+            //If possible, remove scale to allow zero scale matrices (see UUM-62355)
+            var transformForInversion = transform;
+            var isInverseTransposeBoxOrthonormal = VFXOperatorUtility.FalseExpression;
+            if (positionBase.inputSlots[0].space == VFXSpace.None || positionBase.inputSlots[0].space == positionBase.GetParent().space)
+            {
+                if (transform is VFXExpressionTRSToMatrix)
+                {
+                    transformForInversion = new VFXExpressionTRSToMatrix(VFXOperatorUtility.ZeroExpression[VFXValueType.Float3], transform.parents[1], VFXOperatorUtility.OneExpression[VFXValueType.Float3]);
+                    isInverseTransposeBoxOrthonormal = VFXOperatorUtility.TrueExpression;
+                }
+            }
+            else
+            {
+                if (transform is not VFXExpressionTransformMatrix)
+                    throw new InvalidOperationException("Unexpected missing space conversion");
+
+                var left = transform.parents[0];
+                var right = transform.parents[1];
+                if (right is VFXExpressionTRSToMatrix)
+                {
+                    right = new VFXExpressionTRSToMatrix(VFXOperatorUtility.ZeroExpression[VFXValueType.Float3], right.parents[1], VFXOperatorUtility.OneExpression[VFXValueType.Float3]);
+                    transformForInversion = new VFXExpressionTransformMatrix(left, right);
+                    //inverseTransposeBoxOrthonormal still false, LocalToWorld can contains scale
+                }
+            }
+
             yield return new VFXNamedExpression(transform, "Box");
-            yield return new VFXNamedExpression(VFXOperatorUtility.InverseTransposeTRS(transform), "InverseTransposeBox");
+            yield return new VFXNamedExpression(VFXOperatorUtility.InverseTransposeTRS(transformForInversion), "InverseTransposeBox");
+            yield return new VFXNamedExpression(isInverseTransposeBoxOrthonormal, "IsInverseTransposeBoxOrthonormal");
             yield return new VFXNamedExpression(boxSize, "Box_size");
             foreach (var p in GetVolumeExpressions(positionBase.positionMode, boxSize, thickness))
                 yield return p;
@@ -210,8 +237,11 @@ public override string GetSource(PositionShape positionBase)
 outPos = mul(Box, float4(outPos, 1.0f)).xyz;
 outUp = mul(InverseTransposeBox, float4(outUp, 0.0f)).xyz;
 outDir = mul(InverseTransposeBox, float4(outDir, 0.0f)).xyz;
-outDir = normalize(outDir);
-outUp = normalize(outUp);
+if (!IsInverseTransposeBoxOrthonormal)
+{
+    outDir = normalize(outDir);
+    outUp = normalize(outUp);
+}
 outTan = cross(outDir, outUp);
 ";
 

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

@@ -1,6 +1,7 @@
 using System;
 using System.Linq;
 using System.Collections.Generic;
+using System.Text;
 using UnityEngine;
 
 namespace UnityEditor.VFX.Block
@@ -45,7 +46,7 @@ public override IEnumerable<VFXNamedExpression> GetParameters(PositionShape posi
 
             var extents = new VFXNamedExpression(new VFXExpressionExtractScaleFromMatrix(transform), "extents");
             yield return new VFXNamedExpression(VFX.VFXOperatorUtility.Max3(extents.exp), "scalingFactor");
-            yield return new VFXNamedExpression(new VFXExpressionInverseTRSMatrix(transform), "InvFieldTransform");
+            yield return new VFXNamedExpression(new VFXExpressionInverseTRSMatrix(transform), "inverseTransform");
             var minDim = new VFXExpressionCastUintToFloat(VFX.VFXOperatorUtility.Min3(new VFXExpressionTextureHeight(sdf), new VFXExpressionTextureWidth(sdf), new VFXExpressionTextureDepth(sdf)));
             var gradStep = VFXValue.Constant(0.01f);  //kStep used in SampleSDFDerivativesFast and SampleSDFDerivatives
             var margin = VFXValue.Constant(0.5f) / minDim + gradStep + VFXValue.Constant(0.001f);
@@ -55,32 +56,33 @@ public override IEnumerable<VFXNamedExpression> GetParameters(PositionShape posi
 
         public override string GetSource(PositionShape positionBase)
         {
-            string outSource = @"float cosPhi = 2.0f * RAND - 1.0f;";
+            var outSource = new StringBuilder(@"float cosPhi = 2.0f * RAND - 1.0f;");
             if (positionBase.spawnMode == PositionBase.SpawnMode.Random)
-                outSource += @"float theta = TWO_PI * RAND;";
+                outSource.AppendLine(@"float theta = TWO_PI * RAND;");
             else
-                outSource += @"float theta = TWO_PI * ArcSequencer;";
+                outSource.AppendLine(@"float theta = TWO_PI * ArcSequencer;");
             switch (positionBase.positionMode)
             {
                 case (PositionBase.PositionMode.Surface):
-                    outSource += @" float Thickness = 0.0f;";
+                    outSource.AppendLine(@" float Thickness = 0.0f;");
                     break;
                 case (PositionBase.PositionMode.Volume):
-                    outSource += @" float Thickness = scalingFactor;";
+                    outSource.AppendLine(@" float Thickness = scalingFactor;");
                     break;
                 case (PositionBase.PositionMode.ThicknessRelative):
-                    outSource += @" Thickness *= scalingFactor * 0.5f;";
+                    outSource.AppendLine(@" Thickness *= scalingFactor * 0.5f;");
                     break;
             }
-            outSource += @"
+
+            outSource.Append(@"
 //Initialize position within texture bounds
 float2 sincosTheta;
 sincos(theta, sincosTheta.x, sincosTheta.y);
 sincosTheta *= sqrt(1.0f - cosPhi * cosPhi);
-direction = float3(sincosTheta, cosPhi) *  sqrt(3)/2;
-float maxDir = max(0.5f, max(abs(direction.x), max(abs(direction.y), abs(direction.z))));
-direction = direction * (projectionRayWithMargin/maxDir);
-float3 tPos = direction * pow(RAND, 1.0f/3.0f);
+float3 currentAxisY = float3(sincosTheta, cosPhi) *  sqrt(3)/2;
+float maxDir = max(0.5f, max(abs(currentAxisY.x), max(abs(currentAxisY.y), abs(currentAxisY.z))));
+currentAxisY = currentAxisY * (projectionRayWithMargin/maxDir);
+float3 tPos = currentAxisY * pow(RAND, 1.0f/3.0f);
 float3 coord = tPos + 0.5f;
 float3 wPos, n, worldNormal;
 
@@ -92,33 +94,63 @@ public override string GetSource(PositionShape positionBase)
 
     //Projection on surface/volume
     float3 delta;
-    worldNormal = VFXSafeNormalize(mul(float4(n, 0), InvFieldTransform).xyz);
+    worldNormal = VFXSafeNormalize(mul(float4(n, 0), inverseTransform).xyz);
     if (dist > 0)
         delta = dist * worldNormal;
     else
     {
         delta = min(dist + Thickness, 0) * worldNormal;
     }
 
-    wPos =  mul(FieldTransform, float4(tPos,1)).xyz + delta;
-    tPos = mul(InvFieldTransform, float4(wPos,1)).xyz;
+    wPos = mul(FieldTransform, float4(tPos,1)).xyz + delta;
+    tPos = mul(inverseTransform, float4(wPos, 1)).xyz;
     coord = tPos + 0.5f;
 
+}");
+            outSource.AppendFormat(positionBase.composePositionFormatString, "wPos");
+
+            if (positionBase.applyOrientation != PositionBase.Orientation.None)
+                outSource.Append(@"currentAxisY = -worldNormal;");
+
+            if (positionBase.applyOrientation.HasFlag(PositionBase.Orientation.Axes))
+                outSource.Append(@"
+float3 AxisZCandidateA = float3(-sincosTheta.y, sincosTheta.x, 0);
+float3 AxisZCandidateB = float3(sign(cosPhi), 0, 0);
+AxisZCandidateA = mul(float4(AxisZCandidateA, 0), inverseTransform).xyz;
+AxisZCandidateB = mul(float4(AxisZCandidateB, 0), inverseTransform).xyz;
+
+float3 currentAxisZ = AxisZCandidateA;
+float3 currentAxisX = cross(currentAxisZ, currentAxisY);
+if (dot(currentAxisX, currentAxisX) < 0.00001f)
+{
+    currentAxisZ = AxisZCandidateB;
+    currentAxisX = cross(currentAxisZ, currentAxisY);
 }
-position = wPos;
-direction = -worldNormal;
-                        ";
-            if (positionBase.killOutliers)
+
+currentAxisX = normalize(currentAxisX);
+currentAxisZ = normalize(cross(currentAxisX, currentAxisY));");
+
+            if (positionBase.applyOrientation.HasFlag(PositionBase.Orientation.Direction))
             {
-                outSource += @"
+                outSource.AppendFormat(positionBase.composeDirectionFormatString, "currentAxisY");
+            }
 
+            if (positionBase.applyOrientation.HasFlag(PositionBase.Orientation.Axes))
+            {
+                outSource.AppendFormat(VFXBlockUtility.GetComposeString(positionBase.compositionAxes, "axisX", "currentAxisX", "blendAxes"));
+                outSource.AppendFormat(VFXBlockUtility.GetComposeString(positionBase.compositionAxes, "axisY", "currentAxisY", "blendAxes"));
+                outSource.AppendFormat(VFXBlockUtility.GetComposeString(positionBase.compositionAxes, "axisZ", "currentAxisZ", "blendAxes"));
+            }
+
+            if (positionBase.killOutliers)
+            {
+                outSource.Append(@"
  float dist = SampleSDF(SDF, coord);
  if (dist * scalingFactor > 0.01)
-    alive = false;
-";
+    alive = false;");
             }
 
-            return outSource;
+            return outSource.ToString();
         }
     }
 }

Packages/com.unity.visualeffectgraph/Editor/Models/Operators/VFXOperatorUtility.cs

@@ -22,6 +22,8 @@ public static Dictionary<VFXValueType, VFXExpression> GenerateExpressionConstant
             };
         }
 
+        public static readonly VFXExpression TrueExpression = VFXValue.Constant(true);
+        public static readonly VFXExpression FalseExpression = VFXValue.Constant(false);
         public static readonly Dictionary<VFXValueType, VFXExpression> OneExpression = GenerateExpressionConstant(1.0f);
         public static readonly Dictionary<VFXValueType, VFXExpression> MinusOneExpression = GenerateExpressionConstant(-1.0f);
         public static readonly Dictionary<VFXValueType, VFXExpression> HalfExpression = GenerateExpressionConstant(0.5f);

Tests/SRPTests/Packages/com.unity.testing.visualeffectgraph/Tests/Editor/VFXCodeGenerationTest.cs

@@ -8,7 +8,7 @@
 using UnityEditor.VFX.Block;
 using UnityEngine.TestTools;
 using System.Collections;
-using static UnityEditor.VFX.Block.CollisionBase;
+using UnityEditor.Rendering;
 
 namespace UnityEditor.VFX.Test
 {
@@ -191,16 +191,48 @@ public void Constant_Folding_With_ShaderKeyword([ValueSource("allCompilationMode
             Assert.AreEqual(4, shaderCount);
             vfx.GetOrCreateGraph().SetCompilationMode(VFXCompilationMode.Runtime);
         }
-        
+
+        private IEnumerable CheckCompilation(VFXGraph vfxGraph)
+        {
+            var resource = vfxGraph.GetResource();
+            EditorUtility.SetDirty(resource);
+            var path = AssetDatabase.GetAssetPath(vfxGraph);
+            AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate | ImportAssetOptions.ForceSynchronousImport);
+
+            for (int i = 0; i < 4; ++i)
+                yield return null;
+
+            while (ShaderUtil.anythingCompiling)
+                yield return null;
+
+            var computeShaders = AssetDatabase.LoadAllAssetsAtPath(path).OfType<ComputeShader>().ToArray();
+            Assert.AreEqual(3, computeShaders.Length);
+
+            foreach (var computeShader in computeShaders)
+            {
+                var messages = ShaderUtil.GetComputeShaderMessages(computeShader);
+                foreach (var message in messages)
+                    Assert.AreNotEqual(ShaderCompilerMessageSeverity.Error, message.severity, message.message);
+
+                Assert.AreEqual(0, computeShader.FindKernel("CSMain"));
+                Assert.IsTrue(computeShader.IsSupported(0));
+            }
+            yield return null;
+        }
+
         [UnityTest]
         public IEnumerator Combinatory_Position_Shape()
         {
             var vfxGraph = VFXTestCommon.CreateGraph_And_System();
             var initialize = vfxGraph.children.OfType<VFXBasicInitialize>().First();
 
+            var orientations = new List<PositionBase.Orientation>(Enum.GetValues(typeof(PositionBase.Orientation)).OfType<PositionBase.Orientation>());
+            orientations.Add(PositionBase.Orientation.Axes | PositionBase.Orientation.Direction);
+
             foreach (PositionBase.PositionMode positionMode in Enum.GetValues(typeof(PositionBase.PositionMode)))
             foreach (PositionBase.SpawnMode spawnMode in Enum.GetValues(typeof(PositionBase.SpawnMode)))
             foreach (PositionShapeBase.Type shape in Enum.GetValues(typeof(PositionShapeBase.Type)))
+            foreach (PositionBase.Orientation orientation in orientations)
             {
                 var positionShape = ScriptableObject.CreateInstance<PositionShape>();
                 positionShape.SetSettingValue("positionMode", positionMode);
@@ -211,14 +243,15 @@ public IEnumerator Combinatory_Position_Shape()
                 positionShape.SetSettingValue("compositionPosition", AttributeCompositionMode.Blend);
                 positionShape.SetSettingValue("compositionAxes", AttributeCompositionMode.Blend);
                 positionShape.SetSettingValue("compositionDirection", AttributeCompositionMode.Blend);
-                positionShape.SetSettingValue("applyOrientation", PositionBase.Orientation.Direction | PositionBase.Orientation.Axes);
+                positionShape.SetSettingValue("applyOrientation", orientation);
 
                 initialize.AddChild(positionShape);
             }
 
-            AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(vfxGraph));
-            for (int i = 0; i < 4; ++i) //Wait a few frame in case of shader compilation error
-                yield return null;
+            foreach (var yield in CheckCompilation(vfxGraph))
+            {
+                yield return yield;
+            }
         }
 
         [UnityTest]
@@ -259,9 +292,10 @@ public IEnumerator Combinatory_Collision_Shape()
                 initialize.AddChild(collisionShape);
             }
 
-            AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(vfxGraph));
-            for (int i = 0; i < 4; ++i) //Wait a few frame in case of shader compilation error
-                yield return null;
+            foreach (var yield in CheckCompilation(vfxGraph))
+            {
+                yield return yield;
+            }
         }
     }
 }