[Port] [6000.4] RenderGraph - Add new operator == for the TextureHandle class

Author: svc-reach-platform-support

Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/RenderGraphResourceTexture.cs

@@ -97,7 +97,7 @@ internal enum TextureUVOriginSelection
     /// </summary>
     [DebuggerDisplay("Texture ({handle.index})")]
     [MovedFrom(true, "UnityEngine.Experimental.Rendering.RenderGraphModule", "UnityEngine.Rendering.RenderGraphModule")]
-    public readonly struct TextureHandle
+    public readonly struct TextureHandle : IEquatable<TextureHandle>
     {
         private static TextureHandle s_NullHandle = new TextureHandle();
 
@@ -151,6 +151,52 @@ internal TextureHandle(int handle, bool shared = false, bool builtin = false)
         /// <returns>Resource as a RTHandle.</returns>
         public static implicit operator RTHandle(TextureHandle texture) => texture.IsValid() ? RenderGraphResourceRegistry.current.GetTexture(texture) : null;
 
+        /// <summary>
+        /// Determines whether this instance and another specified <see cref="TextureHandle"/> object have the same underlying resource handle.
+        /// </summary>
+        /// <param name="other">The texture handle to compare with the current instance.</param>
+        /// <returns>
+        /// True if both texture handles reference the same underlying resource; otherwise, false.
+        /// </returns>
+        public bool Equals(TextureHandle other) => handle.Equals(other.handle);
+
+        /// <summary>
+        /// Determines whether the specified object is equal to the current <see cref="TextureHandle"/>.
+        /// </summary>
+        /// <param name="obj">The object to compare with the current instance.</param>
+        /// <returns>
+        /// True if the specified object is a <see cref="TextureHandle"/> and references the same underlying resource; otherwise, false.
+        /// </returns>
+        public override bool Equals(object obj) => obj is TextureHandle other && Equals(other);
+
+        /// <summary>
+        /// Returns the hash code for this <see cref="TextureHandle"/>.
+        /// </summary>
+        /// <returns>
+        /// The hash code of the current <see cref="TextureHandle"/>.
+        /// </returns>
+        public override int GetHashCode() => handle.GetHashCode();
+
+        /// <summary>
+        /// Determines whether two <see cref="TextureHandle"/> instances reference the same underlying resource.
+        /// </summary>
+        /// <param name="lhs">The first texture handle to compare.</param>
+        /// <param name="rhs">The second texture handle to compare.</param>
+        /// <returns>
+        /// True if both handles reference the same underlying resource; otherwise, false.
+        /// </returns>
+        public static bool operator ==(TextureHandle lhs, TextureHandle rhs) => lhs.handle.Equals(rhs.handle);
+
+        /// <summary>
+        /// Determines whether two <see cref="TextureHandle"/> instances reference different underlying resources.
+        /// </summary>
+        /// <param name="lhs">The first texture handle to compare.</param>
+        /// <param name="rhs">The second texture handle to compare.</param>
+        /// <returns>
+        /// True if the handles reference different underlying resources; otherwise, false.
+        /// </returns>
+        public static bool operator !=(TextureHandle lhs, TextureHandle rhs) => !lhs.handle.Equals(rhs.handle);
+
         /// <summary>
         /// Return true if the handle is valid.
         /// </summary>

Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/RenderGraphResources.cs

@@ -123,6 +123,21 @@ public bool Equals(ResourceHandle hdl)
         {
             return hdl.m_Value == this.m_Value && hdl.m_Version == this.m_Version && hdl.type == this.type;
         }
+
+        public static bool operator ==(ResourceHandle lhs, ResourceHandle rhs) => lhs.Equals(rhs);
+
+        public static bool operator !=(ResourceHandle lhs, ResourceHandle rhs) => !lhs.Equals(rhs);
+
+        public override bool Equals(object obj) => obj is ResourceHandle other && Equals(other);
+
+        public override int GetHashCode()
+        {
+            var hashCode = HashFNV1A32.Create();
+            hashCode.Append(m_Value);
+            hashCode.Append(m_Version);
+            hashCode.Append(m_Type);
+            return hashCode.value;
+        }
     }
 
     class IRenderGraphResource

Packages/com.unity.render-pipelines.core/Tests/Editor/RenderGraphTests.cs

@@ -6,7 +6,7 @@
 using UnityEngine.TestTools;
 using Unity.Collections;
 using UnityEngine.Rendering.RendererUtils;
-using System.Text.RegularExpressions;
+using UnityEngine.Rendering.RenderGraphModule.NativeRenderPassCompiler;
 
 #if UNITY_EDITOR
 using UnityEditor;
@@ -1489,7 +1489,7 @@ public void ImportedTexturesAreClearedOnFirstUse()
 
             m_RenderGraphTestPipeline.recordRenderGraphBody = (context, camera, cmd) =>
             {
-                var redTexture = CreateRedTexture(kWidth, kHeight);
+                var redTexture = CreateColorTexture(kWidth, kHeight, Color.red);
                 ImportResourceParams importParams = new ImportResourceParams()
                 {
                     clearColor = Color.blue, clearOnFirstUse = true
@@ -1533,6 +1533,128 @@ public void ImportedTexturesAreClearedOnFirstUse()
             pixels.Dispose();
         }
 
+        [Test]
+        public void ImportedTexturesOperatorEqualAndNotEqual()
+        {
+            const int kWidth = 4;
+            const int kHeight = 4;
+
+            m_RenderGraphTestPipeline.recordRenderGraphBody = (context, camera, cmd) =>
+            {
+                var importParams = new ImportResourceParams()
+                {
+                    clearColor = Color.black,
+                    clearOnFirstUse = true
+                };
+
+                var redTexture = CreateColorTexture(kWidth, kHeight, Color.red);
+                var red2Texture = CreateColorTexture(kWidth, kHeight, Color.red);
+                var blackTexture = CreateColorTexture(kWidth, kHeight, Color.black);
+
+                var importedTextureRed = m_RenderGraph.ImportTexture(redTexture, importParams);
+                var importedTextureRed2 = m_RenderGraph.ImportTexture(red2Texture, importParams);
+                var importedTextureRedSame = m_RenderGraph.ImportTexture(redTexture, importParams);
+                var importedTextureBlack = m_RenderGraph.ImportTexture(blackTexture, importParams);
+
+                // Different textures, different handles.
+                Assert.True(importedTextureRed != importedTextureBlack);
+
+                // Different textures, different handles.
+                Assert.True(importedTextureRed != importedTextureRed2);
+
+                // Same texture, different handles.
+                Assert.False(importedTextureRed == importedTextureRedSame);
+
+                importedTextureRedSame = importedTextureRed;
+
+                // Same texture, same handle.
+                Assert.True(importedTextureRed == importedTextureRedSame);
+            };
+
+            m_Camera.Render();
+        }
+
+        [Test]
+        public void CreatedTexturesOperatorEqualAndNotEqual()
+        {
+            m_RenderGraphTestPipeline.recordRenderGraphBody = (context, camera, cmd) =>
+            {
+                const int kWidth = 4;
+                const int kHeight = 4;
+
+                var texture0 = m_RenderGraph.CreateTexture(new TextureDesc(kWidth, kHeight) { colorFormat = GraphicsFormat.R8G8B8A8_UNorm, name = "Texture0" });
+                var texture1 = m_RenderGraph.CreateTexture(new TextureDesc(kWidth, kHeight) { colorFormat = GraphicsFormat.R8G8B8A8_UNorm, name = "Texture1" });
+
+                // Different textures, different handles.
+                Assert.True(texture0 != texture1);
+
+                // Different textures, different handles.
+                Assert.False(texture0 == texture1);
+
+                texture1 = texture0;
+
+                // Same texture, same handles.
+                Assert.True(texture0 == texture1);
+
+                // Same texture, same handles.
+                Assert.False(texture0 != texture1);
+            };
+
+            m_Camera.Render();
+        }
+
+        [Test]
+        public void TexturesOperatorWorksInList()
+        {
+            m_RenderGraphTestPipeline.recordRenderGraphBody = (context, camera, cmd) =>
+            {
+                const int kWidth = 4;
+                const int kHeight = 4;
+
+                var texture0 = m_RenderGraph.CreateTexture(new TextureDesc(kWidth, kHeight) { colorFormat = GraphicsFormat.R8G8B8A8_UNorm, name = "Texture0" });
+                var texture1 = m_RenderGraph.CreateTexture(new TextureDesc(kWidth, kHeight) { colorFormat = GraphicsFormat.R8G8B8A8_UNorm, name = "Texture1" });
+
+                var listHandles = new List<TextureHandle>();
+                listHandles.Add(texture0);
+
+                Assert.True(listHandles.Contains(texture0));
+                Assert.True(!listHandles.Contains(texture1));
+
+                listHandles.Add(texture1);
+
+                Assert.True(listHandles.Contains(texture1));
+            };
+
+            m_Camera.Render();
+        }
+
+        [Test]
+        public void TexturesOperatorWorksInDictionary()
+        {
+            m_RenderGraphTestPipeline.recordRenderGraphBody = (context, camera, cmd) =>
+            {
+                const int kWidth = 4;
+                const int kHeight = 4;
+
+                var texture0 = m_RenderGraph.CreateTexture(new TextureDesc(kWidth, kHeight) { colorFormat = GraphicsFormat.R8G8B8A8_UNorm, name = "Texture0" });
+                var texture1 = m_RenderGraph.CreateTexture(new TextureDesc(kWidth, kHeight) { colorFormat = GraphicsFormat.R8G8B8A8_UNorm, name = "Texture1" });
+
+                var dictionaryHandles = new Dictionary<TextureHandle, int>();
+                dictionaryHandles.Add(texture0, 0);
+
+                Assert.True(dictionaryHandles.ContainsKey(texture0));
+                Assert.True(dictionaryHandles.TryGetValue(texture0, out var value0) && value0 == 0);
+                Assert.True(!dictionaryHandles.ContainsKey(texture1));
+
+                dictionaryHandles.Add(texture1, 1);
+
+                Assert.True(dictionaryHandles.ContainsKey(texture1));
+                Assert.True(dictionaryHandles.TryGetValue(texture1, out var value1) && value1 == 1);
+            };
+
+            m_Camera.Render();
+        }
+
         [Test]
         public void RequestAsyncReadbackIntoNativeArrayWorks()
         {
@@ -1552,7 +1674,7 @@ public void RequestAsyncReadbackIntoNativeArrayWorks()
 
                 passExecuted = true;
 
-                var redTexture = CreateRedTexture(kWidth, kHeight);
+                var redTexture = CreateColorTexture(kWidth, kHeight, Color.red);
                 var texture0 = m_RenderGraph.ImportTexture(redTexture);
 
                 pixels = new NativeArray<byte>(kWidth * kHeight * 4, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
@@ -1603,11 +1725,8 @@ void RenderGraphTest_AsyncReadbackCallback(AsyncGPUReadbackRequest request, ref
             }
         }
 
-        RTHandle CreateRedTexture(int width, int height)
+        RTHandle CreateColorTexture(int width, int height, Color color)
         {
-            // Create a red color
-            Color redColor = Color.red;
-
             // Initialize the RTHandle system if necessary
             RTHandles.Initialize(width, height);
 
@@ -1625,7 +1744,7 @@ RTHandle CreateRedTexture(int width, int height)
             {
                 for (int x = 0; x < tempTexture.width; x++)
                 {
-                    tempTexture.SetPixel(x, y, redColor);
+                    tempTexture.SetPixel(x, y, color);
                 }
             }
             tempTexture.Apply();