everything is a plugin!

src/app/app_builder.rs

@@ -1,13 +1,17 @@
 use crate::{
-    app::{system_stage, App, plugin::{AppPlugin, load_plugin}},
+    app::{
+        plugin::{load_plugin, AppPlugin},
+        system_stage, App,
+    },
     core::{winit::WinitPlugin, CorePlugin},
     legion::prelude::{Resources, Runnable, Schedulable, Schedule, Universe, World},
-    render::{renderer::Renderer, *},
-    ui,
+    render::{
+        renderer::{renderers::wgpu_renderer::WgpuRendererPlugin, Renderer},
+        RenderPlugin,
+    },
+    ui::UiPlugin,
 };
 
-use bevy_transform::transform_system_bundle;
-use render_resource::build_entity_render_resource_assignments_system;
 use std::collections::HashMap;
 
 pub struct AppBuilder {
@@ -16,6 +20,7 @@ pub struct AppBuilder {
     pub universe: Universe,
     pub renderer: Option<Box<dyn Renderer>>,
     pub run: Option<Box<dyn Fn(App)>>,
+    pub schedule: Option<Schedule>,
     pub setup_systems: Vec<Box<dyn Schedulable>>,
     pub system_stages: HashMap<String, Vec<Box<dyn Schedulable>>>,
     pub runnable_stages: HashMap<String, Vec<Box<dyn Runnable>>>,
@@ -33,6 +38,7 @@ impl AppBuilder {
             resources,
             renderer: None,
             run: None,
+            schedule: None,
             setup_systems: Vec::new(),
             system_stages: HashMap::new(),
             runnable_stages: HashMap::new(),
@@ -40,7 +46,7 @@ impl AppBuilder {
         }
     }
 
-    pub fn build(mut self) -> App {
+    pub fn build_schedule(mut self) -> Self {
         let mut setup_schedule_builder = Schedule::builder();
         for setup_system in self.setup_systems.drain(..) {
             setup_schedule_builder = setup_schedule_builder.add_system(setup_system);
@@ -68,11 +74,19 @@ impl AppBuilder {
             }
         }
 
+        self.schedule = Some(schedule_builder.build());
+
+        self
+    }
+
+    pub fn build(mut self) -> App {
+        self = self.build_schedule();
+
         App::new(
             self.universe,
             self.world,
             self.resources,
-            schedule_builder.build(),
+            self.schedule.take().unwrap(),
             self.run.take(),
             self.renderer.take(),
         )
@@ -135,39 +149,21 @@ impl AppBuilder {
         self
     }
 
-    pub fn add_default_systems(mut self) -> Self {
-        self = self
-            .add_system(build_entity_render_resource_assignments_system())
-            .add_system(ui::ui_update_system::build_ui_update_system());
-        for transform_system in transform_system_bundle::build(&mut self.world).drain(..) {
-            self = self.add_system(transform_system);
-        }
-
-        self
-    }
-
-    #[cfg(feature = "wgpu")]
-    pub fn add_wgpu_renderer(mut self) -> Self {
-        self.renderer = Some(Box::new(
-            renderer::renderers::wgpu_renderer::WgpuRenderer::new(),
-        ));
-        self
-    }
-
     pub fn add_defaults(mut self) -> Self {
         self = self
-            .add_default_systems()
             .add_plugin(CorePlugin::default())
-            .add_plugin(RenderPlugin::default());
+            .add_plugin(RenderPlugin::default())
+            .add_plugin(UiPlugin::default());
 
-        #[cfg(feature = "wgpu")]
-        {
-            self = self.add_wgpu_renderer();
-        }
         #[cfg(feature = "winit")]
         {
             self = self.add_plugin(WinitPlugin::default())
         }
+
+        #[cfg(feature = "wgpu")]
+        {
+            self = self.add_plugin(WgpuRendererPlugin::default());
+        }
         self
     }
 

src/core/core_plugin.rs

@@ -1,11 +1,16 @@
 use super::{Time, Window};
 use crate::{app::{AppBuilder, plugin::AppPlugin}};
+use bevy_transform::transform_system_bundle;
 
 #[derive(Default)]
 pub struct CorePlugin;
 
 impl AppPlugin for CorePlugin {
-    fn build(&self, app: AppBuilder) -> AppBuilder {
+    fn build(&self, mut app: AppBuilder) -> AppBuilder {
+        for transform_system in transform_system_bundle::build(&mut app.world).drain(..) {
+            app = app.add_system(transform_system);
+        }
+
         app.add_resource(Window::default())
             .add_resource(Time::new())
     }

src/render/render_plugin.rs

@@ -6,6 +6,7 @@ use super::{
     pipeline::{pipelines::ForwardPipelineBuilder, PipelineCompiler, ShaderPipelineAssignments},
     render_graph::RenderGraph,
     render_resource::{
+        build_entity_render_resource_assignments_system,
         resource_providers::{
             Camera2dResourceProvider, CameraResourceProvider, LightResourceProvider,
             MeshResourceProvider, UiResourceProvider,
@@ -14,9 +15,8 @@ use super::{
     },
 };
 use crate::{
-    app::AppBuilder,
+    app::{plugin::AppPlugin, AppBuilder},
     asset::AssetStorage,
-    app::plugin::AppPlugin,
     prelude::{
         LocalToWorld, Mesh, PipelineDescriptor, Shader, StandardMaterial, Texture,
         UniformResourceProvider,
@@ -57,6 +57,7 @@ impl AppPlugin for RenderPlugin {
         let mut asset_batchers = AssetBatchers::default();
         asset_batchers.batch_types2::<Mesh, StandardMaterial>();
         app = app
+            .add_system(build_entity_render_resource_assignments_system())
             .add_resource(RenderGraph::default())
             .add_resource(AssetStorage::<Mesh>::new())
             .add_resource(AssetStorage::<Texture>::new())

src/render/renderer/renderers/wgpu_renderer/mod.rs

@@ -9,12 +9,12 @@ pub use wgpu_resources::*;
 
 use crate::{app::AppBuilder, app::plugin::AppPlugin};
 
+#[derive(Default)]
 pub struct WgpuRendererPlugin;
 
 impl AppPlugin for WgpuRendererPlugin {
-    fn build(&self, app: AppBuilder) -> AppBuilder {
-        // let render_context = app.resources.get_mut::<RenderContext>().unwrap();
-        // render_context.renderer = Some(Box::new(WgpuRenderer::new()));
+    fn build(&self, mut app: AppBuilder) -> AppBuilder {
+        app.renderer = Some(Box::new(WgpuRenderer::new()));
         app
     }
     fn name(&self) -> &'static str {

src/ui/mod.rs

@@ -1,8 +1,24 @@
 mod anchors;
 mod margins;
 mod node;
-pub mod ui_update_system;
+mod ui_update_system;
 
 pub use anchors::*;
 pub use margins::*;
 pub use node::*;
+pub use ui_update_system::*;
+
+use crate::{app::AppBuilder, prelude::AppPlugin};
+
+#[derive(Default)]
+pub struct UiPlugin;
+
+impl AppPlugin for UiPlugin {
+    fn build(&self, app: AppBuilder) -> AppBuilder {
+        app
+            .add_system(ui_update_system())
+    }
+    fn name(&self) -> &'static str {
+        "UI"
+    }
+}

src/ui/ui_update_system.rs

@@ -1,6 +1,6 @@
 use crate::prelude::*;
 
-pub fn build_ui_update_system() -> Box<dyn Schedulable> {
+pub fn ui_update_system() -> Box<dyn Schedulable> {
     SystemBuilder::new("ui_update_system")
         .read_resource::<Window>()
         .with_query(<(Write<Node>,)>::query().filter(!component::<Parent>()))