wgpu-3dgs-core 0.7.0

A 3D Gaussian splatting library written in Rust using wgpu.
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

use thiserror::Error;

use crate::{SpzGaussianPosition, SpzGaussianRotation, SpzGaussianSh, SpzGaussianShDegree};

/// The error type for [`SpzGaussians::from_iter`](crate::SpzGaussians::from_iter).
#[derive(Debug, Error)]
pub enum SpzGaussiansFromIterError {
    #[error("invalid mixed position variant: {0:?}")]
    InvalidMixedPositionVariant(SpzGaussiansCollectError<SpzGaussianPosition>),
    #[error("invalid mixed rotation variant: {0:?}")]
    InvalidMixedRotationVariant(SpzGaussiansCollectError<SpzGaussianRotation>),
    #[error("invalid mixed SH variant: {0:?}")]
    InvalidMixedShVariant(SpzGaussiansCollectError<SpzGaussianSh>),
    #[error("Gaussians count mismatch: {actual_count} != {header_count}")]
    CountMismatch {
        actual_count: usize,
        header_count: usize,
    },
    #[error("Position float16 format mismatch: {is_float16} != {header_uses_float16}")]
    PositionFloat16Mismatch {
        is_float16: bool,
        header_uses_float16: bool,
    },
    #[error(
        "Rotation smallest three format mismatch: \
        {is_quat_smallest_three} != {header_uses_quat_smallest_three}\
        "
    )]
    RotationQuatSmallestThreeMismatch {
        is_quat_smallest_three: bool,
        header_uses_quat_smallest_three: bool,
    },
    #[error("SH degree mismatch: {sh_degree:?} != {header_sh_degree:?}")]
    ShDegreeMismatch {
        sh_degree: SpzGaussianShDegree,
        header_sh_degree: SpzGaussianShDegree,
    },
    #[error("{0}")]
    Io(#[from] std::io::Error),
}

/// The error type for collecting SPZ Gaussians.
#[derive(Debug, Error)]
pub enum SpzGaussiansCollectError<T> {
    #[error("invalid mixed variant: {first_variant} != {current_variant}")]
    InvalidMixedVariant {
        first_variant: T,
        current_variant: T,
    },
    #[error("empty iterator")]
    EmptyIterator,
}

/// The error type for downloading buffer.
#[derive(Debug, Error)]
pub enum DownloadBufferError {
    #[error("{0}")]
    OneShotRecv(#[from] oneshot::RecvError),
    #[error("{0}")]
    Async(#[from] wgpu::BufferAsyncError),
    #[error("{0}")]
    Poll(#[from] wgpu::PollError),
}

/// The error type for [`GaussiansBuffer`](crate::GaussiansBuffer) update functions.
#[derive(Debug, Error)]
pub enum GaussiansBufferUpdateError {
    #[error("Gaussians count mismatch: {count} != {expected_count}")]
    CountMismatch { count: usize, expected_count: usize },
}

/// The error type for [`GaussiansBuffer`](crate::GaussiansBuffer) update range functions.
#[derive(Debug, Error)]
pub enum GaussiansBufferUpdateRangeError {
    #[error("Gaussians count mismatch: {count} + {start} > {expected_count}")]
    CountMismatch {
        count: usize,
        start: usize,
        expected_count: usize,
    },
}

/// The error type for [`GaussiansBuffer`](crate::GaussiansBuffer)'s [`TryFrom`] implementation for
/// [`wgpu::Buffer`].
#[derive(Debug, Error)]
pub enum GaussiansBufferTryFromBufferError {
    #[error(
        "buffer size and expected multiple size mismatch: {buffer_size} % {expected_multiple_size} != 0"
    )]
    BufferSizeNotMultiple {
        buffer_size: wgpu::BufferAddress,
        expected_multiple_size: wgpu::BufferAddress,
    },
}

/// The error type for [`FixedSizeBufferWrapper`](crate::FixedSizeBufferWrapper).
#[derive(Debug, Error)]
pub enum FixedSizeBufferWrapperError {
    #[error("buffer size and expected size mismatch: {buffer_size} != {expected_size}")]
    BufferSizeMismatched {
        buffer_size: wgpu::BufferAddress,
        expected_size: wgpu::BufferAddress,
    },
}

/// The error type for [`ComputeBundle`](crate::ComputeBundle) creation.
#[derive(Debug, Error)]
pub enum ComputeBundleCreateError {
    #[error(
        "resource count and bind group layout count mismatch: \
        {resource_count} != {bind_group_layout_count}\
        "
    )]
    ResourceCountMismatch {
        resource_count: usize,
        bind_group_layout_count: usize,
    },
    #[error(
        "workgroup size exceeds device limit: \
        {workgroup_size} > {device_limit}"
    )]
    WorkgroupSizeExceedsDeviceLimit {
        workgroup_size: u32,
        device_limit: u32,
    },
}

/// The error type for [`ComputeBundleBuilder::build`](crate::ComputeBundleBuilder::build) function.
#[derive(Debug, Error)]
pub enum ComputeBundleBuildError {
    #[error("{0}")]
    Wesl(#[from] wesl::Error),
    #[error("{0}")]
    Create(#[from] ComputeBundleCreateError),
    #[error("missing bind group layout for compute bundle")]
    MissingBindGroupLayout,
    #[error("missing resolver for compute bundle")]
    MissingResolver,
    #[error("missing entry point for compute bundle")]
    MissingEntryPoint,
    #[error("missing main shader for compute bundle")]
    MissingMainShader,
}