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

finish wiring up new renderer / render_graph

Browse Source
This commit is contained in:
Carter Anderson 2020-01-19 23:03:08 -08:00
parent e4d42c29a9
commit 54005fcdd0
5 changed files with 70 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
src/app/app.rs
View File

@ -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,
legacy_render_graph: legacy_render_graph,
renderer: renderer,
schedule,
legacy_render_graph,
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(&render_graph, &mut self.world);
}
renderer.process_render_graph(&self.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") {

13
src/app/app_builder.rs
View File

@ -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 {
// self.renderer = Some(render_graph_2::WgpuRenderer);
// self
// }
pub fn add_wgpu_renderer(mut self) -> Self {
self.renderer = Some(Box::new(render_graph_2::WgpuRenderer::new()));
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()
}
}

2
src/render/render_graph_2/mod.rs
View File

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

19
src/render/render_graph_2/render_system.rs
View File

@ -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);
})
}

59
src/render/render_graph_2/renderer.rs
View File

@ -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 =
fn(world: &World, render_pass: &mut dyn RenderPass);
pub type DrawTarget = fn(world: &World, render_pass: &mut dyn RenderPass);
pub fn mesh_draw_target(
world: &World,
render_pass: &mut dyn RenderPass,
) {
pub fn mesh_draw_target(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;