// This is "kernel 4" in a 4-kernel pipeline. It renders the commands
// in the per-tile command list to an image.

// Right now, this kernel stores the image in a buffer, but a better
// plan is to use a texture. This is because of limited support.

#version 450
#extension GL_GOOGLE_include_directive : enable
#extension GL_KHR_shader_subgroup_basic : enable

#include "setup.h"

#define CHUNK 8
#define CHUNK_DY (TILE_HEIGHT_PX / CHUNK)
layout(local_size_x = TILE_WIDTH_PX, local_size_y = CHUNK_DY) in;

// Same concern that this should be readonly as in kernel 3.
layout(set = 0, binding = 0) buffer PtclBuf {
    uint[] ptcl;
};

layout(set = 0, binding = 1) buffer TileBuf {
    uint[] tile;
};

layout(rgba8, set = 0, binding = 2) uniform writeonly image2D image;

#include "ptcl.h"
#include "tile.h"

void main() {
    uint tile_ix = gl_WorkGroupID.y * WIDTH_IN_TILES + gl_WorkGroupID.x;
    CmdRef cmd_ref = CmdRef(tile_ix * PTCL_INITIAL_ALLOC);

    uvec2 xy_uint = uvec2(gl_GlobalInvocationID.x, gl_LocalInvocationID.y + TILE_HEIGHT_PX * gl_WorkGroupID.y);
    vec2 xy = vec2(xy_uint);
    vec2 uv = xy * vec2(1.0 / IMAGE_WIDTH, 1.0 / IMAGE_HEIGHT);
    //vec3 rgb = uv.xyy;
    vec3 rgb[CHUNK];
    for (uint i = 0; i < CHUNK; i++) {
        rgb[i] = vec3(0.5);
    }

    while (true) {
        uint tag = Cmd_tag(cmd_ref);
        if (tag == Cmd_End) {
            break;
        }
        switch (tag) {
        case Cmd_Circle:
            CmdCircle circle = Cmd_Circle_read(cmd_ref);
            vec4 fg_rgba = unpackUnorm4x8(circle.rgba_color).wzyx;
            for (uint i = 0; i < CHUNK; i++) {
                float dy = float(i * CHUNK_DY);
                float r = length(vec2(xy.x, xy.y + dy) + vec2(0.5, 0.5) - circle.center.xy);
                float alpha = clamp(0.5 + circle.radius - r, 0.0, 1.0);
                // TODO: sRGB
                rgb[i] = mix(rgb[i], fg_rgba.rgb, alpha * fg_rgba.a);
            }
            break;
        case Cmd_Stroke:
            // Calculate distance field from all the line segments in this tile.
            CmdStroke stroke = Cmd_Stroke_read(cmd_ref);
            float df[CHUNK];
            for (uint k = 0; k < CHUNK; k++) df[k] = 1e9;
            TileSegRef tile_seg_ref = TileSegRef(stroke.tile_ref);
            do {
                TileSeg seg = TileSeg_read(tile_seg_ref);
                vec2 line_vec = seg.end - seg.start;
                for (uint k = 0; k < CHUNK; k++) {
                    vec2 dpos = xy + vec2(0.5, 0.5) - seg.start;
                    dpos.y += float(k * CHUNK_DY);
                    float t = clamp(dot(line_vec, dpos) / dot(line_vec, line_vec), 0.0, 1.0);
                    df[k] = min(df[k], length(line_vec * t - dpos));
                }
                tile_seg_ref = seg.next;
            } while (tile_seg_ref.offset != 0);
            fg_rgba = unpackUnorm4x8(stroke.rgba_color).wzyx;
            for (uint k = 0; k < CHUNK; k++) {
                float alpha = clamp(stroke.half_width + 0.5 - df[k], 0.0, 1.0);
                rgb[k] = mix(rgb[k], fg_rgba.rgb, alpha * fg_rgba.a);
            }
            break;
        case Cmd_Fill:
            // Calculate coverage based on backdrop + coverage of each line segment
            CmdFill fill = Cmd_Fill_read(cmd_ref);
            // Probably better to store as float, but conversion is no doubt cheap.
            float area[CHUNK];
            for (uint k = 0; k < CHUNK; k++) area[k] = float(fill.backdrop);
            tile_seg_ref = TileSegRef(fill.tile_ref);
            do {
                TileSeg seg = TileSeg_read(tile_seg_ref);
                for (uint k = 0; k < CHUNK; k++) {
                    vec2 my_xy = vec2(xy.x, xy.y + float(k * CHUNK_DY));
                    vec2 start = seg.start - my_xy;
                    vec2 end = seg.end - my_xy;
                    vec2 window = clamp(vec2(start.y, end.y), 0.0, 1.0);
                    if (window.x != window.y) {
                        vec2 t = (window - start.y) / (end.y - start.y);
                        vec2 xs = vec2(mix(start.x, end.x, t.x), mix(start.x, end.x, t.y));
                        float xmin = min(min(xs.x, xs.y), 1.0) - 1e-6;
                        float xmax = max(xs.x, xs.y);
                        float b = min(xmax, 1.0);
                        float c = max(b, 0.0);
                        float d = max(xmin, 0.0);
                        float a = (b + 0.5 * (d * d - c * c) - xmin) / (xmax - xmin);
                        area[k] += a * (window.x - window.y);
                    }
                    area[k] += sign(end.x - start.x) * clamp(my_xy.y - seg.y_edge + 1.0, 0.0, 1.0);
                }
                tile_seg_ref = seg.next;
            } while (tile_seg_ref.offset != 0);
            fg_rgba = unpackUnorm4x8(fill.rgba_color).wzyx;
            for (uint k = 0; k < CHUNK; k++) {
                float alpha = min(abs(area[k]), 1.0);
                rgb[k] = mix(rgb[k], fg_rgba.rgb, alpha * fg_rgba.a);
            }
            break;
        case Cmd_Solid:
            CmdSolid solid = Cmd_Solid_read(cmd_ref);
            fg_rgba = unpackUnorm4x8(solid.rgba_color).wzyx;
            for (uint k = 0; k < CHUNK; k++) {
                rgb[k] = mix(rgb[k], fg_rgba.rgb, fg_rgba.a);
            }
            break;
        case Cmd_Jump:
            cmd_ref = CmdRef(Cmd_Jump_read(cmd_ref).new_ref);
            continue;
        }
        cmd_ref.offset += Cmd_size;
    }

    // TODO: sRGB
    for (uint i = 0; i < CHUNK; i++) {
        imageStore(image, ivec2(xy_uint.x, xy_uint.y + CHUNK_DY * i), vec4(rgb[i], 1.0));
    }
}