Struct Viewer 

pub struct Viewer<G: GaussianPod = DefaultGaussianPod> {

    pub camera_buffer: CameraBuffer,
    pub model_transform_buffer: ModelTransformBuffer,
    pub gaussian_transform_buffer: GaussianTransformBuffer,
    pub gaussians_buffer: GaussiansBuffer<G>,
    pub indirect_args_buffer: IndirectArgsBuffer,
    pub radix_sort_indirect_args_buffer: RadixSortIndirectArgsBuffer,
    pub indirect_indices_buffer: IndirectIndicesBuffer,
    pub gaussians_depth_buffer: GaussiansDepthBuffer,
    pub selection_buffer: SelectionBuffer,
    pub invert_selection_buffer: PreprocessorInvertSelectionBuffer,
    pub preprocessor: Preprocessor<G>,
    pub radix_sorter: RadixSorter,
    pub renderer: Renderer<G>,
}

The 3D Gaussian splatting viewer.

This provides all the necessary buffers and operations to render 3D Gaussians:

• Buffers
  • CameraBuffer
  • ModelTransformBuffer
  • GaussianTransformBuffer
  • GaussiansBuffer
  • IndirectArgsBuffer
  • RadixSortIndirectArgsBuffer
  • IndirectIndicesBuffer
  • GaussiansDepthBuffer
• Operations
  • Preprocessor
  • RadixSorter
  • Renderer

If you wish to manage these buffers yourself, you do not need to use this struct.

Fields

camera_buffer: CameraBuffer

model_transform_buffer: ModelTransformBuffer

gaussian_transform_buffer: GaussianTransformBuffer

gaussians_buffer: GaussiansBuffer<G>

indirect_args_buffer: IndirectArgsBuffer

radix_sort_indirect_args_buffer: RadixSortIndirectArgsBuffer

indirect_indices_buffer: IndirectIndicesBuffer

gaussians_depth_buffer: GaussiansDepthBuffer

selection_buffer: SelectionBuffer

invert_selection_buffer: PreprocessorInvertSelectionBuffer

preprocessor: Preprocessor<G>

radix_sorter: RadixSorter

renderer: Renderer<G>

Implementations

impl<G: GaussianPod> Viewer<G>

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

Create a new viewer.

Examples found in repository

examples/simple.rs (line 167)

    async fn init(window: Arc<Window>, args: &Args) -> Self {
        let model_path = &args.model;
        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 = [GaussiansSource::Ply, GaussiansSource::Spz]
            .into_iter()
            .find_map(|source| gs::core::Gaussians::read_from_file(model_path, source).ok())
            .expect("gaussians");

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

        log::debug!("Creating viewer");
        let mut viewer =
            gs::Viewer::new(&device, config.view_formats[0], &gaussians).expect("viewer");
        viewer.update_model_transform(
            &queue,
            Vec3::ZERO,
            Quat::from_axis_angle(Vec3::Z, 180f32.to_radians()),
            Vec3::ONE,
        );

        viewer.update_gaussian_transform(
            &queue,
            args.size,
            match args.mode {
                DisplayMode::Splat => gs::core::GaussianDisplayMode::Splat,
                DisplayMode::Ellipse => gs::core::GaussianDisplayMode::Ellipse,
                DisplayMode::Point => gs::core::GaussianDisplayMode::Point,
            },
            gs::core::GaussianShDegree::new(args.sh_degree).expect("sh degree"),
            args.no_sh0,
            GaussianMaxStdDev::new(args.std_dev).expect("max std dev"),
        );

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

        Self {
            surface,
            device,
            queue,
            config,

            camera,
            gaussians,
            viewer,
        }
    }

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

Create a new viewer with extra ViewerCreateOptions.

Examples found in repository

examples/selection.rs (lines 154-164)

    async fn init(window: Arc<Window>, args: &Args) -> Self {
        let model_path = &args.model;
        let filter = args.filter;
        let immediate = args.immediate;
        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 = [GaussiansSource::Ply, GaussiansSource::Spz]
            .into_iter()
            .find_map(|source| gs::core::Gaussians::read_from_file(model_path, source).ok())
            .expect("gaussians");

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

        log::debug!("Creating viewer");
        let mut viewer = gs::Viewer::new_with_options(
            &device,
            config.view_formats[0],
            &gaussians,
            gs::ViewerCreateOptions {
                gaussians_buffer_usage:
                    gs::core::GaussiansBuffer::<gs::DefaultGaussianPod>::DEFAULT_USAGES
                        | wgpu::BufferUsages::COPY_SRC,
                ..Default::default()
            },
        )
        .expect("viewer");
        viewer.update_model_transform(
            &queue,
            Vec3::ZERO,
            Quat::from_axis_angle(Vec3::Z, 180f32.to_radians()),
            Vec3::ONE,
        );

        log::debug!("Creating selector");
        let mut selector = gs::selection::ViewportSelector::new(
            &device,
            &queue,
            UVec2::new(size.width, size.height),
            &viewer.camera_buffer,
        )
        .expect("selector");
        selector.selector_type = gs::selection::ViewportSelectorType::Brush;

        log::debug!("Creating selection viewport selection modifier");
        let mut viewport_selection_modifier = gs::editor::NonDestructiveModifier::new(
            &device,
            &queue,
            gs::editor::BasicSelectionModifier::new_with_basic_modifier(
                &device,
                &viewer.gaussians_buffer,
                &viewer.model_transform_buffer,
                &viewer.gaussian_transform_buffer,
                vec![gs::selection::create_viewport_bundle::<
                    gs::DefaultGaussianPod,
                >(&device)],
            ),
            &viewer.gaussians_buffer,
        )
        .expect("modifier");

        let viewport_selection_bind_group = viewport_selection_modifier.modifier.selection.bundles
            [0]
        .create_bind_group(
            &device,
            // index 0 is the Gaussians buffer, so we use 1,
            // see docs of create_viewport_bundle
            1,
            [
                viewer.camera_buffer.buffer().as_entire_binding(),
                wgpu::BindingResource::TextureView(selector.texture().view()),
            ],
        )
        .expect("bind group");

        viewport_selection_modifier.modifier.selection_expr =
            gs::editor::SelectionExpr::Selection(0, vec![viewport_selection_bind_group]);

        viewport_selection_modifier // Non destructive modifier
            .modifier // Selection modifier
            .modifier // Basic modifier
            .basic_color_modifiers_buffer
            .update_with_pod(
                &queue,
                &gs::editor::BasicColorModifiersPod {
                    rgb_or_hsv: BasicColorRgbOverrideOrHsvModifiersPod::new_rgb_override(
                        Vec3::new(1.0, 1.0, 0.0),
                    ),
                    ..Default::default()
                },
            );

        log::debug!("Creating selection viewport texture overlay renderer");
        let viewport_texture_overlay_renderer =
            utils::selection::ViewportTextureOverlayRenderer::new(
                &device,
                config.view_formats[0],
                selector.texture(),
            );

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

        Self {
            surface,
            device,
            queue,
            config,

            filter,
            immediate,
            inverted: filter,
            selector_type: None,

            camera,
            gaussians,
            viewer,
            selector,

            viewport_selection_modifier,
            viewport_texture_overlay_renderer,
        }
    }

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

Update the camera.

Examples found in repository

examples/simple.rs (lines 244-248)

    fn update(&mut self, input: &core::Input, delta_time: f32) {
        // Camera movement
        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),
        );
    }

examples/selection.rs (lines 295-299)

    fn update(&mut self, input: &core::Input, delta_time: f32) {
        // Toggle selection mode
        if input.pressed_keys.contains(&KeyCode::KeyN) {
            self.selector_type = None;
            log::info!("Selector: None");
        }
        if input.pressed_keys.contains(&KeyCode::KeyR) {
            self.selector_type = Some(gs::selection::ViewportSelectorType::Rectangle);
            log::info!("Selector: Rectangle");
            self.selector.selector_type = gs::selection::ViewportSelectorType::Rectangle;
        }
        if input.pressed_keys.contains(&KeyCode::KeyB) {
            self.selector_type = Some(gs::selection::ViewportSelectorType::Brush);
            log::info!("Selector: Brush");
            self.selector.selector_type = gs::selection::ViewportSelectorType::Brush;
        }
        if input.pressed_keys.contains(&KeyCode::KeyI) {
            self.inverted = !self.inverted;
            log::info!("Inverted: {}", self.inverted);
            if self.filter {
                self.viewer
                    .invert_selection_buffer
                    .update(&self.queue, self.inverted);
            }
        }

        if self.selector_type.is_some() {
            self.update_selection(input, delta_time);
        } else {
            self.update_movement(input, delta_time);
        }

        // 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, pos: Vec3, rot: Quat, scale: Vec3, )

Update the model transform.

Examples found in repository

examples/simple.rs (lines 168-173)

    async fn init(window: Arc<Window>, args: &Args) -> Self {
        let model_path = &args.model;
        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 = [GaussiansSource::Ply, GaussiansSource::Spz]
            .into_iter()
            .find_map(|source| gs::core::Gaussians::read_from_file(model_path, source).ok())
            .expect("gaussians");

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

        log::debug!("Creating viewer");
        let mut viewer =
            gs::Viewer::new(&device, config.view_formats[0], &gaussians).expect("viewer");
        viewer.update_model_transform(
            &queue,
            Vec3::ZERO,
            Quat::from_axis_angle(Vec3::Z, 180f32.to_radians()),
            Vec3::ONE,
        );

        viewer.update_gaussian_transform(
            &queue,
            args.size,
            match args.mode {
                DisplayMode::Splat => gs::core::GaussianDisplayMode::Splat,
                DisplayMode::Ellipse => gs::core::GaussianDisplayMode::Ellipse,
                DisplayMode::Point => gs::core::GaussianDisplayMode::Point,
            },
            gs::core::GaussianShDegree::new(args.sh_degree).expect("sh degree"),
            args.no_sh0,
            GaussianMaxStdDev::new(args.std_dev).expect("max std dev"),
        );

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

        Self {
            surface,
            device,
            queue,
            config,

            camera,
            gaussians,
            viewer,
        }
    }

examples/selection.rs (lines 166-171)

    async fn init(window: Arc<Window>, args: &Args) -> Self {
        let model_path = &args.model;
        let filter = args.filter;
        let immediate = args.immediate;
        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 = [GaussiansSource::Ply, GaussiansSource::Spz]
            .into_iter()
            .find_map(|source| gs::core::Gaussians::read_from_file(model_path, source).ok())
            .expect("gaussians");

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

        log::debug!("Creating viewer");
        let mut viewer = gs::Viewer::new_with_options(
            &device,
            config.view_formats[0],
            &gaussians,
            gs::ViewerCreateOptions {
                gaussians_buffer_usage:
                    gs::core::GaussiansBuffer::<gs::DefaultGaussianPod>::DEFAULT_USAGES
                        | wgpu::BufferUsages::COPY_SRC,
                ..Default::default()
            },
        )
        .expect("viewer");
        viewer.update_model_transform(
            &queue,
            Vec3::ZERO,
            Quat::from_axis_angle(Vec3::Z, 180f32.to_radians()),
            Vec3::ONE,
        );

        log::debug!("Creating selector");
        let mut selector = gs::selection::ViewportSelector::new(
            &device,
            &queue,
            UVec2::new(size.width, size.height),
            &viewer.camera_buffer,
        )
        .expect("selector");
        selector.selector_type = gs::selection::ViewportSelectorType::Brush;

        log::debug!("Creating selection viewport selection modifier");
        let mut viewport_selection_modifier = gs::editor::NonDestructiveModifier::new(
            &device,
            &queue,
            gs::editor::BasicSelectionModifier::new_with_basic_modifier(
                &device,
                &viewer.gaussians_buffer,
                &viewer.model_transform_buffer,
                &viewer.gaussian_transform_buffer,
                vec![gs::selection::create_viewport_bundle::<
                    gs::DefaultGaussianPod,
                >(&device)],
            ),
            &viewer.gaussians_buffer,
        )
        .expect("modifier");

        let viewport_selection_bind_group = viewport_selection_modifier.modifier.selection.bundles
            [0]
        .create_bind_group(
            &device,
            // index 0 is the Gaussians buffer, so we use 1,
            // see docs of create_viewport_bundle
            1,
            [
                viewer.camera_buffer.buffer().as_entire_binding(),
                wgpu::BindingResource::TextureView(selector.texture().view()),
            ],
        )
        .expect("bind group");

        viewport_selection_modifier.modifier.selection_expr =
            gs::editor::SelectionExpr::Selection(0, vec![viewport_selection_bind_group]);

        viewport_selection_modifier // Non destructive modifier
            .modifier // Selection modifier
            .modifier // Basic modifier
            .basic_color_modifiers_buffer
            .update_with_pod(
                &queue,
                &gs::editor::BasicColorModifiersPod {
                    rgb_or_hsv: BasicColorRgbOverrideOrHsvModifiersPod::new_rgb_override(
                        Vec3::new(1.0, 1.0, 0.0),
                    ),
                    ..Default::default()
                },
            );

        log::debug!("Creating selection viewport texture overlay renderer");
        let viewport_texture_overlay_renderer =
            utils::selection::ViewportTextureOverlayRenderer::new(
                &device,
                config.view_formats[0],
                selector.texture(),
            );

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

        Self {
            surface,
            device,
            queue,
            config,

            filter,
            immediate,
            inverted: filter,
            selector_type: None,

            camera,
            gaussians,
            viewer,
            selector,

            viewport_selection_modifier,
            viewport_texture_overlay_renderer,
        }
    }

pub fn update_model_transform_with_pod( &mut self, queue: &Queue, pod: &ModelTransformPod, )

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.

Examples found in repository

examples/simple.rs (lines 175-186)

    async fn init(window: Arc<Window>, args: &Args) -> Self {
        let model_path = &args.model;
        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 = [GaussiansSource::Ply, GaussiansSource::Spz]
            .into_iter()
            .find_map(|source| gs::core::Gaussians::read_from_file(model_path, source).ok())
            .expect("gaussians");

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

        log::debug!("Creating viewer");
        let mut viewer =
            gs::Viewer::new(&device, config.view_formats[0], &gaussians).expect("viewer");
        viewer.update_model_transform(
            &queue,
            Vec3::ZERO,
            Quat::from_axis_angle(Vec3::Z, 180f32.to_radians()),
            Vec3::ONE,
        );

        viewer.update_gaussian_transform(
            &queue,
            args.size,
            match args.mode {
                DisplayMode::Splat => gs::core::GaussianDisplayMode::Splat,
                DisplayMode::Ellipse => gs::core::GaussianDisplayMode::Ellipse,
                DisplayMode::Point => gs::core::GaussianDisplayMode::Point,
            },
            gs::core::GaussianShDegree::new(args.sh_degree).expect("sh degree"),
            args.no_sh0,
            GaussianMaxStdDev::new(args.std_dev).expect("max std dev"),
        );

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

        Self {
            surface,
            device,
            queue,
            config,

            camera,
            gaussians,
            viewer,
        }
    }

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)

Render the viewer.

Examples found in repository

examples/simple.rs (line 271)

    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"),
            });

        self.viewer.render(&mut encoder, &texture_view);

        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();
    }

examples/selection.rs (line 322)

    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"),
            });

        self.viewer.render(&mut encoder, &texture_view);

        if !self.immediate && self.selector_type.is_some() {
            self.viewport_texture_overlay_renderer
                .render(&mut encoder, &texture_view);
        }

        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> Debug for Viewer<G>

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

Formats the value using the given formatter.