gaming

src/layout/color.rs

@@ -3,10 +3,10 @@
 #[repr(C)]
 #[derive(Clone, Copy, bytemuck::Zeroable)]
 pub struct Color<T: ColorNum> {
-    r: T,
-    g: T,
-    b: T,
-    a: T,
+    pub r: T,
+    pub g: T,
+    pub b: T,
+    pub a: T,
 }
 
 impl<T: ColorNum> Color<T> {

src/layout/mod.rs

@@ -12,4 +12,4 @@ pub use vec2::*;
 pub use widget::*;
 pub use painter::*;
 
-pub type UIColor = Color<u8>;
+pub type UiColor = Color<u8>;

src/layout/painter.rs

@@ -29,7 +29,7 @@ impl<'a> Painter<'a> {
             .extend_from_slice(bytemuck::cast_slice::<_, u32>(&[data]));
     }
     pub fn draw(&mut self, node: &WidgetId) {
-        self.nodes.get(node).draw(self);
+        self.nodes.get_dyn(node).draw(self);
     }
     pub fn draw_within(&mut self, node: &WidgetId, region: UIRegion) {
         let old = self.region;

src/layout/ui.rs

@@ -1,88 +1,115 @@
 use crate::{
-    HashMap, Painter, Widget, WidgetId, WidgetLike, WidgetRef,
+    HashMap, Painter, Widget, WidgetId, WidgetLike,
     primitive::Primitives,
     util::{ID, IDTracker},
 };
 use std::{
     any::{Any, TypeId},
-    cell::RefCell,
-    rc::Rc,
+    ops::{Index, IndexMut},
 };
 
-pub struct UI {
+#[derive(Default)]
+pub struct Ui {
     ids: IDTracker,
     base: Option<WidgetId>,
-    pub widgets: Widgets,
+    widgets: Widgets,
+    updates: Vec<WidgetId>,
+    primitives: Primitives,
+    full_redraw: bool,
 }
 
+#[derive(Default)]
 pub struct Widgets(HashMap<ID, Box<dyn Widget>>);
 
-#[derive(Clone)]
-pub struct UIBuilder {
-    ui: Rc<RefCell<UI>>,
-}
-
-impl From<UI> for UIBuilder {
-    fn from(ui: UI) -> Self {
-        UIBuilder {
-            ui: Rc::new(RefCell::new(ui)),
-        }
-    }
-}
-
-impl UIBuilder {
-    pub fn add<W: Widget>(&mut self, w: impl WidgetLike<Widget = W>) -> WidgetRef<W> {
-        WidgetRef::new([w.add(self).erase_type()])
+impl Ui {
+    pub fn add<W: Widget>(&mut self, w: impl WidgetLike<Widget = W>) -> WidgetId<W> {
+        w.add(self)
     }
 
-    pub fn add_widget<W: Widget>(&mut self, w: W) -> WidgetRef<W> {
-        WidgetRef::new([self.push(w)])
+    pub fn add_widget<W: Widget>(&mut self, w: W) -> WidgetId<W> {
+        self.push(w)
     }
 
-    pub fn push<W: Widget>(&mut self, w: W) -> WidgetId {
-        let mut ui = self.ui.borrow_mut();
-        let id = ui.ids.next();
-        ui.widgets.insert(id.duplicate(), w);
+    pub fn push<W: Widget>(&mut self, w: W) -> WidgetId<W> {
+        let id = self.ids.next();
+        self.widgets.insert(id.duplicate(), w);
         WidgetId::new(id, TypeId::of::<W>())
     }
 
-    pub fn finish<W: WidgetLike>(mut self, base: W) -> UI {
-        let base = base.add(&mut self).erase_type();
-        let mut ui = Rc::into_inner(self.ui).unwrap().into_inner();
-        ui.base = Some(base);
-        ui
-    }
-}
-
-impl UI {
-    pub fn build() -> UIBuilder {
-        Self::empty().into()
+    pub fn set<W: Widget>(&mut self, i: &WidgetId<W>, w: W) {
+        self.widgets.insert(i.id.duplicate(), w);
     }
 
-    pub fn empty() -> Self {
-        Self {
-            ids: IDTracker::new(),
-            base: None,
-            widgets: Widgets::new(),
-        }
+    pub fn set_base(&mut self, w: impl WidgetLike) {
+        self.base = Some(w.add(self).erase_type());
+        self.full_redraw = true;
     }
 
-    pub fn to_primitives(&self) -> Primitives {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn get<W: Widget>(&self, id: &WidgetId<W>) -> Option<&W> {
+        self.widgets.get(id)
+    }
+
+    pub fn get_mut<W: Widget>(&mut self, id: &WidgetId<W>) -> Option<&mut W> {
+        self.widgets.get_mut(id)
+    }
+
+    pub fn id<W: Widget>(&mut self) -> WidgetId<W> {
+        WidgetId::new(self.ids.next(), TypeId::of::<W>())
+    }
+
+    pub fn redraw_all(&mut self) {
         let mut painter = Painter::new(&self.widgets);
         if let Some(base) = &self.base {
             painter.draw(base);
         }
-        painter.finish()
+        self.primitives = painter.finish();
+    }
+
+    pub fn update(&mut self) -> Option<&Primitives> {
+        if self.full_redraw {
+            self.redraw_all();
+            self.full_redraw = false;
+            return Some(&self.primitives);
+        }
+        if self.updates.is_empty() {
+            return None;
+        }
+        self.redraw_all();
+        self.updates.drain(..);
+        Some(&self.primitives)
+    }
+
+    pub fn needs_redraw(&self) -> bool {
+        self.full_redraw || !self.updates.is_empty()
+    }
+}
+
+impl<W: Widget> Index<&WidgetId<W>> for Ui {
+    type Output = W;
+
+    fn index(&self, id: &WidgetId<W>) -> &Self::Output {
+        self.get(id).unwrap()
+    }
+}
+
+impl<W: Widget> IndexMut<&WidgetId<W>> for Ui {
+    fn index_mut(&mut self, id: &WidgetId<W>) -> &mut Self::Output {
+        self.updates.push(id.clone().erase_type());
+        self.get_mut(id).unwrap()
     }
 }
 
 impl Widgets {
-    fn new() -> Self {
-        Self(HashMap::new())
+    pub fn get_dyn(&self, id: &WidgetId) -> &dyn Widget {
+        self.0.get(&id.id).unwrap().as_ref()
     }
 
-    pub fn get(&self, id: &WidgetId) -> &dyn Widget {
-        self.0.get(&id.id).unwrap().as_ref()
+    pub fn get<W: Widget>(&self, id: &WidgetId<W>) -> Option<&W> {
+        self.0.get(&id.id).unwrap().as_any().downcast_ref()
     }
 
     pub fn get_mut<W: Widget>(&mut self, id: &WidgetId<W>) -> Option<&mut W> {
@@ -99,6 +126,10 @@ impl Widgets {
 }
 
 impl dyn Widget {
+    pub fn as_any(&self) -> &dyn Any {
+        self
+    }
+
     pub fn as_any_mut(&mut self) -> &mut dyn Any {
         self
     }

src/layout/widget.rs

@@ -3,20 +3,19 @@ use std::{
     marker::PhantomData,
 };
 
-use crate::{Painter, util::ID, UIBuilder};
+use crate::{Painter, Ui, util::ID};
 
 pub trait Widget: 'static + Any {
     fn draw(&self, painter: &mut Painter);
 }
 
-impl<W: Widget> Widget for (W,) {
-    fn draw(&self, painter: &mut Painter) {
-        self.0.draw(painter);
-    }
-}
-
 pub struct AnyWidget;
 
+/// An identifier for a widget.
+/// Can index a UI to get the associated widget.
+///
+/// W does not need to implement widget so that AnyWidget is valid;
+/// Instead, add generic bounds on methods that take an ID if they need specific data.
 #[derive(Eq, Hash, PartialEq, Debug)]
 pub struct WidgetId<W = AnyWidget> {
     pub(super) ty: TypeId,
@@ -54,42 +53,83 @@ impl<W> WidgetId<W> {
 
 pub trait WidgetLike {
     type Widget;
-    fn add(self, ui: &mut UIBuilder) -> WidgetId<Self::Widget>;
+    fn add(self, ui: &mut Ui) -> WidgetId<Self::Widget>;
 }
 
-/// wouldn't be needed if negative trait bounds & disjoint impls existed
-pub struct WidgetFn<F: FnOnce(&mut UIBuilder) -> W, W>(pub F);
+/// A function that returns a widget given a UI.
+/// Useful for defining trait functions on widgets that create a parent widget so that the children
+/// don't need to be IDs yet
+pub struct WidgetFn<F: FnOnce(&mut Ui) -> W, W>(pub F);
+pub struct WidgetIdFn<F: FnOnce(&mut Ui) -> WidgetId<W>, W>(pub F);
 
-impl<W: Widget, F: FnOnce(&mut UIBuilder) -> W> WidgetLike for WidgetFn<F, W> {
+pub trait _WidgetFn<W: Widget> {
+    fn call(ui: &mut Ui) -> W;
+}
+
+pub trait Idable {
+    type Widget: Widget;
+    fn set(self, ui: &mut Ui, id: &WidgetId<Self::Widget>);
+}
+
+pub trait WidgetFns<W> {
+    fn id(self, id: &WidgetId<W>) -> impl WidgetLike<Widget = W>;
+}
+
+impl<I: Idable> WidgetFns<I::Widget> for I {
+    fn id(self, id: &WidgetId<I::Widget>) -> impl WidgetLike<Widget = I::Widget> {
+        WidgetIdFn(|ui| {
+            self.set(ui, id);
+            id.clone()
+        })
+    }
+}
+
+impl<W: Widget> Idable for W {
     type Widget = W;
-    fn add(self, ui: &mut UIBuilder) -> WidgetId<W> {
+
+    fn set(self, ui: &mut Ui, id: &WidgetId<Self::Widget>) {
+        ui.set(id, self);
+    }
+}
+
+impl<F: for<'a> FnOnce(&'a mut Ui) -> W, W: Widget> Idable for WidgetFn<F, W> {
+    type Widget = W;
+
+    fn set(self, ui: &mut Ui, id: &WidgetId<Self::Widget>) {
+        let w = self.0(ui);
+        ui.set(id, w);
+    }
+}
+
+impl<W: Widget, F: FnOnce(&mut Ui) -> W> WidgetLike for WidgetFn<F, W> {
+    type Widget = W;
+    fn add(self, ui: &mut Ui) -> WidgetId<W> {
         let w = (self.0)(ui);
-        ui.add_widget(w).to_id()
+        ui.add(w)
+    }
+}
+
+impl<W: Widget, F: FnOnce(&mut Ui) -> WidgetId<W>> WidgetLike for WidgetIdFn<F, W> {
+    type Widget = W;
+    fn add(self, ui: &mut Ui) -> WidgetId<W> {
+        (self.0)(ui)
     }
 }
 
 impl<W: Widget> WidgetLike for W {
     type Widget = W;
-    fn add(self, ui: &mut UIBuilder) -> WidgetId<W> {
-        ui.add_widget(self).to_id()
+    fn add(self, ui: &mut Ui) -> WidgetId<W> {
+        ui.add_widget(self)
     }
 }
 
 impl<W> WidgetLike for WidgetId<W> {
     type Widget = W;
-    fn add(self, _: &mut UIBuilder) -> WidgetId<W> {
+    fn add(self, _: &mut Ui) -> WidgetId<W> {
         self
     }
 }
 
-impl<W> WidgetLike for WidgetArr<1, (W,)> {
-    type Widget = W;
-    fn add(self, _: &mut UIBuilder) -> WidgetId<W> {
-        let [id] = self.arr;
-        id.cast_type()
-    }
-}
-
 pub struct WidgetArr<const LEN: usize, Ws> {
     pub arr: [WidgetId; LEN],
     _pd: PhantomData<Ws>,
@@ -104,37 +144,31 @@ impl<const LEN: usize, Ws> WidgetArr<LEN, Ws> {
     }
 }
 
-pub type WidgetRef<W> = WidgetArr<1, (W,)>;
-
-impl<W> WidgetRef<W> {
-    pub fn handle(&self) -> WidgetId<W> {
-        let [id] = &self.arr;
-        id.clone().cast_type()
-    }
-    pub fn to_id(self) -> WidgetId<W> {
-        let [id] = self.arr;
-        id.cast_type()
-    }
-}
-
 pub trait WidgetArrLike<const LEN: usize> {
     type Ws;
-    fn ui(self, ui: &mut UIBuilder) -> WidgetArr<LEN, Self::Ws>;
+    fn ui(self, ui: &mut Ui) -> WidgetArr<LEN, Self::Ws>;
 }
 
 impl<const LEN: usize, Ws> WidgetArrLike<LEN> for WidgetArr<LEN, Ws> {
     type Ws = Ws;
-    fn ui(self, _: &mut UIBuilder) -> WidgetArr<LEN, Ws> {
+    fn ui(self, _: &mut Ui) -> WidgetArr<LEN, Ws> {
         self
     }
 }
 
+impl<W: WidgetLike> WidgetArrLike<1> for W {
+    type Ws = (W::Widget,);
+    fn ui(self, ui: &mut Ui) -> WidgetArr<1, (W::Widget,)> {
+        WidgetArr::new([self.add(ui).erase_type()])
+    }
+}
+
 // I hate this language it's so bad why do I even use it
 macro_rules! impl_widget_arr {
     ($n:expr;$($T:tt)*) => {
         impl<$($T: WidgetLike,)*> WidgetArrLike<$n> for ($($T,)*) {
             type Ws = ($($T::Widget,)*);
-            fn ui(self, ui: &mut UIBuilder) -> WidgetArr<$n, ($($T::Widget,)*)> {
+            fn ui(self, ui: &mut Ui) -> WidgetArr<$n, ($($T::Widget,)*)> {
                 #[allow(non_snake_case)]
                 let ($($T,)*) = self;
                 WidgetArr::new(