Reworked TAA PR by HifiExperiments

interface/resources/qml/hifi/dialogs/graphics/GraphicsSettings.qml

@@ -4,6 +4,7 @@
 //
 //  Created by Zach Fox on 2019-07-10
 //  Copyright 2019 High Fidelity, Inc.
+//  Copyright 2023 Overte e.V.
 //
 //  Distributed under the Apache License, Version 2.0.
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
@@ -501,7 +502,7 @@ Flickable {
                     ListModel {
                         id: antialiasingModel
 
-                        // Maintain same order as "AntialiasingConfig::Mode".
+                        // Maintain same order as "AntialiasingSetupConfig::Mode".
                         ListElement {
                             text: "None"
                         }

interface/src/SecondaryCamera.cpp

@@ -275,7 +275,7 @@ class EndSecondaryCameraFrame {  // Restores renderContext.
 void SecondaryCameraRenderTask::build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor) {
     const auto cachedArg = task.addJob<SecondaryCameraJob>("SecondaryCamera");
 
-    task.addJob<RenderViewTask>("RenderSecondView", cullFunctor, render::ItemKey::TAG_BITS_1, render::ItemKey::TAG_BITS_1);
+    task.addJob<RenderViewTask>("RenderSecondView", cullFunctor, render::ItemKey::TAG_BITS_1, render::ItemKey::TAG_BITS_1, RenderViewTask::TransformOffset::SECONDARY_VIEW);
 
     task.addJob<EndSecondaryCameraFrame>("EndSecondaryCamera", cachedArg);
 }

interface/src/graphics/GraphicsEngine.cpp

@@ -3,6 +3,7 @@
 //
 //  Created by Sam Gateau on 29/6/2018.
 //  Copyright 2018 High Fidelity, Inc.
+//  Copyright 2020 Vircadia contributors.
 //  Copyright 2023 Overte e.V.
 //
 //  Distributed under the Apache License, Version 2.0.
@@ -189,7 +190,7 @@ void GraphicsEngine::render_performFrame() {
 
     {
         PROFILE_RANGE(render, "/pluginBeginFrameRender");
-        // If a display plugin loses its underlying support, it
+        // If a display plugin loses it's underlying support, it
         // needs to be able to signal us to not use it
         if (!displayPlugin->beginFrameRender(_renderFrameCount)) {
             QMetaObject::invokeMethod(qApp, "updateDisplayMode");
@@ -262,14 +263,14 @@ void GraphicsEngine::render_performFrame() {
             batch.enableStereo(isStereo);
             batch.clearDepthStencilFramebuffer(1.0, 0);
             batch.setViewportTransform({ 0, 0, finalFramebuffer->getSize() });
-            _splashScreen->render(batch, viewFrustum, renderArgs._renderMethod == RenderArgs::RenderMethod::FORWARD);
+            _splashScreen->render(batch, viewFrustum, renderArgs._renderMethod == RenderArgs::RenderMethod::FORWARD, render::RenderEngine::TS_BACKGROUND_VIEW);
         });
     } else {
         {
             PROFILE_RANGE(render, "/renderOverlay");
             PerformanceTimer perfTimer("renderOverlay");
             // NOTE: There is no batch associated with this renderArgs
-            // the ApplicationOverlay class assumes it's viewport is set up to be the device size
+            // the ApplicationOverlay class assumes its viewport is set up to be the device size
             renderArgs._viewport = glm::ivec4(0, 0, qApp->getDeviceSize());
             qApp->getApplicationOverlay().renderOverlay(&renderArgs);
         }

interface/src/raypick/ParabolaPointer.cpp

@@ -1,6 +1,7 @@
 //
 //  Created by Sam Gondelman 7/17/2018
 //  Copyright 2018 High Fidelity, Inc.
+//  Copyright 2020 Vircadia contributors.
 //  Copyright 2023 Overte e.V.
 //
 //  Distributed under the Apache License, Version 2.0.
@@ -444,7 +445,10 @@ void ParabolaPointer::RenderState::ParabolaRenderItem::render(RenderArgs* args)
 
     Transform transform;
     transform.setTranslation(_origin);
-    batch.setModelTransform(transform);
+    batch.setModelTransform(transform, _prevRenderTransform);
+    if (args->_renderMode == RenderArgs::RenderMode::DEFAULT_RENDER_MODE || args->_renderMode == RenderArgs::RenderMode::MIRROR_RENDER_MODE) {
+        _prevRenderTransform = transform;
+    }
 
     batch.setPipeline(getParabolaPipeline(args->_renderMethod == render::Args::RenderMethod::FORWARD));
 
@@ -479,4 +483,4 @@ namespace render {
     template <> const ShapeKey shapeGetShapeKey(const ParabolaPointer::RenderState::ParabolaRenderItem::Pointer& payload) {
         return ShapeKey::Builder::ownPipeline();
     }
-}
+}

interface/src/raypick/ParabolaPointer.h

@@ -1,6 +1,7 @@
 //
 //  Created by Sam Gondelman 7/17/2018
 //  Copyright 2018 High Fidelity, Inc.
+//  Copyright 2020 Vircadia contributors.
 //
 //  Distributed under the Apache License, Version 2.0.
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
@@ -62,6 +63,7 @@ class ParabolaPointer : public PathPointer {
             render::ItemKey _key;
 
             glm::vec3 _origin { 0.0f };
+            Transform _prevRenderTransform;
             bool _isVisibleInSecondaryCamera { DEFAULT_PARABOLA_ISVISIBLEINSECONDARYCAMERA };
             bool _drawInFront { DEFAULT_PARABOLA_DRAWINFRONT };
             bool _visible { false };

interface/src/scripting/RenderScriptingInterface.cpp

@@ -19,14 +19,14 @@ STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
     auto scriptEngine = manager->engine().get();
 
     scriptRegisterMetaType<RenderScriptingInterface::RenderMethod, scriptValueFromEnumClass<RenderScriptingInterface::RenderMethod>, scriptValueToEnumClass<RenderScriptingInterface::RenderMethod> >(scriptEngine, "RenderMethod");
-    scriptRegisterMetaType<AntialiasingConfig::Mode, scriptValueFromEnumClass<AntialiasingConfig::Mode>, scriptValueToEnumClass<AntialiasingConfig::Mode> >(scriptEngine, "Mode");
+    scriptRegisterMetaType<AntialiasingSetupConfig::Mode, scriptValueFromEnumClass<AntialiasingSetupConfig::Mode>, scriptValueToEnumClass<AntialiasingSetupConfig::Mode> >(scriptEngine, "Mode");
 }));
 
 STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager){
     auto scriptEngine = manager->engine().get();
 
     scriptEngine->registerEnum("Render.RenderMethod",QMetaEnum::fromType<RenderScriptingInterface::RenderMethod>());
-    scriptEngine->registerEnum("AntialiasingMode",QMetaEnum::fromType<AntialiasingConfig::Mode>());
+    scriptEngine->registerEnum("AntialiasingMode",QMetaEnum::fromType<AntialiasingSetupConfig::Mode>());
 });
 
 RenderScriptingInterface* RenderScriptingInterface::getInstance() {
@@ -49,7 +49,7 @@ void RenderScriptingInterface::loadSettings() {
         _shadowsEnabled = (_shadowsEnabledSetting.get());
         _ambientOcclusionEnabled = (_ambientOcclusionEnabledSetting.get());
         //_antialiasingMode = (_antialiasingModeSetting.get());
-        _antialiasingMode = static_cast<AntialiasingConfig::Mode>(_antialiasingModeSetting.get());
+        _antialiasingMode = static_cast<AntialiasingSetupConfig::Mode>(_antialiasingModeSetting.get());
         _viewportResolutionScale = (_viewportResolutionScaleSetting.get());
         _fullScreenScreen = (_fullScreenScreenSetting.get());
     });
@@ -84,10 +84,16 @@ void RenderScriptingInterface::forceRenderMethod(RenderMethod renderMethod) {
         _renderMethod = (int)renderMethod;
         _renderMethodSetting.set((int)renderMethod);
 
-        auto config = dynamic_cast<render::SwitchConfig*>(qApp->getRenderEngine()->getConfiguration()->getConfig("RenderMainView.DeferredForwardSwitch"));
+        auto renderConfig = qApp->getRenderEngine()->getConfiguration();
+        auto config = dynamic_cast<render::SwitchConfig*>(renderConfig->getConfig("RenderMainView.DeferredForwardSwitch"));
         if (config) {
             config->setBranch((int)renderMethod);
         }
+
+        auto secondaryConfig = dynamic_cast<render::SwitchConfig*>(renderConfig->getConfig("RenderSecondView.DeferredForwardSwitch"));
+        if (secondaryConfig) {
+            secondaryConfig->setBranch((int)renderMethod);
+        }
     });
 }
 
@@ -111,17 +117,16 @@ void RenderScriptingInterface::forceShadowsEnabled(bool enabled) {
     _renderSettingLock.withWriteLock([&] {
         _shadowsEnabled = (enabled);
         _shadowsEnabledSetting.set(enabled);
+        Menu::getInstance()->setIsOptionChecked(MenuOption::Shadows, enabled);
 
         auto renderConfig = qApp->getRenderEngine()->getConfiguration();
         assert(renderConfig);
         auto lightingModelConfig = renderConfig->getConfig<MakeLightingModel>("RenderMainView.LightingModel");
         if (lightingModelConfig) {
-            Menu::getInstance()->setIsOptionChecked(MenuOption::Shadows, enabled);
             lightingModelConfig->setShadow(enabled);
         }
         auto secondaryLightingModelConfig = renderConfig->getConfig<MakeLightingModel>("RenderSecondView.LightingModel");
         if (secondaryLightingModelConfig) {
-            Menu::getInstance()->setIsOptionChecked(MenuOption::Shadows, enabled);
             secondaryLightingModelConfig->setShadow(enabled);
         }
     });
@@ -142,70 +147,92 @@ void RenderScriptingInterface::forceAmbientOcclusionEnabled(bool enabled) {
     _renderSettingLock.withWriteLock([&] {
         _ambientOcclusionEnabled = (enabled);
         _ambientOcclusionEnabledSetting.set(enabled);
+        Menu::getInstance()->setIsOptionChecked(MenuOption::AmbientOcclusion, enabled);
 
-        auto lightingModelConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<MakeLightingModel>("RenderMainView.LightingModel");
+        auto renderConfig = qApp->getRenderEngine()->getConfiguration();
+        auto lightingModelConfig = renderConfig->getConfig<MakeLightingModel>("RenderMainView.LightingModel");
         if (lightingModelConfig) {
-            Menu::getInstance()->setIsOptionChecked(MenuOption::AmbientOcclusion, enabled);
             lightingModelConfig->setAmbientOcclusion(enabled);
         }
+
+        auto secondaryLightingModelConfig = renderConfig->getConfig<MakeLightingModel>("RenderSecondView.LightingModel");
+        if (secondaryLightingModelConfig) {
+            secondaryLightingModelConfig->setAmbientOcclusion(enabled);
+        }
     });
 }
 
-AntialiasingConfig::Mode RenderScriptingInterface::getAntialiasingMode() const {
+AntialiasingSetupConfig::Mode RenderScriptingInterface::getAntialiasingMode() const {
     return _antialiasingMode;
 }
 
-void RenderScriptingInterface::setAntialiasingMode(AntialiasingConfig::Mode mode) {
+void RenderScriptingInterface::setAntialiasingMode(AntialiasingSetupConfig::Mode mode) {
     if (_antialiasingMode != mode) {
         forceAntialiasingMode(mode);
         emit settingsChanged();
     }
 }
 
-void setAntialiasingModeForView(AntialiasingConfig::Mode mode, JitterSampleConfig *jitterCamConfig, AntialiasingConfig *antialiasingConfig) {
+void setAntialiasingModeForView(AntialiasingSetupConfig::Mode mode, AntialiasingSetupConfig *antialiasingSetupConfig, AntialiasingConfig *antialiasingConfig) {
     switch (mode) {
-        case AntialiasingConfig::Mode::NONE:
-            jitterCamConfig->none();
+        case AntialiasingSetupConfig::Mode::NONE:
+            antialiasingSetupConfig->none();
             antialiasingConfig->blend = 1;
             antialiasingConfig->setDebugFXAA(false);
             break;
-        case AntialiasingConfig::Mode::TAA:
-            jitterCamConfig->play();
+        case AntialiasingSetupConfig::Mode::TAA:
+            antialiasingSetupConfig->play();
             antialiasingConfig->blend = 0.25;
             antialiasingConfig->setDebugFXAA(false);
             break;
-        case AntialiasingConfig::Mode::FXAA:
-            jitterCamConfig->none();
+        case AntialiasingSetupConfig::Mode::FXAA:
+            antialiasingSetupConfig->none();
             antialiasingConfig->blend = 0.25;
             antialiasingConfig->setDebugFXAA(true);
             break;
         default:
-            jitterCamConfig->none();
+            antialiasingSetupConfig->none();
             antialiasingConfig->blend = 1;
             antialiasingConfig->setDebugFXAA(false);
             break;
     }
 }
 
-void RenderScriptingInterface::forceAntialiasingMode(AntialiasingConfig::Mode mode) {
+void RenderScriptingInterface::forceAntialiasingMode(AntialiasingSetupConfig::Mode mode) {
     _renderSettingLock.withWriteLock([&] {
         _antialiasingMode = mode;
 
-        auto mainViewJitterCamConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<JitterSample>("RenderMainView.JitterCam");
-        auto mainViewAntialiasingConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<Antialiasing>("RenderMainView.Antialiasing");
-        auto secondViewJitterCamConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<JitterSample>("RenderSecondView.JitterCam");
-        auto secondViewAntialiasingConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<Antialiasing>("RenderSecondView.Antialiasing");
-        if (mode != AntialiasingConfig::Mode::NONE
-                && mode != AntialiasingConfig::Mode::TAA
-                && mode != AntialiasingConfig::Mode::FXAA) {
-            _antialiasingMode = AntialiasingConfig::Mode::NONE;
+        auto renderConfig = qApp->getRenderEngine()->getConfiguration();
+        // TODO: this may be needed if there are problems with changing antialiasing settings
+        //auto mainViewAntialiasingSetupConfig  = renderConfig->getConfig<AntialiasingSetup>("RenderMainView.AntialiasingSetup");
+        auto mainViewJitterCamConfig = renderConfig->getConfig<AntialiasingSetup>("RenderMainView.JitterCam");
+        auto mainViewAntialiasingConfig = renderConfig->getConfig<Antialiasing>("RenderMainView.Antialiasing");
+        auto secondViewJitterCamConfig = renderConfig->getConfig<AntialiasingSetup>("RenderSecondView.JitterCam");
+        auto secondViewAntialiasingConfig = renderConfig->getConfig<Antialiasing>("RenderSecondView.Antialiasing");
+        if (mode != AntialiasingSetupConfig::Mode::NONE
+                && mode != AntialiasingSetupConfig::Mode::TAA
+                && mode != AntialiasingSetupConfig::Mode::FXAA) {
+            _antialiasingMode = AntialiasingSetupConfig::Mode::NONE;
         }
         if (mainViewJitterCamConfig && mainViewAntialiasingConfig) {
             setAntialiasingModeForView( mode, mainViewJitterCamConfig, mainViewAntialiasingConfig);
         }
         if (secondViewJitterCamConfig && secondViewAntialiasingConfig) {
             setAntialiasingModeForView( mode, secondViewJitterCamConfig, secondViewAntialiasingConfig);
         }
+        //TODO:
+
+        //auto secondViewAntialiasingSetupConfig  = renderConfig->getConfig<AntialiasingSetup>("RenderSecondView.AntialiasingSetup");
+        //auto secondViewAntialiasingConfig = renderConfig->getConfig<Antialiasing>("RenderSecondView.Antialiasing");
+        //if (secondViewAntialiasingSetupConfig && secondViewAntialiasingConfig) {
+        //    if (enabled) {
+        //        secondViewAntialiasingSetupConfig ->play();
+        //        secondViewAntialiasingConfig->setDebugFXAA(false);
+        //    } else {
+        //        secondViewAntialiasingSetupConfig ->none();
+        //        secondViewAntialiasingConfig->setDebugFXAA(true);
+        //    }
+
 
         _antialiasingModeSetting.set(_antialiasingMode);
     });
@@ -271,20 +298,31 @@ void RenderScriptingInterface::forceViewportResolutionScale(float scale) {
         return;
     }
     _renderSettingLock.withWriteLock([&] {
-        _viewportResolutionScale = (scale);
+        _viewportResolutionScale = scale;
         _viewportResolutionScaleSetting.set(scale);
 
         auto renderConfig = qApp->getRenderEngine()->getConfiguration();
         assert(renderConfig);
         auto deferredView = renderConfig->getConfig("RenderMainView.RenderDeferredTask");
         // mainView can be null if we're rendering in forward mode
         if (deferredView) {
-            deferredView->setProperty("resolutionScale", _viewportResolutionScale);
+            deferredView->setProperty("resolutionScale", scale);
         }
         auto forwardView = renderConfig->getConfig("RenderMainView.RenderForwardTask");
         // mainView can be null if we're rendering in forward mode
         if (forwardView) {
-            forwardView->setProperty("resolutionScale", _viewportResolutionScale);
+            forwardView->setProperty("resolutionScale", scale);
+        }
+
+        auto deferredSecondView = renderConfig->getConfig("RenderSecondView.RenderDeferredTask");
+        // mainView can be null if we're rendering in forward mode
+        if (deferredSecondView) {
+            deferredSecondView->setProperty("resolutionScale", scale);
+        }
+        auto forwardSecondView = renderConfig->getConfig("RenderMainView.RenderForwardTask");
+        // mainView can be null if we're rendering in forward mode
+        if (forwardSecondView) {
+            forwardSecondView->setProperty("resolutionScale", scale);
         }
     });
 }

interface/src/scripting/RenderScriptingInterface.h

@@ -39,7 +39,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(AntialiasingConfig::Mode antialiasingMode READ getAntialiasingMode WRITE setAntialiasingMode NOTIFY settingsChanged)
+    Q_PROPERTY(AntialiasingSetupConfig::Mode antialiasingMode READ getAntialiasingMode WRITE setAntialiasingMode NOTIFY settingsChanged)
     Q_PROPERTY(float viewportResolutionScale READ getViewportResolutionScale WRITE setViewportResolutionScale NOTIFY settingsChanged)
     Q_PROPERTY(float verticalFieldOfView READ getVerticalFieldOfView WRITE setVerticalFieldOfView NOTIFY settingsChanged)
 
@@ -153,14 +153,14 @@ public slots:
      * @function Render.getAntialiasingMode
      * @returns {AntialiasingMode} The active anti-aliasing mode.
      */
-    AntialiasingConfig::Mode getAntialiasingMode() const;
+    AntialiasingSetupConfig::Mode getAntialiasingMode() const;
 
     /*@jsdoc
      * Sets the active anti-aliasing mode.
      * @function Render.setAntialiasingMode
      * @param {AntialiasingMode} The active anti-aliasing mode.
      */
-    void setAntialiasingMode(AntialiasingConfig::Mode mode);
+    void setAntialiasingMode(AntialiasingSetupConfig::Mode mode);
 
     /*@jsdoc
      * Gets the view port resolution scale.
@@ -236,7 +236,7 @@ public slots:
     int  _renderMethod{ RENDER_FORWARD ? render::Args::RenderMethod::FORWARD : render::Args::RenderMethod::DEFERRED };
     bool _shadowsEnabled{ true };
     bool _ambientOcclusionEnabled{ false };
-    AntialiasingConfig::Mode _antialiasingMode{ AntialiasingConfig::Mode::NONE };
+    AntialiasingSetupConfig::Mode _antialiasingMode{ AntialiasingSetupConfig::Mode::NONE };
     float _viewportResolutionScale{ 1.0f };
     QString _fullScreenScreen;
 
@@ -246,15 +246,15 @@ public slots:
     Setting::Handle<bool> _shadowsEnabledSetting { "shadowsEnabled", true };
     Setting::Handle<bool> _ambientOcclusionEnabledSetting { "ambientOcclusionEnabled", false };
     //Setting::Handle<AntialiasingConfig::Mode> _antialiasingModeSetting { "antialiasingMode", AntialiasingConfig::Mode::TAA };
-    Setting::Handle<int> _antialiasingModeSetting { "antialiasingMode", AntialiasingConfig::Mode::NONE };
+    Setting::Handle<int> _antialiasingModeSetting { "antialiasingMode", AntialiasingSetupConfig::Mode::NONE };
     Setting::Handle<float> _viewportResolutionScaleSetting { "viewportResolutionScale", 1.0f };
     Setting::Handle<QString> _fullScreenScreenSetting { "fullScreenScreen", "" };
 
     // Force assign both setting AND runtime value to the parameter value
     void forceRenderMethod(RenderMethod renderMethod);
     void forceShadowsEnabled(bool enabled);
     void forceAmbientOcclusionEnabled(bool enabled);
-    void forceAntialiasingMode(AntialiasingConfig::Mode mode);
+    void forceAntialiasingMode(AntialiasingSetupConfig::Mode mode);
     void forceViewportResolutionScale(float scale);
 
     static std::once_flag registry_flag;