Compute Shader Utility SO

2025-07-09 08:29 UTC o4-mini-high Open in ChatGPT ↗

You can create a ScriptableObject that holds only a reference to your ComputeShader asset and—on validate in the Editor—automatically reads its source to extract all kernels, their indices, and thread‐group sizes. Then at runtime you can simply ask this object for any kernel’s index or thread counts without knowing the internals.

Key API calls

ComputeShader.FindKernel(string name) returns the integer kernel index for a given kernel name citeturn0search0.
ComputeShader.GetKernelThreadGroupSizes(int kernelIndex, out int x, out int y, out int z) retrieves the [numthreads(x,y,z)] sizes for that kernel citeturn0search1.

Parsing the shader source
In the Editor, use AssetDatabase.GetAssetPath(computeShader) to locate the .compute file citeturn4search0, then read it with File.ReadAllText and run a regex to capture every #pragma kernel <name> declaration:

var matches = Regex.Matches(shaderText, @"#pragma\s+kernel\s+(\w+)");

Each match’s group 1 is the kernel name citeturn3search0.

using UnityEngine;
using System.Collections.Generic;
using System.IO;
using System.Text.RegularExpressions;
#if UNITY_EDITOR
using UnityEditor;
#endif

[CreateAssetMenu(menuName = "Compute Shader/Info")]
public class ComputeShaderInfo : ScriptableObject
{
    [SerializeField] private ComputeShader computeShader;
    [SerializeField] private List<KernelInfo> kernels = new List<KernelInfo>();

    [System.Serializable]
    public class KernelInfo
    {
        public string name;
        public int index;
        public Vector3Int threadGroupSize;
    }

#if UNITY_EDITOR
    private void OnValidate()
    {
        if (computeShader == null) return;
        UpdateKernels();
        EditorUtility.SetDirty(this);
    }

    private void UpdateKernels()
    {
        // 1. Find the asset path and read its text
        string path = AssetDatabase.GetAssetPath(computeShader);
        string text = File.ReadAllText(path);

        // 2. Regex out all "#pragma kernel <KernelName>" lines
        var matches = Regex.Matches(text, @"#pragma\s+kernel\s+(\w+)");
        kernels.Clear();
        var seen = new HashSet<string>();

        foreach (Match m in matches)
        {
            string name = m.Groups[1].Value;
            if (!seen.Add(name)) continue;

            // 3. For each kernel name, get its index and thread counts
            int idx = computeShader.FindKernel(name);
            computeShader.GetKernelThreadGroupSizes(idx, out int x, out int y, out int z);

            kernels.Add(new KernelInfo
            {
                name = name,
                index = idx,
                threadGroupSize = new Vector3Int(x, y, z)
            });
        }
    }
#endif

    /// <summary>
    /// Returns the kernel index for the given name, or -1 if not found.
    /// </summary>
    public int GetKernelIndex(string kernelName)
    {
        var k = kernels.Find(info => info.name == kernelName);
        return k != null ? k.index : -1;
    }

    /// <summary>
    /// Returns the thread group size ([x,y,z]) for the named kernel, or zero if not found.
    /// </summary>
    public Vector3Int GetThreadGroupSize(string kernelName)
    {
        var k = kernels.Find(info => info.name == kernelName);
        return k != null ? k.threadGroupSize : Vector3Int.zero;
    }

    /// <summary>All detected kernels (name, index, thread sizes).</summary>
    public IReadOnlyList<KernelInfo> Kernels => kernels;
}

Usage in another script

public class ComputeUser : MonoBehaviour
{
    [SerializeField] private ComputeShaderInfo shaderInfo;

    void DispatchMyKernel()
    {
        // Get the index and group sizes by name:
        int kernel = shaderInfo.GetKernelIndex("MyKernel");
        Vector3Int tg = shaderInfo.GetThreadGroupSize("MyKernel");

        // Compute how many groups to dispatch (example):
        int gx = Mathf.CeilToInt(textureWidth  / (float)tg.x);
        int gy = Mathf.CeilToInt(textureHeight / (float)tg.y);

        // Finally dispatch
        shaderInfo.computeShader.Dispatch(kernel, gx, gy, 1);
    }
}

This way, any script can link to the execution model of your compute shader purely via its high‐level ScriptableObject, without needing to know about #pragma declarations or thread counts.

At runtime, none of the editor‐only parsing ever runs—your OnValidate and AssetDatabase calls are wrapped in #if UNITY_EDITOR, so they’re stripped out in a build. Instead, when you enter play mode (or ship your build), Unity simply deserializes your ComputeShaderInfo asset:

Asset Load
- Unity loads your ComputeShaderInfo ScriptableObject along with its serialized fields:
  - A reference to the ComputeShader asset.
  - A pre‐populated kernels list, containing name, index, and thread‐group sizes for each kernel (this was baked into the asset in the editor).
No Parsing Overhead
- There is no disk I/O or Regex parsing at runtime—everything you need is already in memory.
- The editor‐only code was stripped, so you get zero GC spikes or file reads when the game starts or when you dispatch.

Using the Data

When your gameplay code calls:

int idx = shaderInfo.GetKernelIndex("MyKernel");
Vector3Int tg = shaderInfo.GetThreadGroupSize("MyKernel");
shaderInfo.computeShader.Dispatch(idx,
    Mathf.CeilToInt(width  / (float)tg.x),
    Mathf.CeilToInt(height / (float)tg.y),
    tg.z > 1 ? Mathf.CeilToInt(depth / (float)tg.z) : 1
);

Internally that’s just a quick List.Find on a few dozen small structs (virtually free), followed by a call into the GPU driver.

Safety & Performance
- Because the kernel indices and thread‐group sizes were validated in the editor, you can’t accidentally typo a kernel name at runtime—you’ll simply get back -1 (and you can guard against that).
- Dispatch calls are as fast as a direct call to ComputeShader would have been; you’ve simply removed the “magic strings” and hidden the GPU‐specific constants behind a nice API.
Edge Cases
- If you swap out the compute shader at runtime (e.g. via script), the kernels list won’t update automatically. You’d either need to manually call a runtime‐safe initializer (e.g. loop through computeShader.FindKernel and GetKernelThreadGroupSizes) or re‐assign the SO in the editor to re‐bake it.
- But in the standard workflow—assign the shader once in the inspector and never change it at runtime—nothing ever breaks.

In short: at runtime you get a tiny, fully‐baked lookup table of kernel metadata that lets you dispatch your compute shader without reflection or string parsing, with zero editor‐only overhead.

Here’s an updated ComputeShaderInfo that, in the editor, will automatically rename both the in-memory object and its .asset file to match the referenced ComputeShader’s name:

using UnityEngine;
using System.Collections.Generic;
using System.IO;
using System.Text.RegularExpressions;
#if UNITY_EDITOR
using UnityEditor;
#endif

[CreateAssetMenu(menuName = "Compute Shader/Info", fileName = "NewComputeShaderInfo")]
public class ComputeShaderInfo : ScriptableObject
{
    [SerializeField] private ComputeShader computeShader;
    [SerializeField] private List<KernelInfo> kernels = new List<KernelInfo>();

    [System.Serializable]
    public class KernelInfo
    {
        public string name;
        public int index;
        public Vector3Int threadGroupSize;
    }

#if UNITY_EDITOR
    private void OnValidate()
    {
        if (computeShader == null)
            return;

        // 1) Auto-bake kernels
        UpdateKernels();

        // 2) Auto-rename this SO in-memory and on-disk
        string targetName = $"{computeShader.name}Info";
        if (name != targetName)
        {
            // Rename the in-memory object
            name = targetName;

            // Rename the .asset file
            string myPath = AssetDatabase.GetAssetPath(this);
            if (!string.IsNullOrEmpty(myPath))
            {
                // AssetDatabase.RenameAsset wants the new filename (with .asset!)
                string newFilename = targetName + ".asset";
                AssetDatabase.RenameAsset(myPath, newFilename);
                AssetDatabase.SaveAssets();
            }
        }

        EditorUtility.SetDirty(this);
    }

    private void UpdateKernels()
    {
        string path = AssetDatabase.GetAssetPath(computeShader);
        if (string.IsNullOrEmpty(path) || !File.Exists(path))
            return;

        string text = File.ReadAllText(path);
        var matches = Regex.Matches(text, @"#pragma\s+kernel\s+(\w+)");
        kernels.Clear();
        var seen = new HashSet<string>();

        foreach (Match m in matches)
        {
            string kName = m.Groups[1].Value;
            if (!seen.Add(kName)) continue;

            int idx = computeShader.FindKernel(kName);
            computeShader.GetKernelThreadGroupSizes(idx, out int x, out int y, out int z);

            kernels.Add(new KernelInfo
            {
                name = kName,
                index = idx,
                threadGroupSize = new Vector3Int(x, y, z)
            });
        }
    }
#endif

    /// <summary>Get the kernel index by name, or -1 if missing.</summary>
    public int GetKernelIndex(string kernelName)
    {
        var k = kernels.Find(info => info.name == kernelName);
        return k != null ? k.index : -1;
    }

    /// <summary>Get the kernel's [x,y,z] thread counts, or zero if missing.</summary>
    public Vector3Int GetThreadGroupSize(string kernelName)
    {
        var k = kernels.Find(info => info.name == kernelName);
        return k != null ? k.threadGroupSize : Vector3Int.zero;
    }

    /// <summary>All detected kernels (name, index, thread sizes).</summary>
    public IReadOnlyList<KernelInfo> Kernels => kernels;
}

What’s new?

fileName in [CreateAssetMenu] gives a sensible default when you first create the SO.
In OnValidate(), after baking your kernels, we compute a targetName from computeShader.name + "Info".
We assign this.name = targetName to rename the object in memory.
We fetch the SO’s own asset path with AssetDatabase.GetAssetPath(this) and call AssetDatabase.RenameAsset(path, newFilename) to rename the .asset file on disk.

Now, whenever you assign or reassign the ComputeShader reference in the Inspector, the SO asset will automatically be renamed to match, keeping your project tidy.

Explain why this thread count is used. Review it for correctness. comment thoroughly

protected override void Execute() { if (!skinnedMesh && !staticMesh) return;

        if (wipeBeforeExecution)
            Dispatch(0);

        // Custom dispatch groups
        var dispatchGroups = new int3(1 + (_indexBuffer.count / 3) / (int)KernelThreadGroupSizes[1].x, 1, 1);

        Dispatch(1, dispatchGroups );

        FreshData.name ="MeshToVoxel";
    }

Here’s what that line is doing, step by step, and where it can go wrong:

// How many thread‐groups do we need along X?
// _indexBuffer.count is the total number of indices (3 per triangle).
// Dividing by 3 gives you the number of triangles we need to process.
// KernelThreadGroupSizes[1].x is the number of threads the shader runs per group along X.
// So (triangleCount / threadsPerGroup) tells you how many full groups you need.
// The “+1” is there to make sure we cover any leftover triangles.
var dispatchGroups = new int3(
    1 + (_indexBuffer.count / 3) / (int)KernelThreadGroupSizes[1].x,
    1,
    1
);

Why this calculation exists

Index count → triangle count
A mesh’s index buffer lists vertex indices in triplets.
```
int triangleCount = _indexBuffer.count / 3;
```
This is how many work items (triangles) you actually need to process.
Thread-group size
Your compute shader declares something like
```
[numthreads(64,1,1)]
kernel ProcessTriangles { … }
```
so each dispatched group handles 64 triangles along X before moving to the next group.
```
int threadsPerGroup = (int)KernelThreadGroupSizes[1].x;
```
Groups needed = triangles ÷ threads per group
If you had exactly 64 triangles, you need 1 group. If you had 65, you need 2 groups.
The formula used is
```
1 + (triangleCount / threadsPerGroup)
```
which guarantees at least 1 group and “rounds up” by forcing an extra group even if there’s a perfect division.

Correctness review

triangleCount	threadsPerGroup	triangleCount/threadsPerGroup	1 + (…)	desired groups
63	64	0	1	1
64	64	1	2	1
65	64	1	2	2

For 64 triangles, (64/64)=1, so 1+1=2. But you actually only need one group to cover all 64.
As you see, the +1 trick over-allocates by exactly one group whenever the triangles divide evenly by the group size.

A more robust “ceil” approach

To compute exactly the number of groups needed, use integer‐ceil:

int triangleCount    = _indexBuffer.count / 3;
int threadsPerGroup  = (int)KernelThreadGroupSizes[1].x;

// (a + b - 1) / b is the standard integer‐ceil of a/b
int groupsX = (triangleCount + threadsPerGroup - 1) / threadsPerGroup;

var dispatchGroups = new int3(groupsX, 1, 1);
Dispatch(1, dispatchGroups);

If triangleCount=64:
(64 + 64 - 1) / 64 = 127 / 64 = 1 group ✔️
If triangleCount=65:
(65 + 64 - 1) / 64 = 128 / 64 = 2 groups ✔️

Full annotated Execute() with comments

protected override void Execute()
{
    // Nothing to do if no mesh is assigned
    if (!skinnedMesh && !staticMesh)
        return;

    // Optionally clear previous results with kernel 0
    if (wipeBeforeExecution)
        Dispatch(0);

    // 1. How many triangles?
    int triangleCount   = _indexBuffer.count / 3;

    // 2. How many threads does each group run (from our baked ScriptableObject)?
    int threadsPerGroup = (int)KernelThreadGroupSizes[1].x;

    // 3. Compute the exact # of groups to cover all triangles (integer ceiling)
    int groupsX = (triangleCount + threadsPerGroup - 1) / threadsPerGroup;

    // 4. Dispatch kernel #1 with just enough groups along X
    var dispatchGroups = new int3(groupsX, 1, 1);
    Dispatch(1, dispatchGroups);

    // 5. Tag the output buffer for debugging/inspection
    FreshData.name = "MeshToVoxel";
}

Takeaways:

The original 1 + (…/…) trick almost works, but over-dispatches whenever your triangle count is an exact multiple of the thread-group size.
Using (count + size - 1) / size is the standard integer‐ceil pattern: it allocates exactly the right number of groups every time, no more, no less.

I am wondering if this gaussian blur for voxels is correct when applied to directions, and not simple scalars… Main kernel:

#pragma kernel Zero #pragma kernel gaussianBlur

#include ”./ShaderUtils.hlsl”

RWTexture3D bufferA; RWTexture3D bufferB;

[numthreads(8, 8, 8)] void Zero(uint3 id : SV_DispatchThreadID) { bufferA[id.xyz] = 0; bufferB[id.xyz] = 0; }

[numthreads(8, 8, 8)] void gaussianBlur(uint3 id : SV_DispatchThreadID) { bufferB[id.xyz] = gaussian5x5(int3(id.xyz), bufferA); }

Shader Utils:

#include ”./GaussianConstants.hlsl”

float3 unlerp(float3 a, float3 b, float3 x) { return (x - a) / (b - a); }

float unlerp(float a, float b, float x) { return (x - a) / (b - a); }

float3 remap(float3 a, float3 b, float3 c, float3 d, float3 x) { return lerp(c, d, unlerp(a, b, x)); }

float remap(float a, float b, float c, float d, float x) { return lerp(c, d, unlerp(a, b, x)); }

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;

}

// from https://beta.observablehq.com/@jrus/plastic-sequence float2 plastic(float index) { return float2(0.5 + frac(0.7548776662466927 * index), 0.5 + frac(0.5698402909980532 * index)); }

// sample num, triangle basis vectors float3 triangleSample(int n, float3 A, float3 B) { float2 s = plastic((half)n);

s = s.x + s.y > 1.0 ? 1.0 - s : s;

return s.x * A + s.y * B;

}

// Hash function from H. Schechter & R. Bridson, goo.gl/RXiKaH uint Hash(uint s) { s ^= 2747636419u; s *= 2654435769u; s ^= s >> 16; s *= 2654435769u; s ^= s >> 16; s *= 2654435769u; return s; }////1

float3 slerp(float3 start, float3 end, float percent) { // Dot product - the cosine of the angle between 2 vectors. float _dot = dot(start, end);
// Clamp it to be in the range of Acos() // This may be unnecessary, but floating point // precision can be a fickle mistress. _dot = clamp(_dot, -1.0, 1.0); // Acos(dot) returns the angle between start and end, // And multiplying that by percent returns the angle between // start and the final result. float theta = acos(_dot)percent; float3 RelativeVec = normalize(end - start_dot); // Orthonormal basis // The final result. return ((startcos(theta)) + (RelativeVecsin(theta))); }

float4 gaussian5x5(int3 id, RWTexture3D bufferC) { float4 _01 = bufferC[id + GAUSSIAN_5X5_OFFSETS[0]] * GAUSSIAN_5X5_WEIGHTS[0]; float4 _02 = bufferC[id + GAUSSIAN_5X5_OFFSETS[1]] * GAUSSIAN_5X5_WEIGHTS[1]; float4 _03 = bufferC[id + GAUSSIAN_5X5_OFFSETS[2]] * GAUSSIAN_5X5_WEIGHTS[2]; float4 _04 = bufferC[id + GAUSSIAN_5X5_OFFSETS[3]] * GAUSSIAN_5X5_WEIGHTS[3]; float4 _05 = bufferC[id + GAUSSIAN_5X5_OFFSETS[4]] * GAUSSIAN_5X5_WEIGHTS[4];

float4 _06 = bufferC[id + GAUSSIAN_5X5_OFFSETS[5]] * GAUSSIAN_5X5_WEIGHTS[5];
float4 _07 = bufferC[id + GAUSSIAN_5X5_OFFSETS[6]] * GAUSSIAN_5X5_WEIGHTS[6];
float4 _08 = bufferC[id + GAUSSIAN_5X5_OFFSETS[7]] * GAUSSIAN_5X5_WEIGHTS[7];
float4 _09 = bufferC[id + GAUSSIAN_5X5_OFFSETS[8]] * GAUSSIAN_5X5_WEIGHTS[8];
float4 _10 = bufferC[id + GAUSSIAN_5X5_OFFSETS[9]] * GAUSSIAN_5X5_WEIGHTS[9];

float4 _11 = bufferC[id + GAUSSIAN_5X5_OFFSETS[10]] * GAUSSIAN_5X5_WEIGHTS[10];
float4 _12 = bufferC[id + GAUSSIAN_5X5_OFFSETS[11]] * GAUSSIAN_5X5_WEIGHTS[11];
float4 _13 = bufferC[id + GAUSSIAN_5X5_OFFSETS[12]] * GAUSSIAN_5X5_WEIGHTS[12];
float4 _14 = bufferC[id + GAUSSIAN_5X5_OFFSETS[13]] * GAUSSIAN_5X5_WEIGHTS[13];
float4 _15 = bufferC[id + GAUSSIAN_5X5_OFFSETS[14]] * GAUSSIAN_5X5_WEIGHTS[14];

float4 _16 = bufferC[id + GAUSSIAN_5X5_OFFSETS[15]] * GAUSSIAN_5X5_WEIGHTS[15];
float4 _17 = bufferC[id + GAUSSIAN_5X5_OFFSETS[16]] * GAUSSIAN_5X5_WEIGHTS[16];
float4 _18 = bufferC[id + GAUSSIAN_5X5_OFFSETS[17]] * GAUSSIAN_5X5_WEIGHTS[17];
float4 _19 = bufferC[id + GAUSSIAN_5X5_OFFSETS[18]] * GAUSSIAN_5X5_WEIGHTS[18];
float4 _20 = bufferC[id + GAUSSIAN_5X5_OFFSETS[19]] * GAUSSIAN_5X5_WEIGHTS[19];

float4 _21 = bufferC[id + GAUSSIAN_5X5_OFFSETS[20]] * GAUSSIAN_5X5_WEIGHTS[20];
float4 _22 = bufferC[id + GAUSSIAN_5X5_OFFSETS[21]] * GAUSSIAN_5X5_WEIGHTS[21];
float4 _23 = bufferC[id + GAUSSIAN_5X5_OFFSETS[22]] * GAUSSIAN_5X5_WEIGHTS[22];
float4 _24 = bufferC[id + GAUSSIAN_5X5_OFFSETS[23]] * GAUSSIAN_5X5_WEIGHTS[23];
float4 _25 = bufferC[id + GAUSSIAN_5X5_OFFSETS[24]] * GAUSSIAN_5X5_WEIGHTS[24];

return _01 + _02 + _03 + _04 + _05 + _06 + _07 + _08 + _09 + _10 + _11 + _12 + _13 + _14 + _15 + _16 + _17 + _18 + _19 + _20 + _21 + _22 + _23 + _24 + _25;

return (bufferC[int3(id.x - 2, id.y, id.z + 2)] + bufferC[int3(id.x - 1, id.y, id.z + 2)] * 4.0 + bufferC[int3(id.x, id.y, id.z + 2)] * 6.0 + bufferC[int3(id.x + 1, id.y, id.z + 2)] * 4.0 + bufferC[int3(id.x + 2, id.y, id.z + 2)] +
    bufferC[int3(id.x - 2, id.y, id.z + 1)] * 4.0 + bufferC[int3(id.x - 1, id.y, id.z + 1)] * 16.0 + bufferC[int3(id.x, id.y, id.z + 1)] * 24.0 + bufferC[int3(id.x + 1, id.y, id.z + 1)] * 16.0 + bufferC[int3(id.x + 2, id.y, id.z + 1)] * 4.0 +
    bufferC[int3(id.x - 2, id.y, id.z)] * 6.0 + bufferC[int3(id.x - 1, id.y, id.z)] * 24.0 + bufferC[int3(id.x, id.y, id.z)] * 36.0 + bufferC[int3(id.x + 1, id.y, id.z)] * 24.0 + bufferC[int3(id.x + 2, id.y, id.z)] * 6.0 +
    bufferC[int3(id.x - 2, id.y, id.z - 1)] * 4.0 + bufferC[int3(id.x - 1, id.y, id.z - 1)] * 16.0 + bufferC[int3(id.x, id.y, id.z - 1)] * 24.0 + bufferC[int3(id.x + 1, id.y, id.z - 1)] * 16.0 + bufferC[int3(id.x + 2, id.y, id.z - 1)] * 4.0 +
    bufferC[int3(id.x - 2, id.y, id.z - 2)] + bufferC[int3(id.x - 1, id.y, id.z - 2)] * 4.0 + bufferC[int3(id.x, id.y, id.z - 2)] * 6.0 + bufferC[int3(id.x + 1, id.y, id.z - 2)] * 4.0 + bufferC[int3(id.x + 2, id.y, id.z - 2)]
    ) / 256.0;

}

Below is a line-by-line walkthrough of your gaussian5x5 routine, with an eye toward how it treats directions (unit vectors) rather than simple scalar values—and why as-written it isn’t quite correct for that use-case.

float4 gaussian5x5(int3 id, RWTexture3D<float4> bufferC)
{
    // 25 taps, each grabbing a float4 from the volume
    // and multiplying by the precomputed Gaussian weight.
    // Offsets and weights come from your GAUSSIAN_5X5_* arrays.
    float4 _01 = bufferC[id + GAUSSIAN_5X5_OFFSETS[0]] * GAUSSIAN_5X5_WEIGHTS[0];
    …
    float4 _25 = bufferC[id + GAUSSIAN_5X5_OFFSETS[24]] * GAUSSIAN_5X5_WEIGHTS[24];

    // You sum all weighted samples into a single float4
    float4 result =
          _01 + _02 + /*…*/ + _25;

    return result;
}

1. Missing normalization by total weight

A proper Gaussian blur averages by dividing by the sum of the weights (which for a 5×5 kernel is typically 256). Without that division you’ve effectively boosted the magnitude of every channel by ~256×.

// after summing:
result /= GAUSSIAN_5X5_TOTAL;   // e.g. 256.0

2. Averaging directions ≠ averaging scalars

Scalar blur: you take weighted sums of brightness or density values, then divide by total weight → still a valid scalar.
Direction blur: you have unit vectors (x,y,z). If you simply sum them and divide by weight, you get a vector whose length ≤1, but not necessarily unit‐length. Worse, if neighbors point in opposite directions, they can cancel out entirely.

Fix: after forming the weighted average of the xyz components, re-normalize the vector so you end up back on the unit sphere:

float3 dirSum = float3(0,0,0);
float  totalW = 0;
for (int i = 0; i < 25; i++)
{
    float4 sample = bufferC[id + GAUSSIAN_5X5_OFFSETS[i]];
    float  w      = GAUSSIAN_5X5_WEIGHTS[i];
    dirSum  += sample.xyz * w;
    totalW += w;
}
// 1) average
dirSum /= totalW;
// 2) renormalize to unit-length
dirSum = normalize(dirSum);

// If you have a scalar “magnitude” in .w, blur it separately:
float magSum = 0;
for (int i = 0; i < 25; i++)
{
    magSum += bufferC[id + GAUSSIAN_5X5_OFFSETS[i]].w * GAUSSIAN_5X5_WEIGHTS[i];
}
float blurredMag = magSum / totalW;

// Return the combined result:
return float4(dirSum, blurredMag);

3. Why spherical normalization matters

Preserves unit-length: ensures your output stays on the unit sphere.
Avoids “fade-out”: without renormalization the vector length shrinks (the average of two opposite unit vectors is zero!).
Better geometric mean: summing & renormalizing approximates the geodesic mean on the sphere, which is usually what you want when smoothing orientation data.

4. Edge-cases & performance

Boundary sampling: make sure id + offset stays in‐bounds (clamp or pad) or you’ll read garbage.
Separable blur: a full 5×5×5 3D kernel is 125 taps. You can instead blur in three 1D passes (5 taps each) along X, Y, and Z—only 15 fetches total—to get the same result.

5. Full corrected HLSL snippet

float4 gaussianBlurDirections(int3 id, RWTexture3D<float4> buf)
{
    float3 dirAcc = float3(0,0,0);
    float  magAcc = 0;
    float  wSum   = 0;

    [unroll]
    for (int i = 0; i < 25; i++)
    {
        float4 s = buf[id + GAUSSIAN_5X5_OFFSETS[i]];
        float  w = GAUSSIAN_5X5_WEIGHTS[i];
        dirAcc += s.xyz * w;
        magAcc += s.w   * w;
        wSum   += w;
    }

    // Average and renormalize direction
    dirAcc = normalize(dirAcc / wSum);
    // Average scalar
    magAcc = magAcc / wSum;

    return float4(dirAcc, magAcc);
}

In summary:

Divide by total weight so you truly average rather than amplify.
Renormalize the xyz subnet so directional data remains on the unit sphere.
Blur any accompanying scalars (e.g. magnitudes) independently.
Consider separable, multi-pass filtering for performance.

Below are two HLSL routines for a 5×5 Gaussian blur on a 3D volume slice (XZ-plane). Both are written for maximum clarity and use [unroll] to hint the compiler to inline the loop. You’ll need to have your offsets and weights defined in a header like:

// 25 offsets in the XZ plane, e.g. { {-2,+2}, {-1,+2}, …, {+2,-2} }
static const int2 GAUSSIAN_5X5_OFFSETS[25] = {
    { -2, +2 }, { -1, +2 }, { 0, +2 }, { +1, +2 }, { +2, +2 },
    { -2, +1 }, { -1, +1 }, { 0, +1 }, { +1, +1 }, { +2, +1 },
    { -2,  0 }, { -1,  0 }, { 0,  0 }, { +1,  0 }, { +2,  0 },
    { -2, -1 }, { -1, -1 }, { 0, -1 }, { +1, -1 }, { +2, -1 },
    { -2, -2 }, { -1, -2 }, { 0, -2 }, { +1, -2 }, { +2, -2 }
};

// Standard Gaussian 5×5 weights (sum = 256)
static const float GAUSSIAN_5X5_WEIGHTS[25] = {
     1,  4,  6,  4, 1,
     4, 16, 24, 16, 4,
     6, 24, 36, 24, 6,
     4, 16, 24, 16, 4,
     1,  4,  6,  4, 1
};
static const float GAUSSIAN_5X5_TOTAL = 256.0;

1) Scalar version

/// <summary>
/// Applies a 5×5 Gaussian blur to the scalar (r,g,b,a) channels in bufferA,
/// writing the normalized result to bufferB.
/// Uses 25 fetches in a single unrolled loop for clarity and efficiency.
/// </summary>
float4 Gaussian5x5_Scalar(int3 id, RWTexture3D<float4> bufferA)
{
    float4 accum = float4(0,0,0,0);

    // Unroll the loop so the compiler can optimize fetches & math
    [unroll]
    for (int i = 0; i < 25; ++i)
    {
        // build the full 3D offset (y stays constant)
        int3 off = int3(GAUSSIAN_5X5_OFFSETS[i].x, 0, GAUSSIAN_5X5_OFFSETS[i].y);
        float4 sample = bufferA[id + off];
        accum += sample * GAUSSIAN_5X5_WEIGHTS[i];
    }

    // Normalize by the total weight so brightness remains correct
    return accum / GAUSSIAN_5X5_TOTAL;
}

Key points

Normalization (/256) ensures you’re still averaging, not amplifying.
Keeps the entire 2D blur in one pass (25 taps).
If you only ever need one channel, you can replace float4 with float.

2) Direction‐aware version

/// <summary>
/// Applies a 5×5 Gaussian blur to directional data stored in xyz (unit vectors)
/// plus a scalar in .w (e.g. magnitude).
/// Performs a weighted average then re‐normalizes the vector to avoid
/// “cancelling‐out” artifacts when neighbouring directions oppose each other.
/// </summary>
float4 Gaussian5x5_Direction(int3 id, RWTexture3D<float4> bufferA)
{
    float3 dirAcc = float3(0,0,0);
    float  magAcc = 0;

    [unroll]
    for (int i = 0; i < 25; ++i)
    {
        int3 off      = int3(GAUSSIAN_5X5_OFFSETS[i].x, 0, GAUSSIAN_5X5_OFFSETS[i].y);
        float4 sample = bufferA[id + off];
        float  w      = GAUSSIAN_5X5_WEIGHTS[i];

        dirAcc += sample.xyz * w;    // accumulate weighted direction
        magAcc += sample.w   * w;    // accumulate weighted magnitude
    }

    // 1) average
    dirAcc /= GAUSSIAN_5X5_TOTAL;
    magAcc /= GAUSSIAN_5X5_TOTAL;

    // 2) re‐normalize direction to unit length
    //    this prevents opposite vectors from cancelling each other out
    dirAcc = normalize(dirAcc);

    return float4(dirAcc, magAcc);
}

Why this avoids “cancelling‐out”

When you blur unit vectors by simple averaging:

Two neighbouring voxels with opposite directions (e.g. +X vs –X) sum to zero → you lose all orientation.
Even slightly divergent vectors shrink toward the zero‐vector, losing magnitude and bias.

By re‐normalizing the averaged direction (normalize(dirAcc)), you:

Preserve a unit‐length result, so all outputs stay valid directions.
Bias the result toward the geodesic mean on the sphere rather than the linear mean—small angular differences blend smoothly, large oppositions are resolved to one direction rather than zero.

Further optimizations

Separable blur: split into two 1D passes (5 taps each on X, then on Z) → only 10 fetches per pass × 2 passes = 20 fetches instead of 25.
Boundary handling: clamp or pad id + off to avoid out‐of‐bounds.
Half‐precision: if your data tolerates it, use half for weight and accumulation to reduce bandwidth.

Make it as separable as possible
Ensure proper averaging (without “edge darkening”) at the edge cases

keep in mind that my constants are like this:

static int3 GAUSSIAN_5X5_OFFSETS[25] = { int3(-2,0,2), int3(-1,0,2), int3(0,0,2), int3(1,0,2), int3(2,0,2),

int3(-2,0,1),
int3(-1,0,1),
int3(0,0,1),
int3(1,0,1),
int3(2,0,1),

int3(-2,0,0),
int3(-1,0,0),
int3(0,0,0),
int3(1,0,0),
int3(2,0,0),

int3(-2,0,-1),
int3(-1,0,-1),
int3(0,0,-1),
int3(1,0,-1),
int3(2,0,-1),

int3(-2,0,-2),
int3(-1,0,-2),
int3(0,0,-2),
int3(1,0,-2),
int3(2,0,-2)

};

static float GAUSSIAN_5X5_WEIGHTS[25] = { 1 /256., 4 /256., 6 /256., 4 /256., 1 /256., 4 /256., 16 /256., 24 /256., 16 /256., 4 /256., 6 /256., 24 /256., 36 /256., 24 /256., 6 /256., 4 /256., 16 /256., 24 /256., 16 /256., 4 /256., 1 /256., 4 /256., 6 /256., 4 /256., 1 /256., };

Below is a fully separable, two‐pass 5×5 Gaussian blur for both scalar (float4) data and direction+scalar (float4 where .xyz is a unit vector and .w is a magnitude). Both versions:

Split into a horizontal pass (X) and a vertical pass (Z) of five taps each (total 10 texture fetches × 2 passes = 20 fetches).
Clamp—but more importantly—skip out‐of‐bounds taps at the edges and renormalize by the actual sum of weights used. That guarantees no “edge darkening.”
In the direction version, we re‐normalize the blurred .xyz each pass to stay on the unit sphere, which prevents opposite vectors from cancelling out.

You’ll need to supply your volume dimensions in a constant buffer:

cbuffer BlurParams : register(b0)
{
    int3 volumeSize;    // x = width, y = height (unchanged), z = depth
};

And reuse your 1D offset/weight arrays:

static const int3  OFFSETS[5] = {
    int3(-2,0,0), int3(-1,0,0), int3(0,0,0), int3(1,0,0), int3(2,0,0)
};
static const int3  VOFFSETS[5] = {
    int3(0,0,-2), int3(0,0,-1), int3(0,0,0), int3(0,0,1), int3(0,0,2)
};
static const float WEIGHTS[5] = {
    1/256.0, 4/256.0, 6/256.0, 4/256.0, 1/256.0
};

A) Scalar blur (exactly separable)

Pass 1: horizontal (X)

[numthreads(8,8,8)]
void Gaussian_Horizontal_Scalar(uint3 id : SV_DispatchThreadID)
{
    // 1) Bounds check on Y (height) and Z (depth) so we only blur in X:
    if (id.y < 0 || id.y >= volumeSize.y ||
        id.z < 0 || id.z >= volumeSize.z) return;

    float4 accum = float4(0,0,0,0);
    float   wSum  = 0;

    [unroll]
    for (int i = 0; i < 5; i++)
    {
        int3 pos = id + OFFSETS[i];
        // 2) Skip OOB taps
        if (pos.x < 0 || pos.x >= volumeSize.x) continue;

        float w = WEIGHTS[i];
        accum  += bufferA[pos] * w;
        wSum   += w;
    }

    // 3) Normalize by the actual sum of weights to avoid edge darkening
    bufferB[id] = accum / wSum;
}

Pass 2: vertical (Z)

[numthreads(8,8,8)]
void Gaussian_Vertical_Scalar(uint3 id : SV_DispatchThreadID)
{
    if (id.y < 0 || id.y >= volumeSize.y ||
        id.x < 0 || id.x >= volumeSize.x) return;

    float4 accum = float4(0,0,0,0);
    float   wSum  = 0;

    [unroll]
    for (int i = 0; i < 5; i++)
    {
        int3 pos = id + VOFFSETS[i];
        if (pos.z < 0 || pos.z >= volumeSize.z) continue;

        float w = WEIGHTS[i];
        accum  += bufferB[pos] * w;   // note: reading from the horizontal‐pass buffer
        wSum   += w;
    }

    bufferA[id] = accum / wSum;       // final blurred result back into bufferA
}

B) Direction‐aware blur (separable approximation)

Because true spherical Gaussian blur isn’t strictly separable once you renormalize, this two‐pass version is an efficient approximation: each pass does a weighted average → normalize, which prevents cancellation and roughly mimics a full 5×5 spherical blur.

Pass 1: horizontal (X)

[numthreads(8,8,8)]
void Gaussian_Horizontal_Direction(uint3 id : SV_DispatchThreadID)
{
    if (id.y < 0 || id.y >= volumeSize.y ||
        id.z < 0 || id.z >= volumeSize.z) return;

    float3 dirAcc = float3(0,0,0);
    float  magAcc = 0;
    float  wSum   = 0;

    [unroll]
    for (int i = 0; i < 5; i++)
    {
        int3 pos = id + OFFSETS[i];
        if (pos.x < 0 || pos.x >= volumeSize.x) continue;

        float4 s = bufferA[pos];
        float  w = WEIGHTS[i];

        dirAcc += s.xyz * w;   // weighted sum of direction
        magAcc += s.w   * w;   // weighted sum of magnitude
        wSum   += w;
    }

    // 1) Average
    dirAcc /= wSum;
    magAcc /= wSum;

    // 2) Renormalize direction vector — this avoids opposite‐vector cancellation
    dirAcc = normalize(dirAcc);

    bufferB[id] = float4(dirAcc, magAcc);
}

Pass 2: vertical (Z)

[numthreads(8,8,8)]
void Gaussian_Vertical_Direction(uint3 id : SV_DispatchThreadID)
{
    if (id.y < 0 || id.y >= volumeSize.y ||
        id.x < 0 || id.x >= volumeSize.x) return;

    float3 dirAcc = float3(0,0,0);
    float  magAcc = 0;
    float  wSum   = 0;

    [unroll]
    for (int i = 0; i < 5; i++)
    {
        int3 pos = id + VOFFSETS[i];
        if (pos.z < 0 || pos.z >= volumeSize.z) continue;

        float4 s = bufferB[pos];   // from horizontal‐pass buffer
        float  w = WEIGHTS[i];

        dirAcc += s.xyz * w;
        magAcc += s.w   * w;
        wSum   += w;
    }

    dirAcc /= wSum;
    magAcc /= wSum;
    dirAcc = normalize(dirAcc);

    bufferA[id] = float4(dirAcc, magAcc);
}

Why the direction version avoids cancelling‐out

Linear sum of two opposite unit vectors is zero → scalar‐only blur would collapse to zero length.
Re‐normalizing after the weighted average projects the result back onto the unit sphere, preserving a valid direction even when neighbors “oppose” each other.
By doing this each 1D pass, we approximate a full spherical Gaussian—small deviations blend smoothly, and even large angular differences never “fade away” to black (zero vector).

Below is the full 5×5 (non-separable) Gaussian blur for both scalars and direction+scalar—with edge-aware weighting—followed by the C# “old-school” swap of your ping-pong buffers.

HLSL: Full 5×5 Gaussian (with edge handling)

Keep your GAUSSIAN_5X5_OFFSETS[25] and GAUSSIAN_5X5_WEIGHTS[25] as defined. We assume you also have a volumeSize constant buffer:

cbuffer BlurParams : register(b0)
{
    int3 volumeSize;    // x = width, y = height, z = depth
};

1) Scalar version

/// <summary>
/// 5×5 Gaussian blur of float4 scalar data (RGBA).
/// Skips out-of-bounds taps and renormalizes by actual weight sum
/// to avoid edge darkening.
/// </summary>
float4 Gaussian5x5_Scalar(int3 id, Texture3D<float4> src)
{
    float4 accum = float4(0,0,0,0);
    float   wSum  = 0;

    [unroll]
    for (int i = 0; i < 25; ++i)
    {
        int3 off = GAUSSIAN_5X5_OFFSETS[i];
        int3 pos = id + off;

        // Skip taps outside the volume
        if (any(pos < int3(0,0,0)) || any(pos >= volumeSize))
            continue;

        float  w      = GAUSSIAN_5X5_WEIGHTS[i];
        float4 sample = src.Load(int4(pos, 0));  // or src[pos] if RWTexture
        accum += sample * w;
        wSum  += w;
    }

    // Divide by the sum of used weights → true average
    return accum / wSum;
}

2) Direction + Scalar version

/// <summary>
/// 5×5 Gaussian blur of directional data in .xyz (unit vector)
/// and a magnitude in .w.
/// Skips OOB taps, averages then re-normalizes direction to avoid
/// “cancelling-out,” and scales magnitude correctly.
/// </summary>
float4 Gaussian5x5_Direction(int3 id, Texture3D<float4> src)
{
    float3 dirAcc = float3(0,0,0);
    float  magAcc = 0;
    float  wSum   = 0;

    [unroll]
    for (int i = 0; i < 25; ++i)
    {
        int3 off = GAUSSIAN_5X5_OFFSETS[i];
        int3 pos = id + off;

        if (any(pos < int3(0,0,0)) || any(pos >= volumeSize))
            continue;

        float4 s = src.Load(int4(pos, 0));
        float  w = GAUSSIAN_5X5_WEIGHTS[i];

        dirAcc += s.xyz * w;  // accumulate weighted vector
        magAcc += s.w   * w;  // accumulate weighted magnitude
        wSum   += w;
    }

    // 1) average components
    dirAcc /= wSum;
    magAcc /= wSum;

    // 2) re-normalize to unit length → avoids cancellation
    dirAcc = normalize(dirAcc);

    return float4(dirAcc, magAcc);
}

C# Ping-Pong Buffer Swap (old-school)

Instead of the tuple-swap:

(buffer[READ], buffer[WRITE]) = (buffer[WRITE], buffer[READ]);

use a temporary variable:

// assume these are fields or locals:
RenderTexture readTex, writeTex;

// After dispatching your compute:
computeShader.SetTexture(kernel, "Src", readTex);
computeShader.SetTexture(kernel, "Dst", writeTex);
computeShader.Dispatch(kernel, gx, gy, gz);

// Old-school swap:
var temp     = readTex;
readTex      = writeTex;
writeTex     = temp;

This achieves exactly the same ping-pong behavior without tuple unpacking, and is compatible with all C# versions and code-analysis rules.