use crate::base::{ScreenArray, immutable::ScreenArrayBase};
use crate::unsafe_pointer::UnsafePointerHandler;
use crate::viewer::ArrayViewer;
use crate::viewer::exchange_layer::ExchangeLayer;
use num_traits::Zero;
use std::sync::Arc;
use std::sync::atomic::Ordering;
use std::thread::JoinHandle;
pub struct VisualArray<T: 'static + Zero, const W: usize, const H: usize> {
data: ScreenArrayBase<T, W, H>,
display: Option<ScreenArray<W, H>>,
viewer: Option<ArrayViewer<W, H>>,
handle: Option<JoinHandle<()>>,
converter: Option<Box<dyn Fn(&T) -> u32 + Send>>,
}
impl<T: 'static + Zero, const W: usize, const H: usize> VisualArray<T, W, H> {
pub fn new(converter: Box<dyn Fn(&T) -> u32 + Send>) -> Self {
let data = ScreenArrayBase::zero();
Self {
data,
display: None,
viewer: None,
handle: None,
converter: Some(converter),
}
}
pub fn run(&mut self) {
if self.handle.is_some() {
return;
}
let converter = self.converter.take().expect(
"[VisualArray::run] converter 已被使用;run() 只能调用一次,请重建 VisualArray",
);
let display = ScreenArray::zero();
let viewer = ArrayViewer::new(display.get_ptr() as usize);
let data_handler = unsafe { UnsafePointerHandler::from_mut_ptr(self.data.get_ptr()) };
let display_handler = unsafe { UnsafePointerHandler::from_mut_ptr(display.get_ptr()) };
viewer.get_exchange_layer().set_update_hook(move |_| {
unsafe {
convert_to_display(
data_handler.deref(),
display_handler.deref_mut(),
&*converter,
);
}
});
self.handle = Some(viewer.run(None));
self.display = Some(display);
self.viewer = Some(viewer);
}
pub fn get_data_mut(&mut self) -> &mut ScreenArrayBase<T, W, H> {
&mut self.data
}
pub fn get_data(&self) -> &ScreenArrayBase<T, W, H> {
&self.data
}
pub fn get_display(&self) -> Option<&ScreenArray<W, H>> {
self.display.as_ref()
}
pub fn stop(&mut self) {
if let Some(handle) = self.handle.take() {
if let Some(ref viewer) = self.viewer {
viewer
.get_exchange_layer()
.is_running
.store(false, Ordering::Relaxed);
}
let _ = handle.join(); }
if let Some(ref viewer) = self.viewer {
viewer.get_exchange_layer().clear_update_hook();
}
if let Some(mut display) = self.display.take() {
display.drop();
}
self.viewer = None;
}
pub fn fps(&self) -> usize {
self.viewer.as_ref().map(|v| v.fps()).unwrap_or(0)
}
pub fn exchange_layer(&self) -> Option<Arc<ExchangeLayer>> {
self.viewer.as_ref().map(|v| v.get_exchange_layer())
}
}
impl<T: 'static + Zero, const W: usize, const H: usize> Drop for VisualArray<T, W, H> {
fn drop(&mut self) {
self.stop();
self.data.drop();
}
}
fn convert_to_display<T, const W: usize, const H: usize>(
data: &[[T; W]; H],
display: &mut [[u32; W]; H],
converter: &dyn Fn(&T) -> u32,
) {
for (src_row, dst_row) in data.iter().zip(display.iter_mut()) {
for (src, dst) in src_row.iter().zip(dst_row.iter_mut()) {
*dst = converter(src);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn gray() -> Box<dyn Fn(&u32) -> u32 + Send> {
Box::new(|v: &u32| 0xFF00_0000 | (v & 0x0000_00FF))
}
#[test]
fn convert_to_display_copies_in_row_major() {
const W: usize = 4;
const H: usize = 3;
let data = [[1u32, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]];
let mut display = [[0u32; W]; H];
convert_to_display(&data, &mut display, &*gray());
for (y, src_row) in data.iter().enumerate() {
for (x, src) in src_row.iter().enumerate() {
assert_eq!(display[y][x], 0xFF00_0000 | (src & 0xFF));
}
}
}
#[test]
fn convert_to_display_zero_alpha_kept() {
let data = [[0xABCD_EF01u32]];
let mut display = [[0u32; 1]];
convert_to_display(&data, &mut display, &|v| *v);
assert_eq!(display[0][0], 0xABCD_EF01);
}
#[test]
fn new_does_not_start_rendering() {
let va = VisualArray::<u32, 8, 8>::new(gray());
assert!(va.display.is_none());
assert!(va.viewer.is_none());
assert!(va.handle.is_none());
assert!(va.converter.is_some());
assert_eq!(va.fps(), 0);
assert!(va.exchange_layer().is_none());
assert!(va.get_display().is_none());
assert_eq!(va.data.as_slice(), &[0u32; 8 * 8]);
}
}