diff --git a/kraken/KRAmbientZone.cpp b/kraken/KRAmbientZone.cpp
index 18da8e5..31a8c46 100755
--- a/kraken/KRAmbientZone.cpp
+++ b/kraken/KRAmbientZone.cpp
@@ -31,6 +31,7 @@
 
 #include "KRAmbientZone.h"
 #include "KRContext.h"
+#include "KRRenderPass.h"
 
 using namespace hydra;
 
@@ -128,7 +129,7 @@ void KRAmbientZone::render(RenderInfo& ri)
 
   bool bVisualize = ri.camera->settings.debug_display == KRRenderSettings::KRENGINE_DEBUG_DISPLAY_SIREN_AMBIENT_ZONES;
 
-  if (ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
+  if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
     KRMesh* sphereModel = getContext().getMeshManager()->getMaxLODModel("__sphere");
     if (sphereModel) {
 
@@ -193,4 +194,4 @@ float KRAmbientZone::getContainment(const Vector3& pos)
   } else {
     return 0.0f;
   }
-}
\ No newline at end of file
+}
diff --git a/kraken/KRAudioSource.cpp b/kraken/KRAudioSource.cpp
index ee289ca..a64b212 100755
--- a/kraken/KRAudioSource.cpp
+++ b/kraken/KRAudioSource.cpp
@@ -34,6 +34,7 @@
 #include "KRAudioManager.h"
 #include "KRAudioSample.h"
 #include "KRAudioBuffer.h"
+#include "KRRenderPass.h"
 
 using namespace hydra;
 
@@ -196,7 +197,7 @@ void KRAudioSource::render(RenderInfo& ri)
 
   bool bVisualize = false;
 
-  if (ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
+  if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
     KRMesh* sphereModel = getContext().getMeshManager()->getMaxLODModel("__sphere");
     if (sphereModel) {
       Matrix4 sphereModelMatrix = getModelMatrix();
diff --git a/kraken/KRBone.cpp b/kraken/KRBone.cpp
index afdf899..b416d5f 100755
--- a/kraken/KRBone.cpp
+++ b/kraken/KRBone.cpp
@@ -31,6 +31,7 @@
 
 #include "KRBone.h"
 #include "KRContext.h"
+#include "KRRenderPass.h"
 
 using namespace hydra;
 
@@ -80,7 +81,7 @@ void KRBone::render(RenderInfo& ri)
 
   bool bVisualize = ri.camera->settings.debug_display == KRRenderSettings::KRENGINE_DEBUG_DISPLAY_BONES;
 
-  if (ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
+  if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
     KRMesh* sphereModel = getContext().getMeshManager()->getMaxLODModel("__sphere");
     if (sphereModel) {
       Matrix4 sphereModelMatrix = getModelMatrix();
diff --git a/kraken/KRCamera.cpp b/kraken/KRCamera.cpp
index 49bfa9c..9677be6 100755
--- a/kraken/KRCamera.cpp
+++ b/kraken/KRCamera.cpp
@@ -34,6 +34,7 @@
 #include "KRDirectionalLight.h"
 #include "KRRenderPass.h"
 #include "KRPipeline.h"
+#include "KRRenderPass.h"
 
 using namespace mimir;
 using namespace hydra;
@@ -180,13 +181,13 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
   scene.updateOctree(m_viewport);
 
   // ----====---- Pre-stream resources ----====----
-  scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_PRESTREAM, true);
+  scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_PRESTREAM), true);
 
   // ----====---- Generate Shadowmaps for Lights ----====----
   if (settings.m_cShadowBuffers > 0) {
     GL_PUSH_GROUP_MARKER("Generate Shadowmaps");
 
-    scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_GENERATE_SHADOWMAPS, false /*settings.bEnableDeferredLighting*/);
+    scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_GENERATE_SHADOWMAPS), false /*settings.bEnableDeferredLighting*/);
     GL_POP_GROUP_MARKER;
   }
 
@@ -197,14 +198,14 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
     GL_PUSH_GROUP_MARKER("Deferred Lighting - Pass 1 (Opaque)");
 
     // Start render pass
-    KRRenderPass& deferredGBufferPass = compositeSurface.getDeferredGBufferPass();
-    deferredGBufferPass.begin(commandBuffer, compositeSurface);
+    KRRenderPass* deferredGBufferPass = compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_DEFERRED_GBUFFER);
+    deferredGBufferPass->begin(commandBuffer, compositeSurface);
 
     // Render the geometry
-    scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_DEFERRED_GBUFFER, false);
+    scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, deferredGBufferPass, false);
 
     // End render pass
-    deferredGBufferPass.end(commandBuffer);
+    deferredGBufferPass->end(commandBuffer);
 
     GL_POP_GROUP_MARKER;
 
@@ -225,7 +226,7 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
     m_pContext->getTextureManager()->selectTexture(0 /*GL_TEXTURE_2D*/, 7, compositeDepthTexture);
 
     // Render the geometry
-    scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_DEFERRED_LIGHTS, false);
+    scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_DEFERRED_LIGHTS), false);
 
     GL_POP_GROUP_MARKER;
 
@@ -234,18 +235,18 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
     GL_PUSH_GROUP_MARKER("Deferred Lighting - Pass 3 (Opaque)");
 
     // Start render pass
-    KRRenderPass& deferredOpaquePass = compositeSurface.getDeferredOpaquePass();
-    deferredOpaquePass.begin(commandBuffer, compositeSurface);
+    KRRenderPass* deferredOpaquePass = compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_DEFERRED_OPAQUE);
+    deferredOpaquePass->begin(commandBuffer, compositeSurface);
 
     // Set source to buffers from pass 2
     m_pContext->getTextureManager()->selectTexture(0 /*GL_TEXTURE_2D*/, 6, lightAccumulationTexture);
 
     // Render the geometry
     // TODO: At this point, we only want to render octree nodes that produced fragments during the 1st pass into the GBuffer
-    scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_DEFERRED_OPAQUE, false);
+    scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, deferredOpaquePass, false);
 
     // End render pass
-    deferredOpaquePass.end(commandBuffer);
+    deferredOpaquePass->end(commandBuffer);
 
     GL_POP_GROUP_MARKER;
   } else {
@@ -253,11 +254,11 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
     GL_PUSH_GROUP_MARKER("Forward Rendering - Opaque");
 
     // Start render pass
-    KRRenderPass& forwardOpaquePass = compositeSurface.getForwardOpaquePass();
-    forwardOpaquePass.begin(commandBuffer, compositeSurface);
+    KRRenderPass* forwardOpaquePass = compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_OPAQUE);
+    forwardOpaquePass->begin(commandBuffer, compositeSurface);
 
     // Render the geometry
-    scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_FORWARD_OPAQUE, false);
+    scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, forwardOpaquePass, false);
 
     GL_POP_GROUP_MARKER;
 
@@ -269,19 +270,19 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
       std::string shader_name("vulkan_test");
       info.shader_name = &shader_name;
       info.pCamera = this;
-      info.renderPass = KRNode::RENDER_PASS_FORWARD_TRANSPARENT;
-      info.rasterMode = RasterMode::kAlphaBlend;
+      info.renderPass = forwardOpaquePass;
+      info.rasterMode = RasterMode::kOpaque;
       info.vertexAttributes = sphereMesh->getVertexAttributes();
       info.modelFormat = sphereMesh->getModelFormat();
       KRPipeline* testPipeline = m_pContext->getPipelineManager()->getPipeline(compositeSurface, info);
-      testPipeline->bind(commandBuffer, *this, m_viewport, Matrix4(), nullptr, nullptr, nullptr, KRNode::RENDER_PASS_FORWARD_OPAQUE);
+      testPipeline->bind(commandBuffer, *this, m_viewport, Matrix4(), nullptr, nullptr, nullptr, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_OPAQUE));
       sphereMesh->renderNoMaterials(commandBuffer, info.renderPass, "Vulkan Test", "vulkan_test", 1.0);
     }
 
     // ----------  End: Vulkan Debug Code ----------
 
 
-    forwardOpaquePass.end(commandBuffer);
+    forwardOpaquePass->end(commandBuffer);
   }
 
   // ----====---- Sky Box ----====----
@@ -299,13 +300,13 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
     PipelineInfo info{};
     info.shader_name = &shader_name;
     info.pCamera = this;
-    info.renderPass = KRNode::RENDER_PASS_FORWARD_OPAQUE;
+    info.renderPass = compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_OPAQUE);
     info.rasterMode = RasterMode::kOpaqueNoDepthWrite;
     info.cullMode = CullMode::kCullNone;
 
     KRPipeline* pPipeline = getContext().getPipelineManager()->getPipeline(compositeSurface, info);
     pPipeline->setImageBinding("diffuseTexture", m_pSkyBoxTexture, getContext().getSamplerManager()->DEFAULT_CLAMPED_SAMPLER);
-    pPipeline->bind(commandBuffer, *this, m_viewport, Matrix4(), nullptr, nullptr, nullptr, KRNode::RENDER_PASS_FORWARD_OPAQUE);
+    pPipeline->bind(commandBuffer, *this, m_viewport, Matrix4(), nullptr, nullptr, nullptr, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_OPAQUE));
 
     // Render a full screen quad
     m_pContext->getMeshManager()->bindVBO(commandBuffer, &getContext().getMeshManager()->KRENGINE_VBO_DATA_2D_SQUARE_VERTICES, 1.0f);
@@ -320,7 +321,7 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
   GL_PUSH_GROUP_MARKER("Forward Rendering - Transparent");
 
   // Render all transparent geometry
-  scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_FORWARD_TRANSPARENT, false);
+  scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT), false);
 
   GL_POP_GROUP_MARKER;
 
@@ -329,7 +330,7 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
   GL_PUSH_GROUP_MARKER("Particle Occlusion Tests");
 
   // ----====---- Perform Occlusion Tests ----====----
-  scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, RENDER_PASS_PARTICLE_OCCLUSION, false);
+  scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_PARTICLE_OCCLUSION), false);
 
   GL_POP_GROUP_MARKER;
 
@@ -338,7 +339,7 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
   GL_PUSH_GROUP_MARKER("Additive Particles");
 
   // Render all flares
-  scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_ADDITIVE_PARTICLES, false);
+  scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_ADDITIVE_PARTICLES), false);
 
   GL_POP_GROUP_MARKER;
 
@@ -368,7 +369,7 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
       GLDEBUG(glDepthRangef(0.0, 1.0));
     }
 
-    scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), volumetricLightingViewport, KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE, false);
+    scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), volumetricLightingViewport, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE), false);
 
     GL_POP_GROUP_MARKER;
   }
@@ -386,7 +387,7 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
     std::string shader_name("visualize_overlay");
     info.shader_name = &shader_name;
     info.pCamera = this;
-    info.renderPass = KRNode::RENDER_PASS_FORWARD_TRANSPARENT;
+    info.renderPass = compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT);
     info.rasterMode = RasterMode::kAdditive;
     info.vertexAttributes = vertices.getVertexAttributes();
     info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_STRIP;
@@ -397,7 +398,7 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
       Matrix4 matModel = Matrix4();
       matModel.scale((*itr).first.size() * 0.5f);
       matModel.translate((*itr).first.center());
-      pVisShader->bind(commandBuffer, *this, m_viewport, matModel, nullptr, nullptr, nullptr, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
+      pVisShader->bind(commandBuffer, *this, m_viewport, matModel, nullptr, nullptr, nullptr, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT));
       vkCmdDraw(commandBuffer, 14, 1, 0, 0);
     }
   }
@@ -414,12 +415,12 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
   
   GL_PUSH_GROUP_MARKER("Post Processing");
 
-  KRRenderPass& postCompositePass = compositeSurface.getPostCompositePass();
-  postCompositePass.begin(commandBuffer, compositeSurface);
+  KRRenderPass* postCompositePass = compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_POST_COMPOSITE);
+  postCompositePass->begin(commandBuffer, compositeSurface);
   
   renderPost(commandBuffer, compositeSurface);
 
-  postCompositePass.end(commandBuffer);
+  postCompositePass->end(commandBuffer);
   
   
   GL_POP_GROUP_MARKER;
@@ -594,7 +595,7 @@ void KRCamera::renderPost(VkCommandBuffer& commandBuffer, KRSurface& surface)
    std::string shader_name("PostShader");
    info.shader_name = &shader_name;
    info.pCamera = this;
-   info.renderPass = KRNode::RENDER_PASS_FORWARD_TRANSPARENT;
+   info.renderPass = compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT);
    info.rasterMode = RasterMode::kOpaqueNoTest;
    info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_STRIP;
    info.vertexAttributes = vertices.getVertexAttributes();
@@ -602,7 +603,7 @@ void KRCamera::renderPost(VkCommandBuffer& commandBuffer, KRSurface& surface)
    KRPipeline *postShader = m_pContext->getPipelineManager()->getPipeline(surface, info);
    
    postShader->setPushConstant(KRPipeline::PushConstant::fade_color, m_fade_color);
-   postShader->bind(commandBuffer, *this, m_viewport, Matrix4(), nullptr, nullptr, nullptr, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
+   postShader->bind(commandBuffer, *this, m_viewport, Matrix4(), nullptr, nullptr, nullptr, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT));
    
    m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 0, compositeDepthTexture);
    m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 1, compositeColorTexture);
@@ -619,13 +620,13 @@ void KRCamera::renderPost(VkCommandBuffer& commandBuffer, KRSurface& surface)
   
   
   //    if(bShowShadowBuffer) {
-  //        KRPipeline *blitShader = m_pContext->getPipelineManager()->getShader("simple_blit", this, false, false, false, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
+  //        KRPipeline *blitShader = m_pContext->getPipelineManager()->getShader("simple_blit", this, false, false, false, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT));
   //
   //        for(int iShadow=0; iShadow < m_cShadowBuffers; iShadow++) {
   //            Matrix4 viewMatrix = Matrix4();
   //            viewMatrix.scale(0.20, 0.20, 0.20);
   //            viewMatrix.translate(-0.70, 0.70 - 0.45 * iShadow, 0.0);
-  //            getContext().getPipelineManager()->selectShader(blitShader, KRViewport(getViewportSize(), viewMatrix, Matrix4()), shadowViewports, Matrix4(), Vector3(), NULL, 0, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
+  //            getContext().getPipelineManager()->selectShader(blitShader, KRViewport(getViewportSize(), viewMatrix, Matrix4()), shadowViewports, Matrix4(), Vector3(), NULL, 0, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT));
   //            m_pContext->getTextureManager()->selectTexture(1, NULL);
   //            m_pContext->getMeshManager()->bindVBO(&getContext().getMeshManager()->KRENGINE_VBO_DATA_2D_SQUARE_VERTICES);
   //            m_pContext->getTextureManager()->_setActiveTexture(0);
@@ -774,8 +775,8 @@ void KRCamera::renderDebug(VkCommandBuffer& commandBuffer, KRSurface& surface)
     
     m_debug_text_vbo_data.load(commandBuffer);
     
-    KRRenderPass& debugPass = surface.getDebugPass();
-    debugPass.begin(commandBuffer, surface);
+    KRRenderPass* debugPass = surface.getRenderPass(RenderPassType::RENDER_PASS_DEBUG_OVERLAYS);
+    debugPass->begin(commandBuffer, surface);
 
     KRTexture* fontTexture = m_pContext->getTextureManager()->getTexture("font");
     fontTexture->resetPoolExpiry(0.0f, KRTexture::TEXTURE_USAGE_UI);
@@ -785,21 +786,21 @@ void KRCamera::renderDebug(VkCommandBuffer& commandBuffer, KRSurface& surface)
       std::string shader_name("debug_font");
       info.shader_name = &shader_name;
       info.pCamera = this;
-      info.renderPass = KRNode::RENDER_PASS_FORWARD_TRANSPARENT;
+      info.renderPass = surface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT);
       info.rasterMode = RasterMode::kAlphaBlendNoTest;
       info.cullMode = CullMode::kCullNone;
       info.vertexAttributes = (1 << KRMesh::KRENGINE_ATTRIB_VERTEX) | (1 << KRMesh::KRENGINE_ATTRIB_TEXUVA);
       info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_TRIANGLES;
       KRPipeline* fontShader = m_pContext->getPipelineManager()->getPipeline(surface, info);
       fontShader->setImageBinding("fontTexture", fontTexture, getContext().getSamplerManager()->DEFAULT_CLAMPED_SAMPLER);
-      fontShader->bind(commandBuffer, *this, m_viewport, Matrix4(), nullptr, nullptr, nullptr, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
+      fontShader->bind(commandBuffer, *this, m_viewport, Matrix4(), nullptr, nullptr, nullptr, surface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT));
       
       m_debug_text_vbo_data.bind(commandBuffer);
       
       vkCmdDraw(commandBuffer, vertex_count, 1, 0, 0);
     }
     
-    debugPass.end(commandBuffer);
+    debugPass->end(commandBuffer);
 
     m_debug_text_vertices.unlock();
 
@@ -944,34 +945,34 @@ std::string KRCamera::getDebugText()
       draw_call_count++;
       stream << "\n" << draw_call_count << "\t" << (*itr).vertex_count << "\t";
       switch ((*itr).pass) {
-      case KRNode::RENDER_PASS_FORWARD_OPAQUE:
+      case RenderPassType::RENDER_PASS_FORWARD_OPAQUE:
         stream << "opaq";
         break;
-      case KRNode::RENDER_PASS_DEFERRED_GBUFFER:
+      case RenderPassType::RENDER_PASS_DEFERRED_GBUFFER:
         stream << "d gb";
         break;
-      case KRNode::RENDER_PASS_DEFERRED_LIGHTS:
+      case RenderPassType::RENDER_PASS_DEFERRED_LIGHTS:
         stream << "d light";
         break;
-      case KRNode::RENDER_PASS_DEFERRED_OPAQUE:
+      case RenderPassType::RENDER_PASS_DEFERRED_OPAQUE:
         stream << "d opaq";
         break;
-      case KRNode::RENDER_PASS_FORWARD_TRANSPARENT:
+      case RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT:
         stream << "trans";
         break;
-      case KRNode::RENDER_PASS_PARTICLE_OCCLUSION:
+      case RenderPassType::RENDER_PASS_PARTICLE_OCCLUSION:
         stream << "p occl";
         break;
-      case KRNode::RENDER_PASS_ADDITIVE_PARTICLES:
+      case RenderPassType::RENDER_PASS_ADDITIVE_PARTICLES:
         stream << "a part";
         break;
-      case KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE:
+      case RenderPassType::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE:
         stream << "vol add";
         break;
-      case KRNode::RENDER_PASS_GENERATE_SHADOWMAPS:
+      case RenderPassType::RENDER_PASS_GENERATE_SHADOWMAPS:
         stream << "g shadow";
         break;
-      case KRNode::RENDER_PASS_SHADOWMAP:
+      case RenderPassType::RENDER_PASS_SHADOWMAP:
         stream << "shadow";
         break;
       default:
diff --git a/kraken/KRCollider.cpp b/kraken/KRCollider.cpp
index 9152739..98bd6f9 100755
--- a/kraken/KRCollider.cpp
+++ b/kraken/KRCollider.cpp
@@ -33,6 +33,7 @@
 #include "KRCollider.h"
 #include "KRContext.h"
 #include "KRMesh.h"
+#include "KRRenderPass.h"
 
 using namespace hydra;
 
@@ -217,7 +218,7 @@ void KRCollider::render(RenderInfo& ri)
 
   KRNode::render(ri);
 
-  if (ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && ri.camera->settings.debug_display == KRRenderSettings::KRENGINE_DEBUG_DISPLAY_COLLIDERS) {
+  if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT && ri.camera->settings.debug_display == KRRenderSettings::KRENGINE_DEBUG_DISPLAY_COLLIDERS) {
     loadModel();
     if (m_model) {
 
diff --git a/kraken/KRDirectionalLight.cpp b/kraken/KRDirectionalLight.cpp
index e769093..7ac44d4 100755
--- a/kraken/KRDirectionalLight.cpp
+++ b/kraken/KRDirectionalLight.cpp
@@ -34,6 +34,7 @@
 #include "KRDirectionalLight.h"
 #include "KRPipeline.h"
 #include "KRContext.h"
+#include "KRRenderPass.h"
 #include "assert.h"
 
 using namespace hydra;
@@ -131,7 +132,7 @@ void KRDirectionalLight::render(RenderInfo& ri)
 
   KRLight::render(ri);
 
-  if (ri.renderPass == KRNode::RENDER_PASS_DEFERRED_LIGHTS) {
+  if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_DEFERRED_LIGHTS) {
     // Lights are rendered on the second pass of the deferred renderer
 
     std::vector<KRDirectionalLight*> this_light;
diff --git a/kraken/KRLight.cpp b/kraken/KRLight.cpp
index c9eb8e7..91fae9d 100755
--- a/kraken/KRLight.cpp
+++ b/kraken/KRLight.cpp
@@ -42,6 +42,7 @@
 #include "KRDirectionalLight.h"
 #include "KRSpotLight.h"
 #include "KRPointLight.h"
+#include "KRRenderPass.h"
 
 using namespace hydra;
 
@@ -231,12 +232,12 @@ void KRLight::render(RenderInfo& ri)
 
   KRNode::render(ri);
 
-  if (ri.renderPass == KRNode::RENDER_PASS_GENERATE_SHADOWMAPS && (ri.camera->settings.volumetric_environment_enable || ri.camera->settings.dust_particle_enable || (ri.camera->settings.m_cShadowBuffers > 0 && m_casts_shadow))) {
+  if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_GENERATE_SHADOWMAPS && (ri.camera->settings.volumetric_environment_enable || ri.camera->settings.dust_particle_enable || (ri.camera->settings.m_cShadowBuffers > 0 && m_casts_shadow))) {
     allocateShadowBuffers(configureShadowBufferViewports(ri.viewport));
     renderShadowBuffers(ri);
   }
 
-  if (ri.renderPass == KRNode::RENDER_PASS_ADDITIVE_PARTICLES && ri.camera->settings.dust_particle_enable) {
+  if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_ADDITIVE_PARTICLES && ri.camera->settings.dust_particle_enable) {
     // Render brownian particles for dust floating in air
     if (m_cShadowBuffers >= 1 && shadowValid[0] && m_dust_particle_density > 0.0f && m_dust_particle_size > 0.0f && m_dust_particle_intensity > 0.0f) {
 
@@ -296,7 +297,7 @@ void KRLight::render(RenderInfo& ri)
   }
 
 
-  if (ri.renderPass == KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE && ri.camera->settings.volumetric_environment_enable && m_light_shafts) {
+  if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE && ri.camera->settings.volumetric_environment_enable && m_light_shafts) {
     std::string shader_name = ri.camera->settings.volumetric_environment_downsample != 0 ? "volumetric_fog_downsampled" : "volumetric_fog";
 
     std::vector<KRDirectionalLight*> this_directional_light;
@@ -321,7 +322,7 @@ void KRLight::render(RenderInfo& ri)
     info.point_lights = &this_point_light;
     info.directional_lights = &this_directional_light;
     info.spot_lights = &this_spot_light;
-    info.renderPass = KRNode::RENDER_PASS_ADDITIVE_PARTICLES;
+    info.renderPass = ri.renderPass;
     info.rasterMode = RasterMode::kAdditive;
     info.cullMode = CullMode::kCullNone;
     info.vertexAttributes = (1 << KRMesh::KRENGINE_ATTRIB_VERTEX);
@@ -337,14 +338,14 @@ void KRLight::render(RenderInfo& ri)
 
     pFogShader->setPushConstant(KRPipeline::PushConstant::slice_depth_scale, Vector2::Create(slice_near, slice_spacing));
     pFogShader->setPushConstant(KRPipeline::PushConstant::light_color, (m_color * ri.camera->settings.volumetric_environment_intensity * m_intensity * -slice_spacing / 1000.0f));
-    pFogShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, Matrix4(), &this_point_light, &this_directional_light, &this_spot_light, KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE);
+    pFogShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, Matrix4(), &this_point_light, &this_directional_light, &this_spot_light, ri.renderPass);
 
     m_pContext->getMeshManager()->bindVBO(ri.commandBuffer, &m_pContext->getMeshManager()->KRENGINE_VBO_DATA_VOLUMETRIC_LIGHTING, 1.0f);
     vkCmdDraw(ri.commandBuffer, slice_count * 6, 1, 0, 0);
 
   }
 
-  if (ri.renderPass == KRNode::RENDER_PASS_PARTICLE_OCCLUSION) {
+  if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_PARTICLE_OCCLUSION) {
     if (m_flareTexture.size() && m_flareSize > 0.0f) {
       KRMesh* sphereModel = getContext().getMeshManager()->getMaxLODModel("__sphere");
       if (sphereModel) {
@@ -391,7 +392,7 @@ void KRLight::render(RenderInfo& ri)
     }
   }
 
-  if (ri.renderPass == KRNode::RENDER_PASS_ADDITIVE_PARTICLES) {
+  if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_ADDITIVE_PARTICLES) {
     if (m_flareTexture.size() && m_flareSize > 0.0f) {
 
       if (m_occlusionQuery) {
@@ -534,14 +535,14 @@ void KRLight::renderShadowBuffers(RenderInfo& ri)
       std::string shader_name("ShadowShader");
       info.shader_name = &shader_name;
       info.pCamera = ri.camera;
-      info.renderPass = KRNode::RENDER_PASS_FORWARD_TRANSPARENT;
+      info.renderPass = ri.renderPass;
       info.rasterMode = RasterMode::kOpaqueLessTest; // TODO - This is sub-optimal.  Evaluate increasing depth buffer resolution instead of disabling depth test.
       info.cullMode = CullMode::kCullNone; // Disabling culling, which eliminates some self-cast shadow artifacts
       KRPipeline* shadowShader = m_pContext->getPipelineManager()->getPipeline(*ri.surface, info);
 
-      shadowShader->bind(ri.commandBuffer, *ri.camera, m_shadowViewports[iShadow], Matrix4(), nullptr, nullptr, nullptr, KRNode::RENDER_PASS_SHADOWMAP);
+      shadowShader->bind(ri.commandBuffer, *ri.camera, m_shadowViewports[iShadow], Matrix4(), nullptr, nullptr, nullptr, ri.renderPass);
 
-      getScene().render(ri.commandBuffer, *ri.surface, ri.camera, m_shadowViewports[iShadow].getVisibleBounds(), m_shadowViewports[iShadow], KRNode::RENDER_PASS_SHADOWMAP, true);
+      getScene().render(ri.commandBuffer, *ri.surface, ri.camera, m_shadowViewports[iShadow].getVisibleBounds(), m_shadowViewports[iShadow], ri.renderPass, true);
     }
   }
 }
diff --git a/kraken/KRMaterial.cpp b/kraken/KRMaterial.cpp
index 8bb34c9..b05d90e 100755
--- a/kraken/KRMaterial.cpp
+++ b/kraken/KRMaterial.cpp
@@ -33,6 +33,7 @@
 
 #include "KRMaterial.h"
 #include "KRTextureManager.h"
+#include "KRRenderPass.h"
 
 #include "KRContext.h"
 
@@ -414,14 +415,14 @@ void KRMaterial::bind(const KRNode::RenderInfo& ri, ModelFormat modelFormat, __u
 
   pShader->setPushConstant(KRPipeline::PushConstant::material_ambient, m_ambientColor + ri.camera->settings.ambient_intensity);
 
-  if (ri.renderPass == KRNode::RENDER_PASS_FORWARD_OPAQUE) {
+  if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_FORWARD_OPAQUE) {
     // We pre-multiply the light color with the material color in the forward renderer
     pShader->setPushConstant(KRPipeline::PushConstant::material_diffuse, Vector3::Create(m_diffuseColor.x * ri.camera->settings.light_intensity.x, m_diffuseColor.y * ri.camera->settings.light_intensity.y, m_diffuseColor.z * ri.camera->settings.light_intensity.z));
   } else {
     pShader->setPushConstant(KRPipeline::PushConstant::material_diffuse, m_diffuseColor);
   }
 
-  if (ri.renderPass == KRNode::RENDER_PASS_FORWARD_OPAQUE) {
+  if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_FORWARD_OPAQUE) {
     // We pre-multiply the light color with the material color in the forward renderer
     pShader->setPushConstant(KRPipeline::PushConstant::material_specular, Vector3::Create(m_specularColor.x * ri.camera->settings.light_intensity.x, m_specularColor.y * ri.camera->settings.light_intensity.y, m_specularColor.z * ri.camera->settings.light_intensity.z));
   } else {
diff --git a/kraken/KRMesh.cpp b/kraken/KRMesh.cpp
index 679ca80..a8e07c2 100755
--- a/kraken/KRMesh.cpp
+++ b/kraken/KRMesh.cpp
@@ -37,6 +37,7 @@
 #include "KRPipeline.h"
 #include "KRPipelineManager.h"
 #include "KRContext.h"
+#include "KRRenderPass.h"
 #include "../3rdparty/forsyth/forsyth.h"
 
 using namespace mimir;
@@ -254,7 +255,7 @@ kraken_stream_level KRMesh::getStreamLevel()
 void KRMesh::render(const KRNode::RenderInfo& ri, const std::string& object_name, const Matrix4& matModel, KRTexture* pLightMap, const std::vector<KRBone*>& bones, const Vector3& rim_color, float rim_power, float lod_coverage)
 {
   //fprintf(stderr, "Rendering model: %s\n", m_name.c_str());
-  if (ri.renderPass != KRNode::RENDER_PASS_ADDITIVE_PARTICLES && ri.renderPass != KRNode::RENDER_PASS_PARTICLE_OCCLUSION && ri.renderPass != KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE) {
+  if (ri.renderPass->getType() != RenderPassType::RENDER_PASS_ADDITIVE_PARTICLES && ri.renderPass->getType() != RenderPassType::RENDER_PASS_PARTICLE_OCCLUSION && ri.renderPass->getType() != RenderPassType::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE) {
     preStream(lod_coverage);
     if (getStreamLevel() == kraken_stream_level::STREAM_LEVEL_OUT) {
 
@@ -264,7 +265,7 @@ void KRMesh::render(const KRNode::RenderInfo& ri, const std::string& object_name
       getMaterials();
 
       int cSubmeshes = (int)m_submeshes.size();
-      if (ri.renderPass == KRNode::RENDER_PASS_SHADOWMAP) {
+      if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_SHADOWMAP) {
         for (int iSubmesh = 0; iSubmesh < cSubmeshes; iSubmesh++) {
           KRMaterial* pMaterial = m_materials[iSubmesh];
 
@@ -284,7 +285,7 @@ void KRMesh::render(const KRNode::RenderInfo& ri, const std::string& object_name
             KRMaterial* pMaterial = m_materials[iSubmesh];
 
             if (pMaterial != NULL && pMaterial == (*mat_itr)) {
-              if ((!pMaterial->isTransparent() && ri.renderPass != KRNode::RENDER_PASS_FORWARD_TRANSPARENT) || (pMaterial->isTransparent() && ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT)) {
+              if ((!pMaterial->isTransparent() && ri.renderPass->getType() != RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT) || (pMaterial->isTransparent() && ri.renderPass->getType() == RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT)) {
                 std::vector<Matrix4> bone_bind_poses;
                 for (int i = 0; i < (int)bones.size(); i++) {
                   bone_bind_poses.push_back(getBoneBindPose(i));
@@ -437,7 +438,7 @@ void KRMesh::createDataBlocks(KRMeshManager::KRVBOData::vbo_type t)
   }
 }
 
-void KRMesh::renderNoMaterials(VkCommandBuffer& commandBuffer, KRNode::RenderPass renderPass, const std::string& object_name, const std::string& material_name, float lodCoverage)
+void KRMesh::renderNoMaterials(VkCommandBuffer& commandBuffer, const KRRenderPass* renderPass, const std::string& object_name, const std::string& material_name, float lodCoverage)
 {
   int submesh_count = getSubmeshCount();
   for (int i = 0; i < submesh_count; i++) {
@@ -458,7 +459,7 @@ bool KRMesh::isReady() const
   return true;
 }
 
-void KRMesh::renderSubmesh(VkCommandBuffer& commandBuffer, int iSubmesh, KRNode::RenderPass renderPass, const std::string& object_name, const std::string& material_name, float lodCoverage)
+void KRMesh::renderSubmesh(VkCommandBuffer& commandBuffer, int iSubmesh, const KRRenderPass* renderPass, const std::string& object_name, const std::string& material_name, float lodCoverage)
 {
   getSubmeshes();
 
@@ -485,7 +486,7 @@ void KRMesh::renderSubmesh(VkCommandBuffer& commandBuffer, int iSubmesh, KRNode:
       if (vertex_draw_count > index_count - index_group_offset) vertex_draw_count = index_count - index_group_offset;
 
       vkCmdDrawIndexed(commandBuffer, vertex_draw_count, 1, index_group_offset, 0, 0);
-      m_pContext->getMeshManager()->log_draw_call(renderPass, object_name, material_name, vertex_draw_count);
+      m_pContext->getMeshManager()->log_draw_call(renderPass->getType(), object_name, material_name, vertex_draw_count);
       cVertexes -= vertex_draw_count;
       index_group_offset = 0;
     }
@@ -515,7 +516,7 @@ void KRMesh::renderSubmesh(VkCommandBuffer& commandBuffer, int iSubmesh, KRNode:
           vkCmdDrawIndexed(commandBuffer, (MAX_VBO_SIZE - iVertex), 1, iVertex, 0, 0);
           break;
         }
-        m_pContext->getMeshManager()->log_draw_call(renderPass, object_name, material_name, (MAX_VBO_SIZE - iVertex));
+        m_pContext->getMeshManager()->log_draw_call(renderPass->getType(), object_name, material_name, (MAX_VBO_SIZE - iVertex));
 
         cVertexes -= (MAX_VBO_SIZE - iVertex);
         iVertex = 0;
@@ -531,7 +532,7 @@ void KRMesh::renderSubmesh(VkCommandBuffer& commandBuffer, int iSubmesh, KRNode:
         default:
           break;
         }
-        m_pContext->getMeshManager()->log_draw_call(renderPass, object_name, material_name, cVertexes);
+        m_pContext->getMeshManager()->log_draw_call(renderPass->getType(), object_name, material_name, cVertexes);
 
         cVertexes = 0;
       }
diff --git a/kraken/KRMesh.h b/kraken/KRMesh.h
index 259c4fc..fcf3b57 100755
--- a/kraken/KRMesh.h
+++ b/kraken/KRMesh.h
@@ -56,6 +56,7 @@ using namespace kraken;
 
 class KRMaterial;
 class KRNode;
+class KRRenderPass;
 
 enum class ModelFormat : __uint8_t
 {
@@ -133,7 +134,7 @@ public:
   void optimize();
   void optimizeIndexes();
 
-  void renderNoMaterials(VkCommandBuffer& commandBuffer, KRNode::RenderPass renderPass, const std::string& object_name, const std::string& material_name, float lodCoverage);
+  void renderNoMaterials(VkCommandBuffer& commandBuffer, const KRRenderPass* renderPass, const std::string& object_name, const std::string& material_name, float lodCoverage);
   bool isReady() const;
 
   float getMaxDimension();
@@ -245,7 +246,7 @@ private:
 
   void getSubmeshes();
   void getMaterials();
-  void renderSubmesh(VkCommandBuffer& commandBuffer, int iSubmesh, KRNode::RenderPass renderPass, const std::string& object_name, const std::string& material_name, float lodCoverage);
+  void renderSubmesh(VkCommandBuffer& commandBuffer, int iSubmesh, const KRRenderPass* renderPass, const std::string& object_name, const std::string& material_name, float lodCoverage);
 
   static bool rayCast(const hydra::Vector3& start, const hydra::Vector3& dir, const hydra::Triangle3& tri, const hydra::Vector3& tri_n0, const hydra::Vector3& tri_n1, const hydra::Vector3& tri_n2, hydra::HitInfo& hitinfo);
   static bool sphereCast(const hydra::Matrix4& model_to_world, const hydra::Vector3& v0, const hydra::Vector3& v1, float radius, const hydra::Triangle3& tri, hydra::HitInfo& hitinfo);
diff --git a/kraken/KRMeshManager.cpp b/kraken/KRMeshManager.cpp
index 7690dde..e24493d 100755
--- a/kraken/KRMeshManager.cpp
+++ b/kraken/KRMeshManager.cpp
@@ -37,6 +37,7 @@
 #include "KRMeshCube.h"
 #include "KRMeshQuad.h"
 #include "KRMeshSphere.h"
+#include "KRRenderPass.h"
 
 using namespace mimir;
 
@@ -441,7 +442,7 @@ size_t KRMeshManager::getActiveVBOCount()
   return m_vbosActive.size();
 }
 
-void KRMeshManager::log_draw_call(KRNode::RenderPass pass, const std::string& object_name, const std::string& material_name, int vertex_count)
+void KRMeshManager::log_draw_call(RenderPassType pass, const std::string& object_name, const std::string& material_name, int vertex_count)
 {
   if (m_draw_call_logging_enabled) {
     draw_call_info info;
diff --git a/kraken/KRMeshManager.h b/kraken/KRMeshManager.h
index 079106c..91a3d5f 100755
--- a/kraken/KRMeshManager.h
+++ b/kraken/KRMeshManager.h
@@ -40,6 +40,7 @@
 
 class KRContext;
 class KRMesh;
+enum RenderPassType : uint8_t;
 
 class KRMeshManager : public KRResourceManager
 {
@@ -191,13 +192,13 @@ public:
 
   struct draw_call_info
   {
-    KRNode::RenderPass pass;
+    RenderPassType pass;
     char object_name[256];
     char material_name[256];
     int vertex_count;
   };
 
-  void log_draw_call(KRNode::RenderPass pass, const std::string& object_name, const std::string& material_name, int vertex_count);
+  void log_draw_call(RenderPassType pass, const std::string& object_name, const std::string& material_name, int vertex_count);
   std::vector<draw_call_info> getDrawCalls();
 
 
diff --git a/kraken/KRModel.cpp b/kraken/KRModel.cpp
index 8cc4823..4e41912 100755
--- a/kraken/KRModel.cpp
+++ b/kraken/KRModel.cpp
@@ -35,6 +35,7 @@
 #include "KRContext.h"
 #include "KRMesh.h"
 #include "KRNode.h"
+#include "KRRenderPass.h"
 
 using namespace hydra;
 
@@ -197,7 +198,7 @@ void KRModel::loadModel()
 void KRModel::render(KRNode::RenderInfo& ri)
 {
 
-  if (m_lod_visible >= LOD_VISIBILITY_PRESTREAM && ri.renderPass == KRNode::RENDER_PASS_PRESTREAM) {
+  if (m_lod_visible >= LOD_VISIBILITY_PRESTREAM && ri.renderPass->getType() == RenderPassType::RENDER_PASS_PRESTREAM) {
     preStream(ri.viewport);
   }
 
@@ -205,12 +206,12 @@ void KRModel::render(KRNode::RenderInfo& ri)
 
   KRNode::render(ri);
 
-  if (ri.renderPass != KRNode::RENDER_PASS_DEFERRED_LIGHTS
-    && ri.renderPass != KRNode::RENDER_PASS_ADDITIVE_PARTICLES
-    && ri.renderPass != KRNode::RENDER_PASS_PARTICLE_OCCLUSION
-    && ri.renderPass != KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE
-    && ri.renderPass != KRNode::RENDER_PASS_GENERATE_SHADOWMAPS
-    && ri.renderPass != KRNode::RENDER_PASS_PRESTREAM) {
+  if (ri.renderPass->getType() != RenderPassType::RENDER_PASS_DEFERRED_LIGHTS
+    && ri.renderPass->getType() != RenderPassType::RENDER_PASS_ADDITIVE_PARTICLES
+    && ri.renderPass->getType() != RenderPassType::RENDER_PASS_PARTICLE_OCCLUSION
+    && ri.renderPass->getType()!= RenderPassType::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE
+    && ri.renderPass->getType() != RenderPassType::RENDER_PASS_GENERATE_SHADOWMAPS
+    && ri.renderPass->getType() != RenderPassType::RENDER_PASS_PRESTREAM) {
     loadModel();
 
     if (m_models.size() > 0) {
@@ -246,7 +247,7 @@ void KRModel::render(KRNode::RenderInfo& ri)
           m_pLightMap = getContext().getTextureManager()->getTexture(m_lightMap);
         }
 
-        if (m_pLightMap && ri.camera->settings.bEnableLightMap && ri.renderPass != RENDER_PASS_SHADOWMAP && ri.renderPass != RENDER_PASS_GENERATE_SHADOWMAPS) {
+        if (m_pLightMap && ri.camera->settings.bEnableLightMap && ri.renderPass->getType() != RENDER_PASS_SHADOWMAP && ri.renderPass->getType() != RENDER_PASS_GENERATE_SHADOWMAPS) {
           m_pLightMap->resetPoolExpiry(lod_coverage, KRTexture::TEXTURE_USAGE_LIGHT_MAP);
           // TODO - Vulkan refactoring.  We need to bind the shadow map in KRMesh::Render
           // m_pContext->getTextureManager()->selectTexture(5, m_pLightMap, lod_coverage, KRTexture::TEXTURE_USAGE_LIGHT_MAP);
diff --git a/kraken/KRNode.h b/kraken/KRNode.h
index a13234d..327b44d 100755
--- a/kraken/KRNode.h
+++ b/kraken/KRNode.h
@@ -55,6 +55,7 @@ class KRNode;
 class KRPointLight;
 class KRSpotLight;
 class KRDirectionalLight;
+class KRRenderPass;
 namespace tinyxml2 {
 class XMLNode;
 class XMLAttribute;
@@ -63,20 +64,6 @@ class XMLAttribute;
 class KRNode : public KRContextObject
 {
 public:
-  enum RenderPass
-  {
-    RENDER_PASS_FORWARD_OPAQUE,
-    RENDER_PASS_DEFERRED_GBUFFER,
-    RENDER_PASS_DEFERRED_LIGHTS,
-    RENDER_PASS_DEFERRED_OPAQUE,
-    RENDER_PASS_FORWARD_TRANSPARENT,
-    RENDER_PASS_PARTICLE_OCCLUSION,
-    RENDER_PASS_ADDITIVE_PARTICLES,
-    RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE,
-    RENDER_PASS_GENERATE_SHADOWMAPS,
-    RENDER_PASS_SHADOWMAP,
-    RENDER_PASS_PRESTREAM
-  };
 
   enum LodVisibility
   {
@@ -104,7 +91,7 @@ public:
     std::vector<KRDirectionalLight*> directional_lights;
     std::vector<KRSpotLight*> spot_lights;
     KRViewport viewport;
-    RenderPass renderPass;
+    const KRRenderPass* renderPass;
   };
 
   static void InitNodeInfo(KrNodeInfo* nodeInfo);
diff --git a/kraken/KRParticleSystemNewtonian.cpp b/kraken/KRParticleSystemNewtonian.cpp
index 98e1992..7ba269d 100755
--- a/kraken/KRParticleSystemNewtonian.cpp
+++ b/kraken/KRParticleSystemNewtonian.cpp
@@ -34,6 +34,7 @@
 #include "KRParticleSystemNewtonian.h"
 #include "KRTexture.h"
 #include "KRContext.h"
+#include "KRRenderPass.h"
 
 using namespace hydra;
 
@@ -87,7 +88,7 @@ void KRParticleSystemNewtonian::render(RenderInfo& ri)
 
   KRNode::render(ri);
 
-  if (ri.renderPass == KRNode::RENDER_PASS_ADDITIVE_PARTICLES) {
+  if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_ADDITIVE_PARTICLES) {
     if (ri.viewport.visible(getBounds())) {
 
       int particle_count = 10000;
diff --git a/kraken/KRPipeline.cpp b/kraken/KRPipeline.cpp
index b862d3d..aa8e88d 100644
--- a/kraken/KRPipeline.cpp
+++ b/kraken/KRPipeline.cpp
@@ -111,7 +111,7 @@ const char* KRPipeline::KRENGINE_PUSH_CONSTANT_NAMES[] = {
     "fade_color", // PushConstant::fade_color
 };
 
-KRPipeline::KRPipeline(KRContext& context, KrDeviceHandle deviceHandle, KRRenderPass& renderPass, Vector2i viewport_size, Vector2i scissor_size, const PipelineInfo& info, const char* szKey, const std::vector<KRShader*>& shaders, uint32_t vertexAttributes, ModelFormat modelFormat)
+KRPipeline::KRPipeline(KRContext& context, KrDeviceHandle deviceHandle, KRRenderPass* renderPass, Vector2i viewport_size, Vector2i scissor_size, const PipelineInfo& info, const char* szKey, const std::vector<KRShader*>& shaders, uint32_t vertexAttributes, ModelFormat modelFormat)
   : KRContextObject(context)
   , m_deviceHandle(deviceHandle)
 {
@@ -459,7 +459,7 @@ KRPipeline::KRPipeline(KRContext& context, KrDeviceHandle deviceHandle, KRRender
   pipelineInfo.pColorBlendState = &colorBlending;
   pipelineInfo.pDynamicState = nullptr;
   pipelineInfo.layout = m_pipelineLayout;
-  pipelineInfo.renderPass = renderPass.m_renderPass;
+  pipelineInfo.renderPass = renderPass->m_renderPass;
   pipelineInfo.subpass = 0;
   pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
   pipelineInfo.basePipelineIndex = -1;
@@ -651,7 +651,7 @@ void KRPipeline::updateDescriptorBinding()
   // Vulkan Refactoring
 }
 
-bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera& camera, const KRViewport& viewport, const Matrix4& matModel, const std::vector<KRPointLight*>* point_lights, const std::vector<KRDirectionalLight*>* directional_lights, const std::vector<KRSpotLight*>* spot_lights, const KRNode::RenderPass& renderPass)
+bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera& camera, const KRViewport& viewport, const Matrix4& matModel, const std::vector<KRPointLight*>* point_lights, const std::vector<KRDirectionalLight*>* directional_lights, const std::vector<KRSpotLight*>* spot_lights, const KRRenderPass* renderPass)
 {
   updateDescriptorBinding();
   updateDescriptorSets();
@@ -662,7 +662,7 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera& camera, const KR
   //int light_point_count = 0;
   //int light_spot_count = 0;
   // TODO - Need to support multiple lights and more light types in forward rendering
-  if (renderPass != KRNode::RENDER_PASS_DEFERRED_LIGHTS && renderPass != KRNode::RENDER_PASS_DEFERRED_GBUFFER && renderPass != KRNode::RENDER_PASS_DEFERRED_OPAQUE && renderPass != KRNode::RENDER_PASS_GENERATE_SHADOWMAPS) {
+  if (renderPass->getType() != RenderPassType::RENDER_PASS_DEFERRED_LIGHTS && renderPass->getType() != RenderPassType::RENDER_PASS_DEFERRED_GBUFFER && renderPass->getType() != RenderPassType::RENDER_PASS_DEFERRED_OPAQUE && renderPass->getType() != RenderPassType::RENDER_PASS_GENERATE_SHADOWMAPS) {
 
 
     if (directional_lights) {
diff --git a/kraken/KRPipeline.h b/kraken/KRPipeline.h
index 4c6ca82..b983d8a 100644
--- a/kraken/KRPipeline.h
+++ b/kraken/KRPipeline.h
@@ -207,18 +207,18 @@ public:
   CullMode cullMode;
   uint32_t vertexAttributes;
   ModelFormat modelFormat;
-  KRNode::RenderPass renderPass;
+  const KRRenderPass* renderPass;
 };
 
 class KRPipeline : public KRContextObject
 {
 public:
 
-  KRPipeline(KRContext& context, KrDeviceHandle deviceHandle, KRRenderPass& renderPass, hydra::Vector2i viewport_size, hydra::Vector2i scissor_size, const PipelineInfo& info, const char* szKey, const std::vector<KRShader*>& shaders, uint32_t vertexAttributes, ModelFormat modelFormat);
+  KRPipeline(KRContext& context, KrDeviceHandle deviceHandle, KRRenderPass* renderPass, hydra::Vector2i viewport_size, hydra::Vector2i scissor_size, const PipelineInfo& info, const char* szKey, const std::vector<KRShader*>& shaders, uint32_t vertexAttributes, ModelFormat modelFormat);
   virtual ~KRPipeline();
   const char* getKey() const;
 
-  bool bind(VkCommandBuffer& commandBuffer, KRCamera& camera, const KRViewport& viewport, const hydra::Matrix4& matModel, const std::vector<KRPointLight*>* point_lights, const std::vector<KRDirectionalLight*>* directional_lights, const std::vector<KRSpotLight*>* spot_lights, const KRNode::RenderPass& renderPass);
+  bool bind(VkCommandBuffer& commandBuffer, KRCamera& camera, const KRViewport& viewport, const hydra::Matrix4& matModel, const std::vector<KRPointLight*>* point_lights, const std::vector<KRDirectionalLight*>* directional_lights, const std::vector<KRSpotLight*>* spot_lights, const KRRenderPass* renderPass);
 
   enum class PushConstant : uint8_t
   {
diff --git a/kraken/KRPipelineManager.cpp b/kraken/KRPipelineManager.cpp
index 85ed542..500c720 100644
--- a/kraken/KRPipelineManager.cpp
+++ b/kraken/KRPipelineManager.cpp
@@ -37,6 +37,7 @@
 #include "KRSpotLight.h"
 #include "KRPointLight.h"
 #include "KRSwapchain.h"
+#include "KRRenderPass.h"
 
 #ifndef ANDROID
 #include "glslang/Public/ShaderLang.h"
@@ -83,7 +84,7 @@ KRPipeline* KRPipelineManager::getPipeline(KRSurface& surface, const PipelineInf
   std::vector<KRShader*> shaders;
   shaders.push_back(m_pContext->getShaderManager()->get(*info.shader_name + ".vert", "spv"));
   shaders.push_back(m_pContext->getShaderManager()->get(*info.shader_name + ".frag", "spv"));
-  KRPipeline* pipeline = new KRPipeline(*m_pContext, surface.m_deviceHandle, surface.getForwardOpaquePass(), surface.getDimensions(), surface.getDimensions(), info, info.shader_name->c_str(), shaders, info.vertexAttributes, info.modelFormat);
+  KRPipeline* pipeline = new KRPipeline(*m_pContext, surface.m_deviceHandle, surface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_OPAQUE), surface.getDimensions(), surface.getDimensions(), info, info.shader_name->c_str(), shaders, info.vertexAttributes, info.modelFormat);
 
   m_pipelines[key] = pipeline;
 
@@ -100,7 +101,7 @@ KRPipeline *KRPipelineManager::getPipeline(KRSurface& surface, const PipelineInf
     int light_directional_count = 0;
     int light_point_count = 0;
     int light_spot_count = 0;
-    if(info.renderPass != KRNode::RENDER_PASS_DEFERRED_LIGHTS && info.renderPass != KRNode::RENDER_PASS_DEFERRED_GBUFFER && info.renderPass != KRNode::RENDER_PASS_DEFERRED_OPAQUE && info.renderPass != KRNode::RENDER_PASS_GENERATE_SHADOWMAPS) {
+    if(info.renderPass != RenderPassType::RENDER_PASS_DEFERRED_LIGHTS && info.renderPass != RenderPassType::RENDER_PASS_DEFERRED_GBUFFER && info.renderPass != RenderPassType::RENDER_PASS_DEFERRED_OPAQUE && info.renderPass != RenderPassType::RENDER_PASS_GENERATE_SHADOWMAPS) {
         if (info.directional_lights) {
           light_directional_count = (int)info.directional_lights->size();
         }
@@ -236,13 +237,13 @@ KRPipeline *KRPipelineManager::getPipeline(KRSurface& surface, const PipelineInf
         stream << "\n#define ENABLE_FADE_COLOR " << (bFadeColorEnabled ? "1" : "0");
         stream << "\n#define FOG_TYPE " << info.pCamera->settings.fog_type;
         switch(info.renderPass) {
-            case KRNode::RENDER_PASS_DEFERRED_GBUFFER:
+            case RenderPassType::RENDER_PASS_DEFERRED_GBUFFER:
                 stream << "\n#define GBUFFER_PASS " << 1;
                 break;
-            case KRNode::RENDER_PASS_DEFERRED_LIGHTS:
+            case RenderPassType::RENDER_PASS_DEFERRED_LIGHTS:
                 stream << "\n#define GBUFFER_PASS " << 2;
                 break;
-            case KRNode::RENDER_PASS_DEFERRED_OPAQUE:
+            case RenderPassType::RENDER_PASS_DEFERRED_OPAQUE:
                 stream << "\n#define GBUFFER_PASS " << 3;
                 break;
             default:
@@ -310,4 +311,4 @@ KRPipeline* KRPipelineManager::get(const char* name)
     return nullptr;
   }
   return (*itr).second;
-}
\ No newline at end of file
+}
diff --git a/kraken/KRPointLight.cpp b/kraken/KRPointLight.cpp
index 5923ae5..6ef7e5f 100755
--- a/kraken/KRPointLight.cpp
+++ b/kraken/KRPointLight.cpp
@@ -34,6 +34,7 @@
 #include "KRPointLight.h"
 #include "KRCamera.h"
 #include "KRContext.h"
+#include "KRRenderPass.h"
 
 using namespace hydra;
 
@@ -78,9 +79,9 @@ void KRPointLight::render(RenderInfo& ri)
 
   KRLight::render(ri);
 
-  bool bVisualize = ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && ri.camera->settings.bShowDeferred;
+  bool bVisualize = ri.renderPass->getType() == RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT && ri.camera->settings.bShowDeferred;
 
-  if (ri.renderPass == KRNode::RENDER_PASS_DEFERRED_LIGHTS || bVisualize) {
+  if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_DEFERRED_LIGHTS || bVisualize) {
     // Lights are rendered on the second pass of the deferred renderer
 
     std::vector<KRPointLight*> this_light;
diff --git a/kraken/KRRenderGraph.cpp b/kraken/KRRenderGraph.cpp
index db6187f..98a991e 100644
--- a/kraken/KRRenderGraph.cpp
+++ b/kraken/KRRenderGraph.cpp
@@ -32,6 +32,7 @@
 #include "KRRenderGraph.h"
 #include "KRRenderPass.h"
 #include "KRSurface.h"
+#include "KRDevice.h"
 
 KRRenderGraph::KRRenderGraph(KRContext& context)
   : KRContextObject(context)
@@ -43,16 +44,34 @@ KRRenderGraph::~KRRenderGraph()
 {
 }
 
-void KRRenderGraph::addRenderPass(KRRenderPass *pass)
+void KRRenderGraph::addRenderPass(KRDevice& device, const RenderPassInfo& info)
 {
-  m_renderPasses.push_back(pass);
+  KRRenderPass &pass = m_renderPasses.emplace_back(getContext());
+  pass.create(device, info);
 }
 
+KRRenderPass* KRRenderGraph::getRenderPass(RenderPassType type)
+{
+  for(KRRenderPass& pass : m_renderPasses) {
+    if (pass.getType() == type) {
+      return &pass;
+    }
+  }
+  return nullptr;
+}
 
 void KRRenderGraph::render(VkCommandBuffer &commandBuffer, KRSurface& surface)
 {
-  for(KRRenderPass* pass : m_renderPasses) {
-    pass->begin(commandBuffer, surface);
-    pass->end(commandBuffer);
+  for(KRRenderPass& pass : m_renderPasses) {
+    pass.begin(commandBuffer, surface);
+    pass.end(commandBuffer);
   }
 }
+
+void KRRenderGraph::destroy(KRDevice& device)
+{
+  for(KRRenderPass& pass : m_renderPasses) {
+    pass.destroy(device);
+  }
+  m_renderPasses.clear();
+}
diff --git a/kraken/KRRenderGraph.h b/kraken/KRRenderGraph.h
index 13a37b9..fc32578 100644
--- a/kraken/KRRenderGraph.h
+++ b/kraken/KRRenderGraph.h
@@ -34,9 +34,13 @@
 #include "KREngine-common.h"
 
 #include "KRContextObject.h"
+#include "KRRenderPass.h"
 
 class KRRenderPass;
 class KRSurface;
+class KRDevice;
+struct RenderPassInfo;
+enum RenderPassType : uint8_t;
 
 class KRRenderGraph : public KRContextObject
 {
@@ -44,11 +48,13 @@ public:
   KRRenderGraph(KRContext& context);
   ~KRRenderGraph();
   
-  void addRenderPass(KRRenderPass* pass);
+  void addRenderPass(KRDevice& device, const RenderPassInfo& info);
+  KRRenderPass* getRenderPass(RenderPassType type);
   void render(VkCommandBuffer &commandBuffer, KRSurface& surface);
+  void destroy(KRDevice& device);
     
 private:
   
-  std::vector<KRRenderPass*> m_renderPasses;
+  std::list<KRRenderPass> m_renderPasses;
 
 };
diff --git a/kraken/KRRenderPass.cpp b/kraken/KRRenderPass.cpp
index 2899f2d..2b69b2e 100644
--- a/kraken/KRRenderPass.cpp
+++ b/kraken/KRRenderPass.cpp
@@ -48,7 +48,7 @@ KRRenderPass::~KRRenderPass()
   assert(m_renderPass == VK_NULL_HANDLE);
 }
 
-void KRRenderPass::create(KRDevice& device, VkFormat swapChainImageFormat, VkFormat depthImageFormat, const RenderPassInfo& info)
+void KRRenderPass::create(KRDevice& device, const RenderPassInfo& info)
 {
   if (m_renderPass) {
     return;
@@ -56,7 +56,7 @@ void KRRenderPass::create(KRDevice& device, VkFormat swapChainImageFormat, VkFor
   m_info = info;
 
   VkAttachmentDescription colorAttachment{};
-  colorAttachment.format = swapChainImageFormat;
+  colorAttachment.format = info.colorFormat;
   colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
   colorAttachment.loadOp = info.clearColor ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD;
   colorAttachment.storeOp = info.keepColor ? VK_ATTACHMENT_STORE_OP_STORE : VK_ATTACHMENT_STORE_OP_DONT_CARE;
@@ -71,7 +71,7 @@ void KRRenderPass::create(KRDevice& device, VkFormat swapChainImageFormat, VkFor
 
 
   VkAttachmentDescription depthAttachment{};
-  depthAttachment.format = depthImageFormat;
+  depthAttachment.format = info.depthStencilFormat;
   depthAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
   depthAttachment.loadOp = info.clearDepth ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD;
   depthAttachment.storeOp = info.keepDepth ? VK_ATTACHMENT_STORE_OP_STORE : VK_ATTACHMENT_STORE_OP_DONT_CARE;
@@ -152,3 +152,9 @@ void KRRenderPass::end(VkCommandBuffer& commandBuffer)
 {
   vkCmdEndRenderPass(commandBuffer);
 }
+
+
+RenderPassType KRRenderPass::getType() const
+{
+  return m_info.type;
+}
diff --git a/kraken/KRRenderPass.h b/kraken/KRRenderPass.h
index 7d4cc65..83adb8f 100644
--- a/kraken/KRRenderPass.h
+++ b/kraken/KRRenderPass.h
@@ -36,31 +36,59 @@
 
 class KRSurface;
 
+enum RenderPassType : uint8_t
+{
+  RENDER_PASS_FORWARD_OPAQUE,
+  RENDER_PASS_DEFERRED_GBUFFER,
+  RENDER_PASS_DEFERRED_LIGHTS,
+  RENDER_PASS_DEFERRED_OPAQUE,
+  RENDER_PASS_FORWARD_TRANSPARENT,
+  RENDER_PASS_PARTICLE_OCCLUSION,
+  RENDER_PASS_ADDITIVE_PARTICLES,
+  RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE,
+  RENDER_PASS_GENERATE_SHADOWMAPS,
+  RENDER_PASS_SHADOWMAP,
+  RENDER_PASS_PRESTREAM,
+  RENDER_PASS_POST_COMPOSITE,
+  RENDER_PASS_DEBUG_OVERLAYS,
+  RENDER_PASS_BLACK_FRAME,
+};
+
+struct RenderPassInfo
+{
+  RenderPassType type;
+  bool clearColor;
+  bool keepColor;
+  hydra::Vector4 clearColorValue;
+  VkFormat colorFormat;
+  
+  bool clearDepth;
+  bool keepDepth;
+  float clearDepthValue;
+  
+  bool clearStencil;
+  bool keepStencil;
+  uint32_t clearStencilValue;
+  
+  VkFormat depthStencilFormat;
+  
+  bool finalPass;
+};
+
 class KRRenderPass : public KRContextObject
 {
 public:
+  
   KRRenderPass(KRContext& context);
   ~KRRenderPass();
 
-  struct RenderPassInfo
-  {
-    bool clearColor;
-    bool keepColor;
-    bool clearDepth;
-    bool keepDepth;
-    bool clearStencil;
-    bool keepStencil;
-    bool finalPass;
-    hydra::Vector4 clearColorValue;
-    float clearDepthValue;
-    uint32_t clearStencilValue;
-  };
-
-  void create(KRDevice& device, VkFormat swapChainImageFormat, VkFormat depthImageFormat, const RenderPassInfo& info);
+  void create(KRDevice& device, const RenderPassInfo& info);
   void destroy(KRDevice& device);
 
   void begin(VkCommandBuffer& commandBuffer, KRSurface& surface);
   void end(VkCommandBuffer& commandBuffer);
+  
+  RenderPassType getType() const;
 
   // private:
   VkRenderPass m_renderPass;
diff --git a/kraken/KRReverbZone.cpp b/kraken/KRReverbZone.cpp
index 6bd3a76..e167ad1 100755
--- a/kraken/KRReverbZone.cpp
+++ b/kraken/KRReverbZone.cpp
@@ -31,6 +31,7 @@
 
 #include "KRReverbZone.h"
 #include "KRContext.h"
+#include "KRRenderPass.h"
 
 using namespace hydra;
 
@@ -126,7 +127,7 @@ void KRReverbZone::render(RenderInfo& ri)
 
   bool bVisualize = ri.camera->settings.debug_display == KRRenderSettings::KRENGINE_DEBUG_DISPLAY_SIREN_REVERB_ZONES;
 
-  if (ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
+  if (ri.renderPass->getType()== RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
     KRMesh* sphereModel = getContext().getMeshManager()->getMaxLODModel("__sphere");
     if (sphereModel) {
       Matrix4 sphereModelMatrix = getModelMatrix();
@@ -190,4 +191,4 @@ float KRReverbZone::getContainment(const Vector3& pos)
   } else {
     return 0.0f;
   }
-}
\ No newline at end of file
+}
diff --git a/kraken/KRScene.cpp b/kraken/KRScene.cpp
index 586af1a..9332eab 100755
--- a/kraken/KRScene.cpp
+++ b/kraken/KRScene.cpp
@@ -39,6 +39,7 @@
 #include "KRSpotLight.h"
 #include "KRPointLight.h"
 #include "KRAudioManager.h"
+#include "KRRenderPass.h"
 
 using namespace mimir;
 using namespace hydra;
@@ -102,7 +103,7 @@ std::set<KRLight*>& KRScene::getLights()
   return m_lights;
 }
 
-void KRScene::render(VkCommandBuffer& commandBuffer, KRSurface& surface, KRCamera* pCamera, unordered_map<AABB, int>& visibleBounds, const KRViewport& viewport, KRNode::RenderPass renderPass, bool new_frame)
+void KRScene::render(VkCommandBuffer& commandBuffer, KRSurface& surface, KRCamera* pCamera, unordered_map<AABB, int>& visibleBounds, const KRViewport& viewport, const KRRenderPass* renderPass, bool new_frame)
 {
   if (new_frame) {
     // Expire cached occlusion test results.
@@ -217,7 +218,7 @@ void KRScene::render(KRNode::RenderInfo& ri, KROctreeNode* pOctreeNode, unordere
       }
     } else {
       bool in_viewport = false;
-      if (ri.renderPass == KRNode::RENDER_PASS_PRESTREAM) {
+      if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_PRESTREAM) {
         // When pre-streaming, objects are streamed in behind and in-front of the camera
         AABB viewportExtents = AABB::Create(ri.viewport.getCameraPosition() - Vector3::Create(ri.camera->settings.getPerspectiveFarZ()), ri.viewport.getCameraPosition() + Vector3::Create(ri.camera->settings.getPerspectiveFarZ()));
         in_viewport = octreeBounds.intersects(viewportExtents);
@@ -299,7 +300,7 @@ void KRScene::render(KRNode::RenderInfo& ri, KROctreeNode* pOctreeNode, unordere
           info.point_lights = &ri.point_lights;
           info.directional_lights = &ri.directional_lights;
           info.spot_lights = &ri.spot_lights;
-          info.renderPass = KRNode::RENDER_PASS_FORWARD_TRANSPARENT;
+          info.renderPass = ri.renderPass;
           info.rasterMode = RasterMode::kAdditive;
           info.vertexAttributes = vertices.getVertexAttributes();
           info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_STRIP;
@@ -307,7 +308,7 @@ void KRScene::render(KRNode::RenderInfo& ri, KROctreeNode* pOctreeNode, unordere
           KRPipeline* pPipeline = getContext().getPipelineManager()->getPipeline(*ri.surface, info);
           pPipeline->bind(ri.commandBuffer, *info.pCamera, ri.viewport, matModel, info.point_lights, info.directional_lights, info.spot_lights, info.renderPass);
           vkCmdDraw(ri.commandBuffer, 14, 1, 0, 0);
-          m_pContext->getMeshManager()->log_draw_call(ri.renderPass, "octree", "occlusion_test", 14);
+          m_pContext->getMeshManager()->log_draw_call(ri.renderPass->getType(), "octree", "occlusion_test", 14);
 
           pOctreeNode->endOcclusionQuery();
 
@@ -352,7 +353,7 @@ void KRScene::render(KRNode::RenderInfo& ri, KROctreeNode* pOctreeNode, unordere
           }
 
           // Render child octrees
-          const int* childOctreeOrder = ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT || ri.renderPass == KRNode::RENDER_PASS_ADDITIVE_PARTICLES || ri.renderPass == KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE ? ri.viewport.getBackToFrontOrder() : ri.viewport.getFrontToBackOrder();
+          const int* childOctreeOrder = ri.renderPass->getType() == RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT || ri.renderPass->getType() == RenderPassType::RENDER_PASS_ADDITIVE_PARTICLES || ri.renderPass->getType() == RenderPassType::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE ? ri.viewport.getBackToFrontOrder() : ri.viewport.getFrontToBackOrder();
 
           for (int i = 0; i < 8; i++) {
             render(ri, pOctreeNode->getChildren()[childOctreeOrder[i]], visibleBounds, remainingOctrees, remainingOctreesTestResults, remainingOctreesTestResultsOnly, false, false);
diff --git a/kraken/KRScene.h b/kraken/KRScene.h
index 6fc4444..ed846cf 100755
--- a/kraken/KRScene.h
+++ b/kraken/KRScene.h
@@ -71,7 +71,7 @@ public:
   bool sphereCast(const hydra::Vector3& v0, const hydra::Vector3& v1, float radius, hydra::HitInfo& hitinfo, unsigned int layer_mask);
 
   void renderFrame(VkCommandBuffer& commandBuffer, KRSurface& surface, float deltaTime);
-  void render(VkCommandBuffer& commandBuffer, KRSurface& surface, KRCamera* pCamera, unordered_map<hydra::AABB, int>& visibleBounds, const KRViewport& viewport, KRNode::RenderPass renderPass, bool new_frame);
+  void render(VkCommandBuffer& commandBuffer, KRSurface& surface, KRCamera* pCamera, unordered_map<hydra::AABB, int>& visibleBounds, const KRViewport& viewport, const KRRenderPass* renderPass, bool new_frame);
   void render(KRNode::RenderInfo& ri, KROctreeNode* pOctreeNode, unordered_map<hydra::AABB, int>& visibleBounds, std::vector<KROctreeNode*>& remainingOctrees, std::vector<KROctreeNode*>& remainingOctreesTestResults, std::vector<KROctreeNode*>& remainingOctreesTestResultsOnly, bool bOcclusionResultsPass, bool bOcclusionTestResultsOnly);
 
   void updateOctree(const KRViewport& viewport);
diff --git a/kraken/KRSprite.cpp b/kraken/KRSprite.cpp
index e14074c..36a413c 100755
--- a/kraken/KRSprite.cpp
+++ b/kraken/KRSprite.cpp
@@ -42,6 +42,7 @@
 #include "KRDirectionalLight.h"
 #include "KRSpotLight.h"
 #include "KRPointLight.h"
+#include "KRRenderPass.h"
 
 using namespace hydra;
 
@@ -118,7 +119,7 @@ AABB KRSprite::getBounds()
 void KRSprite::render(RenderInfo& ri)
 {
 
-  if (m_lod_visible >= LOD_VISIBILITY_PRESTREAM && ri.renderPass == KRNode::RENDER_PASS_PRESTREAM) {
+  if (m_lod_visible >= LOD_VISIBILITY_PRESTREAM && ri.renderPass->getType() == RenderPassType::RENDER_PASS_PRESTREAM) {
     // Pre-stream sprites, even if the alpha is zero
     if (m_spriteTexture.size() && m_pSpriteTexture == NULL) {
       if (!m_pSpriteTexture && m_spriteTexture.size()) {
@@ -136,7 +137,7 @@ void KRSprite::render(RenderInfo& ri)
   KRNode::render(ri);
 
 
-  if (ri.renderPass == KRNode::RENDER_PASS_ADDITIVE_PARTICLES) {
+  if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_ADDITIVE_PARTICLES) {
     if (m_spriteTexture.size() && m_spriteAlpha > 0.0f) {
 
 
diff --git a/kraken/KRSurface.cpp b/kraken/KRSurface.cpp
index e8dd694..5c50ec8 100644
--- a/kraken/KRSurface.cpp
+++ b/kraken/KRSurface.cpp
@@ -45,16 +45,10 @@ KRSurface::KRSurface(KRContext& context, KrSurfaceHandle handle, void* platformH
   , m_renderFinishedSemaphores{VK_NULL_HANDLE}
   , m_inFlightFences{VK_NULL_HANDLE}
   , m_frameIndex(0)
-  , m_renderGraph(context)
-  , m_blackFrameRenderGraph(context)
+  , m_renderGraph(std::make_unique<KRRenderGraph>(context))
+  , m_blackFrameRenderGraph(std::make_unique<KRRenderGraph>(context))
+  , m_swapChain(std::make_unique<KRSwapchain>(context))
 {
-  m_forwardOpaquePass = std::make_unique<KRRenderPass>(context);
-  m_deferredGBufferPass = std::make_unique<KRRenderPass>(context);
-  m_deferredOpaquePass = std::make_unique<KRRenderPass>(context);
-  m_postCompositePass = std::make_unique<KRRenderPass>(context);
-  m_debugPass = std::make_unique<KRRenderPass>(context);
-  m_blackFramePass = std::make_unique<KRRenderPass>(context);
-  m_swapChain = std::make_unique<KRSwapchain>(context);
 }
 
 KRSurface::~KRSurface()
@@ -117,30 +111,8 @@ void KRSurface::destroy()
   destroySwapChain();
 
   std::unique_ptr<KRDevice>& device = m_pContext->getDeviceManager()->getDevice(m_deviceHandle);
-
-  if (m_forwardOpaquePass) {
-    m_forwardOpaquePass->destroy(*device);
-  }
-
-  if (m_deferredGBufferPass) {
-    m_deferredGBufferPass->destroy(*device);
-  }
-
-  if (m_deferredOpaquePass) {
-    m_deferredOpaquePass->destroy(*device);
-  }
-  
-  if (m_postCompositePass) {
-    m_postCompositePass->destroy(*device);
-  }
-  
-  if (m_debugPass) {
-    m_debugPass->destroy(*device);
-  }
-  
-  if (m_blackFramePass) {
-    m_blackFramePass->destroy(*device);
-  }
+  m_renderGraph->destroy(*device);
+  m_blackFrameRenderGraph->destroy(*device);
 
   for (int i=0; i < KRENGINE_MAX_FRAMES_IN_FLIGHT; i++) {
     if (device && m_renderFinishedSemaphores[i] != VK_NULL_HANDLE) {
@@ -200,10 +172,11 @@ KrResult KRSurface::createSwapChain()
   }
 
 
-  KRRenderPass::RenderPassInfo info{};
+  RenderPassInfo info{};
   info.clearColor = true;
   info.keepColor = true;
   info.clearColorValue = Vector4::Zero();
+  info.colorFormat = selectedSurfaceFormat.format;
 
   info.clearDepth = true;
   info.keepDepth = true;
@@ -212,52 +185,61 @@ KrResult KRSurface::createSwapChain()
   info.clearStencil = true;
   info.keepStencil = true;
   info.clearStencilValue = 0;
+  info.depthStencilFormat = depthImageFormat;
+  
   info.finalPass = false;
-  m_forwardOpaquePass->create(*device, selectedSurfaceFormat.format, depthImageFormat, info);
-  m_renderGraph.addRenderPass(m_forwardOpaquePass.get());
+  info.type = RenderPassType::RENDER_PASS_FORWARD_OPAQUE;
+  m_renderGraph->addRenderPass(*device, info);
 
   info.clearColor = true;
   info.keepColor = true;
   info.clearDepth = true;
   info.keepDepth = true;
   info.finalPass = false;
-  m_deferredGBufferPass->create(*device, selectedSurfaceFormat.format, depthImageFormat, info);
-  m_renderGraph.addRenderPass(m_deferredGBufferPass.get());
+  info.type = RenderPassType::RENDER_PASS_DEFERRED_GBUFFER;
+  m_renderGraph->addRenderPass(*device, info);
 
   info.clearColor = false;
   info.keepColor = true;
   info.clearDepth = false;
   info.keepDepth = true;
   info.finalPass = false;
-  m_deferredOpaquePass->create(*device, selectedSurfaceFormat.format, depthImageFormat, info);
-  m_renderGraph.addRenderPass(m_deferredOpaquePass.get());
+  info.type = RenderPassType::RENDER_PASS_DEFERRED_LIGHTS;
+  m_renderGraph->addRenderPass(*device, info);
   
   info.clearColor = false;
   info.keepColor = true;
   info.clearDepth = false;
   info.keepDepth = true;
   info.finalPass = false;
-  m_debugPass->create(*device, selectedSurfaceFormat.format, depthImageFormat, info);
-  m_renderGraph.addRenderPass(m_debugPass.get());
+  info.type = RenderPassType::RENDER_PASS_DEFERRED_OPAQUE;
+  m_renderGraph->addRenderPass(*device, info);
+  
+  info.clearColor = false;
+  info.keepColor = true;
+  info.clearDepth = false;
+  info.keepDepth = true;
+  info.finalPass = false;
+  info.type = RenderPassType::RENDER_PASS_DEBUG_OVERLAYS;
+  m_renderGraph->addRenderPass(*device, info);
   
   info.clearColor = false;
   info.keepColor = true;
   info.clearDepth = false;
   info.keepDepth = false;
   info.finalPass = true;
-  m_postCompositePass->create(*device, selectedSurfaceFormat.format, depthImageFormat, info);
-  m_renderGraph.addRenderPass(m_postCompositePass.get());
+  info.type = RenderPassType::RENDER_PASS_POST_COMPOSITE;
+  m_renderGraph->addRenderPass(*device, info);
   
   info.clearColor = true;
   info.keepColor = true;
   info.clearDepth = true;
   info.keepDepth = false;
   info.finalPass = true;
-  m_blackFramePass->create(*device, selectedSurfaceFormat.format, depthImageFormat, info);
-  
-  m_blackFrameRenderGraph.addRenderPass(m_blackFramePass.get());
+  info.type = RenderPassType::RENDER_PASS_BLACK_FRAME;
+  m_blackFrameRenderGraph->addRenderPass(*device, info);
 
-  m_swapChain->create(*device, m_surface, selectedSurfaceFormat, depthImageFormat, swapExtent, imageCount, *m_forwardOpaquePass);
+  m_swapChain->create(*device, m_surface, selectedSurfaceFormat, depthImageFormat, swapExtent, imageCount, *m_renderGraph->getRenderPass(RenderPassType::RENDER_PASS_FORWARD_OPAQUE));
 
   return KR_SUCCESS;
 }
@@ -310,34 +292,9 @@ VkFormat KRSurface::getDepthFormat() const
   return m_swapChain->m_depthFormat;
 }
 
-KRRenderPass& KRSurface::getForwardOpaquePass()
+KRRenderPass* KRSurface::getRenderPass(RenderPassType type)
 {
-  return *m_forwardOpaquePass;
-}
-
-KRRenderPass& KRSurface::getDeferredGBufferPass()
-{
-  return *m_deferredGBufferPass;
-}
-
-KRRenderPass& KRSurface::getDeferredOpaquePass()
-{
-  return *m_deferredOpaquePass;
-}
-
-KRRenderPass& KRSurface::getPostCompositePass()
-{
-  return *m_postCompositePass;
-}
-
-KRRenderPass& KRSurface::getDebugPass()
-{
-  return *m_debugPass;
-}
-
-KRRenderPass& KRSurface::getBlackFramePass()
-{
-  return *m_blackFramePass;
+  return m_renderGraph->getRenderPass(type);
 }
 
 void KRSurface::endFrame()
@@ -348,5 +305,5 @@ void KRSurface::endFrame()
 
 void KRSurface::renderBlackFrame(VkCommandBuffer &commandBuffer)
 {
-  m_blackFrameRenderGraph.render(commandBuffer, *this);
+  m_blackFrameRenderGraph->render(commandBuffer, *this);
 }
diff --git a/kraken/KRSurface.h b/kraken/KRSurface.h
index c94807c..b3774db 100644
--- a/kraken/KRSurface.h
+++ b/kraken/KRSurface.h
@@ -38,6 +38,7 @@
 class KRDevice;
 class KRRenderPass;
 class KRSwapchain;
+class KRRenderGraph;
 
 class KRSurface : public KRContextObject
 {
@@ -57,13 +58,7 @@ public:
 
   KrResult initialize();
   KrResult recreateSwapChain();
-  KRRenderPass& getForwardOpaquePass();
-
-  KRRenderPass& getDeferredGBufferPass();
-  KRRenderPass& getDeferredOpaquePass();
-  KRRenderPass& getPostCompositePass();
-  KRRenderPass& getDebugPass();
-  KRRenderPass& getBlackFramePass();
+  KRRenderPass* getRenderPass(RenderPassType type);
 
   void endFrame();
   KrSurfaceHandle m_handle;
@@ -77,13 +72,6 @@ public:
   VkFence m_inFlightFences[KRENGINE_MAX_FRAMES_IN_FLIGHT];
 
   std::unique_ptr<KRSwapchain> m_swapChain;
-  std::unique_ptr<KRRenderPass> m_forwardOpaquePass;
-  std::unique_ptr<KRRenderPass> m_deferredGBufferPass;
-  std::unique_ptr<KRRenderPass> m_deferredOpaquePass;
-  std::unique_ptr<KRRenderPass> m_postCompositePass;
-  std::unique_ptr<KRRenderPass> m_debugPass;
-  std::unique_ptr<KRRenderPass> m_blackFramePass;
-  
 
   // TODO - This needs to be advanced per swap chain
   uint64_t m_frameIndex;
@@ -91,6 +79,6 @@ public:
 private:
   void destroySwapChain();
   KrResult createSwapChain();
-  KRRenderGraph m_renderGraph;
-  KRRenderGraph m_blackFrameRenderGraph;
+  std::unique_ptr<KRRenderGraph> m_renderGraph;
+  std::unique_ptr<KRRenderGraph> m_blackFrameRenderGraph;
 };