1005 lines
41 KiB
C++
1005 lines
41 KiB
C++
/**
|
|
* @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_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 > 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_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 > 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_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 > 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 ) */
|
|
{
|
|
Pimpl->SyncUProperties();
|
|
}
|
|
|
|
USGSenseGlove::USGSenseGlove(const FSGHapticGloveImpl& HapticGloveImpl)
|
|
: USGHapticGlove(HapticGloveImpl),
|
|
#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 ) */
|
|
{
|
|
Pimpl->SyncUProperties();
|
|
}
|
|
|
|
USGSenseGlove::USGSenseGlove(const FSGSenseGloveImpl& SenseGloveImpl)
|
|
: USGHapticGlove(SenseGloveImpl),
|
|
#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 ) */
|
|
{
|
|
Pimpl->SyncUProperties();
|
|
}
|
|
|
|
USGSenseGlove::USGSenseGlove(TSharedRef<FSGDeviceImpl> SGDeviceImpl)
|
|
: USGHapticGlove(MoveTemp(SGDeviceImpl)),
|
|
#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 ) */
|
|
{
|
|
Pimpl->SyncUProperties();
|
|
}
|
|
|
|
USGSenseGlove::USGSenseGlove(TSharedRef<FSGHapticGloveImpl> HapticGloveImpl)
|
|
: USGHapticGlove(MoveTemp(HapticGloveImpl)),
|
|
#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 ) */
|
|
{
|
|
Pimpl->SyncUProperties();
|
|
}
|
|
|
|
USGSenseGlove::USGSenseGlove(TSharedRef<FSGSenseGloveImpl> SenseGloveImpl)
|
|
: USGHapticGlove(MoveTemp(SenseGloveImpl)),
|
|
#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 ) */
|
|
{
|
|
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;
|
|
}
|
|
|
|
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()
|
|
{
|
|
} |