2020-10-18 20:48:15 +00:00
use anyhow ::Result ;
Bevy ECS V2 (#1525)
# Bevy ECS V2
This is a rewrite of Bevy ECS (basically everything but the new executor/schedule, which are already awesome). The overall goal was to improve the performance and versatility of Bevy ECS. Here is a quick bulleted list of changes before we dive into the details:
* Complete World rewrite
* Multiple component storage types:
* Tables: fast cache friendly iteration, slower add/removes (previously called Archetypes)
* Sparse Sets: fast add/remove, slower iteration
* Stateful Queries (caches query results for faster iteration. fragmented iteration is _fast_ now)
* Stateful System Params (caches expensive operations. inspired by @DJMcNab's work in #1364)
* Configurable System Params (users can set configuration when they construct their systems. once again inspired by @DJMcNab's work)
* Archetypes are now "just metadata", component storage is separate
* Archetype Graph (for faster archetype changes)
* Component Metadata
* Configure component storage type
* Retrieve information about component size/type/name/layout/send-ness/etc
* Components are uniquely identified by a densely packed ComponentId
* TypeIds are now totally optional (which should make implementing scripting easier)
* Super fast "for_each" query iterators
* Merged Resources into World. Resources are now just a special type of component
* EntityRef/EntityMut builder apis (more efficient and more ergonomic)
* Fast bitset-backed `Access<T>` replaces old hashmap-based approach everywhere
* Query conflicts are determined by component access instead of archetype component access (to avoid random failures at runtime)
* With/Without are still taken into account for conflicts, so this should still be comfy to use
* Much simpler `IntoSystem` impl
* Significantly reduced the amount of hashing throughout the ecs in favor of Sparse Sets (indexed by densely packed ArchetypeId, ComponentId, BundleId, and TableId)
* Safety Improvements
* Entity reservation uses a normal world reference instead of unsafe transmute
* QuerySets no longer transmute lifetimes
* Made traits "unsafe" where relevant
* More thorough safety docs
* WorldCell
* Exposes safe mutable access to multiple resources at a time in a World
* Replaced "catch all" `System::update_archetypes(world: &World)` with `System::new_archetype(archetype: &Archetype)`
* Simpler Bundle implementation
* Replaced slow "remove_bundle_one_by_one" used as fallback for Commands::remove_bundle with fast "remove_bundle_intersection"
* Removed `Mut<T>` query impl. it is better to only support one way: `&mut T`
* Removed with() from `Flags<T>` in favor of `Option<Flags<T>>`, which allows querying for flags to be "filtered" by default
* Components now have is_send property (currently only resources support non-send)
* More granular module organization
* New `RemovedComponents<T>` SystemParam that replaces `query.removed::<T>()`
* `world.resource_scope()` for mutable access to resources and world at the same time
* WorldQuery and QueryFilter traits unified. FilterFetch trait added to enable "short circuit" filtering. Auto impled for cases that don't need it
* Significantly slimmed down SystemState in favor of individual SystemParam state
* System Commands changed from `commands: &mut Commands` back to `mut commands: Commands` (to allow Commands to have a World reference)
Fixes #1320
## `World` Rewrite
This is a from-scratch rewrite of `World` that fills the niche that `hecs` used to. Yes, this means Bevy ECS is no longer a "fork" of hecs. We're going out our own!
(the only shared code between the projects is the entity id allocator, which is already basically ideal)
A huge shout out to @SanderMertens (author of [flecs](https://github.com/SanderMertens/flecs)) for sharing some great ideas with me (specifically hybrid ecs storage and archetype graphs). He also helped advise on a number of implementation details.
## Component Storage (The Problem)
Two ECS storage paradigms have gained a lot of traction over the years:
* **Archetypal ECS**:
* Stores components in "tables" with static schemas. Each "column" stores components of a given type. Each "row" is an entity.
* Each "archetype" has its own table. Adding/removing an entity's component changes the archetype.
* Enables super-fast Query iteration due to its cache-friendly data layout
* Comes at the cost of more expensive add/remove operations for an Entity's components, because all components need to be copied to the new archetype's "table"
* **Sparse Set ECS**:
* Stores components of the same type in densely packed arrays, which are sparsely indexed by densely packed unsigned integers (Entity ids)
* Query iteration is slower than Archetypal ECS because each entity's component could be at any position in the sparse set. This "random access" pattern isn't cache friendly. Additionally, there is an extra layer of indirection because you must first map the entity id to an index in the component array.
* Adding/removing components is a cheap, constant time operation
Bevy ECS V1, hecs, legion, flec, and Unity DOTS are all "archetypal ecs-es". I personally think "archetypal" storage is a good default for game engines. An entity's archetype doesn't need to change frequently in general, and it creates "fast by default" query iteration (which is a much more common operation). It is also "self optimizing". Users don't need to think about optimizing component layouts for iteration performance. It "just works" without any extra boilerplate.
Shipyard and EnTT are "sparse set ecs-es". They employ "packing" as a way to work around the "suboptimal by default" iteration performance for specific sets of components. This helps, but I didn't think this was a good choice for a general purpose engine like Bevy because:
1. "packs" conflict with each other. If bevy decides to internally pack the Transform and GlobalTransform components, users are then blocked if they want to pack some custom component with Transform.
2. users need to take manual action to optimize
Developers selecting an ECS framework are stuck with a hard choice. Select an "archetypal" framework with "fast iteration everywhere" but without the ability to cheaply add/remove components, or select a "sparse set" framework to cheaply add/remove components but with slower iteration performance.
## Hybrid Component Storage (The Solution)
In Bevy ECS V2, we get to have our cake and eat it too. It now has _both_ of the component storage types above (and more can be added later if needed):
* **Tables** (aka "archetypal" storage)
* The default storage. If you don't configure anything, this is what you get
* Fast iteration by default
* Slower add/remove operations
* **Sparse Sets**
* Opt-in
* Slower iteration
* Faster add/remove operations
These storage types complement each other perfectly. By default Query iteration is fast. If developers know that they want to add/remove a component at high frequencies, they can set the storage to "sparse set":
```rust
world.register_component(
ComponentDescriptor::new::<MyComponent>(StorageType::SparseSet)
).unwrap();
```
## Archetypes
Archetypes are now "just metadata" ... they no longer store components directly. They do store:
* The `ComponentId`s of each of the Archetype's components (and that component's storage type)
* Archetypes are uniquely defined by their component layouts
* For example: entities with "table" components `[A, B, C]` _and_ "sparse set" components `[D, E]` will always be in the same archetype.
* The `TableId` associated with the archetype
* For now each archetype has exactly one table (which can have no components),
* There is a 1->Many relationship from Tables->Archetypes. A given table could have any number of archetype components stored in it:
* Ex: an entity with "table storage" components `[A, B, C]` and "sparse set" components `[D, E]` will share the same `[A, B, C]` table as an entity with `[A, B, C]` table component and `[F]` sparse set components.
* This 1->Many relationship is how we preserve fast "cache friendly" iteration performance when possible (more on this later)
* A list of entities that are in the archetype and the row id of the table they are in
* ArchetypeComponentIds
* unique densely packed identifiers for (ArchetypeId, ComponentId) pairs
* used by the schedule executor for cheap system access control
* "Archetype Graph Edges" (see the next section)
## The "Archetype Graph"
Archetype changes in Bevy (and a number of other archetypal ecs-es) have historically been expensive to compute. First, you need to allocate a new vector of the entity's current component ids, add or remove components based on the operation performed, sort it (to ensure it is order-independent), then hash it to find the archetype (if it exists). And thats all before we get to the _already_ expensive full copy of all components to the new table storage.
The solution is to build a "graph" of archetypes to cache these results. @SanderMertens first exposed me to the idea (and he got it from @gjroelofs, who came up with it). They propose adding directed edges between archetypes for add/remove component operations. If `ComponentId`s are densely packed, you can use sparse sets to cheaply jump between archetypes.
Bevy takes this one step further by using add/remove `Bundle` edges instead of `Component` edges. Bevy encourages the use of `Bundles` to group add/remove operations. This is largely for "clearer game logic" reasons, but it also helps cut down on the number of archetype changes required. `Bundles` now also have densely-packed `BundleId`s. This allows us to use a _single_ edge for each bundle operation (rather than needing to traverse N edges ... one for each component). Single component operations are also bundles, so this is strictly an improvement over a "component only" graph.
As a result, an operation that used to be _heavy_ (both for allocations and compute) is now two dirt-cheap array lookups and zero allocations.
## Stateful Queries
World queries are now stateful. This allows us to:
1. Cache archetype (and table) matches
* This resolves another issue with (naive) archetypal ECS: query performance getting worse as the number of archetypes goes up (and fragmentation occurs).
2. Cache Fetch and Filter state
* The expensive parts of fetch/filter operations (such as hashing the TypeId to find the ComponentId) now only happen once when the Query is first constructed
3. Incrementally build up state
* When new archetypes are added, we only process the new archetypes (no need to rebuild state for old archetypes)
As a result, the direct `World` query api now looks like this:
```rust
let mut query = world.query::<(&A, &mut B)>();
for (a, mut b) in query.iter_mut(&mut world) {
}
```
Requiring `World` to generate stateful queries (rather than letting the `QueryState` type be constructed separately) allows us to ensure that _all_ queries are properly initialized (and the relevant world state, such as ComponentIds). This enables QueryState to remove branches from its operations that check for initialization status (and also enables query.iter() to take an immutable world reference because it doesn't need to initialize anything in world).
However in systems, this is a non-breaking change. State management is done internally by the relevant SystemParam.
## Stateful SystemParams
Like Queries, `SystemParams` now also cache state. For example, `Query` system params store the "stateful query" state mentioned above. Commands store their internal `CommandQueue`. This means you can now safely use as many separate `Commands` parameters in your system as you want. `Local<T>` system params store their `T` value in their state (instead of in Resources).
SystemParam state also enabled a significant slim-down of SystemState. It is much nicer to look at now.
Per-SystemParam state naturally insulates us from an "aliased mut" class of errors we have hit in the past (ex: using multiple `Commands` system params).
(credit goes to @DJMcNab for the initial idea and draft pr here #1364)
## Configurable SystemParams
@DJMcNab also had the great idea to make SystemParams configurable. This allows users to provide some initial configuration / values for system parameters (when possible). Most SystemParams have no config (the config type is `()`), but the `Local<T>` param now supports user-provided parameters:
```rust
fn foo(value: Local<usize>) {
}
app.add_system(foo.system().config(|c| c.0 = Some(10)));
```
## Uber Fast "for_each" Query Iterators
Developers now have the choice to use a fast "for_each" iterator, which yields ~1.5-3x iteration speed improvements for "fragmented iteration", and minor ~1.2x iteration speed improvements for unfragmented iteration.
```rust
fn system(query: Query<(&A, &mut B)>) {
// you now have the option to do this for a speed boost
query.for_each_mut(|(a, mut b)| {
});
// however normal iterators are still available
for (a, mut b) in query.iter_mut() {
}
}
```
I think in most cases we should continue to encourage "normal" iterators as they are more flexible and more "rust idiomatic". But when that extra "oomf" is needed, it makes sense to use `for_each`.
We should also consider using `for_each` for internal bevy systems to give our users a nice speed boost (but that should be a separate pr).
## Component Metadata
`World` now has a `Components` collection, which is accessible via `world.components()`. This stores mappings from `ComponentId` to `ComponentInfo`, as well as `TypeId` to `ComponentId` mappings (where relevant). `ComponentInfo` stores information about the component, such as ComponentId, TypeId, memory layout, send-ness (currently limited to resources), and storage type.
## Significantly Cheaper `Access<T>`
We used to use `TypeAccess<TypeId>` to manage read/write component/archetype-component access. This was expensive because TypeIds must be hashed and compared individually. The parallel executor got around this by "condensing" type ids into bitset-backed access types. This worked, but it had to be re-generated from the `TypeAccess<TypeId>`sources every time archetypes changed.
This pr removes TypeAccess in favor of faster bitset access everywhere. We can do this thanks to the move to densely packed `ComponentId`s and `ArchetypeComponentId`s.
## Merged Resources into World
Resources had a lot of redundant functionality with Components. They stored typed data, they had access control, they had unique ids, they were queryable via SystemParams, etc. In fact the _only_ major difference between them was that they were unique (and didn't correlate to an entity).
Separate resources also had the downside of requiring a separate set of access controls, which meant the parallel executor needed to compare more bitsets per system and manage more state.
I initially got the "separate resources" idea from `legion`. I think that design was motivated by the fact that it made the direct world query/resource lifetime interactions more manageable. It certainly made our lives easier when using Resources alongside hecs/bevy_ecs. However we already have a construct for safely and ergonomically managing in-world lifetimes: systems (which use `Access<T>` internally).
This pr merges Resources into World:
```rust
world.insert_resource(1);
world.insert_resource(2.0);
let a = world.get_resource::<i32>().unwrap();
let mut b = world.get_resource_mut::<f64>().unwrap();
*b = 3.0;
```
Resources are now just a special kind of component. They have their own ComponentIds (and their own resource TypeId->ComponentId scope, so they don't conflict wit components of the same type). They are stored in a special "resource archetype", which stores components inside the archetype using a new `unique_components` sparse set (note that this sparse set could later be used to implement Tags). This allows us to keep the code size small by reusing existing datastructures (namely Column, Archetype, ComponentFlags, and ComponentInfo). This allows us the executor to use a single `Access<ArchetypeComponentId>` per system. It should also make scripting language integration easier.
_But_ this merge did create problems for people directly interacting with `World`. What if you need mutable access to multiple resources at the same time? `world.get_resource_mut()` borrows World mutably!
## WorldCell
WorldCell applies the `Access<ArchetypeComponentId>` concept to direct world access:
```rust
let world_cell = world.cell();
let a = world_cell.get_resource_mut::<i32>().unwrap();
let b = world_cell.get_resource_mut::<f64>().unwrap();
```
This adds cheap runtime checks (a sparse set lookup of `ArchetypeComponentId` and a counter) to ensure that world accesses do not conflict with each other. Each operation returns a `WorldBorrow<'w, T>` or `WorldBorrowMut<'w, T>` wrapper type, which will release the relevant ArchetypeComponentId resources when dropped.
World caches the access sparse set (and only one cell can exist at a time), so `world.cell()` is a cheap operation.
WorldCell does _not_ use atomic operations. It is non-send, does a mutable borrow of world to prevent other accesses, and uses a simple `Rc<RefCell<ArchetypeComponentAccess>>` wrapper in each WorldBorrow pointer.
The api is currently limited to resource access, but it can and should be extended to queries / entity component access.
## Resource Scopes
WorldCell does not yet support component queries, and even when it does there are sometimes legitimate reasons to want a mutable world ref _and_ a mutable resource ref (ex: bevy_render and bevy_scene both need this). In these cases we could always drop down to the unsafe `world.get_resource_unchecked_mut()`, but that is not ideal!
Instead developers can use a "resource scope"
```rust
world.resource_scope(|world: &mut World, a: &mut A| {
})
```
This temporarily removes the `A` resource from `World`, provides mutable pointers to both, and re-adds A to World when finished. Thanks to the move to ComponentIds/sparse sets, this is a cheap operation.
If multiple resources are required, scopes can be nested. We could also consider adding a "resource tuple" to the api if this pattern becomes common and the boilerplate gets nasty.
## Query Conflicts Use ComponentId Instead of ArchetypeComponentId
For safety reasons, systems cannot contain queries that conflict with each other without wrapping them in a QuerySet. On bevy `main`, we use ArchetypeComponentIds to determine conflicts. This is nice because it can take into account filters:
```rust
// these queries will never conflict due to their filters
fn filter_system(a: Query<&mut A, With<B>>, b: Query<&mut B, Without<B>>) {
}
```
But it also has a significant downside:
```rust
// these queries will not conflict _until_ an entity with A, B, and C is spawned
fn maybe_conflicts_system(a: Query<(&mut A, &C)>, b: Query<(&mut A, &B)>) {
}
```
The system above will panic at runtime if an entity with A, B, and C is spawned. This makes it hard to trust that your game logic will run without crashing.
In this pr, I switched to using `ComponentId` instead. This _is_ more constraining. `maybe_conflicts_system` will now always fail, but it will do it consistently at startup. Naively, it would also _disallow_ `filter_system`, which would be a significant downgrade in usability. Bevy has a number of internal systems that rely on disjoint queries and I expect it to be a common pattern in userspace.
To resolve this, I added a new `FilteredAccess<T>` type, which wraps `Access<T>` and adds with/without filters. If two `FilteredAccess` have with/without values that prove they are disjoint, they will no longer conflict.
## EntityRef / EntityMut
World entity operations on `main` require that the user passes in an `entity` id to each operation:
```rust
let entity = world.spawn((A, )); // create a new entity with A
world.get::<A>(entity);
world.insert(entity, (B, C));
world.insert_one(entity, D);
```
This means that each operation needs to look up the entity location / verify its validity. The initial spawn operation also requires a Bundle as input. This can be awkward when no components are required (or one component is required).
These operations have been replaced by `EntityRef` and `EntityMut`, which are "builder-style" wrappers around world that provide read and read/write operations on a single, pre-validated entity:
```rust
// spawn now takes no inputs and returns an EntityMut
let entity = world.spawn()
.insert(A) // insert a single component into the entity
.insert_bundle((B, C)) // insert a bundle of components into the entity
.id() // id returns the Entity id
// Returns EntityMut (or panics if the entity does not exist)
world.entity_mut(entity)
.insert(D)
.insert_bundle(SomeBundle::default());
{
// returns EntityRef (or panics if the entity does not exist)
let d = world.entity(entity)
.get::<D>() // gets the D component
.unwrap();
// world.get still exists for ergonomics
let d = world.get::<D>(entity).unwrap();
}
// These variants return Options if you want to check existence instead of panicing
world.get_entity_mut(entity)
.unwrap()
.insert(E);
if let Some(entity_ref) = world.get_entity(entity) {
let d = entity_ref.get::<D>().unwrap();
}
```
This _does not_ affect the current Commands api or terminology. I think that should be a separate conversation as that is a much larger breaking change.
## Safety Improvements
* Entity reservation in Commands uses a normal world borrow instead of an unsafe transmute
* QuerySets no longer transmutes lifetimes
* Made traits "unsafe" when implementing a trait incorrectly could cause unsafety
* More thorough safety docs
## RemovedComponents SystemParam
The old approach to querying removed components: `query.removed:<T>()` was confusing because it had no connection to the query itself. I replaced it with the following, which is both clearer and allows us to cache the ComponentId mapping in the SystemParamState:
```rust
fn system(removed: RemovedComponents<T>) {
for entity in removed.iter() {
}
}
```
## Simpler Bundle implementation
Bundles are no longer responsible for sorting (or deduping) TypeInfo. They are just a simple ordered list of component types / data. This makes the implementation smaller and opens the door to an easy "nested bundle" implementation in the future (which i might even add in this pr). Duplicate detection is now done once per bundle type by World the first time a bundle is used.
## Unified WorldQuery and QueryFilter types
(don't worry they are still separate type _parameters_ in Queries .. this is a non-breaking change)
WorldQuery and QueryFilter were already basically identical apis. With the addition of `FetchState` and more storage-specific fetch methods, the overlap was even clearer (and the redundancy more painful).
QueryFilters are now just `F: WorldQuery where F::Fetch: FilterFetch`. FilterFetch requires `Fetch<Item = bool>` and adds new "short circuit" variants of fetch methods. This enables a filter tuple like `(With<A>, Without<B>, Changed<C>)` to stop evaluating the filter after the first mismatch is encountered. FilterFetch is automatically implemented for `Fetch` implementations that return bool.
This forces fetch implementations that return things like `(bool, bool, bool)` (such as the filter above) to manually implement FilterFetch and decide whether or not to short-circuit.
## More Granular Modules
World no longer globs all of the internal modules together. It now exports `core`, `system`, and `schedule` separately. I'm also considering exporting `core` submodules directly as that is still pretty "glob-ey" and unorganized (feedback welcome here).
## Remaining Draft Work (to be done in this pr)
* ~~panic on conflicting WorldQuery fetches (&A, &mut A)~~
* ~~bevy `main` and hecs both currently allow this, but we should protect against it if possible~~
* ~~batch_iter / par_iter (currently stubbed out)~~
* ~~ChangedRes~~
* ~~I skipped this while we sort out #1313. This pr should be adapted to account for whatever we land on there~~.
* ~~The `Archetypes` and `Tables` collections use hashes of sorted lists of component ids to uniquely identify each archetype/table. This hash is then used as the key in a HashMap to look up the relevant ArchetypeId or TableId. (which doesn't handle hash collisions properly)~~
* ~~It is currently unsafe to generate a Query from "World A", then use it on "World B" (despite the api claiming it is safe). We should probably close this gap. This could be done by adding a randomly generated WorldId to each world, then storing that id in each Query. They could then be compared to each other on each `query.do_thing(&world)` operation. This _does_ add an extra branch to each query operation, so I'm open to other suggestions if people have them.~~
* ~~Nested Bundles (if i find time)~~
## Potential Future Work
* Expand WorldCell to support queries.
* Consider not allocating in the empty archetype on `world.spawn()`
* ex: return something like EntityMutUninit, which turns into EntityMut after an `insert` or `insert_bundle` op
* this actually regressed performance last time i tried it, but in theory it should be faster
* Optimize SparseSet::insert (see `PERF` comment on insert)
* Replace SparseArray `Option<T>` with T::MAX to cut down on branching
* would enable cheaper get_unchecked() operations
* upstream fixedbitset optimizations
* fixedbitset could be allocation free for small block counts (store blocks in a SmallVec)
* fixedbitset could have a const constructor
* Consider implementing Tags (archetype-specific by-value data that affects archetype identity)
* ex: ArchetypeA could have `[A, B, C]` table components and `[D(1)]` "tag" component. ArchetypeB could have `[A, B, C]` table components and a `[D(2)]` tag component. The archetypes are different, despite both having D tags because the value inside D is different.
* this could potentially build on top of the `archetype.unique_components` added in this pr for resource storage.
* Consider reverting `all_tuples` proc macro in favor of the old `macro_rules` implementation
* all_tuples is more flexible and produces cleaner documentation (the macro_rules version produces weird type parameter orders due to parser constraints)
* but unfortunately all_tuples also appears to make Rust Analyzer sad/slow when working inside of `bevy_ecs` (does not affect user code)
* Consider "resource queries" and/or "mixed resource and entity component queries" as an alternative to WorldCell
* this is basically just "systems" so maybe it's not worth it
* Add more world ops
* `world.clear()`
* `world.reserve<T: Bundle>(count: usize)`
* Try using the old archetype allocation strategy (allocate new memory on resize and copy everything over). I expect this to improve batch insertion performance at the cost of unbatched performance. But thats just a guess. I'm not an allocation perf pro :)
* Adapt Commands apis for consistency with new World apis
## Benchmarks
key:
* `bevy_old`: bevy `main` branch
* `bevy`: this branch
* `_foreach`: uses an optimized for_each iterator
* ` _sparse`: uses sparse set storage (if unspecified assume table storage)
* `_system`: runs inside a system (if unspecified assume test happens via direct world ops)
### Simple Insert (from ecs_bench_suite)
### Simpler Iter (from ecs_bench_suite)
### Fragment Iter (from ecs_bench_suite)
### Sparse Fragmented Iter
Iterate a query that matches 5 entities from a single matching archetype, but there are 100 unmatching archetypes
### Schedule (from ecs_bench_suite)
### Add Remove Component (from ecs_bench_suite)
### Add Remove Component Big
Same as the test above, but each entity has 5 "large" matrix components and 1 "large" matrix component is added and removed
### Get Component
Looks up a single component value a large number of times
2021-03-05 07:54:35 +00:00
use bevy_asset ::{
AssetIoError , AssetLoader , AssetPath , BoxedFuture , Handle , LoadContext , LoadedAsset ,
} ;
2021-01-01 21:30:18 +00:00
use bevy_core ::Name ;
Camera Driven Rendering (#4745)
This adds "high level camera driven rendering" to Bevy. The goal is to give users more control over what gets rendered (and where) without needing to deal with render logic. This will make scenarios like "render to texture", "multiple windows", "split screen", "2d on 3d", "3d on 2d", "pass layering", and more significantly easier.
Here is an [example of a 2d render sandwiched between two 3d renders (each from a different perspective)](https://gist.github.com/cart/4fe56874b2e53bc5594a182fc76f4915):
Users can now spawn a camera, point it at a RenderTarget (a texture or a window), and it will "just work".
Rendering to a second window is as simple as spawning a second camera and assigning it to a specific window id:
```rust
// main camera (main window)
commands.spawn_bundle(Camera2dBundle::default());
// second camera (other window)
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Window(window_id),
..default()
},
..default()
});
```
Rendering to a texture is as simple as pointing the camera at a texture:
```rust
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Texture(image_handle),
..default()
},
..default()
});
```
Cameras now have a "render priority", which controls the order they are drawn in. If you want to use a camera's output texture as a texture in the main pass, just set the priority to a number lower than the main pass camera (which defaults to `0`).
```rust
// main pass camera with a default priority of 0
commands.spawn_bundle(Camera2dBundle::default());
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Texture(image_handle.clone()),
priority: -1,
..default()
},
..default()
});
commands.spawn_bundle(SpriteBundle {
texture: image_handle,
..default()
})
```
Priority can also be used to layer to cameras on top of each other for the same RenderTarget. This is what "2d on top of 3d" looks like in the new system:
```rust
commands.spawn_bundle(Camera3dBundle::default());
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
// this will render 2d entities "on top" of the default 3d camera's render
priority: 1,
..default()
},
..default()
});
```
There is no longer the concept of a global "active camera". Resources like `ActiveCamera<Camera2d>` and `ActiveCamera<Camera3d>` have been replaced with the camera-specific `Camera::is_active` field. This does put the onus on users to manage which cameras should be active.
Cameras are now assigned a single render graph as an "entry point", which is configured on each camera entity using the new `CameraRenderGraph` component. The old `PerspectiveCameraBundle` and `OrthographicCameraBundle` (generic on camera marker components like Camera2d and Camera3d) have been replaced by `Camera3dBundle` and `Camera2dBundle`, which set 3d and 2d default values for the `CameraRenderGraph` and projections.
```rust
// old 3d perspective camera
commands.spawn_bundle(PerspectiveCameraBundle::default())
// new 3d perspective camera
commands.spawn_bundle(Camera3dBundle::default())
```
```rust
// old 2d orthographic camera
commands.spawn_bundle(OrthographicCameraBundle::new_2d())
// new 2d orthographic camera
commands.spawn_bundle(Camera2dBundle::default())
```
```rust
// old 3d orthographic camera
commands.spawn_bundle(OrthographicCameraBundle::new_3d())
// new 3d orthographic camera
commands.spawn_bundle(Camera3dBundle {
projection: OrthographicProjection {
scale: 3.0,
scaling_mode: ScalingMode::FixedVertical,
..default()
}.into(),
..default()
})
```
Note that `Camera3dBundle` now uses a new `Projection` enum instead of hard coding the projection into the type. There are a number of motivators for this change: the render graph is now a part of the bundle, the way "generic bundles" work in the rust type system prevents nice `..default()` syntax, and changing projections at runtime is much easier with an enum (ex for editor scenarios). I'm open to discussing this choice, but I'm relatively certain we will all come to the same conclusion here. Camera2dBundle and Camera3dBundle are much clearer than being generic on marker components / using non-default constructors.
If you want to run a custom render graph on a camera, just set the `CameraRenderGraph` component:
```rust
commands.spawn_bundle(Camera3dBundle {
camera_render_graph: CameraRenderGraph::new(some_render_graph_name),
..default()
})
```
Just note that if the graph requires data from specific components to work (such as `Camera3d` config, which is provided in the `Camera3dBundle`), make sure the relevant components have been added.
Speaking of using components to configure graphs / passes, there are a number of new configuration options:
```rust
commands.spawn_bundle(Camera3dBundle {
camera_3d: Camera3d {
// overrides the default global clear color
clear_color: ClearColorConfig::Custom(Color::RED),
..default()
},
..default()
})
commands.spawn_bundle(Camera3dBundle {
camera_3d: Camera3d {
// disables clearing
clear_color: ClearColorConfig::None,
..default()
},
..default()
})
```
Expect to see more of the "graph configuration Components on Cameras" pattern in the future.
By popular demand, UI no longer requires a dedicated camera. `UiCameraBundle` has been removed. `Camera2dBundle` and `Camera3dBundle` now both default to rendering UI as part of their own render graphs. To disable UI rendering for a camera, disable it using the CameraUi component:
```rust
commands
.spawn_bundle(Camera3dBundle::default())
.insert(CameraUi {
is_enabled: false,
..default()
})
```
## Other Changes
* The separate clear pass has been removed. We should revisit this for things like sky rendering, but I think this PR should "keep it simple" until we're ready to properly support that (for code complexity and performance reasons). We can come up with the right design for a modular clear pass in a followup pr.
* I reorganized bevy_core_pipeline into Core2dPlugin and Core3dPlugin (and core_2d / core_3d modules). Everything is pretty much the same as before, just logically separate. I've moved relevant types (like Camera2d, Camera3d, Camera3dBundle, Camera2dBundle) into their relevant modules, which is what motivated this reorganization.
* I adapted the `scene_viewer` example (which relied on the ActiveCameras behavior) to the new system. I also refactored bits and pieces to be a bit simpler.
* All of the examples have been ported to the new camera approach. `render_to_texture` and `multiple_windows` are now _much_ simpler. I removed `two_passes` because it is less relevant with the new approach. If someone wants to add a new "layered custom pass with CameraRenderGraph" example, that might fill a similar niche. But I don't feel much pressure to add that in this pr.
* Cameras now have `target_logical_size` and `target_physical_size` fields, which makes finding the size of a camera's render target _much_ simpler. As a result, the `Assets<Image>` and `Windows` parameters were removed from `Camera::world_to_screen`, making that operation much more ergonomic.
* Render order ambiguities between cameras with the same target and the same priority now produce a warning. This accomplishes two goals:
1. Now that there is no "global" active camera, by default spawning two cameras will result in two renders (one covering the other). This would be a silent performance killer that would be hard to detect after the fact. By detecting ambiguities, we can provide a helpful warning when this occurs.
2. Render order ambiguities could result in unexpected / unpredictable render results. Resolving them makes sense.
## Follow Up Work
* Per-Camera viewports, which will make it possible to render to a smaller area inside of a RenderTarget (great for something like splitscreen)
* Camera-specific MSAA config (should use the same "overriding" pattern used for ClearColor)
* Graph Based Camera Ordering: priorities are simple, but they make complicated ordering constraints harder to express. We should consider adopting a "graph based" camera ordering model with "before" and "after" relationships to other cameras (or build it "on top" of the priority system).
* Consider allowing graphs to run subgraphs from any nest level (aka a global namespace for graphs). Right now the 2d and 3d graphs each need their own UI subgraph, which feels "fine" in the short term. But being able to share subgraphs between other subgraphs seems valuable.
* Consider splitting `bevy_core_pipeline` into `bevy_core_2d` and `bevy_core_3d` packages. Theres a shared "clear color" dependency here, which would need a new home.
2022-06-02 00:12:17 +00:00
use bevy_core_pipeline ::prelude ::Camera3d ;
2022-03-29 18:31:13 +00:00
use bevy_ecs ::{ entity ::Entity , prelude ::FromWorld , world ::World } ;
2022-03-15 01:54:05 +00:00
use bevy_hierarchy ::{ BuildWorldChildren , WorldChildBuilder } ;
2021-06-08 02:46:44 +00:00
use bevy_log ::warn ;
2022-05-10 20:01:55 +00:00
use bevy_math ::{ Mat4 , Vec3 } ;
2022-01-03 07:59:25 +00:00
use bevy_pbr ::{
AlphaMode , DirectionalLight , DirectionalLightBundle , PbrBundle , PointLight , PointLightBundle ,
StandardMaterial ,
} ;
2020-05-15 23:55:44 +00:00
use bevy_render ::{
2020-11-07 01:08:15 +00:00
camera ::{
Camera Driven Rendering (#4745)
This adds "high level camera driven rendering" to Bevy. The goal is to give users more control over what gets rendered (and where) without needing to deal with render logic. This will make scenarios like "render to texture", "multiple windows", "split screen", "2d on 3d", "3d on 2d", "pass layering", and more significantly easier.
Here is an [example of a 2d render sandwiched between two 3d renders (each from a different perspective)](https://gist.github.com/cart/4fe56874b2e53bc5594a182fc76f4915):
Users can now spawn a camera, point it at a RenderTarget (a texture or a window), and it will "just work".
Rendering to a second window is as simple as spawning a second camera and assigning it to a specific window id:
```rust
// main camera (main window)
commands.spawn_bundle(Camera2dBundle::default());
// second camera (other window)
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Window(window_id),
..default()
},
..default()
});
```
Rendering to a texture is as simple as pointing the camera at a texture:
```rust
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Texture(image_handle),
..default()
},
..default()
});
```
Cameras now have a "render priority", which controls the order they are drawn in. If you want to use a camera's output texture as a texture in the main pass, just set the priority to a number lower than the main pass camera (which defaults to `0`).
```rust
// main pass camera with a default priority of 0
commands.spawn_bundle(Camera2dBundle::default());
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Texture(image_handle.clone()),
priority: -1,
..default()
},
..default()
});
commands.spawn_bundle(SpriteBundle {
texture: image_handle,
..default()
})
```
Priority can also be used to layer to cameras on top of each other for the same RenderTarget. This is what "2d on top of 3d" looks like in the new system:
```rust
commands.spawn_bundle(Camera3dBundle::default());
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
// this will render 2d entities "on top" of the default 3d camera's render
priority: 1,
..default()
},
..default()
});
```
There is no longer the concept of a global "active camera". Resources like `ActiveCamera<Camera2d>` and `ActiveCamera<Camera3d>` have been replaced with the camera-specific `Camera::is_active` field. This does put the onus on users to manage which cameras should be active.
Cameras are now assigned a single render graph as an "entry point", which is configured on each camera entity using the new `CameraRenderGraph` component. The old `PerspectiveCameraBundle` and `OrthographicCameraBundle` (generic on camera marker components like Camera2d and Camera3d) have been replaced by `Camera3dBundle` and `Camera2dBundle`, which set 3d and 2d default values for the `CameraRenderGraph` and projections.
```rust
// old 3d perspective camera
commands.spawn_bundle(PerspectiveCameraBundle::default())
// new 3d perspective camera
commands.spawn_bundle(Camera3dBundle::default())
```
```rust
// old 2d orthographic camera
commands.spawn_bundle(OrthographicCameraBundle::new_2d())
// new 2d orthographic camera
commands.spawn_bundle(Camera2dBundle::default())
```
```rust
// old 3d orthographic camera
commands.spawn_bundle(OrthographicCameraBundle::new_3d())
// new 3d orthographic camera
commands.spawn_bundle(Camera3dBundle {
projection: OrthographicProjection {
scale: 3.0,
scaling_mode: ScalingMode::FixedVertical,
..default()
}.into(),
..default()
})
```
Note that `Camera3dBundle` now uses a new `Projection` enum instead of hard coding the projection into the type. There are a number of motivators for this change: the render graph is now a part of the bundle, the way "generic bundles" work in the rust type system prevents nice `..default()` syntax, and changing projections at runtime is much easier with an enum (ex for editor scenarios). I'm open to discussing this choice, but I'm relatively certain we will all come to the same conclusion here. Camera2dBundle and Camera3dBundle are much clearer than being generic on marker components / using non-default constructors.
If you want to run a custom render graph on a camera, just set the `CameraRenderGraph` component:
```rust
commands.spawn_bundle(Camera3dBundle {
camera_render_graph: CameraRenderGraph::new(some_render_graph_name),
..default()
})
```
Just note that if the graph requires data from specific components to work (such as `Camera3d` config, which is provided in the `Camera3dBundle`), make sure the relevant components have been added.
Speaking of using components to configure graphs / passes, there are a number of new configuration options:
```rust
commands.spawn_bundle(Camera3dBundle {
camera_3d: Camera3d {
// overrides the default global clear color
clear_color: ClearColorConfig::Custom(Color::RED),
..default()
},
..default()
})
commands.spawn_bundle(Camera3dBundle {
camera_3d: Camera3d {
// disables clearing
clear_color: ClearColorConfig::None,
..default()
},
..default()
})
```
Expect to see more of the "graph configuration Components on Cameras" pattern in the future.
By popular demand, UI no longer requires a dedicated camera. `UiCameraBundle` has been removed. `Camera2dBundle` and `Camera3dBundle` now both default to rendering UI as part of their own render graphs. To disable UI rendering for a camera, disable it using the CameraUi component:
```rust
commands
.spawn_bundle(Camera3dBundle::default())
.insert(CameraUi {
is_enabled: false,
..default()
})
```
## Other Changes
* The separate clear pass has been removed. We should revisit this for things like sky rendering, but I think this PR should "keep it simple" until we're ready to properly support that (for code complexity and performance reasons). We can come up with the right design for a modular clear pass in a followup pr.
* I reorganized bevy_core_pipeline into Core2dPlugin and Core3dPlugin (and core_2d / core_3d modules). Everything is pretty much the same as before, just logically separate. I've moved relevant types (like Camera2d, Camera3d, Camera3dBundle, Camera2dBundle) into their relevant modules, which is what motivated this reorganization.
* I adapted the `scene_viewer` example (which relied on the ActiveCameras behavior) to the new system. I also refactored bits and pieces to be a bit simpler.
* All of the examples have been ported to the new camera approach. `render_to_texture` and `multiple_windows` are now _much_ simpler. I removed `two_passes` because it is less relevant with the new approach. If someone wants to add a new "layered custom pass with CameraRenderGraph" example, that might fill a similar niche. But I don't feel much pressure to add that in this pr.
* Cameras now have `target_logical_size` and `target_physical_size` fields, which makes finding the size of a camera's render target _much_ simpler. As a result, the `Assets<Image>` and `Windows` parameters were removed from `Camera::world_to_screen`, making that operation much more ergonomic.
* Render order ambiguities between cameras with the same target and the same priority now produce a warning. This accomplishes two goals:
1. Now that there is no "global" active camera, by default spawning two cameras will result in two renders (one covering the other). This would be a silent performance killer that would be hard to detect after the fact. By detecting ambiguities, we can provide a helpful warning when this occurs.
2. Render order ambiguities could result in unexpected / unpredictable render results. Resolving them makes sense.
## Follow Up Work
* Per-Camera viewports, which will make it possible to render to a smaller area inside of a RenderTarget (great for something like splitscreen)
* Camera-specific MSAA config (should use the same "overriding" pattern used for ClearColor)
* Graph Based Camera Ordering: priorities are simple, but they make complicated ordering constraints harder to express. We should consider adopting a "graph based" camera ordering model with "before" and "after" relationships to other cameras (or build it "on top" of the priority system).
* Consider allowing graphs to run subgraphs from any nest level (aka a global namespace for graphs). Right now the 2d and 3d graphs each need their own UI subgraph, which feels "fine" in the short term. But being able to share subgraphs between other subgraphs seems valuable.
* Consider splitting `bevy_core_pipeline` into `bevy_core_2d` and `bevy_core_3d` packages. Theres a shared "clear color" dependency here, which would need a new home.
2022-06-02 00:12:17 +00:00
Camera , CameraRenderGraph , OrthographicProjection , PerspectiveProjection , Projection ,
2022-04-08 17:28:32 +00:00
ScalingMode ,
2020-11-07 01:08:15 +00:00
} ,
2021-12-14 03:58:23 +00:00
color ::Color ,
2022-03-29 18:31:13 +00:00
mesh ::{
skinning ::{ SkinnedMesh , SkinnedMeshInverseBindposes } ,
Indices , Mesh , VertexAttributeValues ,
} ,
2021-12-14 03:58:23 +00:00
primitives ::{ Aabb , Frustum } ,
2022-03-20 21:32:38 +00:00
render_resource ::{ AddressMode , Face , FilterMode , PrimitiveTopology , SamplerDescriptor } ,
2022-03-15 22:26:46 +00:00
renderer ::RenderDevice ,
2022-06-11 09:13:37 +00:00
texture ::{ CompressedImageFormats , Image , ImageSampler , ImageType , TextureError } ,
2021-12-14 03:58:23 +00:00
view ::VisibleEntities ,
2020-05-15 23:55:44 +00:00
} ;
2020-10-18 20:48:15 +00:00
use bevy_scene ::Scene ;
2022-06-20 10:32:44 +00:00
#[ cfg(not(target_arch = " wasm32 " )) ]
Add global init and get accessors for all newtyped TaskPools (#2250)
Right now, a direct reference to the target TaskPool is required to launch tasks on the pools, despite the three newtyped pools (AsyncComputeTaskPool, ComputeTaskPool, and IoTaskPool) effectively acting as global instances. The need to pass a TaskPool reference adds notable friction to spawning subtasks within existing tasks. Possible use cases for this may include chaining tasks within the same pool like spawning separate send/receive I/O tasks after waiting on a network connection to be established, or allowing cross-pool dependent tasks like starting dependent multi-frame computations following a long I/O load.
Other task execution runtimes provide static access to spawning tasks (i.e. `tokio::spawn`), which is notably easier to use than the reference passing required by `bevy_tasks` right now.
This PR makes does the following:
* Adds `*TaskPool::init` which initializes a `OnceCell`'ed with a provided TaskPool. Failing if the pool has already been initialized.
* Adds `*TaskPool::get` which fetches the initialized global pool of the respective type or panics. This generally should not be an issue in normal Bevy use, as the pools are initialized before they are accessed.
* Updated default task pool initialization to either pull the global handles and save them as resources, or if they are already initialized, pull the a cloned global handle as the resource.
This should make it notably easier to build more complex task hierarchies for dependent tasks. It should also make writing bevy-adjacent, but not strictly bevy-only plugin crates easier, as the global pools ensure it's all running on the same threads.
One alternative considered is keeping a thread-local reference to the pool for all threads in each pool to enable the same `tokio::spawn` interface. This would spawn tasks on the same pool that a task is currently running in. However this potentially leads to potential footgun situations where long running blocking tasks run on `ComputeTaskPool`.
2022-06-09 02:43:24 +00:00
use bevy_tasks ::IoTaskPool ;
2022-03-15 01:54:05 +00:00
use bevy_transform ::{ components ::Transform , TransformBundle } ;
2021-12-14 03:58:23 +00:00
use bevy_utils ::{ HashMap , HashSet } ;
2020-10-29 21:22:45 +00:00
use gltf ::{
mesh ::Mode ,
texture ::{ MagFilter , MinFilter , WrappingMode } ,
2022-04-02 22:36:02 +00:00
Material , Node , Primitive ,
2020-10-29 21:22:45 +00:00
} ;
2021-12-14 03:58:23 +00:00
use std ::{ collections ::VecDeque , path ::Path } ;
2020-05-15 23:55:44 +00:00
use thiserror ::Error ;
2022-04-02 22:36:02 +00:00
use crate ::{ Gltf , GltfNode } ;
2020-12-31 20:57:15 +00:00
2021-12-14 03:58:23 +00:00
/// An error that occurs when loading a glTF file.
2020-05-15 23:55:44 +00:00
#[ derive(Error, Debug) ]
pub enum GltfError {
2020-12-02 19:31:16 +00:00
#[ error( " unsupported primitive mode " ) ]
2020-05-15 23:55:44 +00:00
UnsupportedPrimitive { mode : Mode } ,
2021-12-14 03:58:23 +00:00
#[ error( " invalid glTF file: {0} " ) ]
2020-05-15 23:55:44 +00:00
Gltf ( #[ from ] gltf ::Error ) ,
2020-12-02 19:31:16 +00:00
#[ error( " binary blob is missing " ) ]
2020-08-25 23:55:08 +00:00
MissingBlob ,
2020-12-02 19:31:16 +00:00
#[ error( " failed to decode base64 mesh data " ) ]
2020-08-12 17:23:54 +00:00
Base64Decode ( #[ from ] base64 ::DecodeError ) ,
2020-12-02 19:31:16 +00:00
#[ error( " unsupported buffer format " ) ]
2020-08-12 17:23:54 +00:00
BufferFormatUnsupported ,
2021-04-13 02:56:30 +00:00
#[ error( " invalid image mime type: {0} " ) ]
2020-10-18 20:48:15 +00:00
InvalidImageMimeType ( String ) ,
2021-06-08 02:46:44 +00:00
#[ error( " You may need to add the feature for the file format: {0} " ) ]
2021-03-03 21:36:16 +00:00
ImageError ( #[ from ] TextureError ) ,
2021-04-13 02:56:30 +00:00
#[ error( " failed to load an asset path: {0} " ) ]
2020-10-18 20:48:15 +00:00
AssetIoError ( #[ from ] AssetIoError ) ,
2022-03-22 02:26:34 +00:00
#[ error( " Missing sampler for animation {0} " ) ]
MissingAnimationSampler ( usize ) ,
2022-05-31 22:53:54 +00:00
#[ error( " failed to generate tangents: {0} " ) ]
GenerateTangentsError ( #[ from ] bevy_render ::mesh ::GenerateTangentsError ) ,
2020-05-15 23:55:44 +00:00
}
2021-12-14 03:58:23 +00:00
/// Loads glTF files with all of their data as their corresponding bevy representations.
2022-03-15 22:26:46 +00:00
pub struct GltfLoader {
supported_compressed_formats : CompressedImageFormats ,
}
2020-10-18 20:48:15 +00:00
impl AssetLoader for GltfLoader {
2020-10-20 00:29:31 +00:00
fn load < ' a > (
& ' a self ,
bytes : & ' a [ u8 ] ,
load_context : & ' a mut LoadContext ,
) -> BoxedFuture < ' a , Result < ( ) > > {
2022-03-15 22:26:46 +00:00
Box ::pin ( async move {
Ok ( load_gltf ( bytes , load_context , self . supported_compressed_formats ) . await ? )
} )
2020-10-18 20:48:15 +00:00
}
fn extensions ( & self ) -> & [ & str ] {
2020-11-17 21:40:18 +00:00
& [ " gltf " , " glb " ]
2020-05-15 23:55:44 +00:00
}
}
2022-03-15 22:26:46 +00:00
impl FromWorld for GltfLoader {
fn from_world ( world : & mut World ) -> Self {
2022-04-05 19:37:23 +00:00
let supported_compressed_formats = match world . get_resource ::< RenderDevice > ( ) {
Some ( render_device ) = > CompressedImageFormats ::from_features ( render_device . features ( ) ) ,
None = > CompressedImageFormats ::all ( ) ,
} ;
2022-03-15 22:26:46 +00:00
Self {
2022-04-05 19:37:23 +00:00
supported_compressed_formats ,
2022-03-15 22:26:46 +00:00
}
}
}
2021-12-14 03:58:23 +00:00
/// Loads an entire glTF file.
2020-10-20 00:29:31 +00:00
async fn load_gltf < ' a , ' b > (
bytes : & ' a [ u8 ] ,
load_context : & ' a mut LoadContext < ' b > ,
2022-03-15 22:26:46 +00:00
supported_compressed_formats : CompressedImageFormats ,
2020-10-20 00:29:31 +00:00
) -> Result < ( ) , GltfError > {
2020-10-18 20:48:15 +00:00
let gltf = gltf ::Gltf ::from_slice ( bytes ) ? ;
2020-10-20 00:29:31 +00:00
let buffer_data = load_buffers ( & gltf , load_context , load_context . path ( ) ) . await ? ;
2020-10-18 20:48:15 +00:00
2020-12-31 20:57:15 +00:00
let mut materials = vec! [ ] ;
2021-12-14 03:58:23 +00:00
let mut named_materials = HashMap ::default ( ) ;
let mut linear_textures = HashSet ::default ( ) ;
2020-12-31 20:57:15 +00:00
for material in gltf . materials ( ) {
let handle = load_material ( & material , load_context ) ;
if let Some ( name ) = material . name ( ) {
named_materials . insert ( name . to_string ( ) , handle . clone ( ) ) ;
}
materials . push ( handle ) ;
2021-03-26 18:47:47 +00:00
if let Some ( texture ) = material . normal_texture ( ) {
linear_textures . insert ( texture . texture ( ) . index ( ) ) ;
}
if let Some ( texture ) = material . occlusion_texture ( ) {
linear_textures . insert ( texture . texture ( ) . index ( ) ) ;
}
2021-03-26 21:00:34 +00:00
if let Some ( texture ) = material
. pbr_metallic_roughness ( )
. metallic_roughness_texture ( )
{
linear_textures . insert ( texture . texture ( ) . index ( ) ) ;
}
2020-12-31 20:57:15 +00:00
}
2020-10-18 20:48:15 +00:00
2022-04-02 22:36:02 +00:00
#[ cfg(feature = " bevy_animation " ) ]
let paths = {
2022-04-05 21:52:00 +00:00
let mut paths = HashMap ::< usize , ( usize , Vec < Name > ) > ::new ( ) ;
2022-04-02 22:36:02 +00:00
for scene in gltf . scenes ( ) {
for node in scene . nodes ( ) {
2022-04-05 21:52:00 +00:00
let root_index = node . index ( ) ;
paths_recur ( node , & [ ] , & mut paths , root_index ) ;
2022-04-02 22:36:02 +00:00
}
}
paths
} ;
2022-03-22 02:26:34 +00:00
2022-04-02 22:36:02 +00:00
#[ cfg(feature = " bevy_animation " ) ]
2022-04-05 21:52:00 +00:00
let ( animations , named_animations , animation_roots ) = {
2022-04-02 22:36:02 +00:00
let mut animations = vec! [ ] ;
let mut named_animations = HashMap ::default ( ) ;
2022-04-05 21:52:00 +00:00
let mut animation_roots = HashSet ::default ( ) ;
2022-04-02 22:36:02 +00:00
for animation in gltf . animations ( ) {
2022-05-10 20:01:55 +00:00
let mut animation_clip = bevy_animation ::AnimationClip ::default ( ) ;
2022-04-02 22:36:02 +00:00
for channel in animation . channels ( ) {
match channel . sampler ( ) . interpolation ( ) {
gltf ::animation ::Interpolation ::Linear = > ( ) ,
other = > warn! (
" Animation interpolation {:?} is not supported, will use linear " ,
other
) ,
} ;
let node = channel . target ( ) . node ( ) ;
let reader = channel . reader ( | buffer | Some ( & buffer_data [ buffer . index ( ) ] ) ) ;
let keyframe_timestamps : Vec < f32 > = if let Some ( inputs ) = reader . read_inputs ( ) {
match inputs {
gltf ::accessor ::Iter ::Standard ( times ) = > times . collect ( ) ,
gltf ::accessor ::Iter ::Sparse ( _ ) = > {
warn! ( " Sparse accessor not supported for animation sampler input " ) ;
continue ;
}
2022-03-22 02:26:34 +00:00
}
2022-04-02 22:36:02 +00:00
} else {
warn! ( " Animations without a sampler input are not supported " ) ;
return Err ( GltfError ::MissingAnimationSampler ( animation . index ( ) ) ) ;
} ;
let keyframes = if let Some ( outputs ) = reader . read_outputs ( ) {
match outputs {
gltf ::animation ::util ::ReadOutputs ::Translations ( tr ) = > {
2022-05-10 20:01:55 +00:00
bevy_animation ::Keyframes ::Translation ( tr . map ( Vec3 ::from ) . collect ( ) )
2022-04-02 22:36:02 +00:00
}
gltf ::animation ::util ::ReadOutputs ::Rotations ( rots ) = > {
2022-05-10 20:01:55 +00:00
bevy_animation ::Keyframes ::Rotation (
rots . into_f32 ( ) . map ( bevy_math ::Quat ::from_array ) . collect ( ) ,
)
2022-04-02 22:36:02 +00:00
}
gltf ::animation ::util ::ReadOutputs ::Scales ( scale ) = > {
2022-05-10 20:01:55 +00:00
bevy_animation ::Keyframes ::Scale ( scale . map ( Vec3 ::from ) . collect ( ) )
2022-04-02 22:36:02 +00:00
}
gltf ::animation ::util ::ReadOutputs ::MorphTargetWeights ( _ ) = > {
warn! ( " Morph animation property not yet supported " ) ;
continue ;
}
2022-03-22 02:26:34 +00:00
}
2022-04-02 22:36:02 +00:00
} else {
warn! ( " Animations without a sampler output are not supported " ) ;
return Err ( GltfError ::MissingAnimationSampler ( animation . index ( ) ) ) ;
} ;
2022-03-22 02:26:34 +00:00
2022-04-05 21:52:00 +00:00
if let Some ( ( root_index , path ) ) = paths . get ( & node . index ( ) ) {
animation_roots . insert ( root_index ) ;
2022-04-02 22:36:02 +00:00
animation_clip . add_curve_to_path (
2022-05-10 20:01:55 +00:00
bevy_animation ::EntityPath {
2022-04-02 22:36:02 +00:00
parts : path . clone ( ) ,
} ,
2022-05-10 20:01:55 +00:00
bevy_animation ::VariableCurve {
2022-04-02 22:36:02 +00:00
keyframe_timestamps ,
keyframes ,
} ,
) ;
} else {
warn! (
" Animation ignored for node {}: part of its hierarchy is missing a name " ,
node . index ( )
) ;
}
}
let handle = load_context . set_labeled_asset (
& format! ( " Animation {} " , animation . index ( ) ) ,
LoadedAsset ::new ( animation_clip ) ,
) ;
if let Some ( name ) = animation . name ( ) {
named_animations . insert ( name . to_string ( ) , handle . clone ( ) ) ;
}
animations . push ( handle ) ;
2022-03-22 02:26:34 +00:00
}
2022-04-05 21:52:00 +00:00
( animations , named_animations , animation_roots )
2022-04-02 22:36:02 +00:00
} ;
2022-03-22 02:26:34 +00:00
2020-12-31 20:57:15 +00:00
let mut meshes = vec! [ ] ;
2021-12-14 03:58:23 +00:00
let mut named_meshes = HashMap ::default ( ) ;
2020-10-18 20:48:15 +00:00
for mesh in gltf . meshes ( ) {
2020-12-31 20:57:15 +00:00
let mut primitives = vec! [ ] ;
2020-10-18 20:48:15 +00:00
for primitive in mesh . primitives ( ) {
let primitive_label = primitive_label ( & mesh , & primitive ) ;
2020-12-31 20:57:15 +00:00
let reader = primitive . reader ( | buffer | Some ( & buffer_data [ buffer . index ( ) ] ) ) ;
let primitive_topology = get_primitive_topology ( primitive . mode ( ) ) ? ;
2020-10-18 20:48:15 +00:00
2020-12-31 20:57:15 +00:00
let mut mesh = Mesh ::new ( primitive_topology ) ;
2020-10-18 20:48:15 +00:00
2020-12-31 20:57:15 +00:00
if let Some ( vertex_attribute ) = reader
. read_positions ( )
2021-05-02 20:45:25 +00:00
. map ( | v | VertexAttributeValues ::Float32x3 ( v . collect ( ) ) )
2020-12-31 20:57:15 +00:00
{
Mesh vertex buffer layouts (#3959)
This PR makes a number of changes to how meshes and vertex attributes are handled, which the goal of enabling easy and flexible custom vertex attributes:
* Reworks the `Mesh` type to use the newly added `VertexAttribute` internally
* `VertexAttribute` defines the name, a unique `VertexAttributeId`, and a `VertexFormat`
* `VertexAttributeId` is used to produce consistent sort orders for vertex buffer generation, replacing the more expensive and often surprising "name based sorting"
* Meshes can be used to generate a `MeshVertexBufferLayout`, which defines the layout of the gpu buffer produced by the mesh. `MeshVertexBufferLayouts` can then be used to generate actual `VertexBufferLayouts` according to the requirements of a specific pipeline. This decoupling of "mesh layout" vs "pipeline vertex buffer layout" is what enables custom attributes. We don't need to standardize _mesh layouts_ or contort meshes to meet the needs of a specific pipeline. As long as the mesh has what the pipeline needs, it will work transparently.
* Mesh-based pipelines now specialize on `&MeshVertexBufferLayout` via the new `SpecializedMeshPipeline` trait (which behaves like `SpecializedPipeline`, but adds `&MeshVertexBufferLayout`). The integrity of the pipeline cache is maintained because the `MeshVertexBufferLayout` is treated as part of the key (which is fully abstracted from implementers of the trait ... no need to add any additional info to the specialization key).
* Hashing `MeshVertexBufferLayout` is too expensive to do for every entity, every frame. To make this scalable, I added a generalized "pre-hashing" solution to `bevy_utils`: `Hashed<T>` keys and `PreHashMap<K, V>` (which uses `Hashed<T>` internally) . Why didn't I just do the quick and dirty in-place "pre-compute hash and use that u64 as a key in a hashmap" that we've done in the past? Because its wrong! Hashes by themselves aren't enough because two different values can produce the same hash. Re-hashing a hash is even worse! I decided to build a generalized solution because this pattern has come up in the past and we've chosen to do the wrong thing. Now we can do the right thing! This did unfortunately require pulling in `hashbrown` and using that in `bevy_utils`, because avoiding re-hashes requires the `raw_entry_mut` api, which isn't stabilized yet (and may never be ... `entry_ref` has favor now, but also isn't available yet). If std's HashMap ever provides the tools we need, we can move back to that. Note that adding `hashbrown` doesn't increase our dependency count because it was already in our tree. I will probably break these changes out into their own PR.
* Specializing on `MeshVertexBufferLayout` has one non-obvious behavior: it can produce identical pipelines for two different MeshVertexBufferLayouts. To optimize the number of active pipelines / reduce re-binds while drawing, I de-duplicate pipelines post-specialization using the final `VertexBufferLayout` as the key. For example, consider a pipeline that needs the layout `(position, normal)` and is specialized using two meshes: `(position, normal, uv)` and `(position, normal, other_vec2)`. If both of these meshes result in `(position, normal)` specializations, we can use the same pipeline! Now we do. Cool!
To briefly illustrate, this is what the relevant section of `MeshPipeline`'s specialization code looks like now:
```rust
impl SpecializedMeshPipeline for MeshPipeline {
type Key = MeshPipelineKey;
fn specialize(
&self,
key: Self::Key,
layout: &MeshVertexBufferLayout,
) -> RenderPipelineDescriptor {
let mut vertex_attributes = vec![
Mesh::ATTRIBUTE_POSITION.at_shader_location(0),
Mesh::ATTRIBUTE_NORMAL.at_shader_location(1),
Mesh::ATTRIBUTE_UV_0.at_shader_location(2),
];
let mut shader_defs = Vec::new();
if layout.contains(Mesh::ATTRIBUTE_TANGENT) {
shader_defs.push(String::from("VERTEX_TANGENTS"));
vertex_attributes.push(Mesh::ATTRIBUTE_TANGENT.at_shader_location(3));
}
let vertex_buffer_layout = layout
.get_layout(&vertex_attributes)
.expect("Mesh is missing a vertex attribute");
```
Notice that this is _much_ simpler than it was before. And now any mesh with any layout can be used with this pipeline, provided it has vertex postions, normals, and uvs. We even got to remove `HAS_TANGENTS` from MeshPipelineKey and `has_tangents` from `GpuMesh`, because that information is redundant with `MeshVertexBufferLayout`.
This is still a draft because I still need to:
* Add more docs
* Experiment with adding error handling to mesh pipeline specialization (which would print errors at runtime when a mesh is missing a vertex attribute required by a pipeline). If it doesn't tank perf, we'll keep it.
* Consider breaking out the PreHash / hashbrown changes into a separate PR.
* Add an example illustrating this change
* Verify that the "mesh-specialized pipeline de-duplication code" works properly
Please dont yell at me for not doing these things yet :) Just trying to get this in peoples' hands asap.
Alternative to #3120
Fixes #3030
Co-authored-by: Carter Anderson <mcanders1@gmail.com>
2022-02-23 23:21:13 +00:00
mesh . insert_attribute ( Mesh ::ATTRIBUTE_POSITION , vertex_attribute ) ;
2020-12-31 20:57:15 +00:00
}
2020-10-18 20:48:15 +00:00
2020-12-31 20:57:15 +00:00
if let Some ( vertex_attribute ) = reader
. read_normals ( )
2021-05-02 20:45:25 +00:00
. map ( | v | VertexAttributeValues ::Float32x3 ( v . collect ( ) ) )
2020-12-31 20:57:15 +00:00
{
Mesh vertex buffer layouts (#3959)
This PR makes a number of changes to how meshes and vertex attributes are handled, which the goal of enabling easy and flexible custom vertex attributes:
* Reworks the `Mesh` type to use the newly added `VertexAttribute` internally
* `VertexAttribute` defines the name, a unique `VertexAttributeId`, and a `VertexFormat`
* `VertexAttributeId` is used to produce consistent sort orders for vertex buffer generation, replacing the more expensive and often surprising "name based sorting"
* Meshes can be used to generate a `MeshVertexBufferLayout`, which defines the layout of the gpu buffer produced by the mesh. `MeshVertexBufferLayouts` can then be used to generate actual `VertexBufferLayouts` according to the requirements of a specific pipeline. This decoupling of "mesh layout" vs "pipeline vertex buffer layout" is what enables custom attributes. We don't need to standardize _mesh layouts_ or contort meshes to meet the needs of a specific pipeline. As long as the mesh has what the pipeline needs, it will work transparently.
* Mesh-based pipelines now specialize on `&MeshVertexBufferLayout` via the new `SpecializedMeshPipeline` trait (which behaves like `SpecializedPipeline`, but adds `&MeshVertexBufferLayout`). The integrity of the pipeline cache is maintained because the `MeshVertexBufferLayout` is treated as part of the key (which is fully abstracted from implementers of the trait ... no need to add any additional info to the specialization key).
* Hashing `MeshVertexBufferLayout` is too expensive to do for every entity, every frame. To make this scalable, I added a generalized "pre-hashing" solution to `bevy_utils`: `Hashed<T>` keys and `PreHashMap<K, V>` (which uses `Hashed<T>` internally) . Why didn't I just do the quick and dirty in-place "pre-compute hash and use that u64 as a key in a hashmap" that we've done in the past? Because its wrong! Hashes by themselves aren't enough because two different values can produce the same hash. Re-hashing a hash is even worse! I decided to build a generalized solution because this pattern has come up in the past and we've chosen to do the wrong thing. Now we can do the right thing! This did unfortunately require pulling in `hashbrown` and using that in `bevy_utils`, because avoiding re-hashes requires the `raw_entry_mut` api, which isn't stabilized yet (and may never be ... `entry_ref` has favor now, but also isn't available yet). If std's HashMap ever provides the tools we need, we can move back to that. Note that adding `hashbrown` doesn't increase our dependency count because it was already in our tree. I will probably break these changes out into their own PR.
* Specializing on `MeshVertexBufferLayout` has one non-obvious behavior: it can produce identical pipelines for two different MeshVertexBufferLayouts. To optimize the number of active pipelines / reduce re-binds while drawing, I de-duplicate pipelines post-specialization using the final `VertexBufferLayout` as the key. For example, consider a pipeline that needs the layout `(position, normal)` and is specialized using two meshes: `(position, normal, uv)` and `(position, normal, other_vec2)`. If both of these meshes result in `(position, normal)` specializations, we can use the same pipeline! Now we do. Cool!
To briefly illustrate, this is what the relevant section of `MeshPipeline`'s specialization code looks like now:
```rust
impl SpecializedMeshPipeline for MeshPipeline {
type Key = MeshPipelineKey;
fn specialize(
&self,
key: Self::Key,
layout: &MeshVertexBufferLayout,
) -> RenderPipelineDescriptor {
let mut vertex_attributes = vec![
Mesh::ATTRIBUTE_POSITION.at_shader_location(0),
Mesh::ATTRIBUTE_NORMAL.at_shader_location(1),
Mesh::ATTRIBUTE_UV_0.at_shader_location(2),
];
let mut shader_defs = Vec::new();
if layout.contains(Mesh::ATTRIBUTE_TANGENT) {
shader_defs.push(String::from("VERTEX_TANGENTS"));
vertex_attributes.push(Mesh::ATTRIBUTE_TANGENT.at_shader_location(3));
}
let vertex_buffer_layout = layout
.get_layout(&vertex_attributes)
.expect("Mesh is missing a vertex attribute");
```
Notice that this is _much_ simpler than it was before. And now any mesh with any layout can be used with this pipeline, provided it has vertex postions, normals, and uvs. We even got to remove `HAS_TANGENTS` from MeshPipelineKey and `has_tangents` from `GpuMesh`, because that information is redundant with `MeshVertexBufferLayout`.
This is still a draft because I still need to:
* Add more docs
* Experiment with adding error handling to mesh pipeline specialization (which would print errors at runtime when a mesh is missing a vertex attribute required by a pipeline). If it doesn't tank perf, we'll keep it.
* Consider breaking out the PreHash / hashbrown changes into a separate PR.
* Add an example illustrating this change
* Verify that the "mesh-specialized pipeline de-duplication code" works properly
Please dont yell at me for not doing these things yet :) Just trying to get this in peoples' hands asap.
Alternative to #3120
Fixes #3030
Co-authored-by: Carter Anderson <mcanders1@gmail.com>
2022-02-23 23:21:13 +00:00
mesh . insert_attribute ( Mesh ::ATTRIBUTE_NORMAL , vertex_attribute ) ;
2020-12-31 20:57:15 +00:00
}
2020-10-18 20:48:15 +00:00
2020-12-31 20:57:15 +00:00
if let Some ( vertex_attribute ) = reader
. read_tex_coords ( 0 )
2021-05-02 20:45:25 +00:00
. map ( | v | VertexAttributeValues ::Float32x2 ( v . into_f32 ( ) . collect ( ) ) )
2020-12-31 20:57:15 +00:00
{
Mesh vertex buffer layouts (#3959)
This PR makes a number of changes to how meshes and vertex attributes are handled, which the goal of enabling easy and flexible custom vertex attributes:
* Reworks the `Mesh` type to use the newly added `VertexAttribute` internally
* `VertexAttribute` defines the name, a unique `VertexAttributeId`, and a `VertexFormat`
* `VertexAttributeId` is used to produce consistent sort orders for vertex buffer generation, replacing the more expensive and often surprising "name based sorting"
* Meshes can be used to generate a `MeshVertexBufferLayout`, which defines the layout of the gpu buffer produced by the mesh. `MeshVertexBufferLayouts` can then be used to generate actual `VertexBufferLayouts` according to the requirements of a specific pipeline. This decoupling of "mesh layout" vs "pipeline vertex buffer layout" is what enables custom attributes. We don't need to standardize _mesh layouts_ or contort meshes to meet the needs of a specific pipeline. As long as the mesh has what the pipeline needs, it will work transparently.
* Mesh-based pipelines now specialize on `&MeshVertexBufferLayout` via the new `SpecializedMeshPipeline` trait (which behaves like `SpecializedPipeline`, but adds `&MeshVertexBufferLayout`). The integrity of the pipeline cache is maintained because the `MeshVertexBufferLayout` is treated as part of the key (which is fully abstracted from implementers of the trait ... no need to add any additional info to the specialization key).
* Hashing `MeshVertexBufferLayout` is too expensive to do for every entity, every frame. To make this scalable, I added a generalized "pre-hashing" solution to `bevy_utils`: `Hashed<T>` keys and `PreHashMap<K, V>` (which uses `Hashed<T>` internally) . Why didn't I just do the quick and dirty in-place "pre-compute hash and use that u64 as a key in a hashmap" that we've done in the past? Because its wrong! Hashes by themselves aren't enough because two different values can produce the same hash. Re-hashing a hash is even worse! I decided to build a generalized solution because this pattern has come up in the past and we've chosen to do the wrong thing. Now we can do the right thing! This did unfortunately require pulling in `hashbrown` and using that in `bevy_utils`, because avoiding re-hashes requires the `raw_entry_mut` api, which isn't stabilized yet (and may never be ... `entry_ref` has favor now, but also isn't available yet). If std's HashMap ever provides the tools we need, we can move back to that. Note that adding `hashbrown` doesn't increase our dependency count because it was already in our tree. I will probably break these changes out into their own PR.
* Specializing on `MeshVertexBufferLayout` has one non-obvious behavior: it can produce identical pipelines for two different MeshVertexBufferLayouts. To optimize the number of active pipelines / reduce re-binds while drawing, I de-duplicate pipelines post-specialization using the final `VertexBufferLayout` as the key. For example, consider a pipeline that needs the layout `(position, normal)` and is specialized using two meshes: `(position, normal, uv)` and `(position, normal, other_vec2)`. If both of these meshes result in `(position, normal)` specializations, we can use the same pipeline! Now we do. Cool!
To briefly illustrate, this is what the relevant section of `MeshPipeline`'s specialization code looks like now:
```rust
impl SpecializedMeshPipeline for MeshPipeline {
type Key = MeshPipelineKey;
fn specialize(
&self,
key: Self::Key,
layout: &MeshVertexBufferLayout,
) -> RenderPipelineDescriptor {
let mut vertex_attributes = vec![
Mesh::ATTRIBUTE_POSITION.at_shader_location(0),
Mesh::ATTRIBUTE_NORMAL.at_shader_location(1),
Mesh::ATTRIBUTE_UV_0.at_shader_location(2),
];
let mut shader_defs = Vec::new();
if layout.contains(Mesh::ATTRIBUTE_TANGENT) {
shader_defs.push(String::from("VERTEX_TANGENTS"));
vertex_attributes.push(Mesh::ATTRIBUTE_TANGENT.at_shader_location(3));
}
let vertex_buffer_layout = layout
.get_layout(&vertex_attributes)
.expect("Mesh is missing a vertex attribute");
```
Notice that this is _much_ simpler than it was before. And now any mesh with any layout can be used with this pipeline, provided it has vertex postions, normals, and uvs. We even got to remove `HAS_TANGENTS` from MeshPipelineKey and `has_tangents` from `GpuMesh`, because that information is redundant with `MeshVertexBufferLayout`.
This is still a draft because I still need to:
* Add more docs
* Experiment with adding error handling to mesh pipeline specialization (which would print errors at runtime when a mesh is missing a vertex attribute required by a pipeline). If it doesn't tank perf, we'll keep it.
* Consider breaking out the PreHash / hashbrown changes into a separate PR.
* Add an example illustrating this change
* Verify that the "mesh-specialized pipeline de-duplication code" works properly
Please dont yell at me for not doing these things yet :) Just trying to get this in peoples' hands asap.
Alternative to #3120
Fixes #3030
Co-authored-by: Carter Anderson <mcanders1@gmail.com>
2022-02-23 23:21:13 +00:00
mesh . insert_attribute ( Mesh ::ATTRIBUTE_UV_0 , vertex_attribute ) ;
2021-05-06 03:08:53 +00:00
} else {
let len = mesh . count_vertices ( ) ;
let uvs = vec! [ [ 0.0 , 0.0 ] ; len ] ;
bevy_log ::debug! ( " missing `TEXCOORD_0` vertex attribute, loading zeroed out UVs " ) ;
Mesh vertex buffer layouts (#3959)
This PR makes a number of changes to how meshes and vertex attributes are handled, which the goal of enabling easy and flexible custom vertex attributes:
* Reworks the `Mesh` type to use the newly added `VertexAttribute` internally
* `VertexAttribute` defines the name, a unique `VertexAttributeId`, and a `VertexFormat`
* `VertexAttributeId` is used to produce consistent sort orders for vertex buffer generation, replacing the more expensive and often surprising "name based sorting"
* Meshes can be used to generate a `MeshVertexBufferLayout`, which defines the layout of the gpu buffer produced by the mesh. `MeshVertexBufferLayouts` can then be used to generate actual `VertexBufferLayouts` according to the requirements of a specific pipeline. This decoupling of "mesh layout" vs "pipeline vertex buffer layout" is what enables custom attributes. We don't need to standardize _mesh layouts_ or contort meshes to meet the needs of a specific pipeline. As long as the mesh has what the pipeline needs, it will work transparently.
* Mesh-based pipelines now specialize on `&MeshVertexBufferLayout` via the new `SpecializedMeshPipeline` trait (which behaves like `SpecializedPipeline`, but adds `&MeshVertexBufferLayout`). The integrity of the pipeline cache is maintained because the `MeshVertexBufferLayout` is treated as part of the key (which is fully abstracted from implementers of the trait ... no need to add any additional info to the specialization key).
* Hashing `MeshVertexBufferLayout` is too expensive to do for every entity, every frame. To make this scalable, I added a generalized "pre-hashing" solution to `bevy_utils`: `Hashed<T>` keys and `PreHashMap<K, V>` (which uses `Hashed<T>` internally) . Why didn't I just do the quick and dirty in-place "pre-compute hash and use that u64 as a key in a hashmap" that we've done in the past? Because its wrong! Hashes by themselves aren't enough because two different values can produce the same hash. Re-hashing a hash is even worse! I decided to build a generalized solution because this pattern has come up in the past and we've chosen to do the wrong thing. Now we can do the right thing! This did unfortunately require pulling in `hashbrown` and using that in `bevy_utils`, because avoiding re-hashes requires the `raw_entry_mut` api, which isn't stabilized yet (and may never be ... `entry_ref` has favor now, but also isn't available yet). If std's HashMap ever provides the tools we need, we can move back to that. Note that adding `hashbrown` doesn't increase our dependency count because it was already in our tree. I will probably break these changes out into their own PR.
* Specializing on `MeshVertexBufferLayout` has one non-obvious behavior: it can produce identical pipelines for two different MeshVertexBufferLayouts. To optimize the number of active pipelines / reduce re-binds while drawing, I de-duplicate pipelines post-specialization using the final `VertexBufferLayout` as the key. For example, consider a pipeline that needs the layout `(position, normal)` and is specialized using two meshes: `(position, normal, uv)` and `(position, normal, other_vec2)`. If both of these meshes result in `(position, normal)` specializations, we can use the same pipeline! Now we do. Cool!
To briefly illustrate, this is what the relevant section of `MeshPipeline`'s specialization code looks like now:
```rust
impl SpecializedMeshPipeline for MeshPipeline {
type Key = MeshPipelineKey;
fn specialize(
&self,
key: Self::Key,
layout: &MeshVertexBufferLayout,
) -> RenderPipelineDescriptor {
let mut vertex_attributes = vec![
Mesh::ATTRIBUTE_POSITION.at_shader_location(0),
Mesh::ATTRIBUTE_NORMAL.at_shader_location(1),
Mesh::ATTRIBUTE_UV_0.at_shader_location(2),
];
let mut shader_defs = Vec::new();
if layout.contains(Mesh::ATTRIBUTE_TANGENT) {
shader_defs.push(String::from("VERTEX_TANGENTS"));
vertex_attributes.push(Mesh::ATTRIBUTE_TANGENT.at_shader_location(3));
}
let vertex_buffer_layout = layout
.get_layout(&vertex_attributes)
.expect("Mesh is missing a vertex attribute");
```
Notice that this is _much_ simpler than it was before. And now any mesh with any layout can be used with this pipeline, provided it has vertex postions, normals, and uvs. We even got to remove `HAS_TANGENTS` from MeshPipelineKey and `has_tangents` from `GpuMesh`, because that information is redundant with `MeshVertexBufferLayout`.
This is still a draft because I still need to:
* Add more docs
* Experiment with adding error handling to mesh pipeline specialization (which would print errors at runtime when a mesh is missing a vertex attribute required by a pipeline). If it doesn't tank perf, we'll keep it.
* Consider breaking out the PreHash / hashbrown changes into a separate PR.
* Add an example illustrating this change
* Verify that the "mesh-specialized pipeline de-duplication code" works properly
Please dont yell at me for not doing these things yet :) Just trying to get this in peoples' hands asap.
Alternative to #3120
Fixes #3030
Co-authored-by: Carter Anderson <mcanders1@gmail.com>
2022-02-23 23:21:13 +00:00
mesh . insert_attribute ( Mesh ::ATTRIBUTE_UV_0 , uvs ) ;
2020-12-31 20:57:15 +00:00
}
2020-10-18 20:48:15 +00:00
2022-05-05 00:46:32 +00:00
if let Some ( vertex_attribute ) = reader
. read_colors ( 0 )
. map ( | v | VertexAttributeValues ::Float32x4 ( v . into_rgba_f32 ( ) . collect ( ) ) )
{
mesh . insert_attribute ( Mesh ::ATTRIBUTE_COLOR , vertex_attribute ) ;
}
2021-04-13 01:47:25 +00:00
2022-03-29 18:31:13 +00:00
if let Some ( iter ) = reader . read_joints ( 0 ) {
let vertex_attribute = VertexAttributeValues ::Uint16x4 ( iter . into_u16 ( ) . collect ( ) ) ;
mesh . insert_attribute ( Mesh ::ATTRIBUTE_JOINT_INDEX , vertex_attribute ) ;
}
if let Some ( vertex_attribute ) = reader
. read_weights ( 0 )
. map ( | v | VertexAttributeValues ::Float32x4 ( v . into_f32 ( ) . collect ( ) ) )
{
mesh . insert_attribute ( Mesh ::ATTRIBUTE_JOINT_WEIGHT , vertex_attribute ) ;
}
2020-12-31 20:57:15 +00:00
if let Some ( indices ) = reader . read_indices ( ) {
mesh . set_indices ( Some ( Indices ::U32 ( indices . into_u32 ( ) . collect ( ) ) ) ) ;
2020-10-18 20:48:15 +00:00
} ;
2020-12-31 20:57:15 +00:00
2022-03-31 20:43:01 +00:00
if mesh . attribute ( Mesh ::ATTRIBUTE_NORMAL ) . is_none ( )
& & matches! ( mesh . primitive_topology ( ) , PrimitiveTopology ::TriangleList )
{
2021-04-15 21:06:49 +00:00
let vertex_count_before = mesh . count_vertices ( ) ;
mesh . duplicate_vertices ( ) ;
mesh . compute_flat_normals ( ) ;
let vertex_count_after = mesh . count_vertices ( ) ;
if vertex_count_before ! = vertex_count_after {
bevy_log ::debug! ( " Missing vertex normals in indexed geometry, computing them as flat. Vertex count increased from {} to {} " , vertex_count_before , vertex_count_after ) ;
} else {
bevy_log ::debug! (
" Missing vertex normals in indexed geometry, computing them as flat. "
) ;
}
}
2022-05-31 22:53:54 +00:00
if let Some ( vertex_attribute ) = reader
. read_tangents ( )
. map ( | v | VertexAttributeValues ::Float32x4 ( v . collect ( ) ) )
{
mesh . insert_attribute ( Mesh ::ATTRIBUTE_TANGENT , vertex_attribute ) ;
} else if mesh . attribute ( Mesh ::ATTRIBUTE_NORMAL ) . is_some ( )
& & primitive . material ( ) . normal_texture ( ) . is_some ( )
{
bevy_log ::debug! (
" Missing vertex tangents, computing them using the mikktspace algorithm "
) ;
if let Err ( err ) = mesh . generate_tangents ( ) {
bevy_log ::warn! (
" Failed to generate vertex tangents using the mikktspace algorithm: {:?} " ,
err
) ;
}
}
2020-12-31 20:57:15 +00:00
let mesh = load_context . set_labeled_asset ( & primitive_label , LoadedAsset ::new ( mesh ) ) ;
primitives . push ( super ::GltfPrimitive {
mesh ,
material : primitive
. material ( )
. index ( )
. and_then ( | i | materials . get ( i ) . cloned ( ) ) ,
} ) ;
}
2022-05-31 22:53:54 +00:00
2020-12-31 20:57:15 +00:00
let handle = load_context . set_labeled_asset (
& mesh_label ( & mesh ) ,
LoadedAsset ::new ( super ::GltfMesh { primitives } ) ,
) ;
if let Some ( name ) = mesh . name ( ) {
named_meshes . insert ( name . to_string ( ) , handle . clone ( ) ) ;
}
meshes . push ( handle ) ;
}
let mut nodes_intermediate = vec! [ ] ;
2021-12-14 03:58:23 +00:00
let mut named_nodes_intermediate = HashMap ::default ( ) ;
2020-12-31 20:57:15 +00:00
for node in gltf . nodes ( ) {
let node_label = node_label ( & node ) ;
nodes_intermediate . push ( (
node_label ,
GltfNode {
children : vec ! [ ] ,
mesh : node
. mesh ( )
. map ( | mesh | mesh . index ( ) )
. and_then ( | i | meshes . get ( i ) . cloned ( ) ) ,
transform : match node . transform ( ) {
gltf ::scene ::Transform ::Matrix { matrix } = > {
Transform ::from_matrix ( bevy_math ::Mat4 ::from_cols_array_2d ( & matrix ) )
}
gltf ::scene ::Transform ::Decomposed {
translation ,
rotation ,
scale ,
} = > Transform {
translation : bevy_math ::Vec3 ::from ( translation ) ,
2021-05-18 18:56:15 +00:00
rotation : bevy_math ::Quat ::from_vec4 ( rotation . into ( ) ) ,
2020-12-31 20:57:15 +00:00
scale : bevy_math ::Vec3 ::from ( scale ) ,
} ,
} ,
} ,
node . children ( )
. map ( | child | child . index ( ) )
. collect ::< Vec < _ > > ( ) ,
) ) ;
if let Some ( name ) = node . name ( ) {
named_nodes_intermediate . insert ( name , node . index ( ) ) ;
2020-05-15 23:55:44 +00:00
}
}
2021-12-14 03:58:23 +00:00
let nodes = resolve_node_hierarchy ( nodes_intermediate , load_context . path ( ) )
2020-12-31 20:57:15 +00:00
. into_iter ( )
. map ( | ( label , node ) | load_context . set_labeled_asset ( & label , LoadedAsset ::new ( node ) ) )
. collect ::< Vec < bevy_asset ::Handle < GltfNode > > > ( ) ;
let named_nodes = named_nodes_intermediate
. into_iter ( )
. filter_map ( | ( name , index ) | {
nodes
. get ( index )
. map ( | handle | ( name . to_string ( ) , handle . clone ( ) ) )
} )
. collect ( ) ;
2020-05-15 23:55:44 +00:00
2021-04-30 20:12:50 +00:00
// TODO: use the threaded impl on wasm once wasm thread pool doesn't deadlock on it
2022-01-07 07:19:22 +00:00
// See https://github.com/bevyengine/bevy/issues/1924 for more details
// The taskpool use is also avoided when there is only one texture for performance reasons and
// to avoid https://github.com/bevyengine/bevy/pull/2725
if gltf . textures ( ) . len ( ) = = 1 | | cfg! ( target_arch = " wasm32 " ) {
for gltf_texture in gltf . textures ( ) {
2022-03-15 22:26:46 +00:00
let ( texture , label ) = load_texture (
gltf_texture ,
& buffer_data ,
& linear_textures ,
load_context ,
supported_compressed_formats ,
)
. await ? ;
2022-01-07 07:19:22 +00:00
load_context . set_labeled_asset ( & label , LoadedAsset ::new ( texture ) ) ;
}
} else {
#[ cfg(not(target_arch = " wasm32 " )) ]
Add global init and get accessors for all newtyped TaskPools (#2250)
Right now, a direct reference to the target TaskPool is required to launch tasks on the pools, despite the three newtyped pools (AsyncComputeTaskPool, ComputeTaskPool, and IoTaskPool) effectively acting as global instances. The need to pass a TaskPool reference adds notable friction to spawning subtasks within existing tasks. Possible use cases for this may include chaining tasks within the same pool like spawning separate send/receive I/O tasks after waiting on a network connection to be established, or allowing cross-pool dependent tasks like starting dependent multi-frame computations following a long I/O load.
Other task execution runtimes provide static access to spawning tasks (i.e. `tokio::spawn`), which is notably easier to use than the reference passing required by `bevy_tasks` right now.
This PR makes does the following:
* Adds `*TaskPool::init` which initializes a `OnceCell`'ed with a provided TaskPool. Failing if the pool has already been initialized.
* Adds `*TaskPool::get` which fetches the initialized global pool of the respective type or panics. This generally should not be an issue in normal Bevy use, as the pools are initialized before they are accessed.
* Updated default task pool initialization to either pull the global handles and save them as resources, or if they are already initialized, pull the a cloned global handle as the resource.
This should make it notably easier to build more complex task hierarchies for dependent tasks. It should also make writing bevy-adjacent, but not strictly bevy-only plugin crates easier, as the global pools ensure it's all running on the same threads.
One alternative considered is keeping a thread-local reference to the pool for all threads in each pool to enable the same `tokio::spawn` interface. This would spawn tasks on the same pool that a task is currently running in. However this potentially leads to potential footgun situations where long running blocking tasks run on `ComputeTaskPool`.
2022-06-09 02:43:24 +00:00
IoTaskPool ::get ( )
2022-01-07 07:19:22 +00:00
. scope ( | scope | {
gltf . textures ( ) . for_each ( | gltf_texture | {
let linear_textures = & linear_textures ;
let load_context : & LoadContext = load_context ;
let buffer_data = & buffer_data ;
scope . spawn ( async move {
2022-03-15 22:26:46 +00:00
load_texture (
gltf_texture ,
buffer_data ,
linear_textures ,
load_context ,
supported_compressed_formats ,
)
. await
2022-01-07 07:19:22 +00:00
} ) ;
2021-04-30 20:12:50 +00:00
} ) ;
2022-01-07 07:19:22 +00:00
} )
. into_iter ( )
. filter_map ( | res | {
if let Err ( err ) = res . as_ref ( ) {
warn! ( " Error loading glTF texture: {} " , err ) ;
}
res . ok ( )
} )
. for_each ( | ( texture , label ) | {
load_context . set_labeled_asset ( & label , LoadedAsset ::new ( texture ) ) ;
2021-04-30 20:12:50 +00:00
} ) ;
2022-01-07 07:19:22 +00:00
}
2021-04-30 20:12:50 +00:00
2022-03-29 18:31:13 +00:00
let skinned_mesh_inverse_bindposes : Vec < _ > = gltf
. skins ( )
. map ( | gltf_skin | {
let reader = gltf_skin . reader ( | buffer | Some ( & buffer_data [ buffer . index ( ) ] ) ) ;
let inverse_bindposes : Vec < Mat4 > = reader
. read_inverse_bind_matrices ( )
. unwrap ( )
. map ( | mat | Mat4 ::from_cols_array_2d ( & mat ) )
. collect ( ) ;
load_context . set_labeled_asset (
& skin_label ( & gltf_skin ) ,
LoadedAsset ::new ( SkinnedMeshInverseBindposes ::from ( inverse_bindposes ) ) ,
)
} )
. collect ( ) ;
2020-12-31 20:57:15 +00:00
let mut scenes = vec! [ ] ;
2021-12-14 03:58:23 +00:00
let mut named_scenes = HashMap ::default ( ) ;
Camera Driven Rendering (#4745)
This adds "high level camera driven rendering" to Bevy. The goal is to give users more control over what gets rendered (and where) without needing to deal with render logic. This will make scenarios like "render to texture", "multiple windows", "split screen", "2d on 3d", "3d on 2d", "pass layering", and more significantly easier.
Here is an [example of a 2d render sandwiched between two 3d renders (each from a different perspective)](https://gist.github.com/cart/4fe56874b2e53bc5594a182fc76f4915):
Users can now spawn a camera, point it at a RenderTarget (a texture or a window), and it will "just work".
Rendering to a second window is as simple as spawning a second camera and assigning it to a specific window id:
```rust
// main camera (main window)
commands.spawn_bundle(Camera2dBundle::default());
// second camera (other window)
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Window(window_id),
..default()
},
..default()
});
```
Rendering to a texture is as simple as pointing the camera at a texture:
```rust
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Texture(image_handle),
..default()
},
..default()
});
```
Cameras now have a "render priority", which controls the order they are drawn in. If you want to use a camera's output texture as a texture in the main pass, just set the priority to a number lower than the main pass camera (which defaults to `0`).
```rust
// main pass camera with a default priority of 0
commands.spawn_bundle(Camera2dBundle::default());
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Texture(image_handle.clone()),
priority: -1,
..default()
},
..default()
});
commands.spawn_bundle(SpriteBundle {
texture: image_handle,
..default()
})
```
Priority can also be used to layer to cameras on top of each other for the same RenderTarget. This is what "2d on top of 3d" looks like in the new system:
```rust
commands.spawn_bundle(Camera3dBundle::default());
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
// this will render 2d entities "on top" of the default 3d camera's render
priority: 1,
..default()
},
..default()
});
```
There is no longer the concept of a global "active camera". Resources like `ActiveCamera<Camera2d>` and `ActiveCamera<Camera3d>` have been replaced with the camera-specific `Camera::is_active` field. This does put the onus on users to manage which cameras should be active.
Cameras are now assigned a single render graph as an "entry point", which is configured on each camera entity using the new `CameraRenderGraph` component. The old `PerspectiveCameraBundle` and `OrthographicCameraBundle` (generic on camera marker components like Camera2d and Camera3d) have been replaced by `Camera3dBundle` and `Camera2dBundle`, which set 3d and 2d default values for the `CameraRenderGraph` and projections.
```rust
// old 3d perspective camera
commands.spawn_bundle(PerspectiveCameraBundle::default())
// new 3d perspective camera
commands.spawn_bundle(Camera3dBundle::default())
```
```rust
// old 2d orthographic camera
commands.spawn_bundle(OrthographicCameraBundle::new_2d())
// new 2d orthographic camera
commands.spawn_bundle(Camera2dBundle::default())
```
```rust
// old 3d orthographic camera
commands.spawn_bundle(OrthographicCameraBundle::new_3d())
// new 3d orthographic camera
commands.spawn_bundle(Camera3dBundle {
projection: OrthographicProjection {
scale: 3.0,
scaling_mode: ScalingMode::FixedVertical,
..default()
}.into(),
..default()
})
```
Note that `Camera3dBundle` now uses a new `Projection` enum instead of hard coding the projection into the type. There are a number of motivators for this change: the render graph is now a part of the bundle, the way "generic bundles" work in the rust type system prevents nice `..default()` syntax, and changing projections at runtime is much easier with an enum (ex for editor scenarios). I'm open to discussing this choice, but I'm relatively certain we will all come to the same conclusion here. Camera2dBundle and Camera3dBundle are much clearer than being generic on marker components / using non-default constructors.
If you want to run a custom render graph on a camera, just set the `CameraRenderGraph` component:
```rust
commands.spawn_bundle(Camera3dBundle {
camera_render_graph: CameraRenderGraph::new(some_render_graph_name),
..default()
})
```
Just note that if the graph requires data from specific components to work (such as `Camera3d` config, which is provided in the `Camera3dBundle`), make sure the relevant components have been added.
Speaking of using components to configure graphs / passes, there are a number of new configuration options:
```rust
commands.spawn_bundle(Camera3dBundle {
camera_3d: Camera3d {
// overrides the default global clear color
clear_color: ClearColorConfig::Custom(Color::RED),
..default()
},
..default()
})
commands.spawn_bundle(Camera3dBundle {
camera_3d: Camera3d {
// disables clearing
clear_color: ClearColorConfig::None,
..default()
},
..default()
})
```
Expect to see more of the "graph configuration Components on Cameras" pattern in the future.
By popular demand, UI no longer requires a dedicated camera. `UiCameraBundle` has been removed. `Camera2dBundle` and `Camera3dBundle` now both default to rendering UI as part of their own render graphs. To disable UI rendering for a camera, disable it using the CameraUi component:
```rust
commands
.spawn_bundle(Camera3dBundle::default())
.insert(CameraUi {
is_enabled: false,
..default()
})
```
## Other Changes
* The separate clear pass has been removed. We should revisit this for things like sky rendering, but I think this PR should "keep it simple" until we're ready to properly support that (for code complexity and performance reasons). We can come up with the right design for a modular clear pass in a followup pr.
* I reorganized bevy_core_pipeline into Core2dPlugin and Core3dPlugin (and core_2d / core_3d modules). Everything is pretty much the same as before, just logically separate. I've moved relevant types (like Camera2d, Camera3d, Camera3dBundle, Camera2dBundle) into their relevant modules, which is what motivated this reorganization.
* I adapted the `scene_viewer` example (which relied on the ActiveCameras behavior) to the new system. I also refactored bits and pieces to be a bit simpler.
* All of the examples have been ported to the new camera approach. `render_to_texture` and `multiple_windows` are now _much_ simpler. I removed `two_passes` because it is less relevant with the new approach. If someone wants to add a new "layered custom pass with CameraRenderGraph" example, that might fill a similar niche. But I don't feel much pressure to add that in this pr.
* Cameras now have `target_logical_size` and `target_physical_size` fields, which makes finding the size of a camera's render target _much_ simpler. As a result, the `Assets<Image>` and `Windows` parameters were removed from `Camera::world_to_screen`, making that operation much more ergonomic.
* Render order ambiguities between cameras with the same target and the same priority now produce a warning. This accomplishes two goals:
1. Now that there is no "global" active camera, by default spawning two cameras will result in two renders (one covering the other). This would be a silent performance killer that would be hard to detect after the fact. By detecting ambiguities, we can provide a helpful warning when this occurs.
2. Render order ambiguities could result in unexpected / unpredictable render results. Resolving them makes sense.
## Follow Up Work
* Per-Camera viewports, which will make it possible to render to a smaller area inside of a RenderTarget (great for something like splitscreen)
* Camera-specific MSAA config (should use the same "overriding" pattern used for ClearColor)
* Graph Based Camera Ordering: priorities are simple, but they make complicated ordering constraints harder to express. We should consider adopting a "graph based" camera ordering model with "before" and "after" relationships to other cameras (or build it "on top" of the priority system).
* Consider allowing graphs to run subgraphs from any nest level (aka a global namespace for graphs). Right now the 2d and 3d graphs each need their own UI subgraph, which feels "fine" in the short term. But being able to share subgraphs between other subgraphs seems valuable.
* Consider splitting `bevy_core_pipeline` into `bevy_core_2d` and `bevy_core_3d` packages. Theres a shared "clear color" dependency here, which would need a new home.
2022-06-02 00:12:17 +00:00
let mut active_camera_found = false ;
2020-10-18 20:48:15 +00:00
for scene in gltf . scenes ( ) {
let mut err = None ;
2020-12-31 20:57:15 +00:00
let mut world = World ::default ( ) ;
2022-03-29 18:31:13 +00:00
let mut node_index_to_entity_map = HashMap ::new ( ) ;
let mut entity_to_skin_index_map = HashMap ::new ( ) ;
Bevy ECS V2 (#1525)
# Bevy ECS V2
This is a rewrite of Bevy ECS (basically everything but the new executor/schedule, which are already awesome). The overall goal was to improve the performance and versatility of Bevy ECS. Here is a quick bulleted list of changes before we dive into the details:
* Complete World rewrite
* Multiple component storage types:
* Tables: fast cache friendly iteration, slower add/removes (previously called Archetypes)
* Sparse Sets: fast add/remove, slower iteration
* Stateful Queries (caches query results for faster iteration. fragmented iteration is _fast_ now)
* Stateful System Params (caches expensive operations. inspired by @DJMcNab's work in #1364)
* Configurable System Params (users can set configuration when they construct their systems. once again inspired by @DJMcNab's work)
* Archetypes are now "just metadata", component storage is separate
* Archetype Graph (for faster archetype changes)
* Component Metadata
* Configure component storage type
* Retrieve information about component size/type/name/layout/send-ness/etc
* Components are uniquely identified by a densely packed ComponentId
* TypeIds are now totally optional (which should make implementing scripting easier)
* Super fast "for_each" query iterators
* Merged Resources into World. Resources are now just a special type of component
* EntityRef/EntityMut builder apis (more efficient and more ergonomic)
* Fast bitset-backed `Access<T>` replaces old hashmap-based approach everywhere
* Query conflicts are determined by component access instead of archetype component access (to avoid random failures at runtime)
* With/Without are still taken into account for conflicts, so this should still be comfy to use
* Much simpler `IntoSystem` impl
* Significantly reduced the amount of hashing throughout the ecs in favor of Sparse Sets (indexed by densely packed ArchetypeId, ComponentId, BundleId, and TableId)
* Safety Improvements
* Entity reservation uses a normal world reference instead of unsafe transmute
* QuerySets no longer transmute lifetimes
* Made traits "unsafe" where relevant
* More thorough safety docs
* WorldCell
* Exposes safe mutable access to multiple resources at a time in a World
* Replaced "catch all" `System::update_archetypes(world: &World)` with `System::new_archetype(archetype: &Archetype)`
* Simpler Bundle implementation
* Replaced slow "remove_bundle_one_by_one" used as fallback for Commands::remove_bundle with fast "remove_bundle_intersection"
* Removed `Mut<T>` query impl. it is better to only support one way: `&mut T`
* Removed with() from `Flags<T>` in favor of `Option<Flags<T>>`, which allows querying for flags to be "filtered" by default
* Components now have is_send property (currently only resources support non-send)
* More granular module organization
* New `RemovedComponents<T>` SystemParam that replaces `query.removed::<T>()`
* `world.resource_scope()` for mutable access to resources and world at the same time
* WorldQuery and QueryFilter traits unified. FilterFetch trait added to enable "short circuit" filtering. Auto impled for cases that don't need it
* Significantly slimmed down SystemState in favor of individual SystemParam state
* System Commands changed from `commands: &mut Commands` back to `mut commands: Commands` (to allow Commands to have a World reference)
Fixes #1320
## `World` Rewrite
This is a from-scratch rewrite of `World` that fills the niche that `hecs` used to. Yes, this means Bevy ECS is no longer a "fork" of hecs. We're going out our own!
(the only shared code between the projects is the entity id allocator, which is already basically ideal)
A huge shout out to @SanderMertens (author of [flecs](https://github.com/SanderMertens/flecs)) for sharing some great ideas with me (specifically hybrid ecs storage and archetype graphs). He also helped advise on a number of implementation details.
## Component Storage (The Problem)
Two ECS storage paradigms have gained a lot of traction over the years:
* **Archetypal ECS**:
* Stores components in "tables" with static schemas. Each "column" stores components of a given type. Each "row" is an entity.
* Each "archetype" has its own table. Adding/removing an entity's component changes the archetype.
* Enables super-fast Query iteration due to its cache-friendly data layout
* Comes at the cost of more expensive add/remove operations for an Entity's components, because all components need to be copied to the new archetype's "table"
* **Sparse Set ECS**:
* Stores components of the same type in densely packed arrays, which are sparsely indexed by densely packed unsigned integers (Entity ids)
* Query iteration is slower than Archetypal ECS because each entity's component could be at any position in the sparse set. This "random access" pattern isn't cache friendly. Additionally, there is an extra layer of indirection because you must first map the entity id to an index in the component array.
* Adding/removing components is a cheap, constant time operation
Bevy ECS V1, hecs, legion, flec, and Unity DOTS are all "archetypal ecs-es". I personally think "archetypal" storage is a good default for game engines. An entity's archetype doesn't need to change frequently in general, and it creates "fast by default" query iteration (which is a much more common operation). It is also "self optimizing". Users don't need to think about optimizing component layouts for iteration performance. It "just works" without any extra boilerplate.
Shipyard and EnTT are "sparse set ecs-es". They employ "packing" as a way to work around the "suboptimal by default" iteration performance for specific sets of components. This helps, but I didn't think this was a good choice for a general purpose engine like Bevy because:
1. "packs" conflict with each other. If bevy decides to internally pack the Transform and GlobalTransform components, users are then blocked if they want to pack some custom component with Transform.
2. users need to take manual action to optimize
Developers selecting an ECS framework are stuck with a hard choice. Select an "archetypal" framework with "fast iteration everywhere" but without the ability to cheaply add/remove components, or select a "sparse set" framework to cheaply add/remove components but with slower iteration performance.
## Hybrid Component Storage (The Solution)
In Bevy ECS V2, we get to have our cake and eat it too. It now has _both_ of the component storage types above (and more can be added later if needed):
* **Tables** (aka "archetypal" storage)
* The default storage. If you don't configure anything, this is what you get
* Fast iteration by default
* Slower add/remove operations
* **Sparse Sets**
* Opt-in
* Slower iteration
* Faster add/remove operations
These storage types complement each other perfectly. By default Query iteration is fast. If developers know that they want to add/remove a component at high frequencies, they can set the storage to "sparse set":
```rust
world.register_component(
ComponentDescriptor::new::<MyComponent>(StorageType::SparseSet)
).unwrap();
```
## Archetypes
Archetypes are now "just metadata" ... they no longer store components directly. They do store:
* The `ComponentId`s of each of the Archetype's components (and that component's storage type)
* Archetypes are uniquely defined by their component layouts
* For example: entities with "table" components `[A, B, C]` _and_ "sparse set" components `[D, E]` will always be in the same archetype.
* The `TableId` associated with the archetype
* For now each archetype has exactly one table (which can have no components),
* There is a 1->Many relationship from Tables->Archetypes. A given table could have any number of archetype components stored in it:
* Ex: an entity with "table storage" components `[A, B, C]` and "sparse set" components `[D, E]` will share the same `[A, B, C]` table as an entity with `[A, B, C]` table component and `[F]` sparse set components.
* This 1->Many relationship is how we preserve fast "cache friendly" iteration performance when possible (more on this later)
* A list of entities that are in the archetype and the row id of the table they are in
* ArchetypeComponentIds
* unique densely packed identifiers for (ArchetypeId, ComponentId) pairs
* used by the schedule executor for cheap system access control
* "Archetype Graph Edges" (see the next section)
## The "Archetype Graph"
Archetype changes in Bevy (and a number of other archetypal ecs-es) have historically been expensive to compute. First, you need to allocate a new vector of the entity's current component ids, add or remove components based on the operation performed, sort it (to ensure it is order-independent), then hash it to find the archetype (if it exists). And thats all before we get to the _already_ expensive full copy of all components to the new table storage.
The solution is to build a "graph" of archetypes to cache these results. @SanderMertens first exposed me to the idea (and he got it from @gjroelofs, who came up with it). They propose adding directed edges between archetypes for add/remove component operations. If `ComponentId`s are densely packed, you can use sparse sets to cheaply jump between archetypes.
Bevy takes this one step further by using add/remove `Bundle` edges instead of `Component` edges. Bevy encourages the use of `Bundles` to group add/remove operations. This is largely for "clearer game logic" reasons, but it also helps cut down on the number of archetype changes required. `Bundles` now also have densely-packed `BundleId`s. This allows us to use a _single_ edge for each bundle operation (rather than needing to traverse N edges ... one for each component). Single component operations are also bundles, so this is strictly an improvement over a "component only" graph.
As a result, an operation that used to be _heavy_ (both for allocations and compute) is now two dirt-cheap array lookups and zero allocations.
## Stateful Queries
World queries are now stateful. This allows us to:
1. Cache archetype (and table) matches
* This resolves another issue with (naive) archetypal ECS: query performance getting worse as the number of archetypes goes up (and fragmentation occurs).
2. Cache Fetch and Filter state
* The expensive parts of fetch/filter operations (such as hashing the TypeId to find the ComponentId) now only happen once when the Query is first constructed
3. Incrementally build up state
* When new archetypes are added, we only process the new archetypes (no need to rebuild state for old archetypes)
As a result, the direct `World` query api now looks like this:
```rust
let mut query = world.query::<(&A, &mut B)>();
for (a, mut b) in query.iter_mut(&mut world) {
}
```
Requiring `World` to generate stateful queries (rather than letting the `QueryState` type be constructed separately) allows us to ensure that _all_ queries are properly initialized (and the relevant world state, such as ComponentIds). This enables QueryState to remove branches from its operations that check for initialization status (and also enables query.iter() to take an immutable world reference because it doesn't need to initialize anything in world).
However in systems, this is a non-breaking change. State management is done internally by the relevant SystemParam.
## Stateful SystemParams
Like Queries, `SystemParams` now also cache state. For example, `Query` system params store the "stateful query" state mentioned above. Commands store their internal `CommandQueue`. This means you can now safely use as many separate `Commands` parameters in your system as you want. `Local<T>` system params store their `T` value in their state (instead of in Resources).
SystemParam state also enabled a significant slim-down of SystemState. It is much nicer to look at now.
Per-SystemParam state naturally insulates us from an "aliased mut" class of errors we have hit in the past (ex: using multiple `Commands` system params).
(credit goes to @DJMcNab for the initial idea and draft pr here #1364)
## Configurable SystemParams
@DJMcNab also had the great idea to make SystemParams configurable. This allows users to provide some initial configuration / values for system parameters (when possible). Most SystemParams have no config (the config type is `()`), but the `Local<T>` param now supports user-provided parameters:
```rust
fn foo(value: Local<usize>) {
}
app.add_system(foo.system().config(|c| c.0 = Some(10)));
```
## Uber Fast "for_each" Query Iterators
Developers now have the choice to use a fast "for_each" iterator, which yields ~1.5-3x iteration speed improvements for "fragmented iteration", and minor ~1.2x iteration speed improvements for unfragmented iteration.
```rust
fn system(query: Query<(&A, &mut B)>) {
// you now have the option to do this for a speed boost
query.for_each_mut(|(a, mut b)| {
});
// however normal iterators are still available
for (a, mut b) in query.iter_mut() {
}
}
```
I think in most cases we should continue to encourage "normal" iterators as they are more flexible and more "rust idiomatic". But when that extra "oomf" is needed, it makes sense to use `for_each`.
We should also consider using `for_each` for internal bevy systems to give our users a nice speed boost (but that should be a separate pr).
## Component Metadata
`World` now has a `Components` collection, which is accessible via `world.components()`. This stores mappings from `ComponentId` to `ComponentInfo`, as well as `TypeId` to `ComponentId` mappings (where relevant). `ComponentInfo` stores information about the component, such as ComponentId, TypeId, memory layout, send-ness (currently limited to resources), and storage type.
## Significantly Cheaper `Access<T>`
We used to use `TypeAccess<TypeId>` to manage read/write component/archetype-component access. This was expensive because TypeIds must be hashed and compared individually. The parallel executor got around this by "condensing" type ids into bitset-backed access types. This worked, but it had to be re-generated from the `TypeAccess<TypeId>`sources every time archetypes changed.
This pr removes TypeAccess in favor of faster bitset access everywhere. We can do this thanks to the move to densely packed `ComponentId`s and `ArchetypeComponentId`s.
## Merged Resources into World
Resources had a lot of redundant functionality with Components. They stored typed data, they had access control, they had unique ids, they were queryable via SystemParams, etc. In fact the _only_ major difference between them was that they were unique (and didn't correlate to an entity).
Separate resources also had the downside of requiring a separate set of access controls, which meant the parallel executor needed to compare more bitsets per system and manage more state.
I initially got the "separate resources" idea from `legion`. I think that design was motivated by the fact that it made the direct world query/resource lifetime interactions more manageable. It certainly made our lives easier when using Resources alongside hecs/bevy_ecs. However we already have a construct for safely and ergonomically managing in-world lifetimes: systems (which use `Access<T>` internally).
This pr merges Resources into World:
```rust
world.insert_resource(1);
world.insert_resource(2.0);
let a = world.get_resource::<i32>().unwrap();
let mut b = world.get_resource_mut::<f64>().unwrap();
*b = 3.0;
```
Resources are now just a special kind of component. They have their own ComponentIds (and their own resource TypeId->ComponentId scope, so they don't conflict wit components of the same type). They are stored in a special "resource archetype", which stores components inside the archetype using a new `unique_components` sparse set (note that this sparse set could later be used to implement Tags). This allows us to keep the code size small by reusing existing datastructures (namely Column, Archetype, ComponentFlags, and ComponentInfo). This allows us the executor to use a single `Access<ArchetypeComponentId>` per system. It should also make scripting language integration easier.
_But_ this merge did create problems for people directly interacting with `World`. What if you need mutable access to multiple resources at the same time? `world.get_resource_mut()` borrows World mutably!
## WorldCell
WorldCell applies the `Access<ArchetypeComponentId>` concept to direct world access:
```rust
let world_cell = world.cell();
let a = world_cell.get_resource_mut::<i32>().unwrap();
let b = world_cell.get_resource_mut::<f64>().unwrap();
```
This adds cheap runtime checks (a sparse set lookup of `ArchetypeComponentId` and a counter) to ensure that world accesses do not conflict with each other. Each operation returns a `WorldBorrow<'w, T>` or `WorldBorrowMut<'w, T>` wrapper type, which will release the relevant ArchetypeComponentId resources when dropped.
World caches the access sparse set (and only one cell can exist at a time), so `world.cell()` is a cheap operation.
WorldCell does _not_ use atomic operations. It is non-send, does a mutable borrow of world to prevent other accesses, and uses a simple `Rc<RefCell<ArchetypeComponentAccess>>` wrapper in each WorldBorrow pointer.
The api is currently limited to resource access, but it can and should be extended to queries / entity component access.
## Resource Scopes
WorldCell does not yet support component queries, and even when it does there are sometimes legitimate reasons to want a mutable world ref _and_ a mutable resource ref (ex: bevy_render and bevy_scene both need this). In these cases we could always drop down to the unsafe `world.get_resource_unchecked_mut()`, but that is not ideal!
Instead developers can use a "resource scope"
```rust
world.resource_scope(|world: &mut World, a: &mut A| {
})
```
This temporarily removes the `A` resource from `World`, provides mutable pointers to both, and re-adds A to World when finished. Thanks to the move to ComponentIds/sparse sets, this is a cheap operation.
If multiple resources are required, scopes can be nested. We could also consider adding a "resource tuple" to the api if this pattern becomes common and the boilerplate gets nasty.
## Query Conflicts Use ComponentId Instead of ArchetypeComponentId
For safety reasons, systems cannot contain queries that conflict with each other without wrapping them in a QuerySet. On bevy `main`, we use ArchetypeComponentIds to determine conflicts. This is nice because it can take into account filters:
```rust
// these queries will never conflict due to their filters
fn filter_system(a: Query<&mut A, With<B>>, b: Query<&mut B, Without<B>>) {
}
```
But it also has a significant downside:
```rust
// these queries will not conflict _until_ an entity with A, B, and C is spawned
fn maybe_conflicts_system(a: Query<(&mut A, &C)>, b: Query<(&mut A, &B)>) {
}
```
The system above will panic at runtime if an entity with A, B, and C is spawned. This makes it hard to trust that your game logic will run without crashing.
In this pr, I switched to using `ComponentId` instead. This _is_ more constraining. `maybe_conflicts_system` will now always fail, but it will do it consistently at startup. Naively, it would also _disallow_ `filter_system`, which would be a significant downgrade in usability. Bevy has a number of internal systems that rely on disjoint queries and I expect it to be a common pattern in userspace.
To resolve this, I added a new `FilteredAccess<T>` type, which wraps `Access<T>` and adds with/without filters. If two `FilteredAccess` have with/without values that prove they are disjoint, they will no longer conflict.
## EntityRef / EntityMut
World entity operations on `main` require that the user passes in an `entity` id to each operation:
```rust
let entity = world.spawn((A, )); // create a new entity with A
world.get::<A>(entity);
world.insert(entity, (B, C));
world.insert_one(entity, D);
```
This means that each operation needs to look up the entity location / verify its validity. The initial spawn operation also requires a Bundle as input. This can be awkward when no components are required (or one component is required).
These operations have been replaced by `EntityRef` and `EntityMut`, which are "builder-style" wrappers around world that provide read and read/write operations on a single, pre-validated entity:
```rust
// spawn now takes no inputs and returns an EntityMut
let entity = world.spawn()
.insert(A) // insert a single component into the entity
.insert_bundle((B, C)) // insert a bundle of components into the entity
.id() // id returns the Entity id
// Returns EntityMut (or panics if the entity does not exist)
world.entity_mut(entity)
.insert(D)
.insert_bundle(SomeBundle::default());
{
// returns EntityRef (or panics if the entity does not exist)
let d = world.entity(entity)
.get::<D>() // gets the D component
.unwrap();
// world.get still exists for ergonomics
let d = world.get::<D>(entity).unwrap();
}
// These variants return Options if you want to check existence instead of panicing
world.get_entity_mut(entity)
.unwrap()
.insert(E);
if let Some(entity_ref) = world.get_entity(entity) {
let d = entity_ref.get::<D>().unwrap();
}
```
This _does not_ affect the current Commands api or terminology. I think that should be a separate conversation as that is a much larger breaking change.
## Safety Improvements
* Entity reservation in Commands uses a normal world borrow instead of an unsafe transmute
* QuerySets no longer transmutes lifetimes
* Made traits "unsafe" when implementing a trait incorrectly could cause unsafety
* More thorough safety docs
## RemovedComponents SystemParam
The old approach to querying removed components: `query.removed:<T>()` was confusing because it had no connection to the query itself. I replaced it with the following, which is both clearer and allows us to cache the ComponentId mapping in the SystemParamState:
```rust
fn system(removed: RemovedComponents<T>) {
for entity in removed.iter() {
}
}
```
## Simpler Bundle implementation
Bundles are no longer responsible for sorting (or deduping) TypeInfo. They are just a simple ordered list of component types / data. This makes the implementation smaller and opens the door to an easy "nested bundle" implementation in the future (which i might even add in this pr). Duplicate detection is now done once per bundle type by World the first time a bundle is used.
## Unified WorldQuery and QueryFilter types
(don't worry they are still separate type _parameters_ in Queries .. this is a non-breaking change)
WorldQuery and QueryFilter were already basically identical apis. With the addition of `FetchState` and more storage-specific fetch methods, the overlap was even clearer (and the redundancy more painful).
QueryFilters are now just `F: WorldQuery where F::Fetch: FilterFetch`. FilterFetch requires `Fetch<Item = bool>` and adds new "short circuit" variants of fetch methods. This enables a filter tuple like `(With<A>, Without<B>, Changed<C>)` to stop evaluating the filter after the first mismatch is encountered. FilterFetch is automatically implemented for `Fetch` implementations that return bool.
This forces fetch implementations that return things like `(bool, bool, bool)` (such as the filter above) to manually implement FilterFetch and decide whether or not to short-circuit.
## More Granular Modules
World no longer globs all of the internal modules together. It now exports `core`, `system`, and `schedule` separately. I'm also considering exporting `core` submodules directly as that is still pretty "glob-ey" and unorganized (feedback welcome here).
## Remaining Draft Work (to be done in this pr)
* ~~panic on conflicting WorldQuery fetches (&A, &mut A)~~
* ~~bevy `main` and hecs both currently allow this, but we should protect against it if possible~~
* ~~batch_iter / par_iter (currently stubbed out)~~
* ~~ChangedRes~~
* ~~I skipped this while we sort out #1313. This pr should be adapted to account for whatever we land on there~~.
* ~~The `Archetypes` and `Tables` collections use hashes of sorted lists of component ids to uniquely identify each archetype/table. This hash is then used as the key in a HashMap to look up the relevant ArchetypeId or TableId. (which doesn't handle hash collisions properly)~~
* ~~It is currently unsafe to generate a Query from "World A", then use it on "World B" (despite the api claiming it is safe). We should probably close this gap. This could be done by adding a randomly generated WorldId to each world, then storing that id in each Query. They could then be compared to each other on each `query.do_thing(&world)` operation. This _does_ add an extra branch to each query operation, so I'm open to other suggestions if people have them.~~
* ~~Nested Bundles (if i find time)~~
## Potential Future Work
* Expand WorldCell to support queries.
* Consider not allocating in the empty archetype on `world.spawn()`
* ex: return something like EntityMutUninit, which turns into EntityMut after an `insert` or `insert_bundle` op
* this actually regressed performance last time i tried it, but in theory it should be faster
* Optimize SparseSet::insert (see `PERF` comment on insert)
* Replace SparseArray `Option<T>` with T::MAX to cut down on branching
* would enable cheaper get_unchecked() operations
* upstream fixedbitset optimizations
* fixedbitset could be allocation free for small block counts (store blocks in a SmallVec)
* fixedbitset could have a const constructor
* Consider implementing Tags (archetype-specific by-value data that affects archetype identity)
* ex: ArchetypeA could have `[A, B, C]` table components and `[D(1)]` "tag" component. ArchetypeB could have `[A, B, C]` table components and a `[D(2)]` tag component. The archetypes are different, despite both having D tags because the value inside D is different.
* this could potentially build on top of the `archetype.unique_components` added in this pr for resource storage.
* Consider reverting `all_tuples` proc macro in favor of the old `macro_rules` implementation
* all_tuples is more flexible and produces cleaner documentation (the macro_rules version produces weird type parameter orders due to parser constraints)
* but unfortunately all_tuples also appears to make Rust Analyzer sad/slow when working inside of `bevy_ecs` (does not affect user code)
* Consider "resource queries" and/or "mixed resource and entity component queries" as an alternative to WorldCell
* this is basically just "systems" so maybe it's not worth it
* Add more world ops
* `world.clear()`
* `world.reserve<T: Bundle>(count: usize)`
* Try using the old archetype allocation strategy (allocate new memory on resize and copy everything over). I expect this to improve batch insertion performance at the cost of unbatched performance. But thats just a guess. I'm not an allocation perf pro :)
* Adapt Commands apis for consistency with new World apis
## Benchmarks
key:
* `bevy_old`: bevy `main` branch
* `bevy`: this branch
* `_foreach`: uses an optimized for_each iterator
* ` _sparse`: uses sparse set storage (if unspecified assume table storage)
* `_system`: runs inside a system (if unspecified assume test happens via direct world ops)
### Simple Insert (from ecs_bench_suite)
### Simpler Iter (from ecs_bench_suite)
### Fragment Iter (from ecs_bench_suite)
### Sparse Fragmented Iter
Iterate a query that matches 5 entities from a single matching archetype, but there are 100 unmatching archetypes
### Schedule (from ecs_bench_suite)
### Add Remove Component (from ecs_bench_suite)
### Add Remove Component Big
Same as the test above, but each entity has 5 "large" matrix components and 1 "large" matrix component is added and removed
### Get Component
Looks up a single component value a large number of times
2021-03-05 07:54:35 +00:00
world
. spawn ( )
2022-02-06 01:07:55 +00:00
. insert_bundle ( TransformBundle ::identity ( ) )
2020-10-18 20:48:15 +00:00
. with_children ( | parent | {
for node in scene . nodes ( ) {
2022-03-29 18:31:13 +00:00
let result = load_node (
& node ,
parent ,
load_context ,
& buffer_data ,
& mut node_index_to_entity_map ,
& mut entity_to_skin_index_map ,
Camera Driven Rendering (#4745)
This adds "high level camera driven rendering" to Bevy. The goal is to give users more control over what gets rendered (and where) without needing to deal with render logic. This will make scenarios like "render to texture", "multiple windows", "split screen", "2d on 3d", "3d on 2d", "pass layering", and more significantly easier.
Here is an [example of a 2d render sandwiched between two 3d renders (each from a different perspective)](https://gist.github.com/cart/4fe56874b2e53bc5594a182fc76f4915):
Users can now spawn a camera, point it at a RenderTarget (a texture or a window), and it will "just work".
Rendering to a second window is as simple as spawning a second camera and assigning it to a specific window id:
```rust
// main camera (main window)
commands.spawn_bundle(Camera2dBundle::default());
// second camera (other window)
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Window(window_id),
..default()
},
..default()
});
```
Rendering to a texture is as simple as pointing the camera at a texture:
```rust
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Texture(image_handle),
..default()
},
..default()
});
```
Cameras now have a "render priority", which controls the order they are drawn in. If you want to use a camera's output texture as a texture in the main pass, just set the priority to a number lower than the main pass camera (which defaults to `0`).
```rust
// main pass camera with a default priority of 0
commands.spawn_bundle(Camera2dBundle::default());
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Texture(image_handle.clone()),
priority: -1,
..default()
},
..default()
});
commands.spawn_bundle(SpriteBundle {
texture: image_handle,
..default()
})
```
Priority can also be used to layer to cameras on top of each other for the same RenderTarget. This is what "2d on top of 3d" looks like in the new system:
```rust
commands.spawn_bundle(Camera3dBundle::default());
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
// this will render 2d entities "on top" of the default 3d camera's render
priority: 1,
..default()
},
..default()
});
```
There is no longer the concept of a global "active camera". Resources like `ActiveCamera<Camera2d>` and `ActiveCamera<Camera3d>` have been replaced with the camera-specific `Camera::is_active` field. This does put the onus on users to manage which cameras should be active.
Cameras are now assigned a single render graph as an "entry point", which is configured on each camera entity using the new `CameraRenderGraph` component. The old `PerspectiveCameraBundle` and `OrthographicCameraBundle` (generic on camera marker components like Camera2d and Camera3d) have been replaced by `Camera3dBundle` and `Camera2dBundle`, which set 3d and 2d default values for the `CameraRenderGraph` and projections.
```rust
// old 3d perspective camera
commands.spawn_bundle(PerspectiveCameraBundle::default())
// new 3d perspective camera
commands.spawn_bundle(Camera3dBundle::default())
```
```rust
// old 2d orthographic camera
commands.spawn_bundle(OrthographicCameraBundle::new_2d())
// new 2d orthographic camera
commands.spawn_bundle(Camera2dBundle::default())
```
```rust
// old 3d orthographic camera
commands.spawn_bundle(OrthographicCameraBundle::new_3d())
// new 3d orthographic camera
commands.spawn_bundle(Camera3dBundle {
projection: OrthographicProjection {
scale: 3.0,
scaling_mode: ScalingMode::FixedVertical,
..default()
}.into(),
..default()
})
```
Note that `Camera3dBundle` now uses a new `Projection` enum instead of hard coding the projection into the type. There are a number of motivators for this change: the render graph is now a part of the bundle, the way "generic bundles" work in the rust type system prevents nice `..default()` syntax, and changing projections at runtime is much easier with an enum (ex for editor scenarios). I'm open to discussing this choice, but I'm relatively certain we will all come to the same conclusion here. Camera2dBundle and Camera3dBundle are much clearer than being generic on marker components / using non-default constructors.
If you want to run a custom render graph on a camera, just set the `CameraRenderGraph` component:
```rust
commands.spawn_bundle(Camera3dBundle {
camera_render_graph: CameraRenderGraph::new(some_render_graph_name),
..default()
})
```
Just note that if the graph requires data from specific components to work (such as `Camera3d` config, which is provided in the `Camera3dBundle`), make sure the relevant components have been added.
Speaking of using components to configure graphs / passes, there are a number of new configuration options:
```rust
commands.spawn_bundle(Camera3dBundle {
camera_3d: Camera3d {
// overrides the default global clear color
clear_color: ClearColorConfig::Custom(Color::RED),
..default()
},
..default()
})
commands.spawn_bundle(Camera3dBundle {
camera_3d: Camera3d {
// disables clearing
clear_color: ClearColorConfig::None,
..default()
},
..default()
})
```
Expect to see more of the "graph configuration Components on Cameras" pattern in the future.
By popular demand, UI no longer requires a dedicated camera. `UiCameraBundle` has been removed. `Camera2dBundle` and `Camera3dBundle` now both default to rendering UI as part of their own render graphs. To disable UI rendering for a camera, disable it using the CameraUi component:
```rust
commands
.spawn_bundle(Camera3dBundle::default())
.insert(CameraUi {
is_enabled: false,
..default()
})
```
## Other Changes
* The separate clear pass has been removed. We should revisit this for things like sky rendering, but I think this PR should "keep it simple" until we're ready to properly support that (for code complexity and performance reasons). We can come up with the right design for a modular clear pass in a followup pr.
* I reorganized bevy_core_pipeline into Core2dPlugin and Core3dPlugin (and core_2d / core_3d modules). Everything is pretty much the same as before, just logically separate. I've moved relevant types (like Camera2d, Camera3d, Camera3dBundle, Camera2dBundle) into their relevant modules, which is what motivated this reorganization.
* I adapted the `scene_viewer` example (which relied on the ActiveCameras behavior) to the new system. I also refactored bits and pieces to be a bit simpler.
* All of the examples have been ported to the new camera approach. `render_to_texture` and `multiple_windows` are now _much_ simpler. I removed `two_passes` because it is less relevant with the new approach. If someone wants to add a new "layered custom pass with CameraRenderGraph" example, that might fill a similar niche. But I don't feel much pressure to add that in this pr.
* Cameras now have `target_logical_size` and `target_physical_size` fields, which makes finding the size of a camera's render target _much_ simpler. As a result, the `Assets<Image>` and `Windows` parameters were removed from `Camera::world_to_screen`, making that operation much more ergonomic.
* Render order ambiguities between cameras with the same target and the same priority now produce a warning. This accomplishes two goals:
1. Now that there is no "global" active camera, by default spawning two cameras will result in two renders (one covering the other). This would be a silent performance killer that would be hard to detect after the fact. By detecting ambiguities, we can provide a helpful warning when this occurs.
2. Render order ambiguities could result in unexpected / unpredictable render results. Resolving them makes sense.
## Follow Up Work
* Per-Camera viewports, which will make it possible to render to a smaller area inside of a RenderTarget (great for something like splitscreen)
* Camera-specific MSAA config (should use the same "overriding" pattern used for ClearColor)
* Graph Based Camera Ordering: priorities are simple, but they make complicated ordering constraints harder to express. We should consider adopting a "graph based" camera ordering model with "before" and "after" relationships to other cameras (or build it "on top" of the priority system).
* Consider allowing graphs to run subgraphs from any nest level (aka a global namespace for graphs). Right now the 2d and 3d graphs each need their own UI subgraph, which feels "fine" in the short term. But being able to share subgraphs between other subgraphs seems valuable.
* Consider splitting `bevy_core_pipeline` into `bevy_core_2d` and `bevy_core_3d` packages. Theres a shared "clear color" dependency here, which would need a new home.
2022-06-02 00:12:17 +00:00
& mut active_camera_found ,
2022-03-29 18:31:13 +00:00
) ;
2020-10-18 20:48:15 +00:00
if result . is_err ( ) {
err = Some ( result ) ;
return ;
}
}
} ) ;
if let Some ( Err ( err ) ) = err {
return Err ( err ) ;
}
2022-03-29 18:31:13 +00:00
2022-04-02 22:36:02 +00:00
#[ cfg(feature = " bevy_animation " ) ]
2022-04-05 21:52:00 +00:00
{
// for each node root in a scene, check if it's the root of an animation
// if it is, add the AnimationPlayer component
for node in scene . nodes ( ) {
if animation_roots . contains ( & node . index ( ) ) {
world
. entity_mut ( * node_index_to_entity_map . get ( & node . index ( ) ) . unwrap ( ) )
2022-05-10 20:01:55 +00:00
. insert ( bevy_animation ::AnimationPlayer ::default ( ) ) ;
2022-04-05 21:52:00 +00:00
}
}
2022-04-02 22:36:02 +00:00
}
2022-03-29 18:31:13 +00:00
for ( & entity , & skin_index ) in & entity_to_skin_index_map {
let mut entity = world . entity_mut ( entity ) ;
let skin = gltf . skins ( ) . nth ( skin_index ) . unwrap ( ) ;
let joint_entities : Vec < _ > = skin
. joints ( )
. map ( | node | node_index_to_entity_map [ & node . index ( ) ] )
. collect ( ) ;
entity . insert ( SkinnedMesh {
inverse_bindposes : skinned_mesh_inverse_bindposes [ skin_index ] . clone ( ) ,
joints : joint_entities ,
} ) ;
}
2020-12-31 20:57:15 +00:00
let scene_handle = load_context
. set_labeled_asset ( & scene_label ( & scene ) , LoadedAsset ::new ( Scene ::new ( world ) ) ) ;
if let Some ( name ) = scene . name ( ) {
named_scenes . insert ( name . to_string ( ) , scene_handle . clone ( ) ) ;
}
scenes . push ( scene_handle ) ;
2020-10-18 20:48:15 +00:00
}
2020-12-31 20:57:15 +00:00
load_context . set_default_asset ( LoadedAsset ::new ( Gltf {
default_scene : gltf
. default_scene ( )
. and_then ( | scene | scenes . get ( scene . index ( ) ) )
. cloned ( ) ,
scenes ,
named_scenes ,
meshes ,
named_meshes ,
materials ,
named_materials ,
nodes ,
named_nodes ,
2022-04-02 22:36:02 +00:00
#[ cfg(feature = " bevy_animation " ) ]
2022-03-22 02:26:34 +00:00
animations ,
2022-04-02 22:36:02 +00:00
#[ cfg(feature = " bevy_animation " ) ]
2022-03-22 02:26:34 +00:00
named_animations ,
2020-12-31 20:57:15 +00:00
} ) ) ;
2020-10-18 20:48:15 +00:00
Ok ( ( ) )
}
2020-08-16 07:30:04 +00:00
2022-04-04 20:26:11 +00:00
fn node_name ( node : & Node ) -> Name {
let name = node
. name ( )
. map ( | s | s . to_string ( ) )
. unwrap_or_else ( | | format! ( " GltfNode {} " , node . index ( ) ) ) ;
Name ::new ( name )
}
2022-05-10 20:01:55 +00:00
#[ cfg(feature = " bevy_animation " ) ]
2022-04-05 21:52:00 +00:00
fn paths_recur (
node : Node ,
current_path : & [ Name ] ,
paths : & mut HashMap < usize , ( usize , Vec < Name > ) > ,
root_index : usize ,
) {
2022-04-04 20:26:11 +00:00
let mut path = current_path . to_owned ( ) ;
path . push ( node_name ( & node ) ) ;
for child in node . children ( ) {
2022-04-05 21:52:00 +00:00
paths_recur ( child , & path , paths , root_index ) ;
2022-04-02 22:36:02 +00:00
}
2022-04-05 21:52:00 +00:00
paths . insert ( node . index ( ) , ( root_index , path ) ) ;
2022-04-02 22:36:02 +00:00
}
2021-12-14 03:58:23 +00:00
/// Loads a glTF texture as a bevy [`Image`] and returns it together with its label.
2021-04-30 20:12:50 +00:00
async fn load_texture < ' a > (
gltf_texture : gltf ::Texture < ' a > ,
buffer_data : & [ Vec < u8 > ] ,
linear_textures : & HashSet < usize > ,
load_context : & LoadContext < ' a > ,
2022-03-15 22:26:46 +00:00
supported_compressed_formats : CompressedImageFormats ,
2021-12-14 03:58:23 +00:00
) -> Result < ( Image , String ) , GltfError > {
2022-03-15 22:26:46 +00:00
let is_srgb = ! linear_textures . contains ( & gltf_texture . index ( ) ) ;
2021-04-30 20:12:50 +00:00
let mut texture = match gltf_texture . source ( ) . source ( ) {
gltf ::image ::Source ::View { view , mime_type } = > {
let start = view . offset ( ) as usize ;
let end = ( view . offset ( ) + view . length ( ) ) as usize ;
let buffer = & buffer_data [ view . buffer ( ) . index ( ) ] [ start .. end ] ;
2022-03-15 22:26:46 +00:00
Image ::from_buffer (
buffer ,
ImageType ::MimeType ( mime_type ) ,
supported_compressed_formats ,
is_srgb ,
) ?
2021-04-30 20:12:50 +00:00
}
gltf ::image ::Source ::Uri { uri , mime_type } = > {
let uri = percent_encoding ::percent_decode_str ( uri )
. decode_utf8 ( )
. unwrap ( ) ;
let uri = uri . as_ref ( ) ;
2022-02-13 22:33:55 +00:00
let ( bytes , image_type ) = if let Ok ( data_uri ) = DataUri ::parse ( uri ) {
( data_uri . decode ( ) ? , ImageType ::MimeType ( data_uri . mime_type ) )
} else {
let parent = load_context . path ( ) . parent ( ) . unwrap ( ) ;
let image_path = parent . join ( uri ) ;
let bytes = load_context . read_asset_bytes ( image_path . clone ( ) ) . await ? ;
2021-04-30 20:12:50 +00:00
2022-02-13 22:33:55 +00:00
let extension = Path ::new ( uri ) . extension ( ) . unwrap ( ) . to_str ( ) . unwrap ( ) ;
let image_type = ImageType ::Extension ( extension ) ;
2021-04-30 20:12:50 +00:00
2022-02-13 22:33:55 +00:00
( bytes , image_type )
2021-04-30 20:12:50 +00:00
} ;
2021-12-14 03:58:23 +00:00
Image ::from_buffer (
2021-04-30 20:12:50 +00:00
& bytes ,
2021-12-02 23:40:37 +00:00
mime_type . map ( ImageType ::MimeType ) . unwrap_or ( image_type ) ,
2022-03-15 22:26:46 +00:00
supported_compressed_formats ,
is_srgb ,
2021-04-30 20:12:50 +00:00
) ?
}
} ;
2022-06-11 09:13:37 +00:00
texture . sampler_descriptor = ImageSampler ::Descriptor ( texture_sampler ( & gltf_texture ) ) ;
2021-04-30 20:12:50 +00:00
Ok ( ( texture , texture_label ( & gltf_texture ) ) )
}
2021-12-14 03:58:23 +00:00
/// Loads a glTF material as a bevy [`StandardMaterial`] and returns it.
2020-12-31 20:57:15 +00:00
fn load_material ( material : & Material , load_context : & mut LoadContext ) -> Handle < StandardMaterial > {
2021-07-29 20:52:15 +00:00
let material_label = material_label ( material ) ;
2021-03-26 21:00:34 +00:00
2020-12-09 03:36:41 +00:00
let pbr = material . pbr_metallic_roughness ( ) ;
2021-03-26 21:00:34 +00:00
let color = pbr . base_color_factor ( ) ;
2022-05-31 01:38:07 +00:00
let base_color_texture = pbr . base_color_texture ( ) . map ( | info | {
2021-03-26 21:00:34 +00:00
// TODO: handle info.tex_coord() (the *set* index for the right texcoords)
let label = texture_label ( & info . texture ( ) ) ;
let path = AssetPath ::new_ref ( load_context . path ( ) , Some ( & label ) ) ;
2022-05-31 01:38:07 +00:00
load_context . get_handle ( path )
} ) ;
2021-03-26 21:00:34 +00:00
2021-12-14 03:58:23 +00:00
let normal_map_texture : Option < Handle < Image > > =
2022-05-31 01:38:07 +00:00
material . normal_texture ( ) . map ( | normal_texture | {
2021-12-14 03:58:23 +00:00
// TODO: handle normal_texture.scale
// TODO: handle normal_texture.tex_coord() (the *set* index for the right texcoords)
let label = texture_label ( & normal_texture . texture ( ) ) ;
let path = AssetPath ::new_ref ( load_context . path ( ) , Some ( & label ) ) ;
2022-05-31 01:38:07 +00:00
load_context . get_handle ( path )
} ) ;
2021-03-26 21:00:34 +00:00
2022-05-31 01:38:07 +00:00
let metallic_roughness_texture = pbr . metallic_roughness_texture ( ) . map ( | info | {
2021-03-26 21:00:34 +00:00
// TODO: handle info.tex_coord() (the *set* index for the right texcoords)
let label = texture_label ( & info . texture ( ) ) ;
let path = AssetPath ::new_ref ( load_context . path ( ) , Some ( & label ) ) ;
2022-05-31 01:38:07 +00:00
load_context . get_handle ( path )
} ) ;
2021-03-26 21:00:34 +00:00
2022-05-31 01:38:07 +00:00
let occlusion_texture = material . occlusion_texture ( ) . map ( | occlusion_texture | {
2021-03-26 21:00:34 +00:00
// TODO: handle occlusion_texture.tex_coord() (the *set* index for the right texcoords)
// TODO: handle occlusion_texture.strength() (a scalar multiplier for occlusion strength)
let label = texture_label ( & occlusion_texture . texture ( ) ) ;
let path = AssetPath ::new_ref ( load_context . path ( ) , Some ( & label ) ) ;
2022-05-31 01:38:07 +00:00
load_context . get_handle ( path )
} ) ;
2021-03-26 21:00:34 +00:00
let emissive = material . emissive_factor ( ) ;
2022-05-31 01:38:07 +00:00
let emissive_texture = material . emissive_texture ( ) . map ( | info | {
2021-03-26 21:00:34 +00:00
// TODO: handle occlusion_texture.tex_coord() (the *set* index for the right texcoords)
// TODO: handle occlusion_texture.strength() (a scalar multiplier for occlusion strength)
2021-03-26 18:47:47 +00:00
let label = texture_label ( & info . texture ( ) ) ;
let path = AssetPath ::new_ref ( load_context . path ( ) , Some ( & label ) ) ;
2022-05-31 01:38:07 +00:00
load_context . get_handle ( path )
} ) ;
2020-12-09 03:36:41 +00:00
load_context . set_labeled_asset (
& material_label ,
LoadedAsset ::new ( StandardMaterial {
2021-03-20 03:22:33 +00:00
base_color : Color ::rgba ( color [ 0 ] , color [ 1 ] , color [ 2 ] , color [ 3 ] ) ,
2021-03-26 21:00:34 +00:00
base_color_texture ,
2021-12-14 03:58:23 +00:00
perceptual_roughness : pbr . roughness_factor ( ) ,
2021-03-20 03:22:33 +00:00
metallic : pbr . metallic_factor ( ) ,
2021-03-26 21:00:34 +00:00
metallic_roughness_texture ,
2021-12-14 03:58:23 +00:00
normal_map_texture ,
2021-03-26 21:00:34 +00:00
double_sided : material . double_sided ( ) ,
2022-03-20 21:32:38 +00:00
cull_mode : if material . double_sided ( ) {
None
} else {
Some ( Face ::Back )
} ,
2021-03-26 21:00:34 +00:00
occlusion_texture ,
emissive : Color ::rgba ( emissive [ 0 ] , emissive [ 1 ] , emissive [ 2 ] , 1.0 ) ,
emissive_texture ,
2021-02-01 01:13:16 +00:00
unlit : material . unlit ( ) ,
2021-12-14 03:58:23 +00:00
alpha_mode : alpha_mode ( material ) ,
2021-03-20 03:22:33 +00:00
.. Default ::default ( )
2021-03-26 18:47:47 +00:00
} ) ,
2020-12-09 03:36:41 +00:00
)
}
2021-12-14 03:58:23 +00:00
/// Loads a glTF node.
2020-10-18 20:48:15 +00:00
fn load_node (
2020-11-07 01:08:15 +00:00
gltf_node : & gltf ::Node ,
2020-10-18 20:48:15 +00:00
world_builder : & mut WorldChildBuilder ,
load_context : & mut LoadContext ,
buffer_data : & [ Vec < u8 > ] ,
2022-03-29 18:31:13 +00:00
node_index_to_entity_map : & mut HashMap < usize , Entity > ,
entity_to_skin_index_map : & mut HashMap < Entity , usize > ,
Camera Driven Rendering (#4745)
This adds "high level camera driven rendering" to Bevy. The goal is to give users more control over what gets rendered (and where) without needing to deal with render logic. This will make scenarios like "render to texture", "multiple windows", "split screen", "2d on 3d", "3d on 2d", "pass layering", and more significantly easier.
Here is an [example of a 2d render sandwiched between two 3d renders (each from a different perspective)](https://gist.github.com/cart/4fe56874b2e53bc5594a182fc76f4915):
Users can now spawn a camera, point it at a RenderTarget (a texture or a window), and it will "just work".
Rendering to a second window is as simple as spawning a second camera and assigning it to a specific window id:
```rust
// main camera (main window)
commands.spawn_bundle(Camera2dBundle::default());
// second camera (other window)
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Window(window_id),
..default()
},
..default()
});
```
Rendering to a texture is as simple as pointing the camera at a texture:
```rust
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Texture(image_handle),
..default()
},
..default()
});
```
Cameras now have a "render priority", which controls the order they are drawn in. If you want to use a camera's output texture as a texture in the main pass, just set the priority to a number lower than the main pass camera (which defaults to `0`).
```rust
// main pass camera with a default priority of 0
commands.spawn_bundle(Camera2dBundle::default());
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Texture(image_handle.clone()),
priority: -1,
..default()
},
..default()
});
commands.spawn_bundle(SpriteBundle {
texture: image_handle,
..default()
})
```
Priority can also be used to layer to cameras on top of each other for the same RenderTarget. This is what "2d on top of 3d" looks like in the new system:
```rust
commands.spawn_bundle(Camera3dBundle::default());
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
// this will render 2d entities "on top" of the default 3d camera's render
priority: 1,
..default()
},
..default()
});
```
There is no longer the concept of a global "active camera". Resources like `ActiveCamera<Camera2d>` and `ActiveCamera<Camera3d>` have been replaced with the camera-specific `Camera::is_active` field. This does put the onus on users to manage which cameras should be active.
Cameras are now assigned a single render graph as an "entry point", which is configured on each camera entity using the new `CameraRenderGraph` component. The old `PerspectiveCameraBundle` and `OrthographicCameraBundle` (generic on camera marker components like Camera2d and Camera3d) have been replaced by `Camera3dBundle` and `Camera2dBundle`, which set 3d and 2d default values for the `CameraRenderGraph` and projections.
```rust
// old 3d perspective camera
commands.spawn_bundle(PerspectiveCameraBundle::default())
// new 3d perspective camera
commands.spawn_bundle(Camera3dBundle::default())
```
```rust
// old 2d orthographic camera
commands.spawn_bundle(OrthographicCameraBundle::new_2d())
// new 2d orthographic camera
commands.spawn_bundle(Camera2dBundle::default())
```
```rust
// old 3d orthographic camera
commands.spawn_bundle(OrthographicCameraBundle::new_3d())
// new 3d orthographic camera
commands.spawn_bundle(Camera3dBundle {
projection: OrthographicProjection {
scale: 3.0,
scaling_mode: ScalingMode::FixedVertical,
..default()
}.into(),
..default()
})
```
Note that `Camera3dBundle` now uses a new `Projection` enum instead of hard coding the projection into the type. There are a number of motivators for this change: the render graph is now a part of the bundle, the way "generic bundles" work in the rust type system prevents nice `..default()` syntax, and changing projections at runtime is much easier with an enum (ex for editor scenarios). I'm open to discussing this choice, but I'm relatively certain we will all come to the same conclusion here. Camera2dBundle and Camera3dBundle are much clearer than being generic on marker components / using non-default constructors.
If you want to run a custom render graph on a camera, just set the `CameraRenderGraph` component:
```rust
commands.spawn_bundle(Camera3dBundle {
camera_render_graph: CameraRenderGraph::new(some_render_graph_name),
..default()
})
```
Just note that if the graph requires data from specific components to work (such as `Camera3d` config, which is provided in the `Camera3dBundle`), make sure the relevant components have been added.
Speaking of using components to configure graphs / passes, there are a number of new configuration options:
```rust
commands.spawn_bundle(Camera3dBundle {
camera_3d: Camera3d {
// overrides the default global clear color
clear_color: ClearColorConfig::Custom(Color::RED),
..default()
},
..default()
})
commands.spawn_bundle(Camera3dBundle {
camera_3d: Camera3d {
// disables clearing
clear_color: ClearColorConfig::None,
..default()
},
..default()
})
```
Expect to see more of the "graph configuration Components on Cameras" pattern in the future.
By popular demand, UI no longer requires a dedicated camera. `UiCameraBundle` has been removed. `Camera2dBundle` and `Camera3dBundle` now both default to rendering UI as part of their own render graphs. To disable UI rendering for a camera, disable it using the CameraUi component:
```rust
commands
.spawn_bundle(Camera3dBundle::default())
.insert(CameraUi {
is_enabled: false,
..default()
})
```
## Other Changes
* The separate clear pass has been removed. We should revisit this for things like sky rendering, but I think this PR should "keep it simple" until we're ready to properly support that (for code complexity and performance reasons). We can come up with the right design for a modular clear pass in a followup pr.
* I reorganized bevy_core_pipeline into Core2dPlugin and Core3dPlugin (and core_2d / core_3d modules). Everything is pretty much the same as before, just logically separate. I've moved relevant types (like Camera2d, Camera3d, Camera3dBundle, Camera2dBundle) into their relevant modules, which is what motivated this reorganization.
* I adapted the `scene_viewer` example (which relied on the ActiveCameras behavior) to the new system. I also refactored bits and pieces to be a bit simpler.
* All of the examples have been ported to the new camera approach. `render_to_texture` and `multiple_windows` are now _much_ simpler. I removed `two_passes` because it is less relevant with the new approach. If someone wants to add a new "layered custom pass with CameraRenderGraph" example, that might fill a similar niche. But I don't feel much pressure to add that in this pr.
* Cameras now have `target_logical_size` and `target_physical_size` fields, which makes finding the size of a camera's render target _much_ simpler. As a result, the `Assets<Image>` and `Windows` parameters were removed from `Camera::world_to_screen`, making that operation much more ergonomic.
* Render order ambiguities between cameras with the same target and the same priority now produce a warning. This accomplishes two goals:
1. Now that there is no "global" active camera, by default spawning two cameras will result in two renders (one covering the other). This would be a silent performance killer that would be hard to detect after the fact. By detecting ambiguities, we can provide a helpful warning when this occurs.
2. Render order ambiguities could result in unexpected / unpredictable render results. Resolving them makes sense.
## Follow Up Work
* Per-Camera viewports, which will make it possible to render to a smaller area inside of a RenderTarget (great for something like splitscreen)
* Camera-specific MSAA config (should use the same "overriding" pattern used for ClearColor)
* Graph Based Camera Ordering: priorities are simple, but they make complicated ordering constraints harder to express. We should consider adopting a "graph based" camera ordering model with "before" and "after" relationships to other cameras (or build it "on top" of the priority system).
* Consider allowing graphs to run subgraphs from any nest level (aka a global namespace for graphs). Right now the 2d and 3d graphs each need their own UI subgraph, which feels "fine" in the short term. But being able to share subgraphs between other subgraphs seems valuable.
* Consider splitting `bevy_core_pipeline` into `bevy_core_2d` and `bevy_core_3d` packages. Theres a shared "clear color" dependency here, which would need a new home.
2022-06-02 00:12:17 +00:00
active_camera_found : & mut bool ,
2020-10-18 20:48:15 +00:00
) -> Result < ( ) , GltfError > {
2020-11-07 01:08:15 +00:00
let transform = gltf_node . transform ( ) ;
2020-10-18 20:48:15 +00:00
let mut gltf_error = None ;
2022-02-06 01:07:55 +00:00
let mut node = world_builder . spawn_bundle ( TransformBundle ::from ( Transform ::from_matrix (
Mat4 ::from_cols_array_2d ( & transform . matrix ( ) ) ,
) ) ) ;
2020-11-07 01:08:15 +00:00
2022-04-04 20:26:11 +00:00
node . insert ( node_name ( gltf_node ) ) ;
2020-12-31 20:57:15 +00:00
2022-04-07 21:30:52 +00:00
if let Some ( extras ) = gltf_node . extras ( ) {
node . insert ( super ::GltfExtras {
value : extras . get ( ) . to_string ( ) ,
} ) ;
}
2020-11-07 01:08:15 +00:00
// create camera node
if let Some ( camera ) = gltf_node . camera ( ) {
Camera Driven Rendering (#4745)
This adds "high level camera driven rendering" to Bevy. The goal is to give users more control over what gets rendered (and where) without needing to deal with render logic. This will make scenarios like "render to texture", "multiple windows", "split screen", "2d on 3d", "3d on 2d", "pass layering", and more significantly easier.
Here is an [example of a 2d render sandwiched between two 3d renders (each from a different perspective)](https://gist.github.com/cart/4fe56874b2e53bc5594a182fc76f4915):
Users can now spawn a camera, point it at a RenderTarget (a texture or a window), and it will "just work".
Rendering to a second window is as simple as spawning a second camera and assigning it to a specific window id:
```rust
// main camera (main window)
commands.spawn_bundle(Camera2dBundle::default());
// second camera (other window)
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Window(window_id),
..default()
},
..default()
});
```
Rendering to a texture is as simple as pointing the camera at a texture:
```rust
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Texture(image_handle),
..default()
},
..default()
});
```
Cameras now have a "render priority", which controls the order they are drawn in. If you want to use a camera's output texture as a texture in the main pass, just set the priority to a number lower than the main pass camera (which defaults to `0`).
```rust
// main pass camera with a default priority of 0
commands.spawn_bundle(Camera2dBundle::default());
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Texture(image_handle.clone()),
priority: -1,
..default()
},
..default()
});
commands.spawn_bundle(SpriteBundle {
texture: image_handle,
..default()
})
```
Priority can also be used to layer to cameras on top of each other for the same RenderTarget. This is what "2d on top of 3d" looks like in the new system:
```rust
commands.spawn_bundle(Camera3dBundle::default());
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
// this will render 2d entities "on top" of the default 3d camera's render
priority: 1,
..default()
},
..default()
});
```
There is no longer the concept of a global "active camera". Resources like `ActiveCamera<Camera2d>` and `ActiveCamera<Camera3d>` have been replaced with the camera-specific `Camera::is_active` field. This does put the onus on users to manage which cameras should be active.
Cameras are now assigned a single render graph as an "entry point", which is configured on each camera entity using the new `CameraRenderGraph` component. The old `PerspectiveCameraBundle` and `OrthographicCameraBundle` (generic on camera marker components like Camera2d and Camera3d) have been replaced by `Camera3dBundle` and `Camera2dBundle`, which set 3d and 2d default values for the `CameraRenderGraph` and projections.
```rust
// old 3d perspective camera
commands.spawn_bundle(PerspectiveCameraBundle::default())
// new 3d perspective camera
commands.spawn_bundle(Camera3dBundle::default())
```
```rust
// old 2d orthographic camera
commands.spawn_bundle(OrthographicCameraBundle::new_2d())
// new 2d orthographic camera
commands.spawn_bundle(Camera2dBundle::default())
```
```rust
// old 3d orthographic camera
commands.spawn_bundle(OrthographicCameraBundle::new_3d())
// new 3d orthographic camera
commands.spawn_bundle(Camera3dBundle {
projection: OrthographicProjection {
scale: 3.0,
scaling_mode: ScalingMode::FixedVertical,
..default()
}.into(),
..default()
})
```
Note that `Camera3dBundle` now uses a new `Projection` enum instead of hard coding the projection into the type. There are a number of motivators for this change: the render graph is now a part of the bundle, the way "generic bundles" work in the rust type system prevents nice `..default()` syntax, and changing projections at runtime is much easier with an enum (ex for editor scenarios). I'm open to discussing this choice, but I'm relatively certain we will all come to the same conclusion here. Camera2dBundle and Camera3dBundle are much clearer than being generic on marker components / using non-default constructors.
If you want to run a custom render graph on a camera, just set the `CameraRenderGraph` component:
```rust
commands.spawn_bundle(Camera3dBundle {
camera_render_graph: CameraRenderGraph::new(some_render_graph_name),
..default()
})
```
Just note that if the graph requires data from specific components to work (such as `Camera3d` config, which is provided in the `Camera3dBundle`), make sure the relevant components have been added.
Speaking of using components to configure graphs / passes, there are a number of new configuration options:
```rust
commands.spawn_bundle(Camera3dBundle {
camera_3d: Camera3d {
// overrides the default global clear color
clear_color: ClearColorConfig::Custom(Color::RED),
..default()
},
..default()
})
commands.spawn_bundle(Camera3dBundle {
camera_3d: Camera3d {
// disables clearing
clear_color: ClearColorConfig::None,
..default()
},
..default()
})
```
Expect to see more of the "graph configuration Components on Cameras" pattern in the future.
By popular demand, UI no longer requires a dedicated camera. `UiCameraBundle` has been removed. `Camera2dBundle` and `Camera3dBundle` now both default to rendering UI as part of their own render graphs. To disable UI rendering for a camera, disable it using the CameraUi component:
```rust
commands
.spawn_bundle(Camera3dBundle::default())
.insert(CameraUi {
is_enabled: false,
..default()
})
```
## Other Changes
* The separate clear pass has been removed. We should revisit this for things like sky rendering, but I think this PR should "keep it simple" until we're ready to properly support that (for code complexity and performance reasons). We can come up with the right design for a modular clear pass in a followup pr.
* I reorganized bevy_core_pipeline into Core2dPlugin and Core3dPlugin (and core_2d / core_3d modules). Everything is pretty much the same as before, just logically separate. I've moved relevant types (like Camera2d, Camera3d, Camera3dBundle, Camera2dBundle) into their relevant modules, which is what motivated this reorganization.
* I adapted the `scene_viewer` example (which relied on the ActiveCameras behavior) to the new system. I also refactored bits and pieces to be a bit simpler.
* All of the examples have been ported to the new camera approach. `render_to_texture` and `multiple_windows` are now _much_ simpler. I removed `two_passes` because it is less relevant with the new approach. If someone wants to add a new "layered custom pass with CameraRenderGraph" example, that might fill a similar niche. But I don't feel much pressure to add that in this pr.
* Cameras now have `target_logical_size` and `target_physical_size` fields, which makes finding the size of a camera's render target _much_ simpler. As a result, the `Assets<Image>` and `Windows` parameters were removed from `Camera::world_to_screen`, making that operation much more ergonomic.
* Render order ambiguities between cameras with the same target and the same priority now produce a warning. This accomplishes two goals:
1. Now that there is no "global" active camera, by default spawning two cameras will result in two renders (one covering the other). This would be a silent performance killer that would be hard to detect after the fact. By detecting ambiguities, we can provide a helpful warning when this occurs.
2. Render order ambiguities could result in unexpected / unpredictable render results. Resolving them makes sense.
## Follow Up Work
* Per-Camera viewports, which will make it possible to render to a smaller area inside of a RenderTarget (great for something like splitscreen)
* Camera-specific MSAA config (should use the same "overriding" pattern used for ClearColor)
* Graph Based Camera Ordering: priorities are simple, but they make complicated ordering constraints harder to express. We should consider adopting a "graph based" camera ordering model with "before" and "after" relationships to other cameras (or build it "on top" of the priority system).
* Consider allowing graphs to run subgraphs from any nest level (aka a global namespace for graphs). Right now the 2d and 3d graphs each need their own UI subgraph, which feels "fine" in the short term. But being able to share subgraphs between other subgraphs seems valuable.
* Consider splitting `bevy_core_pipeline` into `bevy_core_2d` and `bevy_core_3d` packages. Theres a shared "clear color" dependency here, which would need a new home.
2022-06-02 00:12:17 +00:00
let projection = match camera . projection ( ) {
2020-11-07 01:08:15 +00:00
gltf ::camera ::Projection ::Orthographic ( orthographic ) = > {
let xmag = orthographic . xmag ( ) ;
2020-11-09 22:12:42 +00:00
let orthographic_projection : OrthographicProjection = OrthographicProjection {
far : orthographic . zfar ( ) ,
near : orthographic . znear ( ) ,
2022-05-31 17:14:12 +00:00
scaling_mode : ScalingMode ::FixedHorizontal ( 1.0 ) ,
scale : xmag ,
2020-11-09 22:12:42 +00:00
.. Default ::default ( )
} ;
Camera Driven Rendering (#4745)
This adds "high level camera driven rendering" to Bevy. The goal is to give users more control over what gets rendered (and where) without needing to deal with render logic. This will make scenarios like "render to texture", "multiple windows", "split screen", "2d on 3d", "3d on 2d", "pass layering", and more significantly easier.
Here is an [example of a 2d render sandwiched between two 3d renders (each from a different perspective)](https://gist.github.com/cart/4fe56874b2e53bc5594a182fc76f4915):
Users can now spawn a camera, point it at a RenderTarget (a texture or a window), and it will "just work".
Rendering to a second window is as simple as spawning a second camera and assigning it to a specific window id:
```rust
// main camera (main window)
commands.spawn_bundle(Camera2dBundle::default());
// second camera (other window)
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Window(window_id),
..default()
},
..default()
});
```
Rendering to a texture is as simple as pointing the camera at a texture:
```rust
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Texture(image_handle),
..default()
},
..default()
});
```
Cameras now have a "render priority", which controls the order they are drawn in. If you want to use a camera's output texture as a texture in the main pass, just set the priority to a number lower than the main pass camera (which defaults to `0`).
```rust
// main pass camera with a default priority of 0
commands.spawn_bundle(Camera2dBundle::default());
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Texture(image_handle.clone()),
priority: -1,
..default()
},
..default()
});
commands.spawn_bundle(SpriteBundle {
texture: image_handle,
..default()
})
```
Priority can also be used to layer to cameras on top of each other for the same RenderTarget. This is what "2d on top of 3d" looks like in the new system:
```rust
commands.spawn_bundle(Camera3dBundle::default());
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
// this will render 2d entities "on top" of the default 3d camera's render
priority: 1,
..default()
},
..default()
});
```
There is no longer the concept of a global "active camera". Resources like `ActiveCamera<Camera2d>` and `ActiveCamera<Camera3d>` have been replaced with the camera-specific `Camera::is_active` field. This does put the onus on users to manage which cameras should be active.
Cameras are now assigned a single render graph as an "entry point", which is configured on each camera entity using the new `CameraRenderGraph` component. The old `PerspectiveCameraBundle` and `OrthographicCameraBundle` (generic on camera marker components like Camera2d and Camera3d) have been replaced by `Camera3dBundle` and `Camera2dBundle`, which set 3d and 2d default values for the `CameraRenderGraph` and projections.
```rust
// old 3d perspective camera
commands.spawn_bundle(PerspectiveCameraBundle::default())
// new 3d perspective camera
commands.spawn_bundle(Camera3dBundle::default())
```
```rust
// old 2d orthographic camera
commands.spawn_bundle(OrthographicCameraBundle::new_2d())
// new 2d orthographic camera
commands.spawn_bundle(Camera2dBundle::default())
```
```rust
// old 3d orthographic camera
commands.spawn_bundle(OrthographicCameraBundle::new_3d())
// new 3d orthographic camera
commands.spawn_bundle(Camera3dBundle {
projection: OrthographicProjection {
scale: 3.0,
scaling_mode: ScalingMode::FixedVertical,
..default()
}.into(),
..default()
})
```
Note that `Camera3dBundle` now uses a new `Projection` enum instead of hard coding the projection into the type. There are a number of motivators for this change: the render graph is now a part of the bundle, the way "generic bundles" work in the rust type system prevents nice `..default()` syntax, and changing projections at runtime is much easier with an enum (ex for editor scenarios). I'm open to discussing this choice, but I'm relatively certain we will all come to the same conclusion here. Camera2dBundle and Camera3dBundle are much clearer than being generic on marker components / using non-default constructors.
If you want to run a custom render graph on a camera, just set the `CameraRenderGraph` component:
```rust
commands.spawn_bundle(Camera3dBundle {
camera_render_graph: CameraRenderGraph::new(some_render_graph_name),
..default()
})
```
Just note that if the graph requires data from specific components to work (such as `Camera3d` config, which is provided in the `Camera3dBundle`), make sure the relevant components have been added.
Speaking of using components to configure graphs / passes, there are a number of new configuration options:
```rust
commands.spawn_bundle(Camera3dBundle {
camera_3d: Camera3d {
// overrides the default global clear color
clear_color: ClearColorConfig::Custom(Color::RED),
..default()
},
..default()
})
commands.spawn_bundle(Camera3dBundle {
camera_3d: Camera3d {
// disables clearing
clear_color: ClearColorConfig::None,
..default()
},
..default()
})
```
Expect to see more of the "graph configuration Components on Cameras" pattern in the future.
By popular demand, UI no longer requires a dedicated camera. `UiCameraBundle` has been removed. `Camera2dBundle` and `Camera3dBundle` now both default to rendering UI as part of their own render graphs. To disable UI rendering for a camera, disable it using the CameraUi component:
```rust
commands
.spawn_bundle(Camera3dBundle::default())
.insert(CameraUi {
is_enabled: false,
..default()
})
```
## Other Changes
* The separate clear pass has been removed. We should revisit this for things like sky rendering, but I think this PR should "keep it simple" until we're ready to properly support that (for code complexity and performance reasons). We can come up with the right design for a modular clear pass in a followup pr.
* I reorganized bevy_core_pipeline into Core2dPlugin and Core3dPlugin (and core_2d / core_3d modules). Everything is pretty much the same as before, just logically separate. I've moved relevant types (like Camera2d, Camera3d, Camera3dBundle, Camera2dBundle) into their relevant modules, which is what motivated this reorganization.
* I adapted the `scene_viewer` example (which relied on the ActiveCameras behavior) to the new system. I also refactored bits and pieces to be a bit simpler.
* All of the examples have been ported to the new camera approach. `render_to_texture` and `multiple_windows` are now _much_ simpler. I removed `two_passes` because it is less relevant with the new approach. If someone wants to add a new "layered custom pass with CameraRenderGraph" example, that might fill a similar niche. But I don't feel much pressure to add that in this pr.
* Cameras now have `target_logical_size` and `target_physical_size` fields, which makes finding the size of a camera's render target _much_ simpler. As a result, the `Assets<Image>` and `Windows` parameters were removed from `Camera::world_to_screen`, making that operation much more ergonomic.
* Render order ambiguities between cameras with the same target and the same priority now produce a warning. This accomplishes two goals:
1. Now that there is no "global" active camera, by default spawning two cameras will result in two renders (one covering the other). This would be a silent performance killer that would be hard to detect after the fact. By detecting ambiguities, we can provide a helpful warning when this occurs.
2. Render order ambiguities could result in unexpected / unpredictable render results. Resolving them makes sense.
## Follow Up Work
* Per-Camera viewports, which will make it possible to render to a smaller area inside of a RenderTarget (great for something like splitscreen)
* Camera-specific MSAA config (should use the same "overriding" pattern used for ClearColor)
* Graph Based Camera Ordering: priorities are simple, but they make complicated ordering constraints harder to express. We should consider adopting a "graph based" camera ordering model with "before" and "after" relationships to other cameras (or build it "on top" of the priority system).
* Consider allowing graphs to run subgraphs from any nest level (aka a global namespace for graphs). Right now the 2d and 3d graphs each need their own UI subgraph, which feels "fine" in the short term. But being able to share subgraphs between other subgraphs seems valuable.
* Consider splitting `bevy_core_pipeline` into `bevy_core_2d` and `bevy_core_3d` packages. Theres a shared "clear color" dependency here, which would need a new home.
2022-06-02 00:12:17 +00:00
Projection ::Orthographic ( orthographic_projection )
2020-11-07 01:08:15 +00:00
}
gltf ::camera ::Projection ::Perspective ( perspective ) = > {
2020-11-09 22:12:42 +00:00
let mut perspective_projection : PerspectiveProjection = PerspectiveProjection {
fov : perspective . yfov ( ) ,
near : perspective . znear ( ) ,
.. Default ::default ( )
} ;
2020-11-07 01:08:15 +00:00
if let Some ( zfar ) = perspective . zfar ( ) {
perspective_projection . far = zfar ;
}
if let Some ( aspect_ratio ) = perspective . aspect_ratio ( ) {
perspective_projection . aspect_ratio = aspect_ratio ;
2020-10-18 20:48:15 +00:00
}
Camera Driven Rendering (#4745)
This adds "high level camera driven rendering" to Bevy. The goal is to give users more control over what gets rendered (and where) without needing to deal with render logic. This will make scenarios like "render to texture", "multiple windows", "split screen", "2d on 3d", "3d on 2d", "pass layering", and more significantly easier.
Here is an [example of a 2d render sandwiched between two 3d renders (each from a different perspective)](https://gist.github.com/cart/4fe56874b2e53bc5594a182fc76f4915):
Users can now spawn a camera, point it at a RenderTarget (a texture or a window), and it will "just work".
Rendering to a second window is as simple as spawning a second camera and assigning it to a specific window id:
```rust
// main camera (main window)
commands.spawn_bundle(Camera2dBundle::default());
// second camera (other window)
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Window(window_id),
..default()
},
..default()
});
```
Rendering to a texture is as simple as pointing the camera at a texture:
```rust
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Texture(image_handle),
..default()
},
..default()
});
```
Cameras now have a "render priority", which controls the order they are drawn in. If you want to use a camera's output texture as a texture in the main pass, just set the priority to a number lower than the main pass camera (which defaults to `0`).
```rust
// main pass camera with a default priority of 0
commands.spawn_bundle(Camera2dBundle::default());
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Texture(image_handle.clone()),
priority: -1,
..default()
},
..default()
});
commands.spawn_bundle(SpriteBundle {
texture: image_handle,
..default()
})
```
Priority can also be used to layer to cameras on top of each other for the same RenderTarget. This is what "2d on top of 3d" looks like in the new system:
```rust
commands.spawn_bundle(Camera3dBundle::default());
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
// this will render 2d entities "on top" of the default 3d camera's render
priority: 1,
..default()
},
..default()
});
```
There is no longer the concept of a global "active camera". Resources like `ActiveCamera<Camera2d>` and `ActiveCamera<Camera3d>` have been replaced with the camera-specific `Camera::is_active` field. This does put the onus on users to manage which cameras should be active.
Cameras are now assigned a single render graph as an "entry point", which is configured on each camera entity using the new `CameraRenderGraph` component. The old `PerspectiveCameraBundle` and `OrthographicCameraBundle` (generic on camera marker components like Camera2d and Camera3d) have been replaced by `Camera3dBundle` and `Camera2dBundle`, which set 3d and 2d default values for the `CameraRenderGraph` and projections.
```rust
// old 3d perspective camera
commands.spawn_bundle(PerspectiveCameraBundle::default())
// new 3d perspective camera
commands.spawn_bundle(Camera3dBundle::default())
```
```rust
// old 2d orthographic camera
commands.spawn_bundle(OrthographicCameraBundle::new_2d())
// new 2d orthographic camera
commands.spawn_bundle(Camera2dBundle::default())
```
```rust
// old 3d orthographic camera
commands.spawn_bundle(OrthographicCameraBundle::new_3d())
// new 3d orthographic camera
commands.spawn_bundle(Camera3dBundle {
projection: OrthographicProjection {
scale: 3.0,
scaling_mode: ScalingMode::FixedVertical,
..default()
}.into(),
..default()
})
```
Note that `Camera3dBundle` now uses a new `Projection` enum instead of hard coding the projection into the type. There are a number of motivators for this change: the render graph is now a part of the bundle, the way "generic bundles" work in the rust type system prevents nice `..default()` syntax, and changing projections at runtime is much easier with an enum (ex for editor scenarios). I'm open to discussing this choice, but I'm relatively certain we will all come to the same conclusion here. Camera2dBundle and Camera3dBundle are much clearer than being generic on marker components / using non-default constructors.
If you want to run a custom render graph on a camera, just set the `CameraRenderGraph` component:
```rust
commands.spawn_bundle(Camera3dBundle {
camera_render_graph: CameraRenderGraph::new(some_render_graph_name),
..default()
})
```
Just note that if the graph requires data from specific components to work (such as `Camera3d` config, which is provided in the `Camera3dBundle`), make sure the relevant components have been added.
Speaking of using components to configure graphs / passes, there are a number of new configuration options:
```rust
commands.spawn_bundle(Camera3dBundle {
camera_3d: Camera3d {
// overrides the default global clear color
clear_color: ClearColorConfig::Custom(Color::RED),
..default()
},
..default()
})
commands.spawn_bundle(Camera3dBundle {
camera_3d: Camera3d {
// disables clearing
clear_color: ClearColorConfig::None,
..default()
},
..default()
})
```
Expect to see more of the "graph configuration Components on Cameras" pattern in the future.
By popular demand, UI no longer requires a dedicated camera. `UiCameraBundle` has been removed. `Camera2dBundle` and `Camera3dBundle` now both default to rendering UI as part of their own render graphs. To disable UI rendering for a camera, disable it using the CameraUi component:
```rust
commands
.spawn_bundle(Camera3dBundle::default())
.insert(CameraUi {
is_enabled: false,
..default()
})
```
## Other Changes
* The separate clear pass has been removed. We should revisit this for things like sky rendering, but I think this PR should "keep it simple" until we're ready to properly support that (for code complexity and performance reasons). We can come up with the right design for a modular clear pass in a followup pr.
* I reorganized bevy_core_pipeline into Core2dPlugin and Core3dPlugin (and core_2d / core_3d modules). Everything is pretty much the same as before, just logically separate. I've moved relevant types (like Camera2d, Camera3d, Camera3dBundle, Camera2dBundle) into their relevant modules, which is what motivated this reorganization.
* I adapted the `scene_viewer` example (which relied on the ActiveCameras behavior) to the new system. I also refactored bits and pieces to be a bit simpler.
* All of the examples have been ported to the new camera approach. `render_to_texture` and `multiple_windows` are now _much_ simpler. I removed `two_passes` because it is less relevant with the new approach. If someone wants to add a new "layered custom pass with CameraRenderGraph" example, that might fill a similar niche. But I don't feel much pressure to add that in this pr.
* Cameras now have `target_logical_size` and `target_physical_size` fields, which makes finding the size of a camera's render target _much_ simpler. As a result, the `Assets<Image>` and `Windows` parameters were removed from `Camera::world_to_screen`, making that operation much more ergonomic.
* Render order ambiguities between cameras with the same target and the same priority now produce a warning. This accomplishes two goals:
1. Now that there is no "global" active camera, by default spawning two cameras will result in two renders (one covering the other). This would be a silent performance killer that would be hard to detect after the fact. By detecting ambiguities, we can provide a helpful warning when this occurs.
2. Render order ambiguities could result in unexpected / unpredictable render results. Resolving them makes sense.
## Follow Up Work
* Per-Camera viewports, which will make it possible to render to a smaller area inside of a RenderTarget (great for something like splitscreen)
* Camera-specific MSAA config (should use the same "overriding" pattern used for ClearColor)
* Graph Based Camera Ordering: priorities are simple, but they make complicated ordering constraints harder to express. We should consider adopting a "graph based" camera ordering model with "before" and "after" relationships to other cameras (or build it "on top" of the priority system).
* Consider allowing graphs to run subgraphs from any nest level (aka a global namespace for graphs). Right now the 2d and 3d graphs each need their own UI subgraph, which feels "fine" in the short term. But being able to share subgraphs between other subgraphs seems valuable.
* Consider splitting `bevy_core_pipeline` into `bevy_core_2d` and `bevy_core_3d` packages. Theres a shared "clear color" dependency here, which would need a new home.
2022-06-02 00:12:17 +00:00
Projection ::Perspective ( perspective_projection )
2020-08-16 07:30:04 +00:00
}
Camera Driven Rendering (#4745)
This adds "high level camera driven rendering" to Bevy. The goal is to give users more control over what gets rendered (and where) without needing to deal with render logic. This will make scenarios like "render to texture", "multiple windows", "split screen", "2d on 3d", "3d on 2d", "pass layering", and more significantly easier.
Here is an [example of a 2d render sandwiched between two 3d renders (each from a different perspective)](https://gist.github.com/cart/4fe56874b2e53bc5594a182fc76f4915):
Users can now spawn a camera, point it at a RenderTarget (a texture or a window), and it will "just work".
Rendering to a second window is as simple as spawning a second camera and assigning it to a specific window id:
```rust
// main camera (main window)
commands.spawn_bundle(Camera2dBundle::default());
// second camera (other window)
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Window(window_id),
..default()
},
..default()
});
```
Rendering to a texture is as simple as pointing the camera at a texture:
```rust
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Texture(image_handle),
..default()
},
..default()
});
```
Cameras now have a "render priority", which controls the order they are drawn in. If you want to use a camera's output texture as a texture in the main pass, just set the priority to a number lower than the main pass camera (which defaults to `0`).
```rust
// main pass camera with a default priority of 0
commands.spawn_bundle(Camera2dBundle::default());
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Texture(image_handle.clone()),
priority: -1,
..default()
},
..default()
});
commands.spawn_bundle(SpriteBundle {
texture: image_handle,
..default()
})
```
Priority can also be used to layer to cameras on top of each other for the same RenderTarget. This is what "2d on top of 3d" looks like in the new system:
```rust
commands.spawn_bundle(Camera3dBundle::default());
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
// this will render 2d entities "on top" of the default 3d camera's render
priority: 1,
..default()
},
..default()
});
```
There is no longer the concept of a global "active camera". Resources like `ActiveCamera<Camera2d>` and `ActiveCamera<Camera3d>` have been replaced with the camera-specific `Camera::is_active` field. This does put the onus on users to manage which cameras should be active.
Cameras are now assigned a single render graph as an "entry point", which is configured on each camera entity using the new `CameraRenderGraph` component. The old `PerspectiveCameraBundle` and `OrthographicCameraBundle` (generic on camera marker components like Camera2d and Camera3d) have been replaced by `Camera3dBundle` and `Camera2dBundle`, which set 3d and 2d default values for the `CameraRenderGraph` and projections.
```rust
// old 3d perspective camera
commands.spawn_bundle(PerspectiveCameraBundle::default())
// new 3d perspective camera
commands.spawn_bundle(Camera3dBundle::default())
```
```rust
// old 2d orthographic camera
commands.spawn_bundle(OrthographicCameraBundle::new_2d())
// new 2d orthographic camera
commands.spawn_bundle(Camera2dBundle::default())
```
```rust
// old 3d orthographic camera
commands.spawn_bundle(OrthographicCameraBundle::new_3d())
// new 3d orthographic camera
commands.spawn_bundle(Camera3dBundle {
projection: OrthographicProjection {
scale: 3.0,
scaling_mode: ScalingMode::FixedVertical,
..default()
}.into(),
..default()
})
```
Note that `Camera3dBundle` now uses a new `Projection` enum instead of hard coding the projection into the type. There are a number of motivators for this change: the render graph is now a part of the bundle, the way "generic bundles" work in the rust type system prevents nice `..default()` syntax, and changing projections at runtime is much easier with an enum (ex for editor scenarios). I'm open to discussing this choice, but I'm relatively certain we will all come to the same conclusion here. Camera2dBundle and Camera3dBundle are much clearer than being generic on marker components / using non-default constructors.
If you want to run a custom render graph on a camera, just set the `CameraRenderGraph` component:
```rust
commands.spawn_bundle(Camera3dBundle {
camera_render_graph: CameraRenderGraph::new(some_render_graph_name),
..default()
})
```
Just note that if the graph requires data from specific components to work (such as `Camera3d` config, which is provided in the `Camera3dBundle`), make sure the relevant components have been added.
Speaking of using components to configure graphs / passes, there are a number of new configuration options:
```rust
commands.spawn_bundle(Camera3dBundle {
camera_3d: Camera3d {
// overrides the default global clear color
clear_color: ClearColorConfig::Custom(Color::RED),
..default()
},
..default()
})
commands.spawn_bundle(Camera3dBundle {
camera_3d: Camera3d {
// disables clearing
clear_color: ClearColorConfig::None,
..default()
},
..default()
})
```
Expect to see more of the "graph configuration Components on Cameras" pattern in the future.
By popular demand, UI no longer requires a dedicated camera. `UiCameraBundle` has been removed. `Camera2dBundle` and `Camera3dBundle` now both default to rendering UI as part of their own render graphs. To disable UI rendering for a camera, disable it using the CameraUi component:
```rust
commands
.spawn_bundle(Camera3dBundle::default())
.insert(CameraUi {
is_enabled: false,
..default()
})
```
## Other Changes
* The separate clear pass has been removed. We should revisit this for things like sky rendering, but I think this PR should "keep it simple" until we're ready to properly support that (for code complexity and performance reasons). We can come up with the right design for a modular clear pass in a followup pr.
* I reorganized bevy_core_pipeline into Core2dPlugin and Core3dPlugin (and core_2d / core_3d modules). Everything is pretty much the same as before, just logically separate. I've moved relevant types (like Camera2d, Camera3d, Camera3dBundle, Camera2dBundle) into their relevant modules, which is what motivated this reorganization.
* I adapted the `scene_viewer` example (which relied on the ActiveCameras behavior) to the new system. I also refactored bits and pieces to be a bit simpler.
* All of the examples have been ported to the new camera approach. `render_to_texture` and `multiple_windows` are now _much_ simpler. I removed `two_passes` because it is less relevant with the new approach. If someone wants to add a new "layered custom pass with CameraRenderGraph" example, that might fill a similar niche. But I don't feel much pressure to add that in this pr.
* Cameras now have `target_logical_size` and `target_physical_size` fields, which makes finding the size of a camera's render target _much_ simpler. As a result, the `Assets<Image>` and `Windows` parameters were removed from `Camera::world_to_screen`, making that operation much more ergonomic.
* Render order ambiguities between cameras with the same target and the same priority now produce a warning. This accomplishes two goals:
1. Now that there is no "global" active camera, by default spawning two cameras will result in two renders (one covering the other). This would be a silent performance killer that would be hard to detect after the fact. By detecting ambiguities, we can provide a helpful warning when this occurs.
2. Render order ambiguities could result in unexpected / unpredictable render results. Resolving them makes sense.
## Follow Up Work
* Per-Camera viewports, which will make it possible to render to a smaller area inside of a RenderTarget (great for something like splitscreen)
* Camera-specific MSAA config (should use the same "overriding" pattern used for ClearColor)
* Graph Based Camera Ordering: priorities are simple, but they make complicated ordering constraints harder to express. We should consider adopting a "graph based" camera ordering model with "before" and "after" relationships to other cameras (or build it "on top" of the priority system).
* Consider allowing graphs to run subgraphs from any nest level (aka a global namespace for graphs). Right now the 2d and 3d graphs each need their own UI subgraph, which feels "fine" in the short term. But being able to share subgraphs between other subgraphs seems valuable.
* Consider splitting `bevy_core_pipeline` into `bevy_core_2d` and `bevy_core_3d` packages. Theres a shared "clear color" dependency here, which would need a new home.
2022-06-02 00:12:17 +00:00
} ;
node . insert_bundle ( (
projection ,
Camera {
is_active : ! * active_camera_found ,
.. Default ::default ( )
} ,
VisibleEntities ::default ( ) ,
Frustum ::default ( ) ,
Camera3d ::default ( ) ,
CameraRenderGraph ::new ( bevy_core_pipeline ::core_3d ::graph ::NAME ) ,
) ) ;
* active_camera_found = true ;
2020-11-07 01:08:15 +00:00
}
2020-08-16 07:30:04 +00:00
2022-03-29 18:31:13 +00:00
// Map node index to entity
node_index_to_entity_map . insert ( gltf_node . index ( ) , node . id ( ) ) ;
2020-11-07 01:08:15 +00:00
node . with_children ( | parent | {
if let Some ( mesh ) = gltf_node . mesh ( ) {
// append primitives
for primitive in mesh . primitives ( ) {
2020-12-09 03:36:41 +00:00
let material = primitive . material ( ) ;
let material_label = material_label ( & material ) ;
// This will make sure we load the default material now since it would not have been
// added when iterating over all the gltf materials (since the default material is
// not explicitly listed in the gltf).
if ! load_context . has_labeled_asset ( & material_label ) {
load_material ( & material , load_context ) ;
}
2020-11-07 01:08:15 +00:00
let primitive_label = primitive_label ( & mesh , & primitive ) ;
2022-03-29 18:31:13 +00:00
let bounds = primitive . bounding_box ( ) ;
2020-11-07 01:08:15 +00:00
let mesh_asset_path =
AssetPath ::new_ref ( load_context . path ( ) , Some ( & primitive_label ) ) ;
let material_asset_path =
AssetPath ::new_ref ( load_context . path ( ) , Some ( & material_label ) ) ;
2020-12-09 03:36:41 +00:00
2022-04-07 21:30:52 +00:00
let mut mesh_entity = parent . spawn_bundle ( PbrBundle {
mesh : load_context . get_handle ( mesh_asset_path ) ,
material : load_context . get_handle ( material_asset_path ) ,
.. Default ::default ( )
} ) ;
mesh_entity . insert ( Aabb ::from_min_max (
Vec3 ::from_slice ( & bounds . min ) ,
Vec3 ::from_slice ( & bounds . max ) ,
) ) ;
if let Some ( extras ) = primitive . extras ( ) {
mesh_entity . insert ( super ::GltfExtras {
value : extras . get ( ) . to_string ( ) ,
} ) ;
}
2022-04-07 22:19:32 +00:00
if let Some ( name ) = mesh . name ( ) {
mesh_entity . insert ( Name ::new ( name . to_string ( ) ) ) ;
}
2022-03-29 18:31:13 +00:00
// Mark for adding skinned mesh
if let Some ( skin ) = gltf_node . skin ( ) {
2022-04-07 21:30:52 +00:00
entity_to_skin_index_map . insert ( mesh_entity . id ( ) , skin . index ( ) ) ;
2022-03-29 18:31:13 +00:00
}
2020-09-25 21:29:30 +00:00
}
2020-11-07 01:08:15 +00:00
}
2020-05-15 23:55:44 +00:00
2022-01-03 07:59:25 +00:00
if let Some ( light ) = gltf_node . light ( ) {
match light . kind ( ) {
gltf ::khr_lights_punctual ::Kind ::Directional = > {
2022-01-05 03:27:17 +00:00
let mut entity = parent . spawn_bundle ( DirectionalLightBundle {
2022-01-03 07:59:25 +00:00
directional_light : DirectionalLight {
color : Color ::from ( light . color ( ) ) ,
// NOTE: KHR_punctual_lights defines the intensity units for directional
// lights in lux (lm/m^2) which is what we need.
illuminance : light . intensity ( ) ,
.. Default ::default ( )
} ,
.. Default ::default ( )
} ) ;
2022-01-05 03:27:17 +00:00
if let Some ( name ) = light . name ( ) {
entity . insert ( Name ::new ( name . to_string ( ) ) ) ;
}
2022-04-07 21:30:52 +00:00
if let Some ( extras ) = light . extras ( ) {
entity . insert ( super ::GltfExtras {
value : extras . get ( ) . to_string ( ) ,
} ) ;
}
2022-01-03 07:59:25 +00:00
}
gltf ::khr_lights_punctual ::Kind ::Point = > {
2022-01-05 03:27:17 +00:00
let mut entity = parent . spawn_bundle ( PointLightBundle {
2022-01-03 07:59:25 +00:00
point_light : PointLight {
color : Color ::from ( light . color ( ) ) ,
// NOTE: KHR_punctual_lights defines the intensity units for point lights in
// candela (lm/sr) which is luminous intensity and we need luminous power.
// For a point light, luminous power = 4 * pi * luminous intensity
intensity : light . intensity ( ) * std ::f32 ::consts ::PI * 4.0 ,
range : light . range ( ) . unwrap_or ( 20.0 ) ,
radius : light . range ( ) . unwrap_or ( 0.0 ) ,
.. Default ::default ( )
} ,
.. Default ::default ( )
} ) ;
2022-01-05 03:27:17 +00:00
if let Some ( name ) = light . name ( ) {
entity . insert ( Name ::new ( name . to_string ( ) ) ) ;
}
2022-04-07 21:30:52 +00:00
if let Some ( extras ) = light . extras ( ) {
entity . insert ( super ::GltfExtras {
value : extras . get ( ) . to_string ( ) ,
} ) ;
}
2022-01-03 07:59:25 +00:00
}
gltf ::khr_lights_punctual ::Kind ::Spot {
inner_cone_angle : _inner_cone_angle ,
outer_cone_angle : _outer_cone_angle ,
} = > warn! ( " Spot lights are not yet supported. " ) ,
}
}
2020-11-07 01:08:15 +00:00
// append other nodes
for child in gltf_node . children ( ) {
2022-03-29 18:31:13 +00:00
if let Err ( err ) = load_node (
& child ,
parent ,
load_context ,
buffer_data ,
node_index_to_entity_map ,
entity_to_skin_index_map ,
Camera Driven Rendering (#4745)
This adds "high level camera driven rendering" to Bevy. The goal is to give users more control over what gets rendered (and where) without needing to deal with render logic. This will make scenarios like "render to texture", "multiple windows", "split screen", "2d on 3d", "3d on 2d", "pass layering", and more significantly easier.
Here is an [example of a 2d render sandwiched between two 3d renders (each from a different perspective)](https://gist.github.com/cart/4fe56874b2e53bc5594a182fc76f4915):
Users can now spawn a camera, point it at a RenderTarget (a texture or a window), and it will "just work".
Rendering to a second window is as simple as spawning a second camera and assigning it to a specific window id:
```rust
// main camera (main window)
commands.spawn_bundle(Camera2dBundle::default());
// second camera (other window)
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Window(window_id),
..default()
},
..default()
});
```
Rendering to a texture is as simple as pointing the camera at a texture:
```rust
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Texture(image_handle),
..default()
},
..default()
});
```
Cameras now have a "render priority", which controls the order they are drawn in. If you want to use a camera's output texture as a texture in the main pass, just set the priority to a number lower than the main pass camera (which defaults to `0`).
```rust
// main pass camera with a default priority of 0
commands.spawn_bundle(Camera2dBundle::default());
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
target: RenderTarget::Texture(image_handle.clone()),
priority: -1,
..default()
},
..default()
});
commands.spawn_bundle(SpriteBundle {
texture: image_handle,
..default()
})
```
Priority can also be used to layer to cameras on top of each other for the same RenderTarget. This is what "2d on top of 3d" looks like in the new system:
```rust
commands.spawn_bundle(Camera3dBundle::default());
commands.spawn_bundle(Camera2dBundle {
camera: Camera {
// this will render 2d entities "on top" of the default 3d camera's render
priority: 1,
..default()
},
..default()
});
```
There is no longer the concept of a global "active camera". Resources like `ActiveCamera<Camera2d>` and `ActiveCamera<Camera3d>` have been replaced with the camera-specific `Camera::is_active` field. This does put the onus on users to manage which cameras should be active.
Cameras are now assigned a single render graph as an "entry point", which is configured on each camera entity using the new `CameraRenderGraph` component. The old `PerspectiveCameraBundle` and `OrthographicCameraBundle` (generic on camera marker components like Camera2d and Camera3d) have been replaced by `Camera3dBundle` and `Camera2dBundle`, which set 3d and 2d default values for the `CameraRenderGraph` and projections.
```rust
// old 3d perspective camera
commands.spawn_bundle(PerspectiveCameraBundle::default())
// new 3d perspective camera
commands.spawn_bundle(Camera3dBundle::default())
```
```rust
// old 2d orthographic camera
commands.spawn_bundle(OrthographicCameraBundle::new_2d())
// new 2d orthographic camera
commands.spawn_bundle(Camera2dBundle::default())
```
```rust
// old 3d orthographic camera
commands.spawn_bundle(OrthographicCameraBundle::new_3d())
// new 3d orthographic camera
commands.spawn_bundle(Camera3dBundle {
projection: OrthographicProjection {
scale: 3.0,
scaling_mode: ScalingMode::FixedVertical,
..default()
}.into(),
..default()
})
```
Note that `Camera3dBundle` now uses a new `Projection` enum instead of hard coding the projection into the type. There are a number of motivators for this change: the render graph is now a part of the bundle, the way "generic bundles" work in the rust type system prevents nice `..default()` syntax, and changing projections at runtime is much easier with an enum (ex for editor scenarios). I'm open to discussing this choice, but I'm relatively certain we will all come to the same conclusion here. Camera2dBundle and Camera3dBundle are much clearer than being generic on marker components / using non-default constructors.
If you want to run a custom render graph on a camera, just set the `CameraRenderGraph` component:
```rust
commands.spawn_bundle(Camera3dBundle {
camera_render_graph: CameraRenderGraph::new(some_render_graph_name),
..default()
})
```
Just note that if the graph requires data from specific components to work (such as `Camera3d` config, which is provided in the `Camera3dBundle`), make sure the relevant components have been added.
Speaking of using components to configure graphs / passes, there are a number of new configuration options:
```rust
commands.spawn_bundle(Camera3dBundle {
camera_3d: Camera3d {
// overrides the default global clear color
clear_color: ClearColorConfig::Custom(Color::RED),
..default()
},
..default()
})
commands.spawn_bundle(Camera3dBundle {
camera_3d: Camera3d {
// disables clearing
clear_color: ClearColorConfig::None,
..default()
},
..default()
})
```
Expect to see more of the "graph configuration Components on Cameras" pattern in the future.
By popular demand, UI no longer requires a dedicated camera. `UiCameraBundle` has been removed. `Camera2dBundle` and `Camera3dBundle` now both default to rendering UI as part of their own render graphs. To disable UI rendering for a camera, disable it using the CameraUi component:
```rust
commands
.spawn_bundle(Camera3dBundle::default())
.insert(CameraUi {
is_enabled: false,
..default()
})
```
## Other Changes
* The separate clear pass has been removed. We should revisit this for things like sky rendering, but I think this PR should "keep it simple" until we're ready to properly support that (for code complexity and performance reasons). We can come up with the right design for a modular clear pass in a followup pr.
* I reorganized bevy_core_pipeline into Core2dPlugin and Core3dPlugin (and core_2d / core_3d modules). Everything is pretty much the same as before, just logically separate. I've moved relevant types (like Camera2d, Camera3d, Camera3dBundle, Camera2dBundle) into their relevant modules, which is what motivated this reorganization.
* I adapted the `scene_viewer` example (which relied on the ActiveCameras behavior) to the new system. I also refactored bits and pieces to be a bit simpler.
* All of the examples have been ported to the new camera approach. `render_to_texture` and `multiple_windows` are now _much_ simpler. I removed `two_passes` because it is less relevant with the new approach. If someone wants to add a new "layered custom pass with CameraRenderGraph" example, that might fill a similar niche. But I don't feel much pressure to add that in this pr.
* Cameras now have `target_logical_size` and `target_physical_size` fields, which makes finding the size of a camera's render target _much_ simpler. As a result, the `Assets<Image>` and `Windows` parameters were removed from `Camera::world_to_screen`, making that operation much more ergonomic.
* Render order ambiguities between cameras with the same target and the same priority now produce a warning. This accomplishes two goals:
1. Now that there is no "global" active camera, by default spawning two cameras will result in two renders (one covering the other). This would be a silent performance killer that would be hard to detect after the fact. By detecting ambiguities, we can provide a helpful warning when this occurs.
2. Render order ambiguities could result in unexpected / unpredictable render results. Resolving them makes sense.
## Follow Up Work
* Per-Camera viewports, which will make it possible to render to a smaller area inside of a RenderTarget (great for something like splitscreen)
* Camera-specific MSAA config (should use the same "overriding" pattern used for ClearColor)
* Graph Based Camera Ordering: priorities are simple, but they make complicated ordering constraints harder to express. We should consider adopting a "graph based" camera ordering model with "before" and "after" relationships to other cameras (or build it "on top" of the priority system).
* Consider allowing graphs to run subgraphs from any nest level (aka a global namespace for graphs). Right now the 2d and 3d graphs each need their own UI subgraph, which feels "fine" in the short term. But being able to share subgraphs between other subgraphs seems valuable.
* Consider splitting `bevy_core_pipeline` into `bevy_core_2d` and `bevy_core_3d` packages. Theres a shared "clear color" dependency here, which would need a new home.
2022-06-02 00:12:17 +00:00
active_camera_found ,
2022-03-29 18:31:13 +00:00
) {
2020-11-07 01:08:15 +00:00
gltf_error = Some ( err ) ;
return ;
}
}
} ) ;
2020-10-18 20:48:15 +00:00
if let Some ( err ) = gltf_error {
Err ( err )
} else {
Ok ( ( ) )
2020-05-15 23:55:44 +00:00
}
2020-10-18 20:48:15 +00:00
}
2020-05-15 23:55:44 +00:00
2021-12-14 03:58:23 +00:00
/// Returns the label for the `mesh`.
2020-12-31 20:57:15 +00:00
fn mesh_label ( mesh : & gltf ::Mesh ) -> String {
format! ( " Mesh {} " , mesh . index ( ) )
}
2021-12-14 03:58:23 +00:00
/// Returns the label for the `mesh` and `primitive`.
2020-10-18 20:48:15 +00:00
fn primitive_label ( mesh : & gltf ::Mesh , primitive : & Primitive ) -> String {
format! ( " Mesh {} /Primitive {} " , mesh . index ( ) , primitive . index ( ) )
}
2021-12-14 03:58:23 +00:00
/// Returns the label for the `material`.
2020-10-18 20:48:15 +00:00
fn material_label ( material : & gltf ::Material ) -> String {
if let Some ( index ) = material . index ( ) {
format! ( " Material {} " , index )
} else {
" MaterialDefault " . to_string ( )
2020-05-15 23:55:44 +00:00
}
2020-10-18 20:48:15 +00:00
}
2021-12-14 03:58:23 +00:00
/// Returns the label for the `texture`.
2020-10-18 20:48:15 +00:00
fn texture_label ( texture : & gltf ::Texture ) -> String {
format! ( " Texture {} " , texture . index ( ) )
}
2020-05-15 23:55:44 +00:00
2021-12-14 03:58:23 +00:00
/// Returns the label for the `node`.
2020-12-31 20:57:15 +00:00
fn node_label ( node : & gltf ::Node ) -> String {
format! ( " Node {} " , node . index ( ) )
}
2021-12-14 03:58:23 +00:00
/// Returns the label for the `scene`.
2020-12-31 20:57:15 +00:00
fn scene_label ( scene : & gltf ::Scene ) -> String {
format! ( " Scene {} " , scene . index ( ) )
}
2022-03-29 18:31:13 +00:00
fn skin_label ( skin : & gltf ::Skin ) -> String {
format! ( " Skin {} " , skin . index ( ) )
}
2021-12-14 03:58:23 +00:00
/// Extracts the texture sampler data from the glTF texture.
fn texture_sampler < ' a > ( texture : & gltf ::Texture ) -> SamplerDescriptor < ' a > {
2020-10-29 21:22:45 +00:00
let gltf_sampler = texture . sampler ( ) ;
2021-03-13 18:44:26 +00:00
SamplerDescriptor {
2020-10-29 21:22:45 +00:00
address_mode_u : texture_address_mode ( & gltf_sampler . wrap_s ( ) ) ,
address_mode_v : texture_address_mode ( & gltf_sampler . wrap_t ( ) ) ,
mag_filter : gltf_sampler
. mag_filter ( )
. map ( | mf | match mf {
MagFilter ::Nearest = > FilterMode ::Nearest ,
MagFilter ::Linear = > FilterMode ::Linear ,
} )
. unwrap_or ( SamplerDescriptor ::default ( ) . mag_filter ) ,
min_filter : gltf_sampler
. min_filter ( )
. map ( | mf | match mf {
2021-03-13 18:44:26 +00:00
MinFilter ::Nearest
| MinFilter ::NearestMipmapNearest
| MinFilter ::NearestMipmapLinear = > FilterMode ::Nearest ,
MinFilter ::Linear
| MinFilter ::LinearMipmapNearest
| MinFilter ::LinearMipmapLinear = > FilterMode ::Linear ,
2020-10-29 21:22:45 +00:00
} )
. unwrap_or ( SamplerDescriptor ::default ( ) . min_filter ) ,
2021-03-13 18:44:26 +00:00
mipmap_filter : gltf_sampler
. min_filter ( )
. map ( | mf | match mf {
MinFilter ::Nearest
| MinFilter ::Linear
| MinFilter ::NearestMipmapNearest
| MinFilter ::LinearMipmapNearest = > FilterMode ::Nearest ,
MinFilter ::NearestMipmapLinear | MinFilter ::LinearMipmapLinear = > {
FilterMode ::Linear
}
} )
. unwrap_or ( SamplerDescriptor ::default ( ) . mipmap_filter ) ,
2020-10-29 21:22:45 +00:00
.. Default ::default ( )
2021-03-13 18:44:26 +00:00
}
2020-10-29 21:22:45 +00:00
}
2021-12-14 03:58:23 +00:00
/// Maps the texture address mode form glTF to wgpu.
2020-10-29 21:22:45 +00:00
fn texture_address_mode ( gltf_address_mode : & gltf ::texture ::WrappingMode ) -> AddressMode {
match gltf_address_mode {
WrappingMode ::ClampToEdge = > AddressMode ::ClampToEdge ,
WrappingMode ::Repeat = > AddressMode ::Repeat ,
WrappingMode ::MirroredRepeat = > AddressMode ::MirrorRepeat ,
}
}
2021-12-29 17:38:09 +00:00
/// Maps the `primitive_topology` form glTF to `wgpu`.
2020-10-18 20:48:15 +00:00
fn get_primitive_topology ( mode : Mode ) -> Result < PrimitiveTopology , GltfError > {
match mode {
Mode ::Points = > Ok ( PrimitiveTopology ::PointList ) ,
Mode ::Lines = > Ok ( PrimitiveTopology ::LineList ) ,
Mode ::LineStrip = > Ok ( PrimitiveTopology ::LineStrip ) ,
Mode ::Triangles = > Ok ( PrimitiveTopology ::TriangleList ) ,
Mode ::TriangleStrip = > Ok ( PrimitiveTopology ::TriangleStrip ) ,
mode = > Err ( GltfError ::UnsupportedPrimitive { mode } ) ,
}
2020-05-15 23:55:44 +00:00
}
2021-12-14 03:58:23 +00:00
fn alpha_mode ( material : & Material ) -> AlphaMode {
match material . alpha_mode ( ) {
gltf ::material ::AlphaMode ::Opaque = > AlphaMode ::Opaque ,
gltf ::material ::AlphaMode ::Mask = > AlphaMode ::Mask ( material . alpha_cutoff ( ) . unwrap_or ( 0.5 ) ) ,
gltf ::material ::AlphaMode ::Blend = > AlphaMode ::Blend ,
}
}
/// Loads the raw glTF buffer data for a specific glTF file.
2020-10-20 00:29:31 +00:00
async fn load_buffers (
2020-10-18 20:48:15 +00:00
gltf : & gltf ::Gltf ,
2020-10-20 00:29:31 +00:00
load_context : & LoadContext < '_ > ,
2020-10-18 20:48:15 +00:00
asset_path : & Path ,
) -> Result < Vec < Vec < u8 > > , GltfError > {
2021-11-11 01:58:57 +00:00
const VALID_MIME_TYPES : & [ & str ] = & [ " application/octet-stream " , " application/gltf-buffer " ] ;
2020-08-12 17:23:54 +00:00
2020-05-15 23:55:44 +00:00
let mut buffer_data = Vec ::new ( ) ;
2020-08-25 23:55:08 +00:00
for buffer in gltf . buffers ( ) {
2020-05-15 23:55:44 +00:00
match buffer . source ( ) {
2020-10-18 20:48:15 +00:00
gltf ::buffer ::Source ::Uri ( uri ) = > {
2021-04-13 21:30:32 +00:00
let uri = percent_encoding ::percent_decode_str ( uri )
. decode_utf8 ( )
. unwrap ( ) ;
let uri = uri . as_ref ( ) ;
let buffer_bytes = match DataUri ::parse ( uri ) {
2021-11-11 01:58:57 +00:00
Ok ( data_uri ) if VALID_MIME_TYPES . contains ( & data_uri . mime_type ) = > {
data_uri . decode ( ) ?
}
2021-04-13 21:30:32 +00:00
Ok ( _ ) = > return Err ( GltfError ::BufferFormatUnsupported ) ,
Err ( ( ) ) = > {
// TODO: Remove this and add dep
let buffer_path = asset_path . parent ( ) . unwrap ( ) . join ( uri ) ;
let buffer_bytes = load_context . read_asset_bytes ( buffer_path ) . await ? ;
buffer_bytes
}
} ;
buffer_data . push ( buffer_bytes ) ;
2020-05-15 23:55:44 +00:00
}
2020-10-18 20:48:15 +00:00
gltf ::buffer ::Source ::Bin = > {
2020-08-25 23:55:08 +00:00
if let Some ( blob ) = gltf . blob . as_deref ( ) {
buffer_data . push ( blob . into ( ) ) ;
} else {
return Err ( GltfError ::MissingBlob ) ;
}
}
2020-05-15 23:55:44 +00:00
}
}
Ok ( buffer_data )
}
2020-12-31 20:57:15 +00:00
fn resolve_node_hierarchy (
nodes_intermediate : Vec < ( String , GltfNode , Vec < usize > ) > ,
2021-12-14 03:58:23 +00:00
asset_path : & Path ,
2020-12-31 20:57:15 +00:00
) -> Vec < ( String , GltfNode ) > {
2021-12-14 03:58:23 +00:00
let mut has_errored = false ;
let mut empty_children = VecDeque ::new ( ) ;
let mut parents = vec! [ None ; nodes_intermediate . len ( ) ] ;
let mut unprocessed_nodes = nodes_intermediate
2020-12-31 20:57:15 +00:00
. into_iter ( )
. enumerate ( )
2021-12-14 03:58:23 +00:00
. map ( | ( i , ( label , node , children ) ) | {
2022-02-13 22:33:55 +00:00
for child in & children {
2021-12-14 03:58:23 +00:00
if let Some ( parent ) = parents . get_mut ( * child ) {
* parent = Some ( i ) ;
} else if ! has_errored {
has_errored = true ;
warn! ( " Unexpected child in GLTF Mesh {} " , child ) ;
2020-12-31 20:57:15 +00:00
}
}
2021-12-14 03:58:23 +00:00
let children = children . into_iter ( ) . collect ::< HashSet < _ > > ( ) ;
if children . is_empty ( ) {
empty_children . push_back ( i ) ;
}
( i , ( label , node , children ) )
} )
. collect ::< HashMap < _ , _ > > ( ) ;
let mut nodes = std ::collections ::HashMap ::< usize , ( String , GltfNode ) > ::new ( ) ;
while let Some ( index ) = empty_children . pop_front ( ) {
let ( label , node , children ) = unprocessed_nodes . remove ( & index ) . unwrap ( ) ;
assert! ( children . is_empty ( ) ) ;
nodes . insert ( index , ( label , node ) ) ;
if let Some ( parent_index ) = parents [ index ] {
let ( _ , parent_node , parent_children ) =
unprocessed_nodes . get_mut ( & parent_index ) . unwrap ( ) ;
assert! ( parent_children . remove ( & index ) ) ;
if let Some ( ( _ , child_node ) ) = nodes . get ( & index ) {
2022-02-13 22:33:55 +00:00
parent_node . children . push ( child_node . clone ( ) ) ;
2021-12-14 03:58:23 +00:00
}
if parent_children . is_empty ( ) {
empty_children . push_back ( parent_index ) ;
}
2020-12-31 20:57:15 +00:00
}
}
2021-12-14 03:58:23 +00:00
if ! unprocessed_nodes . is_empty ( ) {
warn! ( " GLTF model must be a tree: {:?} " , asset_path ) ;
}
2020-12-31 20:57:15 +00:00
let mut nodes_to_sort = nodes . into_iter ( ) . collect ::< Vec < _ > > ( ) ;
nodes_to_sort . sort_by_key ( | ( i , _ ) | * i ) ;
nodes_to_sort
. into_iter ( )
. map ( | ( _ , resolved ) | resolved )
. collect ( )
}
2021-04-13 21:30:32 +00:00
struct DataUri < ' a > {
mime_type : & ' a str ,
base64 : bool ,
data : & ' a str ,
}
fn split_once ( input : & str , delimiter : char ) -> Option < ( & str , & str ) > {
let mut iter = input . splitn ( 2 , delimiter ) ;
Some ( ( iter . next ( ) ? , iter . next ( ) ? ) )
}
impl < ' a > DataUri < ' a > {
fn parse ( uri : & ' a str ) -> Result < DataUri < ' a > , ( ) > {
let uri = uri . strip_prefix ( " data: " ) . ok_or ( ( ) ) ? ;
let ( mime_type , data ) = split_once ( uri , ',' ) . ok_or ( ( ) ) ? ;
let ( mime_type , base64 ) = match mime_type . strip_suffix ( " ;base64 " ) {
Some ( mime_type ) = > ( mime_type , true ) ,
None = > ( mime_type , false ) ,
} ;
Ok ( DataUri {
mime_type ,
base64 ,
data ,
} )
}
fn decode ( & self ) -> Result < Vec < u8 > , base64 ::DecodeError > {
if self . base64 {
base64 ::decode ( self . data )
} else {
Ok ( self . data . as_bytes ( ) . to_owned ( ) )
}
}
}
2020-12-31 20:57:15 +00:00
#[ cfg(test) ]
mod test {
2021-12-14 03:58:23 +00:00
use std ::path ::PathBuf ;
2020-12-31 20:57:15 +00:00
use super ::resolve_node_hierarchy ;
use crate ::GltfNode ;
impl GltfNode {
fn empty ( ) -> Self {
GltfNode {
children : vec ! [ ] ,
mesh : None ,
2021-03-13 18:23:39 +00:00
transform : bevy_transform ::prelude ::Transform ::identity ( ) ,
2020-12-31 20:57:15 +00:00
}
}
}
#[ test ]
fn node_hierarchy_single_node ( ) {
2021-12-14 03:58:23 +00:00
let result = resolve_node_hierarchy (
vec! [ ( " l1 " . to_string ( ) , GltfNode ::empty ( ) , vec! [ ] ) ] ,
PathBuf ::new ( ) . as_path ( ) ,
) ;
2020-12-31 20:57:15 +00:00
assert_eq! ( result . len ( ) , 1 ) ;
assert_eq! ( result [ 0 ] . 0 , " l1 " ) ;
assert_eq! ( result [ 0 ] . 1. children . len ( ) , 0 ) ;
}
#[ test ]
fn node_hierarchy_no_hierarchy ( ) {
2021-12-14 03:58:23 +00:00
let result = resolve_node_hierarchy (
vec! [
( " l1 " . to_string ( ) , GltfNode ::empty ( ) , vec! [ ] ) ,
( " l2 " . to_string ( ) , GltfNode ::empty ( ) , vec! [ ] ) ,
] ,
PathBuf ::new ( ) . as_path ( ) ,
) ;
2020-12-31 20:57:15 +00:00
assert_eq! ( result . len ( ) , 2 ) ;
assert_eq! ( result [ 0 ] . 0 , " l1 " ) ;
assert_eq! ( result [ 0 ] . 1. children . len ( ) , 0 ) ;
assert_eq! ( result [ 1 ] . 0 , " l2 " ) ;
assert_eq! ( result [ 1 ] . 1. children . len ( ) , 0 ) ;
}
#[ test ]
fn node_hierarchy_simple_hierarchy ( ) {
2021-12-14 03:58:23 +00:00
let result = resolve_node_hierarchy (
vec! [
( " l1 " . to_string ( ) , GltfNode ::empty ( ) , vec! [ 1 ] ) ,
( " l2 " . to_string ( ) , GltfNode ::empty ( ) , vec! [ ] ) ,
] ,
PathBuf ::new ( ) . as_path ( ) ,
) ;
2020-12-31 20:57:15 +00:00
assert_eq! ( result . len ( ) , 2 ) ;
assert_eq! ( result [ 0 ] . 0 , " l1 " ) ;
assert_eq! ( result [ 0 ] . 1. children . len ( ) , 1 ) ;
assert_eq! ( result [ 1 ] . 0 , " l2 " ) ;
assert_eq! ( result [ 1 ] . 1. children . len ( ) , 0 ) ;
}
#[ test ]
fn node_hierarchy_hierarchy ( ) {
2021-12-14 03:58:23 +00:00
let result = resolve_node_hierarchy (
vec! [
( " l1 " . to_string ( ) , GltfNode ::empty ( ) , vec! [ 1 ] ) ,
( " l2 " . to_string ( ) , GltfNode ::empty ( ) , vec! [ 2 ] ) ,
( " l3 " . to_string ( ) , GltfNode ::empty ( ) , vec! [ 3 , 4 , 5 ] ) ,
( " l4 " . to_string ( ) , GltfNode ::empty ( ) , vec! [ 6 ] ) ,
( " l5 " . to_string ( ) , GltfNode ::empty ( ) , vec! [ ] ) ,
( " l6 " . to_string ( ) , GltfNode ::empty ( ) , vec! [ ] ) ,
( " l7 " . to_string ( ) , GltfNode ::empty ( ) , vec! [ ] ) ,
] ,
PathBuf ::new ( ) . as_path ( ) ,
) ;
2020-12-31 20:57:15 +00:00
assert_eq! ( result . len ( ) , 7 ) ;
assert_eq! ( result [ 0 ] . 0 , " l1 " ) ;
assert_eq! ( result [ 0 ] . 1. children . len ( ) , 1 ) ;
assert_eq! ( result [ 1 ] . 0 , " l2 " ) ;
assert_eq! ( result [ 1 ] . 1. children . len ( ) , 1 ) ;
assert_eq! ( result [ 2 ] . 0 , " l3 " ) ;
assert_eq! ( result [ 2 ] . 1. children . len ( ) , 3 ) ;
assert_eq! ( result [ 3 ] . 0 , " l4 " ) ;
assert_eq! ( result [ 3 ] . 1. children . len ( ) , 1 ) ;
assert_eq! ( result [ 4 ] . 0 , " l5 " ) ;
assert_eq! ( result [ 4 ] . 1. children . len ( ) , 0 ) ;
assert_eq! ( result [ 5 ] . 0 , " l6 " ) ;
assert_eq! ( result [ 5 ] . 1. children . len ( ) , 0 ) ;
assert_eq! ( result [ 6 ] . 0 , " l7 " ) ;
assert_eq! ( result [ 6 ] . 1. children . len ( ) , 0 ) ;
}
#[ test ]
fn node_hierarchy_cyclic ( ) {
2021-12-14 03:58:23 +00:00
let result = resolve_node_hierarchy (
vec! [
( " l1 " . to_string ( ) , GltfNode ::empty ( ) , vec! [ 1 ] ) ,
( " l2 " . to_string ( ) , GltfNode ::empty ( ) , vec! [ 0 ] ) ,
] ,
PathBuf ::new ( ) . as_path ( ) ,
) ;
2020-12-31 20:57:15 +00:00
assert_eq! ( result . len ( ) , 0 ) ;
}
#[ test ]
fn node_hierarchy_missing_node ( ) {
2021-12-14 03:58:23 +00:00
let result = resolve_node_hierarchy (
vec! [
( " l1 " . to_string ( ) , GltfNode ::empty ( ) , vec! [ 2 ] ) ,
( " l2 " . to_string ( ) , GltfNode ::empty ( ) , vec! [ ] ) ,
] ,
PathBuf ::new ( ) . as_path ( ) ,
) ;
2020-12-31 20:57:15 +00:00
assert_eq! ( result . len ( ) , 1 ) ;
assert_eq! ( result [ 0 ] . 0 , " l2 " ) ;
assert_eq! ( result [ 0 ] . 1. children . len ( ) , 0 ) ;
}
}
