assets/shaders/tacbody.wgsl


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

struct VertexInput {
    @location(0) position: vec3<f32>
};

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

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

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

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

@vertex
fn vs_main(
    model: VertexInput,
    instance: InstanceInput
) -> VertexOutput {
    var out: VertexOutput;

    var view = camera.view;
    
    //Billboard the circle
    view[0][0] = 1.0;
    view[0][1] = 0.0;
    view[0][2] = 0.0;

    view[1][0] = 0.0;
    view[1][1] = 1.0;
    view[1][2] = 0.0;

    view[2][0] = 0.0;
    view[2][1] = 0.0;
    view[2][2] = 1.0;

    let min_size = 0.025;

    //Scale the world around the camera scale.
    let model_pos = model.position;
    let instance_pos = instance.position * 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 * 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_pos.xy * (min_size / 2), 0.0, 0.0);
    }else{
        out.clip_position = vertex_view_pos;
    }

    out.local_position = model.position;

    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;
    }
    return vec4<f32>(1.0, 1.0, 1.0, alpha);
}