Merge remote-tracking branch 'overte/master' into application

Author: HifiExperiments

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

@@ -658,6 +658,36 @@ Flickable {
                         }
                     }
                 }
+                Item {
+                    Layout.preferredWidth: parent.width
+                    Layout.preferredHeight: 35
+                    Layout.topMargin: 16
+
+                    HifiStylesUit.RalewayRegular {
+                        id: enableCameraClippingHeader
+                        text: "3rd Person Camera Clipping"
+                        anchors.left: parent.left
+                        anchors.top: parent.top
+                        width: 200
+                        height: parent.height
+                        size: 16
+                        color: "#FFFFFF"
+                    }
+
+                    HifiControlsUit.CheckBox {
+                        id: enableCameraClipping
+                        checked: Render.cameraClippingEnabled
+                        boxSize: 16
+                        spacing: -1
+                        colorScheme: hifi.colorSchemes.dark
+                        anchors.left: enableCameraClippingHeader.right
+                        anchors.leftMargin: 20
+                        anchors.top: parent.top
+                        onCheckedChanged: {
+                            Render.cameraClippingEnabled = enableCameraClipping.checked;
+                        }
+                    }
+                }
             }
 
             ColumnLayout {
@@ -683,7 +713,7 @@ Flickable {
                     ListModel {
                         id: antialiasingModel
 
-                        // Maintain same order as "AntialiasingConfig::Mode".
+                        // Maintain same order as "AntialiasingSetupConfig::Mode".
                         ListElement {
                             text: "None"
                         }

interface/src/Application.cpp

@@ -234,7 +234,8 @@ Application::Application(
     _maxOctreePacketsPerSecond("maxOctreePPS", DEFAULT_MAX_OCTREE_PPS),
     _maxOctreePPS(_maxOctreePacketsPerSecond.get()),
     // Camera
-    _fieldOfView("fieldOfView", DEFAULT_FIELD_OF_VIEW_DEGREES)
+    _fieldOfView("fieldOfView", DEFAULT_FIELD_OF_VIEW_DEGREES),
+    _cameraClippingEnabled("cameraClippingEnabled", false)
 {
     setProperty(hifi::properties::CRASHED, _previousSessionCrashed);
 

interface/src/Application.h

@@ -300,6 +300,9 @@ class Application : public QApplication,
     float getFieldOfView() { return _fieldOfView.get(); }
     void setFieldOfView(float fov);
 
+    bool getCameraClippingEnabled() { return _cameraClippingEnabled.get(); }
+    void setCameraClippingEnabled(bool enabled);
+
     void updateMyAvatarLookAtPosition(float deltaTime);
 
 
@@ -880,6 +883,10 @@ private slots:
     ConicalViewFrustums _lastQueriedViews;  // last views used to query servers
 
     Setting::Handle<float> _fieldOfView;
+    Setting::Handle<float> _cameraClippingEnabled;
+
+    bool _prevCameraClippingEnabled { false };
+    unsigned int _cameraClippingRayPickID;
 
 
     // Graphics

interface/src/Application_Camera.cpp

@@ -18,6 +18,8 @@
 #include <glm/gtx/transform.hpp>
 
 #include <controllers/UserInputMapper.h>
+#include <PickManager.h>
+#include <raypick/RayPick.h>
 #include <SecondaryCamera.h>
 
 #include "avatar/MyAvatar.h"
@@ -40,9 +42,7 @@ void Application::updateCamera(RenderArgs& renderArgs, float deltaTime) {
     PROFILE_RANGE(render, __FUNCTION__);
     PerformanceTimer perfTimer("updateCamera");
 
-    glm::vec3 boomOffset;
     auto myAvatar = getMyAvatar();
-    boomOffset = myAvatar->getModelScale() * myAvatar->getBoomLength() * -IDENTITY_FORWARD;
 
     // The render mode is default or mirror if the camera is in mirror mode, assigned further below
     renderArgs._renderMode = RenderArgs::DEFAULT_RENDER_MODE;
@@ -81,6 +81,16 @@ void Application::updateCamera(RenderArgs& renderArgs, float deltaTime) {
             _myCamera.setOrientation(glm::normalize(glmExtractRotation(worldCameraMat)));
             _myCamera.setPosition(extractTranslation(worldCameraMat));
         } else {
+            float boomLength = myAvatar->getBoomLength();
+            if (getCameraClippingEnabled()) {
+                auto result =
+                    DependencyManager::get<PickManager>()->getPrevPickResultTyped<RayPickResult>(_cameraClippingRayPickID);
+                if (result && result->doesIntersect()) {
+                    const float CAMERA_CLIPPING_EPSILON = 0.1f;
+                    boomLength = std::min(boomLength, result->distance - CAMERA_CLIPPING_EPSILON);
+                }
+            }
+            glm::vec3 boomOffset = myAvatar->getModelScale() * boomLength * -IDENTITY_FORWARD;
             _thirdPersonHMDCameraBoomValid = false;
             if (mode == CAMERA_MODE_THIRD_PERSON) {
                 _myCamera.setOrientation(myAvatar->getHead()->getOrientation());
@@ -158,7 +168,19 @@ void Application::updateCamera(RenderArgs& renderArgs, float deltaTime) {
         _myCamera.update();
     }
 
-    renderArgs._cameraMode = (int8_t)_myCamera.getMode();
+    renderArgs._cameraMode = (int8_t)mode;
+
+    const bool shouldEnableCameraClipping =
+        (mode == CAMERA_MODE_THIRD_PERSON || mode == CAMERA_MODE_LOOK_AT || mode == CAMERA_MODE_SELFIE) && !isHMDMode() &&
+        getCameraClippingEnabled();
+    if (_prevCameraClippingEnabled != shouldEnableCameraClipping) {
+        if (shouldEnableCameraClipping) {
+            DependencyManager::get<PickManager>()->enablePick(_cameraClippingRayPickID);
+        } else {
+            DependencyManager::get<PickManager>()->disablePick(_cameraClippingRayPickID);
+        }
+        _prevCameraClippingEnabled = shouldEnableCameraClipping;
+    }
 }
 
 void Application::updateSecondaryCameraViewFrustum() {
@@ -277,6 +299,16 @@ void Application::setFieldOfView(float fov) {
     }
 }
 
+void Application::setCameraClippingEnabled(bool enabled) {
+    _cameraClippingEnabled.set(enabled);
+    _prevCameraClippingEnabled = enabled;
+    if (enabled) {
+        DependencyManager::get<PickManager>()->enablePick(_cameraClippingRayPickID);
+    } else {
+        DependencyManager::get<PickManager>()->disablePick(_cameraClippingRayPickID);
+    }
+}
+
 // Called during Application::update immediately before AvatarManager::updateMyAvatar, updating my data that is then sent
 // to everyone.
 // The principal result is to call updateLookAtTargetAvatar() and then setLookAtPosition().

interface/src/Application_Setup.cpp

@@ -35,6 +35,7 @@
 #include <AutoUpdater.h>
 #include <avatar/AvatarManager.h>
 #include <BuildInfo.h>
+#include <CameraRootTransformNode.h>
 #include <crash-handler/CrashHandler.h>
 #include <DebugDraw.h>
 #include <DeferredLightingEffect.h>
@@ -1277,6 +1278,17 @@ void Application::initialize(const QCommandLineParser &parser) {
         DependencyManager::get<EntityTreeRenderer>()->setMouseRayPickID(mouseRayPickID);
     }
 
+    // Setup the camera clipping ray pick
+    {
+        _prevCameraClippingEnabled = _cameraClippingEnabled.get();
+        auto cameraRayPick = std::make_shared<RayPick>(Vectors::ZERO, -Vectors::UP,
+                                                       PickFilter(PickScriptingInterface::getPickEntities() |
+                                                                  PickScriptingInterface::getPickLocalEntities()),
+                                                       MyAvatar::ZOOM_MAX, 0.0f, _prevCameraClippingEnabled);
+        cameraRayPick->parentTransform = std::make_shared<CameraRootTransformNode>();
+        _cameraClippingRayPickID = DependencyManager::get<PickManager>()->addPick(PickQuery::Ray, cameraRayPick);
+    }
+
     // Preload Tablet sounds
     DependencyManager::get<EntityScriptingInterface>()->setEntityTree(qApp->getEntities()->getTree());
     DependencyManager::get<TabletScriptingInterface>()->preloadSounds();
@@ -1656,8 +1668,10 @@ void Application::setupSignalsAndOperators() {
             return nullptr;
         });
 
-        Procedural::opaqueStencil = [](gpu::StatePointer state) { PrepareStencil::testMaskDrawShape(*state); };
-        Procedural::transparentStencil = [](gpu::StatePointer state) { PrepareStencil::testMask(*state); };
+        Procedural::opaqueStencil = [](gpu::StatePointer state, bool useAA) {
+            useAA ? PrepareStencil::testMaskDrawShape(*state) : PrepareStencil::testMaskDrawShapeNoAA(*state);
+        };
+        Procedural::transparentStencil = [](gpu::StatePointer state) { PrepareStencil::testMaskResetNoAA(*state); };
 
         EntityTree::setGetEntityObjectOperator([this](const QUuid& id) -> QObject* {
             auto entities = getEntities();

interface/src/CameraRootTransformNode.cpp

@@ -0,0 +1,48 @@
+//
+//  Created by HifiExperiments on 10/30/2024
+//  Copyright 2024 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
+//
+
+#include "CameraRootTransformNode.h"
+
+#include "Application.h"
+#include "DependencyManager.h"
+#include "avatar/AvatarManager.h"
+#include "avatar/MyAvatar.h"
+
+Transform CameraRootTransformNode::getTransform() {
+    auto myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
+
+    glm::vec3 pos;
+    glm::quat ori;
+
+    CameraMode mode = qApp->getCamera().getMode();
+    if (mode == CAMERA_MODE_FIRST_PERSON || mode == CAMERA_MODE_THIRD_PERSON) {
+        pos = myAvatar->getDefaultEyePosition();
+        ori = myAvatar->getHeadOrientation();
+    } else if (mode == CAMERA_MODE_FIRST_PERSON_LOOK_AT) {
+        pos = myAvatar->getCameraEyesPosition(0.0f);
+        ori = myAvatar->getLookAtRotation();
+    } else {
+        ori = myAvatar->getLookAtRotation();
+        pos = myAvatar->getLookAtPivotPoint();
+
+        if (mode == CAMERA_MODE_SELFIE) {
+            ori = ori * glm::angleAxis(PI, ori * Vectors::UP);
+        }
+    }
+
+    ori = ori * glm::angleAxis(-PI / 2.0f, Vectors::RIGHT);
+
+    glm::vec3 scale = glm::vec3(myAvatar->scaleForChildren());
+    return Transform(ori, scale, pos);
+}
+
+QVariantMap CameraRootTransformNode::toVariantMap() const {
+    QVariantMap map;
+    map["joint"] = "CameraRoot";
+    return map;
+}

interface/src/CameraRootTransformNode.h

@@ -0,0 +1,20 @@
+//
+//  Created by HifiExperiments on 10/30/2024
+//  Copyright 2024 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
+//
+#ifndef hifi_CameraRootTransformNode_h
+#define hifi_CameraRootTransformNode_h
+
+#include "TransformNode.h"
+
+class CameraRootTransformNode : public TransformNode {
+public:
+    CameraRootTransformNode() {}
+    Transform getTransform() override;
+    QVariantMap toVariantMap() const override;
+};
+
+#endif // hifi_CameraRootTransformNode_h

interface/src/SecondaryCamera.cpp

@@ -274,7 +274,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

@@ -262,14 +262,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

@@ -446,7 +446,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));
 
@@ -481,4 +484,4 @@ namespace render {
     template <> const ShapeKey shapeGetShapeKey(const ParabolaPointer::RenderState::ParabolaRenderItem::Pointer& payload) {
         return ShapeKey::Builder::ownPipeline();
     }
-}
+}