refactor(engine): use winit instead of glfw

1 files changed, 69 insertions, 73 deletions

diff --git a/engine/src/util.rs b/engine/src/util.rs
index cc4677d..9174734 100644
--- a/engine/src/util.rs
+++ b/engine/src/util.rs
@@ -1,4 +1,72 @@
-use std::marker::PhantomData;
+use ecs::util::VecExt;
+
+#[derive(Debug)]
+pub struct MapVec<Key: Ord, Value>
+{
+    inner: Vec<(Key, Value)>,
+}
+
+impl<Key: Ord, Value> MapVec<Key, Value>
+{
+    pub fn insert(&mut self, key: Key, value: Value)
+    {
+        self.inner
+            .insert_at_part_pt_by_key((key, value), |(a_key, _)| a_key);
+    }
+
+    pub fn remove(&mut self, key: Key) -> Option<Value>
+    {
+        let index = self
+            .inner
+            .binary_search_by_key(&&key, |(a_key, _)| a_key)
+            .ok()?;
+
+        let (_, value) = self.inner.remove(index);
+
+        Some(value)
+    }
+
+    pub fn get(&self, key: &Key) -> Option<&Value>
+    {
+        let index = self
+            .inner
+            .binary_search_by_key(&key, |(a_key, _)| a_key)
+            .ok()?;
+
+        let Some((_, value)) = self.inner.get(index) else {
+            unreachable!(); // Reason: Index from binary search cannot be OOB
+        };
+
+        Some(value)
+    }
+
+    pub fn get_mut(&mut self, key: &Key) -> Option<&mut Value>
+    {
+        let index = self
+            .inner
+            .binary_search_by_key(&key, |(a_key, _)| a_key)
+            .ok()?;
+
+        let Some((_, value)) = self.inner.get_mut(index) else {
+            unreachable!(); // Reason: Index from binary search cannot be OOB
+        };
+
+        Some(value)
+    }
+
+    pub fn values(&self) -> impl Iterator<Item = &Value>
+    {
+        self.inner.iter().map(|(_, value)| value)
+    }
+}
+
+impl<Key: Ord, Value> Default for MapVec<Key, Value>
+{
+    fn default() -> Self
+    {
+        Self { inner: Vec::new() }
+    }
+}
 
 macro_rules! try_option {
     ($expr: expr) => {
@@ -113,75 +181,3 @@ macro_rules! builder {
         }
     };
 }
-
-pub enum RefOrValue<'a, T>
-{
-    Ref(&'a T),
-    Value(Option<T>),
-}
-
-impl<'a, T> RefOrValue<'a, T>
-{
-    pub fn get(&self) -> Option<&T>
-    {
-        match self {
-            Self::Ref(val_ref) => Some(val_ref),
-            Self::Value(val_cell) => val_cell.as_ref(),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Defer<'func, Func, Data>
-where
-    Func: FnMut(&mut Data) + 'func,
-{
-    func: Func,
-    pub data: Data,
-    _pd: PhantomData<&'func ()>,
-}
-
-impl<'func, Func, Data> Defer<'func, Func, Data>
-where
-    Func: FnMut(&mut Data) + 'func,
-{
-    pub fn new(data: Data, func: Func) -> Self
-    {
-        Self { func, data, _pd: PhantomData }
-    }
-}
-
-impl<'func, Func, Data> Drop for Defer<'func, Func, Data>
-where
-    Func: FnMut(&mut Data) + 'func,
-{
-    fn drop(&mut self)
-    {
-        (self.func)(&mut self.data)
-    }
-}
-
-/// Defines a function that will be called at the end of the current scope.
-///
-/// Only captured variables that are later mutably borrowed needs to specified as
-/// captures.
-macro_rules! defer {
-    (|$capture: ident| {$($tt: tt)*}) => {
-        // This uses the automatic temporary lifetime extension behaviour introduced
-        // in Rust 1.79.0 (https://blog.rust-lang.org/2024/06/13/Rust-1.79.0.html) to
-        // create a unnamable variable for the Defer struct. The variable should be
-        // unnamable so that it cannot be missused and so that this macro can be used
-        // multiple times without having to give it a identifier for the Defer struct
-        // variable
-        let Defer { data: $capture, .. } = if true {
-            &Defer::new($capture, |$capture| {
-                $($tt)*
-            })
-        }
-        else {
-            unreachable!();
-        };
-    };
-}
-
-pub(crate) use defer;