better & more fine grained redraw system (should allow movement)

src/render/mod.rs

@@ -51,8 +51,8 @@ impl UiRenderer {
     pub fn update(&mut self, device: &Device, queue: &Queue, ui: &mut Ui) {
         if ui.primitives.updated {
             self.instance
-                .update(device, queue, &ui.primitives.instances);
-            self.primitives.update(device, queue, &ui.primitives.data);
+                .update(device, queue, ui.primitives.instances());
+            self.primitives.update(device, queue, ui.primitives.data());
             self.primitive_group =
                 Self::primitive_group(device, &self.primitive_layout, self.primitives.buffers())
         }

src/render/primitive.rs

@@ -1,19 +1,24 @@
-use std::{
-    marker::PhantomData,
-    ops::{Deref, DerefMut, Range},
-};
+use std::ops::{Deref, DerefMut, Range};
 
 use crate::{
     layout::{Color, UiRegion},
     render::{ArrBuf, data::PrimitiveInstance},
+    util::Id,
 };
 use bytemuck::Pod;
 use wgpu::*;
 
+#[derive(Default)]
+struct Instances {
+    data: Vec<PrimitiveInstance>,
+    assoc: Vec<Id>,
+}
+
 pub struct Primitives {
-    pub(super) instances: Vec<PrimitiveInstance>,
-    pub(super) run: Vec<PrimitiveInstance>,
-    pub(super) data: PrimitiveData,
+    instances: Instances,
+    run: Instances,
+    pos: usize,
+    data: PrimitiveData,
     pub updated: bool,
     run_start: usize,
 }
@@ -23,6 +28,7 @@ impl Default for Primitives {
         Self {
             instances: Default::default(),
             run: Default::default(),
+            pos: 0,
             data: Default::default(),
             updated: true,
             run_start: 0,
@@ -98,15 +104,40 @@ macro_rules! primitives {
 }
 
 impl Primitives {
-    pub fn write<P: Primitive>(&mut self, data: P, region: UiRegion) -> PrimitiveHandle<P> {
+    pub fn write<P: Primitive>(&mut self, id: Id, data: P, region: UiRegion) -> PrimitiveHandle {
         let vec = P::vec(&mut self.data);
         let i = vec.add(data);
-        self.run.push(PrimitiveInstance {
+        let inst = PrimitiveInstance {
             region,
             idx: i as u32,
             binding: P::BINDING,
-        });
-        PrimitiveHandle::new(i)
+        };
+        if self.running() {
+            self.run.push(id, inst);
+        } else if self.instances.assoc.get(self.pos).is_some_and(|i| *i == id) {
+            self.instances.data[self.pos] = inst;
+        } else {
+            self.run_start = self.pos;
+            self.run.push(id, inst);
+        }
+        self.pos += 1;
+        PrimitiveHandle::new::<P>(i)
+    }
+
+    fn running(&self) -> bool {
+        self.run.len() != 0
+    }
+
+    pub fn skip(&mut self, range: &Range<usize>) {
+        if self.running() {
+            self.run.data.extend(&self.instances.data[range.clone()]);
+            self.run.assoc.extend(
+                self.instances.assoc[range.clone()]
+                    .iter()
+                    .map(|i| i.duplicate()),
+            );
+        }
+        self.pos += range.len();
     }
 
     pub(crate) fn clear(&mut self) {
@@ -114,53 +145,55 @@ impl Primitives {
         self.instances.clear();
         self.run.clear();
         self.data.clear();
-    }
-
-    pub fn set<P: Primitive>(&mut self, handle: &PrimitiveHandle<P>, data: P) {
-        P::vec(&mut self.data)[handle.idx] = data;
-    }
-
-    pub fn prepare(&mut self, span: Range<usize>) {
-        self.run_start = span.start;
-        for instance in &self.instances[span] {
-            self.data.free(instance.binding, instance.idx as usize);
-        }
+        self.pos = 0;
     }
 
     pub fn apply(&mut self, span: Range<usize>) -> isize {
-        let delta = self.run.len() as isize - span.len() as isize;
-        self.instances.splice(span, self.run.drain(..));
+        let delta = self.pos as isize - span.end as isize;
+        if self.run.len() == 0 {
+            self.run_start = self.pos;
+        }
+        let span = self.run_start..span.end;
+        self.instances.splice(span, &mut self.run);
         delta
     }
 
+    pub fn set_pos(&mut self, p: usize) {
+        self.pos = p;
+    }
+
+    pub fn free(&mut self, h: &PrimitiveHandle) {
+        self.data.free(h.binding, h.idx);
+    }
+
     pub fn replace(&mut self) {
         std::mem::swap(&mut self.run, &mut self.instances);
         self.run.clear();
     }
 
     pub fn cur_pos(&self) -> usize {
-        self.run_start + self.run.len()
+        self.pos
+    }
+
+    pub fn data(&self) -> &PrimitiveData {
+        &self.data
+    }
+
+    pub fn instances(&self) -> &Vec<PrimitiveInstance> {
+        &self.instances.data
     }
 }
 
-/// primitives but only exposes set for redrawing
-pub struct PrimitiveEditor<'a>(&'a mut Primitives);
-impl PrimitiveEditor<'_> {
-    pub fn set<P: Primitive>(&mut self, handle: &PrimitiveHandle<P>, data: P) {
-        self.0.set(handle, data);
-    }
-}
-
-pub struct PrimitiveHandle<P: Primitive> {
+pub struct PrimitiveHandle {
     idx: usize,
-    _pd: PhantomData<P>,
+    binding: u32,
 }
 
-impl<P: Primitive> PrimitiveHandle<P> {
-    fn new(idx: usize) -> Self {
+impl PrimitiveHandle {
+    fn new<P: Primitive>(idx: usize) -> Self {
         Self {
             idx,
-            _pd: PhantomData,
+            binding: P::BINDING,
         }
     }
 }
@@ -236,3 +269,21 @@ impl<T> DerefMut for PrimitiveVec<T> {
         &mut self.vec
     }
 }
+
+impl Instances {
+    pub fn clear(&mut self) {
+        self.data.clear();
+        self.assoc.clear();
+    }
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+    pub fn push(&mut self, id: Id, inst: PrimitiveInstance) {
+        self.assoc.push(id);
+        self.data.push(inst);
+    }
+    pub fn splice(&mut self, span: Range<usize>, other: &mut Instances) {
+        self.data.splice(span.clone(), other.data.drain(..));
+        self.assoc.splice(span, other.assoc.drain(..));
+    }
+}