implement the api updates and bump the senseglove libraries to v2.101.2-2eb7439f

Source/SenseGloveCore/Private/SGCore/SGHandLayer.cpp

@@ -132,14 +132,29 @@ void FSGHandLayer::GetWristLocation(
     OutWristRotation = MoveTemp(OutWristRotationContainer.Quat);
 }
 
+void FSGHandLayer::StopAllHaptics(const bool bRightHanded)
+{
+    SGCoreImpl_FSGHandLayerImpl_StopAllHaptics(bRightHanded);
+}
+
 bool FSGHandLayer::SendHaptics(const bool bRightHanded)
 {
     return SGCoreImpl_FSGHandLayerImpl_SendHaptics(bRightHanded);
 }
 
-void FSGHandLayer::StopAllHaptics(const bool bRightHanded)
+bool FSGHandLayer::SupportsCustomWaveform(
+    const bool bRightHanded, const ESGHapticLocation AtLocation)
 {
-    SGCoreImpl_FSGHandLayerImpl_StopAllHaptics(bRightHanded);
+    FSGIC_ESGHapticLocation AtLocationContainer{AtLocation};
+    return SGCoreImpl_FSGHandLayerImpl_SupportsCustomWaveform(bRightHanded, &AtLocationContainer);
+}
+
+bool FSGHandLayer::SendCustomWaveform(
+    const bool bRightHanded, USGCustomWaveform* OutWaveform, const ESGHapticLocation Location)
+{
+    FSGIC_FSGCustomWaveformImpl OutWaveformContainer{OutWaveform->ToCustomWaveformImpl()};
+    FSGIC_ESGHapticLocation LocationContainer{Location};
+    return SGCoreImpl_FSGHandLayerImpl_SendCustomWaveform(bRightHanded, &OutWaveformContainer, &LocationContainer);
 }
 
 bool FSGHandLayer::QueueCommand_ForceFeedbackLevel(
@@ -156,32 +171,26 @@ bool FSGHandLayer::QueueCommand_ForceFeedbackLevels(
         bRightHanded, &Levels01Container, bSendImmediate);
 }
 
-bool FSGHandLayer::QueueCommand_SetVibroLevel(
-    const bool bRightHanded, const int32 Finger, const float Level01, const bool bSendImmediate)
-{
-    return SGCoreImpl_FSGHandLayerImpl_QueueCommand_SetVibroLevel(bRightHanded, Finger, Level01, bSendImmediate);
-}
-
-bool FSGHandLayer::QueueCommand_SetVibroLevels(
+bool FSGHandLayer::QueueCommand_VibroLevels(
     const bool bRightHanded, const TArray<float>& Levels01, const bool bSendImmediate)
 {
     FSGIC_TArray_float Levels01Container{Levels01};
-    return SGCoreImpl_FSGHandLayerImpl_QueueCommand_SetVibroLevels(bRightHanded, &Levels01Container, bSendImmediate);
+    return SGCoreImpl_FSGHandLayerImpl_QueueCommand_VibroLevels(bRightHanded, &Levels01Container, bSendImmediate);
 }
 
-bool FSGHandLayer::SupportsCustomWaveform(
-    const bool bRightHanded, const ESGHapticLocation AtLocation)
+bool FSGHandLayer::QueueCommand_VibroLevel(
+    const bool bRightHanded, const int32 Finger, const float Level01, const bool bSendImmediate)
+{
+    return SGCoreImpl_FSGHandLayerImpl_QueueCommand_VibroLevel_bRightHanded_Finger_Level0_bSendImmediate(
+        bRightHanded, Finger, Level01, bSendImmediate);
+}
+
+bool FSGHandLayer::QueueCommand_VibroLevel(
+    const bool bRightHanded, const ESGHapticLocation AtLocation, const float Level01, const bool bSendImmediate)
 {
     FSGIC_ESGHapticLocation AtLocationContainer{AtLocation};
-    return SGCoreImpl_FSGHandLayerImpl_SupportsCustomWaveform(bRightHanded, &AtLocationContainer);
-}
-
-bool FSGHandLayer::SendCustomWaveform(
-    const bool bRightHanded, USGCustomWaveform* OutWaveform, const ESGHapticLocation Location)
-{
-    FSGIC_FSGCustomWaveformImpl OutWaveformContainer{OutWaveform->ToCustomWaveformImpl()};
-    FSGIC_ESGHapticLocation LocationContainer{Location};
-    return SGCoreImpl_FSGHandLayerImpl_SendCustomWaveform(bRightHanded, &OutWaveformContainer, &LocationContainer);
+    return SGCoreImpl_FSGHandLayerImpl_QueueCommand_VibroLevel_bRightHanded_AtLocation_Level01_bSendImmediate(
+        bRightHanded, &AtLocationContainer, Level01, bSendImmediate);
 }
 
 bool FSGHandLayer::SupportsWristSqueeze(const bool bRightHanded)

Source/SenseGloveCore/Private/SGCore/SGHapticGlove.cpp

@@ -394,6 +394,20 @@ bool USGHapticGlove::QueueForceFeedbackLevel(const int32 Finger, const float Lev
     return SGCoreImpl_FSGHapticGloveImpl_QueueForceFeedbackLevel(&InstanceContainer, Finger, Level01);
 }
 
+bool USGHapticGlove::QueueVibroLevels(const TArray<float>& Levels01)
+{
+    FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
+    FSGIC_TArray_float Levels01Container{Levels01};
+    return SGCoreImpl_FSGHapticGloveImpl_QueueVibroLevels(&InstanceContainer, &Levels01Container);
+}
+
+bool USGHapticGlove::QueueVibroLevel(const ESGHapticLocation Location, const float Level01)
+{
+    FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
+    FSGIC_ESGHapticLocation LocationContainer{Location};
+    return SGCoreImpl_FSGHapticGloveImpl_QueueVibroLevel(&InstanceContainer, &LocationContainer, Level01);
+}
+
 bool USGHapticGlove::SupportsCustomWaveform(const ESGHapticLocation AtLocation) const
 {
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};

Source/SenseGloveCore/Private/SGCore/SGNova2Glove.cpp

@@ -531,6 +531,20 @@ bool USGNova2Glove::QueueForceFeedbackLevel(const int32 Finger, const float Leve
     return SGCoreImpl_FSGNova2GloveImpl_QueueForceFeedbackLevel(&InstanceContainer, Finger, Level01);
 }
 
+bool USGNova2Glove::QueueVibroLevels(const TArray<float>& Amplitudes)
+{
+    FSGIC_TSharedPtr_FSGNova2GloveImpl InstanceContainer{ToNova2GloveImpl()};
+    FSGIC_TArray_float AmplitudesContainer{Amplitudes};
+    return SGCoreImpl_FSGNova2GloveImpl_QueueVibroLevels(&InstanceContainer, &AmplitudesContainer);
+}
+
+bool USGNova2Glove::QueueVibroLevel(const ESGHapticLocation Location, const float Level01)
+{
+    FSGIC_TSharedPtr_FSGNova2GloveImpl InstanceContainer{ToNova2GloveImpl()};
+    FSGIC_ESGHapticLocation LocationContainer{Location};
+    return SGCoreImpl_FSGNova2GloveImpl_QueueVibroLevel(&InstanceContainer, &LocationContainer, Level01);
+}
+
 bool USGNova2Glove::QueueSqueezeLevel(const float SqueezeLevel01)
 {
     FSGIC_TSharedPtr_FSGNova2GloveImpl InstanceContainer{ToNova2GloveImpl()};

Source/SenseGloveCore/Private/SGCore/SGNovaGlove.cpp

@@ -551,6 +551,21 @@ bool USGNovaGlove::QueueForceFeedbackLevel(const int32 Finger, const float Level
     return SGCoreImpl_FSGNovaGloveImpl_QueueForceFeedbackLevel(&InstanceContainer, Finger, Level01);
 }
 
+bool USGNovaGlove::QueueVibroLevels(const TArray<float>& Amplitudes)
+{
+    FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
+    FSGIC_TArray_float AmplitudesContainer{Amplitudes};
+    return SGCoreImpl_FSGNovaGloveImpl_QueueVibroLevels(&InstanceContainer, &AmplitudesContainer);
+}
+
+bool USGNovaGlove::QueueVibroLevel(ESGHapticLocation Location, float Level01)
+{
+    FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
+    FSGIC_ESGHapticLocation LocationContainer{Location};
+    return SGCoreImpl_FSGNovaGloveImpl_QueueVibroLevel_Localtion_Level01(
+        &InstanceContainer, &LocationContainer, Level01);
+}
+
 void USGNovaGlove::GetGloveLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
                                     const ESGPositionalTrackingHardware TrackingHardware,
                                     FVector& OutGlovePosition, FQuat& OutGloveRotation) const
@@ -701,17 +716,10 @@ FString USGNovaGlove::ToNovaCommand(
     return MoveTemp(OutStringContainer.String);
 }
 
-bool USGNovaGlove::QueueVibroLevels(const TArray<float>& Amplitudes)
-{
-    FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
-    FSGIC_TArray_float AmplitudesContainer{Amplitudes};
-    return SGCoreImpl_FSGNovaGloveImpl_QueueVibroLevels(&InstanceContainer, &AmplitudesContainer);
-}
-
 bool USGNovaGlove::QueueVibroLevel(const int32 Finger, const float Amplitude)
 {
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
-    return SGCoreImpl_FSGNovaGloveImpl_QueueVibroLevel(&InstanceContainer, Finger, Amplitude);
+    return SGCoreImpl_FSGNovaGloveImpl_QueueVibroLevel_Finger_Amplitude(&InstanceContainer, Finger, Amplitude);
 }
 
 bool USGNovaGlove::QueueWristLevel(const float Amplitude)

Source/SenseGloveCore/Private/SGCore/SGSenseGlove.cpp

@@ -52,6 +52,7 @@
 #include "SGInterop/SGIC_ESGDeviceType.h"
 #include "SGInterop/SGIC_ESGFinger.h"
 #include "SGInterop/SGIC_ESGHapticGloveCalibrationState.h"
+#include "SGInterop/SGIC_ESGHapticLocation.h"
 #include "SGInterop/SGIC_ESGPositionalTrackingHardware.h"
 #include "SGInterop/SGIC_ESGSenseGloveThumperCommand.h"
 #include "SGInterop/SGIC_FQuat.h"
@@ -535,6 +536,21 @@ bool USGSenseGlove::QueueForceFeedbackLevel(const int32 Finger, const float Leve
     return SGCoreImpl_FSGSenseGloveImpl_QueueForceFeedbackLevel(&InstanceContainer, Finger, Level01);
 }
 
+bool USGSenseGlove::QueueVibroLevels(const TArray<float>& Amplitudes)
+{
+    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
+    FSGIC_TArray_float AmplitudesContainer{Amplitudes};
+    return SGCoreImpl_FSGSenseGloveImpl_QueueVibroLevels(&InstanceContainer, &AmplitudesContainer);
+}
+
+bool USGSenseGlove::QueueVibroLevel(const ESGHapticLocation Location, const float Level01)
+{
+    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
+    FSGIC_ESGHapticLocation LocationContainer{Location};
+    return SGCoreImpl_FSGSenseGloveImpl_QueueVibroLevel_Location_Level01(
+        &InstanceContainer, &LocationContainer, Level01);
+}
+
 void USGSenseGlove::GetGloveLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
                                      const ESGPositionalTrackingHardware TrackingHardware,
                                      FVector& OutGlovePosition, FQuat& OutGloveRotation) const
@@ -790,17 +806,10 @@ bool USGSenseGlove::GetGlovePose(
     return bResult;
 }
 
-bool USGSenseGlove::QueueVibroLevels(const TArray<float>& Amplitudes)
-{
-    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
-    FSGIC_TArray_float AmplitudesContainer{Amplitudes};
-    return SGCoreImpl_FSGSenseGloveImpl_QueueVibroLevels(&InstanceContainer, &AmplitudesContainer);
-}
-
 bool USGSenseGlove::QueueVibroLevel(const int32 Finger, const float Amplitude)
 {
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
-    return SGCoreImpl_FSGSenseGloveImpl_QueueVibroLevel(&InstanceContainer, Finger, Amplitude);
+    return SGCoreImpl_FSGSenseGloveImpl_QueueVibroLevel_Finger_Amplitude(&InstanceContainer, Finger, Amplitude);
 }
 
 bool USGSenseGlove::QueueThumperCommand(ESGSenseGloveThumperCommand Command)

Source/SenseGloveCore/Private/SGCore/SGTracking.cpp

@@ -451,6 +451,48 @@ FRotator FSGTracking::GetLeftNovaViveFocus3ToAttachRotation()
     return OutRotationContainer.Quat.Rotator();
 }
 
+FVector FSGTracking::GetRightNovaQuest3ToAttachPosition()
+{
+    FSGIC_FVector OutPositionContainer;
+    SGCoreImpl_FSGTrackingImpl_GetRightNovaQuest3ToAttachPosition(&OutPositionContainer);
+    return MoveTemp(OutPositionContainer.Vector);
+}
+
+FQuat FSGTracking::GetRightNovaQuest3ToAttachRotationQ()
+{
+    FSGIC_FQuat OutRotationContainer;
+    SGCoreImpl_FSGTrackingImpl_GetRightNovaQuest3ToAttachRotation(&OutRotationContainer);
+    return MoveTemp(OutRotationContainer.Quat);
+}
+
+FRotator FSGTracking::GetRightNovaQuest3ToAttachRotation()
+{
+    FSGIC_FQuat OutRotationContainer;
+    SGCoreImpl_FSGTrackingImpl_GetRightNovaQuest3ToAttachRotation(&OutRotationContainer);
+    return OutRotationContainer.Quat.Rotator();
+}
+
+FVector FSGTracking::GetLeftNovaQuest3ToAttachPosition()
+{
+    FSGIC_FVector OutPositionContainer;
+    SGCoreImpl_FSGTrackingImpl_GetLeftNovaQuest3ToAttachPosition(&OutPositionContainer);
+    return MoveTemp(OutPositionContainer.Vector);
+}
+
+FQuat FSGTracking::GetLeftNovaQuest3ToAttachRotationQ()
+{
+    FSGIC_FQuat OutRotationContainer;
+    SGCoreImpl_FSGTrackingImpl_GetLeftNovaQuest3ToAttachRotation(&OutRotationContainer);
+    return MoveTemp(OutRotationContainer.Quat);
+}
+
+FRotator FSGTracking::GetLeftNovaQuest3ToAttachRotation()
+{
+    FSGIC_FQuat OutRotationContainer;
+    SGCoreImpl_FSGTrackingImpl_GetLeftNovaQuest3ToAttachRotation(&OutRotationContainer);
+    return OutRotationContainer.Quat.Rotator();
+}
+
 void FSGTracking::GetNovaGloveWristOffset(const bool bRightHanded, FVector& OutPositionOffset, FQuat& OutRotationOffset)
 {
     FSGIC_FVector OutPositionOffsetContainer;
@@ -686,6 +728,48 @@ FQuat FSGTracking::GetRightNova2ViveWristTrackerToAttachRotationQ()
     return MoveTemp(OutRotationContainer.Quat);
 }
 
+FVector FSGTracking::GetRightNova2Quest3ToAttachPosition()
+{
+    FSGIC_FVector OutPositionContainer;
+    SGCoreImpl_FSGTrackingImpl_GetRightNova2Quest3ToAttachPosition(&OutPositionContainer);
+    return MoveTemp(OutPositionContainer.Vector);
+}
+
+FQuat FSGTracking::GetRightNova2Quest3ToAttachRotationQ()
+{
+    FSGIC_FQuat OutRotationContainer;
+    SGCoreImpl_FSGTrackingImpl_GetRightNova2Quest3ToAttachRotation(&OutRotationContainer);
+    return MoveTemp(OutRotationContainer.Quat);
+}
+
+FRotator FSGTracking::GetRightNova2Quest3ToAttachRotation()
+{
+    FSGIC_FQuat OutRotationContainer;
+    SGCoreImpl_FSGTrackingImpl_GetRightNova2Quest3ToAttachRotation(&OutRotationContainer);
+    return OutRotationContainer.Quat.Rotator();
+}
+
+FVector FSGTracking::GetLeftNova2Quest3ToAttachPosition()
+{
+    FSGIC_FVector OutPositionContainer;
+    SGCoreImpl_FSGTrackingImpl_GetLeftNova2Quest3ToAttachPosition(&OutPositionContainer);
+    return MoveTemp(OutPositionContainer.Vector);
+}
+
+FQuat FSGTracking::GetLeftNova2Quest3ToAttachRotationQ()
+{
+    FSGIC_FQuat OutRotationContainer;
+    SGCoreImpl_FSGTrackingImpl_GetLeftNova2Quest3ToAttachRotation(&OutRotationContainer);
+    return MoveTemp(OutRotationContainer.Quat);
+}
+
+FRotator FSGTracking::GetLeftNova2Quest3ToAttachRotation()
+{
+    FSGIC_FQuat OutRotationContainer;
+    SGCoreImpl_FSGTrackingImpl_GetLeftNova2Quest3ToAttachRotation(&OutRotationContainer);
+    return OutRotationContainer.Quat.Rotator();
+}
+
 FRotator FSGTracking::GetRightNova2ViveWristTrackerToAttachRotation()
 {
     FSGIC_FQuat OutRotationContainer;

Source/SenseGloveCore/Public/SGCore/SGHandLayer.h

@@ -148,6 +148,13 @@ public:
         ESGPositionalTrackingHardware TrackingHardware,
         FVector& OutWristPosition, FQuat& OutWristRotation);
 
+    /**
+     * Stop all haptics on the chosen hand.
+     *
+     * @param bRightHanded
+     */
+    static void StopAllHaptics(bool bRightHanded);
+
     /**
      * Sends all haptics in the queue for the Left / Right hand.
      * @param bRightHanded
@@ -155,11 +162,21 @@ public:
     static bool SendHaptics(bool bRightHanded);
 
     /**
-     * Stop all haptics on the chosen hand.
+     * Returns true if the glove for this hand supports a custom waveform vibration on said location.
      *
      * @param bRightHanded
+     * @param AtLocation
      */
-    static void StopAllHaptics(bool bRightHanded);
+    static bool SupportsCustomWaveform(bool bRightHanded, ESGHapticLocation AtLocation);
+
+    /**
+     * Send a Custom Waveform to a glove at a specific location.
+     *
+     * @param bRightHanded
+     * @param OutWaveform
+     * @param Location
+     */
+    static bool SendCustomWaveform(bool bRightHanded, USGCustomWaveform* OutWaveform, ESGHapticLocation Location);
 
     /**
      * Tell a specific hand to hold the force-feedback at a certain level.
@@ -186,38 +203,33 @@ public:
      * DK1.0.
      *
      * @param bRightHanded
-     * @param Finger
-     * @param Level01
+     * @param Levels01
      * @param bSendImmediate
      */
-    static bool QueueCommand_SetVibroLevel(bool bRightHanded, int32 Finger, float Level01, bool bSendImmediate);
+    static bool QueueCommand_VibroLevels(bool bRightHanded, const TArray<float>& Levels01, bool bSendImmediate);
 
     /**
      * Queue a command to set the vibration level(s) of a Haptic Glove's finger. Note: This is only for Nova 1.0 and
      * DK1.0.
      *
      * @param bRightHanded
-     * @param Levels01
+     * @param Finger
+     * @param Level01
      * @param bSendImmediate
      */
-    static bool QueueCommand_SetVibroLevels(bool bRightHanded, const TArray<float>& Levels01, bool bSendImmediate);
+    static bool QueueCommand_VibroLevel(bool bRightHanded, int32 Finger, float Level01, bool bSendImmediate);
 
     /**
-     * Returns true if the glove for this hand supports a custom waveform vibration on said location.
+     * Queue a vibration level command for a specific HapticLocation. If the gloves has this vibration motor installed.
+     * Cross-compatible with Nova 2.0.
      *
      * @param bRightHanded
      * @param AtLocation
+     * @param Level01
+     * @param bSendImmediate
      */
-    static bool SupportsCustomWaveform(bool bRightHanded, ESGHapticLocation AtLocation);
-
-    /**
-     * Send a Custom Waveform to a glove at a specific location.
-     *
-     * @param bRightHanded
-     * @param OutWaveform
-     * @param Location
-     */
-    static bool SendCustomWaveform(bool bRightHanded, USGCustomWaveform* OutWaveform, ESGHapticLocation Location);
+    static bool QueueCommand_VibroLevel(
+            bool bRightHanded, ESGHapticLocation AtLocation, float Level01, bool bSendImmediate);
 
     /**
      * Returns true if the chosen glove supports active contact feedback on the Wrist.

Source/SenseGloveCore/Public/SGCore/SGHapticGlove.h

@@ -295,6 +295,22 @@ public:
     virtual bool SendHaptics();
 
 public:
+    /**
+     * Returns true if the HapticGlove supports vibration feedback on the specified location.
+     *
+     * @param AtLocation
+     */
+    virtual bool SupportsCustomWaveform(ESGHapticLocation AtLocation) const;
+
+    /**
+     * Sends a custom waveform to the location specified, provided that the glove has a motor there, and can support
+     * custom waveforms.
+     *
+     * @param OutWaveform
+     * @param Location
+     */
+    virtual bool SendCustomWaveform(USGCustomWaveform* OutWaveform, ESGHapticLocation Location);
+
     /**
      * Queue a list of force-feedback levels, between 0.0f and 1.0f. Your list should be sorted from thumb to pinky.
      *
@@ -315,20 +331,23 @@ public:
     virtual bool QueueForceFeedbackLevel(int32 Finger, float Level01);
 
     /**
-     * Returns true if the HapticGlove supports vibration feedback on the specified location.
+     * Queue a list of vibration levels, between 0.0 and 1.0. Your list should be sorted from thumb to pinky.
      *
-     * @param AtLocation
+     * @param Levels01 Array containing the vibration levels, from 0.0 (no vibration) to 1.0. A value < 0.0f will be
+     * ignored.
+     *
+     * @remarks Devices that 'only' have on/off FFB will treat any value > 0.0 as 1.0.
      */
-    virtual bool SupportsCustomWaveform(ESGHapticLocation AtLocation) const;
+    virtual bool QueueVibroLevels(const TArray<float>& Levels01);
 
     /**
-     * Sends a custom waveform to the location specified, provided that the glove has a motor there, and can support
-     * custom waveforms.
+     * Queue a command to set the (continuous) vibration level at a specific location to a set amplitude.
      *
-     * @param OutWaveform
      * @param Location
+     * @param Level01 Value will be clamped between [0...1], where 0.0f means no vibration, and 1.0 means full
+     * vibration.
      */
-    virtual bool SendCustomWaveform(USGCustomWaveform* OutWaveform, ESGHapticLocation Location);
+    virtual bool QueueVibroLevel(ESGHapticLocation Location, float Level01);
 
 public:
     /**

Source/SenseGloveCore/Public/SGCore/SGNova2Glove.h

@@ -420,6 +420,26 @@ public:
      */
     virtual bool QueueForceFeedbackLevel(int32 Finger, float Level01) override;
 
+    /**
+     * Queue a list of vibration levels, between 0.0 and 1.0. Your list should be sorted from thumb to pinky.
+     *
+     * @param Amplitudes Array containing the vibration levels, from 0.0 (no vibration) to 1.0. A value < 0.0f will be
+     * ignored.
+     *
+     * @remarks Devices that 'only' have on/off FFB will treat any value > 0.0 as 1.0.
+     */
+    virtual bool QueueVibroLevels(const TArray<float>& Amplitudes) override;
+
+    /**
+     * Queue a command to set the (continuous) vibration level at a specific location to a set amplitude. This is to
+     * support backwards compatibility for older plugins. Use of Customwaveforms is encouraged.
+     *
+     * @param Location
+     * @param Level01 Value will be clamped between [0...1], where 0.0f means no vibration, and 1.0 means full
+     * vibration.
+     */
+    virtual bool QueueVibroLevel(ESGHapticLocation Location, float Level01) override;
+
     /**
      * Set the amount of squeeze-feedback to the desired level (0 = no squeeze, 1 = full squeeze).
      *

Source/SenseGloveCore/Public/SGCore/SGNovaGlove.h

@@ -440,6 +440,22 @@ public:
      */
     virtual bool QueueForceFeedbackLevel(int32 Finger, float Level01) override;
 
+    /**
+     * Queue a vibrotactile level for each finger.
+     *
+     * @param Amplitudes
+     */
+    virtual bool QueueVibroLevels(const TArray<float>& Amplitudes) override;
+
+    /**
+     * Queue a command to set the (continuous) vibration level at a specific location to a set amplitude.
+     *
+     * @param Location
+     * @param Level01 Value will be clamped between [0...1], where 0.0f means no vibration, and 1.0 means full
+     * vibration.
+     */
+    virtual bool QueueVibroLevel(ESGHapticLocation Location, float Level01) override;
+
 public:
     /**
      * Retrieve the location of the glove origin, based on a reference location.
@@ -543,13 +559,6 @@ public:
     virtual FString ToNovaCommand(
         const TArray<float>& ForceFeedbackLevels, const TArray<float>& BuzzLevels, float WristLevel) const;
 
-    /**
-     * Queue a vibrotactile level for each finger.
-     *
-     * @param Amplitudes
-     */
-    virtual bool QueueVibroLevels(const TArray<float>& Amplitudes);
-
     /**
      * Queue a vibrotactle level for a specific finger.
      *

Source/SenseGloveCore/Public/SGCore/SGSenseGlove.h

@@ -423,6 +423,22 @@ public:
      */
     virtual bool QueueForceFeedbackLevel(int32 Finger, float Level01) override;
 
+    /**
+     * Queue a vibrotactile level for each finger.
+     *
+     * @param Amplitudes
+     */
+    virtual bool QueueVibroLevels(const TArray<float>& Amplitudes) override;
+
+    /**
+     * Queue a command to set the (continuous) vibration level at a specific location to a set amplitude.
+     *
+     * @param Location
+     * @param Level01 Value will be clamped between [0...1], where 0.0f means no vibration, and 1.0 means full
+     * vibration.
+     */
+    virtual bool QueueVibroLevel(ESGHapticLocation Location, float Level01) override;
+
 public:
     /**
      * Retrieve the location of the glove origin, based on a reference location.
@@ -582,13 +598,6 @@ public:
     bool GetGlovePose(UObject* Outer, const USGSenseGloveSensorData* SensorData, USGSenseGlovePose*& OutGlovePose);
 
 public:
-    /**
-     * Queue a vibrotactile level for each finger.
-     *
-     * @param Amplitudes
-     */
-    virtual bool QueueVibroLevels(const TArray<float>& Amplitudes);
-
     /**
      * Queue a vibrotactle level for a specific finger.
      *

Source/SenseGloveCore/Public/SGCore/SGTracking.h

@@ -319,6 +319,36 @@ public:
      */
     static FRotator GetLeftNovaViveFocus3ToAttachRotation();
 
+    /**
+     *
+     */
+    static FVector GetRightNovaQuest3ToAttachPosition();
+
+    /**
+     *
+     */
+    static FQuat GetRightNovaQuest3ToAttachRotationQ();
+
+    /**
+     *
+     */
+    static FRotator GetRightNovaQuest3ToAttachRotation();
+
+    /**
+     *
+     */
+    static FVector GetLeftNovaQuest3ToAttachPosition();
+
+    /**
+     *
+     */
+    static FQuat GetLeftNovaQuest3ToAttachRotationQ();
+
+    /**
+     *
+     */
+    static FRotator GetLeftNovaQuest3ToAttachRotation();
+
     /**
      * Returns the Offsets that will bring us from the Nova origin to the wrist position.
      */
@@ -503,6 +533,36 @@ public:
      */
     static FRotator GetLeftNova2ViveWristTrackerToAttachRotation();
 
+    /**
+     *
+     */
+    static FVector GetRightNova2Quest3ToAttachPosition();
+
+    /**
+     *
+     */
+    static FQuat GetRightNova2Quest3ToAttachRotationQ();
+
+    /**
+     *
+     */
+    static FRotator GetRightNova2Quest3ToAttachRotation();
+
+    /**
+     *
+     */
+    static FVector GetLeftNova2Quest3ToAttachPosition();
+
+    /**
+     *
+     */
+    static FQuat GetLeftNova2Quest3ToAttachRotationQ();
+
+    /**
+     *
+     */
+    static FRotator GetLeftNova2Quest3ToAttachRotation();
+
     /**
      * Returns the Offsets that will bring us from the Nova origin to the wrist position.
      *