作業メモ：bevy 0.12 → 0.13

use bevy::core_pipeline::clear_color::ClearColorConfig;

cmds.spawn( Camera2dBundle::default() )
    .insert( Camera2d { clear_color: ClearColorConfig::None } )
    .insert( UiCameraConfig { show_ui: true } ) //UI表示
    ;

cmds.spawn( Camera3dBundle:: default() )
    .insert( Camera3d { clear_color: ClearColorConfig::None, ..default() } )
    .insert( UiCameraConfig { show_ui: false } ) //UI非表示
    ;

use bevy::render::camera::ClearColorConfig;

cmds.spawn( Camera2dBundle::default() )
    .insert( Camera { clear_color: ClearColorConfig::None, ..default() } )
    ;

cmds.spawn( Camera3dBundle:: default() )
    .insert( Camera { clear_color: ClearColorConfig::None, ..default() } )
    ;

let sections  = vec![ TextSection { value, style } ];
let alignment = TextAlignment::Center;

cmds.spawn( Text2dBundle::default() )
    .insert( Text { sections, alignment, ..default() } )
    ;

let sections  = vec![ TextSection { value, style } ];
let justify = JustifyText::Center;

cmds.spawn( Text2dBundle::default() )
    .insert( Text { sections, justify, ..default() } )
    ;

.run_if( not( state_exists::<MyState>() ) )
.run_if( resource_exists::<IsLoadingFinished>() ) 

.run_if( not( state_exists::<MyState> ) )
.run_if( resource_exists::<IsLoadingFinished> ) 

pub fn spawn_3d_objects
(   mut cmds: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
)
{   //立方体
    cmds.spawn( PbrBundle::default() )
    .insert( meshes.add( shape::Cube::new( 1.0 ).into() ) )
    .insert( Transform::from_translation( Vec3::ZERO ) )
    .insert( materials.add( Color::BISQUE.into() ) )
    ;

    //地面
    cmds.spawn( PbrBundle::default() )
    .insert( meshes.add( shape::Plane::from_size( 5.0 ).into() ) )
    .insert( Transform::from_translation( Vec3::Y / -2.0 ) )
    .insert( materials.add( Color::SEA_GREEN.into() ) )
    ;
}

pub fn spawn_3d_objects
(   mut cmds: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
)
{   //立方体
    cmds.spawn( PbrBundle::default() )
    .insert( meshes.add( shape::Cube::new( 1.0 ) ) )
    .insert( Transform::from_translation( Vec3::ZERO ) )
    .insert( materials.add( Color::BISQUE ) )
    ;

    //地面
    cmds.spawn( PbrBundle::default() )
    .insert( meshes.add( shape::Plane::from_size( 5.0 ) ) )
    .insert( Transform::from_translation( Vec3::Y / -2.0 ) )
    .insert( materials.add( Color::SEA_GREEN) )
    ;
}

    app.add_state::<MyState>();

    app.init_state::<MyState>();

fn update_fps( diag_store: Res<DiagnosticsStore> )
{   let fps_avr = diag_store
        .get( FrameTimeDiagnosticsPlugin::FPS )
//（後略）

fn update_fps( diag_store: Res<DiagnosticsStore> )
{   let fps_avr = diag_store
        .get( &FrameTimeDiagnosticsPlugin::FPS )
//（後略）

fn despawn<T: Component>
(   qry_entity: Query<Entity, With<T>>,
    mut cmds: Commands,
)
{   qry_entity.for_each( | id | cmds.entity( id ).despawn_recursive() );
}

fn despawn<T: Component>
(   qry_entity: Query<Entity, With<T>>,
    mut cmds: Commands,
)
{   qry_entity.iter().for_each( | id | cmds.entity( id ).despawn_recursive() );
}

use bevy::audio::{ Volume, VolumeLevel };
let volume = Volume::Relative ( VolumeLevel::new( 0.1 ) );

use bevy::audio::Volume;
let volume = Volume::new( 0.1 );

let circle   = shape::Circle::new( radius );
let triangle = shape::RegularPolygon::new( radius, 3 );

let cube3d  = shape::Cube::new( 1.0 );
let plane3d = shape::Plane::from_size( 5.0 );

let circle2d   = Circle::new( radius ).mesh().resolution( 64 ).build();
let triangle2d = RegularPolygon::new( radius, 3 ).mesh();

let cube3d  = Cuboid::default();
let plane3d = Plane3d::default().mesh().size( 5.0, 5.0 );

pub struct TextureAtlasSprite {
    pub color: Color,
    pub index: usize,  //これだけ新TextureAtlasに引っ越す。他はSpriteへ
    pub flip_x: bool,
    pub flip_y: bool,
    pub custom_size: Option<Vec2>,
    pub anchor: Anchor,
}
pub struct Sprite { //0.13でも中身は変わらない
    pub color: Color,
    pub flip_x: bool,
    pub flip_y: bool,
    pub custom_size: Option<Vec2>,
    pub rect: Option<Rect>,
    pub anchor: Anchor,
}

pub struct TextureAtlasLayout { //改名された旧TextureAtlas
    //pub texture: Handle<Image>, が削除
    pub size: Vec2,
    pub textures: Vec<Rect>,
    /* private fields */
}
pub struct TextureAtlas { //新設
    pub layout: Handle<TextureAtlasLayout>,
    pub index: usize,  //ここがindexの新居
}
pub struct SpriteSheetBundle {
    pub sprite: Sprite, //TextureAtlasSpriteのindex以外の引っ越し先
    pub transform: Transform,
    pub global_transform: GlobalTransform,
    pub texture: Handle<Image>, //Handle<Image>の引っ越し先
    pub atlas: TextureAtlas, //追加された新TextureAtlas
    pub visibility: Visibility,
    pub inherited_visibility: InheritedVisibility,
    pub view_visibility: ViewVisibility,
}

pub struct ChildBuilder<'w, 's, 'a> { /* private fields */ }

pub struct ChildBuilder<'a> { /* private fields */ }

#[derive( Component )] pub struct FppCamera;
#[derive( Component )] pub struct TppCamera;

fn switch_fpp_tpp_cameras
(   mut qry_fpp_tpp: Query<&mut Camera, Or<( &FppCamera, &TppCamera )>>, //これが
)
{   qry_fpp_tpp.for_each_mut( | mut camera | camera.is_active = ! camera.is_active );
}

#[derive( Component )] pub struct FppCamera;
#[derive( Component )] pub struct TppCamera;

fn switch_fpp_tpp_cameras
(   mut qry_fpp_tpp: Query<&mut Camera, Or<( With<FppCamera>, With<TppCamera> )>>, //こう
)
{   qry_fpp_tpp.iter_mut().for_each( | mut camera | camera.is_active = ! camera.is_active );
}

#[derive( Component )] pub struct FppCamera;
#[derive( Component )] pub struct TppCamera;

fn switch_fpp_tpp_cameras
(   mut param_set: ParamSet
    <(  Query<&mut Camera, With<FppCamera>>,
        Query<&mut Camera, With<TppCamera>>,
    )>,
)
{   let mut qry_fpp = param_set.p0();
    let Ok ( mut fpp ) = qry_fpp.get_single_mut() else { return };
    fpp.is_active = ! fpp.is_active;

    let mut qry_tpp = param_set.p1();
    let Ok ( mut tpp ) = qry_tpp.get_single_mut() else { return };
    tpp.is_active = ! tpp.is_active;
}

2024-02-13T12:16:26.664379Z ERROR log: Handling wgpu errors as fatal by default    
thread 'Compute Task Pool (2)' panicked at C:\Users\hyoi\.cargo\registry\src\index.crates.io-6f17d22bba15001f\wgpu-0.19.1\src\backend\wgpu_core.rs:3009:5:
wgpu error: Validation Error

Caused by:
    In a RenderPass
      note: encoder = `main_opaque_pass_3d_command_encoder`
    In a set_viewport command
    Viewport has invalid rect Rect { x: 0.0, y: 0.0, w: 1376.0, h: 768.0 }; origin and/or size is less than or equal to 0, and/or is not contained in the render target (1366, 768, 1)


note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Encountered a panic in exclusive system `bevy_render::renderer::render_system`!        
thread 'Compute Task Pool (2)' panicked at C:\Users\hyoi\.cargo\git\checkouts\bevy-f7ffde730c324c74\f1f83bf\crates\bevy_render\src\pipelined_rendering.rs:49:67:
called `Result::unwrap()` on an `Err` value: RecvError
error: process didn't exit successfully: `target\debug\my_bevyapp_template.exe` (exit code: 101)

use bevy::
{   prelude::*,
    render::camera::Viewport,
    window::WindowMode,
};

// const WINDOW_WIDTH : f32 = 1366.0; //OK
const WINDOW_WIDTH : f32 = 1376.0; //Panic: Viewport has invalid rect
const WINDOW_HEIGHT: f32 = 768.0;

fn main()
{   //Specify Window Size.
    let window = Window { resolution: ( WINDOW_WIDTH, WINDOW_HEIGHT ).into(), ..default() };
    let primary_window = Some ( window );

    App::new()
        .add_plugins( DefaultPlugins.set( WindowPlugin { primary_window, ..default() } ) )
        .add_systems( Startup, startup )
        .add_systems( Update, toggle_window_mode )
        .run();
}

fn startup( mut cmds: Commands )
{   //Match viewport to Window size.
    let physical_position = UVec2::new( 0, 0 );
    let physical_size = Vec2::new( WINDOW_WIDTH, WINDOW_HEIGHT ).as_uvec2();
    let viewport = Some ( Viewport { physical_position, physical_size, ..default() } );

    cmds.spawn( Camera2dBundle::default() ).insert( Camera { viewport, ..default() } );
}

fn toggle_window_mode
(   mut qry_window: Query<&mut Window>,
    inkey: Res<ButtonInput<KeyCode>>,
)
{   let Ok( mut window ) = qry_window.get_single_mut() else { return };

    //Use the [SPACE] key to toggle between window and full screen.
    if inkey.just_pressed( KeyCode::Space )
    {   window.mode = match window.mode
        {   WindowMode::Windowed => WindowMode::SizedFullscreen,
            _                    => WindowMode::Windowed,
        };
    }
}