Struct MultiModelViewer 

pub struct MultiModelViewer<G: GaussianPod = DefaultGaussianPod, K: Hash + Eq = String> {
    pub models: HashMap<K, MultiModelViewerModel<G>>,
    pub world_buffers: MultiModelViewerWorldBuffers,
    pub preprocessor: Preprocessor<G, ()>,
    pub radix_sorter: RadixSorter<()>,
    pub renderer: Renderer<G, ()>,
    pub gaussians_buffer_usage: BufferUsages,
}

The 3D Gaussian splatting viewer for multiple models.

Fields

models: HashMap<K, MultiModelViewerModel<G>>

world_buffers: MultiModelViewerWorldBuffers

preprocessor: Preprocessor<G, ()>

radix_sorter: RadixSorter<()>

renderer: Renderer<G, ()>

gaussians_buffer_usage: BufferUsages

The usage for the gaussians buffer when MultiModelViewer::insert_model is called.

Can be overridden when inserting model using MultiModelViewer::insert_model_with.

Implementations

impl<G: GaussianPod, K: Hash + Eq> MultiModelViewer<G, K>

pub fn new( device: &Device, texture_format: TextureFormat, ) -> Result<Self, ViewerCreateError>

Create a new viewer.

Examples found in repository

examples/multi_model.rs (line 155)

    async fn init(window: Arc<Window>, args: &Args) -> Self {
        let model_paths = &args.models;
        let model_offset = Vec3::from_slice(&args.offset);
        let size = window.inner_size();

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

        log::debug!("Creating window surface");
        let surface = instance.create_surface(window.clone()).expect("surface");

        log::debug!("Requesting adapter");
        let adapter = instance
            .request_adapter(&wgpu::RequestAdapterOptions {
                power_preference: wgpu::PowerPreference::HighPerformance,
                compatible_surface: Some(&surface),
                force_fallback_adapter: false,
            })
            .await
            .expect("adapter");

        log::debug!("Requesting device");
        let (device, queue) = adapter
            .request_device(&wgpu::DeviceDescriptor {
                label: Some("Device"),
                required_limits: adapter.limits(),
                ..Default::default()
            })
            .await
            .expect("device");

        let surface_caps = surface.get_capabilities(&adapter);
        let surface_format = surface_caps.formats[0];
        let config = wgpu::SurfaceConfiguration {
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
            format: surface_format,
            width: size.width.max(1),
            height: size.height.max(1),
            present_mode: surface_caps.present_modes[0],
            alpha_mode: surface_caps.alpha_modes[0],
            view_formats: vec![surface_format.remove_srgb_suffix()],
            desired_maximum_frame_latency: 2,
        };

        log::debug!("Configuring surface");
        surface.configure(&device, &config);

        log::debug!("Creating gaussians");
        let gaussians = model_paths
            .iter()
            .map(|model_path| {
                log::debug!("Reading model from {model_path}");
                [GaussiansSource::Ply, GaussiansSource::Spz]
                    .into_iter()
                    .find_map(|source| gs::core::Gaussians::read_from_file(model_path, source).ok())
                    .expect("gaussians")
            })
            .collect::<Vec<_>>();

        log::debug!("Computing gaussian centroids");
        let mut gaussian_centroids = gaussians
            .iter()
            .map(|g| {
                let mut centroid = Vec3::ZERO;
                for gaussian in g.iter_gaussian() {
                    centroid += gaussian.pos;
                }
                centroid / g.len() as f32
            })
            .collect::<Vec<_>>();

        log::debug!("Creating camera");
        let camera = gs::Camera::new(0.1..1e4, 60f32.to_radians());

        log::debug!("Creating viewer");
        let mut viewer =
            gs::MultiModelViewer::new(&device, config.view_formats[0]).expect("viewer");

        let quat = Quat::from_axis_angle(Vec3::Z, 180f32.to_radians());
        for (i, gaussians) in gaussians.iter().enumerate() {
            let offset = model_offset * i as f32;

            log::debug!("Pushing model {i}");

            viewer.insert_model(&device, i, gaussians);
            viewer
                .update_model_transform(&queue, &i, offset, quat, Vec3::ONE)
                .expect("update model");

            gaussian_centroids[i] = quat.mul_vec3(gaussian_centroids[i]) + offset;
        }

        log::info!("System initialized");

        Self {
            surface,
            device,
            queue,
            config,

            camera,
            gaussians,
            gaussian_centroids,
            viewer,
        }
    }

pub fn new_with_options( device: &Device, texture_format: TextureFormat, options: ViewerCreateOptions, ) -> Result<Self, ViewerCreateError>

Create a new viewer with extra ViewerCreateOptions.

Note that only ViewerCreateOptions::gaussians_buffer_usage is used when inserting models with MultiModelViewer::insert_model. You can also override the usage using MultiModelViewer::insert_model_with.

pub fn insert_model( &mut self, device: &Device, key: K, gaussians: &impl IterGaussian, ) -> Option<MultiModelViewerModel<G>>

Insert a new model to the viewer.

Examples found in repository

examples/multi_model.rs (line 163)

    async fn init(window: Arc<Window>, args: &Args) -> Self {
        let model_paths = &args.models;
        let model_offset = Vec3::from_slice(&args.offset);
        let size = window.inner_size();

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

        log::debug!("Creating window surface");
        let surface = instance.create_surface(window.clone()).expect("surface");

        log::debug!("Requesting adapter");
        let adapter = instance
            .request_adapter(&wgpu::RequestAdapterOptions {
                power_preference: wgpu::PowerPreference::HighPerformance,
                compatible_surface: Some(&surface),
                force_fallback_adapter: false,
            })
            .await
            .expect("adapter");

        log::debug!("Requesting device");
        let (device, queue) = adapter
            .request_device(&wgpu::DeviceDescriptor {
                label: Some("Device"),
                required_limits: adapter.limits(),
                ..Default::default()
            })
            .await
            .expect("device");

        let surface_caps = surface.get_capabilities(&adapter);
        let surface_format = surface_caps.formats[0];
        let config = wgpu::SurfaceConfiguration {
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
            format: surface_format,
            width: size.width.max(1),
            height: size.height.max(1),
            present_mode: surface_caps.present_modes[0],
            alpha_mode: surface_caps.alpha_modes[0],
            view_formats: vec![surface_format.remove_srgb_suffix()],
            desired_maximum_frame_latency: 2,
        };

        log::debug!("Configuring surface");
        surface.configure(&device, &config);

        log::debug!("Creating gaussians");
        let gaussians = model_paths
            .iter()
            .map(|model_path| {
                log::debug!("Reading model from {model_path}");
                [GaussiansSource::Ply, GaussiansSource::Spz]
                    .into_iter()
                    .find_map(|source| gs::core::Gaussians::read_from_file(model_path, source).ok())
                    .expect("gaussians")
            })
            .collect::<Vec<_>>();

        log::debug!("Computing gaussian centroids");
        let mut gaussian_centroids = gaussians
            .iter()
            .map(|g| {
                let mut centroid = Vec3::ZERO;
                for gaussian in g.iter_gaussian() {
                    centroid += gaussian.pos;
                }
                centroid / g.len() as f32
            })
            .collect::<Vec<_>>();

        log::debug!("Creating camera");
        let camera = gs::Camera::new(0.1..1e4, 60f32.to_radians());

        log::debug!("Creating viewer");
        let mut viewer =
            gs::MultiModelViewer::new(&device, config.view_formats[0]).expect("viewer");

        let quat = Quat::from_axis_angle(Vec3::Z, 180f32.to_radians());
        for (i, gaussians) in gaussians.iter().enumerate() {
            let offset = model_offset * i as f32;

            log::debug!("Pushing model {i}");

            viewer.insert_model(&device, i, gaussians);
            viewer
                .update_model_transform(&queue, &i, offset, quat, Vec3::ONE)
                .expect("update model");

            gaussian_centroids[i] = quat.mul_vec3(gaussian_centroids[i]) + offset;
        }

        log::info!("System initialized");

        Self {
            surface,
            device,
            queue,
            config,

            camera,
            gaussians,
            gaussian_centroids,
            viewer,
        }
    }

pub fn insert_model_with( &mut self, device: &Device, key: K, gaussians_buffer_usage: BufferUsages, gaussians: &impl IterGaussian, ) -> Option<MultiModelViewerModel<G>>

Insert a new model to the viewer with custom gaussians buffer usage.

This ignores MultiModelViewer::gaussians_buffer_usage, and instead uses the provided usage in the argument.

pub fn remove_model(&mut self, key: &K) -> Option<MultiModelViewerModel<G>>

Remove a model from the viewer.

pub fn update_camera( &mut self, queue: &Queue, camera: &impl CameraTrait, texture_size: UVec2, )

Update the camera.

Examples found in repository

examples/multi_model.rs (lines 227-231)

    fn update(&mut self, input: &core::Input, delta_time: f32) {
        const SPEED: f32 = 1.0;

        let mut forward = 0.0;
        if input.held_keys.contains(&KeyCode::KeyW) {
            forward += SPEED * delta_time;
        }
        if input.held_keys.contains(&KeyCode::KeyS) {
            forward -= SPEED * delta_time;
        }

        let mut right = 0.0;
        if input.held_keys.contains(&KeyCode::KeyD) {
            right += SPEED * delta_time;
        }
        if input.held_keys.contains(&KeyCode::KeyA) {
            right -= SPEED * delta_time;
        }

        self.camera.move_by(forward, right);

        let mut up = 0.0;
        if input.held_keys.contains(&KeyCode::Space) {
            up += SPEED * delta_time;
        }
        if input.held_keys.contains(&KeyCode::ShiftLeft) {
            up -= SPEED * delta_time;
        }

        self.camera.move_up(up);

        // Camera rotation
        const SENSITIVITY: f32 = 0.15;

        let yaw = input.mouse_diff.x * SENSITIVITY * delta_time;
        let pitch = input.mouse_diff.y * SENSITIVITY * delta_time;

        self.camera.pitch_by(-pitch);
        self.camera.yaw_by(-yaw);

        // Update the viewer
        self.viewer.update_camera(
            &self.queue,
            &self.camera,
            uvec2(self.config.width, self.config.height),
        );
    }

pub fn update_camera_with_pod(&mut self, queue: &Queue, pod: &CameraPod)

Update the camera with CameraPod.

pub fn update_model_transform( &mut self, queue: &Queue, key: &K, pos: Vec3, rot: Quat, scale: Vec3, ) -> Result<(), MultiModelViewerAccessError>

Update the model transform.

Examples found in repository

examples/multi_model.rs (line 165)

    async fn init(window: Arc<Window>, args: &Args) -> Self {
        let model_paths = &args.models;
        let model_offset = Vec3::from_slice(&args.offset);
        let size = window.inner_size();

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

        log::debug!("Creating window surface");
        let surface = instance.create_surface(window.clone()).expect("surface");

        log::debug!("Requesting adapter");
        let adapter = instance
            .request_adapter(&wgpu::RequestAdapterOptions {
                power_preference: wgpu::PowerPreference::HighPerformance,
                compatible_surface: Some(&surface),
                force_fallback_adapter: false,
            })
            .await
            .expect("adapter");

        log::debug!("Requesting device");
        let (device, queue) = adapter
            .request_device(&wgpu::DeviceDescriptor {
                label: Some("Device"),
                required_limits: adapter.limits(),
                ..Default::default()
            })
            .await
            .expect("device");

        let surface_caps = surface.get_capabilities(&adapter);
        let surface_format = surface_caps.formats[0];
        let config = wgpu::SurfaceConfiguration {
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
            format: surface_format,
            width: size.width.max(1),
            height: size.height.max(1),
            present_mode: surface_caps.present_modes[0],
            alpha_mode: surface_caps.alpha_modes[0],
            view_formats: vec![surface_format.remove_srgb_suffix()],
            desired_maximum_frame_latency: 2,
        };

        log::debug!("Configuring surface");
        surface.configure(&device, &config);

        log::debug!("Creating gaussians");
        let gaussians = model_paths
            .iter()
            .map(|model_path| {
                log::debug!("Reading model from {model_path}");
                [GaussiansSource::Ply, GaussiansSource::Spz]
                    .into_iter()
                    .find_map(|source| gs::core::Gaussians::read_from_file(model_path, source).ok())
                    .expect("gaussians")
            })
            .collect::<Vec<_>>();

        log::debug!("Computing gaussian centroids");
        let mut gaussian_centroids = gaussians
            .iter()
            .map(|g| {
                let mut centroid = Vec3::ZERO;
                for gaussian in g.iter_gaussian() {
                    centroid += gaussian.pos;
                }
                centroid / g.len() as f32
            })
            .collect::<Vec<_>>();

        log::debug!("Creating camera");
        let camera = gs::Camera::new(0.1..1e4, 60f32.to_radians());

        log::debug!("Creating viewer");
        let mut viewer =
            gs::MultiModelViewer::new(&device, config.view_formats[0]).expect("viewer");

        let quat = Quat::from_axis_angle(Vec3::Z, 180f32.to_radians());
        for (i, gaussians) in gaussians.iter().enumerate() {
            let offset = model_offset * i as f32;

            log::debug!("Pushing model {i}");

            viewer.insert_model(&device, i, gaussians);
            viewer
                .update_model_transform(&queue, &i, offset, quat, Vec3::ONE)
                .expect("update model");

            gaussian_centroids[i] = quat.mul_vec3(gaussian_centroids[i]) + offset;
        }

        log::info!("System initialized");

        Self {
            surface,
            device,
            queue,
            config,

            camera,
            gaussians,
            gaussian_centroids,
            viewer,
        }
    }

pub fn update_model_transform_with_pod( &mut self, queue: &Queue, key: &K, pod: &ModelTransformPod, ) -> Result<(), MultiModelViewerAccessError>

Update the model transform with ModelTransformPod.

pub fn update_gaussian_transform( &mut self, queue: &Queue, size: f32, display_mode: GaussianDisplayMode, sh_deg: GaussianShDegree, no_sh0: bool, max_std_dev: GaussianMaxStdDev, )

Update the Gaussian transform.

pub fn update_gaussian_transform_with_pod( &mut self, queue: &Queue, pod: &GaussianTransformPod, )

Update the Gaussian transform with GaussianTransformPod.

pub fn render( &self, encoder: &mut CommandEncoder, texture_view: &TextureView, keys: &[&K], ) -> Result<(), MultiModelViewerAccessError>

Render the viewer.

Examples found in repository

examples/multi_model.rs (lines 274-278)

    fn render(&mut self) {
        let texture = match self.surface.get_current_texture() {
            Ok(texture) => texture,
            Err(e) => {
                log::error!("Failed to get current texture: {e:?}");
                return;
            }
        };
        let texture_view = texture.texture.create_view(&wgpu::TextureViewDescriptor {
            label: Some("Texture View"),
            format: Some(self.config.view_formats[0]),
            ..Default::default()
        });

        let mut encoder = self
            .device
            .create_command_encoder(&wgpu::CommandEncoderDescriptor {
                label: Some("Command Encoder"),
            });

        let mut render_keys = self
            .gaussian_centroids
            .iter()
            .enumerate()
            .map(|(i, centroid)| (i, centroid - self.camera.pos))
            .collect::<Vec<_>>();

        render_keys.sort_by(|(_, a), (_, b)| {
            a.length()
                .partial_cmp(&b.length())
                .unwrap_or(std::cmp::Ordering::Equal)
        });

        let render_keys = render_keys
            .into_iter()
            .rev()
            .map(|(i, _)| i)
            .collect::<Vec<_>>();

        self.viewer
            .render(
                &mut encoder,
                &texture_view,
                render_keys.iter().collect::<Vec<_>>().as_slice(),
            )
            .expect("render");

        self.queue.submit(std::iter::once(encoder.finish()));
        if let Err(e) = self.device.poll(wgpu::PollType::wait_indefinitely()) {
            log::error!("Failed to poll device: {e:?}");
        }
        texture.present();
    }

Trait Implementations

impl<G: Debug + GaussianPod, K: Debug + Hash + Eq> Debug for MultiModelViewer<G, K>

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

Formats the value using the given formatter.