Voxelizer Box Size Fix

2026-02-03 16:53 UTC gpt-5-2-thinking Open in ChatGPT ↗

You

I need to make this voxelizer work with arbitrary box sizes, not just perfect cubes as it is now.

this is Unity HLSL

#pragma kernel Zero #pragma kernel MeshToVoxel

// Resolution uint voxelSide;

// Bounds float3 minCorner; float3 boundsSize;

// Mesh Data Texture2D VertexBuffer;

// Output RWTexture3D Voxels; float4x4 transform;

float3 Flip; float MaxZ;

[numthreads(8, 8, 8)] void Zero(uint3 id : SV_DispatchThreadID) { Voxels[id] = half4(0.0f, 0.0f, 0.0f, 0.0f); }

float3 toNormalizedCoordinates(float3 xyz, float3 size, float3 minCorner ) { float maxSize = max(max(size.x, size.y), size.z); float3 scalingFactor = size.xyz / maxSize; float3 offset = minCorner;

return ((xyz - offset) / maxSize) / scalingFactor;

}

[numthreads(32,32,1)] void MeshToVoxel(uint3 id : SV_DispatchThreadID) {

float3 p = VertexBuffer[id.xy];

p = mul(p,transform) *Flip;

float3 pNorm = toNormalizedCoordinates(p, boundsSize, minCorner) ;

float3 scaled = pNorm * voxelSide;

uint3 voxelIdx = uint3(floor(scaled));

float distFromCenter = 1.0 - length(frac(scaled) - float3(0.5, 0.5, 0.5));

float value = p.z < MaxZ ? distFromCenter: 0;

Voxels[voxelIdx] = float4(value, value, value, value);

}

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

Right now you’re forcing everything into a cube space by normalizing with maxSize. That’s why it only behaves correctly for perfect cubes.

To support an arbitrary axis-aligned box (different X/Y/Z sizes), you want to:

1. Normalize per-axis into $[0,1]$:
   $ p01 = (p - minCorner) / boundsSize $
2. Scale into voxel dimensions per-axis (not a single voxelSide):
   $ v = p01 * voxelDims $
3. Clamp / bounds-check before writing into RWTexture3D, because non-cube sizes make out-of-range writes more likely.

Below is a drop-in rewrite that keeps your intent but removes the “maxSize cube” assumption.

---

Minimal changes: use uint3 voxelDims instead of uint voxelSide

#pragma kernel Zero
#pragma kernel MeshToVoxel

// Resolution (per-axis)
uint3 voxelDims;   // (width, height, depth)

// Bounds
float3 minCorner;
float3 boundsSize;

// Mesh Data
Texture2D<float3> VertexBuffer;

// Output
RWTexture3D<float4> Voxels;

float4x4 transform;
float3 Flip;
float MaxZ;

[numthreads(8, 8, 8)]
void Zero(uint3 id : SV_DispatchThreadID)
{
    // If you dispatch a bit larger than the texture, avoid OOB writes.
    if (any(id >= voxelDims)) return;
    Voxels[id] = float4(0, 0, 0, 0);
}

float3 ToBox01(float3 pWorld, float3 minC, float3 size)
{
    // Normalize into [0..1] over the *actual* box size per-axis.
    return (pWorld - minC) / size;
}

[numthreads(32, 32, 1)]
void MeshToVoxel(uint3 id : SV_DispatchThreadID)
{
    float3 p = VertexBuffer[id.xy];

    // Transform to world (or whatever space your bounds are in)
    p = mul(float4(p, 1.0f), transform).xyz * Flip;

    // Per-axis normalized coordinates in the bounds box
    float3 p01 = ToBox01(p, minCorner, boundsSize);

    // If outside bounds, skip (important for non-cubes)
    // Using >= 1 also excludes the max face, keeping indices in-range.
    if (any(p01 < 0.0f) || any(p01 >= 1.0f))
        return;

    // Scale into voxel grid space
    float3 grid = p01 * (float3)voxelDims;

    // Compute voxel index (guaranteed in-range due to p01 < 1)
    uint3 voxelIdx = (uint3)grid;

    // Local position inside the voxel [0..1)
    float3 f = frac(grid);

    // Your existing “distance from center” value
    float distFromCenter = 1.0 - length(f - float3(0.5, 0.5, 0.5));

    // Keep your MaxZ logic (note: uses p.z in the same space as MaxZ)
    float value = (p.z < MaxZ) ? distFromCenter : 0.0;

    Voxels[voxelIdx] = float4(value, value, value, value);
}

What changed (and why)

• Removed maxSize normalization: that was warping your box into a cube.
• Replaced voxelSide with voxelDims: lets you have (Nx, Ny, Nz) voxel counts.
• Added bounds checks: prevents invalid writes and handles meshes that poke outside the bounds.

---

If you must keep a single “density” value

Sometimes you want “voxels per meter” (or similar) and then derive dims from bounds:

• On CPU: compute
  • voxelDims.x = ceil(boundsSize.x * density)
  • voxelDims.y = ceil(boundsSize.y * density)
  • voxelDims.z = ceil(boundsSize.z * density)
• Create the RenderTexture / RWTexture3D with those dimensions.
• Pass voxelDims to the shader.

This gives uniform voxel size in world units across all axes, while still allowing non-cube textures.

---

Two easy gotchas to watch

1. MaxZ space: You’re testing p.z < MaxZ after transform and flip. Make sure MaxZ is defined in that same space.
2. Dispatch sizes:
   • Zero must cover the whole 3D texture. If you dispatch in groups, your thread grid should match voxelDims (or do the bounds check like above).
   • MeshToVoxel is 2D-dispatching over VertexBuffer texel coordinates; make sure you don’t read outside the vertex texture.

---

If you tell me how you currently choose voxelSide (eg “128 voxels along longest axis” vs “N voxels per meter”), I can show the exact CPU-side formula to compute voxelDims so the voxel size stays consistent and the box fills the texture perfectly.

You

now we need to adapt this JFA (jump flood) 3d compute shader, to make it work with non-cubic boxes.

// Each #kernel tells which function to compile; you can have many kernels

#pragma kernel Preprocess #pragma kernel JFA #pragma kernel Postprocess #pragma kernel Zero

#include ”./ShaderConditionals.hlsl” #include ”./ShaderUtils.hlsl”

uint dispatchCubeSide; uint samplingOffset; float postProcessThickness; float fracRepetitions; float cutOff; float transitionSharpness; int resultType;

RWTexture3D Voxels;

[numthreads(8, 8, 8)] void Zero(uint3 id : SV_DispatchThreadID) { Voxels[id] = float4(0.0f, 0.0f, 0.0f, 0.0f); }

void JFAIter(uint offset, uint3 id) { float3 idF = float3(id); float4 closest = Voxels[id]; float closestDist = 500000.0f; uint3 bounds = uint3(dispatchCubeSide, dispatchCubeSide, dispatchCubeSide);

for (uint i = 0; i < 3; i++)
{
  for (uint j = 0; j < 3; j++)
  {
    for (uint k = 0; k < 3; k++)
    {

      uint3 at = uint3(i - 1, j - 1, k - 1) * offset + id;
      if (any(at < 0) || any(at >= bounds)) continue;

      float4 voxel = Voxels[at];

      // non seed / hasn't seen a seed
      if (voxel.w == 0.0f) continue;

      float voxelDist = distance(idF, voxel.xyz);

      if (voxelDist < closestDist)
      {
        closestDist = voxelDist;
        closest = voxel;
      }
    }
  }
}

Voxels[id] = closest;

}

[numthreads(8, 8, 8)] void Preprocess(uint3 id : SV_DispatchThreadID) { float isVoxel = Voxels[id].x; Voxels[id] = float4( (float)id.x, (float) id.y, (float) id.z, isVoxel); }

[numthreads(8, 8, 8)] void JFA(uint3 id : SV_DispatchThreadID) { JFAIter(samplingOffset, id); }

[numthreads(8, 8, 8)] void Postprocess(uint3 id : SV_DispatchThreadID) { float3 seedPos = Voxels[id].xyz;

float dist = (distance(seedPos, float3(id)) / (float)dispatchCubeSide) - postProcessThickness;

float ts = transitionSharpness;

// Apply SDF Repetitions
float reps = frac(abs(dist) * fracRepetitions);// - 0.5;
reps = 2 * abs(reps - 0.5);

// Normalize SDF
float normalized = saturate(remap(0.0, cutOff, 1.0, 0.0, 2.0 * dist));

// Create smooth mask
float mask = smoothstep(0.5 - ts, 0.5 + ts, normalized);

// Apply SDF CutOff
float repDist = reps * mask; // lerp(reps,dist,equals(reps,0.0));

if(resultType == 0)
{
  Voxels[id] = float4(repDist, mask, dist, 1.0);
}
else
{
  Voxels[id] =  float4(dist, dist, dist, dist);
}

}

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

Yep — same root issue as before: the shader assumes a single dispatchCubeSide and it also has a subtle bug (any(at < 0) can never be true because at is uint3). For non-cubic boxes you want:

• Bounds = uint3 dispatchDims (width/height/depth)
• Bounds checks that actually work (use int3 for neighbor coords)
• Distance normalization: don’t divide by dispatchCubeSide. Either:
  • normalize by max(dispatchDims) (simple), or
  • normalize by a per-axis scale if your voxels represent different world sizes per axis (more correct if voxel sizes differ in world space)

Below is a clean adaptation that works for arbitrary dispatchDims.

---

Updated JFA 3D compute shader for non-cubic volumes

#pragma kernel Preprocess
#pragma kernel JFA
#pragma kernel Postprocess
#pragma kernel Zero

#include "./ShaderConditionals.hlsl"
#include "./ShaderUtils.hlsl"

// Dimensions of the 3D texture / voxel volume
uint3 dispatchDims;          // (Nx, Ny, Nz)

// Jump offset (still scalar, works fine; CPU should halve each pass)
uint samplingOffset;

float postProcessThickness;
float fracRepetitions;
float cutOff;
float transitionSharpness;
int resultType;

RWTexture3D<float4> Voxels;

[numthreads(8, 8, 8)]
void Zero(uint3 id : SV_DispatchThreadID)
{
    if (any(id >= dispatchDims)) return;
    Voxels[id] = float4(0, 0, 0, 0);
}

void JFAIter(uint offset, uint3 id)
{
    if (any(id >= dispatchDims)) return;

    float3 idF = (float3)id;

    float4 closest = Voxels[id];
    float closestDist = 1e20;

    int3 boundsI = (int3)dispatchDims;
    int3 idI = (int3)id;

    // 3x3x3 neighborhood at "offset" jumps
    [unroll] for (int i = -1; i <= 1; i++)
    {
        [unroll] for (int j = -1; j <= 1; j++)
        {
            [unroll] for (int k = -1; k <= 1; k++)
            {
                int3 atI = idI + int3(i, j, k) * (int)offset;

                // Correct OOB test (works because atI is signed)
                if (any(atI < 0) || any(atI >= boundsI))
                    continue;

                uint3 at = (uint3)atI;
                float4 voxel = Voxels[at];

                // Not a seed / hasn't seen a seed
                if (voxel.w == 0.0f)
                    continue;

                // Distance in voxel-index space
                float voxelDist = distance(idF, voxel.xyz);

                if (voxelDist < closestDist)
                {
                    closestDist = voxelDist;
                    closest = voxel;
                }
            }
        }
    }

    Voxels[id] = closest;
}

[numthreads(8, 8, 8)]
void Preprocess(uint3 id : SV_DispatchThreadID)
{
    if (any(id >= dispatchDims)) return;

    float isVoxel = Voxels[id].x; // your "seed" marker
    Voxels[id] = float4((float)id.x, (float)id.y, (float)id.z, isVoxel);
}

[numthreads(8, 8, 8)]
void JFA(uint3 id : SV_DispatchThreadID)
{
    JFAIter(samplingOffset, id);
}

[numthreads(8, 8, 8)]
void Postprocess(uint3 id : SV_DispatchThreadID)
{
    if (any(id >= dispatchDims)) return;

    float3 seedPos = Voxels[id].xyz;

    // Normalize distance: use max dimension (works for non-cubic grids)
    float maxDim = (float)max(dispatchDims.x, max(dispatchDims.y, dispatchDims.z));

    float dist = (distance(seedPos, (float3)id) / maxDim) - postProcessThickness;

    float ts = transitionSharpness;

    // Apply SDF repetitions
    float reps = frac(abs(dist) * fracRepetitions);
    reps = 2 * abs(reps - 0.5);

    // Normalize SDF (your remap is from ShaderUtils)
    float normalized = saturate(remap(0.0, cutOff, 1.0, 0.0, 2.0 * dist));

    // Smooth mask
    float mask = smoothstep(0.5 - ts, 0.5 + ts, normalized);

    float repDist = reps * mask;

    if (resultType == 0)
        Voxels[id] = float4(repDist, mask, dist, 1.0);
    else
        Voxels[id] = float4(dist, dist, dist, dist);
}

---

Important note: what “non-cubic” means for distance

The above makes the volume non-cubic (different voxel counts per axis) and keeps distance in voxel-index units.

If your voxels represent uniform world spacing (same world size per voxel along x/y/z), this is correct.

If instead your voxels correspond to a stretched box where voxel world size differs per axis (anisotropic voxels), then Euclidean distance should be computed in world units by scaling axes:

// pass this from CPU if needed:
float3 voxelWorldSize; // world meters per voxel step (x,y,z)

// then:
float3 d = (seedPos - (float3)id) * voxelWorldSize;
float distWorld = length(d);

…and normalize by something like max(boundsSize) or your chosen scale.

---

CPU-side reminders (so the whole JFA works on a box)

• Set dispatchDims to the 3D texture dimensions.
• Dispatch thread groups using ceil-div per axis:
  • (dispatchDims + (8-1)) / 8 for these kernels.
• Your JFA loop (CPU) should choose offsets based on the largest dimension:
  • start at highestPowerOfTwoCeil(max(dispatchDims)) / 2, then halve until 1.

That’s it.

If you paste how you’re currently computing samplingOffset and dispatching the kernels from C#, I can rewrite that snippet too so it correctly handles uint3 dispatchDims end-to-end.

You

yes, my voxels could be stretched. account for this and give me the final coe

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

Got it — if voxels can be stretched (anisotropic voxel size in world space), then all distances in JFA + Postprocess must be computed in world units, not voxel-index units.

That means:

• Store seed position in world space in Voxels[id].xyz during Preprocess
• Compute distances in world space in JFAIter
• Normalize distance in Postprocess by a world-space extent (eg max(volumeWorldSize))

Here’s the “final” adapted shader (non-cubic + stretched voxels), with the important fixes included.

#pragma kernel Preprocess
#pragma kernel JFA
#pragma kernel Postprocess
#pragma kernel Zero

#include "./ShaderConditionals.hlsl"
#include "./ShaderUtils.hlsl"

// Dimensions of the 3D texture (non-cubic supported)
uint3 dispatchDims;              // (Nx, Ny, Nz)

// JFA jump offset (scalar, CPU halves it each pass)
uint samplingOffset;

// World-space mapping for anisotropic voxels
float3 minCornerWorld;           // world-space origin of the voxel volume (same space as your mesh bounds)
float3 voxelWorldSize;           // world units per voxel step along x/y/z (can be different)

// Postprocess params
float postProcessThickness;      // in *normalized* distance units (see below)
float fracRepetitions;
float cutOff;
float transitionSharpness;
int resultType;

// Output 3D texture
RWTexture3D<float4> Voxels;

// Convert voxel index -> world position (centered)
float3 VoxelIndexToWorld(uint3 id)
{
    // +0.5 to sample at voxel centers (recommended for SDF stability)
    return minCornerWorld + ((float3)id + 0.5f) * voxelWorldSize;
}

// Max world extent for normalization (avoids cube assumption)
float MaxWorldExtent()
{
    float3 volumeWorldSize = (float3)dispatchDims * voxelWorldSize;
    return max(volumeWorldSize.x, max(volumeWorldSize.y, volumeWorldSize.z));
}

[numthreads(8, 8, 8)]
void Zero(uint3 id : SV_DispatchThreadID)
{
    if (any(id >= dispatchDims)) return;
    Voxels[id] = float4(0, 0, 0, 0);
}

void JFAIter(uint offset, uint3 id)
{
    if (any(id >= dispatchDims)) return;

    // World position of the current voxel center
    float3 idWorld = VoxelIndexToWorld(id);

    float4 closest = Voxels[id];
    float closestDist = 1e30;

    int3 boundsI = (int3)dispatchDims;
    int3 idI = (int3)id;

    // Search 3x3x3 neighborhood at jump distance "offset"
    [unroll] for (int i = -1; i <= 1; i++)
    {
        [unroll] for (int j = -1; j <= 1; j++)
        {
            [unroll] for (int k = -1; k <= 1; k++)
            {
                int3 atI = idI + int3(i, j, k) * (int)offset;

                // Correct bounds test (must be signed)
                if (any(atI < 0) || any(atI >= boundsI))
                    continue;

                uint3 at = (uint3)atI;
                float4 voxel = Voxels[at];

                // Not a seed / hasn't been assigned a seed yet
                if (voxel.w == 0.0f)
                    continue;

                // voxel.xyz stores seed WORLD position (set in Preprocess)
                float d = distance(idWorld, voxel.xyz);

                if (d < closestDist)
                {
                    closestDist = d;
                    closest = voxel;
                }
            }
        }
    }

    Voxels[id] = closest;
}

[numthreads(8, 8, 8)]
void Preprocess(uint3 id : SV_DispatchThreadID)
{
    if (any(id >= dispatchDims)) return;

    // You currently use Voxels[id].x as your seed marker.
    // Keep that behavior: if x > 0 => seed (or whatever convention you use).
    float isSeed = Voxels[id].x;

    float3 seedWorld = VoxelIndexToWorld(id);

    // Store seed world position in xyz, and seed-flag in w.
    // Non-seeds keep w==0 so they get skipped by JFA until assigned.
    Voxels[id] = float4(seedWorld, isSeed);
}

[numthreads(8, 8, 8)]
void JFA(uint3 id : SV_DispatchThreadID)
{
    JFAIter(samplingOffset, id);
}

[numthreads(8, 8, 8)]
void Postprocess(uint3 id : SV_DispatchThreadID)
{
    if (any(id >= dispatchDims)) return;

    float4 v = Voxels[id];

    // If a voxel never got a seed, you may want to define behavior:
    // Here we just output 0.
    if (v.w == 0.0f)
    {
        Voxels[id] = float4(0, 0, 0, 0);
        return;
    }

    float3 seedWorld = v.xyz;
    float3 idWorld = VoxelIndexToWorld(id);

    float maxExtent = MaxWorldExtent();

    // World distance normalized by max world extent
    float dist = (distance(seedWorld, idWorld) / maxExtent) - postProcessThickness;

    float ts = transitionSharpness;

    // Apply SDF repetitions
    float reps = frac(abs(dist) * fracRepetitions);
    reps = 2 * abs(reps - 0.5);

    // Normalize SDF (remap() comes from ShaderUtils.hlsl)
    float normalized = saturate(remap(0.0, cutOff, 1.0, 0.0, 2.0 * dist));

    // Smooth mask
    float mask = smoothstep(0.5 - ts, 0.5 + ts, normalized);

    // Apply cutoff / repetitions
    float repDist = reps * mask;

    if (resultType == 0)
    {
        // repDist, mask, dist, 1
        Voxels[id] = float4(repDist, mask, dist, 1.0);
    }
    else
    {
        // grayscale distance
        Voxels[id] = float4(dist, dist, dist, dist);
    }
}

What you must pass from C#/Unity now

• dispatchDims = texture (width,height,depth)
• minCornerWorld = bounds min corner in the same space as you voxelized into
• voxelWorldSize = (boundsSizeWorld / dispatchDims) per-axis (so it naturally accounts for stretching)

Example (CPU logic):

• voxelWorldSize = boundsSizeWorld / (Vector3)dispatchDims;

One more important CPU detail (offset schedule)

If you’re currently basing offsets on a cube side, switch to:

• maxDim = max(dispatchDims.x, dispatchDims.y, dispatchDims.z)
• initial offset = highest power of two ≥ maxDim, divided by 2
• then halve until 1

If you paste your C# JFA loop that sets samplingOffset and dispatches kernels, I’ll rewrite it to match dispatchDims + correct group counts.

You

how to calculate this? float3 voxelWorldSize; // world units per voxel step along x/y/z (can be different)

ChatGPT

You calculate voxelWorldSize as world-space size of your voxel volume divided by the voxel counts per axis.

1) If your volume is defined by minCornerWorld + boundsSizeWorld

// dispatchDims = (Nx, Ny, Nz) == your 3D texture dimensions
Vector3 voxelWorldSize = new Vector3(
    boundsSizeWorld.x / dispatchDims.x,
    boundsSizeWorld.y / dispatchDims.y,
    boundsSizeWorld.z / dispatchDims.z
);

That’s “world units per voxel step” on each axis.

2) If you instead have minCornerWorld + maxCornerWorld

Vector3 boundsSizeWorld = maxCornerWorld - minCornerWorld;

Vector3 voxelWorldSize = new Vector3(
    boundsSizeWorld.x / dispatchDims.x,
    boundsSizeWorld.y / dispatchDims.y,
    boundsSizeWorld.z / dispatchDims.z
);

3) Matching what the shader expects (centers)

In the shader I used voxel centers:

worldPos = minCornerWorld + (id + 0.5) * voxelWorldSize;

So on CPU, minCornerWorld should be the min corner of the volume (not the center), and boundsSizeWorld should be the full extents.

Unity snippet with Bounds

Bounds b = meshRenderer.bounds; // or your own bounds in world space

Vector3 minCornerWorld = b.min;
Vector3 boundsSizeWorld = b.size;

Vector3 voxelWorldSize = new Vector3(
    boundsSizeWorld.x / dispatchDims.x,
    boundsSizeWorld.y / dispatchDims.y,
    boundsSizeWorld.z / dispatchDims.z
);

// Pass to compute
compute.SetVector("minCornerWorld", minCornerWorld);
compute.SetVector("voxelWorldSize", voxelWorldSize);
compute.SetInts("dispatchDims", dispatchDims.x, dispatchDims.y, dispatchDims.z);

That’s it: voxelWorldSize is just the per-axis voxel spacing in world units.

You

does anything else need to change?

ChatGPT

A few things do, yes — otherwise you’ll get wrong distances, out-of-bounds writes, or “looks fine for cubes but breaks for boxes”.

Here’s the full checklist (shader + C#). No fluff, just the stuff that actually matters.

---

1) Replace dispatchCubeSide everywhere

You already did this in the shader I gave:

• uint dispatchCubeSide → uint3 dispatchDims
• Bounds check every kernel: if (any(id >= dispatchDims)) return;
• In JFAIter, bounds must be done with signed coordinates (int3), because uint3 can’t go negative.

✅ Required.

---

2) Decide what postProcessThickness, cutOff, etc. mean now

In the updated shader, dist is:

distance(seedWorld, idWorld) / maxWorldExtent

So dist is normalized world distance, not “voxel count distance”.

That means:

• If you previously tuned postProcessThickness, cutOff, etc. for cubes using /dispatchCubeSide, you will likely need to retune slightly (or convert them).

If you want thickness in world units instead (often nicer), change this line:

float dist = (distance(seedWorld, idWorld) / maxExtent) - postProcessThickness;

to:

float distWorld = distance(seedWorld, idWorld) - postProcessThickness; // thickness in world units
float dist = distWorld / maxExtent; // normalize after (optional if you want)

Not strictly required, but you should be aware your parameters are now tied to world size.

---

3) JFA offset schedule must be based on the largest dimension

If you still compute offsets using dispatchCubeSide, JFA will under-sample on the longest axis.

Use:

int maxDim = Mathf.Max(dimX, Mathf.Max(dimY, dimZ));
int offset = 1;
while (offset < maxDim) offset <<= 1;
offset >>= 1; // start at pow2/2

for (; offset >= 1; offset >>= 1)
{
    compute.SetInt("samplingOffset", offset);
    compute.Dispatch(kernelJFA, groupsX, groupsY, groupsZ);
}

✅ Required.

---

4) Dispatch group counts must be per-axis

For [numthreads(8,8,8)] kernels:

int groupsX = (dimX + 7) / 8;
int groupsY = (dimY + 7) / 8;
int groupsZ = (dimZ + 7) / 8;

✅ Required (unless you already do this).

---

5) Your voxelizer must match the same world-space box

For the JFA distances to be meaningful:

• The volume bounds used to voxelize your mesh must match the box you pass to JFA as:
  • minCornerWorld
  • voxelWorldSize (derived from bounds size and dims)

If voxelization is done in a different space (eg local mesh space) but JFA uses world bounds, distances will be wrong.

✅ Required conceptually.

---

6) Seed definition needs to be consistent

Your preprocess uses:

float isSeed = Voxels[id].x;
Voxels[id] = float4(seedWorld, isSeed);

This assumes your “seed mask” is stored in .x before preprocess.

So you must ensure:

• your voxelizer writes seeds into Voxels[x,y,z].x (or adjust preprocess to read the correct channel)
• seeds have w > 0 after preprocess (they will, because isSeed becomes .w)

✅ Required, but usually already true in your pipeline.

---

7) Fix a subtle bug you had: any(at < 0) was meaningless

You had:

uint3 at = ...
if (any(at < 0) || any(at >= bounds)) continue;

at < 0 is always false for uint3.
The signed int3 atI fix is not optional.

✅ Required.

---

Summary: Do you have to change anything else?

Yes, three things are “must”:

1. dispatchDims + signed bounds check in JFA neighbor sampling
2. JFA offset schedule based on max(dispatchDims)
3. Per-axis dispatch group counts + out-of-bounds guards

Everything else is parameter tuning / meaning of “thickness” and “cutoff”.

---

If you paste your C# code that creates the 3D texture + dispatches the kernels, I’ll rewrite it into a correct “final” version that handles (Nx,Ny,Nz) + stretched voxels end-to-end.

You

ok, fix my c#

using UnityEngine; using UnchartedLimbo.Core.Algorithms.GPU; using UnchartedLimbo.Core.Runtime.Attributes; using UnchartedLimbo.VoxelUtils.Runtime.Utilities;

namespace UnchartedLimbo.VoxelUtils.Runtime.Algorithms.SDF {

public class JumpFlood_v2 : SingleBufferGpuAlgorithm
{
    private static readonly int SamplingOffset = Shader.PropertyToID(SamplingOffsetName);
    private static readonly int DispatchCubeSide = Shader.PropertyToID(VoxelsPerSideName);
    private static readonly int PostProcessThickness = Shader.PropertyToID(PostProcessThicknessName);
    private static readonly int FracRepetitions = Shader.PropertyToID(FracRepetitionsName);
    private static readonly int CutOff = Shader.PropertyToID(CutOffName);
    private static readonly int TransitionSharpness = Shader.PropertyToID(SharpnessName);
    private static readonly int ResultType = Shader.PropertyToID(ResultTypeName);

    public BoxCollider bounds;

    [Header("Jump Flood Algorithm")]
    [Range(-0.05f, 0.2f)]
    [Presetable] public float postProcessThickness;

    [Range(0, 32)]
    [Presetable] public float fracRepetitions;

    [Range(0, 32)]
    [Presetable]public float cutOff = 5;

    [Range(0,1)]
    [Presetable] public float transitionSharpness = 0.5f;

    [Presetable] public int resultType = 0;

    public override string BufferAName => "Voxels";
    private const string PostProcessThicknessName = "postProcessThickness";
    private const string VoxelsPerSideName = "dispatchCubeSide";
    private const string SamplingOffsetName = "samplingOffset";
    private const string FracRepetitionsName = "fracRepetitions";
    private const string CutOffName = "cutOff";
    private const string SharpnessName = "transitionSharpness";
    private const string ResultTypeName = "resultType";

    public RenderTexture rt;

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

    protected override void Schedule()
    {
        Vector3 minCornerWorld = bounds.bounds.min;
        Vector3 boundsSizeWorld = bounds.bounds.size;

        Vector3 voxelWorldSize = new Vector3(
            boundsSizeWorld.x / Resolution.x,
            boundsSizeWorld.y / Resolution.y,
            boundsSizeWorld.z / Resolution.z
        );

        Compute.SetVector("dispatchDims", new Vector3(Resolution.x, Resolution.y, Resolution.z));
        Compute.SetVector("minCornerWorld",minCornerWorld);
        Compute.SetVector("voxelWorldSize", voxelWorldSize);

        Compute.SetFloat(PostProcessThickness, postProcessThickness);
        Compute.SetFloat(FracRepetitions, fracRepetitions);
        Compute.SetFloat(CutOff, cutOff);
        Compute.SetFloat(TransitionSharpness, 0.5f - transitionSharpness * 0.5f);
        Compute.SetInt(ResultType,resultType);

        for (var i = 0; i < KernelIndices.Length; i++)
        {
            Compute.SetTexture(KernelIndices[i], BufferAName, FreshData);
        }
    }

    protected override void Execute()
    {
        Dispatch(KernelIndices[0]);

        // Start from Half the initial resolution, and keep dividing by 2 at each iteration until you reach 1
        for (var offset = Resolution.x / 2; offset >= 1; offset /= 2)
        {
            Compute.SetInt(SamplingOffset, offset);
            Dispatch(KernelIndices[1]);
        }

        Dispatch(KernelIndices[2]);

        FreshData.name = "JFA Result";

        rt = FreshData;
    }
}

}

ChatGPT

Below is a “fixed” version of your C# that matches the non-cubic + stretched voxels shader:

• Sets dispatchDims as ints (matches uint3 dispatchDims in HLSL)
• Computes group counts per axis (don’t rely on old Dispatch(...) if it assumes cubes)
• Computes the JFA offsets from the largest dimension, not Resolution.x
• Passes minCornerWorld + voxelWorldSize correctly
• Keeps your existing uniforms (thickness/reps/cutoff/sharpness/resultType)

I’m assuming your kernels are ordered:
KernelIndices[0]=Preprocess, [1]=JFA, [2]=Postprocess, and Zero is either separate or not used.

---

Final corrected C# (drop-in)

using UnityEngine;
using UnchartedLimbo.Core.Algorithms.GPU;
using UnchartedLimbo.Core.Runtime.Attributes;
using UnchartedLimbo.VoxelUtils.Runtime.Utilities;

namespace UnchartedLimbo.VoxelUtils.Runtime.Algorithms.SDF
{
    public class JumpFlood_v2 : SingleBufferGpuAlgorithm
    {
        private static readonly int SamplingOffset = Shader.PropertyToID(SamplingOffsetName);
        private static readonly int PostProcessThickness = Shader.PropertyToID(PostProcessThicknessName);
        private static readonly int FracRepetitions = Shader.PropertyToID(FracRepetitionsName);
        private static readonly int CutOff = Shader.PropertyToID(CutOffName);
        private static readonly int TransitionSharpness = Shader.PropertyToID(SharpnessName);
        private static readonly int ResultType = Shader.PropertyToID(ResultTypeName);

        // New ids for the anisotropic/non-cubic version
        private static readonly int DispatchDims = Shader.PropertyToID("dispatchDims");
        private static readonly int MinCornerWorld = Shader.PropertyToID("minCornerWorld");
        private static readonly int VoxelWorldSize = Shader.PropertyToID("voxelWorldSize");

        public BoxCollider bounds;

        [Header("Jump Flood Algorithm")]
        [Range(-0.05f, 0.2f)]
        [Presetable] public float postProcessThickness;

        [Range(0, 32)]
        [Presetable] public float fracRepetitions;

        [Range(0, 32)]
        [Presetable] public float cutOff = 5;

        [Range(0, 1)]
        [Presetable] public float transitionSharpness = 0.5f;

        [Presetable] public int resultType = 0;

        public override string BufferAName => "Voxels";

        private const string PostProcessThicknessName = "postProcessThickness";
        private const string SamplingOffsetName = "samplingOffset";
        private const string FracRepetitionsName = "fracRepetitions";
        private const string CutOffName = "cutOff";
        private const string SharpnessName = "transitionSharpness";
        private const string ResultTypeName = "resultType";

        public RenderTexture rt;

        protected override void Initialize()
        {
            base.Initialize();
        }

        protected override void Schedule()
        {
            // World-space bounds of the volume we’re voxelizing into
            Bounds b = bounds.bounds;
            Vector3 minCornerWorld = b.min;
            Vector3 boundsSizeWorld = b.size;

            // Resolution MUST be (Nx,Ny,Nz). If your base class uses Vector3Int, great.
            // If it’s Vector3/Vector3Int-like, ensure you’re using ints here.
            int dimX = Resolution.x;
            int dimY = Resolution.y;
            int dimZ = Resolution.z;

            // World units per voxel step per axis (anisotropic supported)
            Vector3 voxelWorldSize = new Vector3(
                boundsSizeWorld.x / dimX,
                boundsSizeWorld.y / dimY,
                boundsSizeWorld.z / dimZ
            );

            // Match HLSL types:
            // - dispatchDims is uint3 -> set as ints
            Compute.SetInts(DispatchDims, dimX, dimY, dimZ);
            Compute.SetVector(MinCornerWorld, minCornerWorld);
            Compute.SetVector(VoxelWorldSize, voxelWorldSize);

            Compute.SetFloat(PostProcessThickness, postProcessThickness);
            Compute.SetFloat(FracRepetitions, fracRepetitions);
            Compute.SetFloat(CutOff, cutOff);

            // keep your mapping (if it’s intentional); otherwise pass transitionSharpness directly
            Compute.SetFloat(TransitionSharpness, 0.5f - transitionSharpness * 0.5f);

            Compute.SetInt(ResultType, resultType);

            for (var i = 0; i < KernelIndices.Length; i++)
            {
                Compute.SetTexture(KernelIndices[i], BufferAName, FreshData);
            }
        }

        protected override void Execute()
        {
            int dimX = Resolution.x;
            int dimY = Resolution.y;
            int dimZ = Resolution.z;

            // numthreads(8,8,8) -> group counts per axis
            int groupsX = (dimX + 7) / 8;
            int groupsY = (dimY + 7) / 8;
            int groupsZ = (dimZ + 7) / 8;

            // Kernel order assumption:
            // 0 = Preprocess, 1 = JFA, 2 = Postprocess
            Compute.Dispatch(KernelIndices[0], groupsX, groupsY, groupsZ);

            // JFA offset schedule must use the largest dimension (non-cubic!)
            int maxDim = Mathf.Max(dimX, Mathf.Max(dimY, dimZ));

            // Start at highest power-of-two >= maxDim, then /2 (classic JFA)
            int start = 1;
            while (start < maxDim) start <<= 1;
            int offset = start >> 1;

            for (; offset >= 1; offset >>= 1)
            {
                Compute.SetInt(SamplingOffset, offset);
                Compute.Dispatch(KernelIndices[1], groupsX, groupsY, groupsZ);
            }

            Compute.Dispatch(KernelIndices[2], groupsX, groupsY, groupsZ);

            FreshData.name = "JFA Result";
            rt = FreshData;
        }
    }
}

---

Two “gotchas” to double-check in your project

A) Resolution must be 3D (Nx,Ny,Nz)

Your old code uses Resolution.x only for offsets — that was the cube assumption.
If Resolution is currently one int or only meaningful in X, you need to refactor it to hold XYZ.

B) KernelIndices order

If your compute shader includes Zero too, make sure KernelIndices[] matches what you think. If it’s actually:

• 0 = Zero
• 1 = Preprocess
• 2 = JFA
• 3 = Postprocess

…then shift the indices accordingly.

If you paste how KernelIndices is populated in SingleBufferGpuAlgorithm, I’ll adapt the dispatch section to your exact ordering without guessing.