lyra-game/src/render/graph/context.rs

@@ -2,7 +2,7 @@ use std::{collections::VecDeque, sync::Arc};
 
 use tracing::instrument;
 
-use super::{RenderGraphLabel, RenderGraphLabelValue};
+use super::{Frame, RenderGraphLabel, RenderGraphLabelValue, RenderTarget};
 
 /// A queued write to a GPU buffer targeting a graph slot.
 pub(crate) struct GraphBufferWrite {
@@ -87,15 +87,14 @@ impl<'a> RenderGraphContext<'a> {
         self.queue_buffer_write(target_slot, offset, bytemuck::bytes_of(&bytes));
     }
 
-    /// Submit the encoder to the gpu queue.
+    pub fn get_frame(&self, render_target: &RenderTarget) -> super::Frame {
-    /// 
+        let texture = render_target.frame_texture()
-    /// The `encoder` of this context will be `None` until the next node is executed, then another
+            .expect("failed to create frame texture"); // should this be returned to the user?
-    /// one will be made. You likely don't need to run this yourself until you are manually
+        
-    /// presenting a surface texture.
+        Frame {
-    pub fn submit_encoder(&mut self) {
+            device: self.device.clone(),
-        let en = self.encoder.take()
+            queue: self.queue.clone(),
-            .unwrap()
+            texture,
-            .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, RefMut}, collections::{HashMap, VecDeque}, fmt::Debug, hash::Hash, rc::Rc, sync::Arc
+    cell::{Ref, RefCell}, collections::{HashMap, VecDeque}, fmt::Debug, hash::Hash, rc::Rc, sync::Arc
 };
 
 use lyra_ecs::World;
@@ -125,11 +125,10 @@ 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>, view_target: Rc<RefCell<ViewTarget>>) -> Self {
+    pub fn new(device: Arc<wgpu::Device>, queue: Arc<wgpu::Queue>) -> Self {
         Self {
             device,
             queue,
@@ -138,7 +137,6 @@ impl RenderGraph {
             sub_graphs: Default::default(),
             bind_groups: Default::default(),
             node_graph: Default::default(),
-            view_target,
         }
     }
 
@@ -346,18 +344,28 @@ impl RenderGraph {
             let device = self.device.clone();
             let queue = self.queue.clone();
 
-            // create a new encoder if the last one was submitted
+            // create a new encoder since the last one was presented
             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;
         }
 
@@ -523,14 +531,6 @@ 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,6 +1,5 @@
-use std::rc::Rc;
+use std::{cell::RefCell, rc::Rc};
 
-use glam::UVec2;
 use lyra_game_derive::RenderGraphLabel;
 use tracing::warn;
 use winit::dpi::PhysicalSize;
@@ -9,7 +8,7 @@ use crate::{
     render::{
         camera::{CameraUniform, RenderCamera},
         graph::{
-            Node, NodeDesc, NodeType, RenderGraph, RenderGraphContext, SlotAttribute, SlotValue
+            Node, NodeDesc, NodeSlot, NodeType, RenderGraph, RenderGraphContext, RenderTarget, SlotAttribute, SlotType, SlotValue
         },
         render_buffer::BufferWrapper, texture::RenderTexture,
     },
@@ -24,7 +23,10 @@ pub enum BasePassSlots {
     DepthTexture,
     ScreenSize,
     Camera,
+    MainRenderTarget,
+    WindowTextureView,
     DepthTextureView,
+    Frame,
 }
 
 /// Supplies some basic things other passes needs.
@@ -32,12 +34,23 @@ pub enum BasePassSlots {
 /// screen size buffer, camera buffer,
 #[derive(Default)]
 pub struct BasePass {
-    screen_size: UVec2,
+    /// 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,
 }
 
 impl BasePass {
-    pub fn new() -> Self {
+    pub fn new(render_target: RenderTarget) -> Self {
-        Self::default()
+        let size = render_target.size();
+
+        Self {
+            temp_render_target: Some(render_target),
+            screen_size: size,
+            ..Default::default()
+        }
     }
 }
 
@@ -46,8 +59,8 @@ impl Node for BasePass {
         &mut self,
         graph: &mut crate::render::graph::RenderGraph,
     ) -> crate::render::graph::NodeDesc {
-        let vt = graph.view_target();
+        let render_target = self.temp_render_target.take().unwrap();
-        self.screen_size = vt.size();
+        self.screen_size = render_target.size();
 
         let (screen_size_bgl, screen_size_bg, screen_size_buf, _) = BufferWrapper::builder()
             .buffer_usage(wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST)
@@ -94,6 +107,25 @@ 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,
@@ -113,12 +145,10 @@ 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(screen_size.x, screen_size.y));
+                RenderCamera::new(PhysicalSize::new(self.screen_size.x, self.screen_size.y));
             let uniform = render_cam.calc_view_projection(&camera);
 
             context.queue_buffer_write_with(BasePassSlots::Camera, 0, uniform)
@@ -133,20 +163,38 @@ impl Node for BasePass {
         _desc: &crate::render::graph::NodeDesc,
         context: &mut crate::render::graph::RenderGraphContext,
     ) {
-        let mut vt = graph.view_target_mut();
+        let tv_slot = graph
-        vt.primary.create_frame();
+            .slot_value_mut(BasePassSlots::MainRenderTarget)
-        vt.next_chain(context.encoder.as_mut().unwrap());
+            .expect("somehow the main render target slot is missing");
-        vt.primary.create_frame_view();
+        let rt = tv_slot.as_render_target().unwrap();
+        let rt_size = rt.size();
+        let frame = context.get_frame(&rt);
         /* 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,7 +440,12 @@ impl Node for MeshPass {
 
         if self.pipeline.is_none() {
             let device = graph.device();
-            let surface_config_format = graph.view_target().format();
+
+            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 camera_bgl = graph.bind_group_layout(BasePassSlots::Camera);
             let lights_bgl = graph.bind_group_layout(LightBasePassSlots::Lights);
@@ -503,14 +508,11 @@ 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;
+mod tint;
-pub use tint::*; */
+pub use tint::*;

lyra-game/src/render/graph/passes/present_pass.rs

@@ -2,42 +2,72 @@ use std::hash::Hash;
 
 use lyra_game_derive::RenderGraphLabel;
 
-use crate::render::graph::{Node, NodeDesc, NodeType, RenderGraph, RenderGraphContext};
+use crate::render::graph::{Node, NodeDesc, NodeSlot, NodeType, RenderGraph, RenderGraphContext, RenderGraphLabel, RenderGraphLabelValue, SlotAttribute, SlotType};
 
 #[derive(Debug, Clone, Hash, PartialEq, RenderGraphLabel)]
-pub struct PresentPassLabel;
+pub struct PresentPassLabel(RenderGraphLabelValue);
+
+impl PresentPassLabel {
+    pub fn new(frame_label: impl RenderGraphLabel) -> Self {
+        Self(frame_label.into())
+    }
+}
 
 /// Supplies some basic things other passes needs.
 /// 
 /// screen size buffer, camera buffer,
-#[derive(Default, Debug)]
+pub struct PresentPass {
-pub struct PresentPass;
+    /// Label of this pass
+    pub label: PresentPassLabel,
+}
 
 impl PresentPass {
-    pub fn new() -> Self {
+    /// Create a new PresentNode, presenting the frame at `frame_label`
-        Self::default()
+    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,
+        }
     }
 }
 
 impl Node for PresentPass {
     fn desc(&mut self, _graph: &mut crate::render::graph::RenderGraph) -> crate::render::graph::NodeDesc {
-        NodeDesc::new(
+        let mut desc = 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 mut vt = graph.view_target_mut();
+    fn execute(&mut self, graph: &mut crate::render::graph::RenderGraph, _desc: &crate::render::graph::NodeDesc, _context: &mut crate::render::graph::RenderGraphContext) {
-        vt.copy_to_primary(context.encoder.as_mut().unwrap());
+        let slot = graph.slot_value_mut(self.label.0.clone())
-        context.submit_encoder();
+            .unwrap_or_else(|| panic!("frame slot '{:?}' for PresentPass is missing", self.label.0))
-
+            .as_frame_mut()
-        let frame = vt.primary.frame.take()
+            .unwrap()
-            .expect("ViewTarget.primary was already presented");
+            .take()
-        frame.present();
+            .unwrap_or_else(|| panic!("frame '{:?}' was already presented", self.label.0));
+        slot.present();
     }
 }

lyra-game/src/render/graph/passes/tint.rs

@@ -1,190 +0,0 @@
-use std::{cell::RefCell, rc::Rc};
-
-use lyra_game_derive::RenderGraphLabel;
-
-use crate::render::{
-    graph::{Node, NodeDesc, NodeSlot, NodeType, RenderTarget, SlotAttribute, SlotType, SlotValue},
-    resource::{FragmentState, PipelineDescriptor, RenderPipelineDescriptor, Shader, VertexState},
-};
-
-use super::BasePassSlots;
-
-#[derive(Debug, Clone, Copy, Hash, RenderGraphLabel)]
-pub enum TintPassSlots {
-    InputRenderTarget,
-    InputTextureView,
-
-    TextureViewBindGroup,
-    Frame
-}
-
-#[derive(Default, Debug, Clone, Copy, Hash, RenderGraphLabel)]
-pub struct TintPassLabel;
-
-pub struct TintPass {
-    render_target: Option<RenderTarget>,
-}
-
-impl TintPass {
-    pub fn new(render_target: RenderTarget) -> Self {
-        Self {
-            render_target: Some(render_target)
-        }
-    }
-}
-
-impl Node for TintPass {
-    fn desc<'a, 'b>(
-        &'a mut self,
-        graph: &'b mut crate::render::graph::RenderGraph,
-    ) -> crate::render::graph::NodeDesc {
-        let device = &graph.device;
-
-        // get surface config format
-        /* 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 bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-            label: Some("tint_bgl"),
-            entries: &[
-                wgpu::BindGroupLayoutEntry {
-                    binding: 0,
-                    visibility: wgpu::ShaderStages::FRAGMENT,
-                    ty: wgpu::BindingType::Texture {
-                        sample_type: wgpu::TextureSampleType::Float { filterable: false },
-                        view_dimension: wgpu::TextureViewDimension::D2,
-                        multisampled: false,
-                    },
-                    count: None,
-                },
-                wgpu::BindGroupLayoutEntry {
-                    binding: 1,
-                    visibility: wgpu::ShaderStages::FRAGMENT,
-                    ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::NonFiltering),
-                    count: None,
-                },
-            ],
-        });
-        let bgl = Rc::new(bgl);
-
-        let input_view = graph
-            .slot_value(BasePassSlots::WindowTextureView)
-            .and_then(|s| s.as_texture_view())
-            .expect("missing input texture view");
-
-        let bg = device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some("tint_bg"),
-            layout: &*bgl,
-            entries: &[wgpu::BindGroupEntry {
-                binding: 0,
-                resource: wgpu::BindingResource::TextureView(input_view),
-            }],
-        });
-
-        let shader = Rc::new(Shader {
-            label: Some("tint_shader".into()),
-            source: include_str!("../../shaders/tint.wgsl").to_string(),
-        });
-
-        let mut desc = NodeDesc::new(
-            NodeType::Render,
-            Some(PipelineDescriptor::Render(RenderPipelineDescriptor {
-                label: Some("tint_pass".into()),
-                layouts: vec![bgl.clone()],
-                push_constant_ranges: vec![],
-                vertex: VertexState {
-                    module: shader.clone(),
-                    entry_point: "vs_main".into(),
-                    buffers: vec![],
-                },
-                fragment: Some(FragmentState {
-                    module: shader,
-                    entry_point: "fs_main".into(),
-                    targets: vec![Some(wgpu::ColorTargetState {
-                        format: self.render_target.as_ref().unwrap().format(),
-                        blend: Some(wgpu::BlendState::REPLACE),
-                        write_mask: wgpu::ColorWrites::ALL,
-                    })],
-                }),
-                depth_stencil: None,
-                primitive: wgpu::PrimitiveState::default(),
-                multisample: wgpu::MultisampleState::default(),
-                multiview: None,
-            })),
-            vec![(&TintPassSlots::TextureViewBindGroup, bg.into(), Some(bgl))],
-        );
-
-        // desc.add_buffer_slot(
-        //     FxaaPassSlots::Lights,
-        //     SlotAttribute::Output,
-        //     Some(SlotValue::Buffer(light_buffers.buffer.clone())),
-        // );
-
-        desc.add_slot(NodeSlot {
-            ty: SlotType::Frame,
-            attribute: SlotAttribute::Output,
-            label: TintPassSlots::Frame.into(),
-            value: Some(SlotValue::Lazy),
-        });
-
-        desc
-    }
-
-    fn prepare(
-        &mut self,
-        _: &mut crate::render::graph::RenderGraph,
-        _: &mut lyra_ecs::World,
-        _: &mut crate::render::graph::RenderGraphContext,
-    ) {
-        //todo!()
-    }
-
-    fn execute(
-        &mut self,
-        graph: &mut crate::render::graph::RenderGraph,
-        _: &crate::render::graph::NodeDesc,
-        context: &mut crate::render::graph::RenderGraphContext,
-    ) {
-        let rt = self.render_target.as_ref().unwrap();
-        let frame = rt.create_frame();
-
-        let view = frame.texture()
-            .create_view(&wgpu::TextureViewDescriptor::default());
-
-        let frame_slot = graph
-            .slot_value_mut(TintPassSlots::Frame)
-            .expect("somehow the frame slot is missing");
-        *frame_slot = SlotValue::Frame(Rc::new(RefCell::new(Some(frame))));
-
-        let bg = graph.bind_group(TintPassSlots::TextureViewBindGroup);
-
-        /* let view = graph
-            .slot_value(BasePassSlots::WindowTextureView)
-            .unwrap()
-            .as_texture_view()
-            .expect("BasePassSlots::WindowTextureView was not a TextureView slot"); */
-
-        {
-            let encoder = context.encoder.as_mut().unwrap();
-            let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-                label: Some("tint_pass"),
-                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-                    view: &view,
-                    resolve_target: None,
-                    ops: wgpu::Operations {
-                        load: wgpu::LoadOp::Load,
-                        store: true,
-                    },
-                })],
-                depth_stencil_attachment: None,
-            });
-
-            pass.set_bind_group(0, bg, &[]);
-            pass.draw(0..4, 0..1);
-        }
-    }
-}

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 | wgpu::TextureUsages::COPY_SRC,
+            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_DST,
             view_formats: &[],
         });
 
@@ -89,21 +89,6 @@ impl RenderTarget {
             },
         }
     }
-
-    /// Create the frame of the RenderTarget.
-    /// 
-    /// If this is target is a surface and the frame texture was already retrieved from the
-    /// swap chain, a [`wgpu::SurfaceError`] error will be returned.
-    pub fn create_frame(&self) -> Frame {
-        let texture = self.frame_texture()
-            .expect("failed to create frame texture"); // TODO: should be returned to the user
-        let size = self.size();
-
-        Frame {
-            size,
-            texture,
-        }
-    }
 }
 
 pub enum FrameTexture {
@@ -111,12 +96,10 @@ pub enum FrameTexture {
     Texture(Arc<wgpu::Texture>),
 }
 
-/// Represents the current frame that is being rendered to.
+#[allow(dead_code)]
-//#[allow(dead_code)]
 pub struct Frame {
-    /* pub(crate) device: Arc<wgpu::Device>,
+    pub(crate) device: Arc<wgpu::Device>,
-    pub(crate) queue: Arc<wgpu::Queue>, */
+    pub(crate) queue: Arc<wgpu::Queue>,
-    pub(crate) size: math::UVec2,
     pub(crate) texture: FrameTexture,
 }
 
@@ -137,178 +120,4 @@ impl Frame {
             FrameTexture::Texture(_) => {},
         }
     }
-
-    /// The size of the 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<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,7 +1,5 @@
-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;
@@ -9,7 +7,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, ViewTarget};
+use crate::render::graph::{BasePass, BasePassLabel, BasePassSlots, LightBasePass, LightBasePassLabel, LightCullComputePass, LightCullComputePassLabel, MeshPass, MeshesPassLabel, PresentPass, PresentPassLabel, RenderGraphLabelValue, RenderTarget, SubGraphNode, TintPass, TintPassLabel, TintPassSlots};
 
 use super::graph::RenderGraph;
 use super::{resource::RenderPipeline, render_job::RenderJob};
@@ -116,7 +114,7 @@ impl BasicRenderer {
             .find(|f| f.describe().srgb)
             .unwrap_or(surface_caps.formats[0]);
         let config = wgpu::SurfaceConfiguration {
-            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_DST,
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
             format: surface_format,
             width: size.width,
             height: size.height,
@@ -129,16 +127,35 @@ 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 mut main_graph = RenderGraph::new(device.clone(), queue.clone(), view_target.clone());
+        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());
 
         debug!("Adding base pass");
-        main_graph.add_node(BasePassLabel, BasePass::new());
+        main_graph.add_node(BasePassLabel, BasePass::new(surface_target));
 
         {
-            let mut forward_plus_graph = RenderGraph::new(device.clone(), queue.clone(), view_target.clone());
+            let mut forward_plus_graph = RenderGraph::new(device.clone(), queue.clone());
 
             debug!("Adding light base pass");
             forward_plus_graph.add_node(LightBasePassLabel, LightBasePass::new());
@@ -154,8 +171,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::WindowTextureView),
-                    RenderGraphLabelValue::from(BasePassSlots::MainRenderTarget), */
+                    RenderGraphLabelValue::from(BasePassSlots::MainRenderTarget),
                     RenderGraphLabelValue::from(BasePassSlots::DepthTexture),
                     RenderGraphLabelValue::from(BasePassSlots::DepthTextureView),
                     RenderGraphLabelValue::from(BasePassSlots::Camera),
@@ -164,12 +181,12 @@ impl BasicRenderer {
             ));
         }
 
-        //let present_pass_label = PresentPassLabel::new(BasePassSlots::Frame);//TintPassSlots::Frame);
+        let present_pass_label = PresentPassLabel::new(BasePassSlots::Frame);//TintPassSlots::Frame);
-        let p = PresentPass::default();
+        let p = PresentPass::from_node_label(present_pass_label.clone());
-        main_graph.add_node(PresentPassLabel, p);
+        main_graph.add_node(p.label.clone(), p);
 
         main_graph.add_edge(BasePassLabel, TestSubGraphLabel);
-        main_graph.add_edge(TestSubGraphLabel, PresentPassLabel);
+        main_graph.add_edge(TestSubGraphLabel, present_pass_label);
 
         /* debug!("Adding base pass");
         g.add_node(BasePassLabel, BasePass::new(surface_target));
@@ -242,10 +259,9 @@ 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); */
@@ -253,8 +269,6 @@ 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);
-
-            
         }
     }
 

lyra-game/src/render/shaders/tint.wgsl

@@ -1,31 +0,0 @@
-@group(0) @binding(0)
-var t_screen: texture_2d<f32>;
-@group(0) @binding(1)
-var s_screen: sampler;
-
-struct VertexOutput {
-    @builtin(position) clip_position: vec4<f32>,
-    @location(0) tex_coords: vec2<f32>,
-}
-
-@vertex
-fn vs_main(
-    @builtin(vertex_index) vertex_index: u32,
-) -> VertexOutput {
-    
-    const vertices = array<vec4<f32>, 4>(vec4<f32>(-1.0, -1.0, 0.0, 1.0), vec4<f32>(1.0, -1.0, 0.0, 1.0), vec4<f32>(-1.0, 1.0, 0.0, 1.0), vec4<f32>(1.0, 1.0, 0.0, 1.0));
-    const tex_coords = array<vec2<f32>, 4>(vec2<f32>(0.0, 0.0), vec2<f32>(1.0, 0.0), vec2<f32>(0.0, 1.0), vec2<f32>(1.0, 1.0));
-    
-    var out: VertexOutput;
-    out.clip_position = vertices[vertex_index];
-    out.tex_coords = tex_coords[vertex_index];
-
-    return out;
-}
-
-@fragment
-fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
-    let rgb: vec3<f32> = textureSample(t_screen, s_screen, in.tex_coords).xyz;
-    rgb *= vec3<f32>(0.8);
-    return vec4<f32>(rgb, 1.0);
-}