Struct BasicModifier 

pub struct BasicModifier<G: GaussianPod, S = NoSelection> {
    pub transform_flags_buffer: TransformFlagsBuffer,
    pub basic_color_modifiers_buffer: BasicColorModifiersBuffer,
    pub rot_scale_buffer: RotScaleBuffer,
    pub modifier: BasicModifierBundle<G, S>,
}

A struct to handle basic modifier.

This modifier holds a BasicModifierBundle along with necessary buffers, and applies the basic modifier.

Fields

transform_flags_buffer: TransformFlagsBuffer

basic_color_modifiers_buffer: BasicColorModifiersBuffer

rot_scale_buffer: RotScaleBuffer

modifier: BasicModifierBundle<G, S>

Implementations

impl<G: GaussianPod> BasicModifier<G>

pub fn new( device: &Device, gaussians_buffer: &GaussiansBuffer<G>, model_transform_buffer: &ModelTransformBuffer, gaussian_transform_buffer: &GaussianTransformBuffer, ) -> Self

Create a new basic modifier.

Examples found in repository

examples/modify.rs (lines 104-109)

async fn main() {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    let args = Args::parse();
    let model_path = &args.model;

    log::debug!("Creating wgpu instance");
    let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor::default());

    log::debug!("Requesting adapter");
    let adapter = instance
        .request_adapter(&wgpu::RequestAdapterOptions::default())
        .await
        .expect("adapter");

    log::debug!("Requesting device");
    let (device, queue) = adapter
        .request_device(&wgpu::DeviceDescriptor {
            label: Some("Device"),
            required_features: wgpu::Features::empty(),
            required_limits: adapter.limits(),
            memory_hints: wgpu::MemoryHints::default(),
            trace: wgpu::Trace::Off,
        })
        .await
        .expect("device");

    log::debug!("Creating gaussians");
    let f = std::fs::File::open(model_path).expect("ply file");
    let mut reader = std::io::BufReader::new(f);
    let gaussians = gs::core::Gaussians::read_ply(&mut reader).expect("gaussians");

    log::debug!("Creating editor");
    let editor = gs::Editor::<GaussianPod>::new(&device, &gaussians);

    log::debug!("Creating basic modifier");
    let basic_modifier = gs::BasicModifier::<GaussianPod>::new(
        &device,
        &editor.gaussians_buffer,
        &editor.model_transform_buffer,
        &editor.gaussian_transform_buffer,
    );

    log::debug!("Configuring modifiers");
    match args.override_rgb {
        true => basic_modifier
            .basic_color_modifiers_buffer
            .update_with_override_rgb(
                &queue,
                Vec3::from_slice(&args.rgb_or_hsv),
                args.alpha,
                args.contrast,
                args.exposure,
                args.gamma,
            ),
        false => basic_modifier
            .basic_color_modifiers_buffer
            .update_with_hsv_modifiers(
                &queue,
                Vec3::from_slice(&args.rgb_or_hsv),
                args.alpha,
                args.contrast,
                args.exposure,
                args.gamma,
            ),
    }

    log::info!("Starting editing process");
    let time = std::time::Instant::now();

    log::debug!("Editing Gaussians");
    let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
        label: Some("Edit Encoder"),
    });

    editor.apply(
        &device,
        &mut encoder,
        [&basic_modifier as &dyn gs::Modifier<GaussianPod>],
    );

    queue.submit(Some(encoder.finish()));

    #[allow(unused_must_use)]
    device.poll(wgpu::PollType::Wait);

    log::info!("Editing process completed in {:?}", time.elapsed());

    log::debug!("Downloading Gaussians");
    let modified_gaussians = gs::core::Gaussians {
        gaussians: editor
            .gaussians_buffer
            .download_gaussians(&device, &queue)
            .await
            .expect("gaussians download"),
    };

    log::debug!("Writing modified Gaussians to output file");
    let output_file = std::fs::File::create(&args.output).expect("output file");
    let mut writer = std::io::BufWriter::new(output_file);
    modified_gaussians
        .write_ply(&mut writer)
        .expect("write modified Gaussians to output file");

    log::info!("Modified Gaussians written to {}", args.output);
}

impl<G: GaussianPod> BasicModifier<G, WithSelection>

pub fn new_with_selection( device: &Device, gaussians_buffer: &GaussiansBuffer<G>, model_transform_buffer: &ModelTransformBuffer, gaussian_transform_buffer: &GaussianTransformBuffer, selection_buffer: &SelectionBuffer, ) -> Self

Create a new basic modifier with selection.

Trait Implementations

impl<G: Debug + GaussianPod, S: Debug> Debug for BasicModifier<G, S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<G: GaussianPod, S> Modifier<G> for BasicModifier<G, S>

fn apply( &self, _device: &Device, encoder: &mut CommandEncoder, gaussians: &GaussiansBuffer<G>, _model_transform: &ModelTransformBuffer, _gaussian_transform: &GaussianTransformBuffer, )

Apply the modifier to the Gaussians.