layers initial impl (no sensors)

src/render/primitive.rs

@@ -1,4 +1,4 @@
-use std::ops::{Deref, DerefMut, Range};
+use std::ops::{Deref, DerefMut};
 
 use crate::{
     layout::{Color, UiRegion},
@@ -8,30 +8,22 @@ use crate::{
 use bytemuck::Pod;
 use wgpu::*;
 
-#[derive(Default)]
-struct Instances {
-    data: Vec<PrimitiveInstance>,
-    assoc: Vec<Id>,
-}
-
 pub struct Primitives {
-    instances: Instances,
-    run: Instances,
-    pos: usize,
+    instances: Vec<PrimitiveInstance>,
+    assoc: Vec<Id>,
     data: PrimitiveData,
+    free: Vec<usize>,
     pub updated: bool,
-    run_start: usize,
 }
 
 impl Default for Primitives {
     fn default() -> Self {
         Self {
             instances: Default::default(),
-            run: Default::default(),
-            pos: 0,
+            assoc: Default::default(),
             data: Default::default(),
+            free: Vec::new(),
             updated: true,
-            run_start: 0,
         }
     }
 }
@@ -104,7 +96,13 @@ macro_rules! primitives {
 }
 
 impl Primitives {
-    pub fn write<P: Primitive>(&mut self, id: Id, data: P, region: UiRegion) -> PrimitiveHandle {
+    pub fn write<P: Primitive>(
+        &mut self,
+        layer: usize,
+        id: Id,
+        data: P,
+        region: UiRegion,
+    ) -> PrimitiveHandle {
         let vec = P::vec(&mut self.data);
         let i = vec.add(data);
         let inst = PrimitiveInstance {
@@ -112,69 +110,37 @@ impl Primitives {
             idx: i as u32,
             binding: P::BINDING,
         };
-        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;
+        let inst_i = if let Some(i) = self.free.pop() {
+            self.instances[i] = inst;
+            self.assoc[i] = id;
+            i
         } else {
-            self.run_start = self.pos;
-            self.run.push(id, inst);
-        }
-        self.pos += 1;
-        PrimitiveHandle::new::<P>(i)
+            let i = self.instances.len();
+            self.instances.push(inst);
+            self.assoc.push(id);
+            i
+        };
+        PrimitiveHandle::new::<P>(layer, inst_i, i)
     }
 
-    fn running(&self) -> bool {
-        self.run.len() != 0
-    }
-
-    pub fn skip(&mut self, range: &mut 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()),
-            );
-        }
-        range.start = self.pos;
-        self.pos += range.len();
-        range.end = self.pos;
-    }
-
-    pub(crate) fn clear(&mut self) {
-        self.updated = true;
-        self.instances.clear();
-        self.run.clear();
-        self.data.clear();
-        self.pos = 0;
-    }
-
-    pub fn apply(&mut self, span: Range<usize>) -> isize {
-        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;
+    /// returns (old index, new index)
+    pub fn apply_free(&mut self) -> impl Iterator<Item = PrimitiveChange> {
+        self.free.sort_by(|a, b| b.cmp(a));
+        self.free.drain(..).filter_map(|i| {
+            self.instances.swap_remove(i);
+            self.assoc.swap_remove(i);
+            if i == self.instances.len() {
+                return None;
+            }
+            let id = self.assoc[i].duplicate();
+            let old = self.instances.len();
+            Some(PrimitiveChange { id, old, new: i })
+        })
     }
 
     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.pos
+        self.data.free(h.binding, h.data_idx);
+        self.free.push(h.inst_idx);
     }
 
     pub fn data(&self) -> &PrimitiveData {
@@ -182,20 +148,30 @@ impl Primitives {
     }
 
     pub fn instances(&self) -> &Vec<PrimitiveInstance> {
-        &self.instances.data
+        &self.instances
     }
 }
 
+pub struct PrimitiveChange {
+    pub id: Id,
+    pub old: usize,
+    pub new: usize,
+}
+
 #[derive(Debug)]
 pub struct PrimitiveHandle {
-    idx: usize,
-    binding: u32,
+    pub layer: usize,
+    pub inst_idx: usize,
+    pub data_idx: usize,
+    pub binding: u32,
 }
 
 impl PrimitiveHandle {
-    fn new<P: Primitive>(idx: usize) -> Self {
+    fn new<P: Primitive>(layer: usize, inst_idx: usize, data_idx: usize) -> Self {
         Self {
-            idx,
+            layer,
+            inst_idx,
+            data_idx,
             binding: P::BINDING,
         }
     }
@@ -283,21 +259,3 @@ 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(..));
-    }
-}