Struct Camera

Source

pub struct Camera {
    pub pos: Vec3,
    pub z: Range<f32>,
    pub vertical_fov: f32,
    pub pitch: f32,
    pub yaw: f32,
}

Expand description

A camera.

Fields§

§pos: Vec3

The position of the camera.

§z: Range<f32>

The z range of the camera.

§vertical_fov: f32

The vertical FOV.

§pitch: f32

The pitch.

§yaw: f32

The yaw.

Implementations§

Source §

impl Camera

Source

pub const UP: Vec3 = Vec3::Y

Up direction.

Source

pub const PITCH_LIMIT: Range<f32>

The pitch limit.

Source

pub fn new(z: Range<f32>, vertical_fov: f32) -> Self

Create a new camera.

Examples found in repository ?

examples/simple.rs (line 164)

110    async fn init(window: Arc<Window>, args: &Args) -> Self {
111        let model_path = &args.model;
112        let size = window.inner_size();
113
114        log::debug!("Creating wgpu instance");
115        let instance =
116            wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle_from_env());
117
118        log::debug!("Creating window surface");
119        let surface = instance.create_surface(window.clone()).expect("surface");
120
121        log::debug!("Requesting adapter");
122        let adapter = instance
123            .request_adapter(&wgpu::RequestAdapterOptions {
124                power_preference: wgpu::PowerPreference::HighPerformance,
125                compatible_surface: Some(&surface),
126                force_fallback_adapter: false,
127            })
128            .await
129            .expect("adapter");
130
131        log::debug!("Requesting device");
132        let (device, queue) = adapter
133            .request_device(&wgpu::DeviceDescriptor {
134                label: Some("Device"),
135                required_limits: adapter.limits(),
136                ..Default::default()
137            })
138            .await
139            .expect("device");
140
141        let surface_caps = surface.get_capabilities(&adapter);
142        let surface_format = surface_caps.formats[0];
143        let config = wgpu::SurfaceConfiguration {
144            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
145            format: surface_format,
146            width: size.width.max(1),
147            height: size.height.max(1),
148            present_mode: surface_caps.present_modes[0],
149            alpha_mode: surface_caps.alpha_modes[0],
150            view_formats: vec![surface_format.remove_srgb_suffix()],
151            desired_maximum_frame_latency: 2,
152        };
153
154        log::debug!("Configuring surface");
155        surface.configure(&device, &config);
156
157        log::debug!("Creating gaussians");
158        let gaussians = [GaussiansSource::Ply, GaussiansSource::Spz]
159            .into_iter()
160            .find_map(|source| gs::core::Gaussians::read_from_file(model_path, source).ok())
161            .expect("gaussians");
162
163        log::debug!("Creating camera");
164        let camera = gs::Camera::new(0.1..1e4, 60f32.to_radians());
165
166        log::debug!("Creating viewer");
167        let mut viewer =
168            gs::Viewer::new(&device, config.view_formats[0], &gaussians).expect("viewer");
169        viewer.update_model_transform(
170            &queue,
171            Vec3::ZERO,
172            Quat::from_axis_angle(Vec3::Z, 180f32.to_radians()),
173            Vec3::ONE,
174        );
175
176        viewer.update_gaussian_transform(
177            &queue,
178            args.size,
179            match args.mode {
180                DisplayMode::Splat => gs::core::GaussianDisplayMode::Splat,
181                DisplayMode::Ellipse => gs::core::GaussianDisplayMode::Ellipse,
182                DisplayMode::Point => gs::core::GaussianDisplayMode::Point,
183            },
184            gs::core::GaussianShDegree::new(args.sh_degree).expect("sh degree"),
185            args.no_sh0,
186            GaussianMaxStdDev::new(args.std_dev).expect("max std dev"),
187        );
188
189        log::info!("System initialized");
190
191        Self {
192            surface,
193            device,
194            queue,
195            config,
196
197            camera,
198            gaussians,
199            viewer,
200        }
201    }

More examples

Hide additional examples

examples/multi_model.rs (line 152)

79    async fn init(window: Arc<Window>, args: &Args) -> Self {
80        let model_paths = &args.models;
81        let model_offset = Vec3::from_slice(&args.offset);
82        let size = window.inner_size();
83
84        log::debug!("Creating wgpu instance");
85        let instance =
86            wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle_from_env());
87
88        log::debug!("Creating window surface");
89        let surface = instance.create_surface(window.clone()).expect("surface");
90
91        log::debug!("Requesting adapter");
92        let adapter = instance
93            .request_adapter(&wgpu::RequestAdapterOptions {
94                power_preference: wgpu::PowerPreference::HighPerformance,
95                compatible_surface: Some(&surface),
96                force_fallback_adapter: false,
97            })
98            .await
99            .expect("adapter");
100
101        log::debug!("Requesting device");
102        let (device, queue) = adapter
103            .request_device(&wgpu::DeviceDescriptor {
104                label: Some("Device"),
105                required_limits: adapter.limits(),
106                ..Default::default()
107            })
108            .await
109            .expect("device");
110
111        let surface_caps = surface.get_capabilities(&adapter);
112        let surface_format = surface_caps.formats[0];
113        let config = wgpu::SurfaceConfiguration {
114            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
115            format: surface_format,
116            width: size.width.max(1),
117            height: size.height.max(1),
118            present_mode: surface_caps.present_modes[0],
119            alpha_mode: surface_caps.alpha_modes[0],
120            view_formats: vec![surface_format.remove_srgb_suffix()],
121            desired_maximum_frame_latency: 2,
122        };
123
124        log::debug!("Configuring surface");
125        surface.configure(&device, &config);
126
127        log::debug!("Creating gaussians");
128        let gaussians = model_paths
129            .iter()
130            .map(|model_path| {
131                log::debug!("Reading model from {model_path}");
132                [GaussiansSource::Ply, GaussiansSource::Spz]
133                    .into_iter()
134                    .find_map(|source| gs::core::Gaussians::read_from_file(model_path, source).ok())
135                    .expect("gaussians")
136            })
137            .collect::<Vec<_>>();
138
139        log::debug!("Computing gaussian centroids");
140        let mut gaussian_centroids = gaussians
141            .iter()
142            .map(|g| {
143                let mut centroid = Vec3::ZERO;
144                for gaussian in g.iter_gaussian() {
145                    centroid += gaussian.pos;
146                }
147                centroid / g.len() as f32
148            })
149            .collect::<Vec<_>>();
150
151        log::debug!("Creating camera");
152        let camera = gs::Camera::new(0.1..1e4, 60f32.to_radians());
153
154        log::debug!("Creating viewer");
155        let mut viewer =
156            gs::MultiModelViewer::new(&device, config.view_formats[0]).expect("viewer");
157
158        let quat = Quat::from_axis_angle(Vec3::Z, 180f32.to_radians());
159        for (i, gaussians) in gaussians.iter().enumerate() {
160            let offset = model_offset * i as f32;
161
162            log::debug!("Pushing model {i}");
163
164            viewer.insert_model(&device, i, gaussians);
165            viewer
166                .update_model_transform(&queue, &i, offset, quat, Vec3::ONE)
167                .expect("update model");
168
169            gaussian_centroids[i] = quat.mul_vec3(gaussian_centroids[i]) + offset;
170        }
171
172        log::info!("System initialized");
173
174        Self {
175            surface,
176            device,
177            queue,
178            config,
179
180            camera,
181            gaussians,
182            gaussian_centroids,
183            viewer,
184        }
185    }

examples/selection.rs (line 152)

96    async fn init(window: Arc<Window>, args: &Args) -> Self {
97        let model_path = &args.model;
98        let filter = args.filter;
99        let immediate = args.immediate;
100        let size = window.inner_size();
101
102        log::debug!("Creating wgpu instance");
103        let instance =
104            wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle_from_env());
105
106        log::debug!("Creating window surface");
107        let surface = instance.create_surface(window.clone()).expect("surface");
108
109        log::debug!("Requesting adapter");
110        let adapter = instance
111            .request_adapter(&wgpu::RequestAdapterOptions {
112                power_preference: wgpu::PowerPreference::HighPerformance,
113                compatible_surface: Some(&surface),
114                force_fallback_adapter: false,
115            })
116            .await
117            .expect("adapter");
118
119        log::debug!("Requesting device");
120        let (device, queue) = adapter
121            .request_device(&wgpu::DeviceDescriptor {
122                label: Some("Device"),
123                required_limits: adapter.limits(),
124                ..Default::default()
125            })
126            .await
127            .expect("device");
128
129        let surface_caps = surface.get_capabilities(&adapter);
130        let surface_format = surface_caps.formats[0];
131        let config = wgpu::SurfaceConfiguration {
132            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
133            format: surface_format,
134            width: size.width.max(1),
135            height: size.height.max(1),
136            present_mode: surface_caps.present_modes[0],
137            alpha_mode: surface_caps.alpha_modes[0],
138            view_formats: vec![surface_format.remove_srgb_suffix()],
139            desired_maximum_frame_latency: 2,
140        };
141
142        log::debug!("Configuring surface");
143        surface.configure(&device, &config);
144
145        log::debug!("Creating gaussians");
146        let gaussians = [GaussiansSource::Ply, GaussiansSource::Spz]
147            .into_iter()
148            .find_map(|source| gs::core::Gaussians::read_from_file(model_path, source).ok())
149            .expect("gaussians");
150
151        log::debug!("Creating camera");
152        let camera = gs::Camera::new(0.1..1e4, 60f32.to_radians());
153
154        log::debug!("Creating viewer");
155        let mut viewer = gs::Viewer::new_with_options(
156            &device,
157            config.view_formats[0],
158            &gaussians,
159            gs::ViewerCreateOptions {
160                gaussians_buffer_usage:
161                    gs::core::GaussiansBuffer::<gs::DefaultGaussianPod>::DEFAULT_USAGES
162                        | wgpu::BufferUsages::COPY_SRC,
163                ..Default::default()
164            },
165        )
166        .expect("viewer");
167        viewer.update_model_transform(
168            &queue,
169            Vec3::ZERO,
170            Quat::from_axis_angle(Vec3::Z, 180f32.to_radians()),
171            Vec3::ONE,
172        );
173
174        log::debug!("Creating selector");
175        let mut selector = gs::selection::ViewportSelector::new(
176            &device,
177            &queue,
178            UVec2::new(size.width, size.height),
179            &viewer.camera_buffer,
180        )
181        .expect("selector");
182        selector.selector_type = gs::selection::ViewportSelectorType::Brush;
183
184        log::debug!("Creating selection viewport selection modifier");
185        let mut viewport_selection_modifier = gs::editor::NonDestructiveModifier::new(
186            &device,
187            &queue,
188            gs::editor::BasicSelectionModifier::new_with_basic_modifier(
189                &device,
190                &viewer.gaussians_buffer,
191                &viewer.model_transform_buffer,
192                &viewer.gaussian_transform_buffer,
193                vec![gs::selection::create_viewport_bundle::<
194                    gs::DefaultGaussianPod,
195                >(&device)],
196            ),
197            &viewer.gaussians_buffer,
198        )
199        .expect("modifier");
200
201        let viewport_selection_bind_group = viewport_selection_modifier.modifier.selection.bundles
202            [0]
203        .create_bind_group(
204            &device,
205            // index 0 is the Gaussians buffer, so we use 1,
206            // see docs of create_viewport_bundle
207            1,
208            [
209                viewer.camera_buffer.buffer().as_entire_binding(),
210                wgpu::BindingResource::TextureView(selector.texture().view()),
211            ],
212        )
213        .expect("bind group");
214
215        viewport_selection_modifier.modifier.selection_expr =
216            gs::editor::SelectionExpr::Selection(0, vec![viewport_selection_bind_group]);
217
218        viewport_selection_modifier // Non destructive modifier
219            .modifier // Selection modifier
220            .modifier // Basic modifier
221            .basic_color_modifiers_buffer
222            .update_with_pod(
223                &queue,
224                &gs::editor::BasicColorModifiersPod {
225                    rgb_or_hsv: BasicColorRgbOverrideOrHsvModifiersPod::new_rgb_override(
226                        Vec3::new(1.0, 1.0, 0.0),
227                    ),
228                    ..Default::default()
229                },
230            );
231
232        log::debug!("Creating selection viewport texture overlay renderer");
233        let viewport_texture_overlay_renderer =
234            utils::selection::ViewportTextureOverlayRenderer::new(
235                &device,
236                config.view_formats[0],
237                selector.texture(),
238            );
239
240        log::info!("System initialized");
241
242        Self {
243            surface,
244            device,
245            queue,
246            config,
247
248            filter,
249            immediate,
250            inverted: filter,
251            selector_type: None,
252
253            camera,
254            gaussians,
255            viewer,
256            selector,
257
258            viewport_selection_modifier,
259            viewport_texture_overlay_renderer,
260        }
261    }

Source

pub fn move_by(&mut self, forward: f32, right: f32)

Move the camera.

Examples found in repository ?

examples/selection.rs (line 474)

454    fn update_movement(&mut self, input: &core::Input, delta_time: f32) {
455        // Camera movement
456        const SPEED: f32 = 1.0;
457
458        let mut forward = 0.0;
459        if input.held_keys.contains(&KeyCode::KeyW) {
460            forward += SPEED * delta_time;
461        }
462        if input.held_keys.contains(&KeyCode::KeyS) {
463            forward -= SPEED * delta_time;
464        }
465
466        let mut right = 0.0;
467        if input.held_keys.contains(&KeyCode::KeyD) {
468            right += SPEED * delta_time;
469        }
470        if input.held_keys.contains(&KeyCode::KeyA) {
471            right -= SPEED * delta_time;
472        }
473
474        self.camera.move_by(forward, right);
475
476        let mut up = 0.0;
477        if input.held_keys.contains(&KeyCode::Space) {
478            up += SPEED * delta_time;
479        }
480        if input.held_keys.contains(&KeyCode::ShiftLeft) {
481            up -= SPEED * delta_time;
482        }
483
484        self.camera.move_up(up);
485
486        // Camera rotation
487        const SENSITIVITY: f32 = 0.15;
488
489        let yaw = input.mouse_diff.x * SENSITIVITY * delta_time;
490        let pitch = input.mouse_diff.y * SENSITIVITY * delta_time;
491
492        self.camera.pitch_by(-pitch);
493        self.camera.yaw_by(-yaw);
494    }

More examples

Hide additional examples

examples/multi_model.rs (line 206)

187    fn update(&mut self, input: &core::Input, delta_time: f32) {
188        const SPEED: f32 = 1.0;
189
190        let mut forward = 0.0;
191        if input.held_keys.contains(&KeyCode::KeyW) {
192            forward += SPEED * delta_time;
193        }
194        if input.held_keys.contains(&KeyCode::KeyS) {
195            forward -= SPEED * delta_time;
196        }
197
198        let mut right = 0.0;
199        if input.held_keys.contains(&KeyCode::KeyD) {
200            right += SPEED * delta_time;
201        }
202        if input.held_keys.contains(&KeyCode::KeyA) {
203            right -= SPEED * delta_time;
204        }
205
206        self.camera.move_by(forward, right);
207
208        let mut up = 0.0;
209        if input.held_keys.contains(&KeyCode::Space) {
210            up += SPEED * delta_time;
211        }
212        if input.held_keys.contains(&KeyCode::ShiftLeft) {
213            up -= SPEED * delta_time;
214        }
215
216        self.camera.move_up(up);
217
218        // Camera rotation
219        const SENSITIVITY: f32 = 0.15;
220
221        let yaw = input.mouse_diff.x * SENSITIVITY * delta_time;
222        let pitch = input.mouse_diff.y * SENSITIVITY * delta_time;
223
224        self.camera.pitch_by(-pitch);
225        self.camera.yaw_by(-yaw);
226
227        // Update the viewer
228        self.viewer.update_camera(
229            &self.queue,
230            &self.camera,
231            uvec2(self.config.width, self.config.height),
232        );
233    }

examples/simple.rs (line 223)

203    fn update(&mut self, input: &core::Input, delta_time: f32) {
204        // Camera movement
205        const SPEED: f32 = 1.0;
206
207        let mut forward = 0.0;
208        if input.held_keys.contains(&KeyCode::KeyW) {
209            forward += SPEED * delta_time;
210        }
211        if input.held_keys.contains(&KeyCode::KeyS) {
212            forward -= SPEED * delta_time;
213        }
214
215        let mut right = 0.0;
216        if input.held_keys.contains(&KeyCode::KeyD) {
217            right += SPEED * delta_time;
218        }
219        if input.held_keys.contains(&KeyCode::KeyA) {
220            right -= SPEED * delta_time;
221        }
222
223        self.camera.move_by(forward, right);
224
225        let mut up = 0.0;
226        if input.held_keys.contains(&KeyCode::Space) {
227            up += SPEED * delta_time;
228        }
229        if input.held_keys.contains(&KeyCode::ShiftLeft) {
230            up -= SPEED * delta_time;
231        }
232
233        self.camera.move_up(up);
234
235        // Camera rotation
236        const SENSITIVITY: f32 = 0.15;
237
238        let yaw = input.mouse_diff.x * SENSITIVITY * delta_time;
239        let pitch = input.mouse_diff.y * SENSITIVITY * delta_time;
240
241        self.camera.pitch_by(-pitch);
242        self.camera.yaw_by(-yaw);
243
244        // Update the viewer
245        self.viewer.update_camera(
246            &self.queue,
247            &self.camera,
248            uvec2(self.config.width, self.config.height),
249        );
250    }

Source

pub fn move_up(&mut self, up: f32)

Move the camera forward.

Examples found in repository ?

examples/selection.rs (line 484)

454    fn update_movement(&mut self, input: &core::Input, delta_time: f32) {
455        // Camera movement
456        const SPEED: f32 = 1.0;
457
458        let mut forward = 0.0;
459        if input.held_keys.contains(&KeyCode::KeyW) {
460            forward += SPEED * delta_time;
461        }
462        if input.held_keys.contains(&KeyCode::KeyS) {
463            forward -= SPEED * delta_time;
464        }
465
466        let mut right = 0.0;
467        if input.held_keys.contains(&KeyCode::KeyD) {
468            right += SPEED * delta_time;
469        }
470        if input.held_keys.contains(&KeyCode::KeyA) {
471            right -= SPEED * delta_time;
472        }
473
474        self.camera.move_by(forward, right);
475
476        let mut up = 0.0;
477        if input.held_keys.contains(&KeyCode::Space) {
478            up += SPEED * delta_time;
479        }
480        if input.held_keys.contains(&KeyCode::ShiftLeft) {
481            up -= SPEED * delta_time;
482        }
483
484        self.camera.move_up(up);
485
486        // Camera rotation
487        const SENSITIVITY: f32 = 0.15;
488
489        let yaw = input.mouse_diff.x * SENSITIVITY * delta_time;
490        let pitch = input.mouse_diff.y * SENSITIVITY * delta_time;
491
492        self.camera.pitch_by(-pitch);
493        self.camera.yaw_by(-yaw);
494    }

More examples

Hide additional examples

examples/multi_model.rs (line 216)

187    fn update(&mut self, input: &core::Input, delta_time: f32) {
188        const SPEED: f32 = 1.0;
189
190        let mut forward = 0.0;
191        if input.held_keys.contains(&KeyCode::KeyW) {
192            forward += SPEED * delta_time;
193        }
194        if input.held_keys.contains(&KeyCode::KeyS) {
195            forward -= SPEED * delta_time;
196        }
197
198        let mut right = 0.0;
199        if input.held_keys.contains(&KeyCode::KeyD) {
200            right += SPEED * delta_time;
201        }
202        if input.held_keys.contains(&KeyCode::KeyA) {
203            right -= SPEED * delta_time;
204        }
205
206        self.camera.move_by(forward, right);
207
208        let mut up = 0.0;
209        if input.held_keys.contains(&KeyCode::Space) {
210            up += SPEED * delta_time;
211        }
212        if input.held_keys.contains(&KeyCode::ShiftLeft) {
213            up -= SPEED * delta_time;
214        }
215
216        self.camera.move_up(up);
217
218        // Camera rotation
219        const SENSITIVITY: f32 = 0.15;
220
221        let yaw = input.mouse_diff.x * SENSITIVITY * delta_time;
222        let pitch = input.mouse_diff.y * SENSITIVITY * delta_time;
223
224        self.camera.pitch_by(-pitch);
225        self.camera.yaw_by(-yaw);
226
227        // Update the viewer
228        self.viewer.update_camera(
229            &self.queue,
230            &self.camera,
231            uvec2(self.config.width, self.config.height),
232        );
233    }

examples/simple.rs (line 233)

203    fn update(&mut self, input: &core::Input, delta_time: f32) {
204        // Camera movement
205        const SPEED: f32 = 1.0;
206
207        let mut forward = 0.0;
208        if input.held_keys.contains(&KeyCode::KeyW) {
209            forward += SPEED * delta_time;
210        }
211        if input.held_keys.contains(&KeyCode::KeyS) {
212            forward -= SPEED * delta_time;
213        }
214
215        let mut right = 0.0;
216        if input.held_keys.contains(&KeyCode::KeyD) {
217            right += SPEED * delta_time;
218        }
219        if input.held_keys.contains(&KeyCode::KeyA) {
220            right -= SPEED * delta_time;
221        }
222
223        self.camera.move_by(forward, right);
224
225        let mut up = 0.0;
226        if input.held_keys.contains(&KeyCode::Space) {
227            up += SPEED * delta_time;
228        }
229        if input.held_keys.contains(&KeyCode::ShiftLeft) {
230            up -= SPEED * delta_time;
231        }
232
233        self.camera.move_up(up);
234
235        // Camera rotation
236        const SENSITIVITY: f32 = 0.15;
237
238        let yaw = input.mouse_diff.x * SENSITIVITY * delta_time;
239        let pitch = input.mouse_diff.y * SENSITIVITY * delta_time;
240
241        self.camera.pitch_by(-pitch);
242        self.camera.yaw_by(-yaw);
243
244        // Update the viewer
245        self.viewer.update_camera(
246            &self.queue,
247            &self.camera,
248            uvec2(self.config.width, self.config.height),
249        );
250    }

Source

pub fn pitch_by(&mut self, delta: f32)

Apply pitch.

Examples found in repository ?

examples/selection.rs (line 492)

454    fn update_movement(&mut self, input: &core::Input, delta_time: f32) {
455        // Camera movement
456        const SPEED: f32 = 1.0;
457
458        let mut forward = 0.0;
459        if input.held_keys.contains(&KeyCode::KeyW) {
460            forward += SPEED * delta_time;
461        }
462        if input.held_keys.contains(&KeyCode::KeyS) {
463            forward -= SPEED * delta_time;
464        }
465
466        let mut right = 0.0;
467        if input.held_keys.contains(&KeyCode::KeyD) {
468            right += SPEED * delta_time;
469        }
470        if input.held_keys.contains(&KeyCode::KeyA) {
471            right -= SPEED * delta_time;
472        }
473
474        self.camera.move_by(forward, right);
475
476        let mut up = 0.0;
477        if input.held_keys.contains(&KeyCode::Space) {
478            up += SPEED * delta_time;
479        }
480        if input.held_keys.contains(&KeyCode::ShiftLeft) {
481            up -= SPEED * delta_time;
482        }
483
484        self.camera.move_up(up);
485
486        // Camera rotation
487        const SENSITIVITY: f32 = 0.15;
488
489        let yaw = input.mouse_diff.x * SENSITIVITY * delta_time;
490        let pitch = input.mouse_diff.y * SENSITIVITY * delta_time;
491
492        self.camera.pitch_by(-pitch);
493        self.camera.yaw_by(-yaw);
494    }

More examples

Hide additional examples

examples/multi_model.rs (line 224)

187    fn update(&mut self, input: &core::Input, delta_time: f32) {
188        const SPEED: f32 = 1.0;
189
190        let mut forward = 0.0;
191        if input.held_keys.contains(&KeyCode::KeyW) {
192            forward += SPEED * delta_time;
193        }
194        if input.held_keys.contains(&KeyCode::KeyS) {
195            forward -= SPEED * delta_time;
196        }
197
198        let mut right = 0.0;
199        if input.held_keys.contains(&KeyCode::KeyD) {
200            right += SPEED * delta_time;
201        }
202        if input.held_keys.contains(&KeyCode::KeyA) {
203            right -= SPEED * delta_time;
204        }
205
206        self.camera.move_by(forward, right);
207
208        let mut up = 0.0;
209        if input.held_keys.contains(&KeyCode::Space) {
210            up += SPEED * delta_time;
211        }
212        if input.held_keys.contains(&KeyCode::ShiftLeft) {
213            up -= SPEED * delta_time;
214        }
215
216        self.camera.move_up(up);
217
218        // Camera rotation
219        const SENSITIVITY: f32 = 0.15;
220
221        let yaw = input.mouse_diff.x * SENSITIVITY * delta_time;
222        let pitch = input.mouse_diff.y * SENSITIVITY * delta_time;
223
224        self.camera.pitch_by(-pitch);
225        self.camera.yaw_by(-yaw);
226
227        // Update the viewer
228        self.viewer.update_camera(
229            &self.queue,
230            &self.camera,
231            uvec2(self.config.width, self.config.height),
232        );
233    }

examples/simple.rs (line 241)

203    fn update(&mut self, input: &core::Input, delta_time: f32) {
204        // Camera movement
205        const SPEED: f32 = 1.0;
206
207        let mut forward = 0.0;
208        if input.held_keys.contains(&KeyCode::KeyW) {
209            forward += SPEED * delta_time;
210        }
211        if input.held_keys.contains(&KeyCode::KeyS) {
212            forward -= SPEED * delta_time;
213        }
214
215        let mut right = 0.0;
216        if input.held_keys.contains(&KeyCode::KeyD) {
217            right += SPEED * delta_time;
218        }
219        if input.held_keys.contains(&KeyCode::KeyA) {
220            right -= SPEED * delta_time;
221        }
222
223        self.camera.move_by(forward, right);
224
225        let mut up = 0.0;
226        if input.held_keys.contains(&KeyCode::Space) {
227            up += SPEED * delta_time;
228        }
229        if input.held_keys.contains(&KeyCode::ShiftLeft) {
230            up -= SPEED * delta_time;
231        }
232
233        self.camera.move_up(up);
234
235        // Camera rotation
236        const SENSITIVITY: f32 = 0.15;
237
238        let yaw = input.mouse_diff.x * SENSITIVITY * delta_time;
239        let pitch = input.mouse_diff.y * SENSITIVITY * delta_time;
240
241        self.camera.pitch_by(-pitch);
242        self.camera.yaw_by(-yaw);
243
244        // Update the viewer
245        self.viewer.update_camera(
246            &self.queue,
247            &self.camera,
248            uvec2(self.config.width, self.config.height),
249        );
250    }

Source

pub fn yaw_by(&mut self, delta: f32)

Apply yaw.

Examples found in repository ?

examples/selection.rs (line 493)

454    fn update_movement(&mut self, input: &core::Input, delta_time: f32) {
455        // Camera movement
456        const SPEED: f32 = 1.0;
457
458        let mut forward = 0.0;
459        if input.held_keys.contains(&KeyCode::KeyW) {
460            forward += SPEED * delta_time;
461        }
462        if input.held_keys.contains(&KeyCode::KeyS) {
463            forward -= SPEED * delta_time;
464        }
465
466        let mut right = 0.0;
467        if input.held_keys.contains(&KeyCode::KeyD) {
468            right += SPEED * delta_time;
469        }
470        if input.held_keys.contains(&KeyCode::KeyA) {
471            right -= SPEED * delta_time;
472        }
473
474        self.camera.move_by(forward, right);
475
476        let mut up = 0.0;
477        if input.held_keys.contains(&KeyCode::Space) {
478            up += SPEED * delta_time;
479        }
480        if input.held_keys.contains(&KeyCode::ShiftLeft) {
481            up -= SPEED * delta_time;
482        }
483
484        self.camera.move_up(up);
485
486        // Camera rotation
487        const SENSITIVITY: f32 = 0.15;
488
489        let yaw = input.mouse_diff.x * SENSITIVITY * delta_time;
490        let pitch = input.mouse_diff.y * SENSITIVITY * delta_time;
491
492        self.camera.pitch_by(-pitch);
493        self.camera.yaw_by(-yaw);
494    }

More examples

Hide additional examples

examples/multi_model.rs (line 225)

187    fn update(&mut self, input: &core::Input, delta_time: f32) {
188        const SPEED: f32 = 1.0;
189
190        let mut forward = 0.0;
191        if input.held_keys.contains(&KeyCode::KeyW) {
192            forward += SPEED * delta_time;
193        }
194        if input.held_keys.contains(&KeyCode::KeyS) {
195            forward -= SPEED * delta_time;
196        }
197
198        let mut right = 0.0;
199        if input.held_keys.contains(&KeyCode::KeyD) {
200            right += SPEED * delta_time;
201        }
202        if input.held_keys.contains(&KeyCode::KeyA) {
203            right -= SPEED * delta_time;
204        }
205
206        self.camera.move_by(forward, right);
207
208        let mut up = 0.0;
209        if input.held_keys.contains(&KeyCode::Space) {
210            up += SPEED * delta_time;
211        }
212        if input.held_keys.contains(&KeyCode::ShiftLeft) {
213            up -= SPEED * delta_time;
214        }
215
216        self.camera.move_up(up);
217
218        // Camera rotation
219        const SENSITIVITY: f32 = 0.15;
220
221        let yaw = input.mouse_diff.x * SENSITIVITY * delta_time;
222        let pitch = input.mouse_diff.y * SENSITIVITY * delta_time;
223
224        self.camera.pitch_by(-pitch);
225        self.camera.yaw_by(-yaw);
226
227        // Update the viewer
228        self.viewer.update_camera(
229            &self.queue,
230            &self.camera,
231            uvec2(self.config.width, self.config.height),
232        );
233    }

examples/simple.rs (line 242)

203    fn update(&mut self, input: &core::Input, delta_time: f32) {
204        // Camera movement
205        const SPEED: f32 = 1.0;
206
207        let mut forward = 0.0;
208        if input.held_keys.contains(&KeyCode::KeyW) {
209            forward += SPEED * delta_time;
210        }
211        if input.held_keys.contains(&KeyCode::KeyS) {
212            forward -= SPEED * delta_time;
213        }
214
215        let mut right = 0.0;
216        if input.held_keys.contains(&KeyCode::KeyD) {
217            right += SPEED * delta_time;
218        }
219        if input.held_keys.contains(&KeyCode::KeyA) {
220            right -= SPEED * delta_time;
221        }
222
223        self.camera.move_by(forward, right);
224
225        let mut up = 0.0;
226        if input.held_keys.contains(&KeyCode::Space) {
227            up += SPEED * delta_time;
228        }
229        if input.held_keys.contains(&KeyCode::ShiftLeft) {
230            up -= SPEED * delta_time;
231        }
232
233        self.camera.move_up(up);
234
235        // Camera rotation
236        const SENSITIVITY: f32 = 0.15;
237
238        let yaw = input.mouse_diff.x * SENSITIVITY * delta_time;
239        let pitch = input.mouse_diff.y * SENSITIVITY * delta_time;
240
241        self.camera.pitch_by(-pitch);
242        self.camera.yaw_by(-yaw);
243
244        // Update the viewer
245        self.viewer.update_camera(
246            &self.queue,
247            &self.camera,
248            uvec2(self.config.width, self.config.height),
249        );
250    }

Source

pub fn get_forward(&self) -> Vec3

Get the forward vector.

Source

pub fn get_right(&self) -> Vec3

Get the right vector.

Trait Implementations§

Source §

impl CameraTrait for Camera

Source §

fn view(&self) -> Mat4

Get the view matrix.

Source §

fn projection(&self, aspect_ratio: f32) -> Mat4

Get the projection matrix.

Source §

impl Clone for Camera

Source §

fn clone(&self) -> Camera

Returns a duplicate of the value. Read more

1.0.0 (const: unstable) · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

Source §

impl Debug for Camera

Source §

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

§

impl UnwindSafe for Camera

Blanket Implementations§

Source §

impl<T> Any for T
where T: 'static + ?Sized,

Source §

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

Source §

impl<T> Borrow<T> for T
where T: ?Sized,

Source §

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

Source §

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source §

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

Source §

impl<T> CloneToUninit for T
where T: Clone,

Source §

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dest. Read more

Source §

impl<T> Downcast<T> for T

Source §

fn downcast(&self) -> &T

Source §

impl<T> From<T> for T

Source §

fn from(t: T) -> T

Returns the argument unchanged.

Source §

impl<T, U> Into for T
where U: From<T>,

Source §

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source §

impl<T> IntoEither for T

Source §

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §

impl<T> ToOwned for T
where T: Clone,

Source §

type Owned = T

The resulting type after obtaining ownership.

Source §

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

Source §

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

Source §

impl<T, U> TryFrom for T
where U: Into<T>,

Source §

type Error = Infallible

The type returned in the event of a conversion error.

Source §

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

Source §

impl<T, U> TryInto for T
where U: TryFrom<T>,

Source §

type Error = >::Error

The type returned in the event of a conversion error.

Source §

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Source §

impl<T> Upcast<T> for T

Source §

fn upcast(&self) -> Option<&T>

Source §

impl<T> WasmNotSend for T
where T: Send,

Source §

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

Source §

Struct Camera Copy item path

Fields§

Implementations§

impl Camera

pub const UP: Vec3 = Vec3::Y

pub const PITCH_LIMIT: Range<f32>

pub fn new(z: Range<f32>, vertical_fov: f32) -> Self

pub fn move_by(&mut self, forward: f32, right: f32)

pub fn move_up(&mut self, up: f32)

pub fn pitch_by(&mut self, delta: f32)

pub fn yaw_by(&mut self, delta: f32)

pub fn get_forward(&self) -> Vec3

pub fn get_right(&self) -> Vec3

Trait Implementations§

impl CameraTrait for Camera

fn view(&self) -> Mat4

fn projection(&self, aspect_ratio: f32) -> Mat4

impl Clone for Camera

fn clone(&self) -> Camera

fn clone_from(&mut self, source: &Self)

impl Debug for Camera

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

Auto Trait Implementations§

impl Freeze for Camera

impl RefUnwindSafe for Camera

impl Send for Camera

impl Sync for Camera

impl Unpin for Camera

impl UnsafeUnpin for Camera

impl UnwindSafe for Camera

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for Twhere T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> Downcast<T> for T

fn downcast(&self) -> &T

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>where F: FnOnce(&Self) -> bool,

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

fn to_owned(&self) -> T

fn clone_into(&self, target: &mut T)

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<T> Upcast<T> for T

fn upcast(&self) -> Option<&T>

impl<T> WasmNotSend for Twhere T: Send,

impl<T> WasmNotSendSync for Twhere T: WasmNotSend + WasmNotSync,

impl<T> WasmNotSync for Twhere T: Sync,

Struct Camera

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<T> ToOwned for T
where T: Clone,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

impl<T> WasmNotSend for T
where T: Send,

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

impl<T> WasmNotSync for T
where T: Sync,