feat(render): draw passes

19 files changed, 1003 insertions, 626 deletions

diff --git a/stockton-render/src/draw/buffers/mod.rs b/stockton-render/src/draw/buffers/mod.rs
index 5093872..dc7df65 100644
--- a/stockton-render/src/draw/buffers/mod.rs
+++ b/stockton-render/src/draw/buffers/mod.rs
@@ -11,9 +11,9 @@ use hal::{
     MemoryTypeId,
 };
 
-mod dedicated_image;
-mod draw_buffers;
-mod staged;
+pub mod dedicated_image;
+pub mod draw_buffers;
+pub mod staged;
 
 pub use dedicated_image::DedicatedLoadedImage;
 pub use draw_buffers::DrawBuffers;
@@ -58,11 +58,6 @@ 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>;
+    /// Record the command(s) required to commit changes to this buffer to the given command buffer.
+    fn record_commit_cmds<'a>(&'a mut self, cmd_buffer: &mut CommandBufferT) -> Result<()>;
 }
diff --git a/stockton-render/src/draw/buffers/staged.rs b/stockton-render/src/draw/buffers/staged.rs
index f92c41d..71b5204 100644
--- a/stockton-render/src/draw/buffers/staged.rs
+++ b/stockton-render/src/draw/buffers/staged.rs
@@ -1,20 +1,19 @@
 //! A buffer that can be written to by the CPU using staging memory
 
 use super::{create_buffer, ModifiableBuffer};
-use crate::{error::EnvironmentError, types::*};
+use crate::types::*;
 
 use core::mem::{size_of, ManuallyDrop};
 use std::{
     convert::TryInto,
-    iter::{empty, once},
     ops::{Index, IndexMut},
 };
 
 use anyhow::{Context, Result};
 use hal::{
     buffer::Usage,
-    memory::{Properties, Segment, SparseFlags},
-    MemoryTypeId,
+    command::BufferCopy,
+    memory::{Properties, Segment},
 };
 
 /// A GPU buffer that is written to using a staging buffer
@@ -34,9 +33,6 @@ pub struct StagedBuffer<'a, T: Sized> {
     /// Where staged buffer is mapped in CPU memory
     staged_mapped_memory: &'a mut [T],
 
-    /// If staged memory has been changed since last `commit`
-    staged_is_dirty: bool,
-
     /// The highest index in the buffer that's been written to.
     pub highest_used: usize,
 }
@@ -88,7 +84,6 @@ impl<'a, T: Sized> StagedBuffer<'a, T> {
             buffer: ManuallyDrop::new(buffer),
             memory: ManuallyDrop::new(memory),
             staged_mapped_memory,
-            staged_is_dirty: false,
             highest_used: 0,
         })
     }
@@ -112,60 +107,20 @@ impl<'a, T: Sized> ModifiableBuffer for StagedBuffer<'a, T> {
         &self.buffer
     }
 
-    fn commit<'b>(
-        &'b mut self,
-        device: &DeviceT,
-        command_queue: &mut QueueT,
-        command_pool: &mut CommandPoolT,
-    ) -> Result<&'b BufferT> {
-        // Only commit if there's changes to commit.
-        if self.staged_is_dirty {
-            // Copy from staged to buffer
-            let buf = unsafe {
-                use hal::command::{BufferCopy, CommandBufferFlags};
-                // Get a command buffer
-                let mut buf = command_pool.allocate_one(hal::command::Level::Primary);
-
-                // Put in our copy command
-                buf.begin_primary(CommandBufferFlags::ONE_TIME_SUBMIT);
-                buf.copy_buffer(
-                    &self.staged_buffer,
-                    &self.buffer,
-                    std::iter::once(BufferCopy {
-                        src: 0,
-                        dst: 0,
-                        size: ((self.highest_used + 1) * size_of::<T>()) as u64,
-                    }),
-                );
-                buf.finish();
-
-                buf
-            };
-
-            // Submit it and wait for completion
-            // TODO: Proper management of transfer operations
-            unsafe {
-                let mut copy_finished = device.create_fence(false)?;
-                command_queue.submit(
-                    once(&buf),
-                    empty::<(&SemaphoreT, hal::pso::PipelineStage)>(),
-                    empty::<&SemaphoreT>(),
-                    Some(&mut copy_finished),
-                );
-
-                device
-                    .wait_for_fence(&copy_finished, core::u64::MAX)
-                    .context("Error waiting for fence")?;
-
-                // Destroy temporary resources
-                device.destroy_fence(copy_finished);
-                command_pool.free(once(buf));
-            }
-
-            self.staged_is_dirty = false;
+    fn record_commit_cmds(&mut self, buf: &mut CommandBufferT) -> Result<()> {
+        unsafe {
+            buf.copy_buffer(
+                &self.staged_buffer,
+                &self.buffer,
+                std::iter::once(BufferCopy {
+                    src: 0,
+                    dst: 0,
+                    size: ((self.highest_used + 1) * size_of::<T>()) as u64,
+                }),
+            );
         }
 
-        Ok(&self.buffer)
+        Ok(())
     }
 }
 
@@ -179,7 +134,6 @@ impl<'a, T: Sized> Index<usize> for StagedBuffer<'a, T> {
 
 impl<'a, T: Sized> IndexMut<usize> for StagedBuffer<'a, T> {
     fn index_mut(&mut self, index: usize) -> &mut Self::Output {
-        self.staged_is_dirty = true;
         if index > self.highest_used {
             self.highest_used = index;
         }
diff --git a/stockton-render/src/draw/builders/mod.rs b/stockton-render/src/draw/builders/mod.rs
new file mode 100644
index 0000000..002c09f
--- /dev/null
+++ b/stockton-render/src/draw/builders/mod.rs
@@ -0,0 +1,3 @@
+pub mod pipeline;
+pub mod renderpass;
+pub mod shader;
diff --git a/stockton-render/src/draw/builders/pipeline.rs b/stockton-render/src/draw/builders/pipeline.rs
new file mode 100644
index 0000000..cdd9736
--- /dev/null
+++ b/stockton-render/src/draw/builders/pipeline.rs
@@ -0,0 +1,276 @@
+use super::{renderpass::RenderpassSpec, shader::ShaderDesc};
+use crate::{draw::target::SwapchainProperties, error::EnvironmentError, types::*};
+
+use std::{mem::ManuallyDrop, ops::Range};
+
+use anyhow::{Context, Result};
+use hal::{
+    format::Format,
+    pso::{
+        AttributeDesc, BakedStates, BasePipeline, BlendDesc, BufferIndex, DepthStencilDesc,
+        ElemStride, Element, GraphicsPipelineDesc, InputAssemblerDesc, PipelineCreationFlags,
+        PrimitiveAssemblerDesc, Rasterizer, Rect, ShaderStageFlags, VertexBufferDesc,
+        VertexInputRate, Viewport,
+    },
+};
+use shaderc::Compiler;
+
+pub struct VertexBufferSpec {
+    pub attributes: Vec<Format>,
+    pub rate: VertexInputRate,
+}
+
+impl VertexBufferSpec {
+    pub fn as_attribute_desc(&self, binding: BufferIndex) -> Vec<AttributeDesc> {
+        let mut v = Vec::with_capacity(self.attributes.len());
+        let mut offset = 0;
+        for (idx, format) in self.attributes.iter().enumerate() {
+            v.push(AttributeDesc {
+                location: idx as u32,
+                binding,
+                element: Element {
+                    offset,
+                    format: *format,
+                },
+            });
+            offset += get_size(*format);
+        }
+
+        v
+    }
+    pub fn stride(&self) -> ElemStride {
+        self.attributes.iter().fold(0, |x, f| x + get_size(*f))
+    }
+}
+
+fn get_size(f: Format) -> u32 {
+    match f {
+        Format::Rgb32Sfloat => 4 * 3,
+        Format::R32Sint => 4,
+        Format::Rg32Sfloat => 4 * 2,
+        _ => unimplemented!("dont know size of format {:?}", f),
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct VertexPrimitiveAssemblerSpec {
+    buffers: Vec<VertexBufferDesc>,
+    attributes: Vec<AttributeDesc>,
+    input_assembler: InputAssemblerDesc,
+}
+
+impl VertexPrimitiveAssemblerSpec {
+    pub fn with_buffer(&mut self, bd: VertexBufferSpec) -> &mut Self {
+        let idx = self.buffers.len() as u32;
+        self.buffers.push(VertexBufferDesc {
+            binding: idx,
+            stride: bd.stride(),
+            rate: bd.rate,
+        });
+
+        self.attributes.extend(bd.as_attribute_desc(idx));
+
+        self
+    }
+
+    pub fn with_buffers(iad: InputAssemblerDesc, mut bds: Vec<VertexBufferSpec>) -> Self {
+        let mut this = VertexPrimitiveAssemblerSpec {
+            buffers: vec![],
+            attributes: vec![],
+            input_assembler: iad,
+        };
+
+        for bd in bds.drain(..) {
+            this.with_buffer(bd);
+        }
+
+        this
+    }
+}
+
+#[derive(Builder, Debug)]
+#[builder(public)]
+pub struct PipelineSpec {
+    rasterizer: Rasterizer,
+    depth_stencil: DepthStencilDesc,
+    blender: BlendDesc,
+    primitive_assembler: VertexPrimitiveAssemblerSpec,
+
+    shader_vertex: ShaderDesc,
+    #[builder(setter(strip_option))]
+    shader_fragment: Option<ShaderDesc>,
+    #[builder(setter(strip_option), default)]
+    shader_geom: Option<ShaderDesc>,
+    #[builder(setter(strip_option), default)]
+    shader_tesselation: Option<(ShaderDesc, ShaderDesc)>,
+
+    push_constants: Vec<(ShaderStageFlags, Range<u32>)>,
+
+    renderpass: RenderpassSpec,
+}
+
+impl PipelineSpec {
+    pub fn build<'b, T: Iterator<Item = &'b DescriptorSetLayoutT> + std::fmt::Debug>(
+        self,
+        device: &mut DeviceT,
+        extent: hal::image::Extent,
+        _swapchain_properties: &SwapchainProperties,
+        set_layouts: T,
+    ) -> Result<CompletePipeline> {
+        // Renderpass
+        let renderpass = self.renderpass.build_renderpass(device)?;
+
+        // Subpass
+        let subpass = hal::pass::Subpass {
+            index: 0,
+            main_pass: &renderpass,
+        };
+
+        let mut compiler = Compiler::new().ok_or(EnvironmentError::NoShaderC)?;
+        let (vs_module, fs_module, gm_module, ts_module) = {
+            (
+                self.shader_vertex.compile(&mut compiler, device)?,
+                self.shader_fragment
+                    .as_ref()
+                    .map(|x| x.compile(&mut compiler, device))
+                    .transpose()?,
+                self.shader_geom
+                    .as_ref()
+                    .map(|x| x.compile(&mut compiler, device))
+                    .transpose()?,
+                self.shader_tesselation
+                    .as_ref()
+                    .map::<Result<_>, _>(|(a, b)| {
+                        Ok((
+                            a.compile(&mut compiler, device)?,
+                            b.compile(&mut compiler, device)?,
+                        ))
+                    })
+                    .transpose()?,
+            )
+        };
+
+        // Safety: *_module is always populated when shader_* is, so this is safe
+        let (vs_entry, fs_entry, gm_entry, ts_entry) = (
+            self.shader_vertex.as_entry(&vs_module),
+            self.shader_fragment
+                .as_ref()
+                .map(|x| x.as_entry(fs_module.as_ref().unwrap())),
+            self.shader_geom
+                .as_ref()
+                .map(|x| x.as_entry(gm_module.as_ref().unwrap())),
+            self.shader_tesselation.as_ref().map(|(a, b)| {
+                (
+                    a.as_entry(&ts_module.as_ref().unwrap().0),
+                    b.as_entry(&ts_module.as_ref().unwrap().1),
+                )
+            }),
+        );
+
+        // Pipeline layout
+        let layout = unsafe {
+            device.create_pipeline_layout(set_layouts.into_iter(), self.push_constants.into_iter())
+        }
+        .context("Error creating pipeline layout")?;
+
+        // Baked states
+        let baked_states = BakedStates {
+            viewport: Some(Viewport {
+                rect: extent.rect(),
+                depth: (0.0..1.0),
+            }),
+            scissor: Some(extent.rect()),
+            blend_constants: None,
+            depth_bounds: None,
+        };
+
+        // Primitive assembler
+        let primitive_assembler = PrimitiveAssemblerDesc::Vertex {
+            buffers: self.primitive_assembler.buffers.as_slice(),
+            attributes: self.primitive_assembler.attributes.as_slice(),
+            input_assembler: self.primitive_assembler.input_assembler,
+            vertex: vs_entry,
+            tessellation: ts_entry,
+            geometry: gm_entry,
+        };
+
+        // Pipeline description
+        let pipeline_desc = GraphicsPipelineDesc {
+            label: Some("stockton"),
+            rasterizer: self.rasterizer,
+            fragment: fs_entry,
+            blender: self.blender,
+            depth_stencil: self.depth_stencil,
+            multisampling: None,
+            baked_states,
+            layout: &layout,
+            subpass,
+            flags: PipelineCreationFlags::empty(),
+            parent: BasePipeline::None,
+            primitive_assembler,
+        };
+
+        // Pipeline
+        let pipeline = unsafe { device.create_graphics_pipeline(&pipeline_desc, None) }
+            .context("Error creating graphics pipeline")?;
+
+        Ok(CompletePipeline {
+            renderpass: ManuallyDrop::new(renderpass),
+            pipeline_layout: ManuallyDrop::new(layout),
+            pipeline: ManuallyDrop::new(pipeline),
+            vs_module: ManuallyDrop::new(vs_module),
+            fs_module,
+            gm_module,
+            ts_module,
+            render_area: extent.rect(),
+        })
+    }
+}
+
+pub struct CompletePipeline {
+    /// Our main render pass
+    pub(crate) renderpass: ManuallyDrop<RenderPassT>,
+
+    /// The layout of our main graphics pipeline
+    pub(crate) pipeline_layout: ManuallyDrop<PipelineLayoutT>,
+
+    /// Our main graphics pipeline
+    pub(crate) pipeline: ManuallyDrop<GraphicsPipelineT>,
+
+    /// The vertex shader module
+    pub(crate) vs_module: ManuallyDrop<ShaderModuleT>,
+
+    /// The fragment shader module
+    pub(crate) fs_module: Option<ShaderModuleT>,
+    pub(crate) gm_module: Option<ShaderModuleT>,
+    pub(crate) ts_module: Option<(ShaderModuleT, ShaderModuleT)>,
+
+    pub(crate) render_area: Rect,
+}
+
+impl CompletePipeline {
+    /// Deactivate vulkan resources. Use before dropping
+    pub fn deactivate(mut self, device: &mut DeviceT) {
+        unsafe {
+            use core::ptr::read;
+
+            device.destroy_render_pass(ManuallyDrop::into_inner(read(&self.renderpass)));
+
+            device.destroy_shader_module(ManuallyDrop::into_inner(read(&self.vs_module)));
+            if let Some(x) = self.fs_module.take() {
+                device.destroy_shader_module(x)
+            }
+            if let Some(x) = self.gm_module.take() {
+                device.destroy_shader_module(x)
+            }
+            self.ts_module.take().map(|(a, b)| {
+                device.destroy_shader_module(a);
+                device.destroy_shader_module(b);
+            });
+
+            device.destroy_graphics_pipeline(ManuallyDrop::into_inner(read(&self.pipeline)));
+
+            device.destroy_pipeline_layout(ManuallyDrop::into_inner(read(&self.pipeline_layout)));
+        }
+    }
+}
diff --git a/stockton-render/src/draw/builders/renderpass.rs b/stockton-render/src/draw/builders/renderpass.rs
new file mode 100644
index 0000000..43f0eb2
--- /dev/null
+++ b/stockton-render/src/draw/builders/renderpass.rs
@@ -0,0 +1,75 @@
+use crate::types::*;
+
+use std::iter::{empty, once};
+
+use anyhow::Result;
+use hal::pass::{Attachment, AttachmentRef, SubpassDesc};
+
+#[derive(Debug, Clone)]
+pub struct RenderpassSpec {
+    pub colors: Vec<Attachment>,
+    pub depth: Option<Attachment>,
+    pub inputs: Vec<Attachment>,
+    pub resolves: Vec<Attachment>,
+    pub preserves: Vec<Attachment>,
+}
+
+impl RenderpassSpec {
+    pub fn build_renderpass(self, device: &mut DeviceT) -> Result<RenderPassT> {
+        let mut next_offset = 0;
+
+        let colors: Vec<AttachmentRef> = self
+            .colors
+            .iter()
+            .enumerate()
+            .map(|(i, a)| (next_offset + i, a.layouts.end))
+            .collect();
+        next_offset = colors.len();
+
+        let depth_stencil = self.depth.as_ref().map(|x| (next_offset, x.layouts.end));
+        if depth_stencil.is_some() {
+            next_offset += 1;
+        }
+
+        let inputs: Vec<AttachmentRef> = self
+            .inputs
+            .iter()
+            .enumerate()
+            .map(|(i, a)| (next_offset + i, a.layouts.end))
+            .collect();
+        next_offset += inputs.len();
+
+        let resolves: Vec<AttachmentRef> = self
+            .resolves
+            .iter()
+            .enumerate()
+            .map(|(i, a)| (next_offset + i, a.layouts.end))
+            .collect();
+        next_offset += resolves.len();
+
+        let preserves: Vec<usize> = self
+            .preserves
+            .iter()
+            .enumerate()
+            .map(|(i, _a)| next_offset + i)
+            .collect();
+
+        let sp_desc = SubpassDesc {
+            colors: colors.as_slice(),
+            depth_stencil: depth_stencil.as_ref(),
+            inputs: inputs.as_slice(),
+            resolves: resolves.as_slice(),
+            preserves: preserves.as_slice(),
+        };
+
+        let all_attachments = self
+            .colors
+            .into_iter()
+            .chain(self.depth.into_iter())
+            .chain(self.inputs.into_iter())
+            .chain(self.resolves.into_iter())
+            .chain(self.preserves.into_iter());
+
+        Ok(unsafe { device.create_render_pass(all_attachments, once(sp_desc), empty())? })
+    }
+}
diff --git a/stockton-render/src/draw/builders/shader.rs b/stockton-render/src/draw/builders/shader.rs
new file mode 100644
index 0000000..fde185d
--- /dev/null
+++ b/stockton-render/src/draw/builders/shader.rs
@@ -0,0 +1,35 @@
+use crate::types::*;
+
+use anyhow::{Context, Result};
+use hal::pso::Specialization;
+use shaderc::{Compiler, ShaderKind};
+
+#[derive(Debug, Clone)]
+pub struct ShaderDesc {
+    pub source: String,
+    pub entry: String,
+    pub kind: ShaderKind,
+}
+
+impl ShaderDesc {
+    pub fn compile(&self, compiler: &mut Compiler, device: &mut DeviceT) -> Result<ShaderModuleT> {
+        let artifact = compiler
+            .compile_into_spirv(&self.source, self.kind, "shader", &self.entry, None)
+            .context("Shader compilation failed")?;
+
+        // Make into shader module
+        Ok(unsafe {
+            device
+                .create_shader_module(artifact.as_binary())
+                .context("Shader module creation failed")?
+        })
+    }
+
+    pub fn as_entry<'a>(&'a self, module: &'a ShaderModuleT) -> EntryPoint<'a> {
+        EntryPoint {
+            entry: &self.entry,
+            module,
+            specialization: Specialization::default(),
+        }
+    }
+}
diff --git a/stockton-render/src/draw/camera.rs b/stockton-render/src/draw/camera.rs
index 421b661..495e6a2 100644
--- a/stockton-render/src/draw/camera.rs
+++ b/stockton-render/src/draw/camera.rs
@@ -1,14 +1,15 @@
 //! Things related to converting 3D world space to 2D screen space
 
 use legion::maybe_changed;
+use na::{look_at_lh, perspective_lh_zo};
+use stockton_types::{
+    components::{CameraSettings, CameraVPMatrix, Transform},
+    Vector3,
+};
+
+
 
-use nalgebra_glm::look_at_lh;
-use nalgebra_glm::perspective_lh_zo;
-use stockton_levels::prelude::MinRenderFeatures;
 
-use crate::Renderer;
-use stockton_types::components::{CameraSettings, Transform};
-use stockton_types::Vector3;
 
 fn euler_to_direction(euler: &Vector3) -> Vector3 {
     let pitch = euler.x;
@@ -22,35 +23,34 @@ 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(
+    transform: &Transform,
+    settings: &CameraSettings,
+    matrix: &mut CameraVPMatrix,
+    #[state] ratio: &mut 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
+    matrix.vp_matrix = projection_matrix * view_matrix;
+}
diff --git a/stockton-render/src/draw/context.rs b/stockton-render/src/draw/context.rs
index 1a690fe..65dcff6 100644
--- a/stockton-render/src/draw/context.rs
+++ b/stockton-render/src/draw/context.rs
@@ -10,20 +10,19 @@ use std::{
 use anyhow::{Context, Result};
 use hal::pool::CommandPoolCreateFlags;
 use log::debug;
-use na::Mat4;
+
 use winit::window::Window;
 
 use super::{
-    draw_passes::{DrawPass, IntoDrawPass, LevelDrawPass},
+    draw_passes::{DrawPass, IntoDrawPass},
     queue_negotiator::{DrawQueue, QueueNegotiator},
     target::{SwapchainProperties, TargetChain},
 };
 use crate::{
     error::{EnvironmentError, LockPoisoned},
     types::*,
-    window::UiState,
 };
-use stockton_levels::prelude::*;
+
 use stockton_types::Session;
 
 /// Contains all the hal related stuff.
@@ -53,17 +52,15 @@ pub struct RenderingContext<DP> {
     /// Deals with drawing logic, and holds any data required for drawing.
     draw_pass: ManuallyDrop<DP>,
 
-    /// View projection matrix
-    pub(crate) vp_matrix: Mat4,
-
     pub(crate) pixels_per_point: f32,
 }
 
 impl<DP: DrawPass> RenderingContext<DP> {
     /// Create a new RenderingContext for the given window.
-    pub fn new<ILDP: IntoDrawPass<DP>>(
+    pub fn new<IDP: IntoDrawPass<DP>>(
         window: &Window,
-        idp: ILDP,
+        session: &Session,
+        idp: IDP,
     ) -> Result<Self> {
         // Create surface
         let (instance, surface, mut adapters) = unsafe {
@@ -97,7 +94,7 @@ impl<DP: DrawPass> RenderingContext<DP> {
 
             // Auxiliary queues for DP
             queue_families_specs.extend(
-                DP::find_aux_queues(&adapter, &mut qn)
+                IDP::find_aux_queues(&adapter, &mut qn)
                     .context("Level pass couldn't populate queue negotiator")?,
             );
 
@@ -105,7 +102,7 @@ impl<DP: DrawPass> RenderingContext<DP> {
         };
 
         // Device & Queue groups
-        let (device_lock, mut queue_groups) = {
+        let (device_lock, queue_groups) = {
             // TODO: This sucks, but hal is restrictive on how we can pass this specific argument.
             let queue_families_specs_real: Vec<_> = queue_families_specs
                 .iter()
@@ -122,16 +119,22 @@ impl<DP: DrawPass> RenderingContext<DP> {
             (Arc::new(RwLock::new(gpu.device)), gpu.queue_groups)
         };
 
+        queue_negotiator.set_queue_groups(queue_groups);
+
         // Figure out what our swapchain will look like
         let swapchain_properties = SwapchainProperties::find_best(&adapter, &surface)
             .context("Error getting properties for swapchain")?;
 
         // Draw pass
-        let dp = idp.init(
-            device_lock.clone(),
-            &mut queue_negotiator,
-            &swapchain_properties,
-        )?;
+        let dp = idp
+            .init(
+                session,
+                &adapter,
+                device_lock.clone(),
+                &mut queue_negotiator,
+                &swapchain_properties,
+            )
+            .context("Error initialising draw pass")?;
 
         // Lock device
         let mut device = device_lock
@@ -172,7 +175,7 @@ impl<DP: DrawPass> RenderingContext<DP> {
             adapter,
 
             queue: queue_negotiator
-                .get_queue::<DrawQueue>(&mut queue_groups)
+                .get_queue::<DrawQueue>()
                 .ok_or(EnvironmentError::NoQueues)
                 .context("Error getting draw queue")?,
 
@@ -180,8 +183,6 @@ impl<DP: DrawPass> RenderingContext<DP> {
             target_chain: ManuallyDrop::new(target_chain),
             cmd_pool: ManuallyDrop::new(cmd_pool),
 
-            vp_matrix: Mat4::identity(),
-
             // pixels_per_point: window.scale_factor() as f32,
             pixels_per_point: window.scale_factor() as f32,
         })
@@ -237,7 +238,7 @@ impl<DP: DrawPass> RenderingContext<DP> {
 
         // Level draw pass
         self.target_chain
-            .do_draw_with(&mut device, &mut queue, &*self.draw_pass, session)
+            .do_draw_with(&mut device, &mut queue, &mut *self.draw_pass, session)
             .context("Error preparing next target")?;
 
         Ok(())
diff --git a/stockton-render/src/draw/draw_passes/cons.rs b/stockton-render/src/draw/draw_passes/cons.rs
index 76e2f32..8f912ec 100644
--- a/stockton-render/src/draw/draw_passes/cons.rs
+++ b/stockton-render/src/draw/draw_passes/cons.rs
@@ -1,8 +1,10 @@
 //! 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 std::sync::{Arc, RwLock};
+
 use super::DrawPass;
-use crate::{draw::queue_negotiator::QueueNegotiator, types::*};
+use crate::types::*;
 use stockton_types::Session;
 
 use anyhow::Result;
@@ -14,23 +16,21 @@ pub struct ConsDrawPass<A: DrawPass, B: DrawPass> {
 }
 
 impl<A: DrawPass, B: DrawPass> DrawPass for ConsDrawPass<A, B> {
-    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)?;
+    fn queue_draw(
+        &mut self,
+        session: &Session,
+        img_view: &ImageViewT,
+        cmd_buffer: &mut CommandBufferT,
+    ) -> Result<()> {
+        self.a.queue_draw(session, img_view, cmd_buffer)?;
+        self.b.queue_draw(session, img_view, cmd_buffer)?;
 
         Ok(())
     }
 
-    fn find_aux_queues<'a>(
-        adapter: &'a Adapter,
-        queue_negotiator: &mut QueueNegotiator,
-    ) -> Result<Vec<(&'a QueueFamilyT, Vec<f32>)>> {
-        let mut vec = Vec::new();
-
-        vec.extend(A::find_aux_queues(adapter, queue_negotiator)?);
-        vec.extend(B::find_aux_queues(adapter, queue_negotiator)?);
-
-        Ok(vec)
+    fn deactivate(self, device: &mut Arc<RwLock<DeviceT>>) -> Result<()> {
+        self.a.deactivate(device)?;
+        self.b.deactivate(device)
     }
 }
 
@@ -38,15 +38,16 @@ impl<A: DrawPass, B: DrawPass> DrawPass for ConsDrawPass<A, B> {
 pub struct NilDrawPass;
 
 impl DrawPass for NilDrawPass {
-
-    fn queue_draw(&self, _input: &Session, _cmd_buffer: &mut CommandBufferT) -> Result<()> {
+    fn queue_draw(
+        &mut self,
+        _input: &Session,
+        _img_view: &ImageViewT,
+        _cmd_buffer: &mut CommandBufferT,
+    ) -> Result<()> {
         Ok(())
     }
 
-    fn find_aux_queues<'a>(
-        _adapter: &'a Adapter,
-        _queue_negotiator: &mut QueueNegotiator,
-    ) -> Result<Vec<(&'a QueueFamilyT, Vec<f32>)>> {
-        Ok(vec![])
+    fn deactivate(self, _device: &mut Arc<RwLock<DeviceT>>) -> Result<()> {
+        Ok(())
     }
-}
\ 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 b968a1a..3a4e748 100644
--- a/stockton-render/src/draw/draw_passes/level.rs
+++ b/stockton-render/src/draw/draw_passes/level.rs
@@ -2,18 +2,57 @@
 
 use super::{DrawPass, IntoDrawPass};
 use crate::{
-    draw::{queue_negotiator::QueueNegotiator, target::SwapchainProperties, texture::TextureRepo},
-    error::EnvironmentError,
+    draw::{
+        buffers::{
+            draw_buffers::{DrawBuffers, INITIAL_INDEX_SIZE, INITIAL_VERT_SIZE},
+            DedicatedLoadedImage, ModifiableBuffer,
+        },
+        builders::{
+            pipeline::{
+                CompletePipeline, PipelineSpecBuilder, VertexBufferSpec,
+                VertexPrimitiveAssemblerSpec,
+            },
+            renderpass::RenderpassSpec,
+            shader::ShaderDesc,
+        },
+        queue_negotiator::QueueNegotiator,
+        target::SwapchainProperties,
+        texture::{resolver::FsResolver, TexLoadQueue, TextureLoadConfig, TextureRepo},
+    },
+    error::{EnvironmentError, LevelError, LockPoisoned},
     types::*,
 };
-use stockton_levels::features::MinRenderFeatures;
-use stockton_types::*;
+use hal::{
+    buffer::SubRange,
+    command::{ClearColor, ClearDepthStencil, ClearValue, RenderAttachmentInfo, SubpassContents},
+    format::{Aspects, Format},
+    image::{
+        Filter, FramebufferAttachment, Layout, SubresourceRange, Usage, ViewCapabilities, WrapMode,
+    },
+    pass::{Attachment, AttachmentLoadOp, AttachmentOps, AttachmentStoreOp},
+    pso::{
+        BlendDesc, BlendOp, BlendState, ColorBlendDesc, ColorMask, Comparison, DepthStencilDesc,
+        DepthTest, Face, Factor, FrontFace, InputAssemblerDesc, LogicOp, PolygonMode, Primitive,
+        Rasterizer, ShaderStageFlags, State, VertexInputRate,
+    },
+};
+use legion::{Entity, IntoQuery};
+use shaderc::ShaderKind;
+use stockton_levels::{
+    features::MinRenderFeatures,
+    parts::{data::Geometry, IsFace},
+};
+use stockton_types::{
+    components::{CameraSettings, CameraVPMatrix, Transform},
+    *,
+};
 
 use std::{
     array::IntoIter,
+    convert::TryInto,
     iter::{empty, once},
     marker::PhantomData,
-    mem::{size_of, ManuallyDrop},
+    path::Path,
     sync::{Arc, RwLock},
 };
 
@@ -24,435 +63,398 @@ use anyhow::{Context, Result};
 struct UvPoint(pub Vector3, pub i32, pub Vector2);
 
 /// Draw a level
-pub struct LevelDrawPass<M: MinRenderFeatures> {
+pub struct LevelDrawPass<'a, M> {
     pipeline: CompletePipeline,
     repo: TextureRepo,
+    active_camera: Entity,
+    draw_buffers: DrawBuffers<'a, UvPoint>,
+
+    framebuffers: Vec<FramebufferT>,
+    depth_buffers: Vec<DedicatedLoadedImage>,
+    next_resources: usize,
+
     _d: PhantomData<M>,
 }
 
-impl<M: MinRenderFeatures> DrawPass for LevelDrawPass<M> {
+impl<'a, M> DrawPass for LevelDrawPass<'a, M>
+where
+    M: for<'b> MinRenderFeatures<'b> + 'static,
+{
     fn queue_draw(
-        &self,
-        _input: &Session,
-        _cmd_buffer: &mut crate::types::CommandBufferT,
+        &mut self,
+        session: &Session,
+        img_view: &ImageViewT,
+        cmd_buffer: &mut crate::types::CommandBufferT,
     ) -> anyhow::Result<()> {
-        todo!()
-        // // Get visible faces
-        // // let faces = get_visible_faces(
-        // //     pos,
-        // //     &*self
-        // //         .context
-        // //         .map
-        // //         .read()
-        // //         .map_err(|_| LockPoisoned::Map)
-        // //         .context("Error getting read lock on map")?,
-        // // );
-        // let faces: Vec<u32> = {
-        //     let map = &*self
-        //         .context
-        //         .map
-        //         .read()
-        //         .map_err(|_| LockPoisoned::Map)
-        //         .context("Error getting read lock on map")?;
-
-        //     map.iter_faces().map(|x| x.index(map)).collect()
-        // };
-
-        // // Iterate over faces, copying them in and drawing groups that use the same texture chunk all at once.
-        // let mut current_chunk = file
-        //     .get_face(0)
-        //     .ok_or(LevelError::BadReference)?
-        //     .texture_idx(file) as usize
-        //     / 8;
-        // let mut chunk_start = 0;
-
-        // let mut curr_vert_idx: usize = 0;
-        // let mut curr_idx_idx: usize = 0;
-
-        // for face in faces.iter().map(|idx| file.get_face(*idx)) {
-        //     if let Some(face) = face {
-        //         if current_chunk != face.texture_idx(file) as usize / 8 {
-        //             // Last index was last of group, so draw it all if textures are loaded.
-        //             draw_or_queue(
-        //                 current_chunk,
-        //                 self.tex_repo,
-        //                 cmd_buffer,
-        //                 self.pipeline.pipeline_layout,
-        //                 chunk_start as u32,
-        //                 curr_idx_idx as u32,
-        //             )?;
-
-        //             // Next group of same-chunked faces starts here.
-        //             chunk_start = curr_idx_idx;
-        //             current_chunk = face.texture_idx(file) as usize / 8;
-        //         }
-
-        //         match face.geometry(file) {
-        //             Geometry::Vertices(v1, v2, v3) => {
-        //                 for v in [v1, v2, v3] {
-        //                     let uvp =
-        //                         UvPoint(v.position, face.texture_idx(file).try_into()?, v.tex);
-
-        //                     draw_buffers.vertex_buffer[curr_vert_idx] = uvp;
-        //                     curr_vert_idx += 1;
-        //                 }
-        //                 draw_buffers.index_buffer[curr_idx_idx] = (
-        //                     curr_vert_idx as u16 - 2,
-        //                     curr_vert_idx as u16 - 1,
-        //                     curr_vert_idx as u16,
-        //                 );
-        //                 curr_idx_idx += 1;
-        //             }
-        //         }
-
-        //         if curr_vert_idx >= INITIAL_VERT_SIZE.try_into()?
-        //             || curr_idx_idx >= INITIAL_INDEX_SIZE.try_into()?
-        //         {
-        //             println!("out of vertex buffer space!");
-        //             break;
-        //         }
-        //     } else {
-        //         anyhow::bail!(LevelError::BadReference);
-        //     }
-        // }
-
-        // // Draw the final group of chunks
-        // draw_or_queue(
-        //     current_chunk,
-        //     self.tex_repo,
-        //     cmd_buffer,
-        //     self.pipeline.pipeline_layout,
-        //     chunk_start as u32,
-        //     curr_idx_idx as u32,
-        // )?;
-
-        // Ok(())
-    }
-
-    fn find_aux_queues<'a>(
-        _adapter: &'a Adapter,
-        _queue_negotiator: &mut QueueNegotiator,
-    ) -> Result<Vec<(&'a QueueFamilyT, Vec<f32>)>> {
-        todo!()
-        // queue_negotiator.find(TexLoadQueue)
-    }
-}
-
-impl<M: MinRenderFeatures> IntoDrawPass<LevelDrawPass<M>> for () {
-    fn init(
-        self,
-        _device_lock: Arc<RwLock<DeviceT>>,
-        _queue_negotiator: &mut QueueNegotiator,
-        _swapchain_properties: &SwapchainProperties,
-    ) -> Result<LevelDrawPass<M>> {
-        todo!()
-        // let repo = TextureRepo::new(
-        //     device_lock.clone(),
-        //     queue_negotiator
-        //         .family()
-        //         .ok_or(EnvironmentError::NoQueues)?,
-        // );
-        // let pipeline = {
-        //     let device = device_lock.write().or(Err(LockPoisoned::Device))?;
-        //     CompletePipeline::new(
-        //         device,
-        //         swapchain_properties.extent,
-        //         swapchain_properties,
-        //         std::iter::empty(),
-        //     )?
-        // };
-        // Ok(LevelDrawPass {
-        //     pipeline,
-        //     repo,
-        //     _d: PhantomData,
-        // })
-    }
-}
-
-/// Entry point name for shaders
-const ENTRY_NAME: &str = "main";
-
-/// Source for vertex shader. TODO
-const VERTEX_SOURCE: &str = include_str!("../data/stockton.vert");
+        // We might have loaded more textures
+        self.repo.process_responses();
+
+        // Make sure we update the vertex buffers after they're written to, but before they're read from.
+        self.draw_buffers
+            .vertex_buffer
+            .record_commit_cmds(cmd_buffer)?;
+        self.draw_buffers
+            .index_buffer
+            .record_commit_cmds(cmd_buffer)?;
+
+        // Get level & camera
+        let mut query = <(&Transform, &CameraSettings, &CameraVPMatrix)>::query();
+        let (camera_transform, camera_settings, camera_vp) = query
+            .get(&session.world, self.active_camera)
+            .context("Couldn't find camera components")?;
+        let map_lock: Arc<RwLock<M>> = session.resources.get::<Arc<RwLock<M>>>().unwrap().clone();
+        let map = map_lock.read().map_err(|_| LockPoisoned::Map)?;
+
+        // Get framebuffer and depth buffer
+        let fb = &self.framebuffers[self.next_resources];
+        let db = &self.depth_buffers[self.next_resources];
+        self.next_resources = (self.next_resources + 1) % self.framebuffers.len();
 
-/// Source for fragment shader. TODO
-const FRAGMENT_SOURCE: &str = include_str!("../data/stockton.frag");
-
-/// A complete graphics pipeline and associated resources
-pub struct CompletePipeline {
-    /// Our main render pass
-    pub(crate) renderpass: ManuallyDrop<RenderPassT>,
-
-    /// The layout of our main graphics pipeline
-    pub(crate) pipeline_layout: ManuallyDrop<PipelineLayoutT>,
-
-    /// Our main graphics pipeline
-    pub(crate) pipeline: ManuallyDrop<GraphicsPipelineT>,
-
-    /// The vertex shader module
-    pub(crate) vs_module: ManuallyDrop<ShaderModuleT>,
+        unsafe {
+            cmd_buffer.begin_render_pass(
+                &self.pipeline.renderpass,
+                fb,
+                self.pipeline.render_area,
+                vec![
+                    RenderAttachmentInfo {
+                        image_view: img_view,
+                        clear_value: ClearValue {
+                            color: ClearColor {
+                                float32: [0.0, 0.0, 0.0, 1.0],
+                            },
+                        },
+                    },
+                    RenderAttachmentInfo {
+                        image_view: &*db.image_view,
+                        clear_value: ClearValue {
+                            depth_stencil: ClearDepthStencil {
+                                depth: 1.0,
+                                stencil: 0,
+                            },
+                        },
+                    },
+                ]
+                .into_iter(),
+                SubpassContents::Inline,
+            );
+            cmd_buffer.bind_graphics_pipeline(&self.pipeline.pipeline);
+
+            // VP Matrix
+            let vp = &*(camera_vp.vp_matrix.data.as_slice() as *const [f32] as *const [u32]);
+
+            cmd_buffer.push_graphics_constants(
+                &self.pipeline.pipeline_layout,
+                ShaderStageFlags::VERTEX,
+                0,
+                vp,
+            );
+
+            // Bind buffers
+            cmd_buffer.bind_vertex_buffers(
+                0,
+                once((
+                    self.draw_buffers.vertex_buffer.get_buffer(),
+                    SubRange {
+                        offset: 0,
+                        size: None,
+                    },
+                )),
+            );
+            cmd_buffer.bind_index_buffer(
+                self.draw_buffers.index_buffer.get_buffer(),
+                SubRange {
+                    offset: 0,
+                    size: None,
+                },
+                hal::IndexType::U16,
+            );
+        }
 
-    /// The fragment shader module
-    pub(crate) fs_module: ManuallyDrop<ShaderModuleT>,
-}
+        // Get visible faces
+        let mut faces = map.get_visible(camera_transform, camera_settings);
+
+        // Iterate over faces, copying them in and drawing groups that use the same texture chunk all at once.
+        let face = faces.next();
+        if let Some(face) = face {
+            let mut face = map.get_face(face).ok_or(LevelError::BadReference)?;
+            let mut current_chunk = face.texture_idx(&map) as usize / 8;
+            let mut chunk_start = 0;
+
+            let mut curr_vert_idx: usize = 0;
+            let mut curr_idx_idx: usize = 0;
+            loop {
+                if current_chunk != face.texture_idx(&map) as usize / 8 {
+                    // Last index was last of group, so draw it all if textures are loaded.
+                    draw_or_queue(
+                        current_chunk,
+                        &mut self.repo,
+                        cmd_buffer,
+                        &*self.pipeline.pipeline_layout,
+                        chunk_start as u32,
+                        curr_idx_idx as u32,
+                    )?;
+
+                    // Next group of same-chunked faces starts here.
+                    chunk_start = curr_idx_idx;
+                    current_chunk = face.texture_idx(&map) as usize / 8;
+                }
+
+                match face.geometry(&map) {
+                    Geometry::Vertices(v1, v2, v3) => {
+                        for v in [v1, v2, v3] {
+                            let uvp =
+                                UvPoint(v.position, face.texture_idx(&map).try_into()?, v.tex);
+
+                            self.draw_buffers.vertex_buffer[curr_vert_idx] = uvp;
+                            curr_vert_idx += 1;
+                        }
+                        self.draw_buffers.index_buffer[curr_idx_idx] = (
+                            curr_vert_idx as u16 - 3,
+                            curr_vert_idx as u16 - 2,
+                            curr_vert_idx as u16 - 1,
+                        );
+                        curr_idx_idx += 1;
+                    }
+                }
+
+                if curr_vert_idx >= INITIAL_VERT_SIZE.try_into()?
+                    || curr_idx_idx >= INITIAL_INDEX_SIZE.try_into()?
+                {
+                    println!("out of vertex buffer space!");
+                    break;
+                }
+
+                match faces.next() {
+                    Some(x) => face = map.get_face(x).ok_or(LevelError::BadReference)?,
+                    None => break,
+                };
+            }
 
-impl CompletePipeline {
-    pub fn new<'a, T: Iterator<Item = &'a DescriptorSetLayoutT> + std::fmt::Debug>(
-        device: &mut DeviceT,
-        extent: hal::image::Extent,
-        swapchain_properties: &SwapchainProperties,
-        set_layouts: T,
-    ) -> Result<Self> {
-        use hal::format::Format;
-        use hal::pso::*;
-
-        // Renderpass
-        let renderpass = {
-            use hal::{image::Layout, pass::*};
-
-            let img_attachment = Attachment {
-                format: Some(swapchain_properties.format),
-                samples: 1,
-                ops: AttachmentOps::new(AttachmentLoadOp::Clear, AttachmentStoreOp::Store),
-                stencil_ops: AttachmentOps::new(
-                    AttachmentLoadOp::Clear,
-                    AttachmentStoreOp::DontCare,
-                ),
-                layouts: Layout::Undefined..Layout::ColorAttachmentOptimal,
-            };
+            // Draw the final group of chunks
+            draw_or_queue(
+                current_chunk,
+                &mut self.repo,
+                cmd_buffer,
+                &*self.pipeline.pipeline_layout,
+                chunk_start as u32,
+                curr_idx_idx as u32,
+            )?;
+        }
 
-            let depth_attachment = Attachment {
-                format: Some(swapchain_properties.depth_format),
-                samples: 1,
-                ops: AttachmentOps::new(AttachmentLoadOp::Clear, AttachmentStoreOp::DontCare),
-                stencil_ops: AttachmentOps::new(
-                    AttachmentLoadOp::DontCare,
-                    AttachmentStoreOp::DontCare,
-                ),
-                layouts: Layout::Undefined..Layout::DepthStencilAttachmentOptimal,
-            };
+        unsafe {
+            cmd_buffer.end_render_pass();
+        }
 
-            let subpass = SubpassDesc {
-                colors: &[(0, Layout::ColorAttachmentOptimal)],
-                depth_stencil: Some(&(1, Layout::DepthStencilAttachmentOptimal)),
-                inputs: &[],
-                resolves: &[],
-                preserves: &[],
-            };
+        Ok(())
+    }
 
-            unsafe {
-                device.create_render_pass(
-                    IntoIter::new([img_attachment, depth_attachment]),
-                    once(subpass),
-                    empty(),
-                )
+    fn deactivate(self, device_lock: &mut Arc<RwLock<DeviceT>>) -> Result<()> {
+        unsafe {
+            let mut device = device_lock.write().map_err(|_| LockPoisoned::Device)?;
+            self.pipeline.deactivate(&mut device);
+            self.draw_buffers.deactivate(&mut device);
+            for fb in self.framebuffers.into_iter() {
+                device.destroy_framebuffer(fb);
             }
-            .context("Error creating render pass")?
-        };
-
-        // Subpass
-        let subpass = hal::pass::Subpass {
-            index: 0,
-            main_pass: &renderpass,
-        };
-
-        // Shader modules
-        let (vs_module, fs_module) = {
-            let mut compiler = shaderc::Compiler::new().ok_or(EnvironmentError::NoShaderC)?;
-
-            let vertex_compile_artifact = compiler
-                .compile_into_spirv(
-                    VERTEX_SOURCE,
-                    shaderc::ShaderKind::Vertex,
-                    "vertex.vert",
-                    ENTRY_NAME,
-                    None,
-                )
-                .context("Error compiling vertex shader")?;
-
-            let fragment_compile_artifact = compiler
-                .compile_into_spirv(
-                    FRAGMENT_SOURCE,
-                    shaderc::ShaderKind::Fragment,
-                    "fragment.frag",
-                    ENTRY_NAME,
-                    None,
-                )
-                .context("Error compiling fragment shader")?;
-
-            // Make into shader module
-            unsafe {
-                (
-                    device
-                        .create_shader_module(vertex_compile_artifact.as_binary())
-                        .context("Error creating vertex shader module")?,
-                    device
-                        .create_shader_module(fragment_compile_artifact.as_binary())
-                        .context("Error creating fragment shader module")?,
-                )
+            for db in self.depth_buffers.into_iter() {
+                db.deactivate(&mut device);
             }
-        };
-
-        // Shader entry points (ShaderStage)
-        let (vs_entry, fs_entry) = (
-            EntryPoint::<back::Backend> {
-                entry: ENTRY_NAME,
-                module: &vs_module,
-                specialization: Specialization::default(),
-            },
-            EntryPoint::<back::Backend> {
-                entry: ENTRY_NAME,
-                module: &fs_module,
-                specialization: Specialization::default(),
-            },
-        );
-
-        // Rasterizer
-        let rasterizer = Rasterizer {
-            polygon_mode: PolygonMode::Fill,
-            cull_face: Face::BACK,
-            front_face: FrontFace::CounterClockwise,
-            depth_clamping: false,
-            depth_bias: None,
-            conservative: true,
-            line_width: State::Static(1.0),
-        };
-
-        // Depth stencil
-        let depth_stencil = DepthStencilDesc {
-            depth: Some(DepthTest {
-                fun: Comparison::Less,
-                write: true,
-            }),
-            depth_bounds: false,
-            stencil: None,
-        };
-
-        // Pipeline layout
-        let layout = unsafe {
-            device.create_pipeline_layout(
-                set_layouts.into_iter(),
-                // vp matrix, 4x4 f32
-                IntoIter::new([(ShaderStageFlags::VERTEX, 0..64)]),
-            )
         }
-        .context("Error creating pipeline layout")?;
-
-        // Colour blending
-        let blender = {
-            let blend_state = BlendState {
-                color: BlendOp::Add {
-                    src: Factor::One,
-                    dst: Factor::Zero,
-                },
-                alpha: BlendOp::Add {
-                    src: Factor::One,
-                    dst: Factor::Zero,
-                },
-            };
+        self.repo.deactivate(device_lock);
+
+        Ok(())
+    }
+}
 
-            BlendDesc {
+impl<'a, M> IntoDrawPass<LevelDrawPass<'a, M>> for Entity
+where
+    M: for<'b> MinRenderFeatures<'b> + 'static,
+{
+    fn init(
+        self,
+        session: &Session,
+        adapter: &Adapter,
+        device_lock: Arc<RwLock<DeviceT>>,
+        queue_negotiator: &mut QueueNegotiator,
+        swapchain_properties: &SwapchainProperties,
+    ) -> Result<LevelDrawPass<'a, M>> {
+        let spec = PipelineSpecBuilder::default()
+            .rasterizer(Rasterizer {
+                polygon_mode: PolygonMode::Fill,
+                cull_face: Face::BACK,
+                front_face: FrontFace::CounterClockwise,
+                depth_clamping: false,
+                depth_bias: None,
+                conservative: true,
+                line_width: State::Static(1.0),
+            })
+            .depth_stencil(DepthStencilDesc {
+                depth: Some(DepthTest {
+                    fun: Comparison::Less,
+                    write: true,
+                }),
+                depth_bounds: false,
+                stencil: None,
+            })
+            .blender(BlendDesc {
                 logic_op: Some(LogicOp::Copy),
                 targets: vec![ColorBlendDesc {
                     mask: ColorMask::ALL,
-                    blend: Some(blend_state),
+                    blend: Some(BlendState {
+                        color: BlendOp::Add {
+                            src: Factor::One,
+                            dst: Factor::Zero,
+                        },
+                        alpha: BlendOp::Add {
+                            src: Factor::One,
+                            dst: Factor::Zero,
+                        },
+                    }),
+                }],
+            })
+            .primitive_assembler(VertexPrimitiveAssemblerSpec::with_buffers(
+                InputAssemblerDesc::new(Primitive::TriangleList),
+                vec![VertexBufferSpec {
+                    attributes: vec![Format::Rgb32Sfloat, Format::R32Sint, Format::Rg32Sfloat],
+                    rate: VertexInputRate::Vertex,
+                }],
+            ))
+            .shader_vertex(ShaderDesc {
+                source: include_str!("../data/stockton.vert").to_string(),
+                entry: "main".to_string(),
+                kind: ShaderKind::Vertex,
+            })
+            .shader_fragment(ShaderDesc {
+                source: include_str!("../data/stockton.frag").to_string(),
+                entry: "main".to_string(),
+                kind: ShaderKind::Fragment,
+            })
+            .push_constants(vec![(ShaderStageFlags::VERTEX, 0..64)])
+            .renderpass(RenderpassSpec {
+                colors: vec![Attachment {
+                    format: Some(swapchain_properties.format),
+                    samples: 1,
+                    ops: AttachmentOps::new(AttachmentLoadOp::Clear, AttachmentStoreOp::Store),
+                    stencil_ops: AttachmentOps::new(
+                        AttachmentLoadOp::Clear,
+                        AttachmentStoreOp::DontCare,
+                    ),
+                    layouts: Layout::ColorAttachmentOptimal..Layout::ColorAttachmentOptimal,
                 }],
+                depth: Some(Attachment {
+                    format: Some(swapchain_properties.depth_format),
+                    samples: 1,
+                    ops: AttachmentOps::new(AttachmentLoadOp::Clear, AttachmentStoreOp::DontCare),
+                    stencil_ops: AttachmentOps::new(
+                        AttachmentLoadOp::DontCare,
+                        AttachmentStoreOp::DontCare,
+                    ),
+                    layouts: Layout::Undefined..Layout::DepthStencilAttachmentOptimal,
+                }),
+                inputs: vec![],
+                resolves: vec![],
+                preserves: vec![],
+            })
+            .build()
+            .context("Error building pipeline")?;
+
+        let map_lock: Arc<RwLock<M>> = session.resources.get::<Arc<RwLock<M>>>().unwrap().clone();
+        let repo = TextureRepo::new(
+            device_lock.clone(),
+            queue_negotiator
+                .family::<TexLoadQueue>()
+                .ok_or(EnvironmentError::NoSuitableFamilies)
+                .context("Error finding texture queue")?,
+            queue_negotiator
+                .get_queue::<TexLoadQueue>()
+                .ok_or(EnvironmentError::NoQueues)
+                .context("Error finding texture queue")?,
+            adapter,
+            TextureLoadConfig {
+                resolver: FsResolver::new(Path::new("textures"), map_lock),
+                filter: Filter::Linear,
+                wrap_mode: WrapMode::Tile,
+            },
+        )
+        .context("Error creating texture repo")?;
+
+        let (draw_buffers, pipeline, framebuffers, depth_buffers) = {
+            let mut device = device_lock.write().map_err(|_| LockPoisoned::Device)?;
+            let draw_buffers =
+                DrawBuffers::new(&mut device, adapter).context("Error creating draw buffers")?;
+            let pipeline = spec
+                .build(
+                    &mut device,
+                    swapchain_properties.extent,
+                    swapchain_properties,
+                    once(&*repo.get_ds_layout()?),
+                )
+                .context("Error building pipeline")?;
+
+            let mut framebuffers = Vec::with_capacity(swapchain_properties.image_count as usize);
+            let mut depth_buffers = Vec::with_capacity(swapchain_properties.image_count as usize);
+            let fat = FramebufferAttachment {
+                usage: Usage::COLOR_ATTACHMENT,
+                format: swapchain_properties.format,
+                view_caps: ViewCapabilities::empty(),
+            };
+            let dat = FramebufferAttachment {
+                usage: Usage::DEPTH_STENCIL_ATTACHMENT,
+                format: swapchain_properties.depth_format,
+                view_caps: ViewCapabilities::empty(),
+            };
+            for _i in 0..swapchain_properties.image_count {
+                unsafe {
+                    framebuffers.push(device.create_framebuffer(
+                        &pipeline.renderpass,
+                        IntoIter::new([fat.clone(), dat.clone()]),
+                        swapchain_properties.extent,
+                    )?);
+                    depth_buffers.push(
+                        DedicatedLoadedImage::new(
+                            &mut device,
+                            adapter,
+                            swapchain_properties.depth_format,
+                            Usage::DEPTH_STENCIL_ATTACHMENT,
+                            SubresourceRange {
+                                aspects: Aspects::DEPTH,
+                                level_start: 0,
+                                level_count: Some(1),
+                                layer_start: 0,
+                                layer_count: Some(1),
+                            },
+                            swapchain_properties.extent.width as usize,
+                            swapchain_properties.extent.height as usize,
+                        )
+                        .context("Error creating depth buffer")?,
+                    )
+                }
             }
-        };
-
-        // Baked states
-        let baked_states = BakedStates {
-            viewport: Some(Viewport {
-                rect: extent.rect(),
-                depth: (0.0..1.0),
-            }),
-            scissor: Some(extent.rect()),
-            blend_constants: None,
-            depth_bounds: None,
-        };
-
-        // Primitive assembler
-        let primitive_assembler = PrimitiveAssemblerDesc::Vertex {
-            buffers: &[VertexBufferDesc {
-                binding: 0,
-                stride: (size_of::<f32>() * 6) as u32,
-                rate: VertexInputRate::Vertex,
-            }],
-            attributes: &[
-                AttributeDesc {
-                    location: 0,
-                    binding: 0,
-                    element: Element {
-                        format: Format::Rgb32Sfloat,
-                        offset: 0,
-                    },
-                },
-                AttributeDesc {
-                    location: 1,
-                    binding: 0,
-                    element: Element {
-                        format: Format::R32Sint,
-                        offset: (size_of::<f32>() * 3) as u32,
-                    },
-                },
-                AttributeDesc {
-                    location: 2,
-                    binding: 0,
-                    element: Element {
-                        format: Format::Rg32Sfloat,
-                        offset: (size_of::<f32>() * 4) as u32,
-                    },
-                },
-            ],
-            input_assembler: InputAssemblerDesc::new(Primitive::TriangleList),
-            vertex: vs_entry,
-            tessellation: None,
-            geometry: None,
-        };
 
-        // Pipeline description
-        let pipeline_desc = GraphicsPipelineDesc {
-            label: Some("3D"),
-            rasterizer,
-            fragment: Some(fs_entry),
-            blender,
-            depth_stencil,
-            multisampling: None,
-            baked_states,
-            layout: &layout,
-            subpass,
-            flags: PipelineCreationFlags::empty(),
-            parent: BasePipeline::None,
-            primitive_assembler,
+            (draw_buffers, pipeline, framebuffers, depth_buffers)
         };
 
-        // Pipeline
-        let pipeline = unsafe { device.create_graphics_pipeline(&pipeline_desc, None) }
-            .context("Error creating graphics pipeline")?;
-
-        Ok(CompletePipeline {
-            renderpass: ManuallyDrop::new(renderpass),
-            pipeline_layout: ManuallyDrop::new(layout),
-            pipeline: ManuallyDrop::new(pipeline),
-            vs_module: ManuallyDrop::new(vs_module),
-            fs_module: ManuallyDrop::new(fs_module),
+        Ok(LevelDrawPass {
+            pipeline,
+            repo,
+            draw_buffers,
+            active_camera: self,
+            _d: PhantomData,
+            framebuffers,
+            depth_buffers,
+            next_resources: 0,
         })
     }
 
-    /// Deactivate vulkan resources. Use before dropping
-    pub fn deactivate(self, device: &mut DeviceT) {
-        unsafe {
-            use core::ptr::read;
-
-            device.destroy_render_pass(ManuallyDrop::into_inner(read(&self.renderpass)));
-
-            device.destroy_shader_module(ManuallyDrop::into_inner(read(&self.vs_module)));
-            device.destroy_shader_module(ManuallyDrop::into_inner(read(&self.fs_module)));
+    fn find_aux_queues<'c>(
+        adapter: &'c Adapter,
+        queue_negotiator: &mut QueueNegotiator,
+    ) -> Result<Vec<(&'c QueueFamilyT, Vec<f32>)>> {
+        queue_negotiator.find(adapter, &TexLoadQueue)?;
 
-            device.destroy_graphics_pipeline(ManuallyDrop::into_inner(read(&self.pipeline)));
-
-            device.destroy_pipeline_layout(ManuallyDrop::into_inner(read(&self.pipeline_layout)));
-        }
+        Ok(vec![queue_negotiator
+            .family_spec::<TexLoadQueue>(&adapter.queue_families, 1)
+            .ok_or(EnvironmentError::NoSuitableFamilies)?])
     }
 }
 
diff --git a/stockton-render/src/draw/draw_passes/mod.rs b/stockton-render/src/draw/draw_passes/mod.rs
index 566a64b..70f1786 100644
--- a/stockton-render/src/draw/draw_passes/mod.rs
+++ b/stockton-render/src/draw/draw_passes/mod.rs
@@ -10,22 +10,21 @@ use anyhow::Result;
 mod cons;
 mod level;
 
-pub use level::LevelDrawPass;
 pub use cons::{ConsDrawPass, NilDrawPass};
+pub use level::LevelDrawPass;
 
 /// One of several 'passes' that draw on each frame.
 pub trait DrawPass {
     /// 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, session: &Session, cmd_buffer: &mut CommandBufferT) -> Result<()>;
+    fn queue_draw(
+        &mut self,
+        session: &Session,
+        img_view: &ImageViewT,
+        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)
-    /// It should return then call .family_spec for each queue type negotiated and return the results.
-    fn find_aux_queues<'a>(
-        adapter: &'a Adapter,
-        queue_negotiator: &mut QueueNegotiator,
-    ) -> Result<Vec<(&'a QueueFamilyT, Vec<f32>)>>;
+    fn deactivate(self, device: &mut Arc<RwLock<DeviceT>>) -> Result<()>;
 }
 
 /// A type that can be made into a specific draw pass type.
@@ -33,8 +32,18 @@ pub trait DrawPass {
 pub trait IntoDrawPass<O: DrawPass> {
     fn init(
         self,
+        session: &Session,
+        adapter: &Adapter,
         device: Arc<RwLock<DeviceT>>,
         queue_negotiator: &mut QueueNegotiator,
         swapchain_properties: &SwapchainProperties,
     ) -> Result<O>;
+
+    /// This function should ask the queue negotatior to find families for any auxilary operations this draw pass needs to perform
+    /// For example, .find(&TexLoadQueue)
+    /// It should return then call .family_spec for each queue type negotiated and return the results.
+    fn find_aux_queues<'a>(
+        adapter: &'a Adapter,
+        queue_negotiator: &mut QueueNegotiator,
+    ) -> Result<Vec<(&'a QueueFamilyT, Vec<f32>)>>;
 }
diff --git a/stockton-render/src/draw/mod.rs b/stockton-render/src/draw/mod.rs
index 411e835..b570b12 100644
--- a/stockton-render/src/draw/mod.rs
+++ b/stockton-render/src/draw/mod.rs
@@ -3,7 +3,8 @@
 pub mod target;
 
 mod buffers;
-mod camera;
+mod builders;
+pub mod camera;
 mod context;
 pub mod draw_passes;
 mod queue_negotiator;
diff --git a/stockton-render/src/draw/queue_negotiator.rs b/stockton-render/src/draw/queue_negotiator.rs
index b39678f..65c7aa4 100644
--- a/stockton-render/src/draw/queue_negotiator.rs
+++ b/stockton-render/src/draw/queue_negotiator.rs
@@ -12,6 +12,7 @@ use std::{
 pub struct QueueNegotiator {
     family_ids: HashMap<TypeId, QueueFamilyId>,
     already_allocated: HashMap<TypeId, (Vec<Arc<RwLock<QueueT>>>, usize)>,
+    all: Vec<QueueGroup>,
 }
 
 /// Can be used to select a specific queue family
@@ -25,6 +26,7 @@ impl QueueNegotiator {
         QueueNegotiator {
             family_ids: HashMap::new(),
             already_allocated: HashMap::new(),
+            all: vec![],
         }
     }
 
@@ -57,20 +59,23 @@ impl QueueNegotiator {
         Ok(())
     }
 
-    pub fn get_queue<T: QueueFamilySelector>(
-        &mut self,
-        groups: &mut Vec<QueueGroup>,
-    ) -> Option<Arc<RwLock<QueueT>>> {
+    pub fn set_queue_groups(&mut self, queue_groups: Vec<QueueGroup>) {
+        self.all = queue_groups
+    }
+
+    pub fn get_queue<T: QueueFamilySelector>(&mut self) -> Option<Arc<RwLock<QueueT>>> {
         let tid = TypeId::of::<T>();
         let family_id = self.family_ids.get(&tid)?;
-
-        match groups
+        log::debug!("{:?}", self.all);
+        log::debug!("{:?}", self.already_allocated);
+        match self
+            .all
             .iter()
             .position(|x| !x.queues.is_empty() && x.family == *family_id)
         {
             Some(idx) => {
                 // At least one remaining queue
-                let queue = groups[idx].queues.pop().unwrap();
+                let queue = self.all[idx].queues.pop().unwrap();
                 let queue = Arc::new(RwLock::new(queue));
 
                 self.add_to_allocated::<T>(queue.clone());
diff --git a/stockton-render/src/draw/target.rs b/stockton-render/src/draw/target.rs
index c46feb5..de803aa 100644
--- a/stockton-render/src/draw/target.rs
+++ b/stockton-render/src/draw/target.rs
@@ -1,19 +1,21 @@
 //! Resources needed for drawing on the screen, including sync objects
 
 use std::{
+    borrow::Borrow,
     iter::{empty, once},
     mem::ManuallyDrop,
 };
 
 use hal::{
     command::CommandBufferFlags,
-    format::{ChannelType, Format, ImageFeature},
-    image::{Extent, Usage as ImgUsage},
-    pso::Viewport,
+    format::{Aspects, ChannelType, Format, ImageFeature},
+    image::{Access, Extent, Layout, SubresourceRange, Usage as ImgUsage},
+    memory::{Barrier, Dependencies},
+    pso::{PipelineStage, Viewport},
     window::{CompositeAlphaMode, Extent2D, PresentMode, SwapchainConfig},
 };
 
-use super::{buffers::DedicatedLoadedImage, draw_passes::DrawPass};
+use super::{draw_passes::DrawPass};
 use crate::{error::EnvironmentError, types::*};
 use anyhow::{Context, Result};
 use stockton_types::Session;
@@ -26,6 +28,7 @@ pub struct SwapchainProperties {
     pub composite_alpha_mode: CompositeAlphaMode,
     pub viewport: Viewport,
     pub extent: Extent,
+    pub image_count: u32,
 }
 
 impl SwapchainProperties {
@@ -97,6 +100,11 @@ impl SwapchainProperties {
             composite_alpha_mode,
             extent,
             viewport,
+            image_count: if present_mode == PresentMode::MAILBOX {
+                ((*caps.image_count.end()) - 1).min((*caps.image_count.start()).max(3))
+            } else {
+                ((*caps.image_count.end()) - 1).min((*caps.image_count.start()).max(2))
+            },
         })
     }
 }
@@ -104,12 +112,8 @@ impl SwapchainProperties {
 pub struct TargetChain {
     /// Surface we're targeting
     pub surface: ManuallyDrop<SurfaceT>,
-
     pub properties: SwapchainProperties,
 
-    /// The depth buffer/image used for drawing
-    pub depth_buffer: ManuallyDrop<DedicatedLoadedImage>,
-
     /// Resources tied to each target frame in the swapchain
     pub targets: Box<[TargetResources]>,
 
@@ -155,28 +159,6 @@ impl TargetChain {
             image_usage: ImgUsage::COLOR_ATTACHMENT,
         };
 
-        let depth_buffer = {
-            use hal::format::Aspects;
-            use hal::image::SubresourceRange;
-
-            DedicatedLoadedImage::new(
-                device,
-                adapter,
-                properties.depth_format,
-                ImgUsage::DEPTH_STENCIL_ATTACHMENT,
-                SubresourceRange {
-                    aspects: Aspects::DEPTH,
-                    level_start: 0,
-                    level_count: Some(1),
-                    layer_start: 0,
-                    layer_count: Some(1),
-                },
-                properties.extent.width as usize,
-                properties.extent.height as usize,
-            )
-            .context("Error creating depth buffer")?
-        };
-
         let _fat = swap_config.framebuffer_attachment();
         let mut targets: Vec<TargetResources> =
             Vec::with_capacity(swap_config.image_count as usize);
@@ -203,7 +185,6 @@ impl TargetChain {
             surface: ManuallyDrop::new(surface),
             targets: targets.into_boxed_slice(),
             sync_objects: sync_objects.into_boxed_slice(),
-            depth_buffer: ManuallyDrop::new(depth_buffer),
             properties,
             last_syncs: (image_count - 1) as usize, // This means the next one to be used is index 0
             last_image: 0,
@@ -230,8 +211,6 @@ impl TargetChain {
     ) -> SurfaceT {
         use core::ptr::read;
         unsafe {
-            ManuallyDrop::into_inner(read(&self.depth_buffer)).deactivate(device);
-
             for i in 0..self.targets.len() {
                 read(&self.targets[i]).deactivate(device, cmd_pool);
             }
@@ -250,7 +229,7 @@ impl TargetChain {
         &'a mut self,
         device: &mut DeviceT,
         command_queue: &mut QueueT,
-        dp: &DP,
+        dp: &mut DP,
         session: &Session,
     ) -> Result<()> {
         self.last_syncs = (self.last_syncs + 1) % self.sync_objects.len();
@@ -280,9 +259,45 @@ impl TargetChain {
         unsafe {
             target.cmd_buffer.begin_primary(CommandBufferFlags::empty());
 
-            dp.queue_draw(session, &mut target.cmd_buffer)
+            target.cmd_buffer.pipeline_barrier(
+                PipelineStage::TOP_OF_PIPE..PipelineStage::TOP_OF_PIPE,
+                Dependencies::empty(),
+                once(Barrier::Image {
+                    states: (Access::empty(), Layout::Undefined)
+                        ..(Access::empty(), Layout::ColorAttachmentOptimal),
+                    target: img.borrow(),
+                    range: SubresourceRange {
+                        aspects: Aspects::COLOR,
+                        level_start: 0,
+                        level_count: Some(1),
+                        layer_start: 0,
+                        layer_count: Some(1),
+                    },
+                    families: None,
+                }),
+            );
+
+            dp.queue_draw(session, img.borrow(), &mut target.cmd_buffer)
                 .context("Error in draw pass")?;
 
+            target.cmd_buffer.pipeline_barrier(
+                PipelineStage::BOTTOM_OF_PIPE..PipelineStage::BOTTOM_OF_PIPE,
+                Dependencies::empty(),
+                once(Barrier::Image {
+                    states: (Access::empty(), Layout::ColorAttachmentOptimal)
+                        ..(Access::empty(), Layout::Present),
+                    target: img.borrow(),
+                    range: SubresourceRange {
+                        aspects: Aspects::COLOR,
+                        level_start: 0,
+                        level_count: Some(1),
+                        layer_start: 0,
+                        layer_count: Some(1),
+                    },
+                    families: None,
+                }),
+            );
+
             target.cmd_buffer.finish();
         }
 
diff --git a/stockton-render/src/draw/texture/resolver.rs b/stockton-render/src/draw/texture/resolver.rs
index 1dbc62d..4b61c41 100644
--- a/stockton-render/src/draw/texture/resolver.rs
+++ b/stockton-render/src/draw/texture/resolver.rs
@@ -4,7 +4,6 @@ use crate::draw::texture::image::LoadableImage;
 use stockton_levels::{parts::IsTexture, prelude::HasTextures};
 
 use std::{
-    mem::drop,
     path::Path,
     sync::{Arc, RwLock},
 };
@@ -39,8 +38,8 @@ impl<'a, T: HasTextures> TextureResolver for FsResolver<'a, T> {
         let tex = map.get_texture(tex)?;
         let path = self.path.join(&tex.name());
 
-        drop(tex);
-        drop(map);
+        // drop(tex);
+        // drop(map);
 
         if let Ok(file) = Reader::open(path) {
             if let Ok(guessed) = file.with_guessed_format() {
@@ -50,6 +49,7 @@ impl<'a, T: HasTextures> TextureResolver for FsResolver<'a, T> {
             }
         }
 
+        log::warn!("Couldn't resolve texture {:?}", tex.name());
         None
     }
 }
diff --git a/stockton-render/src/lib.rs b/stockton-render/src/lib.rs
index 850d3eb..17dbf03 100644
--- a/stockton-render/src/lib.rs
+++ b/stockton-render/src/lib.rs
@@ -6,6 +6,9 @@ extern crate gfx_hal as hal;
 extern crate nalgebra_glm as na;
 
 #[macro_use]
+extern crate derive_builder;
+
+#[macro_use]
 extern crate legion;
 
 pub mod draw;
@@ -15,22 +18,18 @@ mod types;
 pub mod window;
 
 use draw::{
+    draw_passes::{DrawPass, IntoDrawPass},
     RenderingContext,
-    draw_passes::{DrawPass, IntoDrawPass}
 };
-use error::full_error_display;
-use legion::world::SubWorld;
-use legion::IntoQuery;
+
 use std::sync::mpsc::{Receiver, Sender};
 use std::sync::Arc;
 use std::sync::RwLock;
 pub use window::{UiState, WindowEvent};
 
 use anyhow::Result;
-use log::error;
-use stockton_levels::prelude::*;
-use stockton_types::components::{CameraSettings, Transform};
-use stockton_types::{Vector3, Session};
+
+use stockton_types::Session;
 use winit::event_loop::ControlFlow;
 use winit::window::Window;
 
@@ -51,13 +50,17 @@ pub struct Renderer<DP> {
 
 impl<DP: DrawPass> Renderer<DP> {
     /// Create a new Renderer.
-    pub fn new<IDP: IntoDrawPass<DP>>(window: &Window, ui: &mut UiState, idp: IDP) -> Result<(Self, Sender<WindowEvent>)> {
+    pub fn new<IDP: IntoDrawPass<DP>>(
+        window: &Window,
+        session: &Session,
+        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, idp)?,
+                context: RenderingContext::new(window, session, idp)?,
                 window_events: rx,
                 update_control_flow,
             },
@@ -66,7 +69,7 @@ impl<DP: DrawPass> Renderer<DP> {
     }
 
     /// Render a single frame of the given session.
-    fn render(&mut self, session: &Session) -> Result<()> {
+    pub fn render(&mut self, session: &Session) -> Result<()> {
         // Try to draw
         if self.context.draw_next_frame(session).is_err() {
             // Probably the surface changed
@@ -82,4 +85,4 @@ impl<DP: DrawPass> Renderer<DP> {
     fn resize(&mut self) -> Result<()> {
         unsafe { self.context.handle_surface_change() }
     }
-}
\ No newline at end of file
+}
diff --git a/stockton-render/src/systems.rs b/stockton-render/src/systems.rs
index 67cea84..5f86c29 100644
--- a/stockton-render/src/systems.rs
+++ b/stockton-render/src/systems.rs
@@ -1 +1,2 @@
+pub use crate::draw::camera::calc_vp_matrix_system;
 pub use crate::window::process_window_events_system;
diff --git a/stockton-render/src/types.rs b/stockton-render/src/types.rs
index 797ced9..03c6e37 100644
--- a/stockton-render/src/types.rs
+++ b/stockton-render/src/types.rs
@@ -25,6 +25,7 @@ pub type FramebufferT = <back::Backend as hal::Backend>::Framebuffer;
 pub type RenderPassT = <back::Backend as hal::Backend>::RenderPass;
 
 pub type Adapter = hal::adapter::Adapter<back::Backend>;
+pub type EntryPoint<'a> = hal::pso::EntryPoint<'a, back::Backend>;
 pub type QueueGroup = hal::queue::QueueGroup<back::Backend>;
 
 pub type DescriptorAllocator = rendy_descriptor::DescriptorAllocator<back::Backend>;
diff --git a/stockton-render/src/window.rs b/stockton-render/src/window.rs
index 6e6a0e1..62e43d3 100644
--- a/stockton-render/src/window.rs
+++ b/stockton-render/src/window.rs
@@ -1,8 +1,8 @@
-use crate::{error::full_error_display, Renderer, DrawPass};
+use crate::{error::full_error_display, DrawPass, Renderer};
 use egui::{Modifiers, Rect, Vec2};
 use legion::systems::Runnable;
 use log::debug;
-use stockton_levels::prelude::MinRenderFeatures;
+
 
 use egui::{CtxRef, Event, Output, Pos2, RawInput};
 use epaint::ClippedShape;
@@ -93,7 +93,7 @@ impl UiState {
         }
     }
 
-    pub fn populate_initial_state<T: MinRenderFeatures>(&mut self, renderer: &Renderer<T>) {
+    pub fn populate_initial_state<'a, T: DrawPass>(&mut self, renderer: &Renderer<T>) {
         let props = &renderer.context.target_chain.properties;
         self.set_dimensions(props.extent.width, props.extent.height);
         self.set_pixels_per_point(Some(renderer.context.pixels_per_point));