升级6.4.升级水，升级天气

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/AlbedoLod.cs

@@ -18,7 +18,8 @@ namespace WaveHarmonic.Crest
         internal override string ID => "Albedo";
         internal override Color GizmoColor => s_GizmoColor;
         private protected override Color ClearColor => Color.clear;
-        private protected override bool NeedToReadWriteTextureData => false;
+        private protected override bool NeedToReadWriteTextureData => Blur;
+        internal override bool SkipEndOfFrame => true;
 
         private protected override GraphicsFormat RequestedTextureFormat => _TextureFormatMode switch
         {

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/AnimatedWavesLod.cs

@@ -1,13 +1,15 @@
 // Crest Water System
 // Copyright © 2024 Wave Harmonic. All rights reserved.
 
+using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.Experimental.Rendering;
 using UnityEngine.Rendering;
+using WaveHarmonic.Crest.Internal;
 
 namespace WaveHarmonic.Crest
 {
-    abstract class BakedWaveData : ScriptableObject
+    abstract class BakedWaveData : CustomScriptableObject
     {
         public abstract ICollisionProvider CreateCollisionProvider();
         public abstract float WindSpeed { get; }
@@ -20,6 +22,7 @@ namespace WaveHarmonic.Crest
     /// <summary>
     /// The source of collisions (ie water shape).
     /// </summary>
+    [System.Obsolete("Please use QuerySource and LodQuerySource.")]
     [@GenerateDoc]
     public enum CollisionSource
     {
@@ -67,13 +70,9 @@ namespace WaveHarmonic.Crest
     {
         // NOTE: numbers must be in order for defaults to work (everything first).
 
-        /// <inheritdoc cref="Generated.CollisionLayers.Everything"/>
-        [Tooltip("All layers.")]
-        Everything = -1,
-
         /// <inheritdoc cref="Generated.CollisionLayers.Nothing"/>
         [Tooltip("No extra layers (ie single layer).")]
-        Nothing,
+        Nothing = 0,
 
         /// <inheritdoc cref="Generated.CollisionLayers.DynamicWaves"/>
         [Tooltip("Separate layer for dynamic waves.\n\nDynamic waves are normally combined together for efficiency. By enabling this layer, dynamic waves are combined and added in a separate pass.")]
@@ -82,6 +81,29 @@ namespace WaveHarmonic.Crest
         /// <inheritdoc cref="Generated.CollisionLayers.Displacement"/>
         [Tooltip("Extra displacement layer for visual displacement.")]
         Displacement = 1 << 2,
+
+        /// <inheritdoc cref="Generated.CollisionLayers.Everything"/>
+        [Tooltip("All layers.")]
+        Everything = ~0,
+    }
+
+    /// <summary>
+    /// The wave sampling method to determine quality and performance.
+    /// </summary>
+    [@GenerateDoc]
+    public enum WaveSampling
+    {
+        /// <inheritdoc cref="Generated.WaveSampling.Automatic"/>
+        [Tooltip("Automatically chooses the other options as needed (512+ resolution needs precision).")]
+        Automatic,
+
+        /// <inheritdoc cref="Generated.WaveSampling.Performance"/>
+        [Tooltip("Reduces samples by copying waves from higher LODs to lower LODs.\n\nBest for resolutions lower than 512.")]
+        Performance,
+
+        /// <inheritdoc cref="Generated.WaveSampling.Precision"/>
+        [Tooltip("Samples directly from the wave buffers to preserve wave quality.\n\nNeeded for higher resolutions (512+). Higher LOD counts can also benefit with this enabled.")]
+        Precision,
     }
 
     /// <summary>
@@ -108,14 +130,33 @@ namespace WaveHarmonic.Crest
     [@FilterEnum(nameof(_TextureFormatMode), Filtered.Mode.Exclude, (int)LodTextureFormatMode.Automatic)]
     public sealed partial class AnimatedWavesLod : Lod<ICollisionProvider>
     {
+        [Tooltip("Collision layers to enable.\n\nSome layers will have overhead with CPU, GPU and memory.")]
+        [@Enable(nameof(_QuerySource), nameof(LodQuerySource.GPU))]
+        [@GenerateAPI]
+        [@DecoratedField, SerializeField]
+        internal CollisionLayers _CollisionLayers = CollisionLayers.Everything;
+
+        [@Enable(nameof(_QuerySource), nameof(LodQuerySource.CPU))]
+        [@DecoratedField, SerializeField]
+        internal BakedWaveData _BakedWaveData;
+
         [@Space(10)]
 
-        [Tooltip("Shifts wavelengths to maintain quality for higher resolutions.\n\nSet this to 2 to improve wave quality. In some cases like flowing rivers, this can make a substantial difference to visual stability. We recommend doubling the Resolution on the WaterRenderer component to preserve detail after making this change.")]
-        [@Range(1f, 4f)]
+        [Tooltip("The wave sampling method to determine quality and performance.")]
         [@GenerateAPI]
+        [@DecoratedField]
+        [SerializeField]
+        internal WaveSampling _WaveSampling;
+
+        [Tooltip("Shifts wavelengths to maintain quality for higher resolutions.\n\nSet this to 2 to improve wave quality. In some cases like flowing rivers, this can make a substantial difference to visual stability. We recommend doubling the Resolution on the WaterRenderer component to preserve detail after making this change.")]
+        [@Enable(nameof(_WaveSampling), nameof(WaveSampling.Performance))]
+        [@Range(1f, 4f)]
+        [@GenerateAPI(Getter.Custom)]
         [SerializeField]
         float _WaveResolutionMultiplier = 1f;
 
+        [@Space(10)]
+
         [Tooltip("How much waves are dampened in shallow water.")]
         [@Range(0f, 1f)]
         [@GenerateAPI]
@@ -129,30 +170,6 @@ namespace WaveHarmonic.Crest
         float _ShallowsMaximumDepth = 1000f;
 
 
-        [@Heading("Collisions")]
-
-        [Tooltip("Where to obtain water shape on CPU for physics / gameplay.")]
-        [@GenerateAPI(Setter.Internal)]
-        [@DecoratedField, SerializeField]
-        internal CollisionSource _CollisionSource = CollisionSource.GPU;
-
-        [Tooltip("Collision layers to enable.\n\nSome layers will have overhead with CPU, GPU and memory.")]
-        [@Predicated(nameof(_CollisionSource), inverted: true, nameof(CollisionSource.GPU))]
-        [@GenerateAPI]
-        [@DecoratedField, SerializeField]
-        internal CollisionLayers _CollisionLayers = CollisionLayers.Everything;
-
-        [Tooltip("Maximum number of wave queries that can be performed when using GPU queries.")]
-        [@Predicated(nameof(_CollisionSource), true, nameof(CollisionSource.GPU))]
-        [@GenerateAPI(Setter.None)]
-        [@DecoratedField, SerializeField]
-        int _MaximumQueryCount = QueryBase.k_DefaultMaximumQueryCount;
-
-        [@Predicated(nameof(_CollisionSource), true, nameof(CollisionSource.CPU))]
-        [@DecoratedField, SerializeField]
-        internal BakedWaveData _BakedWaveData;
-
-
         const string k_DrawCombine = "Combine";
 
 
@@ -160,7 +177,6 @@ namespace WaveHarmonic.Crest
         {
             public static readonly int s_WaveBuffer = Shader.PropertyToID("_Crest_WaveBuffer");
             public static readonly int s_DynamicWavesTarget = Shader.PropertyToID("_Crest_DynamicWavesTarget");
-            public static readonly int s_AnimatedWavesTarget = Shader.PropertyToID("_Crest_AnimatedWavesTarget");
             public static readonly int s_AttenuationInShallows = Shader.PropertyToID("_Crest_AttenuationInShallows");
         }
 
@@ -171,6 +187,9 @@ namespace WaveHarmonic.Crest
         /// </summary>
         internal static bool s_Combine = true;
 
+        WaterResources.ShapeCombineCompute _CombineShader;
+        RenderTexture _PersistentDataTexture;
+
         internal override string ID => "AnimatedWaves";
         internal override string Name => "Animated Waves";
         internal override Color GizmoColor => s_GizmoColor;
@@ -187,17 +206,13 @@ namespace WaveHarmonic.Crest
             _ => throw new System.NotImplementedException(),
         };
 
-        ComputeShader _CombineShader;
-
-        int _KernalShapeCombine = -1;
-        int _KernalShapeCombine_DISABLE_COMBINE = -1;
-        int _KernalShapeCombine_FLOW_ON = -1;
-        int _KernalShapeCombine_FLOW_ON_DISABLE_COMBINE = -1;
-        int _KernalShapeCombine_DYNAMIC_WAVE_SIM_ON = -1;
-        int _KernalShapeCombine_DYNAMIC_WAVE_SIM_ON_DISABLE_COMBINE = -1;
-        int _KernalShapeCombine_FLOW_ON_DYNAMIC_WAVE_SIM_ON = -1;
-        int _KernalShapeCombine_FLOW_ON_DYNAMIC_WAVE_SIM_ON_DISABLE_COMBINE = -1;
-
+        internal bool PreserveWaveQuality => WaveSampling switch
+        {
+            WaveSampling.Automatic => Resolution >= 512,
+            WaveSampling.Performance => false,
+            WaveSampling.Precision => true,
+            _ => throw new System.NotImplementedException(),
+        };
 
         internal AnimatedWavesLod()
         {
@@ -208,35 +223,67 @@ namespace WaveHarmonic.Crest
 
         internal override void Initialize()
         {
-            _CombineShader = WaterResources.Instance.Compute._ShapeCombine;
-            if (_CombineShader == null)
+            _CombineShader = WaterResources.Instance._ComputeLibrary._ShapeCombineCompute;
+            if (_CombineShader._Shader == null)
             {
                 _Valid = false;
                 return;
             }
 
             base.Initialize();
+
+            if (Persistent && !_Water.IsMultipleViewpointMode)
+            {
+                _PersistentDataTexture = CreateLodDataTextures();
+            }
         }
 
-        private protected override void Allocate()
+        internal override void Destroy()
         {
-            base.Allocate();
+            base.Destroy();
 
-            _KernalShapeCombine = _CombineShader.FindKernel("ShapeCombine");
-            _KernalShapeCombine_DISABLE_COMBINE = _CombineShader.FindKernel("ShapeCombine_DISABLE_COMBINE");
-            _KernalShapeCombine_FLOW_ON = _CombineShader.FindKernel("ShapeCombine_FLOW_ON");
-            _KernalShapeCombine_FLOW_ON_DISABLE_COMBINE = _CombineShader.FindKernel("ShapeCombine_FLOW_ON_DISABLE_COMBINE");
-            _KernalShapeCombine_DYNAMIC_WAVE_SIM_ON = _CombineShader.FindKernel("ShapeCombine_DYNAMIC_WAVE_SIM_ON");
-            _KernalShapeCombine_DYNAMIC_WAVE_SIM_ON_DISABLE_COMBINE = _CombineShader.FindKernel("ShapeCombine_DYNAMIC_WAVE_SIM_ON_DISABLE_COMBINE");
-            _KernalShapeCombine_FLOW_ON_DYNAMIC_WAVE_SIM_ON = _CombineShader.FindKernel("ShapeCombine_FLOW_ON_DYNAMIC_WAVE_SIM_ON");
-            _KernalShapeCombine_FLOW_ON_DYNAMIC_WAVE_SIM_ON_DISABLE_COMBINE = _CombineShader.FindKernel("ShapeCombine_FLOW_ON_DYNAMIC_WAVE_SIM_ON_DISABLE_COMBINE");
+            if (_PersistentDataTexture != null) _PersistentDataTexture.Release();
+            Helpers.Destroy(_PersistentDataTexture);
+
+            foreach (var data in _AdditionalCameraData.Values)
+            {
+                if (data != null) data.Release();
+                Helpers.Destroy(data);
+            }
+
+            _AdditionalCameraData.Clear();
+        }
+
+        internal override void SetGlobals(bool enable)
+        {
+            base.SetGlobals(enable);
+
+            if (_Water.IsRunningWithoutGraphics)
+            {
+                return;
+            }
+
+            if (Persistent)
+            {
+                Shader.SetGlobalTexture(_TextureSourceShaderID, enable && Enabled ? _PersistentDataTexture : NullTexture);
+            }
         }
 
         internal override void BuildCommandBuffer(WaterRenderer water, CommandBuffer buffer)
         {
             buffer.BeginSample(ID);
 
-            FlipBuffers();
+            FlipBuffers(buffer);
+
+            // Flip textures
+            if (Persistent)
+            {
+                (_PersistentDataTexture, DataTexture) = (DataTexture, _PersistentDataTexture);
+
+                // Update current and previous. Latter for MVs and/or VFX.
+                buffer.SetGlobalTexture(_TextureSourceShaderID, _PersistentDataTexture);
+                buffer.SetGlobalTexture(_TextureShaderID, DataTexture);
+            }
 
             Shader.SetGlobalFloat(ShaderIDs.s_AttenuationInShallows, _AttenuationInShallows);
 
@@ -244,6 +291,18 @@ namespace WaveHarmonic.Crest
             buffer.GetTemporaryRT(ShaderIDs.s_WaveBuffer, DataTexture.descriptor);
             CoreUtils.SetRenderTarget(buffer, ShaderIDs.s_WaveBuffer, ClearFlag.Color, ClearColor);
 
+            // Custom clear because clear not working.
+            if (Helpers.RequiresCustomClear && WaterResources.Instance.Compute._Clear != null)
+            {
+                var compute = WaterResources.Instance._ComputeLibrary._ClearCompute;
+                var wrapper = new PropertyWrapperCompute(buffer, compute._Shader, compute._KernelClearTarget);
+                compute.SetVariantForFormat(wrapper, DataTexture.graphicsFormat);
+                wrapper.SetTexture(Crest.ShaderIDs.s_Target, ShaderIDs.s_WaveBuffer);
+                wrapper.SetVector(Crest.ShaderIDs.s_ClearMask, Color.white);
+                wrapper.SetVector(Crest.ShaderIDs.s_ClearColor, ClearColor);
+                wrapper.Dispatch(Resolution / k_ThreadGroupSizeX, Resolution / k_ThreadGroupSizeY, Slices);
+            }
+
             // LOD dependent data.
             // Write to per-octave _WaveBuffers. Not the same as _AnimatedWaves.
             // Draw any data with lod preference.
@@ -254,54 +313,53 @@ namespace WaveHarmonic.Crest
 
             // Combine the LODs - copy results from biggest LOD down to LOD 0
             {
-                var combineShaderKernel = _KernalShapeCombine;
-                var combineShaderKernel_lastLOD = _KernalShapeCombine_DISABLE_COMBINE;
-                {
-                    var isFlowOn = _Water._FlowLod.Enabled;
-                    var isDynamicWavesOn = _Water._DynamicWavesLod.Enabled && !_CollisionLayers.HasFlag(CollisionLayers.DynamicWaves);
+                var wrapper = new PropertyWrapperCompute
+                (
+                    buffer,
+                    _CombineShader._Shader,
+                    PreserveWaveQuality
+                        ? _CombineShader._CopyAnimatedWavesKernel
+                        : _CombineShader._CombineAnimatedWavesKernel
+                );
 
-                    // Set the shader kernels that we will use.
-                    if (isFlowOn && isDynamicWavesOn)
-                    {
-                        combineShaderKernel = _KernalShapeCombine_FLOW_ON_DYNAMIC_WAVE_SIM_ON;
-                        combineShaderKernel_lastLOD = _KernalShapeCombine_FLOW_ON_DYNAMIC_WAVE_SIM_ON_DISABLE_COMBINE;
-                    }
-                    else if (isFlowOn)
-                    {
-                        combineShaderKernel = _KernalShapeCombine_FLOW_ON;
-                        combineShaderKernel_lastLOD = _KernalShapeCombine_FLOW_ON_DISABLE_COMBINE;
-                    }
-                    else if (isDynamicWavesOn)
-                    {
-                        combineShaderKernel = _KernalShapeCombine_DYNAMIC_WAVE_SIM_ON;
-                        combineShaderKernel_lastLOD = _KernalShapeCombine_DYNAMIC_WAVE_SIM_ON_DISABLE_COMBINE;
-                    }
+                if (_Water._DynamicWavesLod.Enabled)
+                {
+                    _Water._DynamicWavesLod.Bind(wrapper);
                 }
 
-                buffer.BeginSample(k_DrawCombine);
+                // Start with last LOD which does not combine.
+                wrapper.SetKeyword(_CombineShader._CombineKeyword, false);
+                wrapper.SetKeyword(_CombineShader._DynamicWavesKeyword, _Water._DynamicWavesLod.Enabled && !PreserveWaveQuality && !_CollisionLayers.HasFlag(CollisionLayers.DynamicWaves));
 
-                // Combine waves.
-                for (var slice = lastSlice; slice >= 0; slice--)
+                // The per-octave wave buffers we read from.
+                wrapper.SetTexture(ShaderIDs.s_WaveBuffer, ShaderIDs.s_WaveBuffer);
+
+                // Set the animated waves texture where we read/write to combine the results.
+                wrapper.SetTexture(Crest.ShaderIDs.s_Target, DataTexture);
+
+                if (PreserveWaveQuality)
                 {
-                    var kernel = slice < lastSlice && s_Combine
-                        ? combineShaderKernel : combineShaderKernel_lastLOD;
-
-                    var wrapper = new PropertyWrapperCompute(buffer, _CombineShader, kernel);
-
-                    // The per-octave wave buffers we read from.
-                    wrapper.SetTexture(ShaderIDs.s_WaveBuffer, ShaderIDs.s_WaveBuffer);
-
-                    if (_Water._DynamicWavesLod.Enabled) _Water._DynamicWavesLod.Bind(wrapper);
-
-                    // Set the animated waves texture where we read/write to combine the results. Use
-                    // compute suffix to avoid collision as a file already uses the normal name.
-                    wrapper.SetTexture(Crest.ShaderIDs.s_Target, DataTexture);
-                    wrapper.SetInteger(Lod.ShaderIDs.s_LodIndex, slice);
-
-                    wrapper.Dispatch(threadSize, threadSize, 1);
+                    wrapper.Dispatch(threadSize, threadSize, Slices);
                 }
+                else
+                {
+                    buffer.BeginSample(k_DrawCombine);
 
-                buffer.EndSample(k_DrawCombine);
+                    // Combine waves.
+                    for (var slice = lastSlice; slice >= 0; slice--)
+                    {
+                        wrapper.SetInteger(Lod.ShaderIDs.s_LodIndex, slice);
+                        wrapper.Dispatch(threadSize, threadSize, 1);
+
+                        if (slice == lastSlice)
+                        {
+                            // From here on, use combine.
+                            wrapper.SetKeyword(_CombineShader._CombineKeyword, s_Combine);
+                        }
+                    }
+
+                    buffer.EndSample(k_DrawCombine);
+                }
             }
 
             buffer.ReleaseTemporaryRT(ShaderIDs.s_WaveBuffer);
@@ -312,20 +370,15 @@ namespace WaveHarmonic.Crest
 
             // Alpha channel is cleared in combine step, but if any inputs draw in post-combine
             // step then alpha may have data.
-            var clear = WaterResources.Instance.Compute._Clear;
-            if (drawn && clear != null)
+            if (drawn && WaterResources.Instance.Compute._Clear != null)
             {
-                buffer.SetComputeTextureParam(clear, 0, Crest.ShaderIDs.s_Target, DataTexture);
-                buffer.SetComputeVectorParam(clear, Crest.ShaderIDs.s_ClearMask, Color.black);
-                buffer.SetComputeVectorParam(clear, Crest.ShaderIDs.s_ClearColor, Color.clear);
-                buffer.DispatchCompute
-                (
-                    clear,
-                    0,
-                    Resolution / k_ThreadGroupSizeX,
-                    Resolution / k_ThreadGroupSizeY,
-                    Slices
-                );
+                var compute = WaterResources.Instance._ComputeLibrary._ClearCompute;
+                var wrapper = new PropertyWrapperCompute(buffer, compute._Shader, compute._KernelClearTarget);
+                compute.SetVariantForFormat(wrapper, DataTexture.graphicsFormat);
+                wrapper.SetTexture(Crest.ShaderIDs.s_Target, DataTexture);
+                wrapper.SetVector(Crest.ShaderIDs.s_ClearMask, Color.black);
+                wrapper.SetVector(Crest.ShaderIDs.s_ClearColor, Color.clear);
+                wrapper.Dispatch(Resolution / k_ThreadGroupSizeX, Resolution / k_ThreadGroupSizeY, Slices);
             }
 
             // Pack height data into alpha channel.
@@ -355,15 +408,21 @@ namespace WaveHarmonic.Crest
             }
 
             // Transfer Dynamic Waves to Animated Waves.
-            if (_CollisionLayers.HasFlag(CollisionLayers.DynamicWaves) && _Water._DynamicWavesLod.Enabled)
+            if ((_CollisionLayers.HasFlag(CollisionLayers.DynamicWaves) || PreserveWaveQuality) && _Water._DynamicWavesLod.Enabled)
             {
                 buffer.BeginSample(k_DrawCombine);
                 // Clearing not required as we overwrite enter texture.
                 buffer.GetTemporaryRT(ShaderIDs.s_DynamicWavesTarget, DataTexture.descriptor);
 
-                var wrapper = new PropertyWrapperCompute(buffer, _CombineShader, 9);
+                var wrapper = new PropertyWrapperCompute(buffer, _CombineShader._Shader, _CombineShader._CombineDynamicWavesKernel);
 
-                wrapper.SetTexture(ShaderIDs.s_DynamicWavesTarget, ShaderIDs.s_DynamicWavesTarget);
+                // Flow keyword is already set, and Dynamic Waves already bound. If binding Dynamic
+                // Waves becomes kernel specific (eg binding textures), then we need to rebind.
+
+                // Start with last LOD which does not combine.
+                wrapper.SetKeyword(_CombineShader._CombineKeyword, false);
+
+                wrapper.SetTexture(Crest.ShaderIDs.s_Target, ShaderIDs.s_DynamicWavesTarget);
 
                 _Water._DynamicWavesLod.Bind(wrapper);
 
@@ -373,18 +432,21 @@ namespace WaveHarmonic.Crest
                     wrapper.SetInteger(Lod.ShaderIDs.s_LodIndex, slice);
                     wrapper.Dispatch(threadSize, threadSize, 1);
 
-                    // Change to kernel with combine enabled.
                     if (slice == lastSlice)
                     {
-                        wrapper = new(buffer, _CombineShader, 8);
+                        // From here on, use combine.
+                        wrapper.SetKeyword(_CombineShader._CombineKeyword, s_Combine);
                     }
                 }
 
                 // Copy Dynamic Waves displacement into Animated Waves.
+                if (WaterResources.Instance.Compute._Blit != null)
                 {
-                    wrapper = new(buffer, _CombineShader, 10);
-                    wrapper.SetTexture(ShaderIDs.s_AnimatedWavesTarget, DataTexture);
-                    wrapper.SetTexture(ShaderIDs.s_DynamicWavesTarget, ShaderIDs.s_DynamicWavesTarget);
+                    var compute = WaterResources.Instance._ComputeLibrary._BlitCompute;
+                    wrapper = new(buffer, compute._Shader, 0);
+                    compute.SetVariantForFormat(wrapper, DataTexture.graphicsFormat);
+                    wrapper.SetTexture(Crest.ShaderIDs.s_Source, ShaderIDs.s_DynamicWavesTarget);
+                    wrapper.SetTexture(Crest.ShaderIDs.s_Target, DataTexture);
                     wrapper.Dispatch(threadSize, threadSize, Slices);
                 }
 
@@ -393,7 +455,10 @@ namespace WaveHarmonic.Crest
 
                 // Query collisions including Dynamic Waves.
                 // Does not require copying the water level as they are added with zero alpha.
-                Provider.UpdateQueries(_Water, CollisionLayer.AfterDynamicWaves);
+                if (_CollisionLayers.HasFlag(CollisionLayers.DynamicWaves))
+                {
+                    Provider.UpdateQueries(_Water, CollisionLayer.AfterDynamicWaves);
+                }
             }
 
             if (_CollisionLayers.HasFlag(CollisionLayers.Displacement))
@@ -408,13 +473,6 @@ namespace WaveHarmonic.Crest
                 Queryable?.UpdateQueries(_Water);
             }
 
-            if (BufferCount > 1)
-            {
-                // Update current and previous. Latter for MVs and/or VFX.
-                Shader.SetGlobalTexture(_TextureSourceShaderID, _Targets.Previous(1));
-                Shader.SetGlobalTexture(_TextureShaderID, DataTexture);
-            }
-
             buffer.EndSample(ID);
         }
 
@@ -426,50 +484,59 @@ namespace WaveHarmonic.Crest
         /// <summary>
         /// Provides water shape to CPU.
         /// </summary>
-        private protected override ICollisionProvider CreateProvider(bool enable)
+        private protected override ICollisionProvider CreateProvider(bool onEnable)
         {
-            ICollisionProvider result = null;
+            ICollisionProvider provider = ICollisionProvider.None;
 
             Queryable?.CleanUp();
 
-            if (!enable)
+            // Respect user choice and early exit. If not in OnEnable, then none provider.
+            // Do not check Enabled, as it includes _Valid which checks for GPU.
+            if (!_Enabled || !onEnable)
             {
-                return ICollisionProvider.None;
+                return provider;
             }
 
-            switch (_CollisionSource)
+            var source = QuerySource;
+
+            if (_Water.Surface.IsQuadMesh)
             {
-                case CollisionSource.None:
-                    result = ICollisionProvider.None;
-                    break;
-                case CollisionSource.GPU:
-                    if (_Valid && !_Water.IsRunningWithoutGraphics)
+                source = LodQuerySource.None;
+            }
+
+            switch (source)
+            {
+                case LodQuerySource.GPU:
+                {
+                    if (_Valid)
                     {
-                        result = new CollisionQueryWithPasses(_Water);
+                        provider = ICollisionProvider.Create(_Water);
                     }
 
                     if (_Water.IsRunningWithoutGraphics)
                     {
-                        Debug.LogError($"Crest: GPU queries not supported in headless/batch mode. To resolve, assign an Animated Wave Settings asset to the {nameof(WaterRenderer)} component and set the Collision Source to be a CPU option.");
+                        Debug.LogError("Crest: GPU queries requires a GPU. Please consider CPU queries if running from a server without a GPU.");
                     }
+
                     break;
-                case CollisionSource.CPU:
+                }
+                case LodQuerySource.CPU:
+                {
                     if (_BakedWaveData != null)
                     {
-                        result = _BakedWaveData.CreateCollisionProvider();
+                        provider = _BakedWaveData.CreateCollisionProvider();
                     }
+
                     break;
+                }
             }
 
-            if (result == null)
-            {
-                // This should not be hit, but can be if compute shaders aren't loaded correctly.
-                // They will print out appropriate errors. Don't just return null and have null reference
-                // exceptions spamming the logs.
-                return ICollisionProvider.None;
-            }
+            // This should not be hit, but can be if compute shaders aren't loaded correctly.
+            // They will print out appropriate errors. Don't just return null and have null
+            // reference exceptions spamming the logs.
+            provider ??= ICollisionProvider.None;
 
-            return result;
+            return provider;
         }
 
         //
@@ -484,15 +551,17 @@ namespace WaveHarmonic.Crest
             public readonly float _ViewerAltitudeLevelAlpha;
             public readonly int _Slice;
             public readonly int _Slices;
+            public readonly bool _HighQualityCombine;
 
-            public WavelengthFilter(WaterRenderer water, int slice)
+            public WavelengthFilter(WaterRenderer water, int slice, int resolution)
             {
                 _Slice = slice;
                 _Slices = water.LodLevels;
-                _Maximum = water.MaximumWavelength(slice);
+                _Maximum = water.MaximumWavelength(slice, resolution);
                 _Minimum = _Maximum * 0.5f;
-                _TransitionThreshold = water.MaximumWavelength(_Slices - 1) * 0.5f;
+                _TransitionThreshold = water.MaximumWavelength(_Slices - 1, resolution) * 0.5f;
                 _ViewerAltitudeLevelAlpha = water.ViewerAltitudeLevelAlpha;
+                _HighQualityCombine = water.AnimatedWavesLod.PreserveWaveQuality;
             }
         }
 
@@ -513,7 +582,7 @@ namespace WaveHarmonic.Crest
             // If approaching end of lod chain, start smoothly transitioning any large wavelengths across last two lods
             if (wavelength >= filter._TransitionThreshold)
             {
-                if (filter._Slice == filter._Slices - 2)
+                if (filter._Slice == filter._Slices - 2 && !filter._HighQualityCombine)
                 {
                     return 1f - filter._ViewerAltitudeLevelAlpha;
                 }
@@ -529,12 +598,12 @@ namespace WaveHarmonic.Crest
                 return 1f;
             }
 
-            return 0f;
+            return filter._HighQualityCombine ? 1f : 0f;
         }
 
-        internal static float FilterByWavelength(WaterRenderer water, int slice, float wavelength)
+        internal static float FilterByWavelength(WaterRenderer water, int slice, float wavelength, int resolution)
         {
-            return FilterByWavelength(new(water, slice), wavelength);
+            return FilterByWavelength(new(water, slice, resolution), wavelength);
         }
 
 
@@ -550,8 +619,83 @@ namespace WaveHarmonic.Crest
         {
             s_Inputs.Clear();
         }
+    }
+
+    // Multiple Viewpoints
+    partial class AnimatedWavesLod
+    {
+        readonly Dictionary<Camera, RenderTexture> _AdditionalCameraData = new();
+
+        internal override void LoadCameraData(Camera camera)
+        {
+            base.LoadCameraData(camera);
+
+            if (!Persistent)
+            {
+                return;
+            }
+
+            if (!_AdditionalCameraData.ContainsKey(camera))
+            {
+                _PersistentDataTexture = CreateLodDataTextures();
+                Clear(_PersistentDataTexture);
+                _AdditionalCameraData.Add(camera, _PersistentDataTexture);
+            }
+            else
+            {
+                _PersistentDataTexture = _AdditionalCameraData[camera];
+            }
+        }
+
+        internal override void StoreCameraData(Camera camera)
+        {
+            base.StoreCameraData(camera);
+
+            if (!Persistent)
+            {
+                return;
+            }
+
+            _AdditionalCameraData[camera] = _PersistentDataTexture;
+        }
+
+        internal override void RemoveCameraData(Camera camera)
+        {
+            base.RemoveCameraData(camera);
+
+            if (_AdditionalCameraData.ContainsKey(camera))
+            {
+                var rt = _AdditionalCameraData[camera];
+                if (rt != null) rt.Release();
+                Helpers.Destroy(rt);
+                _AdditionalCameraData.Remove(camera);
+            }
+        }
+    }
+
+    // API
+    partial class AnimatedWavesLod
+    {
+        float GetWaveResolutionMultiplier()
+        {
+            return PreserveWaveQuality ? 1f : _WaveResolutionMultiplier;
+        }
+    }
+
+    partial class AnimatedWavesLod
+    {
+        [@HideInInspector]
+        [@System.Obsolete("Please use QuerySource instead.")]
+        [Tooltip("Where to obtain water shape on CPU for physics / gameplay.")]
+        [@GenerateAPI(Setter.Internal)]
+        [@DecoratedField, SerializeField]
+        internal CollisionSource _CollisionSource = CollisionSource.GPU;
+    }
 
 #if UNITY_EDITOR
+    // Editor
+    partial class AnimatedWavesLod
+    {
         [@OnChange]
         private protected override void OnChange(string propertyPath, object previousValue)
         {
@@ -560,13 +704,10 @@ namespace WaveHarmonic.Crest
             switch (propertyPath)
             {
                 case nameof(_CollisionLayers):
-                case nameof(_CollisionSource):
-                    if (_Water == null || !_Water.isActiveAndEnabled || !Enabled) return;
-                    Queryable?.CleanUp();
-                    InitializeProvider(true);
+                    ResetQueryChange();
                     break;
             }
         }
-#endif
     }
+#endif
 }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/ClipLod.cs

@@ -3,7 +3,6 @@
 
 using UnityEngine;
 using UnityEngine.Experimental.Rendering;
-using UnityEngine.Rendering;
 using WaveHarmonic.Crest.Utility;
 
 namespace WaveHarmonic.Crest
@@ -37,11 +36,6 @@ namespace WaveHarmonic.Crest
         [@DecoratedField, SerializeField]
         internal DefaultClippingState _DefaultClippingState = DefaultClippingState.NothingClipped;
 
-        static new class ShaderIDs
-        {
-            public static readonly int s_ClipByDefault = Shader.PropertyToID("g_Crest_ClipByDefault");
-        }
-
         internal static readonly Color s_GizmoColor = new(0f, 1f, 1f, 0.5f);
 
         internal override string ID => "Clip";
@@ -50,6 +44,7 @@ namespace WaveHarmonic.Crest
         private protected override Color ClearColor => _DefaultClippingState == DefaultClippingState.EverythingClipped ? Color.white : Color.black;
         private protected override bool NeedToReadWriteTextureData => true;
         private protected override bool RequiresClearBorder => true;
+        internal override bool SkipEndOfFrame => true;
 
         private protected override GraphicsFormat RequestedTextureFormat => _TextureFormatMode switch
         {
@@ -65,24 +60,6 @@ namespace WaveHarmonic.Crest
             _TextureFormat = GraphicsFormat.R8_UNorm;
         }
 
-        internal override void SetGlobals(bool enable)
-        {
-            base.SetGlobals(enable);
-            Shader.SetGlobalFloat(ShaderIDs.s_ClipByDefault, enable && Enabled ? (float)_DefaultClippingState : (float)DefaultClippingState.NothingClipped);
-        }
-
-        internal override void Disable()
-        {
-            base.Disable();
-            Shader.SetGlobalFloat(ShaderIDs.s_ClipByDefault, (float)DefaultClippingState.NothingClipped);
-        }
-
-        internal override void BuildCommandBuffer(WaterRenderer water, CommandBuffer buffer)
-        {
-            base.BuildCommandBuffer(water, buffer);
-            Shader.SetGlobalFloat(ShaderIDs.s_ClipByDefault, (float)_DefaultClippingState);
-        }
-
         internal static readonly SortedList<int, ILodInput> s_Inputs = new(Helpers.DuplicateComparison);
         private protected override SortedList<int, ILodInput> Inputs => s_Inputs;
 
@@ -98,7 +75,7 @@ namespace WaveHarmonic.Crest
             if (_Water == null || !_Water.isActiveAndEnabled || !Enabled) return;
 
             // Change default clipping state.
-            _TargetsToClear = Mathf.Max(1, _TargetsToClear);
+            _TargetsToClear = true;
         }
 
 #if UNITY_EDITOR

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/ColorLod.cs

@@ -41,19 +41,19 @@ namespace WaveHarmonic.Crest
         internal ShorelineVolumeColorSource _ShorelineColorSource;
 
         [Tooltip("Color of the shoreline color.")]
-        [@Predicated(nameof(_ShorelineColorSource), inverted: false, nameof(ShorelineVolumeColorSource.None), hide: true)]
+        [@Hide(nameof(_ShorelineColorSource), nameof(ShorelineVolumeColorSource.None))]
         [@GenerateAPI(Setter.Custom)]
         [@DecoratedField, SerializeField]
         private protected Color _ShorelineColor;
 
         [Tooltip("The maximum distance of the shoreline color.\n\nIf using Depth, then it is maximum depth.")]
-        [@Predicated(nameof(_ShorelineColorSource), inverted: false, nameof(ShorelineVolumeColorSource.None), hide: true)]
+        [@Hide(nameof(_ShorelineColorSource), nameof(ShorelineVolumeColorSource.None))]
         [@GenerateAPI]
         [@DecoratedField, SerializeField]
         float _ShorelineColorMaximumDistance = 10f;
 
         [Tooltip("Shoreline color falloff value.")]
-        [@Predicated(nameof(_ShorelineColorSource), inverted: false, nameof(ShorelineVolumeColorSource.None), hide: true)]
+        [@Hide(nameof(_ShorelineColorSource), nameof(ShorelineVolumeColorSource.None))]
         [@GenerateAPI]
         [@DecoratedField, SerializeField]
         float _ShorelineColorFalloff = 2f;
@@ -69,6 +69,7 @@ namespace WaveHarmonic.Crest
         private protected abstract void SetShorelineColor(Color previous, Color current);
         private protected Vector4 _ShorelineColorValue;
         ShorelineColorInput _ShorelineColorInput;
+        internal override bool SkipEndOfFrame => true;
 
         private protected override GraphicsFormat RequestedTextureFormat => _TextureFormatMode switch
         {

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/DepthLod.cs

@@ -12,6 +12,7 @@ namespace WaveHarmonic.Crest
     /// <summary>
     /// Data that gives depth of the water (height of sea level above water floor).
     /// </summary>
+    [FilterEnum(nameof(_QuerySource), Filtered.Mode.Exclude, (int)LodQuerySource.CPU)]
     [FilterEnum(nameof(_TextureFormatMode), Filtered.Mode.Exclude, (int)LodTextureFormatMode.Automatic)]
     public sealed partial class DepthLod : Lod<IDepthProvider>
     {
@@ -33,11 +34,12 @@ namespace WaveHarmonic.Crest
         // We want the clear color to be the mininimum terrain height (-1000m).
         // Mathf.Infinity can cause problems for distance.
         static readonly Color s_NullColor = new(-k_DepthBaseline, k_DepthBaseline, 0, 0);
+        static Color NullColor => Helpers.IsWebGPU ? new(float.MinValue, float.MaxValue, 0, 0) : s_NullColor;
 
         internal override string ID => "Depth";
         internal override string Name => "Water Depth";
         internal override Color GizmoColor => s_GizmoColor;
-        private protected override Color ClearColor => s_NullColor;
+        private protected override Color ClearColor => NullColor;
         private protected override bool NeedToReadWriteTextureData => true;
 
         private protected override GraphicsFormat RequestedTextureFormat => _TextureFormatMode switch
@@ -56,7 +58,7 @@ namespace WaveHarmonic.Crest
             {
                 if (_NullTexture == null)
                 {
-                    var texture = TextureArrayHelpers.CreateTexture2D(s_NullColor, UnityEngine.TextureFormat.RFloat);
+                    var texture = TextureArrayHelpers.CreateTexture2D(NullColor, UnityEngine.TextureFormat.RFloat);
                     texture.name = $"_Crest_{ID}LodTemporaryDefaultTexture";
                     _NullTexture = TextureArrayHelpers.CreateTexture2DArray(texture, k_MaximumSlices);
                     _NullTexture.name = $"_Crest_{ID}LodDefaultTexture";
@@ -71,13 +73,16 @@ namespace WaveHarmonic.Crest
         {
             _Enabled = true;
             _TextureFormat = GraphicsFormat.R16G16_SFloat;
+            _MaximumQueryCount = 512;
         }
 
-        private protected override IDepthProvider CreateProvider(bool enable)
+        private protected override IDepthProvider CreateProvider(bool onEnable)
         {
             Queryable?.CleanUp();
             // Depth is GPU only, and can only be queried using the compute path.
-            return enable && Enabled ? new DepthQuery(_Water) : IDepthProvider.None;
+            return onEnable && Enabled && QuerySource == LodQuerySource.GPU
+                ? IDepthProvider.Create(_Water)
+                : IDepthProvider.None;
         }
 
         internal static readonly SortedList<int, ILodInput> s_Inputs = new(Helpers.DuplicateComparison);

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/DynamicWavesLod.cs

@@ -97,12 +97,6 @@ namespace WaveHarmonic.Crest
             simMaterial.SetFloat(AnimatedWavesLod.ShaderIDs.s_AttenuationInShallows, _AttenuationInShallows);
         }
 
-        private protected override void GetSubstepData(float timeToSimulate, out int substeps, out float delta)
-        {
-            substeps = Mathf.FloorToInt(timeToSimulate * _SimulationFrequency);
-            delta = substeps > 0 ? (1f / _SimulationFrequency) : 0f;
-        }
-
         internal static readonly SortedList<int, ILodInput> s_Inputs = new(Helpers.DuplicateComparison);
         private protected override SortedList<int, ILodInput> Inputs => s_Inputs;
 

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/FlowLod.cs

@@ -3,6 +3,7 @@
 
 using UnityEngine;
 using UnityEngine.Experimental.Rendering;
+using UnityEngine.Rendering;
 using WaveHarmonic.Crest.Utility;
 
 namespace WaveHarmonic.Crest
@@ -10,11 +11,17 @@ namespace WaveHarmonic.Crest
     /// <summary>
     /// Simulates horizontal motion of water.
     /// </summary>
+    [FilterEnum(nameof(_QuerySource), Filtered.Mode.Exclude, (int)LodQuerySource.CPU)]
     [FilterEnum(nameof(_TextureFormatMode), Filtered.Mode.Exclude, (int)LodTextureFormatMode.Automatic)]
     public sealed partial class FlowLod : Lod<IFlowProvider>
     {
         const string k_FlowKeyword = "CREST_FLOW_ON_INTERNAL";
 
+        static new class ShaderIDs
+        {
+            public static readonly int s_Flow = Shader.PropertyToID("g_Crest_Flow");
+        }
+
         internal static readonly Color s_GizmoColor = new(0f, 0f, 1f, 0.5f);
 
         internal override string ID => "Flow";
@@ -34,6 +41,7 @@ namespace WaveHarmonic.Crest
         {
             _Resolution = 128;
             _TextureFormat = GraphicsFormat.R16G16_SFloat;
+            _MaximumQueryCount = 1024;
         }
 
         internal override void Enable()
@@ -50,11 +58,37 @@ namespace WaveHarmonic.Crest
             Shader.DisableKeyword(k_FlowKeyword);
         }
 
-        private protected override IFlowProvider CreateProvider(bool enable)
+        internal override void BuildCommandBuffer(WaterRenderer water, CommandBuffer buffer)
+        {
+            var time = water.CurrentTime;
+            var period = 1f;
+            var half = period * 0.5f;
+            var offset0 = Helpers.Fmod(time, period);
+            var weight0 = offset0 / half;
+            if (weight0 > 1f) weight0 = 2f - weight0;
+            var offset1 = Helpers.Fmod(time + half, period);
+            var weight1 = 1f - weight0;
+
+            Shader.SetGlobalVector(ShaderIDs.s_Flow, new(offset0, weight0, offset1, weight1));
+
+            base.BuildCommandBuffer(water, buffer);
+        }
+
+        private protected override IFlowProvider CreateProvider(bool onEnable)
         {
             Queryable?.CleanUp();
             // Flow is GPU only, and can only be queried using the compute path.
-            return enable && Enabled ? new FlowQuery(_Water) : IFlowProvider.None;
+            return onEnable && Enabled && QuerySource == LodQuerySource.GPU
+                ? IFlowProvider.Create(_Water)
+                : IFlowProvider.None;
+        }
+
+        internal override void SetGlobals(bool onEnable)
+        {
+            base.SetGlobals(onEnable);
+
+            // Zero offset. Use the first sample.
+            Shader.SetGlobalVector(ShaderIDs.s_Flow, new(0, 1, 0, 0));
         }
 
         internal static readonly SortedList<int, ILodInput> s_Inputs = new(Helpers.DuplicateComparison);

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/FoamLod.cs

@@ -69,13 +69,6 @@ namespace WaveHarmonic.Crest
             properties.SetInteger(ShaderIDs.s_MinimumWavesSlice, Settings.FilterWaves);
         }
 
-        private protected override void GetSubstepData(float timeToSimulate, out int substeps, out float delta)
-        {
-            substeps = Mathf.FloorToInt(timeToSimulate * _SimulationFrequency);
-
-            delta = substeps > 0 ? (1f / _SimulationFrequency) : 0f;
-        }
-
         internal FoamLod()
         {
             _Enabled = true;

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Generated/Lod.Generated.cs

@@ -59,6 +59,7 @@ namespace WaveHarmonic.Crest
         {
             base.Destroy();
             Helpers.Destroy(_DefaultSettings);
+            _DefaultSettings = null;
         }
     }
 
@@ -93,6 +94,7 @@ namespace WaveHarmonic.Crest
         {
             base.Destroy();
             Helpers.Destroy(_DefaultSettings);
+            _DefaultSettings = null;
         }
     }
 

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/AbsorptionLodInput.cs

@@ -1,8 +1,6 @@
 // Crest Water System
 // Copyright © 2024 Wave Harmonic. All rights reserved.
 
-using UnityEngine;
-
 namespace WaveHarmonic.Crest
 {
     /// <summary>
@@ -14,11 +12,6 @@ namespace WaveHarmonic.Crest
     [@HelpURL("Manual/WaterAppearance.html#volume-color-inputs")]
     public sealed partial class AbsorptionLodInput : LodInput
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 0;
-#pragma warning restore 414
-
 #if d_CrestPaint
         internal override LodInputMode DefaultMode => LodInputMode.Paint;
 #else

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/AlbedoLodInput.cs

@@ -1,8 +1,6 @@
 // Crest Water System
 // Copyright © 2024 Wave Harmonic. All rights reserved.
 
-using UnityEngine;
-
 namespace WaveHarmonic.Crest
 {
     /// <summary>
@@ -14,11 +12,6 @@ namespace WaveHarmonic.Crest
     [@HelpURL("Manual/WaterAppearance.html#albedo-inputs")]
     public sealed partial class AlbedoLodInput : LodInput
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 0;
-#pragma warning restore 414
-
         internal override LodInputMode DefaultMode => LodInputMode.Renderer;
     }
 }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/AnimatedWavesLodInput.cs

@@ -23,14 +23,14 @@ namespace WaveHarmonic.Crest
         DisplacementPass _DisplacementPass = DisplacementPass.LodIndependent;
 
         [Tooltip("Whether to filter this input by wavelength.\n\nIf disabled, it will render to all LODs.")]
-        [@Predicated(nameof(_DisplacementPass), inverted: true, nameof(DisplacementPass.LodDependent))]
+        [@Enable(nameof(_DisplacementPass), nameof(DisplacementPass.LodDependent))]
         [@GenerateAPI]
         [DecoratedField, SerializeField]
         bool _FilterByWavelength;
 
         [Tooltip("Which octave to render into.\n\nFor example, set this to 2 to render into the 2m-4m octave. These refer to the same octaves as the wave spectrum editor.")]
-        [@Predicated(nameof(_DisplacementPass), inverted: true, nameof(DisplacementPass.LodDependent))]
-        [@Predicated(nameof(_FilterByWavelength))]
+        [@Enable(nameof(_DisplacementPass), nameof(DisplacementPass.LodDependent))]
+        [@Enable(nameof(_FilterByWavelength))]
         [@GenerateAPI]
         [@DecoratedField, SerializeField]
         float _OctaveWavelength = 512f;
@@ -49,7 +49,7 @@ namespace WaveHarmonic.Crest
         float _MaximumDisplacementHorizontal = 0f;
 
         [Tooltip("Use the bounding box of an attached renderer component to determine the maximum vertical displacement.")]
-        [@Predicated(nameof(_Mode), inverted: true, nameof(LodInputMode.Renderer))]
+        [@Enable(nameof(_Mode), nameof(LodInputMode.Renderer))]
         [@GenerateAPI]
         [@DecoratedField, SerializeField]
         bool _ReportRendererBounds = false;
@@ -63,23 +63,35 @@ namespace WaveHarmonic.Crest
             _FollowHorizontalWaveMotion = true;
         }
 
-        internal override float Filter(WaterRenderer water, int slice)
+        private protected override void Initialize()
         {
-            return AnimatedWavesLod.FilterByWavelength(water, slice, _FilterByWavelength ? _OctaveWavelength : 0f);
+            base.Initialize();
+            _Reporter ??= new(this);
+            _DisplacementReporter = _Reporter;
         }
 
-        private protected override void OnUpdate(WaterRenderer water)
+        private protected override void OnDisable()
         {
-            base.OnUpdate(water);
+            base.OnDisable();
+            _DisplacementReporter = null;
+        }
 
+        internal override float Filter(WaterRenderer water, int slice)
+        {
+            return AnimatedWavesLod.FilterByWavelength(water, slice, _FilterByWavelength ? _OctaveWavelength : 0f, water.AnimatedWavesLod.Resolution);
+        }
+
+        bool ReportDisplacement(WaterRenderer water, ref Rect bounds, ref float horizontal, ref float vertical)
+        {
             if (!Enabled)
             {
-                return;
+                return false;
             }
 
             var maxDispVert = _MaximumDisplacementVertical;
 
             // let water system know how far from the sea level this shape may displace the surface
+            // TODO: we need separate min/max vertical displacement to be optimal.
             if (_ReportRendererBounds)
             {
                 var range = Data.HeightRange;
@@ -89,19 +101,40 @@ namespace WaveHarmonic.Crest
                 maxDispVert = Mathf.Max(maxDispVert, Mathf.Abs(seaLevel - minY), Mathf.Abs(seaLevel - maxY));
             }
 
-            if (_MaximumDisplacementHorizontal > 0f || maxDispVert > 0f)
+            var rect = Data.Rect;
+
+            if (bounds.Overlaps(rect, false))
             {
-                water.ReportMaximumDisplacement(_MaximumDisplacementHorizontal, maxDispVert, 0f);
+                horizontal += _MaximumDisplacementHorizontal;
+                vertical += maxDispVert;
+                return true;
             }
+
+            return false;
+        }
+
+        float ReportWaveDisplacement(WaterRenderer water, float displacement)
+        {
+            return displacement;
         }
     }
 
-    partial class AnimatedWavesLodInput : ISerializationCallbackReceiver
+    partial class AnimatedWavesLodInput
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 1;
-#pragma warning restore 414
+        Reporter _Reporter;
+
+        sealed class Reporter : IReportsDisplacement, IReportWaveDisplacement
+        {
+            readonly AnimatedWavesLodInput _Input;
+            public Reporter(AnimatedWavesLodInput input) => _Input = input;
+            public bool ReportDisplacement(WaterRenderer water, ref Rect bounds, ref float horizontal, ref float vertical) => _Input.ReportDisplacement(water, ref bounds, ref horizontal, ref vertical);
+            public float ReportWaveDisplacement(WaterRenderer water, float displacement) => _Input.ReportWaveDisplacement(water, displacement);
+        }
+    }
+
+    partial class AnimatedWavesLodInput
+    {
+        private protected override int Version => Mathf.Max(base.Version, 1);
 
         [System.Obsolete("Please use DisplacementPass instead.")]
         [Tooltip("When to render the input into the displacement data.\n\nIf enabled, it renders into all LODs of the simulation after the combine step rather than before with filtering. Furthermore, it will also affect dynamic waves.")]
@@ -110,30 +143,25 @@ namespace WaveHarmonic.Crest
         [HideInInspector]
         bool _RenderPostCombine = true;
 
+        [System.Obsolete]
         void SetRenderPostCombine(bool previous, bool current, bool force = false)
         {
             if (previous == current && !force) return;
             _DisplacementPass = current ? DisplacementPass.LodIndependent : DisplacementPass.LodDependent;
         }
 
+#pragma warning disable CS0612 // Type or member is obsolete
 #pragma warning disable CS0618 // Type or member is obsolete
-
-        /// <inheritdoc/>
-        void ISerializationCallbackReceiver.OnAfterDeserialize()
+        private protected override void OnMigrate()
         {
+            base.OnMigrate();
+
             if (_Version < 1)
             {
                 SetRenderPostCombine(_RenderPostCombine, _RenderPostCombine, force: true);
-                _Version = 1;
             }
         }
-
+#pragma warning restore CS0612 // Type or member is obsolete
 #pragma warning restore CS0618 // Type or member is obsolete
-
-        /// <inheritdoc/>
-        void ISerializationCallbackReceiver.OnBeforeSerialize()
-        {
-
-        }
     }
 }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/ClipLodInput.cs

@@ -16,22 +16,17 @@ namespace WaveHarmonic.Crest
     [@HelpURL("Manual/Clipping.html#clip-inputs")]
     public sealed partial class ClipLodInput : LodInput
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 0;
-#pragma warning restore 414
-
         [@Heading("Primitive")]
 
         [Tooltip("The primitive to render (signed distance) into the simulation.")]
-        [@Predicated(nameof(_Mode), inverted: true, nameof(LodInputMode.Primitive), hide: true)]
+        [@Show(nameof(_Mode), nameof(LodInputMode.Primitive))]
         [@GenerateAPI]
         [@DecoratedField, SerializeField]
         internal LodInputPrimitive _Primitive = LodInputPrimitive.Cube;
 
         // Only Mode.Primitive SDF supports inverted.
         [Tooltip("Removes clip surface data instead of adding it.")]
-        [@Predicated(nameof(_Mode), inverted: true, nameof(LodInputMode.Primitive), hide: true)]
+        [@Show(nameof(_Mode), nameof(LodInputMode.Primitive))]
         [@GenerateAPI]
         [@DecoratedField, SerializeField]
         bool _Inverted;
@@ -39,8 +34,7 @@ namespace WaveHarmonic.Crest
         [@Heading("Culling")]
 
         [Tooltip("Prevents inputs from cancelling each other out when aligned vertically.\n\nIt is imperfect so custom logic might be needed for your use case.")]
-        [@Predicated(nameof(_Mode), inverted: false, nameof(LodInputMode.Paint), hide: true)]
-        [@Predicated(nameof(_Mode), inverted: true, nameof(LodInputMode.Renderer))]
+        [@Show(nameof(_Mode), nameof(LodInputMode.Renderer))]
         [@GenerateAPI]
         [@DecoratedField, SerializeField]
         bool _WaterHeightDistanceCulling = false;

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/DepthLodInput.cs

@@ -21,11 +21,6 @@ namespace WaveHarmonic.Crest
     [@HelpURL("Manual/ShallowsAndShorelines.html#sea-floor-depth")]
     public sealed partial class DepthLodInput : LodInput
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 0;
-#pragma warning restore 414
-
         [@Space(10)]
 
         [@Label("Relative Height")]

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/DynamicWavesLodInput.cs

@@ -1,8 +1,6 @@
 // Crest Water System
 // Copyright © 2024 Wave Harmonic. All rights reserved.
 
-using UnityEngine;
-
 namespace WaveHarmonic.Crest
 {
     /// <summary>
@@ -15,11 +13,6 @@ namespace WaveHarmonic.Crest
     [@HelpURL("Manual/Waves.html#dynamic-waves-inputs")]
     public sealed partial class DynamicWavesLodInput : LodInput
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 0;
-#pragma warning restore 414
-
         internal override LodInputMode DefaultMode => LodInputMode.Renderer;
     }
 }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/FlowLodInput.cs

@@ -1,8 +1,6 @@
 // Crest Water System
 // Copyright © 2024 Wave Harmonic. All rights reserved.
 
-using UnityEngine;
-
 namespace WaveHarmonic.Crest
 {
     /// <summary>
@@ -16,11 +14,6 @@ namespace WaveHarmonic.Crest
     [FilterEnum(nameof(_Blend), Filtered.Mode.Include, (int)LodInputBlend.Additive, (int)LodInputBlend.Alpha)]
     public sealed partial class FlowLodInput : LodInput
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 0;
-#pragma warning restore 414
-
         // Countering will incur thrashing. Previously we allowed the option so the
         // serialized value could be "false".
         private protected override bool FollowHorizontalMotion => true;

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/FoamLodInput.cs

@@ -1,8 +1,6 @@
 // Crest Water System
 // Copyright © 2024 Wave Harmonic. All rights reserved.
 
-using UnityEngine;
-
 namespace WaveHarmonic.Crest
 {
     /// <summary>
@@ -16,11 +14,6 @@ namespace WaveHarmonic.Crest
     [@FilterEnum(nameof(_Blend), Filtered.Mode.Include, (int)LodInputBlend.Additive, (int)LodInputBlend.Maximum)]
     public sealed partial class FoamLodInput : LodInput
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 0;
-#pragma warning restore 414
-
 #if d_CrestPaint
         internal override LodInputMode DefaultMode => LodInputMode.Paint;
 #else

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/LevelLodInput.cs

@@ -19,11 +19,12 @@ namespace WaveHarmonic.Crest
 
         [Tooltip("Whether to use the manual \"Height Range\" for water chunk culling.\n\nMandatory for non mesh inputs like \"Texture\".")]
         [@GenerateAPI]
-        [@DecoratedField, SerializeField]
+        [@InlineToggle]
+        [@SerializeField]
         bool _OverrideHeight;
 
         [Tooltip("The minimum and maximum height value to report for water chunk culling.")]
-        [@Predicated(nameof(_OverrideHeight))]
+        [@Enable(nameof(_OverrideHeight))]
         [@Range(-100, 100, Range.Clamp.None)]
         [@GenerateAPI]
         [SerializeField]
@@ -38,8 +39,6 @@ namespace WaveHarmonic.Crest
         private protected override bool FollowHorizontalMotion => true;
         internal override LodInputMode DefaultMode => LodInputMode.Geometry;
 
-        internal Rect _Rect;
-
         internal override void InferBlend()
         {
             base.InferBlend();
@@ -56,35 +55,52 @@ namespace WaveHarmonic.Crest
         {
             base.Initialize();
             _Reporter ??= new(this);
-            WaterChunkRenderer.HeightReporters.Add(_Reporter);
+            _HeightReporter = _Reporter;
         }
 
         private protected override void OnDisable()
         {
             base.OnDisable();
-            WaterChunkRenderer.HeightReporters.Remove(_Reporter);
+            _HeightReporter = null;
         }
 
-        bool ReportHeight(ref Rect bounds, ref float minimum, ref float maximum)
+        bool ReportHeight(WaterRenderer water, ref Rect bounds, ref float minimum, ref float maximum)
         {
             if (!Enabled)
             {
                 return false;
             }
 
-            _Rect = Data.Rect;
-
             // These modes do not provide a height yet.
             if (!Data.HasHeightRange && !_OverrideHeight)
             {
                 return false;
             }
 
-            if (bounds.Overlaps(_Rect, false))
+            var rect = Data.Rect;
+
+            if (bounds.Overlaps(rect, false))
             {
                 var range = _OverrideHeight ? _HeightRange : Data.HeightRange;
-                minimum = range.x;
-                maximum = range.y;
+                range *= Weight;
+
+                // Make relative to sea level.
+                range.x -= water.SeaLevel;
+                range.y -= water.SeaLevel;
+
+                var current = new Vector2(minimum, maximum);
+
+                range = _Blend switch
+                {
+                    LodInputBlend.Additive => range + current,
+                    LodInputBlend.Minimum => Vector2.Min(range, current),
+                    LodInputBlend.Maximum => Vector2.Max(range, current),
+                    _ => range,
+                };
+
+                minimum = Mathf.Min(minimum, range.x);
+                maximum = Mathf.Max(maximum, range.y);
+
                 return true;
             }
 
@@ -100,33 +116,25 @@ namespace WaveHarmonic.Crest
         {
             readonly LevelLodInput _Input;
             public Reporter(LevelLodInput input) => _Input = input;
-            public bool ReportHeight(ref Rect bounds, ref float minimum, ref float maximum) => _Input.ReportHeight(ref bounds, ref minimum, ref maximum);
+            public bool ReportHeight(WaterRenderer water, ref Rect bounds, ref float minimum, ref float maximum) =>
+                _Input.ReportHeight(water, ref bounds, ref minimum, ref maximum);
         }
     }
 
-    partial class LevelLodInput : ISerializationCallbackReceiver
+    partial class LevelLodInput
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 1;
-#pragma warning restore 414
+        private protected override int Version => Mathf.Max(base.Version, 1);
 
-        /// <inheritdoc/>
-        void ISerializationCallbackReceiver.OnAfterDeserialize()
+        private protected override void OnMigrate()
         {
+            base.OnMigrate();
+
             // Version 1
             // - Implemented blend mode but default value was serialized as Additive.
             if (_Version < 1)
             {
                 if (_Mode is LodInputMode.Spline or LodInputMode.Renderer) _Blend = LodInputBlend.Off;
-                _Version = 1;
             }
         }
-
-        /// <inheritdoc/>
-        void ISerializationCallbackReceiver.OnBeforeSerialize()
-        {
-            // Empty.
-        }
     }
 }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/LodInput.cs

@@ -36,6 +36,10 @@ namespace WaveHarmonic.Crest
 
         MonoBehaviour Component { get; }
 
+        IReportsHeight HeightReporter => null;
+        IReportsDisplacement DisplacementReporter => null;
+        IReportWaveDisplacement WaveDisplacementReporter => null;
+
         // Allow sorting within a queue. Callers can pass in things like sibling index to
         // get deterministic sorting.
         int Order => Queue * k_QueueMaximumSubIndex + Mathf.Min(Component.transform.GetSiblingIndex(), k_QueueMaximumSubIndex - 1);
@@ -70,9 +74,9 @@ namespace WaveHarmonic.Crest
         // For others it is a case of only supporting unsupported mode(s).
 
         [Tooltip("Scales the input.")]
-        [@Predicated(typeof(AlbedoLodInput), inverted: true, hide: true)]
-        [@Predicated(typeof(ClipLodInput), inverted: true, hide: true)]
-        [@Predicated(typeof(DepthLodInput), inverted: true, hide: true)]
+        [@Hide(typeof(AlbedoLodInput))]
+        [@Hide(typeof(ClipLodInput))]
+        [@Hide(typeof(DepthLodInput))]
         [@Range(0f, 1f)]
         [@GenerateAPI]
         [SerializeField]
@@ -84,17 +88,17 @@ namespace WaveHarmonic.Crest
         int _Queue;
 
         [Tooltip("How this input blends into existing data.\n\nSimilar to blend operations in shaders. For inputs which have materials, use the blend functionality on the shader/material.")]
-        [@Predicated(typeof(AbsorptionLodInput), inverted: true, hide: true)]
-        [@Predicated(typeof(AlbedoLodInput), inverted: true, hide: true)]
-        [@Predicated(typeof(AnimatedWavesLodInput), inverted: true, hide: true)]
-        [@Predicated(typeof(ClipLodInput), inverted: true, hide: true)]
-        [@Predicated(typeof(DepthLodInput), inverted: true, hide: true)]
-        [@Predicated(typeof(DynamicWavesLodInput), inverted: true, hide: true)]
-        [@Predicated(typeof(ScatteringLodInput), inverted: true, hide: true)]
-        [@Predicated(typeof(ShadowLodInput), inverted: true, hide: true)]
-        [@Predicated(nameof(_Mode), inverted: false, nameof(LodInputMode.Global))]
-        [@Predicated(nameof(_Mode), inverted: false, nameof(LodInputMode.Primitive))]
-        [@Predicated(nameof(_Mode), inverted: false, nameof(LodInputMode.Renderer))]
+        [@Hide(typeof(AbsorptionLodInput))]
+        [@Hide(typeof(AlbedoLodInput))]
+        [@Hide(typeof(AnimatedWavesLodInput))]
+        [@Hide(typeof(ClipLodInput))]
+        [@Hide(typeof(DepthLodInput))]
+        [@Hide(typeof(DynamicWavesLodInput))]
+        [@Hide(typeof(ScatteringLodInput))]
+        [@Hide(typeof(ShadowLodInput))]
+        [@Disable(nameof(_Mode), nameof(LodInputMode.Global))]
+        [@Disable(nameof(_Mode), nameof(LodInputMode.Primitive))]
+        [@Disable(nameof(_Mode), nameof(LodInputMode.Renderer))]
         [@Filtered]
         [@GenerateAPI]
         [SerializeField]
@@ -102,35 +106,35 @@ namespace WaveHarmonic.Crest
 
         [@Label("Feather")]
         [Tooltip("The width of the feathering to soften the edges to blend inputs.\n\nInputs that do not support feathering will have this field disabled or hidden in UI.")]
-        [@Predicated(typeof(AlbedoLodInput), inverted: true, hide: true)]
-        [@Predicated(typeof(AnimatedWavesLodInput), inverted: true, hide: true)]
-        [@Predicated(typeof(ClipLodInput), inverted: true, hide: true)]
-        [@Predicated(typeof(DepthLodInput), inverted: true, hide: true)]
-        [@Predicated(typeof(DynamicWavesLodInput), inverted: true, hide: true)]
-        [@Predicated(typeof(LevelLodInput), inverted: true, hide: true)]
-        [@Predicated(nameof(_Mode), inverted: false, nameof(LodInputMode.Renderer))]
-        [@Predicated(nameof(_Mode), inverted: false, nameof(LodInputMode.Global))]
-        [@Predicated(nameof(_Mode), inverted: false, nameof(LodInputMode.Primitive))]
+        [@Hide(typeof(AlbedoLodInput))]
+        [@Hide(typeof(AnimatedWavesLodInput))]
+        [@Hide(typeof(ClipLodInput))]
+        [@Hide(typeof(DepthLodInput))]
+        [@Hide(typeof(DynamicWavesLodInput))]
+        [@Hide(typeof(LevelLodInput))]
+        [@Disable(nameof(_Mode), nameof(LodInputMode.Renderer))]
+        [@Disable(nameof(_Mode), nameof(LodInputMode.Global))]
+        [@Disable(nameof(_Mode), nameof(LodInputMode.Primitive))]
         [@GenerateAPI]
         [@DecoratedField, SerializeField]
         float _FeatherWidth = 0.1f;
 
         [Tooltip("How this input responds to horizontal displacement.\n\nIf false, data will not move horizontally with the waves. Has a small performance overhead when disabled. Only suitable for inputs of small size.")]
-        [@Predicated(typeof(ClipLodInput), inverted: true, hide: true)]
-        [@Predicated(typeof(FlowLodInput), inverted: true, hide: true)]
-        [@Predicated(typeof(LevelLodInput), inverted: true, hide: true)]
-        [@Predicated(typeof(ShapeWaves), inverted: true, hide: true)]
-        [@Predicated(nameof(_Mode), inverted: false, nameof(LodInputMode.Global))]
-        [@Predicated(nameof(_Mode), inverted: false, nameof(LodInputMode.Spline))]
+        [@Hide(typeof(ClipLodInput))]
+        [@Hide(typeof(FlowLodInput))]
+        [@Hide(typeof(LevelLodInput))]
+        [@Hide(typeof(ShapeWaves))]
+        [@Disable(nameof(_Mode), nameof(LodInputMode.Global))]
+        [@Disable(nameof(_Mode), nameof(LodInputMode.Spline))]
         [@GenerateAPI]
         [@DecoratedField, SerializeField]
         private protected bool _FollowHorizontalWaveMotion = false;
 
         [@Heading("Mode")]
 
-        [@Predicated(nameof(_Mode), inverted: false, nameof(LodInputMode.Unset), hide: true)]
-        [@Predicated(nameof(_Mode), inverted: false, nameof(LodInputMode.Primitive), hide: true)]
-        [@Predicated(nameof(_Mode), inverted: false, nameof(LodInputMode.Global), hide: true)]
+        [@Hide(nameof(_Mode), nameof(LodInputMode.Unset))]
+        [@Hide(nameof(_Mode), nameof(LodInputMode.Primitive))]
+        [@Hide(nameof(_Mode), nameof(LodInputMode.Global))]
         [@Stripped]
         [SerializeReference]
         internal LodInputData _Data;
@@ -140,7 +144,7 @@ namespace WaveHarmonic.Crest
 
         [@Group("Debug", order = k_DebugGroupOrder)]
 
-        [@Predicated(nameof(_Mode), inverted: false, nameof(LodInputMode.Global))]
+        [@Disable(nameof(_Mode), nameof(LodInputMode.Global))]
         [@DecoratedField, SerializeField]
         internal bool _DrawBounds;
 
@@ -376,6 +380,16 @@ namespace WaveHarmonic.Crest
         //
 
 #if UNITY_EDITOR
+        void SetMode(LodInputMode previous, LodInputMode current)
+        {
+            if (previous == current) return;
+            if (!isActiveAndEnabled) { ChangeMode(Mode); return; }
+            OnDisable();
+            ChangeMode(Mode);
+            UnityEditor.EditorTools.ToolManager.RefreshAvailableTools();
+            OnEnable();
+        }
+
         [@OnChange(skipIfInactive: false)]
         void OnChange(string propertyPath, object previousValue)
         {
@@ -385,15 +399,11 @@ namespace WaveHarmonic.Crest
                     SetQueue((int)previousValue, _Queue);
                     break;
                 case nameof(_Mode):
-                    if (!isActiveAndEnabled) { ChangeMode(Mode); break; }
-                    OnDisable();
-                    ChangeMode(Mode);
-                    UnityEditor.EditorTools.ToolManager.RefreshAvailableTools();
-                    OnEnable();
+                    SetMode((LodInputMode)previousValue, Mode);
                     break;
                 case nameof(_Blend):
                     // TODO: Make compatible with disabled.
-                    if (isActiveAndEnabled) Data.OnChange($"../{propertyPath}", previousValue);
+                    if (isActiveAndEnabled) Data?.OnChange($"../{propertyPath}", previousValue);
                     break;
             }
         }
@@ -467,6 +477,9 @@ namespace WaveHarmonic.Crest
     partial class LodInput
     {
         Input _Input;
+        private protected IReportsHeight _HeightReporter;
+        internal IReportsDisplacement _DisplacementReporter;
+        private protected IReportWaveDisplacement _WaveDisplacementReporter;
 
         sealed class Input : ILodInput
         {
@@ -478,6 +491,9 @@ namespace WaveHarmonic.Crest
             public int Pass => _Input.Pass;
             public Rect Rect => _Input.Rect;
             public MonoBehaviour Component => _Input;
+            public IReportsHeight HeightReporter => _Input._HeightReporter;
+            public IReportsDisplacement DisplacementReporter => _Input._DisplacementReporter;
+            public IReportWaveDisplacement WaveDisplacementReporter => _Input._WaveDisplacementReporter;
             public float Filter(WaterRenderer water, int slice) => _Input.Filter(water, slice);
             public void Draw(Lod lod, CommandBuffer buffer, RenderTargetIdentifier target, int pass = -1, float weight = 1, int slice = -1) => _Input.Draw(lod, buffer, target, pass, weight, slice);
         }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/LodInputData.cs

@@ -4,6 +4,7 @@
 using System;
 using UnityEngine;
 using UnityEngine.Rendering;
+using WaveHarmonic.Crest.Internal;
 
 namespace WaveHarmonic.Crest
 {
@@ -24,7 +25,7 @@ namespace WaveHarmonic.Crest
     /// Data storage for an input, pertinent to the associated input mode.
     /// </summary>
     [Serializable]
-    public abstract class LodInputData
+    public abstract partial class LodInputData : Versioned
     {
         [SerializeField, HideInInspector]
         internal LodInput _Input;

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/Probe/DepthProbe.cs

@@ -2,10 +2,15 @@
 // Copyright © 2024 Wave Harmonic. All rights reserved.
 
 using UnityEngine;
+using UnityEngine.Experimental.Rendering;
 using UnityEngine.Rendering;
 using WaveHarmonic.Crest.Internal;
 using WaveHarmonic.Crest.Utility;
 
+#if !UNITY_6000_0_OR_NEWER
+using GraphicsFormatUsage = UnityEngine.Experimental.Rendering.FormatUsage;
+#endif
+
 namespace WaveHarmonic.Crest
 {
     /// <summary>
@@ -33,7 +38,9 @@ namespace WaveHarmonic.Crest
         [Tooltip("Populates the DepthProbe in Start.")]
         OnStart = 0,
 
-        // EveryFrame = 1,
+        /// <inheritdoc cref="Generated.DepthProbeRefreshMode.EveryFrame"/>
+        [Tooltip("Populates the DepthProbe every frame.")]
+        EveryFrame = 1,
 
         /// <inheritdoc cref="Generated.DepthProbeRefreshMode.ViaScripting"/>
         [Tooltip("Requires manual updating via DepthProbe.Populate.")]
@@ -77,8 +84,13 @@ namespace WaveHarmonic.Crest
         [SerializeField]
         internal DepthProbeMode _Type = DepthProbeMode.RealTime;
 
-        [Tooltip("Controls how the probe is refreshed in the Player.\n\nCall Populate() if scripting.")]
-        [@Predicated(nameof(_Type), inverted: true, nameof(DepthProbeMode.RealTime), hide: true)]
+        [Tooltip("Where the Depth Probe is placed.\n\nThe default performs the best.")]
+        [@GenerateAPI]
+        [@DecoratedField, SerializeField]
+        Placement _Placement;
+
+        [Tooltip("Controls how the probe is refreshed in the Player.\n\nCall Populate() if scripting.\n\nWhen Placement is not set to Fixed, EveryFrame is still applicable, but the others are not (update only happens on position change).")]
+        [@Show(nameof(_Type), nameof(DepthProbeMode.RealTime))]
         [@GenerateAPI]
         [@DecoratedField, SerializeField]
         internal DepthProbeRefreshMode _RefreshMode = DepthProbeRefreshMode.OnStart;
@@ -87,26 +99,26 @@ namespace WaveHarmonic.Crest
         [@Heading("Capture")]
 
         [Tooltip("The layers to render into the probe.")]
-        [@Predicated(nameof(_Type), inverted: true, nameof(DepthProbeMode.RealTime))]
+        [@Enable(nameof(_Type), nameof(DepthProbeMode.RealTime))]
         [@GenerateAPI(Setter.Dirty)]
         [@DecoratedField, SerializeField]
         internal LayerMask _Layers = 1; // Default
 
         [Tooltip("The resolution of the probe.\n\nLower will be more efficient.")]
-        [@Predicated(nameof(_Type), inverted: true, nameof(DepthProbeMode.RealTime))]
+        [@Enable(nameof(_Type), nameof(DepthProbeMode.RealTime))]
         [@GenerateAPI(Setter.Dirty)]
         [@DecoratedField, SerializeField]
         internal int _Resolution = 512;
 
         [Tooltip("The far and near plane of the depth probe camera respectively, relative to the transform.\n\nDepth is captured top-down and orthographically. The gizmo will visualize this range as the bottom box.")]
-        [@Predicated(nameof(_Type), inverted: true, nameof(DepthProbeMode.RealTime))]
+        [@Enable(nameof(_Type), nameof(DepthProbeMode.RealTime))]
         [@Range(-100f, 100f, Range.Clamp.None)]
         [@GenerateAPI(Setter.Dirty)]
         [SerializeField]
         internal Vector2 _CaptureRange = new(-1000f, 1000f);
 
         [Tooltip("Fills holes left by the maximum of the capture range.\n\nSetting the maximum capture range lower than the highest point of geometry can be useful for eliminating depth artifacts from overhangs, but the side effect is there will be a hole in the depth data where geometry is clipped by the near plane. This will only capture where the holes are to fill them in. This height is relative to the maximum capture range. Set to zero to skip.")]
-        [@Predicated(nameof(_Type), inverted: true, nameof(DepthProbeMode.RealTime))]
+        [@Enable(nameof(_Type), nameof(DepthProbeMode.RealTime))]
         [@Range(0f, 100f, Range.Clamp.Minimum)]
         [UnityEngine.Serialization.FormerlySerializedAs("_MaximumHeight")]
         [@GenerateAPI(Setter.Dirty)]
@@ -115,14 +127,14 @@ namespace WaveHarmonic.Crest
 
         [@Label("Enable Back-Face Inclusion")]
         [Tooltip("Increase coverage by testing mesh back faces within the Fill Holes area.\n\nUses the back-faces to include meshes where the front-face is within the Fill Holes area and the back-face is within the capture area. An example would be an upright cylinder not over a hole but was not captured due to the top being clipped by the near plane.")]
-        [@Predicated(nameof(_Type), inverted: true, nameof(DepthProbeMode.RealTime))]
-        [@Predicated(nameof(_FillHolesCaptureHeight), inverted: false, 0f)]
+        [@Enable(nameof(_Type), nameof(DepthProbeMode.RealTime))]
+        [@Disable(nameof(_FillHolesCaptureHeight), 0f)]
         [@GenerateAPI(Setter.Dirty)]
         [@DecoratedField, SerializeField]
         bool _EnableBackFaceInclusion = true;
 
         [Tooltip("Overrides global quality settings.")]
-        [@Predicated(nameof(_Type), inverted: true, nameof(DepthProbeMode.RealTime))]
+        [@Enable(nameof(_Type), nameof(DepthProbeMode.RealTime))]
         [GenerateAPI(Setter.None)]
         [@DecoratedField, SerializeField]
         QualitySettingsOverride _QualitySettingsOverride = new()
@@ -139,7 +151,7 @@ namespace WaveHarmonic.Crest
 
         [Tooltip("Baked probe.\n\nCan only bake in edit mode.")]
         [@Disabled]
-        [@Predicated(nameof(_Type), inverted: true, nameof(DepthProbeMode.Baked), hide: true)]
+        [@Show(nameof(_Type), nameof(DepthProbeMode.Baked))]
         [@GenerateAPI]
         [@DecoratedField, SerializeField]
 #pragma warning disable 649
@@ -151,7 +163,7 @@ namespace WaveHarmonic.Crest
 
         [@Label("Generate")]
         [Tooltip("Generate a signed distance field for the shoreline.")]
-        [@Predicated(nameof(_Type), inverted: true, nameof(DepthProbeMode.RealTime))]
+        [@Enable(nameof(_Type), nameof(DepthProbeMode.RealTime))]
         [@GenerateAPI(Setter.Dirty)]
         [@DecoratedField, SerializeField]
         internal bool _GenerateSignedDistanceField = true;
@@ -159,8 +171,8 @@ namespace WaveHarmonic.Crest
         // Additional rounds of JFA, over the standard log2(resolution), can help reduce
         // innacuracies from JFA, see paper for details.
         [Tooltip("How many additional Jump Flood rounds to use.\n\nThe standard number of rounds is log2(resolution). Additional rounds can reduce innaccuracies.")]
-        [@Predicated(nameof(_Type), inverted: true, nameof(DepthProbeMode.RealTime))]
-        [@Predicated(nameof(_GenerateSignedDistanceField))]
+        [@Enable(nameof(_Type), nameof(DepthProbeMode.RealTime))]
+        [@Enable(nameof(_GenerateSignedDistanceField))]
         [@GenerateAPI(Setter.Dirty)]
         [@DecoratedField, SerializeField]
         int _AdditionalJumpFloodRounds = 7;
@@ -174,11 +186,6 @@ namespace WaveHarmonic.Crest
         [System.Serializable]
         internal sealed class DebugFields
         {
-            [Tooltip("Will render into the probe every frame. Intended for debugging, will generate garbage.")]
-            [@Predicated(nameof(_Type), inverted: true, nameof(DepthProbeMode.RealTime))]
-            [@DecoratedField, SerializeField]
-            public bool _ForceAlwaysUpdateDebug;
-
             [Tooltip("Shows hidden objects like the camera which renders into the probe.")]
             [@DecoratedField, SerializeField]
             public bool _ShowHiddenObjects;
@@ -342,6 +349,11 @@ namespace WaveHarmonic.Crest
             if (transform.hasChanged)
             {
                 _RecalculateBounds = true;
+
+                if (_Placement == Placement.Transform)
+                {
+                    UpdatePosition(water, transform);
+                }
             }
         }
 
@@ -351,6 +363,14 @@ namespace WaveHarmonic.Crest
             transform.hasChanged = false;
         }
 
+        void OnBeforeBuildCommandBuffer(WaterRenderer water, Camera camera)
+        {
+            if (_Placement == Placement.Viewpoint)
+            {
+                UpdatePosition(water, camera.transform);
+            }
+        }
+
         internal bool Outdated => _CurrentStateHash != _RenderedStateHash;
 
         bool IsTextureOutdated(RenderTexture texture, bool target)
@@ -358,16 +378,19 @@ namespace WaveHarmonic.Crest
             return texture != null &&
                 texture.width != _Resolution ||
                 texture.height != _Resolution ||
-                texture.format != (target ? RenderTextureFormat.Depth : FinalFormat);
+                texture.graphicsFormat != (target ? SystemInfo.GetGraphicsFormat(DefaultFormat.DepthStencil) : FinalFormat);
         }
 
-        RenderTextureFormat FinalFormat => _GenerateSignedDistanceField ? RenderTextureFormat.RGFloat : RenderTextureFormat.RFloat;
+        GraphicsFormat FinalFormat => _GenerateSignedDistanceField
+            ? Helpers.GetCompatibleTextureFormat(GraphicsFormat.R32G32_SFloat, Helpers.s_DataGraphicsFormatUsage, "Depth Probe", randomWrite: true)
+            : GraphicsFormat.R32_SFloat;
 
         void MakeRT(RenderTexture texture, bool target)
         {
-            var format = target ? RenderTextureFormat.Depth : FinalFormat;
+            var format = target ? SystemInfo.GetGraphicsFormat(DefaultFormat.DepthStencil) : FinalFormat;
             var descriptor = texture.descriptor;
-            descriptor.colorFormat = format;
+            descriptor.graphicsFormat = target ? GraphicsFormat.None : format;
+            descriptor.depthStencilFormat = target ? format : GraphicsFormat.None;
             descriptor.width = descriptor.height = _Resolution;
             descriptor.depthBufferBits = target ? 24 : 0;
             descriptor.useMipMap = false;
@@ -375,7 +398,11 @@ namespace WaveHarmonic.Crest
             descriptor.enableRandomWrite = !target;
             texture.descriptor = descriptor;
             texture.Create();
-            Debug.Assert(SystemInfo.SupportsRenderTextureFormat(format), "Crest: The graphics device does not support the render texture format " + format.ToString());
+
+            if (!target)
+            {
+                Debug.Assert(SystemInfo.IsFormatSupported(format, GraphicsFormatUsage.Sample), "Crest: The graphics device does not support the render texture format " + format.ToString());
+            }
         }
 
         bool InitObjects()
@@ -704,7 +731,7 @@ namespace WaveHarmonic.Crest
             var descriptor = new RenderTextureDescriptor(_Resolution, _Resolution)
             {
                 autoGenerateMips = false,
-                colorFormat = RenderTextureFormat.RGHalf,
+                graphicsFormat = Helpers.GetCompatibleTextureFormat(GraphicsFormat.R16G16_SFloat, Helpers.s_DataGraphicsFormatUsage, "Depth Probe SDF", randomWrite: true),
                 useMipMap = false,
                 enableRandomWrite = true,
                 depthBufferBits = 0,
@@ -838,6 +865,9 @@ namespace WaveHarmonic.Crest
             ILodInput.Attach(_Input, DepthLod.s_Inputs);
             HashState(ref _CurrentStateHash);
 
+            WaterRenderer.s_OnBeforeBuildCommandBuffer -= OnBeforeBuildCommandBuffer;
+            WaterRenderer.s_OnBeforeBuildCommandBuffer += OnBeforeBuildCommandBuffer;
+
 #if CREST_DEBUG
             if (_Debug._ShowSimulationDataInScene)
             {
@@ -852,6 +882,8 @@ namespace WaveHarmonic.Crest
             base.OnDisable();
             ILodInput.Detach(_Input, DepthLod.s_Inputs);
 
+            WaterRenderer.s_OnBeforeBuildCommandBuffer -= OnBeforeBuildCommandBuffer;
+
 #if CREST_DEBUG
             if (_Debug._ShowSimulationDataInScene)
             {
@@ -926,6 +958,29 @@ namespace WaveHarmonic.Crest
         }
     }
 
+    sealed partial class DepthProbe
+    {
+        Vector3 _PreviousPosition;
+
+        void UpdatePosition(WaterRenderer water, Transform target)
+        {
+            var position = target.position.XNZ(water.transform.position.y);
+            var texelSize = Scale / _Resolution;
+            position.x = Mathf.Round(position.x / texelSize.x) * texelSize.x;
+            position.z = Mathf.Round(position.z / texelSize.y) * texelSize.y;
+
+            if ((_Placement == Placement.Viewpoint && !water.IsSingleViewpointMode) || _RefreshMode == DepthProbeRefreshMode.EveryFrame || _PreviousPosition != position)
+            {
+                Managed = true;
+                OverridePosition = true;
+                Position = position;
+                Scale = new(transform.lossyScale.x, transform.lossyScale.z);
+                Populate();
+                _PreviousPosition = position;
+            }
+        }
+    }
+
     sealed partial class DepthProbe
     {
         // Hash is used to notify whether the probe is outdated in the UI.
@@ -974,7 +1029,7 @@ namespace WaveHarmonic.Crest
 
         void Update()
         {
-            if (_Debug._ForceAlwaysUpdateDebug && _Type != DepthProbeMode.Baked)
+            if (_RefreshMode == DepthProbeRefreshMode.EveryFrame && _Placement == Placement.Fixed && _Type != DepthProbeMode.Baked)
             {
                 Populate();
             }
@@ -987,30 +1042,21 @@ namespace WaveHarmonic.Crest
 #endif
     }
 
-    partial class DepthProbe : ISerializationCallbackReceiver
+    partial class DepthProbe
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 1;
-#pragma warning restore 414
+        private protected override int Version => Mathf.Max(base.Version, 1);
 
-        /// <inheritdoc/>
-        void ISerializationCallbackReceiver.OnAfterDeserialize()
+        private protected override void OnMigrate()
         {
+            base.OnMigrate();
+
             // Version 1 (2024.06.04)
             // - Added new capture options replacing Maximum Height's behaviour.
             if (_Version < 1)
             {
                 _CaptureRange.y = _FillHolesCaptureHeight;
                 _FillHolesCaptureHeight = 0f;
-                _Version = 1;
             }
         }
-
-        /// <inheritdoc/>
-        void ISerializationCallbackReceiver.OnBeforeSerialize()
-        {
-
-        }
     }
 }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/RendererLodInputData.cs

@@ -26,11 +26,12 @@ namespace WaveHarmonic.Crest
 
         [Tooltip("Whether to set the shader pass manually.")]
         [@GenerateAPI]
-        [@DecoratedField, SerializeField]
+        [@InlineToggle]
+        [@SerializeField]
         internal bool _OverrideShaderPass;
 
         [Tooltip("The shader pass to execute.\n\nSet to -1 to execute all passes.")]
-        [@Predicated(nameof(_OverrideShaderPass))]
+        [@Enable(nameof(_OverrideShaderPass))]
         [@GenerateAPI]
         [@DecoratedField, SerializeField]
         internal int _ShaderPassIndex;

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/ScatteringLodInput.cs

@@ -1,8 +1,6 @@
 // Crest Water System
 // Copyright © 2024 Wave Harmonic. All rights reserved.
 
-using UnityEngine;
-
 namespace WaveHarmonic.Crest
 {
     /// <summary>
@@ -14,11 +12,6 @@ namespace WaveHarmonic.Crest
     [@HelpURL("Manual/WaterAppearance.html#volume-color-inputs")]
     public sealed partial class ScatteringLodInput : LodInput
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 0;
-#pragma warning restore 414
-
 #if d_CrestPaint
         internal override LodInputMode DefaultMode => LodInputMode.Paint;
 #else

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/ShadowLodInput.cs

@@ -1,8 +1,6 @@
 // Crest Water System
 // Copyright © 2024 Wave Harmonic. All rights reserved.
 
-using UnityEngine;
-
 namespace WaveHarmonic.Crest
 {
     /// <summary>
@@ -14,11 +12,6 @@ namespace WaveHarmonic.Crest
     [@HelpURL("Manual/WaterAppearance.html#shadows-lod")]
     public sealed partial class ShadowLodInput : LodInput
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 0;
-#pragma warning restore 414
-
         internal override LodInputMode DefaultMode => LodInputMode.Renderer;
     }
 }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/Shape/ShapeFFT.cs

@@ -14,21 +14,32 @@ namespace WaveHarmonic.Crest
     {
         // Waves
 
-        [Tooltip("Whether to use the wind turbulence on this component rather than the global wind turbulence.\n\nGlobal wind turbulence comes from the Water Renderer component.")]
+        [Tooltip("Whether to apply the options shown when \"Show Advanced Controls\" is active.")]
+        [@Order(nameof(_EvaluateSpectrumAtRunTimeEveryFrame), Order.Placement.Below)]
+        [@DecoratedField]
         [@GenerateAPI]
-        [@InlineToggle(order = -3), SerializeField]
+        [@SerializeField]
+        bool _ApplyAdvancedSpectrumControls;
+
+        [Tooltip("Whether to use the wind turbulence on this component rather than the global wind turbulence.\n\nGlobal wind turbulence comes from the Water Renderer component.")]
+        [@Order("Waves")]
+        [@InlineToggle]
+        [@GenerateAPI]
+        [@SerializeField]
         bool _OverrideGlobalWindTurbulence;
 
         [Tooltip("How turbulent/chaotic the waves are.")]
-        [@Predicated(nameof(_OverrideGlobalWindTurbulence), hide: true)]
+        [@Order("Waves")]
+        [@Show(nameof(_OverrideGlobalWindTurbulence))]
         [@ShowComputedProperty(nameof(WindTurbulence))]
-        [@Range(0, 1, order = -4)]
+        [@Range(0, 1)]
         [@GenerateAPI(Getter.Custom)]
         [SerializeField]
         float _WindTurbulence = 0.145f;
 
         [Tooltip("How aligned the waves are with wind.")]
-        [@Range(0, 1, order = -5)]
+        [@Range(0, 1)]
+        [@Order("Waves")]
         [@GenerateAPI]
         [SerializeField]
         float _WindAlignment;
@@ -37,21 +48,30 @@ namespace WaveHarmonic.Crest
         // Generation
 
         [Tooltip("FFT waves will loop with a period of this many seconds.")]
+        [@Order("Generation Settings")]
         [@Range(4f, 128f, Range.Clamp.Minimum)]
         [@GenerateAPI]
         [SerializeField]
         float _TimeLoopLength = Mathf.Infinity;
 
 
-        [Header("Culling")]
+        [@Heading("Culling")]
+
+        [Tooltip("Whether to override automatic culling based on heuristics.")]
+        [@GenerateAPI]
+        [@DecoratedField]
+        [SerializeField]
+        bool _OverrideCulling;
 
         [Tooltip("Maximum amount the surface will be displaced vertically from sea level.\n\nIncrease this if gaps appear at bottom of screen.")]
         [@GenerateAPI]
+        [@DecoratedField]
         [SerializeField]
         float _MaximumVerticalDisplacement = 10f;
 
         [Tooltip("Maximum amount a point on the surface will be displaced horizontally by waves from its rest position.\n\nIncrease this if gaps appear at sides of screen.")]
         [@GenerateAPI]
+        [@DecoratedField]
         [SerializeField]
         float _MaximumHorizontalDisplacement = 15f;
 
@@ -63,7 +83,7 @@ namespace WaveHarmonic.Crest
 #endif
 
         [Tooltip("Enable running this FFT with baked data.\n\nThis makes the FFT periodic (repeating in time).")]
-        [@Predicated(nameof(_Mode), inverted: true, nameof(LodInputMode.Global), hide: true)]
+        [@Show(nameof(_Mode), nameof(LodInputMode.Global))]
         [@DecoratedField, SerializeField]
         internal bool _EnableBakedCollision = false;
 
@@ -72,8 +92,8 @@ namespace WaveHarmonic.Crest
 #endif
 
         [Tooltip("Frames per second of baked data.\n\nLarger values may help the collision track the surface closely at the cost of more frames and increase baked data size.")]
-        [@Predicated(nameof(_EnableBakedCollision))]
-        [@Predicated(nameof(_Mode), inverted: true, nameof(LodInputMode.Global), hide: true)]
+        [@Enable(nameof(_EnableBakedCollision))]
+        [@Show(nameof(_Mode), nameof(LodInputMode.Global))]
         [@DecoratedField, SerializeField]
         internal int _TimeResolution = 4;
 
@@ -82,8 +102,8 @@ namespace WaveHarmonic.Crest
 #endif
 
         [Tooltip("Smallest wavelength required in collision.\n\nTo preview the effect of this, disable power sliders in spectrum for smaller values than this number. Smaller values require more resolution and increase baked data size.")]
-        [@Predicated(nameof(_EnableBakedCollision))]
-        [@Predicated(nameof(_Mode), inverted: true, nameof(LodInputMode.Global), hide: true)]
+        [@Enable(nameof(_EnableBakedCollision))]
+        [@Show(nameof(_Mode), nameof(LodInputMode.Global))]
         [@DecoratedField, SerializeField]
         internal float _SmallestWavelengthRequired = 2f;
 
@@ -92,8 +112,8 @@ namespace WaveHarmonic.Crest
 #endif
 
         [Tooltip("FFT waves will loop with a period of this many seconds.\n\nSmaller values decrease data size but can make waves visibly repetitive.")]
-        [@Predicated(nameof(_EnableBakedCollision))]
-        [@Predicated(nameof(_Mode), inverted: true, nameof(LodInputMode.Global), hide: true)]
+        [@Enable(nameof(_EnableBakedCollision))]
+        [@Show(nameof(_Mode), nameof(LodInputMode.Global))]
         [@Range(4f, 128f)]
         [SerializeField]
         internal float _BakedTimeLoopLength = 32f;
@@ -104,8 +124,9 @@ namespace WaveHarmonic.Crest
 #endif
             _TimeLoopLength;
 
+        // WebGPU will crash above at 128.
         private protected override int MinimumResolution => 16;
-        private protected override int MaximumResolution => int.MaxValue;
+        private protected override int MaximumResolution => Helpers.IsWebGPU ? 64 : int.MaxValue;
 
         FFTCompute _FFTCompute;
 
@@ -119,7 +140,8 @@ namespace WaveHarmonic.Crest
             WindDirRadForFFT,
             WindTurbulence,
             _WindAlignment,
-            gravity
+            gravity,
+            _ApplyAdvancedSpectrumControls
         );
 
         private protected override void OnUpdate(WaterRenderer water)
@@ -189,13 +211,28 @@ namespace WaveHarmonic.Crest
         {
             if (!Enabled) return;
 
-            // Apply weight or will cause popping due to scale change.
-            MaximumReportedHorizontalDisplacement = _MaximumHorizontalDisplacement * Weight;
-            MaximumReportedVerticalDisplacement = MaximumReportedWavesDisplacement = _MaximumVerticalDisplacement * Weight;
-
-            if (Mode == LodInputMode.Global)
+            if (_OverrideCulling)
             {
-                water.ReportMaximumDisplacement(MaximumReportedHorizontalDisplacement, MaximumReportedVerticalDisplacement, MaximumReportedVerticalDisplacement);
+                // Apply weight or will cause popping due to scale change.
+                MaximumReportedHorizontalDisplacement = _MaximumHorizontalDisplacement * Weight;
+                MaximumReportedVerticalDisplacement = MaximumReportedWavesDisplacement = _MaximumVerticalDisplacement * Weight;
+            }
+            else
+            {
+                var powerLinear = 0f;
+
+                for (var i = 0; i < WaveSpectrum.k_NumberOfOctaves; i++)
+                {
+                    powerLinear += _ActiveSpectrum._PowerLinearScales[i];
+                }
+
+                // Empirical multiplier (3-5), went with 5 to be safe.
+                // We may be missing some more multipliers from the compute shader.
+                // Look there if this proves insufficient.
+                var wind = Mathf.Clamp01(WindSpeedKPH / 150f);
+                var rms = Mathf.Sqrt(powerLinear) * 5f;
+                MaximumReportedHorizontalDisplacement = rms * _ActiveSpectrum._Chop * Weight * wind;
+                MaximumReportedVerticalDisplacement = MaximumReportedWavesDisplacement = rms * Weight * wind;
             }
         }
 
@@ -250,28 +287,18 @@ namespace WaveHarmonic.Crest
         }
     }
 
-    partial class ShapeFFT : ISerializationCallbackReceiver
+    partial class ShapeFFT
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 2;
-#pragma warning restore 414
+        private protected override int Version => Mathf.Max(base.Version, 2);
 
-        void ISerializationCallbackReceiver.OnAfterDeserialize()
+        private protected override void OnMigrate()
         {
-            _Version = MigrateV1(_Version);
+            base.OnMigrate();
 
             if (_Version < 2)
             {
                 _OverrideGlobalWindTurbulence = true;
             }
-
-            _Version = MigrateV2(_Version);
-        }
-
-        void ISerializationCallbackReceiver.OnBeforeSerialize()
-        {
-            // Empty.
         }
     }
 

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/Shape/ShapeGerstner.cs

@@ -19,14 +19,18 @@ namespace WaveHarmonic.Crest
 
         [@Space(10)]
 
+        // If disabled, there will be a difference due to Random.value.
         [Tooltip("Use a swell spectrum as the default.\n\nUses a swell spectrum as default (when none is assigned), and disabled reverse waves.")]
+        [@Order("Waves")]
+        [@DecoratedField]
         [@GenerateAPI]
-        [@DecoratedField(order = -3), SerializeField]
+        [@SerializeField]
         bool _Swell = true;
 
         [Tooltip("The weight of the opposing, second pair of Gerstner waves.\n\nEach Gerstner wave is actually a pair of waves travelling in opposite directions (similar to FFT). This weight is applied to the wave travelling in against-wind direction. Set to zero to obtain simple single waves which are useful for shorelines waves.")]
-        [Predicated(nameof(_Swell), inverted: true)]
-        [@Range(0f, 1f, order = -4)]
+        [@Order("Waves")]
+        [@Disable(nameof(_Swell))]
+        [@Range(0f, 1f)]
         [@GenerateAPI(Getter.Custom)]
         [SerializeField]
         float _ReverseWaveWeight = 0.5f;
@@ -35,23 +39,28 @@ namespace WaveHarmonic.Crest
         // Generation Settings
 
         [Tooltip("How many wave components to generate in each octave.")]
+        [@Order("Generation Settings")]
         [@Delayed]
         [@GenerateAPI]
         [SerializeField]
         int _ComponentsPerOctave = 8;
 
         [Tooltip("Change to get a different set of waves.")]
+        [@Order("Generation Settings")]
         [@GenerateAPI]
+        [@DecoratedField]
         [SerializeField]
         int _RandomSeed = 0;
 
         [Tooltip("Prevent data arrays from being written to so one can provide their own.")]
+        [@Order("Generation Settings")]
         [@GenerateAPI]
+        [@DecoratedField]
         [SerializeField]
         bool _ManualGeneration;
 
         private protected override int MinimumResolution => 8;
-        private protected override int MaximumResolution => 64;
+        private protected override int MaximumResolution => int.MaxValue;
 
         float _WindSpeedWhenGenerated = -1f;
 
@@ -93,12 +102,7 @@ namespace WaveHarmonic.Crest
         float[] _Amplitudes2;
         float[] _Phases2;
 
-        struct GerstnerCascadeParams
-        {
-            public int _StartIndex;
-        }
-        ComputeBuffer _BufferCascadeParameters;
-        readonly GerstnerCascadeParams[] _CascadeParameters = new GerstnerCascadeParams[k_CascadeCount + 1];
+        readonly int[] _StartIndices = new int[k_CascadeCount];
 
         // Caution - order here impact performance. Rearranging these to match order
         // they're read in the compute shader made it 50% slower..
@@ -111,6 +115,7 @@ namespace WaveHarmonic.Crest
             public Vector4 _Omega;
             public Vector4 _Phase;
             public Vector4 _ChopAmplitude;
+
             // Waves are generated in pairs, these values are for the second in the pair
             public Vector4 _Amplitude2;
             public Vector4 _ChopAmplitude2;
@@ -119,8 +124,7 @@ namespace WaveHarmonic.Crest
         ComputeBuffer _BufferWaveData;
         readonly GerstnerWaveComponent4[] _WaveData = new GerstnerWaveComponent4[k_MaximumWaveComponents / 4];
 
-        ComputeShader _ShaderGerstner;
-        int _KernelGerstner = -1;
+        WaterResources.GerstnerCompute _Shader;
 
         private protected override WaveSpectrum DefaultSpectrum => _Swell ? SwellSpectrum : WindSpectrum;
         static WaveSpectrum s_SwellSpectrum;
@@ -154,7 +158,7 @@ namespace WaveHarmonic.Crest
         {
             public static readonly int s_FirstCascadeIndex = Shader.PropertyToID("_Crest_FirstCascadeIndex");
             public static readonly int s_TextureRes = Shader.PropertyToID("_Crest_TextureRes");
-            public static readonly int s_CascadeParams = Shader.PropertyToID("_Crest_GerstnerCascadeParams");
+            public static readonly int s_StartIndices = Shader.PropertyToID("_Crest_StartIndices");
             public static readonly int s_GerstnerWaveData = Shader.PropertyToID("_Crest_GerstnerWaveData");
         }
 
@@ -179,7 +183,7 @@ namespace WaveHarmonic.Crest
         {
             if (_WaveBuffers == null)
             {
-                _WaveBuffers = new(_Resolution, _Resolution, 0, GraphicsFormat.R16G16B16A16_SFloat);
+                _WaveBuffers = new(Resolution, Resolution, 0, Helpers.GetCompatibleTextureFormat(GraphicsFormat.R16G16B16A16_SFloat, randomWrite: true));
             }
             else
             {
@@ -187,7 +191,7 @@ namespace WaveHarmonic.Crest
             }
 
             {
-                _WaveBuffers.width = _WaveBuffers.height = _Resolution;
+                _WaveBuffers.width = _WaveBuffers.height = Resolution;
                 _WaveBuffers.wrapMode = TextureWrapMode.Clamp;
                 _WaveBuffers.antiAliasing = 1;
                 _WaveBuffers.filterMode = FilterMode.Bilinear;
@@ -200,14 +204,11 @@ namespace WaveHarmonic.Crest
                 _WaveBuffers.Create();
             }
 
-            _BufferCascadeParameters?.Release();
             _BufferWaveData?.Release();
 
-            _BufferCascadeParameters = new(k_CascadeCount + 1, UnsafeUtility.SizeOf<GerstnerCascadeParams>());
             _BufferWaveData = new(k_MaximumWaveComponents / 4, UnsafeUtility.SizeOf<GerstnerWaveComponent4>());
 
-            _ShaderGerstner = WaterResources.Instance.Compute._Gerstner;
-            _KernelGerstner = _ShaderGerstner.FindKernel("Gerstner");
+            _Shader = WaterResources.Instance._ComputeLibrary._GerstnerCompute;
         }
 
         private protected override void OnUpdate(WaterRenderer water)
@@ -216,7 +217,7 @@ namespace WaveHarmonic.Crest
 
             base.OnUpdate(water);
 
-            if (_WaveBuffers == null || _Resolution != _WaveBuffers.width || _BufferCascadeParameters == null || _BufferWaveData == null)
+            if (_WaveBuffers == null || Resolution != _WaveBuffers.width || _BufferWaveData == null)
             {
                 InitData();
             }
@@ -266,7 +267,7 @@ namespace WaveHarmonic.Crest
             var cascadeIdx = 0;
             var componentIdx = 0;
             var outputIdx = 0;
-            _CascadeParameters[0]._StartIndex = 0;
+            _StartIndices[0] = 0;
 
             if (_ManualGeneration)
             {
@@ -313,12 +314,14 @@ namespace WaveHarmonic.Crest
                         _WaveData[vi]._Omega[ei] = 0f;
                         _WaveData[vi]._Phase[ei] = 0f;
                         _WaveData[vi]._ChopAmplitude[ei] = 0f;
-                        if (!_ManualGeneration)
+
+                        if (!_ManualGeneration && !_Swell)
                         {
                             _WaveData[vi]._Phase2[ei] = 0f;
                             _WaveData[vi]._Amplitude2[ei] = 0f;
                             _WaveData[vi]._ChopAmplitude2[ei] = 0f;
                         }
+
                         ei = (ei + 1) % 4;
                         outputIdx++;
                     }
@@ -326,7 +329,7 @@ namespace WaveHarmonic.Crest
                     if (outputIdx > 0 && _FirstCascade < 0) _FirstCascade = cascadeIdx;
 
                     cascadeIdx++;
-                    _CascadeParameters[cascadeIdx]._StartIndex = outputIdx / 4;
+                    _StartIndices[cascadeIdx] = outputIdx / 4;
                     minWl *= 2f;
 
                     //Debug.Log($"Crest: {cascadeIdx}: start {_cascadeParams[cascadeIdx]._startIndex} minWL {minWl}");
@@ -343,7 +346,7 @@ namespace WaveHarmonic.Crest
                     var chopScale = _ActiveSpectrum._ChopScales[componentIdx / _ComponentsPerOctave];
                     _WaveData[vi]._ChopAmplitude[ei] = -chopScale * _ActiveSpectrum._Chop * _Amplitudes[componentIdx];
 
-                    if (!_ManualGeneration)
+                    if (!_ManualGeneration && !_Swell)
                     {
                         _WaveData[vi]._Amplitude2[ei] = _Amplitudes2[componentIdx];
                         _WaveData[vi]._ChopAmplitude2[ei] = -chopScale * _ActiveSpectrum._Chop * _Amplitudes2[componentIdx];
@@ -385,7 +388,7 @@ namespace WaveHarmonic.Crest
                     _WaveData[vi]._Omega[ei] = k * c;
                     _WaveData[vi]._Phase[ei] = Mathf.Repeat(_Phases[componentIdx], Mathf.PI * 2f);
 
-                    if (!_ManualGeneration)
+                    if (!_ManualGeneration && !_Swell)
                     {
                         _WaveData[vi]._Phase2[ei] = Mathf.Repeat(_Phases2[componentIdx], Mathf.PI * 2f);
                     }
@@ -410,40 +413,46 @@ namespace WaveHarmonic.Crest
                     _WaveData[vi]._Omega[ei] = 0f;
                     _WaveData[vi]._Phase[ei] = 0f;
                     _WaveData[vi]._ChopAmplitude[ei] = 0f;
-                    if (!_ManualGeneration)
+
+                    if (!_ManualGeneration && !_Swell)
                     {
                         _WaveData[vi]._Phase2[ei] = 0f;
                         _WaveData[vi]._Amplitude2[ei] = 0f;
                         _WaveData[vi]._ChopAmplitude2[ei] = 0f;
                     }
+
                     ei = (ei + 1) % 4;
                     outputIdx++;
                 }
             }
 
-            while (cascadeIdx < k_CascadeCount)
+            // Fill the remaining.
+            while (cascadeIdx < k_CascadeCount - 1)
             {
                 cascadeIdx++;
                 minWl *= 2f;
-                _CascadeParameters[cascadeIdx]._StartIndex = outputIdx / 4;
+                _StartIndices[cascadeIdx] = outputIdx / 4;
                 //Debug.Log($"Crest: {cascadeIdx}: start {_cascadeParams[cascadeIdx]._startIndex} minWL {minWl}");
             }
 
-            _BufferCascadeParameters.SetData(_CascadeParameters);
             _BufferWaveData.SetData(_WaveData);
         }
 
-        void UpdateGenerateWaves(CommandBuffer buf)
+        void UpdateGenerateWaves(CommandBuffer buffer)
         {
             // Clear existing waves or they could get copied.
-            CoreUtils.SetRenderTarget(buf, _WaveBuffers, ClearFlag.Color);
-            buf.SetComputeFloatParam(_ShaderGerstner, ShaderIDs.s_TextureRes, _WaveBuffers.width);
-            buf.SetComputeIntParam(_ShaderGerstner, ShaderIDs.s_FirstCascadeIndex, _FirstCascade);
-            buf.SetComputeBufferParam(_ShaderGerstner, _KernelGerstner, ShaderIDs.s_CascadeParams, _BufferCascadeParameters);
-            buf.SetComputeBufferParam(_ShaderGerstner, _KernelGerstner, ShaderIDs.s_GerstnerWaveData, _BufferWaveData);
-            buf.SetComputeTextureParam(_ShaderGerstner, _KernelGerstner, ShapeWaves.ShaderIDs.s_WaveBuffer, _WaveBuffers);
+            CoreUtils.SetRenderTarget(buffer, _WaveBuffers, ClearFlag.Color);
 
-            buf.DispatchCompute(_ShaderGerstner, _KernelGerstner, _WaveBuffers.width / Lod.k_ThreadGroupSizeX, _WaveBuffers.height / Lod.k_ThreadGroupSizeY, _LastCascade - _FirstCascade + 1);
+            var wrapper = new PropertyWrapperCompute(buffer, _Shader._Shader, _Shader._ExecuteKernel);
+
+            wrapper.SetFloat(ShaderIDs.s_TextureRes, _WaveBuffers.width);
+            wrapper.SetInteger(ShaderIDs.s_FirstCascadeIndex, _FirstCascade);
+            wrapper.SetIntegers(ShaderIDs.s_StartIndices, _StartIndices);
+            wrapper.SetBuffer(ShaderIDs.s_GerstnerWaveData, _BufferWaveData);
+            wrapper.SetTexture(ShapeWaves.ShaderIDs.s_WaveBuffer, _WaveBuffers);
+            wrapper.SetKeyword(_Shader._WavePairsKeyword, !_Swell && _ReverseWaveWeight > 0f);
+
+            wrapper.Dispatch(_WaveBuffers.width / Lod.k_ThreadGroupSizeX, _WaveBuffers.height / Lod.k_ThreadGroupSizeY, _LastCascade - _FirstCascade + 1);
         }
 
         /// <summary>
@@ -503,16 +512,16 @@ namespace WaveHarmonic.Crest
             {
                 var amp = _ActiveSpectrum.GetAmplitude(_Wavelengths[i], _ComponentsPerOctave, windSpeed, water.Gravity, out _Powers[i]);
                 _Amplitudes[i] = Random.value * amp;
-                _Amplitudes2[i] = Random.value * amp * ReverseWaveWeight;
+
+                if (!_Swell)
+                {
+                    _Amplitudes2[i] = Random.value * amp * ReverseWaveWeight;
+                }
             }
         }
 
         void InitPhases()
         {
-            // Set random seed to get repeatable results
-            var randomStateBkp = Random.state;
-            Random.InitState(_RandomSeed);
-
             var totalComps = _ComponentsPerOctave * WaveSpectrum.k_NumberOfOctaves;
             _Phases = new float[totalComps];
             _Phases2 = new float[totalComps];
@@ -524,12 +533,13 @@ namespace WaveHarmonic.Crest
                     var rnd = (i + Random.value) / _ComponentsPerOctave;
                     _Phases[index] = 2f * Mathf.PI * rnd;
 
-                    var rnd2 = (i + Random.value) / _ComponentsPerOctave;
-                    _Phases2[index] = 2f * Mathf.PI * rnd2;
+                    if (!_Swell)
+                    {
+                        var rnd2 = (i + Random.value) / _ComponentsPerOctave;
+                        _Phases2[index] = 2f * Mathf.PI * rnd2;
+                    }
                 }
             }
-
-            Random.state = randomStateBkp;
         }
 
         private protected override void ReportMaxDisplacement(WaterRenderer water)
@@ -546,23 +556,23 @@ namespace WaveHarmonic.Crest
                 return;
             }
 
-            var ampSum = 0f;
+            MaximumReportedVerticalDisplacement = 0;
+            MaximumReportedHorizontalDisplacement = 0;
+
             for (var i = 0; i < _Wavelengths.Length; i++)
             {
-                ampSum += _Amplitudes[i] * _ActiveSpectrum._ChopScales[i / _ComponentsPerOctave];
+                var amplitude = _Amplitudes[i];
+                MaximumReportedVerticalDisplacement += amplitude;
+                MaximumReportedHorizontalDisplacement += amplitude * _ActiveSpectrum._ChopScales[i / _ComponentsPerOctave];
             }
 
+            MaximumReportedHorizontalDisplacement *= _ActiveSpectrum._Chop;
+
             // Apply weight or will cause popping due to scale change.
-            ampSum *= Weight;
+            MaximumReportedVerticalDisplacement *= Weight;
+            MaximumReportedHorizontalDisplacement *= Weight;
 
-            MaximumReportedHorizontalDisplacement = ampSum * _ActiveSpectrum._Chop;
-            MaximumReportedVerticalDisplacement = ampSum;
-            MaximumReportedWavesDisplacement = ampSum;
-
-            if (Mode == LodInputMode.Global)
-            {
-                water.ReportMaximumDisplacement(ampSum * _ActiveSpectrum._Chop, ampSum, ampSum);
-            }
+            MaximumReportedWavesDisplacement = MaximumReportedVerticalDisplacement;
         }
 
         private protected override void Initialize()
@@ -577,11 +587,6 @@ namespace WaveHarmonic.Crest
 
             s_Instances.Remove(this);
 
-            if (_BufferCascadeParameters != null && _BufferCascadeParameters.IsValid())
-            {
-                _BufferCascadeParameters.Dispose();
-                _BufferCascadeParameters = null;
-            }
             if (_BufferWaveData != null && _BufferWaveData.IsValid())
             {
                 _BufferWaveData.Dispose();
@@ -623,32 +628,23 @@ namespace WaveHarmonic.Crest
             if (s_SwellSpectrum != null)
             {
                 Helpers.Destroy(s_SwellSpectrum);
+                s_SwellSpectrum = null;
             }
         }
     }
 
-    partial class ShapeGerstner : ISerializationCallbackReceiver
+    partial class ShapeGerstner
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 2;
-#pragma warning restore 414
+        private protected override int Version => Mathf.Max(base.Version, 2);
 
-        void ISerializationCallbackReceiver.OnAfterDeserialize()
+        private protected override void OnMigrate()
         {
-            _Version = MigrateV1(_Version);
+            base.OnMigrate();
 
             if (_Version < 2)
             {
                 _Swell = false;
             }
-
-            _Version = MigrateV2(_Version);
-        }
-
-        void ISerializationCallbackReceiver.OnBeforeSerialize()
-        {
-            // Empty.
         }
     }
 }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/Shape/ShapeWaves.cs

@@ -4,6 +4,7 @@
 using UnityEngine;
 using UnityEngine.Rendering;
 using UnityEngine.Serialization;
+using WaveHarmonic.Crest.Internal;
 
 namespace WaveHarmonic.Crest
 {
@@ -26,8 +27,11 @@ namespace WaveHarmonic.Crest
         [Tooltip("Whether to evaluate the spectrum every frame.\n\nWhen false, the wave spectrum is evaluated once on startup in editor play mode and standalone builds, rather than every frame. This is less flexible, but it reduces the performance cost significantly.")]
         [@GenerateAPI]
         [FormerlySerializedAs("_SpectrumFixedAtRuntime")]
+        [@DecoratedField]
         [SerializeField]
-        bool _EvaluateSpectrumAtRunTimeEveryFrame;
+        private protected bool _EvaluateSpectrumAtRunTimeEveryFrame;
+
+        [@Space(10)]
 
         [Tooltip("How much these waves respect the shallow water attenuation.\n\nAttenuation is defined on the Animated Waves. Set to zero to ignore attenuation.")]
         [@Range(0f, 1f)]
@@ -35,6 +39,15 @@ namespace WaveHarmonic.Crest
         [SerializeField]
         float _RespectShallowWaterAttenuation = 1f;
 
+        [Tooltip("Whether global waves is applied above or below sea level.\n\nWaves are faded out to avoid hard transitionds. They are fully faded by 1m from sea level.")]
+        [@Enable(nameof(_Mode), nameof(LodInputMode.Global))]
+        [@GenerateAPI]
+        [@DecoratedField]
+        [SerializeField]
+        bool _SeaLevelOnly = true;
+
+        [@Space(10)]
+
         [Tooltip("Whether to use the wind direction on this component rather than the global wind direction.\n\nGlobal wind direction comes from the Water Renderer component.")]
         [@GenerateAPI]
         [@InlineToggle, SerializeField]
@@ -42,8 +55,8 @@ namespace WaveHarmonic.Crest
 
         [@Label("Wind Direction")]
         [Tooltip("Primary wave direction heading (degrees).\n\nThis is the angle from x axis in degrees that the waves are oriented towards. If a spline is being used to place the waves, this angle is relative to the spline.")]
-        [@Predicated(nameof(_Mode), inverted: false, nameof(LodInputMode.Paint))]
-        [@Predicated(nameof(_OverrideGlobalWindDirection), hide: true)]
+        [@Disable(nameof(_Mode), nameof(LodInputMode.Paint))]
+        [@Show(nameof(_OverrideGlobalWindDirection))]
         [@ShowComputedProperty(nameof(WaveDirectionHeadingAngle))]
         [@Range(-180, 180)]
         [@GenerateAPI(Getter.Custom)]
@@ -57,22 +70,32 @@ namespace WaveHarmonic.Crest
 
         [Tooltip("Wind speed in km/h. Controls wave conditions.")]
         [@ShowComputedProperty(nameof(WindSpeedKPH))]
-        [@Predicated(nameof(_OverrideGlobalWindSpeed), hide: true)]
+        [@Show(nameof(_OverrideGlobalWindSpeed))]
         [@Range(0, 150f, scale: 2f)]
         [@GenerateAPI]
         [SerializeField]
         float _WindSpeed = 20f;
 
 
-        [Header("Generation Settings")]
+        [@Heading("Generation Settings")]
 
         [Tooltip("Resolution to use for wave generation buffers.\n\nLow resolutions are more efficient but can result in noticeable patterns in the shape.")]
         [@Stepped(16, 512, step: 2, power: true)]
-        [@GenerateAPI]
+        [@GenerateAPI(Getter.Custom)]
         [SerializeField]
         private protected int _Resolution = 128;
 
 
+        [@Heading("Level of Detail")]
+
+        [Tooltip("Whether the maximum possible vertical displacement is used for the Drop Detail Height Based On Waves calculation.\n\nThis setting is ignored for global waves, as they always contribute. For local waves, only enable for large areas that are treated like global waves (eg a storm).")]
+        [@Disable(nameof(_Mode), nameof(LodInputMode.Global))]
+        [@GenerateAPI]
+        [@DecoratedField]
+        [SerializeField]
+        bool _IncludeInDropDetailHeightBasedOnWaves;
+
+
         // Debug
 
         [Tooltip("In Editor, shows the wave generation buffers on screen.")]
@@ -92,6 +115,8 @@ namespace WaveHarmonic.Crest
             public static readonly int s_RespectShallowWaterAttenuation = Shader.PropertyToID("_Crest_RespectShallowWaterAttenuation");
             public static readonly int s_MaximumAttenuationDepth = Shader.PropertyToID("_Crest_MaximumAttenuationDepth");
             public static readonly int s_AxisX = Shader.PropertyToID("_Crest_AxisX");
+            public static readonly int s_SeaLevelOnly = Shader.PropertyToID("_Crest_SeaLevelOnly");
+            public static readonly int s_WaveBufferAttenuation = Shader.PropertyToID("_Crest_WaveBufferAttenuation");
         }
 
         private protected virtual WaveSpectrum DefaultSpectrum => WindSpectrum;
@@ -136,7 +161,7 @@ namespace WaveHarmonic.Crest
         /// <summary>
         /// The wind speed in meters per second (MPS).
         /// </summary>
-        /// /// <remarks>
+        /// <remarks>
         /// Wind speed can come from this component or the <see cref="WaterRenderer"/>.
         /// </remarks>
         public float WindSpeedMPS => WindSpeedKPH / 3.6f;
@@ -150,13 +175,32 @@ namespace WaveHarmonic.Crest
         {
             base.Attach();
             _Reporter ??= new(this);
-            WaterChunkRenderer.DisplacementReporters.Add(_Reporter);
+            _DisplacementReporter = _Reporter;
+            _WaveDisplacementReporter = _Reporter;
         }
 
         private protected override void Detach()
         {
             base.Detach();
-            WaterChunkRenderer.DisplacementReporters.Remove(_Reporter);
+            _DisplacementReporter = null;
+            _WaveDisplacementReporter = null;
+        }
+
+        internal enum WindSpeedSource
+        {
+            None, // Wind Speed is at maximum.
+            ShapeWaves,
+            WaterRenderer,
+        }
+
+        internal WindSpeedSource GetWindSpeedSource()
+        {
+            if (WindSpeedKPH >= WaterRenderer.k_MaximumWindSpeedKPH)
+            {
+                return WindSpeedSource.None;
+            }
+
+            return OverrideGlobalWindSpeed ? WindSpeedSource.ShapeWaves : WindSpeedSource.WaterRenderer;
         }
 
         internal override void Draw(Lod simulation, CommandBuffer buffer, RenderTargetIdentifier target, int pass = -1, float weight = 1f, int slice = -1)
@@ -173,30 +217,32 @@ namespace WaveHarmonic.Crest
                 return;
             }
 
-            var lodCount = simulation.Slices;
-
-            var shape = (AnimatedWavesLod)simulation;
-
-            var wrapper = new PropertyWrapperCompute(buffer, s_TransferWavesComputeShader, 0);
-
             if (_FirstCascade < 0 || _LastCascade < 0)
             {
                 return;
             }
 
+            var lodCount = simulation.Slices;
+            var lodResolution = simulation.Resolution;
+            var shape = (AnimatedWavesLod)simulation;
+
+            var wrapper = new PropertyWrapperCompute(buffer, s_TransferWavesComputeShader, 0);
+
             // Write to per-octave _WaveBuffers (ie pre-combined). Not the same as _AnimatedWaves.
             wrapper.SetTexture(Crest.ShaderIDs.s_Target, target);
             // Input weight. Weight for each octave calculated in compute.
             wrapper.SetFloat(LodInput.ShaderIDs.s_Weight, Weight);
 
+            wrapper.SetInteger(Crest.ShaderIDs.s_Resolution, Resolution);
+
             var water = shape._Water;
 
             for (var lodIdx = lodCount - 1; lodIdx >= lodCount - slice; lodIdx--)
             {
-                _WaveBufferParameters[lodIdx] = new(-1, -2, 0, 0);
+                _WaveBufferParameters[lodIdx] = new(-1, -2, 0, 1);
 
                 var found = false;
-                var filter = new AnimatedWavesLod.WavelengthFilter(water, lodIdx);
+                var filter = new AnimatedWavesLod.WavelengthFilter(water, lodIdx, lodResolution);
 
                 for (var i = _FirstCascade; i <= _LastCascade; i++)
                 {
@@ -221,13 +267,17 @@ namespace WaveHarmonic.Crest
             }
 
             // Set transitional weights.
-            _WaveBufferParameters[lodCount - 2].w = 1f - water.ViewerAltitudeLevelAlpha;
+            if (!shape.PreserveWaveQuality)
+            {
+                _WaveBufferParameters[lodCount - 2].w = 1f - water.ViewerAltitudeLevelAlpha;
+            }
+
             _WaveBufferParameters[lodCount - 1].w = water.ViewerAltitudeLevelAlpha;
 
             SetRenderParameters(water, wrapper);
 
             wrapper.SetFloat(ShaderIDs.s_WaveResolutionMultiplier, shape.WaveResolutionMultiplier);
-            wrapper.SetFloat(ShaderIDs.s_TransitionalWavelengthThreshold, water.MaximumWavelength(water.LodLevels - 1) * 0.5f);
+            wrapper.SetFloat(ShaderIDs.s_TransitionalWavelengthThreshold, water.MaximumWavelength(water.LodLevels - 1, simulation.Resolution) * 0.5f);
             wrapper.SetVectorArray(ShaderIDs.s_WaveBufferParameters, _WaveBufferParameters);
 
             var isTexture = Mode is LodInputMode.Paint or LodInputMode.Texture;
@@ -236,6 +286,8 @@ namespace WaveHarmonic.Crest
             wrapper.SetKeyword(s_KeywordTexture, isTexture && !isAlphaBlend);
             wrapper.SetKeyword(s_KeywordTextureBlend, isTexture && isAlphaBlend);
 
+            wrapper.SetFloatArray(ShaderIDs.s_WaveBufferAttenuation, _ActiveSpectrum._Attenuation);
+
             if (isTexture)
             {
                 wrapper.SetInteger(Crest.ShaderIDs.s_Blend, (int)_Blend);
@@ -243,6 +295,8 @@ namespace WaveHarmonic.Crest
 
             if (Mode == LodInputMode.Global)
             {
+                wrapper.SetBoolean(ShaderIDs.s_SeaLevelOnly, _SeaLevelOnly);
+
                 var threads = shape.Resolution / Lod.k_ThreadGroupSize;
                 wrapper.Dispatch(threads, threads, slice);
             }
@@ -255,6 +309,7 @@ namespace WaveHarmonic.Crest
         void GraphicsDraw(Lod simulation, CommandBuffer buffer, RenderTargetIdentifier target, int pass, float weight, int slice)
         {
             var lod = simulation as AnimatedWavesLod;
+            var lodResolution = simulation.Resolution;
 
             var wrapper = new PropertyWrapperBuffer(buffer);
             SetRenderParameters(simulation._Water, wrapper);
@@ -266,7 +321,7 @@ namespace WaveHarmonic.Crest
                 _Wavelength = MinWavelength(i) / lod.WaveResolutionMultiplier;
 
                 // Do the weight from scratch because this is the real filter.
-                weight = AnimatedWavesLod.FilterByWavelength(simulation._Water, slice, _Wavelength) * Weight;
+                weight = AnimatedWavesLod.FilterByWavelength(simulation._Water, slice, _Wavelength, lodResolution) * Weight;
                 if (weight <= 0f) continue;
 
                 var average = _Wavelength * 1.5f * lod.WaveResolutionMultiplier;
@@ -411,40 +466,101 @@ namespace WaveHarmonic.Crest
             s_KeywordTextureBlend = WaterResources.Instance.Keywords.AnimatedWavesTransferWavesTextureBlend;
         }
 
-        bool ReportDisplacement(ref Rect bounds, ref float horizontal, ref float vertical)
+        bool ReportDisplacement(WaterRenderer water, ref Rect bounds, ref float horizontal, ref float vertical)
         {
-            if (Mode == LodInputMode.Global || !Enabled)
+            if (!Enabled)
             {
                 return false;
             }
 
+            if (Mode == LodInputMode.Global)
+            {
+                // Global is always additive.
+                horizontal += MaximumReportedHorizontalDisplacement;
+                vertical += MaximumReportedVerticalDisplacement;
+                return true;
+            }
+
             _Rect = Data.Rect;
 
             if (bounds.Overlaps(_Rect, false))
             {
-                horizontal = MaximumReportedHorizontalDisplacement;
-                vertical = MaximumReportedVerticalDisplacement;
+                var nh = horizontal;
+                var nv = vertical;
+                switch (Blend)
+                {
+                    case LodInputBlend.Off:
+                        nh = MaximumReportedHorizontalDisplacement;
+                        nv = MaximumReportedVerticalDisplacement;
+                        break;
+                    case LodInputBlend.Additive:
+                        nh += MaximumReportedHorizontalDisplacement;
+                        nv += MaximumReportedVerticalDisplacement;
+                        break;
+                    case LodInputBlend.Alpha:
+                    case LodInputBlend.AlphaClip:
+                        nh = Mathf.Max(nh, MaximumReportedHorizontalDisplacement);
+                        nv = Mathf.Max(nh, MaximumReportedVerticalDisplacement);
+                        break;
+                }
+
+                horizontal = Mathf.Max(horizontal, nh);
+                vertical = Mathf.Max(vertical, nv);
+
                 return true;
             }
 
             return false;
         }
 
+        float ReportWaveDisplacement(WaterRenderer water, float displacement)
+        {
+            if (Mode == LodInputMode.Global)
+            {
+                return displacement + MaximumReportedWavesDisplacement;
+            }
+
+            if (!_IncludeInDropDetailHeightBasedOnWaves)
+            {
+                return displacement;
+            }
+
+            // TODO: use bounds to transition slowly to avoid pops.
+            if (_Rect.Contains(water.Position.XZ()))
+            {
+                displacement = Blend switch
+                {
+                    LodInputBlend.Off => MaximumReportedWavesDisplacement,
+                    LodInputBlend.Additive => displacement + MaximumReportedWavesDisplacement,
+                    LodInputBlend.Alpha or LodInputBlend.AlphaClip => Mathf.Max(displacement, MaximumReportedWavesDisplacement),
+                    _ => MaximumReportedWavesDisplacement,
+                };
+            }
+
+            return displacement;
+        }
+
         float GetWaveDirectionHeadingAngle()
         {
             return _OverrideGlobalWindDirection || WaterRenderer.Instance == null ? _WaveDirectionHeadingAngle : WaterRenderer.Instance.WindDirection;
         }
+
+        internal int GetResolution()
+        {
+            return Mathf.Clamp(_Resolution, MinimumResolution, MaximumResolution);
+        }
     }
 
     partial class ShapeWaves
     {
         Reporter _Reporter;
 
-        sealed class Reporter : IReportsDisplacement
+        sealed class Reporter : IReportsDisplacement, IReportWaveDisplacement
         {
             readonly ShapeWaves _Input;
             public Reporter(ShapeWaves input) => _Input = input;
-            public bool ReportDisplacement(ref Rect bounds, ref float horizontal, ref float vertical) => _Input.ReportDisplacement(ref bounds, ref horizontal, ref vertical);
+            public bool ReportDisplacement(WaterRenderer water, ref Rect bounds, ref float horizontal, ref float vertical) => _Input.ReportDisplacement(water, ref bounds, ref horizontal, ref vertical);
+            public float ReportWaveDisplacement(WaterRenderer water, float displacement) => _Input.ReportWaveDisplacement(water, displacement);
         }
     }
 
@@ -465,6 +581,7 @@ namespace WaveHarmonic.Crest
                 if (s_WindSpectrum != null)
                 {
                     Helpers.Destroy(s_WindSpectrum);
+                    s_WindSpectrum = null;
                 }
             }
         }
@@ -472,16 +589,20 @@ namespace WaveHarmonic.Crest
 
     partial class ShapeWaves
     {
+        private protected override int Version => Mathf.Max(base.Version, 3);
+
         [HideInInspector, SerializeField]
         AlphaSource _AlphaSource;
         enum AlphaSource { AlwaysOne, FromZero, FromZeroNormalized }
 
-        private protected int MigrateV1(int version)
+        private protected override void OnMigrate()
         {
+            base.OnMigrate();
+
             // Version 1
             // - Merge Alpha Source into Blend.
             // - Rename and invert Spectrum Fixed at Run-Time
-            if (version < 1)
+            if (_Version < 1)
             {
                 if (_Blend == LodInputBlend.Alpha)
                 {
@@ -495,24 +616,19 @@ namespace WaveHarmonic.Crest
                 }
 
                 _EvaluateSpectrumAtRunTimeEveryFrame = !_EvaluateSpectrumAtRunTimeEveryFrame;
-
-                version = 1;
             }
 
-            return version;
-        }
-
-        private protected int MigrateV2(int version)
-        {
             // Version 2
             // - Global wind direction
-            if (version < 2)
+            if (_Version < 2)
             {
                 _OverrideGlobalWindDirection = true;
-                version = 2;
             }
 
-            return version;
+            if (_Version < 3)
+            {
+                _SeaLevelOnly = false;
+            }
         }
     }
 

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/SphereWaterInteraction.cs

@@ -17,11 +17,6 @@ namespace WaveHarmonic.Crest
     [@HelpURL("Manual/Waves.html#adding-interaction-forces")]
     public sealed partial class SphereWaterInteraction : ManagedBehaviour<WaterRenderer>
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 0;
-#pragma warning restore 414
-
         [Tooltip("Radius of the sphere that is modelled from which the interaction forces are calculated.")]
         [@Range(0.01f, 50f)]
         [@GenerateAPI]

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/TextureLodInputData.cs

@@ -34,7 +34,10 @@ namespace WaveHarmonic.Crest
 
         internal override void RecalculateBounds()
         {
-            throw new System.NotImplementedException();
+            var transform = _Input.transform;
+            var scale = transform.lossyScale.XZ();
+            scale = Helpers.RotateAndEncapsulateXZ(scale, transform.rotation.eulerAngles.y);
+            _Bounds = new(_Input.transform.position, scale.XNZ());
         }
 
         internal override void Draw(Lod lod, Component component, CommandBuffer buffer, RenderTargetIdentifier target, int slices)
@@ -45,7 +48,7 @@ namespace WaveHarmonic.Crest
             wrapper.SetVector(ShaderIDs.s_TextureSize, transform.lossyScale.XZ());
             wrapper.SetVector(ShaderIDs.s_TexturePosition, transform.position.XZ());
             wrapper.SetVector(ShaderIDs.s_TextureRotation, rotation);
-            wrapper.SetVector(ShaderIDs.s_Resolution, new(_Texture.width, _Texture.height));
+            wrapper.SetVector(ShaderIDs.s_TextureResolution, new(_Texture.width, _Texture.height));
             wrapper.SetVector(ShaderIDs.s_Multiplier, _Multiplier);
             wrapper.SetFloat(ShaderIDs.s_FeatherWidth, _Input.FeatherWidth);
             wrapper.SetTexture(ShaderIDs.s_Texture, _Texture);

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Input/WatertightHull.cs

@@ -52,14 +52,14 @@ namespace WaveHarmonic.Crest
         WatertightHullMode _Mode = WatertightHullMode.Displacement;
 
         [Tooltip("Inverts the effect to remove clipping (ie add water).")]
-        [@Predicated(nameof(_Mode), inverted: true, nameof(WatertightHullMode.Clip), hide: true)]
+        [@Show(nameof(_Mode), nameof(WatertightHullMode.Clip))]
         [@GenerateAPI]
         [@DecoratedField, SerializeField]
         bool _Inverted;
 
         [@Label("Use Clip")]
         [Tooltip("Whether to also to clip the surface when using displacement mode.\n\nDisplacement mode can have a leaky hull by allowing chop top push waves across the hull boundaries slightly. Clipping the surface will remove these interior leaks.")]
-        [@Predicated(nameof(_Mode), inverted: true, nameof(WatertightHullMode.Displacement), hide: true)]
+        [@Show(nameof(_Mode), nameof(WatertightHullMode.Displacement))]
         [@GenerateAPI(Setter.Custom)]
         [@DecoratedField, SerializeField]
         bool _UseClipWithDisplacement = true;
@@ -248,28 +248,19 @@ namespace WaveHarmonic.Crest
         }
     }
 
-    partial class WatertightHull : ISerializationCallbackReceiver
+    partial class WatertightHull
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 1;
-#pragma warning restore 414
+        private protected override int Version => Mathf.Max(base.Version, 1);
 
-        /// <inheritdoc/>
-        void ISerializationCallbackReceiver.OnAfterDeserialize()
+        private protected override void OnMigrate()
         {
+            base.OnMigrate();
+
             if (_Version < 1)
             {
                 // Keep clip for existing.
                 _Mode = WatertightHullMode.Clip;
-                _Version = 1;
             }
         }
-
-        /// <inheritdoc/>
-        void ISerializationCallbackReceiver.OnBeforeSerialize()
-        {
-
-        }
     }
 }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/LevelLod.cs

@@ -18,6 +18,7 @@ namespace WaveHarmonic.Crest
         internal static readonly Color s_GizmoColor = new(75f / 255f, 0f, 130f / 255f, 0.5f);
 
         internal override string ID => "Level";
+        internal override string Name => "Water Level";
         internal override Color GizmoColor => s_GizmoColor;
         private protected override Color ClearColor => Color.black;
         private protected override bool NeedToReadWriteTextureData => true;
@@ -41,6 +42,7 @@ namespace WaveHarmonic.Crest
             _OverrideResolution = false;
             _TextureFormatMode = LodTextureFormatMode.Automatic;
             _TextureFormat = GraphicsFormat.R16_SFloat;
+            _BlurIterations = 4;
         }
 
         internal static readonly SortedList<int, ILodInput> s_Inputs = new(Helpers.DuplicateComparison);

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Lod.cs

@@ -1,19 +1,16 @@
 // Crest Water System
 // Copyright © 2024 Wave Harmonic. All rights reserved.
 
+using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.Experimental.Rendering;
 using UnityEngine.Rendering;
 using WaveHarmonic.Crest.Internal;
 using WaveHarmonic.Crest.Utility;
 
-#if !UNITY_2023_2_OR_NEWER
-using GraphicsFormatUsage = UnityEngine.Experimental.Rendering.FormatUsage;
-#endif
-
 namespace WaveHarmonic.Crest
 {
-    using Inputs = SortedList<int, ILodInput>;
+    using Inputs = Utility.SortedList<int, ILodInput>;
 
     /// <summary>
     /// Texture format preset.
@@ -42,7 +39,7 @@ namespace WaveHarmonic.Crest
     /// Base class for data/behaviours created on each LOD.
     /// </summary>
     [System.Serializable]
-    public abstract partial class Lod
+    public abstract partial class Lod : Versioned
     {
         [Tooltip("Whether the simulation is enabled.")]
         [@GenerateAPI(Getter.Custom, Setter.Custom)]
@@ -50,14 +47,13 @@ namespace WaveHarmonic.Crest
         internal bool _Enabled;
 
         [Tooltip("Whether to override the resolution.\n\nIf not enabled, then the simulation will use the resolution defined on the Water Renderer.")]
-        [@Predicated(typeof(AnimatedWavesLod), inverted: true, hide: true)]
+        [@Hide(typeof(AnimatedWavesLod))]
         [@GenerateAPI(Setter.Dirty)]
-        [@InlineToggle(fix: true), SerializeField]
+        [@InlineToggle, SerializeField]
         internal bool _OverrideResolution = true;
 
         [Tooltip("The resolution of the simulation data.\n\nSet higher for sharper results at the cost of higher memory usage.")]
-        [@Predicated(typeof(AnimatedWavesLod), inverted: true, hide: true)]
-        [@Predicated(nameof(_OverrideResolution), hide: true)]
+        [@Show(nameof(_OverrideResolution))]
         [@ShowComputedProperty(nameof(Resolution))]
         [@Delayed]
         [@GenerateAPI(Getter.Custom, Setter.Dirty)]
@@ -72,25 +68,45 @@ namespace WaveHarmonic.Crest
 
         [Tooltip("The render texture format used for this simulation data.\n\nIt will be overriden if the format is incompatible with the platform.")]
         [@ShowComputedProperty(nameof(RequestedTextureFormat))]
-        [@Predicated(nameof(_TextureFormatMode), inverted: true, nameof(LodTextureFormatMode.Manual), hide: true)]
+        [@Show(nameof(_TextureFormatMode), nameof(LodTextureFormatMode.Manual))]
         [@GenerateAPI(Setter.Dirty)]
         [@DecoratedField, SerializeField]
         internal GraphicsFormat _TextureFormat;
 
+        [@Space(10)]
+
+        [Tooltip("Blurs the output.\n\nEnable if blurring is desired or intolerable artifacts are present.\nThe blur is optimized to only run on inner LODs and at lower scales.")]
+        [@Hide(typeof(AnimatedWavesLod))]
+        [@Hide(typeof(DynamicWavesLod))]
+        [@GenerateAPI(Setter.Dirty)]
+        [@DecoratedField]
+        [SerializeField]
+        private protected bool _Blur;
+
+        [Tooltip("Number of blur iterations.\n\nBlur iterations are optimized to only run maximum iterations on the inner LODs.")]
+        [@Hide(typeof(AnimatedWavesLod))]
+        [@Hide(typeof(DynamicWavesLod))]
+        [@Enable(nameof(_Blur))]
+        [@GenerateAPI]
+        [@DecoratedField]
+        [SerializeField]
+        private protected int _BlurIterations = 1;
+
         // NOTE: This MUST match the value in Constants.hlsl, as it
         // determines the size of the texture arrays in the shaders.
         internal const int k_MaximumSlices = 15;
-
-        // NOTE: these MUST match the values in Constants.hlsl
-        // 64 recommended as a good common minimum: https://www.reddit.com/r/GraphicsProgramming/comments/aeyfkh/for_compute_shaders_is_there_an_ideal_numthreads/
         internal const int k_ThreadGroupSize = 8;
         internal const int k_ThreadGroupSizeX = k_ThreadGroupSize;
         internal const int k_ThreadGroupSizeY = k_ThreadGroupSize;
 
+        internal const string k_BlurField = nameof(_Blur);
+        internal const string k_TextureFormatModeField = nameof(_TextureFormatMode);
+
         internal static class ShaderIDs
         {
             public static readonly int s_LodIndex = Shader.PropertyToID("_Crest_LodIndex");
             public static readonly int s_LodChange = Shader.PropertyToID("_Crest_LodChange");
+            public static readonly int s_TemporaryBlurLodTexture = Shader.PropertyToID("_Crest_TemporaryBlurLodTexture");
         }
 
         // Used for creating shader property names etc.
@@ -136,17 +152,10 @@ namespace WaveHarmonic.Crest
             }
         }
 
-        static readonly GraphicsFormatUsage s_GraphicsFormatUsage =
-            // Ensures a non compressed format is returned.
-            GraphicsFormatUsage.LoadStore |
-            // All these textures are sampled at some point.
-            GraphicsFormatUsage.Sample |
-            // Always use linear filtering.
-            GraphicsFormatUsage.Linear;
+        private protected bool Persistent => BufferCount > 1;
+        internal virtual bool SkipEndOfFrame => false;
 
-        private protected BufferedData<RenderTexture> _Targets;
-        internal RenderTexture DataTexture => _Targets.Current;
-        internal RenderTexture GetDataTexture(int frameDelta) => _Targets.Previous(frameDelta);
+        internal RenderTexture DataTexture { get; private protected set; }
 
         private protected Matrix4x4[] _ViewMatrices = new Matrix4x4[k_MaximumSlices];
         private protected Cascade[] _Cascades = new Cascade[k_MaximumSlices];
@@ -161,7 +170,7 @@ namespace WaveHarmonic.Crest
         internal WaterRenderer _Water;
         internal WaterRenderer Water => _Water;
 
-        private protected int _TargetsToClear;
+        private protected bool _TargetsToClear;
 
         private protected readonly int _TextureShaderID;
         private protected readonly int _TextureSourceShaderID;
@@ -184,8 +193,10 @@ namespace WaveHarmonic.Crest
             _TextureName = $"_Crest_{ID}Lod";
         }
 
-        private protected RenderTexture CreateLodDataTextures()
+        private protected RenderTexture CreateLodDataTextures(string postfix = null)
         {
+            postfix ??= string.Empty;
+
             RenderTexture result = new(Resolution, Resolution, 0, CompatibleTextureFormat)
             {
                 wrapMode = TextureWrapMode.Clamp,
@@ -193,7 +204,7 @@ namespace WaveHarmonic.Crest
                 filterMode = FilterMode.Bilinear,
                 anisoLevel = 0,
                 useMipMap = false,
-                name = _TextureName,
+                name = _TextureName + postfix,
                 dimension = TextureDimension.Tex2DArray,
                 volumeDepth = Slices,
                 enableRandomWrite = NeedToReadWriteTextureData
@@ -202,7 +213,7 @@ namespace WaveHarmonic.Crest
             return result;
         }
 
-        private protected void FlipBuffers()
+        private protected void FlipBuffers(CommandBuffer commands)
         {
             if (_ReAllocateTexture)
             {
@@ -214,11 +225,10 @@ namespace WaveHarmonic.Crest
             if (!UnityEditor.EditorApplication.isPaused || Time.deltaTime > 0)
 #endif
             {
-                _Targets.Flip();
                 _SamplingParameters.Flip();
             }
 
-            UpdateSamplingParameters();
+            UpdateSamplingParameters(commands);
         }
 
         private protected void Clear(RenderTexture target)
@@ -226,29 +236,36 @@ namespace WaveHarmonic.Crest
             Helpers.ClearRenderTexture(target, ClearColor, depth: false);
         }
 
-        /// <summary>
-        /// Clears persistent LOD data. Some simulations have persistent data which can linger for a little while after
-        /// being disabled. This will manually clear that data.
-        /// </summary>
-        internal virtual void ClearLodData()
-        {
-            // Empty.
-        }
-
         private protected virtual bool AlwaysClear => false;
 
         // Only works with input-only data (ie no simulation steps).
         internal virtual void BuildCommandBuffer(WaterRenderer water, CommandBuffer buffer)
         {
-            FlipBuffers();
+            FlipBuffers(buffer);
 
             buffer.BeginSample(ID);
 
-            if (_TargetsToClear > 0 || AlwaysClear)
+            if (_TargetsToClear || AlwaysClear)
             {
+                // IMPORTANT:
+                // We need both clears otherwise problems on PS5.
+                // With only native clear, flow would clear to non black (ie constant flow).
+                // With only custom clear, absorption/scattering inputs were not clearing.
                 CoreUtils.SetRenderTarget(buffer, DataTexture, ClearFlag.Color, ClearColor);
 
-                _TargetsToClear--;
+                // Custom clear because clear not working.
+                if (Helpers.RequiresCustomClear && WaterResources.Instance.Compute._Clear != null)
+                {
+                    var compute = WaterResources.Instance._ComputeLibrary._ClearCompute;
+                    var wrapper = new PropertyWrapperCompute(buffer, compute._Shader, compute._KernelClearTarget);
+                    compute.SetVariantForFormat(wrapper, CompatibleTextureFormat);
+                    wrapper.SetTexture(Crest.ShaderIDs.s_Target, DataTexture);
+                    wrapper.SetVector(Crest.ShaderIDs.s_ClearMask, Color.white);
+                    wrapper.SetVector(Crest.ShaderIDs.s_ClearColor, ClearColor);
+                    wrapper.Dispatch(Resolution / k_ThreadGroupSizeX, Resolution / k_ThreadGroupSizeY, Slices);
+                }
+
+                _TargetsToClear = false;
             }
 
             if (Inputs.Count > 0)
@@ -256,9 +273,11 @@ namespace WaveHarmonic.Crest
                 SubmitDraws(buffer, Inputs, DataTexture);
 
                 // Ensure all targets clear when there are no inputs.
-                _TargetsToClear = _Targets.Size;
+                _TargetsToClear = true;
             }
 
+            TryBlur(buffer);
+
             if (RequiresClearBorder)
             {
                 ClearBorder(buffer);
@@ -354,14 +373,18 @@ namespace WaveHarmonic.Crest
         {
             var size = Resolution / 8;
 
-            var wrapper = new PropertyWrapperCompute(buffer, WaterResources.Instance.Compute._Clear, 1);
+            var compute = WaterResources.Instance._ComputeLibrary._ClearCompute;
+
+            var wrapper = new PropertyWrapperCompute(buffer, compute._Shader, compute._KernelClearTargetBoundaryX);
+            // Only need to be done once.
+            compute.SetVariantForFormat(wrapper, DataTexture.graphicsFormat);
             wrapper.SetTexture(Crest.ShaderIDs.s_Target, DataTexture);
             wrapper.SetVector(Crest.ShaderIDs.s_ClearColor, ClearColor);
             wrapper.SetInteger(Crest.ShaderIDs.s_Resolution, Resolution);
             wrapper.SetInteger(Crest.ShaderIDs.s_TargetSlice, Slices - 1);
             wrapper.Dispatch(size, 1, 1);
 
-            wrapper = new PropertyWrapperCompute(buffer, WaterResources.Instance.Compute._Clear, 2);
+            wrapper = new(buffer, compute._Shader, compute._KernelClearTargetBoundaryY);
             wrapper.SetTexture(Crest.ShaderIDs.s_Target, DataTexture);
             wrapper.SetVector(Crest.ShaderIDs.s_ClearColor, ClearColor);
             wrapper.SetInteger(Crest.ShaderIDs.s_Resolution, Resolution);
@@ -369,7 +392,7 @@ namespace WaveHarmonic.Crest
             wrapper.Dispatch(1, size, 1);
         }
 
-        void UpdateSamplingParameters(bool initialize = false)
+        void UpdateSamplingParameters(CommandBuffer commands, bool initialize = false)
         {
             var position = _Water.Position;
             var resolution = _Enabled ? Resolution : TextureArrayHelpers.k_SmallTextureSize;
@@ -380,7 +403,7 @@ namespace WaveHarmonic.Crest
             for (var slice = 0; slice < levels; slice++)
             {
                 // Find snap period.
-                var texel = 2f * 2f * _Water._CascadeData.Current[slice].x / resolution;
+                var texel = 2f * 2f * _Water.CascadeData.Current[slice].x / resolution;
                 // Snap so that shape texels are stationary.
                 var snapped = position - new Vector3(Mathf.Repeat(position.x, texel), 0, Mathf.Repeat(position.z, texel));
 
@@ -392,11 +415,20 @@ namespace WaveHarmonic.Crest
                 _ViewMatrices[slice] = WaterRenderer.CalculateViewMatrixFromSnappedPositionRHS(snapped);
             }
 
-            if (initialize)
+            if (!initialize)
             {
-                Shader.SetGlobalVector(_SamplingParametersShaderID, new(levels, resolution, 1f / resolution, 0));
+                commands.SetGlobalVector(_SamplingParametersShaderID, new(levels, resolution, 1f / resolution, 0));
+                commands.SetGlobalVectorArray(_SamplingParametersCascadeShaderID, parameters);
+
+                if (BufferCount > 1)
+                {
+                    commands.SetGlobalVectorArray(_SamplingParametersCascadeSourceShaderID, _SamplingParameters.Previous(1));
+                }
+
+                return;
             }
 
+            Shader.SetGlobalVector(_SamplingParametersShaderID, new(levels, resolution, 1f / resolution, 0));
             Shader.SetGlobalVectorArray(_SamplingParametersCascadeShaderID, parameters);
 
             if (BufferCount > 1)
@@ -468,7 +500,7 @@ namespace WaveHarmonic.Crest
 
                 // The smallest wavelengths should repeat no more than twice across the smaller
                 // spatial length. Unless we're in the last LOD - then this is the best we can do.
-                var minimumWavelength = _Water.MaximumWavelength(index) / 2f;
+                var minimumWavelength = _Water.MaximumWavelength(index, Resolution) / 2f;
                 if (minimumWavelength < minimumSpatialLength / 2f && index < count - 1)
                 {
                     continue;
@@ -480,6 +512,48 @@ namespace WaveHarmonic.Crest
             return -1;
         }
 
+        // Blurs the output if enabled.
+        private protected void TryBlur(CommandBuffer commands)
+        {
+            if (!_Blur || _Water.Scale >= 32)
+            {
+                return;
+            }
+
+            var rt = DataTexture;
+
+            var compute = WaterResources.Instance._ComputeLibrary._BlurCompute;
+
+            var horizontal = new PropertyWrapperCompute(commands, compute._Shader, compute._KernelHorizontal);
+            var vertical = new PropertyWrapperCompute(commands, compute._Shader, compute._KernelVertical);
+
+            var temporary = ShaderIDs.s_TemporaryBlurLodTexture;
+
+            commands.GetTemporaryRT(temporary, rt.descriptor);
+
+            // Applies to both.
+            compute.SetVariantForFormat(horizontal, rt.graphicsFormat);
+            horizontal.SetInteger(Crest.ShaderIDs.s_Resolution, rt.width);
+
+            horizontal.SetTexture(Crest.ShaderIDs.s_Source, rt);
+            horizontal.SetTexture(Crest.ShaderIDs.s_Target, temporary);
+            vertical.SetTexture(Crest.ShaderIDs.s_Source, temporary);
+            vertical.SetTexture(Crest.ShaderIDs.s_Target, rt);
+
+            var x = rt.width / 8;
+            var y = rt.height / 8;
+            // Skip outer LODs.
+            var z = Mathf.Min(rt.volumeDepth, 4);
+            for (var i = 0; i < _BlurIterations; i++)
+            {
+                // Limit number of iterations for outer LODs.
+                horizontal.Dispatch(x, y, Mathf.Max(z - i, 1));
+                vertical.Dispatch(x, y, Mathf.Max(z - i, 1));
+            }
+
+            commands.ReleaseTemporaryRT(temporary);
+        }
+
         /// <summary>
         /// Bind data needed to load or compute from this simulation.
         /// </summary>
@@ -500,7 +574,7 @@ namespace WaveHarmonic.Crest
             // Validate textures.
             {
                 // Find a compatible texture format.
-                CompatibleTextureFormat = Helpers.GetCompatibleTextureFormat(RequestedTextureFormat, s_GraphicsFormatUsage, Name, NeedToReadWriteTextureData);
+                CompatibleTextureFormat = Helpers.GetCompatibleTextureFormat(RequestedTextureFormat, Helpers.s_DataGraphicsFormatUsage, Name, NeedToReadWriteTextureData);
 
                 if (CompatibleTextureFormat == GraphicsFormat.None)
                 {
@@ -523,20 +597,15 @@ namespace WaveHarmonic.Crest
             // Bind/unbind data texture for all shaders.
             Shader.SetGlobalTexture(_TextureShaderID, enable && Enabled ? DataTexture : NullTexture);
 
-            if (BufferCount > 1)
-            {
-                Shader.SetGlobalTexture(_TextureSourceShaderID, enable && Enabled ? GetDataTexture(1) : NullTexture);
-            }
-
             if (_SamplingParameters == null || _SamplingParameters.Size != BufferCount)
             {
                 _SamplingParameters = new(BufferCount, () => new Vector4[k_MaximumSlices]);
             }
 
             // For safety. Disable to see if we are sampling outside of LOD chain.
-            _SamplingParameters.RunLambda(x => System.Array.Fill(x, Vector4.zero));
+            _SamplingParameters.RunLambda(x => System.Array.Fill(x, new(0, 0, 1, 0)));
 
-            UpdateSamplingParameters(initialize: true);
+            UpdateSamplingParameters(null, initialize: true);
         }
 
         internal virtual void Enable()
@@ -553,11 +622,10 @@ namespace WaveHarmonic.Crest
         internal virtual void Destroy()
         {
             // Release resources and destroy object to avoid reference leak.
-            _Targets?.RunLambda(x =>
-            {
-                if (x != null) x.Release();
-                Helpers.Destroy(x);
-            });
+            if (DataTexture != null) DataTexture.Release();
+            Helpers.Destroy(DataTexture);
+
+            _AdditionalCameraData.Clear();
         }
 
         internal virtual void AfterExecute()
@@ -567,10 +635,11 @@ namespace WaveHarmonic.Crest
 
         private protected virtual void Allocate()
         {
-            _Targets = new(BufferCount, CreateLodDataTextures);
-            _Targets.RunLambda(Clear);
+            // Use per-camera data.
+            DataTexture = CreateLodDataTextures();
+            Clear(DataTexture);
 
-            // Bind globally once here on init, which will bind to all graphics shaders (not compute)
+            // Bind globally once here on init, which will bind to all shaders.
             Shader.SetGlobalTexture(_TextureShaderID, DataTexture);
 
             _ReAllocateTexture = false;
@@ -600,23 +669,21 @@ namespace WaveHarmonic.Crest
 
         int GetResolution() => _OverrideResolution || Water == null ? _Resolution : Water.LodResolution;
 
-        private protected void ReAllocate()
+        private protected virtual void ReAllocate()
         {
             if (!Enabled) return;
-            CompatibleTextureFormat = Helpers.GetCompatibleTextureFormat(RequestedTextureFormat, s_GraphicsFormatUsage, Name, NeedToReadWriteTextureData);
-            var descriptor = _Targets.Current.descriptor;
+            CompatibleTextureFormat = Helpers.GetCompatibleTextureFormat(RequestedTextureFormat, Helpers.s_DataGraphicsFormatUsage, Name, NeedToReadWriteTextureData);
+            var descriptor = DataTexture.descriptor;
             descriptor.height = descriptor.width = Resolution;
             descriptor.graphicsFormat = CompatibleTextureFormat;
-            _Targets.RunLambda(texture =>
-            {
-                texture.Release();
-                texture.descriptor = descriptor;
-                texture.Create();
-            });
+            descriptor.enableRandomWrite = NeedToReadWriteTextureData;
+            DataTexture.Release();
+            DataTexture.descriptor = descriptor;
+            DataTexture.Create();
 
             _ReAllocateTexture = false;
 
-            UpdateSamplingParameters(initialize: true);
+            UpdateSamplingParameters(null, initialize: true);
         }
 
 #if UNITY_EDITOR
@@ -628,6 +695,7 @@ namespace WaveHarmonic.Crest
                 case nameof(_Enabled):
                     SetEnabled((bool)previousValue, _Enabled);
                     break;
+                case nameof(_Blur):
                 case nameof(_Resolution):
                 case nameof(_OverrideResolution):
                 case nameof(_TextureFormat):
@@ -639,6 +707,45 @@ namespace WaveHarmonic.Crest
 #endif
     }
 
+    partial class Lod
+    {
+        readonly Dictionary<Camera, BufferedData<Vector4[]>> _AdditionalCameraData = new();
+
+        internal virtual void LoadCameraData(Camera camera)
+        {
+            Queryable?.Initialize(_Water);
+
+            // For non-persistent sims, we do not need to store per camera data.
+            if (!Persistent)
+            {
+                return;
+            }
+
+            if (!_AdditionalCameraData.ContainsKey(camera))
+            {
+                _SamplingParameters = new(BufferCount, () => new Vector4[k_MaximumSlices]);
+                _AdditionalCameraData.Add(camera, _SamplingParameters);
+            }
+            else
+            {
+                _SamplingParameters = _AdditionalCameraData[camera];
+            }
+        }
+
+        internal virtual void StoreCameraData(Camera camera)
+        {
+
+        }
+
+        internal virtual void RemoveCameraData(Camera camera)
+        {
+            if (_AdditionalCameraData.ContainsKey(camera))
+            {
+                _AdditionalCameraData.Remove(camera);
+            }
+        }
+    }
+
     // API
     partial class Lod
     {
@@ -657,29 +764,78 @@ namespace WaveHarmonic.Crest
         }
     }
 
+    interface IQueryableLod<out T> where T : IQueryProvider
+    {
+        string Name { get; }
+        bool Enabled { get; }
+        WaterRenderer Water { get; }
+        int MaximumQueryCount { get; }
+        float Texel { get; }
+        LodQuerySource QuerySource { get; }
+    }
+
+    /// <summary>
+    /// The source of collisions (ie water shape).
+    /// </summary>
+    [@GenerateDoc]
+    public enum LodQuerySource
+    {
+        /// <inheritdoc cref="Generated.LodQuerySource.None"/>
+        [Tooltip("No query source.")]
+        None,
+
+        /// <inheritdoc cref="Generated.LodQuerySource.GPU"/>
+        [Tooltip("Uses AsyncGPUReadback to retrieve data from GPU to CPU.\n\nThis is the most optimal approach.")]
+        GPU,
+
+        /// <inheritdoc cref="Generated.LodQuerySource.CPU"/>
+        [Tooltip("Computes data entirely on the CPU.")]
+        CPU,
+    }
+
     /// <summary>
     /// Base type for simulations with a provider.
     /// </summary>
     /// <typeparam name="T">The query provider.</typeparam>
     [System.Serializable]
-    public abstract class Lod<T> : Lod where T : IQueryProvider
+    public abstract partial class Lod<T> : Lod, IQueryableLod<T> where T : IQueryProvider
     {
+        [@Space(10)]
+
+        [Tooltip("Where to obtain water data on CPU for physics / gameplay.")]
+        [@GenerateAPI(Setter.Internal)]
+        [@Filtered]
+        [SerializeField]
+        private protected LodQuerySource _QuerySource = LodQuerySource.GPU;
+
+        [Tooltip("Maximum number of queries that can be performed when using GPU queries.")]
+        [@Show(nameof(_QuerySource), nameof(LodQuerySource.GPU))]
+        [@GenerateAPI(Setter.None)]
+        [@DecoratedField]
+        [SerializeField]
+        private protected int _MaximumQueryCount = QueryBase.k_DefaultMaximumQueryCount;
+
         /// <summary>
         /// Provides data from the GPU to CPU.
         /// </summary>
         public T Provider { get; set; }
-        private protected abstract T CreateProvider(bool enable);
 
-        internal override void SetGlobals(bool enable)
+        WaterRenderer IQueryableLod<T>.Water => Water;
+        string IQueryableLod<T>.Name => Name;
+        float IQueryableLod<T>.Texel => _Cascades[0]._Texel;
+
+        private protected abstract T CreateProvider(bool onEnable);
+
+        internal override void SetGlobals(bool onEnable)
         {
-            base.SetGlobals(enable);
+            base.SetGlobals(onEnable);
             // We should always have a provider (null provider if disabled).
-            InitializeProvider(enable);
+            InitializeProvider(onEnable);
         }
 
-        private protected void InitializeProvider(bool enable)
+        private protected void InitializeProvider(bool onEnable)
         {
-            Provider = CreateProvider(enable);
+            Provider = CreateProvider(onEnable);
             // None providers are not IQueryable.
             Queryable = Provider as IQueryable;
         }
@@ -689,4 +845,30 @@ namespace WaveHarmonic.Crest
             Queryable?.SendReadBack(_Water);
         }
     }
+
+#if UNITY_EDITOR
+    partial class Lod<T>
+    {
+        private protected void ResetQueryChange()
+        {
+            if (_Water == null || !_Water.isActiveAndEnabled || !_Enabled) return;
+            Queryable?.CleanUp();
+            InitializeProvider(true);
+        }
+
+        [@OnChange]
+        private protected override void OnChange(string path, object previous)
+        {
+            base.OnChange(path, previous);
+
+            switch (path)
+            {
+                case nameof(_QuerySource):
+                case nameof(_MaximumQueryCount):
+                    ResetQueryChange();
+                    break;
+            }
+        }
+    }
+#endif
 }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/PersistentLod.cs

@@ -12,8 +12,10 @@ namespace WaveHarmonic.Crest
     [System.Serializable]
     public abstract partial class PersistentLod : Lod
     {
+        [@Space(10)]
+
         [Tooltip("Frequency to run the simulation, in updates per second.\n\nLower frequencies are more efficient but may lead to visible jitter or slowness.")]
-        [@Range(15, 200, order = -1000)]
+        [@Range(15, 200)]
         [@GenerateAPI]
         [SerializeField]
         private protected int _SimulationFrequency = 60;
@@ -21,27 +23,27 @@ namespace WaveHarmonic.Crest
         static new class ShaderIDs
         {
             public static readonly int s_SimDeltaTime = Shader.PropertyToID("_Crest_SimDeltaTime");
-            public static readonly int s_SimDeltaTimePrev = Shader.PropertyToID("_Crest_SimDeltaTimePrev");
             public static readonly int s_TemporaryPersistentTarget = Shader.PropertyToID("_Crest_TemporaryPersistentTarget");
         }
 
         private protected override bool NeedToReadWriteTextureData => true;
         internal override int BufferCount => 2;
 
-        float _PreviousSubstepDeltaTime = 1f / 60f;
-
         // Is this the first step since being enabled?
         private protected bool _NeedsPrewarmingThisStep = true;
 
         // This is how far the simulation time is behind Unity's time.
         private protected float _TimeToSimulate = 0f;
 
+        // Pristine historic data. Needed if using blur or multiple viewpoints. For the
+        // latter, we cannot optimize the upstream data texture away due to camera filtering.
+        private protected RenderTexture _PersistentDataTexture;
+
         internal int LastUpdateSubstepCount { get; private set; }
 
         private protected virtual int Kernel => 0;
         private protected virtual bool SkipFlipBuffers => false;
         private protected abstract ComputeShader SimulationShader { get; }
-        private protected abstract void GetSubstepData(float timeToSimulate, out int substeps, out float delta);
 
         internal override void Initialize()
         {
@@ -56,28 +58,51 @@ namespace WaveHarmonic.Crest
             _NeedsPrewarmingThisStep = true;
         }
 
-        internal override void ClearLodData()
+        private protected override void Allocate()
         {
-            base.ClearLodData();
-            _Targets.RunLambda(x => Clear(x));
+            base.Allocate();
+
+            // Use per-camera data.
+            if (!_Water.IsSingleViewpointMode)
+            {
+                return;
+            }
+
+            if (Blur)
+            {
+                _PersistentDataTexture = CreateLodDataTextures("_Source");
+            }
+        }
+
+        internal override void Destroy()
+        {
+            base.Destroy();
+
+            if (_PersistentDataTexture != null) _PersistentDataTexture.Release();
+            Helpers.Destroy(_PersistentDataTexture);
+
+            foreach (var data in _AdditionalCameraData.Values)
+            {
+                var x = data._PersistentData;
+                if (x != null) x.Release();
+                Helpers.Destroy(x);
+            }
+
+            _AdditionalCameraData.Clear();
         }
 
         internal override void BuildCommandBuffer(WaterRenderer water, CommandBuffer buffer)
         {
             buffer.BeginSample(ID);
 
-            if (!SkipFlipBuffers)
-            {
-                FlipBuffers();
-            }
-
-            var slices = water.LodLevels;
+            FlipBuffers(buffer);
 
             // How far are we behind.
             _TimeToSimulate += water.DeltaTime;
 
             // Do a set of substeps to catch up.
-            GetSubstepData(_TimeToSimulate, out var substeps, out var delta);
+            var substeps = Mathf.FloorToInt(_TimeToSimulate * _SimulationFrequency);
+            var delta = substeps > 0 ? (1f / _SimulationFrequency) : 0f;
 
             LastUpdateSubstepCount = substeps;
 
@@ -91,7 +116,10 @@ namespace WaveHarmonic.Crest
                 delta = 0f;
             }
 
-            if (substeps > 1)
+            // Use temporary if only storing one texture upstream which has the source.
+            var useTemporary = _Water.IsSingleViewpointMode && !Blur;
+
+            if (useTemporary)
             {
                 // No need to clear, as the update dispatch overwrites every pixel, but finding
                 // artifacts if not and there is a renderer input. Happens for foam and dynamic
@@ -100,9 +128,9 @@ namespace WaveHarmonic.Crest
                 CoreUtils.SetRenderTarget(buffer, ShaderIDs.s_TemporaryPersistentTarget, ClearFlag.Color, ClearColor);
             }
 
-            var target = new RenderTargetIdentifier(DataTexture);
-            var source = new RenderTargetIdentifier(ShaderIDs.s_TemporaryPersistentTarget);
-            var current = target;
+            var final = new RenderTargetIdentifier(DataTexture);
+            var target = useTemporary ? new RenderTargetIdentifier(ShaderIDs.s_TemporaryPersistentTarget) : final;
+            var source = useTemporary ? final : new RenderTargetIdentifier(_PersistentDataTexture);
 
             var wrapper = new PropertyWrapperCompute(buffer, SimulationShader, Kernel);
 
@@ -130,10 +158,9 @@ namespace WaveHarmonic.Crest
 
                 // Both simulation update and input draws need delta time.
                 buffer.SetGlobalFloat(ShaderIDs.s_SimDeltaTime, delta);
-                buffer.SetGlobalFloat(ShaderIDs.s_SimDeltaTimePrev, _PreviousSubstepDeltaTime);
 
+                wrapper.SetTexture(Crest.ShaderIDs.s_Source, source);
                 wrapper.SetTexture(Crest.ShaderIDs.s_Target, target);
-                wrapper.SetTexture(_TextureSourceShaderID, isFirstStep ? _Targets.Previous(1) : source);
 
                 // Compute which LOD data we are sampling source data from. if a scale change has
                 // happened this can be any LOD up or down the chain. This is only valid on the
@@ -141,7 +168,7 @@ namespace WaveHarmonic.Crest
                 // places.
                 wrapper.SetFloat(Lod.ShaderIDs.s_LodChange, isFirstStep ? _Water.ScaleDifferencePower2 : 0);
 
-                wrapper.SetVectorArray(WaterRenderer.ShaderIDs.s_CascadeDataSource, _Water._CascadeData.Previous(frame));
+                wrapper.SetVectorArray(WaterRenderer.ShaderIDs.s_CascadeDataSource, _Water.CascadeData.Previous(frame));
                 wrapper.SetVectorArray(_SamplingParametersCascadeSourceShaderID, _SamplingParameters.Previous(frame));
 
                 SetAdditionalSimulationParameters(wrapper);
@@ -157,22 +184,25 @@ namespace WaveHarmonic.Crest
 
                 // The very first step since being enabled.
                 _NeedsPrewarmingThisStep = false;
-                _PreviousSubstepDeltaTime = delta;
             }
 
             // Swap textures if needed.
-            if (target != current)
+            if (target != final)
             {
-                buffer.CopyTexture(target, DataTexture);
+                buffer.CopyTexture(target, final);
+            }
+            // Preserve non-blurred historic data.
+            else if (!useTemporary)
+            {
+                buffer.CopyTexture(target, source);
             }
 
-            if (substeps > 1)
+            if (useTemporary)
             {
                 buffer.ReleaseTemporaryRT(ShaderIDs.s_TemporaryPersistentTarget);
             }
 
-            // Set the target texture as to make sure we catch the 'pong' each frame.
-            Shader.SetGlobalTexture(_TextureShaderID, DataTexture);
+            TryBlur(buffer);
 
             buffer.EndSample(ID);
         }
@@ -184,5 +214,107 @@ namespace WaveHarmonic.Crest
         {
 
         }
+
+        private protected override void ReAllocate()
+        {
+            base.ReAllocate();
+
+            if (!Enabled)
+            {
+                return;
+            }
+
+            var descriptor = DataTexture.descriptor;
+
+            if (_Water.IsMultipleViewpointMode)
+            {
+                foreach (var (key, data) in _AdditionalCameraData)
+                {
+                    var texture = data._PersistentData;
+                    texture.Release();
+                    texture.descriptor = descriptor;
+                    texture.Create();
+                }
+
+                return;
+            }
+
+            if (_PersistentDataTexture != null)
+            {
+                _PersistentDataTexture.Release();
+                if (Blur)
+                {
+                    _PersistentDataTexture.descriptor = descriptor;
+                    _PersistentDataTexture.Create();
+                }
+                else
+                {
+                    Helpers.Destroy(_PersistentDataTexture);
+                }
+            }
+            else if (Blur)
+            {
+                _PersistentDataTexture = CreateLodDataTextures("_Source");
+            }
+        }
+    }
+
+    partial class PersistentLod
+    {
+        sealed class AdditionalCameraData
+        {
+            public RenderTexture _PersistentData;
+            public float _TimeToSimulate;
+        }
+
+        readonly System.Collections.Generic.Dictionary<Camera, AdditionalCameraData> _AdditionalCameraData = new();
+
+        internal override void LoadCameraData(Camera camera)
+        {
+            base.LoadCameraData(camera);
+
+            AdditionalCameraData data;
+
+            if (!_AdditionalCameraData.ContainsKey(camera))
+            {
+                data = new()
+                {
+                    _PersistentData = CreateLodDataTextures("_Source"),
+                    _TimeToSimulate = _TimeToSimulate,
+                };
+
+                _AdditionalCameraData.Add(camera, data);
+            }
+            else
+            {
+                data = _AdditionalCameraData[camera];
+            }
+
+            _PersistentDataTexture = data._PersistentData;
+            _TimeToSimulate = data._TimeToSimulate;
+        }
+
+        internal override void StoreCameraData(Camera camera)
+        {
+            base.StoreCameraData(camera);
+
+            if (_AdditionalCameraData.ContainsKey(camera))
+            {
+                _AdditionalCameraData[camera]._TimeToSimulate = _TimeToSimulate;
+            }
+        }
+
+        internal override void RemoveCameraData(Camera camera)
+        {
+            base.RemoveCameraData(camera);
+
+            if (_AdditionalCameraData.ContainsKey(camera))
+            {
+                var rt = _AdditionalCameraData[camera]._PersistentData;
+                if (rt != null) rt.Release();
+                Helpers.Destroy(rt);
+                _AdditionalCameraData.Remove(camera);
+            }
+        }
     }
 }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Query/Collision/CollisionAreaVisualizer.cs

@@ -14,11 +14,6 @@ namespace WaveHarmonic.Crest
     [AddComponentMenu(Constants.k_MenuPrefixDebug + "Collision Area Visualizer")]
     sealed class CollisionAreaVisualizer : ManagedBehaviour<WaterRenderer>
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 0;
-#pragma warning restore 414
-
         [Tooltip(ICollisionProvider.k_LayerTooltip)]
         [SerializeField]
         internal CollisionLayer _Layer;

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Query/Collision/CollisionProvider.cs

@@ -38,12 +38,17 @@ namespace WaveHarmonic.Crest
 
         internal static NoneProvider None { get; } = new();
 
+        internal static ICollisionProvider Create(WaterRenderer water)
+        {
+            return water.IsMultipleViewpointMode ? new CollisionQueryPerCamera(water) : new CollisionQueryWithPasses(water);
+        }
+
         /// <summary>
         /// Gives a flat, still water.
         /// </summary>
         internal sealed class NoneProvider : ICollisionProvider
         {
-            public int Query(int _0, float _1, Vector3[] _2, Vector3[] result0, Vector3[] result1, Vector3[] result2, CollisionLayer _3 = CollisionLayer.Everything)
+            public int Query(int _0, float _1, Vector3[] _2, Vector3[] result0, Vector3[] result1, Vector3[] result2, CollisionLayer _3 = CollisionLayer.Everything, Vector3? _4 = null)
             {
                 if (result0 != null) System.Array.Fill(result0, Vector3.zero);
                 if (result1 != null) System.Array.Fill(result1, Vector3.up);
@@ -51,7 +56,7 @@ namespace WaveHarmonic.Crest
                 return 0;
             }
 
-            public int Query(int _0, float _1, Vector3[] _2, float[] result0, Vector3[] result1, Vector3[] result2, CollisionLayer _3 = CollisionLayer.Everything)
+            public int Query(int _0, float _1, Vector3[] _2, float[] result0, Vector3[] result1, Vector3[] result2, CollisionLayer _3 = CollisionLayer.Everything, Vector3? _4 = null)
             {
                 if (result0 != null) System.Array.Fill(result0, WaterRenderer.Instance.SeaLevel);
                 if (result1 != null) System.Array.Fill(result1, Vector3.up);
@@ -66,12 +71,11 @@ namespace WaveHarmonic.Crest
         /// <param name="heights">Resulting heights (displacement Y + sea level) at the query positions. Pass null if this information is not required.</param>
         /// <param name="normals">Resulting normals at the query positions. Pass null if this information is not required.</param>
         /// <param name="velocities">Resulting velocities at the query positions. Pass null if this information is not required.</param>
-        /// <inheritdoc cref="IQueryProvider.Query(int, float, Vector3[], int)" />
-        int Query(int hash, float minimumLength, Vector3[] points, float[] heights, Vector3[] normals, Vector3[] velocities, CollisionLayer layer = CollisionLayer.Everything);
+        /// <inheritdoc cref="IQueryProvider.Query(int, float, Vector3[], int, Vector3?)" />
+        int Query(int hash, float minimumLength, Vector3[] points, float[] heights, Vector3[] normals, Vector3[] velocities, CollisionLayer layer = CollisionLayer.Everything, Vector3? center = null);
 
         /// <param name="displacements">Resulting displacement vectors at the query positions. Add sea level to Y to get world space height.</param>
-        /// <inheritdoc cref="IQueryProvider.Query(int, float, Vector3[], int)" />
-        /// <inheritdoc cref="Query(int, float, Vector3[], float[], Vector3[], Vector3[], CollisionLayer)" />
-        int Query(int hash, float minimumLength, Vector3[] points, Vector3[] displacements, Vector3[] normals, Vector3[] velocities, CollisionLayer layer = CollisionLayer.Everything);
+        /// <inheritdoc cref="Query(int, float, Vector3[], float[], Vector3[], Vector3[], CollisionLayer, Vector3?)" />
+        int Query(int hash, float minimumLength, Vector3[] points, Vector3[] displacements, Vector3[] normals, Vector3[] velocities, CollisionLayer layer = CollisionLayer.Everything, Vector3? center = null);
     }
 }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Query/Collision/CollisionQuery.cs

@@ -2,6 +2,7 @@
 // Copyright © 2024 Wave Harmonic. All rights reserved.
 
 using UnityEngine;
+using WaveHarmonic.Crest.Internal;
 
 namespace WaveHarmonic.Crest
 {
@@ -10,10 +11,10 @@ namespace WaveHarmonic.Crest
     /// </summary>
     sealed class CollisionQuery : QueryBase, ICollisionProvider
     {
-        public CollisionQuery(WaterRenderer water) : base(water) { }
+        public CollisionQuery(WaterRenderer water) : base(water.AnimatedWavesLod) { }
         protected override int Kernel => 0;
 
-        public int Query(int ownerHash, float minSpatialLength, Vector3[] queryPoints, Vector3[] resultDisplacements, Vector3[] resultNormals, Vector3[] resultVelocities, CollisionLayer layer = CollisionLayer.Everything)
+        public int Query(int ownerHash, float minSpatialLength, Vector3[] queryPoints, Vector3[] resultDisplacements, Vector3[] resultNormals, Vector3[] resultVelocities, CollisionLayer layer = CollisionLayer.Everything, Vector3? center = null)
         {
             var result = (int)QueryStatus.OK;
 
@@ -35,7 +36,7 @@ namespace WaveHarmonic.Crest
             return result;
         }
 
-        public int Query(int ownerHash, float minimumSpatialLength, Vector3[] queryPoints, float[] resultHeights, Vector3[] resultNormals, Vector3[] resultVelocities, CollisionLayer layer = CollisionLayer.Everything)
+        public int Query(int ownerHash, float minimumSpatialLength, Vector3[] queryPoints, float[] resultHeights, Vector3[] resultNormals, Vector3[] resultVelocities, CollisionLayer layer = CollisionLayer.Everything, Vector3? center = null)
         {
             var result = (int)QueryStatus.OK;
 
@@ -58,6 +59,102 @@ namespace WaveHarmonic.Crest
         }
     }
 
+    sealed class CollisionQueryPerCamera : QueryPerCamera<CollisionQueryWithPasses>, ICollisionProvider
+    {
+        public CollisionQueryPerCamera() : base(WaterRenderer.Instance) { }
+        public CollisionQueryPerCamera(WaterRenderer water) : base(water) { }
+
+        public int Query(int hash, float minimumLength, Vector3[] points, float[] heights, Vector3[] normals, Vector3[] velocities, CollisionLayer layer = CollisionLayer.Everything, Vector3? center = null)
+        {
+            if (_Water.IsSeparateViewpointCameraLoop)
+            {
+                return _Providers[_Water.CurrentCamera].Query(hash, minimumLength, points, heights, normals, velocities, layer, center);
+            }
+
+            var lastStatus = -1;
+            var lastDistance = Mathf.Infinity;
+
+            var newCenter = FindCenter(points, center);
+
+            foreach (var provider in _Providers)
+            {
+                var camera = provider.Key;
+
+                if (!_Water.ShouldExecuteQueries(camera))
+                {
+                    continue;
+                }
+
+                var distance = (newCenter - camera.transform.position.XZ()).sqrMagnitude;
+
+                if (lastStatus == (int)QueryBase.QueryStatus.OK && lastDistance < distance)
+                {
+                    continue;
+                }
+
+                var status = provider.Value.Query(hash, minimumLength, points, heights, normals, velocities, layer, center);
+
+                if (lastStatus < 0 || status == (int)QueryBase.QueryStatus.OK)
+                {
+                    lastStatus = status;
+                    lastDistance = distance;
+                }
+            }
+
+            return lastStatus;
+        }
+
+        public int Query(int hash, float minimumLength, Vector3[] points, Vector3[] displacements, Vector3[] normals, Vector3[] velocities, CollisionLayer layer = CollisionLayer.Everything, Vector3? center = null)
+        {
+            if (_Water.IsSeparateViewpointCameraLoop)
+            {
+                return _Providers[_Water.CurrentCamera].Query(hash, minimumLength, points, displacements, normals, velocities, layer, center);
+            }
+
+            var lastStatus = -1;
+            var lastDistance = Mathf.Infinity;
+
+            var newCenter = FindCenter(points, center);
+
+            foreach (var provider in _Providers)
+            {
+                var camera = provider.Key;
+
+                if (!_Water.ShouldExecuteQueries(camera))
+                {
+                    continue;
+                }
+
+                var distance = (newCenter - camera.transform.position.XZ()).sqrMagnitude;
+
+                if (lastStatus == (int)QueryBase.QueryStatus.OK && lastDistance < distance)
+                {
+                    continue;
+                }
+
+                var status = provider.Value.Query(hash, minimumLength, points, displacements, normals, velocities, layer, center);
+
+                if (lastStatus < 0 || status == (int)QueryBase.QueryStatus.OK)
+                {
+                    lastStatus = status;
+                    lastDistance = distance;
+                }
+            }
+
+            return lastStatus;
+        }
+
+        public void SendReadBack(WaterRenderer water, CollisionLayers layers)
+        {
+            _Providers[water.CurrentCamera].SendReadBack(water, layers);
+        }
+
+        public void UpdateQueries(WaterRenderer water, CollisionLayer layer)
+        {
+            _Providers[water.CurrentCamera].UpdateQueries(water, layer);
+        }
+    }
+
     sealed class CollisionQueryWithPasses : ICollisionProvider, IQueryable
     {
         readonly CollisionQuery _AnimatedWaves;
@@ -69,6 +166,14 @@ namespace WaveHarmonic.Crest
         public int RequestCount => _AnimatedWaves.RequestCount + _DynamicWaves.RequestCount + _Displacement.RequestCount;
         public int QueryCount => _AnimatedWaves.QueryCount + _DynamicWaves.QueryCount + _Displacement.QueryCount;
 
+        public CollisionQueryWithPasses()
+        {
+            _Water = WaterRenderer.Instance;
+            _AnimatedWaves = new(_Water);
+            _DynamicWaves = new(_Water);
+            _Displacement = new(_Water);
+        }
+
         public CollisionQueryWithPasses(WaterRenderer water)
         {
             _Water = water;
@@ -107,12 +212,12 @@ namespace WaveHarmonic.Crest
             return _AnimatedWaves;
         }
 
-        public int Query(int hash, float minimumLength, Vector3[] points, float[] heights, Vector3[] normals, Vector3[] velocities, CollisionLayer layer = CollisionLayer.Everything)
+        public int Query(int hash, float minimumLength, Vector3[] points, float[] heights, Vector3[] normals, Vector3[] velocities, CollisionLayer layer = CollisionLayer.Everything, Vector3? center = null)
         {
             return GetProvider(layer).Query(hash, minimumLength, points, heights, normals, velocities);
         }
 
-        public int Query(int hash, float minimumLength, Vector3[] points, Vector3[] displacements, Vector3[] normals, Vector3[] velocities, CollisionLayer layer = CollisionLayer.Everything)
+        public int Query(int hash, float minimumLength, Vector3[] points, Vector3[] displacements, Vector3[] normals, Vector3[] velocities, CollisionLayer layer = CollisionLayer.Everything, Vector3? center = null)
         {
             return GetProvider(layer).Query(hash, minimumLength, points, displacements, normals, velocities);
         }
@@ -151,13 +256,55 @@ namespace WaveHarmonic.Crest
             _DynamicWaves.CleanUp();
             _Displacement.CleanUp();
         }
+
+        public void Initialize(WaterRenderer water)
+        {
+
+        }
     }
 
+    // These are required because of collision layer.
     static partial class Extensions
     {
-        public static void UpdateQueries(this ICollisionProvider self, WaterRenderer water, CollisionLayer layer) => (self as CollisionQueryWithPasses)?.UpdateQueries(water, layer);
+        public static void UpdateQueries(this ICollisionProvider self, WaterRenderer water, CollisionLayer layer)
+        {
+            if (self is CollisionQueryPerCamera a)
+            {
+                a.UpdateQueries(water, layer);
+            }
+            else if (self is CollisionQueryWithPasses b)
+            {
+                b.UpdateQueries(water, layer);
+            }
+            else if (self is ICollisionProvider.NoneProvider c)
+            {
+
+            }
+            else
+            {
+                Debug.LogError("Crest: no valid query provider. Report this to developers!");
+            }
+        }
         public static void UpdateQueries(this ICollisionProvider self, WaterRenderer water) => (self as IQueryable)?.UpdateQueries(water);
-        public static void SendReadBack(this ICollisionProvider self, WaterRenderer water, CollisionLayers layer) => (self as CollisionQueryWithPasses)?.SendReadBack(water, layer);
+        public static void SendReadBack(this ICollisionProvider self, WaterRenderer water, CollisionLayers layer)
+        {
+            if (self is CollisionQueryPerCamera a)
+            {
+                a.SendReadBack(water, layer);
+            }
+            else if (self is CollisionQueryWithPasses b)
+            {
+                b.SendReadBack(water, layer);
+            }
+            else if (self is ICollisionProvider.NoneProvider c)
+            {
+
+            }
+            else
+            {
+                Debug.LogError("Crest: no valid query provider. Report this to developers!");
+            }
+        }
         public static void CleanUp(this ICollisionProvider self) => (self as IQueryable)?.CleanUp();
     }
 }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Query/Collision/RayTraceHelper.cs

@@ -59,7 +59,9 @@ namespace WaveHarmonic.Crest
         {
             distance = -1f;
 
-            Validate(allowMultipleCallsPerFrame: false);
+            var id = GetHashCode();
+
+            Validate(allowMultipleCallsPerFrame: false, id);
 
             var water = WaterRenderer.Instance;
             var provider = water == null ? null : water.AnimatedWavesLod.Provider;
@@ -70,7 +72,7 @@ namespace WaveHarmonic.Crest
                 _QueryPosition[i] = origin + i * _RayStepSize * direction;
             }
 
-            var status = provider.Query(GetHashCode(), _MinimumLength, _QueryPosition, _QueryResult, null, null, layer);
+            var status = provider.Query(id, _MinimumLength, _QueryPosition, _QueryResult, null, null, layer);
 
             if (!provider.RetrieveSucceeded(status))
             {

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Query/Collision/RayTraceVisualizer.cs

@@ -14,11 +14,6 @@ namespace WaveHarmonic.Crest
     [AddComponentMenu(Constants.k_MenuPrefixDebug + "Ray Cast Visualizer")]
     sealed class RayTraceVisualizer : ManagedBehaviour<WaterRenderer>
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 0;
-#pragma warning restore 414
-
         readonly RayCastHelper _RayCast = new(50f, 2f);
 
         private protected override System.Action<WaterRenderer> OnUpdateMethod => OnUpdate;

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Query/Depth/DepthProvider.cs

@@ -15,9 +15,14 @@ namespace WaveHarmonic.Crest
     {
         internal static NoneProvider None { get; } = new();
 
+        internal static IDepthProvider Create(WaterRenderer water)
+        {
+            return water.IsMultipleViewpointMode ? new DepthQueryPerCamera(water) : new DepthQuery(water);
+        }
+
         internal sealed class NoneProvider : IDepthProvider
         {
-            public int Query(int _0, float _1, Vector3[] _2, Vector3[] result)
+            public int Query(int _0, float _1, Vector3[] _2, Vector3[] result, Vector3? _3 = null)
             {
                 if (result != null) System.Array.Clear(result, 0, result.Length);
                 return 0;
@@ -28,7 +33,7 @@ namespace WaveHarmonic.Crest
         /// Query water depth data at a set of points.
         /// </summary>
         /// <param name="results">Water depth and distance to shoreline (XY respectively). Both are signed.</param>
-        /// <inheritdoc cref="IQueryProvider.Query(int, float, Vector3[], int)" />
-        int Query(int hash, float minimumLength, Vector3[] points, Vector3[] results);
+        /// <inheritdoc cref="IQueryProvider.Query(int, float, Vector3[], int, Vector3?)" />
+        int Query(int hash, float minimumLength, Vector3[] points, Vector3[] results, Vector3? center = null);
     }
 }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Query/Depth/DepthQuery.cs

@@ -5,14 +5,15 @@ using UnityEngine;
 
 namespace WaveHarmonic.Crest
 {
-    sealed class DepthQuery : QueryBase, IDepthProvider
+    sealed class DepthQuery : QueryBaseSimple, IDepthProvider
     {
-        public DepthQuery(WaterRenderer water) : base(water) { }
+        public DepthQuery() : base(WaterRenderer.Instance.DepthLod) { }
+        public DepthQuery(WaterRenderer water) : base(water.DepthLod) { }
         protected override int Kernel => 2;
 
-        public override int Query(int hash, float minimumSpatialLength, Vector3[] queries, Vector3[] results)
+        public override int Query(int hash, float minimumSpatialLength, Vector3[] queries, Vector3[] results, Vector3? center = null)
         {
-            var id = base.Query(hash, minimumSpatialLength, queries, results);
+            var id = base.Query(hash, minimumSpatialLength, queries, results, center);
 
             // Infinity will become NaN. Convert back to infinity.
             // Negative infinity should not happen.
@@ -27,4 +28,9 @@ namespace WaveHarmonic.Crest
             return id;
         }
     }
+
+    sealed class DepthQueryPerCamera : QueryPerCameraSimple<DepthQuery>, IDepthProvider
+    {
+        public DepthQueryPerCamera(WaterRenderer water) : base(water) { }
+    }
 }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Query/Flow/FlowProvider.cs

@@ -15,12 +15,17 @@ namespace WaveHarmonic.Crest
     {
         internal static NoneProvider None { get; } = new();
 
+        internal static IFlowProvider Create(WaterRenderer water)
+        {
+            return water.IsMultipleViewpointMode ? new FlowQueryPerCamera(water) : new FlowQuery(water);
+        }
+
         /// <summary>
         /// Gives a stationary water (no horizontal flow).
         /// </summary>
         internal sealed class NoneProvider : IFlowProvider
         {
-            public int Query(int _0, float _1, Vector3[] _2, Vector3[] result)
+            public int Query(int _0, float _1, Vector3[] _2, Vector3[] result, Vector3? _3 = null)
             {
                 if (result != null) System.Array.Clear(result, 0, result.Length);
                 return 0;
@@ -31,7 +36,7 @@ namespace WaveHarmonic.Crest
         /// Query water flow data (horizontal motion) at a set of points.
         /// </summary>
         /// <param name="results">Water surface flow velocities at the query positions.</param>
-        /// <inheritdoc cref="IQueryProvider.Query(int, float, Vector3[], int)" />
-        int Query(int hash, float minimumLength, Vector3[] points, Vector3[] results);
+        /// <inheritdoc cref="IQueryProvider.Query(int, float, Vector3[], int, Vector3?)" />
+        int Query(int hash, float minimumLength, Vector3[] points, Vector3[] results, Vector3? center = null);
     }
 }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Query/Flow/FlowQuery.cs

@@ -6,9 +6,15 @@ namespace WaveHarmonic.Crest
     /// <summary>
     /// Samples horizontal motion of water volume
     /// </summary>
-    sealed class FlowQuery : QueryBase, IFlowProvider
+    sealed class FlowQuery : QueryBaseSimple, IFlowProvider
     {
-        public FlowQuery(WaterRenderer water) : base(water) { }
+        public FlowQuery() : base(WaterRenderer.Instance.FlowLod) { }
+        public FlowQuery(WaterRenderer water) : base(water.FlowLod) { }
         protected override int Kernel => 1;
     }
+
+    sealed class FlowQueryPerCamera : QueryPerCameraSimple<FlowQuery>, IFlowProvider
+    {
+        public FlowQueryPerCamera(WaterRenderer water) : base(water) { }
+    }
 }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Query/Query.cs

@@ -9,6 +9,7 @@ using System.Collections.Generic;
 using Unity.Collections;
 using UnityEngine;
 using UnityEngine.Rendering;
+using WaveHarmonic.Crest.Internal;
 
 namespace WaveHarmonic.Crest
 {
@@ -22,8 +23,9 @@ namespace WaveHarmonic.Crest
         /// <param name="minimumLength">The minimum spatial length of the object, such as the width of a boat. Useful for filtering out detail when not needed. Set to zero to get full available detail.</param>
         /// <param name="points">The world space points that will be queried.</param>
         /// <param name="layer">The layer this query targets.</param>
+        /// <param name="center">The center of all the query positions. Used to choose the closest query provider.</param>
         /// <returns>The status of the query.</returns>
-        internal static int Query(int hash, float minimumLength, Vector3[] points, int layer) => 0;
+        internal static int Query(int hash, float minimumLength, Vector3[] points, int layer, Vector3? center) => throw new System.NotImplementedException("Crest: this method is for documentation reuse only. Do not invoke.");
 
         /// <summary>
         /// Check if the query results could be retrieved successfully using the return code
@@ -45,6 +47,12 @@ namespace WaveHarmonic.Crest
         void UpdateQueries(WaterRenderer water);
         void SendReadBack(WaterRenderer water);
         void CleanUp();
+        void Initialize(WaterRenderer water);
+    }
+
+    interface IQueryableSimple : IQueryable
+    {
+        int Query(int hash, float minimumLength, Vector3[] queries, Vector3[] results, Vector3? center);
     }
 
     /// <summary>
@@ -64,6 +72,7 @@ namespace WaveHarmonic.Crest
         const int k_NormalAdditionalQueryCount = 2;
 
         readonly WaterRenderer _Water;
+        readonly IQueryableLod<IQueryProvider> _Lod;
 
         readonly PropertyWrapperCompute _Wrapper;
 
@@ -85,8 +94,8 @@ namespace WaveHarmonic.Crest
 
         internal const int k_DefaultMaximumQueryCount = 4096;
 
-        readonly int _MaximumQueryCount = k_DefaultMaximumQueryCount;
-        readonly Vector3[] _QueryPositionXZ_MinimumGridSize = new Vector3[k_DefaultMaximumQueryCount];
+        readonly int _MaximumQueryCount;
+        readonly Vector3[] _QueryPositionXZ_MinimumGridSize;
 
         /// <summary>
         /// Holds information about all query points. Maps from unique hash code to position in point array.
@@ -147,8 +156,9 @@ namespace WaveHarmonic.Crest
                 // queries are often made from FixedUpdate(), and at high framerates this may not be called, which would mean
                 // the query would get lost and this leads to stuttering and other artifacts.
                 {
-                    _Segments[_SegmentAcquire]._QueryCount = 0;
-                    _Segments[_SegmentAcquire]._Segments.Clear();
+                    var registrar = _Segments[_SegmentAcquire];
+                    registrar._QueryCount = 0;
+                    registrar._Segments.Clear();
 
                     foreach (var segment in _Segments[lastIndex]._Segments)
                     {
@@ -160,11 +170,10 @@ namespace WaveHarmonic.Crest
                             // Compute a new segment range - we may have removed some segments that were too old, so this ensures
                             // we have a nice compact array of queries each frame rather than accumulating persistent air bubbles
                             var newSegment = segment.Value;
-                            newSegment.x = _Segments[_SegmentAcquire]._QueryCount;
+                            newSegment.x = registrar._QueryCount;
                             newSegment.y = newSegment.x + (segment.Value.y - segment.Value.x);
-                            _Segments[_SegmentAcquire]._QueryCount = newSegment.y + 1;
-
-                            _Segments[_SegmentAcquire]._Segments.Add(segment.Key, newSegment);
+                            registrar._QueryCount = newSegment.y + 1;
+                            registrar._Segments.Add(segment.Key, newSegment);
                         }
                     }
                 }
@@ -253,17 +262,15 @@ namespace WaveHarmonic.Crest
             InvalidDtForVelocity = 16,
         }
 
-        public QueryBase(WaterRenderer water)
+        public QueryBase(IQueryableLod<IQueryProvider> lod)
         {
-            _Water = water;
+            _Water = lod.Water;
+            _Lod = lod;
 
             _DataArrivedAction = new(DataArrived);
 
-            if (_MaximumQueryCount != water._AnimatedWavesLod.MaximumQueryCount)
-            {
-                _MaximumQueryCount = water._AnimatedWavesLod.MaximumQueryCount;
-                _QueryPositionXZ_MinimumGridSize = new Vector3[_MaximumQueryCount];
-            }
+            _MaximumQueryCount = lod.MaximumQueryCount;
+            _QueryPositionXZ_MinimumGridSize = new Vector3[_MaximumQueryCount];
 
             _ComputeBufferQueries = new(_MaximumQueryCount, 12, ComputeBufferType.Default);
             _ComputeBufferResults = new(_MaximumQueryCount, 12, ComputeBufferType.Default);
@@ -277,7 +284,13 @@ namespace WaveHarmonic.Crest
                 Debug.LogError($"Crest: Could not load Query compute shader");
                 return;
             }
-            _Wrapper = new(water.SimulationBuffer, shader, Kernel);
+
+            _Wrapper = new(_Water.SimulationBuffer, shader, Kernel);
+        }
+
+        void LogMaximumQueryCountExceededError()
+        {
+            Debug.LogError($"Crest: Maximum query count ({_MaximumQueryCount}) exceeded, increase the <i>{nameof(WaterRenderer)} > Simulations > {_Lod.Name} > {nameof(_Lod.MaximumQueryCount)}</i> to support a higher number of queries.", _Water);
         }
 
         /// <summary>
@@ -286,9 +299,11 @@ namespace WaveHarmonic.Crest
         /// </summary>
         protected bool UpdateQueryPoints(int ownerHash, float minSpatialLength, Vector3[] queryPoints, Vector3[] queryNormals)
         {
-            if (queryPoints.Length + _SegmentRegistrarRingBuffer.Current._QueryCount > _MaximumQueryCount)
+            var registrar = _SegmentRegistrarRingBuffer.Current;
+
+            if (queryPoints.Length + registrar._QueryCount > _MaximumQueryCount)
             {
-                Debug.LogError($"Crest: Max query count ({_MaximumQueryCount}) exceeded, increase the max query count in the Animated Waves Settings to support a higher number of queries.");
+                LogMaximumQueryCountExceededError();
                 return false;
             }
 
@@ -299,20 +314,20 @@ namespace WaveHarmonic.Crest
             var countNorms = queryNormals != null ? queryNormals.Length : 0;
             var countTotal = countPts + countNorms * k_NormalAdditionalQueryCount;
 
-            if (_SegmentRegistrarRingBuffer.Current._Segments.TryGetValue(ownerHash, out var segment))
+            if (registrar._Segments.TryGetValue(ownerHash, out var segment))
             {
                 var segmentSize = segment.y - segment.x + 1;
                 if (segmentSize == countTotal)
                 {
                     // Update frame count
                     segment.z = Time.frameCount;
-                    _SegmentRegistrarRingBuffer.Current._Segments[ownerHash] = segment;
+                    registrar._Segments[ownerHash] = segment;
 
                     segmentRetrieved = true;
                 }
                 else
                 {
-                    _SegmentRegistrarRingBuffer.Current._Segments.Remove(ownerHash);
+                    registrar._Segments.Remove(ownerHash);
                 }
             }
 
@@ -324,18 +339,18 @@ namespace WaveHarmonic.Crest
 
             if (!segmentRetrieved)
             {
-                if (_SegmentRegistrarRingBuffer.Current._Segments.Count >= k_MaximumGuids)
+                if (registrar._Segments.Count >= k_MaximumGuids)
                 {
                     Debug.LogError("Crest: Too many guids registered with CollProviderCompute. Increase s_maxGuids.");
                     return false;
                 }
 
-                segment.x = _SegmentRegistrarRingBuffer.Current._QueryCount;
+                segment.x = registrar._QueryCount;
                 segment.y = segment.x + countTotal - 1;
                 segment.z = Time.frameCount;
-                _SegmentRegistrarRingBuffer.Current._Segments.Add(ownerHash, segment);
+                registrar._Segments.Add(ownerHash, segment);
 
-                _SegmentRegistrarRingBuffer.Current._QueryCount += countTotal;
+                registrar._QueryCount += countTotal;
 
                 //Debug.Log("Crest: Added points for " + guid);
             }
@@ -346,9 +361,14 @@ namespace WaveHarmonic.Crest
             var samplesPerWave = 2f;
             var minGridSize = minWavelength / samplesPerWave;
 
+            // Displacements should not utilize the last slice which is used for transitioning
+            // waves between sampling resolutions. While it might be ok to use the last slice
+            // for other targets, we avoid using it to be consistent with displacements.
+            var minimumSlice = Mathf.Clamp(Mathf.FloorToInt(Mathf.Log(Mathf.Max(minGridSize / _Lod.Texel, 1f), 2f)), 0, _Water.LodLevels - 2);
+
             if (countPts + segment.x > _QueryPositionXZ_MinimumGridSize.Length)
             {
-                Debug.LogError("Crest: Too many wave height queries. Increase Max Query Count in the Animated Waves Settings.");
+                LogMaximumQueryCountExceededError();
                 return false;
             }
 
@@ -356,7 +376,7 @@ namespace WaveHarmonic.Crest
             {
                 _QueryPositionXZ_MinimumGridSize[pointi + segment.x].x = queryPoints[pointi].x;
                 _QueryPositionXZ_MinimumGridSize[pointi + segment.x].y = queryPoints[pointi].z;
-                _QueryPositionXZ_MinimumGridSize[pointi + segment.x].z = minGridSize;
+                _QueryPositionXZ_MinimumGridSize[pointi + segment.x].z = minimumSlice;
             }
 
             // To compute each normal, post 2 query points (reuse point above)
@@ -366,13 +386,13 @@ namespace WaveHarmonic.Crest
 
                 _QueryPositionXZ_MinimumGridSize[arrIdx].x = queryNormals[normi].x + k_FiniteDifferenceDx;
                 _QueryPositionXZ_MinimumGridSize[arrIdx].y = queryNormals[normi].z;
-                _QueryPositionXZ_MinimumGridSize[arrIdx].z = minGridSize;
+                _QueryPositionXZ_MinimumGridSize[arrIdx].z = minimumSlice;
 
                 arrIdx += 1;
 
                 _QueryPositionXZ_MinimumGridSize[arrIdx].x = queryNormals[normi].x;
                 _QueryPositionXZ_MinimumGridSize[arrIdx].y = queryNormals[normi].z + k_FiniteDifferenceDx;
-                _QueryPositionXZ_MinimumGridSize[arrIdx].z = minGridSize;
+                _QueryPositionXZ_MinimumGridSize[arrIdx].z = minimumSlice;
             }
 
             return true;
@@ -590,10 +610,11 @@ namespace WaveHarmonic.Crest
                 _QueryResultsTimeLast = _QueryResultsTime;
                 _ResultSegmentsLast = _ResultSegments;
 
-                var data = _Requests[lastDoneIndex]._Request.GetData<Vector3>();
+                var last = _Requests[lastDoneIndex];
+                var data = last._Request.GetData<Vector3>();
                 data.CopyTo(_QueryResults);
-                _QueryResultsTime = _Requests[lastDoneIndex]._DataTimestamp;
-                _ResultSegments = _Requests[lastDoneIndex]._Segments;
+                _QueryResultsTime = last._DataTimestamp;
+                _ResultSegments = last._Segments;
             }
 
             // Remove all the requests up to the last completed one
@@ -618,7 +639,23 @@ namespace WaveHarmonic.Crest
             _SegmentRegistrarRingBuffer.ClearAll();
         }
 
-        public virtual int Query(int ownerHash, float minSpatialLength, Vector3[] queryPoints, Vector3[] results)
+        public virtual void Initialize(WaterRenderer water)
+        {
+
+        }
+
+        public int ResultGuidCount => _ResultSegments != null ? _ResultSegments.Count : 0;
+
+        public int RequestCount => _Requests != null ? _Requests.Count : 0;
+
+        public int QueryCount => _SegmentRegistrarRingBuffer != null ? _SegmentRegistrarRingBuffer.Current._QueryCount : 0;
+    }
+
+    abstract class QueryBaseSimple : QueryBase, IQueryableSimple
+    {
+        protected QueryBaseSimple(IQueryableLod<IQueryProvider> lod) : base(lod) { }
+
+        public virtual int Query(int ownerHash, float minSpatialLength, Vector3[] queryPoints, Vector3[] results, Vector3? center)
         {
             var result = (int)QueryStatus.OK;
 
@@ -634,12 +671,159 @@ namespace WaveHarmonic.Crest
 
             return result;
         }
+    }
 
-        public int ResultGuidCount => _ResultSegments != null ? _ResultSegments.Count : 0;
+    abstract class QueryPerCamera<T> : IQueryable where T : IQueryable, new()
+    {
+        internal readonly WaterRenderer _Water;
+        internal readonly Dictionary<Camera, T> _Providers = new();
 
-        public int RequestCount => _Requests != null ? _Requests.Count : 0;
+        public QueryPerCamera(WaterRenderer water)
+        {
+            _Water = water;
+            Initialize(water);
+        }
 
-        public int QueryCount => _SegmentRegistrarRingBuffer != null ? _SegmentRegistrarRingBuffer.Current._QueryCount : 0;
+        public int ResultGuidCount
+        {
+            get
+            {
+                var total = 0;
+                foreach (var (camera, provider) in _Providers)
+                {
+                    if (_Water.ShouldExecuteQueries(camera)) total += provider.ResultGuidCount;
+                }
+                return total;
+            }
+        }
+
+        public int RequestCount
+        {
+            get
+            {
+                var total = 0;
+                foreach (var (camera, provider) in _Providers)
+                {
+                    if (_Water.ShouldExecuteQueries(camera)) total += provider.RequestCount;
+                }
+                return total;
+            }
+        }
+
+        public int QueryCount
+        {
+            get
+            {
+                var total = 0;
+                foreach (var (camera, provider) in _Providers)
+                {
+                    if (_Water.ShouldExecuteQueries(camera)) total += provider.QueryCount;
+                }
+                return total;
+            }
+        }
+
+        public void CleanUp()
+        {
+            foreach (var provider in _Providers.Values)
+            {
+                provider?.CleanUp();
+            }
+        }
+
+        public void Initialize(WaterRenderer water)
+        {
+            var camera = water.CurrentCamera;
+
+            if (camera == null)
+            {
+                camera = water.Viewer;
+            }
+
+            if (camera == null)
+            {
+                return;
+            }
+
+            if (!_Providers.ContainsKey(camera))
+            {
+                // Cannot use parameters. We could use System.Activator.CreateInstance to get
+                // around that, but instead we just use WaterRenderer.Instance.
+                _Providers.Add(camera, new());
+            }
+        }
+
+        public void SendReadBack(WaterRenderer water)
+        {
+            _Providers[water.CurrentCamera].SendReadBack(water);
+        }
+
+        public void UpdateQueries(WaterRenderer water)
+        {
+            _Providers[water.CurrentCamera].UpdateQueries(water);
+        }
+
+        public Vector2 FindCenter(Vector3[] queries, Vector3? center)
+        {
+            if (center != null)
+            {
+                return ((Vector3)center).XZ();
+            }
+
+            // Calculate center if none provided.
+            var sum = Vector2.zero;
+            foreach (var point in queries)
+            {
+                sum += point.XZ();
+            }
+
+            return new(sum.x / queries.Length, sum.y / queries.Length);
+        }
+    }
+
+    abstract class QueryPerCameraSimple<T> : QueryPerCamera<T>, IQueryableSimple where T : IQueryableSimple, new()
+    {
+        protected QueryPerCameraSimple(WaterRenderer water) : base(water) { }
+
+        public int Query(int id, float length, Vector3[] queries, Vector3[] results, Vector3? center = null)
+        {
+            if (_Water.IsSeparateViewpointCameraLoop)
+            {
+                return _Providers[_Water.CurrentCamera].Query(id, length, queries, results, center);
+            }
+
+            var lastStatus = -1;
+            var lastDistance = Mathf.Infinity;
+
+            var newCenter = FindCenter(queries, center);
+
+            foreach (var provider in _Providers)
+            {
+                var camera = provider.Key;
+
+                if (!_Water.ShouldExecuteQueries(camera))
+                {
+                    continue;
+                }
+
+                var distance = (newCenter - camera.transform.position.XZ()).sqrMagnitude;
+
+                if (lastStatus == (int)QueryBase.QueryStatus.OK && lastDistance < distance)
+                {
+                    continue;
+                }
+
+                var status = provider.Value.Query(id, length, queries, results, center);
+
+                if (lastStatus < 0 || status == (int)QueryBase.QueryStatus.OK)
+                {
+                    lastStatus = status;
+                    lastDistance = distance;
+                }
+            }
+
+            return lastStatus;
+        }
     }
 
     static partial class Extensions

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Query/QueryEvents.cs

@@ -29,17 +29,18 @@ namespace WaveHarmonic.Crest
     [@HelpURL("Manual/Events.html#query-events")]
     public sealed partial class QueryEvents : ManagedBehaviour<WaterRenderer>
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 0;
-#pragma warning restore 414
-
-
         [Tooltip("What transform should the queries be based on.\n\n\"Viewer\" will reuse queries already performed by the Water Renderer")]
         [@GenerateAPI]
         [@DecoratedField, SerializeField]
         QuerySource _Source;
 
+        [Tooltip("The viewer as the source of the queries.\n\nOnly needs to be set if using multiple viewpoints on the Water Renderer.")]
+        [@Show(nameof(_Source), nameof(QuerySource.Viewer))]
+        [@GenerateAPI]
+        [@DecoratedField]
+        [SerializeField]
+        Camera _Viewer;
+
         [Tooltip(ICollisionProvider.k_LayerTooltip)]
         [@GenerateAPI]
         [@DecoratedField, SerializeField]
@@ -49,14 +50,14 @@ namespace WaveHarmonic.Crest
         [Header("Distance From Water Surface")]
 
         [Tooltip("The minimum wavelength for queries.\n\nThe higher the value, the more smaller waves will be ignored when sampling the water surface.")]
-        [@Predicated(nameof(_Source), inverted: true, nameof(QuerySource.Transform))]
+        [@Enable(nameof(_Source), nameof(QuerySource.Transform))]
         [@GenerateAPI]
         [@DecoratedField, SerializeField]
         float _MinimumWavelength = 1f;
 
         [@Label("Signed")]
         [Tooltip("Whether to keep the sign of the value (ie positive/negative).\n\nA positive value means the query point is above the surface, while a negative means it below the surface.")]
-        [@Predicated(nameof(_DistanceFromSurfaceUseCurve), inverted: true)]
+        [@Disable(nameof(_DistanceFromSurfaceUseCurve))]
         [@GenerateAPI]
         [@DecoratedField, SerializeField]
         bool _DistanceFromSurfaceSigned;
@@ -77,7 +78,7 @@ namespace WaveHarmonic.Crest
 
         [@Label("Curve")]
         [Tooltip("Apply a curve to the distance.\n\nValues towards \"one\" means closer to the water surface.")]
-        [@Predicated(nameof(_DistanceFromSurfaceUseCurve))]
+        [@Enable(nameof(_DistanceFromSurfaceUseCurve))]
         [@GenerateAPI]
         [UnityEngine.Serialization.FormerlySerializedAs("_DistanceCurve")]
         [@DecoratedField, SerializeField]
@@ -88,7 +89,7 @@ namespace WaveHarmonic.Crest
 
         [@Label("Signed")]
         [Tooltip("Whether to keep the sign of the value (ie positive/negative).\n\nA positive value means the query point is over water, while a negative means it is over land.")]
-        [@Predicated(nameof(_DistanceFromEdgeUseCurve), inverted: true)]
+        [@Disable(nameof(_DistanceFromEdgeUseCurve))]
         [@GenerateAPI]
         [@DecoratedField, SerializeField]
         bool _DistanceFromEdgeSigned;
@@ -107,7 +108,7 @@ namespace WaveHarmonic.Crest
 
         [@Label("Curve")]
         [Tooltip("Apply a curve to the distance.\n\nValues towards \"one\" means closer to the water's edge.")]
-        [@Predicated(nameof(_DistanceFromEdgeUseCurve))]
+        [@Enable(nameof(_DistanceFromEdgeUseCurve))]
         [@GenerateAPI]
         [@DecoratedField, SerializeField]
         AnimationCurve _DistanceFromEdgeCurve = AnimationCurve.Linear(0f, 0f, 1f, 1f);
@@ -174,6 +175,11 @@ namespace WaveHarmonic.Crest
 
             var distance = water.ViewerHeightAboveWater;
 
+            if (water.MultipleViewpoints && (_Viewer == null || !water.GetViewerHeightAboveWater(_Viewer, out distance)))
+            {
+                return;
+            }
+
             if (_Source == QuerySource.Transform)
             {
                 if (!_SampleHeightHelper.SampleHeight(transform.position, out var height, minimumLength: 2f * _MinimumWavelength, _Layer)) return;
@@ -233,6 +239,11 @@ namespace WaveHarmonic.Crest
 
             var distance = water.ViewerDistanceToShoreline;
 
+            if (water.MultipleViewpoints && (_Viewer == null || !water.GetViewerDistanceToShoreline(_Viewer, out distance)))
+            {
+                return;
+            }
+
             if (_Source == QuerySource.Transform)
             {
                 if (!_SampleDepthHelper.SampleDistanceToWaterEdge(transform.position, out distance))

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Query/SamplingHelpers.cs

@@ -1,6 +1,7 @@
 // Crest Water System
 // Copyright © 2024 Wave Harmonic. All rights reserved.
 
+using System.Collections.Generic;
 using UnityEngine;
 
 // Linter does not support mixing inheritdoc plus defining own parameters.
@@ -20,7 +21,7 @@ namespace WaveHarmonic.Crest.Internal
         private protected readonly Vector3[] _QueryPosition;
         private protected readonly Vector3[] _QueryResult;
 
-        int _LastFrame = -1;
+        readonly Dictionary<int, int> _LastFrame = new();
 
         private protected SampleHelper(int queryCount = 1)
         {
@@ -29,15 +30,29 @@ namespace WaveHarmonic.Crest.Internal
         }
 
         [System.Diagnostics.Conditional("UNITY_EDITOR")]
-        private protected void Validate(bool allowMultipleCallsPerFrame)
+        private protected void Validate(bool allowMultipleCallsPerFrame, int id)
         {
-            if (Application.isPlaying && !Time.inFixedTimeStep && !allowMultipleCallsPerFrame && _LastFrame == Time.frameCount)
+            if (!_LastFrame.ContainsKey(id))
+            {
+                _LastFrame.Add(id, -1);
+            }
+
+#if UNITY_EDITOR
+            // Prevent false positives spamming the console.
+            if (!UnityEditor.EditorApplication.isFocused || (Application.isPlaying && UnityEditor.EditorApplication.isPaused))
+            {
+                _LastFrame[id] = Time.frameCount;
+                return;
+            }
+#endif
+
+            if (!Time.inFixedTimeStep && !allowMultipleCallsPerFrame && _LastFrame[id] == Time.frameCount)
             {
                 var type = GetType().Name;
                 Debug.LogWarning($"Crest: {type} sample called multiple times in one frame which is not expected. Each {type} object services a single sample per frame. To perform multiple queries, create multiple {type} objects or use the query provider API directly.");
             }
 
-            _LastFrame = Time.frameCount;
+            _LastFrame[id] = Time.frameCount;
         }
 
         // The first method is there just to get inheritdoc to work as it does not like
@@ -103,7 +118,7 @@ namespace WaveHarmonic.Crest
             var isVelocity = (options & QueryOptions.Velocity) == QueryOptions.Velocity;
             var isNormal = (options & QueryOptions.Normal) == QueryOptions.Normal;
 
-            Validate(allowMultipleCallsPerFrame);
+            Validate(allowMultipleCallsPerFrame, id);
 
             _QueryPosition[0] = position;
 
@@ -115,7 +130,8 @@ namespace WaveHarmonic.Crest
                 _QueryResult,
                 isNormal ? _QueryResultNormal : null,
                 isVelocity ? _QueryResultVelocity : null,
-                layer
+                layer,
+                position
             );
 
             if (!provider.RetrieveSucceeded(status))
@@ -234,11 +250,13 @@ namespace WaveHarmonic.Crest
                 return false;
             }
 
-            Validate(false);
+            var id = GetHashCode();
+
+            Validate(false, id);
 
             _QueryPosition[0] = position;
 
-            var status = flowProvider.Query(GetHashCode(), minimumLength, _QueryPosition, _QueryResult);
+            var status = flowProvider.Query(id, minimumLength, _QueryPosition, _QueryResult, position);
 
             if (!flowProvider.RetrieveSucceeded(status))
             {
@@ -259,25 +277,25 @@ namespace WaveHarmonic.Crest
     /// </summary>
     public sealed class SampleDepthHelper : Internal.SampleHelper
     {
-        bool Sample(Vector3 position, out Vector2 result)
+        internal bool Sample(int id, Vector3 position, out Vector2 result, bool allowMultipleCallsPerFrame = false)
         {
             var water = WaterRenderer.Instance;
             var depthProvider = water == null ? null : water.DepthLod.Provider;
 
             if (depthProvider == null)
             {
-                result = Vector2.zero;
+                result = new(Mathf.Infinity, Mathf.Infinity);
                 return false;
             }
 
-            Validate(false);
+            Validate(allowMultipleCallsPerFrame, id);
 
             _QueryPosition[0] = position;
 
-            var status = depthProvider.Query(GetHashCode(), minimumLength: 0, _QueryPosition, _QueryResult);
+            var status = depthProvider.Query(id, minimumLength: 0, _QueryPosition, _QueryResult, position);
             if (!depthProvider.RetrieveSucceeded(status))
             {
-                result = Vector2.zero;
+                result = new(Mathf.Infinity, Mathf.Infinity);
                 return false;
             }
 
@@ -285,13 +303,18 @@ namespace WaveHarmonic.Crest
             return true;
         }
 
+        bool Sample(Vector3 position, out Vector2 result)
+        {
+            return Sample(GetHashCode(), position, out result);
+        }
+
         /// <summary>
         /// Sample both the water depth and water edge distance.
         /// </summary>
         /// <param name="depth">Filled by the water depth at the query position.</param>
         /// <param name="distance">Filled by the distance to water edge at the query position.</param>
         /// <inheritdoc cref="Internal.SampleHelper.Sample" />
-        bool Sample(Vector3 position, out float depth, out float distance)
+        internal bool Sample(Vector3 position, out float depth, out float distance)
         {
             var success = Sample(position, out var result);
             depth = result.x;
@@ -312,7 +335,12 @@ namespace WaveHarmonic.Crest
         /// <inheritdoc cref="Sample(Vector3, out float, out float)"/>
         public bool SampleDistanceToWaterEdge(Vector3 position, out float distance)
         {
-            var success = Sample(position, out var result);
+            return SampleDistanceToWaterEdge(GetHashCode(), position, out distance);
+        }
+
+        internal bool SampleDistanceToWaterEdge(int id, Vector3 position, out float distance)
+        {
+            var success = Sample(id, position, out var result);
             distance = result.y;
             return success;
         }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/SampleShadowsHDRP.cs

@@ -19,22 +19,13 @@ namespace WaveHarmonic.Crest
         {
             var water = _Water;
 
-            if (!water._ShadowLod.Enabled)
+            if (!water._ActiveModules.HasFlag(WaterRenderer.ActiveModules.Shadows))
             {
                 return;
             }
 
-#if UNITY_EDITOR
-            if (!WaterRenderer.IsWithinEditorUpdate)
-            {
-                return;
-            }
-#endif
-
             var camera = context.hdCamera.camera;
 
-            // Custom passes execute for every camera. We only support one camera for now.
-            if (!ReferenceEquals(camera, water.Viewer)) return;
             // TODO: bail when not executing for main light or when no main light exists?
             // if (renderingData.lightData.mainLightIndex == -1) return;
 

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/SampleShadowsURP.RenderGraph.cs

@@ -45,6 +45,7 @@ namespace WaveHarmonic.Crest
             }
         }
 
+#if URP_COMPATIBILITY_MODE
         [System.Obsolete]
         public override void Execute(ScriptableRenderContext context, ref RenderingData data)
         {
@@ -54,6 +55,7 @@ namespace WaveHarmonic.Crest
             context.ExecuteCommandBuffer(buffer);
             CommandBufferPool.Release(buffer);
         }
+#endif
     }
 }
 

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/SampleShadowsURP.cs

@@ -34,25 +34,6 @@ namespace WaveHarmonic.Crest
                 return;
             }
 
-            var water = s_Instance._Water;
-
-            if (!water._ShadowLod.Enabled)
-            {
-                return;
-            }
-
-#if UNITY_EDITOR
-            if (!WaterRenderer.IsWithinEditorUpdate)
-            {
-                return;
-            }
-#endif
-
-            // Only sample shadows for the main camera.
-            if (!ReferenceEquals(water.Viewer, camera))
-            {
-                return;
-            }
 
             if (camera.TryGetComponent<UniversalAdditionalCameraData>(out var cameraData))
             {

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Settings/DynamicWavesLodSettings.cs

@@ -12,11 +12,6 @@ namespace WaveHarmonic.Crest
     [@HelpURL("Manual/Waves.html#dynamic-waves-settings")]
     public sealed partial class DynamicWavesLodSettings : LodSettings
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 0;
-#pragma warning restore 414
-
         [Header("Simulation")]
 
         [Tooltip("How much energy is dissipated each frame.\n\nHelps simulation stability, but limits how far ripples will propagate. Set this as large as possible/acceptable. Default is 0.05.")]
@@ -52,5 +47,14 @@ namespace WaveHarmonic.Crest
         [@GenerateAPI]
         [SerializeField]
         internal float _GravityMultiplier = 1f;
+
+
+        [@Heading("Culling")]
+
+        [Tooltip("Adds padding to water chunk bounds.\n\nDynamic Waves displaces the surface which can push vertices outside of the chunk bounds leading to culling issues. This value adds padding to the chunk bounds to mitigate this.")]
+        [@GenerateAPI]
+        [@DecoratedField]
+        [@SerializeField]
+        internal float _VerticalDisplacementCullingContributions = 5f;
     }
 }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Settings/FoamLodSettings.cs

@@ -12,12 +12,6 @@ namespace WaveHarmonic.Crest
     [@HelpURL("Manual/WaterAppearance.html#foam-settings")]
     public sealed partial class FoamLodSettings : LodSettings
     {
-        [SerializeField, HideInInspector]
-#pragma warning disable 414
-        int _Version = 0;
-#pragma warning restore 414
-
-
         [Header("General settings")]
 
         [Tooltip("Foam will not exceed this value in the simulation which can be used to prevent foam from accumulating too much.")]

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/Settings/LodSettings.cs

@@ -1,14 +1,14 @@
 // Crest Water System
 // Copyright © 2024 Wave Harmonic. All rights reserved.
 
-using UnityEngine;
+using WaveHarmonic.Crest.Internal;
 
 namespace WaveHarmonic.Crest
 {
     /// <summary>
     /// Base class for simulation settings.
     /// </summary>
-    public abstract partial class LodSettings : ScriptableObject
+    public abstract partial class LodSettings : CustomScriptableObject
     {
 
     }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/ShadowLod.Legacy.cs

@@ -8,49 +8,55 @@ namespace WaveHarmonic.Crest
 {
     partial class ShadowLod
     {
+        internal bool ShouldRender(Camera camera)
+        {
+            if (!_Enabled)
+            {
+                return false;
+            }
+
+            // Even though volume also uses shadows, it only makes sense with a surface.
+            if (!_Water._ActiveModules.HasFlag(WaterRenderer.ActiveModules.Surface))
+            {
+                return false;
+            }
+
+            // Only sample shadows for the main camera.
+            if (_Water.IsSingleViewpointMode && _Water.Viewer != camera)
+            {
+                return false;
+            }
+
+            return true;
+        }
+
         internal void OnBeginCameraRendering(ScriptableRenderContext context, Camera camera)
         {
             // TODO: refactor this similar to MaskRenderer.
-            if (!RenderPipelineHelper.IsLegacy)
-            {
 #if d_UnityURP
-                if (RenderPipelineHelper.IsUniversal)
-                {
-                    SampleShadowsURP.EnqueuePass(context, camera);
-                }
-#endif
-
+            if (RenderPipelineHelper.IsUniversal)
+            {
+                SampleShadowsURP.EnqueuePass(context, camera);
                 return;
             }
+#endif
+
+            if (!RenderPipelineHelper.IsLegacy)
+            {
+                return;
+            }
+
+            CopyShadowMapBuffer?.Clear();
 
 #if UNITY_EDITOR
             // Do not execute when editor is not active to conserve power and prevent possible leaks.
             if (!UnityEditorInternal.InternalEditorUtility.isApplicationActive)
             {
-                CopyShadowMapBuffer?.Clear();
-                return;
-            }
-
-            if (!WaterRenderer.IsWithinEditorUpdate)
-            {
-                CopyShadowMapBuffer?.Clear();
                 return;
             }
 #endif
 
-            var water = _Water;
-
-            if (water == null)
-            {
-                return;
-            }
-
-            if (!WaterRenderer.ShouldRender(camera, water.Surface.Layer))
-            {
-                return;
-            }
-
-            if (camera == water.Viewer && CopyShadowMapBuffer != null)
+            if (CopyShadowMapBuffer != null)
             {
                 if (_Light != null)
                 {
@@ -62,7 +68,7 @@ namespace WaveHarmonic.Crest
                 // Disable for XR SPI otherwise input will not have correct world position.
                 Rendering.BIRP.DisableXR(CopyShadowMapBuffer, camera);
 
-                BuildCommandBuffer(water, CopyShadowMapBuffer);
+                BuildCommandBuffer(_Water, CopyShadowMapBuffer);
 
                 // Restore XR SPI as we cannot rely on remaining pipeline to do it for us.
                 Rendering.BIRP.EnableXR(CopyShadowMapBuffer, camera);
@@ -71,6 +77,12 @@ namespace WaveHarmonic.Crest
 
         internal void OnEndCameraRendering(Camera camera)
         {
+            // Method is only called for either single viewpoint mode or separate viewpoints.
+            if (_Water.IsMultipleViewpointMode)
+            {
+                StoreCameraData(camera);
+            }
+
             if (!RenderPipelineHelper.IsLegacy)
             {
                 return;
@@ -83,36 +95,15 @@ namespace WaveHarmonic.Crest
                 CopyShadowMapBuffer?.Clear();
                 return;
             }
-
-            if (!WaterRenderer.IsWithinEditorUpdate)
-            {
-                CopyShadowMapBuffer?.Clear();
-                return;
-            }
 #endif
 
-            var water = _Water;
-
-            if (water == null)
+            // CBs added to a light are executed for every camera, but the LOD data is only
+            // supports a single camera. Removing the CB after the camera renders restricts the
+            // CB to one camera. Careful of recursive rendering for planar reflections, as it
+            // executes a camera within this camera's frame.
+            if (_Light != null && CopyShadowMapBuffer != null)
             {
-                return;
-            }
-
-            if (!WaterRenderer.ShouldRender(camera, water.Surface.Layer))
-            {
-                return;
-            }
-
-            if (camera == water.Viewer)
-            {
-                // CBs added to a light are executed for every camera, but the LOD data is only
-                // supports a single camera. Removing the CB after the camera renders restricts the
-                // CB to one camera. Careful of recursive rendering for planar reflections, as it
-                // executes a camera within this camera's frame.
-                if (_Light != null && CopyShadowMapBuffer != null)
-                {
-                    _Light.RemoveCommandBuffer(LightEvent.BeforeScreenspaceMask, CopyShadowMapBuffer);
-                }
+                _Light.RemoveCommandBuffer(LightEvent.BeforeScreenspaceMask, CopyShadowMapBuffer);
             }
         }
     }

Packages/com.waveharmonic.crest/Runtime/Scripts/Data/ShadowLod.cs

@@ -29,13 +29,13 @@ namespace WaveHarmonic.Crest
         bool _DynamicSoftShadows = true;
 
         [Tooltip("Factor control for dynamic soft jitter.")]
-        [@Predicated(nameof(_DynamicSoftShadows), hide: true)]
+        [@Show(nameof(_DynamicSoftShadows))]
         [@Range(0f, 1f, Range.Clamp.Minimum)]
         [SerializeField]
         float _SoftJitterExtinctionFactor = 0.75f;
 
         [Tooltip("Jitter diameter for soft shadows, controls softness of this shadowing component.")]
-        [@Predicated(nameof(_DynamicSoftShadows), hide: true, inverted: true)]
+        [@Hide(nameof(_DynamicSoftShadows))]
         [@Range(0f, k_MaximumJitter)]
         [@GenerateAPI]
         [SerializeField]
@@ -96,6 +96,7 @@ namespace WaveHarmonic.Crest
         private protected override Color ClearColor => Color.black;
         private protected override bool NeedToReadWriteTextureData => true;
         internal override int BufferCount => 2;
+        internal override bool SkipEndOfFrame => true;
 
         private protected override GraphicsFormat RequestedTextureFormat => _TextureFormatMode switch
         {
@@ -150,17 +151,9 @@ namespace WaveHarmonic.Crest
 #if d_UnityURP
                 var asset = GraphicsSettings.currentRenderPipeline as UniversalRenderPipelineAsset;
 
-                // TODO: Support single casacades as it is possible.
-                if (asset && asset.shadowCascadeCount < 2)
-                {
-                    Debug.LogError("Crest shadowing requires shadow cascades to be enabled on the pipeline asset.", asset);
-                    _Valid = false;
-                    return;
-                }
-
                 if (asset.mainLightRenderingMode == LightRenderingMode.Disabled)
                 {
-                    Debug.LogError("Crest: Main Light must be enabled to enable water shadowing.", _Water);
+                    Debug.LogWarning("Crest: Main Light must be enabled to enable water shadowing.", _Water);
                     _Valid = false;
                     return;
                 }
@@ -171,7 +164,7 @@ namespace WaveHarmonic.Crest
 
             if (isShadowsDisabled)
             {
-                Debug.LogError("Crest: Shadows must be enabled in the quality settings to enable water shadowing.", _Water);
+                Debug.LogWarning("Crest: Shadows must be enabled in the quality settings to enable water shadowing.", _Water);
                 _Valid = false;
                 return;
             }
@@ -236,8 +229,6 @@ namespace WaveHarmonic.Crest
         {
             base.Allocate();
 
-            _Targets.RunLambda(buffer => Clear(buffer));
-
             {
                 _RenderMaterial = new PropertyWrapperMaterial[Slices];
                 var shader = WaterResources.Instance.Shaders._UpdateShadow;
@@ -263,12 +254,6 @@ namespace WaveHarmonic.Crest
             }
         }
 
-        internal override void ClearLodData()
-        {
-            base.ClearLodData();
-            _Targets.RunLambda(buffer => Clear(buffer));
-        }
-
         /// <summary>
         /// Validates the primary light.
         /// </summary>
@@ -309,7 +294,7 @@ namespace WaveHarmonic.Crest
             {
                 if (_Error != Error.IncorrectLightType)
                 {
-                    Debug.LogError("Crest: Primary light must be of type Directional.", _Light);
+                    Debug.LogWarning("Crest: Primary light must be of type Directional.", _Light);
                     _Error = Error.IncorrectLightType;
                 }
                 return false;
@@ -352,7 +337,8 @@ namespace WaveHarmonic.Crest
         {
             if (_Light != _Water.PrimaryLight)
             {
-                _Targets.RunLambda(buffer => Clear(buffer));
+                Clear(DataTexture);
+                Clear(_PersistentDataTexture);
                 CleanUpShadowCommandBuffers();
                 _Light = null;
             }
@@ -388,7 +374,8 @@ namespace WaveHarmonic.Crest
                 if (CopyShadowMapBuffer != null)
                 {
                     // If we have a command buffer, then there is likely shadow data so we need to clear it.
-                    _Targets.RunLambda(buffer => Clear(buffer));
+                    Clear(DataTexture);
+                    Clear(_PersistentDataTexture);
                     CleanUpShadowCommandBuffers();
                 }
 
@@ -398,8 +385,6 @@ namespace WaveHarmonic.Crest
             CopyShadowMapBuffer ??= new() { name = WaterRenderer.k_DrawLodData };
             CopyShadowMapBuffer.Clear();
 
-            FlipBuffers();
-
             // clear the shadow collection. it will be overwritten with shadow values IF the shadows render,
             // which only happens if there are (nontransparent) shadow receivers around. this is only reliable
             // in play mode, so don't do it in edit mode.
@@ -457,12 +442,6 @@ namespace WaveHarmonic.Crest
             }
         }
 
-        private protected override void GetSubstepData(float timeToSimulate, out int substeps, out float delta)
-        {
-            substeps = Mathf.FloorToInt(timeToSimulate * _SimulationFrequency);
-            delta = substeps > 0 ? (1f / _SimulationFrequency) : 0f;
-        }
-
         private protected override void SetAdditionalSimulationParameters(PropertyWrapperCompute properties)
         {
             base.SetAdditionalSimulationParameters(properties);
@@ -521,6 +500,7 @@ namespace WaveHarmonic.Crest
         {
             _Enabled = true;
             _TextureFormat = GraphicsFormat.R8G8_UNorm;
+            _Blur = true;
         }
 
         internal static SortedList<int, ILodInput> s_Inputs = new(Helpers.DuplicateComparison);