Mirrors/bevy
2
0
Fork 0
mirror of https://github.com/bevyengine/bevy synced 2025-02-16 14:08:32 +00:00
Code Issues Projects Releases Packages Wiki Activity

cargo fmt

Browse source
This commit is contained in:
Carter Anderson 2020-04-24 18:55:15 -07:00
parent 057ad97a46
commit 115a009c16
39 changed files with 168 additions and 149 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
crates/bevy_app/src/app_builder.rs
View file

@ -1,7 +1,7 @@
use crate::{
plugin::{load_plugin, AppPlugin},
schedule_plan::{SchedulePlan, System},
stage, App, Events, AppExit,
stage, App, AppExit, Events,
};
use legion::prelude::{Resources, Universe, World};

18
crates/bevy_app/src/event/event.rs
View file

@ -161,25 +161,23 @@ where
/// Retrieves the latest event. This updates the `event_reader`'s event counter,
/// which means subsequent event reads will not include events that happened before now.
pub fn latest(&self, event_reader: &mut EventReader<T>) -> Option<&T> {
self.iter(event_reader)
.rev()
.next()
self.iter(event_reader).rev().next()
}
/// Retrieves the latest event that matches the given `predicate`. This updates the `event_reader`'s event counter,
/// which means subsequent event reads will not include events that happened before now.
pub fn find_latest(&self, event_reader: &mut EventReader<T>, predicate: impl FnMut(&&T) -> bool) -> Option<&T> {
self.iter(event_reader)
.rev()
.filter(predicate)
.next()
pub fn find_latest(
&self,
event_reader: &mut EventReader<T>,
predicate: impl FnMut(&&T) -> bool,
) -> Option<&T> {
self.iter(event_reader).rev().filter(predicate).next()
}
/// Retrieves the earliest event. This updates the `event_reader`'s event counter,
/// which means subsequent event reads will not include events that happened before now.
pub fn earliest(&self, event_reader: &mut EventReader<T>) -> Option<&T> {
self.iter(event_reader)
.next()
self.iter(event_reader).next()
}
/// Gets a new [EventReader]. This will include all events already in the event buffers.

2
crates/bevy_app/src/event/mod.rs
View file

@ -2,4 +2,4 @@ mod event;
pub use event::*;
/// An event that indicates the app should exit. This will fully exit the app process.
pub struct AppExit;
pub struct AppExit;

1
crates/bevy_gltf/src/lib.rs
View file

@ -74,7 +74,6 @@ fn load_node(buffer_data: &[Vec<u8>], node: &gltf::Node, depth: i32) -> Result<M
})
.map(|vertex_attribute| mesh.attributes.push(vertex_attribute));
reader.read_indices().map(|indices| {
mesh.indices = Some(indices.into_u32().collect::<Vec<u32>>());
});

24
crates/bevy_input/src/system.rs
View file

@ -1,19 +1,23 @@
use bevy_app::{Events, GetEventReader, AppExit};
use crate::keyboard::{ElementState, KeyboardInput, VirtualKeyCode};
use bevy_app::{AppExit, Events, GetEventReader};
use legion::prelude::*;
use crate::keyboard::{VirtualKeyCode, KeyboardInput, ElementState};
pub fn exit_on_esc_system(resources: &mut Resources) -> Box<dyn Schedulable> {
let mut keyboard_input_event_reader = resources.get_event_reader::<KeyboardInput>();
SystemBuilder::new("exit_on_esc")
.read_resource::<Events<KeyboardInput>>()
.write_resource::<Events<AppExit>>()
.build(move |_, _, (ref keyboard_input_events, ref mut app_exit_events), _| {
for event in keyboard_input_events.iter(&mut keyboard_input_event_reader) {
if let Some(virtual_key_code) = event.virtual_key_code {
if event.state == ElementState::Pressed && virtual_key_code == VirtualKeyCode::Escape {
app_exit_events.send(AppExit);
.build(
move |_, _, (ref keyboard_input_events, ref mut app_exit_events), _| {
for event in keyboard_input_events.iter(&mut keyboard_input_event_reader) {
if let Some(virtual_key_code) = event.virtual_key_code {
if event.state == ElementState::Pressed
&& virtual_key_code == VirtualKeyCode::Escape
{
app_exit_events.send(AppExit);
}
}
}
}
})
}
},
)
}

2
crates/bevy_pbr/src/entity.rs
View file

@ -1,8 +1,8 @@
use crate::{light::Light, material::StandardMaterial};
use bevy_asset::Handle;
use bevy_derive::EntityArchetype;
use bevy_render::{mesh::Mesh, Renderable};
use bevy_transform::prelude::{LocalToWorld, Rotation, Scale, Translation};
use bevy_derive::EntityArchetype;
#[derive(EntityArchetype, Default)]
#[module(meta = false)]

4
crates/bevy_pbr/src/lib.rs
View file

@ -8,10 +8,10 @@ pub mod pipelines;
mod forward_pbr_render_graph;
pub use forward_pbr_render_graph::*;
use bevy_app::{AppBuilder, AppPlugin, stage};
use bevy_app::{stage, AppBuilder, AppPlugin};
use bevy_asset::AssetStorage;
use material::StandardMaterial;
use bevy_render::{render_graph::RenderGraph, shader};
use material::StandardMaterial;
#[derive(Default)]
pub struct PbrPlugin;

2
crates/bevy_pbr/src/light.rs
View file

@ -1,8 +1,8 @@
use bevy_render::{Color, PerspectiveCamera};
use bevy_transform::components::Translation;
use glam::Mat4;
use std::ops::Range;
use zerocopy::{AsBytes, FromBytes};
use bevy_render::{PerspectiveCamera, Color};
pub struct Light {
pub color: Color,

5
crates/bevy_pbr/src/material.rs
View file

@ -1,7 +1,6 @@
use bevy_render::{texture::Texture, Color};
use bevy_asset::Handle;
use bevy_asset::{self, Handle};
use bevy_derive::Uniforms;
use bevy_asset;
use bevy_render::{texture::Texture, Color};
#[derive(Uniforms)]
#[module(meta = false)]

2
crates/bevy_pbr/src/nodes/lights_node.rs
View file

@ -4,10 +4,10 @@ use bevy_render::{
renderer::{GlobalRenderResourceContext, RenderContext},
};
use crate::light::{Light, LightRaw};
use bevy_transform::prelude::*;
use legion::prelude::*;
use zerocopy::AsBytes;
use crate::light::{LightRaw, Light};
#[derive(Default)]
pub struct LightsNode {

2
crates/bevy_pbr/src/nodes/mod.rs
View file

@ -1,3 +1,3 @@
mod lights_node;
pub use lights_node::*;
pub use lights_node::*;

2
crates/bevy_pbr/src/passes/mod.rs
View file

@ -1,3 +1,3 @@
mod main;
pub use main::*;
pub use main::*;

34
crates/bevy_pbr/src/pipelines/forward/mod.rs
View file

@ -1,3 +1,4 @@
use bevy_asset::AssetStorage;
use bevy_render::{
pipeline::{
state_descriptors::{
@ -10,7 +11,6 @@ use bevy_render::{
shader::{Shader, ShaderStage, ShaderStages},
texture::TextureFormat,
};
use bevy_asset::AssetStorage;
pub fn build_forward_pipeline(shaders: &mut AssetStorage<Shader>) -> PipelineDescriptor {
PipelineDescriptor {
@ -30,22 +30,20 @@ pub fn build_forward_pipeline(shaders: &mut AssetStorage<Shader>) -> PipelineDes
stencil_read_mask: 0,
stencil_write_mask: 0,
}),
color_states: vec![
ColorStateDescriptor {
format: TextureFormat::Bgra8UnormSrgb,
color_blend: BlendDescriptor {
src_factor: BlendFactor::SrcAlpha,
dst_factor: BlendFactor::OneMinusSrcAlpha,
operation: BlendOperation::Add,
},
alpha_blend: BlendDescriptor {
src_factor: BlendFactor::One,
dst_factor: BlendFactor::One,
operation: BlendOperation::Add,
},
write_mask: ColorWrite::ALL,
}
],
color_states: vec![ColorStateDescriptor {
format: TextureFormat::Bgra8UnormSrgb,
color_blend: BlendDescriptor {
src_factor: BlendFactor::SrcAlpha,
dst_factor: BlendFactor::OneMinusSrcAlpha,
operation: BlendOperation::Add,
},
alpha_blend: BlendDescriptor {
src_factor: BlendFactor::One,
dst_factor: BlendFactor::One,
operation: BlendOperation::Add,
},
write_mask: ColorWrite::ALL,
}],
..PipelineDescriptor::new(ShaderStages {
vertex: shaders.add(Shader::from_glsl(
ShaderStage::Vertex,
@ -57,4 +55,4 @@ pub fn build_forward_pipeline(shaders: &mut AssetStorage<Shader>) -> PipelineDes
))),
})
}
}
}

5
crates/bevy_render/src/entity.rs
View file

@ -1,7 +1,4 @@
use crate::{
mesh::Mesh, ActiveCamera, ActiveCamera2d, Camera,
CameraType, Renderable,
};
use crate::{mesh::Mesh, ActiveCamera, ActiveCamera2d, Camera, CameraType, Renderable};
use bevy_asset::Handle;
use bevy_derive::EntityArchetype;
use bevy_transform::components::{LocalToWorld, Rotation, Scale, Translation};

3
crates/bevy_render/src/lib.rs
View file

@ -48,8 +48,7 @@ pub static RENDER_STAGE: &str = "render";
#[derive(Default)]
pub struct RenderPlugin;
impl RenderPlugin {
}
impl RenderPlugin {}
impl AppPlugin for RenderPlugin {
fn build(&self, app: &mut AppBuilder) {

24
crates/bevy_render/src/mesh.rs
View file

@ -1,11 +1,12 @@
use crate::{
pipeline::{
state_descriptors::{IndexFormat, PrimitiveTopology},
VertexBufferDescriptor, VertexFormat, VertexBufferDescriptors,
VertexBufferDescriptor, VertexBufferDescriptors, VertexFormat,
},
render_resource::{RenderResourceAssignments, AssetBatchers, BufferInfo, BufferUsage},
Renderable, renderer::{GlobalRenderResourceContext, RenderResourceContext}, Vertex,
render_resource::{AssetBatchers, BufferInfo, BufferUsage, RenderResourceAssignments},
renderer::{GlobalRenderResourceContext, RenderResourceContext},
shader::AsUniforms,
Renderable, Vertex,
};
use bevy_asset::{AssetStorage, Handle};
use glam::*;
@ -326,12 +327,16 @@ pub fn mesh_specializer_system() -> Box<dyn Schedulable> {
SystemBuilder::new("mesh_batcher")
.read_resource::<AssetStorage<Mesh>>()
.with_query(
<(Read<Handle<Mesh>>, Write<Renderable>)>::query().filter(changed::<Handle<Mesh>>() | changed::<Renderable>()),
<(Read<Handle<Mesh>>, Write<Renderable>)>::query()
.filter(changed::<Handle<Mesh>>() | changed::<Renderable>()),
)
.build(|_, world, meshes, query| {
for (mesh_handle, mut renderable) in query.iter_mut(world) {
let mesh = meshes.get(&mesh_handle).unwrap();
renderable.render_resource_assignments.pipeline_specialization.primitive_topology = mesh.primitive_topology;
renderable
.render_resource_assignments
.pipeline_specialization
.primitive_topology = mesh.primitive_topology;
}
})
}
@ -422,11 +427,10 @@ pub fn mesh_resource_provider_system(resources: &mut Resources) -> Box<dyn Sched
)
}
#[cfg(test)]
mod tests {
use crate::{Vertex, pipeline::state_descriptors::PrimitiveTopology, shader::AsUniforms};
use super::{Mesh, VertexAttribute};
use crate::{pipeline::state_descriptors::PrimitiveTopology, shader::AsUniforms, Vertex};
use zerocopy::AsBytes;
#[test]
@ -475,6 +479,10 @@ mod tests {
];
let descriptor = Vertex::get_vertex_buffer_descriptor().unwrap();
assert_eq!(mesh.get_vertex_buffer_bytes(descriptor).unwrap(), expected_vertices.as_bytes(), "buffer bytes are equal");
assert_eq!(
mesh.get_vertex_buffer_bytes(descriptor).unwrap(),
expected_vertices.as_bytes(),
"buffer bytes are equal"
);
}
}

14
crates/bevy_render/src/pipeline/pipeline_compiler.rs
View file

@ -6,7 +6,7 @@ use crate::{
render_resource::{
BufferInfo, RenderResourceAssignments, RenderResourceAssignmentsId, ResourceInfo,
},
renderer::{RenderResourceContext, GlobalRenderResourceContext},
renderer::{GlobalRenderResourceContext, RenderResourceContext},
shader::{Shader, ShaderSource},
Renderable,
};
@ -256,9 +256,7 @@ impl PipelineCompiler {
}
}
pub fn iter_all_compiled_pipelines(
&self,
) -> impl Iterator<Item = &Handle<PipelineDescriptor>> {
pub fn iter_all_compiled_pipelines(&self) -> impl Iterator<Item = &Handle<PipelineDescriptor>> {
self.pipeline_source_to_compiled
.values()
.map(|compiled_pipelines| {
@ -283,10 +281,7 @@ impl PipelineAssignments {
}
// TODO: make this a system
pub fn update_shader_assignments(
world: &mut World,
resources: &Resources,
) {
pub fn update_shader_assignments(world: &mut World, resources: &Resources) {
// PERF: this seems like a lot of work for things that don't change that often.
// lots of string + hashset allocations. sees uniform_resource_provider for more context
{
@ -294,7 +289,8 @@ pub fn update_shader_assignments(
let mut pipeline_compiler = resources.get_mut::<PipelineCompiler>().unwrap();
let mut shader_storage = resources.get_mut::<AssetStorage<Shader>>().unwrap();
let vertex_buffer_descriptors = resources.get::<VertexBufferDescriptors>().unwrap();
let global_render_resource_context = resources.get::<GlobalRenderResourceContext>().unwrap();
let global_render_resource_context =
resources.get::<GlobalRenderResourceContext>().unwrap();
let mut pipeline_descriptor_storage = resources
.get_mut::<AssetStorage<PipelineDescriptor>>()
.unwrap();

12
crates/bevy_render/src/render_graph/graph.rs
View file

@ -1,4 +1,4 @@
use super::{Node, NodeId, NodeLabel, NodeState, RenderGraphError, SlotLabel, SystemNode, Edge};
use super::{Edge, Node, NodeId, NodeLabel, NodeState, RenderGraphError, SlotLabel, SystemNode};
use legion::prelude::{Executor, Resources, Schedulable};
use std::{borrow::Cow, collections::HashMap, fmt::Debug};
@ -41,7 +41,12 @@ impl RenderGraph {
self.add_node(node)
}
pub fn add_system_node_named<T>(&mut self, name: impl Into<Cow<'static, str>>, node: T, resources: &Resources) -> NodeId
pub fn add_system_node_named<T>(
&mut self,
name: impl Into<Cow<'static, str>>,
node: T,
resources: &Resources,
) -> NodeId
where
T: SystemNode + 'static,
{
@ -49,7 +54,6 @@ impl RenderGraph {
self.add_node_named(name, node)
}
pub fn get_node_state(
&self,
label: impl Into<NodeLabel>,
@ -367,7 +371,7 @@ mod tests {
let b_id = graph.add_node_named("B", TestNode::new(0, 1));
let c_id = graph.add_node_named("C", TestNode::new(1, 1));
let d_id = graph.add_node_named("D", TestNode::new(1, 0));
graph.add_slot_edge("A", "out_0", "C", "in_0").unwrap();
graph.add_node_edge("B", "C").unwrap();
graph.add_slot_edge("C", 0, "D", 0).unwrap();

14
crates/bevy_render/src/render_graph/mod.rs
View file

@ -1,14 +1,14 @@
pub mod nodes;
mod command;
mod edge;
mod graph;
mod node;
mod edge;
mod node_slot;
pub mod nodes;
mod schedule;
pub use command::*;
pub use edge::*;
pub use graph::*;
pub use node::*;
pub use edge::*;
pub use node_slot::*;
pub use schedule::*;
@ -36,5 +36,9 @@ pub enum RenderGraphError {
#[error("Node has an unconnected output slot.")]
UnconnectedNodeOutputSlot { node: NodeId, output_slot: usize },
#[error("Node input slot already occupied")]
NodeInputSlotAlreadyOccupied { node: NodeId, input_slot: usize, occupied_by_node: NodeId },
}
NodeInputSlotAlreadyOccupied {
node: NodeId,
input_slot: usize,
occupied_by_node: NodeId,
},
}

1
crates/bevy_render/src/render_graph/node.rs
View file

@ -155,7 +155,6 @@ impl NodeState {
.ok_or_else(|| RenderGraphError::WrongNodeType)
}
pub fn validate_output_slots(&self) -> Result<(), RenderGraphError> {
for i in 0..self.output_slots.len() {
self.edges.get_output_slot_edge(i)?;

5
crates/bevy_render/src/render_graph/node_slot.rs
View file

@ -54,10 +54,7 @@ impl ResourceSlots {
slot.resource.clone()
}
pub fn get_slot(
&self,
label: impl Into<SlotLabel>,
) -> Result<&ResourceSlot, RenderGraphError> {
pub fn get_slot(&self, label: impl Into<SlotLabel>) -> Result<&ResourceSlot, RenderGraphError> {
let label = label.into();
let index = self.get_slot_index(&label)?;
self.slots

14
crates/bevy_render/src/render_graph/nodes.rs
View file

@ -1,13 +1,13 @@
mod camera_node;
mod camera2d_node;
mod window_texture_node;
mod window_swapchain_node;
mod camera_node;
mod pass_node;
mod uniform_node;
mod window_swapchain_node;
mod window_texture_node;
pub use camera_node::*;
pub use camera2d_node::*;
pub use window_texture_node::*;
pub use window_swapchain_node::*;
pub use camera_node::*;
pub use pass_node::*;
pub use uniform_node::*;
pub use uniform_node::*;
pub use window_swapchain_node::*;
pub use window_texture_node::*;

2
crates/bevy_render/src/render_graph/nodes/camera2d_node.rs
View file

@ -3,7 +3,7 @@ use bevy_window::WindowResized;
use crate::{
camera::{ActiveCamera2d, Camera},
render_graph::{CommandQueue, Node, SystemNode, ResourceSlots},
render_graph::{CommandQueue, Node, ResourceSlots, SystemNode},
render_resource::{resource_name, BufferInfo, BufferUsage, RenderResourceAssignments},
renderer::{GlobalRenderResourceContext, RenderContext},
};

6
crates/bevy_render/src/render_graph/nodes/camera_node.rs
View file

@ -1,5 +1,5 @@
use crate::{
render_graph::{CommandQueue, Node, SystemNode, ResourceSlots},
render_graph::{CommandQueue, Node, ResourceSlots, SystemNode},
render_resource::{resource_name, BufferInfo, BufferUsage, RenderResourceAssignments},
renderer::{GlobalRenderResourceContext, RenderContext},
ActiveCamera, Camera,
@ -7,9 +7,9 @@ use crate::{
use bevy_app::{Events, GetEventReader};
use bevy_transform::prelude::*;
use bevy_window::WindowResized;
use legion::prelude::*;
use zerocopy::AsBytes;
use bevy_window::WindowResized;
#[derive(Default)]
pub struct CameraNode {
@ -96,4 +96,4 @@ impl SystemNode for CameraNode {
},
)
}
}
}

2
crates/bevy_render/src/render_graph/nodes/uniform_node.rs
View file

@ -332,7 +332,7 @@ where
}
}
// TODO: use something like this to remove redundancy between AssetUniformNode and UniformNode
// TODO: use something like this to remove redundancy between AssetUniformNode and UniformNode
// fn update_uniforms<T>(
// render_resource_context: &dyn RenderResourceContext,
// staging_buffer_resource: &mut Option<RenderResource>,

16
crates/bevy_render/src/render_graph/nodes/window_swapchain_node.rs
View file

@ -1,10 +1,10 @@
use crate::{
render_graph::{Node, ResourceSlots, ResourceSlotInfo},
render_graph::{Node, ResourceSlotInfo, ResourceSlots},
render_resource::ResourceInfo,
renderer::RenderContext,
};
use bevy_app::{EventReader, Events};
use bevy_window::{WindowCreated, WindowResized, Windows, WindowReference};
use bevy_window::{WindowCreated, WindowReference, WindowResized, Windows};
use legion::prelude::*;
use std::borrow::Cow;
@ -52,9 +52,7 @@ impl Node for WindowSwapChainNode {
let windows = resources.get::<Windows>().unwrap();
let window = match self.window_reference {
WindowReference::Primary => {
windows.get_primary().expect("No primary window exists")
}
WindowReference::Primary => windows.get_primary().expect("No primary window exists"),
WindowReference::Id(id) => windows
.get(id)
.expect("Received window resized event for non-existent window"),
@ -64,9 +62,11 @@ impl Node for WindowSwapChainNode {
// create window swapchain when window is resized or created
if window_created_events
.find_latest(&mut self.window_created_event_reader, |e| e.id == window.id).is_some() ||
window_resized_events
.find_latest(&mut self.window_resized_event_reader, |e| e.id == window.id).is_some()
.find_latest(&mut self.window_created_event_reader, |e| e.id == window.id)
.is_some()
|| window_resized_events
.find_latest(&mut self.window_resized_event_reader, |e| e.id == window.id)
.is_some()
{
render_resources.create_swap_chain(window);
}

8
crates/bevy_render/src/render_graph/nodes/window_texture_node.rs
View file

@ -63,9 +63,11 @@ impl Node for WindowTextureNode {
};
if window_created_events
.find_latest(&mut self.window_created_event_reader, |e| e.id == window.id).is_some() ||
window_resized_events
.find_latest(&mut self.window_resized_event_reader, |e| e.id == window.id).is_some()
.find_latest(&mut self.window_created_event_reader, |e| e.id == window.id)
.is_some()
|| window_resized_events
.find_latest(&mut self.window_resized_event_reader, |e| e.id == window.id)
.is_some()
{
let render_resources = render_context.resources_mut();
if let Some(old_texture) = output.get(WINDOW_TEXTURE) {

4
crates/bevy_render/src/render_resource/render_resource_assignments.rs
View file

@ -141,9 +141,7 @@ pub struct RenderResourceSetId(u64);
#[cfg(test)]
mod tests {
use super::*;
use crate::pipeline::{
BindType, BindingDescriptor, UniformProperty, UniformPropertyType,
};
use crate::pipeline::{BindType, BindingDescriptor, UniformProperty, UniformPropertyType};
#[test]
fn test_render_resource_sets() {

2
crates/bevy_render/src/vertex.rs
View file

@ -14,4 +14,4 @@ pub struct Vertex {
pub normal: [f32; 3],
#[uniform(vertex)]
pub uv: [f32; 2],
}
}

4
crates/bevy_wgpu/src/renderer/mod.rs
View file

@ -1,9 +1,9 @@
mod systems;
mod wgpu_render_context;
mod wgpu_render_resource_context;
mod wgpu_render_graph_executor;
mod wgpu_render_resource_context;
pub use systems::*;
pub use wgpu_render_context::*;
pub use wgpu_render_graph_executor::*;
pub use wgpu_render_resource_context::*;
pub use wgpu_render_graph_executor::*;

2
crates/bevy_wgpu/src/renderer/systems.rs
View file

@ -1,7 +1,7 @@
use bevy_asset::AssetStorage;
use bevy_render::{
pipeline::{PipelineAssignments, PipelineCompiler, PipelineDescriptor},
render_resource::{EntityRenderResourceAssignments},
render_resource::EntityRenderResourceAssignments,
Renderable,
};
use legion::prelude::*;

3
crates/bevy_wgpu/src/renderer/wgpu_render_graph_executor.rs
View file

@ -47,7 +47,8 @@ impl WgpuRenderGraphExecutor {
for job in jobs_chunk.iter_mut() {
for node_state in job.node_states.iter_mut() {
// bind inputs from connected node outputs
for (i, mut input_slot) in node_state.input_slots.iter_mut().enumerate()
for (i, mut input_slot) in
node_state.input_slots.iter_mut().enumerate()
{
if let Edge::SlotEdge {
output_node,

5
crates/bevy_wgpu/src/wgpu_resources.rs
View file

@ -355,10 +355,7 @@ impl WgpuResources {
.write()
.unwrap()
.insert(resource, texture_view);
self.textures
.write()
.unwrap()
.insert(resource, texture);
self.textures.write().unwrap().insert(resource, texture);
resource
}

2
crates/bevy_window/src/event.rs
View file

@ -34,4 +34,4 @@ pub struct WindowCreated {
pub struct WindowCloseRequested {
pub id: WindowId,
pub is_primary: bool,
}
}

42
crates/bevy_window/src/system.rs
View file

@ -1,22 +1,34 @@
use crate::{WindowCloseRequested, WindowId};
use bevy_app::{AppExit, Events, GetEventReader};
use legion::prelude::*;
use bevy_app::{Events, AppExit, GetEventReader};
use crate::{WindowId, WindowCloseRequested};
pub fn exit_on_window_close_system(resources: &mut Resources, window_id: Option<WindowId>) -> Box<dyn Schedulable> {
let mut window_close_requested_event_reader = resources.get_event_reader::<WindowCloseRequested>();
pub fn exit_on_window_close_system(
resources: &mut Resources,
window_id: Option<WindowId>,
) -> Box<dyn Schedulable> {
let mut window_close_requested_event_reader =
resources.get_event_reader::<WindowCloseRequested>();
SystemBuilder::new("exit_on_window_close")
.read_resource::<Events<WindowCloseRequested>>()
.write_resource::<Events<AppExit>>()
.build(move |_, _, (ref window_close_requested_events, ref mut app_exit_events), _| {
for window_close_requested_event in window_close_requested_events.iter(&mut window_close_requested_event_reader) {
match window_id.as_ref() {
Some(window_id) => if *window_id == window_close_requested_event.id {
app_exit_events.send(AppExit);
},
None => if window_close_requested_event.is_primary {
app_exit_events.send(AppExit);
.build(
move |_, _, (ref window_close_requested_events, ref mut app_exit_events), _| {
for window_close_requested_event in
window_close_requested_events.iter(&mut window_close_requested_event_reader)
{
match window_id.as_ref() {
Some(window_id) => {
if *window_id == window_close_requested_event.id {
app_exit_events.send(AppExit);
}
}
None => {
if window_close_requested_event.is_primary {
app_exit_events.send(AppExit);
}
}
}
}
}
})
}
},
)
}

5
examples/dynamic_plugin_loading/example_plugin/src/lib.rs
View file

@ -20,7 +20,8 @@ pub fn setup(world: &mut World, resources: &mut Resources) {
..Default::default()
});
world.build()
world
.build()
// cube
.add_entity(MeshEntity {
mesh: cube_handle,
@ -41,4 +42,4 @@ pub fn setup(world: &mut World, resources: &mut Resources) {
)),
..Default::default()
});
}
}

2
src/add_default_plugins.rs
View file

@ -34,4 +34,4 @@ impl AddDefaultPlugins for AppBuilder {
self
}
}
}

4
src/lib.rs
View file

@ -33,8 +33,8 @@
#![feature(min_specialization)]
pub mod prelude;
mod add_default_plugins;
pub mod prelude;
pub use add_default_plugins::*;
pub use bevy_app as app;
@ -64,4 +64,4 @@ pub use bevy_transform as transform;
#[cfg(feature = "ui")]
pub use bevy_ui as ui;
#[cfg(feature = "window")]
pub use bevy_window as window;
pub use bevy_window as window;

16
src/prelude.rs
View file

@ -10,14 +10,20 @@ pub use crate::derive::*;
#[cfg(feature = "diagnostic")]
pub use crate::diagnostic::DiagnosticsPlugin;
#[cfg(feature = "pbr")]
pub use crate::pbr::{material::StandardMaterial, light::Light, entity::*};
pub use crate::pbr::{entity::*, light::Light, material::StandardMaterial};
#[cfg(feature = "render")]
pub use crate::render::{
entity::*,
mesh::{Mesh, shape},
pipeline::PipelineDescriptor,
draw_target,
render_graph::{RenderGraph, nodes::{UniformNode, AssetUniformNode, PassNode, WindowSwapChainNode, WindowTextureNode, Camera2dNode, CameraNode}},
entity::*,
mesh::{shape, Mesh},
pipeline::PipelineDescriptor,
render_graph::{
nodes::{
AssetUniformNode, Camera2dNode, CameraNode, PassNode, UniformNode, WindowSwapChainNode,
WindowTextureNode,
},
RenderGraph,
},
render_resource::{resource_name, AssetBatchers},
shader::{Shader, ShaderDefSuffixProvider, ShaderStage, ShaderStages},
texture::{Texture, TextureType},