From 7a17707517886df784082e03943671c1cfa3f576 Mon Sep 17 00:00:00 2001
From: vE5li <ve5li@tuta.io>
Date: Tue, 13 Feb 2024 12:32:11 +0100
Subject: [PATCH] Add wrapper for render and resolve logic

---
 src/input/mod.rs                              |  20 +-
 .../elements/containers/character.rs          |   2 +-
 src/interface/elements/containers/dialog.rs   |   2 +-
 .../elements/containers/equipment.rs          |   2 +-
 src/interface/elements/containers/friends.rs  |  10 +-
 src/interface/elements/containers/hotbar.rs   |   2 +-
 .../elements/containers/inventory.rs          |   2 +-
 src/interface/elements/containers/packet.rs   |  16 +-
 src/interface/elements/containers/scroll.rs   |   2 +-
 .../elements/containers/skill_tree.rs         |   2 +-
 src/interface/elements/miscellanious/chat.rs  |   2 +-
 src/interface/elements/miscellanious/input.rs |   4 +-
 .../elements/miscellanious/slider.rs          |   2 +-
 src/interface/elements/profiler/frame.rs      |   2 +-
 src/interface/elements/profiler/inspector.rs  |   2 +-
 .../elements/values/mutable/color.rs          |   2 +-
 .../elements/values/mutable/number.rs         |   2 +-
 .../elements/values/mutable/vector.rs         |   2 +-
 src/interface/event/change.rs                 |  20 +-
 src/interface/mod.rs                          | 236 +++++++++++-------
 src/interface/settings.rs                     |   2 +-
 src/interface/theme.rs                        | 176 ++++++-------
 src/main.rs                                   |   8 +-
 23 files changed, 291 insertions(+), 229 deletions(-)

diff --git a/src/input/mod.rs b/src/input/mod.rs
index d12b4fd6d..397ff9316 100644
--- a/src/input/mod.rs
+++ b/src/input/mod.rs
@@ -287,16 +287,16 @@ impl InputSystem {
 
                         ClickAction::MoveItem(item_source, item) => {
                             self.mouse_input_mode = MouseInputMode::MoveItem(item_source, item);
-                            // Needs to rerender because some elements will render differently
+                            // Needs to re-render because some elements will render differently
                             // based on the mouse input mode.
-                            interface.schedule_rerender();
+                            interface.schedule_render();
                         }
 
                         ClickAction::MoveSkill(skill_source, skill) => {
                             self.mouse_input_mode = MouseInputMode::MoveSkill(skill_source, skill);
-                            // Needs to rerender because some elements will render differently
+                            // Needs to re-render because some elements will render differently
                             // based on the mouse input mode.
-                            interface.schedule_rerender();
+                            interface.schedule_render();
                         }
 
                         ClickAction::OpenWindow(prototype_window) => interface.open_window(focus_state, prototype_window.as_ref()),
@@ -315,9 +315,9 @@ impl InputSystem {
                 }
             } else {
                 let mouse_input_mode = std::mem::take(&mut self.mouse_input_mode);
-                // Needs to rerender because some elements will render differently
+                // Needs to re-render because some elements will render differently
                 // based on the mouse input mode.
-                interface.schedule_rerender();
+                interface.schedule_render();
 
                 match mouse_input_mode {
                     MouseInputMode::MoveItem(item_source, item) => {
@@ -641,21 +641,21 @@ impl InputSystem {
 
         if focus_state.did_hovered_element_change(&hovered_element) {
             if let Some(window_index) = focus_state.previous_hovered_window() {
-                interface.schedule_rerender_window(window_index);
+                interface.schedule_render_window(window_index);
             }
 
             if let Some(window_index) = window_index {
-                interface.schedule_rerender_window(window_index);
+                interface.schedule_render_window(window_index);
             }
         }
 
         if focus_state.did_focused_element_change() {
             if let Some(window_index) = focus_state.previous_focused_window() {
-                interface.schedule_rerender_window(window_index);
+                interface.schedule_render_window(window_index);
             }
 
             if let Some(window_index) = focus_state.focused_window() {
-                interface.schedule_rerender_window(window_index);
+                interface.schedule_render_window(window_index);
             }
         }
 
diff --git a/src/interface/elements/containers/character.rs b/src/interface/elements/containers/character.rs
index 5cc0f85f9..428046716 100644
--- a/src/interface/elements/containers/character.rs
+++ b/src/interface/elements/containers/character.rs
@@ -133,7 +133,7 @@ impl Element for CharacterPreview {
             // scrolling would break
             self.state.link_back(weak_self, weak_parent);
 
-            return Some(ChangeEvent::RERESOLVE_WINDOW);
+            return Some(ChangeEvent::RESOLVE_WINDOW);
         }
 
         None
diff --git a/src/interface/elements/containers/dialog.rs b/src/interface/elements/containers/dialog.rs
index 2e257c2f8..75c4df1e6 100644
--- a/src/interface/elements/containers/dialog.rs
+++ b/src/interface/elements/containers/dialog.rs
@@ -87,7 +87,7 @@ impl Element for DialogContainer {
 
             // TODO: link back like in character container
 
-            return Some(ChangeEvent::RERESOLVE_WINDOW);
+            return Some(ChangeEvent::RESOLVE_WINDOW);
         }
 
         None
diff --git a/src/interface/elements/containers/equipment.rs b/src/interface/elements/containers/equipment.rs
index a88ab14a3..4576dbbdd 100644
--- a/src/interface/elements/containers/equipment.rs
+++ b/src/interface/elements/containers/equipment.rs
@@ -107,7 +107,7 @@ impl Element for EquipmentContainer {
             // scrolling would break
             self.link_back(weak_self, weak_parent);
 
-            return Some(ChangeEvent::RERESOLVE_WINDOW);
+            return Some(ChangeEvent::RESOLVE_WINDOW);
         }
 
         None
diff --git a/src/interface/elements/containers/friends.rs b/src/interface/elements/containers/friends.rs
index d4fc91f36..b4010ddd8 100644
--- a/src/interface/elements/containers/friends.rs
+++ b/src/interface/elements/containers/friends.rs
@@ -90,7 +90,7 @@ impl Element for FriendView {
     }
 
     fn update(&mut self) -> Option<ChangeEvent> {
-        let mut reresolve = false;
+        let mut resolve = false;
 
         if self.friends.consume_changed() {
             // Remove elements of old friends from the start of the list and add new friends
@@ -110,7 +110,7 @@ impl Element for FriendView {
                         element.borrow_mut().link_back(Rc::downgrade(&element), self.weak_self.clone());
 
                         self.state.elements.insert(index, element);
-                        reresolve = true;
+                        resolve = true;
                     }
                 });
 
@@ -118,12 +118,12 @@ impl Element for FriendView {
             let friend_count = self.friends.borrow().len();
             if friend_count < self.state.elements.len() {
                 self.state.elements.truncate(friend_count);
-                reresolve = true;
+                resolve = true;
             }
         }
 
-        match reresolve {
-            true => Some(ChangeEvent::RERESOLVE_WINDOW),
+        match resolve {
+            true => Some(ChangeEvent::RESOLVE_WINDOW),
             false => None,
         }
     }
diff --git a/src/interface/elements/containers/hotbar.rs b/src/interface/elements/containers/hotbar.rs
index 7a3f1cf20..b6d0d99a8 100644
--- a/src/interface/elements/containers/hotbar.rs
+++ b/src/interface/elements/containers/hotbar.rs
@@ -88,7 +88,7 @@ impl Element for HotbarContainer {
             // scrolling would break
             self.link_back(weak_self, weak_parent);
 
-            return Some(ChangeEvent::RERESOLVE_WINDOW);
+            return Some(ChangeEvent::RESOLVE_WINDOW);
         }
 
         None
diff --git a/src/interface/elements/containers/inventory.rs b/src/interface/elements/containers/inventory.rs
index f0eb28eeb..613103127 100644
--- a/src/interface/elements/containers/inventory.rs
+++ b/src/interface/elements/containers/inventory.rs
@@ -78,7 +78,7 @@ impl Element for InventoryContainer {
             // scrolling would break
             self.link_back(weak_self, weak_parent);
 
-            return Some(ChangeEvent::RERESOLVE_WINDOW);
+            return Some(ChangeEvent::RESOLVE_WINDOW);
         }
 
         None
diff --git a/src/interface/elements/containers/packet.rs b/src/interface/elements/containers/packet.rs
index 558f02e09..eeceebf71 100644
--- a/src/interface/elements/containers/packet.rs
+++ b/src/interface/elements/containers/packet.rs
@@ -174,7 +174,7 @@ impl<const N: usize> Element for PacketView<N> {
     }
 
     fn update(&mut self) -> Option<ChangeEvent> {
-        let mut reresolve = false;
+        let mut resolve = false;
 
         if self.show_pings.consume_changed() | self.packets.consume_changed() {
             fn compare(linked_element: &UnsafeCell<Option<WeakElementCell>>, element: &ElementCell) -> bool {
@@ -196,7 +196,7 @@ impl<const N: usize> Element for PacketView<N> {
                 for _index in 0..self.state.elements.len() {
                     if !std::ptr::addr_eq(first_visible_element, Rc::downgrade(&self.state.elements[0]).as_ptr()) {
                         self.state.elements.remove(0);
-                        reresolve = true;
+                        resolve = true;
                     } else {
                         break;
                     }
@@ -204,7 +204,7 @@ impl<const N: usize> Element for PacketView<N> {
             } else {
                 // This means that there are no visible packets at all, so remove every element.
                 self.state.elements.clear();
-                reresolve = true;
+                resolve = true;
             }
 
             let show_pings = *self.show_pings.borrow();
@@ -226,7 +226,7 @@ impl<const N: usize> Element for PacketView<N> {
                         element.borrow_mut().link_back(Rc::downgrade(&element), self.weak_self.clone());
 
                         self.state.elements.insert(index, element);
-                        reresolve = true;
+                        resolve = true;
                     }
 
                     // Packet was previously visible but now should be hidden.
@@ -234,7 +234,7 @@ impl<const N: usize> Element for PacketView<N> {
                         *linked_element = Rc::downgrade(&self.hidden_element);
 
                         self.state.elements.remove(index);
-                        reresolve = true;
+                        resolve = true;
                     }
                 } else {
                     // Getting here means thatt the packet was newly added.
@@ -245,7 +245,7 @@ impl<const N: usize> Element for PacketView<N> {
                             element.borrow_mut().link_back(Rc::downgrade(&element), self.weak_self.clone());
 
                             self.state.elements.push(element);
-                            reresolve = true;
+                            resolve = true;
                         }
                         false => {
                             unsafe { *linked_element.get() = Some(Rc::downgrade(&self.hidden_element)) };
@@ -259,8 +259,8 @@ impl<const N: usize> Element for PacketView<N> {
             });
         }
 
-        match reresolve {
-            true => Some(ChangeEvent::RERESOLVE_WINDOW),
+        match resolve {
+            true => Some(ChangeEvent::RESOLVE_WINDOW),
             false => None,
         }
     }
diff --git a/src/interface/elements/containers/scroll.rs b/src/interface/elements/containers/scroll.rs
index 7716ad6ad..354ee46cc 100644
--- a/src/interface/elements/containers/scroll.rs
+++ b/src/interface/elements/containers/scroll.rs
@@ -77,7 +77,7 @@ impl Element for ScrollView {
     fn scroll(&mut self, delta: f32) -> Option<ChangeEvent> {
         self.scroll -= delta * SCROLL_SPEED;
         self.scroll = self.scroll.max(0.0);
-        Some(ChangeEvent::RERENDER_WINDOW)
+        Some(ChangeEvent::RENDER_WINDOW)
     }
 
     fn render(
diff --git a/src/interface/elements/containers/skill_tree.rs b/src/interface/elements/containers/skill_tree.rs
index cf5c66920..4a670d8ca 100644
--- a/src/interface/elements/containers/skill_tree.rs
+++ b/src/interface/elements/containers/skill_tree.rs
@@ -78,7 +78,7 @@ impl Element for SkillTreeContainer {
             // scrolling would break
             self.link_back(weak_self, weak_parent);
 
-            return Some(ChangeEvent::RERESOLVE_WINDOW);
+            return Some(ChangeEvent::RESOLVE_WINDOW);
         }
 
         None
diff --git a/src/interface/elements/miscellanious/chat.rs b/src/interface/elements/miscellanious/chat.rs
index 37a463575..2fae6e2ce 100644
--- a/src/interface/elements/miscellanious/chat.rs
+++ b/src/interface/elements/miscellanious/chat.rs
@@ -71,7 +71,7 @@ impl Element for Chat {
 
         if messages.len() != self.cached_message_count {
             self.cached_message_count = messages.len();
-            return Some(ChangeEvent::RERESOLVE_WINDOW);
+            return Some(ChangeEvent::RESOLVE_WINDOW);
         }
 
         None
diff --git a/src/interface/elements/miscellanious/input.rs b/src/interface/elements/miscellanious/input.rs
index 2d3983449..97739d56c 100644
--- a/src/interface/elements/miscellanious/input.rs
+++ b/src/interface/elements/miscellanious/input.rs
@@ -27,7 +27,7 @@ impl<const LENGTH: usize, const HIDDEN: bool> InputField<LENGTH, HIDDEN> {
         }
 
         display.pop();
-        Some(ClickAction::ChangeEvent(ChangeEvent::RERENDER_WINDOW))
+        Some(ClickAction::ChangeEvent(ChangeEvent::RENDER_WINDOW))
     }
 
     fn add_character(&mut self, character: char) -> Option<ClickAction> {
@@ -38,7 +38,7 @@ impl<const LENGTH: usize, const HIDDEN: bool> InputField<LENGTH, HIDDEN> {
         }
 
         display.push(character);
-        Some(ClickAction::ChangeEvent(ChangeEvent::RERENDER_WINDOW))
+        Some(ClickAction::ChangeEvent(ChangeEvent::RENDER_WINDOW))
     }
 }
 
diff --git a/src/interface/elements/miscellanious/slider.rs b/src/interface/elements/miscellanious/slider.rs
index fdd59e877..0f7ad19ec 100644
--- a/src/interface/elements/miscellanious/slider.rs
+++ b/src/interface/elements/miscellanious/slider.rs
@@ -39,7 +39,7 @@ impl<T: Zero + NumOps + NumCast + Copy + PartialOrd> Element for Slider<T> {
 
         if self.cached_value != current_value {
             self.cached_value = current_value;
-            return Some(ChangeEvent::RERENDER_WINDOW);
+            return Some(ChangeEvent::RENDER_WINDOW);
         }
 
         None
diff --git a/src/interface/elements/profiler/frame.rs b/src/interface/elements/profiler/frame.rs
index 442e6b974..b6e3575ba 100644
--- a/src/interface/elements/profiler/frame.rs
+++ b/src/interface/elements/profiler/frame.rs
@@ -46,7 +46,7 @@ impl Element for FrameView {
 
         if *self.always_update.borrow() || self.frame_counter == SAVED_FRAME_COUNT {
             self.frame_counter = 0;
-            return Some(ChangeEvent::RERENDER_WINDOW);
+            return Some(ChangeEvent::RENDER_WINDOW);
         }
 
         None
diff --git a/src/interface/elements/profiler/inspector.rs b/src/interface/elements/profiler/inspector.rs
index 0da9e6a7e..690db2e62 100644
--- a/src/interface/elements/profiler/inspector.rs
+++ b/src/interface/elements/profiler/inspector.rs
@@ -195,7 +195,7 @@ impl Element for FrameInspectorView {
             self.start_offset += total_offset.mul_f32(side_bias);
         }
 
-        Some(ChangeEvent::RERENDER_WINDOW)
+        Some(ChangeEvent::RENDER_WINDOW)
     }
 
     fn render(
diff --git a/src/interface/elements/values/mutable/color.rs b/src/interface/elements/values/mutable/color.rs
index 5c6508bcb..b8cad00e0 100644
--- a/src/interface/elements/values/mutable/color.rs
+++ b/src/interface/elements/values/mutable/color.rs
@@ -53,7 +53,7 @@ impl Element for MutableColorValue {
                 "{}, {}, {}, {}",
                 self.cached_color.red, self.cached_color.green, self.cached_color.blue, self.cached_color.alpha
             );
-            return Some(ChangeEvent::RERENDER_WINDOW);
+            return Some(ChangeEvent::RENDER_WINDOW);
         }
 
         None
diff --git a/src/interface/elements/values/mutable/number.rs b/src/interface/elements/values/mutable/number.rs
index e2ac18a47..1f7201948 100644
--- a/src/interface/elements/values/mutable/number.rs
+++ b/src/interface/elements/values/mutable/number.rs
@@ -57,7 +57,7 @@ impl<T: Zero + NumOps + NumCast + Copy + PartialOrd + Display + 'static> Element
         if self.cached_inner != current_value {
             self.cached_inner = current_value;
             self.cached_values = format!("{:.1}", self.cached_inner);
-            return Some(ChangeEvent::RERENDER_WINDOW);
+            return Some(ChangeEvent::RENDER_WINDOW);
         }
 
         None
diff --git a/src/interface/elements/values/mutable/vector.rs b/src/interface/elements/values/mutable/vector.rs
index 8be418249..970d9323c 100644
--- a/src/interface/elements/values/mutable/vector.rs
+++ b/src/interface/elements/values/mutable/vector.rs
@@ -70,7 +70,7 @@ where
         if self.cached_inner != current_value {
             self.cached_inner = current_value;
             self.cached_values = self.cached_inner.display();
-            return Some(ChangeEvent::RERENDER_WINDOW);
+            return Some(ChangeEvent::RENDER_WINDOW);
         }
 
         None
diff --git a/src/interface/event/change.rs b/src/interface/event/change.rs
index 471ec7102..0e33311c7 100644
--- a/src/interface/event/change.rs
+++ b/src/interface/event/change.rs
@@ -3,10 +3,10 @@ use bitflags::bitflags;
 bitflags! {
     #[derive(Copy, Clone, Debug, PartialEq, Eq)]
     pub struct ChangeEvent: u8 {
-        const RERENDER_WINDOW = 0b00000001;
-        const RERESOLVE_WINDOW = 0b00000010;
-        const RERENDER = 0b00000100;
-        const RERESOLVE = 0b00001000;
+        const RENDER_WINDOW = 0b00000001;
+        const RESOLVE_WINDOW = 0b00000010;
+        const RENDER = 0b00000100;
+        const RESOLVE = 0b00001000;
     }
 }
 
@@ -14,19 +14,19 @@ pub trait IntoChangeEvent {
     fn into_change_event() -> Option<ChangeEvent>;
 }
 
-pub struct Rerender {}
-pub struct Reresolve {}
+pub struct Render {}
+pub struct Resolve {}
 pub struct Nothing {}
 
-impl IntoChangeEvent for Rerender {
+impl IntoChangeEvent for Render {
     fn into_change_event() -> Option<ChangeEvent> {
-        Some(ChangeEvent::RERENDER)
+        Some(ChangeEvent::RENDER)
     }
 }
 
-impl IntoChangeEvent for Reresolve {
+impl IntoChangeEvent for Resolve {
     fn into_change_event() -> Option<ChangeEvent> {
-        Some(ChangeEvent::RERESOLVE)
+        Some(ChangeEvent::RESOLVE)
     }
 }
 
diff --git a/src/interface/mod.rs b/src/interface/mod.rs
index aa6a612d9..e5167758d 100644
--- a/src/interface/mod.rs
+++ b/src/interface/mod.rs
@@ -10,6 +10,7 @@ mod cursor;
 mod windows;
 
 use std::cell::RefCell;
+use std::marker::PhantomData;
 use std::rc::Rc;
 
 use cgmath::Vector2;
@@ -63,8 +64,66 @@ struct DialogHandle {
     clear: bool,
 }
 
+#[derive(Clone)]
+struct PerWindow;
+
+#[derive(Clone)]
+struct PostUpdate<T> {
+    resolve: bool,
+    render: bool,
+    marker: PhantomData<T>,
+}
+
+impl<T> PostUpdate<T> {
+    pub fn new() -> Self {
+        Self {
+            resolve: false,
+            render: false,
+            marker: PhantomData,
+        }
+    }
+
+    pub fn render(&mut self) {
+        self.render = true;
+    }
+
+    pub fn resolve(&mut self) {
+        self.resolve = true;
+    }
+
+    pub fn with_render(mut self) -> Self {
+        self.render = true;
+        self
+    }
+
+    pub fn with_resolve(mut self) -> Self {
+        self.resolve = true;
+        self
+    }
+
+    pub fn needs_render(&self) -> bool {
+        self.render
+    }
+
+    pub fn needs_resolve(&self) -> bool {
+        self.resolve
+    }
+
+    pub fn take_render(&mut self) -> bool {
+        let state = self.render;
+        self.render = false;
+        state
+    }
+
+    pub fn take_resolve(&mut self) -> bool {
+        let state = self.resolve;
+        self.resolve = false;
+        state
+    }
+}
+
 pub struct Interface {
-    windows: Vec<(Window, bool, bool)>,
+    windows: Vec<(Window, PostUpdate<PerWindow>)>,
     window_cache: WindowCache,
     interface_settings: InterfaceSettings,
     available_space: Size,
@@ -72,8 +131,7 @@ pub struct Interface {
     dialog_handle: Option<DialogHandle>,
     mouse_cursor: MouseCursor,
     mouse_cursor_hidden: bool,
-    reresolve: bool,
-    rerender: bool,
+    post_update: PostUpdate<Self>,
 }
 
 impl Interface {
@@ -89,6 +147,8 @@ impl Interface {
         let dialog_handle = None;
         let mouse_cursor = MouseCursor::new(game_file_loader, sprite_loader, action_loader);
         let mouse_cursor_hidden = false;
+        // NOTE: We need to initially clear the interface buffer
+        let post_update = PostUpdate::new().with_render();
 
         Self {
             windows: Vec::new(),
@@ -99,8 +159,7 @@ impl Interface {
             dialog_handle,
             mouse_cursor,
             mouse_cursor_hidden,
-            reresolve: false,
-            rerender: true, // set to true initially to clear the interface buffer
+            post_update,
         }
     }
 
@@ -116,7 +175,7 @@ impl Interface {
     #[profile]
     pub fn reload_theme(&mut self) {
         if self.theme.reload(&self.interface_settings.theme_file) {
-            self.reresolve = true;
+            self.post_update.resolve();
         }
     }
 
@@ -124,18 +183,14 @@ impl Interface {
         &self.theme
     }
 
-    pub fn schedule_rerender(&mut self) {
-        self.rerender = true;
+    pub fn schedule_render(&mut self) {
+        self.post_update.render();
     }
 
-    pub fn schedule_rerender_window(&mut self, window_index: usize) {
+    pub fn schedule_render_window(&mut self, window_index: usize) {
         if window_index < self.windows.len() {
-            let (window, _reresolve, rerender) = &mut self.windows[window_index];
-
-            match window.has_transparency(&self.theme) {
-                true => self.rerender = true,
-                false => *rerender = true,
-            }
+            let (_, post_update) = &mut self.windows[window_index];
+            post_update.render();
         }
     }
 
@@ -147,27 +202,21 @@ impl Interface {
 
     /// The update and render functions take care of merging the window specific
     /// flags with the interface wide flags.
-    fn handle_change_event(
-        rerender: &mut bool,
-        reresolve: &mut bool,
-        rerender_window: &mut bool,
-        reresolve_window: &mut bool,
-        change_event: ChangeEvent,
-    ) {
-        if change_event.contains(ChangeEvent::RERENDER_WINDOW) {
-            *rerender_window = true;
+    fn handle_change_event(post_update: &mut PostUpdate<Self>, window_post_update: &mut PostUpdate<PerWindow>, change_event: ChangeEvent) {
+        if change_event.contains(ChangeEvent::RENDER_WINDOW) {
+            window_post_update.render();
         }
 
-        if change_event.contains(ChangeEvent::RERESOLVE_WINDOW) {
-            *reresolve_window = true;
+        if change_event.contains(ChangeEvent::RESOLVE_WINDOW) {
+            window_post_update.resolve();
         }
 
-        if change_event.contains(ChangeEvent::RERENDER) {
-            *rerender = true;
+        if change_event.contains(ChangeEvent::RENDER) {
+            post_update.render();
         }
 
-        if change_event.contains(ChangeEvent::RERESOLVE) {
-            *reresolve = true;
+        if change_event.contains(ChangeEvent::RESOLVE) {
+            post_update.resolve();
         }
     }
 
@@ -175,23 +224,23 @@ impl Interface {
     pub fn update(&mut self, font_loader: Rc<RefCell<FontLoader>>, focus_state: &mut FocusState, client_tick: ClientTick) -> (bool, bool) {
         self.mouse_cursor.update(client_tick);
 
-        for (window, reresolve, rerender) in &mut self.windows {
+        for (window, post_update) in &mut self.windows {
             #[cfg(feature = "debug")]
 
             profile_block!("update window");
 
             if let Some(change_event) = window.update() {
-                Self::handle_change_event(&mut self.rerender, &mut self.reresolve, rerender, reresolve, change_event);
+                Self::handle_change_event(&mut self.post_update, post_update, change_event);
             }
         }
 
         let mut restore_focus = false;
 
-        for (window_index, (window, reresolve, rerender)) in self.windows.iter_mut().enumerate() {
-            if self.reresolve || *reresolve {
+        for (window_index, (window, post_update)) in self.windows.iter_mut().enumerate() {
+            if self.post_update.needs_resolve() || post_update.take_resolve() {
                 #[cfg(feature = "debug")]
 
-                profile_block!("reresolve window");
+                profile_block!("resolve window");
 
                 let (_position, previous_size) = window.get_area();
                 let (window_class, new_position, new_size) =
@@ -208,13 +257,12 @@ impl Interface {
                     self.window_cache.register_window(window_class, new_position, new_size);
                 }
 
-                self.rerender |= previous_size.x > new_size.x || previous_size.y > new_size.y;
-
-                match window.has_transparency(&self.theme) {
-                    true => self.rerender = true,
-                    false => *rerender = true,
+                // NOTE: If the window got smaller, we need to re-render the entire interface.
+                // If it got bigger, we can just draw over the previous frame.
+                match previous_size.x > new_size.x || previous_size.y > new_size.y {
+                    true => self.post_update.render(),
+                    false => post_update.render(),
                 }
-                *reresolve = false;
             }
         }
 
@@ -222,32 +270,33 @@ impl Interface {
             self.restore_focus(focus_state);
         }
 
-        self.rerender |= self.reresolve;
-        self.reresolve = false;
+        if self.post_update.take_resolve() {
+            self.post_update.render();
+        }
 
-        if !self.rerender {
+        if !self.post_update.needs_render() {
             // We profile this block rather than the flag function itself because it calls
             // itself recursively
             #[cfg(feature = "debug")]
-            profile_block!("flag rerender windows");
+            profile_block!("flag render windows");
 
-            self.flag_rerender_windows(0, None);
+            self.flag_render_windows(0, None);
         }
 
-        (
-            self.rerender,
-            self.rerender | self.windows.iter().any(|(_window, _reresolve, rerender)| *rerender),
-        )
+        let render_interface = self.post_update.needs_render();
+        let render_window = self.post_update.needs_render() | self.windows.iter().any(|(_window, post_update)| post_update.needs_render());
+
+        (render_interface, render_window)
     }
 
     pub fn update_window_size(&mut self, screen_size: Size) {
         self.available_space = screen_size;
-        self.reresolve = true;
+        self.post_update.resolve();
     }
 
     #[profile("get hovered element")]
     pub fn hovered_element(&self, mouse_position: Position, mouse_mode: &MouseInputMode) -> (Option<ElementCell>, Option<usize>) {
-        for (window_index, (window, _reresolve, _rerender)) in self.windows.iter().enumerate().rev() {
+        for (window_index, (window, _)) in self.windows.iter().enumerate().rev() {
             match window.hovered_element(mouse_position, mouse_mode) {
                 HoverInformation::Element(hovered_element) => return (Some(hovered_element), Some(window_index)),
                 HoverInformation::Hovered => return (None, Some(window_index)),
@@ -260,57 +309,68 @@ impl Interface {
 
     #[profile]
     pub fn move_window_to_top(&mut self, window_index: usize) -> usize {
-        let (window, reresolve, _rerender) = self.windows.remove(window_index);
+        let (window, post_update) = self.windows.remove(window_index);
         let new_window_index = self.windows.len();
-        let has_transparency = window.has_transparency(&self.theme);
 
-        self.windows.push((window, reresolve, !has_transparency));
-        self.rerender |= has_transparency;
+        self.windows.push((window, post_update.with_render()));
 
         new_window_index
     }
 
     #[profile]
     pub fn left_click_element(&mut self, hovered_element: &ElementCell, window_index: usize) -> Option<ClickAction> {
-        let (_window, reresolve, _rerender) = &mut self.windows[window_index];
-        hovered_element.borrow_mut().left_click(reresolve) // TODO: add same change_event check as
-        // for input character ?
+        let (_, post_update) = &mut self.windows[window_index];
+        let mut resolve = false;
+
+        let action = hovered_element.borrow_mut().left_click(&mut resolve); // TODO: add same change_event check as for input character ?
+
+        if resolve {
+            post_update.resolve();
+        }
+
+        action
     }
 
     #[profile]
     pub fn right_click_element(&mut self, hovered_element: &ElementCell, window_index: usize) -> Option<ClickAction> {
-        let (_window, reresolve, _rerender) = &mut self.windows[window_index];
-        hovered_element.borrow_mut().right_click(reresolve) // TODO: add same change_event check as
-        // for input character ?
+        let (_, post_update) = &mut self.windows[window_index];
+        let mut resolve = false;
+
+        let action = hovered_element.borrow_mut().right_click(&mut resolve); // TODO: add same change_event check as for input character ?
+
+        if resolve {
+            post_update.resolve();
+        }
+
+        action
     }
 
     #[profile]
     pub fn drag_element(&mut self, element: &ElementCell, _window_index: usize, mouse_delta: Position) {
-        //let (_window, _reresolve, _rerender) = &mut self.windows[window_index];
+        //let (_window, post_update) = &mut self.windows[window_index];
 
         if let Some(change_event) = element.borrow_mut().drag(mouse_delta) {
-            Self::handle_change_event(&mut self.rerender, &mut self.reresolve, &mut false, &mut false, change_event);
+            // TODO: Use the window post_update here (?)
+            Self::handle_change_event(&mut self.post_update, &mut PostUpdate::new(), change_event);
         }
     }
 
     #[profile]
     pub fn scroll_element(&mut self, element: &ElementCell, window_index: usize, scroll_delta: f32) {
-        let (_, reresolve, rerender) = &mut self.windows[window_index];
+        let (_, post_update) = &mut self.windows[window_index];
 
         if let Some(change_event) = element.borrow_mut().scroll(scroll_delta) {
-            Self::handle_change_event(&mut self.rerender, &mut self.reresolve, rerender, reresolve, change_event);
+            Self::handle_change_event(&mut self.post_update, post_update, change_event);
         }
     }
 
     #[profile]
     pub fn input_character_element(&mut self, element: &ElementCell, window_index: usize, character: char) -> Option<ClickAction> {
-        let (_, reresolve, rerender) = &mut self.windows[window_index];
+        let (_, post_update) = &mut self.windows[window_index];
 
         if let Some(click_event) = element.borrow_mut().input_character(character) {
             match click_event {
-                ClickAction::ChangeEvent(change_event) => {
-                    Self::handle_change_event(&mut self.rerender, &mut self.reresolve, rerender, reresolve, change_event)
-                }
+                ClickAction::ChangeEvent(change_event) => Self::handle_change_event(&mut self.post_update, post_update, change_event),
                 other => return Some(other),
             }
         }
@@ -324,12 +384,12 @@ impl Interface {
             self.window_cache.update_position(window_class, position);
         }
 
-        self.rerender = true;
+        self.post_update.render();
     }
 
     #[profile]
     pub fn resize_window(&mut self, window_index: usize, growth: Size) {
-        let (window, reresolve, _rerender) = &mut self.windows[window_index];
+        let (window, post_update) = &mut self.windows[window_index];
 
         let (_position, previous_size) = window.get_area();
         let (window_class, new_size) = window.resize(&self.interface_settings, &self.theme, self.available_space, growth);
@@ -339,8 +399,11 @@ impl Interface {
                 self.window_cache.update_size(window_class, new_size);
             }
 
-            *reresolve = true;
-            self.rerender |= previous_size.x > new_size.x || previous_size.y > new_size.y;
+            post_update.resolve();
+
+            if previous_size.x > new_size.x || previous_size.y > new_size.y {
+                self.post_update.render();
+            }
         }
     }
 
@@ -348,25 +411,25 @@ impl Interface {
     /// re-render a window with transparency will result in re-rendering the
     /// entire interface. This serves as a single point of truth and simplifies
     /// the rest of the code.
-    fn flag_rerender_windows(&mut self, start_index: usize, area: Option<(Position, Size)>) {
+    fn flag_render_windows(&mut self, start_index: usize, area: Option<(Position, Size)>) {
         for window_index in start_index..self.windows.len() {
-            let rerender = self.windows[window_index].2;
+            let needs_render = self.windows[window_index].1.needs_render();
             let is_hovering = |(position, scale)| self.windows[window_index].0.hovers_area(position, scale);
 
-            if rerender || area.map(is_hovering).unwrap_or(false) {
+            if needs_render || area.map(is_hovering).unwrap_or(false) {
                 let (position, scale) = {
-                    let (window, _reresolve, rerender) = &mut self.windows[window_index];
+                    let (window, post_update) = &mut self.windows[window_index];
 
                     if window.has_transparency(&self.theme) {
-                        self.rerender = true;
+                        self.post_update.render();
                         return;
                     }
 
-                    *rerender = true;
+                    post_update.render();
                     window.get_area()
                 };
 
-                self.flag_rerender_windows(window_index + 1, Some((position, scale)));
+                self.flag_render_windows(window_index + 1, Some((position, scale)));
             }
         }
     }
@@ -384,8 +447,8 @@ impl Interface {
         let hovered_element = hovered_element.map(|element| unsafe { &*element.as_ptr() });
         let focused_element = focused_element.map(|element| unsafe { &*element.as_ptr() });
 
-        for (window, _reresolve, rerender) in &mut self.windows {
-            if self.rerender || *rerender {
+        for (window, post_update) in &mut self.windows {
+            if self.post_update.needs_render() || post_update.take_render() {
                 #[cfg(feature = "debug")]
                 profile_block!("render window");
 
@@ -399,11 +462,10 @@ impl Interface {
                     focused_element,
                     mouse_mode,
                 );
-                *rerender = false;
             }
         }
 
-        self.rerender = false;
+        self.post_update.take_render();
     }
 
     #[profile]
@@ -479,7 +541,7 @@ impl Interface {
     }
 
     fn open_new_window(&mut self, focus_state: &mut FocusState, window: Window) {
-        self.windows.push((window, true, true));
+        self.windows.push((window, PostUpdate::new().with_resolve()));
         focus_state.set_focused_window(self.windows.len() - 1);
     }
 
@@ -566,7 +628,7 @@ impl Interface {
     #[profile]
     pub fn close_window(&mut self, focus_state: &mut FocusState, window_index: usize) {
         let (window, ..) = self.windows.remove(window_index);
-        self.rerender = true;
+        self.post_update.render();
 
         // drop window in another thread to avoid frame drops when deallocation a large
         // amount of elements
diff --git a/src/interface/settings.rs b/src/interface/settings.rs
index 7a007969a..b87bd5706 100644
--- a/src/interface/settings.rs
+++ b/src/interface/settings.rs
@@ -9,7 +9,7 @@ use crate::interface::*;
 #[derive(Serialize, Deserialize, PrototypeElement)]
 pub struct InterfaceSettings {
     #[name("Scaling")]
-    pub scaling: MutableRange<f32, Reresolve>,
+    pub scaling: MutableRange<f32, Resolve>,
     #[hidden_element]
     pub theme_file: String,
 }
diff --git a/src/interface/theme.rs b/src/interface/theme.rs
index f84c34bde..6e3521ba6 100644
--- a/src/interface/theme.rs
+++ b/src/interface/theme.rs
@@ -10,19 +10,19 @@ use crate::interface::*;
 
 #[derive(Serialize, Deserialize, PrototypeElement)]
 pub struct ButtonTheme {
-    pub background_color: Mutable<Color, Rerender>,
-    pub hovered_background_color: Mutable<Color, Rerender>,
-    pub disabled_background_color: Mutable<Color, Rerender>,
-    pub foreground_color: Mutable<Color, Rerender>,
-    pub hovered_foreground_color: Mutable<Color, Rerender>,
-    pub disabled_foreground_color: Mutable<Color, Rerender>,
-    pub debug_foreground_color: Mutable<Color, Rerender>,
-    pub border_radius: MutableRange<Vector4<f32>, Rerender>,
-    pub icon_offset: MutableRange<Vector2<f32>, Rerender>,
-    pub icon_size: MutableRange<Vector2<f32>, Rerender>,
-    pub icon_text_offset: MutableRange<Vector2<f32>, Rerender>,
-    pub text_offset: MutableRange<Vector2<f32>, Rerender>,
-    pub font_size: MutableRange<f32, Rerender>,
+    pub background_color: Mutable<Color, Render>,
+    pub hovered_background_color: Mutable<Color, Render>,
+    pub disabled_background_color: Mutable<Color, Render>,
+    pub foreground_color: Mutable<Color, Render>,
+    pub hovered_foreground_color: Mutable<Color, Render>,
+    pub disabled_foreground_color: Mutable<Color, Render>,
+    pub debug_foreground_color: Mutable<Color, Render>,
+    pub border_radius: MutableRange<Vector4<f32>, Render>,
+    pub icon_offset: MutableRange<Vector2<f32>, Render>,
+    pub icon_size: MutableRange<Vector2<f32>, Render>,
+    pub icon_text_offset: MutableRange<Vector2<f32>, Render>,
+    pub text_offset: MutableRange<Vector2<f32>, Render>,
+    pub font_size: MutableRange<f32, Render>,
     pub height_constraint: DimensionConstraint,
 }
 
@@ -49,15 +49,15 @@ impl Default for ButtonTheme {
 
 #[derive(Serialize, Deserialize, PrototypeElement)]
 pub struct WindowTheme {
-    pub background_color: Mutable<Color, Rerender>,
-    pub title_background_color: Mutable<Color, Rerender>,
-    pub foreground_color: Mutable<Color, Rerender>,
-    pub border_radius: MutableRange<Vector4<f32>, Rerender>,
-    pub title_border_radius: MutableRange<Vector4<f32>, Rerender>,
-    pub border_size: MutableRange<Vector2<f32>, Reresolve>,
-    pub text_offset: MutableRange<Vector2<f32>, Rerender>,
-    pub gaps: MutableRange<Vector2<f32>, Reresolve>,
-    pub font_size: MutableRange<f32, Rerender>,
+    pub background_color: Mutable<Color, Render>,
+    pub title_background_color: Mutable<Color, Render>,
+    pub foreground_color: Mutable<Color, Render>,
+    pub border_radius: MutableRange<Vector4<f32>, Render>,
+    pub title_border_radius: MutableRange<Vector4<f32>, Render>,
+    pub border_size: MutableRange<Vector2<f32>, Resolve>,
+    pub text_offset: MutableRange<Vector2<f32>, Render>,
+    pub gaps: MutableRange<Vector2<f32>, Resolve>,
+    pub font_size: MutableRange<f32, Render>,
     pub title_height: DimensionConstraint,
 }
 
@@ -80,18 +80,18 @@ impl Default for WindowTheme {
 
 #[derive(Serialize, Deserialize, PrototypeElement)]
 pub struct ExpandableTheme {
-    pub background_color: Mutable<Color, Rerender>,
-    pub second_background_color: Mutable<Color, Rerender>,
-    pub foreground_color: Mutable<Color, Rerender>,
-    pub hovered_foreground_color: Mutable<Color, Rerender>,
-    pub border_radius: MutableRange<Vector4<f32>, Rerender>,
-    pub border_size: MutableRange<Vector2<f32>, Reresolve>,
-    pub element_offset: MutableRange<Vector2<f32>, Reresolve>,
-    pub icon_offset: MutableRange<Vector2<f32>, Rerender>,
-    pub icon_size: MutableRange<Vector2<f32>, Rerender>,
-    pub text_offset: MutableRange<Vector2<f32>, Rerender>,
-    pub gaps: MutableRange<Vector2<f32>, Reresolve>,
-    pub font_size: MutableRange<f32, Rerender>,
+    pub background_color: Mutable<Color, Render>,
+    pub second_background_color: Mutable<Color, Render>,
+    pub foreground_color: Mutable<Color, Render>,
+    pub hovered_foreground_color: Mutable<Color, Render>,
+    pub border_radius: MutableRange<Vector4<f32>, Render>,
+    pub border_size: MutableRange<Vector2<f32>, Resolve>,
+    pub element_offset: MutableRange<Vector2<f32>, Resolve>,
+    pub icon_offset: MutableRange<Vector2<f32>, Render>,
+    pub icon_size: MutableRange<Vector2<f32>, Render>,
+    pub text_offset: MutableRange<Vector2<f32>, Render>,
+    pub gaps: MutableRange<Vector2<f32>, Resolve>,
+    pub font_size: MutableRange<f32, Render>,
 }
 
 impl Default for ExpandableTheme {
@@ -115,11 +115,11 @@ impl Default for ExpandableTheme {
 
 #[derive(Serialize, Deserialize, PrototypeElement)]
 pub struct LabelTheme {
-    pub background_color: Mutable<Color, Rerender>,
-    pub foreground_color: Mutable<Color, Rerender>,
-    pub border_radius: MutableRange<Vector4<f32>, Rerender>,
-    pub text_offset: MutableRange<Vector2<f32>, Rerender>,
-    pub font_size: MutableRange<f32, Rerender>,
+    pub background_color: Mutable<Color, Render>,
+    pub foreground_color: Mutable<Color, Render>,
+    pub border_radius: MutableRange<Vector4<f32>, Render>,
+    pub text_offset: MutableRange<Vector2<f32>, Render>,
+    pub font_size: MutableRange<f32, Render>,
     pub size_constraint: SizeConstraint,
 }
 
@@ -138,12 +138,12 @@ impl Default for LabelTheme {
 
 #[derive(Serialize, Deserialize, PrototypeElement)]
 pub struct ValueTheme {
-    pub background_color: Mutable<Color, Rerender>,
-    pub hovered_background_color: Mutable<Color, Rerender>,
-    pub foreground_color: Mutable<Color, Rerender>,
-    pub border_radius: MutableRange<Vector4<f32>, Rerender>,
-    pub text_offset: MutableRange<Vector2<f32>, Rerender>,
-    pub font_size: MutableRange<f32, Rerender>,
+    pub background_color: Mutable<Color, Render>,
+    pub hovered_background_color: Mutable<Color, Render>,
+    pub foreground_color: Mutable<Color, Render>,
+    pub border_radius: MutableRange<Vector4<f32>, Render>,
+    pub text_offset: MutableRange<Vector2<f32>, Render>,
+    pub font_size: MutableRange<f32, Render>,
     pub size_constraint: SizeConstraint,
 }
 
@@ -163,12 +163,12 @@ impl Default for ValueTheme {
 
 #[derive(Serialize, Deserialize, PrototypeElement)]
 pub struct CloseButtonTheme {
-    pub background_color: Mutable<Color, Rerender>,
-    pub hovered_background_color: Mutable<Color, Rerender>,
-    pub foreground_color: Mutable<Color, Rerender>,
-    pub border_radius: MutableRange<Vector4<f32>, Rerender>,
-    pub text_offset: MutableRange<Vector2<f32>, Rerender>,
-    pub font_size: MutableRange<f32, Rerender>,
+    pub background_color: Mutable<Color, Render>,
+    pub hovered_background_color: Mutable<Color, Render>,
+    pub foreground_color: Mutable<Color, Render>,
+    pub border_radius: MutableRange<Vector4<f32>, Render>,
+    pub text_offset: MutableRange<Vector2<f32>, Render>,
+    pub font_size: MutableRange<f32, Render>,
     pub size_constraint: SizeConstraint,
 }
 
@@ -205,9 +205,9 @@ impl Default for OverlayTheme {
 
 #[derive(Serialize, Deserialize, PrototypeElement)]
 pub struct SliderTheme {
-    pub background_color: Mutable<Color, Rerender>,
-    pub rail_color: Mutable<Color, Rerender>,
-    pub knob_color: Mutable<Color, Rerender>,
+    pub background_color: Mutable<Color, Render>,
+    pub rail_color: Mutable<Color, Render>,
+    pub knob_color: Mutable<Color, Render>,
     pub size_constraint: SizeConstraint,
 }
 
@@ -224,17 +224,17 @@ impl Default for SliderTheme {
 
 #[derive(Serialize, Deserialize, PrototypeElement)]
 pub struct InputTheme {
-    pub background_color: Mutable<Color, Rerender>,
-    pub hovered_background_color: Mutable<Color, Rerender>,
-    pub focused_background_color: Mutable<Color, Rerender>,
-    pub text_color: Mutable<Color, Rerender>,
-    pub ghost_text_color: Mutable<Color, Rerender>,
-    pub focused_text_color: Mutable<Color, Rerender>,
-    pub border_radius: MutableRange<Vector4<f32>, Rerender>,
-    pub font_size: MutableRange<f32, Rerender>,
-    pub text_offset: MutableRange<f32, Rerender>,
-    pub cursor_offset: MutableRange<f32, Rerender>,
-    pub cursor_width: MutableRange<f32, Rerender>,
+    pub background_color: Mutable<Color, Render>,
+    pub hovered_background_color: Mutable<Color, Render>,
+    pub focused_background_color: Mutable<Color, Render>,
+    pub text_color: Mutable<Color, Render>,
+    pub ghost_text_color: Mutable<Color, Render>,
+    pub focused_text_color: Mutable<Color, Render>,
+    pub border_radius: MutableRange<Vector4<f32>, Render>,
+    pub font_size: MutableRange<f32, Render>,
+    pub text_offset: MutableRange<f32, Render>,
+    pub cursor_offset: MutableRange<f32, Render>,
+    pub cursor_width: MutableRange<f32, Render>,
     pub height_constraint: DimensionConstraint,
 }
 
@@ -259,8 +259,8 @@ impl Default for InputTheme {
 
 #[derive(Serialize, Deserialize, PrototypeElement)]
 pub struct ChatTheme {
-    pub background_color: Mutable<Color, Rerender>,
-    pub font_size: MutableRange<f32, Rerender>,
+    pub background_color: Mutable<Color, Render>,
+    pub font_size: MutableRange<f32, Render>,
 }
 
 impl Default for ChatTheme {
@@ -287,18 +287,18 @@ impl Default for CursorTheme {
 
 #[derive(Serialize, Deserialize, PrototypeElement)]
 pub struct ProfilerTheme {
-    pub background_color: Mutable<Color, Rerender>,
-    pub border_radius: MutableRange<Vector4<f32>, Rerender>,
-    pub line_color: Mutable<Color, Rerender>,
-    pub line_width: MutableRange<f32, Rerender>,
-    pub bar_height: MutableRange<f32, Rerender>,
-    pub bar_gap: MutableRange<Vector2<f32>, Rerender>,
-    pub bar_border_radius: MutableRange<Vector4<f32>, Rerender>,
-    pub bar_text_color: Mutable<Color, Rerender>,
-    pub bar_text_size: MutableRange<f32, Rerender>,
-    pub bar_text_offset: MutableRange<Vector2<f32>, Rerender>,
-    pub distance_text_size: MutableRange<f32, Rerender>,
-    pub distance_text_offset: MutableRange<f32, Rerender>,
+    pub background_color: Mutable<Color, Render>,
+    pub border_radius: MutableRange<Vector4<f32>, Render>,
+    pub line_color: Mutable<Color, Render>,
+    pub line_width: MutableRange<f32, Render>,
+    pub bar_height: MutableRange<f32, Render>,
+    pub bar_gap: MutableRange<Vector2<f32>, Render>,
+    pub bar_border_radius: MutableRange<Vector4<f32>, Render>,
+    pub bar_text_color: Mutable<Color, Render>,
+    pub bar_text_size: MutableRange<f32, Render>,
+    pub bar_text_offset: MutableRange<Vector2<f32>, Render>,
+    pub distance_text_size: MutableRange<f32, Render>,
+    pub distance_text_offset: MutableRange<f32, Render>,
 }
 
 impl Default for ProfilerTheme {
@@ -327,14 +327,14 @@ pub struct StatusBarTheme {
     pub enemy_health_color: Mutable<Color, Nothing>,
     pub spell_point_color: Mutable<Color, Nothing>,
     pub activity_point_color: Mutable<Color, Nothing>,
-    pub player_bar_width: MutableRange<f32, Rerender>,
-    pub enemy_bar_width: MutableRange<f32, Rerender>,
-    pub health_height: MutableRange<f32, Rerender>,
-    pub enemy_health_height: MutableRange<f32, Rerender>,
-    pub spell_point_height: MutableRange<f32, Rerender>,
-    pub activity_point_height: MutableRange<f32, Rerender>,
-    pub border_size: MutableRange<Vector2<f32>, Rerender>,
-    pub gap: MutableRange<f32, Rerender>,
+    pub player_bar_width: MutableRange<f32, Render>,
+    pub enemy_bar_width: MutableRange<f32, Render>,
+    pub health_height: MutableRange<f32, Render>,
+    pub enemy_health_height: MutableRange<f32, Render>,
+    pub spell_point_height: MutableRange<f32, Render>,
+    pub activity_point_height: MutableRange<f32, Render>,
+    pub border_size: MutableRange<Vector2<f32>, Render>,
+    pub gap: MutableRange<f32, Render>,
 }
 
 impl Default for StatusBarTheme {
@@ -359,7 +359,7 @@ impl Default for StatusBarTheme {
 
 #[derive(Serialize, Deserialize, PrototypeElement)]
 pub struct IndicatorTheme {
-    pub walking: Mutable<Color, Rerender>,
+    pub walking: Mutable<Color, Render>,
 }
 
 impl Default for IndicatorTheme {
diff --git a/src/main.rs b/src/main.rs
index b8052088d..ddad9d67d 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -761,7 +761,7 @@ fn main() {
 
                             // NOTE: For some reason the interface buffer becomes messed up when
                             // recreating the swapchain, so we need to render it again.
-                            interface.schedule_rerender();
+                            interface.schedule_render();
                         }
                         UserEvent::ToggleShowInterface => graphics_settings.toggle_show_interface(),
                         UserEvent::OpenMenuWindow => {
@@ -1028,7 +1028,7 @@ fn main() {
 
                             // NOTE: For some reason the interface buffer becomes messed up when
                             // recreating the swapchain, so we need to render it again.
-                            interface.schedule_rerender();
+                            interface.schedule_render();
                         }
                         #[cfg(feature = "debug")]
                         UserEvent::ToggleShowMap => render_settings.toggle_show_map(),
@@ -1119,7 +1119,7 @@ fn main() {
                 particle_holder.update(delta_time as f32);
                 effect_holder.update(&entities, delta_time as f32);
 
-                let (clear_interface, rerender_interface) = interface.update(font_loader.clone(), &mut focus_state, client_tick);
+                let (clear_interface, render_interface) = interface.update(font_loader.clone(), &mut focus_state, client_tick);
 
                 if swapchain_holder.is_swapchain_invalid() {
                     #[cfg(feature = "debug")]
@@ -1409,7 +1409,7 @@ fn main() {
                         effect_holder.render(screen_target, &deferred_renderer, current_camera);
                     });
 
-                    if rerender_interface {
+                    if render_interface {
                         #[cfg(feature = "debug")]
                         profile_block!("render user interface");