nightshade-renderer 0.57.0

GPU-driven wgpu renderer with a built-in frame graph.
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

struct SpringChain {
    joint_start: u32,
    joint_count: u32,
    descendant_start: u32,
    descendant_count: u32,
    state_start: u32,
    reset: u32,
    enabled: u32,
    pad0: u32,
    gravity: vec4<f32>,
    stiffness: f32,
    damping: f32,
    dt: f32,
    pad1: f32,
}

@group(0) @binding(0) var<storage, read_write> bone_transforms: array<mat4x4<f32>>;
@group(0) @binding(1) var<storage, read> chains: array<SpringChain>;
@group(0) @binding(2) var<storage, read> joint_indices: array<u32>;
@group(0) @binding(3) var<storage, read> tip_descendants: array<u32>;
@group(0) @binding(4) var<storage, read> rest_axes: array<vec4<f32>>;
@group(0) @binding(5) var<storage, read> bone_lengths: array<f32>;
@group(0) @binding(6) var<storage, read_write> spring_state: array<vec4<f32>>;

fn quat_from_axis_angle(axis: vec3<f32>, angle: f32) -> vec4<f32> {
    let half = angle * 0.5;
    let s = sin(half);
    return vec4<f32>(axis.x * s, axis.y * s, axis.z * s, cos(half));
}

fn quat_rotate(q: vec4<f32>, v: vec3<f32>) -> vec3<f32> {
    let u = q.xyz;
    return v + 2.0 * cross(u, cross(u, v) + q.w * v);
}

fn quat_to_mat3(q: vec4<f32>) -> mat3x3<f32> {
    let x = q.x;
    let y = q.y;
    let z = q.z;
    let w = q.w;
    return mat3x3<f32>(
        vec3<f32>(1.0 - 2.0 * (y * y + z * z), 2.0 * (x * y + w * z), 2.0 * (x * z - w * y)),
        vec3<f32>(2.0 * (x * y - w * z), 1.0 - 2.0 * (x * x + z * z), 2.0 * (y * z + w * x)),
        vec3<f32>(2.0 * (x * z + w * y), 2.0 * (y * z - w * x), 1.0 - 2.0 * (x * x + y * y)),
    );
}

fn quat_from_to(from_direction: vec3<f32>, to_direction: vec3<f32>) -> vec4<f32> {
    let source = normalize(from_direction);
    let destination = normalize(to_direction);
    let cos_angle = dot(source, destination);
    if (cos_angle > 0.99999) {
        return vec4<f32>(0.0, 0.0, 0.0, 1.0);
    }
    if (cos_angle < -0.99999) {
        var axis = cross(vec3<f32>(1.0, 0.0, 0.0), source);
        if (length(axis) < 0.0001) {
            axis = cross(vec3<f32>(0.0, 1.0, 0.0), source);
        }
        return vec4<f32>(normalize(axis), 0.0);
    }
    let axis = normalize(cross(source, destination));
    let angle = acos(clamp(cos_angle, -1.0, 1.0));
    return quat_from_axis_angle(axis, angle);
}

fn rotate_bone_about(index: u32, pivot: vec3<f32>, q: vec4<f32>) {
    let m = bone_transforms[index];
    let position = m[3].xyz;
    let new_position = pivot + quat_rotate(q, position - pivot);
    let rotation = quat_to_mat3(q);
    let column0 = rotation * m[0].xyz;
    let column1 = rotation * m[1].xyz;
    let column2 = rotation * m[2].xyz;
    bone_transforms[index] = mat4x4<f32>(
        vec4<f32>(column0, 0.0),
        vec4<f32>(column1, 0.0),
        vec4<f32>(column2, 0.0),
        vec4<f32>(new_position, 1.0),
    );
}

@compute @workgroup_size(64)
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let chain_index = global_id.x;
    if (chain_index >= arrayLength(&chains)) {
        return;
    }
    let chain = chains[chain_index];
    if (chain.enabled == 0u || chain.joint_count < 2u) {
        return;
    }

    for (var i = 1u; i < chain.joint_count; i = i + 1u) {
        let joint = joint_indices[chain.joint_start + i];
        let parent = joint_indices[chain.joint_start + i - 1u];
        let parent_matrix = bone_transforms[parent];
        let parent_position = parent_matrix[3].xyz;
        let bone_length = bone_lengths[chain.joint_start + i];
        let rest_axis = rest_axes[chain.joint_start + i].xyz;

        let px = normalize(parent_matrix[0].xyz);
        let py = normalize(parent_matrix[1].xyz);
        let pz = normalize(parent_matrix[2].xyz);
        let rest_goal = parent_position
            + (px * rest_axis.x + py * rest_axis.y + pz * rest_axis.z) * bone_length;

        let slot = 2u * (chain.state_start + i);
        var tip = spring_state[slot].xyz;
        var prev = spring_state[slot + 1u].xyz;
        let current_joint_position = bone_transforms[joint][3].xyz;

        if (chain.reset == 1u || distance(tip, rest_goal) > bone_length * 8.0 + 0.001) {
            tip = rest_goal;
            prev = rest_goal;
        } else {
            let inertia = (tip - prev) * (1.0 - chain.damping);
            var next = tip + inertia + chain.gravity.xyz * chain.dt;
            next = next + (rest_goal - next) * chain.stiffness;
            let direction = next - parent_position;
            let direction_length = length(direction);
            if (direction_length > 0.00001) {
                next = parent_position + direction / direction_length * bone_length;
            } else {
                next = rest_goal;
            }
            prev = tip;
            tip = next;
        }

        spring_state[slot] = vec4<f32>(tip, 0.0);
        spring_state[slot + 1u] = vec4<f32>(prev, 0.0);

        let current_direction = current_joint_position - parent_position;
        let new_direction = tip - parent_position;
        if (length(current_direction) > 0.00001 && length(new_direction) > 0.00001) {
            let rotation = quat_from_to(current_direction, new_direction);
            for (var k = i - 1u; k < chain.joint_count; k = k + 1u) {
                rotate_bone_about(joint_indices[chain.joint_start + k], parent_position, rotation);
            }
            for (var descendant = 0u; descendant < chain.descendant_count; descendant = descendant + 1u) {
                rotate_bone_about(
                    tip_descendants[chain.descendant_start + descendant],
                    parent_position,
                    rotation,
                );
            }
        }
    }
}