[HDRP] Fix missing API to sync clouds over network

Simple API to get animation state to be able to restore it later, or on another machine over network.

```cs
var data = VolumetricClouds.animationData;
VolumetricClouds.animationData = data;
```

Author: adrien-de-tocqueville

Packages/com.unity.render-pipelines.high-definition/Documentation~/create-realistic-clouds-volumetric-clouds.md

@@ -33,3 +33,33 @@ When **Rendering Space** is set to **Camera**, the clouds are always located abo
 
 [!include[](snippets/volume-override-api.md)]
 
+By default, animation data for clouds gets incremented automatically depending on the wind parameters.
+In some cases, it can be useful to manually set the animation time, which can be done by using the following script on a Camera:
+
+```cs
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.HighDefinition;
+
+public class CloudSync : MonoBehaviour
+{
+    VolumetricClouds.AnimationData data;
+
+    void Update()
+    {
+        // Save animation data
+        if (Input.GetKeyDown(KeyCode.A))
+            data = VolumetricClouds.animationData;
+
+        // Set animation data
+        if (Input.GetKeyDown(KeyCode.B))
+        {
+            var camera = this.GetComponent<Camera>();
+            var hdCamera = HDCamera.GetOrCreate(camera);
+            VolumetricClouds.animationData = data;
+            // We reset the camera to discard the history buffer manually 
+            hdCamera.Reset(); 
+        }
+    }
+}
+```

Packages/com.unity.render-pipelines.high-definition/Documentation~/water-scripting-in-the-water-system.md

@@ -207,15 +207,21 @@ public class FitToWaterSurface_Burst : MonoBehaviour
 
 ## Synchronizing Water Surfaces
 
-When making a multiplayer game, it can be useful to ensure all clients have a water simulation that is running in sync.
-You can achieve this by specifying the absolute time at which the simulation started by using the following API:
+When working with multiple water surfaces, it can be useful to synchronize the water simulation of each of the surface.
+In a multiplayer game, this can ensure all clients have a water simulation that is running in sync.
+You can achieve this by using one of the two following APIs;
 
 ```cs
-water.simulationStart = new DateTime(2008, 5, 1, 8, 30, 52); // HDRP will compute the water simulation as if the program started at that time
+water.simulationStart = DateTime.Now; // HDRP will compute the water simulation as if the game just started
+water.simulationTime = 0; // Set the exact simulation time in seconds
 ```
 
-Alternatively, if you have a reference water surface, you can make sure other existing surfaces are synchronized with this one by copying the start value:
+Alternatively, if you have a reference water surface, you can make sure other existing surfaces are synchronized with this one by copying the simulation time value:
 
 ```cs
 water.simulationStart = referenceSurface.simulationStart;
+water.simulationTime = referenceSurface.simulationTime;
 ```
+
+The `simulationStart` API works with absolute time data, which simplifies synchronization when sending the value over the network, as you don't have to account for the latency.
+Using the `simulationTime` gives you direct access to the time value used to compute the result of the water simulation and is useful when synchronizing surfaces locally.

Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/VolumetricClouds/HDRenderPipeline.VolumetricClouds.cs

@@ -45,17 +45,9 @@ public partial class HDRenderPipeline
         Material m_CloudCombinePass;
 
         LocalKeyword m_OutputFogTransmittanceKeyword;
-
-        // Animation time is shared for all cameras, but only updated by the main camera
-        internal struct VolumetricCloudsAnimationData
-        {
-            internal float time;
-            public Vector2 cloudOffset;
-            public float verticalShapeOffset;
-            public float verticalErosionOffset;
-        }
-
-        internal VolumetricCloudsAnimationData m_CloudsAnimationData;
+        
+        float m_CloudsAnimationLastTime;
+        internal VolumetricClouds.AnimationData m_CloudsAnimationData;
 
         struct VolumetricCloudsCameraData
         {
@@ -108,9 +100,9 @@ void InitializeVolumetricClouds()
             AllocatePresetTextures();
 
             // Initialize cloud animation
+            m_CloudsAnimationLastTime = -1.0f;
             m_CloudsAnimationData = new()
             {
-                time = -1.0f,
                 cloudOffset = new Vector2(0.0f, 0.0f),
                 verticalShapeOffset = 0.0f,
                 verticalErosionOffset = 0.0f,
@@ -515,8 +507,8 @@ void UpdateVolumetricClouds(HDCamera hdCamera, in VolumetricClouds settings)
             if (EvaluateVolumetricCloudsHistoryValidity(hdCamera))
             {
                 float totalTime = Application.isPlaying ? Time.time : Time.realtimeSinceStartup;
-                float deltaTime = totalTime - m_CloudsAnimationData.time;
-                if (m_CloudsAnimationData.time == -1.0f)
+                float deltaTime = totalTime - m_CloudsAnimationLastTime;
+                if (m_CloudsAnimationLastTime == -1.0f)
                     deltaTime = 0.0f;
 
                 #if UNITY_EDITOR
@@ -533,7 +525,7 @@ void UpdateVolumetricClouds(HDCamera hdCamera, in VolumetricClouds settings)
                 Vector2 windDirection = new Vector2(Mathf.Cos(theta), Mathf.Sin(theta));
 
                 // Animate the offsets
-                m_CloudsAnimationData.time = totalTime;
+                m_CloudsAnimationLastTime = totalTime;
                 m_CloudsAnimationData.cloudOffset += deltaTime * settings.globalWindSpeed.GetValue(hdCamera) * windDirection;
                 m_CloudsAnimationData.verticalShapeOffset += deltaTime * settings.verticalShapeWindSpeed.value;
                 m_CloudsAnimationData.verticalErosionOffset += deltaTime * settings.verticalErosionWindSpeed.value;

Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/VolumetricClouds/VolumetricClouds.cs

@@ -11,6 +11,26 @@ namespace UnityEngine.Rendering.HighDefinition
     [HDRPHelpURL("Override-Volumetric-Clouds")]
     public sealed partial class VolumetricClouds : VolumeComponent
     {
+        /// <summary>
+        /// Struct holding animation data for volumetric clouds.
+        /// Animation data is shared for all cameras, but only updated by the main camera.
+        /// </summary>
+        public struct AnimationData
+        {
+            internal Vector2 cloudOffset;
+            internal float verticalShapeOffset;
+            internal float verticalErosionOffset;
+        }
+
+        /// <summary>
+        /// Override current clouds animation data. Can be used to synchronize clouds over the network.
+        /// </summary>
+        public static AnimationData animationData
+        {
+            get => HDRenderPipeline.currentPipeline.m_CloudsAnimationData;
+            set { HDRenderPipeline.currentPipeline.m_CloudsAnimationData = value; }
+        }
+
         /// <summary>
         /// Control mode for the volumetric clouds.
         /// </summary>

Packages/com.unity.render-pipelines.high-definition/Runtime/Water/HDRenderPipeline.WaterSystem.Foam.cs

@@ -193,7 +193,7 @@ void UpdateWaterFoamSimulation(CommandBuffer cmd, WaterSurface currentWater)
                 return;
 
             // First we must ensure, that the texture is there (if it should be) and at the right resolution
-            currentWater.CheckFoamResources();
+            currentWater.CheckFoamResources(cmd);
 
             // Skip if there are is foam to render
             if (!currentWater.foam)

Packages/com.unity.render-pipelines.high-definition/Runtime/Water/WaterSurface/WaterSurface.Foam.cs

@@ -123,7 +123,7 @@ public enum WaterFoamResolution
         internal RTHandle[] foamBuffers = new RTHandle[2];
         internal float4 previousFoamRegionScaleOffset;
 
-        internal void CheckFoamResources()
+        internal void CheckFoamResources(CommandBuffer cmd)
         {
             if (foam)
             {
@@ -137,6 +137,9 @@ internal void CheckFoamResources()
                 {
                     foamBuffers[0] = RTHandles.Alloc(resolution, resolution, 1, dimension: TextureDimension.Tex2D, colorFormat: GraphicsFormat.R16G16_SFloat, enableRandomWrite: true, wrapMode: TextureWrapMode.Clamp);
                     foamBuffers[1] = RTHandles.Alloc(resolution, resolution, 1, dimension: TextureDimension.Tex2D, colorFormat: GraphicsFormat.R16G16_SFloat, enableRandomWrite: true, wrapMode: TextureWrapMode.Clamp);
+
+                    // Clear buffer 0 only
+                    CoreUtils.SetRenderTarget(cmd, foamBuffers[0], ClearFlag.Color, Color.black);
                 }
             }
             else

Packages/com.unity.render-pipelines.high-definition/Runtime/Water/WaterSurface/WaterSurface.Simulation.cs

@@ -148,6 +148,20 @@ public DateTime simulationStart
             }
         }
 
+        /// <summary>Current simulation time in seconds.</summary>
+        public float simulationTime
+        {
+            get
+            {
+                return simulation?.simulationTime ?? 0.0f;
+            }
+            set
+            {
+                if (simulation != null)
+                    simulation.simulationTime = value;
+            }
+        }
+
         internal int numActiveBands => HDRenderPipeline.EvaluateBandCount(surfaceType, ripples);
 
         // Optional CPU simulation data