Turanszki Janos
431 lines
19 KiB
C++
431 lines
19 KiB
C++
#include "stdafx.h"
|
|
#include "PostprocessWindow.h"
|
|
#include "Editor.h"
|
|
|
|
#include <thread>
|
|
|
|
using namespace std;
|
|
using namespace wiGraphics;
|
|
|
|
|
|
void PostprocessWindow::Create(EditorComponent* editor)
|
|
{
|
|
wiWindow::Create("PostProcess Window");
|
|
SetSize(XMFLOAT2(420, 520));
|
|
|
|
float x = 150;
|
|
float y = 10;
|
|
float hei = 18;
|
|
float step = hei + 2;
|
|
|
|
exposureSlider.Create(0.0f, 3.0f, 1, 10000, "Exposure: ");
|
|
exposureSlider.SetTooltip("Set the tonemap exposure value");
|
|
exposureSlider.SetScriptTip("RenderPath3D::SetExposure(float value)");
|
|
exposureSlider.SetSize(XMFLOAT2(100, hei));
|
|
exposureSlider.SetPos(XMFLOAT2(x, y += step));
|
|
exposureSlider.SetValue(editor->renderPath->getExposure());
|
|
exposureSlider.OnSlide([=](wiEventArgs args) {
|
|
editor->renderPath->setExposure(args.fValue);
|
|
});
|
|
AddWidget(&exposureSlider);
|
|
|
|
lensFlareCheckBox.Create("LensFlare: ");
|
|
lensFlareCheckBox.SetTooltip("Toggle visibility of light source flares. Additional setup needed per light for a lensflare to be visible.");
|
|
lensFlareCheckBox.SetScriptTip("RenderPath3D::SetLensFlareEnabled(bool value)");
|
|
lensFlareCheckBox.SetSize(XMFLOAT2(hei, hei));
|
|
lensFlareCheckBox.SetPos(XMFLOAT2(x, y += step));
|
|
lensFlareCheckBox.SetCheck(editor->renderPath->getLensFlareEnabled());
|
|
lensFlareCheckBox.OnClick([=](wiEventArgs args) {
|
|
editor->renderPath->setLensFlareEnabled(args.bValue);
|
|
});
|
|
AddWidget(&lensFlareCheckBox);
|
|
|
|
lightShaftsCheckBox.Create("LightShafts: ");
|
|
lightShaftsCheckBox.SetTooltip("Enable light shaft for directional light sources.");
|
|
lightShaftsCheckBox.SetScriptTip("RenderPath3D::SetLightShaftsEnabled(bool value)");
|
|
lightShaftsCheckBox.SetSize(XMFLOAT2(hei, hei));
|
|
lightShaftsCheckBox.SetPos(XMFLOAT2(x, y += step));
|
|
lightShaftsCheckBox.SetCheck(editor->renderPath->getLightShaftsEnabled());
|
|
lightShaftsCheckBox.OnClick([=](wiEventArgs args) {
|
|
editor->renderPath->setLightShaftsEnabled(args.bValue);
|
|
});
|
|
AddWidget(&lightShaftsCheckBox);
|
|
|
|
volumetricCloudsCheckBox.Create("Volumetric clouds: ");
|
|
volumetricCloudsCheckBox.SetTooltip("Enable volumetric cloud rendering.");
|
|
volumetricCloudsCheckBox.SetSize(XMFLOAT2(hei, hei));
|
|
volumetricCloudsCheckBox.SetPos(XMFLOAT2(x, y += step));
|
|
volumetricCloudsCheckBox.SetCheck(editor->renderPath->getVolumetricCloudsEnabled());
|
|
volumetricCloudsCheckBox.OnClick([=](wiEventArgs args) {
|
|
editor->renderPath->setVolumetricCloudsEnabled(args.bValue);
|
|
});
|
|
AddWidget(&volumetricCloudsCheckBox);
|
|
|
|
aoComboBox.Create("AO: ");
|
|
aoComboBox.SetTooltip("Choose Ambient Occlusion type. RTAO is only available if hardware supports ray tracing");
|
|
aoComboBox.SetScriptTip("RenderPath3D::SetAO(int value)");
|
|
aoComboBox.SetSize(XMFLOAT2(150, hei));
|
|
aoComboBox.SetPos(XMFLOAT2(x, y += step));
|
|
aoComboBox.AddItem("Disabled");
|
|
aoComboBox.AddItem("SSAO");
|
|
aoComboBox.AddItem("HBAO");
|
|
aoComboBox.AddItem("MSAO");
|
|
if (wiRenderer::GetDevice()->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
|
|
{
|
|
aoComboBox.AddItem("RTAO");
|
|
}
|
|
aoComboBox.SetSelected(editor->renderPath->getAO());
|
|
aoComboBox.OnSelect([=](wiEventArgs args) {
|
|
editor->renderPath->setAO((RenderPath3D::AO)args.iValue);
|
|
|
|
switch (editor->renderPath->getAO())
|
|
{
|
|
case RenderPath3D::AO_SSAO:
|
|
aoRangeSlider.SetEnabled(true);
|
|
aoRangeSlider.SetValue(2.0f);
|
|
aoSampleCountSlider.SetEnabled(true);
|
|
aoSampleCountSlider.SetValue(9.0f);
|
|
break;
|
|
case RenderPath3D::AO_RTAO:
|
|
aoRangeSlider.SetEnabled(true);
|
|
aoRangeSlider.SetValue(10.0f);
|
|
aoSampleCountSlider.SetEnabled(true);
|
|
aoSampleCountSlider.SetValue(2.0f);
|
|
break;
|
|
default:
|
|
aoRangeSlider.SetEnabled(false);
|
|
aoSampleCountSlider.SetEnabled(false);
|
|
break;
|
|
}
|
|
|
|
editor->renderPath->setAORange(aoRangeSlider.GetValue());
|
|
editor->renderPath->setAOSampleCount((uint32_t)aoSampleCountSlider.GetValue());
|
|
});
|
|
AddWidget(&aoComboBox);
|
|
|
|
aoPowerSlider.Create(0.25f, 8.0f, 2, 1000, "Power: ");
|
|
aoPowerSlider.SetTooltip("Set SSAO Power. Higher values produce darker, more pronounced effect");
|
|
aoPowerSlider.SetSize(XMFLOAT2(100, hei));
|
|
aoPowerSlider.SetPos(XMFLOAT2(x + 100, y += step));
|
|
aoPowerSlider.SetValue((float)editor->renderPath->getAOPower());
|
|
aoPowerSlider.OnSlide([=](wiEventArgs args) {
|
|
editor->renderPath->setAOPower(args.fValue);
|
|
});
|
|
AddWidget(&aoPowerSlider);
|
|
|
|
aoRangeSlider.Create(1.0f, 100.0f, 1, 1000, "Range: ");
|
|
aoRangeSlider.SetTooltip("Set AO ray length. Only for SSAO and RTAO");
|
|
aoRangeSlider.SetSize(XMFLOAT2(100, hei));
|
|
aoRangeSlider.SetPos(XMFLOAT2(x + 100, y += step));
|
|
aoRangeSlider.SetValue((float)editor->renderPath->getAOPower());
|
|
aoRangeSlider.OnSlide([=](wiEventArgs args) {
|
|
editor->renderPath->setAORange(args.fValue);
|
|
});
|
|
AddWidget(&aoRangeSlider);
|
|
|
|
aoSampleCountSlider.Create(1, 16, 9, 15, "Sample Count: ");
|
|
aoSampleCountSlider.SetTooltip("Set AO ray count. Only for SSAO and RTAO");
|
|
aoSampleCountSlider.SetSize(XMFLOAT2(100, hei));
|
|
aoSampleCountSlider.SetPos(XMFLOAT2(x + 100, y += step));
|
|
aoSampleCountSlider.SetValue((float)editor->renderPath->getAOPower());
|
|
aoSampleCountSlider.OnSlide([=](wiEventArgs args) {
|
|
editor->renderPath->setAOSampleCount(args.iValue);
|
|
});
|
|
AddWidget(&aoSampleCountSlider);
|
|
|
|
ssrCheckBox.Create("SSR: ");
|
|
ssrCheckBox.SetTooltip("Enable Screen Space Reflections.");
|
|
ssrCheckBox.SetScriptTip("RenderPath3D::SetSSREnabled(bool value)");
|
|
ssrCheckBox.SetSize(XMFLOAT2(hei, hei));
|
|
ssrCheckBox.SetPos(XMFLOAT2(x, y += step));
|
|
ssrCheckBox.SetCheck(editor->renderPath->getSSREnabled());
|
|
ssrCheckBox.OnClick([=](wiEventArgs args) {
|
|
editor->renderPath->setSSREnabled(args.bValue);
|
|
});
|
|
AddWidget(&ssrCheckBox);
|
|
|
|
raytracedReflectionsCheckBox.Create("Ray Traced Reflections: ");
|
|
raytracedReflectionsCheckBox.SetTooltip("Enable Ray Traced Reflections. Only if GPU supports raytracing.");
|
|
raytracedReflectionsCheckBox.SetScriptTip("RenderPath3D::SetRaytracedReflectionsEnabled(bool value)");
|
|
raytracedReflectionsCheckBox.SetSize(XMFLOAT2(hei, hei));
|
|
raytracedReflectionsCheckBox.SetPos(XMFLOAT2(x + 200, y));
|
|
raytracedReflectionsCheckBox.SetCheck(editor->renderPath->getRaytracedReflectionEnabled());
|
|
raytracedReflectionsCheckBox.OnClick([=](wiEventArgs args) {
|
|
editor->renderPath->setRaytracedReflectionsEnabled(args.bValue);
|
|
});
|
|
AddWidget(&raytracedReflectionsCheckBox);
|
|
raytracedReflectionsCheckBox.SetEnabled(wiRenderer::GetDevice()->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING));
|
|
|
|
screenSpaceShadowsCheckBox.Create("SS Shadows: ");
|
|
screenSpaceShadowsCheckBox.SetTooltip("Enable screen space contact shadows. This can add small shadows details to shadow maps in screen space.");
|
|
screenSpaceShadowsCheckBox.SetSize(XMFLOAT2(hei, hei));
|
|
screenSpaceShadowsCheckBox.SetPos(XMFLOAT2(x, y += step));
|
|
screenSpaceShadowsCheckBox.SetCheck(wiRenderer::GetScreenSpaceShadowsEnabled());
|
|
screenSpaceShadowsCheckBox.OnClick([=](wiEventArgs args) {
|
|
wiRenderer::SetScreenSpaceShadowsEnabled(args.bValue);
|
|
});
|
|
AddWidget(&screenSpaceShadowsCheckBox);
|
|
|
|
screenSpaceShadowsRangeSlider.Create(0.1f, 10.0f, 1, 1000, "Range: ");
|
|
screenSpaceShadowsRangeSlider.SetTooltip("Range of contact shadows");
|
|
screenSpaceShadowsRangeSlider.SetSize(XMFLOAT2(100, hei));
|
|
screenSpaceShadowsRangeSlider.SetPos(XMFLOAT2(x + 100, y));
|
|
screenSpaceShadowsRangeSlider.SetValue((float)editor->renderPath->getScreenSpaceShadowRange());
|
|
screenSpaceShadowsRangeSlider.OnSlide([=](wiEventArgs args) {
|
|
editor->renderPath->setScreenSpaceShadowRange(args.fValue);
|
|
});
|
|
AddWidget(&screenSpaceShadowsRangeSlider);
|
|
|
|
screenSpaceShadowsStepCountSlider.Create(4, 128, 16, 128 - 4, "Sample Count: ");
|
|
screenSpaceShadowsStepCountSlider.SetTooltip("Sample count of contact shadows. Higher values are better quality but slower.");
|
|
screenSpaceShadowsStepCountSlider.SetSize(XMFLOAT2(100, hei));
|
|
screenSpaceShadowsStepCountSlider.SetPos(XMFLOAT2(x + 100, y += step));
|
|
screenSpaceShadowsStepCountSlider.SetValue((float)editor->renderPath->getScreenSpaceShadowSampleCount());
|
|
screenSpaceShadowsStepCountSlider.OnSlide([=](wiEventArgs args) {
|
|
editor->renderPath->setScreenSpaceShadowSampleCount(args.iValue);
|
|
});
|
|
AddWidget(&screenSpaceShadowsStepCountSlider);
|
|
|
|
eyeAdaptionCheckBox.Create("EyeAdaption: ");
|
|
eyeAdaptionCheckBox.SetTooltip("Enable eye adaption for the overall screen luminance");
|
|
eyeAdaptionCheckBox.SetSize(XMFLOAT2(hei, hei));
|
|
eyeAdaptionCheckBox.SetPos(XMFLOAT2(x, y += step));
|
|
eyeAdaptionCheckBox.SetCheck(editor->renderPath->getEyeAdaptionEnabled());
|
|
eyeAdaptionCheckBox.OnClick([=](wiEventArgs args) {
|
|
editor->renderPath->setEyeAdaptionEnabled(args.bValue);
|
|
});
|
|
AddWidget(&eyeAdaptionCheckBox);
|
|
|
|
motionBlurCheckBox.Create("MotionBlur: ");
|
|
motionBlurCheckBox.SetTooltip("Enable motion blur for camera movement and animated meshes.");
|
|
motionBlurCheckBox.SetScriptTip("RenderPath3D::SetMotionBlurEnabled(bool value)");
|
|
motionBlurCheckBox.SetSize(XMFLOAT2(hei, hei));
|
|
motionBlurCheckBox.SetPos(XMFLOAT2(x, y += step));
|
|
motionBlurCheckBox.SetCheck(editor->renderPath->getMotionBlurEnabled());
|
|
motionBlurCheckBox.OnClick([=](wiEventArgs args) {
|
|
editor->renderPath->setMotionBlurEnabled(args.bValue);
|
|
});
|
|
AddWidget(&motionBlurCheckBox);
|
|
|
|
motionBlurStrengthSlider.Create(0.1f, 400, 100, 10000, "Strength: ");
|
|
motionBlurStrengthSlider.SetTooltip("Set the camera shutter speed for motion blur (higher value means stronger blur).");
|
|
motionBlurStrengthSlider.SetScriptTip("RenderPath3D::SetMotionBlurStrength(float value)");
|
|
motionBlurStrengthSlider.SetSize(XMFLOAT2(100, hei));
|
|
motionBlurStrengthSlider.SetPos(XMFLOAT2(x + 100, y));
|
|
motionBlurStrengthSlider.SetValue(editor->renderPath->getMotionBlurStrength());
|
|
motionBlurStrengthSlider.OnSlide([=](wiEventArgs args) {
|
|
editor->renderPath->setMotionBlurStrength(args.fValue);
|
|
});
|
|
AddWidget(&motionBlurStrengthSlider);
|
|
|
|
depthOfFieldCheckBox.Create("DepthOfField: ");
|
|
depthOfFieldCheckBox.SetTooltip("Enable Depth of field effect. Additional focus and strength setup required.");
|
|
depthOfFieldCheckBox.SetScriptTip("RenderPath3D::SetDepthOfFieldEnabled(bool value)");
|
|
depthOfFieldCheckBox.SetSize(XMFLOAT2(hei, hei));
|
|
depthOfFieldCheckBox.SetPos(XMFLOAT2(x, y += step));
|
|
depthOfFieldCheckBox.SetCheck(editor->renderPath->getDepthOfFieldEnabled());
|
|
depthOfFieldCheckBox.OnClick([=](wiEventArgs args) {
|
|
editor->renderPath->setDepthOfFieldEnabled(args.bValue);
|
|
});
|
|
AddWidget(&depthOfFieldCheckBox);
|
|
|
|
depthOfFieldFocusSlider.Create(1.0f, 100, 10, 10000, "Focus: ");
|
|
depthOfFieldFocusSlider.SetTooltip("Set the focus distance from the camera. The picture will be sharper near the focus, and blurrier further from it.");
|
|
depthOfFieldFocusSlider.SetScriptTip("RenderPath3D::SetDepthOfFieldFocus(float value)");
|
|
depthOfFieldFocusSlider.SetSize(XMFLOAT2(100, hei));
|
|
depthOfFieldFocusSlider.SetPos(XMFLOAT2(x + 100, y));
|
|
depthOfFieldFocusSlider.SetValue(editor->renderPath->getDepthOfFieldFocus());
|
|
depthOfFieldFocusSlider.OnSlide([=](wiEventArgs args) {
|
|
editor->renderPath->setDepthOfFieldFocus(args.fValue);
|
|
});
|
|
AddWidget(&depthOfFieldFocusSlider);
|
|
|
|
depthOfFieldScaleSlider.Create(1.0f, 20, 100, 1000, "Scale: ");
|
|
depthOfFieldScaleSlider.SetTooltip("Set depth of field scale/falloff.");
|
|
depthOfFieldScaleSlider.SetScriptTip("RenderPath3D::SetDepthOfFieldStrength(float value)");
|
|
depthOfFieldScaleSlider.SetSize(XMFLOAT2(100, hei));
|
|
depthOfFieldScaleSlider.SetPos(XMFLOAT2(x + 100, y += step));
|
|
depthOfFieldScaleSlider.SetValue(editor->renderPath->getDepthOfFieldStrength());
|
|
depthOfFieldScaleSlider.OnSlide([=](wiEventArgs args) {
|
|
editor->renderPath->setDepthOfFieldStrength(args.fValue);
|
|
});
|
|
AddWidget(&depthOfFieldScaleSlider);
|
|
|
|
depthOfFieldAspectSlider.Create(0.01f, 2, 1, 1000, "Aspect: ");
|
|
depthOfFieldAspectSlider.SetTooltip("Set depth of field bokeh aspect ratio (width/height).");
|
|
depthOfFieldAspectSlider.SetScriptTip("RenderPath3D::SetDepthOfFieldAspect(float value)");
|
|
depthOfFieldAspectSlider.SetSize(XMFLOAT2(100, hei));
|
|
depthOfFieldAspectSlider.SetPos(XMFLOAT2(x + 100, y += step));
|
|
depthOfFieldAspectSlider.SetValue(editor->renderPath->getDepthOfFieldAspect());
|
|
depthOfFieldAspectSlider.OnSlide([=](wiEventArgs args) {
|
|
editor->renderPath->setDepthOfFieldAspect(args.fValue);
|
|
});
|
|
AddWidget(&depthOfFieldAspectSlider);
|
|
|
|
bloomCheckBox.Create("Bloom: ");
|
|
bloomCheckBox.SetTooltip("Enable bloom. The effect adds color bleeding to the brightest parts of the scene.");
|
|
bloomCheckBox.SetScriptTip("RenderPath3D::SetBloomEnabled(bool value)");
|
|
bloomCheckBox.SetSize(XMFLOAT2(hei, hei));
|
|
bloomCheckBox.SetPos(XMFLOAT2(x, y += step));
|
|
bloomCheckBox.SetCheck(editor->renderPath->getBloomEnabled());
|
|
bloomCheckBox.OnClick([=](wiEventArgs args) {
|
|
editor->renderPath->setBloomEnabled(args.bValue);
|
|
});
|
|
AddWidget(&bloomCheckBox);
|
|
|
|
bloomStrengthSlider.Create(0.0f, 10, 1, 1000, "Threshold: ");
|
|
bloomStrengthSlider.SetTooltip("Set bloom threshold. The values below this will not glow on the screen.");
|
|
bloomStrengthSlider.SetSize(XMFLOAT2(100, hei));
|
|
bloomStrengthSlider.SetPos(XMFLOAT2(x + 100, y));
|
|
bloomStrengthSlider.SetValue(editor->renderPath->getBloomThreshold());
|
|
bloomStrengthSlider.OnSlide([=](wiEventArgs args) {
|
|
editor->renderPath->setBloomThreshold(args.fValue);
|
|
});
|
|
AddWidget(&bloomStrengthSlider);
|
|
|
|
fxaaCheckBox.Create("FXAA: ");
|
|
fxaaCheckBox.SetTooltip("Fast Approximate Anti Aliasing. A fast antialiasing method, but can be a bit too blurry.");
|
|
fxaaCheckBox.SetScriptTip("RenderPath3D::SetFXAAEnabled(bool value)");
|
|
fxaaCheckBox.SetSize(XMFLOAT2(hei, hei));
|
|
fxaaCheckBox.SetPos(XMFLOAT2(x, y += step));
|
|
fxaaCheckBox.SetCheck(editor->renderPath->getFXAAEnabled());
|
|
fxaaCheckBox.OnClick([=](wiEventArgs args) {
|
|
editor->renderPath->setFXAAEnabled(args.bValue);
|
|
});
|
|
AddWidget(&fxaaCheckBox);
|
|
|
|
colorGradingCheckBox.Create("Color Grading: ");
|
|
colorGradingCheckBox.SetTooltip("Enable color grading of the final render. An additional lookup texture must be set for it to take effect.");
|
|
colorGradingCheckBox.SetScriptTip("RenderPath3D::SetColorGradingEnabled(bool value)");
|
|
colorGradingCheckBox.SetSize(XMFLOAT2(hei, hei));
|
|
colorGradingCheckBox.SetPos(XMFLOAT2(x, y += step));
|
|
colorGradingCheckBox.SetCheck(editor->renderPath->getColorGradingEnabled());
|
|
colorGradingCheckBox.OnClick([=](wiEventArgs args) {
|
|
editor->renderPath->setColorGradingEnabled(args.bValue);
|
|
});
|
|
AddWidget(&colorGradingCheckBox);
|
|
|
|
colorGradingButton.Create("Load Color Grading LUT...");
|
|
colorGradingButton.SetTooltip("Load a color grading lookup texture...");
|
|
colorGradingButton.SetPos(XMFLOAT2(x + 35, y));
|
|
colorGradingButton.SetSize(XMFLOAT2(200, hei));
|
|
colorGradingButton.OnClick([=](wiEventArgs args) {
|
|
auto x = editor->renderPath->getColorGradingTexture();
|
|
|
|
if (x == nullptr)
|
|
{
|
|
wiHelper::FileDialogParams params;
|
|
params.type = wiHelper::FileDialogParams::OPEN;
|
|
params.description = "Texture";
|
|
params.extensions.push_back("dds");
|
|
params.extensions.push_back("png");
|
|
params.extensions.push_back("jpg");
|
|
params.extensions.push_back("jpeg");
|
|
params.extensions.push_back("tga");
|
|
wiHelper::FileDialog(params, [=](std::string fileName) {
|
|
wiEvent::Subscribe_Once(SYSTEM_EVENT_THREAD_SAFE_POINT, [=](uint64_t userdata) {
|
|
editor->renderPath->setColorGradingTexture(wiResourceManager::Load(fileName));
|
|
if (editor->renderPath->getColorGradingTexture() != nullptr)
|
|
{
|
|
colorGradingButton.SetText(fileName);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
else
|
|
{
|
|
editor->renderPath->setColorGradingTexture(nullptr);
|
|
colorGradingButton.SetText("Load Color Grading LUT...");
|
|
}
|
|
|
|
});
|
|
AddWidget(&colorGradingButton);
|
|
|
|
ditherCheckBox.Create("Dithering: ");
|
|
ditherCheckBox.SetTooltip("Toggle the full screen dithering effect. This helps to reduce color banding.");
|
|
ditherCheckBox.SetSize(XMFLOAT2(hei, hei));
|
|
ditherCheckBox.SetPos(XMFLOAT2(x, y += step));
|
|
ditherCheckBox.SetCheck(editor->renderPath->getDitherEnabled());
|
|
ditherCheckBox.OnClick([=](wiEventArgs args) {
|
|
editor->renderPath->setDitherEnabled(args.bValue);
|
|
});
|
|
AddWidget(&ditherCheckBox);
|
|
|
|
sharpenFilterCheckBox.Create("Sharpen Filter: ");
|
|
sharpenFilterCheckBox.SetTooltip("Toggle sharpening post process of the final image.");
|
|
sharpenFilterCheckBox.SetScriptTip("RenderPath3D::SetSharpenFilterEnabled(bool value)");
|
|
sharpenFilterCheckBox.SetSize(XMFLOAT2(hei, hei));
|
|
sharpenFilterCheckBox.SetPos(XMFLOAT2(x, y += step));
|
|
sharpenFilterCheckBox.SetCheck(editor->renderPath->getSharpenFilterEnabled());
|
|
sharpenFilterCheckBox.OnClick([=](wiEventArgs args) {
|
|
editor->renderPath->setSharpenFilterEnabled(args.bValue);
|
|
});
|
|
AddWidget(&sharpenFilterCheckBox);
|
|
|
|
sharpenFilterAmountSlider.Create(0, 4, 1, 1000, "Amount: ");
|
|
sharpenFilterAmountSlider.SetTooltip("Set sharpness filter strength.");
|
|
sharpenFilterAmountSlider.SetScriptTip("RenderPath3D::SetSharpenFilterAmount(float value)");
|
|
sharpenFilterAmountSlider.SetSize(XMFLOAT2(100, hei));
|
|
sharpenFilterAmountSlider.SetPos(XMFLOAT2(x + 100, y));
|
|
sharpenFilterAmountSlider.SetValue(editor->renderPath->getSharpenFilterAmount());
|
|
sharpenFilterAmountSlider.OnSlide([=](wiEventArgs args) {
|
|
editor->renderPath->setSharpenFilterAmount(args.fValue);
|
|
});
|
|
AddWidget(&sharpenFilterAmountSlider);
|
|
|
|
outlineCheckBox.Create("Cartoon Outline: ");
|
|
outlineCheckBox.SetTooltip("Toggle the full screen cartoon outline effect.");
|
|
outlineCheckBox.SetSize(XMFLOAT2(hei, hei));
|
|
outlineCheckBox.SetPos(XMFLOAT2(x, y += step));
|
|
outlineCheckBox.SetCheck(editor->renderPath->getOutlineEnabled());
|
|
outlineCheckBox.OnClick([=](wiEventArgs args) {
|
|
editor->renderPath->setOutlineEnabled(args.bValue);
|
|
});
|
|
AddWidget(&outlineCheckBox);
|
|
|
|
outlineThresholdSlider.Create(0, 1, 0.1f, 1000, "Threshold: ");
|
|
outlineThresholdSlider.SetTooltip("Outline edge detection threshold. Increase if not enough otlines are detected, decrease if too many outlines are detected.");
|
|
outlineThresholdSlider.SetSize(XMFLOAT2(100, hei));
|
|
outlineThresholdSlider.SetPos(XMFLOAT2(x + 100, y));
|
|
outlineThresholdSlider.SetValue(editor->renderPath->getOutlineThreshold());
|
|
outlineThresholdSlider.OnSlide([=](wiEventArgs args) {
|
|
editor->renderPath->setOutlineThreshold(args.fValue);
|
|
});
|
|
AddWidget(&outlineThresholdSlider);
|
|
|
|
outlineThicknessSlider.Create(0, 4, 1, 1000, "Thickness: ");
|
|
outlineThicknessSlider.SetTooltip("Set outline thickness.");
|
|
outlineThicknessSlider.SetSize(XMFLOAT2(100, hei));
|
|
outlineThicknessSlider.SetPos(XMFLOAT2(x + 100, y += step));
|
|
outlineThicknessSlider.SetValue(editor->renderPath->getOutlineThickness());
|
|
outlineThicknessSlider.OnSlide([=](wiEventArgs args) {
|
|
editor->renderPath->setOutlineThickness(args.fValue);
|
|
});
|
|
AddWidget(&outlineThicknessSlider);
|
|
|
|
chromaticaberrationCheckBox.Create("Chromatic Aberration: ");
|
|
chromaticaberrationCheckBox.SetTooltip("Toggle the full screen chromatic aberration effect. This simulates lens distortion at screen edges.");
|
|
chromaticaberrationCheckBox.SetSize(XMFLOAT2(hei, hei));
|
|
chromaticaberrationCheckBox.SetPos(XMFLOAT2(x, y += step));
|
|
chromaticaberrationCheckBox.SetCheck(editor->renderPath->getOutlineEnabled());
|
|
chromaticaberrationCheckBox.OnClick([=](wiEventArgs args) {
|
|
editor->renderPath->setChromaticAberrationEnabled(args.bValue);
|
|
});
|
|
AddWidget(&chromaticaberrationCheckBox);
|
|
|
|
chromaticaberrationSlider.Create(0, 4, 1.0f, 1000, "Amount: ");
|
|
chromaticaberrationSlider.SetTooltip("The lens distortion amount.");
|
|
chromaticaberrationSlider.SetSize(XMFLOAT2(100, hei));
|
|
chromaticaberrationSlider.SetPos(XMFLOAT2(x + 100, y));
|
|
chromaticaberrationSlider.SetValue(editor->renderPath->getChromaticAberrationAmount());
|
|
chromaticaberrationSlider.OnSlide([=](wiEventArgs args) {
|
|
editor->renderPath->setChromaticAberrationAmount(args.fValue);
|
|
});
|
|
AddWidget(&chromaticaberrationSlider);
|
|
|
|
|
|
Translate(XMFLOAT3((float)wiRenderer::GetDevice()->GetScreenWidth() - 500, 80, 0));
|
|
SetVisible(false);
|
|
|
|
}
|