diff --git a/interface/resources/qml/hifi/dialogs/graphics/GraphicsSettings.qml b/interface/resources/qml/hifi/dialogs/graphics/GraphicsSettings.qml
index 6e345caaf7..2041bab9f8 100644
--- a/interface/resources/qml/hifi/dialogs/graphics/GraphicsSettings.qml
+++ b/interface/resources/qml/hifi/dialogs/graphics/GraphicsSettings.qml
@@ -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();
renderingEffectsDropdown.refreshRenderingEffectsDropdownDisplay();
refreshRateDropdown.refreshRefreshRateDropdownDisplay();
+ antialiasingDropdown.refreshAntialiasingDropdown();
}
}
diff --git a/interface/src/Menu.cpp b/interface/src/Menu.cpp
index 760a7b1127..0e0250501d 100644
--- a/interface/src/Menu.cpp
+++ b/interface/src/Menu.cpp
@@ -405,8 +405,8 @@ Menu::Menu() {
// Developer > Render >>>
MenuWrapper* renderOptionsMenu = developerMenu->addMenu("Render");
- addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::AntiAliasing, 0, RenderScriptingInterface::getInstance()->getAntialiasingEnabled(),
- RenderScriptingInterface::getInstance(), SLOT(setAntialiasingEnabled(bool)));
+ addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::AntiAliasing, 0, RenderScriptingInterface::getInstance()->getAntialiasingMode(),
+ RenderScriptingInterface::getInstance(), SLOT(setAntialiasingMode(int)));
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::Shadows, 0, RenderScriptingInterface::getInstance()->getShadowsEnabled(),
RenderScriptingInterface::getInstance(), SLOT(setShadowsEnabled(bool)));
diff --git a/interface/src/scripting/RenderScriptingInterface.cpp b/interface/src/scripting/RenderScriptingInterface.cpp
index 56e9a93377..22598f690a 100644
--- a/interface/src/scripting/RenderScriptingInterface.cpp
+++ b/interface/src/scripting/RenderScriptingInterface.cpp
@@ -8,7 +8,6 @@
#include "RenderScriptingInterface.h"
#include "LightingModel.h"
-#include "AntialiasingEffect.h"
RenderScriptingInterface* RenderScriptingInterface::getInstance() {
@@ -29,13 +28,14 @@ void RenderScriptingInterface::loadSettings() {
_renderMethod = (_renderMethodSetting.get());
_shadowsEnabled = (_shadowsEnabledSetting.get());
_ambientOcclusionEnabled = (_ambientOcclusionEnabledSetting.get());
- _antialiasingEnabled = (_antialiasingEnabledSetting.get());
+ _antialiasingMode = (_antialiasingModeSetting.get());
_viewportResolutionScale = (_viewportResolutionScaleSetting.get());
});
forceRenderMethod((RenderMethod)_renderMethod);
forceShadowsEnabled(_shadowsEnabled);
forceAmbientOcclusionEnabled(_ambientOcclusionEnabled);
- forceAntialiasingEnabled(_antialiasingEnabled);
+ forceAntialiasingMode(_antialiasingMode);
+ forceAntialiasingMode(_antialiasingMode);
forceViewportResolutionScale(_viewportResolutionScale);
}
@@ -121,33 +121,45 @@ void RenderScriptingInterface::forceAmbientOcclusionEnabled(bool enabled) {
});
}
-bool RenderScriptingInterface::getAntialiasingEnabled() const {
- return _antialiasingEnabled;
+AntialiasingConfig::Mode RenderScriptingInterface::getAntialiasingMode() const {
+ return _antialiasingMode;
}
-void RenderScriptingInterface::setAntialiasingEnabled(bool enabled) {
- if (_antialiasingEnabled != enabled) {
- forceAntialiasingEnabled(enabled);
+void RenderScriptingInterface::setAntialiasingMode(AntialiasingConfig::Mode mode) {
+ if (_antialiasingMode != mode) {
+ forceAntialiasingMode(mode);
emit settingsChanged();
}
}
-void RenderScriptingInterface::forceAntialiasingEnabled(bool enabled) {
+void RenderScriptingInterface::forceAntialiasingMode(AntialiasingConfig::Mode mode) {
_renderSettingLock.withWriteLock([&] {
- _antialiasingEnabled = (enabled);
- _antialiasingEnabledSetting.set(enabled);
+ _antialiasingMode = static_cast<AntialiasingConfig::Mode>(mode);
+ _antialiasingModeSetting.set(mode);
auto mainViewJitterCamConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<JitterSample>("RenderMainView.JitterCam");
auto mainViewAntialiasingConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<Antialiasing>("RenderMainView.Antialiasing");
if (mainViewJitterCamConfig && mainViewAntialiasingConfig) {
- Menu::getInstance()->setIsOptionChecked(MenuOption::AntiAliasing, enabled);
- if (enabled) {
- mainViewJitterCamConfig->play();
- mainViewAntialiasingConfig->setDebugFXAA(false);
- }
- else {
- mainViewJitterCamConfig->none();
- mainViewAntialiasingConfig->setDebugFXAA(true);
+ Menu::getInstance()->setIsOptionChecked(MenuOption::AntiAliasing, mode);
+ switch (mode) {
+ case AntialiasingConfig::Mode::NONE:
+ mainViewJitterCamConfig->none();
+ mainViewAntialiasingConfig->setDebugFXAA(false);
+ break;
+ case AntialiasingConfig::TAA:
+ 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;
}
}
});
diff --git a/interface/src/scripting/RenderScriptingInterface.h b/interface/src/scripting/RenderScriptingInterface.h
index 97b736259b..3c2b489a8e 100644
--- a/interface/src/scripting/RenderScriptingInterface.h
+++ b/interface/src/scripting/RenderScriptingInterface.h
@@ -13,6 +13,8 @@
#include "Application.h"
#include "RenderForward.h"
+#include "AntialiasingEffect.h"
+
/*@jsdoc
* 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} ambientOcclusionEnabled - <code>true</code> if ambient occlusion is enabled, <code>false</code> if it's
* 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>> 0.0</code>.
*/
class RenderScriptingInterface : public QObject {
@@ -35,7 +37,7 @@ class RenderScriptingInterface : public QObject {
Q_PROPERTY(RenderMethod renderMethod READ getRenderMethod WRITE setRenderMethod 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 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)
public:
@@ -143,18 +145,18 @@ public slots:
void setAmbientOcclusionEnabled(bool enabled);
/*@jsdoc
- * Gets whether or not anti-aliasing is enabled.
- * @function Render.getAntialiasingEnabled
- * @returns {boolean} <code>true</code> if anti-aliasing is enabled, <code>false</code> if it's disabled.
+ * Gets the active anti-aliasing mode.
+ * @function Render.getAntialiasingMode
+ * @returns {integer} the active anti-aliasing mode.
*/
- bool getAntialiasingEnabled() const;
+ AntialiasingConfig::Mode getAntialiasingMode() const;
/*@jsdoc
- * Sets whether or not anti-aliasing is enabled.
- * @function Render.setAntialiasingEnabled
- * @param {boolean} enabled - <code>true</code> to enable anti-aliasing, <code>false</code> to disable.
+ * Sets the active anti-aliasing mode.
+ * @function Render.setAntialiasingMode
+ * @param {integer} the active anti-aliasing mode.
*/
- void setAntialiasingEnabled(bool enabled);
+ void setAntialiasingMode(AntialiasingConfig::Mode mode);
/*@jsdoc
* Gets the view port resolution scale.
@@ -192,21 +194,21 @@ private:
int _renderMethod{ RENDER_FORWARD ? render::Args::RenderMethod::FORWARD : render::Args::RenderMethod::DEFERRED };
bool _shadowsEnabled{ true };
bool _ambientOcclusionEnabled{ false };
- bool _antialiasingEnabled{ true };
+ AntialiasingConfig::Mode _antialiasingMode;
float _viewportResolutionScale{ 1.0f };
// Actual settings saved on disk
Setting::Handle<int> _renderMethodSetting { "renderMethod", RENDER_FORWARD ? render::Args::RenderMethod::FORWARD : render::Args::RenderMethod::DEFERRED };
Setting::Handle<bool> _shadowsEnabledSetting { "shadowsEnabled", true };
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 };
// Force assign both setting AND runtime value to the parameter value
void forceRenderMethod(RenderMethod renderMethod);
void forceShadowsEnabled(bool enabled);
void forceAmbientOcclusionEnabled(bool enabled);
- void forceAntialiasingEnabled(bool enabled);
+ void forceAntialiasingMode(AntialiasingConfig::Mode mode);
void forceViewportResolutionScale(float scale);
static std::once_flag registry_flag;
diff --git a/libraries/render-utils/src/AntialiasingEffect.h b/libraries/render-utils/src/AntialiasingEffect.h
index fc25343751..2e838764b4 100644
--- a/libraries/render-utils/src/AntialiasingEffect.h
+++ b/libraries/render-utils/src/AntialiasingEffect.h
@@ -110,7 +110,7 @@ public:
AntialiasingConfig() : render::Job::Config(true) {}
enum Mode {
- OFF = 0,
+ NONE = 0,
TAA,
FXAA,
MODE_COUNT
@@ -144,6 +144,7 @@ public:
signals:
void dirty();
};
+Q_DECLARE_METATYPE(AntialiasingConfig::Mode);
#define SET_BIT(bitfield, bitIndex, value) bitfield = ((bitfield) & ~(1 << (bitIndex))) | ((value) << (bitIndex))
#define GET_BIT(bitfield, bitIndex) ((bitfield) & (1 << (bitIndex)))