add missing sense glove wrappers in layer 1/2/3/4 of the api and also more documentation

2022-11-18 13:42:24 +01:00
parent c68d8dc3e9
commit b5d79efab4
10 changed files with 546 additions and 27 deletions
@@ -354,6 +354,70 @@ ESGPositionalTrackingHardware FSGCoreEnumCast::ToESGPositionalTrackingHardware(c
    return ESGPositionalTrackingHardware::None;
 }

+FSGCoreEnumCast::FESenseGloveThumperCommandType FSGCoreEnumCast::ToESenseGloveThumperCommand(
+    const ESGSenseGloveThumperCommand Enum)
+{
+    switch (Enum)
+    {
+    case ESGSenseGloveThumperCommand::None:
+        return FESenseGloveThumperCommandType::None;
+    case ESGSenseGloveThumperCommand::TurnOff:
+        return FESenseGloveThumperCommandType::TurnOff;
+    case ESGSenseGloveThumperCommand::CueGameOver:
+        return FESenseGloveThumperCommandType::CueGameOver;
+    case ESGSenseGloveThumperCommand::ButtonDouble100:
+        return FESenseGloveThumperCommandType::ButtonDouble100;
+    case ESGSenseGloveThumperCommand::ButtonDouble60:
+        return FESenseGloveThumperCommandType::ButtonDouble60;
+    case ESGSenseGloveThumperCommand::ImpactThump30:
+        return FESenseGloveThumperCommandType::ImpactThump30;
+    case ESGSenseGloveThumperCommand::ImpactThump10:
+        return FESenseGloveThumperCommandType::ImpactThump10;
+    case ESGSenseGloveThumperCommand::ImpactThump100:
+        return FESenseGloveThumperCommandType::ImpactThump100;
+    case ESGSenseGloveThumperCommand::ObjectGrasp100:
+        return FESenseGloveThumperCommandType::ObjectGrasp100;
+    case ESGSenseGloveThumperCommand::ObjectGrasp60:
+        return FESenseGloveThumperCommandType::ObjectGrasp60;
+    case ESGSenseGloveThumperCommand::ObjectGrasp30:
+        return FESenseGloveThumperCommandType::ObjectGrasp30;
+    }
+
+    // Keep the compiler satisfied!
+    return FESenseGloveThumperCommandType::None;
+}
+
+ESGSenseGloveThumperCommand FSGCoreEnumCast::ToESGSenseGloveThumperCommand(const FESenseGloveThumperCommandType Enum)
+{
+    switch (Enum)
+    {
+    case FESenseGloveThumperCommandType::None:
+        return ESGSenseGloveThumperCommand::None;
+    case FESenseGloveThumperCommandType::TurnOff:
+        return ESGSenseGloveThumperCommand::TurnOff;
+    case FESenseGloveThumperCommandType::CueGameOver:
+        return ESGSenseGloveThumperCommand::CueGameOver;
+    case FESenseGloveThumperCommandType::ButtonDouble100:
+        return ESGSenseGloveThumperCommand::ButtonDouble100;
+    case FESenseGloveThumperCommandType::ButtonDouble60:
+        return ESGSenseGloveThumperCommand::ButtonDouble60;
+    case FESenseGloveThumperCommandType::ImpactThump30:
+        return ESGSenseGloveThumperCommand::ImpactThump30;
+    case FESenseGloveThumperCommandType::ImpactThump10:
+        return ESGSenseGloveThumperCommand::ImpactThump10;
+    case FESenseGloveThumperCommandType::ImpactThump100:
+        return ESGSenseGloveThumperCommand::ImpactThump100;
+    case FESenseGloveThumperCommandType::ObjectGrasp100:
+        return ESGSenseGloveThumperCommand::ObjectGrasp100;
+    case FESenseGloveThumperCommandType::ObjectGrasp60:
+        return ESGSenseGloveThumperCommand::ObjectGrasp60;
+    case FESenseGloveThumperCommandType::ObjectGrasp30:
+        return ESGSenseGloveThumperCommand::ObjectGrasp30;
+    }
+
+    return ESGSenseGloveThumperCommand::None;
+}
+
 FSGCoreEnumCast::FEThumbMovementType FSGCoreEnumCast::ToEThumbMovement(const ESGThumbMovement Enum)
 {
    switch (Enum)
@@ -36,6 +36,7 @@
 #pragma once

 #include <SenseGlove/Core/Fingers.hpp>
+#include <SenseGlove/Core/SenseGloveThumperCommand.hpp>

 #include "SGBuildHacks/SGInclude_Core_Fingers.h"
 #include "SGBuildHacks/SGInclude_Core_HapticGloveCalibrationCheck.h"
@@ -43,6 +44,7 @@
 #include "SGBuildHacks/SGInclude_Core_SenseGloveHandProfile.h"
 #include "SGBuildHacks/SGInclude_Core_SGDevice.h"
 #include "SGBuildHacks/SGInclude_Core_Tracking.h"
+#include "SGCoreImpl/SGHapticGloveCommandBufferImpl.h"
 #include "SGTypes/SGCoreTypes.h"

 class SENSEGLOVECOREIMPL_API FSGCoreEnumCast
@@ -56,37 +58,41 @@ public:
    typedef SGCore::Kinematics::EFingerMovement FEFingerMovementType;
    typedef SGCore::SG::EFingerSolver FEFingerSolverType;
    typedef SGCore::EPositionalTrackingHardware FEPositionalTrackingHardware;
+    typedef SGCore::Haptics::ESenseGloveThumperCommand FESenseGloveThumperCommandType;
    typedef SGCore::Kinematics::EThumbMovement FEThumbMovementType;
    typedef SGCore::SG::EThumbSolver FEThumbSolverType;

 public:
-    static FEBackendType ToEBackendType(const ESGBackendType Enum);
-    static ESGBackendType ToESGBackendType(const FEBackendType Enum);
+    static FEBackendType ToEBackendType(ESGBackendType Enum);
+    static ESGBackendType ToESGBackendType(FEBackendType Enum);

-    static FECalibrationStageType ToECalibrationStage(const ESGCalibrationStage Enum);
-    static ESGCalibrationStage ToESGCalibrationStage(const FECalibrationStageType Enum);
+    static FECalibrationStageType ToECalibrationStage(ESGCalibrationStage Enum);
+    static ESGCalibrationStage ToESGCalibrationStage(FECalibrationStageType Enum);

-    static FEConnectionType ToEConnectionType(const ESGConnectionType Enum);
-    static ESGConnectionType ToESGConnectionType(const FEConnectionType Enum);
+    static FEConnectionType ToEConnectionType(ESGConnectionType Enum);
+    static ESGConnectionType ToESGConnectionType(FEConnectionType Enum);

-    static FEDeviceType ToEDeviceType(const ESGDeviceType Enum);
-    static ESGDeviceType ToESGDeviceType(const FEDeviceType Enum);
+    static FEDeviceType ToEDeviceType(ESGDeviceType Enum);
+    static ESGDeviceType ToESGDeviceType(FEDeviceType Enum);

-    static FEFingerType ToEFinger(const ESGFinger Enum);
-    static ESGFinger ToESGFinger(const FEFingerType Enum);
+    static FEFingerType ToEFinger(ESGFinger Enum);
+    static ESGFinger ToESGFinger(FEFingerType Enum);

-    static FEFingerMovementType ToEFingerMovement(const ESGFingerMovement Enum);
-    static ESGFingerMovement ToESGFingerMovement(const FEFingerMovementType Enum);
+    static FEFingerMovementType ToEFingerMovement(ESGFingerMovement Enum);
+    static ESGFingerMovement ToESGFingerMovement(FEFingerMovementType Enum);

-    static FEFingerSolverType ToEFingerSolver(const ESGFingerSolver Enum);
-    static ESGFingerSolver ToESGFingerSolver(const FEFingerSolverType Enum);
+    static FEFingerSolverType ToEFingerSolver(ESGFingerSolver Enum);
+    static ESGFingerSolver ToESGFingerSolver(FEFingerSolverType Enum);

-    static FEPositionalTrackingHardware ToEPositionalTrackingHardware(const ESGPositionalTrackingHardware Enum);
-    static ESGPositionalTrackingHardware ToESGPositionalTrackingHardware(const FEPositionalTrackingHardware Enum);
+    static FEPositionalTrackingHardware ToEPositionalTrackingHardware(ESGPositionalTrackingHardware Enum);
+    static ESGPositionalTrackingHardware ToESGPositionalTrackingHardware(FEPositionalTrackingHardware Enum);

-    static FEThumbMovementType ToEThumbMovement(const ESGThumbMovement Enum);
-    static ESGThumbMovement ToESGThumbMovement(const FEThumbMovementType Enum);
+    static FESenseGloveThumperCommandType ToESenseGloveThumperCommand(ESGSenseGloveThumperCommand Enum);
+    static ESGSenseGloveThumperCommand ToESGSenseGloveThumperCommand(FESenseGloveThumperCommandType Enum);

-    static FEThumbSolverType ToEThumbSolver(const ESGThumbSolver Enum);
-    static ESGThumbSolver ToESGThumbSolver(const FEThumbSolverType Enum);
+    static FEThumbMovementType ToEThumbMovement(ESGThumbMovement Enum);
+    static ESGThumbMovement ToESGThumbMovement(FEThumbMovementType Enum);
+
+    static FEThumbSolverType ToEThumbSolver(ESGThumbSolver Enum);
+    static ESGThumbSolver ToESGThumbSolver(FEThumbSolverType Enum);
 };
@@ -5033,6 +5033,26 @@ bool SGCoreImpl_FSGSenseGloveImpl_GetHandPose_HandProfile_OutHandPose(
        StaticCast<FSGIC_FSGHandPoseImpl*>(OutHandPose)->HandPoseImpl);
 }

+bool SGCoreImpl_FSGSenseGloveImpl_SendHaptics_ForceFeedbackCommand_BuzzCommand_ESenseGloveThumperCommand(
+    void* Instance,
+    void* ForceFeedbackCommand,
+    void* BuzzCommand,
+    void* ThumperCommand)
+{
+    return StaticCast<FSGIC_TSharedPtr_FSGSenseGloveImpl*>(Instance)->Ptr->SendHaptics(
+        StaticCast<FSGIC_FSGForceFeedbackCommandImpl*>(ForceFeedbackCommand)->ForceFeedbackCommandImpl,
+        StaticCast<FSGIC_FSGBuzzCommandImpl*>(BuzzCommand)->BuzzCommandImpl,
+        StaticCast<FSGIC_ESGSenseGloveThumperCommand*>(ThumperCommand)->Command);
+}
+
+bool SGCoreImpl_FSGSenseGloveImpl_SendHaptics_ThumperCommand(
+    void* Instance,
+    void* ThumperCommand)
+{
+    return StaticCast<FSGIC_TSharedPtr_FSGSenseGloveImpl*>(Instance)->Ptr->SendHaptics(
+        StaticCast<FSGIC_ESGSenseGloveThumperCommand*>(ThumperCommand)->Command);
+}
+
 void SGCoreImpl_FSGSenseGloveImpl_SendHaptics_ForceFeedbackCommand(
    void* Instance,
    void* ForceFeedbackCommand)
@@ -426,6 +426,20 @@ bool FSGSenseGloveImpl::GetHandPose(const FSGHandProfileImpl& HandProfile, FSGHa
    return bResult;
 }

+bool FSGSenseGloveImpl::SendHaptics(const FSGForceFeedbackCommandImpl& ForceFeedbackCommand,
+                                    const FSGBuzzCommandImpl& BuzzCommand,
+                                    ESGSenseGloveThumperCommand ThumperCommand)
+{
+    return ToSenseGlovePtrChecked()->SendHaptics(ForceFeedbackCommand.ToForceFeedbackCommand(),
+                                                 BuzzCommand.ToBuzzCommand(),
+                                                 FSGCoreEnumCast::ToESenseGloveThumperCommand(ThumperCommand));
+}
+
+bool FSGSenseGloveImpl::SendHaptics(ESGSenseGloveThumperCommand ThumperCommand)
+{
+    return ToSenseGlovePtrChecked()->SendHaptics(FSGCoreEnumCast::ToESenseGloveThumperCommand(ThumperCommand));
+}
+
 void FSGSenseGloveImpl::SendHaptics(const FSGForceFeedbackCommandImpl& ForceFeedbackCommand)
 {
    ToSenseGlovePtrChecked()->SendHaptics(ForceFeedbackCommand.ToForceFeedbackCommand());
@@ -2522,6 +2522,17 @@ SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGSenseGloveImpl_GetHandPose_Hand
    void* HandProfile,
    void* OutHandPose);

+SENSEGLOVECOREIMPL_PUBLIC_API bool
+SGCoreImpl_FSGSenseGloveImpl_SendHaptics_ForceFeedbackCommand_BuzzCommand_ESenseGloveThumperCommand(
+    void* Instance,
+    void* ForceFeedbackCommand,
+    void* BuzzCommand,
+    void* ThumperCommand);
+
+SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGSenseGloveImpl_SendHaptics_ThumperCommand(
+    void* Instance,
+    void* ThumperCommand);
+
 SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveImpl_SendHaptics_ForceFeedbackCommand(
    void* Instance,
    void* ForceFeedbackCommand);
@@ -3236,7 +3247,8 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTimedBuzzCommandImpl_ctor_BaseC
    float DurationSeconds,
    float StartTimeSeconds);

-SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTimedBuzzCommandImpl_ctor_BaseCommand_DurationSeconds_StartTimeSeconds_MakeShared(
+SENSEGLOVECOREIMPL_PUBLIC_API void
+SGCoreImpl_FSGTimedBuzzCommandImpl_ctor_BaseCommand_DurationSeconds_StartTimeSeconds_MakeShared(
    void* OutSharedPtr,
    void* BaseCommand,
    float DurationSeconds,
@@ -236,6 +236,17 @@ public:
    virtual bool GetHandPose(const FSGHandProfileImpl& HandProfile, FSGHandPoseImpl& OutHandPose) override;

 public:
+    /// HACK
+    /// 'FSGSenseGloveImpl::SendHaptics' hides overloaded virtual functions [-Werror,-Woverloaded-virtual]
+    /// tell the compiler we want both the SendHaptics from FSGHapticGloveImpl and FSGSenseGloveImpl
+    using FSGHapticGloveImpl::SendHaptics;
+
+    bool SendHaptics(const FSGForceFeedbackCommandImpl& ForceFeedbackCommand,
+                     const FSGBuzzCommandImpl& BuzzCommand,
+                     ESGSenseGloveThumperCommand ThumperCommand = ESGSenseGloveThumperCommand::None);
+
+    bool SendHaptics(ESGSenseGloveThumperCommand ThumperCommand);
+
    virtual void SendHaptics(const FSGForceFeedbackCommandImpl& ForceFeedbackCommand) override;

    virtual void SendHaptics(const FSGBuzzCommandImpl& BuzzCommand) override;