//! Ported from https://www.shadertoy.com/view/ltXSDB

// Signed Distance to a Quadratic Bezier Curve
// - Adam Simmons (@adamjsimmons) 2015
//
// License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
//
// Inspired by http://www.pouet.net/topic.php?which=9119
// and various shaders by iq, T21, and demofox
// 
// I needed the -signed- distance to a quadratic bezier
// curve but couldn't find any examples online that
// were both fast and precise. This is my solution.
//
// v1 - Initial release
// v2 - Faster and more robust sign computation
//

struct FragUniform {
    points: array<vec4<f32>, 3>,
    type_: u32,
}
@binding(1) @group(0) var<uniform> ubos : array<FragUniform, 3>;

// Test if point p crosses line (a, b), returns sign of result
fn testCross(a:vec2<f32>, b:vec2<f32>, p:vec2<f32>) -> f32{
    return sign((b.y - a.y) * (p.x - a.x) - (b.x - a.x) * (p.y - a.y));
}

// Determine which side we're on (using barycentric parameterization)
fn signBezier(A: vec2<f32>, B: vec2<f32>, C: vec2<f32>, p:vec2<f32>) -> f32 { 
    let a = C - A;
    let b = B - A;
    let c = p - A;
    let bary = vec2(c.x * b.y - b.x * c.y, a.x * c.y - c.x * a.y) / (a.x * b.y - b.x * a.y);
    let d = vec2(bary.y * 0.5, 0.0) + 1.0 - bary.x - bary.y;
    return mix(sign(d.x * d.x - d.y), mix(-1.0, 1.0, 
        step(testCross(A, B, p) * testCross(B, C, p), 0.0)),
        step((d.x - d.y), 0.0)) * testCross(A, C, B);
}

// Solve cubic equation for roots
fn solveCubic(a: f32, b: f32, c: f32) -> vec3<f32> {
    let p = b - a * a / 3.0;
    let p3 = p * p * p;
    let q = a * (2.0 * a * a - 9.0 * b) / 27.0 + c;
    let d = q * q + 4.0 * p3 / 27.0;
    let offset = -a / 3.0;
    if(d >= 0.0) { 
        let z = sqrt(d);
        let x = (vec2(z, -z) - q) / 2.0;
        let uv = sign(x) * pow(abs(x), vec2(1.0 / 3.0));
        return vec3(offset + uv.x + uv.y);
    }
    let v = acos(-sqrt(-27.0 / p3) * q / 2.0) / 3.0;
    let m = cos(v);
    let n = sin(v) * 1.732050808;
    return vec3(m + m, -n - m, n - m) * sqrt(-p / 3.0) + offset;
}

// Find the signed distance from a point to a bezier curve
fn sdBezier(A: vec2<f32>, B_: vec2<f32>,C: vec2<f32>,p: vec2<f32>) -> f32{    
    let B = mix(B_ + vec2(1e-4), B_, abs(sign(B_ * 2.0 - A - C)));

    let a = B - A;
    let b = A - B * 2.0 + C;
    let c = a * 2.0;
    let d = A - p;
    
    let k = vec3(3.0 * dot(a,b), 2.0 * dot(a,a) + dot(d,b), dot(d,a)) / dot(b,b);      
    let t = clamp(solveCubic(k.x, k.y, k.z), vec3(0.0), vec3(1.0));
    
    var pos = A + (c + b * t.x) * t.x;
    var dis = length(pos - p);
    
    pos = A + (c + b * t.y) * t.y;
    dis = min(dis, length(pos - p));
    pos = A + (c + b * t.z) * t.z;
    dis = min(dis, length(pos - p));
    
    return dis * signBezier(A, B, C, p);
}


@stage(fragment) fn main( 
    @location(0) uv : vec2<f32>,
    @interpolate(flat) @location(1) instance_index: u32,
) -> @location(0) vec4<f32> {
    var col = vec4<f32>(0.0); 

    let p = uv;
    
    // Define the control points of our curve
    var A = ubos[instance_index].points[0].xy;
    var B = ubos[instance_index].points[1].xy;
    var C = ubos[instance_index].points[2].xy;

    if(ubos[instance_index].type_ == 2u){
        let tmp = A;
        A.x = C.x;
        A.y = B.y;
        C.y = B.y;
        B.y = tmp.y;
        C.x = tmp.x;
    }
    
    // Render the control points
    // var d = min(distance(p, A),min(distance(p, C),distance(p,B)));
    // if (d < 0.04) { 
    //   return vec4(1.0 - smoothstep(0.025, 0.034, d));
    // }
    
    // Get the signed distance to bezier curve
    let d = sdBezier(A, B, C, p);
    let tex_col = vec4(0.0,1.0,0.0,0.0);
    // Visualize the distance field using iq's orange/blue scheme
    if (ubos[instance_index].type_ == 1u){
        col = tex_col;
    }else{
        col = sign(d) * tex_col;
    }
    return col;
}