pub(crate) use crate::viewer::exchange_layer::hook::{UpdateHook, box_hook};
use atomic_float::AtomicF32;
use key_state::{KeyState, KeyStateDirtyMap};
use minifb::{CursorStyle, MouseButton, MouseMode, Window};
use mouse_state::{MouseState, MouseStateDirtyMap};
use scroll_wheel::{ScrollWheel, ScrollWheelAccumulator};
use signal::{
ApplyFlag, ApplySignal, ApplySignalNonAtomic, UpdateFlag, UpdateSignal, UpdateSignalNonAtomic,
};
use std::any::type_name;
use std::sync::Mutex;
use std::sync::atomic::{AtomicBool, AtomicIsize, AtomicU32, AtomicUsize, Ordering};
use std::thread;
use std::time::Duration;
mod hook;
pub mod key_state;
pub mod mouse_state;
mod scroll_wheel;
pub mod signal;
#[derive(Debug, Default)]
pub struct ExchangeLayer {
pub update_signal: UpdateSignal,
pub apply_signal: ApplySignal,
pub window_size: (AtomicUsize, AtomicUsize),
pub window_position: (AtomicIsize, AtomicIsize),
pub title: Mutex<Option<String>>,
pub topmost: AtomicBool,
pub background_color: AtomicU32,
pub cursor_visibility: AtomicBool,
pub target_fps: AtomicUsize,
pub fps: AtomicUsize,
pub mouse_pos: (AtomicF32, AtomicF32),
mouse_state: MouseStateDirtyMap,
pub cursor_style: Mutex<Option<CursorStyle>>,
pub scaled_mouse_pos: (AtomicF32, AtomicF32),
scroll_wheel: ScrollWheelAccumulator,
key_state: KeyStateDirtyMap,
pub is_active: AtomicBool,
pub is_running: AtomicBool,
pub(crate) update_hook: Mutex<Option<UpdateHook>>,
pub(crate) hook_epoch: AtomicUsize,
}
impl ExchangeLayer {
const RETRY_TIMES: usize = 2;
const RETRY_DELAY: Duration = Duration::from_millis(100);
pub fn new() -> ExchangeLayer {
ExchangeLayer {
update_signal: Default::default(),
apply_signal: Default::default(),
window_size: (Default::default(), Default::default()),
window_position: (Default::default(), Default::default()),
title: Mutex::new(None),
topmost: Default::default(),
background_color: Default::default(),
cursor_visibility: AtomicBool::new(true),
target_fps: AtomicUsize::new(60), fps: Default::default(),
mouse_pos: (Default::default(), Default::default()),
mouse_state: Default::default(),
cursor_style: Mutex::new(None),
scaled_mouse_pos: (Default::default(), Default::default()),
scroll_wheel: ScrollWheelAccumulator::new(),
key_state: Default::default(),
is_active: Default::default(),
is_running: Default::default(),
update_hook: Mutex::new(None),
hook_epoch: AtomicUsize::new(0),
}
}
pub fn get_key_state(&self) -> KeyState<'_> {
KeyState::new(&self.key_state)
}
pub fn get_mouse_state(&self) -> MouseState<'_> {
MouseState::new(&self.mouse_state)
}
pub fn get_scroll_wheel(&self) -> ScrollWheel<'_> {
ScrollWheel::new(&self.scroll_wheel)
}
pub fn set_update_hook(&self, hook: impl Fn(&mut Window) + Send + 'static) {
{
let mut guard = self
.update_hook
.lock()
.expect("[ExchangeLayer::set_update_hook] update_hook mutex poisoned");
*guard = Some(box_hook(hook));
}
self.hook_epoch.fetch_add(1, Ordering::Relaxed);
}
pub fn clear_update_hook(&self) {
{
let mut guard = self
.update_hook
.lock()
.expect("[ExchangeLayer::clear_update_hook] update_hook mutex poisoned");
*guard = None;
}
self.hook_epoch.fetch_add(1, Ordering::Relaxed);
}
pub(crate) fn update_from_window(&self, window: &mut Window) {
let update_signal: UpdateSignalNonAtomic =
self.update_signal.bits.load(Ordering::Relaxed).into();
if update_signal.get(UpdateFlag::WindowSize) {
self.update_window_size(window);
}
if update_signal.get(UpdateFlag::WindowPosition) {
self.update_window_position(window);
}
if update_signal.get(UpdateFlag::MousePos) {
self.update_mouse_pos(window);
}
if update_signal.get(UpdateFlag::ScaledMousePos) {
self.update_scaled_mouse_pos(window);
}
if update_signal.get(UpdateFlag::MouseState) {
self.update_mouse_state(window);
}
if update_signal.get(UpdateFlag::ScrollWheel) {
self.update_scroll_wheel(window);
}
if update_signal.get(UpdateFlag::KeyState) {
self.update_key_state(window);
}
if update_signal.get(UpdateFlag::IsActive) {
self.update_is_active(window);
}
}
pub(crate) fn apply_to_window(&self, window: &mut Window) {
let apply_signal: ApplySignalNonAtomic =
self.apply_signal.bits.load(Ordering::Relaxed).into();
if apply_signal.get(ApplyFlag::WindowPosition) {
self.apply_window_position(window);
}
self.apply_title(window);
if apply_signal.get(ApplyFlag::Topmost) {
self.apply_topmost(window);
}
if apply_signal.get(ApplyFlag::BackgroundColor) {
self.apply_background_color(window);
}
if apply_signal.get(ApplyFlag::CursorVisibility) {
self.apply_cursor_visibility(window);
}
if apply_signal.get(ApplyFlag::TargetFps) {
self.apply_target_fps(window);
}
if apply_signal.get(ApplyFlag::CursorStyle) {
self.apply_cursor_style(window);
}
self.apply_signal.reset();
}
pub(crate) fn update_window_size(&self, window: &Window) {
let (w, h) = window.get_size();
self.window_size.0.store(w, Ordering::Relaxed);
self.window_size.1.store(h, Ordering::Relaxed);
}
pub(crate) fn update_window_position(&self, window: &Window) {
let (x, y) = window.get_position();
self.window_position.0.store(x, Ordering::Relaxed);
self.window_position.1.store(y, Ordering::Relaxed);
}
pub(crate) fn update_mouse_pos(&self, window: &Window) {
if let Some((x, y)) = window.get_unscaled_mouse_pos(MouseMode::Discard) {
self.mouse_pos.0.store(x, Ordering::Relaxed);
self.mouse_pos.1.store(y, Ordering::Relaxed);
}
}
pub(crate) fn update_scaled_mouse_pos(&self, window: &Window) {
if let Some((x, y)) = window.get_mouse_pos(MouseMode::Discard) {
self.scaled_mouse_pos.0.store(x, Ordering::Relaxed);
self.scaled_mouse_pos.1.store(y, Ordering::Relaxed);
}
}
pub(crate) fn update_mouse_state(&self, window: &Window) {
let mouse_state: u8 = u8::from(window.get_mouse_down(MouseButton::Left))
| u8::from(window.get_mouse_down(MouseButton::Middle)) << 1
| u8::from(window.get_mouse_down(MouseButton::Right)) << 2;
self.mouse_state.merge(mouse_state);
}
pub(crate) fn update_scroll_wheel(&self, window: &Window) {
if let Some((x, y)) = window.get_scroll_wheel() {
self.scroll_wheel.merge(x, y);
}
}
pub(crate) fn update_key_state(&self, window: &Window) {
let keys = window.get_keys();
self.key_state.merge(&keys);
}
pub(crate) fn update_is_active(&self, window: &mut Window) {
self.is_active.store(window.is_active(), Ordering::Relaxed);
}
pub(crate) fn apply_window_position(&self, window: &mut Window) {
let x = self.window_position.0.load(Ordering::Relaxed);
let y = self.window_position.1.load(Ordering::Relaxed);
window.set_position(x, y);
}
pub(crate) fn apply_title(&self, window: &mut Window) {
self.apply_option_field(&self.title, |opt| {
if let Some(title) = opt {
window.set_title(title);
} else {
window.set_title(&format!("fps: {}", self.fps.load(Ordering::Relaxed)));
}
});
}
pub(crate) fn apply_topmost(&self, window: &mut Window) {
window.topmost(self.topmost.load(Ordering::Relaxed));
}
pub(crate) fn apply_background_color(&self, window: &mut Window) {
let color = self.background_color.load(Ordering::Relaxed);
let r = ((color >> 16) & 0xFF) as u8;
let g = ((color >> 8) & 0xFF) as u8;
let b = (color & 0xFF) as u8;
window.set_background_color(r, g, b);
}
pub(crate) fn apply_cursor_visibility(&self, window: &mut Window) {
window.set_cursor_visibility(self.cursor_visibility.load(Ordering::Relaxed));
}
pub(crate) fn apply_target_fps(&self, window: &mut Window) {
window.set_target_fps(self.target_fps.load(Ordering::Relaxed));
}
pub(crate) fn apply_cursor_style(&self, window: &mut Window) {
self.apply_option_field(&self.cursor_style, |opt| {
if let Some(style) = opt {
window.set_cursor_style(*style);
}
});
}
fn apply_option_field<T, F>(&self, mutex: &Mutex<Option<T>>, mut apply: F)
where
F: FnMut(Option<&T>),
{
for attempt in 0..=Self::RETRY_TIMES {
if let Ok(guard) = mutex.try_lock() {
apply(guard.as_ref());
break;
} else if attempt == Self::RETRY_TIMES {
eprintln!(
"[warning] The mutex lock of type:{} object in thread:{} is over delay",
type_name::<T>(),
thread::current()
.name()
.unwrap_or(&*format!("id:{:?}", thread::current().id()))
);
break;
}
thread::sleep(Self::RETRY_DELAY);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn dummy_hook() -> impl Fn(&mut Window) + Send {
|_window: &mut Window| {}
}
fn adopt(layer: &ExchangeLayer, cache: &mut Option<UpdateHook>, epoch: &mut usize) {
let e = layer.hook_epoch.load(Ordering::Relaxed);
if e != *epoch {
*cache = layer.update_hook.try_lock().unwrap().take();
*epoch = layer.hook_epoch.load(Ordering::Relaxed);
}
}
#[test]
fn update_hook_default_empty_epoch_zero() {
let layer = ExchangeLayer::new();
assert!(layer.update_hook.try_lock().unwrap().is_none());
assert_eq!(layer.hook_epoch.load(Ordering::Relaxed), 0);
}
#[test]
fn update_hook_set_then_clear_bumps_epoch() {
let layer = ExchangeLayer::new();
layer.set_update_hook(dummy_hook());
assert!(layer.update_hook.try_lock().unwrap().is_some());
assert_eq!(layer.hook_epoch.load(Ordering::Relaxed), 1);
layer.clear_update_hook();
assert!(layer.update_hook.try_lock().unwrap().is_none());
assert_eq!(layer.hook_epoch.load(Ordering::Relaxed), 2);
}
#[test]
fn renderer_adopts_replace_and_clear() {
let layer = ExchangeLayer::new();
let mut cache: Option<UpdateHook> = None;
let mut epoch = 0usize;
layer.set_update_hook(dummy_hook());
adopt(&layer, &mut cache, &mut epoch);
assert!(cache.is_some());
assert!(layer.update_hook.try_lock().unwrap().is_none());
layer.set_update_hook(dummy_hook());
adopt(&layer, &mut cache, &mut epoch);
assert!(cache.is_some());
assert_eq!(epoch, 2);
layer.clear_update_hook();
adopt(&layer, &mut cache, &mut epoch);
assert!(cache.is_none());
assert_eq!(epoch, 3);
}
}