use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::{Rc, Weak};
use crate::core::{ObjectRef as SceneNode, WeakObjectRef};
use crate::math::Matrix4;
use crate::nodes::node::{Type, UniformGroup, UniformSource};
use crate::nodes::tsl::{
float, model_view_matrix, position_local, position_previous, to_const, uniform, vec4_join,
};
use crate::nodes::NodeRef;
use crate::objects::Skeleton;
pub fn velocity() -> NodeRef {
let previous_model_world = uniform(
UniformSource::PreviousModelWorldMatrix,
Type::Mat4,
UniformGroup::Object,
None,
);
let current_projection = uniform(
UniformSource::VelocityProjectionMatrix,
Type::Mat4,
UniformGroup::Render,
None,
);
let previous_projection = uniform(
UniformSource::PreviousProjectionMatrix,
Type::Mat4,
UniformGroup::Render,
None,
);
let previous_camera_view = uniform(
UniformSource::PreviousCameraViewMatrix,
Type::Mat4,
UniformGroup::Render,
None,
);
let previous_model_view = previous_camera_view.mul(previous_model_world);
let clip_current = to_const(
None,
current_projection
.mul(model_view_matrix())
.mul(vec4_join(vec![position_local(), float(1.0)])),
);
let clip_previous = to_const(
None,
previous_projection
.mul(previous_model_view)
.mul(vec4_join(vec![position_previous(), float(1.0)])),
);
let ndc_current = clip_current.xy().div(clip_current.w());
let ndc_previous = clip_previous.xy().div(clip_previous.w());
ndc_current.sub(ndc_previous)
}
#[derive(Clone, Copy, Debug, Default)]
#[doc(hidden)]
pub struct VelocityUniforms {
pub(crate) previous_model_world: Matrix4,
pub(crate) current_projection: Matrix4,
pub(crate) previous_projection: Matrix4,
pub(crate) previous_camera_view: Matrix4,
}
#[derive(Clone, Copy, Debug)]
struct CameraHistory {
frame_id: u64,
previous_projection: Matrix4,
previous_view: Matrix4,
current_projection: Matrix4,
current_view: Matrix4,
}
#[derive(Debug, Default)]
pub struct VelocityState {
objects: HashMap<u32, (WeakObjectRef, Matrix4)>,
cameras: HashMap<u32, (CameraHistory, u64)>,
bones: HashMap<usize, (Weak<RefCell<Skeleton>>, Vec<f32>)>,
projection_override: Option<Matrix4>,
}
impl VelocityState {
pub(crate) fn set_projection_matrix(&mut self, matrix: Option<Matrix4>) {
self.projection_override = matrix;
}
pub(crate) fn update(
&mut self,
frame_id: u64,
object: Option<&SceneNode>,
model_world: Matrix4,
camera_id: u32,
projection: Matrix4,
view: Matrix4,
) -> VelocityUniforms {
let previous_model_world = match object {
Some(node) => {
let id = node.borrow().id;
self.objects
.entry(id)
.or_insert_with(|| (node.downgrade(), model_world))
.1
}
None => model_world,
};
let projection = self.projection_override.unwrap_or(projection);
let (camera, touched) = self.cameras.entry(camera_id).or_insert_with(|| {
(
CameraHistory {
frame_id: frame_id.wrapping_sub(1),
previous_projection: projection,
previous_view: view,
current_projection: projection,
current_view: view,
},
frame_id,
)
});
*touched = frame_id;
if camera.frame_id != frame_id {
camera.frame_id = frame_id;
camera.previous_projection = camera.current_projection;
camera.previous_view = camera.current_view;
camera.current_projection = projection;
camera.current_view = view;
}
VelocityUniforms {
previous_model_world,
current_projection: camera.current_projection,
previous_projection: camera.previous_projection,
previous_camera_view: camera.previous_view,
}
}
pub(crate) fn update_after(&mut self, object: Option<&SceneNode>, model_world: Matrix4) {
if let Some(node) = object {
let id = node.borrow().id;
self.objects
.entry(id)
.or_insert_with(|| (node.downgrade(), model_world))
.1 = model_world;
}
}
pub(crate) fn rotate_bones(&mut self, skeleton: &Rc<RefCell<Skeleton>>) {
if self.bones.is_empty() {
return;
}
let key = Rc::as_ptr(skeleton) as *const u8 as usize;
if let Some((_, previous)) = self.bones.get_mut(&key) {
previous.clone_from(&skeleton.borrow().bone_matrices);
}
}
pub(crate) fn previous_bones(&mut self, skeleton: &Rc<RefCell<Skeleton>>) -> Vec<f32> {
let key = Rc::as_ptr(skeleton) as *const u8 as usize;
self.bones
.entry(key)
.or_insert_with(|| {
(
Rc::downgrade(skeleton),
skeleton.borrow().bone_matrices.clone(),
)
})
.1
.clone()
}
pub(crate) fn sweep(&mut self, frame_id: u64, grace: u64) {
if !self.objects.is_empty() {
self.objects.retain(|_, (node, _)| node.upgrade().is_some());
}
if !self.bones.is_empty() {
self.bones
.retain(|_, (skeleton, _)| skeleton.strong_count() > 0);
}
if !self.cameras.is_empty() {
let cutoff = frame_id.saturating_sub(grace);
self.cameras.retain(|_, (_, touched)| *touched >= cutoff);
}
}
pub fn object_count(&self) -> usize {
self.objects.len()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::core::Object3D;
fn translation(x: f64) -> Matrix4 {
let mut m = Matrix4::identity();
m.elements[12] = x;
m
}
#[test]
fn the_first_frame_is_at_rest_and_the_second_sees_the_move() {
let mut state = VelocityState::default();
let object = Object3D::new_node();
let projection = translation(0.5);
let view = Matrix4::identity();
let first = state.update(1, Some(&object), translation(1.0), 7, projection, view);
assert_eq!(first.previous_model_world, translation(1.0));
assert_eq!(first.previous_projection, projection);
state.update_after(Some(&object), translation(1.0));
let moved_view = translation(-2.0);
let second = state.update(
2,
Some(&object),
translation(3.0),
7,
projection,
moved_view,
);
assert_eq!(second.previous_model_world, translation(1.0));
assert_eq!(second.previous_camera_view, view);
state.update_after(Some(&object), translation(3.0));
let again = state.update(
2,
Some(&object),
translation(3.0),
7,
projection,
moved_view,
);
assert_eq!(again.previous_camera_view, view);
assert_eq!(again.previous_model_world, translation(3.0));
}
#[test]
fn the_projection_override_is_what_the_camera_history_records() {
let mut state = VelocityState::default();
let jittered = translation(0.25);
let unjittered = translation(0.0);
state.set_projection_matrix(Some(unjittered));
let uniforms = state.update(
1,
None,
Matrix4::identity(),
1,
jittered,
Matrix4::identity(),
);
assert_eq!(uniforms.current_projection, unjittered);
assert_eq!(uniforms.previous_projection, unjittered);
}
#[test]
fn a_dropped_object_loses_its_history() {
let mut state = VelocityState::default();
let object = Object3D::new_node();
state.update_after(Some(&object), Matrix4::identity());
assert_eq!(state.object_count(), 1);
drop(object);
state.sweep(10, 4);
assert_eq!(state.object_count(), 0);
}
}