590 lines
24 KiB
C++
590 lines
24 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 "SGCoreImpl/SGSenseGloveImpl.h"
|
|
|
|
#include <memory>
|
|
#include <vector>
|
|
|
|
#include "Containers/StringConv.h"
|
|
#include "Misc/AssertionMacros.h"
|
|
#include "Runtime/Launch/Resources/Version.h"
|
|
|
|
#include "SGBuildHacks/SGInclude_Core_BasicHandModel.h"
|
|
#include "SGBuildHacks/SGInclude_Core_BuzzCommand.h"
|
|
#include "SGBuildHacks/SGInclude_Core_ForceFeedbackCommand.h"
|
|
#include "SGBuildHacks/SGInclude_Core_HandPose.h"
|
|
#include "SGBuildHacks/SGInclude_Core_HandProfile.h"
|
|
#include "SGBuildHacks/SGInclude_Core_HapticGlove.h"
|
|
#include "SGBuildHacks/SGInclude_Core_Quat.h"
|
|
#include "SGBuildHacks/SGInclude_Core_SenseGlove.h"
|
|
#include "SGBuildHacks/SGInclude_Core_SenseGloveHandProfile.h"
|
|
#include "SGBuildHacks/SGInclude_Core_SenseGloveInfo.h"
|
|
#include "SGBuildHacks/SGInclude_Core_SenseGlovePose.h"
|
|
#include "SGBuildHacks/SGInclude_Core_SenseGloveSensorData.h"
|
|
#include "SGBuildHacks/SGInclude_Core_ThumperCommand.h"
|
|
#include "SGBuildHacks/SGInclude_Core_Vect3D.h"
|
|
#include "SGCoreImpl/SGBasicHandModelImpl.h"
|
|
#include "SGCoreImpl/SGBuzzCommandImpl.h"
|
|
#include "SGCoreImpl/SGCoreEnumCast.h"
|
|
#include "SGCoreImpl/SGForceFeedbackCommandImpl.h"
|
|
#include "SGCoreImpl/SGHandPoseImpl.h"
|
|
#include "SGCoreImpl/SGHandProfileImpl.h"
|
|
#include "SGCoreImpl/SGQuatImpl.h"
|
|
#include "SGCoreImpl/SGSenseGloveHandProfileImpl.h"
|
|
#include "SGCoreImpl/SGSenseGloveInfoImpl.h"
|
|
#include "SGCoreImpl/SGSenseGlovePoseImpl.h"
|
|
#include "SGCoreImpl/SGSenseGloveSensorDataImpl.h"
|
|
#include "SGCoreImpl/SGThumperCommandImpl.h"
|
|
#include "SGCoreImpl/SGVect3DImpl.h"
|
|
#include "SGUtils/SGArrayUtils.h"
|
|
|
|
struct FSGSenseGloveImpl::FImpl
|
|
{
|
|
/************************
|
|
* Owner object
|
|
************************/
|
|
|
|
FSGSenseGloveImpl* Owner;
|
|
|
|
/************************
|
|
* Constructor / Destructor
|
|
************************/
|
|
|
|
explicit FImpl(FSGSenseGloveImpl* InOwner);
|
|
~FImpl();
|
|
|
|
/************************
|
|
* Default copy constructor & copy assignment operator
|
|
************************/
|
|
|
|
FImpl(const FImpl& Rhs) = default;
|
|
FImpl& operator=(const FImpl& Rhs) = default;
|
|
};
|
|
|
|
ANSICHAR FSGSenseGloveImpl::GetHapticsByte()
|
|
{
|
|
static const ANSICHAR Byte = FSenseGloveType::GetHapticsByte();
|
|
return Byte;
|
|
}
|
|
|
|
ANSICHAR FSGSenseGloveImpl::GetThumperByte()
|
|
{
|
|
static const ANSICHAR Byte = FSenseGloveType::GetThumperByte();
|
|
return Byte;
|
|
}
|
|
|
|
FSGSenseGlovePoseImpl FSGSenseGloveImpl::CalculateGlovePose(const FSGSenseGloveSensorDataImpl& SensorData,
|
|
const FSGSenseGloveInfoImpl& GloveModel)
|
|
{
|
|
FSGSenseGlovePoseImpl Pose{
|
|
FSenseGloveType::CalculateGlovePose(SensorData.ToSenseGloveSensorData(), GloveModel.ToSenseGloveInfo())
|
|
};
|
|
return MoveTemp(Pose);
|
|
}
|
|
|
|
FSGSenseGlovePoseImpl FSGSenseGloveImpl::CalculateGlovePose(const TArray<TArray<FVector>>& GloveAngles,
|
|
const FSGSenseGloveInfoImpl& GloveModel)
|
|
{
|
|
std::vector<std::vector<FSGVect3DImpl::FVect3DType>> GloveAnglesVector{
|
|
FSGArrayUtils::ToSenseGloveAngles<FSGVect3DImpl::FVect3DType>(GloveAngles)
|
|
};
|
|
FSGSenseGlovePoseImpl Pose{
|
|
FSenseGloveType::CalculateGlovePose(MoveTemp(GloveAnglesVector), GloveModel.ToSenseGloveInfo())
|
|
};
|
|
return MoveTemp(Pose);
|
|
}
|
|
|
|
FSGHandPoseImpl FSGSenseGloveImpl::CalculateHandPose(const FSGSenseGlovePoseImpl& GlovePose,
|
|
const FSGBasicHandModelImpl& HandModel,
|
|
const FSGSenseGloveHandProfileImpl& Profile)
|
|
{
|
|
FSGHandPoseImpl HandPose{FSenseGloveType::CalculateHandPose(
|
|
GlovePose.ToSenseGlovePose(), HandModel.ToBasicHandModel(), Profile.ToSenseGloveHandProfile())
|
|
};
|
|
return MoveTemp(HandPose);
|
|
}
|
|
|
|
TSharedRef<FSGDeviceImpl> FSGSenseGloveImpl::Parse(const FString& ConstantsString)
|
|
{
|
|
std::string ConstantsStdString{TCHAR_TO_UTF8(*ConstantsString)};
|
|
FSGDevicePtrType SGDevicePtr{FSenseGloveType::Parse(MoveTemp(ConstantsStdString))};
|
|
ensureAlwaysMsgf(SGDevicePtr, TEXT("Invalid SGDevice!"));
|
|
TSharedRef<FSGSenseGloveImpl> SenseGloveImpl{MakeShared<FSGSenseGloveImpl>(
|
|
std::dynamic_pointer_cast<FSenseGloveType>(MoveTemp(SGDevicePtr)))};
|
|
return MoveTemp(SenseGloveImpl);
|
|
}
|
|
|
|
TArray<FSGSenseGloveImpl> FSGSenseGloveImpl::GetSenseGloves()
|
|
{
|
|
FSenseGloveVectorType Vector{FSenseGloveType::GetSenseGloves()};
|
|
|
|
TArray<FSGSenseGloveImpl> Array{
|
|
FSGArrayUtils::FromStdVector<FSenseGloveType, FSGSenseGloveImpl>(MoveTemp(Vector))
|
|
};
|
|
|
|
return MoveTemp(Array);
|
|
}
|
|
|
|
|
|
bool FSGSenseGloveImpl::GetSenseGlove(FSGSenseGloveImpl& OutGlove)
|
|
{
|
|
FSenseGloveType Glove;
|
|
const bool bResult = FSenseGloveType::GetSenseGlove(Glove);
|
|
OutGlove = FSGSenseGloveImpl{MoveTemp(Glove)};
|
|
return bResult;
|
|
}
|
|
|
|
bool FSGSenseGloveImpl::GetSenseGlove(const bool bRightHanded, FSGSenseGloveImpl& OutGlove)
|
|
{
|
|
FSenseGloveType Glove;
|
|
const bool bResult = FSenseGloveType::GetSenseGlove(bRightHanded, Glove);
|
|
OutGlove = FSGSenseGloveImpl{MoveTemp(Glove)};
|
|
return bResult;
|
|
}
|
|
|
|
TArray<FVector> FSGSenseGloveImpl::GetCalibrationValues(const FSGSenseGlovePoseImpl& GlovePose)
|
|
{
|
|
TArray<FVector> Values{
|
|
FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
|
|
FSenseGloveType::GetCalibrationValues(GlovePose.ToSenseGlovePose()))
|
|
};
|
|
return MoveTemp(Values);
|
|
}
|
|
|
|
void FSGSenseGloveImpl::CalibrateInterpolation(const TArray<FVector>& MinValues, const TArray<FVector>& MaxValues,
|
|
const bool bRightHanded, FSGSenseGloveHandProfileImpl& OutProfile)
|
|
{
|
|
std::vector<FSGVect3DImpl::FVect3DType> MinValuesVector{
|
|
FSGArrayUtils::ToStdVector<FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(
|
|
MinValues)
|
|
};
|
|
std::vector<FSGVect3DImpl::FVect3DType> MaxValuesVector{
|
|
FSGArrayUtils::ToStdVector<FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(
|
|
MaxValues)
|
|
};
|
|
|
|
FSGSenseGloveHandProfileImpl::FSenseGloveHandProfileType Profile;
|
|
FSenseGloveType::CalibrateInterpolation(MoveTemp(MinValuesVector), MoveTemp(MaxValuesVector),
|
|
bRightHanded, Profile);
|
|
OutProfile = FSGSenseGloveHandProfileImpl{MoveTemp(Profile)};
|
|
}
|
|
|
|
void FSGSenseGloveImpl::CalculateGloveLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
|
|
const ESGPositionalTrackingHardware TrackingHardware,
|
|
const bool bRightHanded, const ESGFinger MountedOn,
|
|
FVector& OutGlovePosition, FQuat& OutGloveRotation)
|
|
{
|
|
FSGVect3DImpl::FVect3DType GlovePosition;
|
|
FSGQuatImpl::FQuatType GloveRotation;
|
|
|
|
FSenseGloveType::CalculateGloveLocation(
|
|
FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(ReferencePosition),
|
|
FSGQuatImpl{ReferenceRotation}.ToQuat(),
|
|
FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
|
|
bRightHanded, FSGCoreEnumCast::ToEFinger(MountedOn),
|
|
GlovePosition, GloveRotation);
|
|
|
|
OutGlovePosition = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
|
|
MoveTemp(GlovePosition));;
|
|
OutGloveRotation = FSGQuatImpl{MoveTemp(GloveRotation)}.ToFQuat();
|
|
}
|
|
|
|
void FSGSenseGloveImpl::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)
|
|
{
|
|
FSGVect3DImpl::FVect3DType WristPosition;
|
|
FSGQuatImpl::FQuatType WristRotation;
|
|
|
|
FSenseGloveType::CalculateWristLocation(
|
|
FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(ReferencePosition),
|
|
FSGQuatImpl{ReferenceRotation}.ToQuat(),
|
|
FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
|
|
bRightHanded, FSGCoreEnumCast::ToEFinger(MountedOn),
|
|
FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(GloveWristPositionOffset),
|
|
FSGQuatImpl(GloveWristRotationOffset).ToQuat(),
|
|
WristPosition, WristRotation);
|
|
|
|
OutWristPosition = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
|
|
MoveTemp(WristPosition));
|
|
OutWristRotation = FSGQuatImpl{MoveTemp(WristRotation)}.ToFQuat();
|
|
}
|
|
|
|
FSGSenseGloveImpl::FSGSenseGloveImpl()
|
|
: FSGHapticGloveImpl(),
|
|
#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 ) */
|
|
{
|
|
}
|
|
|
|
FSGSenseGloveImpl::FSGSenseGloveImpl(const FSGSenseGloveInfoImpl& Model)
|
|
: FSGHapticGloveImpl(std::make_shared<FSenseGloveType>(Model.ToSenseGloveInfo())),
|
|
#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 ) */
|
|
{
|
|
}
|
|
|
|
FSGSenseGloveImpl::FSGSenseGloveImpl(const FSenseGloveType SenseGlove)
|
|
: FSGHapticGloveImpl(std::make_shared<FSenseGloveType>(SenseGlove)),
|
|
#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 ) */
|
|
{
|
|
}
|
|
|
|
FSGSenseGloveImpl::FSGSenseGloveImpl(const FSenseGlovePtrType SenseGlove)
|
|
: FSGHapticGloveImpl(std::dynamic_pointer_cast<FHapticGloveType>(SenseGlove)),
|
|
#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 ) */
|
|
{
|
|
}
|
|
|
|
FSGSenseGloveImpl::FSGSenseGloveImpl(const FSGSenseGloveImpl& Rhs)
|
|
: FSGHapticGloveImpl(Rhs),
|
|
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
|
|
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
|
|
#else
|
|
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}))
|
|
#endif /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
|
|
{
|
|
Pimpl->Owner = this;
|
|
}
|
|
|
|
FSGSenseGloveImpl::FSGSenseGloveImpl(FSGSenseGloveImpl&& Rhs)
|
|
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
|
|
noexcept
|
|
#endif /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
|
|
= default;
|
|
|
|
FSGSenseGloveImpl::~FSGSenseGloveImpl() = default;
|
|
|
|
FSGSenseGloveImpl& FSGSenseGloveImpl::operator=(const FSGSenseGloveImpl& Rhs)
|
|
{
|
|
FSGHapticGloveImpl::operator=(Rhs);
|
|
*Pimpl = *Rhs.Pimpl;
|
|
Pimpl->Owner = this;
|
|
return *this;
|
|
}
|
|
|
|
FSGSenseGloveImpl& FSGSenseGloveImpl::operator=(FSGSenseGloveImpl&& Rhs)
|
|
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
|
|
noexcept
|
|
#endif /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
|
|
= default;
|
|
|
|
const FSGSenseGloveImpl::FSenseGloveType& FSGSenseGloveImpl::ToSenseGlove() const
|
|
{
|
|
return *ToSenseGlovePtrChecked();
|
|
}
|
|
|
|
FSGSenseGloveImpl::FSenseGlovePtrType FSGSenseGloveImpl::ToSenseGlovePtr() const
|
|
{
|
|
return std::dynamic_pointer_cast<FSenseGloveType>(ToSGDevicePtr());
|
|
}
|
|
|
|
FSGSenseGloveImpl::FSenseGlovePtrType FSGSenseGloveImpl::ToSenseGlovePtrChecked() const
|
|
{
|
|
FSenseGlovePtrType SenseGlove = std::dynamic_pointer_cast<FSenseGloveType>(ToSGDevicePtr());
|
|
ensureAlwaysMsgf(SenseGlove.get(), TEXT("Invalid SenseGlove"));
|
|
return SenseGlove;
|
|
}
|
|
|
|
FSGSenseGloveInfoImpl FSGSenseGloveImpl::GetGloveModel() const
|
|
{
|
|
return FSGSenseGloveInfoImpl{ToSenseGlovePtr()->GetGloveModel()};
|
|
}
|
|
|
|
bool FSGSenseGloveImpl::IsRight() const
|
|
{
|
|
return ToSenseGlovePtr()->IsRight();
|
|
}
|
|
|
|
ESGDeviceType FSGSenseGloveImpl::GetDeviceType() const
|
|
{
|
|
return FSGCoreEnumCast::ToESGDeviceType(ToSenseGlovePtrChecked()->GetDeviceType());
|
|
}
|
|
|
|
FString FSGSenseGloveImpl::GetDeviceId() const
|
|
{
|
|
const FString Id{UTF8_TO_TCHAR(ToSenseGlovePtrChecked()->GetDeviceId().c_str())};
|
|
return Id;
|
|
}
|
|
|
|
FString FSGSenseGloveImpl::GetHardwareVersion() const
|
|
{
|
|
const FString Version{UTF8_TO_TCHAR(ToSenseGlovePtrChecked()->GetHardwareVersion().c_str())};
|
|
return Version;
|
|
}
|
|
|
|
int32 FSGSenseGloveImpl::GetFirmwareVersion() const
|
|
{
|
|
return ToSenseGlovePtrChecked()->GetFirmwareVersion();
|
|
}
|
|
|
|
int32 FSGSenseGloveImpl::GetSubFirmwareVersion() const
|
|
{
|
|
return ToSenseGlovePtrChecked()->GetSubFirmwareVersion();
|
|
}
|
|
|
|
bool FSGSenseGloveImpl::GetSensorData(FSGSenseGloveSensorDataImpl& OutSensorData) const
|
|
{
|
|
FSGSenseGloveSensorDataImpl::FSenseGloveSensorDataType SensorData;
|
|
const bool bResult = ToSenseGlovePtrChecked()->GetSensorData(SensorData);
|
|
OutSensorData = FSGSenseGloveSensorDataImpl{MoveTemp(SensorData)};
|
|
return bResult;
|
|
}
|
|
|
|
bool FSGSenseGloveImpl::GetImuRotation(FQuat& OutImu)
|
|
{
|
|
FSGQuatImpl::FQuatType Imu;
|
|
const bool bResult = ToSenseGlovePtrChecked()->GetImuRotation(Imu);
|
|
OutImu = FSGQuatImpl{MoveTemp(Imu)}.ToFQuat();
|
|
return bResult;
|
|
}
|
|
|
|
bool FSGSenseGloveImpl::GetGlovePose(FSGSenseGlovePoseImpl& OutGlovePose)
|
|
{
|
|
FSGSenseGlovePoseImpl::FSenseGlovePoseType GlovePose;
|
|
const bool bResult = ToSenseGlovePtr()->GetGlovePose(GlovePose);
|
|
OutGlovePose = FSGSenseGlovePoseImpl{GlovePose};
|
|
return bResult;
|
|
}
|
|
|
|
bool FSGSenseGloveImpl::GetGlovePose(const FSGSenseGloveSensorDataImpl& SensorData,
|
|
FSGSenseGlovePoseImpl& OutGlovePose)
|
|
{
|
|
FSGSenseGlovePoseImpl::FSenseGlovePoseType GlovePose;
|
|
const bool bResult = ToSenseGlovePtr()->GetGlovePose(SensorData.ToSenseGloveSensorData(), GlovePose);
|
|
OutGlovePose = FSGSenseGlovePoseImpl{GlovePose};
|
|
return bResult;
|
|
}
|
|
|
|
bool FSGSenseGloveImpl::GetHandPose(const FSGBasicHandModelImpl& HandModel, const FSGSenseGloveHandProfileImpl& Profile,
|
|
FSGHandPoseImpl& OutHandPose)
|
|
{
|
|
FSGHandPoseImpl::FHandPoseType HandPose;
|
|
const bool bResult = ToSenseGlovePtrChecked()->GetHandPose(
|
|
HandModel.ToBasicHandModel(), Profile.ToSenseGloveHandProfile(), HandPose);
|
|
OutHandPose = FSGHandPoseImpl{MoveTemp(HandPose)};
|
|
return bResult;
|
|
}
|
|
|
|
bool FSGSenseGloveImpl::GetHandPose(const FSGBasicHandModelImpl& HandGeometry, const FSGHandProfileImpl& HandProfile,
|
|
FSGHandPoseImpl& OutHandPose)
|
|
{
|
|
FSGHandPoseImpl::FHandPoseType HandPose;
|
|
const bool bResult = ToSenseGlovePtrChecked()->GetHandPose(
|
|
HandGeometry.ToBasicHandModel(), HandProfile.ToHandProfile(), HandPose);
|
|
OutHandPose = FSGHandPoseImpl{MoveTemp(HandPose)};
|
|
return bResult;
|
|
}
|
|
|
|
bool FSGSenseGloveImpl::GetHandPose(const FSGHandProfileImpl& HandProfile, FSGHandPoseImpl& OutHandPose)
|
|
{
|
|
FSGHandPoseImpl::FHandPoseType HandPose;
|
|
const bool bResult = ToSenseGlovePtrChecked()->GetHandPose(HandProfile.ToHandProfile(), HandPose);
|
|
OutHandPose = FSGHandPoseImpl{MoveTemp(HandPose)};
|
|
return bResult;
|
|
}
|
|
|
|
bool FSGSenseGloveImpl::SendHaptics(const FSGForceFeedbackCommandImpl& ForceFeedbackCommand,
|
|
const FSGBuzzCommandImpl& BuzzCommand,
|
|
ESGSenseGloveThumperCommand ThumperCommand)
|
|
{
|
|
return ToSenseGlovePtrChecked()->SendHaptics(ForceFeedbackCommand.ToForceFeedbackCommand(),
|
|
BuzzCommand.ToBuzzCommand(),
|
|
FSGCoreEnumCast::ToESenseGloveThumperCommand(ThumperCommand));
|
|
}
|
|
|
|
bool FSGSenseGloveImpl::SendHaptics(ESGSenseGloveThumperCommand ThumperCommand)
|
|
{
|
|
return ToSenseGlovePtrChecked()->SendHaptics(FSGCoreEnumCast::ToESenseGloveThumperCommand(ThumperCommand));
|
|
}
|
|
|
|
void FSGSenseGloveImpl::SendHaptics(const FSGForceFeedbackCommandImpl& ForceFeedbackCommand)
|
|
{
|
|
ToSenseGlovePtrChecked()->SendHaptics(ForceFeedbackCommand.ToForceFeedbackCommand());
|
|
}
|
|
|
|
void FSGSenseGloveImpl::SendHaptics(const FSGBuzzCommandImpl& BuzzCommand)
|
|
{
|
|
ToSenseGlovePtrChecked()->SendHaptics(BuzzCommand.ToBuzzCommand());
|
|
}
|
|
|
|
void FSGSenseGloveImpl::SendHaptics(const FSGForceFeedbackCommandImpl& ForceFeedbackCommand,
|
|
const FSGBuzzCommandImpl& BuzzCommand, const FSGThumperCommandImpl& ThumperCommand)
|
|
{
|
|
ToSenseGlovePtrChecked()->SendHaptics(ForceFeedbackCommand.ToForceFeedbackCommand(),
|
|
BuzzCommand.ToBuzzCommand(), ThumperCommand.ToThumperCommand());
|
|
}
|
|
|
|
bool FSGSenseGloveImpl::GetCalibrationValues(TArray<FVector>& OutValues)
|
|
{
|
|
std::vector<FSGVect3DImpl::FVect3DType> Values;
|
|
const bool bResult = ToSenseGlovePtrChecked()->GetCalibrationValues(Values);
|
|
OutValues = FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector,
|
|
FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(MoveTemp(Values));
|
|
return bResult;
|
|
}
|
|
|
|
void FSGSenseGloveImpl::ResetCalibrationRange()
|
|
{
|
|
ToSenseGlovePtr()->ResetCalibrationRange();
|
|
}
|
|
|
|
void FSGSenseGloveImpl::ApplyCalibration(FSGHandProfileImpl& OutProfile) const
|
|
{
|
|
FSGHandProfileImpl::FHandProfileType Profile;
|
|
ToSenseGlovePtrChecked()->ApplyCalibration(Profile);
|
|
OutProfile = FSGHandProfileImpl{MoveTemp(Profile)};
|
|
}
|
|
|
|
void FSGSenseGloveImpl::ApplyCalibration(FSGSenseGloveHandProfileImpl& OutProfile) const
|
|
{
|
|
FSGSenseGloveHandProfileImpl::FSenseGloveHandProfileType Profile;
|
|
ToSenseGlovePtrChecked()->ApplyCalibration(Profile);
|
|
OutProfile = FSGSenseGloveHandProfileImpl{MoveTemp(Profile)};
|
|
}
|
|
|
|
void FSGSenseGloveImpl::GetGloveLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
|
|
const ESGPositionalTrackingHardware TrackingHardware,
|
|
FVector& OutGlovePosition, FQuat& OutGloveRotation) const
|
|
{
|
|
FSGVect3DImpl::FVect3DType GlovePosition;
|
|
FSGQuatImpl::FQuatType GloveRotation;
|
|
|
|
ToSenseGlovePtrChecked()->GetGloveLocation(
|
|
FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(ReferencePosition),
|
|
FSGQuatImpl{ReferenceRotation}.ToQuat(),
|
|
FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
|
|
GlovePosition, GloveRotation);
|
|
|
|
OutGlovePosition = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
|
|
MoveTemp(GlovePosition));
|
|
OutGloveRotation = FSGQuatImpl{MoveTemp(GloveRotation)}.ToFQuat();
|
|
}
|
|
|
|
void FSGSenseGloveImpl::GetGloveLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
|
|
const ESGPositionalTrackingHardware TrackingHardware,
|
|
const ESGFinger MountedOn,
|
|
FVector& OutGlovePosition, FQuat& OutGloveRotation) const
|
|
{
|
|
FSGVect3DImpl::FVect3DType GlovePosition;
|
|
FSGQuatImpl::FQuatType GloveRotation;
|
|
|
|
ToSenseGlovePtrChecked()->GetGloveLocation(
|
|
FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(ReferencePosition),
|
|
FSGQuatImpl{ReferenceRotation}.ToQuat(),
|
|
FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
|
|
FSGCoreEnumCast::ToEFinger(MountedOn),
|
|
GlovePosition, GloveRotation);
|
|
|
|
OutGlovePosition = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
|
|
MoveTemp(GlovePosition));
|
|
OutGloveRotation = FSGQuatImpl{MoveTemp(GloveRotation)}.ToFQuat();
|
|
}
|
|
|
|
void FSGSenseGloveImpl::GetWristLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
|
|
const ESGPositionalTrackingHardware TrackingHardware,
|
|
FVector& OutWristPosition, FQuat& OutWristRotation) const
|
|
{
|
|
FSGVect3DImpl::FVect3DType WristPosition;
|
|
FSGQuatImpl::FQuatType WristRotation;
|
|
|
|
ToSenseGlovePtrChecked()->GetWristLocation(
|
|
FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(ReferencePosition),
|
|
FSGQuatImpl{ReferenceRotation}.ToQuat(),
|
|
FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
|
|
WristPosition, WristRotation);
|
|
|
|
OutWristPosition = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
|
|
MoveTemp(WristPosition));
|
|
OutWristRotation = FSGQuatImpl{MoveTemp(WristRotation)}.ToFQuat();
|
|
}
|
|
|
|
void FSGSenseGloveImpl::GetWristLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
|
|
const ESGPositionalTrackingHardware TrackingHardware,
|
|
const FVector& GloveWristPositionOffset, const FQuat& GloveWristRotationOffset,
|
|
FVector& OutWristPosition, FQuat& OutWristRotation) const
|
|
{
|
|
FSGVect3DImpl::FVect3DType WristPosition;
|
|
FSGQuatImpl::FQuatType WristRotation;
|
|
|
|
ToSenseGlovePtrChecked()->GetWristLocation(
|
|
FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(ReferencePosition),
|
|
FSGQuatImpl{ReferenceRotation}.ToQuat(),
|
|
FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
|
|
FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(GloveWristPositionOffset),
|
|
FSGQuatImpl(GloveWristRotationOffset).ToQuat(),
|
|
WristPosition, WristRotation);
|
|
|
|
OutWristPosition = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
|
|
MoveTemp(WristPosition));
|
|
OutWristRotation = FSGQuatImpl{MoveTemp(WristRotation)}.ToFQuat();
|
|
}
|
|
|
|
FString FSGSenseGloveImpl::ToString() const
|
|
{
|
|
const FString String{UTF8_TO_TCHAR(ToSenseGlovePtrChecked()->ToString().c_str())};
|
|
return String;
|
|
}
|
|
|
|
|
|
FSGSenseGloveImpl::FImpl::FImpl(FSGSenseGloveImpl* InOwner)
|
|
: Owner(InOwner)
|
|
{
|
|
}
|
|
|
|
FSGSenseGloveImpl::FImpl::~FImpl() = default;
|
|
|
|
void FSGSenseGloveImpl::FImplDeleter::operator()(const FImpl* P) const
|
|
{
|
|
delete P;
|
|
} |