use crate::{
camera::Camera3D,
collision::{Aabb3, Body3D},
input::{Action, Input, InputView},
};
use glam::{Vec2, Vec3};
use std::fmt;
#[derive(Clone, Copy, Debug)]
pub struct FirstPersonActions {
pub left: Action,
pub right: Action,
pub forward: Action,
pub back: Action,
pub jump: Action,
pub sprint: Option<Action>,
pub turn_left: Option<Action>,
pub turn_right: Option<Action>,
}
#[derive(Clone, Copy, Debug, Default)]
pub struct FirstPersonInput {
pub movement: Vec2,
pub look_delta: Vec2,
pub turn_axis: f32,
pub sprint: bool,
pub jump_pressed: bool,
}
impl FirstPersonInput {
pub fn from_actions(input: &Input, actions: FirstPersonActions) -> Self {
Self::from_view(input.routed(&[], false), actions)
}
pub fn from_view(input: InputView<'_>, actions: FirstPersonActions) -> Self {
Self {
movement: Vec2::new(
input.axis(actions.left, actions.right),
input.axis(actions.forward, actions.back),
),
look_delta: input.pointer_delta(),
turn_axis: f32::from(actions.turn_right.is_some_and(|a| input.down(a)))
- f32::from(actions.turn_left.is_some_and(|a| input.down(a))),
sprint: actions.sprint.is_some_and(|a| input.down(a)),
jump_pressed: input.pressed(actions.jump),
}
}
}
#[derive(Clone, Copy, Debug)]
pub struct FirstPersonConfig {
pub walk_speed: f32,
pub sprint_speed: f32,
pub response: f32,
pub jump_speed: f32,
pub gravity: f32,
pub max_fall_speed: f32,
pub mouse_sensitivity: f32,
pub keyboard_turn_speed: f32,
pub min_pitch: f32,
pub max_pitch: f32,
pub eye_offset: Vec3,
pub vertical_fov: f32,
pub coyote_time: f32,
pub jump_buffer_time: f32,
}
impl Default for FirstPersonConfig {
fn default() -> Self {
Self {
walk_speed: 6.0,
sprint_speed: 10.0,
response: 18.0,
jump_speed: 11.0,
gravity: 26.0,
max_fall_speed: 40.0,
mouse_sensitivity: 0.0025,
keyboard_turn_speed: 1.8,
min_pitch: -std::f32::consts::FRAC_PI_2 + 0.05,
max_pitch: std::f32::consts::FRAC_PI_2 - 0.05,
eye_offset: Vec3::new(0.0, 0.7, 0.0),
vertical_fov: 75.0,
coyote_time: 0.1,
jump_buffer_time: 0.12,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct FirstPersonError(pub &'static str);
impl fmt::Display for FirstPersonError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.0)
}
}
impl std::error::Error for FirstPersonError {}
impl FirstPersonConfig {
pub fn validate(&self) -> Result<(), FirstPersonError> {
let nonnegative = [
self.walk_speed,
self.sprint_speed,
self.response,
self.jump_speed,
self.mouse_sensitivity,
self.keyboard_turn_speed,
self.coyote_time,
self.jump_buffer_time,
];
if nonnegative.into_iter().any(|v| !v.is_finite() || v < 0.0) {
return Err(FirstPersonError(
"speeds, response, sensitivity and grace times must be finite and nonnegative",
));
}
if !self.gravity.is_finite()
|| self.gravity <= 0.0
|| !self.max_fall_speed.is_finite()
|| self.max_fall_speed <= 0.0
{
return Err(FirstPersonError(
"gravity and maximum falling speed must be finite and positive",
));
}
if !self.min_pitch.is_finite()
|| !self.max_pitch.is_finite()
|| self.min_pitch <= -std::f32::consts::FRAC_PI_2
|| self.max_pitch >= std::f32::consts::FRAC_PI_2
|| self.min_pitch > self.max_pitch
{
return Err(FirstPersonError(
"pitch limits must be ordered and strictly inside (-PI/2, PI/2)",
));
}
if !self.eye_offset.is_finite()
|| !self.vertical_fov.is_finite()
|| !(0.0..180.0).contains(&self.vertical_fov)
|| self.vertical_fov == 0.0
{
return Err(FirstPersonError(
"eye offset must be finite and vertical FOV must be in (0, 180)",
));
}
Ok(())
}
}
#[derive(Clone, Copy, Debug)]
pub struct FirstPersonController {
pub body: Body3D,
pub previous: Vec3,
config: FirstPersonConfig,
yaw: f32,
pitch: f32,
coyote: f32,
jump_buffer: f32,
}
impl FirstPersonController {
pub fn new(
position: Vec3,
size: Vec3,
config: FirstPersonConfig,
) -> Result<Self, FirstPersonError> {
config.validate()?;
if !position.is_finite() || !size.is_finite() || size.min_element() <= 0.0 {
return Err(FirstPersonError(
"body position must be finite and dimensions finite and positive",
));
}
let body = Body3D::new(position, size);
if !valid_bounds(body.position, body.half_size) {
return Err(FirstPersonError(
"body bounds must retain finite positive extent at the chosen coordinates",
));
}
Ok(Self {
body,
previous: position,
config,
yaw: 0.0,
pitch: 0.0_f32.clamp(config.min_pitch, config.max_pitch),
coyote: 0.0,
jump_buffer: 0.0,
})
}
pub fn config(&self) -> &FirstPersonConfig {
&self.config
}
pub fn set_config(&mut self, config: FirstPersonConfig) -> Result<(), FirstPersonError> {
config.validate()?;
self.config = config;
self.pitch = self.pitch.clamp(config.min_pitch, config.max_pitch);
self.coyote = 0.0;
self.jump_buffer = 0.0;
Ok(())
}
pub fn yaw(&self) -> f32 {
self.yaw
}
pub fn pitch(&self) -> f32 {
self.pitch
}
pub fn set_look(&mut self, yaw: f32, pitch: f32) -> Result<(), FirstPersonError> {
if !yaw.is_finite() || !pitch.is_finite() {
return Err(FirstPersonError("look angles must be finite"));
}
self.yaw = wrap_yaw(f64::from(yaw));
self.pitch = pitch.clamp(self.config.min_pitch, self.config.max_pitch);
Ok(())
}
pub fn teleport(&mut self, position: Vec3) -> Result<(), FirstPersonError> {
if !valid_bounds(position, self.body.half_size) {
return Err(FirstPersonError(
"teleport bounds must retain finite positive extent",
));
}
self.body.position = position;
self.previous = position;
self.body.velocity = Vec3::ZERO;
self.body.grounded = false;
self.coyote = 0.0;
self.jump_buffer = 0.0;
Ok(())
}
pub fn step(&mut self, input: FirstPersonInput, dt: f32, solids: &[Aabb3]) {
assert!(dt.is_finite() && dt >= 0.0);
assert!(
input.movement.is_finite()
&& input.movement.abs().max_element() <= 1.0
&& input.look_delta.is_finite()
&& input.turn_axis.is_finite()
&& input.turn_axis.abs() <= 1.0
);
let turn = f64::from(input.look_delta.x) * f64::from(self.config.mouse_sensitivity)
+ f64::from(input.turn_axis)
* f64::from(dt)
* f64::from(self.config.keyboard_turn_speed);
if turn != 0.0 {
self.yaw = wrap_yaw(f64::from(self.yaw) + turn);
}
self.pitch = (f64::from(self.pitch)
- f64::from(input.look_delta.y) * f64::from(self.config.mouse_sensitivity))
.clamp(
f64::from(self.config.min_pitch),
f64::from(self.config.max_pitch),
) as f32;
if dt == 0.0 {
return;
}
self.previous = self.body.position;
let axis = input.movement.clamp_length_max(1.0);
let (sin, cos) = self.yaw.sin_cos();
let movement = Vec3::new(
axis.x * cos - axis.y * sin,
0.0,
axis.x * sin + axis.y * cos,
);
let speed = if input.sprint {
self.config.sprint_speed
} else {
self.config.walk_speed
};
let blend = if self.config.response == 0.0 {
1.0
} else {
-(-self.config.response * dt).exp_m1()
};
self.body.velocity.x += (movement.x * speed - self.body.velocity.x) * blend;
self.body.velocity.z += (movement.z * speed - self.body.velocity.z) * blend;
self.coyote = if self.body.grounded {
self.config.coyote_time
} else {
(self.coyote - dt).max(0.0)
};
self.jump_buffer = if input.jump_pressed {
self.config.jump_buffer_time
} else {
(self.jump_buffer - dt).max(0.0)
};
if (self.body.grounded || self.coyote > 0.0)
&& (input.jump_pressed || self.jump_buffer > 0.0)
{
self.body.velocity.y = self.config.jump_speed;
self.body.grounded = false;
self.coyote = 0.0;
self.jump_buffer = 0.0;
}
self.body.velocity.y =
(self.body.velocity.y - self.config.gravity * dt).max(-self.config.max_fall_speed);
self.body.move_and_slide(dt, solids);
}
pub fn camera(&self, alpha: f32) -> Camera3D {
assert!(alpha.is_finite() && (0.0..=1.0).contains(&alpha));
let position = self.previous.lerp(self.body.position, alpha) + self.config.eye_offset;
let (sin_yaw, cos_yaw) = self.yaw.sin_cos();
let (sin_pitch, cos_pitch) = self.pitch.sin_cos();
Camera3D {
position,
target: position + Vec3::new(sin_yaw * cos_pitch, sin_pitch, -cos_yaw * cos_pitch),
up: Vec3::new(-sin_yaw * sin_pitch, cos_pitch, cos_yaw * sin_pitch),
vertical_fov: self.config.vertical_fov,
}
}
}
fn wrap_yaw(yaw: f64) -> f32 {
((yaw + std::f64::consts::PI).rem_euclid(std::f64::consts::TAU) - std::f64::consts::PI) as f32
}
fn valid_bounds(position: Vec3, half_size: Vec3) -> bool {
let (min, max) = (position - half_size, position + half_size);
min.is_finite() && max.is_finite() && min.cmplt(max).all()
}
#[cfg(test)]
mod tests;