wip: big flat pt.2: extract engine crate

engine/src/engine.rs

@@ -0,0 +1,80 @@
+use crate::*;
+use std::fmt::{Debug, Display};
+use std::ops::{Add, Sub, Mul, Div};
+
+/// Platform backend.
+pub trait Engine: Send + Sync + Sized {
+    /// Input event type
+    type Input: Input<Self>;
+    /// Result of handling input
+    type Handled;
+    /// Render target
+    type Output: Output<Self>;
+    /// Unit of length
+    type Unit: Coordinate;
+    /// Rectangle without offset
+    type Size: Size<Self::Unit> + From<[Self::Unit;2]> + Debug + Copy;
+    /// Rectangle with offset
+    type Area: Area<Self::Unit> + From<[Self::Unit;4]> + Debug + Copy;
+    /// Prepare before run
+    fn setup (&mut self) -> Usually<()> { Ok(()) }
+    /// True if done
+    fn exited (&self) -> bool;
+    /// Clean up after run
+    fn teardown (&mut self) -> Usually<()> { Ok(()) }
+}
+
+/// A linear coordinate.
+pub trait Coordinate: Send + Sync + Copy
+    + Add<Self, Output=Self>
+    + Sub<Self, Output=Self>
+    + Mul<Self, Output=Self>
+    + Div<Self, Output=Self>
+    + Ord + PartialEq + Eq
+    + Debug + Display + Default
+    + From<u16> + Into<u16>
+    + Into<usize>
+    + Into<f64>
+{
+    fn minus (self, other: Self) -> Self {
+        if self >= other {
+            self - other
+        } else {
+            0.into()
+        }
+    }
+    fn zero () -> Self {
+        0.into()
+    }
+}
+
+pub trait Size<N: Coordinate> {
+    fn x (&self) -> N;
+    fn y (&self) -> N;
+    #[inline] fn w (&self) -> N { self.x() }
+    #[inline] fn h (&self) -> N { self.y() }
+    #[inline] fn wh (&self) -> [N;2] { [self.x(), self.y()] }
+    #[inline] fn clip_w (&self, w: N) -> [N;2] { [self.w().min(w), self.h()] }
+    #[inline] fn clip_h (&self, h: N) -> [N;2] { [self.w(), self.h().min(h)] }
+    #[inline] fn expect_min (&self, w: N, h: N) -> Usually<&Self> {
+        if self.w() < w || self.h() < h {
+            Err(format!("min {w}x{h}").into())
+        } else {
+            Ok(self)
+        }
+    }
+}
+
+pub trait Area<N: Coordinate>: Copy {
+    fn x  (&self) -> N;
+    fn y  (&self) -> N;
+    fn w  (&self) -> N;
+    fn h  (&self) -> N;
+    #[inline] fn expect_min (&self, w: N, h: N) -> Usually<&Self> {
+        if self.w() < w || self.h() < h {
+            Err(format!("min {w}x{h}").into())
+        } else {
+            Ok(self)
+        }
+    }
+}