cvkg-render-gpu 0.3.4

Cyber Viking Kvasir Graph (CVKG) - High-fidelity agentic UI framework
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

// Pass: skinning.rs
// Purpose: Compute-skinning dispatch pass resolving bone matrices and morph target blend shapes.

use crate::kvasir::nodes::PassId;
use crate::kvasir::{ExecutionContext, KvasirNode, ResourceId};

/// Node representing the GPU compute skinning pass.
pub struct SkinningNode {
    /// Inputs slice satisfying KvasirNode lifetime requirements.
    pub inputs: Vec<ResourceId>,
    /// Outputs slice.
    pub outputs: Vec<ResourceId>,
}

impl KvasirNode for SkinningNode {
    fn label(&self) -> &'static str {
        "SkinningComputePass"
    }

    fn inputs(&self) -> &[ResourceId] {
        &self.inputs
    }

    fn outputs(&self) -> &[ResourceId] {
        &self.outputs
    }

    fn pass_id(&self) -> PassId {
        PassId::ComputeSkinning
    }

    fn execute(&self, ctx: &mut ExecutionContext) {
        if ctx.renderer.skinning_buffer_pairs.is_empty() {
            return;
        }

        let total_vertices: u32 = ctx.renderer.skinning_buffer_pairs.iter()
            .map(|(src, _)| {
                // Each src buffer contains SkinnedVertex records; compute size from buffer size
                (src.size() as usize / std::mem::size_of::<crate::vertex::SkinnedVertex>()) as u32
            })
            .sum();

        tracing::debug!(
            "SkinningNode::execute - Dispatching GPU skinning compute shader for {} meshes ({} total vertices)",
            ctx.renderer.skinning_buffer_pairs.len(),
            total_vertices
        );

        // 1. Create Bind Groups for joint matrices and morphs (shared across all mesh dispatches)
        let bind_group_1 = ctx.device.create_bind_group(&wgpu::BindGroupDescriptor {
            label: Some("Skinning Bind Group 1 (Joints)"),
            layout: &ctx.renderer.skinning_bgl1,
            entries: &[
                wgpu::BindGroupEntry {
                    binding: 0,
                    resource: ctx.renderer.skinning_joint_matrices.as_entire_binding(),
                },
            ],
        });

        let bind_group_2 = ctx.device.create_bind_group(&wgpu::BindGroupDescriptor {
            label: Some("Skinning Bind Group 2 (Morphs)"),
            layout: &ctx.renderer.skinning_bgl2,
            entries: &[
                wgpu::BindGroupEntry {
                    binding: 0,
                    resource: ctx.renderer.skinning_morph_positions.as_entire_binding(),
                },
                wgpu::BindGroupEntry {
                    binding: 1,
                    resource: ctx.renderer.skinning_morph_weights.as_entire_binding(),
                },
            ],
        });

        // 2. Begin compute pass and dispatch workgroups for each mesh
        let mut compute_pass = ctx.encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
            label: Some("Skeletal Skinning Compute Pass"),
            timestamp_writes: None,
        });

        compute_pass.set_pipeline(&ctx.renderer.skinning_compute_pipeline);
        compute_pass.set_bind_group(1, &bind_group_1, &[]);
        compute_pass.set_bind_group(2, &bind_group_2, &[]);

        for (src_buffer, dst_buffer) in ctx.renderer.skinning_buffer_pairs.iter() {
            let vertex_count = (src_buffer.size() as usize / std::mem::size_of::<crate::vertex::SkinnedVertex>()) as u32;
            if vertex_count == 0 {
                continue;
            }

            // Create per-mesh bind group for src/dst buffers
            let bind_group_0 = ctx.device.create_bind_group(&wgpu::BindGroupDescriptor {
                label: Some("Skinning Bind Group 0 (Geometry)"),
                layout: &ctx.renderer.skinning_bgl0,
                entries: &[
                    wgpu::BindGroupEntry {
                        binding: 0,
                        resource: src_buffer.as_entire_binding(),
                    },
                    wgpu::BindGroupEntry {
                        binding: 1,
                        resource: dst_buffer.as_entire_binding(),
                    },
                ],
            });

            compute_pass.set_bind_group(0, &bind_group_0, &[]);

            let workgroup_count = (vertex_count + 63) / 64;
            compute_pass.dispatch_workgroups(workgroup_count, 1, 1);
        }

        // NOTE: skinning_buffer_pairs is cleared by the frame loop after all nodes execute,
        // not here, because ExecutionContext.renderer is immutable during node execution.
    }
}