[VFX] Fix and optimize model invalidation

julienf-unity · Evergreen · commit 8ec2362dfe5d · 2024-03-20T03:33:09.000Z
This PR fixes a regression that was introduced by https://github.cds.internal.unity3d.com/unity/unity/pull/41986. The regression caused a change in node settings to not systematically trigger a recompile in auto compile mode. The PR also adds some perf improvements regarding invalidation events: - Don't generate a UI invalidation event every time resync slots is called due to applying property attributes. - Improve the way we determinie whether a context can accept blocks or not.
diff --git a/Packages/com.unity.visualeffectgraph/Editor/GraphView/Elements/Controllers/VFXOperatorController.cs b/Packages/com.unity.visualeffectgraph/Editor/GraphView/Elements/Controllers/VFXOperatorController.cs
@@ -34,7 +34,8 @@ public VFXOperatorController(VFXOperator model, VFXViewController viewController
                 {
                     subgraphOperator.RecreateCopy();
                     model.ResyncSlots(false);
-                    model.UpdateOutputExpressions();
+                    model.MarkOutputExpressionsAsOutOfDate();
+                    model.UpdateOutputExpressionsIfNeeded();
                 }
                 catch (Exception e)
                 {
diff --git a/Packages/com.unity.visualeffectgraph/Editor/GraphView/Elements/VFXContextUI.cs b/Packages/com.unity.visualeffectgraph/Editor/GraphView/Elements/VFXContextUI.cs
@@ -40,15 +40,7 @@ class VFXContextUI : VFXNodeUI
         }
         protected override void OnNewController()
         {
-            foreach (var descriptor in VFXLibrary.GetBlocks())
-            {
-                var model = descriptor.CreateInstance();
-                if (controller.model.AcceptChild(model))
-                {
-                    m_CanHaveBlocks = true;
-                    break;
-                }
-            }
+            m_CanHaveBlocks = controller.model.CanHaveBlocks();
         }
 
         public bool canHaveBlocks { get => m_CanHaveBlocks; }
diff --git a/Packages/com.unity.visualeffectgraph/Editor/Models/Contexts/VFXContext.cs b/Packages/com.unity.visualeffectgraph/Editor/Models/Contexts/VFXContext.cs
@@ -29,6 +29,8 @@ enum VFXContextType
         InitAndUpdateAndOutput = Init | Update | Output,
         UpdateAndOutput = Update | Output,
         All = Init | Update | Output | Spawner | Subgraph,
+
+        CanHaveBlocks = ~(OutputEvent | Event | SpawnerGPU),
     };
 
     [Flags]
@@ -272,6 +274,11 @@ public virtual bool Accept(VFXBlock block, int index = -1)
             return ((block.compatibleContexts & contextType) != 0) && ((block.compatibleData & testedType) != 0);
         }
 
+        public bool CanHaveBlocks()
+        {
+            return (contextType & VFXContextType.CanHaveBlocks) != 0;
+        }
+
         protected override void OnAdded()
         {
             base.OnAdded();
diff --git a/Packages/com.unity.visualeffectgraph/Editor/Models/Operators/VFXAbstractOperatorNew.cs b/Packages/com.unity.visualeffectgraph/Editor/Models/Operators/VFXAbstractOperatorNew.cs
@@ -587,8 +587,11 @@ public void SetOperandType(int index, Type type)
                 return;
             }
 
-            m_Operands[index].type = type;
-            Invalidate(InvalidationCause.kSettingChanged);
+            if (!m_Operands[index].type.Equals(type))
+            {
+                m_Operands[index].type = type;
+                Invalidate(InvalidationCause.kSettingChanged);
+            }
         }
 
         public void OperandMoved(int movedIndex, int targetIndex)
diff --git a/Packages/com.unity.visualeffectgraph/Editor/Models/Operators/VFXOperator.cs b/Packages/com.unity.visualeffectgraph/Editor/Models/Operators/VFXOperator.cs
@@ -28,31 +28,6 @@ private static void GetSlotPredicateRecursive(List<VFXSlot> result, IEnumerable<
             }
         }
 
-        // As connections changed can be triggered from ResyncSlots, we need to make sure it is not reentrant
-        [NonSerialized]
-        private bool m_ResyncingSlots = false;
-
-        public override bool ResyncSlots(bool notify)
-        {
-            bool changed = false;
-            if (!m_ResyncingSlots)
-            {
-                m_ResyncingSlots = true;
-                try
-                {
-                    changed = base.ResyncSlots(notify);
-                    if (changed && notify)
-                        foreach (var slot in outputSlots) // invalidate expressions on output slots
-                            slot.InvalidateExpressionTree();
-                }
-                finally
-                {
-                    m_ResyncingSlots = false;
-                }
-            }
-            return changed;
-        }
-
         protected override void OnInvalidate(VFXModel model, InvalidationCause cause)
         {
             var outputSlotSpaceable = outputSlots.Where(o => o.spaceable);
@@ -79,23 +54,27 @@ protected override void OnInvalidate(VFXModel model, InvalidationCause cause)
                 }
             }
 
-            if (cause == InvalidationCause.kConnectionChanged)
-            {
-                if (model is VFXSlot slot && slot.direction == VFXSlot.Direction.kInput)
-                    ResyncSlots(true);
-            }
+            bool isInputSlot = model is VFXSlot && ((VFXSlot)model).direction == VFXSlot.Direction.kInput;
 
             if (cause == InvalidationCause.kParamChanged ||
                 cause == InvalidationCause.kExpressionValueInvalidated)
             {
-                if (model is VFXSlot && ((VFXSlot)model).direction == VFXSlot.Direction.kInput)
+                if (isInputSlot)
                 {
                     foreach (var slot in outputSlots)
                         slot.Invalidate(InvalidationCause.kExpressionValueInvalidated);
                 }
             }
 
             base.OnInvalidate(model, cause);
+
+            if (cause == InvalidationCause.kSettingChanged ||
+    (isInputSlot && (cause == InvalidationCause.kExpressionInvalidated || cause == InvalidationCause.kConnectionChanged)))
+            {
+                MarkOutputExpressionsAsOutOfDate();
+                foreach (var slot in outputSlots) // invalidate expressions on output slots
+                    slot.InvalidateExpressionTree();
+            }
         }
 
         public override VFXSpace GetOutputSpaceFromSlot(VFXSlot outputSlot)
@@ -106,7 +85,7 @@ public override VFXSpace GetOutputSpaceFromSlot(VFXSlot outputSlot)
                 : VFXSpace.None;
         }
 
-        public override sealed void UpdateOutputExpressions()
+        protected override sealed void UpdateOutputExpressions()
         {
             var outputSlotWithExpression = new List<VFXSlot>();
             var inputSlotWithExpression = new List<VFXSlot>();
diff --git a/Packages/com.unity.visualeffectgraph/Editor/Models/Operators/VFXSubgraphOperator.cs b/Packages/com.unity.visualeffectgraph/Editor/Models/Operators/VFXSubgraphOperator.cs
@@ -241,7 +241,8 @@ public override void CheckGraphBeforeImport()
             // If the graph is reimported it can be because one of its dependency such as the subgraphs, has been changed.
             if (!VFXGraph.explicitCompile)
             {
-                ResyncSlots(true);
+                MarkOutputExpressionsAsOutOfDate();
+                ResyncSlots(true);        
                 ResyncCustomAttributes();
             }
         }
diff --git a/Packages/com.unity.visualeffectgraph/Editor/Models/Parameters/VFXParameter.cs b/Packages/com.unity.visualeffectgraph/Editor/Models/Parameters/VFXParameter.cs
@@ -214,6 +214,7 @@ public void ResetOutputValueExpression()
         {
             if (!isOutput)
             {
+                MarkOutputExpressionsAsOutOfDate();
                 m_ExprSlots = outputSlots[0].GetVFXValueTypeSlots().ToArray();
                 m_ValueExpr = m_ExprSlots.Select(t => t.DefaultExpression(valueMode)).ToArray();
             }
@@ -421,6 +422,7 @@ protected sealed override void OnInvalidate(VFXModel model, InvalidationCause ca
 
                 if (valueExprChanged)
                 {
+                    MarkOutputExpressionsAsOutOfDate();
                     m_ValueExpr = valueExpr;
                     outputSlots[0].InvalidateExpressionTree();
                     Invalidate(InvalidationCause.kExpressionGraphChanged); // As we need to update exposed list event if not connected to a compilable context
@@ -737,7 +739,7 @@ public void UpdateDefaultExpressionValue()
             }
         }
 
-        public override void UpdateOutputExpressions()
+        protected override void UpdateOutputExpressions()
         {
             if (!isOutput)
             {
diff --git a/Packages/com.unity.visualeffectgraph/Editor/Models/Slots/VFXSlot.cs b/Packages/com.unity.visualeffectgraph/Editor/Models/Slots/VFXSlot.cs
@@ -742,10 +742,12 @@ public void UpdateAttributes(VFXPropertyAttributes attributes, bool notify)
         {
             if (notify)
             {
+                bool wasInitialized = m_Property.attributes.IsInitialized;
                 if (!m_Property.attributes.IsEqual(attributes))
                 {
                     m_Property.attributes = attributes;
-                    Invalidate(InvalidationCause.kUIChangedTransient); // TODO This will trigger a setDirty while it shouldn't as property attributes are not serialized
+                    if (wasInitialized) // No invalidate at init 
+                        Invalidate(InvalidationCause.kUIChangedTransient); // TODO This will trigger a setDirty while it shouldn't as property attributes are not serialized
                 }
             }
             else // fast path without comparison
@@ -919,6 +921,7 @@ private void RecomputeExpressionTree()
         {
             // Start from the top most parent
             var masterSlot = GetMasterSlot();
+            bool wasUpToDate = masterSlot.m_ExpressionTreeUpToDate;
 
             // When deserializing, default expression wont be initialized
             if (!m_DefaultExpressionInitialized)
@@ -945,7 +948,7 @@ private void RecomputeExpressionTree()
             {
                 if (owner != null)
                 {
-                    owner.UpdateOutputExpressions();
+                    owner.UpdateOutputExpressionsIfNeeded();
                     // Update outputs can trigger an invalidate, it can be reentrant. Just check if we're up to date after that and early out
                     if (m_ExpressionTreeUpToDate)
                         return;
@@ -995,8 +998,9 @@ private void RecomputeExpressionTree()
                     s[i].SetOutExpression(exp != null ? exp[i] : s[i].m_InExpression, toInvalidate, masterSlot.owner != null ? masterSlot.owner.GetOutputSpaceFromSlot(s) : VFXSpace.None);
             });
 
-            foreach (var slot in toInvalidate)
-                slot.InvalidateExpressionTree();
+            if (wasUpToDate)
+                foreach (var slot in toInvalidate)
+                    slot.InvalidateExpressionTree();
         }
 
         private static VFXExpression ApplySpaceConversion(VFXExpression exp, VFXSlot destSlot, VFXSlot sourceSlot)
@@ -1066,6 +1070,9 @@ private string GetOwnerType()
 
         public void InvalidateExpressionTree()
         {
+            if (!m_ExpressionTreeUpToDate)
+                return;
+
             var masterSlot = GetMasterSlot();
 
             masterSlot.PropagateToChildren(s =>
diff --git a/Packages/com.unity.visualeffectgraph/Editor/Models/VFXGraph.cs b/Packages/com.unity.visualeffectgraph/Editor/Models/VFXGraph.cs
@@ -1274,7 +1274,7 @@ void RecurseSubgraphRecreateCopy(IEnumerable<VFXModel> children)
                 {
                     operatorChild.RecreateCopy();
                     if (operatorChild.ResyncSlots(true))
-                        operatorChild.UpdateOutputExpressions();
+                        operatorChild.UpdateOutputExpressionsIfNeeded();
                 }
             }
         }
@@ -1309,7 +1309,7 @@ void RecurseSubgraphPatchInputExpression(IEnumerable<VFXModel> children)
                 else if (child is VFXSubgraphOperator operatorChild)
                 {
                     operatorChild.ResyncSlots(false);
-                    operatorChild.UpdateOutputExpressions();
+                    operatorChild.UpdateOutputExpressionsIfNeeded();
                 }
             }
             foreach (var child in children)
diff --git a/Packages/com.unity.visualeffectgraph/Editor/Models/VFXSlotContainerModel.cs b/Packages/com.unity.visualeffectgraph/Editor/Models/VFXSlotContainerModel.cs
@@ -27,7 +27,7 @@ interface IVFXSlotContainer
 
         int GetSlotIndex(VFXSlot slot);
 
-        void UpdateOutputExpressions();
+        void UpdateOutputExpressionsIfNeeded();
 
         void ClearSlots();
         bool ResyncSlots(bool notify);
@@ -232,6 +232,7 @@ public override void Sanitize(int version)
         public override void OnUnknownChange()
         {
             base.OnUnknownChange();
+            m_OutputExpressionsUpToDate = false;
             ResyncSlots(false);
         }
 
@@ -448,13 +449,37 @@ public bool IsPathExpanded(string fieldPath)
             return m_expandedPaths.Contains(fieldPath);
         }
 
-        public virtual void UpdateOutputExpressions() { }
+        protected virtual void UpdateOutputExpressions() { }
+
+        [NonSerialized]
+        private bool m_OutputExpressionsUpToDate = false;
+        public void UpdateOutputExpressionsIfNeeded()
+        {
+            if (!m_OutputExpressionsUpToDate)
+            {
+                UpdateOutputExpressions();
+                m_OutputExpressionsUpToDate = true;
+            }
+        }
+
+        public void MarkOutputExpressionsAsOutOfDate()
+        {
+            m_OutputExpressionsUpToDate = false;
+        }
 
         public virtual VFXSpace GetOutputSpaceFromSlot(VFXSlot slot)
         {
             return VFXSpace.None;
         }
 
+        public override void CheckGraphBeforeImport()
+        {
+            // The cache is here to avoid multiple output recomputation when updating the expression graph
+            // So It's marked as out of date before compilation just to minimize risk of cache missed invalidation between different compilation
+            MarkOutputExpressionsAsOutOfDate(); 
+            base.CheckGraphBeforeImport();     
+        }
+
         //[SerializeField]
         HashSet<string> m_expandedPaths = new HashSet<string>();
 
diff --git a/Packages/com.unity.visualeffectgraph/Editor/Types/VFXPropertyAttribute.cs b/Packages/com.unity.visualeffectgraph/Editor/Types/VFXPropertyAttribute.cs
@@ -124,6 +124,8 @@ public VFXPropertyAttributes(params object[] attributes) : this()
                     m_Flag |= attributeType;
                 }
             }
+            else
+                m_AllAttributes = Array.Empty<Attribute>(); // Just to discriminate between uninitialized and no properties
         }
 
         public bool IsEqual(VFXPropertyAttributes other)
@@ -312,6 +314,8 @@ public bool Is(VFXPropertyAttributes.Type type)
             return (m_Flag & type) == type;
         }
 
+        public bool IsInitialized => m_AllAttributes != null;
+
         public IReadOnlyCollection<Attribute> attributes => m_AllAttributes != null ? m_AllAttributes : new Attribute[0];
 
         private Attribute[] m_GraphAttributes;
diff --git a/Tests/SRPTests/Projects/VisualEffectGraph_HDRP/Assets/AllTests/Editor/Tests/VFXModelTests.cs b/Tests/SRPTests/Projects/VisualEffectGraph_HDRP/Assets/AllTests/Editor/Tests/VFXModelTests.cs
@@ -233,6 +233,79 @@ public void OnInvalidateDelegate()
             Assert.AreEqual("OnInvalidateDelegate  (UnityEditor.VFX.VFXGraph) kStructureChanged", s_logs[4]);
         }
 
+
+        private class DummyModel : VFXSlotContainerModel<VFXModel,VFXModel>
+        {
+            public class InputProperties
+            {
+                public float a;
+            }
+
+            protected override void OnInvalidate(VFXModel model, InvalidationCause cause)
+            {
+                s_logs.Add("OnInvalidate DummyModel " + model + " " + cause);
+            }
+        }
+
+        [Test]
+        public void OnExpressionInvalidationPropagation()
+        {
+            s_logs.Clear();
+
+            var graph = ScriptableObject.CreateInstance<VFXGraph>();
+            var testModel = ScriptableObject.CreateInstance<DummyModel>();
+
+            var op = ScriptableObject.CreateInstance<Operator.Noise>();
+            var add = ScriptableObject.CreateInstance<Operator.Add>();
+            var f = ScriptableObject.CreateInstance<VFXInlineOperator>();
+            f.SetSettingValue("m_Type", (SerializableType)typeof(float));
+
+            graph.AddChild(testModel);
+            graph.AddChild(op);
+            graph.AddChild(add);
+            graph.AddChild(f);
+
+            // Noise --|
+            //         |-- Add --> model0
+            // f ------|
+            
+            op.GetOutputSlot(0).Link(add.GetInputSlot(0));
+            f.GetOutputSlot(0).Link(add.GetInputSlot(1));
+
+            Assert.AreEqual(0, s_logs.Count);
+
+            add.GetOutputSlot(0).Link(testModel.GetInputSlot(0));
+            
+            Assert.AreEqual(1, s_logs.Count);
+            Assert.AreEqual("OnInvalidate DummyModel  (UnityEditor.VFX.VFXSlotFloat) kConnectionChanged", s_logs[0]);
+
+            // Change f value
+            f.GetInputSlot(0).value = 42.0f;
+
+            Assert.AreEqual(2, s_logs.Count);
+            Assert.AreEqual("OnInvalidate DummyModel  (UnityEditor.VFX.VFXSlotFloat) kExpressionValueInvalidated", s_logs[1]);
+
+            testModel.GetInputSlot(0).GetExpression(); // Just to trigger recomputation of expression graph
+
+            // Disconnect f
+            f.GetOutputSlot(0).UnlinkAll();
+
+            Assert.AreEqual(3, s_logs.Count);
+            Assert.AreEqual("OnInvalidate DummyModel  (UnityEditor.VFX.VFXSlotFloat) kExpressionInvalidated", s_logs[2]);
+
+            testModel.GetInputSlot(0).GetExpression(); // Just to trigger recomputation of expression graph
+
+            // Change noise setting
+            op.SetSettingValue("type", Operator.Noise.NoiseType.Cellular);
+
+            Assert.AreEqual(4, s_logs.Count);
+            Assert.AreEqual("OnInvalidate DummyModel  (UnityEditor.VFX.VFXSlotFloat) kExpressionInvalidated", s_logs[3]);
+
+            testModel.GetInputSlot(0).GetExpression(); // Just to trigger recomputation of expression graph
+
+            Assert.AreEqual(4, s_logs.Count);
+        }
+
         private void OnModelInvalidated(VFXModel model, VFXModel.InvalidationCause cause)
         {
             s_logs.Add("OnInvalidateDelegate " + model + " " + cause);

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,8 @@ public VFXOperatorController(VFXOperator model, VFXViewController viewController`
`34`	`34`	`{`
`35`	`35`	`subgraphOperator.RecreateCopy();`
`36`	`36`	`model.ResyncSlots(false);`
`37`		`- model.UpdateOutputExpressions();`
	`37`	`+ model.MarkOutputExpressionsAsOutOfDate();`
	`38`	`+ model.UpdateOutputExpressionsIfNeeded();`
`38`	`39`	`}`
`39`	`40`	`catch (Exception e)`
`40`	`41`	`{`
Original file line number	Diff line number	Diff line change
`@@ -40,15 +40,7 @@ class VFXContextUI : VFXNodeUI`
`40`	`40`	`}`
`41`	`41`	`protected override void OnNewController()`
`42`	`42`	`{`
`43`		`- foreach (var descriptor in VFXLibrary.GetBlocks())`
`44`		`- {`
`45`		`- var model = descriptor.CreateInstance();`
`46`		`- if (controller.model.AcceptChild(model))`
`47`		`- {`
`48`		`- m_CanHaveBlocks = true;`
`49`		`- break;`
`50`		`- }`
`51`		`- }`
	`43`	`+ m_CanHaveBlocks = controller.model.CanHaveBlocks();`
`52`	`44`	`}`
`53`	`45`
`54`	`46`	`public bool canHaveBlocks { get => m_CanHaveBlocks; }`
Original file line number	Diff line number	Diff line change
`@@ -587,8 +587,11 @@ public void SetOperandType(int index, Type type)`
`587`	`587`	`return;`
`588`	`588`	`}`
`589`	`589`
`590`		`- m_Operands[index].type = type;`
`591`		`- Invalidate(InvalidationCause.kSettingChanged);`
	`590`	`+ if (!m_Operands[index].type.Equals(type))`
	`591`	`+ {`
	`592`	`+ m_Operands[index].type = type;`
	`593`	`+ Invalidate(InvalidationCause.kSettingChanged);`
	`594`	`+ }`
`592`	`595`	`}`
`593`	`596`
`594`	`597`	`public void OperandMoved(int movedIndex, int targetIndex)`
Original file line number	Diff line number	Diff line change
`@@ -241,7 +241,8 @@ public override void CheckGraphBeforeImport()`
`241`	`241`	`// If the graph is reimported it can be because one of its dependency such as the subgraphs, has been changed.`
`242`	`242`	`if (!VFXGraph.explicitCompile)`
`243`	`243`	`{`
`244`		`- ResyncSlots(true);`
	`244`	`+ MarkOutputExpressionsAsOutOfDate();`
	`245`	`+ ResyncSlots(true);`
`245`	`246`	`ResyncCustomAttributes();`
`246`	`247`	`}`
`247`	`248`	`}`
Original file line number	Diff line number	Diff line change
`@@ -214,6 +214,7 @@ public void ResetOutputValueExpression()`
`214`	`214`	`{`
`215`	`215`	`if (!isOutput)`
`216`	`216`	`{`
	`217`	`+ MarkOutputExpressionsAsOutOfDate();`
`217`	`218`	`m_ExprSlots = outputSlots[0].GetVFXValueTypeSlots().ToArray();`
`218`	`219`	`m_ValueExpr = m_ExprSlots.Select(t => t.DefaultExpression(valueMode)).ToArray();`
`219`	`220`	`}`
`@@ -421,6 +422,7 @@ protected sealed override void OnInvalidate(VFXModel model, InvalidationCause ca`
`421`	`422`
`422`	`423`	`if (valueExprChanged)`
`423`	`424`	`{`
	`425`	`+ MarkOutputExpressionsAsOutOfDate();`
`424`	`426`	`m_ValueExpr = valueExpr;`
`425`	`427`	`outputSlots[0].InvalidateExpressionTree();`
`426`	`428`	`Invalidate(InvalidationCause.kExpressionGraphChanged); // As we need to update exposed list event if not connected to a compilable context`
`@@ -737,7 +739,7 @@ public void UpdateDefaultExpressionValue()`
`737`	`739`	`}`
`738`	`740`	`}`
`739`	`741`
`740`		`- public override void UpdateOutputExpressions()`
	`742`	`+ protected override void UpdateOutputExpressions()`
`741`	`743`	`{`
`742`	`744`	`if (!isOutput)`
`743`	`745`	`{`
Original file line number	Diff line number	Diff line change
`@@ -742,10 +742,12 @@ public void UpdateAttributes(VFXPropertyAttributes attributes, bool notify)`
`742`	`742`	`{`
`743`	`743`	`if (notify)`
`744`	`744`	`{`
	`745`	`+ bool wasInitialized = m_Property.attributes.IsInitialized;`
`745`	`746`	`if (!m_Property.attributes.IsEqual(attributes))`
`746`	`747`	`{`
`747`	`748`	`m_Property.attributes = attributes;`
`748`		`- Invalidate(InvalidationCause.kUIChangedTransient); // TODO This will trigger a setDirty while it shouldn't as property attributes are not serialized`
	`749`	`+ if (wasInitialized) // No invalidate at init`
	`750`	`+ Invalidate(InvalidationCause.kUIChangedTransient); // TODO This will trigger a setDirty while it shouldn't as property attributes are not serialized`
`749`	`751`	`}`
`750`	`752`	`}`
`751`	`753`	`else // fast path without comparison`
`@@ -919,6 +921,7 @@ private void RecomputeExpressionTree()`
`919`	`921`	`{`
`920`	`922`	`// Start from the top most parent`
`921`	`923`	`var masterSlot = GetMasterSlot();`
	`924`	`+ bool wasUpToDate = masterSlot.m_ExpressionTreeUpToDate;`
`922`	`925`
`923`	`926`	`// When deserializing, default expression wont be initialized`
`924`	`927`	`if (!m_DefaultExpressionInitialized)`
`@@ -945,7 +948,7 @@ private void RecomputeExpressionTree()`
`945`	`948`	`{`
`946`	`949`	`if (owner != null)`
`947`	`950`	`{`
`948`		`- owner.UpdateOutputExpressions();`
	`951`	`+ owner.UpdateOutputExpressionsIfNeeded();`
`949`	`952`	`// Update outputs can trigger an invalidate, it can be reentrant. Just check if we're up to date after that and early out`
`950`	`953`	`if (m_ExpressionTreeUpToDate)`
`951`	`954`	`return;`
`@@ -995,8 +998,9 @@ private void RecomputeExpressionTree()`
`995`	`998`	`s[i].SetOutExpression(exp != null ? exp[i] : s[i].m_InExpression, toInvalidate, masterSlot.owner != null ? masterSlot.owner.GetOutputSpaceFromSlot(s) : VFXSpace.None);`
`996`	`999`	`});`
`997`	`1000`
`998`		`- foreach (var slot in toInvalidate)`
`999`		`- slot.InvalidateExpressionTree();`
	`1001`	`+ if (wasUpToDate)`
	`1002`	`+ foreach (var slot in toInvalidate)`
	`1003`	`+ slot.InvalidateExpressionTree();`
`1000`	`1004`	`}`
`1001`	`1005`
`1002`	`1006`	`private static VFXExpression ApplySpaceConversion(VFXExpression exp, VFXSlot destSlot, VFXSlot sourceSlot)`
`@@ -1066,6 +1070,9 @@ private string GetOwnerType()`
`1066`	`1070`
`1067`	`1071`	`public void InvalidateExpressionTree()`
`1068`	`1072`	`{`
	`1073`	`+ if (!m_ExpressionTreeUpToDate)`
	`1074`	`+ return;`
	`1075`	`+`
`1069`	`1076`	`var masterSlot = GetMasterSlot();`
`1070`	`1077`
`1071`	`1078`	`masterSlot.PropagateToChildren(s =>`
Original file line number	Diff line number	Diff line change
`@@ -1274,7 +1274,7 @@ void RecurseSubgraphRecreateCopy(IEnumerable<VFXModel> children)`
`1274`	`1274`	`{`
`1275`	`1275`	`operatorChild.RecreateCopy();`
`1276`	`1276`	`if (operatorChild.ResyncSlots(true))`
`1277`		`- operatorChild.UpdateOutputExpressions();`
	`1277`	`+ operatorChild.UpdateOutputExpressionsIfNeeded();`
`1278`	`1278`	`}`
`1279`	`1279`	`}`
`1280`	`1280`	`}`
`@@ -1309,7 +1309,7 @@ void RecurseSubgraphPatchInputExpression(IEnumerable<VFXModel> children)`
`1309`	`1309`	`else if (child is VFXSubgraphOperator operatorChild)`
`1310`	`1310`	`{`
`1311`	`1311`	`operatorChild.ResyncSlots(false);`
`1312`		`- operatorChild.UpdateOutputExpressions();`
	`1312`	`+ operatorChild.UpdateOutputExpressionsIfNeeded();`
`1313`	`1313`	`}`
`1314`	`1314`	`}`
`1315`	`1315`	`foreach (var child in children)`