GPU Mesh Data Passing

2025-07-05 19:51 UTC o4-mini-high Open in ChatGPT ↗

Can this unity script be rewritten, in a way that passes the mesh data as a graphics buffer to the compute shader, instead of doing a BakeMesh and then explicitly writing the data in each frame?

using System.Collections; using System.Collections.Generic; using UnchartedLimbo.Core.Algorithms.GPU; using UnchartedLimbo.VoxelUtils.Runtime.Algorithms.SDF; using Unity.Collections; using Unity.Mathematics; using UnityEngine;

namespace UnchartedLimbo.VoxelUtils.Runtime.Algorithms.VectorFields { public class MeshVelocityBaker : SingleBufferGpuAlgorithm { [Header(“Clear Buffer Options”)] public bool clearBuffer; [Range(0,1)] public float multiplier;

    [Header("References")]
    public Transform root;
    public BoxCollider _collider;

    [Space] public SDFController.MeshType meshType;
    private        bool                   usesStatic  => meshType == SDFController.MeshType.Static;
    private        bool                   usesSkinned => meshType == SDFController.MeshType.Skinned;

    [Header("USE THIS FOR ANIMATED CHARACTERS")]
   // [NaughtyAttributes.ShowIf(nameof(usesSkinned))]
    public SkinnedMeshRenderer smr;

    [Header("USE THIS FOR PROCEDURAL MESHES")]
  //  [NaughtyAttributes.ShowIf(nameof(usesStatic))]
    public MeshFilter msh;


    // Holds mesh vertices
    private ComputeBuffer _positionBuffer1;
    private ComputeBuffer _positionBuffer2;

    private Mesh _tempMesh;
    private (Matrix4x4 current, Matrix4x4 previous) _rootMatrix;

    private Matrix4x4 GlobalTransformationMatrix => root == null ?
        Matrix4x4.identity :
        root.localToWorldMatrix;

    private const string MULTIPLIER = "Multiplier";
    private const string VOLUME_DIMENSIONS = "VolumeDimensions";
    private const string BOUNDS_MIN = "BoundsMin";
    private const string BOUNDS_SIZE = "BoundsSize";
    private const string CURRENT_MATRIX = "Transform";
    private const string PREVIOUS_MATRIX = "OldTransform";
    private const string FRAMERATE = "FrameRate";
    private const string POSITION_BUFFER = "PositionBuffer";
    private const string OLD_POSITION_BUFFER = "OldPositionBuffer";

    public override void Awake()
    {
        base.Awake();

        var l2w = GlobalTransformationMatrix;

        _rootMatrix = (l2w, l2w);
    }

    protected override void Schedule()
    {

        if (smr == null && msh == null)
            return;

        if (usesSkinned && smr != null)
        {
            ProcessSkinnedMesh(smr);
        }
        else if (usesStatic && msh != null)
        {
            ProcessBakedMesh(msh);
        }

        _rootMatrix.current = GlobalTransformationMatrix;

        compute.SetFloat(MULTIPLIER, multiplier);
        compute.SetVector(VOLUME_DIMENSIONS, new Vector4(Resolution.x, Resolution.y, Resolution.z));
        compute.SetMatrix(CURRENT_MATRIX, _rootMatrix.current);
        compute.SetMatrix(PREVIOUS_MATRIX, _rootMatrix.previous);
        compute.SetFloat(FRAMERATE, 1 / Time.deltaTime);

        if (_collider != null)
        {
            compute.SetVector(BOUNDS_MIN,  new float4(_collider.bounds.min,  1));
            compute.SetVector(BOUNDS_SIZE, new float4(_collider.bounds.size, 1));
        }

        // FIRST KERNEL
        compute.SetTexture(_kernelIndices[0], BufferAName, bufferA.Buffer);

        // SECOND KERNEL
        compute.SetBuffer(_kernelIndices[1], POSITION_BUFFER, _positionBuffer1);
        compute.SetBuffer(_kernelIndices[1], OLD_POSITION_BUFFER, _positionBuffer2);
        compute.SetTexture(_kernelIndices[1], BufferAName, bufferA.Buffer);

    }

    protected override void Execute()
    {
        if (clearBuffer)
            Dispatch(0);

        Dispatch(1);

        SwapPositionMaps();

        if (firstRun)
            firstRun = false;
    }


    private void SwapPositionMaps()
    {
        // Position buffer swapping
        (_positionBuffer1, _positionBuffer2) = (_positionBuffer2, _positionBuffer1);
        _rootMatrix.previous = _rootMatrix.current;
    }

    private void ProcessSkinnedMesh(SkinnedMeshRenderer smr) => BakeSource(smr);

    private void ProcessBakedMesh(MeshFilter mf) => BakeSource(mf);


    private int BakeSource(SkinnedMeshRenderer source, int offset = 0)
    {
        if (_tempMesh == null)
            _tempMesh = new Mesh();

        source.BakeMesh(_tempMesh);

        return BakeSource(_tempMesh, offset);
    }

    private int BakeSource(MeshFilter source, int offset = 0)
    {
        return BakeSource(source.sharedMesh, offset);
    }

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


    private static int CopyVerticesToBuffer(Mesh mesh, ComputeBuffer buffer, int offset = 0)
    {
        using (var dataArray = Mesh.AcquireReadOnlyMeshData(mesh))
        {
            var data = dataArray[0];
            var vcount = data.vertexCount;

            using (var pos = new NativeArray<Vector3>(vcount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory))
            {
                data.GetVertices(pos);

                buffer.SetData(pos, 0, offset, vcount);

                return vcount;
            }
        }
    }
}

}

Below is a refactored version of your baker that pulls the mesh’s GPU vertex buffer directly and feeds it into your compute shader each frame—no more BakeMesh or per-frame SetData. Instead, we grab the mesh’s GraphicsBuffer once in OnEnable, create two GPU buffers for “current” and “previous” positions, and then simply bind and copy buffers on the GPU.

using System;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.Rendering;

namespace UnchartedLimbo.VoxelUtils.Runtime.Algorithms.VectorFields
{
    [RequireComponent(typeof(MeshFilter))]
    public class MeshVelocityBaker : SingleBufferGpuAlgorithm
    {
        [Header("Clear Buffer Options")]
        public bool clearBuffer;
        [Range(0,1)] public float multiplier;

        [Header("References")]
        public Transform root;
        public BoxCollider _collider;

        // internal buffers
        private GraphicsBuffer _sourceVB;           // the mesh’s vertex buffer
        private GraphicsBuffer _positionBufferA;    // current positions
        private GraphicsBuffer _positionBufferB;    // previous positions

        private Matrix4x4 _prevRootMatrix;
        private bool      _firstFrame = true;

        private static readonly int
            kMultiplier        = Shader.PropertyToID("Multiplier"),
            kVolumeDims        = Shader.PropertyToID("VolumeDimensions"),
            kBoundsMin         = Shader.PropertyToID("BoundsMin"),
            kBoundsSize        = Shader.PropertyToID("BoundsSize"),
            kCurrMatrix        = Shader.PropertyToID("Transform"),
            kPrevMatrix        = Shader.PropertyToID("OldTransform"),
            kFrameRate         = Shader.PropertyToID("FrameRate"),
            kPositionBuffer    = Shader.PropertyToID("PositionBuffer"),
            kOldPositionBuffer = Shader.PropertyToID("OldPositionBuffer");

        void OnEnable()
        {
            // grab the mesh’s GPU VB (assumes a single stream of Vector3 positions)
            var mf = GetComponent<MeshFilter>();
            var mesh = mf.sharedMesh;
            if (mesh == null) throw new InvalidOperationException("No MeshFilter.sharedMesh!");

            _sourceVB = mesh.GetVertexBuffer(0);
            int vertexCount = mesh.vertexCount;

            // allocate two structured buffers (float3 per element)
            _positionBufferA = new GraphicsBuffer(GraphicsBuffer.Target.Structured, vertexCount, sizeof(float) * 3);
            _positionBufferB = new GraphicsBuffer(GraphicsBuffer.Target.Structured, vertexCount, sizeof(float) * 3);

            // initialize "previous" from the source VB
            Graphics.CopyBuffer(_sourceVB, _positionBufferB);

            // prime the prev root matrix
            _prevRootMatrix = root?.localToWorldMatrix ?? Matrix4x4.identity;
        }

        void OnDisable()
        {
            _positionBufferA?.Release();
            _positionBufferB?.Release();
        }

        protected override void Schedule()
        {
            // every frame we bind:
            compute.SetFloat(kMultiplier, multiplier);
            compute.SetVector(kVolumeDims, new Vector4(Resolution.x, Resolution.y, Resolution.z));
            compute.SetMatrix(kCurrMatrix, root?.localToWorldMatrix ?? Matrix4x4.identity);
            compute.SetMatrix(kPrevMatrix, _prevRootMatrix);
            compute.SetFloat(kFrameRate, 1f / Time.deltaTime);

            if (_collider != null)
            {
                compute.SetVector(kBoundsMin,  new float4(_collider.bounds.min,  1));
                compute.SetVector(kBoundsSize, new float4(_collider.bounds.size, 1));
            }

            // bind raw mesh VB as "constant" input
            compute.SetGraphicsBuffer(_kernelIndices[1], "SourceVertexBuffer", _sourceVB);

            // bind our two ping-pong buffers
            compute.SetGraphicsBuffer(_kernelIndices[1], kPositionBuffer,    _positionBufferA);
            compute.SetGraphicsBuffer(_kernelIndices[1], kOldPositionBuffer, _positionBufferB);
        }

        protected override void Execute()
        {
            if (clearBuffer)
                Dispatch(0);

            Dispatch(1);

            // swap current<->previous
            Graphics.CopyBuffer(_positionBufferA, _positionBufferB);
            _prevRootMatrix = root?.localToWorldMatrix ?? Matrix4x4.identity;

            if (_firstFrame)
                _firstFrame = false;
        }
    }
}

What changed?

One‐time grab of the GPU vertex buffer
```
_sourceVB = mesh.GetVertexBuffer(0);
```
Meshes now expose their internal GraphicsBuffer for positions. No more BakeMesh + CPU copy.
Ping-pong on the GPU
We allocate two GraphicsBuffer structured buffers (_positionBufferA/B). We initialize buffer B from the source VB once, then every frame after dispatch we simply:
```
Graphics.CopyBuffer(_positionBufferA, _positionBufferB);
```
No NativeArray or CPU round‐trips.

ComputeShader binding
Replace SetBuffer/SetData calls with:

compute.SetGraphicsBuffer(kernel, "SourceVertexBuffer", _sourceVB);
compute.SetGraphicsBuffer(kernel, "PositionBuffer",    _positionBufferA);
compute.SetGraphicsBuffer(kernel, "OldPositionBuffer", _positionBufferB);

Simplified skin/static split
This approach works for any mesh that isn’t skinned on the CPU. For GPU‐skinned characters you’ll need to use Unity’s GPU skinning data (bind joint matrices + weights) and either let the built‐in skinning run into a separate stream or re‐implement skinning in your shader, but you no longer do BakeMesh.

With this you offload all vertex copying to the GPU, avoid per-frame mesh baking, and only update your transform matrices and dispatch your kernels each frame. Let me know if you need an example of how to handle GPU skinning or any other refinements!

This was the original Compute Shader.

Modify accordingly

#pragma kernel ClearPass #pragma kernel BakeVelocitiesPass

#include ”./ShaderUtils.hlsl”

// Output Buffer //============================================================================= RWTexture3D bufferA; //=============================================================================

// ClearPass Variables //============================================================================= float Multiplier; //=============================================================================

// BakeVelocitiesPass Variables //============================================================================= // Resolution float3 VolumeDimensions;

// Bounds float3 BoundsMin; float3 BoundsSize;

// Matrices float4x4 Transform; float4x4 OldTransform;

// Time float FrameRate;

// Read-Only buffers StructuredBuffer PositionBuffer; StructuredBuffer OldPositionBuffer; //=============================================================================

[numthreads(8, 8, 8)] void ClearPass(uint3 id : SV_DispatchThreadID) { bufferA[id.xyz] *= Multiplier; }

[numthreads(512, 1, 1)] void BakeVelocitiesPass(uint3 id : SV_DispatchThreadID) { uint i = id.x;

// Get current and previous points
float3 p0 = OldPositionBuffer[i];
float3 p1 = PositionBuffer[i];

// apply matrix transformations
p0 = mul(OldTransform, float4(p0, 1)).xyz;
p1 = mul(Transform, float4(p1, 1)).xyz;

// Calculate velocity
float3 velocity = (p1 - p0) * FrameRate;

// Normalize position
p1 =  toNormalizedCoordinates(p1, BoundsSize, BoundsMin) ;

// Remap to Voxel space
float3 scaled = p1 * VolumeDimensions;
uint3 voxelIdx = uint3(floor(scaled));

bufferA[voxelIdx] = float4(velocity.xyz, 0);

}

Here’s the adjusted HLSL. We no longer bake the mesh into CPU‐side arrays each frame—instead we read the live vertex buffer (SourceVertexBuffer) and a single “previous” buffer (OldPositionBuffer), which your C# then updates on the GPU with Graphics.CopyBuffer after the dispatch.

#pragma kernel ClearPass
#pragma kernel BakeVelocitiesPass

#include "./ShaderUtils.hlsl"

//================================
// OUTPUT
//================================
RWTexture3D<float4> bufferA;

//================================
// CLEAR PASS
//================================
float Multiplier;

//================================
// BAKE VELOCITIES PASS
//================================
// Volume resolution in voxels
float3 VolumeDimensions;

// World‐space bounds
float3 BoundsMin;
float3 BoundsSize;

// Transforms for this and last frame
float4x4 Transform;
float4x4 OldTransform;

// Inverse delta‐time
float FrameRate;

// GPU‐side mesh data
StructuredBuffer<float3> SourceVertexBuffer;   // current mesh verts
StructuredBuffer<float3> OldPositionBuffer;    // verts from last frame

[numthreads(8, 8, 8)]
void ClearPass(uint3 id : SV_DispatchThreadID)
{
    bufferA[id.xyz] *= Multiplier;
}

[numthreads(512, 1, 1)]
void BakeVelocitiesPass(uint3 id : SV_DispatchThreadID)
{
    uint i = id.x;

    // fetch old & current
    float3 p0 = OldPositionBuffer[i];
    float3 p1 = SourceVertexBuffer[i];

    // bring into world‐space
    p0 = mul(OldTransform, float4(p0, 1)).xyz;
    p1 = mul(Transform,    float4(p1, 1)).xyz;

    // velocity in world‐space
    float3 velocity = (p1 - p0) * FrameRate;

    // to normalized [0…1]
    p1 = toNormalizedCoordinates(p1, BoundsSize, BoundsMin);

    // map into voxel indices
    float3 scaled  = p1 * VolumeDimensions;
    uint3 voxelIdx = uint3(floor(scaled));

    bufferA[voxelIdx] = float4(velocity, 0);
}

What changed?

Removed the old PositionBuffer – you now read current-frame positions directly from SourceVertexBuffer.
Kept OldPositionBuffer to compare against last‐frame verts.

On the C# side you’ll bind like:

compute.SetGraphicsBuffer(kernel, "SourceVertexBuffer", sourceVB);
compute.SetGraphicsBuffer(kernel, "OldPositionBuffer", oldPosBuffer);

After dispatch, update oldPosBuffer with:
```
Graphics.CopyBuffer(sourceVB, oldPosBuffer);
```
so next frame your “previous” data is always one frame behind.

Let me know if you need a snippet of the C# binding or buffer‐update code!

Here’s one way to do it without ever touching the CPU copies at runtime—just treat each SkinnedMeshRenderer as its own GPU‐side buffer, then “stitch” them together into one big ping-pong buffer before you do your velocity bake. The high-level flow is:

OnEnable
- For each SMR in your list:
  - BakeMesh once into a temp Mesh and grab its vertex GraphicsBuffer
    (you could also skip this if you have a fully GPU-skinned path).
  - Allocate two structured GraphicsBuffers for current/old of that mesh.
- Compute the total vertex count and allocate two big “combined” buffers.
- Build an array of (offset, count) for each sub-mesh and upload it to a small GraphicsBuffer called OffsetsBuffer.
Each Frame
1. Combine all per‐SMR buffers into the big “combinedCurrent” and “combinedOld” using a tiny pre-kernel.
2. Dispatch your velocity kernel over the combined buffer.
3. Swap combined buffers (copy combinedCurrent → combinedOld and swap transform).

C# Sketch

public class MultiSmrVelocityBaker : SingleBufferGpuAlgorithm
{
    [Header("Skinned Meshes")]
    public SkinnedMeshRenderer[] skinnedRenderers;

    // per-SMR
    GraphicsBuffer[] _srcBuffers;      // current verts for each SMR
    GraphicsBuffer[] _oldBuffers;      // last-frame verts
    int[]           _offsets;         // flatten offsets & counts
    GraphicsBuffer  _offsetsBuffer;   // StructuredBuffer<int2> (x=offset, y=count)

    // big, combined
    GraphicsBuffer _combinedCur;
    GraphicsBuffer _combinedOld;

    void OnEnable()
    {
        // 1) Bake + grab each source VB
        _srcBuffers = new GraphicsBuffer[skinnedRenderers.Length];
        _oldBuffers = new GraphicsBuffer[skinnedRenderers.Length];
        _offsets    = new int[skinnedRenderers.Length * 2];
        int totalVerts = 0;

        for (int i = 0; i < skinnedRenderers.Length; i++)
        {
            var smr = skinnedRenderers[i];
            var m   = new Mesh();
            smr.BakeMesh(m);

            // grab the GPU VB for the baked mesh positions
            var vb = m.GetVertexBuffer(0);
            int vc = m.vertexCount;

            _srcBuffers[i] = new GraphicsBuffer(
                GraphicsBuffer.Target.Structured, vc, sizeof(float) * 3);
            _oldBuffers[i] = new GraphicsBuffer(
                GraphicsBuffer.Target.Structured, vc, sizeof(float) * 3);

            // initialize old←current
            Graphics.CopyBuffer(vb, _oldBuffers[i]);

            // record offset & count
            _offsets[i*2 + 0] = totalVerts;
            _offsets[i*2 + 1] = vc;
            totalVerts += vc;
        }

        // 2) create combined ping-pong
        _combinedCur = new GraphicsBuffer(
            GraphicsBuffer.Target.Structured, totalVerts, sizeof(float)*3);
        _combinedOld = new GraphicsBuffer(
            GraphicsBuffer.Target.Structured, totalVerts, sizeof(float)*3);

        // 3) upload offsets[]
        _offsetsBuffer = new GraphicsBuffer(
            GraphicsBuffer.Target.Structured, skinnedRenderers.Length, sizeof(int)*2);
        _offsetsBuffer.SetData(_offsets);
    }

    void OnDisable()
    {
        foreach (var b in _srcBuffers)  b.Release();
        foreach (var b in _oldBuffers)  b.Release();
        _combinedCur.Release();
        _combinedOld.Release();
        _offsetsBuffer.Release();
    }

    protected override void Schedule()
    {
        // 1) combine all sub-buffers into one
        compute.SetBuffer(0, "SrcBuffers",   _srcBuffers);     //   Array<StructuredBuffer<float3>>
        compute.SetBuffer(0, "OldBuffers",   _oldBuffers);     //   Array<StructuredBuffer<float3>>
        compute.SetBuffer(0, "Offsets",      _offsetsBuffer);  //   StructuredBuffer<int2>
        compute.SetBuffer(0, "CombinedCur",  _combinedCur);
        compute.SetBuffer(0, "CombinedOld",  _combinedOld);
        compute.Dispatch(0, /*ceil(totalVerts/256)*/,1,1);

        // 2) set up for BakeVelocitiesPass (kernel #1)
        //    bind CombinedCur/Old just like we bound single buffers before:
        compute.SetBuffer(1, "PositionBuffer",    _combinedCur);
        compute.SetBuffer(1, "OldPositionBuffer", _combinedOld);

        // ...and all your other uniforms/textures here...
    }

    protected override void Execute()
    {
        // clear if wanted, then bake
        if (clearBuffer) Dispatch(1, ...clear...);
        Dispatch(2, /*BakeVelocitiesPass*/);

        // swap for next frame
        Graphics.CopyBuffer(_combinedCur, _combinedOld);
        _prevRootMatrix = root?.localToWorldMatrix ?? Matrix4x4.identity;
    }
}

HLSL: the “Combine” kernel

#pragma kernel CombineBuffers
// we bind these as arrays:
StructuredBuffer<float3> SrcBuffers   [/*maxSMR*/];
StructuredBuffer<float3> OldBuffers   [/*maxSMR*/];
StructuredBuffer<int2>    Offsets;     // .x = start offset, .y = count
RWStructuredBuffer<float3> CombinedCur;
RWStructuredBuffer<float3> CombinedOld;

[numthreads(256,1,1)]
void CombineBuffers(uint3 id : SV_DispatchThreadID)
{
    uint globalIdx = id.x;
    // find which mesh this index belongs to
    // (we do a simple linear search here; if you have a lot of SMRs
    //  you can unroll or do a binary search in shader—still fast)
    for (uint m = 0; m < _NumSMRs; ++m)
    {
        int2 oc = Offsets[m];
        uint start = oc.x;
        uint count = oc.y;
        if (globalIdx >= start && globalIdx < start + count)
        {
            uint local = globalIdx - start;
            CombinedCur[ globalIdx ] = SrcBuffers[m][ local ];
            CombinedOld[ globalIdx ] = OldBuffers[m][ local ];
            break;
        }
    }
}

Kernel 0 is the small “CombineBuffers” pass.
Kernel 1 is ClearPass (unchanged).
Kernel 2 is your BakeVelocitiesPass, but now over the flattened CombinedCur/CombinedOld instead of a single mesh.

You’ll need to set _NumSMRs (as an int uniform) and bind your arrays of GraphicsBuffer via compute.SetBuffer(...) overloads that take GraphicsBuffer[].

Why this works

All vertex data stays on the GPU. You never call SetData per frame.
You only do one tiny “combine” dispatch (memory–memory copy) plus your velocity pass.
Supports any number of SkinnedMeshRenderer streams, merged into a single, contiguous buffer for your main algorithm.

You don’t need to ever call BakeMesh if you only want the skinned, per-frame vertex positions on the GPU—you can pull them straight out of the SkinnedMeshRenderer’s own vertex buffers each frame.

Allow raw/byte‐address access
```
// e.g. in Awake or OnEnable:
smr.vertexBufferTarget |= GraphicsBuffer.Target.Raw;
```
By default Unity’s skinned‐mesh VB is marked as Vertex. If you want to slurp it into a compute shader you must add the Raw (or ByteAddress) flag first citeturn3search0.
Grab current & previous GPU buffers
```
// inside your scheduling method, each frame:
GraphicsBuffer currVB = smr.GetVertexBuffer();
GraphicsBuffer prevVB = smr.GetPreviousVertexBuffer();
```
These two calls give you the fully-skinned vertex stream for this frame and last frame respectively—no CPU work, no Mesh copies citeturn3search1.
Bind them to your compute shader
```
compute.SetGraphicsBuffer(kernelIndex, "SourceVertexBuffer", currVB);
compute.SetGraphicsBuffer(kernelIndex, "OldPositionBuffer",    prevVB);
```
Then your HLSL can stay exactly as before (reading SourceVertexBuffer/OldPositionBuffer), and you’ll get correct, up-to-date skinning every frame at zero CPU cost.

Putting it all together (snippet inside your Baker):

public SkinnedMeshRenderer smr;

void OnEnable()
{
    // allow compute‐shader access
    smr.vertexBufferTarget |= GraphicsBuffer.Target.Raw;
}

protected override void Schedule()
{
    if (smr == null) return;

    // fetch the GPU‐skinned VB each frame
    var curr = smr.GetVertexBuffer();
    var prev = smr.GetPreviousVertexBuffer();

    compute.SetFloat("Multiplier", multiplier);
    compute.SetMatrix("Transform",    root.localToWorldMatrix);
    compute.SetMatrix("OldTransform", _prevRootMatrix);
    compute.SetFloat("FrameRate",     1f / Time.deltaTime);

    compute.SetGraphicsBuffer(_kernelIndices[1], "SourceVertexBuffer", curr);
    compute.SetGraphicsBuffer(_kernelIndices[1], "OldPositionBuffer",    prev);

    // …and dispatch as usual…
}

protected override void Execute()
{
    if (clearBuffer) Dispatch(0);
    Dispatch(1);

    // remember for next frame
    _prevRootMatrix = root.localToWorldMatrix;
}

This way you never BakeMesh on the CPU, and you get both current and previous skinned positions directly on the GPU every frame.

what abiut all this?

if (vertexBuffer == null) { meshRenderer.vertexBufferTarget |= GraphicsBuffer.Target.Raw | GraphicsBuffer.Target.Vertex; ;

        vertexBuffer = meshRenderer.GetVertexBuffer();
        Debug.Log("Bound mesh vertex position buffer");

        VertexAttributeDescriptor descPosition = default;
        foreach (var descriptor in meshRenderer.sharedMesh.GetVertexAttributes())
        {
            if (descriptor.attribute == VertexAttribute.Position) descPosition = descriptor;
        }
        int positionOffset = mesh.GetVertexAttributeOffset(VertexAttribute.Position);

        skinnedMotionOffsetsCompute.SetBuffer(StoreVertexPositionKernel, "_MeshVertexBuffer", vertexBuffer);
        skinnedMotionOffsetsCompute.SetInt("_VertBufferStride", mesh.GetVertexBufferStride(descPosition.stream));
        skinnedMotionOffsetsCompute.SetInt("_VertBufferOffset", positionOffset);
    }

That little block is doing exactly what we described above—but in a fully “raw” fashion: it grabs the skinned‐mesh’s GPU VB each frame, computes the byte‐stride and attribute‐offset for the Position channel, and then hands all three pieces to your compute shader so that you can load XYZ directly out of the byte address buffer.

Here’s a breakdown:

Enable raw/byte‐address access
```
meshRenderer.vertexBufferTarget |= GraphicsBuffer.Target.Raw | GraphicsBuffer.Target.Vertex;
```
By OR-ing in Raw, you tell Unity to expose that VB as a ByteAddressBuffer in your compute shader citeturn3search0.
Grab the GraphicsBuffer
```
vertexBuffer = meshRenderer.GetVertexBuffer();
```
That is now your per-frame, GPU-skinned vertex stream.

Find the position attribute’s layout

foreach(var desc in meshRenderer.sharedMesh.GetVertexAttributes())
    if(desc.attribute == VertexAttribute.Position)
        descPosition = desc;
int positionOffset = mesh.GetVertexAttributeOffset(VertexAttribute.Position);
int stride         = mesh.GetVertexBufferStride(descPosition.stream);

Unity gives you both the byte‐offset within each vertex and the total stride (bytes per vertex) citeturn3search1.

Bind into your compute

skinnedMotionOffsetsCompute.SetBuffer(StoreVertexPositionKernel, "_MeshVertexBuffer", vertexBuffer);
skinnedMotionOffsetsCompute.SetInt   ("_VertBufferStride", stride);
skinnedMotionOffsetsCompute.SetInt   ("_VertBufferOffset", positionOffset);

How to load that in your HLSL

// declare as byte‐address
ByteAddressBuffer _MeshVertexBuffer;
int _VertBufferStride;
int _VertBufferOffset;

[numthreads(512,1,1)]
void BakeVelocitiesPass(uint3 id:SV_DispatchThreadID)
{
    uint i = id.x;

    // compute the byte address of vertex i
    uint byteAddr = i * _VertBufferStride + _VertBufferOffset;

    // pull out 3 floats
    float x = asfloat(_MeshVertexBuffer.Load(byteAddr + 0));
    float y = asfloat(_MeshVertexBuffer.Load(byteAddr + 4));
    float z = asfloat(_MeshVertexBuffer.Load(byteAddr + 8));
    float3 p1 = float3(x,y,z);

    // …same for old positions if you bind a second ByteAddressBuffer…

    // now you can transform p1/world, compute velocity, write into your 3D texture etc.
}

That pattern completely eliminates any CPU‐side BakeMesh or SetData—you read the skinned, per-frame verts straight out of the GPU buffer, use the provided stride/offset to index into it, and your compute shader stays fully up to date with zero CPU overhead.

what about this? float3 ReadFromVertexBuffer(uint idx) { uint strided = idx * _VertBufferStride + _VertBufferOffset; uint3 data = _MeshVertexBuffer.Load3(strided); return asfloat(data); }

[numthreads(NR_THREADS, 1, 1)] void StoreVertexPosition(uint3 id : SV_DispatchThreadID) { // Ensure valid index if (id.x >= vertexCount) return;

// Get the object-space vertex position
float3 objectVertexPos = ReadFromVertexBuffer(id.x);

// Convert to world-space
float4 worldVertexPos = float4(
    dot(_ObjectToWorld_0, float4(objectVertexPos, 1.0)),
    dot(_ObjectToWorld_1, float4(objectVertexPos, 1.0)),
    dot(_ObjectToWorld_2, float4(objectVertexPos, 1.0)),
    dot(_ObjectToWorld_3, float4(objectVertexPos, 1.0))
);

// Store world-space vertex position in the circular buffer
_VertexPositions[id.x + vertexCount * frameIndex] = worldVertexPos;

}

That snippet is exactly what you’d use if you want to pull both the current skinned positions and store them in a shader‐side circular buffer – no CPU copy of an “old” buffer at all. Here’s how you’d fold it into your velocity‐baker:

1) C# side

public class SkinnedVertexGPURecorder : MonoBehaviour
{
    public SkinnedMeshRenderer smr;
    public ComputeShader compute;

    // these get set once
    ComputeBuffer vertexPosCircular; // holds 2 frames × vertexCount float4’s
    int          vertexCount;
    int          kernel;

    bool frameToggle = false;

    void OnEnable()
    {
        smr.vertexBufferTarget |= GraphicsBuffer.Target.Raw;
        vertexCount = smr.sharedMesh.vertexCount;
        // 2 frames of float4 per vertex
        vertexPosCircular = new ComputeBuffer(vertexCount * 2, sizeof(float) * 4,
                                ComputeBufferType.Structured);

        kernel = compute.FindKernel("BakeVelocitiesPass");

        // find the position‐attribute layout
        var descs = smr.sharedMesh.GetVertexAttributes();
        var posDesc = System.Array.Find(descs, d => d.attribute == VertexAttribute.Position);
        int posStream = posDesc.stream;
        int offset    = smr.sharedMesh.GetVertexAttributeOffset(VertexAttribute.Position);
        int stride    = smr.sharedMesh.GetVertexBufferStride(posStream);

        compute.SetInt("_VertBufferOffset", offset);
        compute.SetInt("_VertBufferStride", stride);
        compute.SetInt("_VertexCount",       vertexCount);

        compute.SetBuffer(kernel, "_VertexPositions", vertexPosCircular);
    }

    void OnDisable()
    {
        vertexPosCircular.Release();
    }

    void Update()
    {
        var vb = smr.GetVertexBuffer();
        // bind raw skinned stream
        compute.SetBuffer(kernel, "_MeshVertexBuffer", vb);

        // tell the shader which slot (0 or 1) we’re writing into
        compute.SetBool("_FrameToggle", frameToggle);

        // bind your transforms
        compute.SetMatrix("_ObjectToWorld", smr.localToWorldMatrix);
        compute.SetMatrix("_OldObjectToWorld",
            frameToggle
             ? compute.GetMatrix("_ObjectToWorld")   // if toggled, we've just written old
             : compute.GetMatrix("_OldObjectToWorld"));

        compute.Dispatch(kernel, Mathf.CeilToInt(vertexCount / 512f), 1, 1);

        frameToggle = !frameToggle;
    }
}

We allocate one circular StructuredBuffer<float4> of size vertexCount * 2.
Each frame we toggle frameToggle (0 or 1) so the shader knows which half to write into and which half to read from.
We pull the GPU‐skinned VB each frame with GetVertexBuffer() and bind it as a ByteAddressBuffer (via the Raw flag).
We upload the stride & offset once in OnEnable.

2) HLSL side

//-----------------------------------------------------------------------------
// reads three UInts at (idx*stride + offset) and reinterprets them as float3
//-----------------------------------------------------------------------------
float3 ReadFromVertexBuffer(uint idx)
{
    uint addr = idx * _VertBufferStride + _VertBufferOffset;
    uint3 packed = _MeshVertexBuffer.Load3(addr);
    return asfloat(packed);
}

// circular buffer: 2 slots per vertex
RWStructuredBuffer<float4> _VertexPositions;
// 0 = current frame half, 1 = previous
bool  _FrameToggle;
int   _VertexCount;

// object→world rows
float4 _ObjectToWorld_0;
float4 _ObjectToWorld_1;
float4 _ObjectToWorld_2;
float4 _ObjectToWorld_3;

[numthreads(512, 1, 1)]
void BakeVelocitiesPass(uint3 id : SV_DispatchThreadID)
{
    uint i = id.x;
    if (i >= _VertexCount) return;

    // 1) read object-space pos
    float3 objPos = ReadFromVertexBuffer(i);

    // 2) world-space
    float4 w = float4(objPos, 1);
    float3 worldPos = float3(
        dot(_ObjectToWorld_0, w),
        dot(_ObjectToWorld_1, w),
        dot(_ObjectToWorld_2, w)
    );

    // 3) compute indices in circular buffer
    uint slotCurr = _FrameToggle ? 1 : 0;
    uint slotPrev = _FrameToggle ? 0 : 1;

    uint idxCurr = i + slotCurr * _VertexCount;
    uint idxPrev = i + slotPrev * _VertexCount;

    // 4) read last‐frame world pos
    float4 prevW = _VertexPositions[idxPrev];
    float3 worldPrev = prevW.xyz;

    // 5) write our velocity somewhere (e.g. your 3D texture):
    float3 vel = (worldPos - worldPrev) * _FrameRate;
    // … your existing voxel‐write code here …

    // 6) store this frame’s world pos for next time
    _VertexPositions[idxCurr] = float4(worldPos, 0);
}

Why this helps

No CPU copy: you never Graphics.CopyBuffer or SetData at runtime.
Single dispatch: you read current & previous in-shader from the circular buffer.
Unlimited back-history: if you ever want more than 2 frames, just bump the circular size.

Feel free to drop your existing voxel‐texture writes back into step 5, and you’ve got a fully GPU‐resident, multi-frame skinned‐mesh velocity capture!

why does this code return 0,0,0 vertices?

c#:

using System; using UnchartedLimbo.Core.Runtime.Attributes; using Unity.Mathematics; using UnityEngine; using UnityEngine.Rendering; using UnityEngine.VFX;

namespace UnchartedLimbo.VoxelUtils.Runtime { public class MeshVelocityBaker2 : MonoBehaviour {

    public SkinnedMeshRenderer[] skinnedMeshes;
    public ComputeShader computeShader;

    public GraphicsBuffer[] _MeshVertexBuffer;
    public GraphicsBuffer[] _MeshVertexBuffer_Prev;

    public GraphicsBuffer _MergedPositions;
    public GraphicsBuffer _MergedPositions_Prev;
    public ComputeBuffer _Offsets_Strides_Counts;

    public ComputeBuffer velocityField;

    [ReadOnly] public int[] vertexCounts;
    [ReadOnly] public int[] offsets;
    [ReadOnly] public int[] normalOffsets;
    [ReadOnly] public int[] strides;
    [ReadOnly] public int3[] _offsets_strides_counts_array;

    public Vector3[] debug_verts;
    public VisualEffect vfx;

    // Start is called once before the first execution of Update after the MonoBehaviour is created
    private void Awake()
    {
        Initialize();
    }

    // Update is called once per frame
    private void Update()
    {
        if (skinnedMeshes == null || skinnedMeshes.Length == 0)
            return;

        for (var i = 0; i < skinnedMeshes.Length; i++)
        {
            var smr = skinnedMeshes[i];

            _MeshVertexBuffer[i] ??= smr.GetVertexBuffer();
            _MeshVertexBuffer_Prev[i] ??= smr.GetPreviousVertexBuffer();

            if (_MeshVertexBuffer[i] == null)
            {
                Debug.LogError($"{nameof(_MeshVertexBuffer)} {i} is null at frame: {Time.frameCount}");
            }
            else
            {
                vertexCounts[i] = _MeshVertexBuffer[i].count;
            }

            if (computeShader != null)
                return;

            computeShader.SetInt("_MeshIndex", i);
            computeShader.SetBuffer(0,"_MeshVertexBuffer",_MeshVertexBuffer[i]);
            computeShader.SetBuffer(0,"_MeshVertexBuffer_Prev",_MeshVertexBuffer_Prev[i]);
            computeShader.SetBuffer(0,"_MergedPositions",_MergedPositions);
            computeShader.SetBuffer(0,"_MergedPositions_Prev",_MergedPositions_Prev);
            computeShader.SetBuffer(0,"_Offsets_Strides_Counts",_Offsets_Strides_Counts);
            computeShader.Dispatch(0, Mathf.CeilToInt(vertexCounts[i]), 1, 1);
        }

        vfx.SetGraphicsBuffer("Buffer", _MergedPositions);

        _MeshVertexBuffer[0].GetData(debug_verts);
    }

    private void Initialize()
    {
        DisposeAll();

        if (skinnedMeshes == null || skinnedMeshes.Length == 0)
        {
            Debug.LogWarning("MeshVelocityBaker2 requires at least one skinned mesh.");
            return;
        }

        _MeshVertexBuffer = new GraphicsBuffer[skinnedMeshes.Length];
        _MeshVertexBuffer_Prev = new GraphicsBuffer[skinnedMeshes.Length];


        vertexCounts = new int[skinnedMeshes.Length];
        offsets = new int[skinnedMeshes.Length];
        normalOffsets = new int[skinnedMeshes.Length];
        strides = new int[skinnedMeshes.Length];
        _offsets_strides_counts_array = new int3[skinnedMeshes.Length];

        var vertexCount = 0;
        VertexAttributeDescriptor descPosition = default;

        for (var i = 0; i < skinnedMeshes.Length; i++)
        {
            var smr = skinnedMeshes[i];
            smr.vertexBufferTarget |= GraphicsBuffer.Target.Raw | GraphicsBuffer.Target.Vertex;

            var msh = smr.sharedMesh;


            foreach (var descriptor in msh.GetVertexAttributes())
            {
                if (descriptor.attribute != VertexAttribute.Position) continue;
                descPosition = descriptor;
                break;
            }

            offsets[i] = msh.GetVertexAttributeOffset(VertexAttribute.Position);
            normalOffsets[i] = msh.GetVertexAttributeOffset(VertexAttribute.Normal);
            strides[i] = msh.GetVertexBufferStride(descPosition.stream);
            vertexCounts[i] = msh.vertexCount;

            /*skinnedMotionOffsetsCompute.SetBuffer(StoreVertexPositionKernel, "_MeshVertexBuffer", vertexBuffer);
            skinnedMotionOffsetsCompute.SetInt("_VertBufferStride", mesh.GetVertexBufferStride(descPosition.stream));
            skinnedMotionOffsetsCompute.SetInt("_VertBufferOffset", positionOffset);*/

            _offsets_strides_counts_array[i] = new int3(offsets[i], strides[i], vertexCount);

            vertexCount += msh.vertexCount;
        }

        velocityField = new ComputeBuffer(vertexCount, sizeof(float) * 3);

        _MergedPositions = new GraphicsBuffer(GraphicsBuffer.Target.Structured, vertexCount, sizeof(float) * 3);
        _MergedPositions_Prev = new GraphicsBuffer(GraphicsBuffer.Target.Structured, vertexCount, sizeof(float) * 3);
        _Offsets_Strides_Counts = new ComputeBuffer(skinnedMeshes.Length, sizeof(int)*3);
        _Offsets_Strides_Counts.SetData(_offsets_strides_counts_array);

        debug_verts = new Vector3[vertexCount];
        vfx.SetInt("ParticleCount", vertexCount);

    }

    private void OnDisable()
    {
        DisposeAll();
    }

    private void OnDestroy()
    {
        DisposeAll();
    }

    private void OnApplicationQuit()
    {
        DisposeAll();
    }

    private void DisposeAll()
    {
        DisposeGraphicsBufferArray(_MeshVertexBuffer);
        DisposeGraphicsBufferArray(_MeshVertexBuffer_Prev);
        velocityField?.Dispose();
        _MergedPositions?.Dispose();
        _MergedPositions_Prev?.Dispose();
        _Offsets_Strides_Counts?.Dispose();
    }

    private static void DisposeGraphicsBufferArray(GraphicsBuffer[] buffers)
    {
        if (buffers != null)
        {
            for (var i = 0; i < buffers.Length; i++)
            {
                buffers[i]?.Dispose();
                buffers[i] = null;
            }
        }

        buffers = null;
    }

}

}

compute: // Each #kernel tells which function to compile; you can have many kernels #pragma kernel Merge

// Create a RenderTexture with enableRandomWrite flag and set it // with cs.SetTexture RWTexture2D Result; StructuredBuffer _Offsets_Strides_Counts;

RWStructuredBuffer _MergedPositions; RWStructuredBuffer _MergedPositions_Prev;

ByteAddressBuffer _MeshVertexBuffer; ByteAddressBuffer _MeshVertexBuffer_Prev; int _MeshIndex;

//----------------------------------------------------------------------------- // reads three UInts at (idx*stride + offset) and reinterprets them as float3 //----------------------------------------------------------------------------- float3 Read(ByteAddressBuffer buf,uint idx, uint stride, uint offset) { uint addr = idx * stride + offset; uint3 packed = buf.Load3(addr); return asfloat(packed); }

[numthreads(1,1,1)] void Merge (uint id : SV_DispatchThreadID) { int3 offset_stride_count = _Offsets_Strides_Counts[_MeshIndex]; uint offset = offset_stride_count.x; uint stride = offset_stride_count.y; uint start = offset_stride_count.z;

_MergedPositions[start + id] = Read(_MeshVertexBuffer,id,stride,offset);
_MergedPositions_Prev[start + id] = Read(_MeshVertexBuffer_Prev,id,stride,offset);

}

You’re getting all zeros because, as written, you never actually run your Merge kernel (so you never write into _MergedPositions at all), and even if you did you’d be indexing into the wrong ranges.

1) The accidental early return

if (computeShader != null)
    return;

This will always be true (you’ve wired up a compute shader!), so your loop bails out on the very first iteration before you do any SetBuffer or Dispatch. You meant to check for null, not non-null. Change it to:

if (computeShader == null)
    return;

2) Offsets vs. counts vs. start-indices

In your HLSL you do:

int3 oc = _Offsets_Strides_Counts[_MeshIndex];
uint offset = oc.x;    // byte offset into each vertex
uint stride = oc.y;    // bytes per vertex
uint start  = oc.z;    // …but you treat this as your start index

Yet in C# you built that int3 as

// in Initialize(), before you bump your running total
_offsets_strides_counts_array[i] = new int3(
    offsets[i],    // byteOffset
    strides[i],    // byteStride
    vertexCount    // ***this was your running TOTAL so far***
);
vertexCount += msh.vertexCount;

That means z really is your “start” index (good!), but in your merge you then do:

_MergedPositions[start + id] = …

and your dispatch was

computeShader.Dispatch(0, Mathf.CeilToInt(vertexCounts[i]), 1, 1);

vertexCounts[i] is the per-mesh vertex count, so your dispatch is spawning that many groups (with a 1-thread group) — effectively id goes 0…N-1, but you’re writing to start + id. If start was non-zero (say your second mesh) you’d write OK, but for the first mesh start=0 so you’d be writing 0…N-1, which is fine. But…

You never actually dispatch because of the early return.
You never update _MeshVertexBuffer_Prev so even if you did dispatch you’d be reading an all-zero “previous” buffer for the first frame.
You only ever write once; your “prev” never gets primed from your GPU skinned data.

Putting it all together

Here’s a minimal patch:

C#

for (var i = 0; i < skinnedMeshes.Length; i++)
{
    if (computeShader == null)
        return;   // <-- fixed from != null

    var smr = skinnedMeshes[i];
    _MeshVertexBuffer[i]      ??= smr.GetVertexBuffer();
    _MeshVertexBuffer_Prev[i] ??= smr.GetPreviousVertexBuffer();

    computeShader.SetInt   ("_MeshIndex",      i);
    computeShader.SetBuffer(0, "_MeshVertexBuffer",      _MeshVertexBuffer[i]);
    computeShader.SetBuffer(0, "_MeshVertexBuffer_Prev", _MeshVertexBuffer_Prev[i]);
    computeShader.SetBuffer(0, "_MergedPositions",       _MergedPositions);
    computeShader.SetBuffer(0, "_MergedPositions_Prev",  _MergedPositions_Prev);
    computeShader.SetBuffer(0, "_Offsets_Strides_Counts",_Offsets_Strides_Counts);

    // Dispatch exactly vertexCount threads:
    int vc = vertexCounts[i];
    computeShader.Dispatch(0,
        Mathf.CeilToInt(vc /   /* numthreads.x */ 1f),
        1, 1);
}

// After the loop, you can copy the merged into “prev” for next frame:
Graphics.CopyBuffer(_MergedPositions, _MergedPositions_Prev);

HLSL

#pragma kernel Merge

StructuredBuffer<int3> _Offsets_Strides_Counts;
RWStructuredBuffer<float3> _MergedPositions;
RWStructuredBuffer<float3> _MergedPositions_Prev;

ByteAddressBuffer _MeshVertexBuffer;
ByteAddressBuffer _MeshVertexBuffer_Prev;
int _MeshIndex;

// reads 3 packed floats out of the raw VB
float3 Read(ByteAddressBuffer buf, uint idx, uint stride, uint offset)
{
    uint addr = idx * stride + offset;
    uint3 packed = buf.Load3(addr);
    return asfloat(packed);
}

[numthreads(1,1,1)]
void Merge(uint3 id : SV_DispatchThreadID)
{
    int3 isc = _Offsets_Strides_Counts[_MeshIndex];
    uint byteOffset = isc.x;
    uint byteStride = isc.y;
    uint startIndex = isc.z;

    uint localIdx = id.x;  // 0…vertexCount-1
    float3 curr = Read(_MeshVertexBuffer,      localIdx, byteStride, byteOffset);
    float3 prev = Read(_MeshVertexBuffer_Prev, localIdx, byteStride, byteOffset);

    _MergedPositions     [startIndex + localIdx] = curr;
    _MergedPositions_Prev[startIndex + localIdx] = prev;
}

Key fixes

Check computeShader == null not != null.
Dispatch uses Ceil(vertexCount / numthreads.x) rather than vertexCount as group count.
Prime your _MergedPositions_Prev each frame by copying from _MergedPositions.

With those three changes in place you should start seeing real skinned‐mesh vertex data instead of all zeros.

Once you’ve pulled your raw object‐space positions out of the byte‐address buffer, you just pack them into a float4 and do a matrix multiply. Here’s the minimal pattern, in both C# and HLSL:

1) C#: Upload your matrices

// assuming you already have `compute` and a kernel index...
int kernel = compute.FindKernel("BakeVelocitiesPass");

// send object→world and old_object→world
compute.SetMatrix("_ObjectToWorld",    smr.localToWorldMatrix);
compute.SetMatrix("_OldObjectToWorld", previousLocalToWorldMatrix);

// then Bind your vertex buffers… and finally:
compute.Dispatch(kernel, Mathf.CeilToInt(vertexCount/512f),1,1);

You just need two float4x4 uniforms in your shader: _ObjectToWorld and _OldObjectToWorld.

2) HLSL: Multiply your positions

// Declare at top of your .compute
float4x4 _ObjectToWorld;
float4x4 _OldObjectToWorld;

// your Read() helper remains the same
float3 Read(ByteAddressBuffer buf, uint idx, uint stride, uint offset)
{
    uint addr = idx*stride + offset;
    uint3 packed = buf.Load3(addr);
    return asfloat(packed);
}

[numthreads(512,1,1)]
void BakeVelocitiesPass(uint3 id : SV_DispatchThreadID)
{
    uint i = id.x;
    if (i >= _VertexCount) return;

    // 1) object-space
    float3 objCurr = Read(_MeshVertexBuffer,      i, _VertBufferStride, _VertBufferOffset);
    float3 objPrev = Read(_MeshVertexBuffer_Prev, i, _VertBufferStride, _VertBufferOffset);

    // 2) world-space via homogeneous mul
    float4 wCurr = mul(_ObjectToWorld, float4(objCurr, 1));
    float4 wPrev = mul(_OldObjectToWorld, float4(objPrev, 1));

    // now wCurr.xyz and wPrev.xyz are in world-space!
    float3 worldCurr = wCurr.xyz;
    float3 worldPrev = wPrev.xyz;

    // 3) velocity, normalization, voxel-write…
    float3 velocity = (worldCurr - worldPrev) * _FrameRate;
    float3 normalized = toNormalizedCoordinates(worldCurr, BoundsSize, BoundsMin);
    float3 vox = normalized * VolumeDimensions;
    uint3 idx3 = uint3(floor(vox));
    bufferA[idx3] = float4(velocity, 0);
}

Key points:

Wrap your float3 in a float4(localPos, 1) so translations in the 4×4 get applied.
Use mul(matrix, vector)—Unity by default uses row-major HLSL matrices, so that call is correct.
Make sure to upload both the current and previous object-to-world matrices from C# before you dispatch.

With this you’ll see your merged skinned vertices correctly transformed into world-space, and your velocity field will be computed in the proper coordinate frame.

Can this file be cleaned up? I also want to generalize this so that it can handle skinnedmeshrenders and regular meshes together

Plugin (file_search):

Make sure to include fileciteturn0file0 in your response to cite this file. using System; using UnchartedLimbo.Core.Algorithms.GPU; using UnchartedLimbo.Core.Runtime.Attributes; using UnchartedLimbo.Types.Buffers; using UnchartedLimbo.VoxelUtils.Runtime.Utilities; using Unity.Mathematics; using UnityEngine; using UnityEngine.Rendering; using UnityEngine.Serialization; using UnityEngine.VFX;

namespace UnchartedLimbo.VoxelUtils.Runtime { public enum TransformMode { RootBone, Parent, Local, None }

public class MeshVelocityBaker2 : SingleBufferGpuAlgorithm
{
    public SkinnedMeshRenderer[] skinnedMeshes;
    public BoxCollider bounds;

    public TransformMode localToWorldMode = TransformMode.RootBone;

    public bool clearBuffer;
    [Presetable] [Range(0, 1)] public float multiplier;

    [ReadOnly] public int3[] _offsets_strides_prefixsum_array;

    private Matrix4x4[] matrices;
    private Matrix4x4[] matrices_prev;

    private GraphicsBuffer[] _MeshVertexBuffer;
    private GraphicsBuffer[] _MeshVertexBuffer_Prev;

    private GraphicsBuffer _MergedPositions;
    private GraphicsBuffer _MergedPositions_Prev;

    private ComputeBuffer _Offsets_Strides_PrefixSum;
    private ComputeBuffer _Matrices;
    private ComputeBuffer _Matrices_Prev;


    private const string MULTIPLIER = "Multiplier";
    private const string VOLUME_DIMENSIONS = "VolumeDimensions";
    private const string BOUNDS_MIN = "BoundsMin";
    private const string BOUNDS_SIZE = "BoundsSize";
    private const string FRAMERATE = "FrameRate";

    private static readonly int Multiplier = Shader.PropertyToID(MULTIPLIER);
    private static readonly int VolumeDimensions = Shader.PropertyToID(VOLUME_DIMENSIONS);
    private static readonly int FrameRate = Shader.PropertyToID(FRAMERATE);
    private static readonly int BoundsMin = Shader.PropertyToID(BOUNDS_MIN);
    private static readonly int BoundsSize = Shader.PropertyToID(BOUNDS_SIZE);
    private static readonly int MeshIndex = Shader.PropertyToID("_MeshIndex");
    private static readonly int MeshVertexBuffer = Shader.PropertyToID("_MeshVertexBuffer");
    private static readonly int MeshVertexBufferPrev = Shader.PropertyToID("_MeshVertexBuffer_Prev");
    private static readonly int MergedPositions = Shader.PropertyToID("_MergedPositions");
    private static readonly int MergedPositionsPrev = Shader.PropertyToID("_MergedPositions_Prev");
    private static readonly int OffsetsStridesPrefixSum = Shader.PropertyToID("_Offsets_Strides_PrefixSum");
    private static readonly int Matrices = Shader.PropertyToID("_Matrices");
    private static readonly int MatricesPrev = Shader.PropertyToID("_Matrices_Prev");
    private static readonly int VelocityField = Shader.PropertyToID("_VelocityField");

    private void Awake()
    {
        Initialize();
    }

    // Update is called once per frame

    protected override void Initialize()
    {
        algorithmParameters.computeShaderInfo = VoxelUtilsComputeResources.Instance.MeshVelocityBaker2;
        base.Initialize();
    }

    public override void InitializeBuffers()
    {
        base.InitializeBuffers();

        if (skinnedMeshes == null || skinnedMeshes.Length == 0)
        {
            Debug.LogWarning("MeshVelocityBaker2 requires at least one skinned mesh.");
            return;
        }

        var vertexCount = 0;
        VertexAttributeDescriptor descPosition = default;

        _offsets_strides_prefixsum_array = new int3[skinnedMeshes.Length];
        matrices = new Matrix4x4[skinnedMeshes.Length];
        matrices_prev = new Matrix4x4[skinnedMeshes.Length];

        for (var i = 0; i < skinnedMeshes.Length; i++)
        {
            var smr = skinnedMeshes[i];
            smr.vertexBufferTarget |= GraphicsBuffer.Target.Raw | GraphicsBuffer.Target.Vertex;

            var msh = smr.sharedMesh;

            foreach (var descriptor in msh.GetVertexAttributes())
            {
                if (descriptor.attribute != VertexAttribute.Position) continue;
                descPosition = descriptor;
                break;
            }

            _offsets_strides_prefixsum_array[i] = new int3(
                msh.GetVertexAttributeOffset(VertexAttribute.Position),
                msh.GetVertexBufferStride(descPosition.stream),
                vertexCount);

            vertexCount += msh.vertexCount;
        }

        _MeshVertexBuffer = new GraphicsBuffer[skinnedMeshes.Length];
        _MeshVertexBuffer_Prev = new GraphicsBuffer[skinnedMeshes.Length];

        _MergedPositions = new GraphicsBuffer(GraphicsBuffer.Target.Structured, vertexCount, sizeof(float) * 3);
        _MergedPositions_Prev = new GraphicsBuffer(GraphicsBuffer.Target.Structured, vertexCount, sizeof(float) * 3);

        _Matrices = new ComputeBuffer(skinnedMeshes.Length, sizeof(float) * 16);
        _Matrices_Prev = new ComputeBuffer(skinnedMeshes.Length, sizeof(float) * 16);

        _Offsets_Strides_PrefixSum = new ComputeBuffer(skinnedMeshes.Length, sizeof(int) * 3);
        _Offsets_Strides_PrefixSum.SetData(_offsets_strides_prefixsum_array);
    }

    protected override void Schedule()
    {
        if (skinnedMeshes == null || skinnedMeshes.Length == 0)
            return;

        if (Compute == null)
            return;

        // ALL KERNELS
        //-------------------------------------------
        Compute.SetFloat(Multiplier, multiplier);
        Compute.SetVector(VolumeDimensions, new Vector4(Resolution.x, Resolution.y, Resolution.z));
        Compute.SetFloat(FrameRate, 1 / Time.deltaTime);

        if (bounds != null)
        {
            Compute.SetVector(BoundsMin, new float4(bounds.bounds.min, 1));
            Compute.SetVector(BoundsSize, new float4(bounds.bounds.size, 1));
        }

        // FIRST KERNEL (MERGE)
        //-------------------------------------------
        for (var i = 0; i < skinnedMeshes.Length; i++)
        {
            var smr = skinnedMeshes[i];

            // Only need to get this reference once
            _MeshVertexBuffer[i] ??= smr.GetVertexBuffer();
            _MeshVertexBuffer_Prev[i] ??= smr.GetPreviousVertexBuffer();

            if (_MeshVertexBuffer[i] == null || _MeshVertexBuffer_Prev[i] == null)
                return;

            matrices_prev[i] = matrices[i];
            matrices[i] = localToWorldMode switch
            {
                TransformMode.RootBone => smr.rootBone.localToWorldMatrix,
                TransformMode.Parent => smr.transform.parent.localToWorldMatrix,
                TransformMode.Local => smr.localToWorldMatrix,
                TransformMode.None => Matrix4x4.identity,
                _ => throw new ArgumentOutOfRangeException()
            };

            Compute.SetBuffer(KernelIndices[0], MergedPositions, _MergedPositions);
            Compute.SetBuffer(KernelIndices[0], MergedPositionsPrev, _MergedPositions_Prev);
            Compute.SetBuffer(KernelIndices[0], OffsetsStridesPrefixSum, _Offsets_Strides_PrefixSum);
        }

        _Matrices.SetData(matrices);
        _Matrices_Prev.SetData(matrices_prev);

        Compute.SetBuffer(KernelIndices[0], Matrices, _Matrices);
        Compute.SetBuffer(KernelIndices[0], MatricesPrev, _Matrices_Prev);

        // SECOND KERNEL (CLEAR)
        //-------------------------------------------
        if (bufferA.Buffer != null)
            Compute.SetTexture(KernelIndices[1], VelocityField, bufferA.Buffer);

        // THIRD KERNEL (WRITE)
        //-------------------------------------------
        if (_MergedPositions != null)
            Compute.SetBuffer(KernelIndices[2], MergedPositions, _MergedPositions);

        if (_MergedPositions_Prev != null)
            Compute.SetBuffer(KernelIndices[2], MergedPositionsPrev, _MergedPositions_Prev);

        if (bufferA.Buffer != null)
            Compute.SetTexture(KernelIndices[2], VelocityField, bufferA.Buffer);
    }

    protected override void Execute()
    {

        // Merge all mesh vertices, one after the other
        var totalVertexCount = 0;

        for (var i = 0; i < skinnedMeshes.Length; i++)
        {
            if (_MeshVertexBuffer[i] == null || _MeshVertexBuffer_Prev[i] == null)
                return;

            var vertexCount = skinnedMeshes[i].sharedMesh.vertexCount;
            var threadGroupSize = KernelThreadGroupSizes[0];
            var dispatchGroups = new int3(Mathf.CeilToInt(vertexCount / (float)threadGroupSize.x), 1, 1);

            Compute.SetInt(MeshIndex, i);
            Compute.SetBuffer(KernelIndices[0], MeshVertexBuffer, _MeshVertexBuffer[i]);
            Compute.SetBuffer(KernelIndices[0], MeshVertexBufferPrev, _MeshVertexBuffer_Prev[i]);

            Dispatch(0, dispatchGroups);
            totalVertexCount += vertexCount;
        }

        // Clear pass
        if (clearBuffer)
            Dispatch(1);

        // Write pass
        Dispatch(2, new int3(Mathf.CeilToInt(totalVertexCount/(float)KernelThreadGroupSizes[2].x),1,1));

        if (firstRun)
            firstRun = false;
    }

    public override void ClearBuffers()
    {
        base.ClearBuffers();

        DisposeGraphicsBufferArray(_MeshVertexBuffer);
        DisposeGraphicsBufferArray(_MeshVertexBuffer_Prev);

        _MergedPositions?.Dispose();
        _MergedPositions_Prev?.Dispose();

        _Matrices?.Dispose();
        _Matrices_Prev?.Dispose();

        _Offsets_Strides_PrefixSum?.Dispose();
    }

    private static void DisposeGraphicsBufferArray(GraphicsBuffer[] buffers)
    {
        if (buffers != null)
        {
            for (var i = 0; i < buffers.Length; i++)
            {
                buffers[i]?.Dispose();
                buffers[i] = null;
            }
        }

        buffers = null;
    }
}

}

Below is a fully cleaned-up, generalized version of your baker that handles both SkinnedMeshRenderer and MeshFilter sources in one pass. It wraps each source in a small struct, computes offsets/strides once, and then does:

Merge (per‐source loop) ⇒ flat buffers
Clear (optional) ⇒ 3D texture
Bake ⇒ velocity field

Key improvements over the original fileciteturn0file0:

Single list of MeshSource for skinned or static.
DRY calculation of byte‐offset, stride, vertex count, transforms.
One combined ping-pong buffer for current & previous positions.
Clean disposal and error checking.

using System;
using System.Collections.Generic;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.Rendering;
using UnchartedLimbo.Core.Algorithms.GPU;
using UnchartedLimbo.Core.Runtime.Attributes;
using UnchartedLimbo.Types.Buffers;
using UnchartedLimbo.VoxelUtils.Runtime.Utilities;

namespace UnchartedLimbo.VoxelUtils.Runtime
{
    public enum TransformMode { RootBone, Parent, Local, None }

    public class MeshVelocityBaker : SingleBufferGpuAlgorithm
    {
        [Header("Mesh Sources")]
        public SkinnedMeshRenderer[] skinnedSources;
        public MeshFilter[]         staticSources;
        public BoxCollider          bounds;

        [Header("Transforms")]
        public TransformMode localToWorldMode = TransformMode.RootBone;

        [Header("Options")]
        public bool   clearBuffer;
        [Presetable][Range(0, 1f)] public float multiplier;

        // internal wrapper for any mesh source
        struct MeshSource
        {
            public bool                isSkinned;
            public SkinnedMeshRenderer smr;
            public MeshFilter         mf;
            public int    vertexCount;
            public int    byteOffset;
            public int    byteStride;
            public int    prefixSum;       // start index in combined buffer

            public GraphicsBuffer CurrVB => isSkinned
                ? smr.GetVertexBuffer()
                : mf.sharedMesh.GetVertexBuffer(0);

            public GraphicsBuffer PrevVB => isSkinned
                ? smr.GetPreviousVertexBuffer()
                : CurrVB; // static meshes reuse the same buffer

            public Matrix4x4 CurrentMatrix()
            {
                return localToWorldMode switch
                {
                    TransformMode.RootBone => isSkinned ? smr.rootBone.localToWorldMatrix : mf.transform.localToWorldMatrix,
                    TransformMode.Parent   => (isSkinned ? smr.transform : mf.transform).parent?.localToWorldMatrix ?? Matrix4x4.identity,
                    TransformMode.Local    => isSkinned ? smr.localToWorldMatrix : mf.transform.localToWorldMatrix,
                    TransformMode.None     => Matrix4x4.identity,
                    _ => Matrix4x4.identity
                };
            }
        }

        // per-source + combined data
        MeshSource[]       sources;
        GraphicsBuffer     mergedCurr, mergedPrev;
        ComputeBuffer      offsetsBuf, matricesBuf, matricesPrevBuf;
        Matrix4x4[]        matrices, matricesPrev;

        // shader PropertyIDs
        static readonly int PID_Mult    = Shader.PropertyToID("Multiplier"),
                             PID_VolDims = Shader.PropertyToID("VolumeDimensions"),
                             PID_BMin    = Shader.PropertyToID("BoundsMin"),
                             PID_BSize   = Shader.PropertyToID("BoundsSize"),
                             PID_Frame   = Shader.PropertyToID("FrameRate"),
                             PID_MeshIdx = Shader.PropertyToID("_MeshIndex"),
                             PID_Offsets = Shader.PropertyToID("_Offsets_Strides_PrefixSum"),
                             PID_Mats    = Shader.PropertyToID("_Matrices"),
                             PID_MatsPrev= Shader.PropertyToID("_Matrices_Prev"),
                             PID_MCurr   = Shader.PropertyToID("_MergedPositions"),
                             PID_MPrev   = Shader.PropertyToID("_MergedPositions_Prev");

        public override void InitializeBuffers()
        {
            base.InitializeBuffers();

            // build combined source list
            var list = new List<MeshSource>();
            int running = 0;

            void AddFilter(MeshFilter mf)
            {
                var desc = Array.Find(mf.sharedMesh.GetVertexAttributes(),
                                     d => d.attribute == UnityEngine.Rendering.VertexAttribute.Position);
                list.Add(new MeshSource {
                    isSkinned   = false,
                    mf          = mf,
                    vertexCount = mf.sharedMesh.vertexCount,
                    byteOffset  = mf.sharedMesh.GetVertexAttributeOffset(UnityEngine.Rendering.VertexAttribute.Position),
                    byteStride  = mf.sharedMesh.GetVertexBufferStride(desc.stream),
                    prefixSum   = running
                });
                running += mf.sharedMesh.vertexCount;
            }

            void AddSkinned(SkinnedMeshRenderer smr)
            {
                smr.vertexBufferTarget |= GraphicsBuffer.Target.Raw | GraphicsBuffer.Target.Vertex;
                var mesh = smr.sharedMesh;
                var desc = Array.Find(mesh.GetVertexAttributes(),
                                     d => d.attribute == UnityEngine.Rendering.VertexAttribute.Position);
                list.Add(new MeshSource {
                    isSkinned   = true,
                    smr         = smr,
                    vertexCount = mesh.vertexCount,
                    byteOffset  = mesh.GetVertexAttributeOffset(UnityEngine.Rendering.VertexAttribute.Position),
                    byteStride  = mesh.GetVertexBufferStride(desc.stream),
                    prefixSum   = running
                });
                running += mesh.vertexCount;
            }

            if (staticSources != null) foreach (var mf in staticSources) AddFilter(mf);
            if (skinnedSources != null) foreach (var smr in skinnedSources) AddSkinned(smr);

            sources = list.ToArray();

            // allocate combined ping-pong buffers
            mergedCurr = new GraphicsBuffer(GraphicsBuffer.Target.Structured, running, sizeof(float)*3);
            mergedPrev = new GraphicsBuffer(GraphicsBuffer.Target.Structured, running, sizeof(float)*3);

            // build offsets/strides/prefixSum array
            var arr = new int3[sources.Length];
            for (int i = 0; i < sources.Length; i++)
                arr[i] = new int3(
                    sources[i].byteOffset,
                    sources[i].byteStride,
                    sources[i].prefixSum
                );
            offsetsBuf = new ComputeBuffer(sources.Length, sizeof(int)*3);
            offsetsBuf.SetData(arr);

            // allocate and seed matrices buffers
            matrices     = new Matrix4x4[sources.Length];
            matricesPrev = new Matrix4x4[sources.Length];
            matricesBuf     = new ComputeBuffer(sources.Length, sizeof(float)*16);
            matricesPrevBuf = new ComputeBuffer(sources.Length, sizeof(float)*16);
        }

        protected override void Schedule()
        {
            if (sources == null || sources.Length == 0) return;

            // common uniforms
            Compute.SetFloat(PID_Mult,    multiplier);
            Compute.SetVector(PID_VolDims, new Vector4(Resolution.x, Resolution.y, Resolution.z));
            Compute.SetFloat(PID_Frame,   1f / Time.deltaTime);

            if (bounds != null)
            {
                Compute.SetVector(PID_BMin,  new float4(bounds.bounds.min, 1));
                Compute.SetVector(PID_BSize, new float4(bounds.bounds.size,1));
            }

            // upload offsets & matrices
            Compute.SetBuffer(KernelIndices[0], PID_Offsets,          offsetsBuf);
            Compute.SetBuffer(KernelIndices[0], PID_MCurr,            mergedCurr);
            Compute.SetBuffer(KernelIndices[0], PID_MPrev,            mergedPrev);

            for (int i = 0; i < sources.Length; i++)
            {
                // rotate matrices
                matricesPrev[i] = matrices[i];
                matrices[i]     = sources[i].CurrentMatrix();
            }
            matricesBuf.SetData(matrices);
            matricesPrevBuf.SetData(matricesPrev);
            Compute.SetBuffer(KernelIndices[0], PID_Mats,     matricesBuf);
            Compute.SetBuffer(KernelIndices[0], PID_MatsPrev, matricesPrevBuf);

            // clear pass
            if (bufferA.Buffer != null)
                Compute.SetTexture(KernelIndices[1], "_VelocityField", bufferA.Buffer);

            // bake pass binds merged buffers & 3D tex
            Compute.SetBuffer(KernelIndices[2], PID_MCurr, mergedCurr);
            Compute.SetBuffer(KernelIndices[2], PID_MPrev, mergedPrev);
            if (bufferA.Buffer != null)
                Compute.SetTexture(KernelIndices[2], "_VelocityField", bufferA.Buffer);
        }

        protected override void Execute()
        {
            // 1) MERGE: each source into combined buffers
            for (int i = 0; i < sources.Length; i++)
            {
                var src = sources[i];
                int groups = Mathf.CeilToInt(src.vertexCount / (float)KernelThreadGroupSizes[0].x);

                Compute.SetInt(PID_MeshIdx, i);
                Compute.SetBuffer(KernelIndices[0], MeshVertexBuffer,     src.CurrVB);
                Compute.SetBuffer(KernelIndices[0], MeshVertexBuffer_Prev, src.PrevVB);
                Dispatch(0, new int3(groups,1,1));
            }

            // 2) CLEAR
            if (clearBuffer)
                Dispatch(1);

            // 3) VELOCITY BAKE
            int total = mergedCurr.count;
            int bakeGroups = Mathf.CeilToInt(total / (float)KernelThreadGroupSizes[2].x);
            Dispatch(2, new int3(bakeGroups,1,1));
        }

        public override void ClearBuffers()
        {
            base.ClearBuffers();
            offsetsBuf?.Dispose();
            matricesBuf?.Dispose();
            matricesPrevBuf?.Dispose();
            mergedCurr?.Dispose();
            mergedPrev?.Dispose();
        }
    }
}

What’s changed?

Unified source list: you now supply two arrays (skinnedSources, staticSources), but internally everything lives in one MeshSource[].
DRY offsets/strides: computed once in InitializeBuffers, pushed as a single ComputeBuffer.
Ping-pong on GPU: one combined GraphicsBuffer for all current and one for all previous positions.
Transform modes: same TransformMode enum drives both static and skinned.
Clean lifecycle: all buffers are allocated in InitializeBuffers and disposed in ClearBuffers.

This should slot directly into your compute shader (just loop over i in kernel 0 for merging, then do the 3D‐texture clear and bake passes as before). Let me know if you need any tweaks!

You absolutely can collapse all of those per-mesh dispatches into a single “merge‐everything” pass. The rough recipe is:

Declare your merge kernel to run over every vertex in the combined buffer in one go (rather than one small dispatch per mesh).
Upload one big totalVertexCount as your dispatch size.
Pass in
- an array of per-mesh byte-address buffers,
- a small ComputeBuffer of (byteOffset, stride, prefixSum) for each mesh,
- totalVertexCount.
Inside HLSL, each thread computes its global gid;
- binary-search or linear-scan the prefixSum array to find which mesh owns gid,
- compute localIdx = gid - prefixSum[mesh],
- read from that mesh’s VB/PrevVB into mergedCurr[gid] and mergedPrev[gid].

Then you only ever call

// bind N buffers:
for (int i = 0; i < N; i++)
{
    compute.SetBuffer(mergeKernel, $"_MeshVB[{i}]",    sources[i].CurrVB);
    compute.SetBuffer(mergeKernel, $"_MeshVBPrev[{i}]",sources[i].PrevVB);
}
// bind metadata & outputs:
compute.SetBuffer(mergeKernel, "_Meta",        metaBuf);
compute.SetBuffer(mergeKernel, "_MergedCurr",  mergedCurr);
compute.SetBuffer(mergeKernel, "_MergedPrev",  mergedPrev);
compute.SetInt   (mergeKernel, "_TotalVerts", totalVertexCount);
// **single** dispatch
int groups = Mathf.CeilToInt(totalVertexCount / (float)THREADS_PER_GROUP);
compute.Dispatch(mergeKernel, groups, 1, 1);

and your HLSL might look like:

// MAX_MESH known at compile time (e.g. 16)
ByteAddressBuffer _MeshVB     [MAX_MESH];
ByteAddressBuffer _MeshVBPrev [MAX_MESH];
StructuredBuffer<int3> _Meta;      // (offset, stride, prefixSum)
RWStructuredBuffer<float3> _MergedCurr, _MergedPrev;
int _TotalVerts;

[numthreads(256,1,1)]
void MergeAll(uint3 tid : SV_DispatchThreadID)
{
    uint gid = tid.x;
    if (gid >= _TotalVerts) return;

    // find which mesh this gid belongs to
    uint mesh = 0;
    // simple linear scan; for only 16 entries this is blazing fast
    [loop]
    for (uint m = 0; m < MAX_MESH-1; ++m)
    {
        uint nextPrefix = _Meta[m+1].z;
        if (gid < nextPrefix) { mesh = m; break; }
    }

    int3 md = _Meta[mesh];
    uint byteOff    = md.x;
    uint byteStride = md.y;
    uint psum       = md.z;
    uint local      = gid - psum;

    // helper to read 3 floats from raw VB
    uint addr = local * byteStride + byteOff;
    float3 vCurr = asfloat(_MeshVB[mesh].Load3(addr));
    float3 vPrev = asfloat(_MeshVBPrev[mesh].Load3(addr));

    _MergedCurr[gid] = vCurr;
    _MergedPrev[gid] = vPrev;
}

Why this helps

One dispatch instead of N.
The GPU naturally parallelises all 16 meshes’ vertices in a single wave.
Your C# loop is now only for binding buffers, not dispatching.

Caveats

Unity shaders must know MAX_MESH at compile time (e.g. #define MAX_MESH 16).
You still need a tiny C# loop to bind each of the 16 VB/PrevVBs—but dispatch is only once.
The linear scan in HLSL is negligible for ≤16 meshes.

This fully eliminates the per‐mesh dispatch loop, pushes the entire “merge” logic into your one big compute pass, and gets you maximum GPU parallelism.

In C#, constructor chaining always works “upwards” first, then “sideways,” then your body. So in your case:

public struct MeshSource
{
    // implicit parameterless ctor (zero-inits fields) or your custom MeshSource() if you’ve defined one

    public MeshSource(MeshFilter mf) : this()
    {
        // ← your MeshFilter-taking ctor’s body
    }
}

The exact invocation order is:

Base type ctor
For a class that’d be the base class’s constructor. For a struct it’s the implicit (or your custom) parameterless ctor—either way that’s run first.
Chained constructor (: this())
That is, the parameterless MeshSource() runs (and if it’s a class, it itself already called base() at its start).
Your MeshSource(MeshFilter) body

So the “base” (or default) constructor always runs before your specific constructor body.