Unity Recorder Particle Issue

2026-02-04 23:54 UTC gpt-5-2-thinking Open in ChatGPT ↗

You

i am in unity 2023.2 using hdrp and fx graph. my particles run fine when in play mode. however they disappear when i use the unity recorder.

i have identified the problem to be related to my 3d fluid solver. in record mode the vector field is empty with all the values concentrated at the corners. this fucks the particles up.

in play mode the fluid vector field is ok. here’s the c# code:

using UnchartedLimbo.Core.Runtime.Attributes; using UnityEngine; using UnchartedLimbo.VoxelUtils.Runtime.Utilities; using UnityEngine.Events;

namespace UnchartedLimbo.VoxelUtils.Runtime.Algorithms.Fluid3D { [ExecuteAlways] public class SmokeFluidSim : MonoBehaviour { //DONT CHANGE THESE const int READ = 0; const int WRITE = 1; const int PHI_N_HAT = 0; const int PHI_N_1_HAT = 1;

  public enum ADVECTION { NORMAL = 1, BFECC = 2, MACCORMACK = 3 };

  //You can change this but you must change the same value in all the compute shader's to the same
  //Must be a pow2 number
  const int NUM_THREADS = 8;

  //You can change this or even use Time.DeltaTime but large time steps can cause numerical errors
  const float TIME_STEP = 0.1f;

  [FoldoutHeader("ORIGINAL ALGORITHM Params")]
  [Header("Buffer Parameters")]
  public int m_width = 128;
  public int m_height = 128;
  public int m_depth = 128;

  [Header("Basic Sim Parameters")]
  [Presetable] public ADVECTION m_advectionType = ADVECTION.NORMAL;
  [Presetable] public int m_iterations = 10;
  [Presetable] public float m_vorticityStrength = 1.0f;

  [Header("Density Parameters")]
  [Presetable] public float m_densityAmount = 1.0f;
  [Presetable] public float m_densityDissipation = 0.999f;
  [Presetable] public float m_densityBuoyancy = 1.0f;
  [Presetable] public float m_densityWeight = 0.0125f;

  [Header("Temperature Parameters")]
  [Presetable] public float m_ambientTemperature = 0.0f;
  [Presetable] public float m_temperatureAmount = 10.0f;
  [Presetable] public float m_temperatureDissipation = 0.995f;

  [Header("Viscosity Parameters")]
  [Presetable] public float m_velocityDissipation = 0.995f;

  [Header("Input Parameters")]
  [Presetable] public float m_inputRadius = 0.04f;
  public Vector4 m_inputPos = new(0.5f,0.1f,0.5f,0.0f);

  [Header("Compute Resources")]
  public ComputeShader m_applyImpulse;
  public ComputeShader m_applyAdvect;
  public ComputeShader m_computeVorticity;
  public ComputeShader m_computeDivergence;
  public ComputeShader m_computeJacobi;
  public ComputeShader m_computeProjection;
  public ComputeShader m_computeConfinement;
  public ComputeShader m_computeObstacles;
  public ComputeShader m_applyBuoyancy;

  [FoldoutHeader("UNCHARTED LIMBO Params")]
  //-----------------------------------------------------------------------------------------------------------
  [Header("-- ULC -- Feature Toggle")]
  [Presetable] public bool enableBuoyancy = false;
  [Presetable] public bool enableTemperature = false;
  [Presetable] public bool enablePointSource = false;

  [Header("-- ULC -- Extra Compute Resources")]
  public ComputeShader m_applyVelocityField;
  public ComputeShader m_applyDensityField;
  public ComputeShader m_applyCustomObstacles;
  // CURRENTLY NOT IMPLEMENTED
  //public ComputeShader m_advectSDFField;

  [Header("-- ULC -- Extra Parameters")]
  public BoxCollider bounds;
  [Space]
  [Presetable] [Range(0,100)] public float velocityFieldAmount;
  [Presetable] [Range(0,100)] public float densityFieldAmount;
  [Presetable] [Range(0.00f,2)] public float boundaryVelocityThreshold;
  [Space]
  [Presetable] public bool continuousDensityInjection;
  [Presetable] public float injectionInterval = 1;
  [Space]
  public Vector3 pointVelocityPosition;
  public Vector3 pointVelocityDirection;
  [Presetable] public float pointVelocityMagnitude;

  // CURRENTLY NOT IMPLEMENTED
  //public UnityEvent<ComputeBuffer> ONSDFSolved;

  [Header("-- ULC -- Read-Only Parameters")]
  [ReadOnly]
  public RenderTexture externalVelocityField;
  [ReadOnly]
  public RenderTexture externalDensityField;
  // CURRENTLY NOT IMPLEMENTED
  //public RenderTexture externalSDFField;

  [FoldoutHeader("EVENTS")]
  public UnityEvent<ComputeBuffer> OnDensitySolved;
  public UnityEvent<ComputeBuffer> OnVelocitySolved;


  private Vector4 m_size;
  private ComputeBuffer[] m_density, m_velocity, m_pressure, m_temperature, m_phi;
  private ComputeBuffer m_temp3f, m_obstacles;
  private float _nextInjection;

  // MONOBEHAVIOUR METHODS
  //---------------------------------------------------------------
  private void OnEnable()
  {
    var r = VoxelUtilsComputeResources.Instance;
    m_applyImpulse         =  r.m_applyImpulse.ComputeShader;
    m_applyAdvect          =  r.m_applyAdvect.ComputeShader;
    m_computeVorticity     =  r.m_computeVorticity.ComputeShader;
    m_computeDivergence    =  r.m_computeDivergence.ComputeShader;
    m_computeJacobi        =  r.m_computeJacobi.ComputeShader;
    m_computeProjection    =  r.m_computeProjection.ComputeShader;
    m_computeConfinement   =  r.m_computeConfinement.ComputeShader;
    m_computeObstacles     =  r.m_computeObstacles.ComputeShader;
    m_applyBuoyancy        =  r.m_applyBuoyancy.ComputeShader;
    m_applyVelocityField   =  r.m_applyVelocityField.ComputeShader;
    m_applyDensityField    =  r.m_applyDensityField.ComputeShader;
    m_applyCustomObstacles =  r.m_applyCustomObstacles.ComputeShader;


    // CURRENTLY NOT IMPLEMENTED
    // m_advectSDFField ??= VoxelUtilsComputeResources.Instance.m_advectSDFField;
  }

  private void Start ()
  {
    if (!Application.isPlaying)
      return;

    QualitySettings.vSyncCount = 1;
    Application.targetFrameRate = 60;

    //Dimension sizes must be pow2 numbers
    m_width = Mathf.ClosestPowerOfTwo(m_width);
    m_height = Mathf.ClosestPowerOfTwo(m_height);
    m_depth = Mathf.ClosestPowerOfTwo(m_depth);

    //Put all dimension sizes in a vector for easy parsing to shader and also prevents user changing
    //dimension sizes during play
    m_size = new Vector4(m_width, m_height, m_depth, 0.0f);

    //Create all the buffers needed

    var SIZE = m_width*m_height*m_depth;

    m_density = new ComputeBuffer[2];
    m_density[READ] = new ComputeBuffer(SIZE, sizeof(float));
    m_density[WRITE] = new ComputeBuffer(SIZE, sizeof(float));

    m_temperature = new ComputeBuffer[2];
    m_temperature[READ] = new ComputeBuffer(SIZE, sizeof(float));
    m_temperature[WRITE] = new ComputeBuffer(SIZE, sizeof(float));

    m_phi = new ComputeBuffer[2];
    m_phi[READ] = new ComputeBuffer(SIZE, sizeof(float));
    m_phi[WRITE] = new ComputeBuffer(SIZE, sizeof(float));

    m_velocity = new ComputeBuffer[2];
    m_velocity[READ] = new ComputeBuffer(SIZE, sizeof(float)*3);
    m_velocity[WRITE] = new ComputeBuffer(SIZE, sizeof(float)*3);

    m_pressure = new ComputeBuffer[2];
    m_pressure[READ] = new ComputeBuffer(SIZE, sizeof(float));
    m_pressure[WRITE] = new ComputeBuffer(SIZE, sizeof(float));

    m_obstacles = new ComputeBuffer(SIZE, sizeof(float));

    m_temp3f = new ComputeBuffer(SIZE, sizeof(float)*3);

    //Any areas that are obstacles need to be masked of in the obstacle buffer
    //At the moment is only the border around the edge of the buffers to enforce non-slip boundary conditions
    ComputeObstacles();

  }

  private void Update ()
  {
    if (!Application.isPlaying)
      return;

    float dt = TIME_STEP;

    //First off advect any buffers that contain physical quantities like density or temperature by the
    //velocity field. Advection is what moves values around.
    if (enableTemperature)
    {
      ApplyAdvection(dt, m_temperatureDissipation, 0.0f, m_temperature);
    }

    //Normal advection can cause smoothing of the advected field making the results look less interesting.
    //BFECC is a method of advection that helps to prevents this smoothing at a extra performance cost but is less numerically stable.
    //MacCormack does the same as BFECC but is more (not completely) numerically stable and is more costly
    if(m_advectionType == ADVECTION.BFECC)
    {
      ApplyAdvection(dt, 1.0f, 0.0f, m_density, 1.0f); //advect forward into write buffer
      ApplyAdvection(dt, 1.0f, 0.0f, m_density[READ], m_phi[PHI_N_HAT], -1.0f); //advect back into phi_n_hat buffer
      ApplyAdvectionBFECC(dt, m_densityDissipation, 0.0f, m_density); //advect using BFECC
    }
    else if(m_advectionType == ADVECTION.MACCORMACK)
    {
      ApplyAdvection(dt, 1.0f, 0.0f, m_density[READ], m_phi[PHI_N_1_HAT], 1.0f); //advect forward into phi_n_1_hat buffer
      ApplyAdvection(dt, 1.0f, 0.0f, m_phi[PHI_N_1_HAT], m_phi[PHI_N_HAT], -1.0f); //advect back into phi_n_hat buffer
      ApplyAdvectionMacCormack(dt, m_densityDissipation, 0.0f, m_density);
    }
    else
    {
      ApplyAdvection(dt, m_densityDissipation, 0.0f, m_density);
    }

    //The velocity field also advects its self.
    ApplyAdvectionVelocity(dt);

    //Apply the effect the sinking colder smoke has on the velocity field
    if (enableBuoyancy)
    {
      ApplyBuoyancy(dt);
    }

    // UNCHARTED LIMBO COLLECTIVE ------------------------------------------------------------------------------
    // APPLY EXTERNAL FORCE FIELD
    ApplyVelocityField(dt, velocityFieldAmount, externalVelocityField, pointVelocityPosition, pointVelocityDirection, pointVelocityMagnitude);

    // APPLY EXTERNAL DENSITY FIELD
    ApplyDensityField(dt, densityFieldAmount, m_density, externalDensityField);

    // ---------------------------------------------------------------------------------------------------------

    //Adds a certain amount of density (the visible smoke) and temperate
    if (enablePointSource)
    {
      //ApplyImpulse(dt, m_densityAmount, m_density);

      if (enableTemperature)
      {
        ApplyImpulse(dt,  m_temperatureAmount, m_temperature);
      }
    }

    //The fuild sim math tends to remove the swirling movement of fluids.
    //This step will try and add it back in
    ComputeVorticityConfinement(dt);

    //Compute the divergence of the velocity field. In fluid simulation the
    //fluid is modelled as being incompressible meaning that the volume of the fluid
    //does not change over time. The divergence is the amount the field has deviated from being divergence free
    ComputeDivergence();

    //This computes the pressure need return the fluid to a divergence free condition
    ComputePressure();

    //Subtract the pressure field from the velocity field enforcing the divergence free conditions
    ComputeProjection();

    // UNCHARTED LIMBO COLLECTIVE ------------------------------------------------------------------------------
    OnDensitySolved.Invoke(m_density[WRITE]);
    OnVelocitySolved.Invoke(m_velocity[WRITE]);
    // ---------------------------------------------------------------------------------------------------------

    //rotation of box not support because ray cast in shader uses a AABB intersection
    transform.rotation = Quaternion.identity;

    GetComponent<Renderer>().material.SetVector("_Translate", transform.localPosition);
    GetComponent<Renderer>().material.SetVector("_Scale", transform.localScale);
    GetComponent<Renderer>().material.SetBuffer("_Density", m_density[READ]);
    GetComponent<Renderer>().material.SetVector("_Size", m_size);

  }

  private void OnDestroy()
  {
    if (!Application.isPlaying)
      return;

    m_density[READ].Release();
    m_density[WRITE].Release();
    m_temperature[READ].Release();
    m_temperature[WRITE].Release();
    m_phi[PHI_N_1_HAT].Release();
    m_phi[PHI_N_HAT].Release();
    m_velocity[READ].Release();
    m_velocity[WRITE].Release();
    m_pressure[READ].Release();
    m_pressure[WRITE].Release();
    m_obstacles.Release();
    m_temp3f.Release();

  }

  //---------------------------------------------------------------

  // UNCHARTED LIMBO COLLECTIVE
  //---------------------------------------------------------------
  private void ApplyVelocityField(float dt, float amount, Texture velocityField, Vector3 pVelPos  = default, Vector3 pVelDir = default, float pVelMag = 0)
  {
    if (velocityField == null)
      return;

    m_applyVelocityField.SetVector("_Size", m_size);
    m_applyVelocityField.SetFloat("_Amount", amount);
    m_applyVelocityField.SetFloat("_DeltaTime", dt);

    m_applyVelocityField.SetTexture(0,"_VelocityField", velocityField);

    m_applyVelocityField.SetBuffer(0, "_Velocity", m_velocity[READ]);
    m_applyVelocityField.SetBuffer(0, "_Write", m_velocity[WRITE]);

    m_applyVelocityField.SetVector("_PointVelPosition", pVelPos);
    m_applyVelocityField.SetVector("_PointVelDirection", pVelDir);
    m_applyVelocityField.SetFloat("_PointVelMagnitude", pVelMag);

    m_applyVelocityField.SetVector("boundsSize", bounds.size);
    m_applyVelocityField.SetVector("minCorner", bounds.bounds.min);

    m_applyVelocityField.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(m_velocity);
  }

  private void ApplyDensityField(float dt, float amount, ComputeBuffer[] buffer, Texture densityField)
  {
    if (densityField == null)
      return;

    if (!continuousDensityInjection)
    {
      if (Time.time < _nextInjection) return;
    }

    m_applyDensityField.SetVector("_Size", m_size);
    m_applyDensityField.SetFloat("_Amount", amount);
    m_applyDensityField.SetFloat("_DeltaTime", dt);

    m_applyDensityField.SetTexture(0,"_DensityField", densityField);

    m_applyDensityField.SetBuffer(0, "_Read", buffer[READ]);
    m_applyDensityField.SetBuffer(0, "_Write", buffer[WRITE]);

    m_applyDensityField.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(buffer);

    _nextInjection = Time.time + injectionInterval;

  }

  /* CURRENTLY NOT IMPLEMENTED
  private void AdvectSDFField(Texture sdfField, float dt, float dissipation, float decay, ComputeBuffer[] buffer,float forward = 1.0f)
  {
    m_advectSDFField.SetVector("_Size", m_size);
    m_advectSDFField.SetFloat("_DeltaTime", dt);
    m_advectSDFField.SetFloat("_Dissipate", dissipation);
    m_advectSDFField.SetFloat("_Forward", forward);
    m_advectSDFField.SetFloat("_Decay", decay);

    m_advectSDFField.SetBuffer((int)ADVECTION.NORMAL, "_Read1f", buffer[READ]);
    m_advectSDFField.SetBuffer((int)ADVECTION.NORMAL, "_Write1f", buffer[WRITE]);
    m_advectSDFField.SetBuffer((int)ADVECTION.NORMAL, "_Velocity", m_velocity[READ]);
    m_advectSDFField.SetBuffer((int)ADVECTION.NORMAL, "_Obstacles", m_obstacles);

    m_advectSDFField.SetTexture((int)ADVECTION.NORMAL, "_NewSDF", sdfField);

    m_advectSDFField.Dispatch((int)ADVECTION.NORMAL, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(buffer);
  }
  */

  void ComputeCustomObstacles()
  {
    m_applyCustomObstacles.SetVector("_Size", m_size);
    m_applyCustomObstacles.SetBuffer(0, "_Write", m_obstacles);
    m_applyCustomObstacles.SetBuffer(0,"_VelocityField",m_velocity[WRITE]);
    m_applyCustomObstacles.SetFloat("_Thres",boundaryVelocityThreshold);

    m_applyCustomObstacles.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

  }

  //---------------------------------------------------------------

  private static void Swap(ComputeBuffer[] buffer)
  {
    (buffer[READ], buffer[WRITE]) = (buffer[WRITE], buffer[READ]);
  }

  private void ComputeObstacles()
  {
    m_computeObstacles.SetVector("_Size", m_size);
    m_computeObstacles.SetBuffer(0, "_Write", m_obstacles);
    m_computeObstacles.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);
  }

  private void ApplyImpulse(float dt, float amount, ComputeBuffer[] buffer)
  {
    m_applyImpulse.SetVector("_Size", m_size);
    m_applyImpulse.SetFloat("_Radius", m_inputRadius);
    m_applyImpulse.SetFloat("_Amount", amount);
    m_applyImpulse.SetFloat("_DeltaTime", dt);
    m_applyImpulse.SetVector("_Pos", m_inputPos);

    m_applyImpulse.SetBuffer(0, "_Read", buffer[READ]);
    m_applyImpulse.SetBuffer(0, "_Write", buffer[WRITE]);

    m_applyImpulse.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(buffer);
  }

  private void ApplyBuoyancy(float dt)
  {
    m_applyBuoyancy.SetVector("_Size", m_size);
    m_applyBuoyancy.SetVector("_Up", new Vector4(0,1,0,0));
    m_applyBuoyancy.SetFloat("_Buoyancy", m_densityBuoyancy);
    m_applyBuoyancy.SetFloat("_AmbientTemperature", m_ambientTemperature);
    m_applyBuoyancy.SetFloat("_Weight", m_densityWeight);
    m_applyBuoyancy.SetFloat("_DeltaTime", dt);

    m_applyBuoyancy.SetBuffer(0, "_Write", m_velocity[WRITE]);
    m_applyBuoyancy.SetBuffer(0, "_Velocity", m_velocity[READ]);
    m_applyBuoyancy.SetBuffer(0, "_Density", m_density[READ]);
    m_applyBuoyancy.SetBuffer(0, "_Temperature", m_temperature[READ]);

    m_applyBuoyancy.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(m_velocity);
  }

  private void ApplyAdvection(float dt, float dissipation, float decay, ComputeBuffer[] buffer, float forward = 1.0f)
  {
    m_applyAdvect.SetVector("_Size", m_size);
    m_applyAdvect.SetFloat("_DeltaTime", dt);
    m_applyAdvect.SetFloat("_Dissipate", dissipation);
    m_applyAdvect.SetFloat("_Forward", forward);
    m_applyAdvect.SetFloat("_Decay", decay);

    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Read1f", buffer[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Write1f", buffer[WRITE]);
    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Velocity", m_velocity[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Obstacles", m_obstacles);

    m_applyAdvect.Dispatch((int)ADVECTION.NORMAL, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(buffer);
  }

  private void ApplyAdvection(float dt, float dissipation, float decay, ComputeBuffer read, ComputeBuffer write, float forward = 1.0f)
  {
    m_applyAdvect.SetVector("_Size", m_size);
    m_applyAdvect.SetFloat("_DeltaTime", dt);
    m_applyAdvect.SetFloat("_Dissipate", dissipation);
    m_applyAdvect.SetFloat("_Forward", forward);
    m_applyAdvect.SetFloat("_Decay", decay);

    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Read1f", read);
    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Write1f", write);
    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Velocity", m_velocity[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Obstacles", m_obstacles);

    m_applyAdvect.Dispatch((int)ADVECTION.NORMAL, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);
  }

  void ApplyAdvectionBFECC(float dt, float dissipation, float decay, ComputeBuffer[] buffer)
  {
    m_applyAdvect.SetVector("_Size", m_size);
    m_applyAdvect.SetFloat("_DeltaTime", dt);
    m_applyAdvect.SetFloat("_Dissipate", dissipation);
    m_applyAdvect.SetFloat("_Forward", 1.0f);
    m_applyAdvect.SetFloat("_Decay", decay);

    m_applyAdvect.SetBuffer((int)ADVECTION.BFECC, "_Read1f", buffer[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.BFECC, "_Write1f", buffer[WRITE]);
    m_applyAdvect.SetBuffer((int)ADVECTION.BFECC, "_Phi_n_hat", m_phi[PHI_N_HAT]);
    m_applyAdvect.SetBuffer((int)ADVECTION.BFECC, "_Velocity", m_velocity[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.BFECC, "_Obstacles", m_obstacles);

    m_applyAdvect.Dispatch((int)ADVECTION.BFECC, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(buffer);
  }

  private void ApplyAdvectionMacCormack(float dt, float dissipation, float decay, ComputeBuffer[] buffer)
  {
    m_applyAdvect.SetVector("_Size", m_size);
    m_applyAdvect.SetFloat("_DeltaTime", dt);
    m_applyAdvect.SetFloat("_Dissipate", dissipation);
    m_applyAdvect.SetFloat("_Forward", 1.0f);
    m_applyAdvect.SetFloat("_Decay", decay);

    m_applyAdvect.SetBuffer((int)ADVECTION.MACCORMACK, "_Read1f", buffer[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.MACCORMACK, "_Write1f", buffer[WRITE]);
    m_applyAdvect.SetBuffer((int)ADVECTION.MACCORMACK, "_Phi_n_1_hat", m_phi[PHI_N_1_HAT]);
    m_applyAdvect.SetBuffer((int)ADVECTION.MACCORMACK, "_Phi_n_hat", m_phi[PHI_N_HAT]);
    m_applyAdvect.SetBuffer((int)ADVECTION.MACCORMACK, "_Velocity", m_velocity[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.MACCORMACK, "_Obstacles", m_obstacles);

    m_applyAdvect.Dispatch((int)ADVECTION.MACCORMACK, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(buffer);
  }

  private void ApplyAdvectionVelocity(float dt)
  {
    m_applyAdvect.SetVector("_Size", m_size);
    m_applyAdvect.SetFloat("_DeltaTime", dt);
    m_applyAdvect.SetFloat("_Dissipate", m_velocityDissipation);
    m_applyAdvect.SetFloat("_Forward", 1.0f);
    m_applyAdvect.SetFloat("_Decay", 0.0f);

    m_applyAdvect.SetBuffer(0, "_Read3f", m_velocity[READ]);
    m_applyAdvect.SetBuffer(0, "_Write3f", m_velocity[WRITE]);
    m_applyAdvect.SetBuffer(0, "_Velocity", m_velocity[READ]);
    m_applyAdvect.SetBuffer(0, "_Obstacles", m_obstacles);

    m_applyAdvect.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(m_velocity);
  }

  private void ComputeVorticityConfinement(float dt)
  {
    m_computeVorticity.SetVector("_Size", m_size);

    m_computeVorticity.SetBuffer(0, "_Write", m_temp3f);
    m_computeVorticity.SetBuffer(0, "_Velocity", m_velocity[READ]);

    m_computeVorticity.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    m_computeConfinement.SetVector("_Size", m_size);
    m_computeConfinement.SetFloat("_DeltaTime", dt);
    m_computeConfinement.SetFloat("_Epsilon", m_vorticityStrength);

    m_computeConfinement.SetBuffer(0, "_Write", m_velocity[WRITE]);
    m_computeConfinement.SetBuffer(0, "_Read", m_velocity[READ]);
    m_computeConfinement.SetBuffer(0, "_Vorticity", m_temp3f);

    m_computeConfinement.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(m_velocity);
  }

  private void ComputeDivergence()
  {
    m_computeDivergence.SetVector("_Size", m_size);

    m_computeDivergence.SetBuffer(0, "_Write", m_temp3f);
    m_computeDivergence.SetBuffer(0, "_Velocity", m_velocity[READ]);
    m_computeDivergence.SetBuffer(0, "_Obstacles", m_obstacles);

    m_computeDivergence.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);
  }

  private void ComputePressure()
  {
    m_computeJacobi.SetVector("_Size", m_size);
    m_computeJacobi.SetBuffer(0, "_Divergence", m_temp3f);
    m_computeJacobi.SetBuffer(0, "_Obstacles", m_obstacles);

    for(int i = 0; i < m_iterations; i++)
    {
      m_computeJacobi.SetBuffer(0, "_Write", m_pressure[WRITE]);
      m_computeJacobi.SetBuffer(0, "_Pressure", m_pressure[READ]);

      m_computeJacobi.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

      Swap(m_pressure);
    }
  }

  private void ComputeProjection()
  {
    m_computeProjection.SetVector("_Size", m_size);
    m_computeProjection.SetBuffer(0, "_Obstacles", m_obstacles);

    m_computeProjection.SetBuffer(0, "_Pressure", m_pressure[READ]);
    m_computeProjection.SetBuffer(0, "_Velocity", m_velocity[READ]);
    m_computeProjection.SetBuffer(0, "_Write", m_velocity[WRITE]);

    m_computeProjection.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(m_velocity);
  }

}

}

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

Two things jump out that can absolutely produce “works in Play, breaks when Recorder is active” symptoms — especially when VFX Graph is reading GPU buffers/textures and Unity’s capture loop changes the update/render timing.

1) You’re invoking the events with the wrong buffer (WRITE instead of READ)

At the end of your sim step, you swap buffers a bunch of times. After each Swap(), the latest result is in buffer[READ].

But you do:

OnDensitySolved.Invoke(m_density[WRITE]);
OnVelocitySolved.Invoke(m_velocity[WRITE]);

That is almost certainly wrong. You’re handing downstream systems the previous buffer (or worse: on the first frames, an uninitialized buffer). In “normal” play you might not notice because the consumer is effectively one frame behind, but Recorder/capture can change ordering so the consumer reads “garbage/edge clamped/corners” and your field looks empty.

✅ Fix:

OnDensitySolved.Invoke(m_density[READ]);
OnVelocitySolved.Invoke(m_velocity[READ]);

Put those after the last place you swap the corresponding buffers (in your case after ComputeProjection() + its swap).

---

2) VFX Graph may be sampling before your compute dispatch finishes for the frame

Recorder often forces a different “simulation step vs render” cadence (fixed stepping, multiple renders, etc.). That can surface race/order issues that don’t show in realtime.

Practical fixes:

A) Run the sim in LateUpdate() (so it happens after most Update() work)

Move the whole body of Update() (the sim step + event invocation + material binding) into LateUpdate().

This often fixes “VFX reads last frame / reads before data is written” because VFX Graph updates earlier.

B) Or enforce script execution order

Set SmokeFluidSim to execute before the VisualEffect component updates. (Project Settings → Script Execution Order)

---

3) Recorder time stepping: don’t ignore capture delta when it’s enabled

Unity Recorder can adjust time stepping for deterministic capture (via Time.captureDeltaTime / Time.captureFramerate). Unity explicitly exposes this. citeturn0search4
Also, Recorder can affect systems that use unscaled time / different timing assumptions. citeturn0search7

Right now you hardcode:

float dt = TIME_STEP; // 0.1

That means when Recorder wants (say) 1/60, your sim is effectively stepping at 0.1 anyway — which can destabilize advection/projection numerically and yield NaNs/inf that then “collapse” to edges/corners depending on how your compute shader clamps/handles invalid coords.

✅ Safer dt logic (still deterministic in capture):

float dt = (Time.captureDeltaTime > 0f) ? Time.captureDeltaTime : Time.deltaTime;
// Optional clamp for stability:
dt = Mathf.Min(dt, 1f / 30f);

If you really want a fixed dt, then also make Recorder use the same dt (capture framerate) so they agree.

---

Minimal patch to try first (high confidence)

1. Change the two event lines:

OnDensitySolved.Invoke(m_density[READ]);
OnVelocitySolved.Invoke(m_velocity[READ]);

2. Change dt:

float dt = (Time.captureDeltaTime > 0f) ? Time.captureDeltaTime : TIME_STEP;

(or Time.deltaTime if you don’t need fixed dt)

3. If still flaky, move sim to LateUpdate().

---

Quick sanity check that confirms #1 is the culprit

If you temporarily stop swapping right before invoking events (or just log which buffer you hand off), you’ll likely see the VFX is consistently one step behind, and Recorder makes it “hit” the wrong one more often.

---

If you paste the tiny bit of code where the VFX Graph reads the vector field (the binder / custom operator / how you feed the compute buffer or 3D texture into VFX), I can tell you the best place to hand off the buffer (Update vs LateUpdate vs render callback) for deterministic Recorder output.

You

the code is like this now, but the problem is exactly the same.

using UnchartedLimbo.Core.Runtime.Attributes; using UnityEngine; using UnchartedLimbo.VoxelUtils.Runtime.Utilities; using UnityEngine.Events;

namespace UnchartedLimbo.VoxelUtils.Runtime.Algorithms.Fluid3D { [ExecuteAlways] public class SmokeFluidSim : MonoBehaviour { //DONT CHANGE THESE const int READ = 0; const int WRITE = 1; const int PHI_N_HAT = 0; const int PHI_N_1_HAT = 1;

  public enum ADVECTION { NORMAL = 1, BFECC = 2, MACCORMACK = 3 };

  //You can change this but you must change the same value in all the compute shader's to the same
  //Must be a pow2 number
  const int NUM_THREADS = 8;

  //You can change this or even use Time.DeltaTime but large time steps can cause numerical errors
  const float TIME_STEP = 0.1f;

  [FoldoutHeader("ORIGINAL ALGORITHM Params")]
  [Header("Buffer Parameters")]
  public int m_width = 128;
  public int m_height = 128;
  public int m_depth = 128;

  [Header("Basic Sim Parameters")]
  [Presetable] public ADVECTION m_advectionType = ADVECTION.NORMAL;
  [Presetable] public int m_iterations = 10;
  [Presetable] public float m_vorticityStrength = 1.0f;

  [Header("Density Parameters")]
  [Presetable] public float m_densityAmount = 1.0f;
  [Presetable] public float m_densityDissipation = 0.999f;
  [Presetable] public float m_densityBuoyancy = 1.0f;
  [Presetable] public float m_densityWeight = 0.0125f;

  [Header("Temperature Parameters")]
  [Presetable] public float m_ambientTemperature = 0.0f;
  [Presetable] public float m_temperatureAmount = 10.0f;
  [Presetable] public float m_temperatureDissipation = 0.995f;

  [Header("Viscosity Parameters")]
  [Presetable] public float m_velocityDissipation = 0.995f;

  [Header("Input Parameters")]
  [Presetable] public float m_inputRadius = 0.04f;
  public Vector4 m_inputPos = new(0.5f,0.1f,0.5f,0.0f);

  [Header("Compute Resources")]
  public ComputeShader m_applyImpulse;
  public ComputeShader m_applyAdvect;
  public ComputeShader m_computeVorticity;
  public ComputeShader m_computeDivergence;
  public ComputeShader m_computeJacobi;
  public ComputeShader m_computeProjection;
  public ComputeShader m_computeConfinement;
  public ComputeShader m_computeObstacles;
  public ComputeShader m_applyBuoyancy;

  [FoldoutHeader("UNCHARTED LIMBO Params")]
  //-----------------------------------------------------------------------------------------------------------
  [Header("-- ULC -- Feature Toggle")]
  [Presetable] public bool enableBuoyancy = false;
  [Presetable] public bool enableTemperature = false;
  [Presetable] public bool enablePointSource = false;

  [Header("-- ULC -- Extra Compute Resources")]
  public ComputeShader m_applyVelocityField;
  public ComputeShader m_applyDensityField;
  public ComputeShader m_applyCustomObstacles;
  // CURRENTLY NOT IMPLEMENTED
  //public ComputeShader m_advectSDFField;

  [Header("-- ULC -- Extra Parameters")]
  public BoxCollider bounds;
  [Space]
  [Presetable] [Range(0,100)] public float velocityFieldAmount;
  [Presetable] [Range(0,100)] public float densityFieldAmount;
  [Presetable] [Range(0.00f,2)] public float boundaryVelocityThreshold;
  [Space]
  [Presetable] public bool continuousDensityInjection;
  [Presetable] public float injectionInterval = 1;
  [Space]
  public Vector3 pointVelocityPosition;
  public Vector3 pointVelocityDirection;
  [Presetable] public float pointVelocityMagnitude;

  // CURRENTLY NOT IMPLEMENTED
  //public UnityEvent<ComputeBuffer> ONSDFSolved;

  [Header("-- ULC -- Read-Only Parameters")]
  [ReadOnly]
  public RenderTexture externalVelocityField;
  [ReadOnly]
  public RenderTexture externalDensityField;
  // CURRENTLY NOT IMPLEMENTED
  //public RenderTexture externalSDFField;

  [FoldoutHeader("EVENTS")]
  public UnityEvent<ComputeBuffer> OnDensitySolved;
  public UnityEvent<ComputeBuffer> OnVelocitySolved;


  private Vector4 m_size;
  private ComputeBuffer[] m_density, m_velocity, m_pressure, m_temperature, m_phi;
  private ComputeBuffer m_temp3f, m_obstacles;
  private float _nextInjection;

  // MONOBEHAVIOUR METHODS
  //---------------------------------------------------------------
  private void OnEnable()
  {
    var r = VoxelUtilsComputeResources.Instance;
    m_applyImpulse         =  r.m_applyImpulse.ComputeShader;
    m_applyAdvect          =  r.m_applyAdvect.ComputeShader;
    m_computeVorticity     =  r.m_computeVorticity.ComputeShader;
    m_computeDivergence    =  r.m_computeDivergence.ComputeShader;
    m_computeJacobi        =  r.m_computeJacobi.ComputeShader;
    m_computeProjection    =  r.m_computeProjection.ComputeShader;
    m_computeConfinement   =  r.m_computeConfinement.ComputeShader;
    m_computeObstacles     =  r.m_computeObstacles.ComputeShader;
    m_applyBuoyancy        =  r.m_applyBuoyancy.ComputeShader;
    m_applyVelocityField   =  r.m_applyVelocityField.ComputeShader;
    m_applyDensityField    =  r.m_applyDensityField.ComputeShader;
    m_applyCustomObstacles =  r.m_applyCustomObstacles.ComputeShader;


    // CURRENTLY NOT IMPLEMENTED
    // m_advectSDFField ??= VoxelUtilsComputeResources.Instance.m_advectSDFField;
  }

  private void Start ()
  {
    if (!Application.isPlaying)
      return;

    QualitySettings.vSyncCount = 1;
    Application.targetFrameRate = 60;

    //Dimension sizes must be pow2 numbers
    m_width = Mathf.ClosestPowerOfTwo(m_width);
    m_height = Mathf.ClosestPowerOfTwo(m_height);
    m_depth = Mathf.ClosestPowerOfTwo(m_depth);

    //Put all dimension sizes in a vector for easy parsing to shader and also prevents user changing
    //dimension sizes during play
    m_size = new Vector4(m_width, m_height, m_depth, 0.0f);

    //Create all the buffers needed

    var SIZE = m_width*m_height*m_depth;

    m_density = new ComputeBuffer[2];
    m_density[READ] = new ComputeBuffer(SIZE, sizeof(float));
    m_density[WRITE] = new ComputeBuffer(SIZE, sizeof(float));

    m_temperature = new ComputeBuffer[2];
    m_temperature[READ] = new ComputeBuffer(SIZE, sizeof(float));
    m_temperature[WRITE] = new ComputeBuffer(SIZE, sizeof(float));

    m_phi = new ComputeBuffer[2];
    m_phi[READ] = new ComputeBuffer(SIZE, sizeof(float));
    m_phi[WRITE] = new ComputeBuffer(SIZE, sizeof(float));

    m_velocity = new ComputeBuffer[2];
    m_velocity[READ] = new ComputeBuffer(SIZE, sizeof(float)*3);
    m_velocity[WRITE] = new ComputeBuffer(SIZE, sizeof(float)*3);

    m_pressure = new ComputeBuffer[2];
    m_pressure[READ] = new ComputeBuffer(SIZE, sizeof(float));
    m_pressure[WRITE] = new ComputeBuffer(SIZE, sizeof(float));

    m_obstacles = new ComputeBuffer(SIZE, sizeof(float));

    m_temp3f = new ComputeBuffer(SIZE, sizeof(float)*3);

    //Any areas that are obstacles need to be masked of in the obstacle buffer
    //At the moment is only the border around the edge of the buffers to enforce non-slip boundary conditions
    ComputeObstacles();

  }

  private void LateUpdate ()
  {
    if (!Application.isPlaying)
      return;

    //float dt = TIME_STEP;
    float dt = (Time.captureDeltaTime > 0f) ? Time.captureDeltaTime : TIME_STEP;

    //First off advect any buffers that contain physical quantities like density or temperature by the
    //velocity field. Advection is what moves values around.
    if (enableTemperature)
    {
      ApplyAdvection(dt, m_temperatureDissipation, 0.0f, m_temperature);
    }

    //Normal advection can cause smoothing of the advected field making the results look less interesting.
    //BFECC is a method of advection that helps to prevents this smoothing at a extra performance cost but is less numerically stable.
    //MacCormack does the same as BFECC but is more (not completely) numerically stable and is more costly
    if(m_advectionType == ADVECTION.BFECC)
    {
      ApplyAdvection(dt, 1.0f, 0.0f, m_density, 1.0f); //advect forward into write buffer
      ApplyAdvection(dt, 1.0f, 0.0f, m_density[READ], m_phi[PHI_N_HAT], -1.0f); //advect back into phi_n_hat buffer
      ApplyAdvectionBFECC(dt, m_densityDissipation, 0.0f, m_density); //advect using BFECC
    }
    else if(m_advectionType == ADVECTION.MACCORMACK)
    {
      ApplyAdvection(dt, 1.0f, 0.0f, m_density[READ], m_phi[PHI_N_1_HAT], 1.0f); //advect forward into phi_n_1_hat buffer
      ApplyAdvection(dt, 1.0f, 0.0f, m_phi[PHI_N_1_HAT], m_phi[PHI_N_HAT], -1.0f); //advect back into phi_n_hat buffer
      ApplyAdvectionMacCormack(dt, m_densityDissipation, 0.0f, m_density);
    }
    else
    {
      ApplyAdvection(dt, m_densityDissipation, 0.0f, m_density);
    }

    //The velocity field also advects its self.
    ApplyAdvectionVelocity(dt);

    //Apply the effect the sinking colder smoke has on the velocity field
    if (enableBuoyancy)
    {
      ApplyBuoyancy(dt);
    }

    // UNCHARTED LIMBO COLLECTIVE ------------------------------------------------------------------------------
    // APPLY EXTERNAL FORCE FIELD
    ApplyVelocityField(dt, velocityFieldAmount, externalVelocityField, pointVelocityPosition, pointVelocityDirection, pointVelocityMagnitude);

    // APPLY EXTERNAL DENSITY FIELD
    ApplyDensityField(dt, densityFieldAmount, m_density, externalDensityField);

    // ---------------------------------------------------------------------------------------------------------

    //Adds a certain amount of density (the visible smoke) and temperate
    if (enablePointSource)
    {
      //ApplyImpulse(dt, m_densityAmount, m_density);

      if (enableTemperature)
      {
        ApplyImpulse(dt,  m_temperatureAmount, m_temperature);
      }
    }

    //The fuild sim math tends to remove the swirling movement of fluids.
    //This step will try and add it back in
    ComputeVorticityConfinement(dt);

    //Compute the divergence of the velocity field. In fluid simulation the
    //fluid is modelled as being incompressible meaning that the volume of the fluid
    //does not change over time. The divergence is the amount the field has deviated from being divergence free
    ComputeDivergence();

    //This computes the pressure need return the fluid to a divergence free condition
    ComputePressure();

    //Subtract the pressure field from the velocity field enforcing the divergence free conditions
    ComputeProjection();

    // UNCHARTED LIMBO COLLECTIVE ------------------------------------------------------------------------------
    OnDensitySolved.Invoke(m_density[READ]);
    OnVelocitySolved.Invoke(m_velocity[READ]);
    // ---------------------------------------------------------------------------------------------------------

    //rotation of box not support because ray cast in shader uses a AABB intersection
    transform.rotation = Quaternion.identity;

    GetComponent<Renderer>().material.SetVector("_Translate", transform.localPosition);
    GetComponent<Renderer>().material.SetVector("_Scale", transform.localScale);
    GetComponent<Renderer>().material.SetBuffer("_Density", m_density[READ]);
    GetComponent<Renderer>().material.SetVector("_Size", m_size);

  }

  private void OnDestroy()
  {
    if (!Application.isPlaying)
      return;

    m_density[READ].Release();
    m_density[WRITE].Release();
    m_temperature[READ].Release();
    m_temperature[WRITE].Release();
    m_phi[PHI_N_1_HAT].Release();
    m_phi[PHI_N_HAT].Release();
    m_velocity[READ].Release();
    m_velocity[WRITE].Release();
    m_pressure[READ].Release();
    m_pressure[WRITE].Release();
    m_obstacles.Release();
    m_temp3f.Release();

  }

  //---------------------------------------------------------------

  // UNCHARTED LIMBO COLLECTIVE
  //---------------------------------------------------------------
  private void ApplyVelocityField(float dt, float amount, Texture velocityField, Vector3 pVelPos  = default, Vector3 pVelDir = default, float pVelMag = 0)
  {
    if (velocityField == null)
      return;

    m_applyVelocityField.SetVector("_Size", m_size);
    m_applyVelocityField.SetFloat("_Amount", amount);
    m_applyVelocityField.SetFloat("_DeltaTime", dt);

    m_applyVelocityField.SetTexture(0,"_VelocityField", velocityField);

    m_applyVelocityField.SetBuffer(0, "_Velocity", m_velocity[READ]);
    m_applyVelocityField.SetBuffer(0, "_Write", m_velocity[WRITE]);

    m_applyVelocityField.SetVector("_PointVelPosition", pVelPos);
    m_applyVelocityField.SetVector("_PointVelDirection", pVelDir);
    m_applyVelocityField.SetFloat("_PointVelMagnitude", pVelMag);

    m_applyVelocityField.SetVector("boundsSize", bounds.size);
    m_applyVelocityField.SetVector("minCorner", bounds.bounds.min);

    m_applyVelocityField.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(m_velocity);
  }

  private void ApplyDensityField(float dt, float amount, ComputeBuffer[] buffer, Texture densityField)
  {
    if (densityField == null)
      return;

    if (!continuousDensityInjection)
    {
      if (Time.time < _nextInjection) return;
    }

    m_applyDensityField.SetVector("_Size", m_size);
    m_applyDensityField.SetFloat("_Amount", amount);
    m_applyDensityField.SetFloat("_DeltaTime", dt);

    m_applyDensityField.SetTexture(0,"_DensityField", densityField);

    m_applyDensityField.SetBuffer(0, "_Read", buffer[READ]);
    m_applyDensityField.SetBuffer(0, "_Write", buffer[WRITE]);

    m_applyDensityField.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(buffer);

    _nextInjection = Time.time + injectionInterval;

  }

  /* CURRENTLY NOT IMPLEMENTED
  private void AdvectSDFField(Texture sdfField, float dt, float dissipation, float decay, ComputeBuffer[] buffer,float forward = 1.0f)
  {
    m_advectSDFField.SetVector("_Size", m_size);
    m_advectSDFField.SetFloat("_DeltaTime", dt);
    m_advectSDFField.SetFloat("_Dissipate", dissipation);
    m_advectSDFField.SetFloat("_Forward", forward);
    m_advectSDFField.SetFloat("_Decay", decay);

    m_advectSDFField.SetBuffer((int)ADVECTION.NORMAL, "_Read1f", buffer[READ]);
    m_advectSDFField.SetBuffer((int)ADVECTION.NORMAL, "_Write1f", buffer[WRITE]);
    m_advectSDFField.SetBuffer((int)ADVECTION.NORMAL, "_Velocity", m_velocity[READ]);
    m_advectSDFField.SetBuffer((int)ADVECTION.NORMAL, "_Obstacles", m_obstacles);

    m_advectSDFField.SetTexture((int)ADVECTION.NORMAL, "_NewSDF", sdfField);

    m_advectSDFField.Dispatch((int)ADVECTION.NORMAL, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(buffer);
  }
  */

  void ComputeCustomObstacles()
  {
    m_applyCustomObstacles.SetVector("_Size", m_size);
    m_applyCustomObstacles.SetBuffer(0, "_Write", m_obstacles);
    m_applyCustomObstacles.SetBuffer(0,"_VelocityField",m_velocity[WRITE]);
    m_applyCustomObstacles.SetFloat("_Thres",boundaryVelocityThreshold);

    m_applyCustomObstacles.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

  }

  //---------------------------------------------------------------

  private static void Swap(ComputeBuffer[] buffer)
  {
    (buffer[READ], buffer[WRITE]) = (buffer[WRITE], buffer[READ]);
  }

  private void ComputeObstacles()
  {
    m_computeObstacles.SetVector("_Size", m_size);
    m_computeObstacles.SetBuffer(0, "_Write", m_obstacles);
    m_computeObstacles.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);
  }

  private void ApplyImpulse(float dt, float amount, ComputeBuffer[] buffer)
  {
    m_applyImpulse.SetVector("_Size", m_size);
    m_applyImpulse.SetFloat("_Radius", m_inputRadius);
    m_applyImpulse.SetFloat("_Amount", amount);
    m_applyImpulse.SetFloat("_DeltaTime", dt);
    m_applyImpulse.SetVector("_Pos", m_inputPos);

    m_applyImpulse.SetBuffer(0, "_Read", buffer[READ]);
    m_applyImpulse.SetBuffer(0, "_Write", buffer[WRITE]);

    m_applyImpulse.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(buffer);
  }

  private void ApplyBuoyancy(float dt)
  {
    m_applyBuoyancy.SetVector("_Size", m_size);
    m_applyBuoyancy.SetVector("_Up", new Vector4(0,1,0,0));
    m_applyBuoyancy.SetFloat("_Buoyancy", m_densityBuoyancy);
    m_applyBuoyancy.SetFloat("_AmbientTemperature", m_ambientTemperature);
    m_applyBuoyancy.SetFloat("_Weight", m_densityWeight);
    m_applyBuoyancy.SetFloat("_DeltaTime", dt);

    m_applyBuoyancy.SetBuffer(0, "_Write", m_velocity[WRITE]);
    m_applyBuoyancy.SetBuffer(0, "_Velocity", m_velocity[READ]);
    m_applyBuoyancy.SetBuffer(0, "_Density", m_density[READ]);
    m_applyBuoyancy.SetBuffer(0, "_Temperature", m_temperature[READ]);

    m_applyBuoyancy.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(m_velocity);
  }

  private void ApplyAdvection(float dt, float dissipation, float decay, ComputeBuffer[] buffer, float forward = 1.0f)
  {
    m_applyAdvect.SetVector("_Size", m_size);
    m_applyAdvect.SetFloat("_DeltaTime", dt);
    m_applyAdvect.SetFloat("_Dissipate", dissipation);
    m_applyAdvect.SetFloat("_Forward", forward);
    m_applyAdvect.SetFloat("_Decay", decay);

    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Read1f", buffer[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Write1f", buffer[WRITE]);
    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Velocity", m_velocity[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Obstacles", m_obstacles);

    m_applyAdvect.Dispatch((int)ADVECTION.NORMAL, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(buffer);
  }

  private void ApplyAdvection(float dt, float dissipation, float decay, ComputeBuffer read, ComputeBuffer write, float forward = 1.0f)
  {
    m_applyAdvect.SetVector("_Size", m_size);
    m_applyAdvect.SetFloat("_DeltaTime", dt);
    m_applyAdvect.SetFloat("_Dissipate", dissipation);
    m_applyAdvect.SetFloat("_Forward", forward);
    m_applyAdvect.SetFloat("_Decay", decay);

    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Read1f", read);
    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Write1f", write);
    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Velocity", m_velocity[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Obstacles", m_obstacles);

    m_applyAdvect.Dispatch((int)ADVECTION.NORMAL, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);
  }

  void ApplyAdvectionBFECC(float dt, float dissipation, float decay, ComputeBuffer[] buffer)
  {
    m_applyAdvect.SetVector("_Size", m_size);
    m_applyAdvect.SetFloat("_DeltaTime", dt);
    m_applyAdvect.SetFloat("_Dissipate", dissipation);
    m_applyAdvect.SetFloat("_Forward", 1.0f);
    m_applyAdvect.SetFloat("_Decay", decay);

    m_applyAdvect.SetBuffer((int)ADVECTION.BFECC, "_Read1f", buffer[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.BFECC, "_Write1f", buffer[WRITE]);
    m_applyAdvect.SetBuffer((int)ADVECTION.BFECC, "_Phi_n_hat", m_phi[PHI_N_HAT]);
    m_applyAdvect.SetBuffer((int)ADVECTION.BFECC, "_Velocity", m_velocity[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.BFECC, "_Obstacles", m_obstacles);

    m_applyAdvect.Dispatch((int)ADVECTION.BFECC, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(buffer);
  }

  private void ApplyAdvectionMacCormack(float dt, float dissipation, float decay, ComputeBuffer[] buffer)
  {
    m_applyAdvect.SetVector("_Size", m_size);
    m_applyAdvect.SetFloat("_DeltaTime", dt);
    m_applyAdvect.SetFloat("_Dissipate", dissipation);
    m_applyAdvect.SetFloat("_Forward", 1.0f);
    m_applyAdvect.SetFloat("_Decay", decay);

    m_applyAdvect.SetBuffer((int)ADVECTION.MACCORMACK, "_Read1f", buffer[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.MACCORMACK, "_Write1f", buffer[WRITE]);
    m_applyAdvect.SetBuffer((int)ADVECTION.MACCORMACK, "_Phi_n_1_hat", m_phi[PHI_N_1_HAT]);
    m_applyAdvect.SetBuffer((int)ADVECTION.MACCORMACK, "_Phi_n_hat", m_phi[PHI_N_HAT]);
    m_applyAdvect.SetBuffer((int)ADVECTION.MACCORMACK, "_Velocity", m_velocity[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.MACCORMACK, "_Obstacles", m_obstacles);

    m_applyAdvect.Dispatch((int)ADVECTION.MACCORMACK, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(buffer);
  }

  private void ApplyAdvectionVelocity(float dt)
  {
    m_applyAdvect.SetVector("_Size", m_size);
    m_applyAdvect.SetFloat("_DeltaTime", dt);
    m_applyAdvect.SetFloat("_Dissipate", m_velocityDissipation);
    m_applyAdvect.SetFloat("_Forward", 1.0f);
    m_applyAdvect.SetFloat("_Decay", 0.0f);

    m_applyAdvect.SetBuffer(0, "_Read3f", m_velocity[READ]);
    m_applyAdvect.SetBuffer(0, "_Write3f", m_velocity[WRITE]);
    m_applyAdvect.SetBuffer(0, "_Velocity", m_velocity[READ]);
    m_applyAdvect.SetBuffer(0, "_Obstacles", m_obstacles);

    m_applyAdvect.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(m_velocity);
  }

  private void ComputeVorticityConfinement(float dt)
  {
    m_computeVorticity.SetVector("_Size", m_size);

    m_computeVorticity.SetBuffer(0, "_Write", m_temp3f);
    m_computeVorticity.SetBuffer(0, "_Velocity", m_velocity[READ]);

    m_computeVorticity.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    m_computeConfinement.SetVector("_Size", m_size);
    m_computeConfinement.SetFloat("_DeltaTime", dt);
    m_computeConfinement.SetFloat("_Epsilon", m_vorticityStrength);

    m_computeConfinement.SetBuffer(0, "_Write", m_velocity[WRITE]);
    m_computeConfinement.SetBuffer(0, "_Read", m_velocity[READ]);
    m_computeConfinement.SetBuffer(0, "_Vorticity", m_temp3f);

    m_computeConfinement.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(m_velocity);
  }

  private void ComputeDivergence()
  {
    m_computeDivergence.SetVector("_Size", m_size);

    m_computeDivergence.SetBuffer(0, "_Write", m_temp3f);
    m_computeDivergence.SetBuffer(0, "_Velocity", m_velocity[READ]);
    m_computeDivergence.SetBuffer(0, "_Obstacles", m_obstacles);

    m_computeDivergence.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);
  }

  private void ComputePressure()
  {
    m_computeJacobi.SetVector("_Size", m_size);
    m_computeJacobi.SetBuffer(0, "_Divergence", m_temp3f);
    m_computeJacobi.SetBuffer(0, "_Obstacles", m_obstacles);

    for(int i = 0; i < m_iterations; i++)
    {
      m_computeJacobi.SetBuffer(0, "_Write", m_pressure[WRITE]);
      m_computeJacobi.SetBuffer(0, "_Pressure", m_pressure[READ]);

      m_computeJacobi.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

      Swap(m_pressure);
    }
  }

  private void ComputeProjection()
  {
    m_computeProjection.SetVector("_Size", m_size);
    m_computeProjection.SetBuffer(0, "_Obstacles", m_obstacles);

    m_computeProjection.SetBuffer(0, "_Pressure", m_pressure[READ]);
    m_computeProjection.SetBuffer(0, "_Velocity", m_velocity[READ]);
    m_computeProjection.SetBuffer(0, "_Write", m_velocity[WRITE]);

    m_computeProjection.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(m_velocity);
  }

}

}

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

Ok — since you already fixed READ/WRITE, moved to LateUpdate, and use Time.captureDeltaTime, the two remaining “Recorder-only” failure modes that match your symptom (“field collapses to corners / looks empty”) are:

1. You’re reading uninitialized/invalid data (NaNs / Infs) and your sampling clamps to [0,1] → corners, and Recorder makes you hit the “bad” frames consistently (no warmup, different stepping).
2. GPU ordering/sync changes under Recorder / HDRP accumulation (multiple renders/subframes per output frame), so VFX/particles sample the field while it’s still being written or before it’s produced.

Below are the highest-yield fixes for those.

---

1) Hard reset / clear your buffers (this fixes “values at corners” surprisingly often)

Right now, your buffers start with undefined GPU memory. In realtime play you might “get lucky” and the sim quickly overwrites most of it. But Recorder frequently captures frame 0 / immediately, and if your compute ever produces NaNs, they can propagate.

Add a one-time clear right after you allocate:

private void Start()
{
    if (!Application.isPlaying) return;

    // ... allocate buffers ...

    ClearAllBuffers();   // <--- add this
    ComputeObstacles();
}

private void ClearAllBuffers()
{
    int size = m_width * m_height * m_depth;

    m_density[READ].SetData(new float[size]);
    m_density[WRITE].SetData(new float[size]);

    m_temperature[READ].SetData(new float[size]);
    m_temperature[WRITE].SetData(new float[size]);

    m_phi[READ].SetData(new float[size]);
    m_phi[WRITE].SetData(new float[size]);

    m_pressure[READ].SetData(new float[size]);
    m_pressure[WRITE].SetData(new float[size]);

    m_obstacles.SetData(new float[size]);

    // velocity is float3
    var zeros3 = new Vector3[size];
    m_velocity[READ].SetData(zeros3);
    m_velocity[WRITE].SetData(zeros3);

    m_temp3f.SetData(zeros3);
}

Why this helps: when the field “concentrates at corners,” that’s a classic sign of invalid coords / NaNs causing a clamp/branch in your compute or VFX sampling path. Clearing prevents undefined garbage from being the initial condition.

Also: Recorder often has no warmup unless you explicitly set it.

---

2) Add an explicit GPU fence so VFX can’t read mid-write

Unity does not guarantee that a ComputeShader.Dispatch() issued during scripting has fully completed before something else later in the frame samples the buffer — especially when the render pipeline / Recorder decides to do extra passes or multi-frame stuff.

Right after your last compute dispatch (after ComputeProjection()), insert a fence:

using UnityEngine.Rendering;

private void LateUpdate()
{
    if (!Application.isPlaying) return;

    float dt = (Time.captureDeltaTime > 0f) ? Time.captureDeltaTime : TIME_STEP;

    // ... all your dispatches ...

    ComputeProjection();

    // Force compute completion before VFX/material reads
    var fence = Graphics.CreateGraphicsFence(
        GraphicsFenceType.AsyncQueueSynchronisation,
        SynchronisationStageFlags.ComputeProcessing
    );
    Graphics.WaitOnAsyncGraphicsFence(fence);

    OnDensitySolved.Invoke(m_density[READ]);
    OnVelocitySolved.Invoke(m_velocity[READ]);

    // ... material binding ...
}

If this fixes it, you’ve confirmed it’s a GPU scheduling / multi-render ordering issue introduced/exposed by Recorder/HDRP.

(If you want the “proper” version later: drive the whole sim from a CommandBuffer inserted at a known HDRP point, but the fence test is the quick proof.)

---

3) If you’re using HDRP Recorder “Accumulation” / motion blur: disable it while debugging

HDRP can render multiple sub-frames per output frame for accumulation/motion blur. That can cause VFX/compute-driven systems to be evaluated in ways you don’t expect (sub-frame sampling vs per-frame simulation). Unity even documents Recorder limitations around HDRP accumulation/motion blur. citeturn0search21turn0search18

So for a clean test:

• Recorder: turn Accumulation off
• HDRP: turn Motion Blur off (at least while validating)

---

4) Recorder timing gotcha: captureDeltaTime only affects scaled time

Unity’s Time.captureDeltaTime / captureFramerate slows playback to a fixed step for capture, but it affects Time.time (scaled by timeScale). citeturn0search24
Anything using unscaled time can desync under Recorder. citeturn0search5

In your code, you gate density injection with Time.time. That’s fine. But if your VFX Graph is set to use a different update mode / fixed timestep, it may be stepping differently. (Worth checking the VFX Graph Update Mode / Fixed Delta options if you have them set.)

---

Do these in this order (fastest to validate)

1. ClearAllBuffers() on Start.
2. Add the GPU fence after ComputeProjection().
3. Disable Recorder Accumulation + HDRP Motion Blur.

If after (1)+(2) it still collapses to corners, then the next most likely cause is inside your compute shader sampling (bounds/minCorner mapping or normalized coords) — and I’d want to see:

• the kernel that writes the vector field / applies external field (m_applyVelocityField),
• and how VFX Graph samples it (3D texture? structured buffer? custom operator?).

If you paste the compute shader for m_applyVelocityField (or whichever produces the vector field you’re visualizing) and a screenshot of the VFX Graph binding (StructuredBuffer vs Texture3D), I can point to the exact line that typically produces “all values at corners” under NaNs/clamp.

You

this is my code. it is not fixed. it produces a “polluted” black 3d texture which completely fucks the particles.

using UnchartedLimbo.Core.Runtime.Attributes; using UnityEngine; using UnchartedLimbo.VoxelUtils.Runtime.Utilities; using UnityEngine.Events; using UnityEngine.Rendering;

namespace UnchartedLimbo.VoxelUtils.Runtime.Algorithms.Fluid3D { //[ExecuteAlways] public class SmokeFluidSim : MonoBehaviour { //DONT CHANGE THESE const int READ = 0; const int WRITE = 1; const int PHI_N_HAT = 0; const int PHI_N_1_HAT = 1;

  public enum ADVECTION { NORMAL = 1, BFECC = 2, MACCORMACK = 3 };

  //You can change this but you must change the same value in all the compute shader's to the same
  //Must be a pow2 number
  const int NUM_THREADS = 8;

  //You can change this or even use Time.DeltaTime but large time steps can cause numerical errors
  const float TIME_STEP = 0.1f;

  [FoldoutHeader("ORIGINAL ALGORITHM Params")]
  [Header("Buffer Parameters")]
  public int m_width = 128;
  public int m_height = 128;
  public int m_depth = 128;

  [Header("Basic Sim Parameters")]
  [Presetable] public ADVECTION m_advectionType = ADVECTION.NORMAL;
  [Presetable] public int m_iterations = 10;
  [Presetable] public float m_vorticityStrength = 1.0f;

  [Header("Density Parameters")]
  [Presetable] public float m_densityAmount = 1.0f;
  [Presetable] public float m_densityDissipation = 0.999f;
  [Presetable] public float m_densityBuoyancy = 1.0f;
  [Presetable] public float m_densityWeight = 0.0125f;

  [Header("Temperature Parameters")]
  [Presetable] public float m_ambientTemperature = 0.0f;
  [Presetable] public float m_temperatureAmount = 10.0f;
  [Presetable] public float m_temperatureDissipation = 0.995f;

  [Header("Viscosity Parameters")]
  [Presetable] public float m_velocityDissipation = 0.995f;

  [Header("Input Parameters")]
  [Presetable] public float m_inputRadius = 0.04f;
  public Vector4 m_inputPos = new(0.5f,0.1f,0.5f,0.0f);

  [Header("Compute Resources")]
  public ComputeShader m_applyImpulse;
  public ComputeShader m_applyAdvect;
  public ComputeShader m_computeVorticity;
  public ComputeShader m_computeDivergence;
  public ComputeShader m_computeJacobi;
  public ComputeShader m_computeProjection;
  public ComputeShader m_computeConfinement;
  public ComputeShader m_computeObstacles;
  public ComputeShader m_applyBuoyancy;

  [FoldoutHeader("UNCHARTED LIMBO Params")]
  //-----------------------------------------------------------------------------------------------------------
  [Header("-- ULC -- Feature Toggle")]
  [Presetable] public bool enableBuoyancy = false;
  [Presetable] public bool enableTemperature = false;
  [Presetable] public bool enablePointSource = false;

  [Header("-- ULC -- Extra Compute Resources")]
  public ComputeShader m_applyVelocityField;
  public ComputeShader m_applyDensityField;
  public ComputeShader m_applyCustomObstacles;
  // CURRENTLY NOT IMPLEMENTED
  //public ComputeShader m_advectSDFField;

  [Header("-- ULC -- Extra Parameters")]
  public BoxCollider bounds;
  [Space]
  [Presetable] [Range(0,100)] public float velocityFieldAmount;
  [Presetable] [Range(0,100)] public float densityFieldAmount;
  [Presetable] [Range(0.00f,2)] public float boundaryVelocityThreshold;
  [Space]
  [Presetable] public bool continuousDensityInjection;
  [Presetable] public float injectionInterval = 1;
  [Space]
  public Vector3 pointVelocityPosition;
  public Vector3 pointVelocityDirection;
  [Presetable] public float pointVelocityMagnitude;

  // CURRENTLY NOT IMPLEMENTED
  //public UnityEvent<ComputeBuffer> ONSDFSolved;

  [Header("-- ULC -- Read-Only Parameters")]
  [ReadOnly]
  public RenderTexture externalVelocityField;
  [ReadOnly]
  public RenderTexture externalDensityField;
  // CURRENTLY NOT IMPLEMENTED
  //public RenderTexture externalSDFField;

  [FoldoutHeader("EVENTS")]
  public UnityEvent<ComputeBuffer> OnDensitySolved;
  public UnityEvent<ComputeBuffer> OnVelocitySolved;


  private Vector4 m_size;
  private ComputeBuffer[] m_density, m_velocity, m_pressure, m_temperature, m_phi;
  private ComputeBuffer m_temp3f, m_obstacles;
  private float _nextInjection;

  // MONOBEHAVIOUR METHODS
  //---------------------------------------------------------------
  private void OnEnable()
  {
    var r = VoxelUtilsComputeResources.Instance;
    m_applyImpulse         =  r.m_applyImpulse.ComputeShader;
    m_applyAdvect          =  r.m_applyAdvect.ComputeShader;
    m_computeVorticity     =  r.m_computeVorticity.ComputeShader;
    m_computeDivergence    =  r.m_computeDivergence.ComputeShader;
    m_computeJacobi        =  r.m_computeJacobi.ComputeShader;
    m_computeProjection    =  r.m_computeProjection.ComputeShader;
    m_computeConfinement   =  r.m_computeConfinement.ComputeShader;
    m_computeObstacles     =  r.m_computeObstacles.ComputeShader;
    m_applyBuoyancy        =  r.m_applyBuoyancy.ComputeShader;
    m_applyVelocityField   =  r.m_applyVelocityField.ComputeShader;
    m_applyDensityField    =  r.m_applyDensityField.ComputeShader;
    m_applyCustomObstacles =  r.m_applyCustomObstacles.ComputeShader;


    // CURRENTLY NOT IMPLEMENTED
    // m_advectSDFField ??= VoxelUtilsComputeResources.Instance.m_advectSDFField;
  }

  private void Start ()
  {
    if (!Application.isPlaying)
      return;

    /*QualitySettings.vSyncCount = 1;
    Application.targetFrameRate = 60;*/

    //Dimension sizes must be pow2 numbers
    m_width = Mathf.ClosestPowerOfTwo(m_width);
    m_height = Mathf.ClosestPowerOfTwo(m_height);
    m_depth = Mathf.ClosestPowerOfTwo(m_depth);

    //Put all dimension sizes in a vector for easy parsing to shader and also prevents user changing
    //dimension sizes during play
    m_size = new Vector4(m_width, m_height, m_depth, 0.0f);

    //Create all the buffers needed

    var SIZE = m_width*m_height*m_depth;

    m_density = new ComputeBuffer[2];
    m_density[READ] = new ComputeBuffer(SIZE, sizeof(float));
    m_density[WRITE] = new ComputeBuffer(SIZE, sizeof(float));

    m_temperature = new ComputeBuffer[2];
    m_temperature[READ] = new ComputeBuffer(SIZE, sizeof(float));
    m_temperature[WRITE] = new ComputeBuffer(SIZE, sizeof(float));

    m_phi = new ComputeBuffer[2];
    m_phi[READ] = new ComputeBuffer(SIZE, sizeof(float));
    m_phi[WRITE] = new ComputeBuffer(SIZE, sizeof(float));

    m_velocity = new ComputeBuffer[2];
    m_velocity[READ] = new ComputeBuffer(SIZE, sizeof(float)*3);
    m_velocity[WRITE] = new ComputeBuffer(SIZE, sizeof(float)*3);

    m_pressure = new ComputeBuffer[2];
    m_pressure[READ] = new ComputeBuffer(SIZE, sizeof(float));
    m_pressure[WRITE] = new ComputeBuffer(SIZE, sizeof(float));

    m_obstacles = new ComputeBuffer(SIZE, sizeof(float));

    m_temp3f = new ComputeBuffer(SIZE, sizeof(float)*3);

    ClearAllBuffers();   // <--- add this

    //Any areas that are obstacles need to be masked of in the obstacle buffer
    //At the moment is only the border around the edge of the buffers to enforce non-slip boundary conditions
    ComputeObstacles();

  }

  private void LateUpdate ()
  {
    if (!Application.isPlaying)
      return;

    //float dt = TIME_STEP;
    float dt = (Time.captureDeltaTime > 0f) ? Time.captureDeltaTime : TIME_STEP;

    //First off advect any buffers that contain physical quantities like density or temperature by the
    //velocity field. Advection is what moves values around.
    if (enableTemperature)
    {
      ApplyAdvection(dt, m_temperatureDissipation, 0.0f, m_temperature);
    }

    //Normal advection can cause smoothing of the advected field making the results look less interesting.
    //BFECC is a method of advection that helps to prevents this smoothing at a extra performance cost but is less numerically stable.
    //MacCormack does the same as BFECC but is more (not completely) numerically stable and is more costly
    if(m_advectionType == ADVECTION.BFECC)
    {
      ApplyAdvection(dt, 1.0f, 0.0f, m_density, 1.0f); //advect forward into write buffer
      ApplyAdvection(dt, 1.0f, 0.0f, m_density[READ], m_phi[PHI_N_HAT], -1.0f); //advect back into phi_n_hat buffer
      ApplyAdvectionBFECC(dt, m_densityDissipation, 0.0f, m_density); //advect using BFECC
    }
    else if(m_advectionType == ADVECTION.MACCORMACK)
    {
      ApplyAdvection(dt, 1.0f, 0.0f, m_density[READ], m_phi[PHI_N_1_HAT], 1.0f); //advect forward into phi_n_1_hat buffer
      ApplyAdvection(dt, 1.0f, 0.0f, m_phi[PHI_N_1_HAT], m_phi[PHI_N_HAT], -1.0f); //advect back into phi_n_hat buffer
      ApplyAdvectionMacCormack(dt, m_densityDissipation, 0.0f, m_density);
    }
    else
    {
      ApplyAdvection(dt, m_densityDissipation, 0.0f, m_density);
    }

    //The velocity field also advects its self.
    ApplyAdvectionVelocity(dt);

    //Apply the effect the sinking colder smoke has on the velocity field
    if (enableBuoyancy)
    {
      ApplyBuoyancy(dt);
    }

    // UNCHARTED LIMBO COLLECTIVE ------------------------------------------------------------------------------
    // APPLY EXTERNAL FORCE FIELD
    ApplyVelocityField(dt, velocityFieldAmount, externalVelocityField, pointVelocityPosition, pointVelocityDirection, pointVelocityMagnitude);

    // APPLY EXTERNAL DENSITY FIELD
    ApplyDensityField(dt, densityFieldAmount, m_density, externalDensityField);

    // ---------------------------------------------------------------------------------------------------------

    //Adds a certain amount of density (the visible smoke) and temperate
    if (enablePointSource)
    {
      //ApplyImpulse(dt, m_densityAmount, m_density);

      if (enableTemperature)
      {
        ApplyImpulse(dt,  m_temperatureAmount, m_temperature);
      }
    }

    //The fuild sim math tends to remove the swirling movement of fluids.
    //This step will try and add it back in
    ComputeVorticityConfinement(dt);

    //Compute the divergence of the velocity field. In fluid simulation the
    //fluid is modelled as being incompressible meaning that the volume of the fluid
    //does not change over time. The divergence is the amount the field has deviated from being divergence free
    ComputeDivergence();

    //This computes the pressure need return the fluid to a divergence free condition
    ComputePressure();

    //Subtract the pressure field from the velocity field enforcing the divergence free conditions
    ComputeProjection();

    // Force compute completion before VFX/material reads
    var fence = Graphics.CreateGraphicsFence(
      GraphicsFenceType.AsyncQueueSynchronisation,
      SynchronisationStageFlags.ComputeProcessing
    );
    Graphics.WaitOnAsyncGraphicsFence(fence);

    // UNCHARTED LIMBO COLLECTIVE ------------------------------------------------------------------------------
    OnDensitySolved.Invoke(m_density[READ]);
    OnVelocitySolved.Invoke(m_velocity[READ]);
    // ---------------------------------------------------------------------------------------------------------

    //rotation of box not support because ray cast in shader uses a AABB intersection
    transform.rotation = Quaternion.identity;

    GetComponent<Renderer>().material.SetVector("_Translate", transform.localPosition);
    GetComponent<Renderer>().material.SetVector("_Scale", transform.localScale);
    GetComponent<Renderer>().material.SetBuffer("_Density", m_density[READ]);
    GetComponent<Renderer>().material.SetVector("_Size", m_size);

  }

  private void OnDestroy()
  {
    if (!Application.isPlaying)
      return;

    m_density[READ].Release();
    m_density[WRITE].Release();
    m_temperature[READ].Release();
    m_temperature[WRITE].Release();
    m_phi[PHI_N_1_HAT].Release();
    m_phi[PHI_N_HAT].Release();
    m_velocity[READ].Release();
    m_velocity[WRITE].Release();
    m_pressure[READ].Release();
    m_pressure[WRITE].Release();
    m_obstacles.Release();
    m_temp3f.Release();

  }

  //---------------------------------------------------------------

  // UNCHARTED LIMBO COLLECTIVE
  //---------------------------------------------------------------
  private void ApplyVelocityField(float dt, float amount, Texture velocityField, Vector3 pVelPos  = default, Vector3 pVelDir = default, float pVelMag = 0)
  {
    if (velocityField == null)
      return;

    m_applyVelocityField.SetVector("_Size", m_size);
    m_applyVelocityField.SetFloat("_Amount", amount);
    m_applyVelocityField.SetFloat("_DeltaTime", dt);

    m_applyVelocityField.SetTexture(0,"_VelocityField", velocityField);

    m_applyVelocityField.SetBuffer(0, "_Velocity", m_velocity[READ]);
    m_applyVelocityField.SetBuffer(0, "_Write", m_velocity[WRITE]);

    m_applyVelocityField.SetVector("_PointVelPosition", pVelPos);
    m_applyVelocityField.SetVector("_PointVelDirection", pVelDir);
    m_applyVelocityField.SetFloat("_PointVelMagnitude", pVelMag);

    m_applyVelocityField.SetVector("boundsSize", bounds.size);
    m_applyVelocityField.SetVector("minCorner", bounds.bounds.min);

    m_applyVelocityField.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(m_velocity);
  }

  private void ApplyDensityField(float dt, float amount, ComputeBuffer[] buffer, Texture densityField)
  {
    if (densityField == null)
      return;

    if (!continuousDensityInjection)
    {
      if (Time.time < _nextInjection) return;
    }

    m_applyDensityField.SetVector("_Size", m_size);
    m_applyDensityField.SetFloat("_Amount", amount);
    m_applyDensityField.SetFloat("_DeltaTime", dt);

    m_applyDensityField.SetTexture(0,"_DensityField", densityField);

    m_applyDensityField.SetBuffer(0, "_Read", buffer[READ]);
    m_applyDensityField.SetBuffer(0, "_Write", buffer[WRITE]);

    m_applyDensityField.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(buffer);

    _nextInjection = Time.time + injectionInterval;

  }

  /* CURRENTLY NOT IMPLEMENTED
  private void AdvectSDFField(Texture sdfField, float dt, float dissipation, float decay, ComputeBuffer[] buffer,float forward = 1.0f)
  {
    m_advectSDFField.SetVector("_Size", m_size);
    m_advectSDFField.SetFloat("_DeltaTime", dt);
    m_advectSDFField.SetFloat("_Dissipate", dissipation);
    m_advectSDFField.SetFloat("_Forward", forward);
    m_advectSDFField.SetFloat("_Decay", decay);

    m_advectSDFField.SetBuffer((int)ADVECTION.NORMAL, "_Read1f", buffer[READ]);
    m_advectSDFField.SetBuffer((int)ADVECTION.NORMAL, "_Write1f", buffer[WRITE]);
    m_advectSDFField.SetBuffer((int)ADVECTION.NORMAL, "_Velocity", m_velocity[READ]);
    m_advectSDFField.SetBuffer((int)ADVECTION.NORMAL, "_Obstacles", m_obstacles);

    m_advectSDFField.SetTexture((int)ADVECTION.NORMAL, "_NewSDF", sdfField);

    m_advectSDFField.Dispatch((int)ADVECTION.NORMAL, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(buffer);
  }
  */

  void ComputeCustomObstacles()
  {
    m_applyCustomObstacles.SetVector("_Size", m_size);
    m_applyCustomObstacles.SetBuffer(0, "_Write", m_obstacles);
    m_applyCustomObstacles.SetBuffer(0,"_VelocityField",m_velocity[WRITE]);
    m_applyCustomObstacles.SetFloat("_Thres",boundaryVelocityThreshold);

    m_applyCustomObstacles.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

  }

  //---------------------------------------------------------------

  private static void Swap(ComputeBuffer[] buffer)
  {
    (buffer[READ], buffer[WRITE]) = (buffer[WRITE], buffer[READ]);
  }

  private void ComputeObstacles()
  {
    m_computeObstacles.SetVector("_Size", m_size);
    m_computeObstacles.SetBuffer(0, "_Write", m_obstacles);
    m_computeObstacles.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);
  }

  private void ApplyImpulse(float dt, float amount, ComputeBuffer[] buffer)
  {
    m_applyImpulse.SetVector("_Size", m_size);
    m_applyImpulse.SetFloat("_Radius", m_inputRadius);
    m_applyImpulse.SetFloat("_Amount", amount);
    m_applyImpulse.SetFloat("_DeltaTime", dt);
    m_applyImpulse.SetVector("_Pos", m_inputPos);

    m_applyImpulse.SetBuffer(0, "_Read", buffer[READ]);
    m_applyImpulse.SetBuffer(0, "_Write", buffer[WRITE]);

    m_applyImpulse.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(buffer);
  }

  private void ApplyBuoyancy(float dt)
  {
    m_applyBuoyancy.SetVector("_Size", m_size);
    m_applyBuoyancy.SetVector("_Up", new Vector4(0,1,0,0));
    m_applyBuoyancy.SetFloat("_Buoyancy", m_densityBuoyancy);
    m_applyBuoyancy.SetFloat("_AmbientTemperature", m_ambientTemperature);
    m_applyBuoyancy.SetFloat("_Weight", m_densityWeight);
    m_applyBuoyancy.SetFloat("_DeltaTime", dt);

    m_applyBuoyancy.SetBuffer(0, "_Write", m_velocity[WRITE]);
    m_applyBuoyancy.SetBuffer(0, "_Velocity", m_velocity[READ]);
    m_applyBuoyancy.SetBuffer(0, "_Density", m_density[READ]);
    m_applyBuoyancy.SetBuffer(0, "_Temperature", m_temperature[READ]);

    m_applyBuoyancy.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(m_velocity);
  }

  private void ApplyAdvection(float dt, float dissipation, float decay, ComputeBuffer[] buffer, float forward = 1.0f)
  {
    m_applyAdvect.SetVector("_Size", m_size);
    m_applyAdvect.SetFloat("_DeltaTime", dt);
    m_applyAdvect.SetFloat("_Dissipate", dissipation);
    m_applyAdvect.SetFloat("_Forward", forward);
    m_applyAdvect.SetFloat("_Decay", decay);

    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Read1f", buffer[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Write1f", buffer[WRITE]);
    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Velocity", m_velocity[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Obstacles", m_obstacles);

    m_applyAdvect.Dispatch((int)ADVECTION.NORMAL, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(buffer);
  }

  private void ApplyAdvection(float dt, float dissipation, float decay, ComputeBuffer read, ComputeBuffer write, float forward = 1.0f)
  {
    m_applyAdvect.SetVector("_Size", m_size);
    m_applyAdvect.SetFloat("_DeltaTime", dt);
    m_applyAdvect.SetFloat("_Dissipate", dissipation);
    m_applyAdvect.SetFloat("_Forward", forward);
    m_applyAdvect.SetFloat("_Decay", decay);

    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Read1f", read);
    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Write1f", write);
    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Velocity", m_velocity[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.NORMAL, "_Obstacles", m_obstacles);

    m_applyAdvect.Dispatch((int)ADVECTION.NORMAL, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);
  }

  void ApplyAdvectionBFECC(float dt, float dissipation, float decay, ComputeBuffer[] buffer)
  {
    m_applyAdvect.SetVector("_Size", m_size);
    m_applyAdvect.SetFloat("_DeltaTime", dt);
    m_applyAdvect.SetFloat("_Dissipate", dissipation);
    m_applyAdvect.SetFloat("_Forward", 1.0f);
    m_applyAdvect.SetFloat("_Decay", decay);

    m_applyAdvect.SetBuffer((int)ADVECTION.BFECC, "_Read1f", buffer[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.BFECC, "_Write1f", buffer[WRITE]);
    m_applyAdvect.SetBuffer((int)ADVECTION.BFECC, "_Phi_n_hat", m_phi[PHI_N_HAT]);
    m_applyAdvect.SetBuffer((int)ADVECTION.BFECC, "_Velocity", m_velocity[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.BFECC, "_Obstacles", m_obstacles);

    m_applyAdvect.Dispatch((int)ADVECTION.BFECC, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(buffer);
  }

  private void ApplyAdvectionMacCormack(float dt, float dissipation, float decay, ComputeBuffer[] buffer)
  {
    m_applyAdvect.SetVector("_Size", m_size);
    m_applyAdvect.SetFloat("_DeltaTime", dt);
    m_applyAdvect.SetFloat("_Dissipate", dissipation);
    m_applyAdvect.SetFloat("_Forward", 1.0f);
    m_applyAdvect.SetFloat("_Decay", decay);

    m_applyAdvect.SetBuffer((int)ADVECTION.MACCORMACK, "_Read1f", buffer[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.MACCORMACK, "_Write1f", buffer[WRITE]);
    m_applyAdvect.SetBuffer((int)ADVECTION.MACCORMACK, "_Phi_n_1_hat", m_phi[PHI_N_1_HAT]);
    m_applyAdvect.SetBuffer((int)ADVECTION.MACCORMACK, "_Phi_n_hat", m_phi[PHI_N_HAT]);
    m_applyAdvect.SetBuffer((int)ADVECTION.MACCORMACK, "_Velocity", m_velocity[READ]);
    m_applyAdvect.SetBuffer((int)ADVECTION.MACCORMACK, "_Obstacles", m_obstacles);

    m_applyAdvect.Dispatch((int)ADVECTION.MACCORMACK, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(buffer);
  }

  private void ApplyAdvectionVelocity(float dt)
  {
    m_applyAdvect.SetVector("_Size", m_size);
    m_applyAdvect.SetFloat("_DeltaTime", dt);
    m_applyAdvect.SetFloat("_Dissipate", m_velocityDissipation);
    m_applyAdvect.SetFloat("_Forward", 1.0f);
    m_applyAdvect.SetFloat("_Decay", 0.0f);

    m_applyAdvect.SetBuffer(0, "_Read3f", m_velocity[READ]);
    m_applyAdvect.SetBuffer(0, "_Write3f", m_velocity[WRITE]);
    m_applyAdvect.SetBuffer(0, "_Velocity", m_velocity[READ]);
    m_applyAdvect.SetBuffer(0, "_Obstacles", m_obstacles);

    m_applyAdvect.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(m_velocity);
  }

  private void ComputeVorticityConfinement(float dt)
  {
    m_computeVorticity.SetVector("_Size", m_size);

    m_computeVorticity.SetBuffer(0, "_Write", m_temp3f);
    m_computeVorticity.SetBuffer(0, "_Velocity", m_velocity[READ]);

    m_computeVorticity.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    m_computeConfinement.SetVector("_Size", m_size);
    m_computeConfinement.SetFloat("_DeltaTime", dt);
    m_computeConfinement.SetFloat("_Epsilon", m_vorticityStrength);

    m_computeConfinement.SetBuffer(0, "_Write", m_velocity[WRITE]);
    m_computeConfinement.SetBuffer(0, "_Read", m_velocity[READ]);
    m_computeConfinement.SetBuffer(0, "_Vorticity", m_temp3f);

    m_computeConfinement.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(m_velocity);
  }

  private void ComputeDivergence()
  {
    m_computeDivergence.SetVector("_Size", m_size);

    m_computeDivergence.SetBuffer(0, "_Write", m_temp3f);
    m_computeDivergence.SetBuffer(0, "_Velocity", m_velocity[READ]);
    m_computeDivergence.SetBuffer(0, "_Obstacles", m_obstacles);

    m_computeDivergence.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);
  }

  private void ComputePressure()
  {
    m_computeJacobi.SetVector("_Size", m_size);
    m_computeJacobi.SetBuffer(0, "_Divergence", m_temp3f);
    m_computeJacobi.SetBuffer(0, "_Obstacles", m_obstacles);

    for(int i = 0; i < m_iterations; i++)
    {
      m_computeJacobi.SetBuffer(0, "_Write", m_pressure[WRITE]);
      m_computeJacobi.SetBuffer(0, "_Pressure", m_pressure[READ]);

      m_computeJacobi.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

      Swap(m_pressure);
    }
  }

  private void ComputeProjection()
  {
    m_computeProjection.SetVector("_Size", m_size);
    m_computeProjection.SetBuffer(0, "_Obstacles", m_obstacles);

    m_computeProjection.SetBuffer(0, "_Pressure", m_pressure[READ]);
    m_computeProjection.SetBuffer(0, "_Velocity", m_velocity[READ]);
    m_computeProjection.SetBuffer(0, "_Write", m_velocity[WRITE]);

    m_computeProjection.Dispatch(0, (int)m_size.x/NUM_THREADS, (int)m_size.y/NUM_THREADS, (int)m_size.z/NUM_THREADS);

    Swap(m_velocity);
  }

  private void ClearAllBuffers()
  {
    int size = m_width * m_height * m_depth;

    m_density[READ].SetData(new float[size]);
    m_density[WRITE].SetData(new float[size]);

    m_temperature[READ].SetData(new float[size]);
    m_temperature[WRITE].SetData(new float[size]);

    m_phi[READ].SetData(new float[size]);
    m_phi[WRITE].SetData(new float[size]);

    m_pressure[READ].SetData(new float[size]);
    m_pressure[WRITE].SetData(new float[size]);

    m_obstacles.SetData(new float[size]);

    // velocity is float3
    var zeros3 = new Vector3[size];
    m_velocity[READ].SetData(zeros3);
    m_velocity[WRITE].SetData(zeros3);

    m_temp3f.SetData(zeros3);
  }

}

}

ChatGPT

Got it. Given you’ve now:

• cleared buffers,
• moved to LateUpdate,
• used Time.captureDeltaTime,
• added a GPU fence,

…and Recorder still produces a polluted / black / corner-collapsed 3D texture that nukes the particles, the most likely remaining cause is not your solver loop anymore.

It’s almost always one of these:

1. Your “externalVelocityField / externalDensityField” RenderTextures are not valid during Recorder frames (wrong dimension/format, not created, not updated, not enableRandomWrite, or “single-buffered” resources being reallocated by HDRP/Recorder). When sampled in compute, invalid reads often become 0 or NaN → your field “collapses” visually.

2. You’re converting world→volume coordinates using bounds.size and bounds.bounds.min but the collider/bounds aren’t stable at the moment of capture, so most samples fall outside [0..1] → clamped to edges/corners.

3. The RenderTexture you think is 3D is actually 2D (or 2DArray) / wrong volume depth, and your compute shader indexes it like a 3D field. In play it might “kind of work” depending on how the resource is set up; Recorder can change camera/graph lifecycle and make it fail hard.

So: don’t guess—instrument the two inputs and the mapping, and you’ll know in one run.

---

A. Put hard validation on the external fields (this catches 80% of recorder-only breakage)

Add this and call it at the top of LateUpdate():

private void ValidateExternal(Texture t, string name)
{
    if (t == null)
    {
        //Debug.LogWarning($"{name} is null");
        return;
    }

    if (t is RenderTexture rt)
    {
        // Must match what your compute expects
        Debug.Log($"{name}: dim={rt.dimension} {rt.width}x{rt.height} volDepth={rt.volumeDepth} fmt={rt.graphicsFormat} rw={rt.enableRandomWrite} created={rt.IsCreated()}");

        if (!rt.IsCreated())
            rt.Create();

        // If your compute samples it as 3D:
        if (rt.dimension != UnityEngine.Rendering.TextureDimension.Tex3D)
            Debug.LogError($"{name} is not TextureDimension.Tex3D");

        if (rt.volumeDepth <= 1)
            Debug.LogError($"{name} volumeDepth <= 1 (not a 3D texture)");

        // Many compute pipelines require this:
        if (!rt.enableRandomWrite)
            Debug.LogWarning($"{name} enableRandomWrite is false (ok if read-only, but check)");
    }
    else
    {
        Debug.Log($"{name}: type={t.GetType().Name} {t.width}x{t.height}");
    }
}

Then:

private void LateUpdate()
{
    if (!Application.isPlaying) return;

    ValidateExternal(externalVelocityField, nameof(externalVelocityField));
    ValidateExternal(externalDensityField, nameof(externalDensityField));

    // ...
}

What you’re looking for when Recorder is running:

• IsCreated() == false at capture time
• dimension is Tex2D or Tex2DArray (common with VFX Graph outputs)
• volumeDepth is 1
• format changes between play and record

If any of those flip only during recording, that’s your smoking gun.

---

B. Stop using bounds.size / bounds.bounds.min directly (they’re easy to desync). Use a fixed “sim-space” transform.

BoxCollider.bounds is world-space AABB and updates based on physics transform evaluation order. Recorder + HDRP can alter when transforms/physics are evaluated relative to your script.

Instead compute a stable mapping from your sim object:

// Use the sim object's transform to define the volume
Vector3 worldMin = transform.TransformPoint(new Vector3(-0.5f, -0.5f, -0.5f));
Vector3 worldMax = transform.TransformPoint(new Vector3( 0.5f,  0.5f,  0.5f));
// If you scale the object, these points move accordingly.

Vector3 size = worldMax - worldMin;

And pass those to the compute instead of bounds.bounds.min and bounds.size:

m_applyVelocityField.SetVector("boundsSize", size);
m_applyVelocityField.SetVector("minCorner", worldMin);

Why: if your compute does uvw = (worldPos - minCorner) / boundsSize;, any glitch in minCorner/size will shove uvw outside 0..1 and you’ll sample clamped corners → “everything at corners.”

If you must use the collider, at least guard it:

if (bounds == null) { Debug.LogError("bounds collider missing"); return; }
if (bounds.size.sqrMagnitude < 1e-6f) { Debug.LogError("bounds size is ~0"); return; }

---

C. Make Recorder not hit frame-0 garbage: add a warmup gate

Recorder often begins capture immediately, before your field has “settled.” Even with clears, your external fields may still be invalid for a few frames.

Add:

[SerializeField] int warmupFrames = 5;
int _frame;

private void LateUpdate()
{
    if (!Application.isPlaying) return;

    _frame++;
    if (_frame < warmupFrames)
        return;

    // run sim...
}

If this fixes it, your problem is lifecycle/order rather than math.

---

D. If the texture turns “polluted black,” assume NaNs and clamp them out in the producer

You said the vector field becomes empty with values concentrated at corners — that’s classic NaN propagation (from divide by zero, normalize(0), etc.) and then a clamp.

You can’t fix that from C# reliably; you fix it in the compute kernels by sanitizing:

• guard divides (/ max(eps, denom))
• guard normalizations (len > eps ? v/len : 0)
• clamp uvw before sampling
• if any component is NaN, write 0

In HLSL you can do:

if (any(isnan(v)) || any(isinf(v))) v = 0;

I know you haven’t pasted the compute shader, but this is exactly the behavior you described.

---

The one thing I need to pinpoint it (no fluff)

Paste these two snippets and I can tell you exactly which of A/B/C/D it is:

1. The compute kernel for m_applyVelocityField (and how it samples _VelocityField + how it computes coordinates).
2. How externalVelocityField is created/assigned (VFX Graph output? custom RT? camera buffer?).

Because right now your C# sim loop is “reasonable.” The failure screams input texture validity / coordinate mapping / NaNs in compute, not buffer swapping anymore.

If you don’t want to paste everything: just paste the parts of the compute shader that:

• compute UVW / index
• sample _VelocityField
• write to _Write (velocity buffer)

That’s enough.

You

the warmuyp frame fixed it!

write me a nice tooltip explaining

ChatGPT

[Tooltip(
    "Warm-up frames before the simulation starts.\n\n" +
    "Unity Recorder (and some HDRP capture modes) can begin rendering/capturing before all GPU resources " +
    "used by this sim are fully initialized and stable (e.g., external 3D textures from VFX/FX Graph, " +
    "camera-dependent buffers, or the first compute dispatch results).\n\n" +
    "During those first few frames the inputs can be empty/undefined, which may produce polluted/black " +
    "volume data and ‘corner-clamped’ vector fields that break particle advection.\n\n" +
    "Set this to a small number (e.g., 3–10) so the field stabilizes before capture begins."
)]
public int warmupFrames = 5;