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

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGCoreEnumCast.cpp

@@ -435,6 +435,8 @@ FSGCoreEnumCast::FEPositionalTrackingHardwareType FSGCoreEnumCast::ToEPositional
         return FEPositionalTrackingHardwareType::ViveFocus3WristTracker;
     case ESGPositionalTrackingHardware::QuestProController:
         return FEPositionalTrackingHardwareType::QuestProController;
+    case ESGPositionalTrackingHardware::Quest3Controller:
+        return FEPositionalTrackingHardwareType::Quest3Controller;
     default:
         ensureAlwaysMsgf(false, TEXT("Unhandled enum cast item!"));
         break;
@@ -459,6 +461,8 @@ ESGPositionalTrackingHardware FSGCoreEnumCast::ToESGPositionalTrackingHardware(
         return ESGPositionalTrackingHardware::ViveFocus3WristTracker;
     case FEPositionalTrackingHardwareType::QuestProController:
         return ESGPositionalTrackingHardware::QuestProController;
+    case FEPositionalTrackingHardwareType::Quest3Controller:
+        return ESGPositionalTrackingHardware::Quest3Controller;
     default:
         ensureAlwaysMsgf(false, TEXT("Unhandled enum cast item!"));
         break;

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGExportedFunctions.cpp

@@ -1188,9 +1188,9 @@ void SGCoreImpl_FSGDeviceImpl_GetFirmwareString(
 
 bool SGCoreImpl_FSGDeviceImpl_FirmwareNewerThan_MyFirmwareMain_MyFirmwareSub_bInclusive(
     void* Instance,
-    int32 MyFirmwareMain,
-    int32 MyFirmwareSub,
-    bool bInclusive)
+    const int32 MyFirmwareMain,
+    const int32 MyFirmwareSub,
+    const bool bInclusive)
 {
     return StaticCast<FSGIC_TSharedPtr_FSGDeviceImpl*>(Instance)->Ptr->FirmwareNewerThan(
         MyFirmwareMain,
@@ -1200,9 +1200,9 @@ bool SGCoreImpl_FSGDeviceImpl_FirmwareNewerThan_MyFirmwareMain_MyFirmwareSub_bIn
 
 bool SGCoreImpl_FSGDeviceImpl_FirmwareOlderThan_MyFirmwareMain_MyFirmwareSub_bInclusive(
     void* Instance,
-    int32 MyFirmwareMain,
-    int32 MyFirmwareSub,
-    bool bInclusive)
+    const int32 MyFirmwareMain,
+    const int32 MyFirmwareSub,
+    const bool bInclusive)
 {
     return StaticCast<FSGIC_TSharedPtr_FSGDeviceImpl*>(Instance)->Ptr->FirmwareOlderThan(
         MyFirmwareMain,
@@ -1539,11 +1539,12 @@ bool SGCoreImpl_FSGDeviceModelImpl_FirmwareOlderThan(
 void SGCoreImpl_FSGHandInterpolatorImpl_Deserialize(
     void* OutHandInterpolatorImpl,
     void* SerializedString,
-    bool bRightHanded)
+    const bool bRightHanded)
 {
     StaticCast<FSGIC_FSGHandInterpolatorImpl*>(OutHandInterpolatorImpl)->HandInterpolatorImpl =
         FSGHandInterpolatorImpl::Deserialize(
-            StaticCast<FSGIC_FString*>(SerializedString)->String);
+            StaticCast<FSGIC_FString*>(SerializedString)->String,
+            bRightHanded);
 }
 
 void SGCoreImpl_FSGHandInterpolatorImpl_ctor(
@@ -1727,6 +1728,13 @@ void SGCoreImpl_FSGHandLayerImpl_GetWristLocation(
         StaticCast<FSGIC_FQuat*>(OutWristRotation)->Quat);
 }
 
+void SGCoreImpl_FSGHandLayerImpl_StopAllHaptics(
+    const bool bRightHanded)
+{
+    FSGHandLayerImpl::StopAllHaptics(
+        bRightHanded);
+}
+
 bool SGCoreImpl_FSGHandLayerImpl_SendHaptics(
     const bool bRightHanded)
 {
@@ -1734,11 +1742,24 @@ bool SGCoreImpl_FSGHandLayerImpl_SendHaptics(
         bRightHanded);
 }
 
-void SGCoreImpl_FSGHandLayerImpl_StopAllHaptics(
-    const bool bRightHanded)
+bool SGCoreImpl_FSGHandLayerImpl_SupportsCustomWaveform(
+    const bool bRightHanded,
+    void* AtLocation)
 {
-    FSGHandLayerImpl::StopAllHaptics(
-        bRightHanded);
+    return FSGHandLayerImpl::SupportsCustomWaveform(
+        bRightHanded,
+        StaticCast<FSGIC_ESGHapticLocation*>(AtLocation)->Location);
+}
+
+bool SGCoreImpl_FSGHandLayerImpl_SendCustomWaveform(
+    const bool bRightHanded,
+    void* OutWaveform,
+    void* Location)
+{
+    return FSGHandLayerImpl::SendCustomWaveform(
+        bRightHanded,
+        StaticCast<FSGIC_FSGCustomWaveformImpl*>(OutWaveform)->CustomWaveformImpl,
+        StaticCast<FSGIC_ESGHapticLocation*>(Location)->Location);
 }
 
 bool SGCoreImpl_FSGHandLayerImpl_QueueCommand_ForceFeedbackLevel(
@@ -1765,50 +1786,43 @@ bool SGCoreImpl_FSGHandLayerImpl_QueueCommand_ForceFeedbackLevels(
         bSendImmediate);
 }
 
-bool SGCoreImpl_FSGHandLayerImpl_QueueCommand_SetVibroLevel(
+bool SGCoreImpl_FSGHandLayerImpl_QueueCommand_VibroLevels(
+    const bool bRightHanded,
+    void* Levels01,
+    const bool bSendImmediate)
+{
+    return FSGHandLayerImpl::QueueCommand_VibroLevels(
+        bRightHanded,
+        StaticCast<FSGIC_TArray_float*>(Levels01)->Array,
+        bSendImmediate);
+}
+
+bool SGCoreImpl_FSGHandLayerImpl_QueueCommand_VibroLevel_bRightHanded_Finger_Level0_bSendImmediate(
     const bool bRightHanded,
     const int32 Finger,
     const float Level01,
     const bool bSendImmediate)
 {
-    return FSGHandLayerImpl::QueueCommand_SetVibroLevel(
+    return FSGHandLayerImpl::QueueCommand_VibroLevel(
         bRightHanded,
         Finger,
         Level01,
         bSendImmediate);
 }
 
-bool SGCoreImpl_FSGHandLayerImpl_QueueCommand_SetVibroLevels(
+bool SGCoreImpl_FSGHandLayerImpl_QueueCommand_VibroLevel_bRightHanded_AtLocation_Level01_bSendImmediate(
     const bool bRightHanded,
-    void* Levels01,
+    void* AtLocation,
+    const float Level01,
     const bool bSendImmediate)
 {
-    return FSGHandLayerImpl::QueueCommand_SetVibroLevels(
+    return FSGHandLayerImpl::QueueCommand_VibroLevel(
         bRightHanded,
-        StaticCast<FSGIC_TArray_float*>(Levels01)->Array,
+        StaticCast<FSGIC_ESGHapticLocation*>(AtLocation)->Location,
+        Level01,
         bSendImmediate);
 }
 
-bool SGCoreImpl_FSGHandLayerImpl_SupportsCustomWaveform(
-    const bool bRightHanded,
-    void* AtLocation)
-{
-    return FSGHandLayerImpl::SupportsCustomWaveform(
-        bRightHanded,
-        StaticCast<FSGIC_ESGHapticLocation*>(AtLocation)->Location);
-}
-
-bool SGCoreImpl_FSGHandLayerImpl_SendCustomWaveform(
-    const bool bRightHanded,
-    void* OutWaveform,
-    void* Location)
-{
-    return FSGHandLayerImpl::SendCustomWaveform(
-        bRightHanded,
-        StaticCast<FSGIC_FSGCustomWaveformImpl*>(OutWaveform)->CustomWaveformImpl,
-        StaticCast<FSGIC_ESGHapticLocation*>(Location)->Location);
-}
-
 bool SGCoreImpl_FSGHandLayerImpl_SupportsWristSqueeze(
     const bool bRightHanded)
 {
@@ -2434,6 +2448,24 @@ bool SGCoreImpl_FSGHapticGloveImpl_SendHaptics(
     return StaticCast<FSGIC_TSharedPtr_FSGHapticGloveImpl*>(Instance)->Ptr->SendHaptics();
 }
 
+bool SGCoreImpl_FSGHapticGloveImpl_SupportsCustomWaveform(
+    void* Instance,
+    void* AtLocation)
+{
+    return StaticCast<FSGIC_TSharedPtr_FSGHapticGloveImpl*>(Instance)->Ptr->SupportsCustomWaveform(
+        StaticCast<FSGIC_ESGHapticLocation*>(AtLocation)->Location);
+}
+
+bool SGCoreImpl_FSGHapticGloveImpl_SendCustomWaveform(
+    void* Instance,
+    void* OutWaveform,
+    void* Location)
+{
+    return StaticCast<FSGIC_TSharedPtr_FSGHapticGloveImpl*>(Instance)->Ptr->SendCustomWaveform(
+        StaticCast<FSGIC_FSGCustomWaveformImpl*>(OutWaveform)->CustomWaveformImpl,
+        StaticCast<FSGIC_ESGHapticLocation*>(Location)->Location);
+}
+
 bool SGCoreImpl_FSGHapticGloveImpl_QueueForceFeedbackLevels(
     void* Instance,
     void* Levels01)
@@ -2452,22 +2484,22 @@ bool SGCoreImpl_FSGHapticGloveImpl_QueueForceFeedbackLevel(
         Level01);
 }
 
-bool SGCoreImpl_FSGHapticGloveImpl_SupportsCustomWaveform(
+bool SGCoreImpl_FSGHapticGloveImpl_QueueVibroLevels(
     void* Instance,
-    void* AtLocation)
+    void* Levels01)
 {
-    return StaticCast<FSGIC_TSharedPtr_FSGHapticGloveImpl*>(Instance)->Ptr->SupportsCustomWaveform(
-        StaticCast<FSGIC_ESGHapticLocation*>(AtLocation)->Location);
+    return StaticCast<FSGIC_TSharedPtr_FSGHapticGloveImpl*>(Instance)->Ptr->QueueVibroLevels(
+        StaticCast<FSGIC_TArray_float*>(Levels01)->Array);
 }
 
-bool SGCoreImpl_FSGHapticGloveImpl_SendCustomWaveform(
+bool SGCoreImpl_FSGHapticGloveImpl_QueueVibroLevel(
     void* Instance,
-    void* OutWaveform,
-    void* Location)
+    void* Location,
+    const float Level01)
 {
-    return StaticCast<FSGIC_TSharedPtr_FSGHapticGloveImpl*>(Instance)->Ptr->SendCustomWaveform(
-        StaticCast<FSGIC_FSGCustomWaveformImpl*>(OutWaveform)->CustomWaveformImpl,
-        StaticCast<FSGIC_ESGHapticLocation*>(Location)->Location);
+    return StaticCast<FSGIC_TSharedPtr_FSGHapticGloveImpl*>(Instance)->Ptr->QueueVibroLevel(
+        StaticCast<FSGIC_ESGHapticLocation*>(Location)->Location,
+        Level01);
 }
 
 void SGCoreImpl_FSGHapticGloveImpl_GetWristLocation(
@@ -3114,9 +3146,27 @@ bool SGCoreImpl_FSGNova2GloveImpl_QueueForceFeedbackLevel(
         Level01);
 }
 
+bool SGCoreImpl_FSGNova2GloveImpl_QueueVibroLevels(
+    void* Instance,
+    void* Amplitudes)
+{
+    return StaticCast<FSGIC_TSharedPtr_FSGNova2GloveImpl*>(Instance)->Ptr->QueueVibroLevels(
+        StaticCast<FSGIC_TArray_float*>(Amplitudes)->Array);
+}
+
+bool SGCoreImpl_FSGNova2GloveImpl_QueueVibroLevel(
+    void* Instance,
+    void* Location,
+    const float Level01)
+{
+    return StaticCast<FSGIC_TSharedPtr_FSGNova2GloveImpl*>(Instance)->Ptr->QueueVibroLevel(
+        StaticCast<FSGIC_ESGHapticLocation*>(Location)->Location,
+        Level01);
+}
+
 bool SGCoreImpl_FSGNova2GloveImpl_QueueSqueezeLevel(
     void* Instance,
-    float SqueezeLevel01)
+    const float SqueezeLevel01)
 {
     return StaticCast<FSGIC_TSharedPtr_FSGNova2GloveImpl*>(Instance)->Ptr->QueueSqueezeLevel(
         SqueezeLevel01);
@@ -3758,6 +3808,24 @@ bool SGCoreImpl_FSGNovaGloveImpl_QueueForceFeedbackLevel(
         Level01);
 }
 
+bool SGCoreImpl_FSGNovaGloveImpl_QueueVibroLevels(
+    void* Instance,
+    void* Amplitudes)
+{
+    return StaticCast<FSGIC_TSharedPtr_FSGNovaGloveImpl*>(Instance)->Ptr->QueueVibroLevels(
+        StaticCast<FSGIC_TArray_float*>(Amplitudes)->Array);
+}
+
+bool SGCoreImpl_FSGNovaGloveImpl_QueueVibroLevel_Localtion_Level01(
+    void* Instance,
+    void* Location,
+    const float Level01)
+{
+    return StaticCast<FSGIC_TSharedPtr_FSGNovaGloveImpl*>(Instance)->Ptr->QueueVibroLevel(
+        StaticCast<FSGIC_ESGHapticLocation*>(Location)->Location,
+        Level01);
+}
+
 void SGCoreImpl_FSGNovaGloveImpl_GetGloveLocation(
     void* Instance,
     void* ReferencePosition,
@@ -3837,7 +3905,7 @@ void SGCoreImpl_FSGNovaGloveImpl_ToNovaCommand(
     void* OutString,
     void* ForceFeedbackLevels,
     void* BuzzLevels,
-    float WristLevel)
+    const float WristLevel)
 {
     StaticCast<FSGIC_FString*>(OutString)->String =
         StaticCast<FSGIC_TSharedPtr_FSGNovaGloveImpl*>(Instance)->Ptr->ToNovaCommand(
@@ -3846,15 +3914,7 @@ void SGCoreImpl_FSGNovaGloveImpl_ToNovaCommand(
             WristLevel);
 }
 
-bool SGCoreImpl_FSGNovaGloveImpl_QueueVibroLevels(
-    void* Instance,
-    void* Amplitudes)
-{
-    return StaticCast<FSGIC_TSharedPtr_FSGNovaGloveImpl*>(Instance)->Ptr->QueueVibroLevels(
-        StaticCast<FSGIC_TArray_float*>(Amplitudes)->Array);
-}
-
-bool SGCoreImpl_FSGNovaGloveImpl_QueueVibroLevel(
+bool SGCoreImpl_FSGNovaGloveImpl_QueueVibroLevel_Finger_Amplitude(
     void* Instance,
     const int32 Finger,
     const float Amplitude)
@@ -3866,7 +3926,7 @@ bool SGCoreImpl_FSGNovaGloveImpl_QueueVibroLevel(
 
 bool SGCoreImpl_FSGNovaGloveImpl_QueueWristLevel(
     void* Instance,
-    float Amplitude)
+    const float Amplitude)
 {
     return StaticCast<FSGIC_TSharedPtr_FSGNovaGloveImpl*>(Instance)->Ptr->QueueWristLevel(
         Amplitude);
@@ -3915,7 +3975,7 @@ bool SGCoreImpl_FSGNovaGloveImpl_SendCustomWaveform_Nova(
 bool SGCoreImpl_FSGNovaGloveImpl_QueueThresholdCommand_Flexion(
     void* Instance,
     const int32 Finger,
-    float FlexionThreshold)
+    const float FlexionThreshold)
 {
     return StaticCast<FSGIC_TSharedPtr_FSGNovaGloveImpl*>(Instance)->Ptr->QueueThresholdCommand_Flexion(
         Finger,
@@ -4617,6 +4677,24 @@ bool SGCoreImpl_FSGSenseGloveImpl_QueueForceFeedbackLevel(
         Level01);
 }
 
+bool SGCoreImpl_FSGSenseGloveImpl_QueueVibroLevels(
+    void* Instance,
+    void* Amplitudes)
+{
+    return StaticCast<FSGIC_TSharedPtr_FSGSenseGloveImpl*>(Instance)->Ptr->QueueVibroLevels(
+        StaticCast<FSGIC_TArray_float*>(Amplitudes)->Array);
+}
+
+bool SGCoreImpl_FSGSenseGloveImpl_QueueVibroLevel_Location_Level01(
+    void* Instance,
+    void* Location,
+    const float Level01)
+{
+    return StaticCast<FSGIC_TSharedPtr_FSGSenseGloveImpl*>(Instance)->Ptr->QueueVibroLevel(
+        StaticCast<FSGIC_ESGHapticLocation*>(Location)->Location,
+        Level01);
+}
+
 void
 SGCoreImpl_FSGSenseGloveImpl_GetGloveLocation_ReferencePosition_ReferenceRotation_TrackingHardware_OutGlovePosition_OutGloveRotation(
     void* Instance,
@@ -4750,15 +4828,7 @@ bool SGCoreImpl_FSGSenseGloveImpl_GetGlovePose_SensorData_OutGlovePose(
         StaticCast<FSGIC_FSGSenseGlovePoseImpl*>(OutGlovePose)->SenseGlovePoseImpl);
 }
 
-bool SGCoreImpl_FSGSenseGloveImpl_QueueVibroLevels(
-    void* Instance,
-    void* Amplitudes)
-{
-    return StaticCast<FSGIC_TSharedPtr_FSGSenseGloveImpl*>(Instance)->Ptr->QueueVibroLevels(
-        StaticCast<FSGIC_TArray_float*>(Amplitudes)->Array);
-}
-
-bool SGCoreImpl_FSGSenseGloveImpl_QueueVibroLevel(
+bool SGCoreImpl_FSGSenseGloveImpl_QueueVibroLevel_Finger_Amplitude(
     void* Instance,
     const int32 Finger,
     const float Amplitude)
@@ -5945,6 +6015,30 @@ void SGCoreImpl_FSGTrackingImpl_GetLeftNovaViveFocus3ToAttachRotation(
     StaticCast<FSGIC_FQuat*>(OutRotation)->Quat = FSGTrackingImpl::GetLeftNovaViveFocus3ToAttachRotation();
 }
 
+void SGCoreImpl_FSGTrackingImpl_GetRightNovaQuest3ToAttachPosition(
+    void* OutPosition)
+{
+    StaticCast<FSGIC_FVector*>(OutPosition)->Vector = FSGTrackingImpl::GetRightNovaQuest3ToAttachPosition();
+}
+
+void SGCoreImpl_FSGTrackingImpl_GetRightNovaQuest3ToAttachRotation(
+    void* OutRotation)
+{
+    StaticCast<FSGIC_FQuat*>(OutRotation)->Quat = FSGTrackingImpl::GetRightNovaQuest3ToAttachRotation();
+}
+
+void SGCoreImpl_FSGTrackingImpl_GetLeftNovaQuest3ToAttachPosition(
+    void* OutPosition)
+{
+    StaticCast<FSGIC_FVector*>(OutPosition)->Vector = FSGTrackingImpl::GetLeftNovaQuest3ToAttachPosition();
+}
+
+void SGCoreImpl_FSGTrackingImpl_GetLeftNovaQuest3ToAttachRotation(
+    void* OutRotation)
+{
+    StaticCast<FSGIC_FQuat*>(OutRotation)->Quat = FSGTrackingImpl::GetLeftNovaQuest3ToAttachRotation();
+}
+
 void SGCoreImpl_FSGTrackingImpl_GetNovaGloveWristOffset(
     const bool bRightHanded,
     void* OutPositionOffset,
@@ -6091,6 +6185,30 @@ void SGCoreImpl_FSGTrackingImpl_GetLeftNova2ViveWristTrackerToAttachRotation(
     StaticCast<FSGIC_FQuat*>(OutRotation)->Quat = FSGTrackingImpl::GetLeftNova2ViveWristTrackerToAttachRotation();
 }
 
+void SGCoreImpl_FSGTrackingImpl_GetRightNova2Quest3ToAttachPosition(
+    void* OutPosition)
+{
+    StaticCast<FSGIC_FVector*>(OutPosition)->Vector = FSGTrackingImpl::GetRightNova2Quest3ToAttachPosition();
+}
+
+void SGCoreImpl_FSGTrackingImpl_GetRightNova2Quest3ToAttachRotation(
+    void* OutRotation)
+{
+    StaticCast<FSGIC_FQuat*>(OutRotation)->Quat = FSGTrackingImpl::GetRightNova2Quest3ToAttachRotation();
+}
+
+void SGCoreImpl_FSGTrackingImpl_GetLeftNova2Quest3ToAttachPosition(
+    void* OutPosition)
+{
+    StaticCast<FSGIC_FVector*>(OutPosition)->Vector = FSGTrackingImpl::GetLeftNova2Quest3ToAttachPosition();
+}
+
+void SGCoreImpl_FSGTrackingImpl_GetLeftNova2Quest3ToAttachRotation(
+    void* OutRotation)
+{
+    StaticCast<FSGIC_FQuat*>(OutRotation)->Quat = FSGTrackingImpl::GetLeftNova2Quest3ToAttachRotation();
+}
+
 void SGCoreImpl_FSGTrackingImpl_GetNova2GloveWristOffset(
     const bool bRightHanded,
     void* HardwareVersion,

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGHandLayerImpl.cpp

@@ -136,40 +136,14 @@ void FSGHandLayerImpl::GetWristLocation(
     OutWristRotation = FSGQuatImpl{WristRotation}.ToFQuat();
 }
 
-bool FSGHandLayerImpl::SendHaptics(const bool bRightHanded)
-{
-    return FHandLayerType::SendHaptics(bRightHanded);
-}
-
 void FSGHandLayerImpl::StopAllHaptics(const bool bRightHanded)
 {
     FHandLayerType::StopAllHaptics(bRightHanded);
 }
 
-bool FSGHandLayerImpl::QueueCommand_ForceFeedbackLevel(
-    const bool bRightHanded, const int32 Finger, const float Level01, const bool bSendImmediate)
+bool FSGHandLayerImpl::SendHaptics(const bool bRightHanded)
 {
-    return FHandLayerType::QueueCommand_ForceFeedbackLevel(bRightHanded, Finger, Level01, bSendImmediate);
-}
-
-bool FSGHandLayerImpl::QueueCommand_ForceFeedbackLevels(
-    const bool bRightHanded, const TArray<float>& Levels01, const bool bSendImmediate)
-{
-    std::vector<float> Levels01Vector{FSGArrayUtils::ToStdVector(Levels01)};
-    return FHandLayerType::QueueCommand_ForceFeedbackLevels(bRightHanded, MoveTemp(Levels01Vector), bSendImmediate);
-}
-
-bool FSGHandLayerImpl::QueueCommand_SetVibroLevel(
-    const bool bRightHanded, const int32 Finger, const float Level01, const bool bSendImmediate)
-{
-    return FHandLayerType::QueueCommand_SetVibroLevel(bRightHanded, Finger, Level01, bSendImmediate);
-}
-
-bool FSGHandLayerImpl::QueueCommand_SetVibroLevels(
-    const bool bRightHanded, const TArray<float>& Levels01, const bool bSendImmediate)
-{
-    std::vector<float> Levels01Vector{FSGArrayUtils::ToStdVector(Levels01)};
-    return FHandLayerType::QueueCommand_SetVibroLevels(bRightHanded, MoveTemp(Levels01Vector), bSendImmediate);
+    return FHandLayerType::SendHaptics(bRightHanded);
 }
 
 bool FSGHandLayerImpl::SupportsCustomWaveform(const bool bRightHanded, const ESGHapticLocation AtLocation)
@@ -185,6 +159,39 @@ bool FSGHandLayerImpl::SendCustomWaveform(
     return bResult;
 }
 
+bool FSGHandLayerImpl::QueueCommand_ForceFeedbackLevels(
+    const bool bRightHanded, const TArray<float>& Levels01, const bool bSendImmediate)
+{
+    std::vector<float> Levels01Vector{FSGArrayUtils::ToStdVector(Levels01)};
+    return FHandLayerType::QueueCommand_ForceFeedbackLevels(bRightHanded, MoveTemp(Levels01Vector), bSendImmediate);
+}
+
+bool FSGHandLayerImpl::QueueCommand_ForceFeedbackLevel(
+    const bool bRightHanded, const int32 Finger, const float Level01, const bool bSendImmediate)
+{
+    return FHandLayerType::QueueCommand_ForceFeedbackLevel(bRightHanded, Finger, Level01, bSendImmediate);
+}
+
+bool FSGHandLayerImpl::QueueCommand_VibroLevels(
+    const bool bRightHanded, const TArray<float>& Levels01, const bool bSendImmediate)
+{
+    std::vector<float> Levels01Vector{FSGArrayUtils::ToStdVector(Levels01)};
+    return FHandLayerType::QueueCommand_VibroLevels(bRightHanded, MoveTemp(Levels01Vector), bSendImmediate);
+}
+
+bool FSGHandLayerImpl::QueueCommand_VibroLevel(
+    const bool bRightHanded, const int32 Finger, const float Level01, const bool bSendImmediate)
+{
+    return FHandLayerType::QueueCommand_VibroLevel(bRightHanded, Finger, Level01, bSendImmediate);
+}
+
+bool FSGHandLayerImpl::QueueCommand_VibroLevel(
+    const bool bRightHanded, const ESGHapticLocation AtLocation, const float Level01, const bool bSendImmediate)
+{
+    return FHandLayerType::QueueCommand_VibroLevel(
+        bRightHanded, FSGCoreEnumCast::ToEHapticLocation(AtLocation), Level01, bSendImmediate);
+}
+
 bool FSGHandLayerImpl::SupportsWristSqueeze(const bool bRightHanded)
 {
     return FHandLayerType::SupportsWristSqueeze(bRightHanded);

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGHapticGloveImpl.cpp

@@ -293,6 +293,17 @@ bool FSGHapticGloveImpl::SendHaptics()
     return ToHapticGlovePtrChecked()->SendHaptics();
 }
 
+bool FSGHapticGloveImpl::SupportsCustomWaveform(const ESGHapticLocation AtLocation) const
+{
+    return ToHapticGlovePtrChecked()->SupportsCustomWaveform(FSGCoreEnumCast::ToEHapticLocation(AtLocation));
+}
+
+bool FSGHapticGloveImpl::SendCustomWaveform(FSGCustomWaveformImpl& OutWaveform, const ESGHapticLocation Location)
+{
+    return ToHapticGlovePtrChecked()->SendCustomWaveform(
+        OutWaveform.ToCustomWaveform(), FSGCoreEnumCast::ToEHapticLocation(Location));
+}
+
 bool FSGHapticGloveImpl::QueueForceFeedbackLevels(const TArray<float>& Levels01)
 {
     std::vector<float> Levels01Vector{FSGArrayUtils::ToStdVector<float>(Levels01)};
@@ -304,15 +315,15 @@ bool FSGHapticGloveImpl::QueueForceFeedbackLevel(const int32 Finger, const float
     return ToHapticGlovePtrChecked()->QueueForceFeedbackLevel(Finger, Level01);
 }
 
-bool FSGHapticGloveImpl::SupportsCustomWaveform(const ESGHapticLocation AtLocation) const
+bool FSGHapticGloveImpl::QueueVibroLevels(const TArray<float>& Levels01)
 {
-    return ToHapticGlovePtrChecked()->SupportsCustomWaveform(FSGCoreEnumCast::ToEHapticLocation(AtLocation));
+    std::vector<float> Levels01Vector{FSGArrayUtils::ToStdVector(Levels01)};
+    return ToHapticGlovePtrChecked()->QueueVibroLevels(MoveTemp(Levels01Vector));
 }
 
-bool FSGHapticGloveImpl::SendCustomWaveform(FSGCustomWaveformImpl& OutWaveform, const ESGHapticLocation Location)
+bool FSGHapticGloveImpl::QueueVibroLevel(const ESGHapticLocation Location, const float Level01)
 {
-    return ToHapticGlovePtrChecked()->SendCustomWaveform(
-        OutWaveform.ToCustomWaveform(), FSGCoreEnumCast::ToEHapticLocation(Location));
+    return ToHapticGlovePtrChecked()->QueueVibroLevel(FSGCoreEnumCast::ToEHapticLocation(Location), Level01);
 }
 
 void FSGHapticGloveImpl::GetWristLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGNova2GloveImpl.cpp

@@ -408,6 +408,17 @@ bool FSGNova2GloveImpl::QueueForceFeedbackLevel(const int32 Finger, const float
     return ToNova2GlovePtrChecked()->QueueForceFeedbackLevel(Finger, Level01);
 }
 
+bool FSGNova2GloveImpl::QueueVibroLevels(const TArray<float>& Amplitudes)
+{
+    std::vector<float> AmplitudesVector{FSGArrayUtils::ToStdVector(Amplitudes)};
+    return ToNova2GlovePtrChecked()->QueueVibroLevels(MoveTemp(AmplitudesVector));
+}
+
+bool FSGNova2GloveImpl::QueueVibroLevel(const ESGHapticLocation Location, const float Level01)
+{
+    return ToNova2GlovePtrChecked()->QueueVibroLevel(FSGCoreEnumCast::ToEHapticLocation(Location), Level01);
+}
+
 bool FSGNova2GloveImpl::QueueSqueezeLevel(const float SqueezeLevel01)
 {
     return ToNova2GlovePtrChecked()->QueueSqueezeLevel(SqueezeLevel01);

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGNovaGloveImpl.cpp

@@ -516,6 +516,11 @@ bool FSGNovaGloveImpl::QueueVibroLevels(const TArray<float>& Amplitudes)
     return ToNovaGlovePtrChecked()->QueueVibroLevels(MoveTemp(AmplitudesVector));
 }
 
+bool FSGNovaGloveImpl::QueueVibroLevel(const ESGHapticLocation Location, const float Level01)
+{
+    return ToNovaGlovePtrChecked()->QueueVibroLevel(FSGCoreEnumCast::ToEHapticLocation(Location), Level01);
+}
+
 bool FSGNovaGloveImpl::QueueVibroLevel(const int32 Finger, const float Amplitude)
 {
     return ToNovaGlovePtrChecked()->QueueVibroLevel(Finger, Amplitude);

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGSenseGloveImpl.cpp

@@ -419,6 +419,17 @@ bool FSGSenseGloveImpl::QueueForceFeedbackLevel(const int32 Finger, const float
     return ToSenseGlovePtrChecked()->QueueForceFeedbackLevel(Finger, Level01);
 }
 
+bool FSGSenseGloveImpl::QueueVibroLevels(const TArray<float>& Amplitudes)
+{
+    std::vector<float> AmplitudesVector{FSGArrayUtils::ToStdVector(Amplitudes)};
+    return ToSenseGlovePtrChecked()->QueueVibroLevels(MoveTemp(AmplitudesVector));
+}
+
+bool FSGSenseGloveImpl::QueueVibroLevel(const ESGHapticLocation Location, const float Level01)
+{
+    return ToSenseGlovePtrChecked()->QueueVibroLevel(FSGCoreEnumCast::ToEHapticLocation(Location), Level01);
+}
+
 void FSGSenseGloveImpl::GetGloveLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
                                          const ESGPositionalTrackingHardware TrackingHardware,
                                          FVector& OutGlovePosition, FQuat& OutGloveRotation) const
@@ -547,12 +558,6 @@ bool FSGSenseGloveImpl::GetGlovePose(const FSGSenseGloveSensorDataImpl& SensorDa
     return bResult;
 }
 
-bool FSGSenseGloveImpl::QueueVibroLevels(const TArray<float>& Amplitudes)
-{
-    std::vector<float> AmplitudesVector{FSGArrayUtils::ToStdVector(Amplitudes)};
-    return ToSenseGlovePtrChecked()->QueueVibroLevels(MoveTemp(AmplitudesVector));
-}
-
 bool FSGSenseGloveImpl::QueueVibroLevel(const int32 Finger, const float Amplitude)
 {
     return ToSenseGlovePtrChecked()->QueueVibroLevel(Finger, Amplitude);

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGTrackingImpl.cpp

@@ -319,6 +319,36 @@ const FQuat& FSGTrackingImpl::GetLeftNovaViveFocus3ToAttachRotation()
     return Rotation;
 }
 
+const FVector& FSGTrackingImpl::GetRightNovaQuest3ToAttachPosition()
+{
+    static FVector Position{
+        FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+            FTrackingType::GetRightNovaQuest3ToAttachPosition())
+    };
+    return Position;
+}
+
+const FQuat& FSGTrackingImpl::GetRightNovaQuest3ToAttachRotation()
+{
+    static FQuat Rotation(FSGQuatImpl(FTrackingType::GetRightNovaQuest3ToAttachRotation()).ToFQuat());
+    return Rotation;
+}
+
+const FVector& FSGTrackingImpl::GetLeftNovaQuest3ToAttachPosition()
+{
+    static FVector Position{
+        FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+            FTrackingType::GetLeftNovaQuest3ToAttachPosition())
+    };
+    return Position;
+}
+
+const FQuat& FSGTrackingImpl::GetLeftNovaQuest3ToAttachRotation()
+{
+    static FQuat Rotation(FSGQuatImpl(FTrackingType::GetLeftNovaQuest3ToAttachRotation()).ToFQuat());
+    return Rotation;
+}
+
 void FSGTrackingImpl::GetNovaGloveWristOffset(const bool bRightHanded,
                                               FVector& OutPositionOffset, FQuat& OutRotationOffset)
 {
@@ -460,6 +490,36 @@ const FVector& FSGTrackingImpl::GetLeftNova2ViveTrackerToAttachPosition()
     return Position;
 }
 
+const FVector& FSGTrackingImpl::GetRightNova2Quest3ToAttachPosition()
+{
+    static FVector Position{
+        FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+            FTrackingType::GetRightNova2Quest3ToAttachPosition())
+    };
+    return Position;
+}
+
+const FQuat& FSGTrackingImpl::GetRightNova2Quest3ToAttachRotation()
+{
+    static FQuat Rotation(FSGQuatImpl(FTrackingType::GetRightNova2Quest3ToAttachRotation()).ToFQuat());
+    return Rotation;
+}
+
+const FVector& FSGTrackingImpl::GetLeftNova2Quest3ToAttachPosition()
+{
+    static FVector Position{
+        FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+            FTrackingType::GetLeftNova2Quest3ToAttachPosition())
+    };
+    return Position;
+}
+
+const FQuat& FSGTrackingImpl::GetLeftNova2Quest3ToAttachRotation()
+{
+    static FQuat Rotation(FSGQuatImpl(FTrackingType::GetLeftNova2Quest3ToAttachRotation()).ToFQuat());
+    return Rotation;
+}
+
 const FQuat& FSGTrackingImpl::GetLeftNova2ViveTrackerToAttachRotation()
 {
     static FQuat Rotation(FSGQuatImpl(FTrackingType::GetLeftNova2ViveTrackerToAttachRotation()).ToFQuat());

Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGExportedFunctions.h

@@ -885,33 +885,11 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHandLayerImpl_GetWristLocation(
     void* OutWristPosition,
     void* OutWristRotation);
 
-SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHandLayerImpl_SendHaptics(
-    bool bRightHanded);
-
 SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHandLayerImpl_StopAllHaptics(
     bool bRightHanded);
 
-SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHandLayerImpl_QueueCommand_ForceFeedbackLevel(
-    bool bRightHanded,
-    int32 Finger,
-    float Level01,
-    bool bSendImmediate);
-
-SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHandLayerImpl_QueueCommand_ForceFeedbackLevels(
-    bool bRightHanded,
-    void* Levels01,
-    bool bSendImmediate);
-
-SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHandLayerImpl_QueueCommand_SetVibroLevel(
-    bool bRightHanded,
-    int32 Finger,
-    float Level01,
-    bool bSendImmediate);
-
-SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHandLayerImpl_QueueCommand_SetVibroLevels(
-    bool bRightHanded,
-    void* Levels01,
-    bool bSendImmediate);
+SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHandLayerImpl_SendHaptics(
+    bool bRightHanded);
 
 SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHandLayerImpl_SupportsCustomWaveform(
     bool bRightHanded,
@@ -922,6 +900,36 @@ SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHandLayerImpl_SendCustomWavefor
     void* OutWaveform,
     void* Location);
 
+SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHandLayerImpl_QueueCommand_ForceFeedbackLevels(
+    bool bRightHanded,
+    void* Levels01,
+    bool bSendImmediate);
+
+SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHandLayerImpl_QueueCommand_ForceFeedbackLevel(
+    bool bRightHanded,
+    int32 Finger,
+    float Level01,
+    bool bSendImmediate);
+
+SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHandLayerImpl_QueueCommand_VibroLevels(
+    bool bRightHanded,
+    void* Levels01,
+    bool bSendImmediate);
+
+SENSEGLOVECOREIMPL_PUBLIC_API bool
+    SGCoreImpl_FSGHandLayerImpl_QueueCommand_VibroLevel_bRightHanded_Finger_Level0_bSendImmediate(
+    bool bRightHanded,
+    int32 Finger,
+    float Level01,
+    bool bSendImmediate);
+
+SENSEGLOVECOREIMPL_PUBLIC_API bool
+    SGCoreImpl_FSGHandLayerImpl_QueueCommand_VibroLevel_bRightHanded_AtLocation_Level01_bSendImmediate(
+    bool bRightHanded,
+    void* AtLocation,
+    float Level01,
+    bool bSendImmediate);
+
 SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHandLayerImpl_SupportsWristSqueeze(
     bool bRightHanded);
 
@@ -1229,6 +1237,15 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHapticGloveImpl_StopVibrations(
 SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHapticGloveImpl_SendHaptics(
     void* Instance);
 
+SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHapticGloveImpl_SupportsCustomWaveform(
+    void* Instance,
+    void* AtLocation);
+
+SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHapticGloveImpl_SendCustomWaveform(
+    void* Instance,
+    void* OutWaveform,
+    void* Location);
+
 SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHapticGloveImpl_QueueForceFeedbackLevels(
     void* Instance,
     void* Levels01);
@@ -1238,14 +1255,14 @@ SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHapticGloveImpl_QueueForceFeedb
     int32 Finger,
     float Level01);
 
-SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHapticGloveImpl_SupportsCustomWaveform(
+SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHapticGloveImpl_QueueVibroLevels(
     void* Instance,
-    void* AtLocation);
+    void* Levels01);
 
-SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHapticGloveImpl_SendCustomWaveform(
+SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHapticGloveImpl_QueueVibroLevel(
     void* Instance,
-    void* OutWaveform,
-    void* Location);
+    void* Location,
+    float Level01);
 
 SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHapticGloveImpl_GetWristLocation(
     void* Instance,
@@ -1572,6 +1589,15 @@ SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGNova2GloveImpl_QueueForceFeedba
     int32 Finger,
     float Level01);
 
+SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGNova2GloveImpl_QueueVibroLevels(
+    void* Instance,
+    void* Amplitudes);
+
+SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGNova2GloveImpl_QueueVibroLevel(
+    void* Instance,
+    void* Location,
+    float Level01);
+
 SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGNova2GloveImpl_QueueSqueezeLevel(
     void* Instance,
     float SqueezeLevel01);
@@ -1889,6 +1915,15 @@ SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGNovaGloveImpl_QueueForceFeedbac
     int32 Finger,
     float Level01);
 
+SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGNovaGloveImpl_QueueVibroLevels(
+    void* Instance,
+    void* Amplitudes);
+
+SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGNovaGloveImpl_QueueVibroLevel_Localtion_Level01(
+    void* Instance,
+    void* Location,
+    float Level01);
+
 SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveImpl_GetGloveLocation(
     void* Instance,
     void* ReferencePosition,
@@ -1933,11 +1968,7 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveImpl_ToNovaCommand(
     void* BuzzLevels,
     float WristLevel);
 
-SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGNovaGloveImpl_QueueVibroLevels(
-    void* Instance,
-    void* Amplitudes);
-
-SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGNovaGloveImpl_QueueVibroLevel(
+SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGNovaGloveImpl_QueueVibroLevel_Finger_Amplitude(
     void* Instance,
     int32 Finger,
     float Amplitude);
@@ -2320,6 +2351,15 @@ SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGSenseGloveImpl_QueueForceFeedba
     int32 Finger,
     float Level01);
 
+SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGSenseGloveImpl_QueueVibroLevels(
+    void* Instance,
+    void* Amplitudes);
+
+SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGSenseGloveImpl_QueueVibroLevel_Location_Level01(
+    void* Instance,
+    void* Location,
+    float Level01);
+
 SENSEGLOVECOREIMPL_PUBLIC_API void
 SGCoreImpl_FSGSenseGloveImpl_GetGloveLocation_ReferencePosition_ReferenceRotation_TrackingHardware_OutGlovePosition_OutGloveRotation(
     void* Instance,
@@ -2389,11 +2429,7 @@ SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGSenseGloveImpl_GetGlovePose_Sen
     void* SensorData,
     void* OutGlovePose);
 
-SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGSenseGloveImpl_QueueVibroLevels(
-    void* Instance,
-    void* Amplitudes);
-
-SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGSenseGloveImpl_QueueVibroLevel(
+SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGSenseGloveImpl_QueueVibroLevel_Finger_Amplitude(
     void* Instance,
     int32 Finger,
     float Amplitude);
@@ -2995,6 +3031,18 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTrackingImpl_GetLeftNovaViveFoc
 SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTrackingImpl_GetLeftNovaViveFocus3ToAttachRotation(
     void* OutRotation);
 
+SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTrackingImpl_GetRightNovaQuest3ToAttachPosition(
+    void* OutPosition);
+
+SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTrackingImpl_GetRightNovaQuest3ToAttachRotation(
+    void* OutRotation);
+
+SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTrackingImpl_GetLeftNovaQuest3ToAttachPosition(
+    void* OutPosition);
+
+SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTrackingImpl_GetLeftNovaQuest3ToAttachRotation(
+    void* OutRotation);
+
 SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTrackingImpl_GetNovaGloveWristOffset(
     bool bRightHanded,
     void* OutPositionOffset,
@@ -3066,6 +3114,18 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTrackingImpl_GetLeftNova2ViveWr
 SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTrackingImpl_GetLeftNova2ViveWristTrackerToAttachRotation(
     void* OutRotation);
 
+SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTrackingImpl_GetRightNova2Quest3ToAttachPosition(
+    void* OutPosition);
+
+SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTrackingImpl_GetRightNova2Quest3ToAttachRotation(
+    void* OutRotation);
+
+SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTrackingImpl_GetLeftNova2Quest3ToAttachPosition(
+    void* OutPosition);
+
+SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTrackingImpl_GetLeftNova2Quest3ToAttachRotation(
+    void* OutRotation);
+
 SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTrackingImpl_GetNova2GloveWristOffset(
     bool bRightHanded,
     void* HardwareVersion,

Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGHandLayerImpl.h

@@ -85,23 +85,26 @@ public:
         ESGPositionalTrackingHardware TrackingHardware,
         FVector& OutWristPosition, FQuat& OutWristRotation);
 
-    static bool SendHaptics(bool bRightHanded);
-
     static void StopAllHaptics(bool bRightHanded);
 
-    static bool QueueCommand_ForceFeedbackLevel(bool bRightHanded, int32 Finger, float Level01, bool bSendImmediate);
-
-    static bool QueueCommand_ForceFeedbackLevels(
-        bool bRightHanded, const TArray<float>& Levels01, bool bSendImmediate);
-
-    static bool QueueCommand_SetVibroLevel(bool bRightHanded, int32 Finger, float Level01, bool bSendImmediate);
-
-    static bool QueueCommand_SetVibroLevels(bool bRightHanded, const TArray<float>& Levels01, bool bSendImmediate);
+    static bool SendHaptics(bool bRightHanded);
 
     static bool SupportsCustomWaveform(bool bRightHanded, ESGHapticLocation AtLocation);
 
     static bool SendCustomWaveform(bool bRightHanded, FSGCustomWaveformImpl& OutWaveform, ESGHapticLocation Location);
 
+    static bool QueueCommand_ForceFeedbackLevels(
+        bool bRightHanded, const TArray<float>& Levels01, bool bSendImmediate);
+
+    static bool QueueCommand_ForceFeedbackLevel(bool bRightHanded, int32 Finger, float Level01, bool bSendImmediate);
+
+    static bool QueueCommand_VibroLevels(bool bRightHanded, const TArray<float>& Levels01, bool bSendImmediate);
+
+    static bool QueueCommand_VibroLevel(bool bRightHanded, int32 Finger, float Level01, bool bSendImmediate);
+
+    static bool QueueCommand_VibroLevel(
+            bool bRightHanded, ESGHapticLocation AtLocation, float Level01, bool bSendImmediate);
+
     static bool SupportsWristSqueeze(bool bRightHanded);
 
     static bool QueueCommand_WristSqueeze(bool bRightHanded, float SqueezeLevel01, bool bSendImmediate);

Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGHapticGloveImpl.h

@@ -183,13 +183,17 @@ public:
     virtual bool SendHaptics();
 
 public:
+    virtual bool SupportsCustomWaveform(ESGHapticLocation AtLocation) const;
+
+    virtual bool SendCustomWaveform(FSGCustomWaveformImpl& OutWaveform, ESGHapticLocation Location);
+
     virtual bool QueueForceFeedbackLevels(const TArray<float>& Levels01);
 
     virtual bool QueueForceFeedbackLevel(int32 Finger, float Level01);
 
-    virtual bool SupportsCustomWaveform(ESGHapticLocation AtLocation) const;
+    virtual bool QueueVibroLevels(const TArray<float>& Levels01);
 
-    virtual bool SendCustomWaveform(FSGCustomWaveformImpl& OutWaveform, ESGHapticLocation Location);
+    virtual bool QueueVibroLevel(ESGHapticLocation Location, float Level01);
 
 public:
     virtual void GetWristLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,

Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGNova2GloveImpl.h

@@ -240,6 +240,10 @@ public:
 
     virtual bool QueueForceFeedbackLevel(int32 Finger, float Level01) override;
 
+    virtual bool QueueVibroLevels(const TArray<float>& Amplitudes) override;
+
+    virtual bool QueueVibroLevel(ESGHapticLocation Location, float Level01) override;
+
     virtual bool QueueSqueezeLevel(float SqueezeLevel01);
 
 public:

Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGNovaGloveImpl.h

@@ -250,6 +250,10 @@ public:
 
     virtual bool QueueForceFeedbackLevel(int32 Finger, float Level01) override;
 
+    virtual bool QueueVibroLevels(const TArray<float>& Amplitudes) override;
+
+    virtual bool QueueVibroLevel(ESGHapticLocation Location, float Level01) override;
+
 public:
     virtual void GetGloveLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
                                   ESGPositionalTrackingHardware TrackingHardware,
@@ -277,8 +281,6 @@ public:
     virtual FString ToNovaCommand(
         const TArray<float>& ForceFeedbackLevels, const TArray<float>& BuzzLevels, float WristLevel) const;
 
-    virtual bool QueueVibroLevels(const TArray<float>& Amplitudes);
-
     virtual bool QueueVibroLevel(int32 Finger, float Amplitude);
 
     virtual bool QueueWristLevel(float Amplitude);

Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGSenseGloveImpl.h

@@ -241,6 +241,10 @@ public:
 
     virtual bool QueueForceFeedbackLevel(int32 Finger, float Level01) override;
 
+    virtual bool QueueVibroLevels(const TArray<float>& Amplitudes) override;
+
+    virtual bool QueueVibroLevel(ESGHapticLocation Location, float Level01) override;
+
 public:
     virtual void GetGloveLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
                                   ESGPositionalTrackingHardware TrackingHardware,
@@ -277,8 +281,6 @@ public:
     bool GetGlovePose(const FSGSenseGloveSensorDataImpl& SensorData, FSGSenseGlovePoseImpl& OutGlovePose) const;
 
 public:
-    virtual bool QueueVibroLevels(const TArray<float>& Amplitudes);
-
     virtual bool QueueVibroLevel(int32 Finger, float Amplitude);
 
     virtual bool QueueThumperCommand(ESGSenseGloveThumperCommand Command);

Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGTrackingImpl.h

@@ -105,6 +105,12 @@ public:
     static const FVector& GetLeftNovaViveFocus3ToAttachPosition();
     static const FQuat& GetLeftNovaViveFocus3ToAttachRotation();
 
+    static const FVector& GetRightNovaQuest3ToAttachPosition();
+    static const FQuat& GetRightNovaQuest3ToAttachRotation();
+
+    static const FVector& GetLeftNovaQuest3ToAttachPosition();
+    static const FQuat& GetLeftNovaQuest3ToAttachRotation();
+
     static void GetNovaGloveWristOffset(bool bRightHanded, FVector& OutPositionOffset, FQuat& OutRotationOffset);
 
     static void GetNovaGloveTrackerOffset(ESGPositionalTrackingHardware Hardware, bool bRightHanded,
@@ -137,6 +143,12 @@ public:
     static const FVector& GetRightNova2ViveWristTrackerToAttachPosition();
     static const FQuat& GetRightNova2ViveWristTrackerToAttachRotation();
 
+    static const FVector& GetRightNova2Quest3ToAttachPosition();
+    static const FQuat& GetRightNova2Quest3ToAttachRotation();
+
+    static const FVector& GetLeftNova2Quest3ToAttachPosition();
+    static const FQuat& GetLeftNova2Quest3ToAttachRotation();
+
     static const FVector& GetLeftNova2ViveWristTrackerToAttachPosition();
     static const FQuat& GetLeftNova2ViveWristTrackerToAttachRotation();