render: create ViewTarget to make it easier to render to a non-surface texture and chain together postprocess steps

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

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<RenderGraphLabelValue, BindGroupEntry>,
     /// A directed graph used to determine dependencies of nodes.
     node_graph: petgraph::matrix_graph::DiMatrix<RenderGraphLabelValue, (), Option<()>, usize>,
+    view_target: Rc<RefCell<ViewTarget>>,
 }
 
 impl RenderGraph {
-    pub fn new(device: Arc<wgpu::Device>, queue: Arc<wgpu::Queue>) -> Self {
+    pub fn new(device: Arc<wgpu::Device>, queue: Arc<wgpu::Queue>, view_target: Rc<RefCell<ViewTarget>>) -> 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<ViewTarget> {
+        self.view_target.borrow()
+    }
+
+    pub fn view_target_mut(&self) -> RefMut<ViewTarget> {
+        self.view_target.borrow_mut()
+    }
 }
 
 pub struct SubGraphNode {

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<RenderTarget>,
-    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));
     }
 }

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)

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::*;
+/* mod tint;
+pub use tint::*; */

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

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: &[],
         });
 
@@ -143,3 +143,172 @@ impl Frame {
         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<Frame>,
+    /// The view to use to render to the frame.
+    pub frame_view: Option<wgpu::TextureView>,
+}
+
+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<wgpu::Device>,
+    /// The primary RenderTarget, likely a Surface
+    pub primary: FrameTarget,
+    pub chain: Option<TargetViewChain>,
+}
+
+impl ViewTarget {
+    pub fn new(device: Arc<wgpu::Device>, 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);
+    }
+}

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::<ScreenSize>();
             world_ss.0 = glam::UVec2::new(new_size.width, new_size.height);
+
+            
         }
     }