Vendor dependencies for 0.3.0 release

vendor/bevy_window/src/event.rs

@@ -0,0 +1,671 @@
+use alloc::string::String;
+use bevy_ecs::{entity::Entity, event::Event};
+use bevy_input::{
+    gestures::*,
+    keyboard::{KeyboardFocusLost, KeyboardInput},
+    mouse::{MouseButtonInput, MouseMotion, MouseWheel},
+    touch::TouchInput,
+};
+use bevy_math::{IVec2, Vec2};
+
+#[cfg(feature = "std")]
+use std::path::PathBuf;
+
+#[cfg(not(feature = "std"))]
+use alloc::string::String as PathBuf;
+
+#[cfg(feature = "bevy_reflect")]
+use bevy_reflect::Reflect;
+
+#[cfg(feature = "serialize")]
+use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
+
+use crate::WindowTheme;
+
+/// A window event that is sent whenever a window's logical size has changed.
+#[derive(Event, Debug, Clone, PartialEq)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub struct WindowResized {
+    /// Window that has changed.
+    pub window: Entity,
+    /// The new logical width of the window.
+    pub width: f32,
+    /// The new logical height of the window.
+    pub height: f32,
+}
+
+/// An event that indicates all of the application's windows should be redrawn,
+/// even if their control flow is set to `Wait` and there have been no window events.
+#[derive(Event, Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub struct RequestRedraw;
+
+/// An event that is sent whenever a new window is created.
+///
+/// To create a new window, spawn an entity with a [`crate::Window`] on it.
+#[derive(Event, Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub struct WindowCreated {
+    /// Window that has been created.
+    pub window: Entity,
+}
+
+/// An event that is sent whenever the operating systems requests that a window
+/// be closed. This will be sent when the close button of the window is pressed.
+///
+/// If the default [`WindowPlugin`] is used, these events are handled
+/// by closing the corresponding [`Window`].
+/// To disable this behavior, set `close_when_requested` on the [`WindowPlugin`]
+/// to `false`.
+///
+/// [`WindowPlugin`]: crate::WindowPlugin
+/// [`Window`]: crate::Window
+#[derive(Event, Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub struct WindowCloseRequested {
+    /// Window to close.
+    pub window: Entity,
+}
+
+/// An event that is sent whenever a window is closed. This will be sent when
+/// the window entity loses its [`Window`](crate::window::Window) component or is despawned.
+#[derive(Event, Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub struct WindowClosed {
+    /// Window that has been closed.
+    ///
+    /// Note that this entity probably no longer exists
+    /// by the time this event is received.
+    pub window: Entity,
+}
+
+/// An event that is sent whenever a window is closing. This will be sent when
+/// after a [`WindowCloseRequested`] event is received and the window is in the process of closing.
+#[derive(Event, Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub struct WindowClosing {
+    /// Window that has been requested to close and is the process of closing.
+    pub window: Entity,
+}
+
+/// An event that is sent whenever a window is destroyed by the underlying window system.
+///
+/// Note that if your application only has a single window, this event may be your last chance to
+/// persist state before the application terminates.
+#[derive(Event, Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub struct WindowDestroyed {
+    /// Window that has been destroyed.
+    ///
+    /// Note that this entity probably no longer exists
+    /// by the time this event is received.
+    pub window: Entity,
+}
+
+/// An event reporting that the mouse cursor has moved inside a window.
+///
+/// The event is sent only if the cursor is over one of the application's windows.
+/// It is the translated version of [`WindowEvent::CursorMoved`] from the `winit` crate with the addition of `delta`.
+///
+/// Not to be confused with the `MouseMotion` event from `bevy_input`.
+///
+/// Because the range of data is limited by the window area and it may have been transformed by the OS to implement certain effects like acceleration,
+/// you should not use it for non-cursor-like behavior such as 3D camera control. Please see `MouseMotion` instead.
+///
+/// [`WindowEvent::CursorMoved`]: https://docs.rs/winit/latest/winit/event/enum.WindowEvent.html#variant.CursorMoved
+#[derive(Event, Debug, Clone, PartialEq)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub struct CursorMoved {
+    /// Window that the cursor moved inside.
+    pub window: Entity,
+    /// The cursor position in logical pixels.
+    pub position: Vec2,
+    /// The change in the position of the cursor since the last event was sent.
+    /// This value is `None` if the cursor was outside the window area during the last frame.
+    // Because the range of this data is limited by the display area and it may have been
+    //  transformed by the OS to implement effects such as cursor acceleration, it should
+    // not be used to implement non-cursor-like interactions such as 3D camera control.
+    pub delta: Option<Vec2>,
+}
+
+/// An event that is sent whenever the user's cursor enters a window.
+#[derive(Event, Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub struct CursorEntered {
+    /// Window that the cursor entered.
+    pub window: Entity,
+}
+
+/// An event that is sent whenever the user's cursor leaves a window.
+#[derive(Event, Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub struct CursorLeft {
+    /// Window that the cursor left.
+    pub window: Entity,
+}
+
+/// An Input Method Editor event.
+///
+/// This event is the translated version of the `WindowEvent::Ime` from the `winit` crate.
+///
+/// It is only sent if IME was enabled on the window with [`Window::ime_enabled`](crate::window::Window::ime_enabled).
+#[derive(Event, Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub enum Ime {
+    /// Notifies when a new composing text should be set at the cursor position.
+    Preedit {
+        /// Window that received the event.
+        window: Entity,
+        /// Current value.
+        value: String,
+        /// Cursor begin and end position.
+        ///
+        /// `None` indicated the cursor should be hidden
+        cursor: Option<(usize, usize)>,
+    },
+    /// Notifies when text should be inserted into the editor widget.
+    Commit {
+        /// Window that received the event.
+        window: Entity,
+        /// Input string
+        value: String,
+    },
+    /// Notifies when the IME was enabled.
+    ///
+    /// After this event, you will receive events `Ime::Preedit` and `Ime::Commit`.
+    Enabled {
+        /// Window that received the event.
+        window: Entity,
+    },
+    /// Notifies when the IME was disabled.
+    Disabled {
+        /// Window that received the event.
+        window: Entity,
+    },
+}
+
+/// An event that indicates a window has received or lost focus.
+#[derive(Event, Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub struct WindowFocused {
+    /// Window that changed focus.
+    pub window: Entity,
+    /// Whether it was focused (true) or lost focused (false).
+    pub focused: bool,
+}
+
+/// The window has been occluded (completely hidden from view).
+///
+/// This is different to window visibility as it depends on
+/// whether the window is closed, minimized, set invisible,
+/// or fully occluded by another window.
+///
+/// It is the translated version of [`WindowEvent::Occluded`] from the `winit` crate.
+///
+/// [`WindowEvent::Occluded`]: https://docs.rs/winit/latest/winit/event/enum.WindowEvent.html#variant.Occluded
+#[derive(Event, Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub struct WindowOccluded {
+    /// Window that changed occluded state.
+    pub window: Entity,
+    /// Whether it was occluded (true) or not occluded (false).
+    pub occluded: bool,
+}
+
+/// An event that indicates a window's scale factor has changed.
+#[derive(Event, Debug, Clone, PartialEq)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub struct WindowScaleFactorChanged {
+    /// Window that had its scale factor changed.
+    pub window: Entity,
+    /// The new scale factor.
+    pub scale_factor: f64,
+}
+
+/// An event that indicates a window's OS-reported scale factor has changed.
+#[derive(Event, Debug, Clone, PartialEq)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub struct WindowBackendScaleFactorChanged {
+    /// Window that had its scale factor changed by the backend.
+    pub window: Entity,
+    /// The new scale factor.
+    pub scale_factor: f64,
+}
+
+/// Events related to files being dragged and dropped on a window.
+#[derive(Event, Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub enum FileDragAndDrop {
+    /// File is being dropped into a window.
+    DroppedFile {
+        /// Window the file was dropped into.
+        window: Entity,
+        /// Path to the file that was dropped in.
+        path_buf: PathBuf,
+    },
+
+    /// File is currently being hovered over a window.
+    HoveredFile {
+        /// Window a file is possibly going to be dropped into.
+        window: Entity,
+        /// Path to the file that might be dropped in.
+        path_buf: PathBuf,
+    },
+
+    /// File hovering was canceled.
+    HoveredFileCanceled {
+        /// Window that had a canceled file drop.
+        window: Entity,
+    },
+}
+
+/// An event that is sent when a window is repositioned in physical pixels.
+#[derive(Event, Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub struct WindowMoved {
+    /// Window that moved.
+    pub window: Entity,
+    /// Where the window moved to in physical pixels.
+    pub position: IVec2,
+}
+
+/// An event sent when the system theme changes for a window.
+///
+/// This event is only sent when the window is relying on the system theme to control its appearance.
+/// i.e. It is only sent when [`Window::window_theme`](crate::window::Window::window_theme) is `None` and the system theme changes.
+#[derive(Event, Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub struct WindowThemeChanged {
+    /// Window for which the system theme has changed.
+    pub window: Entity,
+    /// The new system theme.
+    pub theme: WindowTheme,
+}
+
+/// Application lifetime events
+#[derive(Event, Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub enum AppLifecycle {
+    /// The application is not started yet.
+    Idle,
+    /// The application is running.
+    Running,
+    /// The application is going to be suspended.
+    /// Applications have one frame to react to this event before being paused in the background.
+    WillSuspend,
+    /// The application was suspended.
+    Suspended,
+    /// The application is going to be resumed.
+    /// Applications have one extra frame to react to this event before being fully resumed.
+    WillResume,
+}
+
+impl AppLifecycle {
+    /// Return `true` if the app can be updated.
+    #[inline]
+    pub fn is_active(&self) -> bool {
+        match self {
+            Self::Idle | Self::Suspended => false,
+            Self::Running | Self::WillSuspend | Self::WillResume => true,
+        }
+    }
+}
+
+/// Wraps all `bevy_window` and `bevy_input` events in a common enum.
+///
+/// Read these events with `EventReader<WindowEvent>` if you need to
+/// access window events in the order they were received from the
+/// operating system. Otherwise, the event types are individually
+/// readable with `EventReader<E>` (e.g. `EventReader<KeyboardInput>`).
+#[derive(Event, Debug, Clone, PartialEq)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+#[expect(missing_docs, reason = "Not all docs are written yet, see #3492.")]
+pub enum WindowEvent {
+    AppLifecycle(AppLifecycle),
+    CursorEntered(CursorEntered),
+    CursorLeft(CursorLeft),
+    CursorMoved(CursorMoved),
+    FileDragAndDrop(FileDragAndDrop),
+    Ime(Ime),
+    RequestRedraw(RequestRedraw),
+    WindowBackendScaleFactorChanged(WindowBackendScaleFactorChanged),
+    WindowCloseRequested(WindowCloseRequested),
+    WindowCreated(WindowCreated),
+    WindowDestroyed(WindowDestroyed),
+    WindowFocused(WindowFocused),
+    WindowMoved(WindowMoved),
+    WindowOccluded(WindowOccluded),
+    WindowResized(WindowResized),
+    WindowScaleFactorChanged(WindowScaleFactorChanged),
+    WindowThemeChanged(WindowThemeChanged),
+
+    MouseButtonInput(MouseButtonInput),
+    MouseMotion(MouseMotion),
+    MouseWheel(MouseWheel),
+
+    PinchGesture(PinchGesture),
+    RotationGesture(RotationGesture),
+    DoubleTapGesture(DoubleTapGesture),
+    PanGesture(PanGesture),
+
+    TouchInput(TouchInput),
+
+    KeyboardInput(KeyboardInput),
+    KeyboardFocusLost(KeyboardFocusLost),
+}
+
+impl From<AppLifecycle> for WindowEvent {
+    fn from(e: AppLifecycle) -> Self {
+        Self::AppLifecycle(e)
+    }
+}
+impl From<CursorEntered> for WindowEvent {
+    fn from(e: CursorEntered) -> Self {
+        Self::CursorEntered(e)
+    }
+}
+impl From<CursorLeft> for WindowEvent {
+    fn from(e: CursorLeft) -> Self {
+        Self::CursorLeft(e)
+    }
+}
+impl From<CursorMoved> for WindowEvent {
+    fn from(e: CursorMoved) -> Self {
+        Self::CursorMoved(e)
+    }
+}
+impl From<FileDragAndDrop> for WindowEvent {
+    fn from(e: FileDragAndDrop) -> Self {
+        Self::FileDragAndDrop(e)
+    }
+}
+impl From<Ime> for WindowEvent {
+    fn from(e: Ime) -> Self {
+        Self::Ime(e)
+    }
+}
+impl From<RequestRedraw> for WindowEvent {
+    fn from(e: RequestRedraw) -> Self {
+        Self::RequestRedraw(e)
+    }
+}
+impl From<WindowBackendScaleFactorChanged> for WindowEvent {
+    fn from(e: WindowBackendScaleFactorChanged) -> Self {
+        Self::WindowBackendScaleFactorChanged(e)
+    }
+}
+impl From<WindowCloseRequested> for WindowEvent {
+    fn from(e: WindowCloseRequested) -> Self {
+        Self::WindowCloseRequested(e)
+    }
+}
+impl From<WindowCreated> for WindowEvent {
+    fn from(e: WindowCreated) -> Self {
+        Self::WindowCreated(e)
+    }
+}
+impl From<WindowDestroyed> for WindowEvent {
+    fn from(e: WindowDestroyed) -> Self {
+        Self::WindowDestroyed(e)
+    }
+}
+impl From<WindowFocused> for WindowEvent {
+    fn from(e: WindowFocused) -> Self {
+        Self::WindowFocused(e)
+    }
+}
+impl From<WindowMoved> for WindowEvent {
+    fn from(e: WindowMoved) -> Self {
+        Self::WindowMoved(e)
+    }
+}
+impl From<WindowOccluded> for WindowEvent {
+    fn from(e: WindowOccluded) -> Self {
+        Self::WindowOccluded(e)
+    }
+}
+impl From<WindowResized> for WindowEvent {
+    fn from(e: WindowResized) -> Self {
+        Self::WindowResized(e)
+    }
+}
+impl From<WindowScaleFactorChanged> for WindowEvent {
+    fn from(e: WindowScaleFactorChanged) -> Self {
+        Self::WindowScaleFactorChanged(e)
+    }
+}
+impl From<WindowThemeChanged> for WindowEvent {
+    fn from(e: WindowThemeChanged) -> Self {
+        Self::WindowThemeChanged(e)
+    }
+}
+impl From<MouseButtonInput> for WindowEvent {
+    fn from(e: MouseButtonInput) -> Self {
+        Self::MouseButtonInput(e)
+    }
+}
+impl From<MouseMotion> for WindowEvent {
+    fn from(e: MouseMotion) -> Self {
+        Self::MouseMotion(e)
+    }
+}
+impl From<MouseWheel> for WindowEvent {
+    fn from(e: MouseWheel) -> Self {
+        Self::MouseWheel(e)
+    }
+}
+impl From<PinchGesture> for WindowEvent {
+    fn from(e: PinchGesture) -> Self {
+        Self::PinchGesture(e)
+    }
+}
+impl From<RotationGesture> for WindowEvent {
+    fn from(e: RotationGesture) -> Self {
+        Self::RotationGesture(e)
+    }
+}
+impl From<DoubleTapGesture> for WindowEvent {
+    fn from(e: DoubleTapGesture) -> Self {
+        Self::DoubleTapGesture(e)
+    }
+}
+impl From<PanGesture> for WindowEvent {
+    fn from(e: PanGesture) -> Self {
+        Self::PanGesture(e)
+    }
+}
+impl From<TouchInput> for WindowEvent {
+    fn from(e: TouchInput) -> Self {
+        Self::TouchInput(e)
+    }
+}
+impl From<KeyboardInput> for WindowEvent {
+    fn from(e: KeyboardInput) -> Self {
+        Self::KeyboardInput(e)
+    }
+}
+impl From<KeyboardFocusLost> for WindowEvent {
+    fn from(e: KeyboardFocusLost) -> Self {
+        Self::KeyboardFocusLost(e)
+    }
+}

vendor/bevy_window/src/lib.rs

@@ -0,0 +1,199 @@
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![doc(
+    html_logo_url = "https://bevyengine.org/assets/icon.png",
+    html_favicon_url = "https://bevyengine.org/assets/icon.png"
+)]
+#![no_std]
+
+//! `bevy_window` provides a platform-agnostic interface for windowing in Bevy.
+//!
+//! This crate contains types for window management and events,
+//! used by windowing implementors such as `bevy_winit`.
+//! The [`WindowPlugin`] sets up some global window-related parameters and
+//! is part of the [`DefaultPlugins`](https://docs.rs/bevy/latest/bevy/struct.DefaultPlugins.html).
+
+#[cfg(feature = "std")]
+extern crate std;
+
+extern crate alloc;
+
+use alloc::sync::Arc;
+
+use bevy_platform::sync::Mutex;
+
+mod event;
+mod monitor;
+mod raw_handle;
+mod system;
+mod system_cursor;
+mod window;
+
+pub use crate::raw_handle::*;
+
+#[cfg(target_os = "android")]
+pub use android_activity;
+
+pub use event::*;
+pub use monitor::*;
+pub use system::*;
+pub use system_cursor::*;
+pub use window::*;
+
+/// The windowing prelude.
+///
+/// This includes the most common types in this crate, re-exported for your convenience.
+pub mod prelude {
+    #[doc(hidden)]
+    pub use crate::{
+        CursorEntered, CursorLeft, CursorMoved, FileDragAndDrop, Ime, MonitorSelection,
+        VideoModeSelection, Window, WindowMoved, WindowPlugin, WindowPosition,
+        WindowResizeConstraints,
+    };
+}
+
+use bevy_app::prelude::*;
+
+impl Default for WindowPlugin {
+    fn default() -> Self {
+        WindowPlugin {
+            primary_window: Some(Window::default()),
+            exit_condition: ExitCondition::OnAllClosed,
+            close_when_requested: true,
+        }
+    }
+}
+
+/// A [`Plugin`] that defines an interface for windowing support in Bevy.
+pub struct WindowPlugin {
+    /// Settings for the primary window.
+    ///
+    /// `Some(custom_window)` will spawn an entity with `custom_window` and [`PrimaryWindow`] as components.
+    /// `None` will not spawn a primary window.
+    ///
+    /// Defaults to `Some(Window::default())`.
+    ///
+    /// Note that if there are no windows the App will exit (by default) due to
+    /// [`exit_on_all_closed`].
+    pub primary_window: Option<Window>,
+
+    /// Whether to exit the app when there are no open windows.
+    ///
+    /// If disabling this, ensure that you send the [`bevy_app::AppExit`]
+    /// event when the app should exit. If this does not occur, you will
+    /// create 'headless' processes (processes without windows), which may
+    /// surprise your users. It is recommended to leave this setting to
+    /// either [`ExitCondition::OnAllClosed`] or [`ExitCondition::OnPrimaryClosed`].
+    ///
+    /// [`ExitCondition::OnAllClosed`] will add [`exit_on_all_closed`] to [`Update`].
+    /// [`ExitCondition::OnPrimaryClosed`] will add [`exit_on_primary_closed`] to [`Update`].
+    pub exit_condition: ExitCondition,
+
+    /// Whether to close windows when they are requested to be closed (i.e.
+    /// when the close button is pressed).
+    ///
+    /// If true, this plugin will add [`close_when_requested`] to [`Update`].
+    /// If this system (or a replacement) is not running, the close button will have no effect.
+    /// This may surprise your users. It is recommended to leave this setting as `true`.
+    pub close_when_requested: bool,
+}
+
+impl Plugin for WindowPlugin {
+    fn build(&self, app: &mut App) {
+        // User convenience events
+        app.add_event::<WindowEvent>()
+            .add_event::<WindowResized>()
+            .add_event::<WindowCreated>()
+            .add_event::<WindowClosing>()
+            .add_event::<WindowClosed>()
+            .add_event::<WindowCloseRequested>()
+            .add_event::<WindowDestroyed>()
+            .add_event::<RequestRedraw>()
+            .add_event::<CursorMoved>()
+            .add_event::<CursorEntered>()
+            .add_event::<CursorLeft>()
+            .add_event::<Ime>()
+            .add_event::<WindowFocused>()
+            .add_event::<WindowOccluded>()
+            .add_event::<WindowScaleFactorChanged>()
+            .add_event::<WindowBackendScaleFactorChanged>()
+            .add_event::<FileDragAndDrop>()
+            .add_event::<WindowMoved>()
+            .add_event::<WindowThemeChanged>()
+            .add_event::<AppLifecycle>();
+
+        if let Some(primary_window) = &self.primary_window {
+            app.world_mut().spawn(primary_window.clone()).insert((
+                PrimaryWindow,
+                RawHandleWrapperHolder(Arc::new(Mutex::new(None))),
+            ));
+        }
+
+        match self.exit_condition {
+            ExitCondition::OnPrimaryClosed => {
+                app.add_systems(PostUpdate, exit_on_primary_closed);
+            }
+            ExitCondition::OnAllClosed => {
+                app.add_systems(PostUpdate, exit_on_all_closed);
+            }
+            ExitCondition::DontExit => {}
+        }
+
+        if self.close_when_requested {
+            // Need to run before `exit_on_*` systems
+            app.add_systems(Update, close_when_requested);
+        }
+
+        // Register event types
+        #[cfg(feature = "bevy_reflect")]
+        app.register_type::<WindowEvent>()
+            .register_type::<WindowResized>()
+            .register_type::<RequestRedraw>()
+            .register_type::<WindowCreated>()
+            .register_type::<WindowCloseRequested>()
+            .register_type::<WindowClosing>()
+            .register_type::<WindowClosed>()
+            .register_type::<CursorMoved>()
+            .register_type::<CursorEntered>()
+            .register_type::<CursorLeft>()
+            .register_type::<WindowFocused>()
+            .register_type::<WindowOccluded>()
+            .register_type::<WindowScaleFactorChanged>()
+            .register_type::<WindowBackendScaleFactorChanged>()
+            .register_type::<FileDragAndDrop>()
+            .register_type::<WindowMoved>()
+            .register_type::<WindowThemeChanged>()
+            .register_type::<AppLifecycle>()
+            .register_type::<Monitor>();
+
+        // Register window descriptor and related types
+        #[cfg(feature = "bevy_reflect")]
+        app.register_type::<Window>()
+            .register_type::<PrimaryWindow>();
+    }
+}
+
+/// Defines the specific conditions the application should exit on
+#[derive(Clone)]
+pub enum ExitCondition {
+    /// Close application when the primary window is closed
+    ///
+    /// The plugin will add [`exit_on_primary_closed`] to [`PostUpdate`].
+    OnPrimaryClosed,
+    /// Close application when all windows are closed
+    ///
+    /// The plugin will add [`exit_on_all_closed`] to [`PostUpdate`].
+    OnAllClosed,
+    /// Keep application running headless even after closing all windows
+    ///
+    /// If selecting this, ensure that you send the [`bevy_app::AppExit`]
+    /// event when the app should exit. If this does not occur, you will
+    /// create 'headless' processes (processes without windows), which may
+    /// surprise your users.
+    DontExit,
+}
+
+/// [`AndroidApp`] provides an interface to query the application state as well as monitor events
+/// (for example lifecycle and input events).
+#[cfg(target_os = "android")]
+pub static ANDROID_APP: std::sync::OnceLock<android_activity::AndroidApp> =
+    std::sync::OnceLock::new();

vendor/bevy_window/src/monitor.rs

@@ -0,0 +1,80 @@
+use alloc::{string::String, vec::Vec};
+use bevy_ecs::component::Component;
+use bevy_math::{IVec2, UVec2};
+
+#[cfg(feature = "bevy_reflect")]
+use {bevy_ecs::prelude::ReflectComponent, bevy_reflect::Reflect};
+
+#[cfg(all(feature = "serialize", feature = "bevy_reflect"))]
+use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
+
+/// Represents an available monitor as reported by the user's operating system, which can be used
+/// to query information about the display, such as its size, position, and video modes.
+///
+/// Each monitor corresponds to an entity and can be used to position a monitor using
+/// [`crate::window::MonitorSelection::Entity`].
+///
+/// # Warning
+///
+/// This component is synchronized with `winit` through `bevy_winit`, but is effectively
+/// read-only as `winit` does not support changing monitor properties.
+#[derive(Component, Debug, Clone)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Component, Debug, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub struct Monitor {
+    /// The name of the monitor
+    pub name: Option<String>,
+    /// The height of the monitor in physical pixels
+    pub physical_height: u32,
+    /// The width of the monitor in physical pixels
+    pub physical_width: u32,
+    /// The position of the monitor in physical pixels
+    pub physical_position: IVec2,
+    /// The refresh rate of the monitor in millihertz
+    pub refresh_rate_millihertz: Option<u32>,
+    /// The scale factor of the monitor
+    pub scale_factor: f64,
+    /// The video modes that the monitor supports
+    pub video_modes: Vec<VideoMode>,
+}
+
+/// A marker component for the primary monitor
+#[derive(Component, Debug, Clone)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Component, Debug, Clone)
+)]
+pub struct PrimaryMonitor;
+
+impl Monitor {
+    /// Returns the physical size of the monitor in pixels
+    pub fn physical_size(&self) -> UVec2 {
+        UVec2::new(self.physical_width, self.physical_height)
+    }
+}
+
+/// Represents a video mode that a monitor supports
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "bevy_reflect", derive(Reflect), reflect(Debug, Clone))]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub struct VideoMode {
+    /// The resolution of the video mode
+    pub physical_size: UVec2,
+    /// The bit depth of the video mode
+    pub bit_depth: u16,
+    /// The refresh rate in millihertz
+    pub refresh_rate_millihertz: u32,
+}

vendor/bevy_window/src/raw_handle.rs

@@ -0,0 +1,162 @@
+#![expect(
+    unsafe_code,
+    reason = "This module acts as a wrapper around the `raw_window_handle` crate, which exposes many unsafe interfaces; thus, we have to use unsafe code here."
+)]
+
+use alloc::sync::Arc;
+use bevy_ecs::prelude::Component;
+use bevy_platform::sync::Mutex;
+use core::{any::Any, marker::PhantomData, ops::Deref};
+use raw_window_handle::{
+    DisplayHandle, HandleError, HasDisplayHandle, HasWindowHandle, RawDisplayHandle,
+    RawWindowHandle, WindowHandle,
+};
+
+/// A wrapper over a window.
+///
+/// This allows us to extend the lifetime of the window, so it doesn't get eagerly dropped while a
+/// pipelined renderer still has frames in flight that need to draw to it.
+///
+/// This is achieved by storing a shared reference to the window in the [`RawHandleWrapper`],
+/// which gets picked up by the renderer during extraction.
+#[derive(Debug)]
+pub struct WindowWrapper<W> {
+    reference: Arc<dyn Any + Send + Sync>,
+    ty: PhantomData<W>,
+}
+
+impl<W: Send + Sync + 'static> WindowWrapper<W> {
+    /// Creates a `WindowWrapper` from a window.
+    pub fn new(window: W) -> WindowWrapper<W> {
+        WindowWrapper {
+            reference: Arc::new(window),
+            ty: PhantomData,
+        }
+    }
+}
+
+impl<W: 'static> Deref for WindowWrapper<W> {
+    type Target = W;
+
+    fn deref(&self) -> &Self::Target {
+        self.reference.downcast_ref::<W>().unwrap()
+    }
+}
+
+/// A wrapper over [`RawWindowHandle`] and [`RawDisplayHandle`] that allows us to safely pass it across threads.
+///
+/// Depending on the platform, the underlying pointer-containing handle cannot be used on all threads,
+/// and so we cannot simply make it (or any type that has a safe operation to get a [`RawWindowHandle`] or [`RawDisplayHandle`])
+/// thread-safe.
+#[derive(Debug, Clone, Component)]
+pub struct RawHandleWrapper {
+    _window: Arc<dyn Any + Send + Sync>,
+    /// Raw handle to a window.
+    window_handle: RawWindowHandle,
+    /// Raw handle to the display server.
+    display_handle: RawDisplayHandle,
+}
+
+impl RawHandleWrapper {
+    /// Creates a `RawHandleWrapper` from a `WindowWrapper`.
+    pub fn new<W: HasWindowHandle + HasDisplayHandle + 'static>(
+        window: &WindowWrapper<W>,
+    ) -> Result<RawHandleWrapper, HandleError> {
+        Ok(RawHandleWrapper {
+            _window: window.reference.clone(),
+            window_handle: window.window_handle()?.as_raw(),
+            display_handle: window.display_handle()?.as_raw(),
+        })
+    }
+
+    /// Returns a [`HasWindowHandle`] + [`HasDisplayHandle`] impl, which exposes [`WindowHandle`] and [`DisplayHandle`].
+    ///
+    /// # Safety
+    ///
+    /// Some platforms have constraints on where/how this handle can be used. For example, some platforms don't support doing window
+    /// operations off of the main thread. The caller must ensure the [`RawHandleWrapper`] is only used in valid contexts.
+    pub unsafe fn get_handle(&self) -> ThreadLockedRawWindowHandleWrapper {
+        ThreadLockedRawWindowHandleWrapper(self.clone())
+    }
+
+    /// Gets the stored window handle.
+    pub fn get_window_handle(&self) -> RawWindowHandle {
+        self.window_handle
+    }
+
+    /// Sets the window handle.
+    ///
+    /// # Safety
+    ///
+    /// The passed in [`RawWindowHandle`] must be a valid window handle.
+    // NOTE: The use of an explicit setter instead of a getter for a mutable reference is to limit the amount of time unsoundness can happen.
+    //       If we handed out a mutable reference the user would have to maintain safety invariants throughout its lifetime. For consistency
+    //       we also prefer to handout copies of the handles instead of immutable references.
+    pub unsafe fn set_window_handle(&mut self, window_handle: RawWindowHandle) -> &mut Self {
+        self.window_handle = window_handle;
+
+        self
+    }
+
+    /// Gets the stored display handle
+    pub fn get_display_handle(&self) -> RawDisplayHandle {
+        self.display_handle
+    }
+
+    /// Sets the display handle.
+    ///
+    /// # Safety
+    ///
+    /// The passed in [`RawDisplayHandle`] must be a valid display handle.
+    pub fn set_display_handle(&mut self, display_handle: RawDisplayHandle) -> &mut Self {
+        self.display_handle = display_handle;
+
+        self
+    }
+}
+
+// SAFETY: [`RawHandleWrapper`] is just a normal "raw pointer", which doesn't impl Send/Sync. However the pointer is only
+// exposed via an unsafe method that forces the user to make a call for a given platform. (ex: some platforms don't
+// support doing window operations off of the main thread).
+// A recommendation for this pattern (and more context) is available here:
+// https://github.com/rust-windowing/raw-window-handle/issues/59
+unsafe impl Send for RawHandleWrapper {}
+// SAFETY: This is safe for the same reasons as the Send impl above.
+unsafe impl Sync for RawHandleWrapper {}
+
+/// A [`RawHandleWrapper`] that cannot be sent across threads.
+///
+/// This safely exposes [`RawWindowHandle`] and [`RawDisplayHandle`], but care must be taken to ensure that the construction itself is correct.
+///
+/// This can only be constructed via the [`RawHandleWrapper::get_handle()`] method;
+/// be sure to read the safety docs there about platform-specific limitations.
+/// In many cases, this should only be constructed on the main thread.
+pub struct ThreadLockedRawWindowHandleWrapper(RawHandleWrapper);
+
+impl HasWindowHandle for ThreadLockedRawWindowHandleWrapper {
+    fn window_handle(&self) -> Result<WindowHandle, HandleError> {
+        // SAFETY: the caller has validated that this is a valid context to get [`RawHandleWrapper`]
+        // as otherwise an instance of this type could not have been constructed
+        // NOTE: we cannot simply impl HasRawWindowHandle for RawHandleWrapper,
+        // as the `raw_window_handle` method is safe. We cannot guarantee that all calls
+        // of this method are correct (as it may be off the main thread on an incompatible platform),
+        // and so exposing a safe method to get a [`RawWindowHandle`] directly would be UB.
+        Ok(unsafe { WindowHandle::borrow_raw(self.0.window_handle) })
+    }
+}
+
+impl HasDisplayHandle for ThreadLockedRawWindowHandleWrapper {
+    fn display_handle(&self) -> Result<DisplayHandle, HandleError> {
+        // SAFETY: the caller has validated that this is a valid context to get [`RawDisplayHandle`]
+        // as otherwise an instance of this type could not have been constructed
+        // NOTE: we cannot simply impl HasRawDisplayHandle for RawHandleWrapper,
+        // as the `raw_display_handle` method is safe. We cannot guarantee that all calls
+        // of this method are correct (as it may be off the main thread on an incompatible platform),
+        // and so exposing a safe method to get a [`RawDisplayHandle`] directly would be UB.
+        Ok(unsafe { DisplayHandle::borrow_raw(self.0.display_handle) })
+    }
+}
+
+/// Holder of the [`RawHandleWrapper`] with wrappers, to allow use in asynchronous context
+#[derive(Debug, Clone, Component)]
+pub struct RawHandleWrapperHolder(pub Arc<Mutex<Option<RawHandleWrapper>>>);

vendor/bevy_window/src/system.rs

@@ -0,0 +1,58 @@
+use crate::{ClosingWindow, PrimaryWindow, Window, WindowCloseRequested};
+
+use bevy_app::AppExit;
+use bevy_ecs::prelude::*;
+
+/// Exit the application when there are no open windows.
+///
+/// This system is added by the [`WindowPlugin`] in the default configuration.
+/// To disable this behavior, set `close_when_requested` (on the [`WindowPlugin`]) to `false`.
+/// Ensure that you read the caveats documented on that field if doing so.
+///
+/// [`WindowPlugin`]: crate::WindowPlugin
+pub fn exit_on_all_closed(mut app_exit_events: EventWriter<AppExit>, windows: Query<&Window>) {
+    if windows.is_empty() {
+        log::info!("No windows are open, exiting");
+        app_exit_events.write(AppExit::Success);
+    }
+}
+
+/// Exit the application when the primary window has been closed
+///
+/// This system is added by the [`WindowPlugin`]
+///
+/// [`WindowPlugin`]: crate::WindowPlugin
+pub fn exit_on_primary_closed(
+    mut app_exit_events: EventWriter<AppExit>,
+    windows: Query<(), (With<Window>, With<PrimaryWindow>)>,
+) {
+    if windows.is_empty() {
+        log::info!("Primary window was closed, exiting");
+        app_exit_events.write(AppExit::Success);
+    }
+}
+
+/// Close windows in response to [`WindowCloseRequested`] (e.g.  when the close button is pressed).
+///
+/// This system is added by the [`WindowPlugin`] in the default configuration.
+/// To disable this behavior, set `close_when_requested` (on the [`WindowPlugin`]) to `false`.
+/// Ensure that you read the caveats documented on that field if doing so.
+///
+/// [`WindowPlugin`]: crate::WindowPlugin
+pub fn close_when_requested(
+    mut commands: Commands,
+    mut closed: EventReader<WindowCloseRequested>,
+    closing: Query<Entity, With<ClosingWindow>>,
+) {
+    // This was inserted by us on the last frame so now we can despawn the window
+    for window in closing.iter() {
+        commands.entity(window).despawn();
+    }
+    // Mark the window as closing so we can despawn it on the next frame
+    for event in closed.read() {
+        // When spamming the window close button on windows (other platforms too probably)
+        // we may receive a `WindowCloseRequested` for a window we've just despawned in the above
+        // loop.
+        commands.entity(event.window).try_insert(ClosingWindow);
+    }
+}

vendor/bevy_window/src/system_cursor.rs

@@ -0,0 +1,224 @@
+// This file contains a portion of the CSS Basic User Interface Module Level 3
+// specification. In particular, the names for the cursor from the #cursor
+// section and documentation for some of the variants were taken.
+//
+// The original document is https://www.w3.org/TR/css-ui-3/#cursor.
+// Copyright © 2018 W3C® (MIT, ERCIM, Keio, Beihang)
+//
+// These documents were used under the terms of the following license. This W3C
+// license as well as the W3C short notice apply to the `CursorIcon` enum's
+// variants and documentation attached to them.
+
+// --------- BEGINNING OF W3C LICENSE
+// --------------------------------------------------------------
+//
+// License
+//
+// By obtaining and/or copying this work, you (the licensee) agree that you have
+// read, understood, and will comply with the following terms and conditions.
+//
+// Permission to copy, modify, and distribute this work, with or without
+// modification, for any purpose and without fee or royalty is hereby granted,
+// provided that you include the following on ALL copies of the work or portions
+// thereof, including modifications:
+//
+// - The full text of this NOTICE in a location viewable to users of the
+//   redistributed or derivative work.
+// - Any pre-existing intellectual property disclaimers, notices, or terms and
+//   conditions. If none exist, the W3C Software and Document Short Notice
+//   should be included.
+// - Notice of any changes or modifications, through a copyright statement on
+//   the new code or document such as "This software or document includes
+//   material copied from or derived from [title and URI of the W3C document].
+//   Copyright © [YEAR] W3C® (MIT, ERCIM, Keio, Beihang)."
+//
+// Disclaimers
+//
+// THIS WORK IS PROVIDED "AS IS," AND COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS
+// OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO, WARRANTIES
+// OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF
+// THE SOFTWARE OR DOCUMENT WILL NOT INFRINGE ANY THIRD PARTY PATENTS,
+// COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS.
+//
+// COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR
+// CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE SOFTWARE OR DOCUMENT.
+//
+// The name and trademarks of copyright holders may NOT be used in advertising
+// or publicity pertaining to the work without specific, written prior
+// permission. Title to copyright in this work will at all times remain with
+// copyright holders.
+//
+// --------- END OF W3C LICENSE
+// --------------------------------------------------------------------
+
+// --------- BEGINNING OF W3C SHORT NOTICE
+// ---------------------------------------------------------
+//
+// winit: https://github.com/rust-windowing/cursor-icon
+//
+// Copyright © 2023 World Wide Web Consortium, (Massachusetts Institute of
+// Technology, European Research Consortium for Informatics and Mathematics,
+// Keio University, Beihang). All Rights Reserved. This work is distributed
+// under the W3C® Software License [1] in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.
+//
+// [1] http://www.w3.org/Consortium/Legal/copyright-software
+//
+// --------- END OF W3C SHORT NOTICE
+// --------------------------------------------------------------
+
+#[cfg(feature = "bevy_reflect")]
+use bevy_reflect::{prelude::ReflectDefault, Reflect};
+
+#[cfg(feature = "serialize")]
+use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
+
+/// The icon to display for a window.
+///
+/// Examples of all of these cursors can be found [here](https://www.w3schools.com/cssref/playit.php?filename=playcss_cursor&preval=crosshair).
+/// This `enum` is simply a copy of a similar `enum` found in [`winit`](https://docs.rs/winit/latest/winit/window/enum.CursorIcon.html).
+/// `winit`, in turn, is based upon the [CSS3 UI spec](https://www.w3.org/TR/css-ui-3/#cursor).
+///
+/// See the [`window_settings`] example for usage.
+///
+/// [`window_settings`]: https://github.com/bevyengine/bevy/blob/latest/examples/window/window_settings.rs
+#[derive(Default, Debug, Hash, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Debug, PartialEq, Hash, Default, Clone)
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect(Serialize, Deserialize)
+)]
+pub enum SystemCursorIcon {
+    /// The platform-dependent default cursor. Often rendered as arrow.
+    #[default]
+    Default,
+
+    /// A context menu is available for the object under the cursor. Often
+    /// rendered as an arrow with a small menu-like graphic next to it.
+    ContextMenu,
+
+    /// Help is available for the object under the cursor. Often rendered as a
+    /// question mark or a balloon.
+    Help,
+
+    /// The cursor is a pointer that indicates a link. Often rendered as the
+    /// backside of a hand with the index finger extended.
+    Pointer,
+
+    /// A progress indicator. The program is performing some processing, but is
+    /// different from [`SystemCursorIcon::Wait`] in that the user may still interact
+    /// with the program.
+    Progress,
+
+    /// Indicates that the program is busy and the user should wait. Often
+    /// rendered as a watch or hourglass.
+    Wait,
+
+    /// Indicates that a cell or set of cells may be selected. Often rendered as
+    /// a thick plus-sign with a dot in the middle.
+    Cell,
+
+    /// A simple crosshair (e.g., short line segments resembling a "+" sign).
+    /// Often used to indicate a two dimensional bitmap selection mode.
+    Crosshair,
+
+    /// Indicates text that may be selected. Often rendered as an I-beam.
+    Text,
+
+    /// Indicates vertical-text that may be selected. Often rendered as a
+    /// horizontal I-beam.
+    VerticalText,
+
+    /// Indicates an alias of/shortcut to something is to be created. Often
+    /// rendered as an arrow with a small curved arrow next to it.
+    Alias,
+
+    /// Indicates something is to be copied. Often rendered as an arrow with a
+    /// small plus sign next to it.
+    Copy,
+
+    /// Indicates something is to be moved.
+    Move,
+
+    /// Indicates that the dragged item cannot be dropped at the current cursor
+    /// location. Often rendered as a hand or pointer with a small circle with a
+    /// line through it.
+    NoDrop,
+
+    /// Indicates that the requested action will not be carried out. Often
+    /// rendered as a circle with a line through it.
+    NotAllowed,
+
+    /// Indicates that something can be grabbed (dragged to be moved). Often
+    /// rendered as the backside of an open hand.
+    Grab,
+
+    /// Indicates that something is being grabbed (dragged to be moved). Often
+    /// rendered as the backside of a hand with fingers closed mostly out of
+    /// view.
+    Grabbing,
+
+    /// The east border to be moved.
+    EResize,
+
+    /// The north border to be moved.
+    NResize,
+
+    /// The north-east corner to be moved.
+    NeResize,
+
+    /// The north-west corner to be moved.
+    NwResize,
+
+    /// The south border to be moved.
+    SResize,
+
+    /// The south-east corner to be moved.
+    SeResize,
+
+    /// The south-west corner to be moved.
+    SwResize,
+
+    /// The west border to be moved.
+    WResize,
+
+    /// The east and west borders to be moved.
+    EwResize,
+
+    /// The south and north borders to be moved.
+    NsResize,
+
+    /// The north-east and south-west corners to be moved.
+    NeswResize,
+
+    /// The north-west and south-east corners to be moved.
+    NwseResize,
+
+    /// Indicates that the item/column can be resized horizontally. Often
+    /// rendered as arrows pointing left and right with a vertical bar
+    /// separating them.
+    ColResize,
+
+    /// Indicates that the item/row can be resized vertically. Often rendered as
+    /// arrows pointing up and down with a horizontal bar separating them.
+    RowResize,
+
+    /// Indicates that the something can be scrolled in any direction. Often
+    /// rendered as arrows pointing up, down, left, and right with a dot in the
+    /// middle.
+    AllScroll,
+
+    /// Indicates that something can be zoomed in. Often rendered as a
+    /// magnifying glass with a "+" in the center of the glass.
+    ZoomIn,
+
+    /// Indicates that something can be zoomed in. Often rendered as a
+    /// magnifying glass with a "-" in the center of the glass.
+    ZoomOut,
+}