#![allow(
clippy::cast_precision_loss,
clippy::float_cmp,
clippy::items_after_statements,
clippy::struct_excessive_bools
)]
use crate::assets::{Assets, Handle, Texture};
use crate::canvas::draw::{DrawList, Rect, SpriteInstance};
use crate::canvas::text::{HAlign, TextChannel, TextRenderer, TextStyle, VAlign};
use sgl_core::math::Vec2;
mod button;
mod input;
mod layout;
mod number_field;
mod popup;
#[cfg(test)]
mod test_ui;
mod text_edit;
mod theme;
pub use crate::fps::FpsCounter;
pub use button::IconButton;
pub use input::{UiInput, UiKey};
pub use layout::{Splitter, SplitterAxis, SplitterResponse, UiCursor};
pub use number_field::NumberField;
pub use theme::UiTheme;
use input::FocusTarget;
use layout::SplitterDrag;
use number_field::NumberDrag;
use text_edit::EditState;
pub const PANEL_COLOR: [f32; 4] = [0.1, 0.1, 0.1, 0.6];
const BUTTON_NORMAL: [f32; 4] = [0.1, 0.1, 0.1, 0.6];
const BUTTON_HOVER: [f32; 4] = [0.225, 0.225, 0.225, 0.6];
const BUTTON_PRESSED: [f32; 4] = [0.0, 0.0, 0.0, 0.6];
const FONT_NORMAL: [f32; 4] = [0.875, 0.875, 0.875, 1.0];
const FONT_HOVER: [f32; 4] = [0.95, 0.95, 0.95, 1.0];
const FONT_PRESSED: [f32; 4] = [1.0, 1.0, 1.0, 1.0];
const ACCENT: [f32; 4] = [0.44, 0.73, 0.98, 1.0];
const CARET: [f32; 4] = [0.95, 0.95, 0.95, 1.0];
const CARET_BLINK: f32 = 1.0;
const WIDGET_OUTLINE: f32 = 1.0;
fn widget_id(name: &str) -> u64 {
let mut hash: u64 = 0xcbf2_9ce4_8422_2325;
for b in name.bytes() {
hash ^= u64::from(b);
hash = hash.wrapping_mul(0x100_0000_01b3);
}
hash
}
fn contains(rect: &Rect, p: Vec2) -> bool {
p.x >= rect.min.x && p.x < rect.max.x && p.y >= rect.min.y && p.y < rect.max.y
}
const SCROLLBAR_TRACK: [f32; 4] = [0.0, 0.0, 0.0, 0.35];
const SCROLLBAR_THUMB: [f32; 4] = [0.5, 0.5, 0.5, 0.8];
const SCROLLBAR_THUMB_HOVER: [f32; 4] = [0.65, 0.65, 0.65, 0.9];
const OVERLAY_Z: f32 = 2_097_152.0;
const POPOVER_Z: f32 = 4_194_304.0;
const MODAL_Z: f32 = 8_388_608.0;
const MAX_UI_Z: f32 = 16_777_216.0;
const POPOVER_BG: [f32; 4] = [0.08, 0.08, 0.08, 0.98];
const MODAL_DIM: [f32; 4] = [0.0, 0.0, 0.0, 0.55];
pub struct Ui {
white: Handle<Texture>,
theme: UiTheme,
active: Option<u64>,
focus: Option<u64>,
focus_order: Vec<FocusTarget>,
edit: EditState,
keyboard_captured: bool,
clipboard_text: Option<String>,
clock: f32,
open_popup: Option<u64>,
blocked: Vec<Rect>,
popover_blocked: Option<(u64, Rect)>,
modal_blocking: bool,
modal_scope: Option<u64>,
thumb_drag: Option<(u64, f32)>,
number_drag: Option<NumberDrag>,
number_edit: String,
splitter_drag: Option<SplitterDrag>,
pointer_consumed: bool,
}
impl Ui {
pub fn new(assets: &mut Assets<Texture>) -> Self {
let white = crate::assets::white_texture(assets);
Self {
white,
theme: UiTheme::default(),
active: None,
focus: None,
focus_order: Vec::new(),
edit: EditState::default(),
keyboard_captured: false,
clipboard_text: None,
clock: 0.0,
open_popup: None,
blocked: Vec::new(),
popover_blocked: None,
modal_blocking: false,
modal_scope: None,
thumb_drag: None,
number_drag: None,
number_edit: String::new(),
splitter_drag: None,
pointer_consumed: false,
}
}
pub fn set_theme(&mut self, theme: UiTheme) {
self.theme = theme;
}
#[must_use]
pub fn theme(&self) -> &UiTheme {
&self.theme
}
#[must_use]
pub fn white_texture(&self) -> Handle<Texture> {
self.white
}
#[must_use]
pub fn pointer_captured(&self) -> bool {
self.pointer_consumed || self.splitter_drag.is_some()
}
#[must_use]
pub fn has_focus(&self) -> bool {
self.focus.is_some() && self.edit.id == self.focus
}
#[must_use]
pub fn keyboard_captured(&self) -> bool {
self.keyboard_captured || self.focus.is_some() || self.any_popup_open()
}
pub fn take_clipboard_text(&mut self) -> Option<String> {
self.clipboard_text.take()
}
#[cfg(test)]
fn is_focused_name(&self, name: &str) -> bool {
self.focus == Some(widget_id(name))
}
#[must_use]
pub fn any_popup_open(&self) -> bool {
self.open_popup.is_some()
}
pub fn close_popups(&mut self) {
self.open_popup = None;
}
pub fn cancel_interactions(&mut self) {
self.active = None;
self.thumb_drag = None;
self.number_drag = None;
self.splitter_drag = None;
self.pointer_consumed = false;
self.open_popup = None;
}
pub fn clear_focus(&mut self) {
self.focus = None;
}
pub fn begin<'a>(
&'a mut self,
text: &'a mut TextRenderer,
list: &'a mut DrawList,
input: UiInput,
) -> UiFrame<'a> {
self.clock = (self.clock + input.dt) % CARET_BLINK;
if input.mouse_pressed && input.mouse_released && input.mouse_down {
self.active = None;
self.thumb_drag = None;
self.number_drag = None;
self.splitter_drag = None;
}
self.pointer_consumed = self.splitter_drag.is_some();
self.keyboard_captured =
self.focus.is_some() || self.open_popup.is_some() || self.modal_blocking;
if input.keys.contains(&UiKey::Tab) {
let candidates: Vec<_> = self
.focus_order
.iter()
.filter(|target| {
if let Some(popup) = self.open_popup {
target.popup == Some(popup)
} else {
target.popup.is_none()
&& (!self.modal_blocking || target.modal == self.modal_scope)
}
})
.collect();
if !candidates.is_empty() {
let at = candidates
.iter()
.position(|target| Some(target.id) == self.focus);
let next = match (at, input.shift) {
(Some(i), true) => (i + candidates.len() - 1) % candidates.len(),
(Some(i), false) => (i + 1) % candidates.len(),
(None, true) => candidates.len() - 1,
(None, false) => 0,
};
self.focus = Some(candidates[next].id);
self.keyboard_captured = true;
}
}
let popup_dismissed = input.keys.contains(&UiKey::Escape) && self.open_popup.is_some();
if popup_dismissed {
self.focus = self.open_popup.take();
}
if self.open_popup.is_none() {
self.popover_blocked = None;
}
UiFrame {
ui: self,
text,
list,
input,
z: 0.0,
z_overlay: OVERLAY_Z,
z_popover: POPOVER_Z,
z_modal: MODAL_Z,
overlay: false,
clip: None,
new_blocked: Vec::new(),
new_popover_blocked: None,
new_modal: None,
modal_scope: None,
edit_clicked: false,
focus_order: Vec::new(),
popup_scope: None,
popup_dismissed,
key_used: false,
focus_requested: false,
splitter_seen: false,
popup_seen: false,
scroll_scopes: Vec::new(),
wheel_consumed: false,
}
}
}
pub struct UiFrame<'a> {
ui: &'a mut Ui,
text: &'a mut TextRenderer,
list: &'a mut DrawList,
input: UiInput,
z: f32,
z_overlay: f32,
z_popover: f32,
z_modal: f32,
overlay: bool,
clip: Option<Rect>,
new_blocked: Vec<Rect>,
new_popover_blocked: Option<(u64, Rect)>,
new_modal: Option<u64>,
modal_scope: Option<u64>,
edit_clicked: bool,
focus_order: Vec<FocusTarget>,
popup_scope: Option<u64>,
popup_dismissed: bool,
key_used: bool,
focus_requested: bool,
splitter_seen: bool,
popup_seen: bool,
scroll_scopes: Vec<layout::ScrollScope>,
wheel_consumed: bool,
}
impl UiFrame<'_> {
fn next_z(&mut self) -> f32 {
let (z, cap) = if self.modal_scope.is_some() {
(&mut self.z_modal, MAX_UI_Z)
} else if self.popup_scope.is_some() {
(&mut self.z_popover, MODAL_Z - 1.0)
} else if self.overlay {
(&mut self.z_overlay, POPOVER_Z - 1.0)
} else {
(&mut self.z, OVERLAY_Z - 1.0)
};
*z = (*z + 1.0).min(cap);
*z
}
fn hit(&self, rect: &Rect) -> bool {
let p = self.input.mouse_pos;
self.ui.splitter_drag.is_none()
&& contains(rect, p)
&& self.clip.is_none_or(|c| contains(&c, p))
&& if self.modal_scope.is_some() {
self.modal_scope == self.ui.modal_scope
} else {
!self.ui.modal_blocking
}
&& self.ui.popover_blocked.is_none_or(|(owner, blocked)| {
!contains(&blocked, p) || self.popup_scope == Some(owner)
})
&& (self.overlay || !self.ui.blocked.iter().any(|r| contains(r, p)))
}
#[must_use]
pub fn hovered(&self, rect: &Rect) -> bool {
self.hit(rect)
}
#[must_use]
pub fn mouse_pos(&self) -> Vec2 {
self.input.mouse_pos
}
#[must_use]
pub fn measure_text(&self, text: &str, px: f32) -> Vec2 {
self.text.measure(text, px)
}
pub fn set_clip(&mut self, clip: Option<Rect>) {
self.clip = clip;
self.text.set_clip(clip);
}
fn clip_within(&self, rect: Rect) -> Rect {
self.clip.map_or(rect, |clip| {
clip.intersection(&rect)
.unwrap_or(Rect::new(0.0, 0.0, 0.0, 0.0))
})
}
pub fn rect(&mut self, rect: Rect, color: [f32; 4]) {
let z = self.next_z();
let size = rect.size();
self.list.push_screen(SpriteInstance {
scale: size,
color,
z,
clip: self.clip,
..SpriteInstance::new(self.ui.white, rect.min + size * 0.5)
});
}
pub fn panel(&mut self, rect: Rect) {
self.rect(rect, self.ui.theme.panel);
}
pub fn sprite(&mut self, instance: SpriteInstance) {
let z = self.next_z();
let clip = instance.clip.or(self.clip);
self.list.push_screen(SpriteInstance {
z,
clip,
..instance
});
}
pub fn border(&mut self, rect: Rect, width: f32, color: [f32; 4]) {
let (w, size) = (width, rect.size());
let full_w = size.x + 2.0 * w;
self.rect(Rect::new(rect.min.x - w, rect.min.y - w, full_w, w), color);
self.rect(Rect::new(rect.min.x - w, rect.max.y, full_w, w), color);
self.rect(Rect::new(rect.min.x - w, rect.min.y, w, size.y), color);
self.rect(Rect::new(rect.max.x, rect.min.y, w, size.y), color);
}
pub fn label(&mut self, rect: Rect, text: &str, style: &TextStyle, h: HAlign, v: VAlign) {
let z = self.next_z();
self.text
.draw_in_rect(text, rect, h, v, style, z, TextChannel::Screen);
}
pub fn end(self) {
self.text.set_clip(None);
let released = self.input.mouse_released && !self.input.mouse_down;
if released || !self.splitter_seen {
self.ui.splitter_drag = None;
}
if !self.popup_seen {
self.ui.open_popup = None;
}
if released {
self.ui.active = None;
self.ui.thumb_drag = None;
self.ui.number_drag = None;
}
if self.input.mouse_pressed && !self.edit_clicked {
self.ui.focus = None;
}
if self.ui.focus.is_none() && self.input.keys.contains(&UiKey::Tab) {
let target = if self.input.shift {
self.focus_order.last()
} else {
self.focus_order.first()
};
if let Some(target) = target {
self.ui.focus = Some(target.id);
self.ui.keyboard_captured = true;
}
}
if !self.focus_requested
&& self
.ui
.focus
.is_some_and(|id| !self.focus_order.iter().any(|target| target.id == id))
{
self.ui.focus = None;
}
if self.ui.edit.id != self.ui.focus {
self.ui.edit = EditState::default();
}
self.ui.focus_order = self.focus_order;
self.ui.blocked = self.new_blocked;
self.ui.popover_blocked = self.new_popover_blocked;
self.ui.modal_blocking = self.new_modal.is_some();
self.ui.modal_scope = self.new_modal;
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ui::test_ui::{BTN, fixture, press_at};
use wasm_bindgen_test::wasm_bindgen_test;
#[wasm_bindgen_test(unsupported = test)]
fn hit_testing_is_half_open() {
let (mut ui, mut text, _assets) = fixture();
let mut list = DrawList::new();
let mut f = ui.begin(&mut text, &mut list, press_at(110.0, 50.0));
assert!(!f.button("b", BTN, "B", 20.0), "max edge is outside");
f.end();
let mut f = ui.begin(&mut text, &mut list, press_at(109.0, 49.0));
assert!(f.button("b", BTN, "B", 20.0));
f.end();
}
#[wasm_bindgen_test(unsupported = test)]
fn ui_shares_the_canonical_white_texture() {
let mut assets: Assets<Texture> = Assets::new();
let ui = Ui::new(&mut assets);
assert_eq!(
ui.white_texture(),
crate::assets::white_texture(&mut assets)
);
}
#[wasm_bindgen_test(unsupported = test)]
fn cancel_interactions_clears_pointer_state() {
let (mut ui, mut text, _assets) = fixture();
let mut list = DrawList::new();
let mut f = ui.begin(&mut text, &mut list, press_at(50.0, 30.0));
f.button("b", BTN, "OK", 24.0);
f.end();
assert!(ui.active.is_some());
ui.cancel_interactions();
assert!(ui.active.is_none());
assert!(ui.thumb_drag.is_none());
let dd = Rect::new(10.0, 10.0, 160.0, 30.0);
let mut selected = 0usize;
let mut f = ui.begin(&mut text, &mut list, press_at(50.0, 25.0));
f.dropdown("zoom", dd, &["a", "b"], &mut selected, 16.0);
f.end();
assert!(ui.any_popup_open());
ui.cancel_interactions();
assert!(!ui.any_popup_open(), "focus loss closes the popover");
}
#[wasm_bindgen_test(unsupported = test)]
fn draws_go_to_screen_channel_with_increasing_z() {
let (mut ui, mut text, mut assets) = fixture();
let mut list = DrawList::new();
let mut f = ui.begin(&mut text, &mut list, UiInput::default());
f.panel(Rect::new(40.0, 340.0, 880.0, 160.0));
f.button("start", Rect::new(81.0, 380.0, 300.0, 80.0), "START", 48.0);
f.end();
text.end_frame(&mut assets, &mut list);
assert!(list.world.is_empty());
assert!(list.screen.len() > 2, "panel + button + glyph quads");
assert!(list.screen[0].z < list.screen[1].z);
let body_z = list.screen[1].z;
assert!(list.screen[2..].iter().all(|i| i.z > body_z));
}
}