use crate::{
collision::Aabb2,
input::{Action, Input},
};
use glam::Vec2;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct UiId(pub u64);
#[derive(Clone, Copy, Debug)]
pub struct UiRegion {
pub id: UiId,
pub bounds: Aabb2,
pub enabled: bool,
pub focusable: bool,
pub draggable: bool,
}
impl UiRegion {
pub fn new(id: UiId, bounds: Aabb2) -> Self {
Self {
id,
bounds,
enabled: true,
focusable: true,
draggable: false,
}
}
}
#[derive(Clone, Copy, Debug)]
pub struct UiActions {
pub primary: Action,
pub next: Action,
pub previous: Action,
pub activate: Action,
pub cancel: Action,
}
#[derive(Clone, Copy, Debug, Default)]
pub struct UiButton {
pub down: bool,
pub pressed: bool,
pub released: bool,
}
#[derive(Clone, Copy, Debug, Default)]
pub struct UiInput {
pub pointer: Option<Vec2>,
pub primary: UiButton,
pub next: bool,
pub previous: bool,
pub activate: bool,
pub cancel: bool,
pub window_focused: bool,
}
impl UiInput {
pub fn from_actions(
input: &Input,
pointer: Option<Vec2>,
actions: UiActions,
window_focused: bool,
) -> Self {
Self {
pointer,
primary: UiButton {
down: input.down(actions.primary),
pressed: input.pressed(actions.primary),
released: input.released(actions.primary),
},
next: input.pressed(actions.next),
previous: input.pressed(actions.previous),
activate: input.pressed(actions.activate),
cancel: input.pressed(actions.cancel),
window_focused: window_focused && !input.reset_pending(),
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct UiCapture {
pub pointer: bool,
pub keyboard: bool,
}
#[derive(Clone, Copy, Debug)]
pub struct UiResponse {
pub id: UiId,
pub enabled: bool,
pub hovered: bool,
pub focused: bool,
pub pressed: bool,
pub held: bool,
pub released: bool,
pub activated: bool,
pub drag_started: bool,
pub drag_delta: Vec2,
pub drag_total: Vec2,
pub drag_ended: bool,
pub cancelled: bool,
}
impl UiResponse {
fn new(id: UiId, enabled: bool) -> Self {
Self {
id,
enabled,
hovered: false,
focused: false,
pressed: false,
held: false,
released: false,
activated: false,
drag_started: false,
drag_delta: Vec2::ZERO,
drag_total: Vec2::ZERO,
drag_ended: false,
cancelled: false,
}
}
}
#[derive(Clone, Copy)]
struct Active {
id: UiId,
draggable: bool,
origin: Vec2,
last: Vec2,
}
#[derive(Default)]
pub struct UiState {
focus: Option<UiId>,
active: Option<Active>,
responses: Vec<UiResponse>,
}
impl UiState {
pub fn with_capacity(regions: usize) -> Self {
Self {
responses: Vec::with_capacity(regions.saturating_add(1)),
..Self::default()
}
}
pub fn focused(&self) -> Option<UiId> {
self.focus
}
pub fn response(&self, id: UiId) -> Option<&UiResponse> {
self.responses.iter().find(|response| response.id == id)
}
pub fn responses(&self) -> &[UiResponse] {
&self.responses
}
pub fn update(&mut self, regions: &[UiRegion], input: UiInput) -> UiCapture {
debug_assert!(
regions
.iter()
.enumerate()
.all(|(i, r)| regions[..i].iter().all(|other| other.id != r.id)),
"UI region IDs must be unique"
);
self.responses.clear();
self.responses
.extend(regions.iter().map(|r| UiResponse::new(r.id, r.enabled)));
let had_focus = self.focus.is_some();
let had_active = self.active.is_some();
if self.focus.is_some_and(|id| {
!regions
.iter()
.any(|r| r.id == id && r.enabled && r.focusable)
}) {
self.focus = None;
}
let invalid_active = self
.active
.is_some_and(|a| !regions.iter().any(|r| r.id == a.id && r.enabled));
if (invalid_active || !input.window_focused || input.cancel)
&& let Some(active) = self.active.take()
{
if self.response(active.id).is_none() {
self.responses.push(UiResponse::new(active.id, false));
}
let response = self.response_mut(active.id);
response.released = true;
response.cancelled = true;
response.drag_ended = active.draggable;
response.drag_total = active.last - active.origin;
}
if !input.window_focused || input.cancel {
self.focus = None;
}
if !input.window_focused {
return UiCapture {
pointer: had_active,
keyboard: had_focus,
};
}
let pointer = input.pointer.filter(|p| p.is_finite());
let hovered = pointer.and_then(|p| regions.iter().rposition(|r| r.bounds.contains(p)));
if !input.cancel && self.active.is_none() && input.next != input.previous {
let current = self
.focus
.and_then(|id| regions.iter().position(|r| r.id == id));
let count = regions.len();
for offset in 0..count {
let index = if input.next {
current.map_or(offset, |i| (i + 1 + offset) % count)
} else {
current.map_or(count - 1 - offset, |i| (i + count - 1 - offset) % count)
};
if regions[index].enabled && regions[index].focusable {
self.focus = Some(regions[index].id);
break;
}
}
}
if !input.cancel && input.primary.pressed && self.active.is_none() {
self.focus = None;
if let Some(index) = hovered.filter(|&i| regions[i].enabled) {
let region = regions[index];
if region.focusable {
self.focus = Some(region.id);
}
let position = pointer.expect("hover requires a pointer");
self.active = Some(Active {
id: region.id,
draggable: region.draggable,
origin: position,
last: position,
});
let response = self.response_mut(region.id);
response.pressed = true;
response.drag_started = region.draggable;
}
}
if let Some(mut active) = self.active {
let response = self.response_mut(active.id);
response.held = input.primary.down;
if active.draggable {
if let Some(position) = pointer {
response.drag_delta = position - active.last;
active.last = position;
}
response.drag_total = active.last - active.origin;
}
if input.primary.released || !input.primary.down {
response.released = true;
response.held = false;
response.drag_ended = active.draggable;
response.cancelled = !input.primary.released;
response.activated = !active.draggable
&& input.primary.released
&& hovered.is_some_and(|i| regions[i].id == active.id);
self.active = None;
} else {
self.active = Some(active);
}
}
if !input.cancel
&& !input.primary.pressed
&& self.active.is_none()
&& input.activate
&& let Some(id) = self.focus
{
self.response_mut(id).activated = true;
}
if let Some(index) = hovered {
self.responses[index].hovered = true;
}
if let Some(id) = self.focus {
self.response_mut(id).focused = true;
}
UiCapture {
pointer: hovered.is_some() || had_active || self.active.is_some(),
keyboard: self.focus.is_some() || (had_focus && input.cancel),
}
}
fn response_mut(&mut self, id: UiId) -> &mut UiResponse {
self.responses
.iter_mut()
.find(|r| r.id == id)
.expect("active/focused region has a response")
}
}
#[cfg(test)]
mod tests;