anvilkit-render 0.1.0

Cross-platform rendering system built on wgpu and winit for AnvilKit game engine
Documentation 
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

// UI rectangle shader — colored rectangles with rounded corners (SDF)

struct OrthoUniform {
    projection: mat4x4<f32>,
};

@group(0) @binding(0)
var<uniform> ortho: OrthoUniform;

struct VertexInput {
    @location(0) position: vec2<f32>,
    @location(1) rect_min: vec2<f32>,
    @location(2) rect_size: vec2<f32>,
    @location(3) color: vec4<f32>,
    @location(4) border_color: vec4<f32>,
    @location(5) params: vec4<f32>,  // border_radius, border_width, 0, 0
};

struct VertexOutput {
    @builtin(position) clip_position: vec4<f32>,
    @location(0) local_pos: vec2<f32>,
    @location(1) rect_size: vec2<f32>,
    @location(2) color: vec4<f32>,
    @location(3) border_color: vec4<f32>,
    @location(4) params: vec4<f32>,
};

@vertex
fn vs_main(in: VertexInput) -> VertexOutput {
    var out: VertexOutput;
    let world_pos = in.rect_min + in.position * in.rect_size;
    out.clip_position = ortho.projection * vec4<f32>(world_pos, 0.0, 1.0);
    out.local_pos = in.position * in.rect_size;
    out.rect_size = in.rect_size;
    out.color = in.color;
    out.border_color = in.border_color;
    out.params = in.params;
    return out;
}

// Rounded rectangle SDF
fn rounded_rect_sdf(pos: vec2<f32>, size: vec2<f32>, radius: f32) -> f32 {
    let half = size * 0.5;
    let r = min(radius, min(half.x, half.y));
    let d = abs(pos - half) - half + vec2<f32>(r, r);
    return length(max(d, vec2<f32>(0.0, 0.0))) + min(max(d.x, d.y), 0.0) - r;
}

@fragment
fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
    let radius = in.params.x;
    let border_width = in.params.y;

    let dist = rounded_rect_sdf(in.local_pos, in.rect_size, radius);

    // Smooth edge antialiasing
    let aa = fwidth(dist);
    let alpha = 1.0 - smoothstep(-aa, aa, dist);

    if alpha < 0.001 {
        discard;
    }

    // Border
    if border_width > 0.0 {
        let inner_offset = border_width;
        let inner = rounded_rect_sdf(
            in.local_pos - vec2<f32>(inner_offset, inner_offset),
            in.rect_size - vec2<f32>(inner_offset * 2.0, inner_offset * 2.0),
            max(radius - border_width, 0.0),
        );
        let border_mask = smoothstep(-aa, aa, -inner);
        let fill_color = mix(in.color, in.border_color, border_mask);
        return vec4<f32>(fill_color.rgb, fill_color.a * alpha);
    }

    return vec4<f32>(in.color.rgb, in.color.a * alpha);
}