struct InstanceInput {
    @location(0) position: vec3<f32>,
    @location(1) origin: vec3<f32>,
    @location(2) radius: f32
};

struct VertexOutput {
    @builtin(position) clip_position: vec4<f32>,
    @location(0) local_position: vec3<f32>,
    @location(1) distance: f32
};

struct CameraUniform {
    view: mat4x4<f32>,
    proj: mat4x4<f32>,
    abs_pos: vec3<f32>,
    rel_pos: vec3<f32>,
    scale: f32,
};

@group(0) @binding(0)
var<uniform> camera: CameraUniform;

const QUAD_VERTICES = array<vec3<f32>,6>(
    vec3<f32>(-1.0, -1.0, 0.0),
    vec3<f32>(-1.0, 1.0 , 0.0),
    vec3<f32>(1.0,  1.0 , 0.0),
    vec3<f32>(1.0,  1.0 , 0.0),
    vec3<f32>(1.0,  -1.0, 0.0),
    vec3<f32>(-1.0, -1.0, 0.0),
);

@vertex
fn vs_main(
    @builtin(vertex_index) index: u32,
    instance: InstanceInput
) -> VertexOutput {
    var out: VertexOutput;

    let model = QUAD_VERTICES[index];
    var view = camera.view;

    //Billboard the circle
    let camera_right = vec3<f32>(view[0][0], view[1][0], view[2][0]);
    let camera_up = vec3<f32>(view[0][1], view[1][1], view[2][1]);
    let model_pos = camera_right * model.x +
                    camera_up * model.y;

    let min_size = 0.025;

    //Scale the world around the camera scale and translate about the camera's
    //absolute (/target) position
    let relative_pos = instance.position;
    let origin_pos = instance.origin - camera.abs_pos;

    /*if all(relative_pos != origin_pos) {
        if length(relative_pos) < 0.01 / camera.scale {
            if length(relative_pos) != 0.0 {
                out.clip_position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
                return out;
            }
        }
    }*/

    let instance_pos = (relative_pos + origin_pos - camera.rel_pos) * camera.scale;

    let view_proj = camera.proj * view;

    let center_view_pos = view_proj * vec4<f32>(instance_pos, 1.0);
    let vertex_view_pos = view_proj * vec4<f32>(instance_pos + (model_pos * instance.radius * camera.scale), 1.0);

    let vertex_dist = length(vertex_view_pos - center_view_pos) / center_view_pos.w;
    if vertex_dist < min_size {
        out.clip_position = center_view_pos / center_view_pos.w;
        out.clip_position += camera.proj * vec4<f32>(model.xy * (min_size / 2.0), 0.0, 0.0);
    }else{
        out.clip_position = vertex_view_pos;
    }

    out.local_position = model;
    out.distance = length(instance_pos);

    return out;
}

@fragment
fn fs_main(in: VertexOutput
) -> @location(0) vec4<f32> {
    let point_dist = length(in.local_position);
    var alpha = 1.0;
    if point_dist > 1.0 {
        alpha = 0.0;
    }
    let color = vec3<f32>(1.0, 1.0, 1.0) / clamp(in.distance, 1.0, 1.5);
    return vec4<f32>(color, alpha);
}