finish wiring up new renderer / render_graph

src/app/app.rs

@@ -13,6 +13,7 @@ pub struct App {
     pub world: World,
     pub legacy_render_graph: Option<render::RenderGraph>,
     pub renderer: Option<Box<dyn Renderer>>,
+    pub render_graph: RenderGraph,
     pub schedule: Schedule,
 }
 
@@ -23,13 +24,15 @@ impl App {
         schedule: Schedule,
         legacy_render_graph: Option<render::RenderGraph>,
         renderer: Option<Box<dyn Renderer>>,
+        render_graph: RenderGraph,
     ) -> App {
         App {
             universe,
             world,
-            schedule: schedule,
+            schedule,
-            legacy_render_graph: legacy_render_graph,
+            legacy_render_graph,
-            renderer: renderer,
+            renderer,
+            render_graph,
         }
     }
 
@@ -49,9 +52,7 @@ impl App {
         }
 
         if let Some(ref mut renderer) = self.renderer {
-            if let Some(render_graph) = self.world.resources.get::<RenderGraph>() {
+            renderer.process_render_graph(&self.render_graph, &mut self.world);
-                renderer.process_render_graph(&render_graph, &mut self.world);
-            }
         }
 
         if let Some(mut time) = self.world.resources.get_mut::<Time>() {
@@ -77,6 +78,10 @@ impl App {
             render_graph.initialize(&mut self.world);
         }
 
+        if let Some(ref mut renderer) = self.renderer {
+            renderer.initialize(&mut self.world);
+        }
+
         log::info!("Entering render loop...");
         event_loop.run(move |event, _, control_flow| {
             *control_flow = if cfg!(feature = "metal-auto-capture") {

src/app/app_builder.rs

@@ -18,6 +18,7 @@ pub struct AppBuilder {
     pub universe: Universe,
     pub legacy_render_graph: Option<RenderGraph>,
     pub renderer: Option<Box<dyn render_graph_2::Renderer>>,
+    pub render_graph: render_graph_2::RenderGraph,
     pub system_stages: HashMap<String, Vec<Box<dyn Schedulable>>>,
     pub runnable_stages: HashMap<String, Vec<Box<dyn Runnable>>>,
     pub stage_order: Vec<String>,
@@ -30,6 +31,7 @@ impl AppBuilder {
         AppBuilder {
             universe,
             world,
+            render_graph: render_graph_2::RenderGraph::default(),
             legacy_render_graph: None,
             renderer: None,
             system_stages: HashMap::new(),
@@ -64,6 +66,7 @@ impl AppBuilder {
             schedule_builder.build(),
             self.legacy_render_graph,
             self.renderer,
+            self.render_graph,
         )
     }
 
@@ -156,7 +159,6 @@ impl AppBuilder {
         resources.insert(Time::new());
         resources.insert(AssetStorage::<Mesh>::new());
         resources.insert(AssetStorage::<Texture>::new());
-        resources.insert(render_graph_2::RenderGraph::default());
         self
     }
 
@@ -169,10 +171,10 @@ impl AppBuilder {
         self
     }
 
-    // pub fn add_wgpu_renderer(mut self) -> Self {
+    pub fn add_wgpu_renderer(mut self) -> Self {
-    //     self.renderer = Some(render_graph_2::WgpuRenderer);
+        self.renderer = Some(Box::new(render_graph_2::WgpuRenderer::new()));
-    //     self
+        self
-    // }
+    }
 
     pub fn add_defaults_legacy(self) -> Self {
         self
@@ -186,5 +188,6 @@ impl AppBuilder {
         self
             .add_default_resources()
             .add_default_systems()
+            .add_wgpu_renderer()
     }
-}
+}

src/render/render_graph_2/mod.rs

@@ -4,14 +4,12 @@ mod renderer;
 mod shader;
 mod render_graph;
 mod example;
-mod render_system;
 
 pub use pipeline::*;
 pub use pass::*;
 pub use renderer::*;
 pub use shader::*;
 pub use render_graph::*;
-pub use render_system::*;
 
 // a named graphics resource provided by a resource provider
 pub struct Resource {

src/render/render_graph_2/render_system.rs

@@ -1,19 +0,0 @@
-use crate::prelude::*;
-use crate::render::render_graph_2::{RenderGraph, WgpuRenderer, Renderer};
-use winit::window::Window;
-
-pub fn build_wgpu_render_system(world: &mut World) -> Box<dyn Schedulable> {
-    let window = world.resources.get::<Window>();
-    let renderer = WgpuRenderer {
-        
-    };
-
-    SystemBuilder::new("wgpu_render_system")
-        .read_resource::<RenderGraph>()
-        .with_query(<(Write<Node>,)>::query().filter(!component::<Parent>()))
-        .write_component::<Node>()
-        .read_component::<Children>()
-        .build(move |_, world, render_graph, node_query| {
-            renderer.process_render_graph(*render_graph);
-        })
-}

src/render/render_graph_2/renderer.rs

@@ -2,11 +2,11 @@ use crate::{
     asset::{AssetStorage, Handle, Mesh},
     legion::prelude::*,
     render::{
-        render_graph_2::{PipelineDescriptor, PassDescriptor, RenderGraph, ShaderMaterials},
+        render_graph_2::{PassDescriptor, PipelineDescriptor, RenderGraph, ShaderMaterials},
         Instanced,
     },
 };
-use std::collections::HashMap;
+use std::{collections::HashMap, ops::Deref};
 use zerocopy::AsBytes;
 
 // A set of draw calls. ex: get + draw meshes, get + draw instanced meshes, draw ui meshes, etc
@@ -14,13 +14,9 @@ use zerocopy::AsBytes;
 // trait DrawTarget {
 //     fn draw(device: &wgpu::Device);
 // }
-pub type DrawTarget =
+pub type DrawTarget = fn(world: &World, render_pass: &mut dyn RenderPass);
-    fn(world: &World, render_pass: &mut dyn RenderPass);
 
-pub fn mesh_draw_target(
+pub fn mesh_draw_target(world: &World, render_pass: &mut dyn RenderPass) {
-    world: &World,
-    render_pass: &mut dyn RenderPass,
-) {
     let mut mesh_storage = world.resources.get_mut::<AssetStorage<Mesh>>().unwrap();
     let mut last_mesh_id = None;
     let mesh_query =
@@ -51,6 +47,7 @@ pub fn mesh_draw_target(
 }
 
 pub trait Renderer {
+    fn initialize(&mut self, world: &mut World);
     fn resize(&mut self, world: &mut World, width: u32, height: u32);
     fn process_render_graph(&mut self, render_graph: &RenderGraph, world: &mut World);
     fn load_mesh(&mut self, asset_id: usize, mesh: &Mesh);
@@ -58,7 +55,7 @@ pub trait Renderer {
 
 pub struct WgpuRenderer {
     pub device: wgpu::Device,
-    pub surface: wgpu::Surface,
+    pub surface: Option<wgpu::Surface>,
     pub swap_chain_descriptor: wgpu::SwapChainDescriptor,
     pub render_pipelines: HashMap<String, wgpu::RenderPipeline>,
     pub buffers: HashMap<String, wgpu::Buffer>,
@@ -66,10 +63,38 @@ pub struct WgpuRenderer {
 
 impl WgpuRenderer {
     pub fn new() -> Self {
-        WgpuRenderer {
+        let adapter = wgpu::Adapter::request(
+            &wgpu::RequestAdapterOptions {
+                power_preference: wgpu::PowerPreference::Default,
+            },
+            wgpu::BackendBit::PRIMARY,
+        )
+        .unwrap();
 
+        let (device, queue) = adapter.request_device(&wgpu::DeviceDescriptor {
+            extensions: wgpu::Extensions {
+                anisotropic_filtering: false,
+            },
+            limits: wgpu::Limits::default(),
+        });
+
+        let swap_chain_descriptor = wgpu::SwapChainDescriptor {
+            usage: wgpu::TextureUsage::OUTPUT_ATTACHMENT,
+            format: wgpu::TextureFormat::Bgra8UnormSrgb,
+            width: 0,
+            height: 0,
+            present_mode: wgpu::PresentMode::Vsync,
+        };
+
+        WgpuRenderer {
+            device,
+            surface: None,
+            swap_chain_descriptor,
+            render_pipelines: HashMap::new(),
+            buffers: HashMap::new(),
         }
     }
+
     pub fn create_render_pipeline(
         pipeline_descriptor: &PipelineDescriptor,
         device: &wgpu::Device,
@@ -131,10 +156,22 @@ impl WgpuRenderer {
 }
 
 impl Renderer for WgpuRenderer {
+    fn initialize(&mut self, world: &mut World) {
+        let (surface, window_size) = {
+            let window = world.resources.get::<winit::window::Window>().unwrap();
+            let surface = wgpu::Surface::create(window.deref());
+            let window_size = window.inner_size();
+            (surface, window_size)
+        };
+
+        self.surface = Some(surface);
+        self.resize(world, window_size.width, window_size.height);
+    }
+
     fn resize(&mut self, world: &mut World, width: u32, height: u32) {
         let swap_chain = self
             .device
-            .create_swap_chain(&self.surface, &self.swap_chain_descriptor);
+            .create_swap_chain(self.surface.as_ref().unwrap(), &self.swap_chain_descriptor);
         self.swap_chain_descriptor.width = width;
         self.swap_chain_descriptor.height = height;
 
@@ -168,7 +205,7 @@ impl Renderer for WgpuRenderer {
                             self.render_pipelines
                                 .insert(pass_pipeline.to_string(), render_pipeline);
                         }
-                        
+
                         let mut render_pass = WgpuRenderPass {
                             render_pass: &mut render_pass,
                             renderer: &self,
@@ -220,4 +257,4 @@ impl<'a, 'b, 'c> RenderPass for WgpuRenderPass<'a, 'b, 'c> {
 //     fn get_buffer(name: &str) -> Option<Buffer>;
 //     fn get_texture(name: &str) -> Option<Texture>;
 //     fn get_sampler(name: &str) -> Option<Sampler>;
-// }
+// }