cyborg
/
cyborg
2
2
Fork 0
Code Issues 19 Pull Requests 1 Projects Releases Wiki Activity

Add RenderCallbacks intermediate layer

This commit is contained in:
mars 2022-05-14 15:29:51 -06:00
parent 55b3979ea7
commit 99633ea0be
2 changed files with 133 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
src/legion.rs
View File

@ -3,7 +3,7 @@
use crate::camera::Camera;
use crate::pass::{self, debug, mesh};
use crate::scene;
use crate::viewport::{ViewportInfo, WinitViewport};
use crate::viewport::{Viewport, ViewportInfo};
use crate::Renderer;
use legion::systems::Builder;
use legion::world::SubWorld;
@ -11,6 +11,12 @@ use legion::*;
use rayon::prelude::*;
use std::sync::Arc;
/// Callbacks trait for acquiring renderer input dynamically.
pub trait RenderCallbacks: 'static + Send + Sync {
fn get_viewports(&mut self) -> Vec<(&dyn Viewport, Camera)>;
fn present(&mut self);
}
/// Initializes the Cyborg renderer within a Legion world.
///
/// Uses the provided [Builder] to run all rendering code.
@ -19,7 +25,11 @@ use std::sync::Arc;
/// - [Renderer]
/// - [ViewportInfo] (TODO: dynamic viewport targeting)
/// - [mesh::ShaderInfo]
pub fn build_renderer(resources: &mut Resources, builder: &mut Builder) {
pub fn build_renderer<T: RenderCallbacks>(
callbacks: T,
resources: &mut Resources,
builder: &mut Builder,
) {
let renderer = resources.get_mut::<Renderer>().unwrap();
let viewport_info = resources.get::<ViewportInfo>().unwrap();
let mesh_shaders = resources.get::<mesh::ShaderInfo>().unwrap();
@ -52,27 +62,27 @@ pub fn build_renderer(resources: &mut Resources, builder: &mut Builder) {
resources.insert(mesh_pass);
resources.insert(debug_pass);
resources.insert(callbacks);
builder.add_system(draw_transformed_meshes_system());
builder.add_system(draw_debug_system());
builder.add_system(draw_debug_transformed_system());
builder.add_system(render_system());
builder.add_system(present_winit_system());
builder.add_system(render_system::<T>());
builder.add_system(present_system::<T>());
}
#[system]
#[read_component(WinitViewport)]
#[read_component(Camera)]
fn render(
world: &mut SubWorld,
fn render<T: RenderCallbacks>(
#[resource] callbacks: &mut T,
#[resource] renderer: &mut Renderer,
#[resource] mesh_pass: &mut pass::RenderPassBox<mesh::MeshPass>,
#[resource] debug_pass: &mut pass::RenderPassBox<debug::DebugPass>,
) {
let target_query: Vec<_> = <(&WinitViewport, &Camera)>::query().iter(world).collect();
if target_query.len() > 1 {
let viewports = callbacks.get_viewports();
if viewports.len() > 1 {
eprintln!("Cyborg does not currently support more than one viewport at a time!");
return;
} else if let Some((viewport, camera)) = target_query.get(0) {
} else if let Some((viewport, camera)) = viewports.get(0) {
let mut passes: Vec<&mut dyn pass::RenderPassBoxTrait> = Vec::new();
passes.push(mesh_pass);
passes.push(debug_pass);
@ -80,6 +90,11 @@ fn render(
}
}
#[system]
fn present<T: RenderCallbacks>(#[resource] callbacks: &mut T) {
callbacks.present();
}
#[system(for_each)]
fn draw_transformed_meshes(
#[resource] mesh_pass: &pass::RenderPassBox<mesh::MeshPass>,
@ -92,11 +107,6 @@ fn draw_transformed_meshes(
}]);
}
#[system(for_each)]
fn present_winit(viewport: &mut WinitViewport) {
viewport.present();
}
#[system(for_each)]
#[filter(!component::<scene::Transform>())]
fn draw_debug(

168
src/main.rs
View File

@ -1,4 +1,4 @@
use cyborg::camera::Camera;
use cyborg::camera::{Camera, Flycam};
use cyborg::pass::{mesh, RenderPassBox};
use cyborg::shader;
use cyborg::storage::mesh::*;
@ -7,6 +7,7 @@ use cyborg::Renderer;
use legion::*;
use rand::prelude::*;
use std::sync::Arc;
use winit::dpi::PhysicalSize;
use winit::{
event::*,
event_loop::{ControlFlow, EventLoop},
@ -58,6 +59,11 @@ fn update_dt(#[resource] dt: &mut DeltaTime) {
dt.last_update = std::time::Instant::now();
}
#[system]
fn update_app(#[resource] app: &mut Application) {
app.update();
}
#[system(for_each)]
fn apply_gravity(#[resource] dt: &DeltaTime, velocity: &mut Velocity) {
const GRAVITY: f32 = 6.0;
@ -114,6 +120,7 @@ fn update_debug(draw_list: &mut cyborg::scene::DebugDrawList, velocity: &Velocit
fn build_update_schedule() -> Schedule {
let mut builder = Schedule::builder();
builder.add_system(update_dt_system());
builder.add_system(update_app_system());
builder.add_system(apply_gravity_system());
builder.add_system(move_particles_system());
builder.add_system(respawn_particles_system());
@ -199,6 +206,65 @@ fn make_terrain(attributes: &mesh::Attributes) -> MeshBuffer {
mesh
}
struct Application {
window: winit::window::Window,
viewport: WinitViewport,
flycam: Flycam,
is_grabbed: bool,
}
impl Application {
pub fn update(&mut self) {
self.flycam.update();
self.window.request_redraw();
}
pub fn on_mouse_motion(&mut self, x: f64, y: f64) {
if self.is_grabbed {
self.flycam.process_mouse(x, y);
}
}
pub fn on_mouse_event(&mut self, button: MouseButton, state: ElementState) {
if button == MouseButton::Left && state == ElementState::Pressed && !self.is_grabbed {
self.window.set_cursor_grab(true).unwrap();
self.window.set_cursor_visible(false);
self.is_grabbed = true;
}
}
pub fn on_key_event(&mut self, key: VirtualKeyCode, state: ElementState) {
if key == VirtualKeyCode::Escape && state == ElementState::Pressed {
if self.is_grabbed {
self.window.set_cursor_grab(false).unwrap();
self.window.set_cursor_visible(true);
self.is_grabbed = false;
}
} else {
self.flycam.process_keyboard(key, state);
}
}
pub fn on_resize(&mut self, new_size: PhysicalSize<u32>) {
self.viewport.resize(new_size);
self.flycam.resize(new_size.width, new_size.height);
}
pub fn on_surface_lost(&mut self) {
self.viewport.resize(self.viewport.size);
}
}
impl cyborg::legion::RenderCallbacks for Application {
fn get_viewports(&mut self) -> Vec<(&dyn Viewport, Camera)> {
vec![(&self.viewport as &dyn Viewport, self.flycam.get_camera())]
}
fn present(&mut self) {
self.viewport.present();
}
}
fn main() {
let event_loop = EventLoop::new();
let window = WindowBuilder::new().build(&event_loop).unwrap();
@ -216,8 +282,7 @@ fn main() {
resources.insert(viewport.get_info().to_owned());
let mut flycam = cyborg::camera::Flycam::new(0.002, 10.0, 0.25);
let mut is_grabbed = false;
let flycam = cyborg::camera::Flycam::new(0.002, 10.0, 0.25);
let shader_store = Arc::new(shader::ShaderStore::new(viewport.device.clone()));
let shaders_dir = std::env::current_dir().unwrap();
@ -235,8 +300,15 @@ fn main() {
resources.insert(mesh_shaders);
let application = Application {
window,
viewport,
flycam,
is_grabbed: false,
};
let mut render_schedule = Schedule::builder();
cyborg::legion::build_renderer(&mut resources, &mut render_schedule);
cyborg::legion::build_renderer(application, &mut resources, &mut render_schedule);
let mut render_schedule = render_schedule.build();
let example_vertices = vec![
@ -317,17 +389,15 @@ fn main() {
}
}
let viewport_entity = world.push((viewport, flycam.get_camera()));
event_loop.run(move |event, _, control_flow| match event {
Event::RedrawRequested(_) => {
let mut viewport_entry = world.entry_mut(viewport_entity).unwrap();
let viewport = viewport_entry.get_component_mut::<WinitViewport>().unwrap();
match viewport.acquire() {
Err(wgpu::SurfaceError::Lost) => viewport.resize(viewport.size),
let mut application = resources.get_mut::<Application>().unwrap();
match application.viewport.acquire() {
Err(wgpu::SurfaceError::Lost) => application.on_surface_lost(),
Err(wgpu::SurfaceError::OutOfMemory) => *control_flow = ControlFlow::Exit,
Err(e) => eprintln!("error: {:?}", e),
Ok(_) => {
drop(application);
render_schedule.execute(&mut world, &mut resources);
}
}
@ -335,70 +405,46 @@ fn main() {
Event::MainEventsCleared => {
update_schedule.execute(&mut world, &mut resources);
shader_watcher.watch();
flycam.update();
window.request_redraw();
let mut viewport_entry = world.entry_mut(viewport_entity).unwrap();
let camera = viewport_entry.get_component_mut::<Camera>().unwrap();
let _ = std::mem::replace(camera, flycam.get_camera());
}
Event::DeviceEvent { ref event, .. } => match event {
DeviceEvent::MouseMotion { delta } => {
if is_grabbed {
flycam.process_mouse(delta.0, delta.1);
}
let mut application = resources.get_mut::<Application>().unwrap();
application.on_mouse_motion(delta.0, delta.1);
}
_ => {}
},
Event::WindowEvent {
ref event,
window_id,
} if window_id == window.id() => match event {
WindowEvent::KeyboardInput {
input:
KeyboardInput {
virtual_keycode: Some(key),
state,
} => {
let mut application = resources.get_mut::<Application>().unwrap();
if window_id == application.window.id() {
match event {
WindowEvent::KeyboardInput {
input:
KeyboardInput {
virtual_keycode: Some(key),
state,
..
},
..
},
..
} => {
if *state == ElementState::Pressed && *key == VirtualKeyCode::Escape {
if is_grabbed {
window.set_cursor_grab(false).unwrap();
window.set_cursor_visible(true);
is_grabbed = false;
} => {
application.on_key_event(*key, *state);
}
} else {
flycam.process_keyboard(*key, *state);
WindowEvent::MouseInput { button, state, .. } => {
application.on_mouse_event(*button, *state);
}
WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
WindowEvent::Resized(physical_size) => {
application.on_resize(*physical_size);
}
WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
application.on_resize(**new_inner_size);
}
_ => {}
}
}
WindowEvent::MouseInput {
button: MouseButton::Left,
state: ElementState::Pressed,
..
} => {
if !is_grabbed {
window.set_cursor_grab(true).unwrap();
window.set_cursor_visible(false);
is_grabbed = true;
}
}
WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
WindowEvent::Resized(physical_size) => {
let mut viewport_entry = world.entry_mut(viewport_entity).unwrap();
let viewport = viewport_entry.get_component_mut::<WinitViewport>().unwrap();
viewport.resize(*physical_size);
flycam.resize(physical_size.width, physical_size.height);
}
WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
let mut viewport_entry = world.entry_mut(viewport_entity).unwrap();
let viewport = viewport_entry.get_component_mut::<WinitViewport>().unwrap();
viewport.resize(**new_inner_size);
flycam.resize(new_inner_size.width, new_inner_size.height);
}
_ => {}
},
}
_ => {}
});
}