forestia/bevy
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use RenderStartup in bevy_sprite. (#20147)

Browse Source 
# Objective

- Progress towards #19887.

## Solution

- Convert FromWorld implementations into systems.
- Move any resource "manipulation" from `Plugin::finish` to systems.
- Add `after` dependencies to any uses of these resources (basically all
`SpritePipeline`).

## Testing

- Ran the `sprite`, and `mesh2d_manual` example and it worked.
This commit is contained in:
andriyDev 2025-07-14 23:30:34 -07:00 committed by GitHub
parent 2be3bc5310
commit 2824bd5f6e
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
8 changed files with 243 additions and 235 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
crates/bevy_gizmos/src/pipeline_2d.rs
View File

@ -27,7 +27,9 @@ use bevy_render::{
Render, RenderApp, RenderSystems, Render, RenderApp, RenderSystems,
}; };
use bevy_render::{sync_world::MainEntity, RenderStartup}; use bevy_render::{sync_world::MainEntity, RenderStartup};
use bevy_sprite::{Mesh2dPipeline, Mesh2dPipelineKey, SetMesh2dViewBindGroup}; use bevy_sprite::{
init_mesh_2d_pipeline, Mesh2dPipeline, Mesh2dPipelineKey, SetMesh2dViewBindGroup,
};
use bevy_utils::default; use bevy_utils::default;
use tracing::error; use tracing::error;
@ -56,7 +58,9 @@ impl Plugin for LineGizmo2dPlugin {
) )
.add_systems( .add_systems(
RenderStartup, RenderStartup,
init_line_gizmo_pipelines.after(init_line_gizmo_uniform_bind_group_layout), init_line_gizmo_pipelines
.after(init_line_gizmo_uniform_bind_group_layout)
.after(init_mesh_2d_pipeline),
) )
.add_systems( .add_systems(
Render, Render,

12
crates/bevy_sprite/src/lib.rs
View File

@ -56,7 +56,7 @@ use bevy_render::{
render_phase::AddRenderCommand, render_phase::AddRenderCommand,
render_resource::SpecializedRenderPipelines, render_resource::SpecializedRenderPipelines,
view::{NoFrustumCulling, VisibilitySystems}, view::{NoFrustumCulling, VisibilitySystems},
ExtractSchedule, Render, RenderApp, RenderSystems, ExtractSchedule, Render, RenderApp, RenderStartup, RenderSystems,
}; };
/// Adds support for 2D sprite rendering. /// Adds support for 2D sprite rendering.
@ -118,7 +118,9 @@ impl Plugin for SpritePlugin {
.init_resource::<ExtractedSprites>() .init_resource::<ExtractedSprites>()
.init_resource::<ExtractedSlices>() .init_resource::<ExtractedSlices>()
.init_resource::<SpriteAssetEvents>() .init_resource::<SpriteAssetEvents>()
.init_resource::<SpriteBatches>()
.add_render_command::<Transparent2d, DrawSprite>() .add_render_command::<Transparent2d, DrawSprite>()
.add_systems(RenderStartup, init_sprite_pipeline)
.add_systems( .add_systems(
ExtractSchedule, ExtractSchedule,
( (
@ -140,14 +142,6 @@ impl Plugin for SpritePlugin {
); );
}; };
} }
fn finish(&self, app: &mut App) {
if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
render_app
.init_resource::<SpriteBatches>()
.init_resource::<SpritePipeline>();
}
}
} }
/// System calculating and inserting an [`Aabb`] component to entities with either: /// System calculating and inserting an [`Aabb`] component to entities with either:

59
crates/bevy_sprite/src/mesh2d/material.rs
View File

@ -1,6 +1,7 @@
use crate::{ use crate::{
DrawMesh2d, Mesh2d, Mesh2dPipeline, Mesh2dPipelineKey, RenderMesh2dInstances, init_mesh_2d_pipeline, DrawMesh2d, Mesh2d, Mesh2dPipeline, Mesh2dPipelineKey,
SetMesh2dBindGroup, SetMesh2dViewBindGroup, ViewKeyCache, ViewSpecializationTicks, RenderMesh2dInstances, SetMesh2dBindGroup, SetMesh2dViewBindGroup, ViewKeyCache,
ViewSpecializationTicks,
}; };
use bevy_app::{App, Plugin, PostUpdate}; use bevy_app::{App, Plugin, PostUpdate};
use bevy_asset::prelude::AssetChanged; use bevy_asset::prelude::AssetChanged;
@ -25,6 +26,7 @@ use bevy_render::camera::extract_cameras;
use bevy_render::render_phase::{DrawFunctionId, InputUniformIndex}; use bevy_render::render_phase::{DrawFunctionId, InputUniformIndex};
use bevy_render::render_resource::CachedRenderPipelineId; use bevy_render::render_resource::CachedRenderPipelineId;
use bevy_render::view::RenderVisibleEntities; use bevy_render::view::RenderVisibleEntities;
use bevy_render::RenderStartup;
use bevy_render::{ use bevy_render::{
mesh::{MeshVertexBufferLayoutRef, RenderMesh}, mesh::{MeshVertexBufferLayoutRef, RenderMesh},
render_asset::{ render_asset::{
@ -285,6 +287,10 @@ where
.add_render_command::<Transparent2d, DrawMaterial2d<M>>() .add_render_command::<Transparent2d, DrawMaterial2d<M>>()
.init_resource::<RenderMaterial2dInstances<M>>() .init_resource::<RenderMaterial2dInstances<M>>()
.init_resource::<SpecializedMeshPipelines<Material2dPipeline<M>>>() .init_resource::<SpecializedMeshPipelines<Material2dPipeline<M>>>()
.add_systems(
RenderStartup,
init_material_2d_pipeline::<M>.after(init_mesh_2d_pipeline),
)
.add_systems( .add_systems(
ExtractSchedule, ExtractSchedule,
( (
@ -306,12 +312,6 @@ where
); );
} }
} }
fn finish(&self, app: &mut App) {
if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
render_app.init_resource::<Material2dPipeline<M>>();
}
}
} }
#[derive(Resource, Deref, DerefMut)] #[derive(Resource, Deref, DerefMut)]
@ -463,28 +463,29 @@ where
} }
} }
impl<M: Material2d> FromWorld for Material2dPipeline<M> { pub fn init_material_2d_pipeline<M: Material2d>(
fn from_world(world: &mut World) -> Self { mut commands: Commands,
let asset_server = world.resource::<AssetServer>(); render_device: Res<RenderDevice>,
let render_device = world.resource::<RenderDevice>(); asset_server: Res<AssetServer>,
let material2d_layout = M::bind_group_layout(render_device); mesh_2d_pipeline: Res<Mesh2dPipeline>,
) {
let material2d_layout = M::bind_group_layout(&render_device);
Material2dPipeline { commands.insert_resource(Material2dPipeline::<M> {
mesh2d_pipeline: world.resource::<Mesh2dPipeline>().clone(), mesh2d_pipeline: mesh_2d_pipeline.clone(),
material2d_layout, material2d_layout,
vertex_shader: match M::vertex_shader() { vertex_shader: match M::vertex_shader() {
ShaderRef::Default => None, ShaderRef::Default => None,
ShaderRef::Handle(handle) => Some(handle), ShaderRef::Handle(handle) => Some(handle),
ShaderRef::Path(path) => Some(asset_server.load(path)), ShaderRef::Path(path) => Some(asset_server.load(path)),
}, },
fragment_shader: match M::fragment_shader() { fragment_shader: match M::fragment_shader() {
ShaderRef::Default => None, ShaderRef::Default => None,
ShaderRef::Handle(handle) => Some(handle), ShaderRef::Handle(handle) => Some(handle),
ShaderRef::Path(path) => Some(asset_server.load(path)), ShaderRef::Path(path) => Some(asset_server.load(path)),
}, },
marker: PhantomData, marker: PhantomData,
} });
}
} }
pub(super) type DrawMaterial2d<M> = ( pub(super) type DrawMaterial2d<M> = (

219
crates/bevy_sprite/src/mesh2d/mesh.rs
View File

@ -1,6 +1,6 @@
use bevy_app::Plugin; use bevy_app::Plugin;
use bevy_asset::{embedded_asset, load_embedded_asset, AssetId, Handle}; use bevy_asset::{embedded_asset, load_embedded_asset, AssetId, AssetServer, Handle};
use bevy_render::load_shader_library; use bevy_render::{load_shader_library, RenderStartup};
use crate::{tonemapping_pipeline_key, Material2dBindGroupId}; use crate::{tonemapping_pipeline_key, Material2dBindGroupId};
use bevy_core_pipeline::tonemapping::DebandDither; use bevy_core_pipeline::tonemapping::DebandDither;
@ -16,7 +16,7 @@ use bevy_ecs::system::SystemChangeTick;
use bevy_ecs::{ use bevy_ecs::{
prelude::*, prelude::*,
query::ROQueryItem, query::ROQueryItem,
system::{lifetimeless::*, SystemParamItem, SystemState}, system::{lifetimeless::*, SystemParamItem},
}; };
use bevy_image::{BevyDefault, Image, ImageSampler, TextureFormatPixelInfo}; use bevy_image::{BevyDefault, Image, ImageSampler, TextureFormatPixelInfo};
use bevy_math::{Affine3, Vec4}; use bevy_math::{Affine3, Vec4};
@ -69,15 +69,29 @@ impl Plugin for Mesh2dRenderPlugin {
embedded_asset!(app, "mesh2d.wgsl"); embedded_asset!(app, "mesh2d.wgsl");
// These bindings should be loaded as a shader library, but it depends on runtime
// information, so we will load it in a system.
embedded_asset!(app, "mesh2d_bindings.wgsl");
if let Some(render_app) = app.get_sub_app_mut(RenderApp) { if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
render_app render_app
.init_resource::<ViewKeyCache>() .init_resource::<ViewKeyCache>()
.init_resource::<RenderMesh2dInstances>() .init_resource::<RenderMesh2dInstances>()
.init_resource::<SpecializedMeshPipelines<Mesh2dPipeline>>() .init_resource::<SpecializedMeshPipelines<Mesh2dPipeline>>()
.init_resource::<ViewSpecializationTicks>()
.add_systems(
RenderStartup,
(
init_mesh_2d_pipeline,
init_batched_instance_buffer,
load_mesh2d_bindings,
),
)
.add_systems(ExtractSchedule, extract_mesh2d) .add_systems(ExtractSchedule, extract_mesh2d)
.add_systems( .add_systems(
Render, Render,
( (
check_views_need_specialization.in_set(PrepareAssets),
( (
sweep_old_entities::<Opaque2d>, sweep_old_entities::<Opaque2d>,
sweep_old_entities::<AlphaMask2d>, sweep_old_entities::<AlphaMask2d>,
@ -100,42 +114,6 @@ impl Plugin for Mesh2dRenderPlugin {
); );
} }
} }
fn finish(&self, app: &mut bevy_app::App) {
let mut mesh_bindings_shader_defs = Vec::with_capacity(1);
if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
let render_device = render_app.world().resource::<RenderDevice>();
let batched_instance_buffer =
BatchedInstanceBuffer::<Mesh2dUniform>::new(render_device);
if let Some(per_object_buffer_batch_size) =
GpuArrayBuffer::<Mesh2dUniform>::batch_size(render_device)
{
mesh_bindings_shader_defs.push(ShaderDefVal::UInt(
"PER_OBJECT_BUFFER_BATCH_SIZE".into(),
per_object_buffer_batch_size,
));
}
render_app
.insert_resource(batched_instance_buffer)
.init_resource::<Mesh2dPipeline>()
.init_resource::<ViewKeyCache>()
.init_resource::<ViewSpecializationTicks>()
.add_systems(
Render,
check_views_need_specialization.in_set(PrepareAssets),
);
}
// Load the mesh_bindings shader module here as it depends on runtime information about
// whether storage buffers are supported, or the maximum uniform buffer binding size.
load_shader_library!(app, "mesh2d_bindings.wgsl", move |settings| *settings =
ShaderSettings {
shader_defs: mesh_bindings_shader_defs.clone()
});
}
} }
#[derive(Resource, Deref, DerefMut, Default, Debug, Clone)] #[derive(Resource, Deref, DerefMut, Default, Debug, Clone)]
@ -180,6 +158,38 @@ pub fn check_views_need_specialization(
} }
} }
pub fn init_batched_instance_buffer(mut commands: Commands, render_device: Res<RenderDevice>) {
commands.insert_resource(BatchedInstanceBuffer::<Mesh2dUniform>::new(&render_device));
}
fn load_mesh2d_bindings(render_device: Res<RenderDevice>, asset_server: Res<AssetServer>) {
let mut mesh_bindings_shader_defs = Vec::with_capacity(1);
if let Some(per_object_buffer_batch_size) =
GpuArrayBuffer::<Mesh2dUniform>::batch_size(&render_device)
{
mesh_bindings_shader_defs.push(ShaderDefVal::UInt(
"PER_OBJECT_BUFFER_BATCH_SIZE".into(),
per_object_buffer_batch_size,
));
}
// Load the mesh_bindings shader module here as it depends on runtime information about
// whether storage buffers are supported, or the maximum uniform buffer binding size.
let handle: Handle<Shader> = load_embedded_asset!(
asset_server.as_ref(),
"mesh2d_bindings.wgsl",
move |settings| {
*settings = ShaderSettings {
shader_defs: mesh_bindings_shader_defs.clone(),
}
}
);
// Forget the handle so we don't have to store it anywhere, and we keep the embedded asset
// loaded. Note: This is what happens in `load_shader_library` internally.
core::mem::forget(handle);
}
#[derive(Component)] #[derive(Component)]
pub struct Mesh2dTransforms { pub struct Mesh2dTransforms {
pub world_from_local: Affine3, pub world_from_local: Affine3,
@ -282,79 +292,74 @@ pub struct Mesh2dPipeline {
pub per_object_buffer_batch_size: Option<u32>, pub per_object_buffer_batch_size: Option<u32>,
} }
impl FromWorld for Mesh2dPipeline { pub fn init_mesh_2d_pipeline(
fn from_world(world: &mut World) -> Self { mut commands: Commands,
let mut system_state: SystemState<( render_device: Res<RenderDevice>,
Res<RenderDevice>, render_queue: Res<RenderQueue>,
Res<RenderQueue>, default_sampler: Res<DefaultImageSampler>,
Res<DefaultImageSampler>, asset_server: Res<AssetServer>,
)> = SystemState::new(world); ) {
let (render_device, render_queue, default_sampler) = system_state.get_mut(world); let tonemapping_lut_entries = get_lut_bind_group_layout_entries();
let render_device = render_device.into_inner(); let view_layout = render_device.create_bind_group_layout(
let tonemapping_lut_entries = get_lut_bind_group_layout_entries(); "mesh2d_view_layout",
let view_layout = render_device.create_bind_group_layout( &BindGroupLayoutEntries::sequential(
"mesh2d_view_layout", ShaderStages::VERTEX_FRAGMENT,
&BindGroupLayoutEntries::sequential( (
ShaderStages::VERTEX_FRAGMENT, uniform_buffer::<ViewUniform>(true),
( uniform_buffer::<GlobalsUniform>(false),
uniform_buffer::<ViewUniform>(true), tonemapping_lut_entries[0].visibility(ShaderStages::FRAGMENT),
uniform_buffer::<GlobalsUniform>(false), tonemapping_lut_entries[1].visibility(ShaderStages::FRAGMENT),
tonemapping_lut_entries[0].visibility(ShaderStages::FRAGMENT),
tonemapping_lut_entries[1].visibility(ShaderStages::FRAGMENT),
),
), ),
); ),
);
let mesh_layout = render_device.create_bind_group_layout( let mesh_layout = render_device.create_bind_group_layout(
"mesh2d_layout", "mesh2d_layout",
&BindGroupLayoutEntries::single( &BindGroupLayoutEntries::single(
ShaderStages::VERTEX_FRAGMENT, ShaderStages::VERTEX_FRAGMENT,
GpuArrayBuffer::<Mesh2dUniform>::binding_layout(render_device), GpuArrayBuffer::<Mesh2dUniform>::binding_layout(&render_device),
), ),
); );
// A 1x1x1 'all 1.0' texture to use as a dummy texture to use in place of optional StandardMaterial textures // A 1x1x1 'all 1.0' texture to use as a dummy texture to use in place of optional StandardMaterial textures
let dummy_white_gpu_image = { let dummy_white_gpu_image = {
let image = Image::default(); let image = Image::default();
let texture = render_device.create_texture(&image.texture_descriptor); let texture = render_device.create_texture(&image.texture_descriptor);
let sampler = match image.sampler { let sampler = match image.sampler {
ImageSampler::Default => (**default_sampler).clone(), ImageSampler::Default => (**default_sampler).clone(),
ImageSampler::Descriptor(ref descriptor) => { ImageSampler::Descriptor(ref descriptor) => {
render_device.create_sampler(&descriptor.as_wgpu()) render_device.create_sampler(&descriptor.as_wgpu())
}
};
let format_size = image.texture_descriptor.format.pixel_size();
render_queue.write_texture(
texture.as_image_copy(),
image.data.as_ref().expect("Image has no data"),
TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(image.width() * format_size as u32),
rows_per_image: None,
},
image.texture_descriptor.size,
);
let texture_view = texture.create_view(&TextureViewDescriptor::default());
GpuImage {
texture,
texture_view,
texture_format: image.texture_descriptor.format,
sampler,
size: image.texture_descriptor.size,
mip_level_count: image.texture_descriptor.mip_level_count,
} }
}; };
Mesh2dPipeline {
view_layout, let format_size = image.texture_descriptor.format.pixel_size();
mesh_layout, render_queue.write_texture(
dummy_white_gpu_image, texture.as_image_copy(),
per_object_buffer_batch_size: GpuArrayBuffer::<Mesh2dUniform>::batch_size( image.data.as_ref().expect("Image has no data"),
render_device, TexelCopyBufferLayout {
), offset: 0,
shader: load_embedded_asset!(world, "mesh2d.wgsl"), bytes_per_row: Some(image.width() * format_size as u32),
rows_per_image: None,
},
image.texture_descriptor.size,
);
let texture_view = texture.create_view(&TextureViewDescriptor::default());
GpuImage {
texture,
texture_view,
texture_format: image.texture_descriptor.format,
sampler,
size: image.texture_descriptor.size,
mip_level_count: image.texture_descriptor.mip_level_count,
} }
} };
commands.insert_resource(Mesh2dPipeline {
view_layout,
mesh_layout,
dummy_white_gpu_image,
per_object_buffer_batch_size: GpuArrayBuffer::<Mesh2dUniform>::batch_size(&render_device),
shader: load_embedded_asset!(asset_server.as_ref(), "mesh2d.wgsl"),
});
} }
impl Mesh2dPipeline { impl Mesh2dPipeline {

35
crates/bevy_sprite/src/mesh2d/wireframe2d.rs
View File

@ -1,11 +1,11 @@
use crate::{ use crate::{
DrawMesh2d, Mesh2dPipeline, Mesh2dPipelineKey, RenderMesh2dInstances, SetMesh2dBindGroup, init_mesh_2d_pipeline, DrawMesh2d, Mesh2dPipeline, Mesh2dPipelineKey, RenderMesh2dInstances,
SetMesh2dViewBindGroup, ViewKeyCache, ViewSpecializationTicks, SetMesh2dBindGroup, SetMesh2dViewBindGroup, ViewKeyCache, ViewSpecializationTicks,
}; };
use bevy_app::{App, Plugin, PostUpdate, Startup, Update}; use bevy_app::{App, Plugin, PostUpdate, Startup, Update};
use bevy_asset::{ use bevy_asset::{
embedded_asset, load_embedded_asset, prelude::AssetChanged, AsAssetId, Asset, AssetApp, embedded_asset, load_embedded_asset, prelude::AssetChanged, AsAssetId, Asset, AssetApp,
AssetEventSystems, AssetId, Assets, Handle, UntypedAssetId, AssetEventSystems, AssetId, AssetServer, Assets, Handle, UntypedAssetId,
}; };
use bevy_color::{Color, ColorToComponents}; use bevy_color::{Color, ColorToComponents};
use bevy_core_pipeline::core_2d::{ use bevy_core_pipeline::core_2d::{
@ -49,7 +49,7 @@ use bevy_render::{
view::{ view::{
ExtractedView, RenderVisibleEntities, RetainedViewEntity, ViewDepthTexture, ViewTarget, ExtractedView, RenderVisibleEntities, RetainedViewEntity, ViewDepthTexture, ViewTarget,
}, },
Extract, Render, RenderApp, RenderDebugFlags, RenderSystems, Extract, Render, RenderApp, RenderDebugFlags, RenderStartup, RenderSystems,
}; };
use core::{hash::Hash, ops::Range}; use core::{hash::Hash, ops::Range};
use tracing::error; use tracing::error;
@ -129,6 +129,10 @@ impl Plugin for Wireframe2dPlugin {
Node2d::PostProcessing, Node2d::PostProcessing,
), ),
) )
.add_systems(
RenderStartup,
init_wireframe_2d_pipeline.after(init_mesh_2d_pipeline),
)
.add_systems( .add_systems(
ExtractSchedule, ExtractSchedule,
( (
@ -150,13 +154,6 @@ impl Plugin for Wireframe2dPlugin {
), ),
); );
} }
fn finish(&self, app: &mut App) {
let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
return;
};
render_app.init_resource::<Wireframe2dPipeline>();
}
} }
/// Enables wireframe rendering for any entity it is attached to. /// Enables wireframe rendering for any entity it is attached to.
@ -327,13 +324,15 @@ pub struct Wireframe2dPipeline {
shader: Handle<Shader>, shader: Handle<Shader>,
} }
impl FromWorld for Wireframe2dPipeline { pub fn init_wireframe_2d_pipeline(
fn from_world(render_world: &mut World) -> Self { mut commands: Commands,
Wireframe2dPipeline { mesh_2d_pipeline: Res<Mesh2dPipeline>,
mesh_pipeline: render_world.resource::<Mesh2dPipeline>().clone(), asset_server: Res<AssetServer>,
shader: load_embedded_asset!(render_world, "wireframe2d.wgsl"), ) {
} commands.insert_resource(Wireframe2dPipeline {
} mesh_pipeline: mesh_2d_pipeline.clone(),
shader: load_embedded_asset!(asset_server.as_ref(), "wireframe2d.wgsl"),
});
} }
impl SpecializedMeshPipeline for Wireframe2dPipeline { impl SpecializedMeshPipeline for Wireframe2dPipeline {

129
crates/bevy_sprite/src/render/mod.rs
View File

@ -1,7 +1,7 @@
use core::ops::Range; use core::ops::Range;
use crate::{Anchor, ComputedTextureSlices, ScalingMode, Sprite}; use crate::{Anchor, ComputedTextureSlices, ScalingMode, Sprite};
use bevy_asset::{load_embedded_asset, AssetEvent, AssetId, Assets, Handle}; use bevy_asset::{load_embedded_asset, AssetEvent, AssetId, AssetServer, Assets, Handle};
use bevy_color::{ColorToComponents, LinearRgba}; use bevy_color::{ColorToComponents, LinearRgba};
use bevy_core_pipeline::{ use bevy_core_pipeline::{
core_2d::{Transparent2d, CORE_2D_DEPTH_FORMAT}, core_2d::{Transparent2d, CORE_2D_DEPTH_FORMAT},
@ -14,7 +14,7 @@ use bevy_derive::{Deref, DerefMut};
use bevy_ecs::{ use bevy_ecs::{
prelude::*, prelude::*,
query::ROQueryItem, query::ROQueryItem,
system::{lifetimeless::*, SystemParamItem, SystemState}, system::{lifetimeless::*, SystemParamItem},
}; };
use bevy_image::{BevyDefault, Image, ImageSampler, TextureAtlasLayout, TextureFormatPixelInfo}; use bevy_image::{BevyDefault, Image, ImageSampler, TextureAtlasLayout, TextureFormatPixelInfo};
use bevy_math::{Affine3A, FloatOrd, Quat, Rect, Vec2, Vec4}; use bevy_math::{Affine3A, FloatOrd, Quat, Rect, Vec2, Vec4};
@ -52,77 +52,74 @@ pub struct SpritePipeline {
pub dummy_white_gpu_image: GpuImage, pub dummy_white_gpu_image: GpuImage,
} }
impl FromWorld for SpritePipeline { pub fn init_sprite_pipeline(
fn from_world(world: &mut World) -> Self { mut commands: Commands,
let mut system_state: SystemState<( render_device: Res<RenderDevice>,
Res<RenderDevice>, default_sampler: Res<DefaultImageSampler>,
Res<DefaultImageSampler>, render_queue: Res<RenderQueue>,
Res<RenderQueue>, asset_server: Res<AssetServer>,
)> = SystemState::new(world); ) {
let (render_device, default_sampler, render_queue) = system_state.get_mut(world); let tonemapping_lut_entries = get_lut_bind_group_layout_entries();
let view_layout = render_device.create_bind_group_layout(
let tonemapping_lut_entries = get_lut_bind_group_layout_entries(); "sprite_view_layout",
let view_layout = render_device.create_bind_group_layout( &BindGroupLayoutEntries::sequential(
"sprite_view_layout", ShaderStages::VERTEX_FRAGMENT,
&BindGroupLayoutEntries::sequential( (
ShaderStages::VERTEX_FRAGMENT, uniform_buffer::<ViewUniform>(true),
( tonemapping_lut_entries[0].visibility(ShaderStages::FRAGMENT),
uniform_buffer::<ViewUniform>(true), tonemapping_lut_entries[1].visibility(ShaderStages::FRAGMENT),
tonemapping_lut_entries[0].visibility(ShaderStages::FRAGMENT),
tonemapping_lut_entries[1].visibility(ShaderStages::FRAGMENT),
),
), ),
); ),
);
let material_layout = render_device.create_bind_group_layout( let material_layout = render_device.create_bind_group_layout(
"sprite_material_layout", "sprite_material_layout",
&BindGroupLayoutEntries::sequential( &BindGroupLayoutEntries::sequential(
ShaderStages::FRAGMENT, ShaderStages::FRAGMENT,
( (
texture_2d(TextureSampleType::Float { filterable: true }), texture_2d(TextureSampleType::Float { filterable: true }),
sampler(SamplerBindingType::Filtering), sampler(SamplerBindingType::Filtering),
),
), ),
); ),
let dummy_white_gpu_image = { );
let image = Image::default(); let dummy_white_gpu_image = {
let texture = render_device.create_texture(&image.texture_descriptor); let image = Image::default();
let sampler = match image.sampler { let texture = render_device.create_texture(&image.texture_descriptor);
ImageSampler::Default => (**default_sampler).clone(), let sampler = match image.sampler {
ImageSampler::Descriptor(ref descriptor) => { ImageSampler::Default => (**default_sampler).clone(),
render_device.create_sampler(&descriptor.as_wgpu()) ImageSampler::Descriptor(ref descriptor) => {
} render_device.create_sampler(&descriptor.as_wgpu())
};
let format_size = image.texture_descriptor.format.pixel_size();
render_queue.write_texture(
texture.as_image_copy(),
image.data.as_ref().expect("Image has no data"),
TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(image.width() * format_size as u32),
rows_per_image: None,
},
image.texture_descriptor.size,
);
let texture_view = texture.create_view(&TextureViewDescriptor::default());
GpuImage {
texture,
texture_view,
texture_format: image.texture_descriptor.format,
sampler,
size: image.texture_descriptor.size,
mip_level_count: image.texture_descriptor.mip_level_count,
} }
}; };
SpritePipeline { let format_size = image.texture_descriptor.format.pixel_size();
view_layout, render_queue.write_texture(
material_layout, texture.as_image_copy(),
dummy_white_gpu_image, image.data.as_ref().expect("Image has no data"),
shader: load_embedded_asset!(world, "sprite.wgsl"), TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(image.width() * format_size as u32),
rows_per_image: None,
},
image.texture_descriptor.size,
);
let texture_view = texture.create_view(&TextureViewDescriptor::default());
GpuImage {
texture,
texture_view,
texture_format: image.texture_descriptor.format,
sampler,
size: image.texture_descriptor.size,
mip_level_count: image.texture_descriptor.mip_level_count,
} }
} };
commands.insert_resource(SpritePipeline {
view_layout,
material_layout,
dummy_white_gpu_image,
shader: load_embedded_asset!(asset_server.as_ref(), "sprite.wgsl"),
});
} }
bitflags::bitflags! { bitflags::bitflags! {

9
examples/2d/mesh2d_manual.rs
View File

@ -30,8 +30,8 @@ use bevy::{
Extract, Render, RenderApp, RenderStartup, RenderSystems, Extract, Render, RenderApp, RenderStartup, RenderSystems,
}, },
sprite::{ sprite::{
extract_mesh2d, DrawMesh2d, Material2dBindGroupId, Mesh2dPipeline, Mesh2dPipelineKey, extract_mesh2d, init_mesh_2d_pipeline, DrawMesh2d, Material2dBindGroupId, Mesh2dPipeline,
Mesh2dTransforms, MeshFlags, RenderMesh2dInstance, SetMesh2dBindGroup, Mesh2dPipelineKey, Mesh2dTransforms, MeshFlags, RenderMesh2dInstance, SetMesh2dBindGroup,
SetMesh2dViewBindGroup, SetMesh2dViewBindGroup,
}, },
}; };
@ -309,7 +309,10 @@ impl Plugin for ColoredMesh2dPlugin {
.add_render_command::<Transparent2d, DrawColoredMesh2d>() .add_render_command::<Transparent2d, DrawColoredMesh2d>()
.init_resource::<SpecializedRenderPipelines<ColoredMesh2dPipeline>>() .init_resource::<SpecializedRenderPipelines<ColoredMesh2dPipeline>>()
.init_resource::<RenderColoredMesh2dInstances>() .init_resource::<RenderColoredMesh2dInstances>()
.add_systems(RenderStartup, init_colored_mesh_2d_pipeline) .add_systems(
RenderStartup,
init_colored_mesh_2d_pipeline.after(init_mesh_2d_pipeline),
)
.add_systems( .add_systems(
ExtractSchedule, ExtractSchedule,
extract_colored_mesh2d.after(extract_mesh2d), extract_colored_mesh2d.after(extract_mesh2d),

7
release-content/migration-guides/render_startup.md
View File

@ -1,6 +1,6 @@
--- ---
title: Many render resources now initialized in `RenderStartup` title: Many render resources now initialized in `RenderStartup`
pull_requests: [19841, 19926, 19885, 19886, 19897, 19898, 19901] pull_requests: [19841, 19926, 19885, 19886, 19897, 19898, 19901, 20147]
--- ---
Many render resources are **no longer present** during `Plugin::finish`. Instead they are Many render resources are **no longer present** during `Plugin::finish`. Instead they are
@ -27,6 +27,11 @@ The following are the (public) resources that are now initialized in `RenderStar
- `PrepassViewBindGroup` - `PrepassViewBindGroup`
- `Wireframe3dPipeline` - `Wireframe3dPipeline`
- `MaterialPipeline` - `MaterialPipeline`
- `Wireframe2dPipeline`
- `Material2dPipeline`
- `SpritePipeline`
- `Mesh2dPipeline`
- `BatchedInstanceBuffer<Mesh2dUniform>`
The vast majority of cases for initializing render resources look like so (in Bevy 0.16): The vast majority of cases for initializing render resources look like so (in Bevy 0.16):