Struct Window 

pub struct Window {

    pub present_mode: PresentMode,
    pub mode: WindowMode,
    pub position: WindowPosition,
    pub resolution: WindowResolution,
    pub title: String,
    pub name: Option<String>,
    pub composite_alpha_mode: CompositeAlphaMode,
    pub resize_constraints: WindowResizeConstraints,
    pub resizable: bool,
    pub enabled_buttons: EnabledButtons,
    pub decorations: bool,
    pub transparent: bool,
    pub focused: bool,
    pub window_level: WindowLevel,
    pub canvas: Option<String>,
    pub fit_canvas_to_parent: bool,
    pub prevent_default_event_handling: bool,
    pub internal: InternalWindowState,
    pub ime_enabled: bool,
    pub ime_position: Vec2,
    pub window_theme: Option<WindowTheme>,
    pub visible: bool,
    pub skip_taskbar: bool,
    pub clip_children: bool,
    pub desired_maximum_frame_latency: Option<NonZero<u32>>,
    pub recognize_pinch_gesture: bool,
    pub recognize_rotation_gesture: bool,
    pub recognize_doubletap_gesture: bool,
    pub recognize_pan_gesture: Option<(u8, u8)>,
    pub movable_by_window_background: bool,
    pub fullsize_content_view: bool,
    pub has_shadow: bool,
    pub titlebar_shown: bool,
    pub titlebar_transparent: bool,
    pub titlebar_show_title: bool,
    pub titlebar_show_buttons: bool,
    pub borderless_game: bool,
    pub prefers_home_indicator_hidden: bool,
    pub prefers_status_bar_hidden: bool,
    pub preferred_screen_edges_deferring_system_gestures: ScreenEdge,
}

The defining Component for window entities, storing information about how it should appear and behave.

Each window corresponds to an entity, and is uniquely identified by the value of their Entity. When the Window component is added to an entity, a new window will be opened. When it is removed or the entity is despawned, the window will close.

The primary window entity (and the corresponding window) is spawned by default by WindowPlugin and is marked with the PrimaryWindow component.

This component is synchronized with winit through bevy_winit: it will reflect the current state of the window and can be modified to change this state.

Example

Because this component is synchronized with winit, it can be used to perform OS-integrated windowing operations. For example, here’s a simple system to change the window mode:

fn change_window_mode(mut windows: Query<&mut Window, With<PrimaryWindow>>) {
    // Query returns one window typically.
    for mut window in windows.iter_mut() {
        window.mode =
            WindowMode::Fullscreen(MonitorSelection::Current, VideoModeSelection::Current);
    }
}

Fields

present_mode: PresentMode

What presentation mode to give the window.

mode: WindowMode

Which fullscreen or windowing mode should be used.

position: WindowPosition

Where the window should be placed.

resolution: WindowResolution

What resolution the window should have.

title: String

Stores the title of the window.

name: Option<String>

Stores the application ID (on Wayland), WM_CLASS (on X11) or window class name (on Windows) of the window.

For details about application ID conventions, see the Desktop Entry Spec. For details about WM_CLASS, see the X11 Manual Pages. For details about Windows’s window class names, see About Window Classes.

Platform-specific

• Windows: Can only be set while building the window, setting the window’s window class name.
• Wayland: Can only be set while building the window, setting the window’s application ID.
• X11: Can only be set while building the window, setting the window’s WM_CLASS.
• macOS, iOS, Android, and Web: not applicable.

Notes: Changing this field during runtime will have no effect for now.

composite_alpha_mode: CompositeAlphaMode

How the alpha channel of textures should be handled while compositing.

resize_constraints: WindowResizeConstraints

The limits of the window’s logical size (found in its resolution) when resizing.

resizable: bool

Should the window be resizable?

Note: This does not stop the program from fullscreening/setting the size programmatically.

enabled_buttons: EnabledButtons

Specifies which window control buttons should be enabled.

Platform-specific

iOS, Android, and the Web do not have window control buttons.

On some Linux environments these values have no effect.

decorations: bool

Should the window have decorations enabled?

(Decorations are the minimize, maximize, and close buttons on desktop apps)

Platform-specific

iOS, Android, and the Web do not have decorations.

transparent: bool

Should the window be transparent?

Defines whether the background of the window should be transparent.

Platform-specific

• iOS / Android / Web: Unsupported.
• macOS: Not working as expected.

macOS transparent works with winit out of the box, so this issue might be related to: https://github.com/gfx-rs/wgpu/issues/687. You should also set the window composite_alpha_mode to CompositeAlphaMode::PostMultiplied.

focused: bool

Get/set whether the window is focused.

It cannot be set unfocused after creation.

Platform-specific

• iOS / Android / X11 / Wayland: Spawning unfocused is not supported.
• iOS / Android / Web / Wayland: Setting focused after creation is not supported.

window_level: WindowLevel

Where should the window appear relative to other overlapping window.

Platform-specific

• iOS / Android / Web / Wayland: Unsupported.

canvas: Option<String>

The “html canvas” element selector.

If set, this selector will be used to find a matching html canvas element, rather than creating a new one. Uses the CSS selector format.

This value has no effect on non-web platforms.

fit_canvas_to_parent: bool

Whether or not to fit the canvas element’s size to its parent element’s size.

Warning: this will not behave as expected for parents that set their size according to the size of their children. This creates a “feedback loop” that will result in the canvas growing on each resize. When using this feature, ensure the parent’s size is not affected by its children.

This value has no effect on non-web platforms.

prevent_default_event_handling: bool

Whether or not to stop events from propagating out of the canvas element

When true, this will prevent common browser hotkeys like F5, F12, Ctrl+R, tab, etc. from performing their default behavior while the bevy app has focus.

This value has no effect on non-web platforms.

internal: InternalWindowState

Stores internal state that isn’t directly accessible.

ime_enabled: bool

Should the window use Input Method Editor?

If enabled, the window will receive Ime events instead of KeyboardInput from bevy_input.

IME should be enabled during text input, but not when you expect to get the exact key pressed.

Platform-specific

• iOS / Android / Web: Unsupported.

ime_position: Vec2

Sets location of IME candidate box in client area coordinates relative to the top left.

Platform-specific

• iOS / Android / Web: Unsupported.

window_theme: Option<WindowTheme>

Sets a specific theme for the window.

If None is provided, the window will use the system theme.

Platform-specific

• iOS / Android / Web: Unsupported.

visible: bool

Sets the window’s visibility.

If false, this will hide the window completely, it won’t appear on the screen or in the task bar. If true, this will show the window. Note that this doesn’t change its focused or minimized state.

Platform-specific

• Android / Wayland / Web: Unsupported.

skip_taskbar: bool

Sets whether the window should be shown in the taskbar.

If true, the window will not appear in the taskbar. If false, the window will appear in the taskbar.

Note that this will only take effect on window creation.

Platform-specific

• Only supported on Windows.

clip_children: bool

Sets whether the window should draw over its child windows.

If true, the window excludes drawing over areas obscured by child windows. If false, the window can draw over child windows.

Platform-specific

• Only supported on Windows.

desired_maximum_frame_latency: Option<NonZero<u32>>

Optional hint given to the rendering API regarding the maximum number of queued frames admissible on the GPU.

Given values are usually within the 1-3 range. If not provided, this will default to 2.

See wgpu::SurfaceConfiguration::desired_maximum_frame_latency.

recognize_pinch_gesture: bool

Sets whether this window recognizes PinchGesture

Platform-specific

• Only used on iOS.
• On macOS, they are recognized by default and can’t be disabled.

recognize_rotation_gesture: bool

Sets whether this window recognizes RotationGesture

Platform-specific

• Only used on iOS.
• On macOS, they are recognized by default and can’t be disabled.

recognize_doubletap_gesture: bool

Sets whether this window recognizes DoubleTapGesture

Platform-specific

• Only used on iOS.
• On macOS, they are recognized by default and can’t be disabled.

recognize_pan_gesture: Option<(u8, u8)>

Sets whether this window recognizes PanGesture, with a number of fingers between the first value and the last.

Platform-specific

• Only used on iOS.

movable_by_window_background: bool

Enables click-and-drag behavior for the entire window, not just the titlebar.

Corresponds to WindowAttributesExtMacOS::with_movable_by_window_background.

Platform-specific

• Only used on macOS.

fullsize_content_view: bool

Makes the window content appear behind the titlebar.

Corresponds to WindowAttributesExtMacOS::with_fullsize_content_view.

For apps which want to render the window buttons on top of the apps itself, this should be enabled along with titlebar_transparent.

Platform-specific

• Only used on macOS.

has_shadow: bool

Toggles drawing the drop shadow behind the window.

Corresponds to WindowAttributesExtMacOS::with_has_shadow.

Platform-specific

• Only used on macOS.

titlebar_shown: bool

Toggles drawing the titlebar.

Corresponds to WindowAttributesExtMacOS::with_titlebar_hidden.

Platform-specific

• Only used on macOS.

titlebar_transparent: bool

Makes the titlebar transparent, allowing the app content to appear behind it.

Corresponds to WindowAttributesExtMacOS::with_titlebar_transparent.

Platform-specific

• Only used on macOS.

titlebar_show_title: bool

Toggles showing the window title.

Corresponds to WindowAttributesExtMacOS::with_title_hidden.

Platform-specific

• Only used on macOS.

titlebar_show_buttons: bool

Toggles showing the traffic light window buttons.

Corresponds to WindowAttributesExtMacOS::with_titlebar_buttons_hidden.

Platform-specific

• Only used on macOS.

borderless_game: bool

Hides the dock and menu bar when a borderless fullscreen window is active.

Corresponds to WindowAttributesExtMacOS::with_borderless_game.

Defaults to true as this is the expected behavior for games.

Platform-specific

• Only used on macOS.

prefers_home_indicator_hidden: bool

Sets whether the Window prefers the home indicator hidden.

Corresponds to WindowAttributesExtIOS::with_prefers_home_indicator_hidden.

Platform-specific

• Only used on iOS.

prefers_status_bar_hidden: bool

Sets whether the Window prefers the status bar hidden.

Corresponds to WindowAttributesExtIOS::with_prefers_status_bar_hidden.

Platform-specific

• Only used on iOS.

preferred_screen_edges_deferring_system_gestures: ScreenEdge

Sets screen edges for which you want your gestures to take precedence over the system gestures.

Corresponds to WindowAttributesExtIOS::with_preferred_screen_edges_deferring_system_gestures.

Platform-specific

• Only used on iOS.

Implementations

impl Window

pub fn set_maximized(&mut self, maximized: bool)

Setting to true will attempt to maximize the window.

Setting to false will attempt to un-maximize the window.

pub fn set_minimized(&mut self, minimized: bool)

Setting to true will attempt to minimize the window.

Setting to false will attempt to un-minimize the window.

Examples found in repository

tests/window/minimizing.rs (line 26)

fn minimize_automatically(mut window: Single<&mut Window>, frames: Res<FrameCount>) {
    if frames.0 != 60 {
        return;
    }

    window.set_minimized(true);
}

pub fn start_drag_move(&mut self)

Calling this will attempt to start a drag-move of the window.

There is no guarantee that this will work unless the left mouse button was pressed immediately before this function was called.

Examples found in repository

examples/window/window_drag_move.rs (line 136)

fn move_or_resize_windows(
    mut windows: Query<&mut Window>,
    action: Res<LeftClickAction>,
    input: Res<ButtonInput<MouseButton>>,
    dir: Res<ResizeDir>,
) {
    // Both `start_drag_move()` and `start_drag_resize()` must be called after a
    // left mouse button press as done here.
    //
    // winit 0.30.5 may panic when initiated without a left mouse button press.
    if input.just_pressed(MouseButton::Left) {
        for mut window in windows.iter_mut() {
            match *action {
                LeftClickAction::Nothing => (),
                LeftClickAction::Move => window.start_drag_move(),
                LeftClickAction::Resize => {
                    let d = DIRECTIONS[dir.0];
                    window.start_drag_resize(d);
                }
            }
        }
    }
}

pub fn start_drag_resize(&mut self, direction: CompassOctant)

Calling this will attempt to start a drag-resize of the window.

There is no guarantee that this will work unless the left mouse button was pressed immediately before this function was called.

Examples found in repository

examples/window/window_drag_move.rs (line 139)

fn move_or_resize_windows(
    mut windows: Query<&mut Window>,
    action: Res<LeftClickAction>,
    input: Res<ButtonInput<MouseButton>>,
    dir: Res<ResizeDir>,
) {
    // Both `start_drag_move()` and `start_drag_resize()` must be called after a
    // left mouse button press as done here.
    //
    // winit 0.30.5 may panic when initiated without a left mouse button press.
    if input.just_pressed(MouseButton::Left) {
        for mut window in windows.iter_mut() {
            match *action {
                LeftClickAction::Nothing => (),
                LeftClickAction::Move => window.start_drag_move(),
                LeftClickAction::Resize => {
                    let d = DIRECTIONS[dir.0];
                    window.start_drag_resize(d);
                }
            }
        }
    }
}

pub fn width(&self) -> f32

The window’s client area width in logical pixels.

See WindowResolution for an explanation about logical/physical sizes.

Examples found in repository

examples/ecs/parallel_query.rs (line 49)

fn bounce_system(window: Query<&Window>, mut sprites: Query<(&Transform, &mut Velocity)>) {
    let Ok(window) = window.single() else {
        return;
    };
    let width = window.width();
    let height = window.height();
    let left = width / -2.0;
    let right = width / 2.0;
    let bottom = height / -2.0;
    let top = height / 2.0;
    // The default batch size can also be overridden.
    // In this case a batch size of 32 is chosen to limit the overhead of
    // ParallelIterator, since negating a vector is very inexpensive.
    sprites
        .par_iter_mut()
        .batching_strategy(BatchingStrategy::fixed(32))
        .for_each(|(transform, mut v)| {
            if !(left < transform.translation.x
                && transform.translation.x < right
                && bottom < transform.translation.y
                && transform.translation.y < top)
            {
                // For simplicity, just reverse the velocity; don't use realistic bounces
                v.0 = -v.0;
            }
        });
}

pub fn height(&self) -> f32

The window’s client area height in logical pixels.

See WindowResolution for an explanation about logical/physical sizes.

Examples found in repository

examples/ecs/parallel_query.rs (line 50)

fn bounce_system(window: Query<&Window>, mut sprites: Query<(&Transform, &mut Velocity)>) {
    let Ok(window) = window.single() else {
        return;
    };
    let width = window.width();
    let height = window.height();
    let left = width / -2.0;
    let right = width / 2.0;
    let bottom = height / -2.0;
    let top = height / 2.0;
    // The default batch size can also be overridden.
    // In this case a batch size of 32 is chosen to limit the overhead of
    // ParallelIterator, since negating a vector is very inexpensive.
    sprites
        .par_iter_mut()
        .batching_strategy(BatchingStrategy::fixed(32))
        .for_each(|(transform, mut v)| {
            if !(left < transform.translation.x
                && transform.translation.x < right
                && bottom < transform.translation.y
                && transform.translation.y < top)
            {
                // For simplicity, just reverse the velocity; don't use realistic bounces
                v.0 = -v.0;
            }
        });
}

pub fn size(&self) -> Vec2

The window’s client size in logical pixels

See WindowResolution for an explanation about logical/physical sizes.

Examples found in repository

examples/stress_tests/bevymark.rs (line 589)

fn collision_system(window: Query<&Window>, mut bird_query: Query<(&mut Bird, &Transform)>) {
    let Ok(window) = window.single() else {
        return;
    };

    let half_extents = 0.5 * window.size();

    for (mut bird, transform) in &mut bird_query {
        handle_collision(half_extents, &transform.translation, &mut bird.velocity);
    }
}

examples/2d/dynamic_mip_generation.rs (line 433)

fn animate_image_scale(
    mut animated_images_query: Query<&mut Transform, With<AnimatedImage>>,
    windows_query: Query<&Window, With<PrimaryWindow>>,
    app_status: Res<AppStatus>,
    time: Res<Time>,
) {
    let window_size = windows_query.iter().next().unwrap().size();
    let animated_mesh_size = app_status.animated_mesh_size(window_size);

    for mut animated_image_transform in &mut animated_images_query {
        animated_image_transform.scale =
            animated_mesh_size.extend(1.0) * triangle_wave(time.elapsed_secs(), ANIMATION_PERIOD);
    }
}

/// Evaluates a [triangle wave] with the given wavelength.
///
/// This is used as part of [`animate_image_scale`], to derive the scale from
/// the current elapsed time.
///
/// [triangle wave]: https://en.wikipedia.org/wiki/Triangle_wave#Definition
fn triangle_wave(time: f32, wavelength: f32) -> f32 {
    2.0 * ops::abs(time / wavelength - ops::floor(time / wavelength + 0.5))
}

/// Adds the top mipmap level of the image to [`MipGenerationJobs`].
///
/// Note that this must run in the render world, not the main world, as
/// [`MipGenerationJobs`] is a resource that exists in the former. Consequently,
/// it must use [`Extract`] to access main world resources.
fn extract_mipmap_source_image(
    mipmap_source_image: Extract<Res<MipmapSourceImage>>,
    app_status: Extract<Res<AppStatus>>,
    mut mip_generation_jobs: ResMut<MipGenerationJobs>,
) {
    if app_status.enable_mip_generation == EnableMipGeneration::On {
        mip_generation_jobs.add(MIP_GENERATION_PHASE_ID, mipmap_source_image.id());
    }
}

/// Updates the widgets at the bottom of the screen to reflect the settings that
/// the user has chosen.
fn update_radio_buttons(
    mut widgets: Query<
        (
            Entity,
            Option<&mut BackgroundColor>,
            Has<Text>,
            &WidgetClickSender<AppSetting>,
        ),
        Or<(With<RadioButton>, With<RadioButtonText>)>,
    >,
    app_status: Res<AppStatus>,
    mut writer: TextUiWriter,
) {
    for (entity, image, has_text, sender) in widgets.iter_mut() {
        let selected = match **sender {
            AppSetting::RegenerateTopMipLevel => continue,
            AppSetting::EnableMipGeneration(enable_mip_generation) => {
                enable_mip_generation == app_status.enable_mip_generation
            }
            AppSetting::ImageWidth(image_width) => image_width == app_status.image_width,
            AppSetting::ImageHeight(image_height) => image_height == app_status.image_height,
        };

        if let Some(mut bg_color) = image {
            widgets::update_ui_radio_button(&mut bg_color, selected);
        }
        if has_text {
            widgets::update_ui_radio_button_text(entity, &mut writer, selected);
        }
    }
}

/// Handles a request from the user to change application settings via the UI.
///
/// This also handles clicks on the "Regenerate Top Mip Level" button.
fn handle_app_setting_change(
    mut events: MessageReader<WidgetClickEvent<AppSetting>>,
    mut app_status: ResMut<AppStatus>,
    mut regenerate_image_message_writer: MessageWriter<RegenerateImage>,
) {
    for event in events.read() {
        // If this is a setting, update the setting. Fall through if, in
        // addition to updating the setting, we need to regenerate the image.
        match **event {
            AppSetting::EnableMipGeneration(enable_mip_generation) => {
                app_status.enable_mip_generation = enable_mip_generation;
                continue;
            }

            AppSetting::RegenerateTopMipLevel => {}
            AppSetting::ImageWidth(image_size) => app_status.image_width = image_size,
            AppSetting::ImageHeight(image_size) => app_status.image_height = image_size,
        }

        // Schedule the image to be regenerated.
        regenerate_image_message_writer.write(RegenerateImage);
    }
}

/// Handles resize events for the window.
///
/// Resizing the window invalidates the image and repositions all image views.
/// (Regenerating the image isn't strictly necessary, but it's simplest to have
/// a single function that both regenerates the image and recreates the image
/// views.)
fn handle_window_resize_events(
    mut events: MessageReader<WindowResized>,
    mut regenerate_image_message_writer: MessageWriter<RegenerateImage>,
) {
    for _ in events.read() {
        regenerate_image_message_writer.write(RegenerateImage);
    }
}

/// Recreates the image, as well as all views that show the image, when a
/// [`RegenerateImage`] message is received.
///
/// The views that show the image consist of the animated mesh on the left side
/// of the window and the column of mipmap level views on the right side of the
/// window.
fn regenerate_image_when_requested(
    mut commands: Commands,
    image_views_query: Query<Entity, With<ImageView>>,
    windows_query: Query<&Window, With<PrimaryWindow>>,
    app_assets: Res<AppAssets>,
    mut app_status: ResMut<AppStatus>,
    mut images: ResMut<Assets<Image>>,
    mut single_mip_level_materials: ResMut<Assets<SingleMipLevelMaterial>>,
    mut color_materials: ResMut<Assets<ColorMaterial>>,
    mut message_reader: MessageReader<RegenerateImage>,
) {
    // Only do this at most once per frame, or else the despawn logic below will
    // get confused.
    if message_reader.read().count() == 0 {
        return;
    }

    // Despawn all entities that show the image.
    for entity in image_views_query.iter() {
        commands.entity(entity).despawn();
    }

    // Regenerate the image.
    let image_handle = app_status.regenerate_mipmap_source_image(&mut commands, &mut images);

    // Respawn the animated image view on the left side of the window.
    spawn_animated_mesh(
        &mut commands,
        &app_status,
        &app_assets,
        &windows_query,
        &mut color_materials,
        &image_handle,
    );

    // Respawn the column of mip level views on the right side of the window.
    spawn_mip_level_views(
        &mut commands,
        &app_status,
        &app_assets,
        &windows_query,
        &mut single_mip_level_materials,
        &image_handle,
    );
}

/// Spawns the image on the left that continually changes scale.
///
/// Continually changing scale effectively cycles though each mip level,
/// demonstrating the difference between mip level images being present and mip
/// level image being absent.
fn spawn_animated_mesh(
    commands: &mut Commands,
    app_status: &AppStatus,
    app_assets: &AppAssets,
    windows_query: &Query<&Window, With<PrimaryWindow>>,
    color_materials: &mut Assets<ColorMaterial>,
    image_handle: &Handle<Image>,
) {
    let window_size = windows_query.iter().next().unwrap().size();
    let animated_mesh_area_size = app_status.animated_mesh_area_size(window_size);
    let animated_mesh_size = app_status.animated_mesh_size(window_size);

    commands.spawn((
        Mesh2d(app_assets.rectangle.clone()),
        MeshMaterial2d(color_materials.add(ColorMaterial {
            texture: Some(image_handle.clone()),
            ..default()
        })),
        Transform::from_translation(
            (animated_mesh_area_size * 0.5 - window_size * 0.5).extend(0.0),
        )
        .with_scale(animated_mesh_size.extend(1.0)),
        AnimatedImage,
        ImageView,
    ));
}

/// Creates the column on the right side of the window that displays each mip
/// level by itself.
fn spawn_mip_level_views(
    commands: &mut Commands,
    app_status: &AppStatus,
    app_assets: &AppAssets,
    windows_query: &Query<&Window, With<PrimaryWindow>>,
    single_mip_level_materials: &mut Assets<SingleMipLevelMaterial>,
    image_handle: &Handle<Image>,
) {
    let window_size = windows_query.iter().next().unwrap().size();

    // Calculate the placement of the column of mipmap levels.
    let max_slice_size = app_status.max_mip_slice_size(window_size);
    let y_origin = app_status.vertical_mip_slice_origin(window_size);
    let y_spacing = app_status.vertical_mip_slice_spacing(window_size);
    let x_origin = app_status.horizontal_mip_slice_origin(window_size);

    for (mip_level, mip_size) in MipmapSizeIterator::new(app_status).enumerate() {
        let y_center = y_origin - y_spacing * mip_level as f32;

        // Size each image to fit its container, preserving aspect ratio.
        let mut slice_size = mip_size.as_vec2();
        let ratios = max_slice_size / slice_size;
        let slice_scale = ratios.x.min(ratios.y).min(1.0);
        slice_size *= slice_scale;

        // Spawn the image. Use the `SingleMipLevelMaterial` with its custom
        // shader so that only the mip level in question is displayed.
        commands.spawn((
            Mesh2d(app_assets.rectangle.clone()),
            MeshMaterial2d(single_mip_level_materials.add(SingleMipLevelMaterial {
                mip_level: mip_level as u32,
                texture: image_handle.clone(),
            })),
            Transform::from_xyz(x_origin, y_center, 0.0).with_scale(slice_size.extend(1.0)),
            ImageView,
        ));

        // Display a label to the side.
        commands.spawn((
            Text2d::new(format!(
                "Level {}\n{}×{}",
                mip_level, mip_size.x, mip_size.y
            )),
            app_assets.text_font.clone(),
            TextLayout::justify(Justify::Center),
            Text2dShadow::default(),
            Transform::from_xyz(x_origin - max_slice_size.x * 0.5 - 64.0, y_center, 0.0),
            ImageView,
        ));
    }
}

examples/showcase/contributors.rs (line 264)

fn collisions(
    window: Query<&Window>,
    mut query: Query<(&mut Velocity, &mut Transform), With<Contributor>>,
    mut rng: ResMut<SharedRng>,
) {
    let Ok(window) = window.single() else {
        return;
    };

    let window_size = window.size();

    let collision_area = Aabb2d::new(Vec2::ZERO, (window_size - SPRITE_SIZE) / 2.);

    // The maximum height the birbs should try to reach is one birb below the top of the window.
    let max_bounce_height = (window_size.y - SPRITE_SIZE * 2.0).max(0.0);
    let min_bounce_height = max_bounce_height * 0.4;

    for (mut velocity, mut transform) in &mut query {
        // Clamp the translation to not go out of the bounds
        if transform.translation.y < collision_area.min.y {
            transform.translation.y = collision_area.min.y;

            // How high this birb will bounce.
            let bounce_height = rng.random_range(min_bounce_height..=max_bounce_height);

            // Apply the velocity that would bounce the birb up to bounce_height.
            velocity.translation.y = (bounce_height * GRAVITY * 2.).sqrt();
        }

        // Birbs might hit the ceiling if the window is resized.
        // If they do, bounce them.
        if transform.translation.y > collision_area.max.y {
            transform.translation.y = collision_area.max.y;
            velocity.translation.y *= -1.0;
        }

        // On side walls flip the horizontal velocity
        if transform.translation.x < collision_area.min.x {
            transform.translation.x = collision_area.min.x;
            velocity.translation.x *= -1.0;
            velocity.rotation *= -1.0;
        }
        if transform.translation.x > collision_area.max.x {
            transform.translation.x = collision_area.max.x;
            velocity.translation.x *= -1.0;
            velocity.rotation *= -1.0;
        }
    }
}

pub fn physical_width(&self) -> u32

The window’s client area width in physical pixels.

See WindowResolution for an explanation about logical/physical sizes.

Examples found in repository

examples/3d/mirror.rs (line 241)

fn create_mirror_texture_resource(
    commands: &mut Commands,
    windows_query: &Query<&Window>,
    images: &mut Assets<Image>,
) -> Handle<Image> {
    let window = windows_query.iter().next().expect("No window found");
    let window_size = uvec2(window.physical_width(), window.physical_height());
    let image = create_mirror_texture_image(images, window_size);
    commands.insert_resource(MirrorImage(image.clone()));
    image
}

/// Spawns the camera that renders the mirror world.
fn spawn_mirror_camera(
    commands: &mut Commands,
    camera_transform: &Transform,
    camera_projection: &PerspectiveProjection,
    mirror_transform: &Transform,
    mirror_render_target: Handle<Image>,
) {
    let (mirror_camera_transform, mirror_camera_projection) =
        calculate_mirror_camera_transform_and_projection(
            camera_transform,
            camera_projection,
            mirror_transform,
        );

    commands.spawn((
        Camera3d::default(),
        Camera {
            order: -1,
            // Reflecting the model across the mirror will flip the winding of
            // all the polygons. Therefore, in order to properly backface cull,
            // we need to turn on `invert_culling`.
            invert_culling: true,
            ..default()
        },
        RenderTarget::Image(mirror_render_target.clone().into()),
        mirror_camera_transform,
        Projection::Perspective(mirror_camera_projection),
        MirrorCamera,
    ));
}

/// Spawns the animated fox.
///
/// Note that this doesn't play the animation; that's handled in
/// [`play_fox_animation`].
fn spawn_fox(commands: &mut Commands, asset_server: &AssetServer) {
    commands.spawn((
        WorldAssetRoot(asset_server.load(GltfAssetLabel::Scene(0).from_asset(FOX_ASSET_PATH))),
        Transform::from_xyz(-50.0, 0.0, -100.0),
    ));
}

/// Spawns the mirror plane mesh and returns its transform.
fn spawn_mirror(
    commands: &mut Commands,
    meshes: &mut Assets<Mesh>,
    screen_space_texture_materials: &mut Assets<
        ExtendedMaterial<StandardMaterial, ScreenSpaceTextureExtension>,
    >,
    mirror_render_target: Handle<Image>,
) -> Transform {
    let mirror_transform = Transform::from_scale(vec3(300.0, 1.0, 150.0))
        .with_rotation(Quat::from_rotation_x(MIRROR_ROTATION_ANGLE))
        .with_translation(MIRROR_POSITION);

    commands.spawn((
        Mesh3d(meshes.add(Plane3d::default().mesh().size(1.0, 1.0))),
        MeshMaterial3d(screen_space_texture_materials.add(ExtendedMaterial {
            base: StandardMaterial {
                base_color: Color::BLACK,
                emissive: Color::WHITE.into(),
                emissive_texture: Some(mirror_render_target),
                perceptual_roughness: 0.0,
                metallic: 1.0,
                ..default()
            },
            extension: ScreenSpaceTextureExtension { dummy: 0.0 },
        })),
        mirror_transform,
        Mirror,
    ));

    mirror_transform
}

/// Spawns the buttons at the bottom of the screen.
fn spawn_buttons(commands: &mut Commands) {
    // Spawn the radio buttons that allow the user to select an object to
    // control.
    commands.spawn((
        widgets::main_ui_node(),
        children![widgets::option_buttons(
            "Drag Action",
            &[
                (DragAction::MoveCamera, "Move Camera"),
                (DragAction::MoveFox, "Move Fox"),
            ],
        )],
    ));
}

/// Given the transform and projection of the main camera, returns an
/// appropriate transform and projection for the mirror camera.
fn calculate_mirror_camera_transform_and_projection(
    main_camera_transform: &Transform,
    main_camera_projection: &PerspectiveProjection,
    mirror_transform: &Transform,
) -> (Transform, PerspectiveProjection) {
    // Calculate the reflection matrix (a.k.a. Householder matrix) that will
    // reflect the scene across the mirror plane.
    //
    // Note that you must calculate this in *matrix* form and only *afterward*
    // convert to a `Transform` instead of composing `Transform`s. This is
    // because the reflection matrix has non-uniform scale, and composing
    // transforms can't always handle composition of matrices with non-uniform
    // scales.
    let mirror_camera_transform = Transform::from_matrix(
        Mat4::from_mat3a(reflection_matrix(Vec3::NEG_Z)) * main_camera_transform.to_matrix(),
    );

    // Compute the distance from the camera to the mirror plane. This will be
    // used to calculate the distance to the near clip plane for the mirror
    // world.
    let distance_from_camera_to_mirror = InfinitePlane3d::new(mirror_transform.rotation * Vec3::Y)
        .signed_distance(
            Isometry3d::IDENTITY,
            mirror_transform.translation - main_camera_transform.translation,
        );

    // Compute the normal of the mirror plane in view space.
    let view_from_world = main_camera_transform.compute_affine().matrix3.inverse();
    let mirror_projection_plane_normal =
        (view_from_world * (mirror_transform.rotation * Vec3::NEG_Y)).normalize();

    // Compute the final projection. It should match the main camera projection,
    // except that `near` and `near_normal` should be set to the updated near
    // plane and near normal plane as above.
    let mirror_camera_projection = PerspectiveProjection {
        near_clip_plane: mirror_projection_plane_normal.extend(distance_from_camera_to_mirror),
        ..*main_camera_projection
    };

    (mirror_camera_transform, mirror_camera_projection)
}

/// A system that resizes the render target image when the user resizes the window.
///
/// Since the image that stores the rendered mirror world has the same physical
/// size as the window, we need to reallocate it and reattach it to the mirror
/// material whenever the window size changes.
fn handle_window_resize_messages(
    windows_query: Query<&Window>,
    mut mirror_cameras_query: Query<&mut RenderTarget, With<MirrorCamera>>,
    mut images: ResMut<Assets<Image>>,
    mut mirror_image: ResMut<MirrorImage>,
    mut screen_space_texture_materials: ResMut<
        Assets<ExtendedMaterial<StandardMaterial, ScreenSpaceTextureExtension>>,
    >,
    mut resize_messages: MessageReader<WindowResized>,
) {
    // We run at most once, regardless of the number of window resize messages
    // there were this frame.
    let Some(resize_message) = resize_messages.read().next() else {
        return;
    };
    let Ok(window) = windows_query.get(resize_message.window) else {
        return;
    };

    let window_size = uvec2(window.physical_width(), window.physical_height());
    let image = create_mirror_texture_image(&mut images, window_size);
    images.remove(mirror_image.0.id());

    mirror_image.0 = image.clone();

    for mut target in mirror_cameras_query.iter_mut() {
        *target = image.clone().into();
    }

    for (_, material) in screen_space_texture_materials.iter_mut() {
        material.base.emissive_texture = Some(image.clone());
    }
}

pub fn physical_height(&self) -> u32

The window’s client area height in physical pixels.

See WindowResolution for an explanation about logical/physical sizes.

Examples found in repository

examples/3d/mirror.rs (line 241)

fn create_mirror_texture_resource(
    commands: &mut Commands,
    windows_query: &Query<&Window>,
    images: &mut Assets<Image>,
) -> Handle<Image> {
    let window = windows_query.iter().next().expect("No window found");
    let window_size = uvec2(window.physical_width(), window.physical_height());
    let image = create_mirror_texture_image(images, window_size);
    commands.insert_resource(MirrorImage(image.clone()));
    image
}

/// Spawns the camera that renders the mirror world.
fn spawn_mirror_camera(
    commands: &mut Commands,
    camera_transform: &Transform,
    camera_projection: &PerspectiveProjection,
    mirror_transform: &Transform,
    mirror_render_target: Handle<Image>,
) {
    let (mirror_camera_transform, mirror_camera_projection) =
        calculate_mirror_camera_transform_and_projection(
            camera_transform,
            camera_projection,
            mirror_transform,
        );

    commands.spawn((
        Camera3d::default(),
        Camera {
            order: -1,
            // Reflecting the model across the mirror will flip the winding of
            // all the polygons. Therefore, in order to properly backface cull,
            // we need to turn on `invert_culling`.
            invert_culling: true,
            ..default()
        },
        RenderTarget::Image(mirror_render_target.clone().into()),
        mirror_camera_transform,
        Projection::Perspective(mirror_camera_projection),
        MirrorCamera,
    ));
}

/// Spawns the animated fox.
///
/// Note that this doesn't play the animation; that's handled in
/// [`play_fox_animation`].
fn spawn_fox(commands: &mut Commands, asset_server: &AssetServer) {
    commands.spawn((
        WorldAssetRoot(asset_server.load(GltfAssetLabel::Scene(0).from_asset(FOX_ASSET_PATH))),
        Transform::from_xyz(-50.0, 0.0, -100.0),
    ));
}

/// Spawns the mirror plane mesh and returns its transform.
fn spawn_mirror(
    commands: &mut Commands,
    meshes: &mut Assets<Mesh>,
    screen_space_texture_materials: &mut Assets<
        ExtendedMaterial<StandardMaterial, ScreenSpaceTextureExtension>,
    >,
    mirror_render_target: Handle<Image>,
) -> Transform {
    let mirror_transform = Transform::from_scale(vec3(300.0, 1.0, 150.0))
        .with_rotation(Quat::from_rotation_x(MIRROR_ROTATION_ANGLE))
        .with_translation(MIRROR_POSITION);

    commands.spawn((
        Mesh3d(meshes.add(Plane3d::default().mesh().size(1.0, 1.0))),
        MeshMaterial3d(screen_space_texture_materials.add(ExtendedMaterial {
            base: StandardMaterial {
                base_color: Color::BLACK,
                emissive: Color::WHITE.into(),
                emissive_texture: Some(mirror_render_target),
                perceptual_roughness: 0.0,
                metallic: 1.0,
                ..default()
            },
            extension: ScreenSpaceTextureExtension { dummy: 0.0 },
        })),
        mirror_transform,
        Mirror,
    ));

    mirror_transform
}

/// Spawns the buttons at the bottom of the screen.
fn spawn_buttons(commands: &mut Commands) {
    // Spawn the radio buttons that allow the user to select an object to
    // control.
    commands.spawn((
        widgets::main_ui_node(),
        children![widgets::option_buttons(
            "Drag Action",
            &[
                (DragAction::MoveCamera, "Move Camera"),
                (DragAction::MoveFox, "Move Fox"),
            ],
        )],
    ));
}

/// Given the transform and projection of the main camera, returns an
/// appropriate transform and projection for the mirror camera.
fn calculate_mirror_camera_transform_and_projection(
    main_camera_transform: &Transform,
    main_camera_projection: &PerspectiveProjection,
    mirror_transform: &Transform,
) -> (Transform, PerspectiveProjection) {
    // Calculate the reflection matrix (a.k.a. Householder matrix) that will
    // reflect the scene across the mirror plane.
    //
    // Note that you must calculate this in *matrix* form and only *afterward*
    // convert to a `Transform` instead of composing `Transform`s. This is
    // because the reflection matrix has non-uniform scale, and composing
    // transforms can't always handle composition of matrices with non-uniform
    // scales.
    let mirror_camera_transform = Transform::from_matrix(
        Mat4::from_mat3a(reflection_matrix(Vec3::NEG_Z)) * main_camera_transform.to_matrix(),
    );

    // Compute the distance from the camera to the mirror plane. This will be
    // used to calculate the distance to the near clip plane for the mirror
    // world.
    let distance_from_camera_to_mirror = InfinitePlane3d::new(mirror_transform.rotation * Vec3::Y)
        .signed_distance(
            Isometry3d::IDENTITY,
            mirror_transform.translation - main_camera_transform.translation,
        );

    // Compute the normal of the mirror plane in view space.
    let view_from_world = main_camera_transform.compute_affine().matrix3.inverse();
    let mirror_projection_plane_normal =
        (view_from_world * (mirror_transform.rotation * Vec3::NEG_Y)).normalize();

    // Compute the final projection. It should match the main camera projection,
    // except that `near` and `near_normal` should be set to the updated near
    // plane and near normal plane as above.
    let mirror_camera_projection = PerspectiveProjection {
        near_clip_plane: mirror_projection_plane_normal.extend(distance_from_camera_to_mirror),
        ..*main_camera_projection
    };

    (mirror_camera_transform, mirror_camera_projection)
}

/// A system that resizes the render target image when the user resizes the window.
///
/// Since the image that stores the rendered mirror world has the same physical
/// size as the window, we need to reallocate it and reattach it to the mirror
/// material whenever the window size changes.
fn handle_window_resize_messages(
    windows_query: Query<&Window>,
    mut mirror_cameras_query: Query<&mut RenderTarget, With<MirrorCamera>>,
    mut images: ResMut<Assets<Image>>,
    mut mirror_image: ResMut<MirrorImage>,
    mut screen_space_texture_materials: ResMut<
        Assets<ExtendedMaterial<StandardMaterial, ScreenSpaceTextureExtension>>,
    >,
    mut resize_messages: MessageReader<WindowResized>,
) {
    // We run at most once, regardless of the number of window resize messages
    // there were this frame.
    let Some(resize_message) = resize_messages.read().next() else {
        return;
    };
    let Ok(window) = windows_query.get(resize_message.window) else {
        return;
    };

    let window_size = uvec2(window.physical_width(), window.physical_height());
    let image = create_mirror_texture_image(&mut images, window_size);
    images.remove(mirror_image.0.id());

    mirror_image.0 = image.clone();

    for mut target in mirror_cameras_query.iter_mut() {
        *target = image.clone().into();
    }

    for (_, material) in screen_space_texture_materials.iter_mut() {
        material.base.emissive_texture = Some(image.clone());
    }
}

pub fn physical_size(&self) -> UVec2

The window’s client size in physical pixels

See WindowResolution for an explanation about logical/physical sizes.

Examples found in repository

examples/3d/split_screen.rs (line 169)

fn set_camera_viewports(
    windows: Query<&Window>,
    mut window_resized_reader: MessageReader<WindowResized>,
    mut query: Query<(&CameraPosition, &mut Camera)>,
) {
    // We need to dynamically resize the camera's viewports whenever the window size changes
    // so then each camera always takes up half the screen.
    // A resize_event is sent when the window is first created, allowing us to reuse this system for initial setup.
    for window_resized in window_resized_reader.read() {
        let window = windows.get(window_resized.window).unwrap();
        let size = window.physical_size() / 2;

        for (camera_position, mut camera) in &mut query {
            camera.viewport = Some(Viewport {
                physical_position: camera_position.pos * size,
                physical_size: size,
                ..default()
            });
        }
    }
}

examples/3d/camera_sub_view.rs (line 259)

fn resize_viewports(
    window: Single<&Window, With<bevy::window::PrimaryWindow>>,
    mut viewports: Query<(&mut Camera, &ExampleViewports)>,
) {
    let window_size = window.physical_size();

    let small_height = window_size.y / 5;
    let small_width = window_size.x / 8;

    let large_height = small_height * 4;
    let large_width = small_width * 4;

    let large_size = UVec2::new(large_width, large_height);

    // Enforce the aspect ratio of the small viewports to ensure the images
    // appear unstretched
    let small_dim = small_height.min(small_width);
    let small_size = UVec2::new(small_dim, small_dim);

    let small_wide_size = UVec2::new(small_dim * 2, small_dim);

    for (mut camera, example_viewport) in viewports.iter_mut() {
        if camera.viewport.is_none() {
            camera.viewport = Some(Viewport::default());
        };

        let Some(viewport) = &mut camera.viewport else {
            continue;
        };

        let (size, position) = match example_viewport {
            ExampleViewports::PerspectiveMain => (large_size, UVec2::new(0, small_height)),
            ExampleViewports::PerspectiveStretched => (small_size, UVec2::ZERO),
            ExampleViewports::PerspectiveMoving => (small_size, UVec2::new(small_width, 0)),
            ExampleViewports::PerspectiveControl => {
                (small_wide_size, UVec2::new(small_width * 2, 0))
            }
            ExampleViewports::OrthographicMain => {
                (large_size, UVec2::new(large_width, small_height))
            }
            ExampleViewports::OrthographicStretched => (small_size, UVec2::new(small_width * 4, 0)),
            ExampleViewports::OrthographicMoving => (small_size, UVec2::new(small_width * 5, 0)),
            ExampleViewports::OrthographicControl => {
                (small_wide_size, UVec2::new(small_width * 6, 0))
            }
        };

        viewport.physical_size = size;
        viewport.physical_position = position;
    }
}

examples/testbed/3d.rs (line 786)

    pub fn setup(
        mut commands: Commands,
        mut meshes: ResMut<Assets<Mesh>>,
        mut materials: ResMut<Assets<StandardMaterial>>,
        window: Single<&Window, With<PrimaryWindow>>,
    ) {
        // circular base
        commands.spawn((
            Mesh3d(meshes.add(Circle::new(4.0))),
            MeshMaterial3d(materials.add(Color::WHITE)),
            Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
            RenderLayers::layer(0).with(1).with(2),
            DespawnOnExit(CURRENT_SCENE),
        ));

        // cubes
        commands.spawn((
            Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
            MeshMaterial3d(materials.add(Color::srgb(1.0, 0.0, 0.0))),
            Transform::from_xyz(-1.5, 0.5, 0.0),
            // No render layer for this one to test the default case
            DespawnOnExit(CURRENT_SCENE),
        ));
        commands.spawn((
            Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
            MeshMaterial3d(materials.add(Color::srgb(0.0, 1.0, 0.0))),
            Transform::from_xyz(0.0, 0.5, 0.0),
            RenderLayers::layer(1),
            DespawnOnExit(CURRENT_SCENE),
        ));
        commands.spawn((
            Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
            MeshMaterial3d(materials.add(Color::srgb(0.0, 0.0, 1.0))),
            Transform::from_xyz(1.5, 0.5, 0.0),
            RenderLayers::layer(2),
            DespawnOnExit(CURRENT_SCENE),
        ));

        // Light
        commands.spawn((
            PointLight {
                shadow_maps_enabled: true,
                ..default()
            },
            Transform::from_xyz(4.0, 8.0, 4.0),
            DespawnOnExit(CURRENT_SCENE),
        ));

        let window_half_size = window.physical_size() / 2;

        // Split the screen in 4 different viewports with each of them having a specific render
        // layer
        for index in 0..4 {
            let viewport_pos = UVec2::new((index % 2) as u32, (index / 2) as u32);
            let mut entity_cmds = commands.spawn((
                Camera3d::default(),
                Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
                Camera {
                    // Renders cameras with different priorities to prevent ambiguities
                    order: index as isize,
                    viewport: Some(Viewport {
                        physical_position: viewport_pos * window_half_size,
                        physical_size: window_half_size,
                        ..default()
                    }),
                    ..default()
                },
                DespawnOnExit(CURRENT_SCENE),
            ));
            match index {
                0 => {}
                1 => {
                    entity_cmds.insert(RenderLayers::layer(1));
                }
                2 => {
                    entity_cmds.insert(RenderLayers::layer(2));
                }
                3 => {
                    entity_cmds.insert(RenderLayers::layer(0).with(1).with(2));
                }
                _ => warn!("Unexpected index {index}"),
            }
        }
    }

examples/usage/debug_frustum_culling.rs (line 129)

fn setup(
    mut commands: Commands,
    windows: Query<&Window>,
    mut config_store: ResMut<GizmoConfigStore>,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) -> Result {
    let window = windows.single()?;
    // The camera that the user controls to observe the scene.
    let free_camera = commands
        .spawn((
            Camera3d::default(),
            FREE_CAMERA_START_TRANSFORM.looking_at(FREE_CAMERA_START_TARGET, Vec3::Y),
            FreeCamera::default(),
        ))
        .id();

    // The camera that we want to debug frustum culling for. This will be rendered
    // as a picture-in-picture in the lower right ninth of the screen.
    let my_camera = commands
        .spawn((
            Camera3d::default(),
            Transform::from_xyz(0., 1.5, 0.).looking_at(Vec3::new(1.0, 1.5, 0.), Vec3::Y),
            Camera {
                order: 1,
                // The camera-to-debug's view will be in the lower right ninth of the screen.
                viewport: Some(Viewport {
                    physical_position: window.physical_size() * 2 / 3,
                    physical_size: window.physical_size() / 3,
                    ..default()
                }),
                // Do not write the free camera's view rendering back into the P-I-P
                msaa_writeback: MsaaWriteback::Off,
                ..default()
            },
            MyCamera,
        ))
        .id();

    // Instructions placed on top of the free_camera view
    commands.spawn((
        UiTargetCamera(free_camera),
        Node {
            width: percent(100),
            height: percent(100),
            ..default()
        },
        children![(
            Text::new(
                "This example utilizes free camera controls i.e. move with WASD and mouse grab to change orientation.\n\
                Press '1' to move the free camera to where MyCamera is, matching its view frustum.\n\
                Press '2' to move the free camera to its initial position in the example.",
            ),
            Node {
                position_type: PositionType::Absolute,
                top: px(12),
                left: px(12),
                ..default()
            },
        )]
    ));
    // Label for the picture-in-picture view of MyCamera
    commands.spawn((
        UiTargetCamera(my_camera),
        Node {
            width: percent(100),
            height: percent(100),
            ..default()
        },
        children![(
            Text::new("View of MyCamera"),
            Node {
                position_type: PositionType::Absolute,
                bottom: px(12),
                right: px(100),
                ..default()
            },
        )],
    ));

    // Green Floor Plane
    commands.spawn((
        Mesh3d(
            meshes.add(
                Plane3d::default()
                    .mesh()
                    .size(SHAPE_RING_RADIUS * 4., SHAPE_RING_RADIUS * 4.),
            ),
        ),
        MeshMaterial3d(materials.add(Color::srgb(0.3, 0.5, 0.3))),
    ));
    // Blue Wall Plane
    commands.spawn((
        Mesh3d(meshes.add(Plane3d::default().mesh().size(5., 5.))),
        MeshMaterial3d(materials.add(Color::srgb(0.3, 0.3, 0.5))),
        Transform::from_xyz(20., 2.5, 10.).with_rotation(Quat::from_rotation_z(PI / 2.)),
    ));
    // Light
    commands.spawn((
        PointLight {
            shadow_maps_enabled: true,
            ..default()
        },
        Transform::from_xyz(0.0, 10.0, 0.0),
    ));

    // Configure all AABB's to have a default color of red
    let (_, aabb_gizmo_config) = config_store.config_mut::<AabbGizmoConfigGroup>();
    aabb_gizmo_config.default_color = Some(Color::LinearRgba(LinearRgba::RED));

    // Configure the shapes on the ring that will have their AABB's drawn and updated
    let white_matl = materials.add(Color::WHITE);
    let shapes = [
        meshes.add(Cuboid {
            half_size: Vec3::new(2., 0.5, 1.),
        }),
        meshes.add(Tetrahedron {
            vertices: [
                Vec3::new(3., 4., 3.),
                Vec3::new(-0.5, 4., -0.5),
                Vec3::new(-0.5, -0.5, 3.),
                Vec3::new(3., -0.5, -0.5),
            ],
        }),
        meshes.add(Cylinder {
            radius: 0.1,
            half_height: 1.5,
        }),
        meshes.add(Cuboid {
            half_size: Vec3::new(1., 0.1, 2.),
        }),
        meshes.add(Sphere::default().mesh().ico(5).unwrap()),
    ];
    let shapes_len = shapes.len() as f32;
    let mut shape_ring = commands.spawn((Transform::default(), Visibility::default(), ShapeRing));
    for (i, shape) in shapes.into_iter().enumerate() {
        // Space the shapes out evenly along the ring
        let shape_angle = i as f32 * 2. * PI / shapes_len;
        let (s, c) = ops::sin_cos(shape_angle);
        let (x, z) = (SHAPE_RING_RADIUS * c, SHAPE_RING_RADIUS * s);
        shape_ring.with_child((
            Mesh3d(shape),
            MeshMaterial3d(white_matl.clone()),
            Transform::from_xyz(x, 1.5, z).with_rotation(Quat::from_rotation_x(-PI / 4.)),
            MyShape,
        ));
    }

    // Configure the shape that peeks out of the wall plane
    let wall_shape = meshes.add(Torus::default());
    commands.spawn((
        Mesh3d(wall_shape),
        MeshMaterial3d(white_matl.clone()),
        Transform::from_xyz(25., 1.5, 12.5).with_rotation(Quat::from_rotation_x(-PI / 4.)),
        WallShape,
    ));

    Ok(())
}

pub fn scale_factor(&self) -> f32

The window’s scale factor.

Ratio of physical size to logical size, see WindowResolution.

Examples found in repository

examples/window/scale_factor_override.rs (line 68)

fn display_override(
    mut window: Single<&mut Window>,
    mut custom_text: Single<&mut Text, With<CustomText>>,
) {
    let text = format!(
        "Scale factor: {:.1} {}",
        window.scale_factor(),
        if window.resolution.scale_factor_override().is_some() {
            "(overridden)"
        } else {
            "(default)"
        }
    );

    window.title.clone_from(&text);
    custom_text.0 = text;
}

pub fn cursor_position(&self) -> Option<Vec2>

The cursor position in this window in logical pixels.

Returns None if the cursor is outside the window area.

See WindowResolution for an explanation about logical/physical sizes.

Examples found in repository

examples/showcase/desk_toy.rs (line 212)

fn get_cursor_world_pos(
    mut cursor_world_pos: ResMut<CursorWorldPos>,
    primary_window: Single<&Window, With<PrimaryWindow>>,
    q_camera: Single<(&Camera, &GlobalTransform)>,
) {
    let (main_camera, main_camera_transform) = *q_camera;
    // Get the cursor position in the world
    cursor_world_pos.0 = primary_window.cursor_position().and_then(|cursor_pos| {
        main_camera
            .viewport_to_world_2d(main_camera_transform, cursor_pos)
            .ok()
    });
}

examples/ecs/observers.rs (line 202)

fn handle_click(
    mouse_button_input: Res<ButtonInput<MouseButton>>,
    camera: Single<(&Camera, &GlobalTransform)>,
    windows: Query<&Window>,
    mut commands: Commands,
) {
    let Ok(windows) = windows.single() else {
        return;
    };

    let (camera, camera_transform) = *camera;
    if let Some(pos) = windows
        .cursor_position()
        .and_then(|cursor| camera.viewport_to_world(camera_transform, cursor).ok())
        .map(|ray| ray.origin.truncate())
        && mouse_button_input.just_pressed(MouseButton::Left)
    {
        commands.trigger(ExplodeMines { pos, radius: 1.0 });
    }
}

examples/2d/2d_viewport_to_world.rs (line 29)

fn draw_cursor(
    camera_query: Single<(&Camera, &GlobalTransform)>,
    window: Single<&Window>,
    mut gizmos: Gizmos,
) {
    let (camera, camera_transform) = *camera_query;

    if let Some(cursor_position) = window.cursor_position()
        // Calculate a world position based on the cursor's position.
        && let Ok(world_pos) = camera.viewport_to_world_2d(camera_transform, cursor_position)
        // To test Camera::world_to_viewport, convert result back to viewport space and then back to world space.
        && let Ok(viewport_check) = camera.world_to_viewport(camera_transform, world_pos.extend(0.0))
        && let Ok(world_check) = camera.viewport_to_world_2d(camera_transform, viewport_check.xy())
    {
        gizmos.circle_2d(world_pos, 10., WHITE);
        // Should be the same as world_pos
        gizmos.circle_2d(world_check, 8., RED);
    }
}

examples/2d/rotate_to_cursor.rs (line 45)

fn player_movement_system(
    mut player: Single<&mut Transform, With<Player>>,
    camera_query: Single<(&Camera, &GlobalTransform)>,
    window: Single<&Window>,
) {
    let (camera, camera_transform) = *camera_query;

    if let Some(cursor_position) = window.cursor_position()
        // Calculate a world position based on the cursor's position.
        && let Ok(cursor_world_pos) = camera.viewport_to_world_2d(camera_transform, cursor_position)
    {
        // The angle an entity needs to rotate to face a point is defined
        // by the vector between the two points (Vec2 - Vec2), which we can then
        // turn into radians using to_angle.
        //
        // FRAC_PI_2 is because our sprite's ship is facing "up" so we rotate it an additional 90 degrees
        // so that it faces the cursor.
        player.rotation = Quat::from_rotation_z(
            (cursor_world_pos - player.translation.xy()).to_angle() - FRAC_PI_2,
        );
    }
}

examples/3d/3d_viewport_to_world.rs (line 21)

fn draw_cursor(
    camera_query: Single<(&Camera, &GlobalTransform)>,
    ground: Single<&GlobalTransform, With<Ground>>,
    window: Single<&Window>,
    mut gizmos: Gizmos,
) {
    let (camera, camera_transform) = *camera_query;

    if let Some(cursor_position) = window.cursor_position()
        // Calculate a ray pointing from the camera into the world based on the cursor's position.
        && let Ok(ray) = camera.viewport_to_world(camera_transform, cursor_position)
        // Calculate if and where the ray is hitting the ground plane.
        && let Some(point) = ray.plane_intersection_point(ground.translation(), InfinitePlane3d::new(ground.up()))
    {
        // Draw a circle just above the ground plane at that position.
        gizmos.circle(
            Isometry3d::new(
                point + ground.up() * 0.01,
                Quat::from_rotation_arc(Vec3::Z, ground.up().as_vec3()),
            ),
            0.2,
            Color::WHITE,
        );
    }
}

pub fn physical_cursor_position(&self) -> Option<Vec2>

The cursor position in this window in physical pixels.

Returns None if the cursor is outside the window area.

See WindowResolution for an explanation about logical/physical sizes.

pub fn set_cursor_position(&mut self, position: Option<Vec2>)

Set the cursor position in this window in logical pixels.

See WindowResolution for an explanation about logical/physical sizes.

pub fn set_physical_cursor_position(&mut self, position: Option<DVec2>)

Set the cursor position in this window in physical pixels.

See WindowResolution for an explanation about logical/physical sizes.

Trait Implementations

impl Clone for Window

fn clone(&self) -> Window

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Component for Window

where Window: Send + Sync + 'static,

Required Components: CursorOptions.

A component’s Required Components are inserted whenever it is inserted. Note that this will also insert the required components of the required components, recursively, in depth-first order.

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have Component<Mutability = Mutable>, while immutable components will instead have Component<Mutability = Immutable>.

fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn relationship_accessor() -> Option<ComponentRelationshipAccessor<Window>>

Returns ComponentRelationshipAccessor required for working with relationships in dynamic contexts.

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add ComponentHook for this Component if one is defined.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert ComponentHook for this Component if one is defined.

fn on_discard() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_discard ComponentHook for this Component if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove ComponentHook for this Component if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn ComponentHook for this Component if one is defined.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given EntityMapper. This is used to remap entities in contexts like scenes and entity cloning. When deriving Component, this is populated by annotating fields containing entities with #[entities]

impl Debug for Window

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Window

fn default() -> Window

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Window

fn deserialize<__D>( __deserializer: __D, ) -> Result<Window, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromArg for Window

type This<'from_arg> = Window

The type to convert into.

fn from_arg(arg: Arg<'_>) -> Result<<Window as FromArg>::This<'_>, ArgError>

Creates an item from an argument.

impl FromReflect for Window

fn from_reflect(reflect: &(dyn PartialReflect + 'static)) -> Option<Window>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetOwnership for Window

fn ownership() -> Ownership

Returns the ownership of Self.

impl GetTypeRegistration for Window

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl IntoReturn for Window

fn into_return<'into_return>(self) -> Return<'into_return>

where Window: 'into_return,

Converts Self into a Return value.

impl PartialReflect for Window

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Window>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<Window>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<Window>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value.

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

Returns a “partial equality” comparison result.

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

Returns a “partial comparison” result.

fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Debug formatter for the value.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind.

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>

where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for Window

fn into_any(self: Box<Window>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Window>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl Serialize for Window

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Struct for Window

fn field(&self, name: &str) -> Option<&(dyn PartialReflect + 'static)>

Gets a reference to the value of the field named name as a &dyn PartialReflect.

fn field_mut( &mut self, name: &str, ) -> Option<&mut (dyn PartialReflect + 'static)>

Gets a mutable reference to the value of the field named name as a &mut dyn PartialReflect.

fn field_at(&self, index: usize) -> Option<&(dyn PartialReflect + 'static)>

Gets a reference to the value of the field with index index as a &dyn PartialReflect.

fn field_at_mut( &mut self, index: usize, ) -> Option<&mut (dyn PartialReflect + 'static)>

Gets a mutable reference to the value of the field with index index as a &mut dyn PartialReflect.

fn name_at(&self, index: usize) -> Option<&str>

Gets the name of the field with index index.

fn index_of_name(&self, name: &str) -> Option<usize>

Gets the index of the field with the given name.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn to_dynamic_struct(&self) -> DynamicStruct

Creates a new DynamicStruct from this struct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl TypePath for Window

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for Window

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.