initial public release

2022-11-02 22:43:14 +01:00
commit ff02526c05
4222 changed files with 85051 additions and 0 deletions
@@ -0,0 +1,311 @@
+/**
+ * @file
+ *
+ * @author  Mamadou Babaei <mamadou@senseglove.com>
+ *
+ * @section LICENSE
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2020 - 2022 SenseGlove
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * @section DESCRIPTION
+ *
+ *
+ */
+
+
+#include "SGCore/SGHapticGloveCalibrationCheck.h"
+
+#include "Runtime/Launch/Resources/Version.h"
+
+#include "SGCoreImpl/SGExportedFunctions.h"
+#include "SGInterop/SGIC_ESGCalibrationStage.h"
+#include "SGInterop/SGIC_ESGDeviceType.h"
+#include "SGInterop/SGIC_FSGHapticGloveCalibrationCheckImpl.h"
+#include "SGInterop/SGIC_FSGSensorRangeImpl.h"
+#include "SGInterop/SGIC_FSGThumperCommandImpl.h"
+#include "SGInterop/SGIC_TArray_FVector.h"
+#include "SGUtils/SGArrayUtils.h"
+
+struct USGHapticGloveCalibrationCheck::FImpl
+{
+    /************************
+     * Member variables
+     ************************/
+
+    FSGHapticGloveCalibrationCheckImpl HapticGloveCalibrationCheckImpl;
+
+    /************************
+     * Owner object
+     ************************/
+
+    USGHapticGloveCalibrationCheck* Owner;
+
+    /************************
+     * Constructor / Destructor
+     ************************/
+
+    explicit FImpl(USGHapticGloveCalibrationCheck* InOwner);
+    ~FImpl();
+
+    /************************
+     * Default copy constructor & copy assignment operator
+     ************************/
+
+    FImpl(const FImpl& Rhs) = default;
+    FImpl& operator=(const FImpl& Rhs) = default;
+
+    /************************
+     * Methods
+     ************************/
+
+    void SyncUProperties();
+    void SyncImplObject();
+};
+
+USGHapticGloveCalibrationCheck* USGHapticGloveCalibrationCheck::NewHapticGloveCalibrationCheck(
+    UObject* Outer, const FSGHapticGloveCalibrationCheckImpl& HapticGloveCalibrationCheckImpl)
+{
+    USGHapticGloveCalibrationCheck* Instance = NewObject<USGHapticGloveCalibrationCheck>(Outer);
+    Instance->SetHapticGloveCalibrationCheckImpl(HapticGloveCalibrationCheckImpl);
+    return Instance;
+}
+
+USGHapticGloveCalibrationCheck* USGHapticGloveCalibrationCheck::NewHapticGloveCalibrationCheck(UObject* Outer)
+{
+    FSGIC_FSGHapticGloveCalibrationCheckImpl OutHapticGloveCalibrationCheckImplContainer;
+    SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_ctor(&OutHapticGloveCalibrationCheckImplContainer);
+
+    return NewHapticGloveCalibrationCheck(
+        Outer, MoveTemp(OutHapticGloveCalibrationCheckImplContainer.HapticGloveCalibrationCheckImpl));
+}
+
+USGHapticGloveCalibrationCheck* USGHapticGloveCalibrationCheck::NewHapticGloveCalibrationCheck(
+    UObject* Outer, const USGSensorRange* LastCalibrationRange)
+{
+    FSGIC_FSGHapticGloveCalibrationCheckImpl OutHapticGloveCalibrationCheckImplContainer;
+    FSGIC_FSGSensorRangeImpl LastCalibrationRangeContainer{LastCalibrationRange->ToSensorRangeImpl()};
+    SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_ctor_LastCalibrationRange(
+        &OutHapticGloveCalibrationCheckImplContainer, &LastCalibrationRangeContainer);
+
+    return NewHapticGloveCalibrationCheck(
+        Outer, MoveTemp(OutHapticGloveCalibrationCheckImplContainer.HapticGloveCalibrationCheckImpl));
+}
+
+float USGHapticGloveCalibrationCheck::GetSenseGloveThreshold()
+{
+    return SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_GetSenseGloveThreshold();
+}
+
+float USGHapticGloveCalibrationCheck::GetNovaGloveThreshold()
+{
+    return SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_GetNovaGloveThreshold();
+}
+
+float USGHapticGloveCalibrationCheck::GetSenseGloveMinFlexion()
+{
+    return SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_GetSenseGloveMinFlexion();
+}
+
+float USGHapticGloveCalibrationCheck::GetNovaGloveMinFlexion()
+{
+    return SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_GetNovaGloveMinFlexion();
+}
+
+float USGHapticGloveCalibrationCheck::GetSenseGloveMinAbduction()
+{
+    return SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_GetSenseGloveMinAbduction();
+}
+
+float USGHapticGloveCalibrationCheck::GetNovaGloveMinAbduction()
+{
+    return SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_GetNovaGloveMinAbduction();
+}
+
+bool USGHapticGloveCalibrationCheck::NeedsCheck(const ESGDeviceType DeviceType)
+{
+    FSGIC_ESGDeviceType DeviceTypeContainer{DeviceType};
+    return SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_NeedsCheck(&DeviceTypeContainer);
+}
+
+int32 USGHapticGloveCalibrationCheck::OutOfBounds(
+    const USGSensorRange* PreviousRange, const TArray<FVector>& CurrentValues, const ESGDeviceType DeviceType)
+{
+    FSGIC_FSGSensorRangeImpl PreviousRangeContainer{PreviousRange->ToSensorRangeImpl()};
+    FSGIC_TArray_FVector CurrentValuesContainer{CurrentValues};
+    FSGIC_ESGDeviceType DeviceTypeContainer{DeviceType};
+    return SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_OutOfBounds(
+        &PreviousRangeContainer, &CurrentValuesContainer, &DeviceTypeContainer);
+}
+
+bool USGHapticGloveCalibrationCheck::MovedMinimum(const TArray<FVector>& CurrentRange, const ESGDeviceType DeviceType)
+{
+    FSGIC_TArray_FVector CurrentRangeContainer{CurrentRange};
+    FSGIC_ESGDeviceType DeviceTypeContainer{DeviceType};
+    return SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_MovedMinimum(&CurrentRangeContainer, &DeviceTypeContainer);
+}
+
+bool USGHapticGloveCalibrationCheck::MatchesLast(const TArray<FVector>& CurrentRange, const TArray<FVector>& LastRange,
+                                                 const ESGDeviceType DeviceType)
+{
+    FSGIC_TArray_FVector CurrentRangeContainer{CurrentRange};
+    FSGIC_TArray_FVector LastRangeContainer{LastRange};
+    FSGIC_ESGDeviceType DeviceTypeContainer{DeviceType};
+    return SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_MatchesLast(
+        &CurrentRangeContainer, &LastRangeContainer, &DeviceTypeContainer);
+}
+
+USGHapticGloveCalibrationCheck::USGHapticGloveCalibrationCheck()
+    :
+#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
+    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
+#else
+    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
+#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 ) */
+{
+    FSGIC_FSGHapticGloveCalibrationCheckImpl OutHapticGloveCalibrationCheckImplContainer;
+    SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_ctor(&OutHapticGloveCalibrationCheckImplContainer);
+
+    Pimpl->HapticGloveCalibrationCheckImpl = MoveTemp(
+        OutHapticGloveCalibrationCheckImplContainer.HapticGloveCalibrationCheckImpl);
+    Pimpl->SyncUProperties();
+}
+
+USGHapticGloveCalibrationCheck::USGHapticGloveCalibrationCheck(const USGSensorRange* LastCalibrationRange)
+    :
+#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
+    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
+#else
+    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
+#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 ) */
+{
+    FSGIC_FSGHapticGloveCalibrationCheckImpl OutHapticGloveCalibrationCheckImplContainer;
+    FSGIC_FSGSensorRangeImpl LastCalibrationRangeContainer{LastCalibrationRange->ToSensorRangeImpl()};
+    SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_ctor_LastCalibrationRange(
+        &OutHapticGloveCalibrationCheckImplContainer, &LastCalibrationRangeContainer);
+
+    Pimpl->HapticGloveCalibrationCheckImpl = MoveTemp(
+        OutHapticGloveCalibrationCheckImplContainer.HapticGloveCalibrationCheckImpl);
+    Pimpl->SyncUProperties();
+}
+
+USGHapticGloveCalibrationCheck::USGHapticGloveCalibrationCheck(
+    const FSGHapticGloveCalibrationCheckImpl& HapticGloveCalibrationCheckImpl)
+    :
+#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
+    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
+#else
+    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
+#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 ) */
+{
+    SetHapticGloveCalibrationCheckImpl(HapticGloveCalibrationCheckImpl);
+    Pimpl->SyncUProperties();
+}
+
+USGHapticGloveCalibrationCheck::~USGHapticGloveCalibrationCheck() = default;
+
+void USGHapticGloveCalibrationCheck::SetHapticGloveCalibrationCheckImpl(
+    const FSGHapticGloveCalibrationCheckImpl& HapticGloveCalibrationCheckImpl)
+{
+    FSGIC_FSGHapticGloveCalibrationCheckImpl OutHapticGloveCalibrationCheckContainer;
+    FSGIC_FSGHapticGloveCalibrationCheckImpl RhsContainer{HapticGloveCalibrationCheckImpl};
+    SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_ctor_copy(&OutHapticGloveCalibrationCheckContainer, &RhsContainer);
+    Pimpl->HapticGloveCalibrationCheckImpl = MoveTemp(
+        OutHapticGloveCalibrationCheckContainer.HapticGloveCalibrationCheckImpl);
+}
+
+const FSGHapticGloveCalibrationCheckImpl& USGHapticGloveCalibrationCheck::ToHapticGloveCalibrationCheckImpl() const
+{
+    Pimpl->SyncImplObject();
+    return Pimpl->HapticGloveCalibrationCheckImpl;
+}
+
+USGSensorRange* USGHapticGloveCalibrationCheck::GetLastSensorRange(UObject* Outer) const
+{
+    FSGIC_FSGHapticGloveCalibrationCheckImpl InstanceContainer{ToHapticGloveCalibrationCheckImpl()};
+    FSGIC_FSGSensorRangeImpl OutLastSensorRangeContainer;
+    SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_GetLastSensorRange(&InstanceContainer, &OutLastSensorRangeContainer);
+    return USGSensorRange::NewSensorRange(Outer, MoveTemp(OutLastSensorRangeContainer.SensorRangeImpl));
+}
+
+ESGCalibrationStage USGHapticGloveCalibrationCheck::GetCalibrationStage() const
+{
+    Pimpl->SyncImplObject();
+
+    FSGIC_FSGHapticGloveCalibrationCheckImpl InstanceContainer{ToHapticGloveCalibrationCheckImpl()};
+    FSGIC_ESGCalibrationStage OutStageContainer;
+    SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_GetCalibrationStage(&InstanceContainer, &OutStageContainer);
+
+    return MoveTemp(OutStageContainer.Stage);
+}
+
+bool USGHapticGloveCalibrationCheck::ReachedConclusion() const
+{
+    Pimpl->SyncImplObject();
+
+    FSGIC_FSGHapticGloveCalibrationCheckImpl InstanceContainer{ToHapticGloveCalibrationCheckImpl()};
+    return SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_ReachedConclusion(&InstanceContainer);
+}
+
+void USGHapticGloveCalibrationCheck::Reset()
+{
+    Pimpl->SyncImplObject();
+
+    FSGIC_FSGHapticGloveCalibrationCheckImpl InstanceContainer{ToHapticGloveCalibrationCheckImpl()};
+    SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_Reset(&InstanceContainer);
+
+    Pimpl->SyncUProperties();
+}
+
+void USGHapticGloveCalibrationCheck::CheckRange(
+    const TArray<FVector>& CurrentValues, const float DeltaSeconds, const ESGDeviceType DeviceType)
+{
+    Pimpl->SyncImplObject();
+
+    FSGIC_FSGHapticGloveCalibrationCheckImpl InstanceContainer{ToHapticGloveCalibrationCheckImpl()};
+    FSGIC_TArray_FVector CurrentValuesContainer{CurrentValues};
+    FSGIC_ESGDeviceType DeviceTypeContainer{DeviceType};
+    SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_CheckRange(&InstanceContainer, &CurrentValuesContainer,
+                                                             DeltaSeconds, &DeviceTypeContainer);
+
+    Pimpl->SyncUProperties();
+}
+
+USGHapticGloveCalibrationCheck::FImpl::FImpl(USGHapticGloveCalibrationCheck* InOwner)
+    : Owner(InOwner)
+{
+}
+
+USGHapticGloveCalibrationCheck::FImpl::~FImpl() = default;
+
+void USGHapticGloveCalibrationCheck::FImplDeleter::operator()(const FImpl* P) const
+{
+    delete P;
+}
+
+void USGHapticGloveCalibrationCheck::FImpl::SyncUProperties()
+{
+}
+
+void USGHapticGloveCalibrationCheck::FImpl::SyncImplObject()
+{
+}