nick/WickedEngine
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
Files
54491ad53651f6356b2c9a403ee84eb19327b2fe
WickedEngine/Editor/RendererWindow.cpp
T
Turánszki János 54491ad536 Visbuffer Optimizations (#438) 
Splitting visibility buffer shaders to reduce register usage:
resolve (async)
binning (async)
velocity (async)
surface sampling (async)
sky (async)
lighting (gfx)

Successfully improved GPU utilization in lighting shader.
Binning is faster, because binning tiles and not pixels
Because tiles are binned, lighting tiles are using coherent tile info for whole thread group
Surface, sky and decal rendering also runs now in async compute.
Velocity is separate pass, improves GPU utilization in resolve, and only runs as optional.
Surface shader occupancy is still bad, and wind computation is still bad per pixel, but now it is only done in surface shader.
Surface shader can now write out proper top layer of clearcoated material, this improves screen space and raytraced reflections.
MSAA not implemented yet for visibility compute shading
Tessellation is still only half way supported in visibility compute shading (tessellation data not available in memory for pixel interpolation, but depth is written in prepass, this causes mismatch)
2022-05-15 15:50:42 +02:00

856 lines
36 KiB
C++
Raw Blame History

#include "stdafx.h"
#include "RendererWindow.h"
#include "Editor.h"
#include "shaders/ShaderInterop_DDGI.h"
void RendererWindow::Create(EditorComponent* editor)
{
wi::gui::Window::Create("Renderer Window");
wi::renderer::SetToDrawDebugEnvProbes(true);
wi::renderer::SetToDrawGridHelper(true);
wi::renderer::SetToDrawDebugCameras(true);
SetSize(XMFLOAT2(580, 600));
float x = 220, y = 5, step = 20, itemheight = 18;
vsyncCheckBox.Create("VSync: ");
vsyncCheckBox.SetTooltip("Toggle vertical sync");
vsyncCheckBox.SetScriptTip("SetVSyncEnabled(opt bool enabled)");
vsyncCheckBox.SetPos(XMFLOAT2(x, y += step));
vsyncCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
vsyncCheckBox.SetCheck(editor->main->swapChain.desc.vsync);
vsyncCheckBox.OnClick([=](wi::gui::EventArgs args) {
wi::eventhandler::SetVSync(args.bValue);
});
AddWidget(&vsyncCheckBox);
swapchainComboBox.Create("Swapchain format: ");
swapchainComboBox.SetSize(XMFLOAT2(100, itemheight));
swapchainComboBox.SetPos(XMFLOAT2(x, y += step));
swapchainComboBox.SetTooltip("Choose between different display output formats.\nIf the display doesn't support the selected format, it will switch back to a reasonable default.\nHDR formats will be only selectable when the current display supports HDR output");
AddWidget(&swapchainComboBox);
UpdateSwapChainFormats(&editor->main->swapChain);
occlusionCullingCheckBox.Create("Occlusion Culling: ");
occlusionCullingCheckBox.SetTooltip("Toggle occlusion culling. This can boost framerate if many objects are occluded in the scene.");
occlusionCullingCheckBox.SetScriptTip("SetOcclusionCullingEnabled(bool enabled)");
occlusionCullingCheckBox.SetPos(XMFLOAT2(x, y += step));
occlusionCullingCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
occlusionCullingCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetOcclusionCullingEnabled(args.bValue);
});
occlusionCullingCheckBox.SetCheck(wi::renderer::GetOcclusionCullingEnabled());
AddWidget(&occlusionCullingCheckBox);
visibilityComputeShadingCheckBox.Create("VCS: ");
visibilityComputeShadingCheckBox.SetTooltip("Visibility Compute Shading (experimental)\nThis will shade the scene in compute shaders instead of pixel shaders\nThis has a higher initial performance cost, but it will be faster in high polygon scenes");
visibilityComputeShadingCheckBox.SetPos(XMFLOAT2(x + 120, y));
visibilityComputeShadingCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
visibilityComputeShadingCheckBox.OnClick([=](wi::gui::EventArgs args) {
if (args.bValue)
{
editor->renderPath->visibility_shading_in_compute = true;
}
else
{
editor->renderPath->visibility_shading_in_compute = false;
}
});
visibilityComputeShadingCheckBox.SetCheck(editor->renderPath->visibility_shading_in_compute);
AddWidget(&visibilityComputeShadingCheckBox);
resolutionScaleSlider.Create(0.25f, 2.0f, 1.0f, 7.0f, "Resolution Scale: ");
resolutionScaleSlider.SetTooltip("Adjust the internal rendering resolution.");
resolutionScaleSlider.SetSize(XMFLOAT2(100, itemheight));
resolutionScaleSlider.SetPos(XMFLOAT2(x, y += step));
resolutionScaleSlider.SetValue(editor->resolutionScale);
resolutionScaleSlider.OnSlide([editor](wi::gui::EventArgs args) {
if (editor->resolutionScale != args.fValue)
{
editor->renderPath->resolutionScale = args.fValue;
editor->resolutionScale = args.fValue;
editor->ResizeBuffers();
}
});
AddWidget(&resolutionScaleSlider);
GIBoostSlider.Create(1, 10, 1.0f, 1000.0f, "GI Boost: ");
GIBoostSlider.SetTooltip("Adjust the strength of GI.\nNote that values other than 1.0 will cause mismatch with path tracing reference!");
GIBoostSlider.SetSize(XMFLOAT2(100, itemheight));
GIBoostSlider.SetPos(XMFLOAT2(x, y += step));
GIBoostSlider.SetValue(wi::renderer::GetGIBoost());
GIBoostSlider.OnSlide([editor](wi::gui::EventArgs args) {
wi::renderer::SetGIBoost(args.fValue);
});
AddWidget(&GIBoostSlider);
surfelGICheckBox.Create("Surfel GI: ");
surfelGICheckBox.SetTooltip("Surfel GI is a raytraced diffuse GI using raytracing and surface cache.");
surfelGICheckBox.SetPos(XMFLOAT2(x, y += step));
surfelGICheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
surfelGICheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetSurfelGIEnabled(args.bValue);
});
surfelGICheckBox.SetCheck(wi::renderer::GetSurfelGIEnabled());
AddWidget(&surfelGICheckBox);
surfelGIDebugComboBox.Create("");
surfelGIDebugComboBox.SetTooltip("Choose Surfel GI debug visualization.");
surfelGIDebugComboBox.SetPos(XMFLOAT2(x + 40, y));
surfelGIDebugComboBox.SetSize(XMFLOAT2(80, itemheight));
surfelGIDebugComboBox.AddItem("No Debug", SURFEL_DEBUG_NONE);
surfelGIDebugComboBox.AddItem("Normal", SURFEL_DEBUG_NORMAL);
surfelGIDebugComboBox.AddItem("Color", SURFEL_DEBUG_COLOR);
surfelGIDebugComboBox.AddItem("Point", SURFEL_DEBUG_POINT);
surfelGIDebugComboBox.AddItem("Random", SURFEL_DEBUG_RANDOM);
surfelGIDebugComboBox.AddItem("Heatmap", SURFEL_DEBUG_HEATMAP);
surfelGIDebugComboBox.AddItem("Inconsist.", SURFEL_DEBUG_INCONSISTENCY);
surfelGIDebugComboBox.OnSelect([](wi::gui::EventArgs args) {
wi::renderer::SetSurfelGIDebugEnabled((SURFEL_DEBUG)args.userdata);
});
AddWidget(&surfelGIDebugComboBox);
ddgiCheckBox.Create("DDGI: ");
ddgiCheckBox.SetTooltip("Toggle Dynamic Diffuse Global Illumination (DDGI).");
ddgiCheckBox.SetPos(XMFLOAT2(x, y += step));
ddgiCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
ddgiCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetDDGIEnabled(args.bValue);
});
ddgiCheckBox.SetCheck(wi::renderer::GetDDGIEnabled());
AddWidget(&ddgiCheckBox);
ddgiDebugCheckBox.Create("DEBUG: ");
ddgiDebugCheckBox.SetTooltip("Toggle DDGI probe visualization.");
ddgiDebugCheckBox.SetPos(XMFLOAT2(x + 120, y));
ddgiDebugCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
ddgiDebugCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetDDGIDebugEnabled(args.bValue);
});
ddgiDebugCheckBox.SetCheck(wi::renderer::GetDDGIDebugEnabled());
AddWidget(&ddgiDebugCheckBox);
ddgiRayCountSlider.Create(32, DDGI_MAX_RAYCOUNT, 64, DDGI_MAX_RAYCOUNT - 32, "DDGI RayCount: ");
ddgiRayCountSlider.SetTooltip("Adjust the ray count per DDGI probe.");
ddgiRayCountSlider.SetSize(XMFLOAT2(100, itemheight));
ddgiRayCountSlider.SetPos(XMFLOAT2(x, y += step));
ddgiRayCountSlider.SetValue((float)wi::renderer::GetDDGIRayCount());
ddgiRayCountSlider.OnSlide([&](wi::gui::EventArgs args) {
wi::renderer::SetDDGIRayCount((uint32_t)args.iValue);
});
AddWidget(&ddgiRayCountSlider);
voxelRadianceCheckBox.Create("Voxel GI: ");
voxelRadianceCheckBox.SetTooltip("Toggle voxel Global Illumination computation.");
voxelRadianceCheckBox.SetPos(XMFLOAT2(x, y += step));
voxelRadianceCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
voxelRadianceCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetVoxelRadianceEnabled(args.bValue);
});
voxelRadianceCheckBox.SetCheck(wi::renderer::GetVoxelRadianceEnabled());
AddWidget(&voxelRadianceCheckBox);
voxelRadianceDebugCheckBox.Create("DEBUG: ");
voxelRadianceDebugCheckBox.SetTooltip("Toggle Voxel GI visualization.");
voxelRadianceDebugCheckBox.SetPos(XMFLOAT2(x + 120, y));
voxelRadianceDebugCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
voxelRadianceDebugCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetToDrawVoxelHelper(args.bValue);
});
voxelRadianceDebugCheckBox.SetCheck(wi::renderer::GetToDrawVoxelHelper());
AddWidget(&voxelRadianceDebugCheckBox);
voxelRadianceSecondaryBounceCheckBox.Create("Secondary Light Bounce: ");
voxelRadianceSecondaryBounceCheckBox.SetTooltip("Toggle secondary light bounce computation for Voxel GI.");
voxelRadianceSecondaryBounceCheckBox.SetPos(XMFLOAT2(x, y += step));
voxelRadianceSecondaryBounceCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
voxelRadianceSecondaryBounceCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetVoxelRadianceSecondaryBounceEnabled(args.bValue);
});
voxelRadianceSecondaryBounceCheckBox.SetCheck(wi::renderer::GetVoxelRadianceSecondaryBounceEnabled());
AddWidget(&voxelRadianceSecondaryBounceCheckBox);
voxelRadianceReflectionsCheckBox.Create("Reflections: ");
voxelRadianceReflectionsCheckBox.SetTooltip("Toggle specular reflections computation for Voxel GI.");
voxelRadianceReflectionsCheckBox.SetPos(XMFLOAT2(x + 120, y));
voxelRadianceReflectionsCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
voxelRadianceReflectionsCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetVoxelRadianceReflectionsEnabled(args.bValue);
});
voxelRadianceReflectionsCheckBox.SetCheck(wi::renderer::GetVoxelRadianceReflectionsEnabled());
AddWidget(&voxelRadianceReflectionsCheckBox);
voxelRadianceVoxelSizeSlider.Create(0.25, 2, 1, 7, "Voxel GI Voxel Size: ");
voxelRadianceVoxelSizeSlider.SetTooltip("Adjust the voxel size for Voxel GI calculations.");
voxelRadianceVoxelSizeSlider.SetSize(XMFLOAT2(100, itemheight));
voxelRadianceVoxelSizeSlider.SetPos(XMFLOAT2(x, y += step));
voxelRadianceVoxelSizeSlider.SetValue(wi::renderer::GetVoxelRadianceVoxelSize());
voxelRadianceVoxelSizeSlider.OnSlide([&](wi::gui::EventArgs args) {
wi::renderer::SetVoxelRadianceVoxelSize(args.fValue);
});
AddWidget(&voxelRadianceVoxelSizeSlider);
voxelRadianceConeTracingSlider.Create(1, 16, 8, 15, "Voxel GI NumCones: ");
voxelRadianceConeTracingSlider.SetTooltip("Adjust the number of cones sampled in the radiance gathering phase.");
voxelRadianceConeTracingSlider.SetSize(XMFLOAT2(100, itemheight));
voxelRadianceConeTracingSlider.SetPos(XMFLOAT2(x, y += step));
voxelRadianceConeTracingSlider.SetValue((float)wi::renderer::GetVoxelRadianceNumCones());
voxelRadianceConeTracingSlider.OnSlide([&](wi::gui::EventArgs args) {
wi::renderer::SetVoxelRadianceNumCones(args.iValue);
});
AddWidget(&voxelRadianceConeTracingSlider);
voxelRadianceRayStepSizeSlider.Create(0.5f, 2.0f, 0.5f, 10000, "Voxel GI Ray Step Size: ");
voxelRadianceRayStepSizeSlider.SetTooltip("Adjust the precision of ray marching for cone tracing step. Lower values = more precision but slower performance.");
voxelRadianceRayStepSizeSlider.SetSize(XMFLOAT2(100, itemheight));
voxelRadianceRayStepSizeSlider.SetPos(XMFLOAT2(x, y += step));
voxelRadianceRayStepSizeSlider.SetValue(wi::renderer::GetVoxelRadianceRayStepSize());
voxelRadianceRayStepSizeSlider.OnSlide([&](wi::gui::EventArgs args) {
wi::renderer::SetVoxelRadianceRayStepSize(args.fValue);
});
AddWidget(&voxelRadianceRayStepSizeSlider);
voxelRadianceMaxDistanceSlider.Create(0, 100, 10, 10000, "Voxel GI Max Distance: ");
voxelRadianceMaxDistanceSlider.SetTooltip("Adjust max raymarching distance for voxel GI.");
voxelRadianceMaxDistanceSlider.SetSize(XMFLOAT2(100, itemheight));
voxelRadianceMaxDistanceSlider.SetPos(XMFLOAT2(x, y += step));
voxelRadianceMaxDistanceSlider.SetValue(wi::renderer::GetVoxelRadianceMaxDistance());
voxelRadianceMaxDistanceSlider.OnSlide([&](wi::gui::EventArgs args) {
wi::renderer::SetVoxelRadianceMaxDistance(args.fValue);
});
AddWidget(&voxelRadianceMaxDistanceSlider);
wireFrameCheckBox.Create("Render Wireframe: ");
wireFrameCheckBox.SetTooltip("Visualize the scene as a wireframe");
wireFrameCheckBox.SetPos(XMFLOAT2(x, y += step));
wireFrameCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
wireFrameCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetWireRender(args.bValue);
});
wireFrameCheckBox.SetCheck(wi::renderer::IsWireRender());
AddWidget(&wireFrameCheckBox);
variableRateShadingClassificationCheckBox.Create("VRS Classification: ");
variableRateShadingClassificationCheckBox.SetTooltip("Enable classification of variable rate shading on the screen. Less important parts will be shaded with lesser resolution.\nRequires Tier2 support for variable shading rate");
variableRateShadingClassificationCheckBox.SetPos(XMFLOAT2(x, y += step));
variableRateShadingClassificationCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
variableRateShadingClassificationCheckBox.OnClick([editor](wi::gui::EventArgs args) {
wi::renderer::SetVariableRateShadingClassification(args.bValue);
editor->ResizeBuffers();
});
variableRateShadingClassificationCheckBox.SetCheck(wi::renderer::GetVariableRateShadingClassification());
AddWidget(&variableRateShadingClassificationCheckBox);
variableRateShadingClassificationCheckBox.SetEnabled(wi::graphics::GetDevice()->CheckCapability(wi::graphics::GraphicsDeviceCapability::VARIABLE_RATE_SHADING_TIER2));
variableRateShadingClassificationDebugCheckBox.Create("DEBUG: ");
variableRateShadingClassificationDebugCheckBox.SetTooltip("Toggle visualization of variable rate shading classification feature");
variableRateShadingClassificationDebugCheckBox.SetPos(XMFLOAT2(x + 120, y));
variableRateShadingClassificationDebugCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
variableRateShadingClassificationDebugCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetVariableRateShadingClassificationDebug(args.bValue);
});
variableRateShadingClassificationDebugCheckBox.SetCheck(wi::renderer::GetVariableRateShadingClassificationDebug());
AddWidget(&variableRateShadingClassificationDebugCheckBox);
variableRateShadingClassificationDebugCheckBox.SetEnabled(wi::graphics::GetDevice()->CheckCapability(wi::graphics::GraphicsDeviceCapability::VARIABLE_RATE_SHADING_TIER2));
advancedLightCullingCheckBox.Create("2.5D Light Culling: ");
advancedLightCullingCheckBox.SetTooltip("Enable a more aggressive light culling approach which can result in slower culling but faster rendering (Tiled renderer only)");
advancedLightCullingCheckBox.SetPos(XMFLOAT2(x, y += step));
advancedLightCullingCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
advancedLightCullingCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetAdvancedLightCulling(args.bValue);
});
advancedLightCullingCheckBox.SetCheck(wi::renderer::GetAdvancedLightCulling());
AddWidget(&advancedLightCullingCheckBox);
debugLightCullingCheckBox.Create("DEBUG: ");
debugLightCullingCheckBox.SetTooltip("Toggle visualization of the screen space light culling heatmap grid (Tiled renderer only)");
debugLightCullingCheckBox.SetPos(XMFLOAT2(x + 120, y));
debugLightCullingCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
debugLightCullingCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetDebugLightCulling(args.bValue);
});
debugLightCullingCheckBox.SetCheck(wi::renderer::GetDebugLightCulling());
AddWidget(&debugLightCullingCheckBox);
tessellationCheckBox.Create("Tessellation Enabled: ");
tessellationCheckBox.SetTooltip("Enable tessellation feature. You also need to specify a tessellation factor for individual objects.");
tessellationCheckBox.SetPos(XMFLOAT2(x, y += step));
tessellationCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
tessellationCheckBox.OnClick([=](wi::gui::EventArgs args) {
wi::renderer::SetTessellationEnabled(args.bValue);
});
tessellationCheckBox.SetCheck(wi::renderer::GetTessellationEnabled());
AddWidget(&tessellationCheckBox);
tessellationCheckBox.SetEnabled(wi::graphics::GetDevice()->CheckCapability(wi::graphics::GraphicsDeviceCapability::TESSELLATION));
speedMultiplierSlider.Create(0, 4, 1, 100000, "Speed: ");
speedMultiplierSlider.SetTooltip("Adjust the global speed (time multiplier)");
speedMultiplierSlider.SetSize(XMFLOAT2(100, itemheight));
speedMultiplierSlider.SetPos(XMFLOAT2(x, y += step));
speedMultiplierSlider.SetValue(wi::renderer::GetGameSpeed());
speedMultiplierSlider.OnSlide([&](wi::gui::EventArgs args) {
wi::renderer::SetGameSpeed(args.fValue);
});
AddWidget(&speedMultiplierSlider);
transparentShadowsCheckBox.Create("Transparent Shadows: ");
transparentShadowsCheckBox.SetTooltip("Enables color tinted shadows and refraction caustics effects for transparent objects and water.");
transparentShadowsCheckBox.SetPos(XMFLOAT2(x, y += step));
transparentShadowsCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
transparentShadowsCheckBox.SetCheck(wi::renderer::GetTransparentShadowsEnabled());
transparentShadowsCheckBox.OnClick([=](wi::gui::EventArgs args) {
wi::renderer::SetTransparentShadowsEnabled(args.bValue);
});
AddWidget(&transparentShadowsCheckBox);
shadowTypeComboBox.Create("Shadow type: ");
shadowTypeComboBox.SetSize(XMFLOAT2(100, itemheight));
shadowTypeComboBox.SetPos(XMFLOAT2(x, y += step));
shadowTypeComboBox.AddItem("Shadowmaps");
if (wi::graphics::GetDevice()->CheckCapability(wi::graphics::GraphicsDeviceCapability::RAYTRACING))
{
shadowTypeComboBox.AddItem("Ray traced");
}
shadowTypeComboBox.OnSelect([&](wi::gui::EventArgs args) {
switch (args.iValue)
{
default:
case 0:
wi::renderer::SetRaytracedShadowsEnabled(false);
break;
case 1:
wi::renderer::SetRaytracedShadowsEnabled(true);
break;
}
});
shadowTypeComboBox.SetSelected(0);
shadowTypeComboBox.SetTooltip("Choose between shadowmaps and ray traced shadows (if available).\n(ray traced shadows need hardware raytracing support)");
AddWidget(&shadowTypeComboBox);
shadowProps2DComboBox.Create("2D Shadowmap resolution: ");
shadowProps2DComboBox.SetSize(XMFLOAT2(100, itemheight));
shadowProps2DComboBox.SetPos(XMFLOAT2(x, y += step));
shadowProps2DComboBox.AddItem("Off");
shadowProps2DComboBox.AddItem("128");
shadowProps2DComboBox.AddItem("256");
shadowProps2DComboBox.AddItem("512");
shadowProps2DComboBox.AddItem("1024");
shadowProps2DComboBox.AddItem("2048");
shadowProps2DComboBox.AddItem("4096");
shadowProps2DComboBox.OnSelect([&](wi::gui::EventArgs args) {
switch (args.iValue)
{
case 0:
wi::renderer::SetShadowProps2D(0, -1);
break;
case 1:
wi::renderer::SetShadowProps2D(128, -1);
break;
case 2:
wi::renderer::SetShadowProps2D(256, -1);
break;
case 3:
wi::renderer::SetShadowProps2D(512, -1);
break;
case 4:
wi::renderer::SetShadowProps2D(1024, -1);
break;
case 5:
wi::renderer::SetShadowProps2D(2048, -1);
break;
case 6:
wi::renderer::SetShadowProps2D(4096, -1);
break;
default:
break;
}
});
shadowProps2DComboBox.SetSelected(4);
shadowProps2DComboBox.SetTooltip("Choose a shadow quality preset for 2D shadow maps (spotlights, directional lights)...");
shadowProps2DComboBox.SetScriptTip("SetShadowProps2D(int resolution, int count, int softShadowQuality)");
AddWidget(&shadowProps2DComboBox);
shadowPropsCubeComboBox.Create("Cube Shadowmap resolution: ");
shadowPropsCubeComboBox.SetSize(XMFLOAT2(100, itemheight));
shadowPropsCubeComboBox.SetPos(XMFLOAT2(x, y += step));
shadowPropsCubeComboBox.AddItem("Off");
shadowPropsCubeComboBox.AddItem("128");
shadowPropsCubeComboBox.AddItem("256");
shadowPropsCubeComboBox.AddItem("512");
shadowPropsCubeComboBox.AddItem("1024");
shadowPropsCubeComboBox.AddItem("2048");
shadowPropsCubeComboBox.AddItem("4096");
shadowPropsCubeComboBox.OnSelect([&](wi::gui::EventArgs args) {
switch (args.iValue)
{
case 0:
wi::renderer::SetShadowPropsCube(0, -1);
break;
case 1:
wi::renderer::SetShadowPropsCube(128, -1);
break;
case 2:
wi::renderer::SetShadowPropsCube(256, -1);
break;
case 3:
wi::renderer::SetShadowPropsCube(512, -1);
break;
case 4:
wi::renderer::SetShadowPropsCube(1024, -1);
break;
case 5:
wi::renderer::SetShadowPropsCube(2048, -1);
break;
case 6:
wi::renderer::SetShadowPropsCube(4096, -1);
break;
default:
break;
}
});
shadowPropsCubeComboBox.SetSelected(2);
shadowPropsCubeComboBox.SetTooltip("Choose a shadow quality preset for cube shadow maps (pointlights, area lights)...");
shadowPropsCubeComboBox.SetScriptTip("SetShadowPropsCube(int resolution, int count)");
AddWidget(&shadowPropsCubeComboBox);
MSAAComboBox.Create("MSAA: ");
MSAAComboBox.SetSize(XMFLOAT2(100, itemheight));
MSAAComboBox.SetPos(XMFLOAT2(x, y += step));
MSAAComboBox.AddItem("Off");
MSAAComboBox.AddItem("2");
MSAAComboBox.AddItem("4");
MSAAComboBox.AddItem("8");
MSAAComboBox.OnSelect([=](wi::gui::EventArgs args) {
switch (args.iValue)
{
case 0:
editor->renderPath->setMSAASampleCount(1);
break;
case 1:
editor->renderPath->setMSAASampleCount(2);
break;
case 2:
editor->renderPath->setMSAASampleCount(4);
break;
case 3:
editor->renderPath->setMSAASampleCount(8);
break;
default:
break;
}
editor->ResizeBuffers();
});
MSAAComboBox.SetSelected(0);
MSAAComboBox.SetTooltip("Multisampling Anti Aliasing quality. ");
AddWidget(&MSAAComboBox);
temporalAACheckBox.Create("Temporal AA: ");
temporalAACheckBox.SetTooltip("Toggle Temporal Anti Aliasing. It is a supersampling techique which is performed across multiple frames.");
temporalAACheckBox.SetPos(XMFLOAT2(x, y += step));
temporalAACheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
temporalAACheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetTemporalAAEnabled(args.bValue);
});
temporalAACheckBox.SetCheck(wi::renderer::GetTemporalAAEnabled());
AddWidget(&temporalAACheckBox);
temporalAADebugCheckBox.Create("DEBUGJitter: ");
temporalAADebugCheckBox.SetText("DEBUG: ");
temporalAADebugCheckBox.SetTooltip("Disable blending of frame history. Camera Subpixel jitter will be visible.");
temporalAADebugCheckBox.SetPos(XMFLOAT2(x + 120, y));
temporalAADebugCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
temporalAADebugCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetTemporalAADebugEnabled(args.bValue);
});
temporalAADebugCheckBox.SetCheck(wi::renderer::GetTemporalAADebugEnabled());
AddWidget(&temporalAADebugCheckBox);
textureQualityComboBox.Create("Texture Quality: ");
textureQualityComboBox.SetSize(XMFLOAT2(100, itemheight));
textureQualityComboBox.SetPos(XMFLOAT2(x, y += step));
textureQualityComboBox.AddItem("Nearest");
textureQualityComboBox.AddItem("Bilinear");
textureQualityComboBox.AddItem("Trilinear");
textureQualityComboBox.AddItem("Anisotropic");
textureQualityComboBox.OnSelect([&](wi::gui::EventArgs args) {
wi::graphics::SamplerDesc desc = wi::renderer::GetSampler(wi::enums::SAMPLER_OBJECTSHADER)->GetDesc();
switch (args.iValue)
{
case 0:
desc.filter = wi::graphics::Filter::MIN_MAG_MIP_POINT;
break;
case 1:
desc.filter = wi::graphics::Filter::MIN_MAG_LINEAR_MIP_POINT;
break;
case 2:
desc.filter = wi::graphics::Filter::MIN_MAG_MIP_LINEAR;
break;
case 3:
desc.filter = wi::graphics::Filter::ANISOTROPIC;
break;
default:
break;
}
wi::renderer::ModifyObjectSampler(desc);
});
textureQualityComboBox.SetSelected(3);
textureQualityComboBox.SetTooltip("Choose a texture sampling method for material textures.");
AddWidget(&textureQualityComboBox);
mipLodBiasSlider.Create(-2, 2, 0, 100000, "MipLOD Bias: ");
mipLodBiasSlider.SetTooltip("Bias the rendered mip map level of the material textures.");
mipLodBiasSlider.SetSize(XMFLOAT2(100, itemheight));
mipLodBiasSlider.SetPos(XMFLOAT2(x, y += step));
mipLodBiasSlider.OnSlide([&](wi::gui::EventArgs args) {
wi::graphics::SamplerDesc desc = wi::renderer::GetSampler(wi::enums::SAMPLER_OBJECTSHADER)->GetDesc();
desc.mip_lod_bias = wi::math::Clamp(args.fValue, -15.9f, 15.9f);
wi::renderer::ModifyObjectSampler(desc);
});
AddWidget(&mipLodBiasSlider);
raytraceBounceCountSlider.Create(1, 10, 1, 9, "Raytrace Bounces: ");
raytraceBounceCountSlider.SetTooltip("How many light bounces to compute when doing ray tracing.");
raytraceBounceCountSlider.SetSize(XMFLOAT2(100, itemheight));
raytraceBounceCountSlider.SetPos(XMFLOAT2(x, y += step));
raytraceBounceCountSlider.SetValue((float)wi::renderer::GetRaytraceBounceCount());
raytraceBounceCountSlider.OnSlide([&](wi::gui::EventArgs args) {
wi::renderer::SetRaytraceBounceCount((uint32_t)args.iValue);
});
AddWidget(&raytraceBounceCountSlider);
// Visualizer toggles:
x = 540, y = 5;
physicsDebugCheckBox.Create("Physics visualizer: ");
physicsDebugCheckBox.SetTooltip("Visualize the physics world");
physicsDebugCheckBox.SetPos(XMFLOAT2(x, y += step));
physicsDebugCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
physicsDebugCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::physics::SetDebugDrawEnabled(args.bValue);
});
physicsDebugCheckBox.SetCheck(wi::physics::IsDebugDrawEnabled());
AddWidget(&physicsDebugCheckBox);
partitionBoxesCheckBox.Create("SPTree visualizer: ");
partitionBoxesCheckBox.SetTooltip("Visualize the scene bounding boxes");
partitionBoxesCheckBox.SetScriptTip("SetDebugPartitionTreeEnabled(bool enabled)");
partitionBoxesCheckBox.SetPos(XMFLOAT2(x, y += step));
partitionBoxesCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
partitionBoxesCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetToDrawDebugPartitionTree(args.bValue);
});
partitionBoxesCheckBox.SetCheck(wi::renderer::GetToDrawDebugPartitionTree());
AddWidget(&partitionBoxesCheckBox);
boneLinesCheckBox.Create("Bone line visualizer: ");
boneLinesCheckBox.SetTooltip("Visualize bones of armatures");
boneLinesCheckBox.SetScriptTip("SetDebugBonesEnabled(bool enabled)");
boneLinesCheckBox.SetPos(XMFLOAT2(x, y += step));
boneLinesCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
boneLinesCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetToDrawDebugBoneLines(args.bValue);
});
boneLinesCheckBox.SetCheck(wi::renderer::GetToDrawDebugBoneLines());
AddWidget(&boneLinesCheckBox);
debugEmittersCheckBox.Create("Emitter visualizer: ");
debugEmittersCheckBox.SetTooltip("Visualize emitters");
debugEmittersCheckBox.SetScriptTip("SetDebugEmittersEnabled(bool enabled)");
debugEmittersCheckBox.SetPos(XMFLOAT2(x, y += step));
debugEmittersCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
debugEmittersCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetToDrawDebugEmitters(args.bValue);
});
debugEmittersCheckBox.SetCheck(wi::renderer::GetToDrawDebugEmitters());
AddWidget(&debugEmittersCheckBox);
debugForceFieldsCheckBox.Create("Force Field visualizer: ");
debugForceFieldsCheckBox.SetTooltip("Visualize force fields");
debugForceFieldsCheckBox.SetScriptTip("SetDebugForceFieldsEnabled(bool enabled)");
debugForceFieldsCheckBox.SetPos(XMFLOAT2(x, y += step));
debugForceFieldsCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
debugForceFieldsCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetToDrawDebugForceFields(args.bValue);
});
debugForceFieldsCheckBox.SetCheck(wi::renderer::GetToDrawDebugForceFields());
AddWidget(&debugForceFieldsCheckBox);
debugRaytraceBVHCheckBox.Create("Raytrace BVH visualizer: ");
debugRaytraceBVHCheckBox.SetTooltip("Visualize scene BVH if raytracing is enabled");
debugRaytraceBVHCheckBox.SetPos(XMFLOAT2(x, y += step));
debugRaytraceBVHCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
debugRaytraceBVHCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetRaytraceDebugBVHVisualizerEnabled(args.bValue);
});
debugRaytraceBVHCheckBox.SetCheck(wi::renderer::GetRaytraceDebugBVHVisualizerEnabled());
AddWidget(&debugRaytraceBVHCheckBox);
envProbesCheckBox.Create("Env probe visualizer: ");
envProbesCheckBox.SetTooltip("Toggle visualization of environment probes as reflective spheres");
envProbesCheckBox.SetPos(XMFLOAT2(x, y += step));
envProbesCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
envProbesCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetToDrawDebugEnvProbes(args.bValue);
});
envProbesCheckBox.SetCheck(wi::renderer::GetToDrawDebugEnvProbes());
AddWidget(&envProbesCheckBox);
cameraVisCheckBox.Create("Camera Proxy visualizer: ");
cameraVisCheckBox.SetTooltip("Toggle visualization of camera proxies in the scene");
cameraVisCheckBox.SetPos(XMFLOAT2(x, y += step));
cameraVisCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
cameraVisCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetToDrawDebugCameras(args.bValue);
});
cameraVisCheckBox.SetCheck(wi::renderer::GetToDrawDebugCameras());
AddWidget(&cameraVisCheckBox);
gridHelperCheckBox.Create("Grid helper: ");
gridHelperCheckBox.SetTooltip("Toggle showing of unit visualizer grid in the world origin");
gridHelperCheckBox.SetPos(XMFLOAT2(x, y += step));
gridHelperCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
gridHelperCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetToDrawGridHelper(args.bValue);
});
gridHelperCheckBox.SetCheck(wi::renderer::GetToDrawGridHelper());
AddWidget(&gridHelperCheckBox);
pickTypeObjectCheckBox.Create("Pick Objects: ");
pickTypeObjectCheckBox.SetTooltip("Enable if you want to pick objects with the pointer");
pickTypeObjectCheckBox.SetPos(XMFLOAT2(x, y += step * 2));
pickTypeObjectCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
pickTypeObjectCheckBox.SetCheck(true);
AddWidget(&pickTypeObjectCheckBox);
pickTypeEnvProbeCheckBox.Create("Pick EnvProbes: ");
pickTypeEnvProbeCheckBox.SetTooltip("Enable if you want to pick environment probes with the pointer");
pickTypeEnvProbeCheckBox.SetPos(XMFLOAT2(x, y += step));
pickTypeEnvProbeCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
pickTypeEnvProbeCheckBox.SetCheck(true);
AddWidget(&pickTypeEnvProbeCheckBox);
pickTypeLightCheckBox.Create("Pick Lights: ");
pickTypeLightCheckBox.SetTooltip("Enable if you want to pick lights with the pointer");
pickTypeLightCheckBox.SetPos(XMFLOAT2(x, y += step));
pickTypeLightCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
pickTypeLightCheckBox.SetCheck(true);
AddWidget(&pickTypeLightCheckBox);
pickTypeDecalCheckBox.Create("Pick Decals: ");
pickTypeDecalCheckBox.SetTooltip("Enable if you want to pick decals with the pointer");
pickTypeDecalCheckBox.SetPos(XMFLOAT2(x, y += step));
pickTypeDecalCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
pickTypeDecalCheckBox.SetCheck(true);
AddWidget(&pickTypeDecalCheckBox);
pickTypeForceFieldCheckBox.Create("Pick Force Fields: ");
pickTypeForceFieldCheckBox.SetTooltip("Enable if you want to pick force fields with the pointer");
pickTypeForceFieldCheckBox.SetPos(XMFLOAT2(x, y += step));
pickTypeForceFieldCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
pickTypeForceFieldCheckBox.SetCheck(true);
AddWidget(&pickTypeForceFieldCheckBox);
pickTypeEmitterCheckBox.Create("Pick Emitters: ");
pickTypeEmitterCheckBox.SetTooltip("Enable if you want to pick emitters with the pointer");
pickTypeEmitterCheckBox.SetPos(XMFLOAT2(x, y += step));
pickTypeEmitterCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
pickTypeEmitterCheckBox.SetCheck(true);
AddWidget(&pickTypeEmitterCheckBox);
pickTypeHairCheckBox.Create("Pick Hairs: ");
pickTypeHairCheckBox.SetTooltip("Enable if you want to pick hairs with the pointer");
pickTypeHairCheckBox.SetPos(XMFLOAT2(x, y += step));
pickTypeHairCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
pickTypeHairCheckBox.SetCheck(true);
AddWidget(&pickTypeHairCheckBox);
pickTypeCameraCheckBox.Create("Pick Cameras: ");
pickTypeCameraCheckBox.SetTooltip("Enable if you want to pick cameras with the pointer");
pickTypeCameraCheckBox.SetPos(XMFLOAT2(x, y += step));
pickTypeCameraCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
pickTypeCameraCheckBox.SetCheck(true);
AddWidget(&pickTypeCameraCheckBox);
pickTypeArmatureCheckBox.Create("Pick Armatures: ");
pickTypeArmatureCheckBox.SetTooltip("Enable if you want to pick armatures with the pointer");
pickTypeArmatureCheckBox.SetPos(XMFLOAT2(x, y += step));
pickTypeArmatureCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
pickTypeArmatureCheckBox.SetCheck(true);
AddWidget(&pickTypeArmatureCheckBox);
pickTypeSoundCheckBox.Create("Pick Sounds: ");
pickTypeSoundCheckBox.SetTooltip("Enable if you want to pick sounds with the pointer");
pickTypeSoundCheckBox.SetPos(XMFLOAT2(x, y += step));
pickTypeSoundCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
pickTypeSoundCheckBox.SetCheck(true);
AddWidget(&pickTypeSoundCheckBox);
freezeCullingCameraCheckBox.Create("Freeze culling camera: ");
freezeCullingCameraCheckBox.SetTooltip("Freeze culling camera update. Scene culling will not be updated with the view");
freezeCullingCameraCheckBox.SetPos(XMFLOAT2(x, y += step * 2));
freezeCullingCameraCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
freezeCullingCameraCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetFreezeCullingCameraEnabled(args.bValue);
});
freezeCullingCameraCheckBox.SetCheck(wi::renderer::GetFreezeCullingCameraEnabled());
AddWidget(&freezeCullingCameraCheckBox);
disableAlbedoMapsCheckBox.Create("Disable albedo maps: ");
disableAlbedoMapsCheckBox.SetTooltip("Disables albedo maps on objects for easier lighting debugging");
disableAlbedoMapsCheckBox.SetPos(XMFLOAT2(x, y += step));
disableAlbedoMapsCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
disableAlbedoMapsCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetDisableAlbedoMaps(args.bValue);
});
disableAlbedoMapsCheckBox.SetCheck(wi::renderer::IsDisableAlbedoMaps());
AddWidget(&disableAlbedoMapsCheckBox);
forceDiffuseLightingCheckBox.Create("Force diffuse lighting: ");
forceDiffuseLightingCheckBox.SetTooltip("Sets every surface fully diffuse, with zero specularity");
forceDiffuseLightingCheckBox.SetPos(XMFLOAT2(x, y += step));
forceDiffuseLightingCheckBox.SetSize(XMFLOAT2(itemheight, itemheight));
forceDiffuseLightingCheckBox.OnClick([](wi::gui::EventArgs args) {
wi::renderer::SetForceDiffuseLighting(args.bValue);
});
forceDiffuseLightingCheckBox.SetCheck(wi::renderer::IsForceDiffuseLighting());
AddWidget(&forceDiffuseLightingCheckBox);
Translate(XMFLOAT3(100, 50, 0));
SetVisible(false);
}
uint32_t RendererWindow::GetPickType() const
{
uint32_t pickType = PICK_VOID;
if (pickTypeObjectCheckBox.GetCheck())
{
pickType |= PICK_OBJECT;
}
if (pickTypeEnvProbeCheckBox.GetCheck())
{
pickType |= PICK_ENVPROBE;
}
if (pickTypeLightCheckBox.GetCheck())
{
pickType |= PICK_LIGHT;
}
if (pickTypeDecalCheckBox.GetCheck())
{
pickType |= PICK_DECAL;
}
if (pickTypeForceFieldCheckBox.GetCheck())
{
pickType |= PICK_FORCEFIELD;
}
if (pickTypeEmitterCheckBox.GetCheck())
{
pickType |= PICK_EMITTER;
}
if (pickTypeHairCheckBox.GetCheck())
{
pickType |= PICK_HAIR;
}
if (pickTypeCameraCheckBox.GetCheck())
{
pickType |= PICK_CAMERA;
}
if (pickTypeArmatureCheckBox.GetCheck())
{
pickType |= PICK_ARMATURE;
}
if (pickTypeSoundCheckBox.GetCheck())
{
pickType |= PICK_SOUND;
}
return pickType;
}
void RendererWindow::UpdateSwapChainFormats(wi::graphics::SwapChain* swapChain)
{
swapchainComboBox.OnSelect(nullptr);
swapchainComboBox.ClearItems();
swapchainComboBox.AddItem("SDR 8bit", static_cast<uint64_t>(wi::graphics::Format::R8G8B8A8_UNORM));
swapchainComboBox.AddItem("SDR 10bit", static_cast<uint64_t>(wi::graphics::Format::R10G10B10A2_UNORM));
if (wi::graphics::GetDevice()->IsSwapChainSupportsHDR(swapChain))
{
swapchainComboBox.AddItem("HDR 10bit", static_cast<uint64_t>(wi::graphics::Format::R10G10B10A2_UNORM));
swapchainComboBox.AddItem("HDR 16bit", static_cast<uint64_t>(wi::graphics::Format::R16G16B16A16_FLOAT));
switch (swapChain->desc.format)
{
default:
case wi::graphics::Format::R8G8B8A8_UNORM:
swapchainComboBox.SetSelected(0);
break;
case wi::graphics::Format::R10G10B10A2_UNORM:
if (swapChain->desc.allow_hdr)
{
swapchainComboBox.SetSelected(2);
}
else
{
swapchainComboBox.SetSelected(1);
}
break;
case wi::graphics::Format::R16G16B16A16_FLOAT:
swapchainComboBox.SetSelected(4);
break;
}
}
else
{
switch (swapChain->desc.format)
{
default:
case wi::graphics::Format::R8G8B8A8_UNORM:
swapchainComboBox.SetSelected(0);
break;
case wi::graphics::Format::R10G10B10A2_UNORM:
swapchainComboBox.SetSelected(1);
break;
case wi::graphics::Format::R16G16B16A16_FLOAT:
swapchainComboBox.SetSelected(1);
break;
}
}
swapchainComboBox.OnSelect([=](wi::gui::EventArgs args) {
swapChain->desc.format = (wi::graphics::Format)args.userdata;
switch (args.iValue)
{
default:
case 0:
case 1:
swapChain->desc.allow_hdr = false;
break;
case 2:
case 3:
swapChain->desc.allow_hdr = true;
break;
}
bool success = wi::graphics::GetDevice()->CreateSwapChain(&swapChain->desc, nullptr, swapChain);
assert(success);
});
}
Reference in New Issue View Git Blame Copy Permalink