[VFX] Integrate the basic structure of new VFX graph compiler.

Author: gabrieldelacruz

Packages/com.unity.visualeffectgraph/Editor/Compiler/VFXGraphCompiledData.cs

@@ -1094,17 +1094,7 @@ public struct VFXCompileOutput
 
             public HashSet<string> sourceDependencies;
 
-            public VFXExpressionSheet sheet;
-            public VFXEditorSystemDesc[] systemDesc;
-            public VFXEventDesc[] eventDesc;
-            public VFXGPUBufferDesc[] gpuBufferDesc;
-            public VFXCPUBufferDesc[] cpuBufferDesc;
-            public VFXTemporaryGPUBufferDesc[] temporaryBufferDesc;
-            public VFXShaderSourceDesc[] shaderSourceDesc;
-            public VFXRendererSettings rendererSettings;
-            public VFXInstancingDisabledReason instancingDisabledReason;
-
-            public uint version;
+            public VisualEffectAssetDesc assetDesc;
         }
 
         public VFXCompileOutput Compile(VFXCompilationMode compilationMode, bool enableShaderDebugSymbols, VFXAnalytics analytics)
@@ -1125,8 +1115,8 @@ public VFXCompileOutput Compile(VFXCompilationMode compilationMode, bool enableS
             if (m_Graph.children.Count() == 0)
             {
                 output.success = true;
-                output.version = compiledVersion;
-                output.systemDesc = Array.Empty<VFXEditorSystemDesc>();
+                output.assetDesc.version = compiledVersion;
+                output.assetDesc.systemDesc = Array.Empty<VFXEditorSystemDesc>();
                 return output;
             }
 
@@ -1351,16 +1341,17 @@ public VFXCompileOutput Compile(VFXCompilationMode compilationMode, bool enableS
 
                 output.success = true;
 
-                output.sheet = expressionSheet;
-                output.systemDesc = systemDescs.ToArray();
-                output.eventDesc = vfxEventDesc;
-                output.gpuBufferDesc = bufferDescs.ToArray();
-                output.cpuBufferDesc = cpuBufferDescs.ToArray();
-                output.temporaryBufferDesc = temporaryBufferDescs.ToArray();
-                output.shaderSourceDesc = shaderSources;
-                output.rendererSettings = new() { shadowCastingMode = shadowCastingMode, motionVectorGenerationMode = motionVectorGenerationMode };
-                output.instancingDisabledReason = instancingDisabledReason;
-                output.version = compiledVersion;
+                output.assetDesc.sheet = expressionSheet;
+                output.assetDesc.systemDesc = systemDescs.ToArray();
+                output.assetDesc.eventDesc = vfxEventDesc;
+                output.assetDesc.gpuBufferDesc = bufferDescs.ToArray();
+                output.assetDesc.cpuBufferDesc = cpuBufferDescs.ToArray();
+                output.assetDesc.temporaryBufferDesc = temporaryBufferDescs.ToArray();
+                output.assetDesc.shaderSourceDesc = shaderSources;
+                output.assetDesc.rendererSettings = new() { shadowCastingMode = shadowCastingMode, motionVectorGenerationMode = motionVectorGenerationMode };
+                output.assetDesc.instancingDisabledReason = instancingDisabledReason;
+                output.assetDesc.compilationMode = compilationMode;
+                output.assetDesc.version = compiledVersion;
 
                 m_ExpressionValues = expressionSheet.values;
             }

Packages/com.unity.visualeffectgraph/Editor/GraphCommon.meta

@@ -0,0 +1,214 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Unity.GraphCommon.LowLevel.Editor
+{
+    /// <summary>
+    /// A double-ended queue (deque) implementation that allows adding and removing elements from both ends.
+    /// </summary>
+    /// <typeparam name="T">The type that the deque is holding.</typeparam>
+    /*public*/ class Deque<T> : IEnumerable<T>
+    {
+        private T[] m_Buffer;
+        private int m_Head;
+        private int m_Tail;
+        private int m_Count;
+        private const int DefaultCapacity = 4;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Deque{T}"/> class with the default capacity.
+        /// </summary>
+        public Deque() : this(DefaultCapacity)
+        {
+        }
+
+        /// <summary>
+        ///  Initializes a new instance of the <see cref="Deque{T}"/> class with a specified capacity.
+        /// </summary>
+        /// <param name="capacity"> The initial capacity of the deque. </param>
+        /// <exception cref="ArgumentOutOfRangeException">Throws if capacity is negative.</exception>
+        public Deque(int capacity)
+        {
+            if (capacity < 0)
+                throw new ArgumentOutOfRangeException(nameof(capacity), "Capacity cannot be negative");
+
+            m_Buffer = new T[capacity];
+            m_Head = 0;
+            m_Tail = 0;
+            m_Count = 0;
+        }
+
+        /// <summary>
+        /// Gets the number of elements in the deque.
+        /// </summary>
+        public int Count => m_Count;
+
+        /// <summary>
+        /// Returns true if the deque is empty. False otherwise.
+        /// </summary>
+        public bool IsEmpty => m_Count == 0;
+
+        /// <summary>
+        /// Adds an element to the front of the deque.
+        /// </summary>
+        /// <param name="item">The element to add.</param>
+        public void AddFront(T item)
+        {
+            if (m_Count == m_Buffer.Length)
+            {
+                Resize();
+            }
+
+            m_Head = (m_Head - 1 + m_Buffer.Length) % m_Buffer.Length;
+            m_Buffer[m_Head] = item;
+            m_Count++;
+        }
+
+        /// <summary>
+        /// Adds an element to the back of the deque.
+        /// </summary>
+        /// <param name="item">The element to add.</param>
+        public void AddBack(T item)
+        {
+            if (m_Count == m_Buffer.Length)
+            {
+                Resize();
+            }
+
+            m_Buffer[m_Tail] = item;
+            m_Tail = (m_Tail + 1) % m_Buffer.Length;
+            m_Count++;
+        }
+
+        /// <summary>
+        /// Removes and returns the element at the front of the deque.
+        /// </summary>
+        /// <returns>The element removed from the front.</returns>
+        /// <exception cref="InvalidOperationException">Thrown if the deque is empty.</exception>
+        public T RemoveFront()
+        {
+            if (IsEmpty)
+                throw new InvalidOperationException("Deque is empty");
+
+            T item = m_Buffer[m_Head];
+            m_Buffer[m_Head] = default(T); // Clear reference
+            m_Head = (m_Head + 1) % m_Buffer.Length;
+            m_Count--;
+            return item;
+        }
+
+        /// <summary>
+        /// Removes and returns the element at the back of the deque.
+        /// </summary>
+        /// <returns>The element removed from the back.</returns>
+        /// <exception cref="InvalidOperationException">Thrown if the deque is empty.</exception>
+        public T RemoveBack()
+        {
+            if (IsEmpty)
+                throw new InvalidOperationException("Deque is empty");
+
+            m_Tail = (m_Tail - 1 + m_Buffer.Length) % m_Buffer.Length;
+            T item = m_Buffer[m_Tail];
+            m_Buffer[m_Tail] = default(T); // Clear reference
+            m_Count--;
+            return item;
+        }
+
+        /// <summary>
+        /// Returns the element at the front of the deque without removing it.
+        /// </summary>
+        /// <returns>The element at the front.</returns>
+        /// <exception cref="InvalidOperationException">Thrown if the deque is empty.</exception>
+        public T PeekFront()
+        {
+            if (IsEmpty)
+                throw new InvalidOperationException("Deque is empty");
+
+            return m_Buffer[m_Head];
+        }
+
+        /// <summary>
+        /// Returns the element at the back of the deque without removing it.
+        /// </summary>
+        /// <returns>The element at the back.</returns>
+        /// <exception cref="InvalidOperationException">Thrown if the deque is empty.</exception>
+        public T PeekBack()
+        {
+            if (IsEmpty)
+                throw new InvalidOperationException("Deque is empty");
+
+            int lastIndex = (m_Tail - 1 + m_Buffer.Length) % m_Buffer.Length;
+            return m_Buffer[lastIndex];
+        }
+
+        // Indexer for random access
+        private T this[int index]
+        {
+            get
+            {
+                if (index < 0 || index >= m_Count)
+                    throw new ArgumentOutOfRangeException(nameof(index));
+
+                int actualIndex = (m_Head + index) % m_Buffer.Length;
+                return m_Buffer[actualIndex];
+            }
+            set
+            {
+                if (index < 0 || index >= m_Count)
+                    throw new ArgumentOutOfRangeException(nameof(index));
+
+                int actualIndex = (m_Head + index) % m_Buffer.Length;
+                m_Buffer[actualIndex] = value;
+            }
+        }
+
+        /// <summary>
+        /// Removes all elements from the deque.
+        /// </summary>
+        public void Clear()
+        {
+            if (m_Count > 0)
+            {
+                Array.Clear(m_Buffer, 0, m_Buffer.Length);
+                m_Head = 0;
+                m_Tail = 0;
+                m_Count = 0;
+            }
+        }
+
+        // Resize the internal buffer when capacity is reached
+        private void Resize()
+        {
+            int newCapacity = m_Buffer.Length == 0 ? DefaultCapacity : m_Buffer.Length * 2;
+            T[] newBuffer = new T[newCapacity];
+
+            // Copy elements to new buffer in order
+            for (int i = 0; i < m_Count; i++)
+            {
+                newBuffer[i] = this[i];
+            }
+
+            m_Buffer = newBuffer;
+            m_Head = 0;
+            m_Tail = m_Count;
+        }
+
+        /// <summary>
+        /// Returns an enumerator that iterates through the deque.
+        /// </summary>
+        /// <returns>An enumerator for the deque.</returns>
+        public IEnumerator<T> GetEnumerator()
+        {
+            for (int i = 0; i < m_Count; i++)
+            {
+                yield return this[i];
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+}