mirror of
https://github.com/bevyengine/bevy
synced 2024-12-24 03:53:06 +00:00
09b0b5df91
# Objective On the web, it's common to attach observers to windows. As @viridia has discovered, this can be quite a nice paradigm in bevy as well when applied to observers. The changes here are intended to make this possible. + Adds a new default picking back-end as part to the core picking plugin (which can be disabled) that causes pointers on windows to treat the window entity as the final hit, behind everything else. This means clicking empty space now dispatches normal picking events to the window, and is especially nice for drag-and-drop functionality. + Adds a new traversal type, specific to picking events, that causes them to bubble up to the window entity after they reach the root of the hierarchy. ## Solution The window picking back-end is extremely simple, but the bubbling changes are much more complex, since they require doing a different traversal depending on the picking event. To achieve this, `Traversal` has been made generic over an associated sized data type `D`. Observer bounds have been changed such that `Event::Traversal<D>` is required for `Trigger<D>`. A blanket implementation has been added for `()` and `Parent` that preserves the existing functionality. A new `PointerTraversal` traversal has been implemented, with a blanket implementation for `Traversal<Pointer<E>>`. It is still possible to use `Parent` as the traversal for any event, because of the blanket implementation. It is now possible for users to add other custom traversals, which read event data during traversal. ## Testing I tested these changes locally on some picking UI prototypes I have been playing with. I also tested them on the picking examples. --------- Co-authored-by: Martín Maita <47983254+mnmaita@users.noreply.github.com>
45 lines
1.6 KiB
Rust
45 lines
1.6 KiB
Rust
//! This module contains a basic backend that implements picking for window
|
|
//! entities.
|
|
//!
|
|
//! Pointers can exist on windows, images, and gpu texture views. With
|
|
//! [`update_window_hits`] enabled, when a pointer hovers over a window that
|
|
//! window will be inserted as a pointer hit, listed behind all other pointer
|
|
//! hits. This means that when the pointer isn't hovering any other entities,
|
|
//! the picking events will be routed to the window.
|
|
|
|
use core::f32;
|
|
|
|
use bevy_ecs::prelude::*;
|
|
use bevy_render::camera::NormalizedRenderTarget;
|
|
|
|
use crate::{
|
|
backend::{HitData, PointerHits},
|
|
pointer::{Location, PointerId, PointerLocation},
|
|
};
|
|
|
|
/// Generates pointer hit events for window entities.
|
|
///
|
|
/// A pointer is treated as hitting a window when it is located on that window. The order
|
|
/// of the hit event is negative infinity, meaning it should appear behind all other entities.
|
|
///
|
|
/// The depth of the hit will be listed as zero.
|
|
pub fn update_window_hits(
|
|
pointers: Query<(&PointerId, &PointerLocation)>,
|
|
mut output_events: EventWriter<PointerHits>,
|
|
) {
|
|
for (pointer_id, pointer_location) in pointers.iter() {
|
|
if let Some(Location {
|
|
target: NormalizedRenderTarget::Window(window_ref),
|
|
..
|
|
}) = pointer_location.location
|
|
{
|
|
let entity = window_ref.entity();
|
|
let hit_data = HitData::new(entity, 0.0, None, None);
|
|
output_events.send(PointerHits::new(
|
|
*pointer_id,
|
|
vec![(entity, hit_data)],
|
|
f32::NEG_INFINITY,
|
|
));
|
|
}
|
|
}
|
|
}
|