From 4ac2ed7cc65863dcd5c0b37f7bf9486ffa8d7ada Mon Sep 17 00:00:00 2001 From: Carter Anderson Date: Sun, 11 Apr 2021 13:13:07 -0700 Subject: [PATCH 01/96] pipelined rendering proof of concept --- Cargo.toml | 13 +- crates/bevy_app/src/app.rs | 572 +++++++- crates/bevy_app/src/app_builder.rs | 559 -------- crates/bevy_app/src/lib.rs | 4 +- crates/bevy_app/src/plugin.rs | 6 +- crates/bevy_app/src/plugin_group.rs | 4 +- crates/bevy_app/src/schedule_runner.rs | 11 +- crates/bevy_asset/src/assets.rs | 10 +- .../asset_count_diagnostics_plugin.rs | 2 +- crates/bevy_asset/src/lib.rs | 12 +- crates/bevy_audio/src/lib.rs | 2 +- crates/bevy_core/src/lib.rs | 10 +- .../src/entity_count_diagnostics_plugin.rs | 4 +- .../src/frame_time_diagnostics_plugin.rs | 2 +- crates/bevy_diagnostic/src/lib.rs | 2 +- .../src/log_diagnostics_plugin.rs | 2 +- crates/bevy_dynamic_plugin/src/loader.rs | 4 +- crates/bevy_ecs/src/archetype.rs | 11 + crates/bevy_ecs/src/entity/mod.rs | 1 + crates/bevy_ecs/src/lib.rs | 22 + crates/bevy_ecs/src/schedule/stage.rs | 20 +- crates/bevy_ecs/src/storage/sparse_set.rs | 17 + crates/bevy_ecs/src/storage/table.rs | 22 + crates/bevy_ecs/src/system/commands/mod.rs | 7 + crates/bevy_ecs/src/system/function_system.rs | 2 +- crates/bevy_ecs/src/system/param_state.rs | 36 + crates/bevy_ecs/src/world/mod.rs | 7 + crates/bevy_gilrs/src/lib.rs | 4 +- crates/bevy_gltf/src/lib.rs | 2 +- crates/bevy_input/src/lib.rs | 2 +- crates/bevy_internal/Cargo.toml | 16 +- crates/bevy_internal/src/default_plugins.rs | 26 + crates/bevy_internal/src/lib.rs | 18 + crates/bevy_log/src/lib.rs | 8 +- crates/bevy_pbr/src/lib.rs | 6 +- crates/bevy_render/src/lib.rs | 4 +- crates/bevy_render/src/wireframe/mod.rs | 4 +- crates/bevy_scene/src/lib.rs | 2 +- crates/bevy_sprite/src/lib.rs | 9 +- crates/bevy_text/src/lib.rs | 2 +- crates/bevy_transform/src/lib.rs | 2 +- crates/bevy_ui/src/lib.rs | 4 +- .../wgpu_resource_diagnostics_plugin.rs | 2 +- crates/bevy_wgpu/src/lib.rs | 4 +- crates/bevy_window/src/lib.rs | 11 +- crates/bevy_winit/src/lib.rs | 4 +- crates/crevice/CHANGELOG.md | 39 + crates/crevice/Cargo.toml | 27 + crates/crevice/LICENSE-APACHE | 201 +++ crates/crevice/LICENSE-MIT | 19 + crates/crevice/README.md | 135 ++ crates/crevice/README.tpl | 15 + crates/crevice/src/glam.rs | 78 ++ crates/crevice/src/internal.rs | 23 + crates/crevice/src/lib.rs | 142 ++ crates/crevice/src/mint.rs | 78 ++ crates/crevice/src/std140.rs | 16 + crates/crevice/src/std140/dynamic_uniform.rs | 56 + crates/crevice/src/std140/primitives.rs | 151 ++ crates/crevice/src/std140/sizer.rs | 81 ++ crates/crevice/src/std140/traits.rs | 160 +++ crates/crevice/src/std140/writer.rs | 162 +++ crates/crevice/src/std430.rs | 14 + crates/crevice/src/std430/primitives.rs | 143 ++ crates/crevice/src/std430/sizer.rs | 81 ++ crates/crevice/src/std430/traits.rs | 159 +++ crates/crevice/src/std430/writer.rs | 150 ++ .../std140__more_than_16_alignment.snap | 16 + .../tests/snapshots/std140__point_light.snap | 40 + .../snapshots/std140__primitive_f32.snap | 24 + .../snapshots/std140__using_vec3_padding.snap | 24 + .../crevice/tests/snapshots/std140__vec3.snap | 24 + crates/crevice/tests/std140.rs | 121 ++ examples/2d/contributors.rs | 2 +- examples/2d/many_sprites.rs | 2 +- examples/2d/mesh.rs | 2 +- examples/2d/sprite.rs | 8 +- examples/2d/sprite_flipping.rs | 2 +- examples/2d/sprite_sheet.rs | 2 +- examples/2d/text2d.rs | 2 +- examples/2d/texture_atlas.rs | 2 +- examples/3d/3d_scene.rs | 2 +- examples/3d/load_gltf.rs | 2 +- examples/3d/msaa.rs | 2 +- examples/3d/orthographic.rs | 2 +- examples/3d/parenting.rs | 2 +- examples/3d/pbr.rs | 2 +- examples/3d/spawner.rs | 2 +- examples/3d/texture.rs | 2 +- examples/3d/update_gltf_scene.rs | 2 +- examples/3d/wireframe.rs | 2 +- examples/3d/z_sort_debug.rs | 2 +- examples/android/android.rs | 2 +- examples/app/custom_loop.rs | 2 +- examples/app/drag_and_drop.rs | 2 +- examples/app/empty.rs | 2 +- examples/app/empty_defaults.rs | 2 +- examples/app/headless.rs | 4 +- examples/app/logs.rs | 2 +- examples/app/plugin.rs | 4 +- examples/app/plugin_group.rs | 6 +- examples/app/return_after_run.rs | 4 +- examples/app/thread_pool_resources.rs | 2 +- examples/asset/asset_loading.rs | 2 +- examples/asset/custom_asset.rs | 2 +- examples/asset/custom_asset_io.rs | 6 +- examples/asset/hot_asset_reloading.rs | 2 +- examples/audio/audio.rs | 2 +- examples/diagnostics/custom_diagnostic.rs | 2 +- examples/diagnostics/log_diagnostics.rs | 2 +- examples/ecs/component_change_detection.rs | 2 +- examples/ecs/ecs_guide.rs | 2 +- examples/ecs/event.rs | 2 +- examples/ecs/fixed_timestep.rs | 2 +- examples/ecs/hierarchy.rs | 2 +- examples/ecs/parallel_query.rs | 2 +- examples/ecs/removal_detection.rs | 2 +- examples/ecs/startup_system.rs | 2 +- examples/ecs/state.rs | 2 +- examples/ecs/system_chaining.rs | 2 +- examples/ecs/system_param.rs | 2 +- examples/ecs/timers.rs | 2 +- examples/game/alien_cake_addict.rs | 2 +- examples/game/breakout.rs | 2 +- examples/hello_world.rs | 2 +- examples/input/char_input_events.rs | 2 +- examples/input/gamepad_input.rs | 2 +- examples/input/gamepad_input_events.rs | 2 +- examples/input/keyboard_input.rs | 2 +- examples/input/keyboard_input_events.rs | 2 +- examples/input/keyboard_modifiers.rs | 2 +- examples/input/mouse_input.rs | 2 +- examples/input/mouse_input_events.rs | 2 +- examples/input/touch_input.rs | 2 +- examples/input/touch_input_events.rs | 2 +- examples/ios/src/lib.rs | 2 +- examples/reflection/generic_reflection.rs | 2 +- examples/reflection/reflection.rs | 2 +- examples/reflection/reflection_types.rs | 2 +- examples/reflection/trait_reflection.rs | 2 +- examples/scene/scene.rs | 2 +- examples/shader/animate_shader.rs | 2 +- examples/shader/array_texture.rs | 2 +- examples/shader/hot_shader_reloading.rs | 2 +- examples/shader/mesh_custom_attribute.rs | 2 +- examples/shader/shader_custom_material.rs | 2 +- examples/shader/shader_defs.rs | 2 +- examples/tools/bevymark.rs | 2 +- examples/tools/bevymark_pipelined.rs | 265 ++++ examples/ui/button.rs | 2 +- examples/ui/font_atlas_debug.rs | 2 +- examples/ui/text.rs | 2 +- examples/ui/text_debug.rs | 2 +- examples/ui/ui.rs | 2 +- examples/wasm/assets_wasm.rs | 2 +- examples/wasm/headless_wasm.rs | 2 +- examples/wasm/hello_wasm.rs | 2 +- examples/wasm/winit_wasm.rs | 2 +- examples/window/clear_color.rs | 2 +- examples/window/multiple_windows.rs | 2 +- examples/window/scale_factor_override.rs | 2 +- examples/window/window_settings.rs | 2 +- pipelined/bevy_render2/Cargo.toml | 60 + .../bevy_render2/src/camera/active_cameras.rs | 73 + pipelined/bevy_render2/src/camera/bundle.rs | 106 ++ pipelined/bevy_render2/src/camera/camera.rs | 113 ++ pipelined/bevy_render2/src/camera/mod.rs | 131 ++ .../bevy_render2/src/camera/projection.rs | 164 +++ pipelined/bevy_render2/src/color/color.rs | 1222 +++++++++++++++++ .../bevy_render2/src/color/colorspace.rs | 201 +++ pipelined/bevy_render2/src/color/mod.rs | 5 + pipelined/bevy_render2/src/lib.rs | 110 ++ pipelined/bevy_render2/src/main_pass/draw.rs | 26 + .../bevy_render2/src/main_pass/draw_state.rs | 154 +++ pipelined/bevy_render2/src/main_pass/mod.rs | 136 ++ pipelined/bevy_render2/src/mesh/mesh.rs | 462 +++++++ .../bevy_render2/src/mesh/mesh/conversions.rs | 521 +++++++ pipelined/bevy_render2/src/mesh/mod.rs | 6 + .../bevy_render2/src/mesh/shape/capsule.rs | 381 +++++ .../bevy_render2/src/mesh/shape/icosphere.rs | 106 ++ pipelined/bevy_render2/src/mesh/shape/mod.rs | 276 ++++ .../bevy_render2/src/mesh/shape/torus.rs | 94 ++ .../bevy_render2/src/mesh/shape/uvsphere.rs | 91 ++ pipelined/bevy_render2/src/pass/mod.rs | 8 + pipelined/bevy_render2/src/pass/ops.rs | 17 + pipelined/bevy_render2/src/pass/pass.rs | 56 + .../bevy_render2/src/pass/render_pass.rs | 25 + .../bevy_render2/src/pipeline/bind_group.rs | 49 + .../bevy_render2/src/pipeline/binding.rs | 82 ++ pipelined/bevy_render2/src/pipeline/mod.rs | 16 + .../bevy_render2/src/pipeline/pipeline.rs | 120 ++ .../src/pipeline/pipeline_layout.rs | 106 ++ .../src/pipeline/state_descriptors.rs | 232 ++++ .../src/pipeline/vertex_buffer_descriptor.rs | 56 + .../src/pipeline/vertex_format.rs | 136 ++ .../bevy_render2/src/render_command/mod.rs | 47 + .../render_command/render_command_queue.rs | 227 +++ .../bevy_render2/src/render_graph/edge.rs | 31 + .../bevy_render2/src/render_graph/graph.rs | 442 ++++++ .../bevy_render2/src/render_graph/mod.rs | 44 + .../bevy_render2/src/render_graph/node.rs | 208 +++ .../src/render_graph/node_slot.rs | 143 ++ .../src/render_graph/nodes/mod.rs | 3 + .../nodes/window_swap_chain_node.rs | 99 ++ .../bevy_render2/src/render_graph/schedule.rs | 552 ++++++++ .../src/render_resource/bind_group.rs | 127 ++ .../src/render_resource/buffer.rs | 51 + .../src/render_resource/buffer_vec.rs | 124 ++ .../bevy_render2/src/render_resource/mod.rs | 17 + .../render_resource_bindings.rs | 61 + .../src/render_resource/render_resource_id.rs | 41 + .../src/render_resource/swap_chain.rs | 16 + .../src/render_resource/texture.rs | 21 + .../src/render_resource/uniform_vec.rs | 183 +++ .../headless_render_resource_context.rs | 137 ++ pipelined/bevy_render2/src/renderer/mod.rs | 7 + .../src/renderer/render_context.rs | 57 + .../src/renderer/render_resource_context.rs | 79 ++ pipelined/bevy_render2/src/shader/mod.rs | 24 + pipelined/bevy_render2/src/shader/shader.rs | 286 ++++ .../bevy_render2/src/shader/shader_reflect.rs | 404 ++++++ .../src/texture/hdr_texture_loader.rs | 53 + .../src/texture/image_texture_conversion.rs | 151 ++ .../src/texture/image_texture_loader.rs | 67 + pipelined/bevy_render2/src/texture/mod.rs | 140 ++ .../src/texture/sampler_descriptor.rs | 79 ++ pipelined/bevy_render2/src/texture/texture.rs | 206 +++ .../src/texture/texture_descriptor.rs | 69 + .../src/texture/texture_dimension.rs | 296 ++++ pipelined/bevy_sprite2/Cargo.toml | 35 + pipelined/bevy_sprite2/src/bundle.rs | 24 + pipelined/bevy_sprite2/src/lib.rs | 47 + pipelined/bevy_sprite2/src/rect.rs | 22 + pipelined/bevy_sprite2/src/render/mod.rs | 394 ++++++ pipelined/bevy_sprite2/src/render/sprite.frag | 11 + pipelined/bevy_sprite2/src/render/sprite.vert | 15 + pipelined/bevy_sprite2/src/sprite.rs | 39 + pipelined/bevy_wgpu2/Cargo.toml | 37 + pipelined/bevy_wgpu2/src/diagnostic/mod.rs | 2 + .../wgpu_resource_diagnostics_plugin.rs | 183 +++ pipelined/bevy_wgpu2/src/lib.rs | 215 +++ pipelined/bevy_wgpu2/src/render_context.rs | 265 ++++ .../bevy_wgpu2/src/render_graph_executor.rs | 102 ++ pipelined/bevy_wgpu2/src/render_pass.rs | 105 ++ .../bevy_wgpu2/src/render_resource_context.rs | 641 +++++++++ pipelined/bevy_wgpu2/src/renderer.rs | 112 ++ pipelined/bevy_wgpu2/src/resources.rs | 181 +++ pipelined/bevy_wgpu2/src/type_converter.rs | 745 ++++++++++ pipelined/changes.md | 10 + src/lib.rs | 2 +- 250 files changed, 16397 insertions(+), 757 deletions(-) delete mode 100644 crates/bevy_app/src/app_builder.rs create mode 100644 crates/bevy_ecs/src/system/param_state.rs create mode 100644 crates/crevice/CHANGELOG.md create mode 100644 crates/crevice/Cargo.toml create mode 100644 crates/crevice/LICENSE-APACHE create mode 100644 crates/crevice/LICENSE-MIT create mode 100644 crates/crevice/README.md create mode 100644 crates/crevice/README.tpl create mode 100644 crates/crevice/src/glam.rs create mode 100644 crates/crevice/src/internal.rs create mode 100644 crates/crevice/src/lib.rs create mode 100644 crates/crevice/src/mint.rs create mode 100644 crates/crevice/src/std140.rs create mode 100644 crates/crevice/src/std140/dynamic_uniform.rs create mode 100644 crates/crevice/src/std140/primitives.rs create mode 100644 crates/crevice/src/std140/sizer.rs create mode 100644 crates/crevice/src/std140/traits.rs create mode 100644 crates/crevice/src/std140/writer.rs create mode 100644 crates/crevice/src/std430.rs create mode 100644 crates/crevice/src/std430/primitives.rs create mode 100644 crates/crevice/src/std430/sizer.rs create mode 100644 crates/crevice/src/std430/traits.rs create mode 100644 crates/crevice/src/std430/writer.rs create mode 100644 crates/crevice/tests/snapshots/std140__more_than_16_alignment.snap create mode 100644 crates/crevice/tests/snapshots/std140__point_light.snap create mode 100644 crates/crevice/tests/snapshots/std140__primitive_f32.snap create mode 100644 crates/crevice/tests/snapshots/std140__using_vec3_padding.snap create mode 100644 crates/crevice/tests/snapshots/std140__vec3.snap create mode 100644 crates/crevice/tests/std140.rs create mode 100644 examples/tools/bevymark_pipelined.rs create mode 100644 pipelined/bevy_render2/Cargo.toml create mode 100644 pipelined/bevy_render2/src/camera/active_cameras.rs create mode 100644 pipelined/bevy_render2/src/camera/bundle.rs create mode 100644 pipelined/bevy_render2/src/camera/camera.rs create mode 100644 pipelined/bevy_render2/src/camera/mod.rs create mode 100644 pipelined/bevy_render2/src/camera/projection.rs create mode 100644 pipelined/bevy_render2/src/color/color.rs create mode 100644 pipelined/bevy_render2/src/color/colorspace.rs create mode 100644 pipelined/bevy_render2/src/color/mod.rs create mode 100644 pipelined/bevy_render2/src/lib.rs create mode 100644 pipelined/bevy_render2/src/main_pass/draw.rs create mode 100644 pipelined/bevy_render2/src/main_pass/draw_state.rs create mode 100644 pipelined/bevy_render2/src/main_pass/mod.rs create mode 100644 pipelined/bevy_render2/src/mesh/mesh.rs create mode 100644 pipelined/bevy_render2/src/mesh/mesh/conversions.rs create mode 100644 pipelined/bevy_render2/src/mesh/mod.rs create mode 100644 pipelined/bevy_render2/src/mesh/shape/capsule.rs create mode 100644 pipelined/bevy_render2/src/mesh/shape/icosphere.rs create mode 100644 pipelined/bevy_render2/src/mesh/shape/mod.rs create mode 100644 pipelined/bevy_render2/src/mesh/shape/torus.rs create mode 100644 pipelined/bevy_render2/src/mesh/shape/uvsphere.rs create mode 100644 pipelined/bevy_render2/src/pass/mod.rs create mode 100644 pipelined/bevy_render2/src/pass/ops.rs create mode 100644 pipelined/bevy_render2/src/pass/pass.rs create mode 100644 pipelined/bevy_render2/src/pass/render_pass.rs create mode 100644 pipelined/bevy_render2/src/pipeline/bind_group.rs create mode 100644 pipelined/bevy_render2/src/pipeline/binding.rs create mode 100644 pipelined/bevy_render2/src/pipeline/mod.rs create mode 100644 pipelined/bevy_render2/src/pipeline/pipeline.rs create mode 100644 pipelined/bevy_render2/src/pipeline/pipeline_layout.rs create mode 100644 pipelined/bevy_render2/src/pipeline/state_descriptors.rs create mode 100644 pipelined/bevy_render2/src/pipeline/vertex_buffer_descriptor.rs create mode 100644 pipelined/bevy_render2/src/pipeline/vertex_format.rs create mode 100644 pipelined/bevy_render2/src/render_command/mod.rs create mode 100644 pipelined/bevy_render2/src/render_command/render_command_queue.rs create mode 100644 pipelined/bevy_render2/src/render_graph/edge.rs create mode 100644 pipelined/bevy_render2/src/render_graph/graph.rs create mode 100644 pipelined/bevy_render2/src/render_graph/mod.rs create mode 100644 pipelined/bevy_render2/src/render_graph/node.rs create mode 100644 pipelined/bevy_render2/src/render_graph/node_slot.rs create mode 100644 pipelined/bevy_render2/src/render_graph/nodes/mod.rs create mode 100644 pipelined/bevy_render2/src/render_graph/nodes/window_swap_chain_node.rs create mode 100644 pipelined/bevy_render2/src/render_graph/schedule.rs create mode 100644 pipelined/bevy_render2/src/render_resource/bind_group.rs create mode 100644 pipelined/bevy_render2/src/render_resource/buffer.rs create mode 100644 pipelined/bevy_render2/src/render_resource/buffer_vec.rs create mode 100644 pipelined/bevy_render2/src/render_resource/mod.rs create mode 100644 pipelined/bevy_render2/src/render_resource/render_resource_bindings.rs create mode 100644 pipelined/bevy_render2/src/render_resource/render_resource_id.rs create mode 100644 pipelined/bevy_render2/src/render_resource/swap_chain.rs create mode 100644 pipelined/bevy_render2/src/render_resource/texture.rs create mode 100644 pipelined/bevy_render2/src/render_resource/uniform_vec.rs create mode 100644 pipelined/bevy_render2/src/renderer/headless_render_resource_context.rs create mode 100644 pipelined/bevy_render2/src/renderer/mod.rs create mode 100644 pipelined/bevy_render2/src/renderer/render_context.rs create mode 100644 pipelined/bevy_render2/src/renderer/render_resource_context.rs create mode 100644 pipelined/bevy_render2/src/shader/mod.rs create mode 100644 pipelined/bevy_render2/src/shader/shader.rs create mode 100644 pipelined/bevy_render2/src/shader/shader_reflect.rs create mode 100644 pipelined/bevy_render2/src/texture/hdr_texture_loader.rs create mode 100644 pipelined/bevy_render2/src/texture/image_texture_conversion.rs create mode 100644 pipelined/bevy_render2/src/texture/image_texture_loader.rs create mode 100644 pipelined/bevy_render2/src/texture/mod.rs create mode 100644 pipelined/bevy_render2/src/texture/sampler_descriptor.rs create mode 100644 pipelined/bevy_render2/src/texture/texture.rs create mode 100644 pipelined/bevy_render2/src/texture/texture_descriptor.rs create mode 100644 pipelined/bevy_render2/src/texture/texture_dimension.rs create mode 100644 pipelined/bevy_sprite2/Cargo.toml create mode 100644 pipelined/bevy_sprite2/src/bundle.rs create mode 100644 pipelined/bevy_sprite2/src/lib.rs create mode 100644 pipelined/bevy_sprite2/src/rect.rs create mode 100644 pipelined/bevy_sprite2/src/render/mod.rs create mode 100644 pipelined/bevy_sprite2/src/render/sprite.frag create mode 100644 pipelined/bevy_sprite2/src/render/sprite.vert create mode 100644 pipelined/bevy_sprite2/src/sprite.rs create mode 100644 pipelined/bevy_wgpu2/Cargo.toml create mode 100644 pipelined/bevy_wgpu2/src/diagnostic/mod.rs create mode 100644 pipelined/bevy_wgpu2/src/diagnostic/wgpu_resource_diagnostics_plugin.rs create mode 100644 pipelined/bevy_wgpu2/src/lib.rs create mode 100644 pipelined/bevy_wgpu2/src/render_context.rs create mode 100644 pipelined/bevy_wgpu2/src/render_graph_executor.rs create mode 100644 pipelined/bevy_wgpu2/src/render_pass.rs create mode 100644 pipelined/bevy_wgpu2/src/render_resource_context.rs create mode 100644 pipelined/bevy_wgpu2/src/renderer.rs create mode 100644 pipelined/bevy_wgpu2/src/resources.rs create mode 100644 pipelined/bevy_wgpu2/src/type_converter.rs create mode 100644 pipelined/changes.md diff --git a/Cargo.toml b/Cargo.toml index f95b76f75a..fc872217a3 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -17,7 +17,7 @@ repository = "https://github.com/bevyengine/bevy" [workspace] exclude = ["benches"] -members = ["crates/*", "examples/ios", "tools/ci"] +members = ["crates/*", "pipelined/*", "examples/ios", "tools/ci"] [features] default = [ @@ -26,6 +26,9 @@ default = [ "bevy_gilrs", "bevy_gltf", "bevy_wgpu", + "bevy_wgpu2", + "bevy_sprite2", + "bevy_render2", "bevy_winit", "render", "png", @@ -48,6 +51,10 @@ bevy_gltf = ["bevy_internal/bevy_gltf"] bevy_wgpu = ["bevy_internal/bevy_wgpu"] bevy_winit = ["bevy_internal/bevy_winit"] +bevy_wgpu2 = ["bevy_internal/bevy_wgpu2"] +bevy_render2 = ["bevy_internal/bevy_render2"] +bevy_sprite2 = ["bevy_internal/bevy_sprite2"] + trace_chrome = ["bevy_internal/trace_chrome"] trace = ["bevy_internal/trace"] wgpu_trace = ["bevy_internal/wgpu_trace"] @@ -419,6 +426,10 @@ path = "examples/shader/shader_defs.rs" name = "bevymark" path = "examples/tools/bevymark.rs" +[[example]] +name = "bevymark_pipelined" +path = "examples/tools/bevymark_pipelined.rs" + # UI (User Interface) [[example]] name = "button" diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs index d30303a4ac..c7a400ad34 100644 --- a/crates/bevy_app/src/app.rs +++ b/crates/bevy_app/src/app.rs @@ -1,10 +1,19 @@ -use crate::app_builder::AppBuilder; +use crate::{CoreStage, Events, Plugin, PluginGroup, PluginGroupBuilder, StartupStage}; use bevy_ecs::{ - schedule::{Schedule, Stage}, + component::{Component, ComponentDescriptor}, + prelude::{FromWorld, IntoExclusiveSystem, IntoSystem}, + schedule::{ + RunOnce, Schedule, Stage, StageLabel, State, SystemDescriptor, SystemSet, SystemStage, + }, world::World, }; +use bevy_utils::tracing::debug; +use std::{fmt::Debug, hash::Hash}; + #[cfg(feature = "trace")] use bevy_utils::tracing::info_span; +use std::fmt::Debug; +use std::hash::Hash; #[allow(clippy::needless_doctest_main)] /// Containers of app logic and data @@ -20,7 +29,7 @@ use bevy_utils::tracing::info_span; /// # use bevy_ecs::prelude::*; /// /// fn main() { -/// App::build() +/// App::new() /// .add_system(hello_world_system.system()) /// .run(); /// } @@ -33,26 +42,46 @@ pub struct App { pub world: World, pub runner: Box, pub schedule: Schedule, + sub_apps: Vec, +} + +struct SubApp { + app: App, + runner: Box, } impl Default for App { fn default() -> Self { + let mut app = App::empty(); + #[cfg(feature = "bevy_reflect")] + app.init_resource::(); + + app.add_default_stages() + .add_event::() + .add_system_to_stage(CoreStage::Last, World::clear_trackers.exclusive_system()); + + #[cfg(feature = "bevy_ci_testing")] + { + crate::ci_testing::setup_app(&mut app); + } + + app + } +} + +impl App { + pub fn new() -> App { + App::default() + } + + pub fn empty() -> App { Self { world: Default::default(), schedule: Default::default(), runner: Box::new(run_once), + sub_apps: Vec::new(), } } -} - -fn run_once(mut app: App) { - app.update(); -} - -impl App { - pub fn build() -> AppBuilder { - AppBuilder::default() - } pub fn update(&mut self) { #[cfg(feature = "trace")] @@ -60,17 +89,528 @@ impl App { #[cfg(feature = "trace")] let _bevy_frame_update_guard = bevy_frame_update_span.enter(); self.schedule.run(&mut self.world); + for sub_app in self.sub_apps.iter_mut() { + (sub_app.runner)(&mut self.world, &mut sub_app.app); + } } - pub fn run(mut self) { + /// Start the application (through main runner) + /// + /// Runs the application main loop. + /// + /// Usually the main loop is handled by Bevy integrated plugins (`winit`), but + /// but one can also set the runner function through [`App::set_runner`]. + /// + /// ## Example + /// ``` + /// # use bevy_app::prelude::*; + /// # + /// App::new() + /// // all required plugin insertions, systems, etc inserted here + /// // finally, call: + /// .run(); + /// ``` + pub fn run(&mut self) { #[cfg(feature = "trace")] let bevy_app_run_span = info_span!("bevy_app"); #[cfg(feature = "trace")] let _bevy_app_run_guard = bevy_app_run_span.enter(); - let runner = std::mem::replace(&mut self.runner, Box::new(run_once)); - (runner)(self); + let mut app = std::mem::replace(self, App::empty()); + let runner = std::mem::replace(&mut app.runner, Box::new(run_once)); + (runner)(app); } + + pub fn add_stage(&mut self, label: impl StageLabel, stage: S) -> &mut Self { + self.schedule.add_stage(label, stage); + self + } + + pub fn add_stage_after( + &mut self, + target: impl StageLabel, + label: impl StageLabel, + stage: S, + ) -> &mut Self { + self.schedule.add_stage_after(target, label, stage); + self + } + + pub fn add_stage_before( + &mut self, + target: impl StageLabel, + label: impl StageLabel, + stage: S, + ) -> &mut Self { + self.schedule.add_stage_before(target, label, stage); + self + } + + pub fn add_startup_stage(&mut self, label: impl StageLabel, stage: S) -> &mut Self { + self.schedule + .stage(CoreStage::Startup, |schedule: &mut Schedule| { + schedule.add_stage(label, stage) + }); + self + } + + pub fn add_startup_stage_after( + &mut self, + target: impl StageLabel, + label: impl StageLabel, + stage: S, + ) -> &mut Self { + self.schedule + .stage(CoreStage::Startup, |schedule: &mut Schedule| { + schedule.add_stage_after(target, label, stage) + }); + self + } + + pub fn add_startup_stage_before( + &mut self, + target: impl StageLabel, + label: impl StageLabel, + stage: S, + ) -> &mut Self { + self.schedule + .stage(CoreStage::Startup, |schedule: &mut Schedule| { + schedule.add_stage_before(target, label, stage) + }); + self + } + + pub fn stage &mut T>( + &mut self, + label: impl StageLabel, + func: F, + ) -> &mut Self { + self.schedule.stage(label, func); + self + } + + /// Adds a system that runs every time `app.update()` is called by the runner + /// + /// Systems are the main building block in the Bevy ECS app model. You can define + /// normal rust functions, and call `.system()` to make them be Bevy systems. + /// + /// System functions can have parameters, through which one can query and + /// mutate Bevy ECS states. + /// See [The Bevy Book](https://bevyengine.org/learn/book/introduction/) for more information. + /// + /// Systems are run in parallel, and the execution order is not deterministic. + /// If you want more fine-grained control for order, see [`App::add_system_to_stage`]. + /// + /// For adding a system that runs only at app startup, see [`App::add_startup_system`]. + /// + /// ## Example + /// ``` + /// # use bevy_app::prelude::*; + /// # use bevy_ecs::prelude::*; + /// # + /// fn my_system(_commands: Commands) { + /// println!("My system, triggered once per frame"); + /// } + /// + /// App::new() + /// .add_system(my_system.system()); + /// ``` + pub fn add_system(&mut self, system: impl IntoSystemDescriptor) -> &mut Self { + self.add_system_to_stage(CoreStage::Update, system) + } + + pub fn add_system_set(&mut self, system_set: SystemSet) -> &mut Self { + self.add_system_set_to_stage(CoreStage::Update, system_set) + } + + pub fn add_system_to_stage( + &mut self, + stage_label: impl StageLabel, + system: impl IntoSystemDescriptor, + ) -> &mut Self { + self.schedule.add_system_to_stage(stage_label, system); + self + } + + pub fn add_system_set_to_stage( + &mut self, + stage_label: impl StageLabel, + system_set: SystemSet, + ) -> &mut Self { + self.schedule + .add_system_set_to_stage(stage_label, system_set); + self + } + + /// Adds a system that is run once at application startup + /// + /// Startup systems run exactly once BEFORE all other systems. These are generally used for + /// app initialization code (ex: adding entities and resources). + /// + /// * For adding a system that runs for every frame, see [`App::add_system`]. + /// * For adding a system to specific stage, see [`App::add_system_to_stage`]. + /// + /// ## Example + /// ``` + /// # use bevy_app::prelude::*; + /// # use bevy_ecs::prelude::*; + /// # + /// fn my_startup_system(_commands: Commands) { + /// println!("My startup system"); + /// } + /// + /// App::new() + /// .add_startup_system(my_startup_system.system()); + /// ``` + pub fn add_startup_system( + &mut self, + system: impl IntoSystemDescriptor, + ) -> &mut Self { + self.add_startup_system_to_stage(StartupStage::Startup, system) + } + + pub fn add_startup_system_set(&mut self, system_set: SystemSet) -> &mut Self { + self.add_startup_system_set_to_stage(StartupStage::Startup, system_set) + } + + pub fn add_startup_system_to_stage( + &mut self, + stage_label: impl StageLabel, + system: impl IntoSystemDescriptor, + ) -> &mut Self { + self.app + .schedule + .stage(CoreStage::Startup, |schedule: &mut Schedule| { + schedule.add_system_to_stage(stage_label, system) + }); + self + } + + pub fn add_startup_system_set_to_stage( + &mut self, + stage_label: impl StageLabel, + system_set: SystemSet, + ) -> &mut Self { + self.app + .schedule + .stage(CoreStage::Startup, |schedule: &mut Schedule| { + schedule.add_system_set_to_stage(stage_label, system_set) + }); + self + } + + /// Adds a new [State] with the given `initial` value. + /// This inserts a new `State` resource and adds a new "driver" to [CoreStage::Update]. + /// Each stage that uses `State` for system run criteria needs a driver. If you need to use + /// your state in a different stage, consider using [Self::add_state_to_stage] or manually + /// adding [State::get_driver] to additional stages you need it in. + pub fn add_state(&mut self, initial: T) -> &mut Self + where + T: Component + Debug + Clone + Eq + Hash, + { + self.add_state_to_stage(CoreStage::Update, initial) + } + + /// Adds a new [State] with the given `initial` value. + /// This inserts a new `State` resource and adds a new "driver" to the given stage. + /// Each stage that uses `State` for system run criteria needs a driver. If you need to use + /// your state in more than one stage, consider manually adding [State::get_driver] to the + /// stages you need it in. + pub fn add_state_to_stage(&mut self, stage: impl StageLabel, initial: T) -> &mut Self + where + T: Component + Debug + Clone + Eq + Hash, + { + self.insert_resource(State::new(initial)) + .add_system_set_to_stage(stage, State::::get_driver()) + } + + pub fn add_default_stages(&mut self) -> &mut Self { + self.add_stage(CoreStage::First, SystemStage::parallel()) + .add_stage( + CoreStage::Startup, + Schedule::default() + .with_run_criteria(RunOnce::default()) + .with_stage(StartupStage::PreStartup, SystemStage::parallel()) + .with_stage(StartupStage::Startup, SystemStage::parallel()) + .with_stage(StartupStage::PostStartup, SystemStage::parallel()), + ) + .add_stage(CoreStage::PreUpdate, SystemStage::parallel()) + .add_stage(CoreStage::Update, SystemStage::parallel()) + .add_stage(CoreStage::PostUpdate, SystemStage::parallel()) + .add_stage(CoreStage::Last, SystemStage::parallel()) + } + + /// Setup the application to manage events of type `T`. + /// + /// This is done by adding a `Resource` of type `Events::`, + /// and inserting a `Events::::update_system` system into `CoreStage::First`. + pub fn add_event(&mut self) -> &mut Self + where + T: Component, + { + self.insert_resource(Events::::default()) + .add_system_to_stage(CoreStage::First, Events::::update_system.system()) + } + + /// Inserts a resource to the current [App] and overwrites any resource previously added of the same type. + /// + /// A resource in Bevy represents globally unique data. Resources must be added to Bevy Apps + /// before using them. This happens with [`App::insert_resource`]. + /// + /// See also `init_resource` for resources that implement `Default` or [`FromResources`]. + /// + /// ## Example + /// ``` + /// # use bevy_app::prelude::*; + /// # + /// struct MyCounter { + /// counter: usize, + /// } + /// + /// App::new() + /// .insert_resource(MyCounter { counter: 0 }); + /// ``` + pub fn insert_resource(&mut self, resource: T) -> &mut Self + where + T: Component, + { + self.world.insert_resource(resource); + self + } + + /// Inserts a non-send resource to the app + /// + /// You usually want to use `insert_resource`, but there are some special cases when a resource must + /// be non-send. + /// + /// ## Example + /// ``` + /// # use bevy_app::prelude::*; + /// # + /// struct MyCounter { + /// counter: usize, + /// } + /// + /// App::new() + /// .insert_non_send_resource(MyCounter { counter: 0 }); + /// ``` + pub fn insert_non_send_resource(&mut self, resource: T) -> &mut Self + where + T: 'static, + { + self.world.insert_non_send(resource); + self + } + + /// Initialize a resource in the current [App], if it does not exist yet + /// + /// Adds a resource that implements `Default` or [`FromResources`] trait. + /// If the resource already exists, `init_resource` does nothing. + /// + /// ## Example + /// ``` + /// # use bevy_app::prelude::*; + /// # + /// struct MyCounter { + /// counter: usize, + /// } + /// + /// impl Default for MyCounter { + /// fn default() -> MyCounter { + /// MyCounter { + /// counter: 100 + /// } + /// } + /// } + /// + /// App::new() + /// .init_resource::(); + /// ``` + pub fn init_resource(&mut self) -> &mut Self + where + R: FromWorld + Send + Sync + 'static, + { + // PERF: We could avoid double hashing here, since the `from_resources` call is guaranteed + // not to modify the map. However, we would need to be borrowing resources both + // mutably and immutably, so we would need to be extremely certain this is correct + if !self.world.contains_resource::() { + let resource = R::from_world(&mut self.world); + self.insert_resource(resource); + } + self + } + + pub fn init_non_send_resource(&mut self) -> &mut Self + where + R: FromWorld + 'static, + { + // See perf comment in init_resource + if self.world.get_non_send_resource::().is_none() { + let resource = R::from_world(&mut self.world); + self.world.insert_non_send(resource); + } + self + } + + /// Sets the main runner loop function for this Bevy App + /// + /// Usually the main loop is handled by Bevy integrated plugins ([`WinitPlugin`]), but + /// in some cases one might wish to implement their own main loop. + /// + /// This method sets the main loop function, overwriting a previous runner if any. + /// + /// ## Example + /// ``` + /// # use bevy_app::prelude::*; + /// # + /// fn my_runner(mut app: App) { + /// loop { + /// println!("In main loop"); + /// app.update(); + /// } + /// } + /// + /// App::new() + /// .set_runner(my_runner); + /// ``` + pub fn set_runner(&mut self, run_fn: impl Fn(App) + 'static) -> &mut Self { + self.runner = Box::new(run_fn); + self + } + + /// Adds a single plugin + /// + /// One of Bevy's core principles is modularity. All Bevy engine features are implemented + /// as plugins. This includes internal features like the renderer. + /// + /// Bevy also provides a few sets of default plugins. See [`App::add_plugins`]. + /// + /// ## Example + /// ``` + /// # use bevy_app::prelude::*; + /// # + /// App::new().add_plugin(bevy_log::LogPlugin::default()); + /// ``` + pub fn add_plugin(&mut self, plugin: T) -> &mut Self + where + T: Plugin, + { + debug!("added plugin: {}", plugin.name()); + plugin.build(self); + self + } + + /// Adds a group of plugins + /// + /// Bevy plugins can be grouped into a set of plugins. Bevy provides + /// built-in PluginGroups that provide core engine functionality. + /// + /// The plugin groups available by default are [`DefaultPlugins`] and [`MinimalPlugins`]. + /// + /// ## Example + /// ``` + /// # use bevy_app::{prelude::*, PluginGroupBuilder}; + /// # + /// # // Dummy created to avoid using bevy_internal, which pulls in to many dependencies. + /// # struct MinimalPlugins; + /// # impl PluginGroup for MinimalPlugins { + /// # fn build(&mut self, group: &mut PluginGroupBuilder){;} + /// # } + /// # + /// App::new() + /// .add_plugins(MinimalPlugins); + /// ``` + pub fn add_plugins(&mut self, mut group: T) -> &mut Self { + let mut plugin_group_builder = PluginGroupBuilder::default(); + group.build(&mut plugin_group_builder); + plugin_group_builder.finish(self); + self + } + + /// Adds a group of plugins with an initializer method + /// + /// Can be used to add a group of plugins, where the group is modified + /// before insertion into Bevy application. For example, you can add + /// extra plugins at a specific place in the plugin group, or deactivate + /// specific plugins while keeping the rest. + /// + /// ## Example + /// ``` + /// # use bevy_app::{prelude::*, PluginGroupBuilder}; + /// # + /// # // Dummies created to avoid using bevy_internal which pulls in to many dependencies. + /// # struct DefaultPlugins; + /// # impl PluginGroup for DefaultPlugins { + /// # fn build(&mut self, group: &mut PluginGroupBuilder){ + /// # group.add(bevy_log::LogPlugin::default()); + /// # } + /// # } + /// # + /// # struct MyOwnPlugin; + /// # impl Plugin for MyOwnPlugin { + /// # fn build(&self, app: &mut AppBuilder){;} + /// # } + /// # + /// App::new() + /// .add_plugins_with(DefaultPlugins, |group| { + /// group.add_before::(MyOwnPlugin) + /// }); + /// ``` + pub fn add_plugins_with(&mut self, mut group: T, func: F) -> &mut Self + where + T: PluginGroup, + F: FnOnce(&mut PluginGroupBuilder) -> &mut PluginGroupBuilder, + { + let mut plugin_group_builder = PluginGroupBuilder::default(); + group.build(&mut plugin_group_builder); + func(&mut plugin_group_builder); + plugin_group_builder.finish(self); + self + } + + /// Registers a new component using the given [ComponentDescriptor]. Components do not need to + /// be manually registered. This just provides a way to override default configuration. + /// Attempting to register a component with a type that has already been used by [World] + /// will result in an error. + /// + /// See [World::register_component] + pub fn register_component(&mut self, descriptor: ComponentDescriptor) -> &mut Self { + self.world.register_component(descriptor).unwrap(); + self + } + + #[cfg(feature = "bevy_reflect")] + pub fn register_type(&mut self) -> &mut Self { + { + let registry = self + .world + .get_resource_mut::() + .unwrap(); + registry.write().register::(); + } + self + } + + pub fn add_sub_app( + &mut self, + app: App, + f: impl Fn(&mut World, &mut App) + 'static, + ) -> &mut Self { + self.sub_apps.push(SubApp { + app, + runner: Box::new(f), + }); + self + } + + // TODO: use labels instead of indices + pub fn sub_app_mut(&mut self, index: usize) -> &mut App { + &mut self.sub_apps[index].app + } +} + +fn run_once(mut app: App) { + app.update(); } /// An event that indicates the app should exit. This will fully exit the app process. diff --git a/crates/bevy_app/src/app_builder.rs b/crates/bevy_app/src/app_builder.rs deleted file mode 100644 index 7c454cd704..0000000000 --- a/crates/bevy_app/src/app_builder.rs +++ /dev/null @@ -1,559 +0,0 @@ -use crate::{ - app::{App, AppExit}, - plugin::Plugin, - CoreStage, PluginGroup, PluginGroupBuilder, StartupStage, -}; -use bevy_ecs::{ - component::{Component, ComponentDescriptor}, - event::Events, - schedule::{ - IntoSystemDescriptor, RunOnce, Schedule, Stage, StageLabel, State, SystemSet, SystemStage, - }, - system::{IntoExclusiveSystem, IntoSystem}, - world::{FromWorld, World}, -}; -use bevy_utils::tracing::debug; -use std::{fmt::Debug, hash::Hash}; - -/// Configure [App]s using the builder pattern -pub struct AppBuilder { - pub app: App, -} - -impl Default for AppBuilder { - fn default() -> Self { - let mut app_builder = AppBuilder { - app: App::default(), - }; - - #[cfg(feature = "bevy_reflect")] - app_builder.init_resource::(); - - app_builder - .add_default_stages() - .add_event::() - .add_system_to_stage(CoreStage::Last, World::clear_trackers.exclusive_system()); - - #[cfg(feature = "bevy_ci_testing")] - { - crate::ci_testing::setup_app(&mut app_builder); - } - app_builder - } -} - -impl AppBuilder { - pub fn empty() -> AppBuilder { - AppBuilder { - app: App::default(), - } - } - - /// Start the application (through main runner) - /// - /// Runs the application main loop. - /// - /// Usually the main loop is handled by Bevy integrated plugins (`winit`), but - /// but one can also set the runner function through [`AppBuilder::set_runner`]. - /// - /// ## Example - /// ``` - /// # use bevy_app::prelude::*; - /// # - /// App::build() - /// // all required plugin insertions, systems, etc inserted here - /// // finally, call: - /// .run(); - /// ``` - pub fn run(&mut self) { - let app = std::mem::take(&mut self.app); - app.run(); - } - - pub fn world(&mut self) -> &World { - &self.app.world - } - - pub fn world_mut(&mut self) -> &mut World { - &mut self.app.world - } - - pub fn set_world(&mut self, world: World) -> &mut Self { - self.app.world = world; - self - } - - pub fn add_stage(&mut self, label: impl StageLabel, stage: S) -> &mut Self { - self.app.schedule.add_stage(label, stage); - self - } - - pub fn add_stage_after( - &mut self, - target: impl StageLabel, - label: impl StageLabel, - stage: S, - ) -> &mut Self { - self.app.schedule.add_stage_after(target, label, stage); - self - } - - pub fn add_stage_before( - &mut self, - target: impl StageLabel, - label: impl StageLabel, - stage: S, - ) -> &mut Self { - self.app.schedule.add_stage_before(target, label, stage); - self - } - - pub fn add_startup_stage(&mut self, label: impl StageLabel, stage: S) -> &mut Self { - self.app - .schedule - .stage(CoreStage::Startup, |schedule: &mut Schedule| { - schedule.add_stage(label, stage) - }); - self - } - - pub fn add_startup_stage_after( - &mut self, - target: impl StageLabel, - label: impl StageLabel, - stage: S, - ) -> &mut Self { - self.app - .schedule - .stage(CoreStage::Startup, |schedule: &mut Schedule| { - schedule.add_stage_after(target, label, stage) - }); - self - } - - pub fn add_startup_stage_before( - &mut self, - target: impl StageLabel, - label: impl StageLabel, - stage: S, - ) -> &mut Self { - self.app - .schedule - .stage(CoreStage::Startup, |schedule: &mut Schedule| { - schedule.add_stage_before(target, label, stage) - }); - self - } - - pub fn stage &mut T>( - &mut self, - label: impl StageLabel, - func: F, - ) -> &mut Self { - self.app.schedule.stage(label, func); - self - } - - /// Adds a system that runs every time `app.update()` is called by the runner - /// - /// Systems are the main building block in the Bevy ECS app model. You can define - /// normal rust functions, and call `.system()` to make them be Bevy systems. - /// - /// System functions can have parameters, through which one can query and - /// mutate Bevy ECS states. - /// See [The Bevy Book](https://bevyengine.org/learn/book/introduction/) for more information. - /// - /// Systems are run in parallel, and the execution order is not deterministic. - /// If you want more fine-grained control for order, see [`AppBuilder::add_system_to_stage`]. - /// - /// For adding a system that runs only at app startup, see [`AppBuilder::add_startup_system`]. - /// - /// ## Example - /// ``` - /// # use bevy_app::prelude::*; - /// # use bevy_ecs::prelude::*; - /// # - /// fn my_system(_commands: Commands) { - /// println!("My system, triggered once per frame"); - /// } - /// - /// App::build() - /// .add_system(my_system.system()); - /// ``` - pub fn add_system(&mut self, system: impl IntoSystemDescriptor) -> &mut Self { - self.add_system_to_stage(CoreStage::Update, system) - } - - pub fn add_system_set(&mut self, system_set: SystemSet) -> &mut Self { - self.add_system_set_to_stage(CoreStage::Update, system_set) - } - - pub fn add_system_to_stage( - &mut self, - stage_label: impl StageLabel, - system: impl IntoSystemDescriptor, - ) -> &mut Self { - self.app.schedule.add_system_to_stage(stage_label, system); - self - } - - pub fn add_system_set_to_stage( - &mut self, - stage_label: impl StageLabel, - system_set: SystemSet, - ) -> &mut Self { - self.app - .schedule - .add_system_set_to_stage(stage_label, system_set); - self - } - - /// Adds a system that is run once at application startup - /// - /// Startup systems run exactly once BEFORE all other systems. These are generally used for - /// app initialization code (ex: adding entities and resources). - /// - /// * For adding a system that runs for every frame, see [`AppBuilder::add_system`]. - /// * For adding a system to specific stage, see [`AppBuilder::add_system_to_stage`]. - /// - /// ## Example - /// ``` - /// # use bevy_app::prelude::*; - /// # use bevy_ecs::prelude::*; - /// # - /// fn my_startup_system(_commands: Commands) { - /// println!("My startup system"); - /// } - /// - /// App::build() - /// .add_startup_system(my_startup_system.system()); - /// ``` - pub fn add_startup_system( - &mut self, - system: impl IntoSystemDescriptor, - ) -> &mut Self { - self.add_startup_system_to_stage(StartupStage::Startup, system) - } - - pub fn add_startup_system_set(&mut self, system_set: SystemSet) -> &mut Self { - self.add_startup_system_set_to_stage(StartupStage::Startup, system_set) - } - - pub fn add_startup_system_to_stage( - &mut self, - stage_label: impl StageLabel, - system: impl IntoSystemDescriptor, - ) -> &mut Self { - self.app - .schedule - .stage(CoreStage::Startup, |schedule: &mut Schedule| { - schedule.add_system_to_stage(stage_label, system) - }); - self - } - - pub fn add_startup_system_set_to_stage( - &mut self, - stage_label: impl StageLabel, - system_set: SystemSet, - ) -> &mut Self { - self.app - .schedule - .stage(CoreStage::Startup, |schedule: &mut Schedule| { - schedule.add_system_set_to_stage(stage_label, system_set) - }); - self - } - - /// Adds a new [State] with the given `initial` value. - /// This inserts a new `State` resource and adds a new "driver" to [CoreStage::Update]. - /// Each stage that uses `State` for system run criteria needs a driver. If you need to use - /// your state in a different stage, consider using [Self::add_state_to_stage] or manually - /// adding [State::get_driver] to additional stages you need it in. - pub fn add_state(&mut self, initial: T) -> &mut Self - where - T: Component + Debug + Clone + Eq + Hash, - { - self.add_state_to_stage(CoreStage::Update, initial) - } - - /// Adds a new [State] with the given `initial` value. - /// This inserts a new `State` resource and adds a new "driver" to the given stage. - /// Each stage that uses `State` for system run criteria needs a driver. If you need to use - /// your state in more than one stage, consider manually adding [State::get_driver] to the - /// stages you need it in. - pub fn add_state_to_stage(&mut self, stage: impl StageLabel, initial: T) -> &mut Self - where - T: Component + Debug + Clone + Eq + Hash, - { - self.insert_resource(State::new(initial)) - .add_system_set_to_stage(stage, State::::get_driver()) - } - - pub fn add_default_stages(&mut self) -> &mut Self { - self.add_stage(CoreStage::First, SystemStage::parallel()) - .add_stage( - CoreStage::Startup, - Schedule::default() - .with_run_criteria(RunOnce::default()) - .with_stage(StartupStage::PreStartup, SystemStage::parallel()) - .with_stage(StartupStage::Startup, SystemStage::parallel()) - .with_stage(StartupStage::PostStartup, SystemStage::parallel()), - ) - .add_stage(CoreStage::PreUpdate, SystemStage::parallel()) - .add_stage(CoreStage::Update, SystemStage::parallel()) - .add_stage(CoreStage::PostUpdate, SystemStage::parallel()) - .add_stage(CoreStage::Last, SystemStage::parallel()) - } - - /// Setup the application to manage events of type `T`. - /// - /// This is done by adding a `Resource` of type `Events::`, - /// and inserting a `Events::::update_system` system into `CoreStage::First`. - pub fn add_event(&mut self) -> &mut Self - where - T: Component, - { - self.insert_resource(Events::::default()) - .add_system_to_stage(CoreStage::First, Events::::update_system.system()) - } - - /// Inserts a resource to the current [App] and overwrites any resource previously added of the same type. - /// - /// A resource in Bevy represents globally unique data. Resources must be added to Bevy Apps - /// before using them. This happens with [`AppBuilder::insert_resource`]. - /// - /// See also `init_resource` for resources that implement `Default` or [`FromResources`]. - /// - /// ## Example - /// ``` - /// # use bevy_app::prelude::*; - /// # - /// struct MyCounter { - /// counter: usize, - /// } - /// - /// App::build() - /// .insert_resource(MyCounter { counter: 0 }); - /// ``` - pub fn insert_resource(&mut self, resource: T) -> &mut Self - where - T: Component, - { - self.app.world.insert_resource(resource); - self - } - - /// Inserts a non-send resource to the app - /// - /// You usually want to use `insert_resource`, but there are some special cases when a resource must - /// be non-send. - /// - /// ## Example - /// ``` - /// # use bevy_app::prelude::*; - /// # - /// struct MyCounter { - /// counter: usize, - /// } - /// - /// App::build() - /// .insert_non_send_resource(MyCounter { counter: 0 }); - /// ``` - pub fn insert_non_send_resource(&mut self, resource: T) -> &mut Self - where - T: 'static, - { - self.app.world.insert_non_send(resource); - self - } - - /// Initialize a resource in the current [App], if it does not exist yet - /// - /// Adds a resource that implements `Default` or [`FromResources`] trait. - /// If the resource already exists, `init_resource` does nothing. - /// - /// ## Example - /// ``` - /// # use bevy_app::prelude::*; - /// # - /// struct MyCounter { - /// counter: usize, - /// } - /// - /// impl Default for MyCounter { - /// fn default() -> MyCounter { - /// MyCounter { - /// counter: 100 - /// } - /// } - /// } - /// - /// App::build() - /// .init_resource::(); - /// ``` - pub fn init_resource(&mut self) -> &mut Self - where - R: FromWorld + Send + Sync + 'static, - { - // PERF: We could avoid double hashing here, since the `from_resources` call is guaranteed - // not to modify the map. However, we would need to be borrowing resources both - // mutably and immutably, so we would need to be extremely certain this is correct - if !self.world_mut().contains_resource::() { - let resource = R::from_world(self.world_mut()); - self.insert_resource(resource); - } - self - } - - pub fn init_non_send_resource(&mut self) -> &mut Self - where - R: FromWorld + 'static, - { - // See perf comment in init_resource - if self.app.world.get_non_send_resource::().is_none() { - let resource = R::from_world(self.world_mut()); - self.app.world.insert_non_send(resource); - } - self - } - - /// Sets the main runner loop function for this Bevy App - /// - /// Usually the main loop is handled by Bevy integrated plugins ([`WinitPlugin`]), but - /// in some cases one might wish to implement their own main loop. - /// - /// This method sets the main loop function, overwriting a previous runner if any. - /// - /// ## Example - /// ``` - /// # use bevy_app::prelude::*; - /// # - /// fn my_runner(mut app: App) { - /// loop { - /// println!("In main loop"); - /// app.update(); - /// } - /// } - /// - /// App::build() - /// .set_runner(my_runner); - /// ``` - pub fn set_runner(&mut self, run_fn: impl Fn(App) + 'static) -> &mut Self { - self.app.runner = Box::new(run_fn); - self - } - - /// Adds a single plugin - /// - /// One of Bevy's core principles is modularity. All Bevy engine features are implemented - /// as plugins. This includes internal features like the renderer. - /// - /// Bevy also provides a few sets of default plugins. See [`AppBuilder::add_plugins`]. - /// - /// ## Example - /// ``` - /// # use bevy_app::prelude::*; - /// # - /// App::build().add_plugin(bevy_log::LogPlugin::default()); - /// ``` - pub fn add_plugin(&mut self, plugin: T) -> &mut Self - where - T: Plugin, - { - debug!("added plugin: {}", plugin.name()); - plugin.build(self); - self - } - - /// Adds a group of plugins - /// - /// Bevy plugins can be grouped into a set of plugins. Bevy provides - /// built-in PluginGroups that provide core engine functionality. - /// - /// The plugin groups available by default are [`DefaultPlugins`] and [`MinimalPlugins`]. - /// - /// ## Example - /// ``` - /// # use bevy_app::{prelude::*, PluginGroupBuilder}; - /// # - /// # // Dummy created to avoid using bevy_internal, which pulls in to many dependencies. - /// # struct MinimalPlugins; - /// # impl PluginGroup for MinimalPlugins { - /// # fn build(&mut self, group: &mut PluginGroupBuilder){;} - /// # } - /// # - /// App::build() - /// .add_plugins(MinimalPlugins); - /// ``` - pub fn add_plugins(&mut self, mut group: T) -> &mut Self { - let mut plugin_group_builder = PluginGroupBuilder::default(); - group.build(&mut plugin_group_builder); - plugin_group_builder.finish(self); - self - } - - /// Adds a group of plugins with an initializer method - /// - /// Can be used to add a group of plugins, where the group is modified - /// before insertion into Bevy application. For example, you can add - /// extra plugins at a specific place in the plugin group, or deactivate - /// specific plugins while keeping the rest. - /// - /// ## Example - /// ``` - /// # use bevy_app::{prelude::*, PluginGroupBuilder}; - /// # - /// # // Dummies created to avoid using bevy_internal which pulls in to many dependencies. - /// # struct DefaultPlugins; - /// # impl PluginGroup for DefaultPlugins { - /// # fn build(&mut self, group: &mut PluginGroupBuilder){ - /// # group.add(bevy_log::LogPlugin::default()); - /// # } - /// # } - /// # - /// # struct MyOwnPlugin; - /// # impl Plugin for MyOwnPlugin { - /// # fn build(&self, app: &mut AppBuilder){;} - /// # } - /// # - /// App::build() - /// .add_plugins_with(DefaultPlugins, |group| { - /// group.add_before::(MyOwnPlugin) - /// }); - /// ``` - pub fn add_plugins_with(&mut self, mut group: T, func: F) -> &mut Self - where - T: PluginGroup, - F: FnOnce(&mut PluginGroupBuilder) -> &mut PluginGroupBuilder, - { - let mut plugin_group_builder = PluginGroupBuilder::default(); - group.build(&mut plugin_group_builder); - func(&mut plugin_group_builder); - plugin_group_builder.finish(self); - self - } - - /// Registers a new component using the given [ComponentDescriptor]. Components do not need to - /// be manually registered. This just provides a way to override default configuration. - /// Attempting to register a component with a type that has already been used by [World] - /// will result in an error. - /// - /// See [World::register_component] - pub fn register_component(&mut self, descriptor: ComponentDescriptor) -> &mut Self { - self.world_mut().register_component(descriptor).unwrap(); - self - } - - #[cfg(feature = "bevy_reflect")] - pub fn register_type(&mut self) -> &mut Self { - { - let registry = self - .world_mut() - .get_resource_mut::() - .unwrap(); - registry.write().register::(); - } - self - } -} diff --git a/crates/bevy_app/src/lib.rs b/crates/bevy_app/src/lib.rs index e5cd52fd6e..04c42b306f 100644 --- a/crates/bevy_app/src/lib.rs +++ b/crates/bevy_app/src/lib.rs @@ -1,5 +1,4 @@ mod app; -mod app_builder; mod plugin; mod plugin_group; mod schedule_runner; @@ -8,7 +7,6 @@ mod schedule_runner; mod ci_testing; pub use app::*; -pub use app_builder::*; pub use bevy_derive::DynamicPlugin; pub use bevy_ecs::event::*; pub use plugin::*; @@ -18,7 +16,7 @@ pub use schedule_runner::*; pub mod prelude { #[doc(hidden)] pub use crate::{ - app::App, app_builder::AppBuilder, CoreStage, DynamicPlugin, Plugin, PluginGroup, + app::App, CoreStage, DynamicPlugin, Plugin, PluginGroup, StartupStage, }; } diff --git a/crates/bevy_app/src/plugin.rs b/crates/bevy_app/src/plugin.rs index ea5ef0021a..38115af2ce 100644 --- a/crates/bevy_app/src/plugin.rs +++ b/crates/bevy_app/src/plugin.rs @@ -1,12 +1,12 @@ -use crate::AppBuilder; +use crate::App; use std::any::Any; /// A collection of Bevy App logic and configuration /// -/// Plugins use [AppBuilder] to configure an [App](crate::App). When an [App](crate::App) registers +/// Plugins configure an [App](crate::App). When an [App](crate::App) registers /// a plugin, the plugin's [Plugin::build] function is run. pub trait Plugin: Any + Send + Sync { - fn build(&self, app: &mut AppBuilder); + fn build(&self, app: &mut App); fn name(&self) -> &str { std::any::type_name::() } diff --git a/crates/bevy_app/src/plugin_group.rs b/crates/bevy_app/src/plugin_group.rs index 074a2d3083..6bb41483bb 100644 --- a/crates/bevy_app/src/plugin_group.rs +++ b/crates/bevy_app/src/plugin_group.rs @@ -1,4 +1,4 @@ -use crate::{AppBuilder, Plugin}; +use crate::{App, Plugin}; use bevy_utils::{tracing::debug, HashMap}; use std::any::TypeId; @@ -96,7 +96,7 @@ impl PluginGroupBuilder { self } - pub fn finish(self, app: &mut AppBuilder) { + pub fn finish(self, app: &mut App) { for ty in self.order.iter() { if let Some(entry) = self.plugins.get(ty) { if entry.enabled { diff --git a/crates/bevy_app/src/schedule_runner.rs b/crates/bevy_app/src/schedule_runner.rs index 7b27cc43c8..9c80d237e6 100644 --- a/crates/bevy_app/src/schedule_runner.rs +++ b/crates/bevy_app/src/schedule_runner.rs @@ -1,5 +1,8 @@ -use super::{App, AppBuilder}; -use crate::{app::AppExit, plugin::Plugin, ManualEventReader}; +use crate::{ + app::{App, AppExit}, + plugin::Plugin, + ManualEventReader, +}; use bevy_ecs::event::Events; use bevy_utils::{Duration, Instant}; @@ -48,9 +51,9 @@ impl ScheduleRunnerSettings { pub struct ScheduleRunnerPlugin {} impl Plugin for ScheduleRunnerPlugin { - fn build(&self, app: &mut AppBuilder) { + fn build(&self, app: &mut App) { let settings = app - .world_mut() + .world .get_resource_or_insert_with(ScheduleRunnerSettings::default) .to_owned(); app.set_runner(move |mut app: App| { diff --git a/crates/bevy_asset/src/assets.rs b/crates/bevy_asset/src/assets.rs index 299be3e3b9..34da94aa50 100644 --- a/crates/bevy_asset/src/assets.rs +++ b/crates/bevy_asset/src/assets.rs @@ -2,7 +2,7 @@ use crate::{ update_asset_storage_system, Asset, AssetLoader, AssetServer, AssetStage, Handle, HandleId, RefChange, }; -use bevy_app::{AppBuilder, EventWriter, Events}; +use bevy_app::{App, EventWriter, Events}; use bevy_ecs::{ system::{IntoSystem, ResMut}, world::FromWorld, @@ -206,13 +206,13 @@ pub trait AddAsset { T: AssetLoader; } -impl AddAsset for AppBuilder { +impl AddAsset for App { fn add_asset(&mut self) -> &mut Self where T: Asset, { let assets = { - let asset_server = self.world().get_resource::().unwrap(); + let asset_server = self.world.get_resource::().unwrap(); asset_server.register_asset_type::() }; @@ -233,7 +233,7 @@ impl AddAsset for AppBuilder { where T: AssetLoader + FromWorld, { - let result = T::from_world(self.world_mut()); + let result = T::from_world(&mut self.world); self.add_asset_loader(result) } @@ -241,7 +241,7 @@ impl AddAsset for AppBuilder { where T: AssetLoader, { - self.world_mut() + self.world .get_resource_mut::() .expect("AssetServer does not exist. Consider adding it as a resource.") .add_loader(loader); diff --git a/crates/bevy_asset/src/diagnostic/asset_count_diagnostics_plugin.rs b/crates/bevy_asset/src/diagnostic/asset_count_diagnostics_plugin.rs index 4dae5198d8..a915d8fe88 100644 --- a/crates/bevy_asset/src/diagnostic/asset_count_diagnostics_plugin.rs +++ b/crates/bevy_asset/src/diagnostic/asset_count_diagnostics_plugin.rs @@ -17,7 +17,7 @@ impl Default for AssetCountDiagnosticsPlugin { } impl Plugin for AssetCountDiagnosticsPlugin { - fn build(&self, app: &mut AppBuilder) { + fn build(&self, app: &mut App) { app.add_startup_system(Self::setup_system.system()) .add_system(Self::diagnostic_system.system()); } diff --git a/crates/bevy_asset/src/lib.rs b/crates/bevy_asset/src/lib.rs index 62808e38a4..12a3149872 100644 --- a/crates/bevy_asset/src/lib.rs +++ b/crates/bevy_asset/src/lib.rs @@ -26,7 +26,7 @@ pub use io::*; pub use loader::*; pub use path::*; -use bevy_app::{prelude::Plugin, AppBuilder}; +use bevy_app::{prelude::Plugin, App}; use bevy_ecs::{ schedule::{StageLabel, SystemStage}, system::IntoSystem, @@ -61,9 +61,9 @@ impl Default for AssetServerSettings { /// /// This is useful when providing a custom `AssetIo` instance that needs to /// delegate to the default `AssetIo` for the platform. -pub fn create_platform_default_asset_io(app: &mut AppBuilder) -> Box { +pub fn create_platform_default_asset_io(app: &mut App) -> Box { let settings = app - .world_mut() + .world .get_resource_or_insert_with(AssetServerSettings::default); #[cfg(all(not(target_arch = "wasm32"), not(target_os = "android")))] @@ -77,10 +77,10 @@ pub fn create_platform_default_asset_io(app: &mut AppBuilder) -> Box().is_none() { + fn build(&self, app: &mut App) { + if app.world.get_resource::().is_none() { let task_pool = app - .world() + .world .get_resource::() .expect("`IoTaskPool` resource not found.") .0 diff --git a/crates/bevy_audio/src/lib.rs b/crates/bevy_audio/src/lib.rs index eb9f148460..5f44d68f9f 100644 --- a/crates/bevy_audio/src/lib.rs +++ b/crates/bevy_audio/src/lib.rs @@ -20,7 +20,7 @@ use bevy_ecs::system::IntoExclusiveSystem; pub struct AudioPlugin; impl Plugin for AudioPlugin { - fn build(&self, app: &mut AppBuilder) { + fn build(&self, app: &mut App) { app.init_non_send_resource::>() .add_asset::() .init_resource::>() diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs index 75fd87adb5..50ab218cd6 100644 --- a/crates/bevy_core/src/lib.rs +++ b/crates/bevy_core/src/lib.rs @@ -38,13 +38,13 @@ pub enum CoreSystem { } impl Plugin for CorePlugin { - fn build(&self, app: &mut AppBuilder) { + fn build(&self, app: &mut App) { // Setup the default bevy task pools - app.world_mut() + app.world .get_resource::() .cloned() .unwrap_or_else(DefaultTaskPoolOptions::default) - .create_default_pools(app.world_mut()); + .create_default_pools(&mut app.world); app.init_resource::