Implement gravity options and ui (#117)

build_scripts/qt/resources.pri

@@ -22,8 +22,8 @@ DISTFILES += \
     src/res/qml/motion_page/gravity/* \
     src/res/qml/motion_page/height_toggle/* \
     src/res/qml/motion_page/snap_turn/* \
-    src/res/qml/motion_page/universe_drag/* \
+    src/res/qml/motion_page/space_drag/* \
-    src/res/qml/motion_page/universe_turn/* \
+    src/res/qml/motion_page/space_turn/* \
     src/res/qml/RevivePage.qml \
     src/res/qml/RootPage.qml \
     src/res/qml/SettingsPage.qml \

src/openvr/ivrinput.cpp

@@ -122,6 +122,7 @@ SteamIVRInput::SteamIVRInput()
       m_swapSpaceDragToRightHandOverride(
           action_keys::k_actionSwapSpaceDragToRightHandOverride ),
       m_gravityToggle( action_keys::k_actionGravityToggle ),
+      m_gravityReverse( action_keys::k_actionGravityReverse ),
       m_heightToggle( action_keys::k_actionHeightToggle ),
       m_resetOffsets( action_keys::k_actionResetOffsets ),
       m_snapTurnLeft( action_keys::k_actionSnapTurnLeft ),
@@ -243,6 +244,11 @@ bool SteamIVRInput::gravityToggle()
     return isDigitalActionActivatedOnce( m_gravityToggle );
 }
 
+bool SteamIVRInput::gravityReverse()
+{
+    return isDigitalActionActivatedConstant( m_gravityReverse );
+}
+
 bool SteamIVRInput::heightToggle()
 {
     return isDigitalActionActivatedOnce( m_heightToggle );

src/openvr/ivrinput.h

@@ -53,6 +53,7 @@ public:
     bool swapSpaceDragToLeftHandOverride();
     bool swapSpaceDragToRightHandOverride();
     bool gravityToggle();
+    bool gravityReverse();
     bool heightToggle();
     bool resetOffsets();
     bool snapTurnLeft();
@@ -111,6 +112,7 @@ private:
     DigitalAction m_swapSpaceDragToLeftHandOverride;
     DigitalAction m_swapSpaceDragToRightHandOverride;
     DigitalAction m_gravityToggle;
+    DigitalAction m_gravityReverse;
     DigitalAction m_heightToggle;
     DigitalAction m_resetOffsets;
     DigitalAction m_snapTurnLeft;
@@ -164,6 +166,7 @@ namespace action_keys
     constexpr auto k_actionSwapSpaceDragToRightHandOverride
         = "/actions/main/in/SwapSpaceDragToRightHandOverride";
     constexpr auto k_actionGravityToggle = "/actions/main/in/GravityToggle";
+    constexpr auto k_actionGravityReverse = "/actions/main/in/GravityReverse";
     constexpr auto k_actionHeightToggle = "/actions/main/in/HeightToggle";
     constexpr auto k_actionResetOffsets = "/actions/main/in/ResetOffsets";
     constexpr auto k_actionSnapTurnLeft = "/actions/main/in/SnapTurnLeft";

src/overlaycontroller.cpp

@@ -496,7 +496,7 @@ void OverlayController::processMediaKeyBindings()
     }
 }
 
-void OverlayController::processRoomBindings()
+void OverlayController::processMotionBindings()
 {
     // Execution order for moveCenterTabController actions is important. Don't
     // reorder these. Override actions must always come after normal because
@@ -511,6 +511,8 @@ void OverlayController::processRoomBindings()
     m_moveCenterTabController.rightHandSpaceTurn(
         m_actions.rightHandSpaceTurn() );
     m_moveCenterTabController.gravityToggleAction( m_actions.gravityToggle() );
+    m_moveCenterTabController.gravityReverseAction(
+        m_actions.gravityReverse() );
     m_moveCenterTabController.heightToggleAction( m_actions.heightToggle() );
     m_moveCenterTabController.resetOffsets( m_actions.resetOffsets() );
     m_moveCenterTabController.snapTurnLeft( m_actions.snapTurnLeft() );
@@ -563,7 +565,7 @@ void OverlayController::processInputBindings()
 {
     processMediaKeyBindings();
 
-    processRoomBindings();
+    processMotionBindings();
 
     processPushToTalkBindings();
 }

src/overlaycontroller.h

@@ -126,7 +126,7 @@ private:
     QPoint getMousePositionForEvent( vr::VREvent_Mouse_t mouse );
     void processInputBindings();
     void processMediaKeyBindings();
-    void processRoomBindings();
+    void processMotionBindings();
     void processPushToTalkBindings();
 
 public:

src/package_files/action_manifest.json

@@ -102,6 +102,11 @@
       "requirement": "optional",
       "type": "boolean"
     },
+    {
+      "name": "/actions/main/in/GravityReverse",
+      "requirement": "optional",
+      "type": "boolean"
+    },
     {
       "name": "/actions/main/in/HeightToggle",
       "requirement": "optional",
@@ -172,6 +177,7 @@
         "/actions/main/in/SwapSpaceDragToLeftHandOverride" : "Swap Active Space Drag to Left Hand (Override)",
         "/actions/main/in/SwapSpaceDragToRightHandOverride" : "Swap Active Space Drag to Right Hand (Override)",
         "/actions/main/in/GravityToggle" : "Gravity Toggle",
+        "/actions/main/in/GravityReverse" : "Gravity Reverse",
         "/actions/main/in/HeightToggle" : "Height Toggle",
         "/actions/main/in/ResetOffsets" : "Reset Offsets",
         "/actions/main/in/SnapTurnLeft" : "Snap-Turn Left",

src/res/qml/motion_page/MotionPage.qml

@@ -3,9 +3,10 @@ import QtQuick.Controls 2.0
 import QtQuick.Layouts 1.3
 import ovras.advsettings 1.0
 import "../common"
-import "universe_drag"
+import "space_drag"
-import "universe_turn"
+import "space_turn"
 import "height_toggle"
+import "gravity"
 
 MyStackViewPage {
     headerText: "Motion Settings"
@@ -13,12 +14,14 @@ MyStackViewPage {
     content: ColumnLayout {
         spacing: 18
 
-        UniverseDragGroupBox { id: universeDragGroupBox }
+        SpaceDragGroupBox { id: spaceDragGroupBox }
 
-        UniverseTurnGroupBox { id: universeTurnGroupBox }
+        SpaceTurnGroupBox { id: spaceTurnGroupBox }
 
         HeightToggleGroupBox { id: heightToggleGroupBox }
 
+        GravityGroupBox { id: gravityGroupBox }
+
         Item {
             Layout.fillHeight: true
         }

src/res/qml/motion_page/gravity/GravityGroupBox.qml

@@ -0,0 +1,172 @@
+import QtQuick 2.7
+import QtQuick.Controls 2.0
+import QtQuick.Layouts 1.3
+import ovras.advsettings 1.0
+import "../../common"
+
+GroupBox {
+    id: gravityGroupBox
+    Layout.fillWidth: true
+
+    label: MyText {
+        leftPadding: 10
+        text: "Gravity Settings"
+        bottomPadding: -10
+    }
+    background: Rectangle {
+        color: "transparent"
+        border.color: "#ffffff"
+        radius: 8
+    }
+
+    ColumnLayout {
+        anchors.fill: parent
+
+        Rectangle {
+            color: "#ffffff"
+            height: 1
+            Layout.fillWidth: true
+            Layout.bottomMargin: 5
+        }
+
+        RowLayout {
+            Layout.fillWidth: true
+
+            MyToggleButton {
+                id: gravityToggleButton
+                text: "On"
+                onCheckedChanged: {
+                    MoveCenterTabController.gravityActive = this.checked
+                }
+            }
+
+            Item {
+                Layout.fillWidth: true
+            }
+
+            MyText {
+                text: "Gravity Strength (+ is down):"
+                horizontalAlignment: Text.AlignRight
+                Layout.rightMargin: 10
+            }
+
+            MyTextField {
+                id: gravityStrengthText
+                text: "9.80"
+                keyBoardUID: 152
+                Layout.preferredWidth: 120
+                Layout.leftMargin: 10
+                Layout.rightMargin: 10
+                horizontalAlignment: Text.AlignHCenter
+                function onInputEvent(input) {
+                    var val = parseFloat(input)
+                    if (!isNaN(val)) {
+                        MoveCenterTabController.gravityStrength = val.toFixed(2)
+                        text = MoveCenterTabController.gravityStrength.toFixed(2)
+                    } else {
+                        text = MoveCenterTabController.gravityStrengtht.toFixed(2)
+                    }
+                }
+            }
+
+            MyPushButton {
+                id: gravityMoonButton
+                Layout.preferredWidth: 110
+                text:"Moon"
+                onClicked: {
+                    MoveCenterTabController.gravityStrength = 1.62
+                }
+           }
+            MyPushButton {
+                id: gravityMarsButton
+                Layout.preferredWidth: 110
+                text:"Mars"
+                onClicked: {
+                    MoveCenterTabController.gravityStrength = 3.71
+                }
+           }
+            MyPushButton {
+                id: gravityEarthButton
+                Layout.preferredWidth: 110
+                text:"Earth"
+                onClicked: {
+                    MoveCenterTabController.gravityStrength = 9.80
+                }
+           }
+            MyPushButton {
+                id: gravityJupiterButton
+                Layout.preferredWidth: 110
+                text:"Jupiter"
+                onClicked: {
+                    MoveCenterTabController.gravityStrength = 24.79
+                }
+           }
+        }
+        RowLayout {
+            Layout.fillWidth: true
+
+            MyToggleButton {
+                id: momentumToggleButton
+                text: "Save Momentum"
+                onCheckedChanged: {
+                    MoveCenterTabController.momentumSave = this.checked
+                }
+            }
+
+            Item {
+                Layout.fillWidth: true
+            }
+
+            MyText {
+                text: "Fling Strength"
+                horizontalAlignment: Text.AlignRight
+                Layout.rightMargin: 10
+            }
+
+            MyTextField {
+                id: flingStrengthText
+                text: "1.00"
+                keyBoardUID: 153
+                Layout.preferredWidth: 120
+                Layout.leftMargin: 10
+                Layout.rightMargin: 10
+                horizontalAlignment: Text.AlignHCenter
+                function onInputEvent(input) {
+                    var val = parseFloat(input)
+                    if (!isNaN(val)) {
+                        MoveCenterTabController.flingStrength = val.toFixed(2)
+                        text = MoveCenterTabController.flingStrength.toFixed(2)
+                    } else {
+                        text = MoveCenterTabController.flingStrength.toFixed(2)
+                    }
+                }
+            }
+
+
+        }
+    }
+
+    Component.onCompleted: {
+        gravityToggleButton.checked = MoveCenterTabController.gravityActive
+        gravityStrengthText.text = MoveCenterTabController.gravityStrength.toFixed(2)
+        momentumToggleButton.checked = MoveCenterTabController.momentumSave
+        flingStrengthText.text = MoveCenterTabController.flingStrength.toFixed(2)
+    }
+
+    Connections {
+        target: MoveCenterTabController
+
+        onGravityActiveChanged: {
+            gravityToggleButton.checked = MoveCenterTabController.gravityActive
+        }
+        onGravityStrengthChanged: {
+            gravityStrengthText.text = MoveCenterTabController.gravityStrength.toFixed(2)
+        }
+        onMomentumSaveChanged: {
+            momentumToggleButton.checked = MoveCenterTabController.momentumSave
+        }
+        onFlingStrengthChanged: {
+            flingStrengthText.text = MoveCenterTabController.flingStrength.toFixed(2)
+        }
+    }
+}

src/res/qml/motion_page/space_drag/SpaceDragGroupBox.qml

@@ -5,12 +5,12 @@ import ovras.advsettings 1.0
 import "../../common"
 
 GroupBox {
-    id: universeDragGroupBox
+    id: spaceDragGroupBox
     Layout.fillWidth: true
 
     label: MyText {
         leftPadding: 10
-        text: "Universe Drag"
+        text: "Space Drag"
         bottomPadding: -10
     }
     background: Rectangle {

src/res/qml/motion_page/space_turn/SpaceTurnGroupBox.qml

@@ -5,12 +5,12 @@ import ovras.advsettings 1.0
 import "../../common"
 
 GroupBox {
-    id: universeTurnGroupBox
+    id: spaceTurnGroupBox
     Layout.fillWidth: true
 
     label: MyText {
         leftPadding: 10
-        text: "Universe Turn"
+        text: "Space Turn"
         bottomPadding: -10
     }
     background: Rectangle {

src/tabcontrollers/MoveCenterTabController.cpp

@@ -88,6 +88,21 @@ void MoveCenterTabController::initStage1()
     {
         m_heightToggleOffset = value.toFloat();
     }
+    value = settings->value( "gravityStrength", m_gravityStrength );
+    if ( value.isValid() && !value.isNull() )
+    {
+        m_gravityStrength = value.toFloat();
+    }
+    value = settings->value( "flingStrength", m_flingStrength );
+    if ( value.isValid() && !value.isNull() )
+    {
+        m_flingStrength = value.toFloat();
+    }
+    value = settings->value( "momentumSave", m_momentumSave );
+    if ( value.isValid() && !value.isNull() )
+    {
+        m_momentumSave = value.toBool();
+    }
     value = settings->value( "lockXToggle", m_lockXToggle );
     if ( value.isValid() && !value.isNull() )
     {
@@ -459,6 +474,97 @@ void MoveCenterTabController::setHeightToggleOffset( float value, bool notify )
     }
 }
 
+float MoveCenterTabController::gravityStrength() const
+{
+    return m_gravityStrength;
+}
+
+void MoveCenterTabController::setGravityStrength( float value, bool notify )
+{
+    m_gravityStrength = value;
+    auto settings = OverlayController::appSettings();
+    settings->beginGroup( "playspaceSettings" );
+    settings->setValue( "gravityStrength", m_gravityStrength );
+    settings->endGroup();
+    settings->sync();
+    if ( notify )
+    {
+        emit gravityStrengthChanged( m_gravityStrength );
+    }
+}
+
+float MoveCenterTabController::flingStrength() const
+{
+    return m_flingStrength;
+}
+
+void MoveCenterTabController::setFlingStrength( float value, bool notify )
+{
+    m_flingStrength = value;
+    auto settings = OverlayController::appSettings();
+    settings->beginGroup( "playspaceSettings" );
+    settings->setValue( "flingStrength", m_flingStrength );
+    settings->endGroup();
+    settings->sync();
+    if ( notify )
+    {
+        emit flingStrengthChanged( m_flingStrength );
+    }
+}
+
+bool MoveCenterTabController::gravityActive() const
+{
+    return m_gravityActive;
+}
+
+void MoveCenterTabController::setGravityActive( bool value, bool notify )
+{
+    // skip if there's no change
+    if ( m_gravityActive == value )
+    {
+        return;
+    }
+
+    // detect new activate
+    if ( !m_gravityActive && value )
+    {
+        // zero out velocity if we aren't saving previous momentum
+        if ( !m_momentumSave )
+        {
+            m_velocity[0] = 0.0;
+            m_velocity[1] = 0.0;
+            m_velocity[2] = 0.0;
+        }
+        // make sure our time slice calculation doesn't use a slice from the
+        // previous activation of gravity
+        m_lastGravityUpdateTimePoint = std::chrono::steady_clock::now();
+    }
+    m_gravityActive = value;
+    if ( notify )
+    {
+        emit gravityActiveChanged( m_gravityActive );
+    }
+}
+
+bool MoveCenterTabController::momentumSave() const
+{
+    return m_momentumSave;
+}
+
+void MoveCenterTabController::setMomentumSave( bool value, bool notify )
+{
+    m_momentumSave = value;
+    auto settings = OverlayController::appSettings();
+    settings->beginGroup( "playspaceSettings" );
+    settings->setValue( "momentumSave", m_momentumSave );
+    settings->endGroup();
+    settings->sync();
+    if ( notify )
+    {
+        emit momentumSaveChanged( m_momentumSave );
+    }
+}
+
 bool MoveCenterTabController::lockXToggle() const
 {
     return m_lockXToggle;
@@ -518,7 +624,6 @@ void MoveCenterTabController::setLockZ( bool value, bool notify )
 
 void MoveCenterTabController::modOffsetX( float value, bool notify )
 {
-    // TODO ? possible issue with locking position this way
     if ( !m_lockXToggle )
     {
         m_offsetX += value;
@@ -1229,15 +1334,25 @@ void MoveCenterTabController::gravityToggleAction(
 
     if ( !m_gravityActive )
     {
-        m_gravityActive = true;
+        setGravityActive( true );
-        m_lastGravityUpdateTimePoint = std::chrono::steady_clock::now();
     }
     else
     {
-        m_gravityActive = false;
+        setGravityActive( false );
     }
 }
 
+void MoveCenterTabController::gravityReverseAction( bool gravityReverseHeld )
+{
+    // detect new press or new release
+    if ( ( gravityReverseHeld && !m_gravityReversed )
+         || ( !gravityReverseHeld && m_gravityReversed ) )
+    {
+        setGravityStrength( m_gravityStrength * -1.0f );
+    }
+    m_gravityReversed = gravityReverseHeld;
+}
+
 void MoveCenterTabController::heightToggleAction( bool heightToggleJustPressed )
 {
     if ( !heightToggleJustPressed )
@@ -1500,9 +1615,12 @@ void MoveCenterTabController::updateHandDrag(
                                              - m_lastDragUpdateTimePoint )
                   .count();
 
-        m_velocity[0] = diff[0] / secondsSinceLastDragUpdate;
+        m_velocity[0] = ( diff[0] / secondsSinceLastDragUpdate )
-        m_velocity[1] = diff[1] / secondsSinceLastDragUpdate;
+                        * static_cast<double>( m_flingStrength );
-        m_velocity[2] = diff[2] / secondsSinceLastDragUpdate;
+        m_velocity[1] = ( diff[1] / secondsSinceLastDragUpdate )
+                        * static_cast<double>( m_flingStrength );
+        m_velocity[2] = ( diff[2] / secondsSinceLastDragUpdate )
+                        * static_cast<double>( m_flingStrength );
     }
     m_lastControllerPosition[0] = absoluteControllerPosition[0];
     m_lastControllerPosition[1] = absoluteControllerPosition[1];
@@ -1634,13 +1752,16 @@ void MoveCenterTabController::updateGravity()
 
     // are we falling?
     // note: up is negative y
-    if ( m_offsetY < m_gravityFloor )
+    // note: set to always fall if gravity reversed (strength < 0)
+    if ( ( m_offsetY < m_gravityFloor ) || ( m_gravityStrength < 0 ) )
     {
         // check if we're about to land
-        if ( m_offsetY
+        // note: we don't land if gravity is reversed (strength < 0)
-                 + static_cast<float>( m_velocity[1]
+        if ( ( m_offsetY
-                                       * secondsSinceLastGravityUpdate )
+                   + static_cast<float>( m_velocity[1]
-             >= m_gravityFloor )
+                                         * secondsSinceLastGravityUpdate )
+               >= m_gravityFloor )
+             && m_gravityStrength >= 0 )
         {
             // get ratio of how much from y velocity applied to overcome y
             // offset and get down to ground.
@@ -1680,8 +1801,9 @@ void MoveCenterTabController::updateGravity()
 
             // accelerate downward velocity for the next update
             // note: downward is positive y
-            m_velocity[1]
+            m_velocity[1] = m_velocity[1]
-                = m_velocity[1] + ( 9.8 * secondsSinceLastGravityUpdate );
+                            + ( static_cast<double>( m_gravityStrength )
+                                * secondsSinceLastGravityUpdate );
             return;
         }
     }
@@ -1868,42 +1990,60 @@ void MoveCenterTabController::eventLoopTick(
             m_hmdRotationStatsUpdateCounter++;
         }
 
-        // Smooth turn motion can cause sim-sickness so we check if the user
+        // only update dynamic motion if the dash is closed
-        // wants to skip frames to reduce vection. We use the factor squared
+        if ( !parent->isDashboardVisible() )
-        // because of logarithmic human perception.
-        if ( m_turnComfortFrameSkipCounter
-             >= ( m_turnComfortFactor * m_turnComfortFactor ) )
         {
-            updateHandTurn( devicePoses, angle );
+            // detect new dash closed
-            m_turnComfortFrameSkipCounter = 0;
+            if ( m_dashWasOpenPreviousFrame )
+            {
+                // reset velocity time points on dash closed so we don't factor
+                // in the time motion was paused during the open dash
+                m_lastDragUpdateTimePoint = std::chrono::steady_clock::now();
+                m_lastGravityUpdateTimePoint = std::chrono::steady_clock::now();
+            }
+
+            // Smooth turn motion can cause sim-sickness so we check if the user
+            // wants to skip frames to reduce vection. We use the factor squared
+            // because of logarithmic human perception.
+            if ( m_turnComfortFrameSkipCounter
+                 >= ( m_turnComfortFactor * m_turnComfortFactor ) )
+            {
+                updateHandTurn( devicePoses, angle );
+                m_turnComfortFrameSkipCounter = 0;
+            }
+            else
+            {
+                m_turnComfortFrameSkipCounter++;
+            }
+
+            // Smooth drag motion can cause sim-sickness so we check if the user
+            // wants to skip frames to reduce vection. We use the factor squared
+            // because of logarithmic human perception.
+            if ( m_dragComfortFrameSkipCounter
+                 >= ( m_dragComfortFactor * m_dragComfortFactor ) )
+            {
+                updateHandDrag( devicePoses, angle );
+                m_lastDragUpdateTimePoint = std::chrono::steady_clock::now();
+                m_dragComfortFrameSkipCounter = 0;
+            }
+            else
+            {
+                m_dragComfortFrameSkipCounter++;
+            }
+
+            if ( m_gravityActive
+                 && m_activeDragHand == vr::TrackedControllerRole_Invalid )
+            {
+                updateGravity();
+                m_lastGravityUpdateTimePoint = std::chrono::steady_clock::now();
+            }
+            m_dashWasOpenPreviousFrame = false;
         }
         else
         {
-            m_turnComfortFrameSkipCounter++;
+            // dash is open this frame
+            m_dashWasOpenPreviousFrame = true;
         }
-
-        // Smooth drag motion can cause sim-sickness so we check if the user
-        // wants to skip frames to reduce vection. We use the factor squared
-        // because of logarithmic human perception.
-        if ( m_dragComfortFrameSkipCounter
-             >= ( m_dragComfortFactor * m_dragComfortFactor ) )
-        {
-            updateHandDrag( devicePoses, angle );
-            m_lastDragUpdateTimePoint = std::chrono::steady_clock::now();
-            m_dragComfortFrameSkipCounter = 0;
-        }
-        else
-        {
-            m_dragComfortFrameSkipCounter++;
-        }
-
-        if ( m_gravityActive
-             && m_activeDragHand == vr::TrackedControllerRole_Invalid )
-        {
-            updateGravity();
-            m_lastGravityUpdateTimePoint = std::chrono::steady_clock::now();
-        }
-
         updateSpace();
     }
 }

src/tabcontrollers/MoveCenterTabController.h

@@ -52,6 +52,14 @@ class MoveCenterTabController : public QObject
                     heightToggleChanged )
     Q_PROPERTY( float heightToggleOffset READ heightToggleOffset WRITE
                     setHeightToggleOffset NOTIFY heightToggleOffsetChanged )
+    Q_PROPERTY( float gravityStrength READ gravityStrength WRITE
+                    setGravityStrength NOTIFY gravityStrengthChanged )
+    Q_PROPERTY( float flingStrength READ flingStrength WRITE setFlingStrength
+                    NOTIFY flingStrengthChanged )
+    Q_PROPERTY( bool gravityActive READ gravityActive WRITE setGravityActive
+                    NOTIFY gravityActiveChanged )
+    Q_PROPERTY( bool momentumSave READ momentumSave WRITE setMomentumSave NOTIFY
+                    momentumSaveChanged )
     Q_PROPERTY( bool lockXToggle READ lockXToggle WRITE setLockX NOTIFY
                     requireLockXChanged )
     Q_PROPERTY( bool lockYToggle READ lockYToggle WRITE setLockY NOTIFY
@@ -90,6 +98,9 @@ private:
     bool m_heightToggle = false;
     float m_heightToggleOffset = -1.0f;
     float m_gravityFloor = 0.0f;
+    float m_gravityStrength = 9.8f;
+    float m_flingStrength = 1.0f;
+    bool m_momentumSave = false;
     bool m_lockXToggle = false;
     bool m_lockYToggle = false;
     bool m_lockZToggle = false;
@@ -123,8 +134,10 @@ private:
     bool m_swapDragToLeftHandActivated = false;
     bool m_swapDragToRightHandActivated = false;
     bool m_gravityActive = false;
+    bool m_gravityReversed = false;
     bool m_chaperoneCommitted = true;
     bool m_pendingZeroOffsets = true;
+    bool m_dashWasOpenPreviousFrame = false;
     unsigned settingsUpdateCounter = 0;
     int m_hmdRotationStatsUpdateCounter = 0;
     unsigned m_dragComfortFrameSkipCounter = 0;
@@ -170,6 +183,10 @@ public:
     unsigned turnComfortFactor() const;
     bool heightToggle() const;
     float heightToggleOffset() const;
+    float gravityStrength() const;
+    float flingStrength() const;
+    bool gravityActive() const;
+    bool momentumSave() const;
     bool lockXToggle() const;
     bool lockYToggle() const;
     bool lockZToggle() const;
@@ -188,6 +205,7 @@ public:
     void swapSpaceDragToLeftHandOverride( bool swapDragToLeftHandActive );
     void swapSpaceDragToRightHandOverride( bool swapDragToRightHandActive );
     void gravityToggleAction( bool gravityToggleJustPressed );
+    void gravityReverseAction( bool gravityReverseHeld );
     void heightToggleAction( bool heightToggleJustPressed );
     void resetOffsets( bool resetOffsetsJustPressed );
     void snapTurnLeft( bool snapTurnLeftJustPressed );
@@ -220,6 +238,10 @@ public slots:
     void setTurnComfortFactor( unsigned value, bool notify = true );
     void setHeightToggle( bool value, bool notify = true );
     void setHeightToggleOffset( float value, bool notify = true );
+    void setGravityStrength( float value, bool notify = true );
+    void setFlingStrength( float value, bool notify = true );
+    void setGravityActive( bool value, bool notify = true );
+    void setMomentumSave( bool value, bool notify = true );
 
     void modOffsetX( float value, bool notify = true );
     void modOffsetY( float value, bool notify = true );
@@ -249,6 +271,10 @@ signals:
     void turnComfortFactorChanged( unsigned value );
     void heightToggleChanged( bool value );
     void heightToggleOffsetChanged( float value );
+    void gravityStrengthChanged( float value );
+    void flingStrengthChanged( float value );
+    void gravityActiveChanged( bool value );
+    void momentumSaveChanged( bool value );
     void requireLockXChanged( bool value );
     void requireLockYChanged( bool value );
     void requireLockZChanged( bool value );