'push'

Packages/com.waveharmonic.crest/Runtime/Scripts/Meniscus/Meniscus.Universal.cs

@@ -0,0 +1,118 @@
+// Crest Water System
+// Copyright © 2024 Wave Harmonic. All rights reserved.
+
+#if d_UnityURP
+
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace WaveHarmonic.Crest
+{
+    partial class Meniscus
+    {
+        internal sealed class MeniscusRendererURP : MeniscusRenderer
+        {
+            readonly MeniscusRenderPass _MaskRenderPass = new();
+
+            public MeniscusRendererURP(WaterRenderer water, Meniscus meniscus) : base(water, meniscus)
+            {
+
+            }
+
+            public override void OnBeginCameraRendering(Camera camera)
+            {
+                if (!ShouldExecute(camera))
+                {
+                    return;
+                }
+
+                _MaskRenderPass._Renderer = this;
+                _MaskRenderPass.EnqueuePass(camera);
+            }
+
+            public override void OnEndCameraRendering(Camera camera)
+            {
+
+            }
+
+            sealed partial class MeniscusRenderPass : ScriptableRenderPass
+            {
+                const string k_Name = k_Draw;
+
+                internal MeniscusRenderer _Renderer;
+
+                bool _RequiresOpaqueTexture;
+
+                public MeniscusRenderPass()
+                {
+                    renderPassEvent = RenderPassEvent.AfterRenderingTransparents;
+                }
+
+                internal void EnqueuePass(Camera camera)
+                {
+                    // TODO: check if we need to even enqueue a pass
+                    var renderer = camera.GetUniversalAdditionalCameraData().scriptableRenderer;
+
+#if UNITY_EDITOR
+                    if (renderer == null)
+                    {
+                        return;
+                    }
+#endif
+
+                    _RequiresOpaqueTexture = _Renderer._Meniscus.RequiresOpaqueTexture;
+
+                    ConfigureInput(_RequiresOpaqueTexture ? ScriptableRenderPassInput.Color : ScriptableRenderPassInput.None);
+
+                    // Enqueue the pass. This happens every frame.
+                    renderer.EnqueuePass(this);
+                }
+
+#if UNITY_6000_0_OR_NEWER
+                class PassData
+                {
+                    public UniversalCameraData _CameraData;
+                    public MeniscusRenderer _Renderer;
+                }
+
+                public override void RecordRenderGraph(UnityEngine.Rendering.RenderGraphModule.RenderGraph graph, ContextContainer frame)
+                {
+                    using (var builder = graph.AddRasterRenderPass<PassData>(k_Name, out var data))
+                    {
+                        builder.AllowPassCulling(false);
+
+                        var resources = frame.Get<UniversalResourceData>();
+
+                        if (_RequiresOpaqueTexture)
+                        {
+                            builder.UseTexture(resources.cameraOpaqueTexture);
+                        }
+
+                        data._CameraData = frame.Get<UniversalCameraData>();
+                        data._Renderer = _Renderer;
+
+                        builder.SetRenderAttachment(resources.activeColorTexture, index: 0);
+
+                        builder.SetRenderFunc<PassData>((data, context) =>
+                        {
+                            data._Renderer.Execute(data._CameraData.camera, new RasterCommandWrapper(context.cmd));
+                        });
+                    }
+                }
+
+                [System.Obsolete]
+#endif
+                public override void Execute(ScriptableRenderContext context, ref RenderingData data)
+                {
+                    var buffer = CommandBufferPool.Get(k_Name);
+                    _Renderer.Execute(data.cameraData.camera, new CommandWrapper(buffer));
+                    context.ExecuteCommandBuffer(buffer);
+                    CommandBufferPool.Release(buffer);
+                }
+            }
+        }
+    }
+}
+
+#endif