515 lines
19 KiB
C++
515 lines
19 KiB
C++
/**
|
|
* @file
|
|
*
|
|
* @author Mamadou Babaei <mamadou@senseglove.com>
|
|
*
|
|
* @section LICENSE
|
|
*
|
|
* (The MIT License)
|
|
*
|
|
* Copyright (c) 2020 - 2024 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/SGHapticGlove.h"
|
|
|
|
#include "SGCore/SGBasicHandModel.h"
|
|
#include "SGCore/SGCustomWaveform.h"
|
|
#include "SGCore/SGDeviceImplCast.h"
|
|
#include "SGCore/SGSenseGlove.h"
|
|
#include "SGCoreImpl/SGBasicHandModelImpl.h"
|
|
#include "SGCoreImpl/SGCustomWaveformImpl.h"
|
|
#include "SGCoreImpl/SGDeviceImpl.h"
|
|
#include "SGCoreImpl/SGHapticGloveImpl.h"
|
|
#include "SGCoreImpl/SGExportedFunctions.h"
|
|
#include "SGInterop/SGIC_ESGDeviceType.h"
|
|
#include "SGInterop/SGIC_ESGHapticGloveCalibrationState.h"
|
|
#include "SGInterop/SGIC_ESGHapticLocation.h"
|
|
#include "SGInterop/SGIC_ESGPositionalTrackingHardware.h"
|
|
#include "SGInterop/SGIC_FQuat.h"
|
|
#include "SGInterop/SGIC_FSGBasicHandModelImpl.h"
|
|
#include "SGInterop/SGIC_FSGCustomWaveformImpl.h"
|
|
#include "SGInterop/SGIC_FSGHandPoseImpl.h"
|
|
#include "SGInterop/SGIC_FString.h"
|
|
#include "SGInterop/SGIC_FVector.h"
|
|
#include "SGInterop/SGIC_TArray_FVector.h"
|
|
#include "SGInterop/SGIC_TArray_TArray_FVector.h"
|
|
#include "SGInterop/SGIC_TArray_TSharedRef_FSGHapticGloveImpl.h"
|
|
#include "SGInterop/SGIC_TArray_float.h"
|
|
#include "SGInterop/SGIC_TSharedPtr_FSGHapticGloveImpl.h"
|
|
|
|
USGHapticGlove* USGHapticGlove::NewHapticGlove(UObject* Outer, const FSGHapticGloveImpl& HapticGloveImpl)
|
|
{
|
|
USGHapticGlove* Instance = NewObject<USGHapticGlove>(Outer);
|
|
Instance->SetSGDeviceImpl(HapticGloveImpl);
|
|
return Instance;
|
|
}
|
|
|
|
USGHapticGlove* USGHapticGlove::NewHapticGlove(UObject* Outer, TSharedRef<FSGHapticGloveImpl> HapticGloveImpl)
|
|
{
|
|
USGHapticGlove* Instance = NewObject<USGHapticGlove>(Outer);
|
|
Instance->SetSGDeviceImpl(MoveTemp(HapticGloveImpl));
|
|
return Instance;
|
|
}
|
|
|
|
USGHapticGlove* USGHapticGlove::NewHapticGlove(UObject* Outer)
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl OutSharedPtrContainer;
|
|
SGCoreImpl_FSGBetaDeviceImpl_ctor_MakeShared(&OutSharedPtrContainer);
|
|
|
|
return NewHapticGlove(Outer, OutSharedPtrContainer.Ptr.ToSharedRef());
|
|
}
|
|
|
|
TArray<USGHapticGlove*> USGHapticGlove::GetHapticGloves(UObject* Outer, const bool bConnectedOnly)
|
|
{
|
|
FSGIC_TArray_TSharedRef_FSGHapticGloveImpl OutGlovesContainer;
|
|
SGCoreImpl_FSGHapticGloveImpl_GetHapticGloves(&OutGlovesContainer, bConnectedOnly);
|
|
TArray<USGHapticGlove*> HapticGloves;
|
|
for (TSharedRef<FSGHapticGloveImpl> HapticGloveImpl: OutGlovesContainer.Array)
|
|
{
|
|
HapticGloves.Add(NewHapticGlove(Outer, MoveTemp(HapticGloveImpl)));
|
|
}
|
|
return HapticGloves;
|
|
}
|
|
|
|
bool USGHapticGlove::GetGlove(UObject* Outer, USGHapticGlove*& OutGlove)
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl OutGloveContainer;
|
|
const bool bResult = SGCoreImpl_FSGHapticGloveImpl_GetGlove_OutGlove(&OutGloveContainer);
|
|
|
|
if (bResult)
|
|
{
|
|
OutGlove = NewHapticGlove(Outer, OutGloveContainer.Ptr.ToSharedRef());
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
bool USGHapticGlove::GetGlove(UObject* Outer, const bool bRightHanded, USGHapticGlove*& OutGlove)
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl OutGloveContainer;
|
|
|
|
const bool bResult = SGCoreImpl_FSGHapticGloveImpl_GetGlove_bRightHanded_OutGlove(
|
|
bRightHanded, &OutGloveContainer);
|
|
if (bResult)
|
|
{
|
|
OutGlove = NewHapticGlove(Outer, OutGloveContainer.Ptr.ToSharedRef());
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
FString USGHapticGlove::ToString(const ESGHapticGloveCalibrationState State)
|
|
{
|
|
FSGIC_ESGHapticGloveCalibrationState StateContainer{State};
|
|
FSGIC_FString OutStringContainer;
|
|
SGCoreImpl_FSGHapticGloveImpl_ToString_State(&StateContainer, &OutStringContainer);
|
|
return OutStringContainer.String;
|
|
}
|
|
|
|
FString USGHapticGlove::ToString(const ESGHapticLocation Location)
|
|
{
|
|
FSGIC_ESGHapticLocation LocationContainer{Location};
|
|
FSGIC_FString OutStringContainer;
|
|
SGCoreImpl_FSGHapticGloveImpl_ToString_Location(&LocationContainer, &OutStringContainer);
|
|
return OutStringContainer.String;
|
|
}
|
|
|
|
USGHapticGlove::USGHapticGlove()
|
|
: USGDevice()
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl OutSharedPtrContainer;
|
|
SGCoreImpl_FSGBetaDeviceImpl_ctor_MakeShared(&OutSharedPtrContainer);
|
|
|
|
SetSGDeviceImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
|
|
}
|
|
|
|
USGHapticGlove::USGHapticGlove(const FSGDeviceImpl& SGDeviceImpl)
|
|
: USGDevice(SGDeviceImpl)
|
|
{
|
|
}
|
|
|
|
USGHapticGlove::USGHapticGlove(const FSGHapticGloveImpl& HapticGloveImpl)
|
|
: USGDevice(HapticGloveImpl)
|
|
{
|
|
}
|
|
|
|
USGHapticGlove::USGHapticGlove(const FSGNova2GloveImpl& Nova2GloveImpl)
|
|
: USGDevice(Nova2GloveImpl)
|
|
{
|
|
}
|
|
|
|
USGHapticGlove::USGHapticGlove(const FSGNovaGloveImpl& NovaGloveImpl)
|
|
: USGDevice(NovaGloveImpl)
|
|
{
|
|
}
|
|
|
|
USGHapticGlove::USGHapticGlove(const FSGSenseGloveImpl& SenseGloveImpl)
|
|
: USGDevice(SenseGloveImpl)
|
|
{
|
|
}
|
|
|
|
USGHapticGlove::USGHapticGlove(TSharedRef<FSGDeviceImpl> SGDeviceImpl)
|
|
: USGDevice(MoveTemp(SGDeviceImpl))
|
|
{
|
|
}
|
|
|
|
USGHapticGlove::USGHapticGlove(TSharedRef<FSGHapticGloveImpl> HapticGloveImpl)
|
|
: USGDevice(MoveTemp(HapticGloveImpl))
|
|
{
|
|
}
|
|
|
|
USGHapticGlove::USGHapticGlove(TSharedRef<FSGNova2GloveImpl> Nova2GloveImpl)
|
|
: USGDevice(MoveTemp(Nova2GloveImpl))
|
|
{
|
|
}
|
|
|
|
USGHapticGlove::USGHapticGlove(TSharedRef<FSGNovaGloveImpl> NovaGloveImpl)
|
|
: USGDevice(MoveTemp(NovaGloveImpl))
|
|
{
|
|
}
|
|
|
|
USGHapticGlove::USGHapticGlove(TSharedRef<FSGSenseGloveImpl> SenseGloveImpl)
|
|
: USGDevice(MoveTemp(SenseGloveImpl))
|
|
{
|
|
}
|
|
|
|
USGHapticGlove::~USGHapticGlove() = default;
|
|
|
|
TSharedRef<FSGHapticGloveImpl> USGHapticGlove::ToHapticGloveImpl() const
|
|
{
|
|
return FSGDeviceImplCast::ToHapticGloveImpl(ToSGDeviceImpl());
|
|
}
|
|
|
|
ESGDeviceType USGHapticGlove::GetDeviceType() const
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_ESGDeviceType OutTypeContainer;
|
|
SGCoreImpl_FSGHapticGloveImpl_GetDeviceType(&InstanceContainer, &OutTypeContainer);
|
|
return OutTypeContainer.Type;
|
|
}
|
|
|
|
FString USGHapticGlove::GetDeviceId() const
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_FString OutIdContainer;
|
|
SGCoreImpl_FSGHapticGloveImpl_GetDeviceId(&InstanceContainer, &OutIdContainer);
|
|
return OutIdContainer.String;
|
|
}
|
|
|
|
FString USGHapticGlove::GetHardwareVersion() const
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_FString OutVersionContainer;
|
|
SGCoreImpl_FSGHapticGloveImpl_GetHardwareVersion(&InstanceContainer, &OutVersionContainer);
|
|
return OutVersionContainer.String;
|
|
}
|
|
|
|
int32 USGHapticGlove::GetFirmwareVersion() const
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
return SGCoreImpl_FSGHapticGloveImpl_GetFirmwareVersion(&InstanceContainer);
|
|
}
|
|
|
|
int32 USGHapticGlove::GetSubFirmwareVersion() const
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
return SGCoreImpl_FSGHapticGloveImpl_GetSubFirmwareVersion(&InstanceContainer);
|
|
}
|
|
|
|
bool USGHapticGlove::IsRight() const
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
return SGCoreImpl_FSGHapticGloveImpl_IsRight(&InstanceContainer);
|
|
}
|
|
|
|
bool USGHapticGlove::GetImuRotation(FQuat& OutImu)
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_FQuat OutImuContainer;
|
|
const bool bResult = SGCoreImpl_FSGHapticGloveImpl_GetImuRotation(&InstanceContainer, &OutImuContainer);
|
|
|
|
if (bResult)
|
|
{
|
|
OutImu = MoveTemp(OutImuContainer.Quat);
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
bool USGHapticGlove::GetImuRotation(FRotator& OutImu)
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_FQuat OutImuContainer;
|
|
const bool bResult = SGCoreImpl_FSGHapticGloveImpl_GetImuRotation(&InstanceContainer, &OutImuContainer);
|
|
|
|
if (bResult)
|
|
{
|
|
OutImu = OutImuContainer.Quat.Rotator();
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
bool USGHapticGlove::GetHandPose(
|
|
UObject* Outer, const USGBasicHandModel* HandGeometry, USGHandPose*& OutHandPose) const
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_FSGBasicHandModelImpl HandGeometryContainer{HandGeometry->ToBasicHandModelImpl()};
|
|
FSGIC_FSGHandPoseImpl OutHandPoseContainer;
|
|
const bool bResult = SGCoreImpl_FSGHapticGloveImpl_GetHandPose_HandGeometry_OutHandPose(
|
|
&InstanceContainer, &HandGeometryContainer, &OutHandPoseContainer);
|
|
|
|
if (bResult)
|
|
{
|
|
OutHandPose = USGHandPose::NewHandPose(Outer, MoveTemp(OutHandPoseContainer.HandPoseImpl));
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
bool USGHapticGlove::GetHandPose(UObject* Outer, USGHandPose*& OutHandPose)
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_FSGHandPoseImpl OutHandPoseContainer;
|
|
const bool bResult = SGCoreImpl_FSGHapticGloveImpl_GetHandPose_OutHandPose(
|
|
&InstanceContainer, &OutHandPoseContainer);
|
|
|
|
if (bResult)
|
|
{
|
|
OutHandPose = USGHandPose::NewHandPose(Outer, MoveTemp(OutHandPoseContainer.HandPoseImpl));
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
bool USGHapticGlove::GetHandAngles(TArray<TArray<FVector>>& OutHandAngles) const
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_TArray_TArray_FVector OutHandAnglesContainer;
|
|
const bool bResult = SGCoreImpl_FSGHapticGloveImpl_GetHandAngles_OutHandAngles(
|
|
&InstanceContainer, &OutHandAnglesContainer);
|
|
|
|
if (bResult)
|
|
{
|
|
OutHandAngles = MoveTemp(OutHandAnglesContainer.Array);
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
USGBasicHandModel* USGHapticGlove::GetHandGeometry(UObject* Outer) const
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_FSGBasicHandModelImpl OutBasicHandModelContainer;
|
|
SGCoreImpl_FSGHapticGloveImpl_GetHandGeometry(&InstanceContainer, &OutBasicHandModelContainer);
|
|
return USGBasicHandModel::NewBasicHandModel(Outer, MoveTemp(OutBasicHandModelContainer.BasicHandModelImpl));
|
|
}
|
|
|
|
void USGHapticGlove::SetHandGeometry(const USGBasicHandModel* HandGeometry)
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_FSGBasicHandModelImpl HandGeometryContainer{HandGeometry->ToBasicHandModelImpl()};
|
|
SGCoreImpl_FSGHapticGloveImpl_SetHandGeometry(&InstanceContainer, &HandGeometryContainer);
|
|
}
|
|
|
|
ESGHapticGloveCalibrationState USGHapticGlove::GetCalibrationState() const
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_ESGHapticGloveCalibrationState OutHapticGloveCalibrationStateContainer;
|
|
SGCoreImpl_FSGHapticGloveImpl_GetCalibrationState(&InstanceContainer, &OutHapticGloveCalibrationStateContainer);
|
|
return OutHapticGloveCalibrationStateContainer.State;
|
|
}
|
|
|
|
void USGHapticGlove::EndCalibration()
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
SGCoreImpl_FSGHapticGloveImpl_EndCalibration(&InstanceContainer);
|
|
}
|
|
|
|
void USGHapticGlove::ResetCalibration()
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
SGCoreImpl_FSGHapticGloveImpl_ResetCalibration(&InstanceContainer);
|
|
}
|
|
|
|
FString USGHapticGlove::GetCalibrationInstruction() const
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_FString OutStringContainer;
|
|
SGCoreImpl_FSGHapticGloveImpl_GetCalibrationInstruction(&InstanceContainer, &OutStringContainer);
|
|
return OutStringContainer.String;
|
|
}
|
|
|
|
void USGHapticGlove::StopHaptics()
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
SGCoreImpl_FSGHapticGloveImpl_StopHaptics(&InstanceContainer);
|
|
}
|
|
|
|
void USGHapticGlove::StopVibrations()
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
SGCoreImpl_FSGHapticGloveImpl_StopVibrations(&InstanceContainer);
|
|
}
|
|
|
|
bool USGHapticGlove::SendHaptics()
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
return SGCoreImpl_FSGHapticGloveImpl_SendHaptics(&InstanceContainer);
|
|
}
|
|
|
|
bool USGHapticGlove::QueueForceFeedbackLevels(const TArray<float>& Levels01)
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_TArray_float Levels01Container{Levels01};
|
|
return SGCoreImpl_FSGHapticGloveImpl_QueueForceFeedbackLevels(&InstanceContainer, &Levels01Container);
|
|
}
|
|
|
|
bool USGHapticGlove::QueueForceFeedbackLevel(const int32 Finger, const float Level01)
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
return SGCoreImpl_FSGHapticGloveImpl_QueueForceFeedbackLevel(&InstanceContainer, Finger, Level01);
|
|
}
|
|
|
|
bool USGHapticGlove::QueueVibroLevels(const TArray<float>& Levels01)
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_TArray_float Levels01Container{Levels01};
|
|
return SGCoreImpl_FSGHapticGloveImpl_QueueVibroLevels(&InstanceContainer, &Levels01Container);
|
|
}
|
|
|
|
bool USGHapticGlove::QueueVibroLevel(const ESGHapticLocation Location, const float Level01)
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_ESGHapticLocation LocationContainer{Location};
|
|
return SGCoreImpl_FSGHapticGloveImpl_QueueVibroLevel(&InstanceContainer, &LocationContainer, Level01);
|
|
}
|
|
|
|
bool USGHapticGlove::SupportsCustomWaveform(const ESGHapticLocation AtLocation) const
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_ESGHapticLocation AtLocationContainer{AtLocation};
|
|
return SGCoreImpl_FSGHapticGloveImpl_SupportsCustomWaveform(&InstanceContainer, &AtLocationContainer);
|
|
}
|
|
|
|
bool USGHapticGlove::SendCustomWaveform(USGCustomWaveform* OutWaveform, const ESGHapticLocation Location)
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_FSGCustomWaveformImpl OutWaveformContainer{OutWaveform->ToCustomWaveformImpl()};
|
|
FSGIC_ESGHapticLocation LocationContainer{Location};
|
|
return SGCoreImpl_FSGHapticGloveImpl_SendCustomWaveform(
|
|
&InstanceContainer, &OutWaveformContainer, &LocationContainer);
|
|
}
|
|
|
|
void USGHapticGlove::GetWristLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
|
|
const ESGPositionalTrackingHardware TrackingHardware,
|
|
FVector& OutWristPosition, FQuat& OutWristRotation) const
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_FVector ReferencePositionContainer{ReferencePosition};
|
|
FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation};
|
|
FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
|
|
FSGIC_FVector OutWristPositionContainer;
|
|
FSGIC_FQuat OutWristRotationContainer;
|
|
SGCoreImpl_FSGHapticGloveImpl_GetWristLocation(
|
|
&InstanceContainer,
|
|
&ReferencePositionContainer, &ReferenceRotationContainer,
|
|
&TrackingHardwareContainer,
|
|
&OutWristPositionContainer, &OutWristRotationContainer);
|
|
|
|
OutWristPosition = MoveTemp(OutWristPositionContainer.Vector);
|
|
OutWristRotation = MoveTemp(OutWristRotationContainer.Quat);
|
|
}
|
|
|
|
void USGHapticGlove::GetWristLocation(const FVector& ReferencePosition, const FRotator& ReferenceRotation,
|
|
const ESGPositionalTrackingHardware TrackingHardware,
|
|
FVector& OutWristPosition, FRotator& OutWristRotation) const
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_FVector ReferencePositionContainer{ReferencePosition};
|
|
FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
|
|
FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
|
|
FSGIC_FVector OutWristPositionContainer;
|
|
FSGIC_FQuat OutWristRotationContainer;
|
|
SGCoreImpl_FSGHapticGloveImpl_GetWristLocation(
|
|
&InstanceContainer,
|
|
&ReferencePositionContainer, &ReferenceRotationContainer,
|
|
&TrackingHardwareContainer,
|
|
&OutWristPositionContainer, &OutWristRotationContainer);
|
|
|
|
OutWristPosition = MoveTemp(OutWristPositionContainer.Vector);
|
|
OutWristRotation = OutWristRotationContainer.Quat.Rotator();
|
|
}
|
|
|
|
void USGHapticGlove::GetGloveLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
|
|
const ESGPositionalTrackingHardware TrackingHardware,
|
|
FVector& OutGlovePosition, FQuat& OutGloveRotation) const
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_FVector ReferencePositionContainer{ReferencePosition};
|
|
FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation};
|
|
FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
|
|
FSGIC_FVector OutGlovePositionContainer;
|
|
FSGIC_FQuat OutGloveRotationContainer;
|
|
|
|
SGCoreImpl_FSGHapticGloveImpl_GetGloveLocation(
|
|
&InstanceContainer,
|
|
&ReferencePositionContainer, &ReferenceRotationContainer,
|
|
&TrackingHardwareContainer,
|
|
&OutGlovePositionContainer, &OutGloveRotationContainer);
|
|
|
|
OutGlovePosition = MoveTemp(OutGlovePositionContainer.Vector);
|
|
OutGloveRotation = MoveTemp(OutGloveRotationContainer.Quat);
|
|
}
|
|
|
|
void USGHapticGlove::GetGloveLocation(const FVector& ReferencePosition, const FRotator& ReferenceRotation,
|
|
const ESGPositionalTrackingHardware TrackingHardware,
|
|
FVector& OutGlovePosition, FRotator& OutGloveRotation) const
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_FVector ReferencePositionContainer{ReferencePosition};
|
|
FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
|
|
FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
|
|
FSGIC_FVector OutGlovePositionContainer;
|
|
FSGIC_FQuat OutGloveRotationContainer;
|
|
|
|
SGCoreImpl_FSGHapticGloveImpl_GetGloveLocation(
|
|
&InstanceContainer,
|
|
&ReferencePositionContainer, &ReferenceRotationContainer,
|
|
&TrackingHardwareContainer,
|
|
&OutGlovePositionContainer, &OutGloveRotationContainer);
|
|
|
|
OutGlovePosition = MoveTemp(OutGlovePositionContainer.Vector);
|
|
OutGloveRotation = OutGloveRotationContainer.Quat.Rotator();
|
|
}
|
|
|
|
FString USGHapticGlove::ToString() const
|
|
{
|
|
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
|
|
FSGIC_FString OutStringContainer;
|
|
SGCoreImpl_FSGHapticGloveImpl_ToString(&InstanceContainer, &OutStringContainer);
|
|
return OutStringContainer.String;
|
|
} |