General cleanup

korangar/Cargo.toml

@@ -20,8 +20,7 @@ num = { workspace = true }
 option-ext = "0.2.0"
 pathfinding = "2.2.2"
 korangar_procedural = { workspace = true }
-ragnarok_bytes = { workspace = true, features = ["cgmath"] }
-ragnarok_procedural = { workspace = true }
+ragnarok_bytes = { workspace = true, features = ["derive", "cgmath"] }
 rand = "0.8.5"
 random_color = { version = "0.6.1", optional = true }
 rayon = "1.5.3"

korangar/src/graphics/color.rs

@@ -1,5 +1,5 @@
 use korangar_procedural::PrototypeElement;
-use ragnarok_procedural::ByteConvertable;
+use ragnarok_bytes::ByteConvertable;
 use serde::{Deserialize, Serialize};
 
 #[derive(Copy, Clone, Debug, Default, PartialEq, Serialize, Deserialize)]

korangar/src/graphics/renderers/mod.rs

@@ -340,6 +340,7 @@ impl DeferredRenderTarget {
             .unwrap();
 
         self.state = RenderTargetState::Rendering(builder);
+        self.bound_subrenderer = None;
     }
 
     pub fn bind_subrenderer(&mut self, subrenderer: DeferredSubrenderer) -> bool {
@@ -405,8 +406,6 @@ impl DeferredRenderTarget {
 
         #[cfg(feature = "debug")]
         flush_measurement.stop();
-
-        self.bound_subrenderer = None;
     }
 }
 
@@ -481,6 +480,7 @@ impl PickerRenderTarget {
             .unwrap();
 
         self.state = RenderTargetState::Rendering(builder);
+        self.bound_subrenderer = None;
     }
 
     #[profile]
@@ -511,7 +511,6 @@ impl PickerRenderTarget {
             .unwrap();
 
         self.state = RenderTargetState::Fence(fence);
-        self.bound_subrenderer = None;
     }
 }
 
@@ -602,7 +601,9 @@ impl<F: IntoFormat, S: PartialEq> SingleRenderTarget<F, S, ClearValue> {
         builder
             .begin_render_pass(render_pass_begin_info, SubpassBeginInfo::default())
             .unwrap();
+
         self.state = RenderTargetState::Rendering(builder);
+        self.bound_subrenderer = None;
     }
 
     #[profile("finalize buffer")]
@@ -620,7 +621,6 @@ impl<F: IntoFormat, S: PartialEq> SingleRenderTarget<F, S, ClearValue> {
             .unwrap();
 
         self.state = RenderTargetState::Semaphore(semaphore);
-        self.bound_subrenderer = None;
     }
 }
 
@@ -666,6 +666,7 @@ impl<F: IntoFormat, S: PartialEq> SingleRenderTarget<F, S, ClearColorValue> {
         }
 
         self.state = RenderTargetState::Rendering(builder);
+        self.bound_subrenderer = None;
     }
 
     #[profile("finish buffer")]
@@ -690,6 +691,5 @@ impl<F: IntoFormat, S: PartialEq> SingleRenderTarget<F, S, ClearColorValue> {
             .unwrap();
 
         self.state = RenderTargetState::Semaphore(semaphore);
-        self.bound_subrenderer = None;
     }
 }

korangar/src/input/mode.rs

@@ -1,7 +1,8 @@
 use std::sync::Arc;
 
 use cgmath::Vector2;
-use korangar_interface::elements::ElementCell;
+use korangar_interface::elements::{Element, ElementCell};
+use korangar_interface::settings::MouseInputModeTrait;
 use vulkano::image::view::ImageView;
 
 use crate::interface::application::Adapter;
@@ -50,12 +51,12 @@ impl MouseInputMode {
     }
 }
 
-impl korangar_interface::settings::MouseInputModeTrait<Adapter> for MouseInputMode {
+impl MouseInputModeTrait<Adapter> for MouseInputMode {
     fn is_none(&self) -> bool {
         matches!(self, MouseInputMode::None)
     }
 
-    fn is_self_dragged(&self, element: &dyn korangar_interface::elements::Element<Adapter>) -> bool {
+    fn is_self_dragged(&self, element: &dyn Element<Adapter>) -> bool {
         matches!(self, Self::DragElement(dragged_element) if std::ptr::eq((&*dragged_element.0.borrow()) as *const _ as *const (), element as *const _ as *const ()))
     }
 }

korangar/src/interface/application.rs

@@ -13,7 +13,7 @@ use walkdir::WalkDir;
 use super::elements::MutableRange;
 use super::layout::{CornerRadius, PartialScreenSize, ScreenClip, ScreenPosition, ScreenSize};
 use super::resource::{Move, PartialMove};
-use super::theme::{GameTheme, InterfaceTheme, Main, Menu, ThemeKind, Themes};
+use super::theme::{DefaultMain, DefaultMenu, GameTheme, InterfaceTheme, InterfaceThemeKind, Themes};
 use super::windows::WindowCache;
 use crate::graphics::{Color, InterfaceRenderer};
 use crate::input::{MouseInputMode, UserEvent};
@@ -260,11 +260,11 @@ impl Adapter {
             scaling,
         } = AdapterStorage::load_or_default();
 
-        let themes = Themes {
-            menu: InterfaceTheme::new::<super::theme::Menu>(&menu_theme),
-            main: InterfaceTheme::new::<super::theme::Main>(&main_theme),
-            game: GameTheme::new(&menu_theme),
-        };
+        let themes = Themes::new(
+            InterfaceTheme::new::<super::theme::DefaultMenu>(&menu_theme),
+            InterfaceTheme::new::<super::theme::DefaultMain>(&main_theme),
+            GameTheme::new(&menu_theme),
+        );
 
         Self {
             main_theme: ThemeSelector(main_theme),
@@ -311,8 +311,8 @@ impl Adapter {
     #[profile]
     pub fn reload_theme(&mut self, kind: InternalThemeKind) {
         match kind {
-            InternalThemeKind::Menu => self.themes.menu.reload::<Menu>(self.menu_theme.get_file()),
-            InternalThemeKind::Main => self.themes.main.reload::<Main>(self.main_theme.get_file()),
+            InternalThemeKind::Menu => self.themes.menu.reload::<DefaultMenu>(self.menu_theme.get_file()),
+            InternalThemeKind::Main => self.themes.main.reload::<DefaultMain>(self.main_theme.get_file()),
             InternalThemeKind::Game => self.themes.game.reload(self.game_theme.get_file()),
         }
     }
@@ -335,16 +335,16 @@ impl Application for Adapter {
     type Scaling = Scaling;
     type Size = ScreenSize;
     type Theme = InterfaceTheme;
-    type ThemeKind = ThemeKind;
+    type ThemeKind = InterfaceThemeKind;
 
     fn get_scaling(&self) -> Self::Scaling {
         self.scaling.get()
     }
 
-    fn get_theme(&self, kind: &ThemeKind) -> &InterfaceTheme {
+    fn get_theme(&self, kind: &InterfaceThemeKind) -> &InterfaceTheme {
         match kind {
-            ThemeKind::Menu => &self.themes.menu,
-            ThemeKind::Main => &self.themes.main,
+            InterfaceThemeKind::Menu => &self.themes.menu,
+            InterfaceThemeKind::Main => &self.themes.main,
         }
     }
 }

korangar/src/interface/elements/containers/equipment.rs

@@ -18,7 +18,6 @@ use crate::network::EquipPosition;
 
 pub struct EquipmentContainer {
     items: RawRemote<Vec<Item>>,
-    weak_self: Option<WeakElementCell<Adapter>>, // TODO: maybe remove?
     state: ContainerState<Adapter>,
 }
 
@@ -62,10 +61,9 @@ impl EquipmentContainer {
                 .collect()
         };
 
-        let weak_self = None;
         let state = ContainerState::new(elements);
 
-        Self { items, weak_self, state }
+        Self { items, state }
     }
 }
 
@@ -79,7 +77,6 @@ impl Element<Adapter> for EquipmentContainer {
     }
 
     fn link_back(&mut self, weak_self: WeakElementCell<Adapter>, weak_parent: Option<WeakElementCell<Adapter>>) {
-        self.weak_self = Some(weak_self.clone());
         self.state.link_back(weak_self, weak_parent);
     }
 
@@ -109,7 +106,7 @@ impl Element<Adapter> for EquipmentContainer {
     fn update(&mut self) -> Option<ChangeEvent> {
         if self.items.consume_changed() {
             let weak_parent = self.state.state.parent_element.take();
-            let weak_self = self.weak_self.take().unwrap();
+            let weak_self = self.state.state.self_element.take().unwrap();
 
             *self = Self::new(self.items.clone());
             // important: link back after creating elements, otherwise focus navigation and

korangar/src/interface/elements/miscellanious/item.rs

@@ -99,14 +99,6 @@ impl Element<Adapter> for ItemBox {
         renderer.render_background(CornerRadius::uniform(5.0), background_color);
 
         if let Some(item) = &self.item {
-            renderer.render_text(
-                //&format!("{}", self.item.amount),
-                "1",
-                ScreenPosition::default(),
-                theme.button.foreground_color.get(),
-                FontSize::new(8.0),
-            );
-
             renderer.renderer.render_sprite(
                 renderer.render_target,
                 item.texture.clone(),
@@ -116,6 +108,14 @@ impl Element<Adapter> for ItemBox {
                 Color::monochrome_u8(255),
                 false,
             );
+
+            renderer.render_text(
+                //&format!("{}", self.item.amount),
+                "1",
+                ScreenPosition::default(),
+                theme.button.foreground_color.get(),
+                FontSize::new(8.0),
+            );
         }
     }
 }

korangar/src/interface/elements/values/color.rs

@@ -1,64 +1,120 @@
+use korangar_interface::elements::{Element, ElementState};
+use korangar_interface::event::{ChangeEvent, ClickAction, HoverInformation};
+use korangar_interface::layout::PlacementResolver;
+
 use crate::graphics::{Color, InterfaceRenderer, Renderer};
-use crate::interface::{Element, *};
+use crate::input::MouseInputMode;
+use crate::interface::application::Adapter;
+use crate::interface::layout::{ScreenClip, ScreenPosition};
+use crate::interface::theme::InterfaceTheme;
+use crate::interface::windows::ColorWindow;
 
-pub struct ColorValue {
-    color: Color,
-    display: String,
-    state: ElementState,
+pub struct MutableColorValue {
+    name: String,
+    reference: &'static Color,
+    change_event: Option<ChangeEvent>,
+    cached_color: Color,
+    cached_values: String,
+    state: ElementState<Adapter>,
 }
 
-impl ColorValue {
-    pub fn new(color: Color) -> Self {
-        let display = format!(
+impl MutableColorValue {
+    pub fn new(name: String, reference: &'static Color, change_event: Option<ChangeEvent>) -> Self {
+        let cached_color = *reference;
+        let cached_values = format!(
             "{}, {}, {}, {}",
-            color.red_as_u8(),
-            color.green_as_u8(),
-            color.blue_as_u8(),
-            color.alpha_as_u8()
+            cached_color.red_as_u8(),
+            cached_color.green_as_u8(),
+            cached_color.blue_as_u8(),
+            cached_color.alpha_as_u8()
         );
         let state = ElementState::default();
 
-        Self { color, display, state }
+        Self {
+            name,
+            reference,
+            change_event,
+            cached_color,
+            cached_values,
+            state,
+        }
     }
 }
 
-impl Element<Application> for ColorValue {
-    fn get_state(&self) -> &ElementState<Application>{
+impl Element<Adapter> for MutableColorValue {
+    fn get_state(&self) -> &ElementState<Adapter> {
         &self.state
     }
 
-    fn get_state_mut(&mut self) -> &mut ElementState<Application>{
+    fn get_state_mut(&mut self) -> &mut ElementState<Adapter> {
         &mut self.state
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver<Application>, _application: &Application, theme: &InterfaceTheme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver<Adapter>, _application: &Adapter, theme: &InterfaceTheme) {
         self.state.resolve(placement_resolver, &theme.value.size_bound);
     }
 
+    fn update(&mut self) -> Option<ChangeEvent> {
+        let current_color = *self.reference;
+
+        if self.cached_color != current_color {
+            self.cached_color = current_color;
+            self.cached_values = format!(
+                "{}, {}, {}, {}",
+                self.cached_color.red_as_u8(),
+                self.cached_color.green_as_u8(),
+                self.cached_color.blue_as_u8(),
+                self.cached_color.alpha_as_u8()
+            );
+            return Some(ChangeEvent::RENDER_WINDOW);
+        }
+
+        None
+    }
+
+    fn hovered_element(&self, mouse_position: ScreenPosition, mouse_mode: &MouseInputMode) -> HoverInformation<Adapter> {
+        match mouse_mode {
+            MouseInputMode::None => self.state.hovered_element(mouse_position),
+            _ => HoverInformation::Missed,
+        }
+    }
+
+    fn left_click(&mut self, _force_update: &mut bool) -> Vec<ClickAction<Adapter>> {
+        vec![ClickAction::OpenWindow(Box::new(ColorWindow::new(
+            self.name.clone(),
+            self.reference,
+            self.change_event,
+        )))]
+    }
+
     fn render(
         &self,
         render_target: &mut <InterfaceRenderer as Renderer>::Target,
         renderer: &InterfaceRenderer,
-
-        application: &Application,
+        application: &Adapter,
         theme: &InterfaceTheme,
         parent_position: ScreenPosition,
         screen_clip: ScreenClip,
-        _hovered_element: Option<&dyn Element<Application>>,
-        _focused_element: Option<&dyn Element<Application>>,
+        hovered_element: Option<&dyn Element<Adapter>>,
+        _focused_element: Option<&dyn Element<Adapter>>,
         _mouse_mode: &MouseInputMode,
         _second_theme: bool,
     ) {
         let mut renderer = self
             .state
             .element_renderer(render_target, renderer, application, parent_position, screen_clip);
 
-        renderer.render_background(theme.value.corner_radius.get(), self.color);
+        let background_color = match self.is_element_self(hovered_element) {
+            true => self.cached_color.shade(),
+            false => self.cached_color,
+        };
+
+        renderer.render_background(theme.value.corner_radius.get(), background_color);
 
         renderer.render_text(
-            &self.display,
+            &self.cached_values,
             theme.value.text_offset.get(),
-            self.color.invert(),
+            self.cached_color.invert(),
             theme.value.font_size.get(),
         );
     }