ComputeBuffer Memory Leak

2025-07-18 18:25 UTC gpt-4o Open in ChatGPT ↗

You

this Unity code seems to have a leak:

private int BakeSource(Mesh _tempMesh, int offset = 0) { if (_positionBuffer1 == null) { _positionBuffer1 = new ComputeBuffer(_tempMesh.vertexCount, 12); } else if (_positionBuffer1.count != _tempMesh.vertexCount) { _positionBuffer1.Dispose(); _positionBuffer1 = new ComputeBuffer(_tempMesh.vertexCount, 12); }

        if (_positionBuffer2 == null)
        {
            _positionBuffer2 = new ComputeBuffer(_tempMesh.vertexCount, 12);
            CopyVerticesToBuffer(_tempMesh, _positionBuffer2, offset);
        }
        else if (_positionBuffer2.count != _tempMesh.vertexCount)
        {
            _positionBuffer2.Dispose();
            _positionBuffer2 = new ComputeBuffer(_tempMesh.vertexCount, 12);
            CopyVerticesToBuffer(_tempMesh, _positionBuffer2, offset);

        }

        return CopyVerticesToBuffer(_tempMesh, _positionBuffer1, offset);
    }

error: VectorFields/MeshVelocityBaker.cs:91) 0x000001bc93971ba8 (Mono JIT Code) UnchartedLimbo.Core.Algorithms.GPU.GpuAlgorithm:MainLoop () (at ./Library/PackageCache/com.ulc.core@1388095b6f1c/Runtime/Algorithms/GPU/GpuAlgorithm.cs:152) 0x000001bc93971b3b (Mono JIT Code) UnchartedLimbo.Core.Algorithms.GPU.GpuAlgorithm:Update () (at ./Library/PackageCache/com.ulc.core@1388095b6f1c/Runtime/Algorithms/GPU/GpuAlgorithm.cs:197) 0x000001bcb3941248 (Mono JIT Code) (wrapper runtime-invoke) object:runtime_invoke_void__this__ (object,intptr,intptr,intptr) 0x00007ffc6f9d6c2e (mono-2.0-bdwgc) mono_jit_runtime_invoke (at C:/build/output/Unity-Technologies/mono/mono/mini/mini-runtime.c:3445) 0x00007ffc6f9185e4 (mono-2.0-bdwgc) do_runtime_invoke (at C:/build/output/Unity-Technologies/mono/mono/metadata/object.c:3068) 0x00007ffc6f9186d0 (mono-2.0-bdwgc) mono_runtime_invoke (at C:/build/output/Unity-Technologies/mono/mono/metadata/object.c:3115) 0x00007ffc65365e64 (Unity) scripting_method_invoke 0x00007ffc6533dc73 (Unity) ScriptingInvocation::Invoke 0x00007ffc65329304 (Unity) MonoBehaviour::CallMethodIfAvailable 0x00007ffc65329432 (Unity) MonoBehaviour::CallUpdateMethod 0x00007ffc64d5614c (Unity) BaseBehaviourManager::CommonUpdate 0x00007ffc64d5dc5a (Unity) BehaviourManager::Update 0x00007ffc64fe999d (Unity) InitPlayerLoopCallbacks'::2’::UpdateScriptRunBehaviourUpdateRegistrator::Forward 0x00007ffc64fb79c7 (Unity) ExecutePlayerLoop

ChatGPT

You’re correct to suspect a resource leak here. The problem likely lies in the lifecycle management of the ComputeBuffers _positionBuffer1 and _positionBuffer2. Here’s a breakdown of what’s wrong and how to fix it:

---

✅ Problem

1. ComputeBuffer memory is only conditionally disposed:

   • Buffers are only disposed if the vertex count changes. If the same mesh is passed repeatedly (same vertex count), they persist indefinitely.
   • But BakeSource() may be called repeatedly per frame, so new buffers aren’t created, but they also aren’t disposed when no longer needed (like on destruction or reuse in a new context).

2. No cleanup on object destruction:

   • There’s no OnDestroy() or similar cleanup method to release _positionBuffer1 and _positionBuffer2 when the component or system is unloaded.

---

🛠️ Fix

🔹 Add explicit disposal on destruction

Add an OnDestroy() method to the class:

private void OnDestroy()
{
    if (_positionBuffer1 != null)
    {
        _positionBuffer1.Dispose();
        _positionBuffer1 = null;
    }

    if (_positionBuffer2 != null)
    {
        _positionBuffer2.Dispose();
        _positionBuffer2 = null;
    }
}

🔹 Optionally: Dispose and recreate if mesh reference changes

If you want tighter control to avoid stale data or if you frequently switch meshes, consider reinitializing buffers when the source mesh changes, not just when vertex count changes. Track the previous mesh reference.

private Mesh _lastMesh;

private int BakeSource(Mesh _tempMesh, int offset = 0)
{
    if (_lastMesh != _tempMesh)
    {
        _positionBuffer1?.Dispose();
        _positionBuffer2?.Dispose();
        _positionBuffer1 = null;
        _positionBuffer2 = null;
        _lastMesh = _tempMesh;
    }

    if (_positionBuffer1 == null || _positionBuffer1.count != _tempMesh.vertexCount)
    {
        _positionBuffer1?.Dispose();
        _positionBuffer1 = new ComputeBuffer(_tempMesh.vertexCount, 12);
    }

    if (_positionBuffer2 == null || _positionBuffer2.count != _tempMesh.vertexCount)
    {
        _positionBuffer2?.Dispose();
        _positionBuffer2 = new ComputeBuffer(_tempMesh.vertexCount, 12);
        CopyVerticesToBuffer(_tempMesh, _positionBuffer2, offset);
    }

    return CopyVerticesToBuffer(_tempMesh, _positionBuffer1, offset);
}

---

🧪 Optional: Use Unity’s Application.quitting to clean up (for non-MonoBehaviour scenarios)

void OnEnable()
{
    Application.quitting += OnAppQuit;
}

void OnDisable()
{
    Application.quitting -= OnAppQuit;
    OnAppQuit();
}

private void OnAppQuit()
{
    _positionBuffer1?.Dispose();
    _positionBuffer2?.Dispose();
}

---

✅ Summary

To fix the leak:

• Always dispose of ComputeBuffers when they are no longer needed.
• Ensure cleanup in OnDestroy() or via lifecycle management.
• Be careful with allocating buffers conditionally without an eventual release path.

Let me know if you’d like help converting this to a more robust buffer pool or persistent compute buffer system.

You

Often this fluid sim produces an empty velocity field, even if the external velocity field is not empty.

When i quit and reopen the editor, the problem disappears.

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")]
  public ADVECTION m_advectionType = ADVECTION.NORMAL;
  public int m_iterations = 10;
  public float m_vorticityStrength = 1.0f;

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

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

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

  [Header("Input Parameters")]
  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")]
  public bool enableBuoyancy = false;
  public bool enableTemperature = false;
  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]
  [Range(0,100)] public float velocityFieldAmount;
  [Range(0,100)] public float densityFieldAmount;
  [Range(0.00f,2)] public float boundaryVelocityThreshold;
  [Space]
  public bool continuousDensityInjection;
  public float injectionInterval = 1;
  [Space]
  public Vector3 pointVelocityPosition;
  public Vector3 pointVelocityDirection;
  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

Thanks for sharing your full SmokeFluidSim class. Based on your description and code, the issue where the fluid sim produces an empty velocity field even when the external velocity field is not empty, and only resolves when restarting the editor, is very likely due to GPU resource state corruption or uninitialized render textures in the Unity editor environment.

---

🔍 Diagnosis Summary

• Your compute shader uses externalVelocityField, which is a RenderTexture.
• If externalVelocityField is not properly initialized or populated (e.g., all zeros or unbound), your ApplyVelocityField step does nothing useful.
• In Editor mode ([ExecuteAlways]), resources like RenderTextures are not always serialized correctly, especially when they’re updated by external scripts or shaders.
• Restarting the editor clears and reinitializes all GPU resources, which “fixes” the issue temporarily — a telltale sign of a stale or uninitialized GPU buffer/texture.

---

✅ What You Should Do

1. Validate externalVelocityField in code

In ApplyVelocityField, add sanity checks and log warnings:

private void ApplyVelocityField(float dt, float amount, Texture velocityField, Vector3 pVelPos = default, Vector3 pVelDir = default, float pVelMag = 0)
{
    if (velocityField == null)
    {
        Debug.LogWarning("externalVelocityField is null – skipping ApplyVelocityField.");
        return;
    }

    if (!(velocityField is RenderTexture rt) || !rt.IsCreated())
    {
        Debug.LogWarning("externalVelocityField is not created or is not a RenderTexture – skipping.");
        return;
    }

    // Rest of method...
}

---

2. Force creation of external textures

Make sure the texture is initialized in code before first use, especially if set externally in-editor:

private void EnsureExternalTextures()
{
    if (externalVelocityField != null && !externalVelocityField.IsCreated())
        externalVelocityField.Create();

    if (externalDensityField != null && !externalDensityField.IsCreated())
        externalDensityField.Create();
}

Call this in Start() or Update():

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

    EnsureExternalTextures();
    ...
}

---

3. Rebind textures explicitly in Update

Sometimes in the editor, binding fails silently. You can force a refresh by rebinding the textures every few frames or during validation/debug builds:

#if UNITY_EDITOR
if (Time.frameCount % 60 == 0)
{
    Shader.SetGlobalTexture("_DebugVelocityField", externalVelocityField);
}
#endif

---

4. Add fallback velocity in shader or CPU

If the external field fails, you may want a backup input so the sim doesn’t stall:

if (externalVelocityField == null || !externalVelocityField.IsCreated())
{
    ApplyImpulse(dt, pointVelocityMagnitude, m_velocity);
}

---

5. Editor-only safeguard for [ExecuteAlways]

Even though you’re not updating in edit mode (!Application.isPlaying), the RenderTexture could still be invalidated outside of playmode. Add an OnValidate() method:

private void OnValidate()
{
    EnsureExternalTextures();
}

---

🧪 Additional Debug Ideas

• Use Graphics.Blit or a RawImage in the UI to visualize externalVelocityField in runtime to confirm it contains meaningful data.
• Add a debug log in OnVelocitySolved to check if the velocity buffer is all zeroes.
• Inspect the compute shader kernel that reads the velocity field — it might be sampling outside bounds if texture coordinates aren’t normalized or if 3D texture access is used incorrectly.

---

✅ TL;DR Fix Summary

• Add checks like !externalVelocityField.IsCreated() before using it.
• Recreate RenderTextures if not initialized.
• Ensure they’re populated with meaningful data.
• Use OnValidate() and Start() to call a texture sanity method like EnsureExternalTextures().

Let me know if you want help debugging the compute shader side too. A single misplaced sampling coordinate in HLSL could also result in a blank field.

You

This is the computeshader #pragma kernel ApplyVelocityField

#define NUM_THREADS 8 #include ”../ShaderUtils.hlsl”

float _Amount, _DeltaTime; float4 _Size;

// Bounds float3 minCorner; float3 boundsSize;

float3 _PointVelPosition; float3 _PointVelDirection; float _PointVelMagnitude;

Texture3D _VelocityField;

RWStructuredBuffer _Write; StructuredBuffer _Velocity;

[numthreads(NUM_THREADS,NUM_THREADS,NUM_THREADS)] void ApplyVelocityField(uint3 id : SV_DispatchThreadID) { // 3D Index to 1D Index int idx = id.x + id.y_Size.x + id.z_Size.x*_Size.y;

float3 oldVelocity = _Velocity[idx];

float3 pointV = 0;
///////////////////////////////////////
/// POINT VELOCITY
/*
// Convert Voxel Coordinates to Space Coordinates and Calculate distance to Force Source
float3 pos = toNormalizedCoordinates(_PointVelPosition,boundsSize, minCorner);

pos = id/(_Size.xyz-1.0f) - pos;


// Squared Magnitude
float mag = pos.x*pos.x + pos.y*pos.y + pos.z*pos.z;

float radius = 0.01f;

// Squared Radius
float rad2 = radius*radius;

// Gaussian Magnitude
float amount = exp(-mag/rad2) * _PointVelMagnitude * _DeltaTime;
pointV = normalize(_PointVelDirection) * amount;
*/

///////////////////////////////////////
/// FIELD VELOCITY
float3 rawVelocity = _VelocityField[id].xyz ;
rawVelocity *= step(0.5, length(rawVelocity));

///////////////////////////////////////
/// COMBINED VELOCITIES
float3 newVelocity = (rawVelocity * _Amount * _DeltaTime) + pointV;

// Additive velocity blending
_Write[idx] = oldVelocity + newVelocity;

}

ChatGPT

Thanks for sharing the compute shader. This clarifies a lot — and it strongly supports the earlier hypothesis: the velocity field is often empty because the shader isn’t receiving valid values from _VelocityField. Let’s walk through the problems and the likely cause of the empty velocity field issue:

---

🧨 Critical Problems in the Shader

🔸 1. No Texture3D Sampling Safety or Validity Checks

You sample directly with:

float3 rawVelocity = _VelocityField[id].xyz;

But:

• Texture3D access with tex[id] requires the texture to be fully initialized.
• In Unity, RenderTextures must be explicitly marked as volume (3D), and their enableRandomWrite flag must be true.
• If the 3D texture is not valid, this line returns zeros silently (or garbage).

Fix: Add validity checks on CPU and shader-side bounds checks if necessary.

---

🔸 2. No Bounds Checks on id Access

You’re assuming id is always in bounds of _VelocityField. But if externalVelocityField is not actually a Texture3D (e.g., accidentally created as a 2D or 2DArray), this silently fails or returns black/zero.

---

🔸 3. Incorrect or Missing Texture Format

If the texture is created without a format compatible with float4 sampling, this will silently zero out all samples. You should ensure it’s created like this:

RenderTexture rt = new RenderTexture(sizeX, sizeY, 0)
{
    dimension = TextureDimension.Tex3D,
    volumeDepth = sizeZ,
    enableRandomWrite = true,
    format = RenderTextureFormat.ARGBFloat
};
rt.Create();

---

🔸 4. Threshold Line Filters Out Small Values

This line suppresses small velocity vectors:

rawVelocity *= step(0.5, length(rawVelocity));

That means:

• Anything below length 0.5 is discarded.
• If _VelocityField values are small (e.g., normalized vectors, flow noise), they all get zeroed.

🧠 Fix: Remove or tweak this line unless absolutely needed. Try:

// rawVelocity *= step(0.5, length(rawVelocity)); // ← likely too aggressive
rawVelocity *= saturate(length(rawVelocity) * 2); // mild dampening

---

✅ Suggested Fixes

🔧 Shader Changes

[numthreads(NUM_THREADS,NUM_THREADS,NUM_THREADS)]
void ApplyVelocityField(uint3 id : SV_DispatchThreadID)
{
    int idx = id.x + id.y*_Size.x + id.z*_Size.x*_Size.y;

    float3 oldVelocity = _Velocity[idx];

    float3 rawVelocity = float3(0, 0, 0);

    // Make sure id is in bounds (sanity check)
    if (id.x < _Size.x && id.y < _Size.y && id.z < _Size.z)
    {
        rawVelocity = _VelocityField[id].xyz;

        // Avoid discarding too much — this line may be too strict
        rawVelocity *= saturate(length(rawVelocity) * 2); // gentle falloff
    }

    float3 pointV = 0; // (Optional: enable point force)

    float3 newVelocity = (rawVelocity * _Amount * _DeltaTime) + pointV;
    _Write[idx] = oldVelocity + newVelocity;
}

---

✅ Unity C# Side: Texture Setup Sanity

Before using externalVelocityField, check:

if (externalVelocityField != null)
{
    if (!externalVelocityField.IsCreated())
        externalVelocityField.Create();

    if (externalVelocityField.dimension != UnityEngine.Rendering.TextureDimension.Tex3D)
        Debug.LogWarning("externalVelocityField is not a Texture3D!");

    if (!externalVelocityField.enableRandomWrite)
        Debug.LogWarning("externalVelocityField does not have random write enabled!");

    if (externalVelocityField.format != RenderTextureFormat.ARGBFloat)
        Debug.LogWarning("externalVelocityField format may be incompatible!");
}

---

🧪 Debug Ideas

• Set _Amount = 1, _DeltaTime = 1, and manually fill _VelocityField with known data.
• Temporarily bypass the velocity threshold in the shader to confirm the data path.
• Log some pixel values in the texture using Graphics.CopyTexture() → Texture3D.GetPixelData.

---

✅ TL;DR – What’s Likely Causing the Issue?

1. Unity not initializing externalVelocityField correctly in editor.
2. Compute shader thresholds (step) filtering out small vectors.
3. Texture dimension or format mismatch.
4. No runtime fallback when the field is null or invalid.

---

If you’d like, I can give you a texture creation helper to make sure externalVelocityField is always initialized correctly. Let me know.

You

When I ran it, I got empty velocity field for the first 5-6 frames. could this early exit mess up the entire algorithm ?

ChatGPT

Yes, getting an empty velocity field in the first 5–6 frames can absolutely mess up the entire fluid simulation — especially for iterative solvers like yours that evolve the field over time using previous results. Here’s why and what you should do:

---

⚠️ Why This Happens

Your sim relies on velocity and density advection, pressure solving, and projection steps that accumulate and modify previous frame data. If the velocity field is:

• Zero initially (first few frames),
• ExternalVelocityField is missing or empty (e.g., delayed initialization),
• Then: m_velocity remains zero, so all steps like advection, vorticity, and pressure calc produce no meaningful motion.

---

🔁 Why It Stays Broken After That

Because most fluid sim steps are in-place and time-integrated, early zeros can:

• Prevent meaningful advection of smoke/density — because there’s no velocity to move anything.
• Cause zero divergence, so pressure solver applies nothing.
• Confinement & buoyancy become no-ops, since there’s no vorticity or temperature/velocity imbalance.
• Even when externalVelocityField starts providing data after a few frames, the internal buffers have already been “poisoned” by zeros.

---

✅ How to Fix It

1. Delay simulation until external field is ready

In Update():

if (externalVelocityField == null || !externalVelocityField.IsCreated())
{
    Debug.LogWarning("Waiting for externalVelocityField to be ready...");
    return; // Skip sim until field is valid
}

You can combine that with:

if (firstValidFrameTime < 0 && externalVelocityField.IsCreated())
    firstValidFrameTime = Time.time;

---

2. Provide a fallback (e.g., small noise velocity)

Temporarily add a basic fallback in the compute shader:

if (length(rawVelocity) < 0.01f)
{
    rawVelocity = float3(0.01f, 0.05f, 0.0f); // tiny starter impulse
}

This gets the simulation “unstuck” even if the external field is late.

---

3. Detect and reset zeroed internal fields

If you want to catch and correct a dead state later:

bool IsVelocityDead()
{
    // Quick heuristic: if no OnVelocitySolved events or internal velocity average is near zero
    // you could read back a few buffer values here (costly, but useful for debugging)
    return false; // implement with a ComputeBuffer readback if needed
}

---

4. Visual debugging: expose field activity

In the editor, log or display:

• External field activity: Graphics.CopyTexture + Texture3D.GetPixelData.
• Sim buffer activity: extract and display total velocity magnitude per frame (e.g., with a debug ComputeShader that sums the buffer).

---

✅ TL;DR

Yes — an empty velocity field for the first few frames can prevent your sim from ever initializing properly, and since it builds iteratively, it will look like the sim is broken even after the data shows up.

Recommended fix: skip Update() until externalVelocityField.IsCreated() && HasMeaningfulData().

Want help writing a lightweight buffer sampling utility to check for “dead” velocity values?

You

I see a “flash” on my vfx debug grid when the game starts, and then nothing. 6 frames of no velocity field (skipping the execution) but then nothing. even force injecting a velocity doesnt fix the issue

ChatGPT

Thanks for the extra context — the “flash then nothing” behavior combined with 6 skipped frames and no recovery even after forced velocity injection points to a state corruption or uninitialized field propagation issue. Let’s break it down clearly and give you actionable steps.

---

🧠 What’s Happening

Your system:

1. Depends on temporal integration (fluid builds on previous frame).
2. Skips simulation for 5–6 frames due to missing or invalid externalVelocityField.
3. During this time, buffers (m_velocity, m_density, etc.) are:
   • Never written to (left at their default/zero state).
   • Used for advection and pressure solves — resulting in no motion.

Then:

• Even forcing a velocity injection adds data to a buffer, but the entire field is already “dead”:
  • There’s no swirling (zero vorticity),
  • No meaningful divergence or pressure response,
  • No non-zero advection direction.

💥 The “flash” is likely the initialization or one good frame before the field goes silent.

---

✅ Fix Strategy

🔧 1. Don’t skip simulation — initialize gracefully instead

If you skip Update() during the first 6 frames, the buffers are never written. Instead:

Replace return with fallback injection during early frames.

bool velocityFieldValid = externalVelocityField != null && externalVelocityField.IsCreated();

if (!velocityFieldValid && Time.frameCount < 10)
{
    Debug.LogWarning("Velocity field not ready — injecting fallback velocity");
    InjectFallbackVelocity(); // (see below)
}

---

🌀 2. Inject fallback velocity field manually

To un-stall the sim if externalVelocityField fails:

private void InjectFallbackVelocity()
{
    Vector3 center = m_size / 2f;

    pointVelocityPosition = center;
    pointVelocityDirection = Vector3.up;
    pointVelocityMagnitude = 1f;

    ApplyVelocityField(TIME_STEP, 1.0f, null, pointVelocityPosition, pointVelocityDirection, pointVelocityMagnitude);
}

Inside ApplyVelocityField(), update your logic so it still runs even if velocityField == null.

---

🔄 3. Clear & reinitialize sim state if velocity field is dead

If you detect a dead field (velocity all zero), forcibly reset the sim:

private bool IsVelocityFieldDead()
{
    // Sample 1 or 2 values from the velocity buffer (READBACK is slow, so use sparingly)
    // Ideally, write a compute shader that checks magnitude and flags if "dead"
    return false; // placeholder
}

private void RecoverFromDeadState()
{
    Debug.LogWarning("Sim is dead. Reinitializing.");

    // Re-initialize internal buffers
    OnDestroy(); // cleanup
    Start();     // rebuild buffers
}

You can trigger this after a few seconds of inactivity or no change in buffer state.

---

🎥 4. Visual debug of velocity field

If you’re using a debug grid or VFX Graph:

• Confirm you’re visualizing m_velocity[WRITE] or [READ] properly (e.g., not a stale or unbound buffer).
• Add a frame count / tick debug line to ensure Update() is running continuously.

---

✅ Summary

Problem	Fix
External velocity missing for 5–6 frames	Inject fallback during init instead of skipping
Velocity field becomes inert permanently	Inject backup force OR reinitialize buffers
Flash and then no motion	Caused by 1–2 good frames, then broken state settles in
Forced velocity injection doesn’t help	Because field is already mathematically dead (no divergence, vorticity, or meaningful gradients)

---

🛠 Want help with…

• A compute shader that scans your velocity buffer for near-zero magnitude?
• A debug UI overlay showing buffer activity?
• An auto-reset mechanism after a few seconds of low motion?

Let me know and I can mock one up for you.

You

I observe that the only place with velocity is concentrated at the corners of the domain, like dots

ChatGPT

Ah — velocity concentrating only at the corners is a very strong clue, and it points to one or more of the following core issues:

---

🚨 Likely Causes

✅ 1. Wrong coordinate normalization when sampling external velocity field

Your compute shader might be reading from the wrong part of _VelocityField, or sampling garbage data, because:

• You’re doing rawVelocity = _VelocityField[id].xyz; directly.
• id is an integer voxel index, but Texture3D requires normalized coordinates if you’re not using Load().

If _VelocityField is a 3D RenderTexture bound as Texture3D<float4>, you must use Load(int3), not direct indexing with non-normalized id unless you’re sure of addressability.

Otherwise, data might wrap or only show up in a few texels — typically corners.

---

✅ 2. Wrong RWStructuredBuffer/StructuredBuffer size alignment

Your idx = id.x + id.y * _Size.x + id.z * _Size.x * _Size.y; is fine, but if your buffer or texture sizes don’t match the dispatch dimensions or aren’t cleared properly, it causes corner-only activation.

Especially if:

• The field is size (N, N, N) but you’re dispatching something else.
• Or your _Size vector is incorrect at dispatch time.

---

✅ 3. Obstacles buffer zeroing out the domain

You’re passing an m_obstacles buffer to most shaders.

If that buffer marks everything except the corners as obstacles, it could be zeroing out velocity update in most of the domain. The result? Velocity only propagates in non-obstacle zones — possibly just edges or corners.

---

✅ 4. Corner-only effects from threshold logic

You had this in your compute shader:

rawVelocity *= step(0.5, length(rawVelocity));

This suppresses everything under length 0.5, which:

• Could clip away most of the field,
• Leaving only areas where the data is at full scale (corners, if that’s how your source texture is initialized).

---

✅ What You Should Do

🔍 1. Use Load() for 3D textures

Update your sampling to:

int3 texCoords = int3(id.x, id.y, id.z);
float4 raw = _VelocityField.Load(texCoords);
float3 rawVelocity = raw.xyz;

✅ Load() guarantees unfiltered, coordinate-aligned access.

---

🔍 2. Visualize _VelocityField content

Quick test in editor or runtime:

// CPU-side visualization/debug
RenderTexture rt = externalVelocityField;
Texture3D debugCopy = new Texture3D(rt.width, rt.height, rt.volumeDepth, TextureFormat.RGBAFloat, false);
Graphics.CopyTexture(rt, debugCopy);
Color sample = debugCopy.GetPixel(0, 0, 0); // or sample corners and center

Debug.Log("Velocity sample at (0,0,0): " + sample);

Check that most values aren’t just zero or garbage.

---

🔍 3. Check obstacle buffer

Log or visualize m_obstacles. Try disabling it temporarily by skipping obstacle logic:

// Comment out obstacle usage
// m_applyAdvect.SetBuffer(... "_Obstacles", m_obstacles);

If behavior changes drastically, your obstacle buffer is incorrectly masking the domain.

---

🔍 4. Remove/adjust the threshold

Temporarily disable:

// rawVelocity *= step(0.5, length(rawVelocity));

or replace with:

rawVelocity = rawVelocity; // allow all values

---

🧪 Want a Test Shader?

Here’s a quick replacement shader for debug purposes:

[numthreads(8, 8, 8)]
void ApplyVelocityField(uint3 id : SV_DispatchThreadID)
{
    int idx = id.x + id.y * _Size.x + id.z * _Size.x * _Size.y;

    float3 rawVelocity = float3(0, 0, 0);
    if (id.x < _Size.x && id.y < _Size.y && id.z < _Size.z)
    {
        rawVelocity = _VelocityField.Load(int3(id)).xyz;
    }

    _Write[idx] = rawVelocity * _Amount * _DeltaTime;
}

---

✅ TL;DR

Symptom	Likely Cause
Velocity only in corners	Bad 3D texture access (non-normalized coordinates or incorrect id)
One-frame “flash”	Only first dispatch hits good memory
Nothing propagates	Obstacle buffer or velocity buffer is all zeros
Threshold blocks everything	That step() line suppresses meaningful values

---

Let me know if you want a complete validation helper to dump field content or visualize it in a debug mesh/grid.

You

even now that im writing only dummy values directly to the buffer, i still get this problem

ChatGPT

Thanks — this detail is crucial.

Even writing dummy values directly into the buffer still results in velocity only at the corners.

This strongly suggests that the issue is not with external velocity field sampling, but with:

---

💥 The Real Problem: Your Dispatch or Thread Group Setup

You’re likely dispatching your compute shader with dimensions that don’t cover the whole buffer, so only some corner regions get written.

This is a classic pitfall when using compute shaders in Unity.

---

✅ Let’s Re-check Dispatch

In your C# code (e.g. ApplyVelocityField()), you dispatch like this:

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

But this only works if m_size.x, m_size.y, and m_size.z are exact multiples of NUM_THREADS.

If they’re not, then:

• Only part of the domain gets processed.
• The rest of the buffer is untouched → all zeros.
• Visually, this looks like only corners or edges are active, because those voxels sit at low indices in each axis.

---

🧠 Example

If m_size.x = 130 and NUM_THREADS = 8:

130 / 8 = 16 // integer division → truncates
16 * 8 = 128 < 130

So only the first 128x128x128 voxels get processed — and the rest are skipped.

---

✅ Fix: Use Mathf.CeilToInt() to cover full domain

Update all your dispatch calls like this:

int x = Mathf.CeilToInt(m_size.x / (float)NUM_THREADS);
int y = Mathf.CeilToInt(m_size.y / (float)NUM_THREADS);
int z = Mathf.CeilToInt(m_size.z / (float)NUM_THREADS);

m_applyVelocityField.Dispatch(0, x, y, z);

Do this for every dispatch call in your sim code.

---

🧪 Quick Debug Test

To confirm the dispatch problem:

1. In the shader, write dummy data:

   _Write[idx] = float3(1, 0, 0);

2. In Unity, set the dispatch group size to 1, 1, 1 temporarily, and log how many threads actually run.

3. Visualize the buffer — you’ll see it only partially written.

---

✅ TL;DR

Symptom	Root Cause	Fix
Velocity only at corners	Dispatch size too small (truncates coverage)	Use Mathf.CeilToInt() when dispatching
Dummy values don’t fill field	Not all threads run	Check dispatch dimensions vs thread count

---

Let me know if you’d like a utility method to automatically validate dispatch coverage or log incomplete thread launches. This issue is subtle but incredibly common — you’re very close to solving it.

You

but if i close unity and open it again, it works. so it’s not this

ChatGPT

You’re absolutely right to challenge that — and the fact that it works after restarting Unity is a critical clue that shifts the diagnosis.

---

🧠 What Does a Unity Restart Fix?

Restarting Unity resets:

• All GPU resources, including buffers and textures.
• Compute shader state, including thread group registration.
• Any dangling bindings, orphaned ComputeBuffers, or invalid RenderTextures.

That strongly suggests the real issue is not dispatch size, but:

---

🔥 ComputeBuffer or RenderTexture Corruption (Stale GPU Resource Binding)

Your simulation is likely using a stale or corrupted buffer/texture, which is only refreshed or correctly bound after a full editor restart. This explains why:

• You write dummy values → no visible effect.
• Velocity appears in corners → partially bound/initialized memory.
• Restart fixes it → Unity fully reinitializes all GPU memory.

---

✅ Root Causes to Investigate

1. ComputeBuffers Not Re-created After Domain Size Changes

If your m_width, m_height, or m_depth values change, but you don’t recreate the compute buffers (or dispose them properly), Unity will:

• Keep using the old buffer with mismatched size.
• Cause incorrect indexing, broken data, or “corner-only” writes.

🧠 Fix: detect size changes and reallocate buffers.

void ValidateBuffer(ref ComputeBuffer buffer, int count, int stride)
{
    if (buffer == null || buffer.count != count)
    {
        buffer?.Release();
        buffer = new ComputeBuffer(count, stride);
    }
}

Call this every frame in debug/dev builds.

---

2. Buffers Not Released in OnDisable() or OnDestroy()

You only dispose your buffers in OnDestroy() — but in edit mode, that method may not be called consistently.

Fix: add cleanup to OnDisable() or OnApplicationQuit():

private void OnDisable()
{
    ReleaseBuffers();
}

private void ReleaseBuffers()
{
    void SafeRelease(ComputeBuffer buffer)
    {
        if (buffer != null)
        {
            buffer.Release();
        }
    }

    SafeRelease(m_density[READ]);
    SafeRelease(m_density[WRITE]);
    SafeRelease(m_velocity[READ]);
    SafeRelease(m_velocity[WRITE]);
    // ... and so on for all buffers
}

---

3. Multiple compute shaders writing to same buffer with bad bindings

If your simulation (or other systems) rebinds _Write or _Velocity incorrectly or asynchronously, it may leave the GPU in a bad state.

Add logging to every SetBuffer/SetTexture call to track accidental re-use.

---

4. ExternalVelocityField is invalid/empty for the first few frames

You’re already aware of this. Even if it becomes valid later, your internal velocity buffer is already dead by then.

🧠 Fix: instead of skipping simulation when external field is null — still inject dummy velocity (to keep the system warm).

---

✅ Sanity Plan

Here’s what I recommend you do step-by-step:

1. Add logging to buffer creation:

   Debug.Log($"Creating buffer: velocity size {SIZE}");

2. Verify that m_velocity is valid immediately after play:

   • Dump m_velocity[READ].count.
   • Confirm m_velocity[WRITE] != null.

3. Force-release and recreate all buffers in OnEnable() if not valid.

4. Temporarily remove all logic relying on externalVelocityField, and just write constant velocity in the shader. If it still breaks until a restart — it’s 100% a stale buffer.

---

✅ Final Fix Summary

Symptom	Real Cause	Fix
Sim “comes alive” after Unity restart	GPU buffers/textures are stale or partially bound	Recreate all ComputeBuffers in OnEnable() and OnDisable()
Dummy writes don’t show	Writing into stale or wrongly-sized ComputeBuffer	Validate buffer size every frame (in dev)
Velocity only in corners	Old memory accessed due to invalid dispatch or uninitialized buffer	Ensure correct dispatch and buffer size alignment

---

Would you like a helper class that automatically manages and recreates buffers based on size changes? I can generate a reusable one for your project.

You

could this be the issue?

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

ChatGPT

Excellent question — and yes, that line could definitely be the issue if the wrong buffers are being read/written due to uncoordinated or unintended Swap() calls.

Let’s break this down clearly:

---

🔁 Your Swap() Method

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

This swaps the READ and WRITE buffers in place.

That’s totally valid if and only if:

• It’s called once and only once per simulation step, and
• It’s called after writing to WRITE and before the next read.

---

🚨 How This Can Break Things

1. Double Swap() in the same frame

If you accidentally call Swap(buffer) twice in a frame:

• READ and WRITE are back where they started.
• You write into stale data.
• Velocity appears to freeze or decay instantly.

2. Calling Swap() too early or too late

If you swap:

• Before you’ve written to WRITE, then the upcoming compute shader will read from what was just a blank write target.
• After a read that expected the latest data, you break the time step.

3. Swap logic out of sync between velocity and other buffers

If you call Swap(m_velocity) but not Swap(m_density), you can get stale or mismatched data, which breaks projection, pressure solving, and advection.

---

✅ What to Do

🔍 Step 1: Add Debug Logs to Track Buffer State

Add:

private static void Swap(ComputeBuffer[] buffer, string name = "")
{
    Debug.Log($"Swapping {name}: READ becomes WRITE, WRITE becomes READ");
    (buffer[READ], buffer[WRITE]) = (buffer[WRITE], buffer[READ]);
}

Then change your calls to:

Swap(m_velocity, "velocity");
Swap(m_density, "density");

---

🔍 Step 2: Track Per-Frame State

Track frame progression and ensure every buffer:

• Is written into WRITE,
• Is swapped exactly once,
• Is then read from READ on next use.

You could even add a bool hasSwapped per buffer for debugging to ensure it doesn’t get swapped twice.

---

🔍 Step 3: Check All Swap() Call Sites

Make sure Swap() is only called:

• At the end of each compute operation using _Write.
• Once per operation.

Examples:

✅ Good:

ApplyAdvection(); // writes to WRITE
Swap(m_velocity); // commit WRITE to READ

🚫 Bad:

Swap(m_velocity); // before writing? NO
ApplyAdvection(); // now writes into what was just READ

---

🔍 Step 4: Confirm Velocity Buffer Is Never Stale

You can verify visually by outputting velocity magnitude to a debug texture or console log:

• If velocity suddenly drops to zero after Swap(), you know you’re reading stale data.

---

✅ TL;DR

Yes — your Swap() function is not broken itself, but:

• If you’re calling it in the wrong place, or
• Calling it too many times per frame, or
• Swapping only some buffers and not others,

then your simulation will break, possibly leaving only corner or partial data (as you observed).

---

Would you like help refactoring your simulation update loop to guarantee correct buffer usage and swaps? I can show you a pattern that isolates write-read-swap clearly.

You

the problem starts after domain reload

ChatGPT

💡 That is extremely helpful.

When you say:

“The problem starts after domain reload”

You’re referring to Unity’s Domain Reload — which occurs when:

• Scripts are recompiled
• You enter Play Mode (if Domain Reload is enabled in Editor settings)
• Or exit Play Mode

This gives us a sharp focus:

---

🔥 Unity Domain Reload: What It Actually Does

During a domain reload, Unity:

What happens	Effect
C# static variables are reset	Any static buffers, flags, or Swap() logic can break
Serialized fields survive	But GPU resources like ComputeBuffer do not
GPU objects (ComputeBuffers, RenderTextures) are not automatically re-created	Leads to invalid memory or zero-filled buffers
OnEnable() and Start() are re-called (if in Play mode)	Can help if buffer setup is clean
But objects that were not destroyed (e.g., via DontDestroyOnLoad) might retain invalid GPU state	Stale GPU data persists silently

---

✅ Key Suspect: ComputeBuffer pointers go stale after domain reload

🔻 Common case:

• Unity reloads your script.
• Your static constants like READ = 0 and WRITE = 1 are reinitialized.
• But the ComputeBuffer[] arrays might not be reallocated properly.
• You think you’re writing to WRITE, but that’s now pointing at a null or garbage buffer.

---

✅ How to Fix It

1. Always recreate ComputeBuffers after domain reload

In OnEnable(), call a method like:

private void EnsureBuffersInitialized()
{
    int SIZE = m_width * m_height * m_depth;
    int stride3f = sizeof(float) * 3;
    int stride1f = sizeof(float);

    void Init(ref ComputeBuffer buffer, int count, int stride)
    {
        if (buffer != null && buffer.count == count)
            return;

        buffer?.Release();
        buffer = new ComputeBuffer(count, stride);
    }

    Init(ref m_velocity[READ], SIZE, stride3f);
    Init(ref m_velocity[WRITE], SIZE, stride3f);
    // repeat for all buffers
}

Call this in OnEnable() and optionally after any domain-sensitive event, like PlayMode state change.

---

2. Ensure all ComputeBuffer[] arrays are recreated (not reused)

If your m_velocity = new ComputeBuffer[2] is done only in Start() and not again after a domain reload — it’s now pointing at garbage.

You need to recreate the array and the inner buffers in OnEnable():

m_velocity = new ComputeBuffer[2];
m_velocity[READ] = new ComputeBuffer(SIZE, stride3f);
m_velocity[WRITE] = new ComputeBuffer(SIZE, stride3f);

---

3. Detect and log buffer invalid state

You can add a debug check like:

void ValidateBuffers()
{
    if (m_velocity == null || m_velocity[READ] == null || m_velocity[WRITE] == null)
    {
        Debug.LogWarning("Velocity buffers are null after domain reload!");
    }
}

Call this in Update() during dev.

---

4. Disable Domain Reload (if you want quick test stability)

Temporarily (Editor only):

• Go to Edit → Project Settings → Editor
• Uncheck Enter Play Mode Options → Reload Domain

This can help you confirm whether domain reload is causing the issue. But don’t rely on this permanently — fix your init logic instead.

---

✅ TL;DR

Symptom	Cause	Fix
Velocity only in corners after domain reload	ComputeBuffer[] arrays or pointers are stale/null	Recreate all buffers in OnEnable()
Only works after Unity restart	Restart forces full GPU memory reinit	Mimic that in your buffer setup
Static values (like READ, WRITE) reset	Buffers now out of sync with logic	Keep logic centralized and reset-safe
Swap() operates on null or old buffer refs	Leads to broken or partial simulation	Add validation + logs

---

Would you like a plug-and-play helper class that auto-manages all buffer creation and disposal safely across domain reloads? I can write one for you.

You

i’m releasing and recreating all buffers

ChatGPT

Thanks — since you’re already releasing and recreating all buffers, and still experiencing issues after domain reload, yet it works after restarting Unity, we need to dig into what Unity doesn’t reset on domain reload but does reset on full editor restart.

This narrows us into some likely suspects:

---

✅ Updated Diagnosis Checklist (Post-Domain Reload)

You’ve ruled out:

• Improper Swap() logic (used correctly)
• ComputeBuffer not being recreated
• External velocity being totally missing
• Dispatch thread size being too small
• Forced buffer writes still result in no velocity

What’s left?

---

🔍 Remaining Likely Causes

🔸 1. ComputeBuffer array (ComputeBuffer[]) is retained but inner elements are null

When Unity reloads the domain:

• The m_velocity = new ComputeBuffer[2] call might be skipped if it was in Start() or guarded by Application.isPlaying.
• The array itself remains allocated.
• But the elements inside are null, so later calls to SetBuffer silently fail.

✅ Fix: Always reallocate ComputeBuffer[] arrays themselves too.

private void OnEnable()
{
    var SIZE = m_width * m_height * m_depth;
    m_velocity = new ComputeBuffer[2];
    m_velocity[READ] = new ComputeBuffer(SIZE, sizeof(float) * 3);
    m_velocity[WRITE] = new ComputeBuffer(SIZE, sizeof(float) * 3);
}

Even if you’re releasing them in OnDestroy(), the array container itself must be replaced.

---

🔸 2. Stale shader bindings or incorrect kernel state

When Unity reloads the domain:

• ComputeShader.SetBuffer bindings may be lost (they are per-dispatch context).
• But the shader doesn’t error — it just dispatches silently with stale bindings.

✅ Fix: Always call SetBuffer, SetTexture, and SetVector every frame before every Dispatch().

Don’t assume they’re persistent.

Example:

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

✅ Call this before every single dispatch, even if you’ve set them before.

---

🔸 3. Corrupted RenderTexture from externalVelocityField

• After domain reload, RenderTextures look valid but are internally invalid.
• You may have a RenderTexture object that returns true for IsCreated(), but fails silently in the GPU.
• Unity doesn’t fully reset the GPU until you quit the editor.

✅ Fix:

if (externalVelocityField != null && externalVelocityField.IsCreated())
{
    externalVelocityField.Release(); // Important!
    externalVelocityField.Create();  // Force reallocation
}

Do this at the beginning of play mode or after reload, especially if you don’t own the code that creates it.

---

🔸 4. Corrupted state in shared ComputeShader resource (e.g. from singleton)

If you’re assigning shaders like:

m_applyVelocityField = VoxelUtilsComputeResources.Instance.m_applyVelocityField.ComputeShader;

Then on domain reload:

• That Instance may be a zombie singleton with invalid references.
• The shader object may not match your actual project asset anymore.

✅ Fix:

• Reassign all shaders in OnEnable() using Resources.Load or serialized fields.
• Avoid using Singleton.Instance for GPU stuff unless it’s domain-reload safe.

---

✅ Add Immediate Debug Hooks

Add this in ApplyVelocityField():

if (m_velocity[READ] == null || m_velocity[WRITE] == null)
{
    Debug.LogError("Velocity buffer is null at dispatch time.");
}
else
{
    Debug.Log($"Dispatching velocity: readCount={m_velocity[READ].count}, writeCount={m_velocity[WRITE].count}");
}

And in the shader, write a visible constant like:

_Write[idx] = float3(1, 0, 0); // bright red

If that doesn’t appear: either dispatch is not happening, or buffer is invalid.

---

✅ Final Checklist

Item	Must Do
ComputeBuffer[] reallocated	✅
Each [READ] and [WRITE] re-created	✅
All SetBuffer/SetTexture calls reissued every frame	✅
RenderTexture explicitly Release()d and Create()d	✅
Singletons reinitialized after reload	✅
Dummy GPU writes show up in visualization	✅
Add Debug.Logs to validate dispatch and buffer state	✅

---

Let me know and I’ll help you write a bulletproof post-domain-reload GPU resource manager if needed. Unity doesn’t make this part easy.

You

this seemed to fix it .

but how can I auto assign compute shaders if this failed ?

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;
  }

ChatGPT

Great to hear that the issue is resolved! 🎉
Now, regarding this part:

“How can I auto-assign compute shaders if this failed?”

That’s a solid follow-up — because Unity’s domain reload can cause singleton instances to go null, and as a result, VoxelUtilsComputeResources.Instance might silently return a broken or partially initialized object.

---

✅ Recommended Strategy: Fallback Auto-Assignment Using Resources.Load

Use Resources.Load<ComputeShader>("Path") as a fallback if the Instance-based assign fails or is null.

Here’s a safe, auto-recovering pattern:

private void OnEnable()
{
    AssignShader(ref m_applyImpulse, "Shaders/ApplyImpulse");
    AssignShader(ref m_applyAdvect, "Shaders/ApplyAdvect");
    AssignShader(ref m_computeVorticity, "Shaders/ComputeVorticity");
    AssignShader(ref m_computeDivergence, "Shaders/ComputeDivergence");
    AssignShader(ref m_computeJacobi, "Shaders/ComputeJacobi");
    AssignShader(ref m_computeProjection, "Shaders/ComputeProjection");
    AssignShader(ref m_computeConfinement, "Shaders/ComputeConfinement");
    AssignShader(ref m_computeObstacles, "Shaders/ComputeObstacles");
    AssignShader(ref m_applyBuoyancy, "Shaders/ApplyBuoyancy");
    AssignShader(ref m_applyVelocityField, "Shaders/ApplyVelocityField");
    AssignShader(ref m_applyDensityField, "Shaders/ApplyDensityField");
    AssignShader(ref m_applyCustomObstacles, "Shaders/ApplyCustomObstacles");
}

private void AssignShader(ref ComputeShader target, string resourcePath)
{
    if (target == null)
    {
        target = Resources.Load<ComputeShader>(resourcePath);
        if (target == null)
        {
            Debug.LogError($"Failed to auto-assign ComputeShader at Resources/{resourcePath}.compute");
        }
        else
        {
            Debug.Log($"Auto-assigned ComputeShader: {resourcePath}");
        }
    }
}

---

🧠 Important Notes

🗂️ 1. Shader Location

• All compute shaders must be placed under a Resources/ folder in your project.
• Example: Assets/Resources/Shaders/ApplyImpulse.compute

🧪 2. Load Once Only

This approach ensures:

• If the original VoxelUtilsComputeResources.Instance failed (domain reload issue),
• You still get valid shader references.

💡 3. Optional: Combine With Original Logic

If you’re confident VoxelUtilsComputeResources.Instance is valid most of the time, use:

var r = VoxelUtilsComputeResources.Instance;

AssignOrFallback(ref m_applyImpulse, r?.m_applyImpulse?.ComputeShader, "Shaders/ApplyImpulse");

And:

private void AssignOrFallback(ref ComputeShader target, ComputeShader candidate, string fallbackPath)
{
    if (candidate != null)
    {
        target = candidate;
    }
    else
    {
        AssignShader(ref target, fallbackPath);
    }
}

---

✅ TL;DR

Problem	Fix
Compute shaders go null after domain reload	Use Resources.Load<ComputeShader> as fallback
Instance references fail silently	Validate and auto-load with a helper
Maintain resilience without clutter	Wrap in AssignShader() or AssignOrFallback()

---

Let me know if you want a lightweight scriptable object resource loader to manage all of these automatically — it’s a good investment for GPU-heavy tools.

You

this actually didnt fix the issue

ChatGPT

Thanks for the update — and sorry that didn’t solve it. Since the problem persists after domain reload even with buffer re-creation and shader reassignment, we need to shift focus to deep GPU state invalidation, likely caused by Unity’s internal handling of ComputeBuffers, ComputeShaders, or RenderTextures during a domain reload in the Editor.

Let’s reset and dig deeper.

---

🧠 Let’s Recap the Facts

You’ve confirmed:

✅ Working After	❌ Broken After
Unity editor restart	Domain reload (Enter Play Mode)
Full buffer and shader recreation	Still broken
Dummy buffer writes	Still broken
External field removed / bypassed	Still broken
Velocity appears only in corners or not at all	Still broken

---

🔍 Most Likely Now: Stale/Corrupted Buffer State on the GPU

Here’s what happens under the hood:

• Unity destroys the C# objects for ComputeBuffer, but the underlying GPU memory might not be released correctly.
• If the buffer object is recreated on the same native pointer, and Unity’s internal compute pipeline isn’t fully flushed, you get:
  • Silent GPU faults (no errors, but invalid memory)
  • Partially working simulations (e.g., velocity only in corners)

This issue often slips past because it only happens when using structured buffers + domain reload, and not on editor restart.

---

✅ High-Confidence Fix Strategy

🔧 1. Force GPU memory purge on buffer recreate

Use Release() followed by explicit GC cleanup, before re-creating buffers:

void SafeRelease(ref ComputeBuffer buffer)
{
    if (buffer != null)
    {
        buffer.Release();
        buffer = null;
    }
}

Before reinitializing:

SafeRelease(ref m_velocity[READ]);
SafeRelease(ref m_velocity[WRITE]);
// repeat for all buffers
GC.Collect();
GC.WaitForPendingFinalizers();

💡 Why? This ensures the C# wrapper is collected before the GPU resource is reallocated — preventing Unity from aliasing invalid memory.

---

🔧 2. Recreate ComputeBuffer[] arrays and their contents

Even if you reassign the inner buffers, the array itself might retain stale object references after reload. Always do:

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

---

🔧 3. Insert Buffer State Sanity Check Before Dispatch

Before every dispatch, add:

if (m_velocity[READ] == null || !m_velocity[READ].IsValid())
{
    Debug.LogError("Velocity READ buffer is invalid before dispatch.");
}

.IsValid() is a Unity API to check GPU-side validity.

---

🔧 4. Force rebind all SetBuffer() calls immediately before dispatch

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

This is critical: even if you reassign the compute shader, the bindings must be refreshed every dispatch, since Unity does not persist SetBuffer bindings through reloads.

---

🔧 5. Force kernel refresh / shader re-import (if needed)

Sometimes the ComputeShader object itself becomes stale after reload. As a test:

Resources.UnloadAsset(m_applyVelocityField);
m_applyVelocityField = Resources.Load<ComputeShader>("Shaders/ApplyVelocityField");

---

🧪 Optional: Force full simulation reset post-domain reload

Add this:

[RuntimeInitializeOnLoadMethod]
static void OnRuntimeLoad()
{
    Debug.Log("RuntimeInitializeOnLoadMethod: Forcing GC and flush.");
    GC.Collect();
    GC.WaitForPendingFinalizers();
    // Optional: clear static flags or singleton state
}

---

✅ TL;DR Recovery Sequence (Safe for Domain Reload)

1. Release + null all buffers (no reuse!)
2. GC.Collect(); GC.WaitForPendingFinalizers();
3. Recreate ComputeBuffer[] arrays AND contents
4. Rebind ALL buffers/textures before EVERY dispatch
5. Use .IsValid() on buffers before dispatching
6. If still broken: unload and reload shaders from Resources

---

Would you like a full GpuBufferManager utility class that handles all this automatically (buffer recreation, GC sync, dispatch validation, etc.)? I can build that in one message.

You

read the above conversation and try to find a solution

ChatGPT

The “vanishing‑velocity” bug you see only after a domain reload is almost always caused by stale GPU resources that survive the C# reload but are no longer valid on the GPU.
Unity recreates the scripting domain, resets all static fields, and keeps the native memory for ComputeBuffer / RenderTexture objects alive. Any new managed handle you create might accidentally point to this half‑dead memory, and subsequent Dispatch calls quietly write into garbage, leaving only a few voxels (often the corners) with data.

Below is a bullet‑proof recovery strategy that has fixed this class of problems for many teams.

---

1  Why the problem appears only after Domain Reload

What Unity does on Domain Reload	Visible symptom	Source
Resets static fields & singletons, leaving their native resources orphaned	your resource locator VoxelUtilsComputeResources.Instance returns assets whose buffers are invalid	citeturn0search12
Does not actually free GPU memory for ComputeBuffer / RenderTexture objects	recreated buffers alias the same native pointer → partial / corrupt writes	citeturn0search0turn0search11
Drops all previous SetBuffer / SetTexture bindings on compute shaders	kernels run but read / write null	citeturn0search2turn0search5

A full editor restart flushes the GPU driver, so the simulation works again, masking the root cause.

---

2  Seven steps to make the simulation immune to reloads

2.1 Completely release the old buffers

void SafeRelease(ref ComputeBuffer buf)
{
    if (buf != null)
    {
        buf.Release();           // free GPU side
        buf = null;              // break managed reference
    }
}

Call SafeRelease for every buffer in OnDisable() and again just before recreating them in OnEnable(); then force a GC pass so Unity drops the orphaned native handles:

GC.Collect();
GC.WaitForPendingFinalizers();

Unity’s own docs recommend an explicit release + recreate when the scripting domain is rebuilt. citeturn0search6turn0search9

2.2 Recreate the array containers as well

After a reload m_velocity[READ] might be null, but the enclosing ComputeBuffer[] is still the old object. Always re‑instantiate the arrays:

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

2.3 Validate every buffer right before dispatch

void Validate(ComputeBuffer buf, string name)
{
    if (buf == null || !buf.IsValid())
        throw new InvalidOperationException($"{name} is not valid!");
}

ComputeBuffer.IsValid reliably detects zombie buffers. citeturn0search4

2.4 Re‑bind all buffers and textures every frame

Bindings are not persistent across reloads or shader recompiles.
Always call SetBuffer, SetTexture, SetVector, etc. immediately before each Dispatch. citeturn0search2

2.5 Force‑recreate external RenderTextures

If a RenderTexture crosses the C#/native boundary during reload it can become “created but unusable”. Do:

if (externalVelocityField != null)
{
    externalVelocityField.Release();
    externalVelocityField.Create();
}

after domain reload to guarantee a fresh GPU allocation. citeturn0search3

2.6 Refresh compute‑shader references safely

Replace the singleton lookup with a “try‑instance‑then‑fallback” loader:

private void AssignShader(ref ComputeShader target,
                          ComputeShader candidate,
                          string resourcesPath)
{
    target = candidate != null ? candidate
            : Resources.Load<ComputeShader>(resourcesPath);

    if (target == null)
        Debug.LogError($"Missing compute shader {resourcesPath}");
}

Resources.Load survives domain reload because Unity re‑indexes the Resources DB automatically. citeturn0search1

2.7 Run a post‑reload reset hook

[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterSceneLoad)]
static void AfterReload()
{
    // optional extra safety net
    GC.Collect();
    GC.WaitForPendingFinalizers();
}

Unity guarantees this method runs once every time the scripting domain is rebuilt. citeturn0search7

---

3  Minimal, reload‑safe buffer manager (drop‑in)

public sealed class GpuBuffer<T> : IDisposable where T : struct
{
    public ComputeBuffer Read  { get; private set; }
    public ComputeBuffer Write { get; private set; }

    readonly int stride;

    public GpuBuffer(int count, int stride)
    {
        this.stride = stride;
        Allocate(count);
    }

    public void Allocate(int count)
    {
        Release();
        Read  = new ComputeBuffer(count, stride);
        Write = new ComputeBuffer(count, stride);
    }

    public void Swap() => (Read, Write) = (Write, Read);

    public void Release()
    {
        Read?.Release();  Write?.Release();
        Read = Write = null;
    }

    public void Dispose() => Release();
}

Instantiate in OnEnable, Release in OnDisable.
Because allocation is centralized, you avoid mismatched Swap() calls and stale pointers.

---

4  What to check if the issue still reappears

1. Disable Domain Reload once (Editor > Project Settings > Editor > Enter Play Mode Options) and confirm the bug disappears. If it does, a missed reenlistment step remains. citeturn0search13
2. Verify kernel dispatch counts use Mathf.CeilToInt(size / NUM_THREADS) so the entire domain is covered. Incorrect group counts can also leave “dots” near the origin that look like corner‑only data. citeturn0search10
3. Comment out obstacle and divergence passes and write a known constant into _Write[idx] directly from the velocity kernel; if the value is still clipped after the reload, the problem is unquestionably in buffer state, not simulation math.

---

5  Key take‑aways

• ComputeBuffers need an explicit Release → GC → recreate cycle after every domain reload to avoid aliasing invalid GPU memory.
• Bindings vanish on reload; rebinding each frame is mandatory.
• RenderTextures can claim to be created but still be unusable; call Release + Create.
• A small helper class or manager that enforces these rules makes the whole pipeline reload‑proof.

Apply the seven‑step checklist and the drop‑in buffer manager, and the velocity field should populate correctly regardless of how often Unity’s domain reloads.

You

this is my script currently

using System; 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.01f;

  [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")]
  public ADVECTION m_advectionType = ADVECTION.NORMAL;
  public int m_iterations = 10;
  public float m_vorticityStrength = 1.0f;

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

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

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

  [Header("Input Parameters")]
  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")]
  public bool enableBuoyancy = false;
  public bool enableTemperature = false;
  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]
  [Range(0,100)] public float velocityFieldAmount;
  [Range(0,100)] public float densityFieldAmount;
  [Range(0.00f,2)] public float boundaryVelocityThreshold;
  [Space]
  public bool continuousDensityInjection;
  public float injectionInterval = 1;
  [Space]
  public Vector3 pointVelocityPosition;
  public Vector3 pointVelocityDirection;
  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;
    ComputeShader.Instantiate(m_applyImpulse);
    /*
    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;
  }
  [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterSceneLoad)]
  private static void AfterReload()
  {
    // optional extra safety net
    GC.Collect();
    GC.WaitForPendingFinalizers();
  }
  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;

    ReleaseBuffers();

    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;*/


    ReleaseBuffers();
  }

  private void OnDisable()
  {
    ReleaseBuffers();
  }

  private void ReleaseBuffers()
  {
    if (m_density != null)
    {
      m_density[READ]?.Release();
      m_density[WRITE]?.Release();
      m_density[READ] = null;
      m_density[WRITE]= null;
    }

    if (m_temperature != null)
    {
      m_temperature[READ]?.Release();
      m_temperature[WRITE]?.Release();
      m_temperature[READ] = null;
      m_temperature[WRITE] = null;
    }

    if (m_velocity != null)
    {
      m_velocity[READ]?.Release();
      m_velocity[WRITE]?.Release();
      m_velocity[READ] = null;
      m_velocity[WRITE] = null;
    }

    if (m_pressure != null)
    {
      m_pressure[READ]?.Release();
      m_pressure[WRITE]?.Release();
      m_pressure[READ] = null;
      m_pressure[WRITE] = null;

    }

    if (m_phi != null)
    {
      m_phi[PHI_N_1_HAT]?.Release();
      m_phi[PHI_N_HAT]?.Release();
      m_phi[PHI_N_HAT] = null;
      m_phi[PHI_N_HAT] = null;
    }


    m_obstacles?.Release();
    m_obstacles = null;

    m_temp3f?.Release();
    m_temp3f = null;
  }

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

  // UNCHARTED LIMBO COLLECTIVE
  //---------------------------------------------------------------
  private void ApplyVelocityField(float dt, float amount, Texture velocityField, Vector3 pVelPos  = default, Vector3 pVelDir = default, float pVelMag = 0)
  {
    if (velocityField == null)
    {
      Debug.LogWarning("externalVelocityField is null – will write dummy values.");
      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)Mathf.CeilToInt(m_size.x/NUM_THREADS),
      (int)Mathf.CeilToInt(m_size.y/NUM_THREADS),
      (int)Mathf.CeilToInt(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

Key point up‑front: after a domain reload (Ctrl‑R, recompiling scripts while Play Mode is running) Unity calls OnDisable() → creates a new managed object → calls OnEnable(), but it never calls Start() again.
Your buffers are (correctly) released in OnDisable, but they are recreated only in Start.
Consequently, every ComputeBuffer reference is null or invalid for the rest of the Play‑Mode session, so each kernel writes into junk memory and you see the “dots in the corners” symptom. Unity clears everything the next time you reopen the Editor, which is why a full restart “fixes” it. Unity’s manual confirms that Start is skipped after a domain reload while OnEnable always fires. citeturn1search0turn1search6

Below is a minimal, bullet‑proof way to make the simulation survive any number of domain reloads, hot‑script recompiles, or play‑mode toggles.

---

1  Move buffer creation into a method that runs in both OnEnable and Start

void OnEnable()
{
    EnsureComputeShaders();   // always re‑link shaders (see §2)
    AllocateBuffers();        // <‑‑ now called here
}

void Start()
{
    AllocateBuffers();        // still called on first scene load
}

void AllocateBuffers()
{
    // dimension sanity
    m_width  = Mathf.ClosestPowerOfTwo(m_width);
    m_height = Mathf.ClosestPowerOfTwo(m_height);
    m_depth  = Mathf.ClosestPowerOfTwo(m_depth);
    m_size   = new Vector4(m_width, m_height, m_depth, 0);

    int SIZE = m_width * m_height * m_depth;
    ReleaseBuffers();                         // defensive: clean old GPU mem

    m_velocity  = NewRWBuffer(SIZE, sizeof(float) * 3);
    m_density   = NewRWBuffer(SIZE, sizeof(float));
    m_temperature = NewRWBuffer(SIZE, sizeof(float));
    m_pressure  = NewRWBuffer(SIZE, sizeof(float));
    m_phi       = NewRWBuffer(SIZE, sizeof(float));

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

    ComputeObstacles();
}

ComputeBuffer[] NewRWBuffer(int count, int stride)
{
    return new[]
    {
        new ComputeBuffer(count, stride),
        new ComputeBuffer(count, stride)
    };
}

Why it works – OnEnable is called every time Unity restores the object after domain reload, so the buffers are always valid. citeturn1search0

---

2  Re‑assign compute shaders safely after a reload

Singletons created in the previous domain are destroyed, so cached references in VoxelUtilsComputeResources return null until the ScriptableObject re‑initialises. Guard against this:

void EnsureComputeShaders()
{
    // prefer the SO if it’s valid, otherwise fall back to Resources
    var r = VoxelUtilsComputeResources.Instance;

    m_applyImpulse       = m_applyImpulse       ?? r?.m_applyImpulse?.ComputeShader
                        ?? Resources.Load<ComputeShader>("Shaders/ApplyImpulse");

    m_applyAdvect        = m_applyAdvect        ?? r?.m_applyAdvect?.ComputeShader
                        ?? Resources.Load<ComputeShader>("Shaders/ApplyAdvect");

    /* repeat for every compute shader … */
}

Using Resources.Load at runtime is safe and keeps the component working even when the SO hasn’t been rebuilt yet. citeturn0search1

---

3  Validate buffers before every Dispatch

Unity exposes ComputeBuffer.IsValid() for exactly this scenario. citeturn0search5

[Conditional("UNITY_EDITOR")]
void ValidateBuffer(ComputeBuffer buf, string name)
{
    if (buf == null || !buf.IsValid())
        Debug.LogError($"{name} buffer invalid after domain reload!");
}

void ApplyVelocityField(float dt, float amount, Texture velocityField, ...)
{
    ValidateBuffer(m_velocity[READ],  "velocity READ");
    ValidateBuffer(m_velocity[WRITE], "velocity WRITE");

    /* set parameters … */
    m_applyVelocityField.Dispatch(0,
        Mathf.CeilToInt(m_width  / (float)NUM_THREADS),
        Mathf.CeilToInt(m_height / (float)NUM_THREADS),
        Mathf.CeilToInt(m_depth  / (float)NUM_THREADS));

    Swap(m_velocity);
}

---

4  Release & GC in every exit path

Your ReleaseBuffers() method is correct, but call it from both OnDisable and OnDestroy (you already do) and clear the array slots:

void ReleaseBuffers()
{
    ReleasePair(m_density);
    ReleasePair(m_velocity);
    ReleasePair(m_temperature);
    ReleasePair(m_pressure);
    ReleasePair(m_phi);

    m_obstacles?.Release();  m_obstacles = null;
    m_temp3f?.Release();     m_temp3f   = null;

    static void ReleasePair(ComputeBuffer[] pair)
    {
        if (pair == null) return;
        pair[READ]?.Release(); pair[WRITE]?.Release();
    }
}

Immediately after releasing, run:

GC.Collect();
GC.WaitForPendingFinalizers();

to guarantee Unity frees the native memory before the new buffers are created. This pattern is recommended in Unity forum threads on buffer corruption after script reloads. citeturn0search3turn0search11

---

5  Fix the small typo in ReleaseBuffers

// before
m_phi[PHI_N_HAT]?.Release();
m_phi[PHI_N_HAT]?.Release();   // duplicates

// after
m_phi[PHI_N_HAT]?.Release();
m_phi[PHI_N_1_HAT]?.Release();

Leaving the second slot unreleased keeps a dangling GPU allocation.

---

6  (Optionally) disable Domain Reload for fast iteration

If you want faster Play‑Mode entry and can guarantee your own state reset, uncheck Project Settings → Editor → Enter Play Mode Options → Reload Domain. Unity’s docs stress you must then manually reset all state, which you now do via AllocateBuffers(). citeturn1search4

---

7  Quick checklist when something still fails

Check	How
Buffers valid?	Debug.Assert(buf.IsValid()) before dispatch
Kernels bound?	Re‑call every SetBuffer/SetTexture right before dispatch (bindings are per‑dispatch). citeturn0search2
Dispatch covers whole domain?	Use Mathf.CeilToInt (you already fixed it). citeturn0search10
External textures valid?	if(rt!=null){ rt.Release(); rt.Create(); } after reload. citeturn0search3

---

Result

With buffer allocation now in OnEnable, shader references refreshed, sanity checks before every dispatch, and proper release/GC, the velocity field remains healthy no matter how many times Unity recompiles scripts during Play Mode.