Iteration of each pixel of a large bitmap in Unity Compute Shaders

Question

I am trying to clone the map generation system of the game Europa Universalis IV. The game has a large sized bitmap and each province is colored in a unique color. I want to use compute shaders to iterate through the bitmap and try to cache the province's shape in the most minimal data structure as possible. But i'm probably doing something wrong either in the C# code or the HLSL code.

The bitmap's size is 5632 * 2048. My aim was to have 32 * 32 threads and have each of them iterate their own part (176 * 64). For example, the thread (4, 15) must start its iteration from (704, 960). The output is a int2 which has the coordinates of each found pixel of the province in the bitmap.

• In the C# code, since the province's pixel count is unknown, I've set the output's array size to a big number like 10000. The index 0 of the output has the found pixel count.
• In the shader code, I started the iteration from 1 so that the index 0 can be set to the found pixel count.
• The bitmap's read/write is enabled.

When I Debug.Log the index 0 of the output, I always get 0. So that the for loop in the C# code doesn't work.

C# code:

struct Int2
{
    public int x, y;
}
private void ReadBitmap() {
    int threadIterationCount = 176 * 64;
    int size = sizeof(int) * 2;
    _shaderOutput = new Int2[10000];
    ComputeBuffer buffer = new ComputeBuffer(10000, size);
    buffer.SetData(_shaderOutput);
    
    Color debugColor = new Color32(173, 66, 32, 255);
    
    bitmapComputeShader.SetVector("reference_color", debugColor);;
    bitmapComputeShader.SetTexture(0, "bitmap", bitmap);
    bitmapComputeShader.SetBuffer(0, "output", buffer);
    bitmapComputeShader.Dispatch(0,
        threadIterationCount, 
        threadIterationCount, 
        1);
    buffer.GetData(_shaderOutput);
    buffer.Dispose();
    Debug.Log(_shaderOutput[0].x); // It logs 0
    
    // The index 0 of the _shaderOutput is set by the shader as the length of the array
    // since we can't be sure of the size of the array.
    for (int m = 0; m < _shaderOutput[0].x; m++) {
        int x = _shaderOutput[m].x;
        int y = _shaderOutput[m].y;
        if(x==0 && y==00) continue;
        Color32 color = bitmap.GetPixel(x, y);
        _areaBuilders[color].AddPixel(x, y);
    }
}

Compute Shader code:

#pragma kernel CSMain

const uint width = 5632;
const uint height = 2048;

const int width_step = 176;
const int height_step = 64;

int last_iteration = 1;

Texture2D bitmap;
SamplerState smp_clamp_point;
float4 reference_color;
RWStructuredBuffer<int2> output;

bool compare_colors(float4 col, float4 ref_col) {
    const int col_r = round(col.x * 255);
    const int col_g = round(col.y * 255);
    const int col_b = round(col.z * 255);

    const int ref_col_r = round(ref_col.x * 255);
    const int ref_col_g = round(ref_col.y * 255);
    const int ref_col_b = round(ref_col.z * 255);

    return (col_r == ref_col_r && col_g == ref_col_g && col_b == ref_col_b);
}

void thread_job(uint x_index, uint y_index) {
    float u = 0;
    float v = 0;

    for (int i = 0; i < width_step; i++) {
        for (int j = 0; j < height_step; j++) {
            int2 xy_coords;
            xy_coords.x = x_index * width_step + i;
            xy_coords.y = y_index * height_step + j;
            
            u = xy_coords.x / width;
            v = xy_coords.y / height;
            
            const float2 uv = float2(u, v);
            const float4 pixel = bitmap.SampleLevel(smp_clamp_point, uv, 0);
            
            if(compare_colors(pixel, reference_color)) {
                output[last_iteration] = xy_coords;
                last_iteration++;
                output[0].x = last_iteration;
            }
        }
    }
}

[numthreads(32,32,1)]
void CSMain (uint3 id : SV_DispatchThreadID) {
    thread_job(id.x, id.y);
}

Thank you for your attention!