2020-07-18 21:08:46 +00:00
|
|
|
use crate::Node;
|
|
|
|
use bevy_app::{EventReader, Events};
|
|
|
|
use bevy_core::FloatOrd;
|
|
|
|
use bevy_ecs::prelude::*;
|
|
|
|
use bevy_input::{mouse::MouseButton, Input};
|
|
|
|
use bevy_math::Vec2;
|
2020-09-14 21:00:32 +00:00
|
|
|
use bevy_transform::components::GlobalTransform;
|
2020-07-26 19:27:09 +00:00
|
|
|
use bevy_window::CursorMoved;
|
2020-07-18 21:08:46 +00:00
|
|
|
|
|
|
|
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
|
2020-07-28 08:20:19 +00:00
|
|
|
pub enum Interaction {
|
|
|
|
Clicked,
|
2020-07-18 21:08:46 +00:00
|
|
|
Hovered,
|
2020-07-28 08:20:19 +00:00
|
|
|
None,
|
2020-07-18 21:08:46 +00:00
|
|
|
}
|
|
|
|
|
2020-07-28 08:20:19 +00:00
|
|
|
impl Default for Interaction {
|
2020-07-18 21:08:46 +00:00
|
|
|
fn default() -> Self {
|
2020-07-28 08:20:19 +00:00
|
|
|
Interaction::None
|
2020-07-18 21:08:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
|
|
|
|
pub enum FocusPolicy {
|
|
|
|
Block,
|
|
|
|
Pass,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Default for FocusPolicy {
|
|
|
|
fn default() -> Self {
|
|
|
|
FocusPolicy::Block
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Default)]
|
|
|
|
pub struct State {
|
|
|
|
cursor_moved_event_reader: EventReader<CursorMoved>,
|
|
|
|
cursor_position: Vec2,
|
2020-07-20 03:52:15 +00:00
|
|
|
hovered_entity: Option<Entity>,
|
2020-07-18 21:08:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn ui_focus_system(
|
|
|
|
mut state: Local<State>,
|
|
|
|
mouse_button_input: Res<Input<MouseButton>>,
|
|
|
|
cursor_moved_events: Res<Events<CursorMoved>>,
|
|
|
|
mut node_query: Query<(
|
2020-07-20 03:52:15 +00:00
|
|
|
Entity,
|
2020-07-18 21:08:46 +00:00
|
|
|
&Node,
|
2020-09-14 21:00:32 +00:00
|
|
|
&GlobalTransform,
|
2020-07-28 08:20:19 +00:00
|
|
|
Option<&mut Interaction>,
|
2020-07-18 21:08:46 +00:00
|
|
|
Option<&FocusPolicy>,
|
|
|
|
)>,
|
|
|
|
) {
|
|
|
|
if let Some(cursor_moved) = state.cursor_moved_event_reader.latest(&cursor_moved_events) {
|
|
|
|
state.cursor_position = cursor_moved.position;
|
|
|
|
}
|
|
|
|
|
|
|
|
if mouse_button_input.just_released(MouseButton::Left) {
|
2020-10-30 06:39:55 +00:00
|
|
|
for (_entity, _node, _global_transform, interaction, _focus_policy) in node_query.iter_mut()
|
2020-09-14 21:00:32 +00:00
|
|
|
{
|
2020-07-28 08:20:19 +00:00
|
|
|
if let Some(mut interaction) = interaction {
|
|
|
|
if *interaction == Interaction::Clicked {
|
|
|
|
*interaction = Interaction::None;
|
2020-07-18 21:08:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
let mouse_clicked = mouse_button_input.just_pressed(MouseButton::Left);
|
2020-07-20 03:52:15 +00:00
|
|
|
let mut hovered_entity = None;
|
2020-07-18 21:08:46 +00:00
|
|
|
|
2020-07-20 03:52:15 +00:00
|
|
|
{
|
2020-10-30 06:39:55 +00:00
|
|
|
let mut moused_over_z_sorted_nodes = node_query
|
|
|
|
.iter_mut()
|
2020-09-14 21:00:32 +00:00
|
|
|
.filter_map(
|
|
|
|
|(entity, node, global_transform, interaction, focus_policy)| {
|
2020-10-18 20:03:16 +00:00
|
|
|
let position = global_transform.translation;
|
2020-09-14 21:00:32 +00:00
|
|
|
let ui_position = position.truncate();
|
|
|
|
let extents = node.size / 2.0;
|
|
|
|
let min = ui_position - extents;
|
|
|
|
let max = ui_position + extents;
|
|
|
|
// if the current cursor position is within the bounds of the node, consider it for clicking
|
|
|
|
if (min.x()..max.x()).contains(&state.cursor_position.x())
|
|
|
|
&& (min.y()..max.y()).contains(&state.cursor_position.y())
|
|
|
|
{
|
|
|
|
Some((entity, focus_policy, interaction, FloatOrd(position.z())))
|
|
|
|
} else {
|
|
|
|
if let Some(mut interaction) = interaction {
|
|
|
|
if *interaction == Interaction::Hovered {
|
|
|
|
*interaction = Interaction::None;
|
|
|
|
}
|
2020-07-20 03:52:15 +00:00
|
|
|
}
|
2020-09-14 21:00:32 +00:00
|
|
|
None
|
2020-07-18 21:08:46 +00:00
|
|
|
}
|
2020-09-14 21:00:32 +00:00
|
|
|
},
|
|
|
|
)
|
2020-07-20 03:52:15 +00:00
|
|
|
.collect::<Vec<_>>();
|
2020-07-18 21:08:46 +00:00
|
|
|
|
2020-07-28 08:20:19 +00:00
|
|
|
moused_over_z_sorted_nodes.sort_by_key(|(_, _, _, z)| -*z);
|
|
|
|
for (entity, focus_policy, interaction, _) in moused_over_z_sorted_nodes {
|
|
|
|
if let Some(mut interaction) = interaction {
|
|
|
|
if mouse_clicked {
|
|
|
|
// only consider nodes with ClickState "clickable"
|
|
|
|
if *interaction != Interaction::Clicked {
|
|
|
|
*interaction = Interaction::Clicked;
|
2020-07-20 03:52:15 +00:00
|
|
|
}
|
2020-07-28 08:20:19 +00:00
|
|
|
} else if *interaction == Interaction::None {
|
|
|
|
*interaction = Interaction::Hovered;
|
2020-07-18 21:08:46 +00:00
|
|
|
}
|
|
|
|
}
|
2020-07-20 03:52:15 +00:00
|
|
|
|
2020-07-28 08:20:19 +00:00
|
|
|
hovered_entity = Some(entity);
|
|
|
|
|
2020-07-20 03:52:15 +00:00
|
|
|
match focus_policy.cloned().unwrap_or(FocusPolicy::Block) {
|
|
|
|
FocusPolicy::Block => {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
FocusPolicy::Pass => { /* allow the next node to be hovered/clicked */ }
|
2020-07-18 21:08:46 +00:00
|
|
|
}
|
|
|
|
}
|
2020-07-20 03:52:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// if there is a new hovered entity, but an entity is currently hovered, unhover the old entity
|
|
|
|
if let Some(new_hovered_entity) = hovered_entity {
|
|
|
|
if let Some(old_hovered_entity) = state.hovered_entity {
|
|
|
|
if new_hovered_entity != old_hovered_entity {
|
2020-10-31 01:04:33 +00:00
|
|
|
if let Ok(mut interaction) =
|
|
|
|
node_query.get_component_mut::<Interaction>(old_hovered_entity)
|
|
|
|
{
|
2020-07-28 08:20:19 +00:00
|
|
|
if *interaction == Interaction::Hovered {
|
|
|
|
*interaction = Interaction::None;
|
2020-07-20 03:52:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
state.hovered_entity = None;
|
2020-07-18 21:08:46 +00:00
|
|
|
}
|
|
|
|
}
|
2020-07-20 03:52:15 +00:00
|
|
|
state.hovered_entity = hovered_entity;
|
2020-07-18 21:08:46 +00:00
|
|
|
}
|
|
|
|
}
|