use glam::{DMat4, DVec3, Mat4, Vec3};
#[derive(Clone, Copy, Debug, PartialEq)]
pub(crate) struct CameraFrame {
pub view: Mat4,
pub projection: Mat4,
pub jitter: [f32; 2],
}
impl CameraFrame {
pub fn jittered_projection(&self) -> Mat4 {
Mat4::from_translation(Vec3::new(self.jitter[0], self.jitter[1], 0.)) * self.projection
}
pub fn jittered_view_projection(&self) -> Mat4 {
self.jittered_projection() * self.view
}
fn translated(self, by: DVec3) -> Self {
if by == DVec3::ZERO {
return self;
}
Self {
view: (self.view.as_dmat4() * DMat4::from_translation(by)).as_mat4(),
..self
}
}
}
#[derive(Clone, Copy)]
pub(crate) struct HistoryFrame {
pub stable: Mat4,
pub previous: Mat4,
pub previous_camera: Option<CameraFrame>,
pub valid: bool,
pub frames: u32,
pub camera: CameraFrame,
pub origin: DVec3,
pub elapsed_seconds: f64,
pub previous_elapsed_seconds: f64,
}
#[derive(Clone, Copy, Default)]
pub(crate) struct StageHistory {
pub count: u32,
pub current: usize,
}
impl StageHistory {
pub fn advance(&mut self) {
self.count = self.count.wrapping_add(1).max(1);
self.current = 1 - self.current;
}
}
#[derive(Default)]
pub(crate) struct CameraHistory {
previous: Option<CameraFrame>,
frames: u32,
origin: DVec3,
elapsed_seconds: f64,
}
impl CameraHistory {
pub fn begin(
&self,
camera: CameraFrame,
reset: bool,
origin: DVec3,
elapsed_seconds: f64,
) -> HistoryFrame {
let (previous, frames) = if reset {
(None, 0)
} else {
(
self.previous
.map(|previous| previous.translated(origin - self.origin)),
self.frames,
)
};
let stable = camera.projection * camera.view;
HistoryFrame {
stable,
previous: previous.map_or(stable, |previous| previous.projection * previous.view),
previous_camera: previous,
valid: previous.is_some(),
frames,
camera,
origin,
elapsed_seconds,
previous_elapsed_seconds: if previous.is_some() {
self.elapsed_seconds
} else {
elapsed_seconds
},
}
}
pub fn finish(&mut self, frame: HistoryFrame) {
self.previous = Some(frame.camera);
self.frames = frame.frames.wrapping_add(1);
self.origin = frame.origin;
self.elapsed_seconds = frame.elapsed_seconds;
}
}
#[cfg(test)]
mod tests {
use super::*;
use glam::Vec4;
use wasm_bindgen_test::wasm_bindgen_test;
#[wasm_bindgen_test(unsupported = test)]
fn a_moved_origin_reprojects_the_same_world_point() {
let projection = crate::perspective(1.1, 1.5, 0.1);
let eye = Vec3::new(5003.25, 12.5, -7020.75);
let camera = |eye: Vec3| CameraFrame {
view: glam::camera::rh::view::look_at_mat4(
eye,
eye + Vec3::new(1., -0.2, -1.),
Vec3::Y,
),
projection,
jitter: [0.25, -0.5],
};
let mut history = CameraHistory::default();
let first = history.begin(camera(eye), false, DVec3::ZERO, 0.);
history.finish(first);
let moved = Vec3::new(5000., 0., -7000.);
let point = Vec3::new(5010.5, 11., -7031.);
let before = first.camera.jittered_view_projection() * point.extend(1.);
for _ in 0..2 {
let frame = history.begin(camera(eye - moved), false, moved.as_dvec3(), 0.);
let previous = frame.previous_camera.expect("history continues");
let after = previous.jittered_view_projection() * (point - moved).extend(1.);
let ndc = |clip: Vec4| clip.truncate() / clip.w;
assert!(
(ndc(before) - ndc(after)).abs().max_element() < 1e-4,
"{:?} became {:?}",
ndc(before),
ndc(after)
);
assert_eq!(previous.jitter, first.camera.jitter);
}
let reset = history.begin(camera(eye - moved), true, moved.as_dvec3(), 0.);
assert!(reset.previous_camera.is_none() && !reset.valid);
}
#[wasm_bindgen_test(unsupported = test)]
fn consecutive_frames_continue_across_the_frame_count_s_wrap() {
let camera = CameraFrame {
view: Mat4::IDENTITY,
projection: crate::perspective(1.1, 1.5, 0.1),
jitter: [0.; 2],
};
let mut history = CameraHistory {
frames: u32::MAX - 1,
..CameraHistory::default()
};
let mut last = None;
for _ in 0..4 {
let frame = history.begin(camera, false, DVec3::ZERO, 0.);
if let Some(last) = last {
assert_eq!(frame.frames, u32::wrapping_add(last, 1));
}
last = Some(frame.frames);
history.finish(frame);
}
}
#[wasm_bindgen_test(unsupported = test)]
fn the_history_halves_alternate_across_the_frame_count_s_wrap() {
let mut frame = StageHistory {
count: u32::MAX - 2,
current: 1,
};
let mut written = vec![frame.current];
for _ in 0..6 {
frame.advance();
assert_ne!(frame.count, 0, "only a restart sets the count to 0");
written.push(frame.current);
}
for pair in written.windows(2) {
assert_ne!(
pair[0], pair[1],
"consecutive frames wrote one half: {written:?}"
);
}
}
}