[VFX] Add support for more HLSL function prototype declaration

JIRA: UUM-59938

1️⃣ The current implementation for Custom HLSL operators do not support all kind of function declaration.
The goal of this PR is to lift this limitation and support all kind of function that makes sense in that context.
Here are the limitation that are lifted:
✔ In operators, a function can return void
✔ In operators, a function can have no parameter at all (but then must return a value)
✔ In operators, a function can have only out parameters (can return void or not)
✔ In operators, a function can have only in parameters (but then must return a value)
✔ In operators, the return slot name can be defined with a comment above the function: /// return: <name-of-the-slot>
❌ In operators, a function cannot return void if there's not at least one out parameter
✔ In blocks, a function still must have a `VFXAttributes` parameter but don't need to access it all
✔ In blocks and operators, `TextureCube` and `Texture2DArray` are now supported

2️⃣ Also, for function which returns a value, until now the output slot was automatically named `out`.
Now the user can use the same syntax as for the tooltip of input parameters to specify a name for the return output.
The syntax is like this:
```hlsl
/// return: My Value
float FloatFunction4(in float t)
{
 	return 3 * t;
}
```
In that case, the output slot will be named `My Value`

3️⃣ Last but not least, the HLSL code editor now supports:
- `CTRL`+`S`: saves only the current file (instead of the whole Unity project)
- `CTRL`+`Z` and `CTRL`+`Y`: adds support for undo/redo inside the code editor.
- `CTRL`+`MouseWheel`: Increase/decrease font size

Author: julienamsellem

Packages/com.unity.visualeffectgraph/Editor/Controls/VFXTextEditor.cs

@@ -1,8 +1,10 @@
 using System;
 using System.Collections.Generic;
-
+using System.Text;
+using System.IO;
+using System.IO.Compression;
+using Unity.Profiling;
 using UnityEditor.Experimental;
-using UnityEditor.Experimental.GraphView;
 using UnityEditor.UIElements;
 using UnityEngine;
 using UnityEngine.UIElements;
@@ -20,16 +22,24 @@ class VFXTextEditor : EditorWindow, ISerializationCallbackReceiver, IComparer<Op
     {
         readonly struct TextArea
         {
+            public static float s_FontSize = 11f;
+
+            static ProfilerMarker s_TextChangedPerfMarker = new("TextArea.OnTextChanged");
+
             readonly VFXTextEditor m_Editor;
             readonly ITextProvider m_TextProvider;
             readonly TextField m_TextField;
             readonly Label m_TitleLabel;
             readonly VisualElement m_Root;
+            readonly Stack<byte[]> m_UndoStack;
+            readonly Stack<byte[]> m_RedoStack;
 
             public TextArea(VFXTextEditor editor, ITextProvider textProvider)
             {
                 m_Editor = editor;
                 m_TextProvider = textProvider;
+                m_UndoStack = new Stack<byte[]>();
+                m_RedoStack = new Stack<byte[]>();
 
                 var tpl = VFXView.LoadUXML("VFXTextEditorArea");
                 m_Root = tpl.CloneTree();
@@ -57,22 +67,84 @@ public TextArea(VFXTextEditor editor, ITextProvider textProvider)
                 closeButton.RegisterCallback<ClickEvent>(OnClose);
                 m_TextProvider.titleChanged += OnProviderTitleChanged;
                 m_TextProvider.textChanged += OnProviderTextChanged;
+                m_TextField.style.fontSize = s_FontSize;
             }
 
             public ITextProvider TextProvider => m_TextProvider;
 
             public VisualElement GetRoot() => m_Root;
+            public void Save() => OnSave(null);
 
+            public bool HasFocus() => m_TextField.HasFocus();
             public void Focus() => m_TextField.Focus();
 
+            public void UpdateTextSize()
+            {
+                m_TextField.style.fontSize = new StyleLength(s_FontSize);
+            }
+
+            public void Undo()
+            {
+                if (m_UndoStack.Count > 0)
+                {
+                    var previousText = Decompress(m_UndoStack.Pop());
+                    m_RedoStack.Push(Compress(m_TextField.value));
+                    m_TextField.SetValueWithoutNotify(previousText);
+                }
+            }
+
+            public void Redo()
+            {
+                if (m_RedoStack.Count > 0)
+                {
+                    var previousText = Decompress(m_RedoStack.Pop());
+                    m_UndoStack.Push(Compress(m_TextField.value));
+                    m_TextField.SetValueWithoutNotify(previousText);
+                }
+            }
+
+            private byte[] Compress(string text)
+            {
+                using var memoryStream = new MemoryStream();
+                using (var gzipStream = new GZipStream(memoryStream, System.IO.Compression.CompressionLevel.Optimal))
+                {
+                    gzipStream.Write(Encoding.UTF8.GetBytes(text));
+                }
+
+                return memoryStream.ToArray();
+            }
+
+            private string Decompress(byte[] data)
+            {
+                using var memoryStream = new MemoryStream(data);
+                using var outputStream = new MemoryStream();
+                using (var gzipStream = new GZipStream(memoryStream, CompressionMode.Decompress))
+                {
+                    gzipStream.CopyTo(outputStream);
+                }
+
+                return Encoding.UTF8.GetString(outputStream.ToArray());
+            }
+
             private void OnProviderTitleChanged() => m_TitleLabel.text = m_TextProvider.title;
             private void OnProviderTextChanged() => m_TextField.value = m_TextProvider.text;
 
             private void OnTextChanged(ChangeEvent<string> evt)
             {
-                m_TitleLabel.text = evt.newValue != m_TextProvider.text
-                    ? $"{m_TextProvider.title}*"
-                    : m_TextProvider.title;
+                s_TextChangedPerfMarker.Begin();
+                try
+                {
+                    m_UndoStack.Push(Compress(evt.previousValue));
+                    m_RedoStack.Clear();
+                    m_TitleLabel.text = evt.newValue != m_TextProvider.text
+                        ? $"{m_TextProvider.title}*"
+                        : m_TextProvider.title;
+                }
+                finally
+                {
+                    s_TextChangedPerfMarker.End();
+                }
+                //Debug.Log($"Undo stack:\n\tmemory occupation: {m_UndoStack.Sum(x => x.Length) * sizeof(byte) / 1000}kb -- Length: {m_UndoStack.Count}");
             }
 
             private void OnSave(ClickEvent ev)
@@ -84,9 +156,11 @@ private void OnSave(ClickEvent ev)
                 }
             }
 
-            private void OnClose(ClickEvent evt)
+            internal void OnClose(ClickEvent evt)
             {
                 m_Editor.Close(this);
+                m_UndoStack.Clear();
+                m_RedoStack.Clear();
                 m_TextProvider.titleChanged -= OnProviderTitleChanged;
                 m_TextProvider.textChanged -= OnProviderTextChanged;
                 (m_TextProvider as IDisposable)?.Dispose();
@@ -149,6 +223,7 @@ private int GetTextIndexFromMousePosition(TextField textField, Vector2 mousePosi
         const string VFXTextEditorTitle = "HLSL Editor";
 
         [NonSerialized] readonly List<TextArea> m_OpenedEditors = new();
+        [NonSerialized] readonly List<VFXGraph> m_RegisteredGraphs = new();
         [SerializeField] List<OpenedTextProvider> m_OpenedModels;
 
         Label m_EmptyMessage;
@@ -163,11 +238,71 @@ public void Show(VFXModel model)
                 container.Add(textArea.GetRoot());
                 m_OpenedEditors.Add(textArea);
                 m_EmptyMessage.style.display = DisplayStyle.None;
+
+                var graph = model.GetGraph();
+                if (!m_RegisteredGraphs.Contains(graph))
+                {
+                    m_RegisteredGraphs.Add(graph);
+                    graph.onInvalidateDelegate += OnGraphInvalidate;
+                }
             }
 
             textArea.Focus();
         }
 
+        private void OnGraphInvalidate(VFXModel model, VFXModel.InvalidationCause cause)
+        {
+            foreach (var textArea in m_OpenedEditors.ToArray())
+            {
+                if (textArea.TextProvider.model.GetParent() == null)
+                {
+                    textArea.OnClose(null);
+                }
+            }
+        }
+
+        public void Undo()
+        {
+            foreach (var textArea in m_OpenedEditors)
+            {
+                if (textArea.HasFocus())
+                {
+                    textArea.Undo();
+                    break;
+                }
+            }
+        }
+
+        public void Redo()
+        {
+            foreach (var textArea in m_OpenedEditors)
+            {
+                if (textArea.HasFocus())
+                {
+                    textArea.Redo();
+                    break;
+                }
+            }
+        }
+
+        public void ChangeTextSize(int delta)
+        {
+            TextArea.s_FontSize = Mathf.Clamp(TextArea.s_FontSize + delta, 11f, 20f);
+            m_OpenedEditors.ForEach(x => x.UpdateTextSize());
+        }
+
+        public void Save()
+        {
+            foreach (var textArea in m_OpenedEditors)
+            {
+                if (textArea.HasFocus())
+                {
+                    textArea.Save();
+                    break;
+                }
+            }
+        }
+
         private void CreateGUI()
         {
             titleContent.text = VFXTextEditorTitle;
@@ -204,6 +339,21 @@ private void Close(TextArea textArea)
             {
                 m_EmptyMessage.style.display = DisplayStyle.Flex;
             }
+
+            var remainingGraphs = new HashSet<VFXGraph>();
+            foreach (var editor in m_OpenedEditors)
+            {
+                remainingGraphs.Add(editor.TextProvider.model.GetGraph());
+            }
+
+            foreach (var toRemoveGraphs in m_RegisteredGraphs.ToArray())
+            {
+                if (!remainingGraphs.Contains(toRemoveGraphs))
+                {
+                    toRemoveGraphs.onInvalidateDelegate -= OnGraphInvalidate;
+                    m_RegisteredGraphs.Remove(toRemoveGraphs);
+                }
+            }
         }
 
         public void OnBeforeSerialize()

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

@@ -4,43 +4,6 @@
 namespace UnityEditor.VFX
 {
 #pragma warning disable 0659
-    class VFXExpressionPassThrough : VFXExpression
-    {
-        private int m_ParentIndex;
-        private VFXValueType m_ValueType;
-
-        public VFXExpressionPassThrough() : this(0, VFXValueType.None, new [] { VFXValue<int>.Default })
-        {
-        }
-
-        public VFXExpressionPassThrough(int index, VFXValueType type, params VFXExpression[] parents) : base(Flags.InvalidOnCPU, parents)
-        {
-            m_ParentIndex = index;
-            m_ValueType = type;
-        }
-
-        public override VFXExpressionOperation operation => VFXExpressionOperation.None;
-
-        public override VFXValueType valueType => m_ValueType;
-
-        protected sealed override VFXExpression Evaluate(VFXExpression[] constParents)
-        {
-            return this;
-        }
-
-        protected override VFXExpression Reduce(VFXExpression[] reducedParents)
-        {
-            var newExpression = (VFXExpressionPassThrough)base.Reduce(reducedParents);
-            newExpression.m_ParentIndex = m_ParentIndex;
-            newExpression.m_ValueType = m_ValueType;
-            return newExpression;
-        }
-
-        public override string GetCodeString(string[] parents)
-        {
-            return parents[m_ParentIndex];
-        }
-    }
 
     class VFXExpressionHLSL : VFXExpression, IHLSLCodeHolder
     {

Packages/com.unity.visualeffectgraph/Editor/Models/Blocks/Implementations/HLSL/CustomHLSL.cs

@@ -46,20 +46,28 @@ public IEnumerable<IHLSMessage> Validate(IEnumerable<string> functions, HLSLFunc
             HLSLFunctionParameter attributesInput = null;
             foreach (var input in selectedFunction.inputs)
             {
-                if (input.rawType == "Texture2D")
+                if (input.access is HLSLAccess.IN or HLSLAccess.INOUT &&
+                   input.rawType is "Texture2D" or "Texture3D" or "TextureCube" or "Texture2DArray")
                 {
-                    yield return new HLSLTexture2DShouldNotBeUsed(input.name);
+                    yield return new HLSLWrongHLSLTextureType(input.rawType, input.name);
+                }
+                if (input.rawType is "TextureCubeArray" or "VFXSamplerCubeArray")
+                {
+                    yield return new HLSLTextureCubeArrayNotSupported(input.name);
                 }
                 if (input.type == typeof(VFXAttribute))
                 {
                     attributesInput = input;
                 }
+                else if (input.access is HLSLAccess.OUT or HLSLAccess.INOUT)
+                {
+                    yield return new HLSLOutParameterNotAllowed(input.name);
+                }
             }
             if (attributesInput == null)
             {
                 yield return new HLSLMissingVFXAttribute();
             }
-
             if (attributesInput != null && selectedFunction.attributes.Count > 0)
             {
                 if (!attributesInput.access.HasFlag(HLSLAccess.OUT))
@@ -309,7 +317,7 @@ private void ParseCodeIfNeeded()
                 return;
             }
 
-            var hasError = m_Function?.errorList != null;
+            var hasError = m_Function?.errorList.Count > 0;
             var strippedHLSL = HLSLParser.StripCommentedCode(GetHLSLCode());
             if (hasError || strippedHLSL != cachedHLSLCode || m_SelectedFunction != m_AvailableFunction.GetSelection() || m_AvailableFunction.values == null)
             {
@@ -355,7 +363,7 @@ private void ParseCodeIfNeeded()
                     m_Properties = new List<VFXPropertyWithValue>();
                     foreach (var input in m_Function.inputs)
                     {
-                        if (input.type != null && input.type != typeof(VFXAttribute))
+                        if (input.type != null && input.type != typeof(VFXAttribute) && input.access is HLSLAccess.IN)
                         {
                             m_Properties.Add(CreateProperty(input));
                         }
@@ -403,16 +411,12 @@ private string BuildSource()
             var functionParameters = new List<string>();
 
             // Create and initialize a VFXAttributes structure
-            if (m_Attributes.Count > 0)
+            builder.AppendLine("VFXAttributes att = (VFXAttributes)0;");
+            foreach (var attribute in m_Attributes)
             {
-                builder.AppendLine("VFXAttributes att = (VFXAttributes)0;");
-                foreach (var attribute in m_Attributes)
-                {
-                    builder.AppendLine($"att.{attribute.attrib.name} = {attribute.attrib.name};");
-                }
-                //builder.AppendLine();
-                functionParameters.Add("att");
+                builder.AppendLine($"att.{attribute.attrib.name} = {attribute.attrib.name};");
             }
+            functionParameters.Add("att");
 
             // Make the call to custom hlsl function
             var functionName = HasShaderFile()