Can one use bevy to return an image as a Vec<u8> representing a PNG?

[DavidBJaffe]

Can one use bevy to generate a PNG as a Vec, rather than display an image? For example, could one do this with https://bevy.org/examples/3d-rendering/3d-scene, or is there a different example somewhere of this use case?

I see this https://docs.rs/bevy/latest/src/screenshot/screenshot.rs.html, but am looking for something one can run from the command line without interaction.

After many attempts, I got Claude to create this code:

use bevy::prelude::*;
use bevy::app::AppExit;
use bevy::window::{WindowResolution, WindowPosition};
use bevy::render::view::window::screenshot::Screenshot;
use bevy::log::LogPlugin;
use image::{ImageBuffer, Rgba, ImageFormat};

#[derive(Resource, Default)]
struct RenderState {
    frame_count: u32,
    screenshot_taken: bool,
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins
            .set(WindowPlugin {
                primary_window: Some(Window {
                    resolution: WindowResolution::new(800.0, 600.0),
                    visible: false,
                    position: WindowPosition::At(IVec2::new(-2000, -2000)),
                    decorations: false,
                    resizable: false,
                    focused: false,
                    ..default()
                }),
                ..default()
            })
            .disable::<LogPlugin>()
        )
        .insert_resource(RenderState::default())
        .add_systems(Startup, setup_scene)
        .add_systems(Update, take_screenshot)
        .run();
}

fn setup_scene(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    commands.spawn((
        Mesh3d(meshes.add(Sphere::new(1.0).mesh().uv(32, 18))),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: Color::srgb(0.3, 0.5, 0.8),
            metallic: 0.1,
            perceptual_roughness: 0.3,
            ..default()
        })),
        Transform::from_xyz(0.0, 0.0, 0.0),
    ));
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(0.0, 0.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
    ));
    commands.spawn((
        PointLight {
            intensity: 1000000.0,
            shadows_enabled: true,
            ..default()
        },
        Transform::from_xyz(4.0, 8.0, 4.0),
    ));
    commands.insert_resource(AmbientLight {
        color: Color::WHITE,
        brightness: 1000.0,
        affects_lightmapped_meshes: false,
    });
}

fn take_screenshot(
    mut state: ResMut<RenderState>,
    mut commands: Commands,
    mut exit: EventWriter<AppExit>,
) {
    state.frame_count += 1;
    if state.frame_count == 30 && !state.screenshot_taken {
        commands.spawn(Screenshot::primary_window()).observe(save_screenshot);
        state.screenshot_taken = true;
    }
    if state.screenshot_taken && state.frame_count > 60 {
        exit.write(AppExit::Success);
    }
}

fn save_screenshot(
    trigger: Trigger<bevy::render::view::window::screenshot::ScreenshotCaptured>,
) {
    let image = trigger.event();
    let width = image.texture_descriptor.size.width;
    let height = image.texture_descriptor.size.height;
    if let Some(ref data) = image.data {
        let mut rgba_data = data.clone(); // convert BGRA to RGBA if needed
        if matches!(image.texture_descriptor.format, 
            bevy::render::render_resource::TextureFormat::Bgra8UnormSrgb | 
            bevy::render::render_resource::TextureFormat::Bgra8Unorm) {
            for chunk in rgba_data.chunks_exact_mut(4) {
                chunk.swap(0, 2);
            }
        }
        if let Some(img_buffer) = ImageBuffer::<Rgba<u8>, _>::from_raw(width, height, rgba_data) {
            let mut png_bytes = Vec::new();
            if img_buffer.write_to(&mut std::io::Cursor::new(&mut png_bytes), ImageFormat::Png).is_ok() {
                // (do something with png_bytes)
            }
        }
    }
}

But possibly there is a better way to do this. If you know, please tell me!