#version 460 core

layout (location = 0) in vec3 position;
layout (location = 1) flat in int id; // 'flat' required
layout (location = 0) out vec4 FragColor;

layout (std430, binding = 2) buffer canvas_stack_fs
{
    int u_ring_count;
    float u_song_time;
    float u_flow_scale;
    float u_thickness;
    vec4 padding;
    vec4 u_hline_color;
};

const float PI = 3.141592653;
const float thickness = 0.010;
const int lane_count = 256;
const int block_count = 16;

uniform samplerBuffer u_tbo_tex[block_count];

float random(float x)
{
    return fract(sin(x + 1000.0) * 100000.0);
}

void main()
{    
    // Pixel coordinates
    vec2 pixel_position = position.xy;
    // Current pixel
    vec2 st = pixel_position;

    // Offset to the middle
    st.x -= 0.5;

    // Flow speed affects how much can be seen
    st.x *= 1.0 / (u_flow_scale); // Multiply by negative for inverse flow

    // Data length * point density = total time in seconds
    float total_time = u_ring_count * 0.016;

    // Distance represents song time
    // Always from "start 0.0 to end 1.0"
    float distance = u_song_time / total_time;

    // Current pixel where distance is applied
    vec2 sts = st;
    sts.x += distance;

    // Apply sliding effect to the current pixel
    st.x += distance;
    st = fract(st);

    // Current ring calculated from sts
    int ring_n = int(floor(sts.x * float(u_ring_count)));

    // Lane index from the total lane count
    int lane_n = id;
    
    int block_lane_count = lane_count / block_count;

    int block_n = int(floor(float(lane_n) / float(block_lane_count)));
    // Lane index within the block lane count
    int block_lane_n = lane_n - (block_lane_count * block_n);

    // Calculate location
    int n = block_lane_n * u_ring_count + ring_n;

    // SRGB
    n *= 4;

    // Fetch audio data
    vec2 audio_texel = vec2(texelFetch(u_tbo_tex[block_n], n).r, texelFetch(u_tbo_tex[block_n], n + 4).r);
    float height_a = audio_texel.x;
    float height_b = audio_texel.y;

    // Noise calculations
    int nr = int(floor(st.x));
    float l = fract(st.x);

    float noise = mix(random(float(nr + lane_n * 10)), random(float(nr + 1 + lane_n * 10)), smoothstep(0.0, 1.0, l));

    // Apply noise to height
    height_a = (height_a + (sin(u_song_time + noise * 10.0) * noise) * 0.05);
    height_b = (height_b + (sin(u_song_time + noise * 10.0) * noise) * 0.05);

    // Space between each point
    float gap = 1.0 / float(u_ring_count);

    // Position x of two points next to each other
    float x0 = gap * float(ring_n);
    float x1 = gap * (float(ring_n) + 1.0);

    // Line calculations
    vec2 pa = st - vec2(x0, height_a);
    vec2 ba = vec2(x1, height_b) - vec2(x0, height_a);
    float h = clamp(dot(pa, ba) / dot(ba, ba), -80.0, 80.0); // High clamp value fixes visual bug

    float dist = length(pa - ba * h);

    // Line appearance adjustments
    vec2 len = vec2(x1 - x0, abs(audio_texel.x - audio_texel.y));
    float ratio = len.y / len.x;
    float side = dist * ratio;

    dist = sqrt(dist * dist + side * side);

    // No need to draw if outside of the line (optimization)
    if (dist > u_thickness)
    {
        discard;
    }

    // Actual line segment calculation
    float line_segment = smoothstep(0.0, u_thickness, dist);

    // Background alpha increases when approaching "zero" height
    float bg_alpha = log(audio_texel.x + 1.0) * 8.0;

    // Distance from edges
    float f = sin(pixel_position.x * PI) * 3.0;
    bg_alpha *= clamp(f, 0.0, 1.0);

    // Texel fetch color data
    vec3 color_texel = vec3
    (
        texelFetch(u_tbo_tex[block_n], n + 1).r, 
        texelFetch(u_tbo_tex[block_n], n + 2).r, 
        texelFetch(u_tbo_tex[block_n], n + 3).r
    );

    // Apply background alpha
    float color_r = color_texel.r * bg_alpha;
    float color_g = color_texel.g * bg_alpha;
    float color_b = color_texel.b * bg_alpha;
    float color_a = 0.1;

    // Mix final color
    vec4 color_final = mix(vec4(color_r, color_g, color_b, color_a), vec4(0.0, 0.0, 0.0, 0.0), line_segment);

    // Middle (hearing) line draw
    if (pixel_position.x > 0.499 && pixel_position.x <