awsm-renderer 0.4.0

awsm-renderer
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
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
151
152
153
154
155
156
157

//***** SKINS *****

// Each skin set has 8 f32 values (4 interleaved index/weight pairs)
const floats_per_set = 8u;

/// Applies skeletal skinning with support for multiple skin sets per vertex
fn apply_position_skin(input: ApplyVertexInput) -> ApplyVertexInput {
    var output = input;

    let skin_sets_count = geometry_mesh_meta.skin_sets_len;

    let original_position = vec4<f32>(input.position, 1.0);

    // Calculate base offset for this vertex's skin data (indexed per original vertex)
    let base_offset = (geometry_mesh_meta.skin_index_weights_offset / 4) + input.vertex_index * skin_sets_count * floats_per_set;

    let matrix_offset = geometry_mesh_meta.skin_matrices_offset / 64; // mat4x4<f32> is 64 bytes

    var skin_matrix: mat4x4<f32>;

    // UNROLLED SKIN SETS

    {% for i in 0..max_skin_unroll %}
        if skin_sets_count >= {{ i + 1}}u {
            let buffer_offset = base_offset + ({{ i }}u * floats_per_set);

            let joint_index_0 = bitcast<u32>(skin_joint_index_weights[buffer_offset]);
            let joint_weight_0 = skin_joint_index_weights[buffer_offset + 1u];

            let joint_index_1 = bitcast<u32>(skin_joint_index_weights[buffer_offset + 2u]);
            let joint_weight_1 = skin_joint_index_weights[buffer_offset + 3u];

            let joint_index_2 = bitcast<u32>(skin_joint_index_weights[buffer_offset + 4u]);
            let joint_weight_2 = skin_joint_index_weights[buffer_offset + 5u];

            let joint_index_3 = bitcast<u32>(skin_joint_index_weights[buffer_offset + 6u]);
            let joint_weight_3 = skin_joint_index_weights[buffer_offset + 7u];

            let skin_mat_acc = joint_weight_0 * skin_joint_matrices[joint_index_0 + matrix_offset]
                            + joint_weight_1 * skin_joint_matrices[joint_index_1 + matrix_offset]
                            + joint_weight_2 * skin_joint_matrices[joint_index_2 + matrix_offset]
                            + joint_weight_3 * skin_joint_matrices[joint_index_3 + matrix_offset];

            {% if i == 0 %}
                skin_matrix = skin_mat_acc;
            {% else %}
                skin_matrix = skin_matrix + skin_mat_acc;
            {% endif %}
        }
    {% endfor %}

    // LOOP FOR REMAINING SKIN SETS
    if skin_sets_count > {{ max_skin_unroll }}u {
        for (var skin_set_index = {{ max_skin_unroll }}u; skin_set_index < skin_sets_count; skin_set_index = skin_set_index + 1u) {
            let buffer_offset = base_offset + (skin_set_index * floats_per_set);

            let joint_index_0 = bitcast<u32>(skin_joint_index_weights[buffer_offset]);
            let joint_weight_0 = skin_joint_index_weights[buffer_offset + 1u];

            let joint_index_1 = bitcast<u32>(skin_joint_index_weights[buffer_offset + 2u]);
            let joint_weight_1 = skin_joint_index_weights[buffer_offset + 3u];

            let joint_index_2 = bitcast<u32>(skin_joint_index_weights[buffer_offset + 4u]);
            let joint_weight_2 = skin_joint_index_weights[buffer_offset + 5u];

            let joint_index_3 = bitcast<u32>(skin_joint_index_weights[buffer_offset + 6u]);
            let joint_weight_3 = skin_joint_index_weights[buffer_offset + 7u];

            let skin_mat_acc = joint_weight_0 * skin_joint_matrices[joint_index_0 + matrix_offset]
                             + joint_weight_1 * skin_joint_matrices[joint_index_1 + matrix_offset]
                             + joint_weight_2 * skin_joint_matrices[joint_index_2 + matrix_offset]
                             + joint_weight_3 * skin_joint_matrices[joint_index_3 + matrix_offset];

            skin_matrix = skin_matrix + skin_mat_acc;
        }
    }

    output.position = (skin_matrix * original_position).xyz;

    return output;
}

/// Applies skeletal skinning to normals and tangents (same weights as positions)
fn apply_normal_skin(input: ApplyVertexInput, normal: vec3<f32>) -> vec3<f32> {
    let skin_sets_count = geometry_mesh_meta.skin_sets_len;

    // Calculate base offset for this vertex's skin data (indexed per original vertex)
    let base_offset = (geometry_mesh_meta.skin_index_weights_offset / 4) + input.vertex_index * skin_sets_count * floats_per_set;
    let matrix_offset = geometry_mesh_meta.skin_matrices_offset / 64; // mat4x4<f32> is 64 bytes

    var skin_matrix: mat4x4<f32>;

    // UNROLLED SKIN SETS
    {% for i in 0..max_skin_unroll %}
        if skin_sets_count >= {{ i + 1}}u {
            let buffer_offset = base_offset + ({{ i }}u * floats_per_set);

            let joint_index_0 = bitcast<u32>(skin_joint_index_weights[buffer_offset]);
            let joint_weight_0 = skin_joint_index_weights[buffer_offset + 1u];

            let joint_index_1 = bitcast<u32>(skin_joint_index_weights[buffer_offset + 2u]);
            let joint_weight_1 = skin_joint_index_weights[buffer_offset + 3u];

            let joint_index_2 = bitcast<u32>(skin_joint_index_weights[buffer_offset + 4u]);
            let joint_weight_2 = skin_joint_index_weights[buffer_offset + 5u];

            let joint_index_3 = bitcast<u32>(skin_joint_index_weights[buffer_offset + 6u]);
            let joint_weight_3 = skin_joint_index_weights[buffer_offset + 7u];

            let skin_mat_acc = joint_weight_0 * skin_joint_matrices[joint_index_0 + matrix_offset]
                            + joint_weight_1 * skin_joint_matrices[joint_index_1 + matrix_offset]
                            + joint_weight_2 * skin_joint_matrices[joint_index_2 + matrix_offset]
                            + joint_weight_3 * skin_joint_matrices[joint_index_3 + matrix_offset];

            {% if i == 0 %}
                skin_matrix = skin_mat_acc;
            {% else %}
                skin_matrix = skin_matrix + skin_mat_acc;
            {% endif %}
        }
    {% endfor %}

    // LOOP FOR REMAINING SKIN SETS
    if skin_sets_count > {{ max_skin_unroll }}u {
        for (var skin_set_index = {{ max_skin_unroll }}u; skin_set_index < skin_sets_count; skin_set_index = skin_set_index + 1u) {
            let buffer_offset = base_offset + (skin_set_index * floats_per_set);

            let joint_index_0 = bitcast<u32>(skin_joint_index_weights[buffer_offset]);
            let joint_weight_0 = skin_joint_index_weights[buffer_offset + 1u];

            let joint_index_1 = bitcast<u32>(skin_joint_index_weights[buffer_offset + 2u]);
            let joint_weight_1 = skin_joint_index_weights[buffer_offset + 3u];

            let joint_index_2 = bitcast<u32>(skin_joint_index_weights[buffer_offset + 4u]);
            let joint_weight_2 = skin_joint_index_weights[buffer_offset + 5u];

            let joint_index_3 = bitcast<u32>(skin_joint_index_weights[buffer_offset + 6u]);
            let joint_weight_3 = skin_joint_index_weights[buffer_offset + 7u];

            let skin_mat_acc = joint_weight_0 * skin_joint_matrices[joint_index_0 + matrix_offset]
                             + joint_weight_1 * skin_joint_matrices[joint_index_1 + matrix_offset]
                             + joint_weight_2 * skin_joint_matrices[joint_index_2 + matrix_offset]
                             + joint_weight_3 * skin_joint_matrices[joint_index_3 + matrix_offset];

            skin_matrix = skin_matrix + skin_mat_acc;
        }
    }

    // Transform normal (use mat3 to ignore translation)
    let normal_matrix = mat3x3<f32>(
        skin_matrix[0].xyz,
        skin_matrix[1].xyz,
        skin_matrix[2].xyz
    );

    return normal_matrix * normal;
}