From 57bfd2d348c5b2f5aad50423505f6a841f73d8dc Mon Sep 17 00:00:00 2001 From: shadow cat Date: Thu, 25 Sep 2025 00:04:01 -0400 Subject: [PATCH] make layer iter reversible --- src/core/sense.rs | 10 +---- src/layout/layer.rs | 103 ++++++++++++++++++++++++++++++++++---------- 2 files changed, 83 insertions(+), 30 deletions(-) diff --git a/src/core/sense.rs b/src/core/sense.rs index 4400fec..14337f8 100644 --- a/src/core/sense.rs +++ b/src/core/sense.rs @@ -141,14 +141,8 @@ impl SensorModule { let mut layers = std::mem::take(&mut ctx.ui().layers); let mut module = std::mem::take(ctx.ui().modules.get_mut::()); - // TODO: temp, need to actually make reverse - let mut layer_idxs = Vec::new(); - for (i, _) in layers.iter_mut() { - layer_idxs.push(i); - } - - for l in &layer_idxs { - let Some(list) = module.active.get_mut(l) else { + for (i, _) in layers.iter_mut().rev() { + let Some(list) = module.active.get_mut(&i) else { continue; }; let mut ran = false; diff --git a/src/layout/layer.rs b/src/layout/layer.rs index fe65477..81d0853 100644 --- a/src/layout/layer.rs +++ b/src/layout/layer.rs @@ -7,21 +7,24 @@ use crate::{ }; struct LayerNode { - next: Next, - child: Option, + next: Ptr, + prev: Ptr, + child: Option, data: Layer, } -#[derive(Clone, Copy)] -enum Next { +#[derive(Clone, Copy, Debug)] +enum Ptr { /// continue on same level - Same(usize), + Next(usize), /// go back to parent Parent(usize), /// end None, } +/// TODO: currently this does not ever free layers +/// is that realistically desired? pub struct Layers { vec: Vec, } @@ -32,6 +35,12 @@ pub struct Layer { pub primitives: Primitives, } +#[derive(Clone, Copy)] +struct Child { + head: usize, + tail: usize, +} + impl Layers { pub fn new() -> Layers { Self { @@ -51,26 +60,48 @@ impl Layers { } pub fn next(&mut self, i: usize) -> usize { - if let Next::Same(i) = self.vec[i].next { + if let Ptr::Next(i) = self.vec[i].next { return i; } - let i_next = self.push(LayerNode::new(Layer::default(), self.vec[i].next)); - self.vec[i].next = Next::Same(i_next); - i_next + let i_new = self.push(LayerNode::new( + Layer::default(), + self.vec[i].next, + Ptr::Next(i), + )); + self.vec[i].next = Ptr::Next(i_new); + self.vec[i_new].prev = Ptr::Next(i); + match self.vec[i_new].next { + Ptr::Next(i) => self.vec[i].prev = Ptr::Next(i_new), + Ptr::Parent(i) => self.vec[i].child.as_mut().unwrap().tail = i_new, + Ptr::None => (), + } + i_new } pub fn child(&mut self, i: usize) -> usize { - if let Some(i) = self.vec[i].child { - return i; + if let Some(c) = self.vec[i].child { + return c.head; } - let i_next = self.push(LayerNode::new(Layer::default(), Next::Parent(i))); - self.vec[i].child = Some(i_next); - i_next + let i_child = self.push(LayerNode::new( + Layer::default(), + Ptr::Parent(i), + Ptr::Parent(i), + )); + self.vec[i].child = Some(Child { + head: i_child, + tail: i_child, + }); + i_child } pub fn iter_mut(&mut self) -> LayerIteratorMut<'_> { + let mut last = 0; + while let Some(c) = self.vec[last].child { + last = c.tail; + } LayerIteratorMut { next: Some(0), + next_back: Some(last), vec: &mut self.vec, } } @@ -111,21 +142,23 @@ impl IndexMut for Layers { } impl LayerNode { - pub fn new(data: Layer, next: Next) -> Self { + pub fn new(data: Layer, next: Ptr, prev: Ptr) -> Self { Self { next, + prev, child: None, data, } } pub fn head() -> Self { - Self::new(Layer::default(), Next::None) + Self::new(Layer::default(), Ptr::None, Ptr::None) } } pub struct LayerIteratorMut<'a> { next: Option, + next_back: Option, vec: &'a mut Vec, } @@ -133,16 +166,16 @@ impl<'a> Iterator for LayerIteratorMut<'a> { type Item = (usize, &'a mut Layer); fn next(&mut self) -> Option { - // chat are we cooked? (if it's not set up correctly this could be catastrophic) let ret_i = self.next?; + // chat are we cooked? (if it's not set up correctly this could be catastrophic) let node: &mut LayerNode = unsafe { std::mem::transmute(&mut self.vec[ret_i]) }; - self.next = if let Some(i) = node.child { + self.next = if let Some(c) = node.child { + Some(c.head) + } else if let Ptr::Next(i) = node.next { Some(i) - } else if let Next::Same(i) = node.next { - Some(i) - } else if let Next::Parent(i) = node.next { + } else if let Ptr::Parent(i) = node.next { let node = &self.vec[i]; - if let Next::Same(i) = node.next { + if let Ptr::Next(i) = node.next { Some(i) } else { None @@ -150,6 +183,32 @@ impl<'a> Iterator for LayerIteratorMut<'a> { } else { None }; + if self.next_back.unwrap() == ret_i { + self.next = None; + self.next_back = None; + } + Some((ret_i, &mut node.data)) + } +} + +impl<'a> DoubleEndedIterator for LayerIteratorMut<'a> { + fn next_back(&mut self) -> Option { + let ret_i = self.next_back?; + let node: &mut LayerNode = unsafe { std::mem::transmute(&mut self.vec[ret_i]) }; + self.next_back = if let Ptr::Next(mut i) = node.prev { + while let Some(c) = self.vec[i].child { + i = c.tail + } + Some(i) + } else if let Ptr::Parent(i) = node.prev { + Some(i) + } else { + None + }; + if self.next.unwrap() == ret_i { + self.next = None; + self.next_back = None; + } Some((ret_i, &mut node.data)) } }