Merge pull request #6569 from Atlante45/graphics

Alpha/Roughness G-Buffer debugging

examples/utilities/tools/renderEngineDebug.js

@@ -11,7 +11,11 @@
 Script.include("cookies.js");
 
 var MENU = "Developer>Render>Debug Deferred Buffer";
-var ACTIONS = ["Off", "Diffuse", "Normal", "Specular", "Depth", "Lighting"];
+var ACTIONS = ["Off", "Diffuse", "Alpha", "Specular", "Roughness", "Normal", "Depth", "Lighting", "Custom"];
+
+Number.prototype.clamp = function(min, max) {
+    return Math.min(Math.max(this, min), max);
+};
 
 var panel = new Panel(10, 100);
 
@@ -64,10 +68,23 @@ var overlaysCounter = new CounterWidget(panel, "Overlays",
     function () { return Scene.getEngineMaxDrawnOverlay3DItems(); }
 );
 
+var resizing = false;
+Scene.setEngineDeferredDebugSize({ x: 0.0, y: -1.0, z: 1.0, w: 1.0 }); // Reset to default size
+
+function setEngineDeferredDebugSize(eventX) {
+    var scaledX = (2.0 * (eventX / Window.innerWidth) - 1.0).clamp(-1.0, 1.0);
+    Scene.setEngineDeferredDebugSize({ x: scaledX, y: -1.0, z: 1.0, w: 1.0 });
+}
+function shouldStartResizing(eventX) {
+    var x = Math.abs(eventX - Window.innerWidth * (1.0 + Scene.getEngineDeferredDebugSize().x) / 2.0);
+    var mode = Scene.getEngineDeferredDebugMode();
+    return mode !== -1 && x < 20;
+}
+
 function menuItemEvent(menuItem) {
     var index = ACTIONS.indexOf(menuItem);
     if (index >= 0) {
-        Scene.setEngineDisplayDebugDeferredBuffer(index);
+        Scene.setEngineDeferredDebugMode(index - 1);
         print(menuItem);
     }
 }
@@ -101,9 +118,33 @@ function updateCounters() {
 }
 Script.setInterval(updateCounters, tickTackPeriod);
 
-Controller.mouseMoveEvent.connect(function panelMouseMoveEvent(event) { return panel.mouseMoveEvent(event); });
+function mouseMoveEvent(event) {
-Controller.mousePressEvent.connect( function panelMousePressEvent(event) { return panel.mousePressEvent(event); });
+    if (resizing) {
-Controller.mouseReleaseEvent.connect(function(event) { return panel.mouseReleaseEvent(event); });
+        setEngineDeferredDebugSize(event.x);
+    } else {
+        panel.mouseMoveEvent(event);
+    }
+}
+
+function mousePressEvent(event) {
+    if (shouldStartResizing(event.x)) {
+        resizing = true;
+    } else {
+        panel.mousePressEvent(event);
+    }
+}
+
+function mouseReleaseEvent(event) {
+    if (resizing) {
+        resizing = false;
+    } else {
+        panel.mouseReleaseEvent(event);
+    }
+}
+
+Controller.mouseMoveEvent.connect(mouseMoveEvent);
+Controller.mousePressEvent.connect(mousePressEvent);
+Controller.mouseReleaseEvent.connect(mouseReleaseEvent);
 
 Menu.menuItemEvent.connect(menuItemEvent);
 Menu.addActionGroup(MENU, ACTIONS, ACTIONS[0]);
@@ -111,5 +152,13 @@ Menu.addActionGroup(MENU, ACTIONS, ACTIONS[0]);
 function scriptEnding() {
     panel.destroy();
     Menu.removeActionGroup(MENU);
+    Scene.setEngineDeferredDebugMode(-1);
+    Scene.setEngineDeferredDebugSize({ x: 0.0, y: -1.0, z: 1.0, w: 1.0 }); // Reset to default size
 }
 Script.scriptEnding.connect(scriptEnding);
+
+
+// Collapse items
+panel.mousePressEvent({ x: panel.x, y: panel.items["Overlays"].y});
+panel.mousePressEvent({ x: panel.x, y: panel.items["Transparents"].y});
+panel.mousePressEvent({ x: panel.x, y: panel.items["Opaques"].y});

interface/src/Application.cpp

@@ -3622,7 +3622,8 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
         renderContext._maxDrawnTransparentItems = sceneInterface->getEngineMaxDrawnTransparentItems();
         renderContext._maxDrawnOverlay3DItems = sceneInterface->getEngineMaxDrawnOverlay3DItems();
         
-        renderContext._drawDebugDeferredBuffer = sceneInterface->doEngineDisplayDebugDeferredBuffer();
+        renderContext._deferredDebugMode = sceneInterface->getEngineDeferredDebugMode();
+        renderContext._deferredDebugSize = sceneInterface->getEngineDeferredDebugSize();
         
         renderContext._drawItemStatus = sceneInterface->doEngineDisplayItemStatus();
         if (Menu::getInstance()->isOptionChecked(MenuOption::PhysicsShowOwned)) {

libraries/render-utils/src/DebugDeferredBuffer.cpp

@@ -11,6 +11,8 @@
 
 #include "DebugDeferredBuffer.h"
 
+#include <QString>
+
 #include <gpu/Batch.h>
 #include <gpu/Context.h>
 #include <render/Scene.h>
@@ -24,8 +26,16 @@
 
 using namespace render;
 
-static const std::string PLACEHOLDER { "DEBUG_PLACEHOLDER" };
+enum Slots {
-static const std::array<std::string, DebugDeferredBuffer::NUM_SLOTS> SLOT_NAMES {{
+    Diffuse = 0,
+    Normal,
+    Specular,
+    Depth,
+    Lighting,
+    
+    NUM_SLOTS
+};
+static const std::array<std::string, Slots::NUM_SLOTS> SLOT_NAMES {{
     "diffuseMap",
     "normalMap",
     "specularMap",
@@ -33,14 +43,52 @@ static const std::array<std::string, DebugDeferredBuffer::NUM_SLOTS> SLOT_NAMES
     "lightingMap"
 }};
 
-std::string getCode(int slot) {
+static const std::string COMPUTE_PLACEHOLDER { "/*COMPUTE_PLACEHOLDER*/" }; // required
-    return std::string("return texture(").append(SLOT_NAMES[slot]).append(", uv);");
+static const std::string FUNCTIONS_PLACEHOLDER { "/*FUNCTIONS_PLACEHOLDER*/" }; // optional
+
+std::string DebugDeferredBuffer::getCode(Modes mode) {
+    switch (mode) {
+        case DiffuseMode: {
+            QString code = "return vec4(texture(%1, uv).xyz, 1.0);";
+            return code.arg(SLOT_NAMES[Diffuse].c_str()).toStdString();
+        }
+        case AlphaMode: {
+            QString code = "return vec4(vec3(texture(%1, uv).a), 1.0);";
+            return code.arg(SLOT_NAMES[Diffuse].c_str()).toStdString();
+        }
+        case SpecularMode: {
+            QString code = "return vec4(texture(%1, uv).xyz, 1.0);";
+            return code.arg(SLOT_NAMES[Specular].c_str()).toStdString();
+        }
+        case RoughnessMode: {
+            QString code = "return vec4(vec3(texture(%1, uv).a), 1.0);";
+            return code.arg(SLOT_NAMES[Specular].c_str()).toStdString();
+        }
+        case NormalMode: {
+            QString code = "return vec4(texture(%1, uv).xyz, 1.0);";
+            return code.arg(SLOT_NAMES[Normal].c_str()).toStdString();
+        }
+        case DepthMode: {
+            QString code = "return vec4(vec3(texture(%1, uv).x), 1.0);";
+            return code.arg(SLOT_NAMES[Depth].c_str()).toStdString();
+        }
+        case LightingMode: {
+            QString code = "return vec4(texture(%1, uv).xyz, 1.0);";
+            return code.arg(SLOT_NAMES[Lighting].c_str()).toStdString();
+        }
+        case CustomMode:
+            return std::string("return vec4(1.0);");
+        case NUM_MODES:
+            Q_UNIMPLEMENTED();
+            return std::string("return vec4(1.0);");
+    }
 }
 
-const gpu::PipelinePointer& DebugDeferredBuffer::getPipeline(int slot) {
+const gpu::PipelinePointer& DebugDeferredBuffer::getPipeline(Modes mode) {
-    if (!_pipelines[slot]) {
+    if (!_pipelines[mode]) {
         std::string fragmentShader = debug_deferred_buffer_frag;
-        fragmentShader.replace(fragmentShader.find(PLACEHOLDER), PLACEHOLDER.size(), getCode(slot));
+        fragmentShader.replace(fragmentShader.find(COMPUTE_PLACEHOLDER), COMPUTE_PLACEHOLDER.size(),
+                               getCode(mode));
         
         auto vs = gpu::ShaderPointer(gpu::Shader::createVertex({ debug_deferred_buffer_vert }));
         auto ps = gpu::ShaderPointer(gpu::Shader::createPixel(fragmentShader));
@@ -53,9 +101,9 @@ const gpu::PipelinePointer& DebugDeferredBuffer::getPipeline(int slot) {
         gpu::Shader::makeProgram(*program, slotBindings);
         
         // Good to go add the brand new pipeline
-        _pipelines[slot] = gpu::Pipeline::create(program, std::make_shared<gpu::State>());
+        _pipelines[mode] = gpu::Pipeline::create(program, std::make_shared<gpu::State>());
     }
-    return _pipelines[slot];
+    return _pipelines[mode];
 }
 
 
@@ -76,7 +124,7 @@ void DebugDeferredBuffer::run(const SceneContextPointer& sceneContext, const Ren
         batch.setViewTransform(viewMat);
         batch.setModelTransform(Transform());
         
-        batch.setPipeline(getPipeline((DebugDeferredBufferSlot)(renderContext->_drawDebugDeferredBuffer - 1)));
+        batch.setPipeline(getPipeline(Modes(renderContext->_deferredDebugMode)));
         
         batch.setResourceTexture(Diffuse, framebufferCache->getDeferredColorTexture());
         batch.setResourceTexture(Normal, framebufferCache->getDeferredNormalTexture());
@@ -84,9 +132,9 @@ void DebugDeferredBuffer::run(const SceneContextPointer& sceneContext, const Ren
         batch.setResourceTexture(Depth, framebufferCache->getPrimaryDepthTexture());
         batch.setResourceTexture(Lighting, framebufferCache->getLightingTexture());
         
-        glm::vec4 color(0.0f, 0.0f, 1.0f, 1.0f);
+        glm::vec4 color(1.0f, 1.0f, 1.0f, 1.0f);
-        glm::vec2 bottomLeft(0.0f, -1.0f);
+        glm::vec2 bottomLeft(renderContext->_deferredDebugSize.x, renderContext->_deferredDebugSize.y);
-        glm::vec2 topRight(1.0f, 1.0f);
+        glm::vec2 topRight(renderContext->_deferredDebugSize.z, renderContext->_deferredDebugSize.w);
         geometryBuffer->renderQuad(batch, bottomLeft, topRight, color);
     });
 }

libraries/render-utils/src/DebugDeferredBuffer.h

@@ -18,22 +18,26 @@ class DebugDeferredBuffer {
 public:
     using JobModel = render::Job::Model<DebugDeferredBuffer>;
     
-    enum DebugDeferredBufferSlot : int {
-        Diffuse = 0,
-        Normal,
-        Specular,
-        Depth,
-        Lighting,
-        
-        NUM_SLOTS
-    };
-    
     void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext);
     
 private:
-    const gpu::PipelinePointer& getPipeline(int slot);
+    enum Modes : int {
+        DiffuseMode = 0,
+        AlphaMode,
+        SpecularMode,
+        RoughnessMode,
+        NormalMode,
+        DepthMode,
+        LightingMode,
+        CustomMode,
+        
+        NUM_MODES
+    };
     
-    std::array<gpu::PipelinePointer, NUM_SLOTS> _pipelines;
+    const gpu::PipelinePointer& getPipeline(Modes mode);
+    std::string getCode(Modes mode);
+    
+    std::array<gpu::PipelinePointer, NUM_MODES> _pipelines;
 };
 
 #endif // hifi_DebugDeferredBuffer_h

libraries/render-utils/src/RenderDeferredTask.cpp

@@ -157,7 +157,7 @@ void RenderDeferredTask::run(const SceneContextPointer& sceneContext, const Rend
     }
 
     // Make sure we turn the deferred buffer debug on/off
-    setDrawDebugDeferredBuffer(renderContext->_drawDebugDeferredBuffer);
+    setDrawDebugDeferredBuffer(renderContext->_deferredDebugMode);
     
     // Make sure we turn the displayItemStatus on/off
     setDrawItemStatus(renderContext->_drawItemStatus);

libraries/render-utils/src/RenderDeferredTask.h

@@ -100,7 +100,7 @@ public:
     
     void setDrawDebugDeferredBuffer(int draw) {
         if (_drawDebugDeferredBufferIndex >= 0) {
-            _jobs[_drawDebugDeferredBufferIndex].setEnabled(draw > 0);
+            _jobs[_drawDebugDeferredBufferIndex].setEnabled(draw >= 0);
         }
     }
     bool doDrawDebugDeferredBuffer() const { if (_drawDebugDeferredBufferIndex >= 0) { return _jobs[_drawDebugDeferredBufferIndex].isEnabled(); } else { return false; } }

libraries/render-utils/src/debug_deferred_buffer.slf

@@ -17,8 +17,10 @@
 in vec2 uv;
 out vec4 outFragColor;
 
+/*FUNCTIONS_PLACEHOLDER*/
+
 vec4 getFragmentColor() {
-    DEBUG_PLACEHOLDER
+    /*COMPUTE_PLACEHOLDER*/
 }
 
 void main(void) {

libraries/render/src/render/Engine.h

@@ -53,7 +53,8 @@ public:
     int _numDrawnOverlay3DItems = 0;
     int _maxDrawnOverlay3DItems = -1;
 
-    int _drawDebugDeferredBuffer = 0;
+    int _deferredDebugMode = -1;
+    glm::vec4 _deferredDebugSize { 0.0f, -1.0f, 1.0f, 1.0f };
     int _drawItemStatus = 0;
     bool _drawHitEffect = false;
 

libraries/script-engine/src/SceneScriptingInterface.h

@@ -107,8 +107,10 @@ public:
     Q_INVOKABLE void setEngineMaxDrawnOverlay3DItems(int count) { _maxDrawnOverlay3DItems = count; }
     Q_INVOKABLE int getEngineMaxDrawnOverlay3DItems() { return _maxDrawnOverlay3DItems; }
     
-    Q_INVOKABLE void setEngineDisplayDebugDeferredBuffer(int display) { _drawDebugDeferredBuffer = display; }
+    Q_INVOKABLE void setEngineDeferredDebugMode(int mode) { _deferredDebugMode = mode; }
-    Q_INVOKABLE int doEngineDisplayDebugDeferredBuffer() { return _drawDebugDeferredBuffer; }
+    Q_INVOKABLE int getEngineDeferredDebugMode() { return _deferredDebugMode; }
+    Q_INVOKABLE void setEngineDeferredDebugSize(glm::vec4 size) { _deferredDebugSize = size; }
+    Q_INVOKABLE glm::vec4 getEngineDeferredDebugSize() { return _deferredDebugSize; }
     
     Q_INVOKABLE void setEngineDisplayItemStatus(int display) { _drawItemStatus = display; }
     Q_INVOKABLE int doEngineDisplayItemStatus() { return _drawItemStatus; }
@@ -146,7 +148,8 @@ protected:
     int _maxDrawnTransparentItems = -1;
     int _maxDrawnOverlay3DItems = -1;
     
-    int _drawDebugDeferredBuffer = 0;
+    int _deferredDebugMode = -1;
+    glm::vec4 _deferredDebugSize { 0.0f, -1.0f, 1.0f, 1.0f };
     int _drawItemStatus = 0;
 
     bool _drawHitEffect = false;