// Compute Shader
[[branch]] if(is_visible) {
    uint index = atomicIncrement(indirect_buffer[0]);
    batch_buffer[index] = (group_id << 16u) | geometry_index;
}

// dispatch raster kernel
compute.setKernel(raster_kernel);
compute.setUniform(0, common_parameters);
compute.setStorageBuffers(0, {
    instances_buffer,
    geometries_buffer,
    batch_buffer,
    vertex_buffer,
    index_buffer,
});
compute.setSurfaceTextures(0, {
    depth_surface,
    color_surface,
});
compute.setIndirectBuffer(indirect_buffer);
compute.dispatchIndirect();

layout(local_size_x = GROUP_SIZE) in;

layout(std430, binding = 1) readonly buffer InstancesBuffer { vec4 instances_buffer[]; };
layout(std430, binding = 2) readonly buffer GeometriesBuffer { GeometryParameters geometries_buffer[]; };
layout(std430, binding = 3) readonly buffer RasterBuffer { uint batch_buffer[]; };
layout(std430, binding = 4) readonly buffer VerticesBuffer { Vertex vertices_buffer[]; };
layout(std430, binding = 5) readonly buffer IndicesBuffer { uint indices_buffer[]; };

layout(std430, binding = 6) buffer DepthBuffer { uint depth_buffer[]; };
layout(binding = 0, set = 1, r32ui) uniform uimage2D color_surface;

shared vec4 transform[3];
shared uint num_vertices;
shared uint base_vertex;
shared uint num_primitives;
shared uint base_primitive;

shared vec3 positions[MAX_VERTICES];
shared vec3 directions[MAX_VERTICES];
shared vec3 normals[MAX_VERTICES];

shared vec3 geometry_color;
shared float split_position;

/*
 */
void raster(uint i0, uint i1, uint i2) {

    // clip triangle
    vec3 p0 = positions[i0];
    vec3 p1 = positions[i1];
    vec3 p2 = positions[i2];
    [[branch]] if(p0.z < 0.0f || p1.z < 0.0f || p2.z < 0.0f) return;

    // backface culling
    vec3 p10 = p1 - p0;
    vec3 p20 = p2 - p0;
    float det = p20.x * p10.y - p20.y * p10.x;
    #if CLAY_VK
        [[branch]] if(det <= 0.0f) return;
    #else
        [[branch]] if(det >= 0.0f) return;
    #endif

    // triangle rect
    float x0 = min(min(p0.x, p1.x), p2.x);
    float y0 = min(min(p0.y, p1.y), p2.y);
    float x1 = ceil(max(max(p0.x, p1.x), p2.x));
    float y1 = ceil(max(max(p0.y, p1.y), p2.y));
    [[branch]] if(x1 - floor(x0) < 2.0f || y1 - floor(y0) < 2.0f) return;
    x0 = floor(x0 + 0.5f);
    y0 = floor(y0 + 0.5f);

    // viewport cull
    [[branch]] if(x1 < 0.0f || y1 < 0.0f || x0 >= surface_width || y0 >= surface_height) return;
    x0 = max(x0, 0.0f); x1 = min(x1, surface_width);
    y0 = max(y0, 0.0f); y1 = min(y1, surface_height);

    // triangle area
    float area = (x1 - x0) * (y1 - y0);
    [[branch]] if(area == 0.0f) return;

    // triangle parameters
    float idet = 1.0f / det;
    vec2 dx = vec2(-p20.y, p10.y) * idet;
    vec2 dy = vec2(p20.x, -p10.x) * idet;
    vec2 texcoord_x = dx * (x0 - p0.x);
    vec2 texcoord_y = dy * (y0 - p0.y);

    vec3 d0 = directions[i0];
    vec3 d10 = directions[i1] - d0;
    vec3 d20 = directions[i2] - d0;

    vec3 n0 = normals[i0];
    vec3 n10 = normals[i1] - n0;
    vec3 n20 = normals[i2] - n0;

    for(float y = y0; y < y1; y += 1.0f) {
        vec2 texcoord = texcoord_x + texcoord_y;
        for(float x = x0; x < x1; x += 1.0f) {
            [[branch]] if(texcoord.x > -1e-5f && texcoord.y > -1e-5f && texcoord.x + texcoord.y < 1.0f + 1e-5f) {

                uint z = floatBitsToUint(p10.z * texcoord.x + p20.z * texcoord.y + p0.z);

                // depth test
                uint index = uint(surface_width * y + x);
                uint old_z = atomicMax(depth_buffer[index], z);
                [[branch]] if(old_z < z) {

                    // interpolate attributes
                    vec3 direction = normalize(d10 * texcoord.x + d20 * texcoord.y + d0);
                    vec3 normal = normalize(n10 * texcoord.x + n20 * texcoord.y + n0);

                    // light color
                    float diffuse = clamp(dot(direction, normal), 0.0f, 1.0f);
                    float specular = pow(clamp(dot(reflect(-direction, normal), direction), 0.0f, 1.0f), 16.0f);

                    // pack color
                    vec3 color = (x < split_position) ? vec3(0.75f) : geometry_color;
                    uint c = packUnorm4x8(vec4(color * diffuse + specular, 1.0f));
                    if(abs(x - split_position) < 1.0f) c = 0u;

                    // write color
                    #if CLAY_GLES || CLAY_MTL || CLAY_WG
                        imageStore(color_surface, ivec2(vec2(x, y)), uvec4(c));
                    #else
                        imageAtomicExchange(color_surface, ivec2(vec2(x, y)), c);
                    #endif
                }
            }

            texcoord += dx;
        }

        texcoord_y += dy;
    }
}

/*
 */
void main() {

    uint local_id = gl_LocalInvocationIndex;
    #if CLAY_WG
        uint group_id = gl_WorkGroupID.y * 256u + gl_WorkGroupID.x;
    #else
        uint group_id = gl_WorkGroupID.x;
    #endif

    // mesh parameters
    [[branch]] if(local_id == 0u) {

        // raster group
        uint index = batch_buffer[group_id];

        // instance transform
        uint instance = (index >> 16u) * 3u;
        transform[0] = instances_buffer[instance + 0u];
        transform[1] = instances_buffer[instance + 1u];
        transform[2] = instances_buffer[instance + 2u];

        // geometry parameters
        uint geometry = index & 0xffffu;
        num_vertices = geometries_buffer[geometry].num_vertices;
        base_vertex = geometries_buffer[geometry].base_vertex;
        num_primitives = geometries_buffer[geometry].num_primitives;
        base_primitive = geometries_buffer[geometry].base_primitive;

        // mesh color
        float seed = mod(instance + geometry * 93.7351f, 1024.0f);
        geometry_color = cos(vec3(0.0f, 0.5f, 1.0f) * 3.14f + seed) * 0.5f + 0.5f;

        // split position
        split_position = surface_width * (cos(time) * 0.25f + 0.75f);
    }
    memoryBarrierShared(); barrier();

    // vertices
    [[loop]] for(uint i = local_id; i < num_vertices; i += GROUP_SIZE) {

        // fetch vertex
        uint vertex = base_vertex + i;
        vec4 position = vec4(vertices_buffer[vertex].position.xyz, 1.0f);
        vec3 normal = vertices_buffer[vertex].normal.xyz;

        // transform position
        position = vec4(dot(transform[0], position), dot(transform[1], position), dot(transform[2], position), 1.0f);

        // camera direction
        directions[i] = camera.xyz - position.xyz;

        // normal vector
        normals[i] = vec3(dot(transform[0].xyz, normal), dot(transform[1].xyz, normal), dot(transform[2].xyz, normal));

        // project position
        position = projection * (modelview * position);
        positions[i] = vec3((position.xy / position.w * 0.5f + 0.5f) * vec2(surface_width, surface_height) - 0.5f, position.z / position.w);
    }
    memoryBarrierShared(); barrier();

    // primitives
    [[loop]] for(uint i = local_id; i < num_primitives; i += GROUP_SIZE) {

        // fetch indices
        uint indices = indices_buffer[base_primitive + i];
        uint index_0 = (indices >>  0u) & 0x3ffu;
        uint index_1 = (indices >> 10u) & 0x3ffu;
        uint index_2 = (indices >> 20u) & 0x3ffu;

        // raster triangle
        raster(index_0, index_1, index_2);
    }
}