bevy_gaussian_splatting 2.4.2

bevy gaussian splatting render pipeline plugin
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

use bevy::render::{
    render_resource::{
        BindGroup,
        BindGroupEntry,
        BindGroupLayout,
        BindGroupLayoutEntry,
        BindingResource,
        BindingType,
        Buffer,
        BufferBinding,
        BufferBindingType,
        BufferInitDescriptor,
        BufferSize,
        BufferUsages,
        ShaderStages,
    },
    renderer::RenderDevice,
};

use crate::{
    gaussian::{
        cloud::GaussianCloud,
        packed::Gaussian,
    },
    render::{
        GaussianCloudPipeline,
        GpuGaussianCloud,
    },
};


#[derive(Debug, Clone)]
pub struct PackedBuffers {
    gaussians: Buffer,
}


pub fn prepare_cloud(
    render_device: &RenderDevice,
    cloud: &GaussianCloud,
) -> PackedBuffers {
    let gaussians = render_device.create_buffer_with_data(&BufferInitDescriptor {
        label: Some("packed_gaussian_cloud_buffer"),
        contents: bytemuck::cast_slice(cloud.gaussian_iter().collect::<Vec<Gaussian>>().as_slice()),
        usage: BufferUsages::VERTEX | BufferUsages::COPY_DST | BufferUsages::STORAGE,
    });

    PackedBuffers {
        gaussians,
    }
}


pub fn get_bind_group_layout(
    render_device: &RenderDevice,
    read_only: bool
) -> BindGroupLayout {
    render_device.create_bind_group_layout(
        Some("packed_gaussian_cloud_layout"),
        &[
            BindGroupLayoutEntry {
                binding: 0,
                visibility: ShaderStages::all(),
                ty: BindingType::Buffer {
                    ty: BufferBindingType::Storage { read_only },
                    has_dynamic_offset: false,
                    min_binding_size: BufferSize::new(std::mem::size_of::<Gaussian>() as u64),
                },
                count: None,
            },
        ],
    )
}


#[cfg(feature = "packed")]
pub fn get_bind_group(
    render_device: &RenderDevice,
    gaussian_cloud_pipeline: &GaussianCloudPipeline,
    cloud: &GpuGaussianCloud,
) -> BindGroup {
    render_device.create_bind_group(
        "packed_gaussian_cloud_bind_group",
        &gaussian_cloud_pipeline.gaussian_cloud_layout,
        &[
            BindGroupEntry {
                binding: 0,
                resource: BindingResource::Buffer(BufferBinding {
                    buffer: &cloud.packed.gaussians,
                    offset: 0,
                    size: BufferSize::new(cloud.packed.gaussians.size()),
                }),
            },
        ],
    )
}