Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-04-20 14:03:55 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Merge pull request #6569 from Atlante45/graphics

Browse source 
Alpha/Roughness G-Buffer debugging
This commit is contained in:
samcake 2015-12-06 18:56:38 -08:00
commit fae1bd98c8
9 changed files with 146 additions and 38 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

59
examples/utilities/tools/renderEngineDebug.js
View file

@ -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); });
Controller.mousePressEvent.connect( function panelMousePressEvent(event) { return panel.mousePressEvent(event); });
Controller.mouseReleaseEvent.connect(function(event) { return panel.mouseReleaseEvent(event); });
function mouseMoveEvent(event) {
if (resizing) {
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});

3
interface/src/Application.cpp
View file

@ -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)) {

74
libraries/render-utils/src/DebugDeferredBuffer.cpp
View file

@ -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" };
static const std::array<std::string, DebugDeferredBuffer::NUM_SLOTS> SLOT_NAMES {{
enum Slots {
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) {
return std::string("return texture(").append(SLOT_NAMES[slot]).append(", uv);");
static const std::string COMPUTE_PLACEHOLDER { "/*COMPUTE_PLACEHOLDER*/" }; // required
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) {
if (!_pipelines[slot]) {
const gpu::PipelinePointer& DebugDeferredBuffer::getPipeline(Modes mode) {
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::vec2 bottomLeft(0.0f, -1.0f);
glm::vec2 topRight(1.0f, 1.0f);
glm::vec4 color(1.0f, 1.0f, 1.0f, 1.0f);
glm::vec2 bottomLeft(renderContext->_deferredDebugSize.x, renderContext->_deferredDebugSize.y);
glm::vec2 topRight(renderContext->_deferredDebugSize.z, renderContext->_deferredDebugSize.w);
geometryBuffer->renderQuad(batch, bottomLeft, topRight, color);
});
}

28
libraries/render-utils/src/DebugDeferredBuffer.h
View file

@ -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

2
libraries/render-utils/src/RenderDeferredTask.cpp
View file

@ -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);

2
libraries/render-utils/src/RenderDeferredTask.h
View file

@ -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; } }

4
libraries/render-utils/src/debug_deferred_buffer.slf
View file

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

3
libraries/render/src/render/Engine.h
View file

@ -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;

9
libraries/script-engine/src/SceneScriptingInterface.h
View file

@ -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 int doEngineDisplayDebugDeferredBuffer() { return _drawDebugDeferredBuffer; }
Q_INVOKABLE void setEngineDeferredDebugMode(int mode) { _deferredDebugMode = mode; }
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;