use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::{Rc, Weak};
use crate::renderer::Renderer;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum NodeUpdateType {
#[default]
None,
Frame,
Render,
Object,
}
pub trait NodeUpdate {
fn update_before_type(&self) -> NodeUpdateType {
NodeUpdateType::None
}
fn update_type(&self) -> NodeUpdateType {
NodeUpdateType::None
}
fn update_after_type(&self) -> NodeUpdateType {
NodeUpdateType::None
}
fn update_before(&self, _renderer: &mut Renderer) -> bool {
true
}
fn update(&self, _renderer: &mut Renderer) -> bool {
true
}
fn update_after(&self, _renderer: &mut Renderer) -> bool {
true
}
fn sync_before_build(&self, _samples: u32) {}
}
#[derive(Clone)]
pub(crate) struct UpdateNode {
pub(crate) reference: usize,
pub(crate) node: Rc<dyn NodeUpdate>,
}
impl UpdateNode {
pub fn new<T: NodeUpdate + 'static>(node: Rc<T>) -> Self {
Self {
reference: Rc::as_ptr(&node) as *const u8 as usize,
node,
}
}
pub(crate) fn with_reference(reference: usize, node: Rc<dyn NodeUpdate>) -> Self {
Self { reference, node }
}
}
impl std::fmt::Debug for UpdateNode {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_tuple("UpdateNode")
.field(&(self.reference as *const u8))
.finish()
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(crate) enum UpdatePhase {
Before,
Update,
After,
}
#[derive(Clone, Copy, Debug, Default)]
struct Stamp {
frame_id: u64,
render_id: u64,
touched: u64,
}
#[must_use]
#[derive(Debug)]
pub(crate) struct Claim {
phase: UpdatePhase,
reference: usize,
ty: NodeUpdateType,
previous: Stamp,
}
#[derive(Debug, Default)]
pub struct NodeFrameState {
pub frame_id: u64,
pub render_id: u64,
pub time: f64,
pub delta_time: f64,
last_time: Option<f64>,
renders: u64,
open: bool,
maps: HashMap<(UpdatePhase, usize), Stamp>,
}
impl NodeFrameState {
pub fn update(&mut self, now: f64) {
self.frame_id += 1;
let last = *self.last_time.get_or_insert(now);
self.delta_time = (now - last) / 1000.0;
self.time += self.delta_time;
self.last_time = Some(now);
}
pub(crate) fn begin_render(&mut self, now: f64) -> u64 {
self.open(now);
self.renders += 1;
std::mem::replace(&mut self.render_id, self.renders)
}
pub(crate) fn open(&mut self, now: f64) {
if !self.open {
self.update(now);
self.open = true;
}
}
pub(crate) fn end_render(&mut self, previous_render_id: u64, to_screen: bool) {
self.render_id = previous_render_id;
if to_screen {
self.open = false;
}
}
pub(crate) fn claim(
&mut self,
phase: UpdatePhase,
reference: usize,
ty: NodeUpdateType,
) -> Option<Claim> {
let (frame_id, render_id) = (self.frame_id, self.render_id);
let stamp = self.maps.entry((phase, reference)).or_default();
stamp.touched = frame_id;
let previous = *stamp;
match ty {
NodeUpdateType::None => return None,
NodeUpdateType::Frame if stamp.frame_id == frame_id => return None,
NodeUpdateType::Render if stamp.render_id == render_id => return None,
NodeUpdateType::Frame if phase == UpdatePhase::Before => stamp.frame_id = frame_id,
NodeUpdateType::Render if phase == UpdatePhase::Before => stamp.render_id = render_id,
_ => {}
}
Some(Claim {
phase,
reference,
ty,
previous,
})
}
pub(crate) fn settle(&mut self, claim: Claim, counted: bool) {
let (frame_id, render_id) = (self.frame_id, self.render_id);
let Some(stamp) = self.maps.get_mut(&(claim.phase, claim.reference)) else {
return;
};
match (claim.phase, counted) {
(UpdatePhase::Before, false) => *stamp = claim.previous,
(UpdatePhase::Before, true) => {}
(_, false) => {}
(_, true) => match claim.ty {
NodeUpdateType::Frame => stamp.frame_id = frame_id,
NodeUpdateType::Render => stamp.render_id = render_id,
NodeUpdateType::None | NodeUpdateType::Object => {}
},
}
}
pub(crate) fn sweep(&mut self, grace: u64) {
let cutoff = self.frame_id.saturating_sub(grace);
self.maps.retain(|_, stamp| stamp.touched >= cutoff);
}
}
type TextureUpdate = (usize, Weak<dyn NodeUpdate>);
thread_local! {
static TEXTURE_UPDATES: RefCell<HashMap<usize, TextureUpdate>> =
RefCell::new(HashMap::new());
}
pub(crate) fn register_texture_update<T: NodeUpdate + 'static>(texture_id: usize, node: &Rc<T>) {
let reference = Rc::as_ptr(node) as *const u8 as usize;
let node: Rc<dyn NodeUpdate> = node.clone();
let weak = Rc::downgrade(&node);
TEXTURE_UPDATES.with(|map| {
let mut map = map.borrow_mut();
map.retain(|_, (_, weak)| weak.strong_count() > 0);
map.insert(texture_id, (reference, weak));
});
}
pub(crate) fn texture_update(texture_id: usize) -> Option<UpdateNode> {
TEXTURE_UPDATES.with(|map| {
let (reference, weak) = map.borrow().get(&texture_id)?.clone();
Some(UpdateNode::with_reference(reference, weak.upgrade()?))
})
}
pub(crate) fn sync_before_build(samples: u32) {
TEXTURE_UPDATES.with(|map| {
for (_, weak) in map.borrow().values() {
if let Some(node) = weak.upgrade() {
node.sync_before_build(samples);
}
}
});
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn two_frames_run_the_phases_in_order_behind_their_guards() {
let mut frame = NodeFrameState::default();
let mut log: Vec<(u64, u64, &str)> = Vec::new();
let nodes = [
(1usize, NodeUpdateType::Frame, "frame"),
(2, NodeUpdateType::Render, "render"),
(3, NodeUpdateType::Object, "object"),
];
for _frame in 0..2 {
for render in 0..2 {
let to_screen = render == 1;
let previous = frame.begin_render(0.0);
for _draw in 0..2 {
for (phase, name) in [
(UpdatePhase::Before, "before"),
(UpdatePhase::Update, "update"),
] {
for (reference, ty, kind) in nodes {
if let Some(claim) = frame.claim(phase, reference, ty) {
log.push((frame.frame_id, frame.render_id, name));
log.push((frame.frame_id, frame.render_id, kind));
frame.settle(claim, true);
}
}
}
log.push((frame.frame_id, frame.render_id, "draw"));
for (reference, ty, kind) in nodes {
if let Some(claim) = frame.claim(UpdatePhase::After, reference, ty) {
log.push((frame.frame_id, frame.render_id, "after"));
log.push((frame.frame_id, frame.render_id, kind));
frame.settle(claim, true);
}
}
}
frame.end_render(previous, to_screen);
}
}
let count = |f: u64, what: &str, kind: &str| {
log.windows(2)
.filter(|w| w[0].0 == f && w[0].2 == what && w[1].2 == kind)
.count()
};
for f in [1, 2] {
for what in ["before", "update", "after"] {
assert_eq!(count(f, what, "frame"), 1, "{what} FRAME in frame {f}");
assert_eq!(count(f, what, "render"), 2, "{what} RENDER in frame {f}");
assert_eq!(count(f, what, "object"), 4, "{what} OBJECT in frame {f}");
}
}
assert_eq!(frame.frame_id, 2);
let first: Vec<&str> = log
.iter()
.take_while(|entry| entry.2 != "draw")
.map(|entry| entry.2)
.collect();
assert_eq!(
first,
[
"before", "frame", "before", "render", "before", "object", "update", "frame",
"update", "render", "update", "object"
]
);
let after_draw = log.iter().position(|e| e.2 == "draw").unwrap();
assert_eq!(log[after_draw + 1].2, "after");
}
#[test]
fn a_phase_that_does_not_count_runs_again() {
let mut frame = NodeFrameState::default();
let previous = frame.begin_render(0.0);
let claim = frame
.claim(UpdatePhase::Before, 7, NodeUpdateType::Frame)
.expect("first claim");
assert!(frame
.claim(UpdatePhase::Before, 7, NodeUpdateType::Frame)
.is_none());
frame.settle(claim, false);
let claim = frame
.claim(UpdatePhase::Before, 7, NodeUpdateType::Frame)
.expect("runs again after a false");
frame.settle(claim, true);
assert!(frame
.claim(UpdatePhase::Before, 7, NodeUpdateType::Frame)
.is_none());
let claim = frame
.claim(UpdatePhase::After, 8, NodeUpdateType::Frame)
.unwrap();
frame.settle(claim, false);
assert!(frame
.claim(UpdatePhase::After, 8, NodeUpdateType::Frame)
.is_some());
frame.end_render(previous, true);
}
#[test]
fn a_nested_render_restores_the_render_id() {
let mut frame = NodeFrameState::default();
let outer = frame.begin_render(0.0);
let outer_id = frame.render_id;
let inner = frame.begin_render(0.0);
assert_ne!(frame.render_id, outer_id);
frame.end_render(inner, false);
assert_eq!(frame.render_id, outer_id);
frame.end_render(outer, true);
assert_eq!(frame.frame_id, 1);
}
}