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

Initialize SpritePipeline in a system in RenderStartup.

Browse Source
This commit is contained in:
andriyDev 2025-07-13 23:19:08 -07:00
parent 33736fc613
commit 330dd2040e
2 changed files with 66 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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:

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! {