diff options
| -rw-r--r-- | examples/render-bsp/src/main.rs | 10 | ||||
| -rw-r--r-- | stockton-render/src/draw/buffers/dedicated_image.rs (renamed from stockton-render/src/draw/depth_buffer.rs) | 23 | ||||
| -rw-r--r-- | stockton-render/src/draw/buffers/draw_buffers.rs (renamed from stockton-render/src/draw/draw_buffers.rs) | 11 | ||||
| -rw-r--r-- | stockton-render/src/draw/buffers/mod.rs | 68 | ||||
| -rw-r--r-- | stockton-render/src/draw/buffers/staged.rs (renamed from stockton-render/src/draw/buffer.rs) | 63 | ||||
| -rw-r--r-- | stockton-render/src/draw/camera.rs | 64 | ||||
| -rw-r--r-- | stockton-render/src/draw/context.rs | 28 | ||||
| -rw-r--r-- | stockton-render/src/draw/draw_passes/cons.rs | 34 | ||||
| -rw-r--r-- | stockton-render/src/draw/draw_passes/level.rs | 10 | ||||
| -rw-r--r-- | stockton-render/src/draw/draw_passes/mod.rs | 21 | ||||
| -rw-r--r-- | stockton-render/src/draw/mod.rs | 8 | ||||
| -rw-r--r-- | stockton-render/src/draw/target.rs | 13 | ||||
| -rw-r--r-- | stockton-render/src/draw/ui/render.rs | 2 | ||||
| -rw-r--r-- | stockton-render/src/lib.rs | 44 | ||||
| -rw-r--r-- | stockton-render/src/systems.rs | 2 | ||||
| -rw-r--r-- | stockton-render/src/window.rs | 10 |
16 files changed, 194 insertions, 217 deletions
diff --git a/examples/render-bsp/src/main.rs b/examples/render-bsp/src/main.rs index a3cea25..73475c0 100644 --- a/examples/render-bsp/src/main.rs +++ b/examples/render-bsp/src/main.rs @@ -94,13 +94,13 @@ fn try_main() -> Result<()> { window.set_cursor_visible(false); // TODO: Parse the map file - let bsp = todo!(); + let map = todo!(); // Create the UI State let mut ui = UiState::new(); // Create the renderer - let (renderer, tx) = Renderer::new(&window, &mut ui, bsp)?; + let (renderer, tx) = Renderer::new(&window)?; let new_control_flow = renderer.update_control_flow.clone(); // Populate the initial UI state @@ -127,7 +127,7 @@ fn try_main() -> Result<()> { let mut session = Session::new( move |resources| { resources.insert(ui); - resources.insert(renderer); + resources.insert(map); resources.insert(manager); resources.insert(Timing::default()); resources.insert(Mouse::default()); @@ -139,9 +139,7 @@ fn try_main() -> Result<()> { .flush() .add_system(hello_world_system()) .add_system(flycam_move_system::<MovementInputsManager>()) - .flush() - .add_system(calc_vp_matrix_system::<MapFile>()) - .add_thread_local(do_render_system::<MapFile>()); + .flush(); }, ); diff --git a/stockton-render/src/draw/depth_buffer.rs b/stockton-render/src/draw/buffers/dedicated_image.rs index e3306c5..38a23c9 100644 --- a/stockton-render/src/draw/depth_buffer.rs +++ b/stockton-render/src/draw/buffers/dedicated_image.rs @@ -1,21 +1,22 @@ -use crate::draw::buffer::create_buffer; -use gfx_hal::{format::Aspects, memory::Properties, MemoryTypeId}; +//! A dedicated image. Used for depth buffers. + +use super::create_buffer; +use crate::draw::texture::{LoadableImage, PIXEL_SIZE}; +use crate::types::*; + +use std::{array::IntoIter, convert::TryInto, iter::empty, mem::ManuallyDrop}; + +use anyhow::{Context, Result}; use hal::{ buffer::Usage as BufUsage, - format::{Format, Swizzle}, + format::{Aspects, Format, Swizzle}, image::{SubresourceRange, Usage, Usage as ImgUsage, ViewKind}, memory, - memory::Segment, + memory::{Properties, Segment}, + MemoryTypeId, }; -use std::{array::IntoIter, convert::TryInto, iter::empty}; - -use crate::types::*; -use anyhow::{Context, Result}; -use std::mem::ManuallyDrop; use thiserror::Error; -use super::texture::{LoadableImage, PIXEL_SIZE}; - /// Holds an image that's loaded into GPU memory dedicated only to that image, bypassing the memory allocator. pub struct DedicatedLoadedImage { /// The GPU Image handle diff --git a/stockton-render/src/draw/draw_buffers.rs b/stockton-render/src/draw/buffers/draw_buffers.rs index 2d2fce4..5baec92 100644 --- a/stockton-render/src/draw/draw_buffers.rs +++ b/stockton-render/src/draw/buffers/draw_buffers.rs @@ -1,12 +1,11 @@ -use crate::{draw::buffer::StagedBuffer, types::*}; +//! A vertex and index buffer set for drawing + +use super::StagedBuffer; +use crate::types::*; + use anyhow::{Context, Result}; use hal::buffer::Usage; use std::mem::ManuallyDrop; -use stockton_types::{Vector2, Vector3}; - -/// Represents a point of a triangle, including UV and texture information. -#[derive(Debug, Clone, Copy)] -pub struct UvPoint(pub Vector3, pub i32, pub Vector2); /// Initial size of vertex buffer. TODO: Way of overriding this pub const INITIAL_VERT_SIZE: u64 = 3 * 3000; diff --git a/stockton-render/src/draw/buffers/mod.rs b/stockton-render/src/draw/buffers/mod.rs new file mode 100644 index 0000000..5093872 --- /dev/null +++ b/stockton-render/src/draw/buffers/mod.rs @@ -0,0 +1,68 @@ +//! All sorts of buffers + +use std::ops::IndexMut; + +use crate::{error::EnvironmentError, types::*}; + +use anyhow::{Context, Result}; +use hal::{ + buffer::Usage, + memory::{Properties, SparseFlags}, + MemoryTypeId, +}; + +mod dedicated_image; +mod draw_buffers; +mod staged; + +pub use dedicated_image::DedicatedLoadedImage; +pub use draw_buffers::DrawBuffers; +pub use staged::StagedBuffer; + +/// Create a buffer of the given specifications, allocating more device memory. +// TODO: Use a different memory allocator? +pub(crate) fn create_buffer( + device: &mut DeviceT, + adapter: &Adapter, + usage: Usage, + properties: Properties, + size: u64, +) -> Result<(BufferT, MemoryT)> { + let mut buffer = unsafe { device.create_buffer(size, usage, SparseFlags::empty()) } + .context("Error creating buffer")?; + + let requirements = unsafe { device.get_buffer_requirements(&buffer) }; + let memory_type_id = adapter + .physical_device + .memory_properties() + .memory_types + .iter() + .enumerate() + .find(|&(id, memory_type)| { + requirements.type_mask & (1 << id) != 0 && memory_type.properties.contains(properties) + }) + .map(|(id, _)| MemoryTypeId(id)) + .ok_or(EnvironmentError::NoMemoryTypes)?; + + let memory = unsafe { device.allocate_memory(memory_type_id, requirements.size) } + .context("Error allocating memory")?; + + unsafe { device.bind_buffer_memory(&memory, 0, &mut buffer) } + .context("Error binding memory to buffer")?; + + Ok((buffer, memory)) +} + +/// A buffer that can be modified by the CPU +pub trait ModifiableBuffer: IndexMut<usize> { + /// Get a handle to the underlying GPU buffer + fn get_buffer(&mut self) -> &BufferT; + + /// Commit all changes to GPU memory, returning a handle to the GPU buffer + fn commit<'a>( + &'a mut self, + device: &DeviceT, + command_queue: &mut QueueT, + command_pool: &mut CommandPoolT, + ) -> Result<&'a BufferT>; +} diff --git a/stockton-render/src/draw/buffer.rs b/stockton-render/src/draw/buffers/staged.rs index 77ac38a..f92c41d 100644 --- a/stockton-render/src/draw/buffer.rs +++ b/stockton-render/src/draw/buffers/staged.rs @@ -1,7 +1,14 @@ +//! A buffer that can be written to by the CPU using staging memory + +use super::{create_buffer, ModifiableBuffer}; +use crate::{error::EnvironmentError, types::*}; + use core::mem::{size_of, ManuallyDrop}; -use std::convert::TryInto; -use std::iter::{empty, once}; -use std::ops::{Index, IndexMut}; +use std::{ + convert::TryInto, + iter::{empty, once}, + ops::{Index, IndexMut}, +}; use anyhow::{Context, Result}; use hal::{ @@ -10,56 +17,6 @@ use hal::{ MemoryTypeId, }; -use crate::{error::EnvironmentError, types::*}; - -/// Create a buffer of the given specifications, allocating more device memory. -// TODO: Use a different memory allocator? -pub(crate) fn create_buffer( - device: &mut DeviceT, - adapter: &Adapter, - usage: Usage, - properties: Properties, - size: u64, -) -> Result<(BufferT, MemoryT)> { - let mut buffer = unsafe { device.create_buffer(size, usage, SparseFlags::empty()) } - .context("Error creating buffer")?; - - let requirements = unsafe { device.get_buffer_requirements(&buffer) }; - let memory_type_id = adapter - .physical_device - .memory_properties() - .memory_types - .iter() - .enumerate() - .find(|&(id, memory_type)| { - requirements.type_mask & (1 << id) != 0 && memory_type.properties.contains(properties) - }) - .map(|(id, _)| MemoryTypeId(id)) - .ok_or(EnvironmentError::NoMemoryTypes)?; - - let memory = unsafe { device.allocate_memory(memory_type_id, requirements.size) } - .context("Error allocating memory")?; - - unsafe { device.bind_buffer_memory(&memory, 0, &mut buffer) } - .context("Error binding memory to buffer")?; - - Ok((buffer, memory)) -} - -/// A buffer that can be modified by the CPU -pub trait ModifiableBuffer: IndexMut<usize> { - /// Get a handle to the underlying GPU buffer - fn get_buffer(&mut self) -> &BufferT; - - /// Commit all changes to GPU memory, returning a handle to the GPU buffer - fn commit<'a>( - &'a mut self, - device: &DeviceT, - command_queue: &mut QueueT, - command_pool: &mut CommandPoolT, - ) -> Result<&'a BufferT>; -} - /// A GPU buffer that is written to using a staging buffer pub struct StagedBuffer<'a, T: Sized> { /// CPU-visible buffer diff --git a/stockton-render/src/draw/camera.rs b/stockton-render/src/draw/camera.rs index a9d10f4..421b661 100644 --- a/stockton-render/src/draw/camera.rs +++ b/stockton-render/src/draw/camera.rs @@ -22,35 +22,35 @@ fn euler_to_direction(euler: &Vector3) -> Vector3 { ) } -#[system(for_each)] -#[filter(maybe_changed::<Transform>() | maybe_changed::<CameraSettings>())] -pub fn calc_vp_matrix<M: 'static + MinRenderFeatures>( - transform: &Transform, - settings: &CameraSettings, - #[resource] renderer: &mut Renderer<M>, -) { - let ratio = renderer.context.target_chain.properties.extent.width as f32 - / renderer.context.target_chain.properties.extent.height as f32; - // Get look direction from euler angles - let direction = euler_to_direction(&transform.rotation); - - // Converts world space to camera space - let view_matrix = look_at_lh( - &transform.position, - &(transform.position + direction), - &Vector3::new(0.0, 1.0, 0.0), - ); - - // Converts camera space to screen space - let projection_matrix = { - let mut temp = perspective_lh_zo(ratio, settings.fov, settings.near, settings.far); - - // Vulkan's co-ord system is different from OpenGLs - temp[(1, 1)] *= -1.0; - - temp - }; - - // Chain them together into a single matrix - renderer.context.vp_matrix = projection_matrix * view_matrix -} +// #[system(for_each)] +// #[filter(maybe_changed::<Transform>() | maybe_changed::<CameraSettings>())] +// pub fn calc_vp_matrix<M: 'static + MinRenderFeatures>( +// transform: &Transform, +// settings: &CameraSettings, +// #[resource] renderer: &mut Renderer<M>, +// ) { +// let ratio = renderer.context.target_chain.properties.extent.width as f32 +// / renderer.context.target_chain.properties.extent.height as f32; +// // Get look direction from euler angles +// let direction = euler_to_direction(&transform.rotation); + +// // Converts world space to camera space +// let view_matrix = look_at_lh( +// &transform.position, +// &(transform.position + direction), +// &Vector3::new(0.0, 1.0, 0.0), +// ); + +// // Converts camera space to screen space +// let projection_matrix = { +// let mut temp = perspective_lh_zo(ratio, settings.fov, settings.near, settings.far); + +// // Vulkan's co-ord system is different from OpenGLs +// temp[(1, 1)] *= -1.0; + +// temp +// }; + +// // Chain them together into a single matrix +// renderer.context.vp_matrix = projection_matrix * view_matrix +// } diff --git a/stockton-render/src/draw/context.rs b/stockton-render/src/draw/context.rs index 2d3d92d..1a690fe 100644 --- a/stockton-render/src/draw/context.rs +++ b/stockton-render/src/draw/context.rs @@ -24,13 +24,12 @@ use crate::{ window::UiState, }; use stockton_levels::prelude::*; +use stockton_types::Session; /// Contains all the hal related stuff. /// In the end, this takes in a depth-sorted list of faces and a map file and renders them. // TODO: Settings for clear colour, buffer sizes, etc -pub struct RenderingContext<M: 'static + MinRenderFeatures, DP = LevelDrawPass<M>> { - pub map: Arc<RwLock<M>>, - +pub struct RenderingContext<DP> { // Parents for most of these things /// Vulkan Instance instance: ManuallyDrop<back::Instance>, @@ -60,19 +59,12 @@ pub struct RenderingContext<M: 'static + MinRenderFeatures, DP = LevelDrawPass<M pub(crate) pixels_per_point: f32, } -impl<M: 'static + MinRenderFeatures, DP> RenderingContext<M, DP> -where - DP: DrawPass<Input = M>, -{ - // TODO: Arbitrary drawpass input +impl<DP: DrawPass> RenderingContext<DP> { /// Create a new RenderingContext for the given window. pub fn new<ILDP: IntoDrawPass<DP>>( window: &Window, - _ui: &mut UiState, - map: M, idp: ILDP, ) -> Result<Self> { - let map = Arc::new(RwLock::new(map)); // Create surface let (instance, surface, mut adapters) = unsafe { let instance = @@ -174,7 +166,6 @@ where drop(device); Ok(RenderingContext { - map, instance: ManuallyDrop::new(instance), device: device_lock, @@ -231,8 +222,8 @@ where Ok(()) } - /// Draw all vertices in the buffer - pub fn draw_next_frame(&mut self) -> Result<()> { + /// Draw onto the next frame of the swapchain + pub fn draw_next_frame(&mut self, session: &Session) -> Result<()> { let mut device = self .device .write() @@ -241,20 +232,19 @@ where let mut queue = self .queue .write() - .map_err(|_| LockPoisoned::Map) - .context("Error getting map lock")?; - let map = self.map.read().or(Err(LockPoisoned::Map))?; + .map_err(|_| LockPoisoned::Queue) + .context("Error getting draw queue lock")?; // Level draw pass self.target_chain - .do_draw_with(&mut device, &mut queue, &*self.draw_pass, &*map) + .do_draw_with(&mut device, &mut queue, &*self.draw_pass, session) .context("Error preparing next target")?; Ok(()) } } -impl<M: 'static + MinRenderFeatures, LDP> core::ops::Drop for RenderingContext<M, LDP> { +impl<DP> core::ops::Drop for RenderingContext<DP> { fn drop(&mut self) { { self.device.write().unwrap().wait_idle().unwrap(); diff --git a/stockton-render/src/draw/draw_passes/cons.rs b/stockton-render/src/draw/draw_passes/cons.rs index 274bd76..76e2f32 100644 --- a/stockton-render/src/draw/draw_passes/cons.rs +++ b/stockton-render/src/draw/draw_passes/cons.rs @@ -1,22 +1,22 @@ //! Code for using multiple draw passes in place of just one //! Note that this can be extended to an arbitrary amount of draw passes. -use super::{DrawPass, DrawPassInput}; +use super::DrawPass; use crate::{draw::queue_negotiator::QueueNegotiator, types::*}; +use stockton_types::Session; + use anyhow::Result; /// One draw pass, then another. -struct ConsDrawPass<A: DrawPass, B: DrawPass> { +pub struct ConsDrawPass<A: DrawPass, B: DrawPass> { a: A, b: B, } impl<A: DrawPass, B: DrawPass> DrawPass for ConsDrawPass<A, B> { - type Input = ConsDrawPassInput<A::Input, B::Input>; - - fn queue_draw(&self, input: &Self::Input, cmd_buffer: &mut CommandBufferT) -> Result<()> { - self.a.queue_draw(&input.a, cmd_buffer)?; - self.b.queue_draw(&input.b, cmd_buffer)?; + fn queue_draw(&self, session: &Session, cmd_buffer: &mut CommandBufferT) -> Result<()> { + self.a.queue_draw(&session, cmd_buffer)?; + self.b.queue_draw(&session, cmd_buffer)?; Ok(()) } @@ -34,21 +34,12 @@ impl<A: DrawPass, B: DrawPass> DrawPass for ConsDrawPass<A, B> { } } -/// Input for a ConsDrawPass. -struct ConsDrawPassInput<A, B> { - pub a: A, - pub b: B, -} - -impl<A: DrawPassInput, B: DrawPassInput> DrawPassInput for ConsDrawPassInput<A, B> {} - /// A draw pass that does nothing. Can be used at the end of sequences if there's an odd number of draw passes. -struct NilDrawPass; +pub struct NilDrawPass; impl DrawPass for NilDrawPass { - type Input = NilDrawPassInput; - fn queue_draw(&self, _input: &Self::Input, _cmd_buffer: &mut CommandBufferT) -> Result<()> { + fn queue_draw(&self, _input: &Session, _cmd_buffer: &mut CommandBufferT) -> Result<()> { Ok(()) } @@ -58,9 +49,4 @@ impl DrawPass for NilDrawPass { ) -> Result<Vec<(&'a QueueFamilyT, Vec<f32>)>> { Ok(vec![]) } -} - -/// Input for a NilDrawPass. -struct NilDrawPassInput; - -impl DrawPassInput for NilDrawPassInput {} +}
\ No newline at end of file diff --git a/stockton-render/src/draw/draw_passes/level.rs b/stockton-render/src/draw/draw_passes/level.rs index afcb703..b968a1a 100644 --- a/stockton-render/src/draw/draw_passes/level.rs +++ b/stockton-render/src/draw/draw_passes/level.rs @@ -1,6 +1,6 @@ //! Minimal code for drawing any level, based on traits from stockton-levels -use super::{DrawPass, DrawPassInput, IntoDrawPass}; +use super::{DrawPass, IntoDrawPass}; use crate::{ draw::{queue_negotiator::QueueNegotiator, target::SwapchainProperties, texture::TextureRepo}, error::EnvironmentError, @@ -30,16 +30,10 @@ pub struct LevelDrawPass<M: MinRenderFeatures> { _d: PhantomData<M>, } -/// Any map can be used as draw pass input. -/// TODO: Restrict this based on the type of the renderer. -impl<T: MinRenderFeatures> DrawPassInput for T {} - impl<M: MinRenderFeatures> DrawPass for LevelDrawPass<M> { - type Input = M; - fn queue_draw( &self, - _file: &Self::Input, + _input: &Session, _cmd_buffer: &mut crate::types::CommandBufferT, ) -> anyhow::Result<()> { todo!() diff --git a/stockton-render/src/draw/draw_passes/mod.rs b/stockton-render/src/draw/draw_passes/mod.rs index 76dd8d6..566a64b 100644 --- a/stockton-render/src/draw/draw_passes/mod.rs +++ b/stockton-render/src/draw/draw_passes/mod.rs @@ -1,26 +1,23 @@ //! Traits and common draw passes. +use super::{queue_negotiator::QueueNegotiator, target::SwapchainProperties}; +use crate::types::*; +use stockton_types::Session; -mod cons; -mod level; use std::sync::{Arc, RwLock}; -pub use level::LevelDrawPass; - -use super::{queue_negotiator::QueueNegotiator, target::SwapchainProperties}; -use crate::types::*; use anyhow::Result; -/// Type can be used as input to a draw pass. This requires it being available from only the resources at draw time. -pub trait DrawPassInput {} +mod cons; +mod level; + +pub use level::LevelDrawPass; +pub use cons::{ConsDrawPass, NilDrawPass}; /// One of several 'passes' that draw on each frame. pub trait DrawPass { - /// Extra input required for this draw pass. - type Input: DrawPassInput; - /// Queue any necessary draw commands to cmd_buffer /// This should assume the command buffer isn't in the middle of a renderpass, and should leave it as such. - fn queue_draw(&self, input: &Self::Input, cmd_buffer: &mut CommandBufferT) -> Result<()>; + fn queue_draw(&self, session: &Session, cmd_buffer: &mut CommandBufferT) -> Result<()>; /// This function should ask the queue negotatior to find families for any auxilary operations this draw pass needs to perform /// For example, .find(&TexLoadQueue) diff --git a/stockton-render/src/draw/mod.rs b/stockton-render/src/draw/mod.rs index 5e1d2cd..411e835 100644 --- a/stockton-render/src/draw/mod.rs +++ b/stockton-render/src/draw/mod.rs @@ -2,17 +2,15 @@ pub mod target; -mod buffer; +mod buffers; mod camera; mod context; -mod depth_buffer; -mod draw_buffers; pub mod draw_passes; mod queue_negotiator; mod texture; mod ui; mod utils; -pub use self::camera::calc_vp_matrix_system; pub use self::context::RenderingContext; -pub use self::draw_buffers::UvPoint; + +pub use self::draw_passes::*; diff --git a/stockton-render/src/draw/target.rs b/stockton-render/src/draw/target.rs index 754bad3..c46feb5 100644 --- a/stockton-render/src/draw/target.rs +++ b/stockton-render/src/draw/target.rs @@ -6,15 +6,17 @@ use std::{ }; use hal::{ + command::CommandBufferFlags, format::{ChannelType, Format, ImageFeature}, image::{Extent, Usage as ImgUsage}, pso::Viewport, window::{CompositeAlphaMode, Extent2D, PresentMode, SwapchainConfig}, }; -use super::{depth_buffer::DedicatedLoadedImage, draw_passes::DrawPass}; +use super::{buffers::DedicatedLoadedImage, draw_passes::DrawPass}; use crate::{error::EnvironmentError, types::*}; use anyhow::{Context, Result}; +use stockton_types::Session; #[derive(Debug, Clone)] pub struct SwapchainProperties { @@ -249,7 +251,7 @@ impl TargetChain { device: &mut DeviceT, command_queue: &mut QueueT, dp: &DP, - dpi: &DP::Input, + session: &Session, ) -> Result<()> { self.last_syncs = (self.last_syncs + 1) % self.sync_objects.len(); self.last_image = (self.last_image + 1) % self.targets.len() as u32; @@ -275,9 +277,12 @@ impl TargetChain { }; // Record commands - dp.queue_draw(dpi, &mut target.cmd_buffer) - .context("Error in draw pass")?; unsafe { + target.cmd_buffer.begin_primary(CommandBufferFlags::empty()); + + dp.queue_draw(session, &mut target.cmd_buffer) + .context("Error in draw pass")?; + target.cmd_buffer.finish(); } diff --git a/stockton-render/src/draw/ui/render.rs b/stockton-render/src/draw/ui/render.rs index a3e0f04..009a1b7 100644 --- a/stockton-render/src/draw/ui/render.rs +++ b/stockton-render/src/draw/ui/render.rs @@ -2,7 +2,7 @@ use crate::draw::texture::TextureRepo; use hal::pso::{Rect, ShaderStageFlags}; use super::UiPoint; -use crate::draw::draw_buffers::DrawBuffers; +use crate::draw::buffers::DrawBuffers; use crate::types::*; use crate::UiState; use anyhow::{anyhow, Result}; diff --git a/stockton-render/src/lib.rs b/stockton-render/src/lib.rs index 4eb51e5..850d3eb 100644 --- a/stockton-render/src/lib.rs +++ b/stockton-render/src/lib.rs @@ -14,7 +14,10 @@ pub mod systems; mod types; pub mod window; -use draw::RenderingContext; +use draw::{ + RenderingContext, + draw_passes::{DrawPass, IntoDrawPass} +}; use error::full_error_display; use legion::world::SubWorld; use legion::IntoQuery; @@ -27,7 +30,7 @@ use anyhow::Result; use log::error; use stockton_levels::prelude::*; use stockton_types::components::{CameraSettings, Transform}; -use stockton_types::Vector3; +use stockton_types::{Vector3, Session}; use winit::event_loop::ControlFlow; use winit::window::Window; @@ -35,9 +38,9 @@ use std::sync::mpsc::channel; /// Renders a world to a window when you tell it to. /// Also takes ownership of the window and channels window events to be processed outside winit's event loop. -pub struct Renderer<M: 'static + MinRenderFeatures> { +pub struct Renderer<DP> { /// All the vulkan stuff - pub(crate) context: RenderingContext<M>, + pub(crate) context: RenderingContext<DP>, /// For getting events from the winit event loop pub window_events: Receiver<WindowEvent>, @@ -46,15 +49,15 @@ pub struct Renderer<M: 'static + MinRenderFeatures> { pub update_control_flow: Arc<RwLock<ControlFlow>>, } -impl<M: 'static + MinRenderFeatures> Renderer<M> { +impl<DP: DrawPass> Renderer<DP> { /// Create a new Renderer. - pub fn new(window: &Window, ui: &mut UiState, file: M) -> Result<(Self, Sender<WindowEvent>)> { + pub fn new<IDP: IntoDrawPass<DP>>(window: &Window, ui: &mut UiState, idp: IDP) -> Result<(Self, Sender<WindowEvent>)> { let (tx, rx) = channel(); let update_control_flow = Arc::new(RwLock::new(ControlFlow::Poll)); Ok(( Renderer { - context: RenderingContext::new(window, ui, file, ())?, + context: RenderingContext::new(window, idp)?, window_events: rx, update_control_flow, }, @@ -62,15 +65,15 @@ impl<M: 'static + MinRenderFeatures> Renderer<M> { )) } - /// Render a single frame of the given map. - fn render(&mut self, _ui: &mut UiState, _pos: Vector3) -> Result<()> { + /// Render a single frame of the given session. + fn render(&mut self, session: &Session) -> Result<()> { // Try to draw - if self.context.draw_next_frame().is_err() { + if self.context.draw_next_frame(session).is_err() { // Probably the surface changed unsafe { self.context.handle_surface_change()? }; // If it fails twice, then error - self.context.draw_next_frame()?; + self.context.draw_next_frame(session)?; } Ok(()) @@ -79,21 +82,4 @@ impl<M: 'static + MinRenderFeatures> Renderer<M> { fn resize(&mut self) -> Result<()> { unsafe { self.context.handle_surface_change() } } -} - -/// A system that just renders the world. -#[system] -#[read_component(Transform)] -#[read_component(CameraSettings)] -pub fn do_render<T: 'static + MinRenderFeatures>( - #[resource] renderer: &mut Renderer<T>, - #[resource] ui: &mut UiState, - world: &SubWorld, -) { - let mut query = <(&Transform, &CameraSettings)>::query(); - for (transform, _) in query.iter(world) { - if let Err(err) = renderer.render(ui, transform.position) { - error!("{}", full_error_display(err)); - } - } -} +}
\ No newline at end of file diff --git a/stockton-render/src/systems.rs b/stockton-render/src/systems.rs index b0c33c2..67cea84 100644 --- a/stockton-render/src/systems.rs +++ b/stockton-render/src/systems.rs @@ -1,3 +1 @@ -pub use crate::do_render_system; -pub use crate::draw::calc_vp_matrix_system; pub use crate::window::process_window_events_system; diff --git a/stockton-render/src/window.rs b/stockton-render/src/window.rs index 7b63bc3..6e6a0e1 100644 --- a/stockton-render/src/window.rs +++ b/stockton-render/src/window.rs @@ -1,4 +1,4 @@ -use crate::{error::full_error_display, Renderer}; +use crate::{error::full_error_display, Renderer, DrawPass}; use egui::{Modifiers, Rect, Vec2}; use legion::systems::Runnable; use log::debug; @@ -177,8 +177,8 @@ impl UiState { #[system] /// A system to process the window events sent to renderer by the winit event loop. -pub fn _process_window_events<T: 'static + InputManager, M: 'static + MinRenderFeatures>( - #[resource] renderer: &mut Renderer<M>, +pub fn _process_window_events<T: 'static + InputManager, DP: 'static + DrawPass>( + #[resource] renderer: &mut Renderer<DP>, #[resource] manager: &mut T, #[resource] mouse: &mut Mouse, #[resource] ui_state: &mut UiState, @@ -237,7 +237,7 @@ pub fn _process_window_events<T: 'static + InputManager, M: 'static + MinRenderF manager.handle_frame(&actions_buf[0..actions_buf_cursor]); } -pub fn process_window_events_system<T: 'static + InputManager, M: 'static + MinRenderFeatures>( +pub fn process_window_events_system<T: 'static + InputManager, DP: 'static + DrawPass>( ) -> impl Runnable { - _process_window_events_system::<T, M>(Vec::with_capacity(4)) + _process_window_events_system::<T, DP>(Vec::with_capacity(4)) } |