/**
 * @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/SGSenseGlove.h"

#include "Runtime/Launch/Resources/Version.h"

#include "SGCore/SGBuzzCommand.h"
#include "SGCore/SGDeviceImplCast.h"
#include "SGCore/SGForceFeedbackCommand.h"
#include "SGCoreImpl/SGDeviceImpl.h"
#include "SGCoreImpl/SGHapticGloveImpl.h"
#include "SGCoreImpl/SGExportedFunctions.h"
#include "SGCoreImpl/SGSenseGloveImpl.h"
#include "SGInterop/SGIC_ESGDeviceType.h"
#include "SGInterop/SGIC_ESGFinger.h"
#include "SGInterop/SGIC_ESGPositionalTrackingHardware.h"
#include "SGInterop/SGIC_ESGSenseGloveThumperCommand.h"
#include "SGInterop/SGIC_FQuat.h"
#include "SGInterop/SGIC_FSGBasicHandModelImpl.h"
#include "SGInterop/SGIC_FSGBuzzCommandImpl.h"
#include "SGInterop/SGIC_FSGForceFeedbackCommandImpl.h"
#include "SGInterop/SGIC_FSGHandPoseImpl.h"
#include "SGInterop/SGIC_FSGHandProfileImpl.h"
#include "SGInterop/SGIC_FSGSenseGloveHandProfileImpl.h"
#include "SGInterop/SGIC_FSGSenseGloveImpl.h"
#include "SGInterop/SGIC_FSGSenseGloveInfoImpl.h"
#include "SGInterop/SGIC_FSGSenseGlovePoseImpl.h"
#include "SGInterop/SGIC_FSGSenseGloveSensorDataImpl.h"
#include "SGInterop/SGIC_FSGThumperCommandImpl.h"
#include "SGInterop/SGIC_FString.h"
#include "SGInterop/SGIC_FVector.h"
#include "SGInterop/SGIC_TArray_FSGSenseGloveImpl.h"
#include "SGInterop/SGIC_TArray_FVector.h"
#include "SGInterop/SGIC_TArray_TArray_FVector.h"
#include "SGInterop/SGIC_TSharedPtr_FSGSenseGloveImpl.h"

struct USGSenseGlove::FImpl
{
    /************************
     * Member variables
     ************************/


    /************************
     * Owner object
     ************************/

    USGDevice* Owner;

    /************************
     * Constructor / Destructor
     ************************/

    explicit FImpl(USGSenseGlove* InOwner);
    ~FImpl();

    /************************
     * Default copy constructor & copy assignment operator
     ************************/

    FImpl(const FImpl& Rhs) = default;
    FImpl& operator=(const FImpl& Rhs) = default;

    /************************
     * Methods
     ************************/

    void SyncUProperties();

    void SyncImplObject();
};

USGSenseGlove* USGSenseGlove::NewSenseGlove(UObject* Outer, const FSGSenseGloveImpl& SenseGloveImpl)
{
    USGSenseGlove* Instance = NewObject<USGSenseGlove>(Outer);
    Instance->SetSGDeviceImpl(SenseGloveImpl);
    return Instance;
}

USGSenseGlove* USGSenseGlove::NewSenseGlove(UObject* Outer, TSharedRef<FSGSenseGloveImpl> SenseGloveImpl)
{
    USGSenseGlove* Instance = NewObject<USGSenseGlove>(Outer);
    Instance->SetSGDeviceImpl(MoveTemp(SenseGloveImpl));
    return Instance;
}

USGSenseGlove* USGSenseGlove::NewSenseGlove(UObject* Outer)
{
    FSGIC_TSharedPtr_FSGSenseGloveImpl OutSharedPtrContainer;
    SGCoreImpl_FSGSenseGloveImpl_ctor_MakeShared(&OutSharedPtrContainer);

    return NewSenseGlove(Outer, OutSharedPtrContainer.Ptr.ToSharedRef());
}

USGSenseGlove* USGSenseGlove::NewSenseGlove(UObject* Outer, const USGSenseGloveInfo& Model)
{
    FSGIC_TSharedPtr_FSGSenseGloveImpl OutSharedPtrContainer;
    FSGIC_FSGSenseGloveInfoImpl ModelContainer{Model.ToSenseGloveInfoImpl()};
    SGCoreImpl_FSGSenseGloveImpl_ctor_Model_MakeShared(&OutSharedPtrContainer, &ModelContainer);

    return NewSenseGlove(Outer, OutSharedPtrContainer.Ptr.ToSharedRef());
}

ANSICHAR USGSenseGlove::GetHapticsByte()
{
    return SGCoreImpl_FSGSenseGloveImpl_GetHapticsByte();
}

ANSICHAR USGSenseGlove::GetThumperByte()
{
    return SGCoreImpl_FSGSenseGloveImpl_GetThumperByte();
}

USGSenseGlovePose* USGSenseGlove::CalculateGlovePose(UObject* Outer,
                                                     const USGSenseGloveSensorData* SensorData,
                                                     const USGSenseGloveInfo* GloveModel)
{
    FSGIC_FSGSenseGlovePoseImpl OutPoseContainer;
    FSGIC_FSGSenseGloveSensorDataImpl SensorDataContainer{SensorData->ToSenseGloveSensorDataImpl()};
    FSGIC_FSGSenseGloveInfoImpl GloveModelContainer{GloveModel->ToSenseGloveInfoImpl()};
    SGCoreImpl_FSGSenseGloveImpl_CalculateGlovePose_SensorData_GloveModel(
        &OutPoseContainer, &SensorDataContainer, &GloveModelContainer);

    return USGSenseGlovePose::NewSenseGlovePose(Outer, MoveTemp(OutPoseContainer.SenseGlovePoseImpl));
}

USGSenseGlovePose* USGSenseGlove::CalculateGlovePose(UObject* Outer,
                                                     const TArray<TArray<FVector>>& GloveAngles,
                                                     const USGSenseGloveInfo* GloveModel)
{
    FSGIC_FSGSenseGlovePoseImpl OutPoseContainer;
    FSGIC_TArray_TArray_FVector GloveAnglesContainer{GloveAngles};
    FSGIC_FSGSenseGloveInfoImpl GloveModelContainer{GloveModel->ToSenseGloveInfoImpl()};
    SGCoreImpl_FSGSenseGloveImpl_CalculateGlovePose_GloveAngles_GloveModel(
        &OutPoseContainer, &GloveAnglesContainer, &GloveModelContainer);

    return USGSenseGlovePose::NewSenseGlovePose(Outer, MoveTemp(OutPoseContainer.SenseGlovePoseImpl));
}

USGHandPose* USGSenseGlove::CalculateHandPose(UObject* Outer,
                                              const USGSenseGlovePose* GlovePose,
                                              const USGBasicHandModel* HandModel,
                                              const USGSenseGloveHandProfile* Profile)
{
    FSGIC_FSGHandPoseImpl OutPoseContainer;
    FSGIC_FSGSenseGlovePoseImpl GlovePoseContainer{GlovePose->ToSenseGlovePoseImpl()};
    FSGIC_FSGBasicHandModelImpl HandModelContainer{HandModel->ToBasicHandModelImpl()};
    FSGIC_FSGSenseGloveHandProfileImpl ProfileContainer{Profile->ToSenseGloveHandProfileImpl()};
    SGCoreImpl_FSGSenseGloveImpl_CalculateHandPose(
        &OutPoseContainer, &GlovePoseContainer, &HandModelContainer, &ProfileContainer);

    return USGHandPose::NewHandPose(Outer, MoveTemp(OutPoseContainer.HandPoseImpl));
}

USGDevice* USGSenseGlove::Parse(UObject* Outer, const FString& ConstantsString)
{
    FSGIC_FSGSenseGloveImpl OutSenseGloveImplContainer;
    FSGIC_FString ConstantsStringContainer{ConstantsString};
    SGCoreImpl_FSGSenseGloveImpl_Parse(&OutSenseGloveImplContainer, &ConstantsStringContainer);

    return NewSenseGlove(Outer, MoveTemp(OutSenseGloveImplContainer.SenseGloveImpl));
}

TArray<USGSenseGlove*> USGSenseGlove::GetSenseGloves(UObject* Outer)
{
    FSGIC_TArray_FSGSenseGloveImpl OutGlovesContainer;
    SGCoreImpl_FSGSenseGloveImpl_GetSenseGloves(&OutGlovesContainer);
    TArray<USGSenseGlove*> Gloves;
    for (const FSGSenseGloveImpl& SenseGloveImpl: OutGlovesContainer.Array)
    {
        USGSenseGlove* SenseGlove = USGSenseGlove::NewSenseGlove(Outer, SenseGloveImpl);
        Gloves.Add(SenseGlove);
    }
    return MoveTemp(Gloves);
}

bool USGSenseGlove::GetSenseGlove(UObject* Outer, USGSenseGlove*& OutGlove)
{
    FSGIC_FSGSenseGloveImpl OutGloveContainer;
    const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetSenseGlove_OutGlove(&OutGloveContainer);

    if (bResult)
    {
        OutGlove = NewSenseGlove(Outer, MoveTemp(OutGloveContainer.SenseGloveImpl));
    }

    return bResult;
}

bool USGSenseGlove::GetSenseGlove(UObject* Outer, const bool bRightHanded, USGSenseGlove*& OutGlove)
{
    FSGIC_FSGSenseGloveImpl OutGloveContainer;
    const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetSenseGlove_bRightHanded_OutGlove(
        bRightHanded, &OutGloveContainer);

    if (bResult)
    {
        OutGlove = NewSenseGlove(Outer, MoveTemp(OutGloveContainer.SenseGloveImpl));
    }

    return bResult;
}

TArray<FVector> USGSenseGlove::GetCalibrationValues(const USGSenseGlovePose* GlovePose)
{
    FSGIC_TArray_FVector OutValuesContainer;
    FSGIC_FSGSenseGlovePoseImpl GlovePoseContainer{GlovePose->ToSenseGlovePoseImpl()};
    SGCoreImpl_FSGSenseGloveImpl_GetCalibrationValues_GlovePose(&OutValuesContainer, &GlovePoseContainer);
    return MoveTemp(OutValuesContainer.Array);
}

void USGSenseGlove::CalibrateInterpolation(UObject* Outer,
                                           const TArray<FVector>& MinValues, const TArray<FVector>& MaxValues,
                                           const bool bRightHanded, USGSenseGloveHandProfile*& OutProfile)
{
    FSGIC_TArray_FVector MinValuesContainer{MinValues};
    FSGIC_TArray_FVector MaxValuesContainer{MaxValues};
    FSGIC_FSGSenseGloveHandProfileImpl OutProfileContainer;
    SGCoreImpl_FSGSenseGloveImpl_CalibrateInterpolation(
        &MinValuesContainer, &MaxValuesContainer, bRightHanded, &OutProfileContainer);
    OutProfile = USGSenseGloveHandProfile::NewSenseGloveHandProfile(
        Outer, MoveTemp(OutProfileContainer.SenseGloveHandProfileImpl));
}

void USGSenseGlove::CalculateGloveLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
                                           const ESGPositionalTrackingHardware TrackingHardware,
                                           const bool bRightHanded, const ESGFinger MountedOn,
                                           FVector& OutGlovePosition, FQuat& OutGloveRotation)
{
    FSGIC_FVector ReferencePositionContainer{ReferencePosition};
    FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation};
    FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
    FSGIC_ESGFinger MountedOnContainer{MountedOn};
    FSGIC_FVector OutGlovePositionContainer;
    FSGIC_FQuat OutGloveRotationContainer;

    SGCoreImpl_FSGSenseGloveImpl_CalculateGloveLocation(
        &ReferencePositionContainer, &ReferenceRotationContainer,
        &TrackingHardwareContainer,
        bRightHanded, &MountedOnContainer,
        &OutGlovePositionContainer, &OutGloveRotationContainer);

    OutGlovePosition = MoveTemp(OutGlovePositionContainer.Vector);
    OutGloveRotation = MoveTemp(OutGloveRotationContainer.Quat);
}

void USGSenseGlove::CalculateGloveLocation(const FVector& ReferencePosition, const FRotator& ReferenceRotation,
                                           const ESGPositionalTrackingHardware TrackingHardware,
                                           const bool bRightHanded, const ESGFinger MountedOn,
                                           FVector& OutGlovePosition, FRotator& OutGloveRotation)
{
    FSGIC_FVector ReferencePositionContainer{ReferencePosition};
    FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
    FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
    FSGIC_ESGFinger MountedOnContainer{MountedOn};
    FSGIC_FVector OutGlovePositionContainer;
    FSGIC_FQuat OutGloveRotationContainer;

    SGCoreImpl_FSGSenseGloveImpl_CalculateGloveLocation(
        &ReferencePositionContainer, &ReferenceRotationContainer,
        &TrackingHardwareContainer,
        bRightHanded, &MountedOnContainer,
        &OutGlovePositionContainer, &OutGloveRotationContainer);

    OutGlovePosition = MoveTemp(OutGlovePositionContainer.Vector);
    OutGloveRotation = OutGloveRotationContainer.Quat.Rotator();
}

void USGSenseGlove::CalculateWristLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
                                           const ESGPositionalTrackingHardware TrackingHardware,
                                           const bool bRightHanded, const ESGFinger MountedOn,
                                           const FVector& GloveWristPositionOffset,
                                           const FQuat& GloveWristRotationOffset,
                                           FVector& OutWristPosition, FQuat& OutWristRotation)
{
    FSGIC_FVector ReferencePositionContainer{ReferencePosition};
    FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation};
    FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
    FSGIC_ESGFinger MountedOnContainer{MountedOn};
    FSGIC_FVector GloveWristPositionOffsetContainer{GloveWristPositionOffset};
    FSGIC_FQuat GloveWristRotationOffsetContainer{GloveWristRotationOffset};
    FSGIC_FVector OutWristPositionContainer;
    FSGIC_FQuat OutWristRotationContainer;

    SGCoreImpl_FSGSenseGloveImpl_CalculateWristLocation(
        &ReferencePositionContainer, &ReferenceRotationContainer,
        &TrackingHardwareContainer,
        bRightHanded, &MountedOnContainer,
        &GloveWristPositionOffsetContainer, &GloveWristRotationOffsetContainer,
        &OutWristPositionContainer, &OutWristRotationContainer);

    OutWristPosition = MoveTemp(OutWristPositionContainer.Vector);
    OutWristRotation = MoveTemp(OutWristRotationContainer.Quat);
}

void USGSenseGlove::CalculateWristLocation(const FVector& ReferencePosition, const FRotator& ReferenceRotation,
                                           const ESGPositionalTrackingHardware TrackingHardware,
                                           const bool bRightHanded, const ESGFinger MountedOn,
                                           const FVector& GloveWristPositionOffset,
                                           const FRotator& GloveWristRotationOffset,
                                           FVector& OutWristPosition, FRotator& OutWristRotation)
{
    FSGIC_FVector ReferencePositionContainer{ReferencePosition};
    FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
    FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
    FSGIC_ESGFinger MountedOnContainer{MountedOn};
    FSGIC_FVector GloveWristPositionOffsetContainer{GloveWristPositionOffset};
    FSGIC_FQuat GloveWristRotationOffsetContainer{GloveWristRotationOffset.Quaternion()};
    FSGIC_FVector OutWristPositionContainer;
    FSGIC_FQuat OutWristRotationContainer;

    SGCoreImpl_FSGSenseGloveImpl_CalculateWristLocation(
        &ReferencePositionContainer, &ReferenceRotationContainer,
        &TrackingHardwareContainer,
        bRightHanded, &MountedOnContainer,
        &GloveWristPositionOffsetContainer, &GloveWristRotationOffsetContainer,
        &OutWristPositionContainer, &OutWristRotationContainer);

    OutWristPosition = MoveTemp(OutWristPositionContainer.Vector);
    OutWristRotation = OutWristRotationContainer.Quat.Rotator();
}

USGSenseGlove::USGSenseGlove()
    : USGHapticGlove(),
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
      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 > 24 ) */
{
    FSGIC_TSharedPtr_FSGSenseGloveImpl OutSharedPtrContainer;
    SGCoreImpl_FSGSenseGloveImpl_ctor_MakeShared(&OutSharedPtrContainer);

    SetSGDeviceImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
    Pimpl->SyncUProperties();
}

USGSenseGlove::USGSenseGlove(const USGSenseGloveInfo& Model)
    : USGHapticGlove(),
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
      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 > 24 ) */
{
    FSGIC_TSharedPtr_FSGSenseGloveImpl OutSharedPtrContainer;
    FSGIC_FSGSenseGloveInfoImpl ModelContainer{Model.ToSenseGloveInfoImpl()};
    SGCoreImpl_FSGSenseGloveImpl_ctor_Model_MakeShared(&OutSharedPtrContainer, &ModelContainer);

    SetSGDeviceImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
    Pimpl->SyncUProperties();
}

USGSenseGlove::USGSenseGlove(const FSGDeviceImpl& SGDeviceImpl)
    : USGHapticGlove(SGDeviceImpl),
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
      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 > 24 ) */
{
    Pimpl->SyncUProperties();
}

USGSenseGlove::USGSenseGlove(const FSGHapticGloveImpl& HapticGloveImpl)
    : USGHapticGlove(HapticGloveImpl),
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
      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 > 24 ) */
{
    Pimpl->SyncUProperties();
}

USGSenseGlove::USGSenseGlove(const FSGSenseGloveImpl& SenseGloveImpl)
    : USGHapticGlove(SenseGloveImpl),
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
      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 > 24 ) */
{
    Pimpl->SyncUProperties();
}

USGSenseGlove::USGSenseGlove(TSharedRef<FSGDeviceImpl> SGDeviceImpl)
    : USGHapticGlove(MoveTemp(SGDeviceImpl)),
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
      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 > 24 ) */
{
    Pimpl->SyncUProperties();
}

USGSenseGlove::USGSenseGlove(TSharedRef<FSGHapticGloveImpl> HapticGloveImpl)
    : USGHapticGlove(MoveTemp(HapticGloveImpl)),
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
      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 > 24 ) */
{
    Pimpl->SyncUProperties();
}

USGSenseGlove::USGSenseGlove(TSharedRef<FSGSenseGloveImpl> SenseGloveImpl)
    : USGHapticGlove(MoveTemp(SenseGloveImpl)),
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
      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 > 24 ) */
{
    Pimpl->SyncUProperties();
}

USGSenseGlove::~USGSenseGlove() = default;

TSharedRef<FSGSenseGloveImpl> USGSenseGlove::ToSenseGloveImpl() const
{
    SyncImplObject();
    return FSGDeviceImplCast::ToSenseGloveImpl(ToSGDeviceImpl());
}

void USGSenseGlove::SyncImplObject() const
{
    Super::SyncImplObject();
    Pimpl->SyncImplObject();
}

void USGSenseGlove::SyncUProperties()
{
    Super::SyncUProperties();
    Pimpl->SyncUProperties();
}

USGSenseGloveInfo* USGSenseGlove::GetGloveModel(UObject* Outer) const
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FSGSenseGloveInfoImpl OutModelContainer;
    SGCoreImpl_FSGSenseGloveImpl_GetGloveModel(&InstanceContainer, &OutModelContainer);

    return USGSenseGloveInfo::NewSenseGloveInfo(Outer, MoveTemp(OutModelContainer.SenseGloveInfoImpl));
}

bool USGSenseGlove::IsRight() const
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    return SGCoreImpl_FSGSenseGloveImpl_IsRight(&InstanceContainer);
}

ESGDeviceType USGSenseGlove::GetDeviceType() const
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_ESGDeviceType OutTypeContainer;
    SGCoreImpl_FSGSenseGloveImpl_GetDeviceType(&InstanceContainer, &OutTypeContainer);
    return OutTypeContainer.Type;
}

FString USGSenseGlove::GetDeviceId() const
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FString OutIdContainer;
    SGCoreImpl_FSGSenseGloveImpl_GetDeviceId(&InstanceContainer, &OutIdContainer);
    return MoveTemp(OutIdContainer.String);
}

FString USGSenseGlove::GetHardwareVersion() const
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FString OutVersionContainer;
    SGCoreImpl_FSGSenseGloveImpl_GetHardwareVersion(&InstanceContainer, &OutVersionContainer);
    return MoveTemp(OutVersionContainer.String);
}

int32 USGSenseGlove::GetFirmwareVersion() const
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    return SGCoreImpl_FSGSenseGloveImpl_GetFirmwareVersion(&InstanceContainer);
}

int32 USGSenseGlove::GetSubFirmwareVersion() const
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    return SGCoreImpl_FSGSenseGloveImpl_GetSubFirmwareVersion(&InstanceContainer);
}

bool USGSenseGlove::GetSensorData(UObject* Outer, USGSenseGloveSensorData*& OutSensorData) const
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FSGSenseGloveSensorDataImpl OutSensorDataContainer;
    const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetSensorData(&InstanceContainer, &OutSensorDataContainer);

    if (bResult)
    {
        OutSensorData = USGSenseGloveSensorData::NewSenseGloveSensorData(
            Outer, MoveTemp(OutSensorDataContainer.SenseGloveSensorDataImpl));
    }

    return bResult;
}

bool USGSenseGlove::GetImuRotation(FQuat& OutImu)
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FQuat OutImuContainer;
    const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetImuRotation(&InstanceContainer, &OutImuContainer);

    SyncUProperties();

    if (bResult)
    {
        OutImu = MoveTemp(OutImuContainer.Quat);
    }

    return bResult;
}

bool USGSenseGlove::GetImuRotation(FRotator& OutImu)
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FQuat OutImuContainer;
    const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetImuRotation(&InstanceContainer, &OutImuContainer);

    SyncUProperties();

    if (bResult)
    {
        OutImu = OutImuContainer.Quat.Rotator();
    }

    return bResult;
}

bool USGSenseGlove::GetGlovePose(UObject* Outer, USGSenseGlovePose*& OutGlovePose)
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FSGSenseGlovePoseImpl OutGlovePoseContainer;
    const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetGlovePose_OutGlovePose(
        &InstanceContainer, &OutGlovePoseContainer);

    SyncUProperties();

    if (bResult)
    {
        OutGlovePose = USGSenseGlovePose::NewSenseGlovePose(Outer, MoveTemp(OutGlovePoseContainer.SenseGlovePoseImpl));
    }

    return bResult;
}

bool USGSenseGlove::GetGlovePose(
    UObject* Outer, const USGSenseGloveSensorData* SensorData, USGSenseGlovePose*& OutGlovePose)
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FSGSenseGloveSensorDataImpl SensorDataContainer{SensorData->ToSenseGloveSensorDataImpl()};
    FSGIC_FSGSenseGlovePoseImpl OutGlovePoseContainer;
    const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetGlovePose_SensorData_OutGlovePose(
        &InstanceContainer, &SensorDataContainer, &OutGlovePoseContainer);

    SyncUProperties();

    if (bResult)
    {
        OutGlovePose = USGSenseGlovePose::NewSenseGlovePose(Outer, MoveTemp(OutGlovePoseContainer.SenseGlovePoseImpl));
    }

    return bResult;
}

bool USGSenseGlove::GetHandPose(
    UObject* Outer, const USGBasicHandModel* HandModel, const USGSenseGloveHandProfile* Profile,
    USGHandPose*& OutHandPose)
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FSGBasicHandModelImpl HandModelContainer{HandModel->ToBasicHandModelImpl()};
    FSGIC_FSGSenseGloveHandProfileImpl ProfileContainer{Profile->ToSenseGloveHandProfileImpl()};
    FSGIC_FSGHandPoseImpl OutHandPoseContainer;
    const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetHandPose_HandModel_Profile_OutHandPose(
        &InstanceContainer, &HandModelContainer, &ProfileContainer, &OutHandPoseContainer);

    SyncUProperties();

    if (bResult)
    {
        OutHandPose = USGHandPose::NewHandPose(Outer, MoveTemp(OutHandPoseContainer.HandPoseImpl));
    }

    return bResult;
}

bool USGSenseGlove::GetHandPose(
    UObject* Outer, const USGBasicHandModel* HandGeometry, const USGHandProfile* HandProfile, USGHandPose*& OutHandPose)
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FSGBasicHandModelImpl HandGeometryContainer{HandGeometry->ToBasicHandModelImpl()};
    FSGIC_FSGHandProfileImpl ProfileContainer{HandProfile->ToHandProfileImpl()};
    FSGIC_FSGHandPoseImpl OutHandPoseContainer;
    const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetHandPose_HandGeometry_HandProfile_OutHandPose(
        &InstanceContainer, &HandGeometryContainer, &ProfileContainer, &OutHandPoseContainer);

    SyncUProperties();

    if (bResult)
    {
        OutHandPose = USGHandPose::NewHandPose(Outer, MoveTemp(OutHandPoseContainer.HandPoseImpl));
    }

    return bResult;
}

bool USGSenseGlove::GetHandPose(UObject* Outer, const USGHandProfile* HandProfile, USGHandPose*& OutHandPose)
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FSGHandProfileImpl ProfileContainer{HandProfile->ToHandProfileImpl()};
    FSGIC_FSGHandPoseImpl OutHandPoseContainer;
    const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetHandPose_HandProfile_OutHandPose(
        &InstanceContainer, &ProfileContainer, &OutHandPoseContainer);

    SyncUProperties();

    if (bResult)
    {
        OutHandPose = USGHandPose::NewHandPose(Outer, MoveTemp(OutHandPoseContainer.HandPoseImpl));
    }

    return bResult;
}

bool USGSenseGlove::SendHaptics(const USGForceFeedbackCommand* ForceFeedbackCommand, const USGBuzzCommand* BuzzCommand,
                                ESGSenseGloveThumperCommand ThumperCommand)
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FSGForceFeedbackCommandImpl ForceFeedbackCommandContainer{
        ForceFeedbackCommand->ToForceFeedbackCommandImpl().Get()
    };
    FSGIC_FSGBuzzCommandImpl BuzzCommandContainer{
        BuzzCommand->ToBuzzCommandImpl().Get()
    };
    FSGIC_ESGSenseGloveThumperCommand ThumperCommandContainer{ThumperCommand};
    const bool bResult =
        SGCoreImpl_FSGSenseGloveImpl_SendHaptics_ForceFeedbackCommand_BuzzCommand_ESenseGloveThumperCommand(
            &InstanceContainer, &ForceFeedbackCommandContainer, &BuzzCommandContainer, &ThumperCommandContainer);

    SyncUProperties();

    return bResult;
}

bool USGSenseGlove::SendHaptics(ESGSenseGloveThumperCommand ThumperCommand)
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_ESGSenseGloveThumperCommand ThumperCommandContainer{ThumperCommand};
    const bool bResult = SGCoreImpl_FSGSenseGloveImpl_SendHaptics_ThumperCommand(
        &InstanceContainer, &ThumperCommandContainer);

    SyncUProperties();

    return bResult;
}

void USGSenseGlove::SendHaptics(const USGForceFeedbackCommand* ForceFeedbackCommand)
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FSGForceFeedbackCommandImpl ForceFeedbackCommandContainer{
        ForceFeedbackCommand->ToForceFeedbackCommandImpl().Get()
    };
    SGCoreImpl_FSGSenseGloveImpl_SendHaptics_ForceFeedbackCommand(&InstanceContainer, &ForceFeedbackCommandContainer);

    SyncUProperties();
}

void USGSenseGlove::SendHaptics(const USGBuzzCommand* BuzzCommand)
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FSGBuzzCommandImpl BuzzCommandContainer{BuzzCommand->ToBuzzCommandImpl().Get()};
    SGCoreImpl_FSGSenseGloveImpl_SendHaptics_ForceFeedbackCommand(&InstanceContainer, &BuzzCommandContainer);

    SyncUProperties();
}

void USGSenseGlove::SendHaptics(const USGForceFeedbackCommand* ForceFeedbackCommand,
                                const USGBuzzCommand* BuzzCommand,
                                const USGThumperCommand* ThumperCommand)
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FSGForceFeedbackCommandImpl ForceFeedbackCommandContainer{
        ForceFeedbackCommand->ToForceFeedbackCommandImpl().Get()
    };
    FSGIC_FSGBuzzCommandImpl BuzzCommandContainer{BuzzCommand->ToBuzzCommandImpl().Get()};
    FSGIC_FSGThumperCommandImpl ThumperCommandContainer{ThumperCommand->ToThumperCommandImpl()};
    SGCoreImpl_FSGSenseGloveImpl_SendHaptics_ForceFeedbackCommand_BuzzCommand_ThumperCommand(
        &InstanceContainer, &ForceFeedbackCommandContainer, &BuzzCommandContainer, &ThumperCommandContainer);

    SyncUProperties();
}

bool USGSenseGlove::GetCalibrationValues(TArray<FVector>& OutValues)
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_TArray_FVector OutValuesContainer;
    const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetCalibrationValues_OutValues(
        &InstanceContainer, &OutValuesContainer);

    SyncUProperties();

    if (bResult)
    {
        OutValues = MoveTemp(OutValuesContainer.Array);
    }

    return bResult;
}

void USGSenseGlove::ResetCalibrationRange()
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    SGCoreImpl_FSGSenseGloveImpl_ResetCalibrationRange(&InstanceContainer);

    SyncUProperties();
}

void USGSenseGlove::ApplyCalibration(UObject* Outer, USGHandProfile*& OutProfile) const
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FSGHandProfileImpl OutProfileContainer;
    SGCoreImpl_FSGSenseGloveImpl_ApplyCalibration_HandProfile(&InstanceContainer, &OutProfileContainer);
    OutProfile = USGHandProfile::NewHandProfile(Outer, MoveTemp(OutProfileContainer.HandProfileImpl));
}

void USGSenseGlove::ApplyCalibration(UObject* Outer, USGSenseGloveHandProfile*& OutProfile) const
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FSGSenseGloveHandProfileImpl OutProfileContainer;
    SGCoreImpl_FSGSenseGloveImpl_ApplyCalibration_SenseGloveHandProfile(&InstanceContainer, &OutProfileContainer);
    OutProfile = USGSenseGloveHandProfile::NewSenseGloveHandProfile(
        Outer, MoveTemp(OutProfileContainer.SenseGloveHandProfileImpl));
}

void USGSenseGlove::GetGloveLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
                                     const ESGPositionalTrackingHardware TrackingHardware,
                                     FVector& OutGlovePosition, FQuat& OutGloveRotation) const
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FVector ReferencePositionContainer{ReferencePosition};
    FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation};
    FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
    FSGIC_FVector OutGlovePositionContainer;
    FSGIC_FQuat OutGloveRotationContainer;

    SGCoreImpl_FSGSenseGloveImpl_GetGloveLocation_ReferencePosition_ReferenceRotation_TrackingHardware_OutGlovePosition_OutGloveRotation(
        &InstanceContainer,
        &ReferencePositionContainer, &ReferenceRotationContainer,
        &TrackingHardwareContainer,
        &OutGlovePositionContainer, &OutGloveRotationContainer);

    OutGlovePosition = MoveTemp(OutGlovePositionContainer.Vector);
    OutGloveRotation = MoveTemp(OutGloveRotationContainer.Quat);
}

void USGSenseGlove::GetGloveLocation(const FVector& ReferencePosition, const FRotator& ReferenceRotation,
                                     const ESGPositionalTrackingHardware TrackingHardware,
                                     FVector& OutGlovePosition, FRotator& OutGloveRotation) const
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FVector ReferencePositionContainer{ReferencePosition};
    FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
    FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
    FSGIC_FVector OutGlovePositionContainer;
    FSGIC_FQuat OutGloveRotationContainer;

    SGCoreImpl_FSGSenseGloveImpl_GetGloveLocation_ReferencePosition_ReferenceRotation_TrackingHardware_OutGlovePosition_OutGloveRotation(
        &InstanceContainer,
        &ReferencePositionContainer, &ReferenceRotationContainer,
        &TrackingHardwareContainer,
        &OutGlovePositionContainer, &OutGloveRotationContainer);

    OutGlovePosition = MoveTemp(OutGlovePositionContainer.Vector);
    OutGloveRotation = OutGloveRotationContainer.Quat.Rotator();
}

void USGSenseGlove::GetGloveLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
                                     const ESGPositionalTrackingHardware TrackingHardware, const ESGFinger MountedOn,
                                     FVector& OutGlovePosition, FQuat& OutGloveRotation) const
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FVector ReferencePositionContainer{ReferencePosition};
    FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation};
    FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
    FSGIC_ESGFinger MountedOnContainer{MountedOn};
    FSGIC_FVector OutGlovePositionContainer;
    FSGIC_FQuat OutGloveRotationContainer;

    SGCoreImpl_FSGSenseGloveImpl_GetGloveLocation_ReferencePosition_ReferenceRotation_TrackingHardware_MountedOn_OutGlovePosition_OutGloveRotation(
        &InstanceContainer,
        &ReferencePositionContainer, &ReferenceRotationContainer,
        &TrackingHardwareContainer, &MountedOnContainer,
        &OutGlovePositionContainer, &OutGloveRotationContainer);

    OutGlovePosition = MoveTemp(OutGlovePositionContainer.Vector);
    OutGloveRotation = MoveTemp(OutGloveRotationContainer.Quat);
}

void USGSenseGlove::GetGloveLocation(const FVector& ReferencePosition, const FRotator& ReferenceRotation,
                                     const ESGPositionalTrackingHardware TrackingHardware, const ESGFinger MountedOn,
                                     FVector& OutGlovePosition, FRotator& OutGloveRotation) const
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FVector ReferencePositionContainer{ReferencePosition};
    FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
    FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
    FSGIC_ESGFinger MountedOnContainer{MountedOn};
    FSGIC_FVector OutGlovePositionContainer;
    FSGIC_FQuat OutGloveRotationContainer;

    SGCoreImpl_FSGSenseGloveImpl_GetGloveLocation_ReferencePosition_ReferenceRotation_TrackingHardware_MountedOn_OutGlovePosition_OutGloveRotation(
        &InstanceContainer,
        &ReferencePositionContainer, &ReferenceRotationContainer,
        &TrackingHardwareContainer, &MountedOnContainer,
        &OutGlovePositionContainer, &OutGloveRotationContainer);

    OutGlovePosition = MoveTemp(OutGlovePositionContainer.Vector);
    OutGloveRotation = OutGloveRotationContainer.Quat.Rotator();
}

void USGSenseGlove::GetWristLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
                                     const ESGPositionalTrackingHardware TrackingHardware,
                                     FVector& OutWristPosition, FQuat& OutWristRotation) const
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FVector ReferencePositionContainer{ReferencePosition};
    FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation};
    FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
    FSGIC_FVector OutWristPositionContainer;
    FSGIC_FQuat OutWristRotationContainer;
    SGCoreImpl_FSGSenseGloveImpl_GetWristLocation_ReferencePosition_ReferenceRotation_TrackingHardware_OutWristPosition_OutWristRotation(
        &InstanceContainer,
        &ReferencePositionContainer, &ReferenceRotationContainer,
        &TrackingHardwareContainer,
        &OutWristPositionContainer, &OutWristRotationContainer);

    OutWristPosition = MoveTemp(OutWristPositionContainer.Vector);
    OutWristRotation = MoveTemp(OutWristRotationContainer.Quat);
}

void USGSenseGlove::GetWristLocation(const FVector& ReferencePosition, const FRotator& ReferenceRotation,
                                     const ESGPositionalTrackingHardware TrackingHardware,
                                     FVector& OutWristPosition, FRotator& OutWristRotation) const
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FVector ReferencePositionContainer{ReferencePosition};
    FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
    FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
    FSGIC_FVector OutWristPositionContainer;
    FSGIC_FQuat OutWristRotationContainer;
    SGCoreImpl_FSGSenseGloveImpl_GetWristLocation_ReferencePosition_ReferenceRotation_TrackingHardware_OutWristPosition_OutWristRotation(
        &InstanceContainer,
        &ReferencePositionContainer, &ReferenceRotationContainer,
        &TrackingHardwareContainer,
        &OutWristPositionContainer, &OutWristRotationContainer);

    OutWristPosition = MoveTemp(OutWristPositionContainer.Vector);
    OutWristRotation = OutWristRotationContainer.Quat.Rotator();
}

void USGSenseGlove::GetWristLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
                                     const ESGPositionalTrackingHardware TrackingHardware,
                                     const FVector& GloveWristPositionOffset,
                                     const FQuat& GloveWristRotationOffset,
                                     FVector& OutWristPosition, FQuat& OutWristRotation) const
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FVector ReferencePositionContainer{ReferencePosition};
    FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation};
    FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
    FSGIC_FVector GloveWristPositionOffsetContainer{GloveWristPositionOffset};
    FSGIC_FQuat GloveWristRotationOffsetContainer{GloveWristRotationOffset};
    FSGIC_FVector OutWristPositionContainer;
    FSGIC_FQuat OutWristRotationContainer;
    SGCoreImpl_FSGSenseGloveImpl_GetWristLocation_ReferencePosition_ReferenceRotation_TrackingHardware_GloveWristPositionOffset_GloveWristRotationOffset_OutWristPosition_OutWristRotation(
        &InstanceContainer,
        &ReferencePositionContainer, &ReferenceRotationContainer,
        &TrackingHardwareContainer,
        &GloveWristPositionOffsetContainer, &GloveWristRotationOffsetContainer,
        &OutWristPositionContainer, &OutWristRotationContainer);

    OutWristPosition = MoveTemp(OutWristPositionContainer.Vector);
    OutWristRotation = MoveTemp(OutWristRotationContainer.Quat);
}

void USGSenseGlove::GetWristLocation(const FVector& ReferencePosition, const FRotator& ReferenceRotation,
                                     const ESGPositionalTrackingHardware TrackingHardware,
                                     const FVector& GloveWristPositionOffset,
                                     const FRotator& GloveWristRotationOffset,
                                     FVector& OutWristPosition, FRotator& OutWristRotation) const
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FVector ReferencePositionContainer{ReferencePosition};
    FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
    FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
    FSGIC_FVector GloveWristPositionOffsetContainer{GloveWristPositionOffset};
    FSGIC_FQuat GloveWristRotationOffsetContainer{GloveWristRotationOffset.Quaternion()};
    FSGIC_FVector OutWristPositionContainer;
    FSGIC_FQuat OutWristRotationContainer;
    SGCoreImpl_FSGSenseGloveImpl_GetWristLocation_ReferencePosition_ReferenceRotation_TrackingHardware_GloveWristPositionOffset_GloveWristRotationOffset_OutWristPosition_OutWristRotation(
        &InstanceContainer,
        &ReferencePositionContainer, &ReferenceRotationContainer,
        &TrackingHardwareContainer,
        &GloveWristPositionOffsetContainer, &GloveWristRotationOffsetContainer,
        &OutWristPositionContainer, &OutWristRotationContainer);

    OutWristPosition = MoveTemp(OutWristPositionContainer.Vector);
    OutWristRotation = OutWristRotationContainer.Quat.Rotator();
}

FString USGSenseGlove::ToString() const
{
    SyncImplObject();

    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGSenseGloveImpl_ToString(&InstanceContainer, &OutStringContainer);
    return MoveTemp(OutStringContainer.String);;
}

USGSenseGlove::FImpl::FImpl(USGSenseGlove* InOwner)
    : Owner(InOwner)
{
}

USGSenseGlove::FImpl::~FImpl() = default;

void USGSenseGlove::FImplDeleter::operator()(const FImpl* P) const
{
    delete P;
}

void USGSenseGlove::FImpl::SyncUProperties()
{
}

void USGSenseGlove::FImpl::SyncImplObject()
{
}