wgpu-3dgs-editor 0.7.0

A 3D Gaussian splatting editing 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

import wgpu_3dgs_core::{
    gaussian::{Gaussian, gaussian_unpack_color},
    gaussian_transform::GaussianTransform,
    model_transform::ModelTransform,
};
import package::modifier::{
    utils::{
        BasicColorModifiers,
        RotScale,
        apply_basic_color_modifiers,
        apply_basic_transform_modifiers,
    },
    consts,
};

@group(0) @binding(0)
var<storage, read_write> gaussians: array<Gaussian>;

@group(0) @binding(1)
var<uniform> model_transform: ModelTransform;

@group(0) @binding(2)
var<uniform> gaussian_transform: GaussianTransform;

@group(1) @binding(0)
var<uniform> transform_flags: u32;

@group(1) @binding(1)
var<uniform> color_modifiers: BasicColorModifiers;

@group(1) @binding(2)
var<uniform> rot_scale: RotScale;

@if(selection_buffer) @group(1) @binding(3)
var<storage, read> selection: array<u32>;

override workgroup_size: u32;

@compute @workgroup_size(workgroup_size)
fn main(@builtin(global_invocation_id) id: vec3<u32>) {
    let index = id.x;

    if index >= arrayLength(&gaussians) {
        return;
    }
    
    @if(selection_buffer) {
        let word_index = index / 32u;
        let bit_index = index % 32u;
        let bit_mask = 1u << bit_index;
        if (selection[word_index] & bit_mask) == 0 {
            return;
        }
    }

    var gaussian = gaussians[index];

    gaussian.color = pack4x8unorm(apply_basic_color_modifiers(
        color_modifiers,
        gaussian_unpack_color(gaussian),
    ));

    var applied_model_transform = ModelTransform(
        vec3<f32>(0.0, 0.0, 0.0),
        vec4<f32>(0.0, 0.0, 0.0, 1.0),
        vec3<f32>(1.0, 1.0, 1.0),
    );
    if (transform_flags & consts::transform_flags_model) != 0 {
        applied_model_transform = model_transform;
    }

    var applied_rot_scale = rot_scale;
    if (transform_flags & consts::transform_flags_gaussian) != 0 {
        applied_rot_scale.scale *= gaussian_transform.size;
    }

    gaussian = apply_basic_transform_modifiers(
        applied_model_transform,
        applied_rot_scale,
        gaussian,
    );

    gaussians[index] = gaussian;
}