28441337bb
Currently, Bevy's implementation of bindless resources is rather unusual: every binding in an object that implements `AsBindGroup` (most commonly, a material) becomes its own separate binding array in the shader. This is inefficient for two reasons: 1. If multiple materials reference the same texture or other resource, the reference to that resource will be duplicated many times. This increases `wgpu` validation overhead. 2. It creates many unused binding array slots. This increases `wgpu` and driver overhead and makes it easier to hit limits on APIs that `wgpu` currently imposes tight resource limits on, like Metal. This PR fixes these issues by switching Bevy to use the standard approach in GPU-driven renderers, in which resources are de-duplicated and passed as global arrays, one for each type of resource. Along the way, this patch introduces per-platform resource limits and bumps them from 16 resources per binding array to 64 resources per bind group on Metal and 2048 resources per bind group on other platforms. (Note that the number of resources per *binding array* isn't the same as the number of resources per *bind group*; as it currently stands, if all the PBR features are turned on, Bevy could pack as many as 496 resources into a single slab.) The limits have been increased because `wgpu` now has universal support for partially-bound binding arrays, which mean that we no longer need to fill the binding arrays with fallback resources on Direct3D 12. The `#[bindless(LIMIT)]` declaration when deriving `AsBindGroup` can now simply be written `#[bindless]` in order to have Bevy choose a default limit size for the current platform. Custom limits are still available with the new `#[bindless(limit(LIMIT))]` syntax: e.g. `#[bindless(limit(8))]`. The material bind group allocator has been completely rewritten. Now there are two allocators: one for bindless materials and one for non-bindless materials. The new non-bindless material allocator simply maintains a 1:1 mapping from material to bind group. The new bindless material allocator maintains a list of slabs and allocates materials into slabs on a first-fit basis. This unfortunately makes its performance O(number of resources per object * number of slabs), but the number of slabs is likely to be low, and it's planned to become even lower in the future with `wgpu` improvements. Resources are de-duplicated with in a slab and reference counted. So, for instance, if multiple materials refer to the same texture, that texture will exist only once in the appropriate binding array. To support these new features, this patch adds the concept of a *bindless descriptor* to the `AsBindGroup` trait. The bindless descriptor allows the material bind group allocator to probe the layout of the material, now that an array of `BindGroupLayoutEntry` records is insufficient to describe the group. The `#[derive(AsBindGroup)]` has been heavily modified to support the new features. The most important user-facing change to that macro is that the struct-level `uniform` attribute, `#[uniform(BINDING_NUMBER, StandardMaterial)]`, now reads `#[uniform(BINDLESS_INDEX, MATERIAL_UNIFORM_TYPE, binding_array(BINDING_NUMBER)]`, allowing the material to specify the binding number for the binding array that holds the uniform data. To make this patch simpler, I removed support for bindless `ExtendedMaterial`s, as well as field-level bindless uniform and storage buffers. I intend to add back support for these as a follow-up. Because they aren't in any released Bevy version yet, I figured this was OK. Finally, this patch updates `StandardMaterial` for the new bindless changes. Generally, code throughout the PBR shaders that looked like `base_color_texture[slot]` now looks like `bindless_2d_textures[material_indices[slot].base_color_texture]`. This patch fixes a system hang that I experienced on the [Caldera test] when running with `caldera --random-materials --texture-count 100`. The time per frame is around 19.75 ms, down from 154.2 ms in Bevy 0.14: a 7.8× speedup. [Caldera test]: https://github.com/DGriffin91/bevy_caldera_scene
88 lines
2.5 KiB
Rust
88 lines
2.5 KiB
Rust
//! A material that uses bindless textures.
|
|
|
|
use bevy::prelude::*;
|
|
use bevy::render::render_resource::{AsBindGroup, ShaderRef, ShaderType};
|
|
|
|
const SHADER_ASSET_PATH: &str = "shaders/bindless_material.wgsl";
|
|
|
|
// `#[bindless(limit(4))]` indicates that we want Bevy to group materials into
|
|
// bind groups of at most 4 materials each.
|
|
// Note that we use the structure-level `#[uniform]` attribute to supply
|
|
// ordinary data to the shader.
|
|
#[derive(Asset, TypePath, AsBindGroup, Debug, Clone)]
|
|
#[uniform(0, BindlessMaterialUniform, binding_array(10))]
|
|
#[bindless(limit(4))]
|
|
struct BindlessMaterial {
|
|
color: LinearRgba,
|
|
// This will be exposed to the shader as a binding array of 4 textures and a
|
|
// binding array of 4 samplers.
|
|
#[texture(1)]
|
|
#[sampler(2)]
|
|
color_texture: Option<Handle<Image>>,
|
|
}
|
|
|
|
// This buffer will be presented to the shader as `@binding(10)`.
|
|
#[derive(ShaderType)]
|
|
struct BindlessMaterialUniform {
|
|
color: LinearRgba,
|
|
}
|
|
|
|
impl<'a> From<&'a BindlessMaterial> for BindlessMaterialUniform {
|
|
fn from(material: &'a BindlessMaterial) -> Self {
|
|
BindlessMaterialUniform {
|
|
color: material.color,
|
|
}
|
|
}
|
|
}
|
|
|
|
// The entry point.
|
|
fn main() {
|
|
App::new()
|
|
.add_plugins((
|
|
DefaultPlugins,
|
|
MaterialPlugin::<BindlessMaterial>::default(),
|
|
))
|
|
.add_systems(Startup, setup)
|
|
.run();
|
|
}
|
|
|
|
// Creates a simple scene.
|
|
fn setup(
|
|
mut commands: Commands,
|
|
mut meshes: ResMut<Assets<Mesh>>,
|
|
mut materials: ResMut<Assets<BindlessMaterial>>,
|
|
asset_server: Res<AssetServer>,
|
|
) {
|
|
// Add a cube with a blue tinted texture.
|
|
commands.spawn((
|
|
Mesh3d(meshes.add(Cuboid::default())),
|
|
MeshMaterial3d(materials.add(BindlessMaterial {
|
|
color: LinearRgba::BLUE,
|
|
color_texture: Some(asset_server.load("branding/bevy_logo_dark.png")),
|
|
})),
|
|
Transform::from_xyz(-2.0, 0.5, 0.0),
|
|
));
|
|
|
|
// Add a cylinder with a red tinted texture.
|
|
commands.spawn((
|
|
Mesh3d(meshes.add(Cylinder::default())),
|
|
MeshMaterial3d(materials.add(BindlessMaterial {
|
|
color: LinearRgba::RED,
|
|
color_texture: Some(asset_server.load("branding/bevy_logo_light.png")),
|
|
})),
|
|
Transform::from_xyz(2.0, 0.5, 0.0),
|
|
));
|
|
|
|
// Add a camera.
|
|
commands.spawn((
|
|
Camera3d::default(),
|
|
Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
|
|
));
|
|
}
|
|
|
|
impl Material for BindlessMaterial {
|
|
fn fragment_shader() -> ShaderRef {
|
|
SHADER_ASSET_PATH.into()
|
|
}
|
|
}
|