#version 450 core

// ---------- Vertex attributes (used in both modes) ----------
layout(location = 0) in vec2 v_position;
layout(location = 1) in vec2 v_uv;
layout(location = 2) in vec4 v_color;

// ---------- Outputs to fragment shader ----------
layout(location = 0) out mediump vec4 f_color;
layout(location = 1) out vec2 f_local_or_uv;
layout(location = 2) out vec4 f_params;
layout(location = 3) out vec4 f_params2;
layout(location = 4) flat out uint f_flags;

layout(location = 6) flat out vec4 f_uv_rect;
layout(location = 7) flat out uvec4 f_effects;

// ---------- Uniforms (single block — avoids spirv-cross reordering on Metal) ----------
layout(set = 1, binding = 0) uniform Uniforms {
    mat4 projection;
    float dpi_scale;
    uint mode; // 0 = tessellated, 1 = SDF
};

// ---------- SDF primitive storage buffer ----------
// Mirrors the CPU-side Base_2D_Primitive in pipeline_2d_base.odin. Named with the
// pipeline prefix so a project-wide grep on the type name matches both the GLSL
// declaration and the Odin declaration.
struct Base_2D_Primitive {
    vec4 bounds; // 0-15
    uint color; // 16-19
    uint flags; // 20-23
    uint rotation_sc; // 24-27: packed f16 pair (sin, cos)
    float _pad; // 28-31
    vec4 params; // 32-47
    vec4 params2; // 48-63
    vec4 uv_rect; // 64-79: texture UV coordinates (read when .Textured)
    uvec4 effects; // 80-95: gradient/outline parameters (read when .Gradient/.Outline)
};

layout(std430, set = 0, binding = 0) readonly buffer Base_2D_Primitives {
    Base_2D_Primitive primitives[];
};

// ---------- Entry point ----------
void main() {
    if (mode == 0u) {
        // ---- Mode 0: Tessellated (legacy) ----
        f_color = v_color;
        f_local_or_uv = v_uv;
        f_params = vec4(0.0);
        f_params2 = vec4(0.0);
        f_flags = 0u;
        f_uv_rect = vec4(0.0);
        f_effects = uvec4(0);

        gl_Position = projection * vec4(v_position * dpi_scale, 0.0, 1.0);
    } else {
        // ---- Mode 1: SDF instanced quads ----
        Base_2D_Primitive p = primitives[gl_InstanceIndex];

        vec2 corner = v_position; // unit quad corners: (0,0)-(1,1)
        vec2 world_pos = mix(p.bounds.xy, p.bounds.zw, corner);
        vec2 center = 0.5 * (p.bounds.xy + p.bounds.zw);

        // Compute shape-local position. Apply inverse rotation here in the vertex
        // shader; the rasterizer interpolates the rotated values across the quad,
        // which is mathematically equivalent to per-fragment rotation under 2D ortho
        // projection. Frees one fragment-shader varying and per-pixel rotation math.
        vec2 local = (world_pos - center) * dpi_scale;
        uint flags = (p.flags >> 8u) & 0xFFu;
        if ((flags & 16u) != 0u) {
            // Rotated flag (bit 4); rotation_sc holds packed f16 (sin, cos).
            // Inverse rotation matrix R(-angle) = [[cos, sin], [-sin, cos]].
            vec2 sc = unpackHalf2x16(p.rotation_sc);
            local = vec2(sc.y * local.x + sc.x * local.y,
                    -sc.x * local.x + sc.y * local.y);
        }

        f_color = unpackUnorm4x8(p.color);
        f_local_or_uv = local; // shape-local physical pixels (rotated if .Rotated set)
        f_params = p.params;
        f_params2 = p.params2;
        f_flags = p.flags;
        f_uv_rect = p.uv_rect;
        f_effects = p.effects;

        gl_Position = projection * vec4(world_pos * dpi_scale, 0.0, 1.0);
    }
}