flow_ngin/

camera.rs

use cgmath::num_traits::ToPrimitive;
use cgmath::*;
use core::f32;
use std::f32::consts::FRAC_PI_2;
use std::time::Duration;
use winit::event::*;
use winit::keyboard::KeyCode;
use winit::{dpi::PhysicalPosition, keyboard::PhysicalKey};

#[rustfmt::skip]
pub const OPENGL_TO_WGPU_MATRIX: cgmath::Matrix4<f32> = cgmath::Matrix4::from_cols(
    cgmath::Vector4::new(1.0, 0.0, 0.0, 0.0),
    cgmath::Vector4::new(0.0, 1.0, 0.0, 0.0),
    cgmath::Vector4::new(0.0, 0.0, 0.5, 0.0),
    cgmath::Vector4::new(0.0, 0.0, 0.5, 1.0),
);

const SAFE_FRAC_PI_2: f32 = FRAC_PI_2 - 0.0001;

fn screen_to_ndc(mouse_x: f32, mouse_y: f32, width: f32, height: f32) -> cgmath::Vector3<f32> {
    let x = (2.0 * mouse_x / width) - 1.0;
    let y = 1.0 - (2.0 * mouse_y) / height; // y is flipped
    let z = 1.0;
    Vector3::new(x, y, z)
}

#[derive(Debug)]
pub struct Ray {
    pub origin: Point3<f32>,
    pub direction: Vector3<f32>,
}

// TODO: calculate intersection with depth buffer elem aswell for a picking alternative
impl Ray {
    /**
     * Calculates the intersection of the ray `self` with the floor (y = 0.0).
     *
     * Returns None if the ray is not pointed towards the floor.
     */
    pub fn intersect_with_floor(&self) -> Option<Point2<f32>> {
        if self.direction.y.abs() < f32::EPSILON {
            return None;
        }
        let t = -self.origin.y / self.direction.y;
        if t < 0.0 {
            return None;
        }
        let intersection_point = self.origin + self.direction * t;
        Some(Point2::new(intersection_point.x, intersection_point.z))
    }
}

#[repr(C)]
#[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
pub struct CameraUniform {
    view_position: [f32; 4],
    view_proj: [[f32; 4]; 4],
}

impl CameraUniform {
    pub fn new() -> Self {
        Self {
            view_position: [0.0; 4],
            view_proj: cgmath::Matrix4::identity().into(),
        }
    }

    pub fn update_view_proj(&mut self, camera: &Camera, projection: &Projection) {
        self.view_position = camera.position.to_homogeneous().into();
        self.view_proj = (projection.calc_matrix() * camera.calc_matrix()).into();
    }
}

#[derive(Debug, Clone)]
pub struct Camera {
    pub position: Point3<f32>,
    yaw: Rad<f32>,
    pitch: Rad<f32>,
}

impl Camera {
    pub fn new<V: Into<Point3<f32>>, Y: Into<Rad<f32>>, P: Into<Rad<f32>>>(
        position: V,
        yaw: Y,
        pitch: P,
    ) -> Self {
        Self {
            position: position.into(),
            yaw: yaw.into(),
            pitch: pitch.into(),
        }
    }

    pub fn calc_matrix(&self) -> Matrix4<f32> {
        let (sin_pitch, cos_pitch) = self.pitch.0.sin_cos();
        let (sin_yaw, cos_yaw) = self.yaw.0.sin_cos();

        Matrix4::look_to_rh(
            self.position,
            Vector3::new(cos_pitch * cos_yaw, sin_pitch, cos_pitch * sin_yaw).normalize(),
            Vector3::unit_y(),
        )
    }

    /**
     * This method casts a ray from the location of the mouse pointer using the camera's FOV and view.
     */
    pub fn cast_ray_from_mouse(
        &self,
        position: PhysicalPosition<f64>,
        width: f32,
        height: f32,
        projection: &Projection,
    ) -> Ray {
        let (mouse_x, mouse_y) = position.into();
        let ndc = screen_to_ndc(mouse_x, mouse_y, width, height);

        let clip = cgmath::Vector4::new(ndc.x, ndc.y, 1.0, 1.0);

        let inv_proj_view = (projection.calc_matrix() * self.calc_matrix())
            .invert()
            .unwrap();

        let mut world_coords = inv_proj_view * clip;

        world_coords /= world_coords.w;
        // TODO: does it make sense to use Point3 or should I stay with Vector3?
        let world_point = Point3::new(world_coords.x, world_coords.y, world_coords.z);

        let ray_origin = self.position;
        let ray_direction = (world_point - ray_origin).normalize();

        Ray {
            origin: ray_origin,
            direction: ray_direction,
        }
    }
}

#[derive(Debug)]
pub struct Projection {
    aspect: f32,
    fovy: Rad<f32>,
    pub znear: f32,
    pub zfar: f32,
}

impl Projection {
    pub fn new<F: Into<Rad<f32>>>(
        width: u32,
        height: u32,
        fovy: F,
        znear: f32,
        zfar: f32,
    ) -> Result<Self, anyhow::Error> {
        let width = width.to_f32().ok_or(anyhow::anyhow!(
            "Width value {} is too large to be represented as f32.",
            width
        ))?;
        let height = height.to_f32().ok_or(
            anyhow::anyhow!(
                "Height value {} is too large to be represented as f32.",
                height
            )
        )?;
        let aspect = width / height;
        Ok(Self {
            aspect,
            fovy: fovy.into(),
            znear,
            zfar,
        })
    }

    pub fn resize(&mut self, width: u32, height: u32) {
        let width = width.to_f32().unwrap_or(f32::MAX);
        let height = height.to_f32().unwrap_or(f32::MAX);
        self.aspect = width as f32 / height as f32;
    }

    pub fn calc_matrix(&self) -> Matrix4<f32> {
        OPENGL_TO_WGPU_MATRIX * perspective(self.fovy, self.aspect, self.znear, self.zfar)
    }
}

#[derive(Debug, Clone)]
pub struct CameraController {
    amount_left: f32,
    amount_right: f32,
    amount_forward: f32,
    amount_backward: f32,
    amount_up: f32,
    amount_down: f32,
    rotate_horizontal: f32,
    rotate_vertical: f32,
    scroll: f32,
    speed: f32,
    sensitivity: f32,
}

impl CameraController {
    pub fn new(speed: f32, sensitivity: f32) -> Self {
        Self {
            amount_left: 0.0,
            amount_right: 0.0,
            amount_forward: 0.0,
            amount_backward: 0.0,
            amount_up: 0.0,
            amount_down: 0.0,
            rotate_horizontal: 0.0,
            rotate_vertical: 0.0,
            scroll: 0.0,
            speed,
            sensitivity,
        }
    }

    pub fn handle_window_events(&mut self, event: &WindowEvent) -> bool {
        if let WindowEvent::KeyboardInput {
            event:
                KeyEvent {
                    physical_key: PhysicalKey::Code(key),
                    state: key_state,
                    ..
                },
            ..
        } = event
        {
            let amount = if key_state.is_pressed() { 1.0 } else { 0.0 };
            match key {
                KeyCode::KeyW | KeyCode::ArrowUp => {
                    self.amount_forward = amount;
                    true
                }
                KeyCode::KeyS | KeyCode::ArrowDown => {
                    self.amount_backward = amount;
                    true
                }
                KeyCode::KeyA | KeyCode::ArrowLeft => {
                    self.amount_left = amount;
                    true
                }
                KeyCode::KeyD | KeyCode::ArrowRight => {
                    self.amount_right = amount;
                    true
                }
                KeyCode::Space => {
                    self.amount_up = amount;
                    true
                }
                KeyCode::ShiftLeft => {
                    self.amount_down = amount;
                    true
                }
                _ => false,
            }
        } else {
            false
        }
    }

    pub fn handle_mouse(&mut self, mouse_dx: f64, mouse_dy: f64) {
        let dx = mouse_dx as f32;
        let dy = mouse_dy as f32;
        // handle f32 to f64 conversion without panicing:
        if dx.is_finite() && dy.is_finite() {
            self.rotate_horizontal = dx;
            self.rotate_vertical = dy;
        } else {
            log::warn!(
                "Mouse coordinates of ({}, {}) are out of bounds and are not updated. The maximum supported coordinate value is {}.",
                mouse_dx,
                mouse_dy,
                f32::MAX
            );
        }
    }

    pub fn handle_scroll(&mut self, delta: &MouseScrollDelta) {
        self.scroll = match delta {
            MouseScrollDelta::LineDelta(_, scroll) => -scroll * 0.5,
            MouseScrollDelta::PixelDelta(PhysicalPosition { y: scroll, .. }) => -*scroll as f32,
        };
    }

    pub fn update(&mut self, camera: &mut Camera, dt: Duration) {
        let dt = dt.as_secs_f32();

        let (yaw_sin, yaw_cos) = camera.yaw.0.sin_cos();
        let forward = Vector3::new(yaw_cos, 0.0, yaw_sin).normalize();
        let right = Vector3::new(-yaw_sin, 0.0, yaw_cos).normalize();
        camera.position += forward * (self.amount_forward - self.amount_backward) * self.speed * dt;
        camera.position += right * (self.amount_right - self.amount_left) * self.speed * dt;

        // Move in/out (aka. "zoom")
        // Note: this isn't an actual zoom. The camera's position
        // changes when zooming. I've added this to make it easier
        // to get closer to an object you want to focus on.
        let (pitch_sin, pitch_cos) = camera.pitch.0.sin_cos();
        let scrollward =
            Vector3::new(pitch_cos * yaw_cos, pitch_sin, pitch_cos * yaw_sin).normalize();
        camera.position += scrollward * self.scroll * self.speed * self.sensitivity * dt;
        self.scroll = 0.0;

        // Move up/down. Since we don't use roll, we can just
        // modify the y coordinate directly.
        camera.position.y += (self.amount_up - self.amount_down) * self.speed * dt;

        // Rotate
        camera.yaw += (Rad(self.rotate_horizontal) * self.speed * self.sensitivity * dt) / 10.0;
        camera.pitch += (Rad(-self.rotate_vertical) * self.speed * self.sensitivity * dt) / 10.0;

        // If process_mouse isn't called every frame, these values
        // will not get set to zero, and the camera will rotate
        // when moving in a non cardinal direction.
        self.rotate_horizontal = 0.0;
        self.rotate_vertical = 0.0;

        // Keep the camera's angle from going too high/low.
        if camera.pitch < -Rad(SAFE_FRAC_PI_2) {
            camera.pitch = -Rad(SAFE_FRAC_PI_2);
        } else if camera.pitch > Rad(SAFE_FRAC_PI_2) {
            camera.pitch = Rad(SAFE_FRAC_PI_2);
        }
    }
}

#[derive(Debug)]
pub struct CameraResources {
    pub camera: Camera,
    pub controller: CameraController,
    pub uniform: CameraUniform,
    pub buffer: wgpu::Buffer,
    pub bind_group: wgpu::BindGroup,
    pub bind_group_layout: wgpu::BindGroupLayout,
}