Rename ShaderStorageBuffer -> ShaderBuffer. (#22558)

The original name is inaccurate since you can provide whatever usages
you want. As we make the renderer more modular and flexible, especially
if we develop a compute abstraction, having an easy way to bind things
like vertex buffers could be desirable.

I'd *really* like to just call this `Buffer` to keep it short and sweet,
but I know that proved controversial in the original PR.

Author: tychedelia

crates/bevy_dev_tools/src/fps_overlay.rs

@@ -15,7 +15,7 @@ use bevy_ecs::{
 };
 use bevy_picking::Pickable;
 use bevy_reflect::Reflect;
-use bevy_render::storage::ShaderStorageBuffer;
+use bevy_render::storage::ShaderBuffer;
 use bevy_text::{TextColor, TextFont, TextSpan};
 use bevy_time::common_conditions::on_timer;
 use bevy_ui::{
@@ -169,7 +169,7 @@ fn setup(
     )]
     (mut frame_time_graph_materials, mut buffers): (
         ResMut<Assets<FrametimeGraphMaterial>>,
-        ResMut<Assets<ShaderStorageBuffer>>,
+        ResMut<Assets<ShaderBuffer>>,
     ),
 ) {
     commands
@@ -218,7 +218,7 @@ fn setup(
                     },
                     Pickable::IGNORE,
                     MaterialNode::from(frame_time_graph_materials.add(FrametimeGraphMaterial {
-                        values: buffers.add(ShaderStorageBuffer {
+                        values: buffers.add(ShaderBuffer {
                             // Initialize with dummy data because the default (`data: None`) will
                             // cause a panic in the shader if the frame time graph is constructed
                             // with `enabled: false`.

crates/bevy_dev_tools/src/frame_time_graph/mod.rs

@@ -8,7 +8,7 @@ use bevy_math::ops::log2;
 use bevy_reflect::TypePath;
 use bevy_render::{
     render_resource::{AsBindGroup, ShaderType},
-    storage::ShaderStorageBuffer,
+    storage::ShaderBuffer,
 };
 use bevy_shader::{Shader, ShaderRef};
 use bevy_ui_render::prelude::{UiMaterial, UiMaterialPlugin};
@@ -77,7 +77,7 @@ pub struct FrametimeGraphMaterial {
     ///
     /// This should be updated every frame to match the frame time history from the [`DiagnosticsStore`]
     #[storage(0, read_only)]
-    pub values: Handle<ShaderStorageBuffer>, // Vec<f32>,
+    pub values: Handle<ShaderBuffer>, // Vec<f32>,
     /// The configuration values used by the shader to control how the graph is rendered
     #[uniform(1)]
     pub config: FrameTimeGraphConfigUniform,
@@ -92,7 +92,7 @@ impl UiMaterial for FrametimeGraphMaterial {
 /// A system that updates the frame time values sent to the frame time graph
 fn update_frame_time_values(
     mut frame_time_graph_materials: ResMut<Assets<FrametimeGraphMaterial>>,
-    mut buffers: ResMut<Assets<ShaderStorageBuffer>>,
+    mut buffers: ResMut<Assets<ShaderBuffer>>,
     diagnostics_store: Res<DiagnosticsStore>,
     config: Option<Res<FpsOverlayConfig>>,
 ) {

crates/bevy_render/macros/src/as_bind_group.rs

@@ -466,7 +466,7 @@ pub fn derive_as_bind_group(ast: syn::DeriveInput) -> Result<TokenStream> {
                         (
                             #binding_index,
                             #render_path::render_resource::OwnedBindingResource::Buffer({
-                                let handle: &#asset_path::Handle<#render_path::storage::ShaderStorageBuffer> = (&self.#field_name);
+                                let handle: &#asset_path::Handle<#render_path::storage::ShaderBuffer> = (&self.#field_name);
                                 storage_buffers.get(handle).ok_or_else(|| #render_path::render_resource::AsBindGroupError::RetryNextUpdate)?.buffer.clone()
                             })
                         )
@@ -1049,7 +1049,7 @@ pub fn derive_as_bind_group(ast: syn::DeriveInput) -> Result<TokenStream> {
             type Param = (
                 #ecs_path::system::lifetimeless::SRes<#render_path::render_asset::RenderAssets<#render_path::texture::GpuImage>>,
                 #ecs_path::system::lifetimeless::SRes<#render_path::texture::FallbackImage>,
-                #ecs_path::system::lifetimeless::SRes<#render_path::render_asset::RenderAssets<#render_path::storage::GpuShaderStorageBuffer>>,
+                #ecs_path::system::lifetimeless::SRes<#render_path::render_asset::RenderAssets<#render_path::storage::GpuShaderBuffer>>,
             );
 
             #bindless_slot_count

crates/bevy_render/src/gpu_readback.rs

@@ -6,7 +6,7 @@ use crate::{
         TextureFormat,
     },
     renderer::{render_system, RenderDevice},
-    storage::{GpuShaderStorageBuffer, ShaderStorageBuffer},
+    storage::{GpuShaderBuffer, ShaderBuffer},
     sync_world::MainEntity,
     texture::GpuImage,
     ExtractSchedule, MainWorld, Render, RenderApp, RenderSystems,
@@ -78,7 +78,7 @@ impl Plugin for GpuReadbackPlugin {
 pub enum Readback {
     Texture(Handle<Image>),
     Buffer {
-        buffer: Handle<ShaderStorageBuffer>,
+        buffer: Handle<ShaderBuffer>,
         start_offset_and_size: Option<(u64, u64)>,
     },
 }
@@ -90,7 +90,7 @@ impl Readback {
     }
 
     /// Create a readback component for a full buffer using the given handle.
-    pub fn buffer(buffer: Handle<ShaderStorageBuffer>) -> Self {
+    pub fn buffer(buffer: Handle<ShaderBuffer>) -> Self {
         Self::Buffer {
             buffer,
             start_offset_and_size: None,
@@ -99,7 +99,7 @@ impl Readback {
 
     /// Create a readback component for a buffer range using the given handle, a start offset in bytes
     /// and a number of bytes to read.
-    pub fn buffer_range(buffer: Handle<ShaderStorageBuffer>, start_offset: u64, size: u64) -> Self {
+    pub fn buffer_range(buffer: Handle<ShaderBuffer>, start_offset: u64, size: u64) -> Self {
         Self::Buffer {
             buffer,
             start_offset_and_size: Some((start_offset, size)),
@@ -255,7 +255,7 @@ fn prepare_buffers(
     mut readbacks: ResMut<GpuReadbacks>,
     mut buffer_pool: ResMut<GpuReadbackBufferPool>,
     gpu_images: Res<RenderAssets<GpuImage>>,
-    ssbos: Res<RenderAssets<GpuShaderStorageBuffer>>,
+    ssbos: Res<RenderAssets<GpuShaderBuffer>>,
     handles: Query<(&MainEntity, &Readback)>,
 ) {
     for (entity, readback) in handles.iter() {

crates/bevy_render/src/render_resource/bind_group.rs

@@ -112,7 +112,7 @@ impl Deref for BindGroup {
 /// # use bevy_image::Image;
 /// # use bevy_color::LinearRgba;
 /// # use bevy_asset::Handle;
-/// # use bevy_render::storage::ShaderStorageBuffer;
+/// # use bevy_render::storage::ShaderBuffer;
 ///
 /// #[derive(AsBindGroup)]
 /// struct CoolMaterial {
@@ -122,7 +122,7 @@ impl Deref for BindGroup {
 ///     #[sampler(2)]
 ///     color_texture: Handle<Image>,
 ///     #[storage(3, read_only)]
-///     storage_buffer: Handle<ShaderStorageBuffer>,
+///     storage_buffer: Handle<ShaderBuffer>,
 ///     #[storage(4, read_only, buffer)]
 ///     raw_buffer: Buffer,
 ///     #[storage_texture(5)]

crates/bevy_render/src/storage.rs

@@ -11,23 +11,23 @@ use bevy_utils::default;
 use encase::{internal::WriteInto, ShaderType};
 use wgpu::util::BufferInitDescriptor;
 
-/// Adds [`ShaderStorageBuffer`] as an asset that is extracted and uploaded to the GPU.
+/// Adds [`ShaderBuffer`] as an asset that is extracted and uploaded to the GPU.
 #[derive(Default)]
 pub struct StoragePlugin;
 
 impl Plugin for StoragePlugin {
     fn build(&self, app: &mut App) {
-        app.add_plugins(RenderAssetPlugin::<GpuShaderStorageBuffer>::default())
-            .init_asset::<ShaderStorageBuffer>()
-            .register_asset_reflect::<ShaderStorageBuffer>();
+        app.add_plugins(RenderAssetPlugin::<GpuShaderBuffer>::default())
+            .init_asset::<ShaderBuffer>()
+            .register_asset_reflect::<ShaderBuffer>();
     }
 }
 
 /// A storage buffer that is prepared as a [`RenderAsset`] and uploaded to the GPU.
 #[derive(Asset, Reflect, Debug, Clone)]
 #[reflect(opaque)]
 #[reflect(Default, Debug, Clone)]
-pub struct ShaderStorageBuffer {
+pub struct ShaderBuffer {
     /// Optional data used to initialize the buffer.
     pub data: Option<Vec<u8>>,
     /// The buffer description used to create the buffer.
@@ -36,7 +36,7 @@ pub struct ShaderStorageBuffer {
     pub asset_usage: RenderAssetUsages,
 }
 
-impl Default for ShaderStorageBuffer {
+impl Default for ShaderBuffer {
     fn default() -> Self {
         Self {
             data: None,
@@ -51,10 +51,10 @@ impl Default for ShaderStorageBuffer {
     }
 }
 
-impl ShaderStorageBuffer {
+impl ShaderBuffer {
     /// Creates a new storage buffer with the given data and asset usage.
     pub fn new(data: &[u8], asset_usage: RenderAssetUsages) -> Self {
-        let mut storage = ShaderStorageBuffer {
+        let mut storage = ShaderBuffer {
             data: Some(data.to_vec()),
             ..default()
         };
@@ -64,7 +64,7 @@ impl ShaderStorageBuffer {
 
     /// Creates a new storage buffer with the given size and asset usage.
     pub fn with_size(size: usize, asset_usage: RenderAssetUsages) -> Self {
-        let mut storage = ShaderStorageBuffer {
+        let mut storage = ShaderBuffer {
             data: None,
             ..default()
         };
@@ -86,7 +86,7 @@ impl ShaderStorageBuffer {
     }
 }
 
-impl<T> From<T> for ShaderStorageBuffer
+impl<T> From<T> for ShaderBuffer
 where
     T: ShaderType + WriteInto,
 {
@@ -99,13 +99,13 @@ where
 }
 
 /// A storage buffer that is prepared as a [`RenderAsset`] and uploaded to the GPU.
-pub struct GpuShaderStorageBuffer {
+pub struct GpuShaderBuffer {
     pub buffer: Buffer,
     pub had_data: bool,
 }
 
-impl RenderAsset for GpuShaderStorageBuffer {
-    type SourceAsset = ShaderStorageBuffer;
+impl RenderAsset for GpuShaderBuffer {
+    type SourceAsset = ShaderBuffer;
     type Param = SRes<RenderDevice>;
 
     fn asset_usage(source_asset: &Self::SourceAsset) -> RenderAssetUsages {
@@ -141,14 +141,14 @@ impl RenderAsset for GpuShaderStorageBuffer {
                     contents: &data,
                     usage: source_asset.buffer_description.usage,
                 });
-                Ok(GpuShaderStorageBuffer {
+                Ok(GpuShaderBuffer {
                     buffer,
                     had_data: true,
                 })
             }
             None => {
                 let buffer = render_device.create_buffer(&source_asset.buffer_description);
-                Ok(GpuShaderStorageBuffer {
+                Ok(GpuShaderBuffer {
                     buffer,
                     had_data: false,
                 })

examples/shader/gpu_readback.rs

@@ -14,7 +14,7 @@ use bevy::{
             *,
         },
         renderer::{RenderContext, RenderDevice},
-        storage::{GpuShaderStorageBuffer, ShaderStorageBuffer},
+        storage::{GpuShaderBuffer, ShaderBuffer},
         texture::GpuImage,
         Render, RenderApp, RenderStartup, RenderSystems,
     },
@@ -62,19 +62,19 @@ impl Plugin for GpuReadbackPlugin {
 }
 
 #[derive(Resource, ExtractResource, Clone)]
-struct ReadbackBuffer(Handle<ShaderStorageBuffer>);
+struct ReadbackBuffer(Handle<ShaderBuffer>);
 
 #[derive(Resource, ExtractResource, Clone)]
 struct ReadbackImage(Handle<Image>);
 
 fn setup(
     mut commands: Commands,
     mut images: ResMut<Assets<Image>>,
-    mut buffers: ResMut<Assets<ShaderStorageBuffer>>,
+    mut buffers: ResMut<Assets<ShaderBuffer>>,
 ) {
     // Create a storage buffer with some data
     let buffer: Vec<u32> = (0..BUFFER_LEN as u32).collect();
-    let mut buffer = ShaderStorageBuffer::from(buffer);
+    let mut buffer = ShaderBuffer::from(buffer);
     // We need to enable the COPY_SRC usage so we can copy the buffer to the cpu
     buffer.buffer_description.usage |= BufferUsages::COPY_SRC;
     let buffer = buffers.add(buffer);
@@ -104,7 +104,7 @@ fn setup(
     commands
         .spawn(Readback::buffer(buffer.clone()))
         .observe(|event: On<ReadbackComplete>| {
-            // This matches the type which was used to create the `ShaderStorageBuffer` above,
+            // This matches the type which was used to create the `ShaderBuffer` above,
             // and is a convenient way to interpret the data.
             let data: Vec<u32> = event.to_shader_type();
             info!("Buffer {:?}", data);
@@ -156,7 +156,7 @@ fn prepare_bind_group(
     pipeline_cache: Res<PipelineCache>,
     buffer: Res<ReadbackBuffer>,
     image: Res<ReadbackImage>,
-    buffers: Res<RenderAssets<GpuShaderStorageBuffer>>,
+    buffers: Res<RenderAssets<GpuShaderBuffer>>,
     images: Res<RenderAssets<GpuImage>>,
 ) {
     let buffer = buffers.get(&buffer.0).unwrap();

examples/shader/storage_buffer.rs

@@ -3,7 +3,7 @@ use bevy::{
     mesh::MeshTag,
     prelude::*,
     reflect::TypePath,
-    render::{render_resource::AsBindGroup, storage::ShaderStorageBuffer},
+    render::{render_resource::AsBindGroup, storage::ShaderBuffer},
     shader::ShaderRef,
 };
 
@@ -21,7 +21,7 @@ fn main() {
 fn setup(
     mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
-    mut buffers: ResMut<Assets<ShaderStorageBuffer>>,
+    mut buffers: ResMut<Assets<ShaderBuffer>>,
     mut materials: ResMut<Assets<CustomMaterial>>,
 ) {
     // Example data for the storage buffer
@@ -33,7 +33,7 @@ fn setup(
         [0.0, 1.0, 1.0, 1.0],
     ];
 
-    let colors = buffers.add(ShaderStorageBuffer::from(color_data));
+    let colors = buffers.add(ShaderBuffer::from(color_data));
 
     let mesh_handle = meshes.add(Cuboid::from_size(Vec3::splat(0.3)));
     // Create the custom material with the storage buffer
@@ -69,7 +69,7 @@ fn update(
     time: Res<Time>,
     material_handles: Res<CustomMaterialHandle>,
     mut materials: ResMut<Assets<CustomMaterial>>,
-    mut buffers: ResMut<Assets<ShaderStorageBuffer>>,
+    mut buffers: ResMut<Assets<ShaderBuffer>>,
 ) {
     let material = materials.get_mut(&material_handles.0).unwrap();
 
@@ -97,7 +97,7 @@ struct CustomMaterialHandle(Handle<CustomMaterial>);
 #[derive(Asset, TypePath, AsBindGroup, Debug, Clone)]
 struct CustomMaterial {
     #[storage(0, read_only)]
-    colors: Handle<ShaderStorageBuffer>,
+    colors: Handle<ShaderBuffer>,
 }
 
 impl Material for CustomMaterial {

release-content/migration-guides/shader_buffer_rename.md

@@ -0,0 +1,7 @@
+---
+title: "`ShaderStorageBuffer` renamed to `ShaderBuffer`"
+pull_requests: [22558]
+---
+
+`ShaderStorageBuffer` has been renamed to `ShaderBuffer` and `GpuShaderStorageBuffer` has been renamed to
+`GpuShaderBuffer`. Update your imports and type references accordingly.