Mirrors/overte-thingvellir
3
0
Fork 0
mirror of https://thingvellir.net/git/overte synced 2025-03-27 23:52:03 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Hopefully implemented antialiasing setting.

Browse source
This commit is contained in:
Penguin-Guru 2021-10-24 15:32:51 -07:00
parent e322d9e506
commit 66fdfa40ad
5 changed files with 112 additions and 35 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

62
interface/resources/qml/hifi/dialogs/graphics/GraphicsSettings.qml
View file

@ -358,6 +358,67 @@ Item {
} }
} }
} }
ColumnLayout {
Layout.topMargin: 20
Layout.preferredWidth: parent.width
spacing: 0
Item {
Layout.preferredWidth: parent.width
Layout.preferredHeight: 35
HifiStylesUit.RalewayRegular {
id: antialiasingHeader
text: "Anti-aliasing"
anchors.left: parent.left
anchors.top: parent.top
width: 130
height: parent.height
size: 16
color: "#FFFFFF"
}
ListModel {
id: antialiasingModel
ListElement {
text: "None"
}
ListElement {
text: "TAA"
}
ListElement {
text: "FXAA"
}
}
HifiControlsUit.ComboBox {
id: antialiasingDropdown
anchors.left: antialiasingHeader.right
anchors.leftMargin: 20
anchors.top: parent.top
width: 280
height: parent.height
colorScheme: hifi.colorSchemes.dark
model: antialiasingModel
currentIndex: -1
function refreshAntialiasingDropdown() {
antialiasingDropdown.currentIndex = Render.antialiasingMode;
}
Component.onCompleted: {
antialiasingDropdown.refreshAntialiasingDropdown();
}
onCurrentIndexChanged: {
Render.antialiasingMode = currentIndex;
antialiasingDropdown.displayText = model.get(currentIndex).text;
}
}
}
}
} }
} }
@ -365,5 +426,6 @@ Item {
worldDetailDropdown.refreshWorldDetailDropdown(); worldDetailDropdown.refreshWorldDetailDropdown();
renderingEffectsDropdown.refreshRenderingEffectsDropdownDisplay(); renderingEffectsDropdown.refreshRenderingEffectsDropdownDisplay();
refreshRateDropdown.refreshRefreshRateDropdownDisplay(); refreshRateDropdown.refreshRefreshRateDropdownDisplay();
antialiasingDropdown.refreshAntialiasingDropdown();
} }
} }

4
interface/src/Menu.cpp
View file

@ -405,8 +405,8 @@ Menu::Menu() {
// Developer > Render >>> // Developer > Render >>>
MenuWrapper* renderOptionsMenu = developerMenu->addMenu("Render"); MenuWrapper* renderOptionsMenu = developerMenu->addMenu("Render");
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::AntiAliasing, 0, RenderScriptingInterface::getInstance()->getAntialiasingEnabled(), addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::AntiAliasing, 0, RenderScriptingInterface::getInstance()->getAntialiasingMode(),
RenderScriptingInterface::getInstance(), SLOT(setAntialiasingEnabled(bool))); RenderScriptingInterface::getInstance(), SLOT(setAntialiasingMode(int)));
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::Shadows, 0, RenderScriptingInterface::getInstance()->getShadowsEnabled(), addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::Shadows, 0, RenderScriptingInterface::getInstance()->getShadowsEnabled(),
RenderScriptingInterface::getInstance(), SLOT(setShadowsEnabled(bool))); RenderScriptingInterface::getInstance(), SLOT(setShadowsEnabled(bool)));

50
interface/src/scripting/RenderScriptingInterface.cpp
View file

@ -8,7 +8,6 @@
#include "RenderScriptingInterface.h" #include "RenderScriptingInterface.h"
#include "LightingModel.h" #include "LightingModel.h"
#include "AntialiasingEffect.h"
RenderScriptingInterface* RenderScriptingInterface::getInstance() { RenderScriptingInterface* RenderScriptingInterface::getInstance() {
@ -29,13 +28,14 @@ void RenderScriptingInterface::loadSettings() {
_renderMethod = (_renderMethodSetting.get()); _renderMethod = (_renderMethodSetting.get());
_shadowsEnabled = (_shadowsEnabledSetting.get()); _shadowsEnabled = (_shadowsEnabledSetting.get());
_ambientOcclusionEnabled = (_ambientOcclusionEnabledSetting.get()); _ambientOcclusionEnabled = (_ambientOcclusionEnabledSetting.get());
_antialiasingEnabled = (_antialiasingEnabledSetting.get()); _antialiasingMode = (_antialiasingModeSetting.get());
_viewportResolutionScale = (_viewportResolutionScaleSetting.get()); _viewportResolutionScale = (_viewportResolutionScaleSetting.get());
}); });
forceRenderMethod((RenderMethod)_renderMethod); forceRenderMethod((RenderMethod)_renderMethod);
forceShadowsEnabled(_shadowsEnabled); forceShadowsEnabled(_shadowsEnabled);
forceAmbientOcclusionEnabled(_ambientOcclusionEnabled); forceAmbientOcclusionEnabled(_ambientOcclusionEnabled);
forceAntialiasingEnabled(_antialiasingEnabled); forceAntialiasingMode(_antialiasingMode);
forceAntialiasingMode(_antialiasingMode);
forceViewportResolutionScale(_viewportResolutionScale); forceViewportResolutionScale(_viewportResolutionScale);
} }
@ -121,33 +121,45 @@ void RenderScriptingInterface::forceAmbientOcclusionEnabled(bool enabled) {
}); });
} }
bool RenderScriptingInterface::getAntialiasingEnabled() const { AntialiasingConfig::Mode RenderScriptingInterface::getAntialiasingMode() const {
return _antialiasingEnabled; return _antialiasingMode;
} }
void RenderScriptingInterface::setAntialiasingEnabled(bool enabled) { void RenderScriptingInterface::setAntialiasingMode(AntialiasingConfig::Mode mode) {
if (_antialiasingEnabled != enabled) { if (_antialiasingMode != mode) {
forceAntialiasingEnabled(enabled); forceAntialiasingMode(mode);
emit settingsChanged(); emit settingsChanged();
} }
} }
void RenderScriptingInterface::forceAntialiasingEnabled(bool enabled) { void RenderScriptingInterface::forceAntialiasingMode(AntialiasingConfig::Mode mode) {
_renderSettingLock.withWriteLock([&] { _renderSettingLock.withWriteLock([&] {
_antialiasingEnabled = (enabled); _antialiasingMode = static_cast<AntialiasingConfig::Mode>(mode);
_antialiasingEnabledSetting.set(enabled); _antialiasingModeSetting.set(mode);
auto mainViewJitterCamConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<JitterSample>("RenderMainView.JitterCam"); auto mainViewJitterCamConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<JitterSample>("RenderMainView.JitterCam");
auto mainViewAntialiasingConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<Antialiasing>("RenderMainView.Antialiasing"); auto mainViewAntialiasingConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<Antialiasing>("RenderMainView.Antialiasing");
if (mainViewJitterCamConfig && mainViewAntialiasingConfig) { if (mainViewJitterCamConfig && mainViewAntialiasingConfig) {
Menu::getInstance()->setIsOptionChecked(MenuOption::AntiAliasing, enabled); Menu::getInstance()->setIsOptionChecked(MenuOption::AntiAliasing, mode);
if (enabled) { switch (mode) {
mainViewJitterCamConfig->play(); case AntialiasingConfig::Mode::NONE:
mainViewAntialiasingConfig->setDebugFXAA(false); mainViewJitterCamConfig->none();
} mainViewAntialiasingConfig->setDebugFXAA(false);
else { break;
mainViewJitterCamConfig->none(); case AntialiasingConfig::TAA:
mainViewAntialiasingConfig->setDebugFXAA(true); mainViewJitterCamConfig->play();
mainViewAntialiasingConfig->setDebugFXAA(false);
break;
case AntialiasingConfig::Mode::FXAA:
mainViewJitterCamConfig->none();
mainViewAntialiasingConfig->setDebugFXAA(true);
break;
default:
_antialiasingMode = AntialiasingConfig::Mode::NONE;
_antialiasingModeSetting.set(AntialiasingConfig::Mode::NONE);
mainViewJitterCamConfig->none();
mainViewAntialiasingConfig->setDebugFXAA(false);
break;
} }
} }
}); });

28
interface/src/scripting/RenderScriptingInterface.h
View file

@ -13,6 +13,8 @@
#include "Application.h" #include "Application.h"
#include "RenderForward.h" #include "RenderForward.h"
#include "AntialiasingEffect.h"
/*@jsdoc /*@jsdoc
* The <code>Render</code> API enables you to configure the graphics engine. * The <code>Render</code> API enables you to configure the graphics engine.
@ -27,7 +29,7 @@
* @property {boolean} shadowsEnabled - <code>true</code> if shadows are enabled, <code>false</code> if they're disabled. * @property {boolean} shadowsEnabled - <code>true</code> if shadows are enabled, <code>false</code> if they're disabled.
* @property {boolean} ambientOcclusionEnabled - <code>true</code> if ambient occlusion is enabled, <code>false</code> if it's * @property {boolean} ambientOcclusionEnabled - <code>true</code> if ambient occlusion is enabled, <code>false</code> if it's
* disabled. * disabled.
* @property {boolean} antialiasingEnabled - <code>true</code> if anti-aliasing is enabled, <code>false</code> if it's disabled. * @property {integer} antialiasingMode - The active anti-aliasing mode.
* @property {number} viewportResolutionScale - The view port resolution scale, <code>&gt; 0.0</code>. * @property {number} viewportResolutionScale - The view port resolution scale, <code>&gt; 0.0</code>.
*/ */
class RenderScriptingInterface : public QObject { class RenderScriptingInterface : public QObject {
@ -35,7 +37,7 @@ class RenderScriptingInterface : public QObject {
Q_PROPERTY(RenderMethod renderMethod READ getRenderMethod WRITE setRenderMethod NOTIFY settingsChanged) Q_PROPERTY(RenderMethod renderMethod READ getRenderMethod WRITE setRenderMethod NOTIFY settingsChanged)
Q_PROPERTY(bool shadowsEnabled READ getShadowsEnabled WRITE setShadowsEnabled NOTIFY settingsChanged) Q_PROPERTY(bool shadowsEnabled READ getShadowsEnabled WRITE setShadowsEnabled NOTIFY settingsChanged)
Q_PROPERTY(bool ambientOcclusionEnabled READ getAmbientOcclusionEnabled WRITE setAmbientOcclusionEnabled NOTIFY settingsChanged) Q_PROPERTY(bool ambientOcclusionEnabled READ getAmbientOcclusionEnabled WRITE setAmbientOcclusionEnabled NOTIFY settingsChanged)
Q_PROPERTY(bool antialiasingEnabled READ getAntialiasingEnabled WRITE setAntialiasingEnabled NOTIFY settingsChanged) Q_PROPERTY(AntialiasingConfig::Mode antialiasingMode READ getAntialiasingMode WRITE setAntialiasingMode NOTIFY settingsChanged)
Q_PROPERTY(float viewportResolutionScale READ getViewportResolutionScale WRITE setViewportResolutionScale NOTIFY settingsChanged) Q_PROPERTY(float viewportResolutionScale READ getViewportResolutionScale WRITE setViewportResolutionScale NOTIFY settingsChanged)
public: public:
@ -143,18 +145,18 @@ public slots:
void setAmbientOcclusionEnabled(bool enabled); void setAmbientOcclusionEnabled(bool enabled);
/*@jsdoc /*@jsdoc
* Gets whether or not anti-aliasing is enabled. * Gets the active anti-aliasing mode.
* @function Render.getAntialiasingEnabled * @function Render.getAntialiasingMode
* @returns {boolean} <code>true</code> if anti-aliasing is enabled, <code>false</code> if it's disabled. * @returns {integer} the active anti-aliasing mode.
*/ */
bool getAntialiasingEnabled() const; AntialiasingConfig::Mode getAntialiasingMode() const;
/*@jsdoc /*@jsdoc
* Sets whether or not anti-aliasing is enabled. * Sets the active anti-aliasing mode.
* @function Render.setAntialiasingEnabled * @function Render.setAntialiasingMode
* @param {boolean} enabled - <code>true</code> to enable anti-aliasing, <code>false</code> to disable. * @param {integer} the active anti-aliasing mode.
*/ */
void setAntialiasingEnabled(bool enabled); void setAntialiasingMode(AntialiasingConfig::Mode mode);
/*@jsdoc /*@jsdoc
* Gets the view port resolution scale. * Gets the view port resolution scale.
@ -192,21 +194,21 @@ private:
int _renderMethod{ RENDER_FORWARD ? render::Args::RenderMethod::FORWARD : render::Args::RenderMethod::DEFERRED }; int _renderMethod{ RENDER_FORWARD ? render::Args::RenderMethod::FORWARD : render::Args::RenderMethod::DEFERRED };
bool _shadowsEnabled{ true }; bool _shadowsEnabled{ true };
bool _ambientOcclusionEnabled{ false }; bool _ambientOcclusionEnabled{ false };
bool _antialiasingEnabled{ true }; AntialiasingConfig::Mode _antialiasingMode;
float _viewportResolutionScale{ 1.0f }; float _viewportResolutionScale{ 1.0f };
// Actual settings saved on disk // Actual settings saved on disk
Setting::Handle<int> _renderMethodSetting { "renderMethod", RENDER_FORWARD ? render::Args::RenderMethod::FORWARD : render::Args::RenderMethod::DEFERRED }; Setting::Handle<int> _renderMethodSetting { "renderMethod", RENDER_FORWARD ? render::Args::RenderMethod::FORWARD : render::Args::RenderMethod::DEFERRED };
Setting::Handle<bool> _shadowsEnabledSetting { "shadowsEnabled", true }; Setting::Handle<bool> _shadowsEnabledSetting { "shadowsEnabled", true };
Setting::Handle<bool> _ambientOcclusionEnabledSetting { "ambientOcclusionEnabled", false }; Setting::Handle<bool> _ambientOcclusionEnabledSetting { "ambientOcclusionEnabled", false };
Setting::Handle<bool> _antialiasingEnabledSetting { "antialiasingEnabled", true }; Setting::Handle<AntialiasingConfig::Mode> _antialiasingModeSetting { "antialiasingMode", AntialiasingConfig::Mode::TAA };
Setting::Handle<float> _viewportResolutionScaleSetting { "viewportResolutionScale", 1.0f }; Setting::Handle<float> _viewportResolutionScaleSetting { "viewportResolutionScale", 1.0f };
// Force assign both setting AND runtime value to the parameter value // Force assign both setting AND runtime value to the parameter value
void forceRenderMethod(RenderMethod renderMethod); void forceRenderMethod(RenderMethod renderMethod);
void forceShadowsEnabled(bool enabled); void forceShadowsEnabled(bool enabled);
void forceAmbientOcclusionEnabled(bool enabled); void forceAmbientOcclusionEnabled(bool enabled);
void forceAntialiasingEnabled(bool enabled); void forceAntialiasingMode(AntialiasingConfig::Mode mode);
void forceViewportResolutionScale(float scale); void forceViewportResolutionScale(float scale);
static std::once_flag registry_flag; static std::once_flag registry_flag;

3
libraries/render-utils/src/AntialiasingEffect.h
View file

@ -110,7 +110,7 @@ public:
AntialiasingConfig() : render::Job::Config(true) {} AntialiasingConfig() : render::Job::Config(true) {}
enum Mode { enum Mode {
OFF = 0, NONE = 0,
TAA, TAA,
FXAA, FXAA,
MODE_COUNT MODE_COUNT
@ -144,6 +144,7 @@ public:
signals: signals:
void dirty(); void dirty();
}; };
Q_DECLARE_METATYPE(AntialiasingConfig::Mode);
#define SET_BIT(bitfield, bitIndex, value) bitfield = ((bitfield) & ~(1 << (bitIndex))) | ((value) << (bitIndex)) #define SET_BIT(bitfield, bitIndex, value) bitfield = ((bitfield) & ~(1 << (bitIndex))) | ((value) << (bitIndex))
#define GET_BIT(bitfield, bitIndex) ((bitfield) & (1 << (bitIndex))) #define GET_BIT(bitfield, bitIndex) ((bitfield) & (1 << (bitIndex)))