mirror of
https://github.com/bevyengine/bevy
synced 2024-11-29 16:10:19 +00:00
01aedc8431
# Objective Now that we can consolidate Bundles and Components under a single insert (thanks to #2975 and #6039), almost 100% of world spawns now look like `world.spawn().insert((Some, Tuple, Here))`. Spawning an entity without any components is an extremely uncommon pattern, so it makes sense to give spawn the "first class" ergonomic api. This consolidated api should be made consistent across all spawn apis (such as World and Commands). ## Solution All `spawn` apis (`World::spawn`, `Commands:;spawn`, `ChildBuilder::spawn`, and `WorldChildBuilder::spawn`) now accept a bundle as input: ```rust // before: commands .spawn() .insert((A, B, C)); world .spawn() .insert((A, B, C); // after commands.spawn((A, B, C)); world.spawn((A, B, C)); ``` All existing instances of `spawn_bundle` have been deprecated in favor of the new `spawn` api. A new `spawn_empty` has been added, replacing the old `spawn` api. By allowing `world.spawn(some_bundle)` to replace `world.spawn().insert(some_bundle)`, this opened the door to removing the initial entity allocation in the "empty" archetype / table done in `spawn()` (and subsequent move to the actual archetype in `.insert(some_bundle)`). This improves spawn performance by over 10%:  To take this measurement, I added a new `world_spawn` benchmark. Unfortunately, optimizing `Commands::spawn` is slightly less trivial, as Commands expose the Entity id of spawned entities prior to actually spawning. Doing the optimization would (naively) require assurances that the `spawn(some_bundle)` command is applied before all other commands involving the entity (which would not necessarily be true, if memory serves). Optimizing `Commands::spawn` this way does feel possible, but it will require careful thought (and maybe some additional checks), which deserves its own PR. For now, it has the same performance characteristics of the current `Commands::spawn_bundle` on main. **Note that 99% of this PR is simple renames and refactors. The only code that needs careful scrutiny is the new `World::spawn()` impl, which is relatively straightforward, but it has some new unsafe code (which re-uses battle tested BundlerSpawner code path).** --- ## Changelog - All `spawn` apis (`World::spawn`, `Commands:;spawn`, `ChildBuilder::spawn`, and `WorldChildBuilder::spawn`) now accept a bundle as input - All instances of `spawn_bundle` have been deprecated in favor of the new `spawn` api - World and Commands now have `spawn_empty()`, which is equivalent to the old `spawn()` behavior. ## Migration Guide ```rust // Old (0.8): commands .spawn() .insert_bundle((A, B, C)); // New (0.9) commands.spawn((A, B, C)); // Old (0.8): commands.spawn_bundle((A, B, C)); // New (0.9) commands.spawn((A, B, C)); // Old (0.8): let entity = commands.spawn().id(); // New (0.9) let entity = commands.spawn_empty().id(); // Old (0.8) let entity = world.spawn().id(); // New (0.9) let entity = world.spawn_empty(); ```
92 lines
4.1 KiB
Markdown
92 lines
4.1 KiB
Markdown
# B0003
|
|
|
|
As commands are executed asynchronously, it is possible to issue a command on an entity that will no longer exist at the time of the command execution.
|
|
|
|
Erroneous code example:
|
|
|
|
```rust,should_panic
|
|
use bevy::prelude::*;
|
|
|
|
fn main() {
|
|
App::new()
|
|
.add_plugins(DefaultPlugins)
|
|
.add_startup_system(setup)
|
|
.add_system(despawning)
|
|
.add_system(use_entity.after(despawning))
|
|
.run();
|
|
}
|
|
|
|
#[derive(Resource)]
|
|
struct MyEntity(Entity);
|
|
|
|
#[derive(Component)]
|
|
struct Hello;
|
|
|
|
fn setup(mut commands: Commands) {
|
|
let entity = commands.spawn_empty().id();
|
|
commands.insert_resource(MyEntity(entity));
|
|
}
|
|
|
|
fn despawning(mut commands: Commands, entity: Option<Res<MyEntity>>) {
|
|
if let Some(my_entity) = entity {
|
|
commands.entity(my_entity.0).despawn();
|
|
commands.remove_resource::<MyEntity>();
|
|
}
|
|
}
|
|
|
|
fn use_entity(mut commands: Commands, entity: Option<Res<MyEntity>>) {
|
|
if let Some(my_entity) = entity {
|
|
commands.entity(my_entity.0).insert(Hello);
|
|
}
|
|
}
|
|
```
|
|
|
|
This will panic, as system `use_entity` is executed after system `despawning`. Without the system ordering specified here, the ordering would be random and this code would panic half the time.
|
|
|
|
The default panic message is telling you the entity id (`0v0`) and the command that failed (adding a component `Hello`):
|
|
|
|
```text
|
|
thread 'main' panicked at 'error[B0003]: Could not add a component (of type `use_entity_after_despawn::Hello`) to entity 0v0 because it doesn't exist in this World.', /bevy/crates/bevy_ecs/src/system/commands/mod.rs:752:13
|
|
```
|
|
|
|
But you don't know which system tried to add a component, and which system despawned the entity.
|
|
|
|
To get the system that created the command that panics, you can enable the `trace` feature of Bevy. This will add a panic handler that will print more informations:
|
|
|
|
```text
|
|
0: bevy_ecs::schedule::stage::system_commands
|
|
with name="use_entity_after_despawn::use_entity"
|
|
at crates/bevy_ecs/src/schedule/stage.rs:880
|
|
1: bevy_ecs::schedule::stage
|
|
with name=Update
|
|
at crates/bevy_ecs/src/schedule/mod.rs:337
|
|
2: bevy_app::app::frame
|
|
at crates/bevy_app/src/app.rs:113
|
|
3: bevy_app::app::bevy_app
|
|
at crates/bevy_app/src/app.rs:126
|
|
thread 'main' panicked at 'error[B0003]: Could not add a component (of type `use_entity_after_despawn::Hello`) to entity 0v0 because it doesn't exist in this World.', /bevy/crates/bevy_ecs/src/system/commands/mod.rs:752:13
|
|
```
|
|
|
|
From the first two lines, you now know that it panics while executing a command from the system `use_entity`.
|
|
|
|
To get the system that created the despawn command, you can enable DEBUG logs for crate `bevy_ecs`, for example by setting the environment variable `RUST_LOG=bevy_ecs=debug`. This will log:
|
|
|
|
```text
|
|
DEBUG stage{name=Update}:system_commands{name="use_entity_after_despawn::despawning"}: bevy_ecs::world: Despawning entity 0v0
|
|
thread 'main' panicked at 'error[B0003]: Could not add a component (of type `use_entity_after_despawn::Hello`) to entity 0v0 because it doesn't exist in this World.', /bevy/crates/bevy_ecs/src/system/commands/mod.rs:752:13
|
|
```
|
|
|
|
From the first line, you know the entity `0v0` was despawned when executing a command from system `despawning`. In a real case, you could have many log lines, you will need to search for the exact entity from the panic message.
|
|
|
|
Combining those two, you should get enough informations to understand why this panic is happening and how to fix it:
|
|
|
|
```text
|
|
DEBUG stage{name=Update}:system_commands{name="use_entity_after_despawn::despawning"}: bevy_ecs::world: Despawning entity 0v0
|
|
0: bevy_ecs::schedule::stage::system_commands
|
|
with name="use_entity_after_despawn::use_entity"
|
|
at crates/bevy_ecs/src/schedule/stage.rs:880
|
|
1: bevy_ecs::schedule::stage
|
|
with name=Update
|
|
at crates/bevy_ecs/src/schedule/mod.rs:337
|
|
thread 'main' panicked at 'error[B0003]: Could not add a component (of type `use_entity_after_despawn::Hello`) to entity 0v0 because it doesn't exist in this World.', /bevy/crates/bevy_ecs/src/system/commands/mod.rs:752:13
|
|
```
|