diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index b58fa57d3f..c8d5739a6c 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -1674,7 +1674,7 @@ void Application::paintGL() {
     auto inputs = AvatarInputs::getInstance();
     if (inputs->mirrorVisible()) {
         PerformanceTimer perfTimer("Mirror");
-        auto primaryFbo = DependencyManager::get<FramebufferCache>()->getPrimaryFramebuffer();
+     //   auto primaryFbo = DependencyManager::get<FramebufferCache>()->getPrimaryFramebuffer();
 
         renderArgs._renderMode = RenderArgs::MIRROR_RENDER_MODE;
         renderArgs._blitFramebuffer = DependencyManager::get<FramebufferCache>()->getSelfieFramebuffer();
diff --git a/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp b/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp
index e0c87fbbed..cd1c8eedd1 100644
--- a/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp
+++ b/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp
@@ -578,6 +578,8 @@ void OpenGLDisplayPlugin::present() {
 
     PROFILE_RANGE_EX(__FUNCTION__, 0xff00ff00, (uint64_t)presentCount())
 
+    glEnable(GL_FRAMEBUFFER_SRGB);
+
     updateTextures();
     if (_currentSceneTexture) {
         // Write all layers to a local framebuffer
diff --git a/libraries/render-utils/src/AmbientOcclusionEffect.cpp b/libraries/render-utils/src/AmbientOcclusionEffect.cpp
index 3b0e4c8d18..4b283731d2 100644
--- a/libraries/render-utils/src/AmbientOcclusionEffect.cpp
+++ b/libraries/render-utils/src/AmbientOcclusionEffect.cpp
@@ -283,6 +283,7 @@ void AmbientOcclusionEffect::updateGaussianDistribution() {
 }
 
 void AmbientOcclusionEffect::run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext) {
+#ifdef FIX_THE_FRAMEBUFFER_CACHE
     assert(renderContext->args);
     assert(renderContext->args->hasViewFrustum());
 
@@ -406,4 +407,5 @@ void AmbientOcclusionEffect::run(const render::SceneContextPointer& sceneContext
 
     // Update the timer
     std::static_pointer_cast<Config>(renderContext->jobConfig)->gpuTime = _gpuTimer.getAverage();
+#endif
 }
diff --git a/libraries/render-utils/src/AntialiasingEffect.cpp b/libraries/render-utils/src/AntialiasingEffect.cpp
index fc09f8431d..2f273f6202 100644
--- a/libraries/render-utils/src/AntialiasingEffect.cpp
+++ b/libraries/render-utils/src/AntialiasingEffect.cpp
@@ -32,6 +32,9 @@ Antialiasing::Antialiasing() {
 }
 
 const gpu::PipelinePointer& Antialiasing::getAntialiasingPipeline() {
+    int width = DependencyManager::get<FramebufferCache>()->getFrameBufferSize().width();
+    int height = DependencyManager::get<FramebufferCache>()->getFrameBufferSize().height();
+    
     if (!_antialiasingPipeline) {
         auto vs = gpu::Shader::createVertex(std::string(fxaa_vert));
         auto ps = gpu::Shader::createPixel(std::string(fxaa_frag));
@@ -49,11 +52,8 @@ const gpu::PipelinePointer& Antialiasing::getAntialiasingPipeline() {
         state->setDepthTest(false, false, gpu::LESS_EQUAL);
 
         // Link the antialiasing FBO to texture
-        _antialiasingBuffer = gpu::FramebufferPointer(gpu::Framebuffer::create(gpu::Element::COLOR_RGBA_32,
-          DependencyManager::get<FramebufferCache>()->getFrameBufferSize().width(), DependencyManager::get<FramebufferCache>()->getFrameBufferSize().height()));
-        auto format = DependencyManager::get<FramebufferCache>()->getLightingTexture()->getTexelFormat();
-        auto width = _antialiasingBuffer->getWidth();
-        auto height = _antialiasingBuffer->getHeight();
+        _antialiasingBuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
+        auto format = gpu::Element::COLOR_SRGBA_32; // DependencyManager::get<FramebufferCache>()->getLightingTexture()->getTexelFormat();
         auto defaultSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_POINT);
         _antialiasingTexture = gpu::TexturePointer(gpu::Texture::create2D(format, width, height, defaultSampler));
         _antialiasingBuffer->setRenderBuffer(0, _antialiasingTexture);
@@ -62,10 +62,8 @@ const gpu::PipelinePointer& Antialiasing::getAntialiasingPipeline() {
         _antialiasingPipeline = gpu::Pipeline::create(program, state);
     }
 
-    int w = DependencyManager::get<FramebufferCache>()->getFrameBufferSize().width();
-    int h = DependencyManager::get<FramebufferCache>()->getFrameBufferSize().height();
-    if (w != _antialiasingBuffer->getWidth() || h != _antialiasingBuffer->getHeight()) {
-        _antialiasingBuffer->resize(w, h);
+    if (width != _antialiasingBuffer->getWidth() || height != _antialiasingBuffer->getHeight()) {
+        _antialiasingBuffer->resize(width, height);
     }
 
     return _antialiasingPipeline;
@@ -92,7 +90,7 @@ const gpu::PipelinePointer& Antialiasing::getBlendPipeline() {
     return _blendPipeline;
 }
 
-void Antialiasing::run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext) {
+void Antialiasing::run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const gpu::FramebufferPointer& sourceBuffer) {
     assert(renderContext->args);
     assert(renderContext->args->hasViewFrustum());
 
@@ -126,7 +124,7 @@ void Antialiasing::run(const render::SceneContextPointer& sceneContext, const re
 
         // FXAA step
         getAntialiasingPipeline();
-        batch.setResourceTexture(0, framebufferCache->getLightingTexture());
+        batch.setResourceTexture(0, sourceBuffer->getRenderBuffer(0));
         batch.setFramebuffer(_antialiasingBuffer);
         batch.setPipeline(getAntialiasingPipeline());
 
@@ -152,10 +150,11 @@ void Antialiasing::run(const render::SceneContextPointer& sceneContext, const re
         glm::vec2 texCoordBottomRight(1.0f, 1.0f);
         DependencyManager::get<GeometryCache>()->renderQuad(batch, bottomLeft, topRight, texCoordTopLeft, texCoordBottomRight, color);
 
+
         // Blend step
         getBlendPipeline();
         batch.setResourceTexture(0, _antialiasingTexture);
-        batch.setFramebuffer(framebufferCache->getLightingFramebuffer());
+        batch.setFramebuffer(sourceBuffer);
         batch.setPipeline(getBlendPipeline());
 
         DependencyManager::get<GeometryCache>()->renderQuad(batch, bottomLeft, topRight, texCoordTopLeft, texCoordBottomRight, color);
diff --git a/libraries/render-utils/src/AntialiasingEffect.h b/libraries/render-utils/src/AntialiasingEffect.h
index 6386622675..f0992ed843 100644
--- a/libraries/render-utils/src/AntialiasingEffect.h
+++ b/libraries/render-utils/src/AntialiasingEffect.h
@@ -26,11 +26,11 @@ public:
 class Antialiasing {
 public:
     using Config = AntiAliasingConfig;
-    using JobModel = render::Job::Model<Antialiasing, Config>;
+    using JobModel = render::Job::ModelI<Antialiasing, gpu::FramebufferPointer, Config>;
 
     Antialiasing();
     void configure(const Config& config) {}
-    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext);
+    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const gpu::FramebufferPointer& sourceBuffer);
 
     const gpu::PipelinePointer& getAntialiasingPipeline();
     const gpu::PipelinePointer& getBlendPipeline();
diff --git a/libraries/render-utils/src/DebugDeferredBuffer.cpp b/libraries/render-utils/src/DebugDeferredBuffer.cpp
index 2fd42ccacd..a1ad480170 100644
--- a/libraries/render-utils/src/DebugDeferredBuffer.cpp
+++ b/libraries/render-utils/src/DebugDeferredBuffer.cpp
@@ -351,8 +351,9 @@ void DebugDeferredBuffer::run(const SceneContextPointer& sceneContext, const Ren
     assert(renderContext->args->hasViewFrustum());
     RenderArgs* args = renderContext->args;
 
-    auto& diffusedCurvatureFramebuffer = inputs.get0();
-    auto& scatteringFramebuffer = inputs.get1();
+    auto& deferredFramebuffer = inputs.get0();
+    auto& diffusedCurvatureFramebuffer = inputs.get1();
+    auto& scatteringFramebuffer = inputs.get2();
 
     gpu::doInBatch(args->_context, [&](gpu::Batch& batch) {
         batch.enableStereo(false);
@@ -376,11 +377,11 @@ void DebugDeferredBuffer::run(const SceneContextPointer& sceneContext, const Ren
 
         batch.setPipeline(getPipeline(_mode, first));
 
-        batch.setResourceTexture(Albedo, framebufferCache->getDeferredColorTexture());
-        batch.setResourceTexture(Normal, framebufferCache->getDeferredNormalTexture());
-        batch.setResourceTexture(Specular, framebufferCache->getDeferredSpecularTexture());
-        batch.setResourceTexture(Depth, framebufferCache->getPrimaryDepthTexture());
-        batch.setResourceTexture(Lighting, framebufferCache->getLightingTexture());
+        batch.setResourceTexture(Albedo, deferredFramebuffer->getDeferredColorTexture());
+        batch.setResourceTexture(Normal, deferredFramebuffer->getDeferredNormalTexture());
+        batch.setResourceTexture(Specular, deferredFramebuffer->getDeferredSpecularTexture());
+        batch.setResourceTexture(Depth, deferredFramebuffer->getPrimaryDepthTexture());
+        batch.setResourceTexture(Lighting, deferredFramebuffer->getLightingTexture());
         batch.setResourceTexture(Shadow, lightStage.lights[0]->shadow.framebuffer->getDepthStencilBuffer());
         batch.setResourceTexture(Pyramid, framebufferCache->getDepthPyramidTexture());
         batch.setResourceTexture(Curvature, framebufferCache->getCurvatureTexture());
diff --git a/libraries/render-utils/src/DebugDeferredBuffer.h b/libraries/render-utils/src/DebugDeferredBuffer.h
index 61ebec8954..09e0380e46 100644
--- a/libraries/render-utils/src/DebugDeferredBuffer.h
+++ b/libraries/render-utils/src/DebugDeferredBuffer.h
@@ -15,6 +15,7 @@
 #include <QFileInfo>
 
 #include <render/DrawTask.h>
+#include "DeferredFramebuffer.h"
 
 class DebugDeferredBufferConfig : public render::Job::Config {
     Q_OBJECT
@@ -34,7 +35,7 @@ signals:
 
 class DebugDeferredBuffer {
 public:
-    using Inputs = render::VaryingSet2<gpu::FramebufferPointer, gpu::FramebufferPointer>;
+    using Inputs = render::VaryingSet3<DeferredFramebufferPointer, gpu::FramebufferPointer, gpu::FramebufferPointer>;
     using Config = DebugDeferredBufferConfig;
     using JobModel = render::Job::ModelI<DebugDeferredBuffer, Inputs, Config>;
     
diff --git a/libraries/render-utils/src/DeferredFrameTransform.h b/libraries/render-utils/src/DeferredFrameTransform.h
index 70ac5fca92..1abd912f15 100644
--- a/libraries/render-utils/src/DeferredFrameTransform.h
+++ b/libraries/render-utils/src/DeferredFrameTransform.h
@@ -75,4 +75,4 @@ public:
 private:
 };
 
-#endif // hifi_SurfaceGeometryPass_h
+#endif // hifi_DeferredFrameTransform_h
diff --git a/libraries/render-utils/src/DeferredLightingEffect.cpp b/libraries/render-utils/src/DeferredLightingEffect.cpp
index 59c5012147..12408f121f 100644
--- a/libraries/render-utils/src/DeferredLightingEffect.cpp
+++ b/libraries/render-utils/src/DeferredLightingEffect.cpp
@@ -328,8 +328,46 @@ model::MeshPointer DeferredLightingEffect::getSpotLightMesh() {
     return _spotLightMesh;
 }
 
-void PrepareDeferred::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
+void PreparePrimaryFramebuffer::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, gpu::FramebufferPointer& primaryFramebuffer) {
     auto args = renderContext->args;
+
+    glm::ivec2 frameSize(args->_viewport.z, args->_viewport.w);
+
+    if (!_primaryFramebuffer) {
+        _primaryFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
+        auto colorFormat = gpu::Element::COLOR_SRGBA_32;
+
+        auto defaultSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_POINT);
+        auto primaryColorTexture = gpu::TexturePointer(gpu::Texture::create2D(colorFormat, frameSize.x, frameSize.y, defaultSampler));
+
+
+        _primaryFramebuffer->setRenderBuffer(0, primaryColorTexture);
+
+
+        auto depthFormat = gpu::Element(gpu::SCALAR, gpu::UINT32, gpu::DEPTH_STENCIL); // Depth24_Stencil8 texel format
+        auto primaryDepthTexture = gpu::TexturePointer(gpu::Texture::create2D(depthFormat, frameSize.x, frameSize.y, defaultSampler));
+
+        _primaryFramebuffer->setDepthStencilBuffer(primaryDepthTexture, depthFormat);
+
+    }
+    _primaryFramebuffer->resize(frameSize.x, frameSize.y);
+
+    primaryFramebuffer = _primaryFramebuffer;
+}
+
+void PrepareDeferred::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const gpu::FramebufferPointer& primaryFramebuffer, Outputs& output) {
+    auto args = renderContext->args;
+
+    if (!_deferredFramebuffer) {
+        _deferredFramebuffer = std::make_shared<DeferredFramebuffer>();
+    }
+    _deferredFramebuffer->setPrimaryDepth(primaryFramebuffer->getDepthStencilBuffer());
+    _deferredFramebuffer->setFrameSize(glm::ivec2(args->_viewport.z, args->_viewport.w));
+
+    output.edit0() = _deferredFramebuffer;
+    output.edit1() = _deferredFramebuffer->getLightingFramebuffer();
+
+
     gpu::doInBatch(args->_context, [&](gpu::Batch& batch) {
         batch.enableStereo(false);
         batch.setViewportTransform(args->_viewport);
@@ -342,13 +380,13 @@ void PrepareDeferred::run(const SceneContextPointer& sceneContext, const RenderC
         batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLOR0, vec4(vec3(0), 0), true);
 */
         // Clear deferred
-        auto deferredFbo = DependencyManager::get<FramebufferCache>()->getDeferredFramebuffer();
-
+    //    auto deferredFbo = DependencyManager::get<FramebufferCache>()->getDeferredFramebuffer();
+        auto deferredFbo = _deferredFramebuffer->getDeferredFramebuffer();
         batch.setFramebuffer(deferredFbo);
 
         // Clear Color, Depth and Stencil for deferred buffer
         batch.clearFramebuffer(
-            gpu::Framebuffer::BUFFER_COLOR0 | gpu::Framebuffer::BUFFER_COLOR1 | gpu::Framebuffer::BUFFER_COLOR2 |
+            gpu::Framebuffer::BUFFER_COLOR0 | gpu::Framebuffer::BUFFER_COLOR1 | gpu::Framebuffer::BUFFER_COLOR2 | gpu::Framebuffer::BUFFER_COLOR3 |
             gpu::Framebuffer::BUFFER_DEPTH |
             gpu::Framebuffer::BUFFER_STENCIL,
             vec4(vec3(0), 0), 1.0, 0.0, true);
@@ -358,6 +396,7 @@ void PrepareDeferred::run(const SceneContextPointer& sceneContext, const RenderC
 
 void RenderDeferredSetup::run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext,
     const DeferredFrameTransformPointer& frameTransform,
+    const DeferredFramebufferPointer& deferredFramebuffer,
     const LightingModelPointer& lightingModel,
     const gpu::TexturePointer& diffusedCurvature2,
     const SubsurfaceScatteringResourcePointer& subsurfaceScatteringResource) {
@@ -370,11 +409,12 @@ void RenderDeferredSetup::run(const render::SceneContextPointer& sceneContext, c
         
         // perform deferred lighting, rendering to free fbo
         auto framebufferCache = DependencyManager::get<FramebufferCache>();
+            
         auto textureCache = DependencyManager::get<TextureCache>();
         auto deferredLightingEffect = DependencyManager::get<DeferredLightingEffect>();
 
         // binding the first framebuffer
-        auto lightingFBO = framebufferCache->getLightingFramebuffer();
+        auto lightingFBO = deferredFramebuffer->getLightingFramebuffer();
         batch.setFramebuffer(lightingFBO);
         
         batch.setViewportTransform(args->_viewport);
@@ -382,10 +422,10 @@ void RenderDeferredSetup::run(const render::SceneContextPointer& sceneContext, c
         
         
         // Bind the G-Buffer surfaces
-        batch.setResourceTexture(DEFERRED_BUFFER_COLOR_UNIT, framebufferCache->getDeferredColorTexture());
-        batch.setResourceTexture(DEFERRED_BUFFER_NORMAL_UNIT, framebufferCache->getDeferredNormalTexture());
-        batch.setResourceTexture(DEFERRED_BUFFER_EMISSIVE_UNIT, framebufferCache->getDeferredSpecularTexture());
-        batch.setResourceTexture(DEFERRED_BUFFER_DEPTH_UNIT, framebufferCache->getPrimaryDepthTexture());
+        batch.setResourceTexture(DEFERRED_BUFFER_COLOR_UNIT, deferredFramebuffer->getDeferredColorTexture());
+        batch.setResourceTexture(DEFERRED_BUFFER_NORMAL_UNIT, deferredFramebuffer->getDeferredNormalTexture());
+        batch.setResourceTexture(DEFERRED_BUFFER_EMISSIVE_UNIT, deferredFramebuffer->getDeferredSpecularTexture());
+        batch.setResourceTexture(DEFERRED_BUFFER_DEPTH_UNIT, deferredFramebuffer->getPrimaryDepthTexture());
         
         // FIXME: Different render modes should have different tasks
         if (args->_renderMode == RenderArgs::DEFAULT_RENDER_MODE && deferredLightingEffect->isAmbientOcclusionEnabled()) {
@@ -631,11 +671,12 @@ void RenderDeferred::configure(const Config& config) {
 
 void RenderDeferred::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const Inputs& inputs) {
     auto deferredTransform = inputs.get0();
-    auto lightingModel = inputs.get1();
-    auto diffusedCurvature2 = inputs.get2()->getRenderBuffer(0);
-    auto subsurfaceScatteringResource = inputs.get4();
+    auto deferredFramebuffer = inputs.get1();
+    auto lightingModel = inputs.get2();
+    auto diffusedCurvature2 = inputs.get3()->getRenderBuffer(0);
+    auto subsurfaceScatteringResource = inputs.get5();
 
-    setupJob.run(sceneContext, renderContext, deferredTransform, lightingModel, diffusedCurvature2, subsurfaceScatteringResource);
+    setupJob.run(sceneContext, renderContext, deferredTransform, deferredFramebuffer, lightingModel, diffusedCurvature2, subsurfaceScatteringResource);
     
     lightsJob.run(sceneContext, renderContext, deferredTransform, lightingModel->isPointLightEnabled(), lightingModel->isSpotLightEnabled());
 
diff --git a/libraries/render-utils/src/DeferredLightingEffect.h b/libraries/render-utils/src/DeferredLightingEffect.h
index 9fb28919d6..b850cce040 100644
--- a/libraries/render-utils/src/DeferredLightingEffect.h
+++ b/libraries/render-utils/src/DeferredLightingEffect.h
@@ -24,6 +24,7 @@
 #include <render/CullTask.h>
 
 #include "DeferredFrameTransform.h"
+#include "DeferredFramebuffer.h"
 #include "LightingModel.h"
 
 #include "LightStage.h"
@@ -105,11 +106,25 @@ private:
     friend class RenderDeferredCleanup;
 };
 
+class PreparePrimaryFramebuffer {
+public:
+    using JobModel = render::Job::ModelO<PreparePrimaryFramebuffer, gpu::FramebufferPointer>;
+
+    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, gpu::FramebufferPointer& primaryFramebuffer);
+
+    gpu::FramebufferPointer _primaryFramebuffer;
+};
+
 class PrepareDeferred {
 public:
-    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext);
+    // Output: DeferredFramebuffer, LightingFramebuffer
+    using Outputs = render::VaryingSet2<DeferredFramebufferPointer, gpu::FramebufferPointer>;
 
-    using JobModel = render::Job::Model<PrepareDeferred>;
+    using JobModel = render::Job::ModelIO<PrepareDeferred, gpu::FramebufferPointer, Outputs>;
+
+    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const gpu::FramebufferPointer& primaryFramebuffer, Outputs& output);
+
+    DeferredFramebufferPointer _deferredFramebuffer;
 };
 
 class RenderDeferredSetup {
@@ -118,6 +133,7 @@ public:
     
     void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext,
         const DeferredFrameTransformPointer& frameTransform,
+        const DeferredFramebufferPointer& deferredFramebuffer,
         const LightingModelPointer& lightingModel,
         const gpu::TexturePointer& diffusedCurvature2,
         const SubsurfaceScatteringResourcePointer& subsurfaceScatteringResource);
@@ -151,7 +167,7 @@ signals:
 
 class RenderDeferred {
 public:
-    using Inputs = render::VaryingSet5 < DeferredFrameTransformPointer, LightingModelPointer, gpu::FramebufferPointer, gpu::FramebufferPointer, SubsurfaceScatteringResourcePointer>;
+    using Inputs = render::VaryingSet6 < DeferredFrameTransformPointer, DeferredFramebufferPointer, LightingModelPointer, gpu::FramebufferPointer, gpu::FramebufferPointer, SubsurfaceScatteringResourcePointer>;
     using Config = RenderDeferredConfig;
     using JobModel = render::Job::ModelI<RenderDeferred, Inputs, Config>;
 
diff --git a/libraries/render-utils/src/FramebufferCache.cpp b/libraries/render-utils/src/FramebufferCache.cpp
index 602e559114..4c9d02ca41 100644
--- a/libraries/render-utils/src/FramebufferCache.cpp
+++ b/libraries/render-utils/src/FramebufferCache.cpp
@@ -33,7 +33,7 @@ void FramebufferCache::setFrameBufferSize(QSize frameBufferSize) {
     //If the size changed, we need to delete our FBOs
     if (_frameBufferSize != frameBufferSize) {
         _frameBufferSize = frameBufferSize;
-        _primaryFramebuffer.reset();
+  /*      _primaryFramebuffer.reset();
         _primaryDepthTexture.reset();
         _primaryColorTexture.reset();
         _deferredFramebuffer.reset();
@@ -41,11 +41,11 @@ void FramebufferCache::setFrameBufferSize(QSize frameBufferSize) {
         _deferredColorTexture.reset();
         _deferredNormalTexture.reset();
         _deferredSpecularTexture.reset();
-        _selfieFramebuffer.reset();
+    */    _selfieFramebuffer.reset();
         _cachedFramebuffers.clear();
-        _lightingTexture.reset();
+  /*      _lightingTexture.reset();
         _lightingFramebuffer.reset();
-        _depthPyramidFramebuffer.reset();
+    */    _depthPyramidFramebuffer.reset();
         _depthPyramidTexture.reset();
         _curvatureFramebuffer.reset();
         _curvatureTexture.reset();
@@ -57,17 +57,17 @@ void FramebufferCache::setFrameBufferSize(QSize frameBufferSize) {
 }
 
 void FramebufferCache::createPrimaryFramebuffer() {
-    _primaryFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
+ /*   _primaryFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
     _deferredFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
     _deferredFramebufferDepthColor = gpu::FramebufferPointer(gpu::Framebuffer::create());
-
+    */
     auto colorFormat = gpu::Element::COLOR_SRGBA_32;
     auto linearFormat = gpu::Element::COLOR_RGBA_32;
     auto width = _frameBufferSize.width();
     auto height = _frameBufferSize.height();
 
     auto defaultSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_POINT);
-    _primaryColorTexture = gpu::TexturePointer(gpu::Texture::create2D(colorFormat, width, height, defaultSampler));
+ /*   _primaryColorTexture = gpu::TexturePointer(gpu::Texture::create2D(colorFormat, width, height, defaultSampler));
 
     _primaryFramebuffer->setRenderBuffer(0, _primaryColorTexture);
 
@@ -81,10 +81,10 @@ void FramebufferCache::createPrimaryFramebuffer() {
     _deferredFramebuffer->setRenderBuffer(2, _deferredSpecularTexture);
 
     _deferredFramebufferDepthColor->setRenderBuffer(0, _deferredColorTexture);
-
+    */
   //  auto depthFormat = gpu::Element(gpu::SCALAR, gpu::FLOAT, gpu::DEPTH);
     auto depthFormat = gpu::Element(gpu::SCALAR, gpu::UINT32, gpu::DEPTH_STENCIL); // Depth24_Stencil8 texel format
-    _primaryDepthTexture = gpu::TexturePointer(gpu::Texture::create2D(depthFormat, width, height, defaultSampler));
+/*    _primaryDepthTexture = gpu::TexturePointer(gpu::Texture::create2D(depthFormat, width, height, defaultSampler));
 
     _primaryFramebuffer->setDepthStencilBuffer(_primaryDepthTexture, depthFormat);
 
@@ -92,31 +92,31 @@ void FramebufferCache::createPrimaryFramebuffer() {
 
     _deferredFramebufferDepthColor->setDepthStencilBuffer(_primaryDepthTexture, depthFormat);
 
-
+*/
     _selfieFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
     auto tex = gpu::TexturePointer(gpu::Texture::create2D(colorFormat, width * 0.5, height * 0.5, defaultSampler));
     _selfieFramebuffer->setRenderBuffer(0, tex);
 
     auto smoothSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_LINEAR);
 
-    _lightingTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element(gpu::SCALAR, gpu::FLOAT, gpu::R11G11B10), width, height, defaultSampler));
+  /*  _lightingTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element(gpu::SCALAR, gpu::FLOAT, gpu::R11G11B10), width, height, defaultSampler));
     _lightingFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
     _lightingFramebuffer->setRenderBuffer(0, _lightingTexture);
     _lightingFramebuffer->setDepthStencilBuffer(_primaryDepthTexture, depthFormat);
 
     _deferredFramebuffer->setRenderBuffer(3, _lightingTexture);
-
+    */
     // For AO:
     auto pointMipSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_POINT);
     _depthPyramidTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element(gpu::SCALAR, gpu::FLOAT, gpu::RGB), width, height, gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR_MIP_POINT)));
     _depthPyramidFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
     _depthPyramidFramebuffer->setRenderBuffer(0, _depthPyramidTexture);
-    _depthPyramidFramebuffer->setDepthStencilBuffer(_primaryDepthTexture, depthFormat);
+   // _depthPyramidFramebuffer->setDepthStencilBuffer(_primaryDepthTexture, depthFormat);
 
     _curvatureTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element::COLOR_RGBA_32, width, height, gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR_MIP_POINT)));
     _curvatureFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
     _curvatureFramebuffer->setRenderBuffer(0, _curvatureTexture);
-    _curvatureFramebuffer->setDepthStencilBuffer(_primaryDepthTexture, depthFormat);
+   // _curvatureFramebuffer->setDepthStencilBuffer(_primaryDepthTexture, depthFormat);
 
     resizeAmbientOcclusionBuffers();
 }
@@ -138,14 +138,14 @@ void FramebufferCache::resizeAmbientOcclusionBuffers() {
     _occlusionTexture = gpu::TexturePointer(gpu::Texture::create2D(colorFormat, width, height, defaultSampler));
     _occlusionFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
     _occlusionFramebuffer->setRenderBuffer(0, _occlusionTexture);
-    _occlusionFramebuffer->setDepthStencilBuffer(_primaryDepthTexture, depthFormat);
+ //   _occlusionFramebuffer->setDepthStencilBuffer(_primaryDepthTexture, depthFormat);
 
     _occlusionBlurredTexture = gpu::TexturePointer(gpu::Texture::create2D(colorFormat, width, height, defaultSampler));
     _occlusionBlurredFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
     _occlusionBlurredFramebuffer->setRenderBuffer(0, _occlusionBlurredTexture);
-    _occlusionBlurredFramebuffer->setDepthStencilBuffer(_primaryDepthTexture, depthFormat);
+   // _occlusionBlurredFramebuffer->setDepthStencilBuffer(_primaryDepthTexture, depthFormat);
 }
-
+/*
 gpu::FramebufferPointer FramebufferCache::getPrimaryFramebuffer() {
     if (!_primaryFramebuffer) {
         createPrimaryFramebuffer();
@@ -214,7 +214,7 @@ gpu::TexturePointer FramebufferCache::getLightingTexture() {
         createPrimaryFramebuffer();
     }
     return _lightingTexture;
-}
+}*/
 
 gpu::FramebufferPointer FramebufferCache::getFramebuffer() {
     if (_cachedFramebuffers.isEmpty()) {
diff --git a/libraries/render-utils/src/FramebufferCache.h b/libraries/render-utils/src/FramebufferCache.h
index ab1d0a555b..9f3b8e504b 100644
--- a/libraries/render-utils/src/FramebufferCache.h
+++ b/libraries/render-utils/src/FramebufferCache.h
@@ -32,7 +32,7 @@ public:
 
     /// Returns a pointer to the primary framebuffer object.  This render target includes a depth component, and is
     /// used for scene rendering.
-    gpu::FramebufferPointer getPrimaryFramebuffer();
+/*    gpu::FramebufferPointer getPrimaryFramebuffer();
 
     gpu::TexturePointer getPrimaryDepthTexture();
     gpu::TexturePointer getPrimaryColorTexture();
@@ -43,26 +43,23 @@ public:
     gpu::TexturePointer getDeferredColorTexture();
     gpu::TexturePointer getDeferredNormalTexture();
     gpu::TexturePointer getDeferredSpecularTexture();
-
+    */
     gpu::FramebufferPointer getDepthPyramidFramebuffer();
     gpu::TexturePointer getDepthPyramidTexture();
 
     gpu::FramebufferPointer getCurvatureFramebuffer();
     gpu::TexturePointer getCurvatureTexture();
 
-    gpu::FramebufferPointer getScatteringFramebuffer();
-    gpu::TexturePointer getScatteringTexture();
-
     void setAmbientOcclusionResolutionLevel(int level);
     gpu::FramebufferPointer getOcclusionFramebuffer();
     gpu::TexturePointer getOcclusionTexture();
     gpu::FramebufferPointer getOcclusionBlurredFramebuffer();
     gpu::TexturePointer getOcclusionBlurredTexture();
     
-
+    /**
     gpu::TexturePointer getLightingTexture();
     gpu::FramebufferPointer getLightingFramebuffer();
-
+    */
     /// Returns the framebuffer object used to render selfie maps;
     gpu::FramebufferPointer getSelfieFramebuffer();
 
diff --git a/libraries/render-utils/src/RenderDeferredTask.cpp b/libraries/render-utils/src/RenderDeferredTask.cpp
index 13ea658d0c..5bf8a52426 100755
--- a/libraries/render-utils/src/RenderDeferredTask.cpp
+++ b/libraries/render-utils/src/RenderDeferredTask.cpp
@@ -27,6 +27,7 @@
 
 #include "LightingModel.h"
 #include "DebugDeferredBuffer.h"
+#include "DeferredFramebuffer.h"
 #include "DeferredLightingEffect.h"
 #include "SurfaceGeometryPass.h"
 #include "FramebufferCache.h"
@@ -93,20 +94,23 @@ RenderDeferredTask::RenderDeferredTask(CullFunctor cullFunctor) {
     const auto lightingModel = addJob<MakeLightingModel>("LightingModel");
 
 
-    // GPU jobs: Start preparing the deferred and lighting buffer
-    addJob<PrepareDeferred>("PrepareDeferred");
+    // GPU jobs: Start preparing the primary, deferred and lighting buffer
+    const auto primaryFramebuffer = addJob<PreparePrimaryFramebuffer>("PreparePrimaryBuffer");
+
+    const auto deferredAndLightingFramebuffer = addJob<PrepareDeferred>("PrepareDeferred", primaryFramebuffer);
+    const auto deferredFramebuffer = deferredAndLightingFramebuffer.getN<PrepareDeferred::Outputs>(0);
+    const auto lightingFramebuffer = deferredAndLightingFramebuffer.getN<PrepareDeferred::Outputs>(1);
 
     // Render opaque objects in DeferredBuffer
     addJob<DrawStateSortDeferred>("DrawOpaqueDeferred", opaques, shapePlumber);
 
     // Once opaque is all rendered create stencil background
-    addJob<DrawStencilDeferred>("DrawOpaqueStencil");
+    addJob<DrawStencilDeferred>("DrawOpaqueStencil", deferredFramebuffer);
 
-    // Use Stencil and start drawing background in Lighting buffer
-    addJob<DrawBackgroundDeferred>("DrawBackgroundDeferred", background);
 
     // Opaque all rendered, generate surface geometry buffers
-    const auto curvatureFramebufferAndDepth = addJob<SurfaceGeometryPass>("SurfaceGeometry", deferredFrameTransform);
+    const auto surfaceGeometryPassInputs = render::Varying(SurfaceGeometryPass::Inputs(deferredFrameTransform, deferredFramebuffer));
+    const auto curvatureFramebufferAndDepth = addJob<SurfaceGeometryPass>("SurfaceGeometry", surfaceGeometryPassInputs);
 
 
     const auto theCurvatureVarying = curvatureFramebufferAndDepth[0];
@@ -128,14 +132,16 @@ RenderDeferredTask::RenderDeferredTask(CullFunctor cullFunctor) {
     // Draw Lights just add the lights to the current list of lights to deal with. NOt really gpu job for now.
     addJob<DrawLight>("DrawLight", lights);
 
-    const auto deferredLightingInputs = render::Varying(RenderDeferred::Inputs(deferredFrameTransform, lightingModel, curvatureFramebuffer, diffusedCurvatureFramebuffer, scatteringResource));
+    const auto deferredLightingInputs = render::Varying(RenderDeferred::Inputs(deferredFrameTransform, deferredFramebuffer, lightingModel,
+        curvatureFramebuffer, diffusedCurvatureFramebuffer, scatteringResource));
    
     // DeferredBuffer is complete, now let's shade it into the LightingBuffer
     addJob<RenderDeferred>("RenderDeferred", deferredLightingInputs);
 
 
-    // AA job to be revisited
-    addJob<Antialiasing>("Antialiasing");
+    // Use Stencil and start drawing background in Lighting buffer
+    addJob<DrawBackgroundDeferred>("DrawBackgroundDeferred", background);
+
 
     // Render transparent objects forward in LightingBuffer
     addJob<DrawDeferred>("DrawTransparentDeferred", transparents, shapePlumber);
@@ -144,7 +150,8 @@ RenderDeferredTask::RenderDeferredTask(CullFunctor cullFunctor) {
 
 
     // Lighting Buffer ready for tone mapping
-    addJob<ToneMappingDeferred>("ToneMapping");
+    const auto toneMappingInputs = render::Varying(ToneMappingDeferred::Inputs(lightingFramebuffer, primaryFramebuffer));
+    addJob<ToneMappingDeferred>("ToneMapping", toneMappingInputs);
 
     // Overlays
     addJob<DrawOverlay3D>("DrawOverlay3DOpaque", overlayOpaques, true);
@@ -155,7 +162,7 @@ RenderDeferredTask::RenderDeferredTask(CullFunctor cullFunctor) {
     {
 
         // Debugging Deferred buffer job
-        const auto debugFramebuffers = render::Varying(DebugDeferredBuffer::Inputs(diffusedCurvatureFramebuffer, curvatureFramebuffer));
+        const auto debugFramebuffers = render::Varying(DebugDeferredBuffer::Inputs(deferredFramebuffer, diffusedCurvatureFramebuffer, curvatureFramebuffer));
         addJob<DebugDeferredBuffer>("DebugDeferredBuffer", debugFramebuffers);
 
         // Scene Octree Debuging job
@@ -173,8 +180,12 @@ RenderDeferredTask::RenderDeferredTask(CullFunctor cullFunctor) {
         }
     }
 
+
+    // AA job to be revisited
+    addJob<Antialiasing>("Antialiasing", primaryFramebuffer);
+
     // Blit!
-    addJob<Blit>("Blit");
+    addJob<Blit>("Blit", primaryFramebuffer);
 }
 
 void RenderDeferredTask::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
@@ -311,7 +322,7 @@ const gpu::PipelinePointer& DrawStencilDeferred::getOpaquePipeline() {
     return _opaquePipeline;
 }
 
-void DrawStencilDeferred::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
+void DrawStencilDeferred::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const DeferredFramebufferPointer& deferredFramebuffer) {
     assert(renderContext->args);
     assert(renderContext->args->hasViewFrustum());
 
@@ -320,7 +331,9 @@ void DrawStencilDeferred::run(const SceneContextPointer& sceneContext, const Ren
     doInBatch(args->_context, [&](gpu::Batch& batch) {
         args->_batch = &batch;
 
-        auto deferredFboColorDepthStencil = DependencyManager::get<FramebufferCache>()->getDeferredFramebufferDepthColor();
+       // auto deferredFboColorDepthStencil = DependencyManager::get<FramebufferCache>()->getDeferredFramebufferDepthColor();
+        auto deferredFboColorDepthStencil = deferredFramebuffer->getDeferredFramebufferDepthColor();
+        
 
         batch.enableStereo(false);
 
@@ -346,11 +359,11 @@ void DrawBackgroundDeferred::run(const SceneContextPointer& sceneContext, const
         args->_batch = &batch;
         _gpuTimer.begin(batch);
 
-        auto lightingFBO = DependencyManager::get<FramebufferCache>()->getLightingFramebuffer();
+    //    auto lightingFBO = DependencyManager::get<FramebufferCache>()->getLightingFramebuffer();
 
         batch.enableSkybox(true);
 
-        batch.setFramebuffer(lightingFBO);
+   //     batch.setFramebuffer(lightingFBO);
 
         batch.setViewportTransform(args->_viewport);
         batch.setStateScissorRect(args->_viewport);
@@ -371,7 +384,7 @@ void DrawBackgroundDeferred::run(const SceneContextPointer& sceneContext, const
     std::static_pointer_cast<Config>(renderContext->jobConfig)->gpuTime = _gpuTimer.getAverage();
 }
 
-void Blit::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
+void Blit::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const gpu::FramebufferPointer& srcFramebuffer) {
     assert(renderContext->args);
     assert(renderContext->args->_context);
 
@@ -387,8 +400,9 @@ void Blit::run(const SceneContextPointer& sceneContext, const RenderContextPoint
     int height = renderArgs->_viewport.w;
 
     // Blit primary to blit FBO
-    auto framebufferCache = DependencyManager::get<FramebufferCache>();
-    auto primaryFbo = framebufferCache->getPrimaryFramebuffer();
+ //   auto framebufferCache = DependencyManager::get<FramebufferCache>();
+ //   auto primaryFbo = framebufferCache->getPrimaryFramebuffer();
+    auto primaryFbo = srcFramebuffer;
 
     gpu::doInBatch(renderArgs->_context, [&](gpu::Batch& batch) {
         batch.setFramebuffer(blitFbo);
diff --git a/libraries/render-utils/src/RenderDeferredTask.h b/libraries/render-utils/src/RenderDeferredTask.h
index 5a80d4bcea..612d1c5ea4 100755
--- a/libraries/render-utils/src/RenderDeferredTask.h
+++ b/libraries/render-utils/src/RenderDeferredTask.h
@@ -87,11 +87,12 @@ protected:
     bool _stateSort;
 };
 
+class DeferredFramebuffer;
 class DrawStencilDeferred {
 public:
-    using JobModel = render::Job::Model<DrawStencilDeferred>;
+    using JobModel = render::Job::ModelI<DrawStencilDeferred, std::shared_ptr<DeferredFramebuffer>>;
 
-    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext);
+    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const std::shared_ptr<DeferredFramebuffer>& deferredFramebuffer);
     static const gpu::PipelinePointer& getOpaquePipeline();
 
 protected:
@@ -157,9 +158,9 @@ protected:
 
 class Blit {
 public:
-    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext);
+    using JobModel = render::Job::ModelI<Blit, gpu::FramebufferPointer>;
 
-    using JobModel = render::Job::Model<Blit>;
+    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const gpu::FramebufferPointer& srcFramebuffer);
 };
 
 class RenderDeferredTask : public render::Task {
diff --git a/libraries/render-utils/src/SubsurfaceScattering.cpp b/libraries/render-utils/src/SubsurfaceScattering.cpp
index 349e6cc0e2..2e8f81cfaf 100644
--- a/libraries/render-utils/src/SubsurfaceScattering.cpp
+++ b/libraries/render-utils/src/SubsurfaceScattering.cpp
@@ -508,9 +508,11 @@ void DebugSubsurfaceScattering::run(const render::SceneContextPointer& sceneCont
 
 
     auto& frameTransform = inputs.get0();
-    auto& curvatureFramebuffer = inputs.get2();
-    auto& diffusedFramebuffer = inputs.get3();
-    auto& scatteringResource = inputs.get4();
+    auto& deferredFramebuffer = inputs.get1();
+
+    auto& curvatureFramebuffer = inputs.get3();
+    auto& diffusedFramebuffer = inputs.get4();
+    auto& scatteringResource = inputs.get5();
 
     if (!scatteringResource) {
         return;
@@ -563,8 +565,8 @@ void DebugSubsurfaceScattering::run(const render::SceneContextPointer& sceneCont
                 batch.setResourceTexture(ScatteringTask_ScatteringTableSlot, scatteringTable);
                 batch.setResourceTexture(ScatteringTask_CurvatureMapSlot, curvatureFramebuffer->getRenderBuffer(0));
                 batch.setResourceTexture(ScatteringTask_DiffusedCurvatureMapSlot, diffusedFramebuffer->getRenderBuffer(0));
-                batch.setResourceTexture(ScatteringTask_NormalMapSlot, framebufferCache->getDeferredNormalTexture());
-                batch.setResourceTexture(ScatteringTask_AlbedoMapSlot, framebufferCache->getDeferredColorTexture());
+                batch.setResourceTexture(ScatteringTask_NormalMapSlot, deferredFramebuffer->getDeferredNormalTexture());
+                batch.setResourceTexture(ScatteringTask_AlbedoMapSlot, deferredFramebuffer->getDeferredColorTexture());
                 batch.setResourceTexture(ScatteringTask_LinearMapSlot, framebufferCache->getDepthPyramidTexture());
 
 
diff --git a/libraries/render-utils/src/SubsurfaceScattering.h b/libraries/render-utils/src/SubsurfaceScattering.h
index 905e30d74e..28e884b552 100644
--- a/libraries/render-utils/src/SubsurfaceScattering.h
+++ b/libraries/render-utils/src/SubsurfaceScattering.h
@@ -16,6 +16,7 @@
 
 #include "render/DrawTask.h"
 #include "DeferredFrameTransform.h"
+#include "DeferredFramebuffer.h"
 #include "LightingModel.h"
 
 class SubsurfaceScatteringResource {
@@ -161,7 +162,7 @@ signals:
 
 class DebugSubsurfaceScattering {
 public:
-    using Inputs = render::VaryingSet5<DeferredFrameTransformPointer, LightingModelPointer, gpu::FramebufferPointer, gpu::FramebufferPointer, SubsurfaceScatteringResourcePointer>;
+    using Inputs = render::VaryingSet6<DeferredFrameTransformPointer, DeferredFramebufferPointer, LightingModelPointer, gpu::FramebufferPointer, gpu::FramebufferPointer, SubsurfaceScatteringResourcePointer>;
     using Config = DebugSubsurfaceScatteringConfig;
     using JobModel = render::Job::ModelI<DebugSubsurfaceScattering, Inputs, Config>;
 
diff --git a/libraries/render-utils/src/SurfaceGeometryPass.cpp b/libraries/render-utils/src/SurfaceGeometryPass.cpp
index 00fce50bb4..b60ed21f7b 100644
--- a/libraries/render-utils/src/SurfaceGeometryPass.cpp
+++ b/libraries/render-utils/src/SurfaceGeometryPass.cpp
@@ -45,16 +45,18 @@ void SurfaceGeometryPass::configure(const Config& config) {
     }
 }
 
-void SurfaceGeometryPass::run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const DeferredFrameTransformPointer& frameTransform, Outputs& curvatureAndDepth) {
+void SurfaceGeometryPass::run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& curvatureAndDepth) {
     assert(renderContext->args);
     assert(renderContext->args->hasViewFrustum());
 
     RenderArgs* args = renderContext->args;
 
+    const auto frameTransform = inputs.get0();
+    const auto deferredFramebuffer = inputs.get1();
 
     auto framebufferCache = DependencyManager::get<FramebufferCache>();
-    auto depthBuffer = framebufferCache->getPrimaryDepthTexture();
-    auto normalTexture = framebufferCache->getDeferredNormalTexture();
+    auto depthBuffer = deferredFramebuffer->getPrimaryDepthTexture();
+    auto normalTexture = deferredFramebuffer->getDeferredNormalTexture();
     auto pyramidFBO = framebufferCache->getDepthPyramidFramebuffer();
     
     auto pyramidTexture = framebufferCache->getDepthPyramidTexture();
diff --git a/libraries/render-utils/src/SurfaceGeometryPass.h b/libraries/render-utils/src/SurfaceGeometryPass.h
index 834b404429..2c1969a519 100644
--- a/libraries/render-utils/src/SurfaceGeometryPass.h
+++ b/libraries/render-utils/src/SurfaceGeometryPass.h
@@ -16,6 +16,7 @@
 
 #include "render/DrawTask.h"
 #include "DeferredFrameTransform.h"
+#include "DeferredFramebuffer.h"
 
 class SurfaceGeometryPassConfig : public render::Job::Config {
     Q_OBJECT
@@ -40,14 +41,15 @@ signals:
 
 class SurfaceGeometryPass {
 public:
+    using Inputs = render::VaryingSet2<DeferredFrameTransformPointer, DeferredFramebufferPointer>;
     using Outputs = render::VaryingSet2<gpu::FramebufferPointer, gpu::TexturePointer>;
     using Config = SurfaceGeometryPassConfig;
-    using JobModel = render::Job::ModelIO<SurfaceGeometryPass, DeferredFrameTransformPointer, Outputs, Config>;
+    using JobModel = render::Job::ModelIO<SurfaceGeometryPass, Inputs, Outputs, Config>;
 
     SurfaceGeometryPass();
 
     void configure(const Config& config);
-    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const DeferredFrameTransformPointer& frameTransform, Outputs& curvatureAndDepth);
+    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& curvatureAndDepth);
     
     float getCurvatureDepthThreshold() const { return _parametersBuffer.get<Parameters>().curvatureInfo.x; }
     float getCurvatureBasisScale() const { return _parametersBuffer.get<Parameters>().curvatureInfo.y; }
diff --git a/libraries/render-utils/src/ToneMappingEffect.cpp b/libraries/render-utils/src/ToneMappingEffect.cpp
index 6a0020edbf..1cd0e42ad1 100644
--- a/libraries/render-utils/src/ToneMappingEffect.cpp
+++ b/libraries/render-utils/src/ToneMappingEffect.cpp
@@ -116,18 +116,14 @@ void ToneMappingEffect::setToneCurve(ToneCurve curve) {
     }
 }
 
-void ToneMappingEffect::render(RenderArgs* args) {
+void ToneMappingEffect::render(RenderArgs* args, const gpu::TexturePointer& lightingBuffer, const gpu::FramebufferPointer& destinationFramebuffer) {
     if (!_blitLightBuffer) {
         init();
     }
-    auto framebufferCache = DependencyManager::get<FramebufferCache>();
+    auto framebufferSize = glm::ivec2(lightingBuffer->getDimensions());
     gpu::doInBatch(args->_context, [&](gpu::Batch& batch) {
         batch.enableStereo(false);
-        QSize framebufferSize = framebufferCache->getFrameBufferSize();
-
-        auto lightingBuffer = framebufferCache->getLightingTexture();
-        auto destFbo = framebufferCache->getPrimaryFramebuffer();
-        batch.setFramebuffer(destFbo);
+        batch.setFramebuffer(destinationFramebuffer);
 
         // FIXME: Generate the Luminosity map
         //batch.generateTextureMips(lightingBuffer);
@@ -136,10 +132,10 @@ void ToneMappingEffect::render(RenderArgs* args) {
         batch.setProjectionTransform(glm::mat4());
         batch.setViewTransform(Transform());
         {
-            float sMin = args->_viewport.x / (float)framebufferSize.width();
-            float sWidth = args->_viewport.z / (float)framebufferSize.width();
-            float tMin = args->_viewport.y / (float)framebufferSize.height();
-            float tHeight = args->_viewport.w / (float)framebufferSize.height();
+            float sMin = args->_viewport.x / (float)framebufferSize.x;
+            float sWidth = args->_viewport.z / (float)framebufferSize.x;
+            float tMin = args->_viewport.y / (float)framebufferSize.y;
+            float tHeight = args->_viewport.w / (float)framebufferSize.y;
             Transform model;
             batch.setPipeline(_blitLightBuffer);
             model.setTranslation(glm::vec3(sMin, tMin, 0.0));
@@ -159,6 +155,12 @@ void ToneMappingDeferred::configure(const Config& config) {
      _toneMappingEffect.setToneCurve((ToneMappingEffect::ToneCurve)config.curve);
 }
 
-void ToneMappingDeferred::run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext) {
-    _toneMappingEffect.render(renderContext->args);
+void ToneMappingDeferred::run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const Inputs& inputs) {
+  /*  auto framebufferCache = DependencyManager::get<FramebufferCache>();
+    auto lightingBuffer = framebufferCache->getLightingTexture();
+    auto destFbo = framebufferCache->getPrimaryFramebuffer();
+    */
+    auto lightingBuffer = inputs.get0()->getRenderBuffer(0);
+    auto destFbo = inputs.get1();
+    _toneMappingEffect.render(renderContext->args, lightingBuffer, destFbo);
 }
diff --git a/libraries/render-utils/src/ToneMappingEffect.h b/libraries/render-utils/src/ToneMappingEffect.h
index a6a08ab87b..9e8b3f6aa4 100644
--- a/libraries/render-utils/src/ToneMappingEffect.h
+++ b/libraries/render-utils/src/ToneMappingEffect.h
@@ -27,7 +27,7 @@ public:
     ToneMappingEffect();
     virtual ~ToneMappingEffect() {}
 
-    void render(RenderArgs* args);
+    void render(RenderArgs* args, const gpu::TexturePointer& lightingBuffer, const gpu::FramebufferPointer& destinationBuffer);
 
     void setExposure(float exposure);
     float getExposure() const { return _parametersBuffer.get<Parameters>()._exposure; }
@@ -83,11 +83,13 @@ signals:
 
 class ToneMappingDeferred {
 public:
+    // Inputs: lightingFramebuffer, destinationFramebuffer
+    using Inputs = render::VaryingSet2<gpu::FramebufferPointer, gpu::FramebufferPointer>;
     using Config = ToneMappingConfig;
-    using JobModel = render::Job::Model<ToneMappingDeferred, Config>;
+    using JobModel = render::Job::ModelI<ToneMappingDeferred, Inputs, Config>;
 
     void configure(const Config& config);
-    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext);
+    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const Inputs& inputs);
 
     ToneMappingEffect _toneMappingEffect;
 };
diff --git a/libraries/render/src/render/Task.h b/libraries/render/src/render/Task.h
index 409ff7b77f..db9573322f 100644
--- a/libraries/render/src/render/Task.h
+++ b/libraries/render/src/render/Task.h
@@ -55,6 +55,9 @@ public:
     // access potential sub varyings contained in this one.
     Varying operator[] (uint8_t index) const { return (*_concept)[index]; }
     uint8_t length() const { return (*_concept).length(); }
+
+    template <class T> Varying getN (uint8_t index) const { return get<T>()[index]; }
+    template <class T> Varying editN (uint8_t index) { return edit<T>()[index]; }
     
 protected:
     class Concept {
@@ -104,6 +107,12 @@ public:
 
     const T1& get1() const { return second.get<T1>(); }
     T1& edit1() { return second.edit<T1>(); }
+
+    Varying operator[] (uint8_t index) const {
+        if (index == 1) { return second; } else { return first; }
+    }
+
+
 };
 
 
@@ -174,6 +183,34 @@ public:
     T4& edit4() { return std::get<4>((*this)).template edit<T4>(); }
 };
 
+template <class T0, class T1, class T2, class T3, class T4, class T5>
+class VaryingSet6 : public std::tuple<Varying, Varying, Varying, Varying, Varying, Varying>{
+public:
+    using Parent = std::tuple<Varying, Varying, Varying, Varying, Varying, Varying>;
+
+    VaryingSet6() : Parent(Varying(T0()), Varying(T1()), Varying(T2()), Varying(T3()), Varying(T4()), Varying(T5())) {}
+    VaryingSet6(const VaryingSet6& src) : Parent(std::get<0>(src), std::get<1>(src), std::get<2>(src), std::get<3>(src), std::get<4>(src), std::get<5>(src)) {}
+    VaryingSet6(const Varying& first, const Varying& second, const Varying& third, const Varying& fourth, const Varying& fifth, const Varying& sixth) : Parent(first, second, third, fourth, fifth, sixth) {}
+
+    const T0& get0() const { return std::get<0>((*this)).template get<T0>(); }
+    T0& edit0() { return std::get<0>((*this)).template edit<T0>(); }
+
+    const T1& get1() const { return std::get<1>((*this)).template get<T1>(); }
+    T1& edit1() { return std::get<1>((*this)).template edit<T1>(); }
+
+    const T2& get2() const { return std::get<2>((*this)).template get<T2>(); }
+    T2& edit2() { return std::get<2>((*this)).template edit<T2>(); }
+
+    const T3& get3() const { return std::get<3>((*this)).template get<T3>(); }
+    T3& edit3() { return std::get<3>((*this)).template edit<T3>(); }
+
+    const T4& get4() const { return std::get<4>((*this)).template get<T4>(); }
+    T4& edit4() { return std::get<4>((*this)).template edit<T4>(); }
+
+    const T5& get5() const { return std::get<5>((*this)).template get<T5>(); }
+    T5& edit5() { return std::get<5>((*this)).template edit<T5>(); }
+};
+
 template < class T, int NUM >
 class VaryingArray : public std::array<Varying, NUM> {
 public:
diff --git a/tests/gpu-test/src/TestWindow.cpp b/tests/gpu-test/src/TestWindow.cpp
index 104755c1b6..2d08993436 100644
--- a/tests/gpu-test/src/TestWindow.cpp
+++ b/tests/gpu-test/src/TestWindow.cpp
@@ -99,7 +99,7 @@ void TestWindow::beginFrame() {
 #ifdef DEFERRED_LIGHTING
     auto deferredLightingEffect = DependencyManager::get<DeferredLightingEffect>();
 
-    _prepareDeferred.run(_sceneContext, _renderContext);
+    _prepareDeferred.run(_sceneContext, _renderContext, _deferredFramebuffer);
 #else
     gpu::doInBatch(_renderArgs->_context, [&](gpu::Batch& batch) {
         batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLORS, { 0.0f, 0.1f, 0.2f, 1.0f });
@@ -134,13 +134,15 @@ void TestWindow::endFrame() {
 
     RenderDeferred::Inputs deferredInputs;
     deferredInputs.edit0() = frameTransform;
+    deferredInputs.edit1() = _deferredFramebuffer;
     _renderDeferred.run(_sceneContext, _renderContext, deferredInputs);
 
     gpu::doInBatch(_renderArgs->_context, [&](gpu::Batch& batch) {
         PROFILE_RANGE_BATCH(batch, "blit");
         // Blit to screen
         auto framebufferCache = DependencyManager::get<FramebufferCache>();
-        auto framebuffer = framebufferCache->getLightingFramebuffer();
+       // auto framebuffer = framebufferCache->getLightingFramebuffer();
+        auto framebuffer = _deferredFramebuffer->getLightingFramebuffer();
         batch.blit(framebuffer, _renderArgs->_viewport, nullptr, _renderArgs->_viewport);
     });
 #endif
diff --git a/tests/gpu-test/src/TestWindow.h b/tests/gpu-test/src/TestWindow.h
index d6c11b7459..1260b519eb 100644
--- a/tests/gpu-test/src/TestWindow.h
+++ b/tests/gpu-test/src/TestWindow.h
@@ -37,6 +37,7 @@ protected:
     model::LightPointer _light { std::make_shared<model::Light>() };
     
     GenerateDeferredFrameTransform _generateDeferredFrameTransform;
+    DeferredFramebufferPointer _deferredFramebuffer;
     PrepareDeferred _prepareDeferred;
     RenderDeferred _renderDeferred;
 #endif