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

Add headless mode (#3439)

Browse Source 
# Objective

In this PR I added the ability to opt-out graphical backends. Closes #3155.

## Solution

I turned backends into `Option` ~~and removed panicking sub app API to force users handle the error (was suggested by `@cart`)~~.
This commit is contained in:
Hennadii Chernyshchyk 2022-01-08 10:39:43 +00:00
parent 2ee38cb9e0
commit 458cb7a9e9
19 changed files with 283 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Cargo.toml
View File

@ -249,6 +249,10 @@ path = "examples/app/return_after_run.rs"
name = "thread_pool_resources" name = "thread_pool_resources"
path = "examples/app/thread_pool_resources.rs" path = "examples/app/thread_pool_resources.rs"
[[example]]
name = "headless_defaults"
path = "examples/app/headless_defaults.rs"
[[example]] [[example]]
name = "without_winit" name = "without_winit"
path = "examples/app/without_winit.rs" path = "examples/app/without_winit.rs"

6
crates/bevy_core_pipeline/src/lib.rs
View File

@ -95,7 +95,11 @@ impl Plugin for CorePipelinePlugin {
fn build(&self, app: &mut App) { fn build(&self, app: &mut App) {
app.init_resource::<ClearColor>(); app.init_resource::<ClearColor>();
let render_app = app.sub_app_mut(RenderApp); let render_app = match app.get_sub_app_mut(RenderApp) {
Ok(render_app) => render_app,
Err(_) => return,
};
render_app render_app
.init_resource::<DrawFunctions<Transparent2d>>() .init_resource::<DrawFunctions<Transparent2d>>()
.init_resource::<DrawFunctions<Opaque3d>>() .init_resource::<DrawFunctions<Opaque3d>>()

6
crates/bevy_pbr/src/lib.rs
View File

@ -138,7 +138,11 @@ impl Plugin for PbrPlugin {
}, },
); );
let render_app = app.sub_app_mut(RenderApp); let render_app = match app.get_sub_app_mut(RenderApp) {
Ok(render_app) => render_app,
Err(_) => return,
};
render_app render_app
.add_system_to_stage( .add_system_to_stage(
RenderStage::Extract, RenderStage::Extract,

12
crates/bevy_pbr/src/render/mesh.rs
View File

@ -53,11 +53,13 @@ impl Plugin for MeshRenderPlugin {
app.add_plugin(UniformComponentPlugin::<MeshUniform>::default()); app.add_plugin(UniformComponentPlugin::<MeshUniform>::default());
app.sub_app_mut(RenderApp) if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
.init_resource::<MeshPipeline>() render_app
.add_system_to_stage(RenderStage::Extract, extract_meshes) .init_resource::<MeshPipeline>()
.add_system_to_stage(RenderStage::Queue, queue_mesh_bind_group) .add_system_to_stage(RenderStage::Extract, extract_meshes)
.add_system_to_stage(RenderStage::Queue, queue_mesh_view_bind_groups); .add_system_to_stage(RenderStage::Queue, queue_mesh_bind_group)
.add_system_to_stage(RenderStage::Queue, queue_mesh_view_bind_groups);
}
} }
} }

16
crates/bevy_pbr/src/wireframe.rs
View File

@ -31,13 +31,15 @@ impl Plugin for WireframePlugin {
app.init_resource::<WireframeConfig>(); app.init_resource::<WireframeConfig>();
app.sub_app_mut(RenderApp) if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
.add_render_command::<Opaque3d, DrawWireframes>() render_app
.init_resource::<WireframePipeline>() .add_render_command::<Opaque3d, DrawWireframes>()
.init_resource::<SpecializedPipelines<WireframePipeline>>() .init_resource::<WireframePipeline>()
.add_system_to_stage(RenderStage::Extract, extract_wireframes) .init_resource::<SpecializedPipelines<WireframePipeline>>()
.add_system_to_stage(RenderStage::Extract, extract_wireframe_config) .add_system_to_stage(RenderStage::Extract, extract_wireframes)
.add_system_to_stage(RenderStage::Queue, queue_wireframes); .add_system_to_stage(RenderStage::Extract, extract_wireframe_config)
.add_system_to_stage(RenderStage::Queue, queue_wireframes);
}
} }
} }

8
crates/bevy_render/src/camera/mod.rs
View File

@ -53,9 +53,11 @@ impl Plugin for CameraPlugin {
CoreStage::PostUpdate, CoreStage::PostUpdate,
crate::camera::camera_system::<PerspectiveProjection>, crate::camera::camera_system::<PerspectiveProjection>,
); );
app.sub_app_mut(RenderApp) if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
.init_resource::<ExtractedCameraNames>() render_app
.add_system_to_stage(RenderStage::Extract, extract_cameras); .init_resource::<ExtractedCameraNames>()
.add_system_to_stage(RenderStage::Extract, extract_cameras);
}
} }
} }

300
crates/bevy_render/src/lib.rs
View File

@ -113,174 +113,178 @@ impl Plugin for RenderPlugin {
.get_resource::<options::WgpuOptions>() .get_resource::<options::WgpuOptions>()
.cloned() .cloned()
.unwrap_or_default(); .unwrap_or_default();
let instance = wgpu::Instance::new(options.backends);
let surface = { app.add_asset::<Shader>()
let world = app.world.cell();
let windows = world.get_resource_mut::<bevy_window::Windows>().unwrap();
let raw_handle = windows.get_primary().map(|window| unsafe {
let handle = window.raw_window_handle().get_handle();
instance.create_surface(&handle)
});
raw_handle
};
let request_adapter_options = wgpu::RequestAdapterOptions {
power_preference: options.power_preference,
compatible_surface: surface.as_ref(),
..Default::default()
};
let (device, queue) = futures_lite::future::block_on(renderer::initialize_renderer(
&instance,
&mut options,
&request_adapter_options,
));
debug!("Configured wgpu adapter Limits: {:#?}", &options.limits);
debug!("Configured wgpu adapter Features: {:#?}", &options.features);
app.insert_resource(device.clone())
.insert_resource(queue.clone())
.insert_resource(options.clone())
.add_asset::<Shader>()
.init_asset_loader::<ShaderLoader>() .init_asset_loader::<ShaderLoader>()
.init_resource::<ScratchRenderWorld>() .register_type::<Color>();
.register_type::<Color>()
.register_type::<Frustum>()
.register_type::<CubemapFrusta>();
let render_pipeline_cache = RenderPipelineCache::new(device.clone());
let asset_server = app.world.get_resource::<AssetServer>().unwrap().clone();
let mut render_app = App::empty(); if let Some(backends) = options.backends {
let mut extract_stage = let instance = wgpu::Instance::new(backends);
SystemStage::parallel().with_system(RenderPipelineCache::extract_shaders); let surface = {
// don't apply buffers when the stage finishes running let world = app.world.cell();
// extract stage runs on the app world, but the buffers are applied to the render world let windows = world.get_resource_mut::<bevy_window::Windows>().unwrap();
extract_stage.set_apply_buffers(false); let raw_handle = windows.get_primary().map(|window| unsafe {
render_app let handle = window.raw_window_handle().get_handle();
.add_stage(RenderStage::Extract, extract_stage) instance.create_surface(&handle)
.add_stage(RenderStage::Prepare, SystemStage::parallel()) });
.add_stage(RenderStage::Queue, SystemStage::parallel()) raw_handle
.add_stage(RenderStage::PhaseSort, SystemStage::parallel()) };
.add_stage( let request_adapter_options = wgpu::RequestAdapterOptions {
RenderStage::Render, power_preference: options.power_preference,
SystemStage::parallel() compatible_surface: surface.as_ref(),
.with_system(RenderPipelineCache::process_pipeline_queue_system) ..Default::default()
.with_system(render_system.exclusive_system().at_end()), };
) let (device, queue) = futures_lite::future::block_on(renderer::initialize_renderer(
.add_stage(RenderStage::Cleanup, SystemStage::parallel()) &instance,
.insert_resource(instance) &mut options,
.insert_resource(device) &request_adapter_options,
.insert_resource(queue) ));
.insert_resource(options) debug!("Configured wgpu adapter Limits: {:#?}", &options.limits);
.insert_resource(render_pipeline_cache) debug!("Configured wgpu adapter Features: {:#?}", &options.features);
.insert_resource(asset_server) app.insert_resource(device.clone())
.init_resource::<RenderGraph>(); .insert_resource(queue.clone())
.insert_resource(options.clone())
.init_resource::<ScratchRenderWorld>()
.register_type::<Frustum>()
.register_type::<CubemapFrusta>();
let render_pipeline_cache = RenderPipelineCache::new(device.clone());
let asset_server = app.world.get_resource::<AssetServer>().unwrap().clone();
app.add_sub_app(RenderApp, render_app, move |app_world, render_app| { let mut render_app = App::empty();
#[cfg(feature = "trace")] let mut extract_stage =
let render_span = bevy_utils::tracing::info_span!("renderer subapp"); SystemStage::parallel().with_system(RenderPipelineCache::extract_shaders);
#[cfg(feature = "trace")] // don't apply buffers when the stage finishes running
let _render_guard = render_span.enter(); // extract stage runs on the app world, but the buffers are applied to the render world
{ extract_stage.set_apply_buffers(false);
render_app
.add_stage(RenderStage::Extract, extract_stage)
.add_stage(RenderStage::Prepare, SystemStage::parallel())
.add_stage(RenderStage::Queue, SystemStage::parallel())
.add_stage(RenderStage::PhaseSort, SystemStage::parallel())
.add_stage(
RenderStage::Render,
SystemStage::parallel()
.with_system(RenderPipelineCache::process_pipeline_queue_system)
.with_system(render_system.exclusive_system().at_end()),
)
.add_stage(RenderStage::Cleanup, SystemStage::parallel())
.insert_resource(instance)
.insert_resource(device)
.insert_resource(queue)
.insert_resource(options)
.insert_resource(render_pipeline_cache)
.insert_resource(asset_server)
.init_resource::<RenderGraph>();
app.add_sub_app(RenderApp, render_app, move |app_world, render_app| {
#[cfg(feature = "trace")] #[cfg(feature = "trace")]
let stage_span = let render_span = bevy_utils::tracing::info_span!("renderer subapp");
bevy_utils::tracing::info_span!("stage", name = "reserve_and_flush");
#[cfg(feature = "trace")] #[cfg(feature = "trace")]
let _stage_guard = stage_span.enter(); let _render_guard = render_span.enter();
{
#[cfg(feature = "trace")]
let stage_span =
bevy_utils::tracing::info_span!("stage", name = "reserve_and_flush");
#[cfg(feature = "trace")]
let _stage_guard = stage_span.enter();
// reserve all existing app entities for use in render_app // reserve all existing app entities for use in render_app
// they can only be spawned using `get_or_spawn()` // they can only be spawned using `get_or_spawn()`
let meta_len = app_world.entities().meta.len(); let meta_len = app_world.entities().meta.len();
render_app render_app
.world .world
.entities() .entities()
.reserve_entities(meta_len as u32); .reserve_entities(meta_len as u32);
// flushing as "invalid" ensures that app world entities aren't added as "empty archetype" entities by default // flushing as "invalid" ensures that app world entities aren't added as "empty archetype" entities by default
// these entities cannot be accessed without spawning directly onto them // these entities cannot be accessed without spawning directly onto them
// this _only_ works as expected because clear_entities() is called at the end of every frame. // this _only_ works as expected because clear_entities() is called at the end of every frame.
render_app.world.entities_mut().flush_as_invalid(); render_app.world.entities_mut().flush_as_invalid();
} }
{ {
#[cfg(feature = "trace")] #[cfg(feature = "trace")]
let stage_span = bevy_utils::tracing::info_span!("stage", name = "extract"); let stage_span = bevy_utils::tracing::info_span!("stage", name = "extract");
#[cfg(feature = "trace")] #[cfg(feature = "trace")]
let _stage_guard = stage_span.enter(); let _stage_guard = stage_span.enter();
// extract // extract
extract(app_world, render_app); extract(app_world, render_app);
} }
{ {
#[cfg(feature = "trace")] #[cfg(feature = "trace")]
let stage_span = bevy_utils::tracing::info_span!("stage", name = "prepare"); let stage_span = bevy_utils::tracing::info_span!("stage", name = "prepare");
#[cfg(feature = "trace")] #[cfg(feature = "trace")]
let _stage_guard = stage_span.enter(); let _stage_guard = stage_span.enter();
// prepare // prepare
let prepare = render_app let prepare = render_app
.schedule .schedule
.get_stage_mut::<SystemStage>(&RenderStage::Prepare) .get_stage_mut::<SystemStage>(&RenderStage::Prepare)
.unwrap(); .unwrap();
prepare.run(&mut render_app.world); prepare.run(&mut render_app.world);
} }
{ {
#[cfg(feature = "trace")] #[cfg(feature = "trace")]
let stage_span = bevy_utils::tracing::info_span!("stage", name = "queue"); let stage_span = bevy_utils::tracing::info_span!("stage", name = "queue");
#[cfg(feature = "trace")] #[cfg(feature = "trace")]
let _stage_guard = stage_span.enter(); let _stage_guard = stage_span.enter();
// queue // queue
let queue = render_app let queue = render_app
.schedule .schedule
.get_stage_mut::<SystemStage>(&RenderStage::Queue) .get_stage_mut::<SystemStage>(&RenderStage::Queue)
.unwrap(); .unwrap();
queue.run(&mut render_app.world); queue.run(&mut render_app.world);
} }
{ {
#[cfg(feature = "trace")] #[cfg(feature = "trace")]
let stage_span = bevy_utils::tracing::info_span!("stage", name = "sort"); let stage_span = bevy_utils::tracing::info_span!("stage", name = "sort");
#[cfg(feature = "trace")] #[cfg(feature = "trace")]
let _stage_guard = stage_span.enter(); let _stage_guard = stage_span.enter();
// phase sort // phase sort
let phase_sort = render_app let phase_sort = render_app
.schedule .schedule
.get_stage_mut::<SystemStage>(&RenderStage::PhaseSort) .get_stage_mut::<SystemStage>(&RenderStage::PhaseSort)
.unwrap(); .unwrap();
phase_sort.run(&mut render_app.world); phase_sort.run(&mut render_app.world);
} }
{ {
#[cfg(feature = "trace")] #[cfg(feature = "trace")]
let stage_span = bevy_utils::tracing::info_span!("stage", name = "render"); let stage_span = bevy_utils::tracing::info_span!("stage", name = "render");
#[cfg(feature = "trace")] #[cfg(feature = "trace")]
let _stage_guard = stage_span.enter(); let _stage_guard = stage_span.enter();
// render // render
let render = render_app let render = render_app
.schedule .schedule
.get_stage_mut::<SystemStage>(&RenderStage::Render) .get_stage_mut::<SystemStage>(&RenderStage::Render)
.unwrap(); .unwrap();
render.run(&mut render_app.world); render.run(&mut render_app.world);
} }
{ {
#[cfg(feature = "trace")] #[cfg(feature = "trace")]
let stage_span = bevy_utils::tracing::info_span!("stage", name = "cleanup"); let stage_span = bevy_utils::tracing::info_span!("stage", name = "cleanup");
#[cfg(feature = "trace")] #[cfg(feature = "trace")]
let _stage_guard = stage_span.enter(); let _stage_guard = stage_span.enter();
// cleanup // cleanup
let cleanup = render_app let cleanup = render_app
.schedule .schedule
.get_stage_mut::<SystemStage>(&RenderStage::Cleanup) .get_stage_mut::<SystemStage>(&RenderStage::Cleanup)
.unwrap(); .unwrap();
cleanup.run(&mut render_app.world); cleanup.run(&mut render_app.world);
render_app.world.clear_entities(); render_app.world.clear_entities();
} }
}); });
}
app.add_plugin(WindowRenderPlugin) app.add_plugin(WindowRenderPlugin)
.add_plugin(CameraPlugin) .add_plugin(CameraPlugin)

4
crates/bevy_render/src/options.rs
View File

@ -12,7 +12,7 @@ pub enum WgpuOptionsPriority {
#[derive(Clone)] #[derive(Clone)]
pub struct WgpuOptions { pub struct WgpuOptions {
pub device_label: Option<Cow<'static, str>>, pub device_label: Option<Cow<'static, str>>,
pub backends: Backends, pub backends: Option<Backends>,
pub power_preference: PowerPreference, pub power_preference: PowerPreference,
pub priority: WgpuOptionsPriority, pub priority: WgpuOptionsPriority,
pub features: WgpuFeatures, pub features: WgpuFeatures,
@ -27,7 +27,7 @@ impl Default for WgpuOptions {
Backends::PRIMARY Backends::PRIMARY
}; };
let backends = wgpu::util::backend_bits_from_env().unwrap_or(default_backends); let backends = Some(wgpu::util::backend_bits_from_env().unwrap_or(default_backends));
let priority = options_priority_from_env().unwrap_or(WgpuOptionsPriority::Functionality); let priority = options_priority_from_env().unwrap_or(WgpuOptionsPriority::Functionality);

17
crates/bevy_render/src/render_asset.rs
View File

@ -54,14 +54,15 @@ impl<A: RenderAsset> Default for RenderAssetPlugin<A> {
impl<A: RenderAsset> Plugin for RenderAssetPlugin<A> { impl<A: RenderAsset> Plugin for RenderAssetPlugin<A> {
fn build(&self, app: &mut App) { fn build(&self, app: &mut App) {
let render_app = app.sub_app_mut(RenderApp); if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
let prepare_asset_system = PrepareAssetSystem::<A>::system(&mut render_app.world); let prepare_asset_system = PrepareAssetSystem::<A>::system(&mut render_app.world);
render_app render_app
.init_resource::<ExtractedAssets<A>>() .init_resource::<ExtractedAssets<A>>()
.init_resource::<RenderAssets<A>>() .init_resource::<RenderAssets<A>>()
.init_resource::<PrepareNextFrameAssets<A>>() .init_resource::<PrepareNextFrameAssets<A>>()
.add_system_to_stage(RenderStage::Extract, extract_render_asset::<A>) .add_system_to_stage(RenderStage::Extract, extract_render_asset::<A>)
.add_system_to_stage(RenderStage::Prepare, prepare_asset_system); .add_system_to_stage(RenderStage::Prepare, prepare_asset_system);
}
} }
} }

19
crates/bevy_render/src/render_component.rs
View File

@ -62,12 +62,14 @@ impl<C> Default for UniformComponentPlugin<C> {
impl<C: Component + AsStd140 + Clone> Plugin for UniformComponentPlugin<C> { impl<C: Component + AsStd140 + Clone> Plugin for UniformComponentPlugin<C> {
fn build(&self, app: &mut App) { fn build(&self, app: &mut App) {
app.sub_app_mut(RenderApp) if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
.insert_resource(ComponentUniforms::<C>::default()) render_app
.add_system_to_stage( .insert_resource(ComponentUniforms::<C>::default())
RenderStage::Prepare, .add_system_to_stage(
prepare_uniform_components::<C>.system(), RenderStage::Prepare,
); prepare_uniform_components::<C>.system(),
);
}
} }
} }
@ -144,8 +146,9 @@ where
{ {
fn build(&self, app: &mut App) { fn build(&self, app: &mut App) {
let system = ExtractComponentSystem::<C>::system(&mut app.world); let system = ExtractComponentSystem::<C>::system(&mut app.world);
let render_app = app.sub_app_mut(RenderApp); if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
render_app.add_system_to_stage(RenderStage::Extract, system); render_app.add_system_to_stage(RenderStage::Extract, system);
}
} }
} }

8
crates/bevy_render/src/texture/mod.rs
View File

@ -35,9 +35,11 @@ impl Plugin for ImagePlugin {
.unwrap() .unwrap()
.set_untracked(DEFAULT_IMAGE_HANDLE, Image::default()); .set_untracked(DEFAULT_IMAGE_HANDLE, Image::default());
app.sub_app_mut(RenderApp) if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
.init_resource::<TextureCache>() render_app
.add_system_to_stage(RenderStage::Cleanup, update_texture_cache_system); .init_resource::<TextureCache>()
.add_system_to_stage(RenderStage::Cleanup, update_texture_cache_system);
}
} }
} }

18
crates/bevy_render/src/view/mod.rs
View File

@ -26,14 +26,16 @@ impl Plugin for ViewPlugin {
fn build(&self, app: &mut App) { fn build(&self, app: &mut App) {
app.init_resource::<Msaa>().add_plugin(VisibilityPlugin); app.init_resource::<Msaa>().add_plugin(VisibilityPlugin);
app.sub_app_mut(RenderApp) if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
.init_resource::<ViewUniforms>() render_app
.add_system_to_stage(RenderStage::Extract, extract_msaa) .init_resource::<ViewUniforms>()
.add_system_to_stage(RenderStage::Prepare, prepare_view_uniforms) .add_system_to_stage(RenderStage::Extract, extract_msaa)
.add_system_to_stage( .add_system_to_stage(RenderStage::Prepare, prepare_view_uniforms)
RenderStage::Prepare, .add_system_to_stage(
prepare_view_targets.after(WindowSystem::Prepare), RenderStage::Prepare,
); prepare_view_targets.after(WindowSystem::Prepare),
);
}
} }
} }

20
crates/bevy_render/src/view/window.rs
View File

@ -24,15 +24,17 @@ pub enum WindowSystem {
impl Plugin for WindowRenderPlugin { impl Plugin for WindowRenderPlugin {
fn build(&self, app: &mut App) { fn build(&self, app: &mut App) {
app.sub_app_mut(RenderApp) if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
.init_resource::<ExtractedWindows>() render_app
.init_resource::<WindowSurfaces>() .init_resource::<ExtractedWindows>()
.init_resource::<NonSendMarker>() .init_resource::<WindowSurfaces>()
.add_system_to_stage(RenderStage::Extract, extract_windows) .init_resource::<NonSendMarker>()
.add_system_to_stage( .add_system_to_stage(RenderStage::Extract, extract_windows)
RenderStage::Prepare, .add_system_to_stage(
prepare_windows.label(WindowSystem::Prepare), RenderStage::Prepare,
); prepare_windows.label(WindowSystem::Prepare),
);
}
} }
} }

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

@ -59,20 +59,22 @@ impl Plugin for SpritePlugin {
.register_type::<Sprite>() .register_type::<Sprite>()
.add_plugin(Mesh2dRenderPlugin) .add_plugin(Mesh2dRenderPlugin)
.add_plugin(ColorMaterialPlugin); .add_plugin(ColorMaterialPlugin);
let render_app = app.sub_app_mut(RenderApp);
render_app if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
.init_resource::<ImageBindGroups>() render_app
.init_resource::<SpritePipeline>() .init_resource::<ImageBindGroups>()
.init_resource::<SpecializedPipelines<SpritePipeline>>() .init_resource::<SpritePipeline>()
.init_resource::<SpriteMeta>() .init_resource::<SpecializedPipelines<SpritePipeline>>()
.init_resource::<ExtractedSprites>() .init_resource::<SpriteMeta>()
.init_resource::<SpriteAssetEvents>() .init_resource::<ExtractedSprites>()
.add_render_command::<Transparent2d, DrawSprite>() .init_resource::<SpriteAssetEvents>()
.add_system_to_stage( .add_render_command::<Transparent2d, DrawSprite>()
RenderStage::Extract, .add_system_to_stage(
render::extract_sprites.label(SpriteSystem::ExtractSprites), RenderStage::Extract,
) render::extract_sprites.label(SpriteSystem::ExtractSprites),
.add_system_to_stage(RenderStage::Extract, render::extract_sprite_events) )
.add_system_to_stage(RenderStage::Queue, queue_sprites); .add_system_to_stage(RenderStage::Extract, render::extract_sprite_events)
.add_system_to_stage(RenderStage::Queue, queue_sprites);
};
} }
} }

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

@ -61,12 +61,14 @@ impl Plugin for Mesh2dRenderPlugin {
app.add_plugin(UniformComponentPlugin::<Mesh2dUniform>::default()); app.add_plugin(UniformComponentPlugin::<Mesh2dUniform>::default());
app.sub_app_mut(RenderApp) if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
.init_resource::<Mesh2dPipeline>() render_app
.init_resource::<SpecializedPipelines<Mesh2dPipeline>>() .init_resource::<Mesh2dPipeline>()
.add_system_to_stage(RenderStage::Extract, extract_mesh2d) .init_resource::<SpecializedPipelines<Mesh2dPipeline>>()
.add_system_to_stage(RenderStage::Queue, queue_mesh2d_bind_group) .add_system_to_stage(RenderStage::Extract, extract_mesh2d)
.add_system_to_stage(RenderStage::Queue, queue_mesh2d_view_bind_groups); .add_system_to_stage(RenderStage::Queue, queue_mesh2d_bind_group)
.add_system_to_stage(RenderStage::Queue, queue_mesh2d_view_bind_groups);
}
} }
} }

11
crates/bevy_text/src/lib.rs
View File

@ -48,10 +48,11 @@ impl Plugin for TextPlugin {
.insert_resource(DefaultTextPipeline::default()) .insert_resource(DefaultTextPipeline::default())
.add_system_to_stage(CoreStage::PostUpdate, text2d_system); .add_system_to_stage(CoreStage::PostUpdate, text2d_system);
let render_app = app.sub_app_mut(RenderApp); if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
render_app.add_system_to_stage( render_app.add_system_to_stage(
RenderStage::Extract, RenderStage::Extract,
extract_text2d_sprite.after(SpriteSystem::ExtractSprites), extract_text2d_sprite.after(SpriteSystem::ExtractSprites),
); );
}
} }
} }

6
crates/bevy_ui/src/render/mod.rs
View File

@ -66,7 +66,11 @@ pub fn build_ui_render(app: &mut App) {
let mut active_cameras = app.world.get_resource_mut::<ActiveCameras>().unwrap(); let mut active_cameras = app.world.get_resource_mut::<ActiveCameras>().unwrap();
active_cameras.add(CAMERA_UI); active_cameras.add(CAMERA_UI);
let render_app = app.sub_app_mut(RenderApp); let render_app = match app.get_sub_app_mut(RenderApp) {
Ok(render_app) => render_app,
Err(_) => return,
};
render_app render_app
.init_resource::<UiPipeline>() .init_resource::<UiPipeline>()
.init_resource::<SpecializedPipelines<UiPipeline>>() .init_resource::<SpecializedPipelines<UiPipeline>>()

1
examples/README.md
View File

@ -121,6 +121,7 @@ Example | File | Description
`empty` | [`app/empty.rs`](./app/empty.rs) | An empty application (does nothing) `empty` | [`app/empty.rs`](./app/empty.rs) | An empty application (does nothing)
`empty_defaults` | [`app/empty_defaults.rs`](./app/empty_defaults.rs) | An empty application with default plugins `empty_defaults` | [`app/empty_defaults.rs`](./app/empty_defaults.rs) | An empty application with default plugins
`headless` | [`app/headless.rs`](./app/headless.rs) | An application that runs without default plugins `headless` | [`app/headless.rs`](./app/headless.rs) | An application that runs without default plugins
`headless_defaults` | [`app/headless_defaults.rs`](./app/headless_defaults.rs) | An application that runs with default plugins, but without an actual renderer
`logs` | [`app/logs.rs`](./app/logs.rs) | Illustrate how to use generate log output `logs` | [`app/logs.rs`](./app/logs.rs) | Illustrate how to use generate log output
`plugin` | [`app/plugin.rs`](./app/plugin.rs) | Demonstrates the creation and registration of a custom plugin `plugin` | [`app/plugin.rs`](./app/plugin.rs) | Demonstrates the creation and registration of a custom plugin
`plugin_group` | [`app/plugin_group.rs`](./app/plugin_group.rs) | Demonstrates the creation and registration of a custom plugin group `plugin_group` | [`app/plugin_group.rs`](./app/plugin_group.rs) | Demonstrates the creation and registration of a custom plugin group

11
examples/app/headless_defaults.rs Normal file
View File

@ -0,0 +1,11 @@
use bevy::{prelude::*, render::options::WgpuOptions};
fn main() {
App::new()
.insert_resource(WgpuOptions {
backends: None,
..Default::default()
})
.add_plugins(DefaultPlugins)
.run();
}