diff --git a/lyra-game/src/render/graph/context.rs b/lyra-game/src/render/graph/context.rs index 06364e4..deee15c 100644 --- a/lyra-game/src/render/graph/context.rs +++ b/lyra-game/src/render/graph/context.rs @@ -2,7 +2,7 @@ use std::{collections::VecDeque, sync::Arc}; use tracing::instrument; -use super::{Frame, RenderGraphLabel, RenderGraphLabelValue, RenderTarget}; +use super::{RenderGraphLabel, RenderGraphLabelValue}; /// A queued write to a GPU buffer targeting a graph slot. pub(crate) struct GraphBufferWrite { @@ -86,4 +86,16 @@ impl<'a> RenderGraphContext<'a> { ) { self.queue_buffer_write(target_slot, offset, bytemuck::bytes_of(&bytes)); } + + /// Submit the encoder to the gpu queue. + /// + /// The `encoder` of this context will be `None` until the next node is executed, then another + /// one will be made. You likely don't need to run this yourself until you are manually + /// presenting a surface texture. + pub fn submit_encoder(&mut self) { + let en = self.encoder.take() + .unwrap() + .finish(); + self.queue.submit(std::iter::once(en)); + } } diff --git a/lyra-game/src/render/graph/mod.rs b/lyra-game/src/render/graph/mod.rs index 35fca1b..1e61ec3 100644 --- a/lyra-game/src/render/graph/mod.rs +++ b/lyra-game/src/render/graph/mod.rs @@ -1,6 +1,6 @@ mod node; use std::{ - cell::{Ref, RefCell}, collections::{HashMap, VecDeque}, fmt::Debug, hash::Hash, rc::Rc, sync::Arc + cell::{Ref, RefCell, RefMut}, collections::{HashMap, VecDeque}, fmt::Debug, hash::Hash, rc::Rc, sync::Arc }; use lyra_ecs::World; @@ -125,10 +125,11 @@ pub struct RenderGraph { bind_groups: FxHashMap, /// A directed graph used to determine dependencies of nodes. node_graph: petgraph::matrix_graph::DiMatrix, usize>, + view_target: Rc>, } impl RenderGraph { - pub fn new(device: Arc, queue: Arc) -> Self { + pub fn new(device: Arc, queue: Arc, view_target: Rc>) -> Self { Self { device, queue, @@ -137,6 +138,7 @@ impl RenderGraph { sub_graphs: Default::default(), bind_groups: Default::default(), node_graph: Default::default(), + view_target, } } @@ -344,28 +346,18 @@ impl RenderGraph { let device = self.device.clone(); let queue = self.queue.clone(); - // create a new encoder since the last one was presented + // create a new encoder if the last one was submitted if encoder.is_none() { encoder = Some(self.create_encoder()); } - // all encoders need to be submitted before a presenter node is executed. - if pass_desc.ty == NodeType::Presenter { - trace!("Submitting encoder before presenting"); - - let finished = encoder.take().unwrap().finish(); - self.queue.submit(std::iter::once(finished)); - - // Do not create a new encoder yet since this node may be the last node. - // A new encoder can be made on the next iteration of this loop. - } - let mut context = RenderGraphContext::new(device, queue, encoder.take(), pass_label.clone()); trace!("Executing {:?}", pass_label.0); let mut inner = pass_inn.borrow_mut(); inner.execute(self, &pass_desc, &mut context); + // take back the encoder from the context encoder = context.encoder; } @@ -531,6 +523,14 @@ impl RenderGraph { sg.bind_groups.insert(bg.label.clone(), bg); } } + + pub fn view_target(&self) -> Ref { + self.view_target.borrow() + } + + pub fn view_target_mut(&self) -> RefMut { + self.view_target.borrow_mut() + } } pub struct SubGraphNode { diff --git a/lyra-game/src/render/graph/passes/base.rs b/lyra-game/src/render/graph/passes/base.rs index bc7359f..6d0d3fb 100644 --- a/lyra-game/src/render/graph/passes/base.rs +++ b/lyra-game/src/render/graph/passes/base.rs @@ -1,5 +1,6 @@ -use std::{cell::RefCell, rc::Rc}; +use std::rc::Rc; +use glam::UVec2; use lyra_game_derive::RenderGraphLabel; use tracing::warn; use winit::dpi::PhysicalSize; @@ -8,7 +9,7 @@ use crate::{ render::{ camera::{CameraUniform, RenderCamera}, graph::{ - Node, NodeDesc, NodeSlot, NodeType, RenderGraph, RenderGraphContext, RenderTarget, SlotAttribute, SlotType, SlotValue + Node, NodeDesc, NodeType, RenderGraph, RenderGraphContext, SlotAttribute, SlotValue }, render_buffer::BufferWrapper, texture::RenderTexture, }, @@ -23,10 +24,7 @@ pub enum BasePassSlots { DepthTexture, ScreenSize, Camera, - MainRenderTarget, - WindowTextureView, DepthTextureView, - Frame, } /// Supplies some basic things other passes needs. @@ -34,23 +32,12 @@ pub enum BasePassSlots { /// screen size buffer, camera buffer, #[derive(Default)] pub struct BasePass { - /// Temporary storage for the main render target - /// - /// This should be Some when the pass is first created then after its added to - /// the render graph it will be None and stay None. - temp_render_target: Option, - screen_size: glam::UVec2, + screen_size: UVec2, } impl BasePass { - pub fn new(render_target: RenderTarget) -> Self { - let size = render_target.size(); - - Self { - temp_render_target: Some(render_target), - screen_size: size, - ..Default::default() - } + pub fn new() -> Self { + Self::default() } } @@ -59,8 +46,8 @@ impl Node for BasePass { &mut self, graph: &mut crate::render::graph::RenderGraph, ) -> crate::render::graph::NodeDesc { - let render_target = self.temp_render_target.take().unwrap(); - self.screen_size = render_target.size(); + let vt = graph.view_target(); + self.screen_size = vt.size(); let (screen_size_bgl, screen_size_bg, screen_size_buf, _) = BufferWrapper::builder() .buffer_usage(wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST) @@ -107,25 +94,6 @@ impl Node for BasePass { ], ); - desc.add_slot(NodeSlot { - ty: SlotType::RenderTarget, - attribute: SlotAttribute::Output, - label: BasePassSlots::MainRenderTarget.into(), - value: Some(SlotValue::RenderTarget(Rc::new(RefCell::new( - render_target, - )))), - }); - desc.add_slot(NodeSlot { - ty: SlotType::Frame, - attribute: SlotAttribute::Output, - label: BasePassSlots::Frame.into(), - value: Some(SlotValue::Lazy), - }); - desc.add_texture_view_slot( - BasePassSlots::WindowTextureView, - SlotAttribute::Output, - Some(SlotValue::Lazy), - ); desc.add_texture_view_slot( BasePassSlots::DepthTextureView, SlotAttribute::Output, @@ -145,10 +113,12 @@ impl Node for BasePass { desc } - fn prepare(&mut self, _graph: &mut RenderGraph, world: &mut lyra_ecs::World, context: &mut RenderGraphContext) { + fn prepare(&mut self, graph: &mut RenderGraph, world: &mut lyra_ecs::World, context: &mut RenderGraphContext) { if let Some(camera) = world.view_iter::<&mut CameraComponent>().next() { + let screen_size = graph.view_target().size(); + let mut render_cam = - RenderCamera::new(PhysicalSize::new(self.screen_size.x, self.screen_size.y)); + RenderCamera::new(PhysicalSize::new(screen_size.x, screen_size.y)); let uniform = render_cam.calc_view_projection(&camera); context.queue_buffer_write_with(BasePassSlots::Camera, 0, uniform) @@ -163,38 +133,20 @@ impl Node for BasePass { _desc: &crate::render::graph::NodeDesc, context: &mut crate::render::graph::RenderGraphContext, ) { - let tv_slot = graph - .slot_value_mut(BasePassSlots::MainRenderTarget) - .expect("somehow the main render target slot is missing"); - let rt = tv_slot.as_render_target().unwrap(); - let rt_size = rt.size(); - let frame = rt.create_frame(); + let mut vt = graph.view_target_mut(); + vt.primary.create_frame(); + vt.next_chain(context.encoder.as_mut().unwrap()); + vt.primary.create_frame_view(); /* debug_assert!( !rt.current_texture.is_some(), "main render target surface was not presented!" ); */ // update the screen size buffer if the size changed. + let rt_size = vt.size(); if rt_size != self.screen_size { self.screen_size = rt_size; context.queue_buffer_write_with(BasePassSlots::ScreenSize, 0, self.screen_size) } - - let surface_tex = frame.texture(); - let view = surface_tex - .create_view(&wgpu::TextureViewDescriptor::default()); - - drop(rt); // must be manually dropped for borrow checker when getting texture view slot - - let frame_slot = graph - .slot_value_mut(BasePassSlots::Frame) - .expect("somehow the frame slot is missing"); - *frame_slot = SlotValue::Frame(Rc::new(RefCell::new(Some(frame)))); - - // store the surface texture to the slot - let tv_slot = graph - .slot_value_mut(BasePassSlots::WindowTextureView) - .expect("somehow the window texture view slot is missing"); - *tv_slot = SlotValue::TextureView(Rc::new(view)); } } diff --git a/lyra-game/src/render/graph/passes/meshes.rs b/lyra-game/src/render/graph/passes/meshes.rs index 1891a39..643caf2 100644 --- a/lyra-game/src/render/graph/passes/meshes.rs +++ b/lyra-game/src/render/graph/passes/meshes.rs @@ -440,12 +440,7 @@ impl Node for MeshPass { if self.pipeline.is_none() { let device = graph.device(); - - let main_rt = graph.slot_value(BasePassSlots::MainRenderTarget) - .and_then(|s| s.as_render_target()) - .expect("missing main render target"); - let surface_config_format = main_rt.format(); - drop(main_rt); + let surface_config_format = graph.view_target().format(); let camera_bgl = graph.bind_group_layout(BasePassSlots::Camera); let lights_bgl = graph.bind_group_layout(LightBasePassSlots::Lights); @@ -508,11 +503,14 @@ impl Node for MeshPass { ) { let encoder = context.encoder.as_mut().unwrap(); - let view = graph + /* let view = graph .slot_value(BasePassSlots::WindowTextureView) .unwrap() .as_texture_view() - .expect("BasePassSlots::WindowTextureView was not a TextureView slot"); + .expect("BasePassSlots::WindowTextureView was not a TextureView slot"); */ + + let vt = graph.view_target(); + let view = vt.render_view(); let depth_view = graph .slot_value(BasePassSlots::DepthTextureView) diff --git a/lyra-game/src/render/graph/passes/mod.rs b/lyra-game/src/render/graph/passes/mod.rs index ccd17ab..f76e6af 100644 --- a/lyra-game/src/render/graph/passes/mod.rs +++ b/lyra-game/src/render/graph/passes/mod.rs @@ -16,5 +16,5 @@ pub use present_pass::*; mod init; pub use init::*; -mod tint; -pub use tint::*; \ No newline at end of file +/* mod tint; +pub use tint::*; */ \ No newline at end of file diff --git a/lyra-game/src/render/graph/passes/present_pass.rs b/lyra-game/src/render/graph/passes/present_pass.rs index b5d356d..8822b90 100644 --- a/lyra-game/src/render/graph/passes/present_pass.rs +++ b/lyra-game/src/render/graph/passes/present_pass.rs @@ -2,72 +2,42 @@ use std::hash::Hash; use lyra_game_derive::RenderGraphLabel; -use crate::render::graph::{Node, NodeDesc, NodeSlot, NodeType, RenderGraph, RenderGraphContext, RenderGraphLabel, RenderGraphLabelValue, SlotAttribute, SlotType}; +use crate::render::graph::{Node, NodeDesc, NodeType, RenderGraph, RenderGraphContext}; #[derive(Debug, Clone, Hash, PartialEq, RenderGraphLabel)] -pub struct PresentPassLabel(RenderGraphLabelValue); - -impl PresentPassLabel { - pub fn new(frame_label: impl RenderGraphLabel) -> Self { - Self(frame_label.into()) - } -} +pub struct PresentPassLabel; /// Supplies some basic things other passes needs. /// /// screen size buffer, camera buffer, -pub struct PresentPass { - /// Label of this pass - pub label: PresentPassLabel, -} +#[derive(Default, Debug)] +pub struct PresentPass; impl PresentPass { - /// Create a new PresentNode, presenting the frame at `frame_label` - pub fn new(frame_label: impl RenderGraphLabel) -> Self { - Self { - //render_target_slot: render_target_slot.rc_clone(), - label: PresentPassLabel::new(frame_label), - } - } - - pub fn from_node_label(present_pass_label: PresentPassLabel) -> Self { - Self { - label: present_pass_label, - } + pub fn new() -> Self { + Self::default() } } impl Node for PresentPass { fn desc(&mut self, _graph: &mut crate::render::graph::RenderGraph) -> crate::render::graph::NodeDesc { - let mut desc = NodeDesc::new( + NodeDesc::new( NodeType::Presenter, None, vec![], - ); - - desc.add_slot( - NodeSlot { - ty: SlotType::Frame, - attribute: SlotAttribute::Input, - label: self.label.0.clone(), - value: None, - } - ); - - desc + ) } fn prepare(&mut self, _graph: &mut RenderGraph, _world: &mut lyra_ecs::World, _context: &mut RenderGraphContext) { } - fn execute(&mut self, graph: &mut crate::render::graph::RenderGraph, _desc: &crate::render::graph::NodeDesc, _context: &mut crate::render::graph::RenderGraphContext) { - let slot = graph.slot_value_mut(self.label.0.clone()) - .unwrap_or_else(|| panic!("frame slot '{:?}' for PresentPass is missing", self.label.0)) - .as_frame_mut() - .unwrap() - .take() - .unwrap_or_else(|| panic!("frame '{:?}' was already presented", self.label.0)); - slot.present(); + fn execute(&mut self, graph: &mut crate::render::graph::RenderGraph, _desc: &crate::render::graph::NodeDesc, context: &mut crate::render::graph::RenderGraphContext) { let mut vt = graph.view_target_mut(); + vt.copy_to_primary(context.encoder.as_mut().unwrap()); + context.submit_encoder(); + + let frame = vt.primary.frame.take() + .expect("ViewTarget.primary was already presented"); + frame.present(); } } \ No newline at end of file diff --git a/lyra-game/src/render/graph/render_target.rs b/lyra-game/src/render/graph/render_target.rs index 09efac5..34f64ba 100644 --- a/lyra-game/src/render/graph/render_target.rs +++ b/lyra-game/src/render/graph/render_target.rs @@ -39,7 +39,7 @@ impl RenderTarget { sample_count: 1, dimension: wgpu::TextureDimension::D2, format, - usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_DST, + usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_DST | wgpu::TextureUsages::COPY_SRC, view_formats: &[], }); @@ -142,4 +142,173 @@ impl Frame { pub fn size(&self) -> math::UVec2 { self.size } +} + +/// Stores the current frame, and the render target it came from. +pub struct FrameTarget { + pub render_target: RenderTarget, + /// None when a frame has not been created yet + pub frame: Option, + /// The view to use to render to the frame. + pub frame_view: Option, +} + +impl FrameTarget { + pub fn new(render_target: RenderTarget) -> Self { + Self { + render_target, + frame: None, + frame_view: None, + } + } + + /// Returns the size of the [`RenderTarget`]. + pub fn size(&self) -> math::UVec2 { + self.render_target.size() + } + + /// Returns the [`wgpu::TextureFormat`] of the [`RenderTarget`]. + pub fn format(&self) -> wgpu::TextureFormat { + self.render_target.format() + } + + /// Create the frame using the inner [`RenderTarget`]. + pub fn create_frame(&mut self) -> &mut Frame { + self.frame = Some(self.render_target.create_frame()); + self.frame.as_mut().unwrap() + } + + /// Create the [`wgpu::TextureView`] for the [`Frame`], storing it in self and returning a reference to it. + pub fn create_frame_view(&mut self) -> &wgpu::TextureView { + let frame = self.frame.as_ref().expect("frame was not created, cannot create view"); + + self.frame_view = Some(frame.texture().create_view(&wgpu::TextureViewDescriptor::default())); + self.frame_view.as_ref().unwrap() + } +} + +pub struct TargetViewChain { + source: FrameTarget, + dest: FrameTarget, +} + +impl TargetViewChain { + pub fn next(&mut self, encoder: &mut wgpu::CommandEncoder) { + let size = self.source.size(); + let size = wgpu::Extent3d { + width: size.x, + height: size.y, + depth_or_array_layers: 1, + }; + + let source_tex = self.source.frame.as_ref().unwrap().texture(); + let dest_tex = self.dest.frame.as_ref().unwrap().texture(); + + let source_ict = wgpu::ImageCopyTexture { + texture: source_tex, + mip_level: 0, + origin: wgpu::Origin3d::ZERO, + aspect: wgpu::TextureAspect::All, + }; + + let dest_ict = wgpu::ImageCopyTexture { + texture: dest_tex, + mip_level: 0, + origin: wgpu::Origin3d::ZERO, + aspect: wgpu::TextureAspect::All, + }; + + encoder.copy_texture_to_texture(source_ict, dest_ict, size); + std::mem::swap(&mut self.source, &mut self.dest); + } +} + +pub struct ViewTarget { + device: Arc, + /// The primary RenderTarget, likely a Surface + pub primary: FrameTarget, + pub chain: Option, +} + +impl ViewTarget { + pub fn new(device: Arc, primary: RenderTarget) -> Self { + Self { + device, + primary: FrameTarget::new(primary), + chain: None + } + } + + pub fn size(&self) -> math::UVec2 { + self.primary.size() + } + + pub fn format(&self) -> wgpu::TextureFormat { + self.primary.format() + } + + pub fn resize(&mut self, device: &wgpu::Device, size: math::UVec2) { + self.primary.render_target.resize(device, size); + } + + /// Cycle the target view chain, storing it in self, and returning a mutable borrow to it. + pub fn next_chain(&mut self, encoder: &mut wgpu::CommandEncoder) -> &mut TargetViewChain { + // TODO: check if chain has already been made. If it has, use next on it. + let _ = encoder; + let format = self.primary.format(); + let size = self.primary.size(); + + let mut source = FrameTarget::new(RenderTarget::new_texture(&self.device, format, size)); + source.create_frame(); + source.create_frame_view(); + + let mut dest = FrameTarget::new(RenderTarget::new_texture(&self.device, format, size)); + dest.create_frame(); + dest.create_frame_view(); + + self.chain = Some(TargetViewChain { + source, + dest, + }); + //self.reset_chain(encoder); + self.chain.as_mut().unwrap() + } + + /// Get the [`wgpu::TextureView`] to render to + pub fn render_view(&self) -> &wgpu::TextureView { + let chain = self.chain.as_ref().unwrap(); + chain.source.frame_view.as_ref().unwrap() + } + + /// Copy the chain target to the primary target + /// + /// The primary target must have `wgpu::TextureUsages::COPY_DST`. + pub fn copy_to_primary(&self, encoder: &mut wgpu::CommandEncoder) { + let chain = self.chain.as_ref().unwrap(); + let chain_tex = chain.source.frame.as_ref().unwrap().texture(); + + let source_ict = wgpu::ImageCopyTexture { + texture: chain_tex, + mip_level: 0, + origin: wgpu::Origin3d::ZERO, + aspect: wgpu::TextureAspect::All, + }; + + let dest_tex = self.primary.frame.as_ref().unwrap().texture(); + let dest_ict = wgpu::ImageCopyTexture { + texture: dest_tex, + mip_level: 0, + origin: wgpu::Origin3d::ZERO, + aspect: wgpu::TextureAspect::All, + }; + + let size = self.primary.size(); + let size = wgpu::Extent3d { + width: size.x, + height: size.y, + depth_or_array_layers: 1, + }; + + encoder.copy_texture_to_texture(source_ict, dest_ict, size); + } } \ No newline at end of file diff --git a/lyra-game/src/render/renderer.rs b/lyra-game/src/render/renderer.rs index a1d301d..ef38375 100755 --- a/lyra-game/src/render/renderer.rs +++ b/lyra-game/src/render/renderer.rs @@ -1,5 +1,7 @@ +use std::cell::RefCell; use std::collections::VecDeque; use std::ops::{Deref, DerefMut}; +use std::rc::Rc; use std::sync::Arc; use lyra_ecs::World; @@ -7,7 +9,7 @@ use lyra_game_derive::RenderGraphLabel; use tracing::{debug, instrument, warn}; use winit::window::Window; -use crate::render::graph::{BasePass, BasePassLabel, BasePassSlots, LightBasePass, LightBasePassLabel, LightCullComputePass, LightCullComputePassLabel, MeshPass, MeshesPassLabel, PresentPass, PresentPassLabel, RenderGraphLabelValue, RenderTarget, SubGraphNode, TintPass, TintPassLabel, TintPassSlots}; +use crate::render::graph::{BasePass, BasePassLabel, BasePassSlots, LightBasePass, LightBasePassLabel, LightCullComputePass, LightCullComputePassLabel, MeshPass, MeshesPassLabel, PresentPass, PresentPassLabel, RenderGraphLabelValue, RenderTarget, SubGraphNode, ViewTarget}; use super::graph::RenderGraph; use super::{resource::RenderPipeline, render_job::RenderJob}; @@ -114,7 +116,7 @@ impl BasicRenderer { .find(|f| f.describe().srgb) .unwrap_or(surface_caps.formats[0]); let config = wgpu::SurfaceConfiguration { - usage: wgpu::TextureUsages::RENDER_ATTACHMENT, + usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_DST, format: surface_format, width: size.width, height: size.height, @@ -127,35 +129,16 @@ impl BasicRenderer { let device = Arc::new(device); let queue = Arc::new(queue); - let surface_size = wgpu::Extent3d { - width: config.width, - height: config.height, - depth_or_array_layers: 1 - }; let surface_target = RenderTarget::from_surface(surface, config); + let view_target = Rc::new(RefCell::new(ViewTarget::new(device.clone(), surface_target))); - let headless_texture = device.create_texture(&wgpu::TextureDescriptor { - label: Some("headless_texture"), - size: surface_size, - mip_level_count: 1, - sample_count: 1, - dimension: wgpu::TextureDimension::D2, - format: surface_format, - usage: wgpu::TextureUsages::RENDER_ATTACHMENT // we'll be rendering to it - | wgpu::TextureUsages::TEXTURE_BINDING, - view_formats: &[], - }); - - let headless_target = RenderTarget::from(headless_texture); - - - let mut main_graph = RenderGraph::new(device.clone(), queue.clone()); + let mut main_graph = RenderGraph::new(device.clone(), queue.clone(), view_target.clone()); debug!("Adding base pass"); - main_graph.add_node(BasePassLabel, BasePass::new(surface_target)); + main_graph.add_node(BasePassLabel, BasePass::new()); { - let mut forward_plus_graph = RenderGraph::new(device.clone(), queue.clone()); + let mut forward_plus_graph = RenderGraph::new(device.clone(), queue.clone(), view_target.clone()); debug!("Adding light base pass"); forward_plus_graph.add_node(LightBasePassLabel, LightBasePass::new()); @@ -171,8 +154,8 @@ impl BasicRenderer { main_graph.add_sub_graph(TestSubGraphLabel, forward_plus_graph); main_graph.add_node(TestSubGraphLabel, SubGraphNode::new(TestSubGraphLabel, vec![ - RenderGraphLabelValue::from(BasePassSlots::WindowTextureView), - RenderGraphLabelValue::from(BasePassSlots::MainRenderTarget), + /* RenderGraphLabelValue::from(BasePassSlots::WindowTextureView), + RenderGraphLabelValue::from(BasePassSlots::MainRenderTarget), */ RenderGraphLabelValue::from(BasePassSlots::DepthTexture), RenderGraphLabelValue::from(BasePassSlots::DepthTextureView), RenderGraphLabelValue::from(BasePassSlots::Camera), @@ -181,12 +164,12 @@ impl BasicRenderer { )); } - let present_pass_label = PresentPassLabel::new(BasePassSlots::Frame);//TintPassSlots::Frame); - let p = PresentPass::from_node_label(present_pass_label.clone()); - main_graph.add_node(p.label.clone(), p); + //let present_pass_label = PresentPassLabel::new(BasePassSlots::Frame);//TintPassSlots::Frame); + let p = PresentPass::default(); + main_graph.add_node(PresentPassLabel, p); main_graph.add_edge(BasePassLabel, TestSubGraphLabel); - main_graph.add_edge(TestSubGraphLabel, present_pass_label); + main_graph.add_edge(TestSubGraphLabel, PresentPassLabel); /* debug!("Adding base pass"); g.add_node(BasePassLabel, BasePass::new(surface_target)); @@ -259,9 +242,10 @@ impl Renderer for BasicRenderer { self.size = new_size; // update surface config and the surface - let mut rt = self.graph.slot_value_mut(BasePassSlots::MainRenderTarget) + /* let mut rt = self.graph.slot_value_mut(BasePassSlots::MainRenderTarget) .unwrap().as_render_target_mut().unwrap(); - rt.resize(&self.device, math::UVec2::new(new_size.width, new_size.height)); + rt.resize(&self.device, math::UVec2::new(new_size.width, new_size.height)); */ + self.graph.view_target_mut().resize(&self.device, math::UVec2::new(new_size.width, new_size.height)); /* rt.surface_config.width = new_size.width; rt.surface_config.height = new_size.height; rt.surface.configure(&self.device, &rt.surface_config); */ @@ -269,6 +253,8 @@ impl Renderer for BasicRenderer { // update screen size resource in ecs let mut world_ss = world.get_resource_mut::(); world_ss.0 = glam::UVec2::new(new_size.width, new_size.height); + + } }