Merging with master

examples/utilities/tools/renderEngineDebug.js

@@ -66,6 +66,12 @@ var overlaysCounter = new CounterWidget(panel, "Overlays",
 var showDisplayStatusFlag = 1;
 var showNetworkStatusFlag = 2;
 
+panel.newCheckbox("Debug deferred buffer",
+    function(value) { Scene.setEngineDisplayDebugDeferredBuffer(value > 0); },
+    function() { return Scene.doEngineDisplayDebugDeferredBuffer() > 0; },
+    function(value) { return value > 0; }
+);
+
 panel.newCheckbox("Display status",
     function(value) { Scene.setEngineDisplayItemStatus(value ?
                                                        Scene.doEngineDisplayItemStatus() | showDisplayStatusFlag :

interface/src/Application.cpp

@@ -683,9 +683,9 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer) :
     _applicationStateDevice->addInputVariant(QString("ComfortMode"), controller::StateController::ReadLambda([]() -> float {
         return (float)Menu::getInstance()->isOptionChecked(MenuOption::ComfortMode);
     }));
-	_applicationStateDevice->addInputVariant(QString("Grounded"), controller::StateController::ReadLambda([]() -> float {
-		return (float)qApp->getMyAvatar()->getCharacterController()->onGround();
-	}));
+    _applicationStateDevice->addInputVariant(QString("Grounded"), controller::StateController::ReadLambda([]() -> float {
+        return (float)qApp->getMyAvatar()->getCharacterController()->onGround();
+    }));
 
     userInputMapper->registerDevice(_applicationStateDevice);
 
@@ -1353,7 +1353,7 @@ void Application::paintGL() {
     {
         PROFILE_RANGE(__FUNCTION__ "/compositor");
         PerformanceTimer perfTimer("compositor");
-        auto primaryFbo = framebufferCache->getPrimaryFramebuffer();
+        auto primaryFbo = framebufferCache->getPrimaryFramebufferDepthColor();
         glBindFramebuffer(GL_DRAW_FRAMEBUFFER, gpu::GLBackend::getFramebufferID(primaryFbo));
         if (displayPlugin->isStereo()) {
             QRect currentViewport(QPoint(0, 0), QSize(size.width() / 2, size.height()));
@@ -1378,7 +1378,8 @@ void Application::paintGL() {
     {
         PROFILE_RANGE(__FUNCTION__ "/pluginOutput");
         PerformanceTimer perfTimer("pluginOutput");
-        auto primaryFramebuffer = framebufferCache->getPrimaryFramebuffer();
+
+        auto primaryFramebuffer = framebufferCache->getPrimaryFramebufferDepthColor();
         auto scratchFramebuffer = framebufferCache->getFramebuffer();
         gpu::doInBatch(renderArgs._context, [=](gpu::Batch& batch) {
             gpu::Vec4i rect;
@@ -3620,7 +3621,9 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
         renderContext._maxDrawnOpaqueItems = sceneInterface->getEngineMaxDrawnOpaqueItems();
         renderContext._maxDrawnTransparentItems = sceneInterface->getEngineMaxDrawnTransparentItems();
         renderContext._maxDrawnOverlay3DItems = sceneInterface->getEngineMaxDrawnOverlay3DItems();
-
+        
+        renderContext._drawDebugDeferredBuffer = sceneInterface->doEngineDisplayDebugDeferredBuffer();
+        
         renderContext._drawItemStatus = sceneInterface->doEngineDisplayItemStatus();
         if (Menu::getInstance()->isOptionChecked(MenuOption::PhysicsShowOwned)) {
             renderContext._drawItemStatus |= render::showNetworkStatusFlag;

libraries/render-utils/src/AmbientOcclusionEffect.cpp

@@ -201,7 +201,7 @@ void AmbientOcclusion::run(const render::SceneContextPointer& sceneContext, cons
         // Occlusion step
         getOcclusionPipeline();
         batch.setResourceTexture(0, framebufferCache->getPrimaryDepthTexture());
-        batch.setResourceTexture(1, framebufferCache->getPrimaryNormalTexture());
+        batch.setResourceTexture(1, framebufferCache->getDeferredNormalTexture());
         _occlusionBuffer->setRenderBuffer(0, _occlusionTexture);
         batch.setFramebuffer(_occlusionBuffer);
 
@@ -276,7 +276,7 @@ void AmbientOcclusion::run(const render::SceneContextPointer& sceneContext, cons
         // Blend step
         getBlendPipeline();
         batch.setResourceTexture(0, _hBlurTexture);
-        batch.setFramebuffer(framebufferCache->getPrimaryFramebuffer());
+        batch.setFramebuffer(framebufferCache->getDeferredFramebuffer());
 
         // Bind the fourth gpu::Pipeline we need - for blending the primary color buffer with blurred occlusion texture
         batch.setPipeline(getBlendPipeline());

libraries/render-utils/src/AntialiasingEffect.cpp

@@ -123,7 +123,7 @@ void Antialiasing::run(const render::SceneContextPointer& sceneContext, const re
 
         // FXAA step
         getAntialiasingPipeline();
-        batch.setResourceTexture(0, framebufferCache->getPrimaryColorTexture());
+        batch.setResourceTexture(0, framebufferCache->getDeferredColorTexture());
         _antialiasingBuffer->setRenderBuffer(0, _antialiasingTexture);
         batch.setFramebuffer(_antialiasingBuffer);
         batch.setPipeline(getAntialiasingPipeline());
@@ -153,7 +153,7 @@ void Antialiasing::run(const render::SceneContextPointer& sceneContext, const re
         // Blend step
         getBlendPipeline();
         batch.setResourceTexture(0, _antialiasingTexture);
-        batch.setFramebuffer(framebufferCache->getPrimaryFramebuffer());
+        batch.setFramebuffer(framebufferCache->getDeferredFramebuffer());
         batch.setPipeline(getBlendPipeline());
 
         DependencyManager::get<GeometryCache>()->renderQuad(batch, bottomLeft, topRight, texCoordTopLeft, texCoordBottomRight, color);

libraries/render-utils/src/DebugDeferredBuffer.cpp

@@ -0,0 +1,70 @@
+//
+//  DebugDeferredBuffer.cpp
+//  libraries/render-utils/src
+//
+//  Created by Clement on 12/3/15.
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include "DebugDeferredBuffer.h"
+
+#include <gpu/Batch.h>
+#include <gpu/Context.h>
+#include <render/Scene.h>
+#include <ViewFrustum.h>
+
+#include "GeometryCache.h"
+#include "FramebufferCache.h"
+
+#include "debug_deferred_buffer_vert.h"
+#include "debug_deferred_buffer_frag.h"
+
+using namespace render;
+
+const gpu::PipelinePointer& DebugDeferredBuffer::getPipeline() {
+    if (!_pipeline) {
+        auto vs = gpu::ShaderPointer(gpu::Shader::createVertex({ debug_deferred_buffer_vert }));
+        auto ps = gpu::ShaderPointer(gpu::Shader::createPixel({ debug_deferred_buffer_frag }));
+        auto program = gpu::ShaderPointer(gpu::Shader::createProgram(vs, ps));
+        
+        
+        gpu::Shader::BindingSet slotBindings;
+        gpu::Shader::makeProgram(*program, slotBindings);
+        
+        // Good to go add the brand new pipeline
+        _pipeline = gpu::Pipeline::create(program, std::make_shared<gpu::State>());
+    }
+    return _pipeline;
+}
+
+
+void DebugDeferredBuffer::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
+    assert(renderContext->args);
+    assert(renderContext->args->_viewFrustum);
+    RenderArgs* args = renderContext->args;
+    gpu::doInBatch(args->_context, [&](gpu::Batch& batch) {
+        auto geometryBuffer = DependencyManager::get<GeometryCache>();
+        auto framebufferCache = DependencyManager::get<FramebufferCache>();
+        
+        
+        glm::mat4 projMat;
+        Transform viewMat;
+        args->_viewFrustum->evalProjectionMatrix(projMat);
+        args->_viewFrustum->evalViewTransform(viewMat);
+        batch.setProjectionTransform(projMat);
+        batch.setViewTransform(viewMat);
+        batch.setModelTransform(Transform());
+        
+        batch.setPipeline(getPipeline());
+        
+        batch.setResourceTexture(0, framebufferCache->getDeferredColorTexture());
+        
+        glm::vec4 color(0.0f, 0.0f, 1.0f, 1.0f);
+        glm::vec2 bottomLeft(0.0f, -1.0f);
+        glm::vec2 topRight(1.0f, 1.0f);
+        geometryBuffer->renderQuad(batch, bottomLeft, topRight, color);
+    });
+}

libraries/render-utils/src/DebugDeferredBuffer.h

@@ -0,0 +1,29 @@
+//
+//  DebugDeferredBuffer.h
+//  libraries/render-utils/src
+//
+//  Created by Clement on 12/3/15.
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef hifi_DebugDeferredBuffer_h
+#define hifi_DebugDeferredBuffer_h
+
+#include <render/DrawTask.h>
+
+class DebugDeferredBuffer {
+public:
+    using JobModel = render::Job::Model<DebugDeferredBuffer>;
+    
+    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext);
+    
+private:
+    const gpu::PipelinePointer& getPipeline();
+    
+    gpu::PipelinePointer _pipeline;
+};
+
+#endif // hifi_DebugDeferredBuffer_h

libraries/render-utils/src/DeferredLightingEffect.cpp

@@ -374,9 +374,9 @@ void DeferredLightingEffect::prepare(RenderArgs* args) {
         batch.enableStereo(false);
         batch.setStateScissorRect(args->_viewport);
 
-        auto primaryFbo = DependencyManager::get<FramebufferCache>()->getPrimaryFramebuffer();
+        auto deferredFbo = DependencyManager::get<FramebufferCache>()->getDeferredFramebuffer();
 
-        batch.setFramebuffer(primaryFbo);
+        batch.setFramebuffer(deferredFbo);
         // clear the normal and specular buffers
         batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLOR1, glm::vec4(0.0f, 0.0f, 0.0f, 0.0f), true);
         const float MAX_SPECULAR_EXPONENT = 128.0f;
@@ -412,9 +412,9 @@ void DeferredLightingEffect::render(RenderArgs* args) {
         batch.clearColorFramebuffer(lightingFBO->getBufferMask(), glm::vec4(0.0f, 0.0f, 0.0f, 0.0f), true);
 
         // BInd the G-Buffer surfaces
-        batch.setResourceTexture(0, framebufferCache->getPrimaryColorTexture());
-        batch.setResourceTexture(1, framebufferCache->getPrimaryNormalTexture());
-        batch.setResourceTexture(2, framebufferCache->getPrimarySpecularTexture());
+        batch.setResourceTexture(0, framebufferCache->getDeferredColorTexture());
+        batch.setResourceTexture(1, framebufferCache->getDeferredNormalTexture());
+        batch.setResourceTexture(2, framebufferCache->getDeferredSpecularTexture());
         batch.setResourceTexture(3, framebufferCache->getPrimaryDepthTexture());
 
         // THe main viewport is assumed to be the mono viewport (or the 2 stereo faces side by side within that viewport)

libraries/render-utils/src/FramebufferCache.cpp

@@ -33,12 +33,14 @@ void FramebufferCache::setFrameBufferSize(QSize frameBufferSize) {
     //If the size changed, we need to delete our FBOs
     if (_frameBufferSize != frameBufferSize) {
         _frameBufferSize = frameBufferSize;
-        _primaryFramebufferFull.reset();
         _primaryFramebufferDepthColor.reset();
         _primaryDepthTexture.reset();
         _primaryColorTexture.reset();
-        _primaryNormalTexture.reset();
-        _primarySpecularTexture.reset();
+        _deferredFramebuffer.reset();
+        _deferredFramebufferDepthColor.reset();
+        _deferredColorTexture.reset();
+        _deferredNormalTexture.reset();
+        _deferredSpecularTexture.reset();
         _selfieFramebuffer.reset();
         _cachedFramebuffers.clear();
         _lightingTexture.reset();
@@ -47,8 +49,9 @@ void FramebufferCache::setFrameBufferSize(QSize frameBufferSize) {
 }
 
 void FramebufferCache::createPrimaryFramebuffer() {
-    _primaryFramebufferFull = gpu::FramebufferPointer(gpu::Framebuffer::create());
     _primaryFramebufferDepthColor = gpu::FramebufferPointer(gpu::Framebuffer::create());
+    _deferredFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
+    _deferredFramebufferDepthColor = gpu::FramebufferPointer(gpu::Framebuffer::create());
 
     auto colorFormat = gpu::Element(gpu::VEC4, gpu::NUINT8, gpu::RGBA);
     auto width = _frameBufferSize.width();
@@ -56,23 +59,30 @@ void FramebufferCache::createPrimaryFramebuffer() {
 
     auto defaultSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_POINT);
     _primaryColorTexture = gpu::TexturePointer(gpu::Texture::create2D(colorFormat, width, height, defaultSampler));
-    _primaryNormalTexture = gpu::TexturePointer(gpu::Texture::create2D(colorFormat, width, height, defaultSampler));
-    _primarySpecularTexture = gpu::TexturePointer(gpu::Texture::create2D(colorFormat, width, height, defaultSampler));
-
-    _primaryFramebufferFull->setRenderBuffer(0, _primaryColorTexture);
-    _primaryFramebufferFull->setRenderBuffer(1, _primaryNormalTexture);
-    _primaryFramebufferFull->setRenderBuffer(2, _primarySpecularTexture);
 
     _primaryFramebufferDepthColor->setRenderBuffer(0, _primaryColorTexture);
 
+    _deferredColorTexture = gpu::TexturePointer(gpu::Texture::create2D(colorFormat, width, height, defaultSampler));
+    _deferredNormalTexture = gpu::TexturePointer(gpu::Texture::create2D(colorFormat, width, height, defaultSampler));
+    _deferredSpecularTexture = gpu::TexturePointer(gpu::Texture::create2D(colorFormat, width, height, defaultSampler));
+
+    _deferredFramebuffer->setRenderBuffer(0, _deferredColorTexture);
+    _deferredFramebuffer->setRenderBuffer(1, _deferredNormalTexture);
+    _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));
- 
-    _primaryFramebufferFull->setDepthStencilBuffer(_primaryDepthTexture, depthFormat);
 
     _primaryFramebufferDepthColor->setDepthStencilBuffer(_primaryDepthTexture, depthFormat);
- 
+
+    _deferredFramebuffer->setDepthStencilBuffer(_primaryDepthTexture, depthFormat);
+
+    _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);
@@ -84,13 +94,6 @@ void FramebufferCache::createPrimaryFramebuffer() {
     _lightingFramebuffer->setRenderBuffer(0, _lightingTexture);
 }
 
-gpu::FramebufferPointer FramebufferCache::getPrimaryFramebuffer() {
-    if (!_primaryFramebufferFull) {
-        createPrimaryFramebuffer();
-    }
-    return _primaryFramebufferFull;
-}
-
 gpu::FramebufferPointer FramebufferCache::getPrimaryFramebufferDepthColor() {
     if (!_primaryFramebufferDepthColor) {
         createPrimaryFramebuffer();
@@ -112,18 +115,39 @@ gpu::TexturePointer FramebufferCache::getPrimaryColorTexture() {
     return _primaryColorTexture;
 }
 
-gpu::TexturePointer FramebufferCache::getPrimaryNormalTexture() {
-    if (!_primaryNormalTexture) {
+gpu::FramebufferPointer FramebufferCache::getDeferredFramebuffer() {
+    if (!_deferredFramebuffer) {
         createPrimaryFramebuffer();
     }
-    return _primaryNormalTexture;
+    return _deferredFramebuffer;
 }
 
-gpu::TexturePointer FramebufferCache::getPrimarySpecularTexture() {
-    if (!_primarySpecularTexture) {
+gpu::FramebufferPointer FramebufferCache::getDeferredFramebufferDepthColor() {
+    if (!_deferredFramebufferDepthColor) {
         createPrimaryFramebuffer();
     }
-    return _primarySpecularTexture;
+    return _deferredFramebufferDepthColor;
+}
+
+gpu::TexturePointer FramebufferCache::getDeferredColorTexture() {
+    if (!_deferredColorTexture) {
+        createPrimaryFramebuffer();
+    }
+    return _deferredColorTexture;
+}
+
+gpu::TexturePointer FramebufferCache::getDeferredNormalTexture() {
+    if (!_deferredNormalTexture) {
+        createPrimaryFramebuffer();
+    }
+    return _deferredNormalTexture;
+}
+
+gpu::TexturePointer FramebufferCache::getDeferredSpecularTexture() {
+    if (!_deferredSpecularTexture) {
+        createPrimaryFramebuffer();
+    }
+    return _deferredSpecularTexture;
 }
 
 gpu::FramebufferPointer FramebufferCache::getLightingFramebuffer() {

libraries/render-utils/src/FramebufferCache.h

@@ -29,13 +29,17 @@ 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 getPrimaryFramebufferDepthColor();
 
     gpu::TexturePointer getPrimaryDepthTexture();
     gpu::TexturePointer getPrimaryColorTexture();
-    gpu::TexturePointer getPrimaryNormalTexture();
-    gpu::TexturePointer getPrimarySpecularTexture();
+
+    gpu::FramebufferPointer getDeferredFramebuffer();
+    gpu::FramebufferPointer getDeferredFramebufferDepthColor();
+
+    gpu::TexturePointer getDeferredColorTexture();
+    gpu::TexturePointer getDeferredNormalTexture();
+    gpu::TexturePointer getDeferredSpecularTexture();
 
     
     gpu::TexturePointer getLightingTexture();
@@ -60,13 +64,17 @@ private:
 
     void createPrimaryFramebuffer();
 
-    gpu::FramebufferPointer _primaryFramebufferFull;
     gpu::FramebufferPointer _primaryFramebufferDepthColor;
 
     gpu::TexturePointer _primaryDepthTexture;
     gpu::TexturePointer _primaryColorTexture;
-    gpu::TexturePointer _primaryNormalTexture;
-    gpu::TexturePointer _primarySpecularTexture;
+
+    gpu::FramebufferPointer _deferredFramebuffer;
+    gpu::FramebufferPointer _deferredFramebufferDepthColor;
+
+    gpu::TexturePointer _deferredColorTexture;
+    gpu::TexturePointer _deferredNormalTexture;
+    gpu::TexturePointer _deferredSpecularTexture;
 
     gpu::TexturePointer _lightingTexture;
     gpu::FramebufferPointer _lightingFramebuffer;

libraries/render-utils/src/HitEffect.cpp

@@ -14,6 +14,7 @@
 
 #include <glm/gtc/random.hpp>
 
+#include <DependencyManager.h>
 #include <PathUtils.h>
 #include <SharedUtil.h>
 

libraries/render-utils/src/HitEffect.h

@@ -9,11 +9,7 @@
 #ifndef hifi_hitEffect_h
 #define hifi_hitEffect_h
 
-#include <DependencyManager.h>
-#include "render/DrawTask.h"
-
-class AbstractViewStateInterface;
-class ProgramObject;
+#include <render/DrawTask.h>
 
 class HitEffect {
 public:
@@ -23,7 +19,7 @@ public:
     void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext);
     typedef render::Job::Model<HitEffect> JobModel;
     
-    const gpu::PipelinePointer&     getHitEffectPipeline();
+    const gpu::PipelinePointer& getHitEffectPipeline();
     
 private:
     gpu::PipelinePointer _hitEffectPipeline;

libraries/render-utils/src/RenderDeferredTask.cpp

@@ -18,10 +18,11 @@
 #include <gpu/Context.h>
 #include <gpu/StandardShaderLib.h>
 
-#include "FramebufferCache.h"
+#include "DebugDeferredBuffer.h"
 #include "DeferredLightingEffect.h"
-#include "TextureCache.h"
+#include "FramebufferCache.h"
 #include "HitEffect.h"
+#include "TextureCache.h"
 
 #include "render/DrawStatus.h"
 #include "AmbientOcclusionEffect.h"
@@ -38,13 +39,13 @@ void SetupDeferred::run(const SceneContextPointer& sceneContext, const RenderCon
     RenderArgs* args = renderContext->args;
     gpu::doInBatch(args->_context, [=](gpu::Batch& batch) {
 
-        auto primaryFbo = DependencyManager::get<FramebufferCache>()->getPrimaryFramebufferDepthColor();
+        auto deferredFbo = DependencyManager::get<FramebufferCache>()->getDeferredFramebufferDepthColor();
 
         batch.enableStereo(false);
         batch.setViewportTransform(args->_viewport);
         batch.setStateScissorRect(args->_viewport);
 
-        batch.setFramebuffer(primaryFbo);
+        batch.setFramebuffer(deferredFbo);
         batch.clearFramebuffer(
             gpu::Framebuffer::BUFFER_COLOR0 |
             gpu::Framebuffer::BUFFER_DEPTH |
@@ -112,6 +113,10 @@ RenderDeferredTask::RenderDeferredTask() : Task() {
     _jobs.push_back(Job(new DepthSortItems::JobModel("DepthSortTransparent", _jobs.back().getOutput(), DepthSortItems(false))));
     _jobs.push_back(Job(new DrawTransparentDeferred::JobModel("TransparentDeferred", _jobs.back().getOutput())));
     
+    _jobs.push_back(Job(new DebugDeferredBuffer::JobModel("DebugDeferredBuffer")));
+    _jobs.back().setEnabled(false);
+    _drawDebugDeferredBufferIndex = _jobs.size() - 1;
+    
     // Grab a texture map representing the different status icons and assign that to the drawStatsuJob
     auto iconMapPath = PathUtils::resourcesPath() + "icons/statusIconAtlas.svg";
 
@@ -151,10 +156,13 @@ void RenderDeferredTask::run(const SceneContextPointer& sceneContext, const Rend
         return;
     }
 
+    // Make sure we turn the deferred buffer debug on/off
+    setDrawDebugDeferredBuffer(renderContext->_drawDebugDeferredBuffer);
+    
     // Make sure we turn the displayItemStatus on/off
     setDrawItemStatus(renderContext->_drawItemStatus);
     
-    //Make sure we display hit effect on screen, as desired from a script
+    // Make sure we display hit effect on screen, as desired from a script
     setDrawHitEffect(renderContext->_drawHitEffect);
     
 
@@ -332,11 +340,11 @@ void DrawStencilDeferred::run(const SceneContextPointer& sceneContext, const Ren
     doInBatch(args->_context, [=](gpu::Batch& batch) {
         args->_batch = &batch;
 
-        auto primaryFboColorDepthStencil = DependencyManager::get<FramebufferCache>()->getPrimaryFramebufferDepthColor();
+        auto deferredFboColorDepthStencil = DependencyManager::get<FramebufferCache>()->getDeferredFramebufferDepthColor();
 
         batch.enableStereo(false);
 
-        batch.setFramebuffer(primaryFboColorDepthStencil);
+        batch.setFramebuffer(deferredFboColorDepthStencil);
         batch.setViewportTransform(args->_viewport);
         batch.setStateScissorRect(args->_viewport);
 
@@ -367,12 +375,12 @@ void DrawBackgroundDeferred::run(const SceneContextPointer& sceneContext, const
     doInBatch(args->_context, [=](gpu::Batch& batch) {
         args->_batch = &batch;
 
-        auto primaryFboColorDepthStencil = DependencyManager::get<FramebufferCache>()->getPrimaryFramebufferDepthColor();
-        auto primaryFboFull = DependencyManager::get<FramebufferCache>()->getPrimaryFramebuffer();
+        auto deferredFboColorDepthStencil = DependencyManager::get<FramebufferCache>()->getDeferredFramebufferDepthColor();
+        auto deferredFboFull = DependencyManager::get<FramebufferCache>()->getDeferredFramebuffer();
 
         batch.enableSkybox(true);
 
-        batch.setFramebuffer(primaryFboColorDepthStencil);
+        batch.setFramebuffer(deferredFboColorDepthStencil);
 
         batch.setViewportTransform(args->_viewport);
         batch.setStateScissorRect(args->_viewport);
@@ -387,7 +395,7 @@ void DrawBackgroundDeferred::run(const SceneContextPointer& sceneContext, const
 
         renderItems(sceneContext, renderContext, inItems);
 
-        batch.setFramebuffer(primaryFboFull);
+        batch.setFramebuffer(deferredFboFull);
 
     });
     args->_batch = nullptr;

libraries/render-utils/src/RenderDeferredTask.h

@@ -80,9 +80,9 @@ class DrawOverlay3D {
     static gpu::PipelinePointer _opaquePipeline; //lazy evaluation hence mutable
 public:
     static const gpu::PipelinePointer& getOpaquePipeline();
-
+    
     void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext);
-
+    
     typedef render::Job::Model<DrawOverlay3D> JobModel;
 };
 
@@ -93,16 +93,23 @@ public:
     ~RenderDeferredTask();
 
     render::Jobs _jobs;
-
+    
+    int _drawDebugDeferredBufferIndex = -1;
     int _drawStatusJobIndex = -1;
     int _drawHitEffectJobIndex = -1;
-
+    
+    void setDrawDebugDeferredBuffer(int draw) {
+        if (_drawDebugDeferredBufferIndex >= 0) {
+            _jobs[_drawDebugDeferredBufferIndex].setEnabled(draw > 0);
+        }
+    }
+    bool doDrawDebugDeferredBuffer() const { if (_drawDebugDeferredBufferIndex >= 0) { return _jobs[_drawDebugDeferredBufferIndex].isEnabled(); } else { return false; } }
+    
     void setDrawItemStatus(int draw) {
         if (_drawStatusJobIndex >= 0) {
             _jobs[_drawStatusJobIndex].setEnabled(draw > 0);
         }
     }
-
     bool doDrawItemStatus() const { if (_drawStatusJobIndex >= 0) { return _jobs[_drawStatusJobIndex].isEnabled(); } else { return false; } }
     
     void setDrawHitEffect(bool draw) { if (_drawHitEffectJobIndex >= 0) { _jobs[_drawHitEffectJobIndex].setEnabled(draw); } }

libraries/render-utils/src/debug_deferred_buffer.slf

@@ -0,0 +1,22 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//
+//  debug_deferred_buffer.slf
+//  fragment shader
+//
+//  Created by Clement on 12/3
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+<@include DeferredBuffer.slh@>
+
+in vec2 uv;
+out vec4 outFragColor;
+
+void main(void) {
+    outFragColor = texture(diffuseMap, uv);
+}

libraries/render-utils/src/debug_deferred_buffer.slv

@@ -0,0 +1,22 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//
+//  debug_deferred_buffer.slv
+//  vertex shader
+//
+//  Created by Clement on 12/3
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+<@include gpu/Inputs.slh@>
+
+out vec2 uv;
+
+void main(void) {
+    uv = (inPosition.xy + 1.0) * 0.5;
+    gl_Position = inPosition;
+}

libraries/render-utils/src/hit_effect.slf

@@ -20,8 +20,8 @@ in vec2 varQuadPosition;
 out vec4 outFragColor;
 
 void main(void) {
-  vec2 center = vec2(0.0, 0.0);
-  float distFromCenter = distance( vec2(0.0, 0.0), varQuadPosition);
-  float alpha = mix(0.0, 0.5, pow(distFromCenter,5.));
-  outFragColor = vec4(1.0, 0.0, 0.0, alpha);
+    vec2 center = vec2(0.0, 0.0);
+    float distFromCenter = distance( vec2(0.0, 0.0), varQuadPosition);
+    float alpha = mix(0.0, 0.5, pow(distFromCenter,5.));
+    outFragColor = vec4(1.0, 0.0, 0.0, alpha);
 }

libraries/render/src/render/Engine.h

@@ -53,6 +53,7 @@ public:
     int _numDrawnOverlay3DItems = 0;
     int _maxDrawnOverlay3DItems = -1;
 
+    int _drawDebugDeferredBuffer = 0;
     int _drawItemStatus = 0;
     bool _drawHitEffect = false;
 

libraries/script-engine/src/SceneScriptingInterface.h

@@ -106,7 +106,10 @@ public:
     Q_INVOKABLE int getEngineMaxDrawnTransparentItems() { return _maxDrawnTransparentItems; }
     Q_INVOKABLE void setEngineMaxDrawnOverlay3DItems(int count) { _maxDrawnOverlay3DItems = count; }
     Q_INVOKABLE int getEngineMaxDrawnOverlay3DItems() { return _maxDrawnOverlay3DItems; }
-
+    
+    Q_INVOKABLE void setEngineDisplayDebugDeferredBuffer(int display) { _drawDebugDeferredBuffer = display; }
+    Q_INVOKABLE int doEngineDisplayDebugDeferredBuffer() { return _drawDebugDeferredBuffer; }
+    
     Q_INVOKABLE void setEngineDisplayItemStatus(int display) { _drawItemStatus = display; }
     Q_INVOKABLE int doEngineDisplayItemStatus() { return _drawItemStatus; }
 
@@ -142,7 +145,8 @@ protected:
     int _maxDrawnOpaqueItems = -1;
     int _maxDrawnTransparentItems = -1;
     int _maxDrawnOverlay3DItems = -1;
-
+    
+    int _drawDebugDeferredBuffer = 0;
     int _drawItemStatus = 0;
 
     bool _drawHitEffect = false;