byte-engine 0.1.0

A composable Rust game engine focused on graphics, input, audio, physics, and retained UI.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use core::task;
use std::{ops::Deref, sync::Arc};

use downcast_rs::Downcast;
use utils::{
	hash::{HashMap, HashMapExt as _},
	sync::Mutex,
};

use super::{Entity, EntityHandle};
use crate::time::MediaTime;

pub enum Interval {
	Time(MediaTime),
	Frames(u32),
}

impl Interval {
	pub fn is_now(&self, elapsed_time: MediaTime, dt: MediaTime, frame: u64) -> bool {
		match self {
			Interval::Time(duration) => {
				let period = duration.as_ticks();
				period == 0 || elapsed_time.as_ticks().rem_euclid(period) < dt.as_ticks()
			}
			Interval::Frames(frames) => *frames == 0 || frame.is_multiple_of(*frames as u64),
		}
	}
}

#[cfg(test)]
mod tests {
	use super::{Interval, Task};
	use crate::time::MediaTime;

	#[test]
	fn frame_intervals_fire_only_on_multiples_including_wrap_origin() {
		let interval = Interval::Frames(3);
		let fired: Vec<_> = (0..10)
			.filter(|frame| interval.is_now(MediaTime::ZERO, MediaTime::ZERO, *frame))
			.collect();

		assert_eq!(fired, [0, 3, 6, 9]);
	}

	#[test]
	fn time_intervals_fire_during_the_frame_that_crosses_each_boundary() {
		let interval = Interval::Time(MediaTime::from_millis(100));
		assert!(interval.is_now(MediaTime::from_millis(200), MediaTime::from_millis(16), 0));
		assert!(interval.is_now(MediaTime::from_millis(305), MediaTime::from_millis(16), 0));
		assert!(!interval.is_now(MediaTime::from_millis(350), MediaTime::from_millis(16), 0));
	}

	#[test]
	fn zero_intervals_are_well_defined_as_every_tick() {
		assert!(Interval::Frames(0).is_now(MediaTime::ZERO, MediaTime::ZERO, 17));
		assert!(Interval::Time(MediaTime::ZERO).is_now(MediaTime::from_seconds(1), MediaTime::ZERO, 17));
	}

	#[test]
	fn task_constructors_encode_distinct_scheduling_contracts() {
		let tick = Task::tick(|| {});
		assert!(tick.every.is_none() && tick.lifetime.is_none() && tick.delay.is_none());

		let every = Task::every(2u32, || {});
		assert!(matches!(every.every, Some(Interval::Frames(2))));
		assert!(every.lifetime.is_none() && every.delay.is_none());

		let once = Task::once(|| {});
		assert!(matches!(once.lifetime, Some(Interval::Frames(1))));

		let delayed = Task::r#in(MediaTime::from_millis(10), || {});
		assert!(matches!(delayed.delay, Some(Interval::Time(duration)) if duration == MediaTime::from_millis(10)));
	}
}

impl From<MediaTime> for Interval {
	fn from(val: MediaTime) -> Self {
		Interval::Time(val)
	}
}

impl From<u32> for Interval {
	fn from(val: u32) -> Self {
		Interval::Frames(val)
	}
}

/// The `Task` struct packages a unit of work for engine execution.
pub struct Task {
	f: Box<dyn FnMut()>,
	every: Option<Interval>,
	lifetime: Option<Interval>,
	delay: Option<Interval>,
}

impl Task {
	/// Creates a task from the provided work item.
	pub fn new(f: impl Fn() + 'static) -> Self {
		Task {
			f: Box::new(f),
			every: None,
			lifetime: None,
			delay: None,
		}
	}

	pub fn tick(f: impl Fn() + 'static) -> Self {
		Self::new(f)
	}

	pub fn every(interval: impl Into<Interval>, f: impl Fn() + 'static) -> Self {
		Self {
			f: Box::new(f),
			every: Some(interval.into()),
			lifetime: None,
			delay: None,
		}
	}

	pub fn once(f: impl Fn() + 'static) -> Self {
		Self {
			f: Box::new(f),
			every: None,
			lifetime: Some(Interval::Frames(1)),
			delay: None,
		}
	}

	pub fn r#in(interval: impl Into<Interval>, f: impl Fn() + 'static) -> Self {
		Self {
			f: Box::new(f),
			every: None,
			lifetime: None,
			delay: Some(interval.into()),
		}
	}
}