Changing the output resolution without changing the window size

[DrupalDoesNotExists]

I'm trying to implement a video resolution option for my game and I'm stuck on changing the actual resolution.

For tests I set up a new blank project (Cargo.toml is default + bevy 0.13.2 as a dependency):

use bevy::core::FrameCount;
use bevy::prelude::*;
use bevy::window::{WindowMode, WindowResolution};

fn main() {
    App::new()
        .add_plugins(DefaultPlugins.set(WindowPlugin {
            primary_window: Some(Window {
                mode: WindowMode::BorderlessFullscreen,
                visible: false,
                ..default()
            }),
            ..default()
        }))
        .add_systems(Startup, setup)
        .add_systems(Update, make_visible)
        .run()
}

fn make_visible(mut window: Query<&mut Window>, frames: Res<FrameCount>) {
    if frames.0 == 3 {
        window.single_mut().visible = true;
    }
}

fn setup(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
) {
    let background_image: Handle<Image> = asset_server.load("textures/background.png");
    commands
        .spawn(Camera2dBundle::default());
    commands
        .spawn(SpriteBundle {
            texture: background_image,
            ..Default::default()
        });
}

It simply renders a background image (1920x1080, matches my monitor size).

There is a discussion #10738, but using suggested solution of

resolution: WindowResolution::new(3840.0, 2160.0).with_scale_factor_override(2.0)

does not seem to work properly. It just displays image twice as big.

AFAIK what I need is to change the logical size of the window without changing the physical size (correct me if i'm wrong). But is there any way to do it? WindowResolution::new requires a logical size, but using workaround like this

fn make_visible(mut window: Query<&mut Window>, frames: Res<FrameCount>) {
    if frames.0 == 3 {
        window.single_mut().visible = true;
        // Workaround below!! vvv
        let resolution = &mut window.single_mut().resolution;
        resolution.set_physical_resolution(3840, 2160);
        resolution.set_scale_factor_override(Some(2.0));
        // Workaround abow!! ^^^
    }
}

does not change the output.

Is there any proper way to implement it right now?

[bugsweeper]

I think the correct way to achieve this is configuring camera (there could be more than one camera in scene, each of them could have different resolution multipliers (for example portrait of main hero could have lower/higher resolution than main scene)). You are using Camera2dBundle::default(), I propose to change Camera2dBundle::projection, namely set OrthographicProjection::scaling_mode to ScalingMode::WindowSize(0.5), for example description of OrthographicProjection already has example for decreasing resolution:
Configure the orthographic projection to one world unit per 100 window pixels:

let projection = Projection::Orthographic(OrthographicProjection {
    scaling_mode: ScalingMode::WindowSize(100.0),
    ..OrthographicProjection::default()
});

In your case you should increase resolution instead.

[DrupalDoesNotExists]

Thanks, that worked just fine!

[bugsweeper]

Code:

fn main() {
    App::new()
        .add_plugins((DefaultPlugins.set(WindowPlugin {
            primary_window: Some(Window {
                mode: WindowMode::Fullscreen,
                ..default()
            }),
            ..default()
        }),))
        .add_systems(Startup, setup)
        .add_systems(Update, display_resolution_and_projection)
        .run();
}

fn setup(mut commands: Commands) {
    commands.spawn(Camera2dBundle {
        projection: OrthographicProjection {
            scaling_mode: ScalingMode::WindowSize(0.5),
            ..default()
        },
        ..default()
    });
}

fn display_resolution_and_projection(
    projection_query: Query<&OrthographicProjection>,
    window_query: Query<&Window, With<PrimaryWindow>>,
) {
    let resolution = &window_query.single().resolution;
    info_once!(
        "Window Physical Size: ({0}, {1})",
        resolution.physical_width(),
        resolution.physical_height()
    );
    info_once!(
        "Window Logical Size: ({0}, {1})",
        resolution.width(),
        resolution.height()
    );
    info_once!("Window Scale Factor: {}", resolution.scale_factor());

    let area = projection_query.single().area;
    info_once!("Projection area: {area:#?}");
}

Produced output:

2024-06-26T09:53:08.246486Z  INFO reso: Window Physical Size: (800, 600)
2024-06-26T09:53:08.246505Z  INFO reso: Window Logical Size: (800, 600)
2024-06-26T09:53:08.246512Z  INFO reso: Window Scale Factor: 1
2024-06-26T09:53:08.246518Z  INFO reso: Projection area: Rect {
    min: Vec2(
        -800.0,
        -600.0,
    ),
    max: Vec2(
        800.0,
        600.0,
    ),
}

You can play with WindowSize and see, that camera's output area reacts on it changing/setting

[bananaturtlesandwich]

is there a solution like this for Camera3d?

[bugsweeper]

If you agree to OrthographicProjection, then solution is same. If you want PerspectiveProjection, then you can try to change window resolution or render to a texture with defined resolution like this:

fn setup(
    mut commands: Commands,
    mut textures: ResMut<Assets<Image>>,
) {
    // Create texture
    let size = Extent3d {
        width: 3840,
        height: 2160,
        depth_or_array_layers: 1,
    };

    let texture = Image {
        texture_descriptor: TextureDescriptor {
            size,
            dimension: TextureDimension::D2,
            format: TextureFormat::Rgba8UnormSrgb,
            usage: TextureUsages::TEXTURE_BINDING
                | TextureUsages::COPY_DST
                | TextureUsages::RENDER_ATTACHMENT,
            ..Default::default()
        },
        ..Default::default()
    };

    let texture_handle = textures.add(texture);

    // spawn Camera, which renders to the texture
    commands.spawn(Camera3dBundle {
        camera: Camera {
            target: RenderTarget::Image(texture_handle.clone()),
            ..Default::default()
        },
        ..Default::default()
    });
}

And then use this texture for your needs...