UnrealEngine/Plugin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

remove archaic pre-public-release dead code

Browse Source
This commit is contained in:
Mamadou Babaei
2023-02-21 00:03:56 +01:00
parent ed27fc6844
commit 2c9eddf7e4
104 changed files with 127 additions and 3880 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGBasicHandModelImpl.cpp
-30
View File
@@ -227,11 +227,6 @@ bool FSGBasicHandModelImpl::IsRight() const
return Pimpl->BasicHandModel.IsRight();
}
void FSGBasicHandModelImpl::SetIsRight(const bool bRightHanded)
{
Pimpl->BasicHandModel.SetIsRight(bRightHanded);
}
TArray<TArray<float>> FSGBasicHandModelImpl::GetFingerLengths() const
{
TArray<TArray<float>> FingerLengths{
@@ -240,14 +235,6 @@ TArray<TArray<float>> FSGBasicHandModelImpl::GetFingerLengths() const
return MoveTemp(FingerLengths);
}
void FSGBasicHandModelImpl::SetFingerLengths(const TArray<TArray<float>>& FingerLengths)
{
std::vector<std::vector<float>> FingerLengthsVector{
FSGArrayUtils::ToMillimeters(FingerLengths)
};
Pimpl->BasicHandModel.SetFingerLengths(MoveTemp(FingerLengthsVector));
}
TArray<float> FSGBasicHandModelImpl::GetFingerLengths(const ESGFinger Finger) const
{
TArray<float> FingerLengths{
@@ -297,14 +284,6 @@ TArray<FVector> FSGBasicHandModelImpl::GetStartJointPositions() const
return MoveTemp(StartJointPositions);
}
void FSGBasicHandModelImpl::SetStartJointPositions(const TArray<FVector>& StartJointPositions)
{
std::vector<FSGVect3DImpl::FVect3DType> StartJointPositionsVector{
FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(StartJointPositions)
};
Pimpl->BasicHandModel.SetStartJointPositions(MoveTemp(StartJointPositionsVector));
}
void FSGBasicHandModelImpl::SetStartJointPosition(const ESGFinger Finger, const FVector& Position)
{
Pimpl->BasicHandModel.SetStartJointPosition(
@@ -329,15 +308,6 @@ TArray<FQuat> FSGBasicHandModelImpl::GetStartJointRotations() const
return MoveTemp(StartJointRotations);
}
void FSGBasicHandModelImpl::SetStartJointRotations(const TArray<FQuat>& StartJointRotations)
{
std::vector<FSGQuatImpl::FQuatType> StartJointRotationsVector{
FSGArrayUtils::ToStdVector<
FQuat, FSGQuatImpl::FQuatType, FSGQuatImpl, &FSGQuatImpl::ToQuat>(StartJointRotations)
};
Pimpl->BasicHandModel.SetStartJointRotations(MoveTemp(StartJointRotationsVector));
}
FVector FSGBasicHandModelImpl::GetJointPosition(const ESGFinger Finger) const
{
return FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGCalibrationDataPointImpl.cpp
+1 -15
View File
@@ -159,25 +159,11 @@ TArray<FVector> FSGCalibrationDataPointImpl::GetCalibrationValues() const
return CalibrationValues;
}
void FSGCalibrationDataPointImpl::SetCalibrationValues(const TArray<FVector>& CalibrationValues)
{
std::vector<FSGVect3DImpl::FVect3DType> CalibrationValuesVector{
FSGArrayUtils::ToStdVector<FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(
CalibrationValues)
};
Pimpl->CalibrationDataPoint.SetCalibrationValues(MoveTemp(CalibrationValuesVector));
}
int32 FSGCalibrationDataPointImpl::GetStage() const
{
return Pimpl->CalibrationDataPoint.GetStage();
}
void FSGCalibrationDataPointImpl::SetStage(const int32 Stage)
{
Pimpl->CalibrationDataPoint.SetStage(Stage);
}
FString FSGCalibrationDataPointImpl::ToLogData(const FString& Delimiter) const
{
std::string DelimiterString(TCHAR_TO_UTF8(*Delimiter));
@@ -195,4 +181,4 @@ FSGCalibrationDataPointImpl::FImpl::~FImpl() = default;
void FSGCalibrationDataPointImpl::FImplDeleter::operator()(const FImpl* P) const
{
delete P;
}
}
Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGDeviceModelImpl.cpp
-20
View File
@@ -174,42 +174,22 @@ FString FSGDeviceModelImpl::GetDeviceId() const
return MoveTemp(DeviceId);
}
void FSGDeviceModelImpl::SetDeviceId(const FString& Id) const
{
Pimpl->DeviceModel.SetDeviceId(TCHAR_TO_UTF8(*Id));
}
FString FSGDeviceModelImpl::GetHardwareVersion() const
{
FString HardwareVersion(UTF8_TO_TCHAR(Pimpl->DeviceModel.GetHardwareVersion().c_str()));
return MoveTemp(HardwareVersion);
}
void FSGDeviceModelImpl::SetHardwareVersion(const FString& Version) const
{
Pimpl->DeviceModel.SetHardwareVersion(TCHAR_TO_UTF8(*Version));
}
int32 FSGDeviceModelImpl::GetFirmwareVersion() const
{
return Pimpl->DeviceModel.GetFirmwareVersion();
}
void FSGDeviceModelImpl::SetFirmwareVersion(const int32 Version) const
{
Pimpl->DeviceModel.SetFirmwareVersion(Version);
}
int32 FSGDeviceModelImpl::GetSubFirmwareVersion() const
{
return Pimpl->DeviceModel.GetSubFirmwareVersion();
}
void FSGDeviceModelImpl::SetSubFirmwareVersion(const int32 Version) const
{
Pimpl->DeviceModel.SetSubFirmwareVersion(Version);
}
FSGDeviceModelImpl::FImpl::FImpl(FSGDeviceModelImpl* InOwner)
: Owner(InOwner)
{
Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGExportedFunctions.cpp
-564
View File
@@ -347,21 +347,6 @@ bool SGCoreImpl_FSGBasicHandModelImpl_IsRight(
return StaticCast<FSGIC_FSGBasicHandModelImpl*>(Instance)->BasicHandModelImpl.IsRight();
}
void SGCoreImpl_FSGBasicHandModelImpl_SetIsRight(
void* Instance,
const bool bRightHanded)
{
StaticCast<FSGIC_FSGBasicHandModelImpl*>(Instance)->BasicHandModelImpl.SetIsRight(bRightHanded);
}
void SGCoreImpl_FSGBasicHandModelImpl_SetFingerLengths(
void* Instance,
void* FingerLengths)
{
StaticCast<FSGIC_FSGBasicHandModelImpl*>(Instance)->BasicHandModelImpl.SetFingerLengths(
StaticCast<FSGIC_TArray_TArray_float*>(FingerLengths)->Array);
}
void SGCoreImpl_FSGBasicHandModelImpl_GetFingerLengths(
void* Instance,
void* OutLengths)
@@ -426,14 +411,6 @@ void SGCoreImpl_FSGBasicHandModelImpl_GetStartJointPositions(
StaticCast<FSGIC_FSGBasicHandModelImpl*>(Instance)->BasicHandModelImpl.GetStartJointPositions();
}
void SGCoreImpl_FSGBasicHandModelImpl_SetStartJointPositions(
void* Instance,
void* StartJointPositions)
{
StaticCast<FSGIC_FSGBasicHandModelImpl*>(Instance)->BasicHandModelImpl.SetStartJointPositions(
StaticCast<FSGIC_TArray_FVector*>(StartJointPositions)->Array);
}
void SGCoreImpl_FSGBasicHandModelImpl_SetStartJointPosition_ESGFinger(
void* Instance,
void* Finger,
@@ -462,14 +439,6 @@ void SGCoreImpl_FSGBasicHandModelImpl_GetStartJointRotations(
StaticCast<FSGIC_FSGBasicHandModelImpl*>(Instance)->BasicHandModelImpl.GetStartJointRotations();
}
void SGCoreImpl_FSGBasicHandModelImpl_SetStartJointRotations(
void* Instance,
void* StartJointRotations)
{
StaticCast<FSGIC_FSGBasicHandModelImpl*>(Instance)->BasicHandModelImpl.SetStartJointRotations(
StaticCast<FSGIC_TArray_FQuat*>(StartJointRotations)->Array);
}
void SGCoreImpl_FSGBasicHandModelImpl_GetJointPosition(
void* Instance,
void* OutPosition,
@@ -912,27 +881,12 @@ void SGCoreImpl_FSGCalibrationDataPointImpl_GetCalibrationValues(
StaticCast<FSGIC_FSGCalibrationDataPointImpl*>(Instance)->CalibrationDataPointImpl.GetCalibrationValues();
}
void SGCoreImpl_FSGCalibrationDataPointImpl_SetCalibrationValues(
void* Instance,
void* CalibrationValues)
{
StaticCast<FSGIC_FSGCalibrationDataPointImpl*>(Instance)->CalibrationDataPointImpl.SetCalibrationValues(
StaticCast<FSGIC_TArray_FVector*>(CalibrationValues)->Array);
}
int32 SGCoreImpl_FSGCalibrationDataPointImpl_GetStage(
void* Instance)
{
return StaticCast<FSGIC_FSGCalibrationDataPointImpl*>(Instance)->CalibrationDataPointImpl.GetStage();
}
void SGCoreImpl_FSGCalibrationDataPointImpl_SetStage(
void* Instance,
const int32 Stage)
{
StaticCast<FSGIC_FSGCalibrationDataPointImpl*>(Instance)->CalibrationDataPointImpl.SetStage(Stage);
}
void SGCoreImpl_FSGCalibrationDataPointImpl_ToLogData(
void* Instance,
void* OutData,
@@ -1337,14 +1291,6 @@ void SGCoreImpl_FSGDeviceModelImpl_GetDeviceId(
StaticCast<FSGIC_FSGDeviceModelImpl*>(Instance)->DeviceModelImpl.GetDeviceId();
}
void SGCoreImpl_FSGDeviceModelImpl_SetDeviceId(
void* Instance,
void* Id)
{
StaticCast<FSGIC_FSGDeviceModelImpl*>(Instance)->DeviceModelImpl.SetDeviceId(
StaticCast<FSGIC_FString*>(Id)->String);
}
void SGCoreImpl_FSGDeviceModelImpl_GetHardwareVersion(
void* Instance,
void* OutVersion)
@@ -1353,41 +1299,18 @@ void SGCoreImpl_FSGDeviceModelImpl_GetHardwareVersion(
StaticCast<FSGIC_FSGDeviceModelImpl*>(Instance)->DeviceModelImpl.GetHardwareVersion();
}
void SGCoreImpl_FSGDeviceModelImpl_SetHardwareVersion(
void* Instance,
void* Version)
{
StaticCast<FSGIC_FSGDeviceModelImpl*>(Instance)->DeviceModelImpl.SetHardwareVersion(
StaticCast<FSGIC_FString*>(Version)->String);
}
int32 SGCoreImpl_FSGDeviceModelImpl_GetFirmwareVersion(
void* Instance)
{
return StaticCast<FSGIC_FSGDeviceModelImpl*>(Instance)->DeviceModelImpl.GetFirmwareVersion();
}
void SGCoreImpl_FSGDeviceModelImpl_SetFirmwareVersion(
void* Instance,
const int32 Version)
{
StaticCast<FSGIC_FSGDeviceModelImpl*>(Instance)->DeviceModelImpl.SetFirmwareVersion(
Version);
}
int32 SGCoreImpl_FSGDeviceModelImpl_GetSubFirmwareVersion(
void* Instance)
{
return StaticCast<FSGIC_FSGDeviceModelImpl*>(Instance)->DeviceModelImpl.GetSubFirmwareVersion();
}
void SGCoreImpl_FSGDeviceModelImpl_SetSubFirmwareVersion(
void* Instance,
const int32 Version)
{
StaticCast<FSGIC_FSGDeviceModelImpl*>(Instance)->DeviceModelImpl.SetSubFirmwareVersion(Version);
}
/*******************************************************************************
* SGFingerCommandImpl.h
******************************************************************************/
@@ -1487,14 +1410,6 @@ void SGCoreImpl_FSGFingerCommandImpl_GetLevels(
StaticCast<FSGIC_TSharedPtr_FSGFingerCommandImpl*>(Instance)->Ptr->GetLevels();
}
void SGCoreImpl_FSGFingerCommandImpl_SetLevels(
void* Instance,
void* Levels)
{
StaticCast<FSGIC_TSharedPtr_FSGFingerCommandImpl*>(Instance)->Ptr->SetLevels(
StaticCast<FSGIC_TArray_int32*>(Levels)->Array);
}
int32 SGCoreImpl_FSGFingerCommandImpl_GetLevel(
void* Instance,
const int32 Finger)
@@ -1773,14 +1688,6 @@ void SGCoreImpl_FSGHandInterpolatorImpl_GetJointInterpolations(
StaticCast<FSGIC_FSGHandInterpolatorImpl*>(Instance)->HandInterpolatorImpl.GetJointInterpolations();
}
void SGCoreImpl_FSGHandInterpolatorImpl_SetJointInterpolations(
void* Instance,
void* OutJointInterpolations)
{
StaticCast<FSGIC_FSGHandInterpolatorImpl*>(Instance)->HandInterpolatorImpl.SetJointInterpolations(
StaticCast<FSGIC_TArray_TArray_FSGInterpolationSetImpl*>(OutJointInterpolations)->Array);
}
void SGCoreImpl_FSGHandInterpolatorImpl_GetCmcStartRotation(
void* Instance,
void* OutRotation)
@@ -1789,14 +1696,6 @@ void SGCoreImpl_FSGHandInterpolatorImpl_GetCmcStartRotation(
StaticCast<FSGIC_FSGHandInterpolatorImpl*>(Instance)->HandInterpolatorImpl.GetCmcStartRotation();
}
void SGCoreImpl_FSGHandInterpolatorImpl_SetCmcStartRotation(
void* Instance,
void* CmcStartRotation)
{
StaticCast<FSGIC_FSGHandInterpolatorImpl*>(Instance)->HandInterpolatorImpl.SetCmcStartRotation(
StaticCast<FSGIC_FQuat*>(CmcStartRotation)->Quat);
}
float SGCoreImpl_FSGHandInterpolatorImpl_CalculateAngle_Finger_int32Movement_Value(
void* Instance,
void* Finger,
@@ -2073,13 +1972,6 @@ bool SGCoreImpl_FSGHandPoseImpl_IsRight(
return StaticCast<FSGIC_FSGHandPoseImpl*>(Instance)->HandPoseImpl.IsRight();
}
void SGCoreImpl_FSGHandPoseImpl_SetIsRight(
void* Instance,
const bool bRightHanded)
{
StaticCast<FSGIC_FSGHandPoseImpl*>(Instance)->HandPoseImpl.SetIsRight(bRightHanded);
}
void SGCoreImpl_FSGHandPoseImpl_GetJointPositions(
void* Instance,
void* OutPositions)
@@ -2088,14 +1980,6 @@ void SGCoreImpl_FSGHandPoseImpl_GetJointPositions(
StaticCast<FSGIC_FSGHandPoseImpl*>(Instance)->HandPoseImpl.GetJointPositions();
}
void SGCoreImpl_FSGHandPoseImpl_SetJointPositions(
void* Instance,
void* JointPositions)
{
StaticCast<FSGIC_FSGHandPoseImpl*>(Instance)->HandPoseImpl.SetJointPositions(
StaticCast<FSGIC_TArray_TArray_FVector*>(JointPositions)->Array);
}
void SGCoreImpl_FSGHandPoseImpl_GetJointRotations(
void* Instance,
void* OutRotations)
@@ -2104,14 +1988,6 @@ void SGCoreImpl_FSGHandPoseImpl_GetJointRotations(
StaticCast<FSGIC_FSGHandPoseImpl*>(Instance)->HandPoseImpl.GetJointRotations();
}
void SGCoreImpl_FSGHandPoseImpl_SetJointRotations(
void* Instance,
void* JointRotations)
{
StaticCast<FSGIC_FSGHandPoseImpl*>(Instance)->HandPoseImpl.SetJointRotations(
StaticCast<FSGIC_TArray_TArray_FQuat*>(JointRotations)->Array);
}
void SGCoreImpl_FSGHandPoseImpl_GetHandAngles(
void* Instance,
void* OutAngles)
@@ -2120,14 +1996,6 @@ void SGCoreImpl_FSGHandPoseImpl_GetHandAngles(
StaticCast<FSGIC_FSGHandPoseImpl*>(Instance)->HandPoseImpl.GetHandAngles();
}
void SGCoreImpl_FSGHandPoseImpl_SetHandAngles(
void* Instance,
void* HandAngles)
{
StaticCast<FSGIC_FSGHandPoseImpl*>(Instance)->HandPoseImpl.SetHandAngles(
StaticCast<FSGIC_TArray_TArray_FVector*>(HandAngles)->Array);
}
bool SGCoreImpl_FSGHandPoseImpl_Equals(
void* Instance,
void* HandPoseImpl)
@@ -2292,13 +2160,6 @@ bool SGCoreImpl_FSGHandProfileImpl_IsRight(
return StaticCast<FSGIC_FSGHandProfileImpl*>(Instance)->HandProfileImpl.IsRight();
}
void SGCoreImpl_FSGHandProfileImpl_SetIsRight(
void* Instance,
const bool bRightHanded)
{
StaticCast<FSGIC_FSGHandProfileImpl*>(Instance)->HandProfileImpl.SetIsRight(bRightHanded);
}
void SGCoreImpl_FSGHandProfileImpl_GetSenseGloveHandProfile(
void* Instance,
void* OutProfile)
@@ -2307,14 +2168,6 @@ void SGCoreImpl_FSGHandProfileImpl_GetSenseGloveHandProfile(
StaticCast<FSGIC_FSGHandProfileImpl*>(Instance)->HandProfileImpl.GetSenseGloveHandProfile();
}
void SGCoreImpl_FSGHandProfileImpl_SetSenseGloveHandProfile(
void* Instance,
void* SenseGloveHandProfile)
{
StaticCast<FSGIC_FSGHandProfileImpl*>(Instance)->HandProfileImpl.SetSenseGloveHandProfile(
StaticCast<FSGIC_FSGSenseGloveHandProfileImpl*>(SenseGloveHandProfile)->SenseGloveHandProfileImpl);
}
void SGCoreImpl_FSGHandProfileImpl_GetNovaGloveHandProfile(
void* Instance,
void* OutProfile)
@@ -2323,14 +2176,6 @@ void SGCoreImpl_FSGHandProfileImpl_GetNovaGloveHandProfile(
StaticCast<FSGIC_FSGHandProfileImpl*>(Instance)->HandProfileImpl.GetNovaGloveHandProfile();
}
void SGCoreImpl_FSGHandProfileImpl_SetNovaGloveHandProfile(
void* Instance,
void* NovaGloveHandProfile)
{
StaticCast<FSGIC_FSGHandProfileImpl*>(Instance)->HandProfileImpl.SetNovaGloveHandProfile(
StaticCast<FSGIC_FSGNovaGloveHandProfileImpl*>(NovaGloveHandProfile)->NovaGloveHandProfileImpl);
}
bool SGCoreImpl_FSGHandProfileImpl_Equals(
void* Instance,
void* HandProfileImpl)
@@ -2756,24 +2601,6 @@ void SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_ctor_copy_assignment(
HapticGloveCalibrationCheckImpl;
}
void SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_GetLastSensorRange(
void* Instance,
void* OutLastSensorRange)
{
StaticCast<FSGIC_FSGSensorRangeImpl*>(OutLastSensorRange)->SensorRangeImpl =
StaticCast<FSGIC_FSGHapticGloveCalibrationCheckImpl*>(
Instance)->HapticGloveCalibrationCheckImpl.GetLastSensorRange();
}
void SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_SetLastSensorRange(
void* Instance,
void* LastSensorRange)
{
StaticCast<FSGIC_FSGHapticGloveCalibrationCheckImpl*>(
Instance)->HapticGloveCalibrationCheckImpl.SetLastSensorRange(
StaticCast<FSGIC_FSGSensorRangeImpl*>(LastSensorRange)->SensorRangeImpl);
}
void SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_GetCalibrationStage(
void* Instance,
void* OutStage)
@@ -3101,17 +2928,6 @@ void SGCoreImpl_FSGHapticGloveCommandBufferImpl_GetForceFeedbackCommandsQueue(
GetForceFeedbackCommandsQueue();
}
void SGCoreImpl_FSGHapticGloveCommandBufferImpl_SetForceFeedbackCommandsQueue(
void* Instance,
void* ForceFeedbackCommandsQueue)
{
StaticCast<FSGIC_FSGHapticGloveCommandBufferImpl*>(Instance)->HapticGloveCommandBufferImpl.
SetForceFeedbackCommandsQueue(
StaticCast<
FSGIC_TArray_FSGForceFeedbackCommandImpl*>(
ForceFeedbackCommandsQueue)->Array);
}
void SGCoreImpl_FSGHapticGloveCommandBufferImpl_GetBuzzCommandsQueue(
void* Instance,
void* OutBuzzCommandsQueue)
@@ -3121,16 +2937,6 @@ void SGCoreImpl_FSGHapticGloveCommandBufferImpl_GetBuzzCommandsQueue(
GetBuzzCommandsQueue();
}
void SGCoreImpl_FSGHapticGloveCommandBufferImpl_SetBuzzCommandsQueue(
void* Instance,
void* BuzzCommandsQueue)
{
StaticCast<FSGIC_FSGHapticGloveCommandBufferImpl*>(Instance)->HapticGloveCommandBufferImpl.
SetBuzzCommandsQueue(
StaticCast<FSGIC_TArray_FSGTimedBuzzCommandImpl*>(
BuzzCommandsQueue)->Array);
}
void SGCoreImpl_FSGHapticGloveCommandBufferImpl_GetThumperCommandsQueue(
void* Instance,
void* OutThumperCommandsQueue)
@@ -3140,17 +2946,6 @@ void SGCoreImpl_FSGHapticGloveCommandBufferImpl_GetThumperCommandsQueue(
GetThumperCommandsQueue();
}
void SGCoreImpl_FSGHapticGloveCommandBufferImpl_SetThumperCommandsQueue(
void* Instance,
void* ThumperCommandsQueue)
{
StaticCast<FSGIC_FSGHapticGloveCommandBufferImpl*>(Instance)->HapticGloveCommandBufferImpl.
SetThumperCommandsQueue(
StaticCast<FSGIC_TArray_FSGTimedThumpCommandImpl
*>(
ThumperCommandsQueue)->Array);
}
void SGCoreImpl_FSGHapticGloveCommandBufferImpl_ClearForceFeedbackCommandsQueue(
void* Instance)
{
@@ -3456,14 +3251,6 @@ float SGCoreImpl_FSGHapticGloveQuickCalibrationImpl_GetAutoEndTimeout(
return StaticCast<FSGIC_TSharedPtr_FSGHapticGloveQuickCalibrationImpl*>(Instance)->Ptr->GetAutoEndTimeout();
}
void SGCoreImpl_FSGHapticGloveQuickCalibrationImpl_SetAutoEndTimeout(
void* Instance,
const float AutoEndTimeout)
{
StaticCast<FSGIC_TSharedPtr_FSGHapticGloveQuickCalibrationImpl*>(Instance)->Ptr->SetAutoEndTimeout(
AutoEndTimeout);
}
int32 SGCoreImpl_FSGHapticGloveQuickCalibrationImpl_GetSmoothingSamples(
void* Instance)
{
@@ -4305,13 +4092,6 @@ bool SGCoreImpl_FSGNovaGloveHandProfileImpl_IsRight(
return StaticCast<FSGIC_FSGNovaGloveHandProfileImpl*>(Instance)->NovaGloveHandProfileImpl.IsRight();
}
void SGCoreImpl_FSGNovaGloveHandProfileImpl_SetIsRight(
void* Instance,
const bool bRightHanded)
{
StaticCast<FSGIC_FSGNovaGloveHandProfileImpl*>(Instance)->NovaGloveHandProfileImpl.SetIsRight(bRightHanded);
}
void SGCoreImpl_FSGNovaGloveHandProfileImpl_GetInterpolationSet(
void* Instance,
void* OutSet)
@@ -4320,14 +4100,6 @@ void SGCoreImpl_FSGNovaGloveHandProfileImpl_GetInterpolationSet(
StaticCast<FSGIC_FSGNovaGloveHandProfileImpl*>(Instance)->NovaGloveHandProfileImpl.GetInterpolationSet();
}
void SGCoreImpl_FSGNovaGloveHandProfileImpl_SetInterpolationSet(
void* Instance,
void* InterpolationSet)
{
StaticCast<FSGIC_FSGNovaGloveHandProfileImpl*>(Instance)->NovaGloveHandProfileImpl.SetInterpolationSet(
StaticCast<FSGIC_FSGHandInterpolatorImpl*>(InterpolationSet)->HandInterpolatorImpl);
}
bool SGCoreImpl_FSGNovaGloveHandProfileImpl_Equals(
void* Instance,
void* NovaGloveHandProfileImpl)
@@ -4424,14 +4196,6 @@ void SGCoreImpl_FSGNovaGloveInfoImpl_GetDeviceId(
StaticCast<FSGIC_FSGNovaGloveInfoImpl*>(Instance)->NovaGloveInfoImpl.GetDeviceId();
}
void SGCoreImpl_FSGNovaGloveInfoImpl_SetDeviceId(
void* Instance,
void* DeviceId)
{
StaticCast<FSGIC_FSGNovaGloveInfoImpl*>(Instance)->NovaGloveInfoImpl.SetDeviceId(
StaticCast<FSGIC_FString*>(DeviceId)->String);
}
void SGCoreImpl_FSGNovaGloveInfoImpl_GetHardwareVersion(
void* Instance,
void* OutVersion)
@@ -4440,53 +4204,24 @@ void SGCoreImpl_FSGNovaGloveInfoImpl_GetHardwareVersion(
StaticCast<FSGIC_FSGNovaGloveInfoImpl*>(Instance)->NovaGloveInfoImpl.GetHardwareVersion();
}
void SGCoreImpl_FSGNovaGloveInfoImpl_SetHardwareVersion(
void* Instance,
void* HardwareVersion)
{
StaticCast<FSGIC_FSGNovaGloveInfoImpl*>(Instance)->NovaGloveInfoImpl.SetHardwareVersion(
StaticCast<FSGIC_FString*>(HardwareVersion)->String);
}
int32 SGCoreImpl_FSGNovaGloveInfoImpl_GetFirmwareVersion(
void* Instance)
{
return StaticCast<FSGIC_FSGNovaGloveInfoImpl*>(Instance)->NovaGloveInfoImpl.GetFirmwareVersion();
}
void SGCoreImpl_FSGNovaGloveInfoImpl_SetFirmwareVersion(
void* Instance,
const int32 FirmwareVersion)
{
StaticCast<FSGIC_FSGNovaGloveInfoImpl*>(Instance)->NovaGloveInfoImpl.SetFirmwareVersion(FirmwareVersion);
}
int32 SGCoreImpl_FSGNovaGloveInfoImpl_GetSubFirmwareVersion(
void* Instance)
{
return StaticCast<FSGIC_FSGNovaGloveInfoImpl*>(Instance)->NovaGloveInfoImpl.GetSubFirmwareVersion();
}
void SGCoreImpl_FSGNovaGloveInfoImpl_SetSubFirmwareVersion(
void* Instance,
const int32 SubFirmwareVersion)
{
StaticCast<FSGIC_FSGNovaGloveInfoImpl*>(Instance)->NovaGloveInfoImpl.SetSubFirmwareVersion(SubFirmwareVersion);
}
bool SGCoreImpl_FSGNovaGloveInfoImpl_IsRight(
void* Instance)
{
return StaticCast<FSGIC_FSGNovaGloveInfoImpl*>(Instance)->NovaGloveInfoImpl.IsRight();
}
void SGCoreImpl_FSGNovaGloveInfoImpl_SetIsRight(
void* Instance,
const bool bRightHanded)
{
StaticCast<FSGIC_FSGNovaGloveInfoImpl*>(Instance)->NovaGloveInfoImpl.SetIsRight(bRightHanded);
}
void SGCoreImpl_FSGNovaGloveInfoImpl_GetImuCorrection(
void* Instance,
void* OutCorrection)
@@ -4495,27 +4230,12 @@ void SGCoreImpl_FSGNovaGloveInfoImpl_GetImuCorrection(
StaticCast<FSGIC_FSGNovaGloveInfoImpl*>(Instance)->NovaGloveInfoImpl.GetImuCorrection();
}
void SGCoreImpl_FSGNovaGloveInfoImpl_SetImuCorrection(
void* Instance,
void* ImuCorrection)
{
StaticCast<FSGIC_FSGNovaGloveInfoImpl*>(Instance)->NovaGloveInfoImpl.SetImuCorrection(
StaticCast<FSGIC_FQuat*>(ImuCorrection)->Quat);
}
int32 SGCoreImpl_FSGNovaGloveInfoImpl_GetNumberOfSensors(
void* Instance)
{
return StaticCast<FSGIC_FSGNovaGloveInfoImpl*>(Instance)->NovaGloveInfoImpl.GetNumberOfSensors();
}
void SGCoreImpl_FSGNovaGloveInfoImpl_SetNumberOfSensors(
void* Instance,
const int32 NumberOfSensors)
{
StaticCast<FSGIC_FSGNovaGloveInfoImpl*>(Instance)->NovaGloveInfoImpl.SetNumberOfSensors(NumberOfSensors);
}
bool SGCoreImpl_FSGNovaGloveInfoImpl_Equals(
void* Instance,
void* NovaGloveInfoImpl)
@@ -4621,14 +4341,6 @@ void SGCoreImpl_FSGNovaGloveSensorDataImpl_GetSensorValues(
StaticCast<FSGIC_FSGNovaGloveSensorDataImpl*>(Instance)->NovaGloveSensorDataImpl.GetSensorValues();
}
void SGCoreImpl_FSGNovaGloveSensorDataImpl_SetSensorValues(
void* Instance,
void* SensorValues)
{
StaticCast<FSGIC_FSGNovaGloveSensorDataImpl*>(Instance)->NovaGloveSensorDataImpl.SetSensorValues(
StaticCast<FSGIC_TArray_FVector*>(SensorValues)->Array);
}
void SGCoreImpl_FSGNovaGloveSensorDataImpl_GetImuRotation(
void* Instance,
void* OutRotation)
@@ -4637,66 +4349,30 @@ void SGCoreImpl_FSGNovaGloveSensorDataImpl_GetImuRotation(
StaticCast<FSGIC_FSGNovaGloveSensorDataImpl*>(Instance)->NovaGloveSensorDataImpl.GetImuRotation();
}
void SGCoreImpl_FSGNovaGloveSensorDataImpl_SetImuRotation(
void* Instance,
void* ImuRotation)
{
StaticCast<FSGIC_FSGNovaGloveSensorDataImpl*>(Instance)->NovaGloveSensorDataImpl.SetImuRotation(
StaticCast<FSGIC_FQuat*>(ImuRotation)->Quat);
}
int32 SGCoreImpl_FSGNovaGloveSensorDataImpl_GetParsedValues(
void* Instance)
{
return StaticCast<FSGIC_FSGNovaGloveSensorDataImpl*>(Instance)->NovaGloveSensorDataImpl.GetParsedValues();
}
void SGCoreImpl_FSGNovaGloveSensorDataImpl_SetParsedValues(
void* Instance,
const int32 ParsedValues)
{
StaticCast<FSGIC_FSGNovaGloveSensorDataImpl*>(Instance)->NovaGloveSensorDataImpl.SetParsedValues(ParsedValues);
}
bool SGCoreImpl_FSGNovaGloveSensorDataImpl_IsImuParsed(
void* Instance)
{
return StaticCast<FSGIC_FSGNovaGloveSensorDataImpl*>(Instance)->NovaGloveSensorDataImpl.IsImuParsed();
}
void SGCoreImpl_FSGNovaGloveSensorDataImpl_SetImuParsed(
void* Instance,
const bool bImuParsed)
{
StaticCast<FSGIC_FSGNovaGloveSensorDataImpl*>(Instance)->NovaGloveSensorDataImpl.SetImuParsed(bImuParsed);
}
float SGCoreImpl_FSGNovaGloveSensorDataImpl_GetBatteryLevel(
void* Instance)
{
return StaticCast<FSGIC_FSGNovaGloveSensorDataImpl*>(Instance)->NovaGloveSensorDataImpl.GetBatteryLevel();
}
void SGCoreImpl_FSGNovaGloveSensorDataImpl_SetBatteryLevel(
void* Instance,
const float BatteryLevel)
{
StaticCast<FSGIC_FSGNovaGloveSensorDataImpl*>(Instance)->NovaGloveSensorDataImpl.SetBatteryLevel(BatteryLevel);
}
bool SGCoreImpl_FSGNovaGloveSensorDataImpl_IsCharging(
void* Instance)
{
return StaticCast<FSGIC_FSGNovaGloveSensorDataImpl*>(Instance)->NovaGloveSensorDataImpl.IsCharging();
}
void SGCoreImpl_FSGNovaGloveSensorDataImpl_SetIsCharging(
void* Instance,
const bool bCharging)
{
StaticCast<FSGIC_FSGNovaGloveSensorDataImpl*>(Instance)->NovaGloveSensorDataImpl.SetIsCharging(bCharging);
}
bool SGCoreImpl_FSGNovaGloveSensorDataImpl_Equals(
void* Instance,
void* NovaGloveSensorDataImpl)
@@ -5306,13 +4982,6 @@ bool SGCoreImpl_FSGSenseGloveHandProfileImpl_IsRight(
return StaticCast<FSGIC_FSGSenseGloveHandProfileImpl*>(Instance)->SenseGloveHandProfileImpl.IsRight();
}
void SGCoreImpl_FSGSenseGloveHandProfileImpl_SetIsRight(
void* Instance,
const bool bRightHanded)
{
StaticCast<FSGIC_FSGSenseGloveHandProfileImpl*>(Instance)->SenseGloveHandProfileImpl.SetIsRight(bRightHanded);
}
void SGCoreImpl_FSGSenseGloveHandProfileImpl_GetInterpolationSet(
void* Instance,
void* OutSet)
@@ -5321,14 +4990,6 @@ void SGCoreImpl_FSGSenseGloveHandProfileImpl_GetInterpolationSet(
StaticCast<FSGIC_FSGSenseGloveHandProfileImpl*>(Instance)->SenseGloveHandProfileImpl.GetInterpolationSet();
}
void SGCoreImpl_FSGSenseGloveHandProfileImpl_SetInterpolationSet(
void* Instance,
void* InterpolationSet)
{
StaticCast<FSGIC_FSGSenseGloveHandProfileImpl*>(Instance)->SenseGloveHandProfileImpl.SetInterpolationSet(
StaticCast<FSGIC_FSGHandInterpolatorImpl*>(InterpolationSet)->HandInterpolatorImpl);
}
void SGCoreImpl_FSGSenseGloveHandProfileImpl_GetThumbSolver(
void* Instance,
void* OutSolver)
@@ -5337,14 +4998,6 @@ void SGCoreImpl_FSGSenseGloveHandProfileImpl_GetThumbSolver(
StaticCast<FSGIC_FSGSenseGloveHandProfileImpl*>(Instance)->SenseGloveHandProfileImpl.GetThumbSolver();
}
void SGCoreImpl_FSGSenseGloveHandProfileImpl_SetThumbSolver(
void* Instance,
void* ThumbSolver)
{
StaticCast<FSGIC_FSGSenseGloveHandProfileImpl*>(Instance)->SenseGloveHandProfileImpl.SetThumbSolver(
StaticCast<FSGIC_ESGThumbSolver*>(ThumbSolver)->Solver);
}
void SGCoreImpl_FSGSenseGloveHandProfileImpl_GetFingerSolver(
void* Instance,
void* OutSolver)
@@ -5353,14 +5006,6 @@ void SGCoreImpl_FSGSenseGloveHandProfileImpl_GetFingerSolver(
StaticCast<FSGIC_FSGSenseGloveHandProfileImpl*>(Instance)->SenseGloveHandProfileImpl.GetFingerSolver();
}
void SGCoreImpl_FSGSenseGloveHandProfileImpl_SetFingerSolver(
void* Instance,
void* FingerSolver)
{
StaticCast<FSGIC_FSGSenseGloveHandProfileImpl*>(Instance)->SenseGloveHandProfileImpl.SetFingerSolver(
StaticCast<FSGIC_ESGFingerSolver*>(FingerSolver)->Solver);
}
void SGCoreImpl_FSGSenseGloveHandProfileImpl_GetFingerThimbleOffset(
void* Instance,
void* OutOffset)
@@ -5369,14 +5014,6 @@ void SGCoreImpl_FSGSenseGloveHandProfileImpl_GetFingerThimbleOffset(
StaticCast<FSGIC_FSGSenseGloveHandProfileImpl*>(Instance)->SenseGloveHandProfileImpl.GetFingerThimbleOffset();
}
void SGCoreImpl_FSGSenseGloveHandProfileImpl_SetFingerThimbleOffset(
void* Instance,
void* FingerThimbleOffset)
{
StaticCast<FSGIC_FSGSenseGloveHandProfileImpl*>(Instance)->SenseGloveHandProfileImpl.SetFingerThimbleOffset(
StaticCast<FSGIC_TArray_FVector*>(FingerThimbleOffset)->Array);
}
bool SGCoreImpl_FSGSenseGloveHandProfileImpl_Equals(
void* Instance,
void* SenseGloveHandProfileImpl)
@@ -5483,14 +5120,6 @@ void SGCoreImpl_FSGSenseGloveInfoImpl_GetDeviceId(
StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.GetDeviceId();
}
void SGCoreImpl_FSGSenseGloveInfoImpl_SetDeviceId(
void* Instance,
void* DeviceId)
{
StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.SetDeviceId(
StaticCast<FSGIC_FString*>(DeviceId)->String);
}
void SGCoreImpl_FSGSenseGloveInfoImpl_GetHardwareVersion(
void* Instance,
void* OutVersion)
@@ -5499,66 +5128,30 @@ void SGCoreImpl_FSGSenseGloveInfoImpl_GetHardwareVersion(
StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.GetHardwareVersion();
}
void SGCoreImpl_FSGSenseGloveInfoImpl_SetHardwareVersion(
void* Instance,
void* HardwareVersion)
{
StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.SetHardwareVersion(
StaticCast<FSGIC_FString*>(HardwareVersion)->String);
}
int32 SGCoreImpl_FSGSenseGloveInfoImpl_GetFirmwareVersion(
void* Instance)
{
return StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.GetFirmwareVersion();
}
void SGCoreImpl_FSGSenseGloveInfoImpl_SetFirmwareVersion(
void* Instance,
const int32 FirmwareVersion)
{
StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.SetFirmwareVersion(FirmwareVersion);
}
int32 SGCoreImpl_FSGSenseGloveInfoImpl_GetSubFirmwareVersion(
void* Instance)
{
return StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.GetSubFirmwareVersion();
}
void SGCoreImpl_FSGSenseGloveInfoImpl_SetSubFirmwareVersion(
void* Instance,
const int32 SubFirmwareVersion)
{
StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.SetSubFirmwareVersion(SubFirmwareVersion);
}
bool SGCoreImpl_FSGSenseGloveInfoImpl_IsRight(
void* Instance)
{
return StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.IsRight();
}
void SGCoreImpl_FSGSenseGloveInfoImpl_SetIsRight(
void* Instance,
const bool bRightHanded)
{
StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.SetIsRight(bRightHanded);
}
int32 SGCoreImpl_FSGSenseGloveInfoImpl_GetNumberOfSensors(
void* Instance)
{
return StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.GetNumberOfSensors();
}
void SGCoreImpl_FSGSenseGloveInfoImpl_SetNumberOfSensors(
void* Instance,
const int32 NumberOfSensors)
{
StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.SetNumberOfSensors(NumberOfSensors);
}
void SGCoreImpl_FSGSenseGloveInfoImpl_GetImuCorrection(
void* Instance,
void* OutCorrection)
@@ -5567,14 +5160,6 @@ void SGCoreImpl_FSGSenseGloveInfoImpl_GetImuCorrection(
StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.GetImuCorrection();
}
void SGCoreImpl_FSGSenseGloveInfoImpl_SetImuCorrection(
void* Instance,
void* ImuCorrection)
{
StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.SetImuCorrection(
StaticCast<FSGIC_FQuat*>(ImuCorrection)->Quat);
}
void SGCoreImpl_FSGSenseGloveInfoImpl_GetStartPositions(
void* Instance,
void* OutPositions)
@@ -5583,14 +5168,6 @@ void SGCoreImpl_FSGSenseGloveInfoImpl_GetStartPositions(
StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.GetStartPositions();
}
void SGCoreImpl_FSGSenseGloveInfoImpl_SetStartPositions(
void* Instance,
void* StartPositions)
{
StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.SetStartPositions(
StaticCast<FSGIC_TArray_FVector*>(StartPositions)->Array);
}
void SGCoreImpl_FSGSenseGloveInfoImpl_GetStartRotations(
void* Instance,
void* OutRotations)
@@ -5599,14 +5176,6 @@ void SGCoreImpl_FSGSenseGloveInfoImpl_GetStartRotations(
StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.GetStartRotations();
}
void SGCoreImpl_FSGSenseGloveInfoImpl_SetStartRotations(
void* Instance,
void* StartRotations)
{
StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.SetStartRotations(
StaticCast<FSGIC_TArray_FQuat*>(StartRotations)->Array);
}
void SGCoreImpl_FSGSenseGloveInfoImpl_GetGloveLengths(
void* Instance,
void* OutLengths)
@@ -5615,14 +5184,6 @@ void SGCoreImpl_FSGSenseGloveInfoImpl_GetGloveLengths(
StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.GetGloveLengths();
}
void SGCoreImpl_FSGSenseGloveInfoImpl_SetGloveLengths(
void* Instance,
void* GloveLengths)
{
StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.SetGloveLengths(
StaticCast<FSGIC_TArray_TArray_FVector*>(GloveLengths)->Array);
}
void SGCoreImpl_FSGSenseGloveInfoImpl_GetFunctions(
void* Instance,
void* OutFunctions)
@@ -5631,14 +5192,6 @@ void SGCoreImpl_FSGSenseGloveInfoImpl_GetFunctions(
StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.GetFunctions();
}
void SGCoreImpl_FSGSenseGloveInfoImpl_SetFunctions(
void* Instance,
void* Functions)
{
StaticCast<FSGIC_FSGSenseGloveInfoImpl*>(Instance)->SenseGloveInfoImpl.SetFunctions(
StaticCast<FSGIC_TArray_bool*>(Functions)->Array);
}
void SGCoreImpl_FSGSenseGloveInfoImpl_GetStartPosition(
void* Instance,
void* OutPosition,
@@ -5777,13 +5330,6 @@ bool SGCoreImpl_FSGSenseGlovePoseImpl_IsRight(
return StaticCast<FSGIC_FSGSenseGlovePoseImpl*>(Instance)->SenseGlovePoseImpl.IsRight();
}
void SGCoreImpl_FSGSenseGlovePoseImpl_SetIsRight(
void* Instance,
const bool bRightGloveed)
{
StaticCast<FSGIC_FSGSenseGlovePoseImpl*>(Instance)->SenseGlovePoseImpl.SetIsRight(bRightGloveed);
}
void SGCoreImpl_FSGSenseGlovePoseImpl_GetJointPositions(
void* Instance,
void* OutPositions)
@@ -5792,14 +5338,6 @@ void SGCoreImpl_FSGSenseGlovePoseImpl_GetJointPositions(
StaticCast<FSGIC_FSGSenseGlovePoseImpl*>(Instance)->SenseGlovePoseImpl.GetJointPositions();
}
void SGCoreImpl_FSGSenseGlovePoseImpl_SetJointPositions(
void* Instance,
void* JointPositions)
{
StaticCast<FSGIC_FSGSenseGlovePoseImpl*>(Instance)->SenseGlovePoseImpl.SetJointPositions(
StaticCast<FSGIC_TArray_TArray_FVector*>(JointPositions)->Array);
}
void SGCoreImpl_FSGSenseGlovePoseImpl_GetJointRotations(
void* Instance,
void* OutRotations)
@@ -5808,14 +5346,6 @@ void SGCoreImpl_FSGSenseGlovePoseImpl_GetJointRotations(
StaticCast<FSGIC_FSGSenseGlovePoseImpl*>(Instance)->SenseGlovePoseImpl.GetJointRotations();
}
void SGCoreImpl_FSGSenseGlovePoseImpl_SetJointRotations(
void* Instance,
void* JointRotations)
{
StaticCast<FSGIC_FSGSenseGlovePoseImpl*>(Instance)->SenseGlovePoseImpl.SetJointRotations(
StaticCast<FSGIC_TArray_TArray_FQuat*>(JointRotations)->Array);
}
void SGCoreImpl_FSGSenseGlovePoseImpl_GetGloveAngles(
void* Instance,
void* OutAngles)
@@ -5824,14 +5354,6 @@ void SGCoreImpl_FSGSenseGlovePoseImpl_GetGloveAngles(
StaticCast<FSGIC_FSGSenseGlovePoseImpl*>(Instance)->SenseGlovePoseImpl.GetGloveAngles();
}
void SGCoreImpl_FSGSenseGlovePoseImpl_SetGloveAngles(
void* Instance,
void* GloveAngles)
{
StaticCast<FSGIC_FSGSenseGlovePoseImpl*>(Instance)->SenseGlovePoseImpl.SetGloveAngles(
StaticCast<FSGIC_TArray_TArray_FVector*>(GloveAngles)->Array);
}
void SGCoreImpl_FSGSenseGlovePoseImpl_GetThimblePositions(
void* Instance,
void* OutPositions)
@@ -5978,14 +5500,6 @@ void SGCoreImpl_FSGSenseGloveSensorDataImpl_GetSensorAngles(
StaticCast<FSGIC_FSGSenseGloveSensorDataImpl*>(Instance)->SenseGloveSensorDataImpl.GetSensorAngles();
}
void SGCoreImpl_FSGSenseGloveSensorDataImpl_SetSensorAngles(
void* Instance,
void* SensorAngles)
{
StaticCast<FSGIC_FSGSenseGloveSensorDataImpl*>(Instance)->SenseGloveSensorDataImpl.SetSensorAngles(
StaticCast<FSGIC_TArray_TArray_float*>(SensorAngles)->Array);
}
void SGCoreImpl_FSGSenseGloveSensorDataImpl_GetSensorAngles_Finger(
void* Instance,
void* OutAngles,
@@ -6012,40 +5526,18 @@ void SGCoreImpl_FSGSenseGloveSensorDataImpl_GetImuRotation(
StaticCast<FSGIC_FSGSenseGloveSensorDataImpl*>(Instance)->SenseGloveSensorDataImpl.GetImuRotation();
}
void SGCoreImpl_FSGSenseGloveSensorDataImpl_SetImuRotation(
void* Instance,
void* ImuRotation)
{
StaticCast<FSGIC_FSGSenseGloveSensorDataImpl*>(Instance)->SenseGloveSensorDataImpl.SetImuRotation(
StaticCast<FSGIC_FQuat*>(ImuRotation)->Quat);
}
int32 SGCoreImpl_FSGSenseGloveSensorDataImpl_GetParsedValues(
void* Instance)
{
return StaticCast<FSGIC_FSGSenseGloveSensorDataImpl*>(Instance)->SenseGloveSensorDataImpl.GetParsedValues();
}
void SGCoreImpl_FSGSenseGloveSensorDataImpl_SetParsedValues(
void* Instance,
const int32 ParsedValues)
{
StaticCast<FSGIC_FSGSenseGloveSensorDataImpl*>(Instance)->SenseGloveSensorDataImpl.SetParsedValues(ParsedValues);
}
bool SGCoreImpl_FSGSenseGloveSensorDataImpl_IsImuParsed(
void* Instance)
{
return StaticCast<FSGIC_FSGSenseGloveSensorDataImpl*>(Instance)->SenseGloveSensorDataImpl.IsImuParsed();
}
void SGCoreImpl_FSGSenseGloveSensorDataImpl_SetImuParsed(
void* Instance,
const bool bImuParsed)
{
StaticCast<FSGIC_FSGSenseGloveSensorDataImpl*>(Instance)->SenseGloveSensorDataImpl.SetImuParsed(bImuParsed);
}
bool SGCoreImpl_FSGSenseGloveSensorDataImpl_Equals(
void* Instance,
void* SenseGloveSensorDataImpl)
@@ -6548,53 +6040,18 @@ void SGCoreImpl_FSGTimedBuzzCommandImpl_GetBaseCommand(
StaticCast<FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl*>(Instance)->Ptr->GetBaseCommand();
}
void SGCoreImpl_FSGTimedBuzzCommandImpl_SetBaseCommand(
void* Instance,
void* BaseCommand)
{
StaticCast<FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl*>(Instance)->Ptr->SetBaseCommand(
StaticCast<FSGIC_FSGBuzzCommandImpl*>(BaseCommand)->BuzzCommandImpl);
}
int32 SGCoreImpl_FSGTimedBuzzCommandImpl_GetMagnitude(
void* Instance)
{
return StaticCast<FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl*>(Instance)->Ptr->GetMagnitude();
}
void SGCoreImpl_FSGTimedBuzzCommandImpl_SetMagnitude(
void* Instance,
const int32 Magnitude)
{
return StaticCast<FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl*>(Instance)->Ptr->SetMagnitude(Magnitude);
}
float SGCoreImpl_FSGTimedBuzzCommandImpl_GetDuration(
void* Instance)
{
return StaticCast<FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl*>(Instance)->Ptr->GetDuration();
}
void SGCoreImpl_FSGTimedBuzzCommandImpl_SetDuration(
void* Instance,
const float Duration)
{
return StaticCast<FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl*>(Instance)->Ptr->SetDuration(Duration);
}
float SGCoreImpl_FSGTimedBuzzCommandImpl_GetElapsedTime(
void* Instance)
{
return StaticCast<FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl*>(Instance)->Ptr->GetElapsedTime();
}
void SGCoreImpl_FSGTimedBuzzCommandImpl_SetElapsedTime(
void* Instance,
const float ElapsedTime)
{
return StaticCast<FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl*>(Instance)->Ptr->SetElapsedTime(ElapsedTime);
}
bool SGCoreImpl_FSGTimedBuzzCommandImpl_HasTimeElapsed(
void* Instance)
{
@@ -6690,39 +6147,18 @@ int32 SGCoreImpl_FSGTimedThumpCommandImpl_GetMagnitude(
return StaticCast<FSGIC_FSGTimedThumpCommandImpl*>(Instance)->TimedThumpCommandImpl.GetMagnitude();
}
void SGCoreImpl_FSGTimedThumpCommandImpl_SetMagnitude(
void* Instance,
const int32 Magnitude)
{
StaticCast<FSGIC_FSGTimedThumpCommandImpl*>(Instance)->TimedThumpCommandImpl.SetMagnitude(Magnitude);
}
float SGCoreImpl_FSGTimedThumpCommandImpl_GetDuration(
void* Instance)
{
return StaticCast<FSGIC_FSGTimedThumpCommandImpl*>(Instance)->TimedThumpCommandImpl.GetDuration();
}
void SGCoreImpl_FSGTimedThumpCommandImpl_SetDuration(
void* Instance,
const float Duration)
{
StaticCast<FSGIC_FSGTimedThumpCommandImpl*>(Instance)->TimedThumpCommandImpl.SetDuration(Duration);
}
float SGCoreImpl_FSGTimedThumpCommandImpl_GetElapsedTime(
void* Instance)
{
return StaticCast<FSGIC_FSGTimedThumpCommandImpl*>(Instance)->TimedThumpCommandImpl.GetElapsedTime();
}
void SGCoreImpl_FSGTimedThumpCommandImpl_SetElapsedTime(
void* Instance,
const float ElapsedTime)
{
StaticCast<FSGIC_FSGTimedThumpCommandImpl*>(Instance)->TimedThumpCommandImpl.SetElapsedTime(ElapsedTime);
}
bool SGCoreImpl_FSGTimedThumpCommandImpl_HasTimeElapsed(
void* Instance)
{
Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGFingerCommandImpl.cpp
-6
View File
@@ -213,12 +213,6 @@ TArray<int32> FSGFingerCommandImpl::GetLevels() const
return FSGArrayUtils::FromStdVector<int32>(Pimpl->FingerCommand->GetLevels());
}
void FSGFingerCommandImpl::SetLevels(const TArray<int32>& Levels)
{
std::vector<int32> LevelsVector{FSGArrayUtils::ToStdVector<int32>(Levels)};
Pimpl->FingerCommand->SetLevels(MoveTemp(LevelsVector));
}
int32 FSGFingerCommandImpl::GetLevel(const int32 Finger) const
{
return Pimpl->FingerCommand->GetLevel(Finger);
Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGHandInterpolatorImpl.cpp
-12
View File
@@ -231,23 +231,11 @@ TArray<TArray<FSGInterpolationSetImpl>> FSGHandInterpolatorImpl::GetJointInterpo
return JointInterpolations;
}
void FSGHandInterpolatorImpl::SetJointInterpolations(const TArray<TArray<FSGInterpolationSetImpl>>& JointInterpolations)
{
Pimpl->HandInterpolator.SetJointInterpolations(
FSGArrayUtils::ToStdVector<FSGInterpolationSetImpl, FSGInterpolationSetImpl::FInterpolationSetType,
&FSGInterpolationSetImpl::ToInterpolationSet>(JointInterpolations));
}
FQuat FSGHandInterpolatorImpl::GetCmcStartRotation() const
{
return FSGQuatImpl(Pimpl->HandInterpolator.GetCmcStartRotation()).ToFQuat();
}
void FSGHandInterpolatorImpl::SetCmcStartRotation(const FQuat& CmcStartRotation)
{
Pimpl->HandInterpolator.SetCmcStartRotation(FSGQuatImpl(CmcStartRotation).ToQuat());
}
float FSGHandInterpolatorImpl::CalculateAngle(const ESGFinger Finger, const int32 Movement, const float Value) const
{
return FSGCoordinates::TransformToUnreal(
Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGHandPoseImpl.cpp
-31
View File
@@ -232,11 +232,6 @@ bool FSGHandPoseImpl::IsRight() const
return Pimpl->HandPose.IsRight();
}
void FSGHandPoseImpl::SetIsRight(const bool bRightHanded) const
{
Pimpl->HandPose.SetIsRight(bRightHanded);
}
TArray<TArray<FVector>> FSGHandPoseImpl::GetJointPositions() const
{
TArray<TArray<FVector>> JointPositions{
@@ -246,15 +241,6 @@ TArray<TArray<FVector>> FSGHandPoseImpl::GetJointPositions() const
return MoveTemp(JointPositions);
}
void FSGHandPoseImpl::SetJointPositions(const TArray<TArray<FVector>>& JointPositions) const
{
std::vector<std::vector<FSGVect3DImpl::FVect3DType>> JointPositionsVector{
FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
JointPositions)
};
Pimpl->HandPose.SetJointPositions(MoveTemp(JointPositionsVector));
}
TArray<TArray<FQuat>> FSGHandPoseImpl::GetJointRotations() const
{
TArray<TArray<FQuat>> JointRotations{
@@ -264,15 +250,6 @@ TArray<TArray<FQuat>> FSGHandPoseImpl::GetJointRotations() const
return MoveTemp(JointRotations);
}
void FSGHandPoseImpl::SetJointRotations(const TArray<TArray<FQuat>>& JointRotations) const
{
std::vector<std::vector<FSGQuatImpl::FQuatType>> JointRotationsVector{
FSGArrayUtils::ToStdVector<FQuat, FSGQuatImpl::FQuatType, FSGQuatImpl, &FSGQuatImpl::ToQuat>(
JointRotations)
};
Pimpl->HandPose.SetJointRotations(MoveTemp(JointRotationsVector));
}
TArray<TArray<FVector>> FSGHandPoseImpl::GetHandAngles() const
{
TArray<TArray<FVector>> HandAngles{
@@ -281,14 +258,6 @@ TArray<TArray<FVector>> FSGHandPoseImpl::GetHandAngles() const
return MoveTemp(HandAngles);
}
void FSGHandPoseImpl::SetHandAngles(const TArray<TArray<FVector>>& HandAngles) const
{
std::vector<std::vector<FSGVect3DImpl::FVect3DType>> HandAnglesVector{
FSGArrayUtils::ToSenseGloveAngles<FSGVect3DImpl::FVect3DType>(HandAngles)
};
Pimpl->HandPose.SetHandAngles(MoveTemp(HandAnglesVector));
}
bool FSGHandPoseImpl::Equals(const FSGHandPoseImpl& HandPoseImpl) const
{
return Pimpl->HandPose.Equals(HandPoseImpl.ToHandPose());
Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGHandProfileImpl.cpp
+1 -16
View File
@@ -218,31 +218,16 @@ bool FSGHandProfileImpl::IsRight() const
return Pimpl->HandProfile.IsRight();
}
void FSGHandProfileImpl::SetIsRight(const bool bRightHanded) const
{
Pimpl->HandProfile.SetIsRight(bRightHanded);
}
FSGSenseGloveHandProfileImpl FSGHandProfileImpl::GetSenseGloveHandProfile() const
{
return FSGSenseGloveHandProfileImpl(Pimpl->HandProfile.GetSenseGloveHandProfile());
}
void FSGHandProfileImpl::SetSenseGloveHandProfile(const FSGSenseGloveHandProfileImpl& SenseGloveHandProfile)
{
Pimpl->HandProfile.SetSenseGloveHandProfile(SenseGloveHandProfile.ToSenseGloveHandProfile());
}
FSGNovaGloveHandProfileImpl FSGHandProfileImpl::GetNovaGloveHandProfile() const
{
return FSGNovaGloveHandProfileImpl(Pimpl->HandProfile.GetNovaGloveHandProfile());
}
void FSGHandProfileImpl::SetNovaGloveHandProfile(const FSGNovaGloveHandProfileImpl& NovaGloveHandProfile)
{
Pimpl->HandProfile.SetNovaGloveHandProfile(NovaGloveHandProfile.ToNovaGloveHandProfile());
}
bool FSGHandProfileImpl::Equals(const FSGHandProfileImpl& HandProfileImpl) const
{
return Pimpl->HandProfile.Equals(HandProfileImpl.ToHandProfile());
@@ -269,4 +254,4 @@ FSGHandProfileImpl::FImpl::~FImpl() = default;
void FSGHandProfileImpl::FImplDeleter::operator()(const FImpl* P) const
{
delete P;
}
}
Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGHapticGloveCalibrationCheckImpl.cpp
-10
View File
@@ -231,16 +231,6 @@ FSGHapticGloveCalibrationCheckImpl::ToHapticGloveCalibrationCheck() const
return Pimpl->HapticGloveCalibrationCheck;
}
FSGSensorRangeImpl FSGHapticGloveCalibrationCheckImpl::GetLastSensorRange() const
{
return FSGSensorRangeImpl{Pimpl->HapticGloveCalibrationCheck.GetLastSensorRange()};
}
void FSGHapticGloveCalibrationCheckImpl::SetLastSensorRange(const FSGSensorRangeImpl& LastSensorRange)
{
Pimpl->HapticGloveCalibrationCheck.SetLastSensorRange(LastSensorRange.ToSensorRange());
}
ESGCalibrationStage FSGHapticGloveCalibrationCheckImpl::GetCalibrationStage() const
{
return FSGCoreEnumCast::ToESGCalibrationStage(Pimpl->HapticGloveCalibrationCheck.GetCalibrationStage());
Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGHapticGloveCommandBufferImpl.cpp
-30
View File
@@ -170,16 +170,6 @@ TArray<FSGForceFeedbackCommandImpl> FSGHapticGloveCommandBufferImpl::GetForceFee
return MoveTemp(ForceFeedbackCommandQueue);
}
void FSGHapticGloveCommandBufferImpl::SetForceFeedbackCommandsQueue(
const TArray<FSGForceFeedbackCommandImpl>& ForceFeedbackCommandsQueue)
{
std::vector<FSGForceFeedbackCommandImpl::FForceFeedbackCommandType> ForceFeedbackCommandsQueueVector{
FSGArrayUtils::ToStdVector<FSGForceFeedbackCommandImpl, FSGForceFeedbackCommandImpl::FForceFeedbackCommandType,
&FSGForceFeedbackCommandImpl::ToForceFeedbackCommand>(ForceFeedbackCommandsQueue)
};
Pimpl->HapticGloveCommandBuffer.SetForceFeedbackCommandsQueue(MoveTemp(ForceFeedbackCommandsQueueVector));
}
TArray<FSGTimedBuzzCommandImpl> FSGHapticGloveCommandBufferImpl::GetBuzzCommandsQueue() const
{
TArray<FSGTimedBuzzCommandImpl> TimedBuzzCommandQueue{
@@ -189,16 +179,6 @@ TArray<FSGTimedBuzzCommandImpl> FSGHapticGloveCommandBufferImpl::GetBuzzCommands
return MoveTemp(TimedBuzzCommandQueue);
}
void FSGHapticGloveCommandBufferImpl::SetBuzzCommandsQueue(
const TArray<FSGTimedBuzzCommandImpl>& TimedBuzzCommandsQueue)
{
std::vector<FSGTimedBuzzCommandImpl::FTimedBuzzCommandType> TimedBuzzCommandsQueueVector{
FSGArrayUtils::ToStdVector<FSGTimedBuzzCommandImpl, FSGTimedBuzzCommandImpl::FTimedBuzzCommandType,
&FSGTimedBuzzCommandImpl::ToTimedBuzzCommand>(TimedBuzzCommandsQueue)
};
Pimpl->HapticGloveCommandBuffer.SetBuzzCommandsQueue(MoveTemp(TimedBuzzCommandsQueueVector));
}
TArray<FSGTimedThumpCommandImpl> FSGHapticGloveCommandBufferImpl::GetThumperCommandsQueue() const
{
TArray<FSGTimedThumpCommandImpl> ThumperCommandQueue{
@@ -208,16 +188,6 @@ TArray<FSGTimedThumpCommandImpl> FSGHapticGloveCommandBufferImpl::GetThumperComm
return MoveTemp(ThumperCommandQueue);
}
void FSGHapticGloveCommandBufferImpl::SetThumperCommandsQueue(
const TArray<FSGTimedThumpCommandImpl>& TimedThumpCommandsQueue)
{
std::vector<FSGTimedThumpCommandImpl::FTimedThumpCommandType> TimedThumpCommandsQueueVector{
FSGArrayUtils::ToStdVector<FSGTimedThumpCommandImpl, FSGTimedThumpCommandImpl::FTimedThumpCommandType,
&FSGTimedThumpCommandImpl::ToTimedThumpCommand>(TimedThumpCommandsQueue)
};
Pimpl->HapticGloveCommandBuffer.SetThumperCommandsQueue(MoveTemp(TimedThumpCommandsQueueVector));
}
void FSGHapticGloveCommandBufferImpl::ClearForceFeedbackCommandsQueue()
{
Pimpl->HapticGloveCommandBuffer.ClearForceFeedbackCommandsQueue();
Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGHapticGloveQuickCalibrationImpl.cpp
-5
View File
@@ -171,11 +171,6 @@ float FSGHapticGloveQuickCalibrationImpl::GetAutoEndTimeout() const
return ToHapticGloveQuickCalibrationRef()->GetAutoEndTimeout();
}
void FSGHapticGloveQuickCalibrationImpl::SetAutoEndTimeout(const float AutoEndTimeout)
{
ToHapticGloveQuickCalibrationRef()->SetAutoEndTimeout(AutoEndTimeout);
}
int32 FSGHapticGloveQuickCalibrationImpl::GetSmoothingSamples() const
{
return ToHapticGloveQuickCalibrationRef()->GetSmoothingSamples();
Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGNovaGloveHandProfileImpl.cpp
-10
View File
@@ -163,11 +163,6 @@ bool FSGNovaGloveHandProfileImpl::IsRight() const
return Pimpl->NovaGloveHandProfile.IsRight();
}
void FSGNovaGloveHandProfileImpl::SetIsRight(const bool bRightHanded)
{
Pimpl->NovaGloveHandProfile.SetIsRight(bRightHanded);
}
FSGHandInterpolatorImpl FSGNovaGloveHandProfileImpl::GetInterpolationSet() const
{
const FSGHandInterpolatorImpl HandInterpolatorImpl(
@@ -175,11 +170,6 @@ FSGHandInterpolatorImpl FSGNovaGloveHandProfileImpl::GetInterpolationSet() const
return HandInterpolatorImpl;
}
void FSGNovaGloveHandProfileImpl::SetInterpolationSet(const FSGHandInterpolatorImpl& InterpolationSet)
{
Pimpl->NovaGloveHandProfile.SetInterpolationSet(InterpolationSet.ToHandInterpolator());
}
bool FSGNovaGloveHandProfileImpl::Equals(const FSGNovaGloveHandProfileImpl& NovaGloveHandProfileImpl) const
{
return Pimpl->NovaGloveHandProfile.Equals(NovaGloveHandProfileImpl.ToNovaGloveHandProfile());
Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGNovaGloveInfoImpl.cpp
-35
View File
@@ -177,73 +177,38 @@ FString FSGNovaGloveInfoImpl::GetDeviceId() const
return DeviceId;
}
void FSGNovaGloveInfoImpl::SetDeviceId(const FString& DeviceId)
{
return Pimpl->NovaGloveInfo.SetDeviceId(TCHAR_TO_UTF8(*DeviceId));
}
FString FSGNovaGloveInfoImpl::GetHardwareVersion() const
{
const FString HardwareVersion(UTF8_TO_TCHAR(Pimpl->NovaGloveInfo.GetHardwareVersion().c_str()));
return HardwareVersion;
}
void FSGNovaGloveInfoImpl::SetHardwareVersion(const FString& HardwareVersion)
{
Pimpl->NovaGloveInfo.SetHardwareVersion(TCHAR_TO_UTF8(*HardwareVersion));
}
int32 FSGNovaGloveInfoImpl::GetFirmwareVersion() const
{
return Pimpl->NovaGloveInfo.GetFirmwareVersion();
}
void FSGNovaGloveInfoImpl::SetFirmwareVersion(const int32 FirmwareVersion)
{
Pimpl->NovaGloveInfo.SetFirmwareVersion(FirmwareVersion);
}
int32 FSGNovaGloveInfoImpl::GetSubFirmwareVersion() const
{
return Pimpl->NovaGloveInfo.GetSubFirmwareVersion();
}
void FSGNovaGloveInfoImpl::SetSubFirmwareVersion(const int32 SubFirmwareVersion)
{
Pimpl->NovaGloveInfo.SetSubFirmwareVersion(SubFirmwareVersion);
}
bool FSGNovaGloveInfoImpl::IsRight() const
{
return Pimpl->NovaGloveInfo.IsRight();
}
void FSGNovaGloveInfoImpl::SetIsRight(const bool bRightHanded)
{
Pimpl->NovaGloveInfo.SetIsRight(bRightHanded);
}
FQuat FSGNovaGloveInfoImpl::GetImuCorrection() const
{
const FQuat ImuCorrection(FSGQuatImpl(Pimpl->NovaGloveInfo.GetImuCorrection()).ToFQuat());
return ImuCorrection;
}
void FSGNovaGloveInfoImpl::SetImuCorrection(const FQuat& ImuCorrection)
{
Pimpl->NovaGloveInfo.SetImuCorrection(FSGQuatImpl(ImuCorrection).ToQuat());
}
int32 FSGNovaGloveInfoImpl::GetNumberOfSensors() const
{
return Pimpl->NovaGloveInfo.GetNumberOfSensors();
}
void FSGNovaGloveInfoImpl::SetNumberOfSensors(const int32 NumberOfSensors)
{
Pimpl->NovaGloveInfo.SetNumberOfSensors(NumberOfSensors);
}
bool FSGNovaGloveInfoImpl::Equals(const FSGNovaGloveInfoImpl& SGNovaGloveInfo) const
{
return Pimpl->NovaGloveInfo.Equals(SGNovaGloveInfo.ToNovaGloveInfo());
Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGNovaGloveSensorDataImpl.cpp
-34
View File
@@ -188,65 +188,31 @@ TArray<FVector> FSGNovaGloveSensorDataImpl::GetSensorValues() const
return MoveTemp(SensorValues);
}
void FSGNovaGloveSensorDataImpl::SetSensorValues(const TArray<FVector>& SensorValues) const
{
std::vector<FSGVect3DImpl::FVect3DType> SensorValuesVector{
FSGArrayUtils::ToStdVector<FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(
SensorValues)
};
Pimpl->NovaGloveSensorData.SetSensorValues(MoveTemp(SensorValuesVector));
}
FQuat FSGNovaGloveSensorDataImpl::GetImuRotation() const
{
return FSGQuatImpl(Pimpl->NovaGloveSensorData.GetImuRotation()).ToFQuat();
}
void FSGNovaGloveSensorDataImpl::SetImuRotation(const FQuat& ImuRotation)
{
Pimpl->NovaGloveSensorData.SetImuRotation(FSGQuatImpl(ImuRotation).ToQuat());
}
int32 FSGNovaGloveSensorDataImpl::GetParsedValues() const
{
return Pimpl->NovaGloveSensorData.GetParsedValues();
}
void FSGNovaGloveSensorDataImpl::SetParsedValues(const int32 ParsedValues)
{
Pimpl->NovaGloveSensorData.SetParsedValues(ParsedValues);
}
bool FSGNovaGloveSensorDataImpl::IsImuParsed() const
{
return Pimpl->NovaGloveSensorData.IsImuParsed();
}
void FSGNovaGloveSensorDataImpl::SetImuParsed(const bool bImuParsed)
{
Pimpl->NovaGloveSensorData.SetImuParsed(bImuParsed);
}
float FSGNovaGloveSensorDataImpl::GetBatteryLevel() const
{
return Pimpl->NovaGloveSensorData.GetBatteryLevel();
}
void FSGNovaGloveSensorDataImpl::SetBatteryLevel(const float BatteryLevel)
{
Pimpl->NovaGloveSensorData.SetBatteryLevel(BatteryLevel);
}
bool FSGNovaGloveSensorDataImpl::IsCharging() const
{
return Pimpl->NovaGloveSensorData.IsCharging();
}
void FSGNovaGloveSensorDataImpl::SetIsCharging(const bool bCharging)
{
Pimpl->NovaGloveSensorData.SetIsCharging(bCharging);
}
bool FSGNovaGloveSensorDataImpl::Equals(const FSGNovaGloveSensorDataImpl& NovaGloveSensorDataImpl) const
{
return Pimpl->NovaGloveSensorData.Equals(NovaGloveSensorDataImpl.ToNovaGloveSensorData());
Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGSenseGloveHandProfileImpl.cpp
+1 -29
View File
@@ -184,11 +184,6 @@ bool FSGSenseGloveHandProfileImpl::IsRight() const
return Pimpl->SenseGloveHandProfile.IsRight();
}
void FSGSenseGloveHandProfileImpl::SetIsRight(const bool bRightHanded)
{
Pimpl->SenseGloveHandProfile.SetIsRight(bRightHanded);
}
FSGHandInterpolatorImpl FSGSenseGloveHandProfileImpl::GetInterpolationSet() const
{
const FSGHandInterpolatorImpl HandInterpolatorImpl(
@@ -196,31 +191,16 @@ FSGHandInterpolatorImpl FSGSenseGloveHandProfileImpl::GetInterpolationSet() cons
return HandInterpolatorImpl;
}
void FSGSenseGloveHandProfileImpl::SetInterpolationSet(const FSGHandInterpolatorImpl& InterpolationSet)
{
Pimpl->SenseGloveHandProfile.SetInterpolationSet(InterpolationSet.ToHandInterpolator());
}
ESGThumbSolver FSGSenseGloveHandProfileImpl::GetThumbSolver() const
{
return FSGCoreEnumCast::ToESGThumbSolver(Pimpl->SenseGloveHandProfile.GetThumbSolver());
}
void FSGSenseGloveHandProfileImpl::SetThumbSolver(const ESGThumbSolver ThumbSolver)
{
Pimpl->SenseGloveHandProfile.SetThumbSolver(FSGCoreEnumCast::ToEThumbSolver(ThumbSolver));
}
ESGFingerSolver FSGSenseGloveHandProfileImpl::GetFingerSolver() const
{
return FSGCoreEnumCast::ToESGFingerSolver(Pimpl->SenseGloveHandProfile.GetFingerSolver());
}
void FSGSenseGloveHandProfileImpl::SetFingerSolver(const ESGFingerSolver FingerSolver)
{
Pimpl->SenseGloveHandProfile.SetFingerSolver(FSGCoreEnumCast::ToEFingerSolver(FingerSolver));
}
TArray<FVector> FSGSenseGloveHandProfileImpl::GetFingerThimbleOffset() const
{
const TArray<FVector> FingerThimbleOffset{
@@ -230,14 +210,6 @@ TArray<FVector> FSGSenseGloveHandProfileImpl::GetFingerThimbleOffset() const
return FingerThimbleOffset;
}
void FSGSenseGloveHandProfileImpl::SetFingerThimbleOffset(const TArray<FVector>& FingerThimbleOffset)
{
std::vector<FSGVect3DImpl::FVect3DType> FingerThimbleOffsetVector{
FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(FingerThimbleOffset)
};
Pimpl->SenseGloveHandProfile.SetFingerThimbleOffset(MoveTemp(FingerThimbleOffsetVector));
}
bool FSGSenseGloveHandProfileImpl::Equals(const FSGSenseGloveHandProfileImpl& SenseGloveHandProfileImpl) const
{
return Pimpl->SenseGloveHandProfile.Equals(SenseGloveHandProfileImpl.ToSenseGloveHandProfile());
@@ -264,4 +236,4 @@ FSGSenseGloveHandProfileImpl::FImpl::~FImpl() = default;
void FSGSenseGloveHandProfileImpl::FImplDeleter::operator()(const FImpl* P) const
{
delete P;
}
}
Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGSenseGloveInfoImpl.cpp
-66
View File
@@ -203,73 +203,38 @@ FString FSGSenseGloveInfoImpl::GetDeviceId() const
return MoveTemp(DeviceId);
}
void FSGSenseGloveInfoImpl::SetDeviceId(const FString& DeviceId)
{
return Pimpl->SenseGloveInfo.SetDeviceId(TCHAR_TO_UTF8(*DeviceId));
}
FString FSGSenseGloveInfoImpl::GetHardwareVersion() const
{
FString HardwareVersion(UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.GetHardwareVersion().c_str()));
return MoveTemp(HardwareVersion);
}
void FSGSenseGloveInfoImpl::SetHardwareVersion(const FString& HardwareVersion)
{
Pimpl->SenseGloveInfo.SetHardwareVersion(TCHAR_TO_UTF8(*HardwareVersion));
}
int32 FSGSenseGloveInfoImpl::GetFirmwareVersion() const
{
return Pimpl->SenseGloveInfo.GetFirmwareVersion();
}
void FSGSenseGloveInfoImpl::SetFirmwareVersion(const int32 FirmwareVersion)
{
Pimpl->SenseGloveInfo.SetFirmwareVersion(FirmwareVersion);
}
int32 FSGSenseGloveInfoImpl::GetSubFirmwareVersion() const
{
return Pimpl->SenseGloveInfo.GetSubFirmwareVersion();
}
void FSGSenseGloveInfoImpl::SetSubFirmwareVersion(const int32 SubFirmwareVersion)
{
Pimpl->SenseGloveInfo.SetSubFirmwareVersion(SubFirmwareVersion);
}
bool FSGSenseGloveInfoImpl::IsRight() const
{
return Pimpl->SenseGloveInfo.IsRight();
}
void FSGSenseGloveInfoImpl::SetIsRight(const bool bRightHanded)
{
Pimpl->SenseGloveInfo.SetIsRight(bRightHanded);
}
int32 FSGSenseGloveInfoImpl::GetNumberOfSensors() const
{
return Pimpl->SenseGloveInfo.GetNumberOfSensors();
}
void FSGSenseGloveInfoImpl::SetNumberOfSensors(const int32 NumberOfSensors)
{
Pimpl->SenseGloveInfo.SetNumberOfSensors(NumberOfSensors);
}
FQuat FSGSenseGloveInfoImpl::GetImuCorrection() const
{
FQuat ImuCorrection(FSGQuatImpl(Pimpl->SenseGloveInfo.GetImuCorrection()).ToFQuat());
return MoveTemp(ImuCorrection);
}
void FSGSenseGloveInfoImpl::SetImuCorrection(const FQuat& ImuCorrection)
{
Pimpl->SenseGloveInfo.SetImuCorrection(FSGQuatImpl(ImuCorrection).ToQuat());
}
TArray<FVector> FSGSenseGloveInfoImpl::GetStartPositions() const
{
TArray<FVector> StartPositionsArray{
@@ -278,14 +243,6 @@ TArray<FVector> FSGSenseGloveInfoImpl::GetStartPositions() const
return MoveTemp(StartPositionsArray);
}
void FSGSenseGloveInfoImpl::SetStartPositions(const TArray<FVector>& StartPositions)
{
std::vector<FSGVect3DImpl::FVect3DType> StartPositionsVector{
FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(StartPositions)
};
Pimpl->SenseGloveInfo.SetStartPositions(MoveTemp(StartPositionsVector));
}
TArray<FQuat> FSGSenseGloveInfoImpl::GetStartRotations() const
{
TArray<FQuat> StartRotationsArray{
@@ -294,15 +251,6 @@ TArray<FQuat> FSGSenseGloveInfoImpl::GetStartRotations() const
return MoveTemp(StartRotationsArray);
}
void FSGSenseGloveInfoImpl::SetStartRotations(const TArray<FQuat>& StartRotations)
{
std::vector<FSGQuatImpl::FQuatType> StartRotationsVector{
FSGArrayUtils::ToStdVector<FQuat, FSGQuatImpl::FQuatType, FSGQuatImpl, &FSGQuatImpl::ToQuat>(
StartRotations)
};
Pimpl->SenseGloveInfo.SetStartRotations(MoveTemp(StartRotationsVector));
}
TArray<TArray<FVector>> FSGSenseGloveInfoImpl::GetGloveLengths() const
{
TArray<TArray<FVector>> GloveLengths{
@@ -312,26 +260,12 @@ TArray<TArray<FVector>> FSGSenseGloveInfoImpl::GetGloveLengths() const
return MoveTemp(GloveLengths);
}
void FSGSenseGloveInfoImpl::SetGloveLengths(const TArray<TArray<FVector>>& GloveLengths) const
{
std::vector<std::vector<FSGVect3DImpl::FVect3DType>> GloveLengthsVector{
FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(GloveLengths)
};
Pimpl->SenseGloveInfo.SetGloveLengths(MoveTemp(GloveLengthsVector));
}
TArray<bool> FSGSenseGloveInfoImpl::GetFunctions() const
{
TArray<bool> FunctionsArray{FSGArrayUtils::FromStdVector(Pimpl->SenseGloveInfo.GetFunctions())};
return MoveTemp(FunctionsArray);
}
void FSGSenseGloveInfoImpl::SetFunctions(const TArray<bool>& Functions) const
{
std::vector<bool> FunctionsVector{FSGArrayUtils::ToStdVector(Functions)};
Pimpl->SenseGloveInfo.SetFunctions(MoveTemp(FunctionsVector));
}
FVector FSGSenseGloveInfoImpl::GetStartPosition(const ESGFinger Finger) const
{
FVector StartPosition{FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGSenseGlovePoseImpl.cpp
-31
View File
@@ -181,11 +181,6 @@ bool FSGSenseGlovePoseImpl::IsRight() const
return Pimpl->SenseGlovePose.IsRight();
}
void FSGSenseGlovePoseImpl::SetIsRight(const bool bRightHanded) const
{
Pimpl->SenseGlovePose.SetIsRight(bRightHanded);
}
TArray<TArray<FVector>> FSGSenseGlovePoseImpl::GetJointPositions() const
{
TArray<TArray<FVector>> JointPositions{
@@ -195,14 +190,6 @@ TArray<TArray<FVector>> FSGSenseGlovePoseImpl::GetJointPositions() const
return MoveTemp(JointPositions);
}
void FSGSenseGlovePoseImpl::SetJointPositions(const TArray<TArray<FVector>>& JointPositions) const
{
std::vector<std::vector<FSGVect3DImpl::FVect3DType>> JointPositionsVector{
FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(JointPositions)
};
Pimpl->SenseGlovePose.SetJointPositions(MoveTemp(JointPositionsVector));
}
TArray<TArray<FQuat>> FSGSenseGlovePoseImpl::GetJointRotations() const
{
TArray<TArray<FQuat>> JointRotations{
@@ -212,15 +199,6 @@ TArray<TArray<FQuat>> FSGSenseGlovePoseImpl::GetJointRotations() const
return MoveTemp(JointRotations);
}
void FSGSenseGlovePoseImpl::SetJointRotations(const TArray<TArray<FQuat>>& JointRotations) const
{
std::vector<std::vector<FSGQuatImpl::FQuatType>> JointRotationsVector{
FSGArrayUtils::ToStdVector<FQuat, FSGQuatImpl::FQuatType, FSGQuatImpl, &FSGQuatImpl::ToQuat>(
JointRotations)
};
Pimpl->SenseGlovePose.SetJointRotations(MoveTemp(JointRotationsVector));
}
TArray<TArray<FVector>> FSGSenseGlovePoseImpl::GetGloveAngles() const
{
TArray<TArray<FVector>> GloveAngles{
@@ -230,15 +208,6 @@ TArray<TArray<FVector>> FSGSenseGlovePoseImpl::GetGloveAngles() const
return MoveTemp(GloveAngles);
}
void FSGSenseGlovePoseImpl::SetGloveAngles(const TArray<TArray<FVector>>& GloveAngles) const
{
std::vector<std::vector<FSGVect3DImpl::FVect3DType>> HandAnglesVector{
FSGArrayUtils::ToSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
GloveAngles)
};
Pimpl->SenseGlovePose.SetGloveAngles(MoveTemp(HandAnglesVector));
}
TArray<FVector> FSGSenseGlovePoseImpl::GetThimblePositions() const
{
TArray<FVector> ThimblePositions{
Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGSenseGloveSensorDataImpl.cpp
-21
View File
@@ -182,12 +182,6 @@ TArray<TArray<float>> FSGSenseGloveSensorDataImpl::GetSensorAngles() const
return MoveTemp(SensorAngles);
}
void FSGSenseGloveSensorDataImpl::SetSensorAngles(const TArray<TArray<float>>& SensorAngles)
{
std::vector<std::vector<float>> SensorAnglesVector{FSGArrayUtils::ToStdVector<float>(SensorAngles)};
Pimpl->SenseGloveSensorData.SetSensorAngles(MoveTemp(SensorAnglesVector));
}
TArray<float> FSGSenseGloveSensorDataImpl::GetSensorAngles(ESGFinger Finger) const
{
TArray<float> SensorAngles{
@@ -210,31 +204,16 @@ FQuat FSGSenseGloveSensorDataImpl::GetImuRotation() const
return FSGQuatImpl(Pimpl->SenseGloveSensorData.GetImuRotation()).ToFQuat();
}
void FSGSenseGloveSensorDataImpl::SetImuRotation(const FQuat& ImuRotation)
{
Pimpl->SenseGloveSensorData.SetImuRotation(FSGQuatImpl{ImuRotation}.ToQuat());
}
int32 FSGSenseGloveSensorDataImpl::GetParsedValues() const
{
return Pimpl->SenseGloveSensorData.GetParsedValues();
}
void FSGSenseGloveSensorDataImpl::SetParsedValues(const int32 ParsedValues)
{
Pimpl->SenseGloveSensorData.SetParsedValues(ParsedValues);
}
bool FSGSenseGloveSensorDataImpl::IsImuParsed() const
{
return Pimpl->SenseGloveSensorData.IsImuParsed();
}
void FSGSenseGloveSensorDataImpl::SetImuParsed(bool bImuParsed)
{
Pimpl->SenseGloveSensorData.SetImuParsed(bImuParsed);
}
bool FSGSenseGloveSensorDataImpl::Equals(const FSGSenseGloveSensorDataImpl& SenseGloveSensorDataImpl) const
{
return Pimpl->SenseGloveSensorData.Equals(SenseGloveSensorDataImpl.ToSenseGloveSensorData());
Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGTimedBuzzCommandImpl.cpp
-25
View File
@@ -189,41 +189,16 @@ FSGBuzzCommandImpl FSGTimedBuzzCommandImpl::GetBaseCommand() const
return FSGBuzzCommandImpl{MakeShared<FBuzzCommandType>(ToTimedBuzzCommandRef()->GetBaseCommand())};
}
void FSGTimedBuzzCommandImpl::SetBaseCommand(const FSGBuzzCommandImpl& BaseCommand)
{
ToTimedBuzzCommandRef()->SetBaseCommand(BaseCommand.ToBuzzCommand());
}
int32 FSGTimedBuzzCommandImpl::GetMagnitude() const
{
return ToTimedBuzzCommandRef()->GetMagnitude();
}
void FSGTimedBuzzCommandImpl::SetMagnitude(const int32 Magnitude)
{
ToTimedBuzzCommandRef()->SetMagnitude(Magnitude);
}
float FSGTimedBuzzCommandImpl::GetDuration() const
{
return ToTimedBuzzCommandRef()->GetDuration();
}
void FSGTimedBuzzCommandImpl::SetDuration(const float Duration)
{
ToTimedBuzzCommandRef()->SetDuration(Duration);
}
float FSGTimedBuzzCommandImpl::GetElapsedTime() const
{
return ToTimedBuzzCommandRef()->GetElapsedTime();
}
void FSGTimedBuzzCommandImpl::SetElapsedTime(const float ElapsedTime)
{
ToTimedBuzzCommandRef()->SetElapsedTime(ElapsedTime);
}
bool FSGTimedBuzzCommandImpl::HasTimeElapsed() const
{
return ToTimedBuzzCommandRef()->HasTimeElapsed();
Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGTimedThumpCommandImpl.cpp
-15
View File
@@ -158,31 +158,16 @@ int32 FSGTimedThumpCommandImpl::GetMagnitude() const
return Pimpl->TimedThumpCommand.GetMagnitude();
}
void FSGTimedThumpCommandImpl::SetMagnitude(const int32 Magnitude)
{
Pimpl->TimedThumpCommand.SetMagnitude(Magnitude);
}
float FSGTimedThumpCommandImpl::GetDuration() const
{
return Pimpl->TimedThumpCommand.GetDuration();
}
void FSGTimedThumpCommandImpl::SetDuration(const float Duration)
{
Pimpl->TimedThumpCommand.SetDuration(Duration);
}
float FSGTimedThumpCommandImpl::GetElapsedTime() const
{
return Pimpl->TimedThumpCommand.GetElapsedTime();
}
void FSGTimedThumpCommandImpl::SetElapsedTime(const float ElapsedTime)
{
Pimpl->TimedThumpCommand.SetElapsedTime(ElapsedTime);
}
bool FSGTimedThumpCommandImpl::HasTimeElapsed() const
{
return Pimpl->TimedThumpCommand.HasTimeElapsed();
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGBasicHandModelImpl.h
+1 -5
View File
@@ -139,11 +139,9 @@ public:
public:
bool IsRight() const;
void SetIsRight(bool bRightHanded);
public:
TArray<TArray<float>> GetFingerLengths() const;
void SetFingerLengths(const TArray<TArray<float>>& FingerLengths);
TArray<float> GetFingerLengths(ESGFinger Finger) const;
@@ -156,13 +154,11 @@ public:
TArray<float> GetFingerRatios(ESGFinger Finger) const;
TArray<FVector> GetStartJointPositions() const;
void SetStartJointPositions(const TArray<FVector>& StartJointPositions);
void SetStartJointPosition(ESGFinger Finger, const FVector& Position);
void SetStartJointPosition(uint8 Finger, const FVector& Position);
TArray<FQuat> GetStartJointRotations() const;
void SetStartJointRotations(const TArray<FQuat>& StartJointRotations);
FVector GetJointPosition(ESGFinger Finger) const;
@@ -188,4 +184,4 @@ public:
FString ToString(bool bLengthsOnly) const;
FString Serialize() const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGBuzzCommandImpl.h
+1 -1
View File
@@ -154,4 +154,4 @@ public:
virtual FSGBuzzCommandImpl Copy() const;
virtual FSGBuzzCommandImpl Merge(const FSGBuzzCommandImpl& Command) const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGCalibrationDataPointImpl.h
+1 -5
View File
@@ -121,12 +121,8 @@ public:
public:
TArray<FVector> GetCalibrationValues() const;
void SetCalibrationValues(const TArray<FVector>& CalibrationValues);
int32 GetStage() const;
void SetStage(int32 Stage);
public:
FString ToLogData(const FString& Delimiter = "\t") const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGDeviceImpl.h
+1 -1
View File
@@ -189,4 +189,4 @@ public:
virtual bool GetBatteryLevel(float& OutLevel);
virtual FString ToString() const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGDeviceListImpl.h
+1 -1
View File
@@ -101,4 +101,4 @@ public:
public:
FSGDeviceListImpl() = delete;
virtual ~FSGDeviceListImpl() = delete;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGDeviceModelImpl.h
+1 -5
View File
@@ -123,14 +123,10 @@ public:
public:
FString GetDeviceId() const;
void SetDeviceId(const FString& Id) const;
FString GetHardwareVersion() const;
void SetHardwareVersion(const FString& Version) const;
int32 GetFirmwareVersion() const;
void SetFirmwareVersion(int32 Version) const;
int32 GetSubFirmwareVersion() const;
void SetSubFirmwareVersion(int32 Version) const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGExportedFunctions.h
-291
View File
@@ -173,18 +173,10 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGBasicHandModelImpl_ctor_copy_as
SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGBasicHandModelImpl_IsRight(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGBasicHandModelImpl_SetIsRight(
void* Instance,
bool bRightHanded);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGBasicHandModelImpl_GetFingerLengths(
void* Instance,
void* OutLengths);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGBasicHandModelImpl_SetFingerLengths(
void* Instance,
void* FingerLengths);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGBasicHandModelImpl_GetFingerLengths_Finger(
void* Instance,
void* OutLengths,
@@ -213,10 +205,6 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGBasicHandModelImpl_GetStartJoin
void* Instance,
void* OutPositions);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGBasicHandModelImpl_SetStartJointPositions(
void* Instance,
void* StartJointPositions);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGBasicHandModelImpl_SetStartJointPosition_ESGFinger(
void* Instance,
void* Finger,
@@ -231,10 +219,6 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGBasicHandModelImpl_GetStartJoin
void* Instance,
void* OutRotations);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGBasicHandModelImpl_SetStartJointRotations(
void* Instance,
void* StartJointRotations);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGBasicHandModelImpl_GetJointPosition(
void* Instance,
void* OutPosition,
@@ -459,17 +443,9 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGCalibrationDataPointImpl_GetCal
void* Instance,
void* Values);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGCalibrationDataPointImpl_SetCalibrationValues(
void* Instance,
void* CalibrationValues);
SENSEGLOVECOREIMPL_PUBLIC_API int32 SGCoreImpl_FSGCalibrationDataPointImpl_GetStage(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGCalibrationDataPointImpl_SetStage(
void* Instance,
int32 Stage);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGCalibrationDataPointImpl_ToLogData(
void* Instance,
void* OutData,
@@ -679,32 +655,16 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGDeviceModelImpl_GetDeviceId(
void* Instance,
void* OutId);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGDeviceModelImpl_SetDeviceId(
void* Instance,
void* Id);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGDeviceModelImpl_GetHardwareVersion(
void* Instance,
void* OutVersion);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGDeviceModelImpl_SetHardwareVersion(
void* Instance,
void* Version);
SENSEGLOVECOREIMPL_PUBLIC_API int32 SGCoreImpl_FSGDeviceModelImpl_GetFirmwareVersion(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGDeviceModelImpl_SetFirmwareVersion(
void* Instance,
int32 Version);
SENSEGLOVECOREIMPL_PUBLIC_API int32 SGCoreImpl_FSGDeviceModelImpl_GetSubFirmwareVersion(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGDeviceModelImpl_SetSubFirmwareVersion(
void* Instance,
int32 Version);
/*******************************************************************************
* SGFingerCommandImpl.h
******************************************************************************/
@@ -755,10 +715,6 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGFingerCommandImpl_GetLevels(
void* Instance,
void* OutLevels);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGFingerCommandImpl_SetLevels(
void* Instance,
void* Levels);
SENSEGLOVECOREIMPL_PUBLIC_API int SGCoreImpl_FSGFingerCommandImpl_GetLevel(
void* Instance,
int32 Finger);
@@ -896,18 +852,10 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHandInterpolatorImpl_GetJointIn
void* Instance,
void* OutInterpolations);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHandInterpolatorImpl_SetJointInterpolations(
void* Instance,
void* OutJointInterpolations);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHandInterpolatorImpl_GetCmcStartRotation(
void* Instance,
void* OutRotation);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHandInterpolatorImpl_SetCmcStartRotation(
void* Instance,
void* CmcStartRotation);
SENSEGLOVECOREIMPL_PUBLIC_API float SGCoreImpl_FSGHandInterpolatorImpl_CalculateAngle_Finger_int32Movement_Value(
void* Instance,
void* Finger,
@@ -1046,34 +994,18 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHandPoseImpl_ctor_copy_assignme
SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHandPoseImpl_IsRight(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHandPoseImpl_SetIsRight(
void* Instance,
bool bRightHanded);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHandPoseImpl_GetJointPositions(
void* Instance,
void* OutPositions);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHandPoseImpl_SetJointPositions(
void* Instance,
void* JointPositions);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHandPoseImpl_GetJointRotations(
void* Instance,
void* OutRotations);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHandPoseImpl_SetJointRotations(
void* Instance,
void* JointRotations);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHandPoseImpl_GetHandAngles(
void* Instance,
void* OutAngles);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHandPoseImpl_SetHandAngles(
void* Instance,
void* HandAngles);
SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHandPoseImpl_Equals(
void* Instance,
void* HandPoseImpl);
@@ -1157,26 +1089,14 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHandProfileImpl_ctor_copy_assig
SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHandProfileImpl_IsRight(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHandProfileImpl_SetIsRight(
void* Instance,
bool bRightHanded);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHandProfileImpl_GetSenseGloveHandProfile(
void* Instance,
void* OutProfile);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHandProfileImpl_SetSenseGloveHandProfile(
void* Instance,
void* SenseGloveHandProfile);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHandProfileImpl_GetNovaGloveHandProfile(
void* Instance,
void* OutProfile);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHandProfileImpl_SetNovaGloveHandProfile(
void* Instance,
void* NovaGloveHandProfile);
SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGHandProfileImpl_Equals(
void* Instance,
void* HandProfileImpl);
@@ -1386,14 +1306,6 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHapticGloveCalibrationCheckImpl
void* OutHapticGloveCalibrationCheckImpl,
void* Rhs);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_GetLastSensorRange(
void* Instance,
void* OutLastSensorRange);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_SetLastSensorRange(
void* Instance,
void* LastSensorRange);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_GetCalibrationStage(
void* Instance,
void* OutStage);
@@ -1554,26 +1466,14 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHapticGloveCommandBufferImpl_Ge
void* Instance,
void* OutForceFeedbackCommandsQueue);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHapticGloveCommandBufferImpl_SetForceFeedbackCommandsQueue(
void* Instance,
void* ForceFeedbackCommandsQueue);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHapticGloveCommandBufferImpl_GetBuzzCommandsQueue(
void* Instance,
void* OutBuzzCommandsQueue);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHapticGloveCommandBufferImpl_SetBuzzCommandsQueue(
void* Instance,
void* BuzzCommandsQueue);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHapticGloveCommandBufferImpl_GetThumperCommandsQueue(
void* Instance,
void* OutThumperCommandsQueue);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHapticGloveCommandBufferImpl_SetThumperCommandsQueue(
void* Instance,
void* ThumperCommandsQueue);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHapticGloveCommandBufferImpl_ClearForceFeedbackCommandsQueue(
void* Instance);
@@ -1721,10 +1621,6 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHapticGloveQuickCalibrationImpl
SENSEGLOVECOREIMPL_PUBLIC_API float SGCoreImpl_FSGHapticGloveQuickCalibrationImpl_GetAutoEndTimeout(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGHapticGloveQuickCalibrationImpl_SetAutoEndTimeout(
void* Instance,
float AutoEndTimeout);
SENSEGLOVECOREIMPL_PUBLIC_API int32 SGCoreImpl_FSGHapticGloveQuickCalibrationImpl_GetSmoothingSamples(
void* Instance);
@@ -2150,18 +2046,10 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveHandProfileImpl_ctor_c
SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGNovaGloveHandProfileImpl_IsRight(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveHandProfileImpl_SetIsRight(
void* Instance,
bool bRightHanded);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveHandProfileImpl_GetInterpolationSet(
void* Instance,
void* OutSet);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveHandProfileImpl_SetInterpolationSet(
void* Instance,
void* InterpolationSet);
SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGNovaGloveHandProfileImpl_Equals(
void* Instance,
void* NovaGloveHandProfileImpl);
@@ -2211,54 +2099,26 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveInfoImpl_GetDeviceId(
void* Instance,
void* OutId);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveInfoImpl_SetDeviceId(
void* Instance,
void* DeviceId);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveInfoImpl_GetHardwareVersion(
void* Instance,
void* OutVersion);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveInfoImpl_SetHardwareVersion(
void* Instance,
void* HardwareVersion);
SENSEGLOVECOREIMPL_PUBLIC_API int32 SGCoreImpl_FSGNovaGloveInfoImpl_GetFirmwareVersion(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveInfoImpl_SetFirmwareVersion(
void* Instance,
int32 FirmwareVersion);
SENSEGLOVECOREIMPL_PUBLIC_API int32 SGCoreImpl_FSGNovaGloveInfoImpl_GetSubFirmwareVersion(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveInfoImpl_SetSubFirmwareVersion(
void* Instance,
int32 SubFirmwareVersion);
SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGNovaGloveInfoImpl_IsRight(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveInfoImpl_SetIsRight(
void* Instance,
bool bRightHanded);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveInfoImpl_GetImuCorrection(
void* Instance,
void* OutCorrection);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveInfoImpl_SetImuCorrection(
void* Instance,
void* ImuCorrection);
SENSEGLOVECOREIMPL_PUBLIC_API int32 SGCoreImpl_FSGNovaGloveInfoImpl_GetNumberOfSensors(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveInfoImpl_SetNumberOfSensors(
void* Instance,
int32 NumberOfSensors);
SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGNovaGloveInfoImpl_Equals(
void* Instance,
void* NovaGloveInfoImpl);
@@ -2312,46 +2172,22 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveSensorDataImpl_GetSens
void* Instance,
void* OutValues);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveSensorDataImpl_SetSensorValues(
void* Instance,
void* SensorValues);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveSensorDataImpl_GetImuRotation(
void* Instance,
void* OutRotation);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveSensorDataImpl_SetImuRotation(
void* Instance,
void* ImuRotation);
SENSEGLOVECOREIMPL_PUBLIC_API int32 SGCoreImpl_FSGNovaGloveSensorDataImpl_GetParsedValues(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveSensorDataImpl_SetParsedValues(
void* Instance,
int32 ParsedValues);
SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGNovaGloveSensorDataImpl_IsImuParsed(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveSensorDataImpl_SetImuParsed(
void* Instance,
bool bImuParsed);
SENSEGLOVECOREIMPL_PUBLIC_API float SGCoreImpl_FSGNovaGloveSensorDataImpl_GetBatteryLevel(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveSensorDataImpl_SetBatteryLevel(
void* Instance,
float BatteryLevel);
SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGNovaGloveSensorDataImpl_IsCharging(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGNovaGloveSensorDataImpl_SetIsCharging(
void* Instance,
bool bCharging);
SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGNovaGloveSensorDataImpl_Equals(
void* Instance,
void* NovaGloveSensorDataImpl);
@@ -2658,42 +2494,22 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveHandProfileImpl_ctor_
SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGSenseGloveHandProfileImpl_IsRight(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveHandProfileImpl_SetIsRight(
void* Instance,
bool bRightHanded);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveHandProfileImpl_GetInterpolationSet(
void* Instance,
void* OutSet);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveHandProfileImpl_SetInterpolationSet(
void* Instance,
void* InterpolationSet);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveHandProfileImpl_GetThumbSolver(
void* Instance,
void* OutSolver);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveHandProfileImpl_SetThumbSolver(
void* Instance,
void* ThumbSolver);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveHandProfileImpl_GetFingerSolver(
void* Instance,
void* OutSolver);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveHandProfileImpl_SetFingerSolver(
void* Instance,
void* FingerSolver);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveHandProfileImpl_GetFingerThimbleOffset(
void* Instance,
void* OutOffset);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveHandProfileImpl_SetFingerThimbleOffset(
void* Instance,
void* FingerThimbleOffset);
SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGSenseGloveHandProfileImpl_Equals(
void* Instance,
void* SenseGloveHandProfileImpl);
@@ -2748,86 +2564,42 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveInfoImpl_GetDeviceId(
void* Instance,
void* OutId);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveInfoImpl_SetDeviceId(
void* Instance,
void* DeviceId);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveInfoImpl_GetHardwareVersion(
void* Instance,
void* OutVersion);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveInfoImpl_SetHardwareVersion(
void* Instance,
void* HardwareVersion);
SENSEGLOVECOREIMPL_PUBLIC_API int32 SGCoreImpl_FSGSenseGloveInfoImpl_GetFirmwareVersion(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveInfoImpl_SetFirmwareVersion(
void* Instance,
int32 FirmwareVersion);
SENSEGLOVECOREIMPL_PUBLIC_API int32 SGCoreImpl_FSGSenseGloveInfoImpl_GetSubFirmwareVersion(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveInfoImpl_SetSubFirmwareVersion(
void* Instance,
int32 SubFirmwareVersion);
SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGSenseGloveInfoImpl_IsRight(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveInfoImpl_SetIsRight(
void* Instance,
bool bRightHanded);
SENSEGLOVECOREIMPL_PUBLIC_API int32 SGCoreImpl_FSGSenseGloveInfoImpl_GetNumberOfSensors(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveInfoImpl_SetNumberOfSensors(
void* Instance,
int32 NumberOfSensors);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveInfoImpl_GetImuCorrection(
void* Instance,
void* OutCorrection);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveInfoImpl_SetImuCorrection(
void* Instance,
void* ImuCorrection);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveInfoImpl_GetStartPositions(
void* Instance,
void* OutPositions);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveInfoImpl_SetStartPositions(
void* Instance,
void* StartPositions);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveInfoImpl_GetStartRotations(
void* Instance,
void* OutRotations);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveInfoImpl_SetStartRotations(
void* Instance,
void* StartRotations);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveInfoImpl_GetGloveLengths(
void* Instance,
void* OutLengths);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveInfoImpl_SetGloveLengths(
void* Instance,
void* GloveLengths);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveInfoImpl_GetFunctions(
void* Instance,
void* OutFunctions);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveInfoImpl_SetFunctions(
void* Instance,
void* Functions);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveInfoImpl_GetStartPosition(
void* Instance,
void* OutPosition,
@@ -2899,34 +2671,18 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGlovePoseImpl_ctor_copy_as
SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGSenseGlovePoseImpl_IsRight(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGlovePoseImpl_SetIsRight(
void* Instance,
bool bRightGloveed);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGlovePoseImpl_GetJointPositions(
void* Instance,
void* OutPositions);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGlovePoseImpl_SetJointPositions(
void* Instance,
void* JointPositions);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGlovePoseImpl_GetJointRotations(
void* Instance,
void* OutRotations);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGlovePoseImpl_SetJointRotations(
void* Instance,
void* JointRotations);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGlovePoseImpl_GetGloveAngles(
void* Instance,
void* OutAngles);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGlovePoseImpl_SetGloveAngles(
void* Instance,
void* GloveAngles);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGlovePoseImpl_GetThimblePositions(
void* Instance,
void* OutPositions);
@@ -3001,10 +2757,6 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveSensorDataImpl_GetSen
void* Instance,
void* OutAngles);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveSensorDataImpl_SetSensorAngles(
void* Instance,
void* SensorAngles);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveSensorDataImpl_GetSensorAngles_Finger(
void* Instance,
void* OutAngles,
@@ -3018,24 +2770,12 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveSensorDataImpl_GetImu
void* Instance,
void* OutRotation);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveSensorDataImpl_SetImuRotation(
void* Instance,
void* ImuRotation);
SENSEGLOVECOREIMPL_PUBLIC_API int32 SGCoreImpl_FSGSenseGloveSensorDataImpl_GetParsedValues(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveSensorDataImpl_SetParsedValues(
void* Instance,
int32 ParsedValues);
SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGSenseGloveSensorDataImpl_IsImuParsed(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGSenseGloveSensorDataImpl_SetImuParsed(
void* Instance,
bool bImuParsed);
SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGSenseGloveSensorDataImpl_Equals(
void* Instance,
void* SenseGloveSensorDataImpl);
@@ -3293,31 +3033,12 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTimedBuzzCommandImpl_GetBaseCom
void* Instance,
void* OutCommand);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTimedBuzzCommandImpl_SetBaseCommand(
void* Instance,
void* BaseCommand);
SENSEGLOVECOREIMPL_PUBLIC_API int32 SGCoreImpl_FSGTimedBuzzCommandImpl_GetMagnitude(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTimedBuzzCommandImpl_SetMagnitude(
void* Instance,
int32 Magnitude);
SENSEGLOVECOREIMPL_PUBLIC_API float SGCoreImpl_FSGTimedBuzzCommandImpl_GetDuration(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTimedBuzzCommandImpl_SetDuration(
void* Instance,
float Duration);
SENSEGLOVECOREIMPL_PUBLIC_API float SGCoreImpl_FSGTimedBuzzCommandImpl_GetElapsedTime(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTimedBuzzCommandImpl_SetElapsedTime(
void* Instance,
float ElapsedTime);
SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGTimedBuzzCommandImpl_HasTimeElapsed(
void* Instance);
@@ -3368,24 +3089,12 @@ SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTimedThumpCommandImpl_ctor_copy
SENSEGLOVECOREIMPL_PUBLIC_API int32 SGCoreImpl_FSGTimedThumpCommandImpl_GetMagnitude(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTimedThumpCommandImpl_SetMagnitude(
void* Instance,
int32 Magnitude);
SENSEGLOVECOREIMPL_PUBLIC_API float SGCoreImpl_FSGTimedThumpCommandImpl_GetDuration(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTimedThumpCommandImpl_SetDuration(
void* Instance,
float Duration);
SENSEGLOVECOREIMPL_PUBLIC_API float SGCoreImpl_FSGTimedThumpCommandImpl_GetElapsedTime(
void* Instance);
SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGTimedThumpCommandImpl_SetElapsedTime(
void* Instance,
float ElapsedTime);
SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGTimedThumpCommandImpl_HasTimeElapsed(
void* Instance);
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGFingerCommandImpl.h
+1 -2
View File
@@ -168,7 +168,6 @@ public:
public:
virtual TArray<int32> GetLevels() const;
void SetLevels(const TArray<int32>& Levels);
virtual int32 GetLevel(int32 Finger) const;
virtual void SetLevel(int32 Finger, int32 Value);
@@ -176,4 +175,4 @@ public:
virtual bool Equals(const FSGFingerCommandImpl& FingerCommandImpl) const;
virtual FString ToString() const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGForceFeedbackCommandImpl.h
+1 -1
View File
@@ -143,4 +143,4 @@ public:
virtual FSGForceFeedbackCommandImpl Copy() const;
virtual FSGForceFeedbackCommandImpl Merge(const FSGForceFeedbackCommandImpl& Command) const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGHandInterpolatorImpl.h
+1 -5
View File
@@ -144,12 +144,8 @@ public:
public:
TArray<TArray<FSGInterpolationSetImpl>> GetJointInterpolations() const;
void SetJointInterpolations(const TArray<TArray<FSGInterpolationSetImpl>>& JointInterpolations);
FQuat GetCmcStartRotation() const;
void SetCmcStartRotation(const FQuat& CmcStartRotation);
public:
float CalculateAngle(ESGFinger Finger, int32 Movement, float Value) const;
@@ -172,4 +168,4 @@ public:
public:
FString Serialize() const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGHandPoseImpl.h
+1 -5
View File
@@ -148,16 +148,12 @@ public:
public:
bool IsRight() const;
void SetIsRight(bool bRightHanded) const;
TArray<TArray<FVector>> GetJointPositions() const;
void SetJointPositions(const TArray<TArray<FVector>>& JointPositions) const;
TArray<TArray<FQuat>> GetJointRotations() const;
void SetJointRotations(const TArray<TArray<FQuat>>& JointRotations) const;
TArray<TArray<FVector>> GetHandAngles() const;
void SetHandAngles(const TArray<TArray<FVector>>& HandAngles) const;
public:
bool Equals(const FSGHandPoseImpl& HandPoseImpl) const;
@@ -170,4 +166,4 @@ public:
FString ToString(bool bShortFormat = false) const;
FString Serialize() const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGHandProfileImpl.h
+1 -7
View File
@@ -147,16 +147,10 @@ public:
public:
bool IsRight() const;
void SetIsRight(bool bRightHanded) const;
FSGSenseGloveHandProfileImpl GetSenseGloveHandProfile() const;
void SetSenseGloveHandProfile(const FSGSenseGloveHandProfileImpl& SenseGloveHandProfile);
FSGNovaGloveHandProfileImpl GetNovaGloveHandProfile() const;
void SetNovaGloveHandProfile(const FSGNovaGloveHandProfileImpl& NovaGloveHandProfile);
public:
bool Equals(const FSGHandProfileImpl& HandProfileImpl) const;
@@ -164,4 +158,4 @@ public:
public:
FString Serialize() const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGHapticGloveCalibrationCheckImpl.h
+1 -5
View File
@@ -147,10 +147,6 @@ public:
*/
const FHapticGloveCalibrationCheckType& ToHapticGloveCalibrationCheck() const;
public:
FSGSensorRangeImpl GetLastSensorRange() const;
void SetLastSensorRange(const FSGSensorRangeImpl& LastSensorRange);
public:
ESGCalibrationStage GetCalibrationStage() const;
@@ -160,4 +156,4 @@ public:
virtual void Reset();
void CheckRange(const TArray<FVector>& CurrentValues, float DeltaSeconds, ESGDeviceType DeviceType);
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGHapticGloveCalibrationSequenceImpl.h
+1 -1
View File
@@ -198,4 +198,4 @@ public:
virtual bool GetHandPose(bool bRightHanded, FSGHandPoseImpl& OutCurrentHandPose) const;
virtual FString GetCurrentInstruction(const FString& NextStepKey = FString{""}) const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGHapticGloveCommandBufferImpl.h
+1 -4
View File
@@ -133,13 +133,10 @@ public:
public:
TArray<FSGForceFeedbackCommandImpl> GetForceFeedbackCommandsQueue() const;
void SetForceFeedbackCommandsQueue(const TArray<FSGForceFeedbackCommandImpl>& ForceFeedbackCommandsQueue);
TArray<FSGTimedBuzzCommandImpl> GetBuzzCommandsQueue() const;
void SetBuzzCommandsQueue(const TArray<FSGTimedBuzzCommandImpl>& TimedBuzzCommandsQueue);
TArray<FSGTimedThumpCommandImpl> GetThumperCommandsQueue() const;
void SetThumperCommandsQueue(const TArray<FSGTimedThumpCommandImpl>& TimedThumpCommandsQueue);
public:
void ClearForceFeedbackCommandsQueue();
@@ -175,4 +172,4 @@ public:
void FlushHaptics(float DeltaSeconds, const FSGForceFeedbackCommandImpl& LastBrakeLevel,
FSGForceFeedbackCommandImpl& OutForceFeedbackCommand, FSGBuzzCommandImpl& OutBuzzCommand,
FSGThumperCommandImpl& OutThumperCommand);
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGHapticGloveHandProfilesImpl.h
+1 -1
View File
@@ -84,4 +84,4 @@ public:
public:
FSGHapticGloveHandProfilesImpl() = delete;
virtual ~FSGHapticGloveHandProfilesImpl() = delete;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGHapticGloveQuickCalibrationImpl.h
+1 -3
View File
@@ -137,8 +137,6 @@ public:
public:
float GetAutoEndTimeout() const;
void SetAutoEndTimeout(float AutoEndTimeout);
int32 GetSmoothingSamples() const;
FSGSensorRangeImpl GetSensorRange() const;
@@ -164,4 +162,4 @@ public:
virtual bool GetHandPose(bool bRightHanded, FSGHandPoseImpl& OutCurrentHandPose) const override;
virtual FString GetCurrentInstruction(const FString& NextStepKey = FString{""}) const override;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGInterpolationSetImpl.h
+1 -1
View File
@@ -160,4 +160,4 @@ public:
FString ToString(bool bLimits) const;
FString Serialize() const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGNovaGloveHandProfileImpl.h
+1 -5
View File
@@ -128,12 +128,8 @@ public:
public:
bool IsRight() const;
void SetIsRight(bool bRightHanded);
FSGHandInterpolatorImpl GetInterpolationSet() const;
void SetInterpolationSet(const FSGHandInterpolatorImpl& InterpolationSet);
public:
bool Equals(const FSGNovaGloveHandProfileImpl& NovaGloveHandProfileImpl) const;
@@ -141,4 +137,4 @@ public:
public:
FString Serialize() const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGNovaGloveInfoImpl.h
+1 -8
View File
@@ -128,25 +128,18 @@ public:
public:
FString GetDeviceId() const;
void SetDeviceId(const FString& DeviceId);
FString GetHardwareVersion() const;
void SetHardwareVersion(const FString& HardwareVersion);
int32 GetFirmwareVersion() const;
void SetFirmwareVersion(int32 FirmwareVersion);
int32 GetSubFirmwareVersion() const;
void SetSubFirmwareVersion(int32 SubFirmwareVersion);
bool IsRight() const;
void SetIsRight(bool bRightHanded);
FQuat GetImuCorrection() const;
void SetImuCorrection(const FQuat& ImuCorrection);
int32 GetNumberOfSensors() const;
void SetNumberOfSensors(int32 NumberOfSensors);
public:
bool Equals(const FSGNovaGloveInfoImpl& SGNovaGloveInfo) const;
@@ -155,4 +148,4 @@ public:
FString ToString() const;
FString Serialize() const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGNovaGloveSensorDataImpl.h
+1 -7
View File
@@ -131,23 +131,17 @@ public:
public:
TArray<FVector> GetSensorValues() const;
void SetSensorValues(const TArray<FVector>& SensorValues) const;
FQuat GetImuRotation() const;
void SetImuRotation(const FQuat& ImuRotation);
int32 GetParsedValues() const;
void SetParsedValues(int32 ParsedValues);
bool IsImuParsed() const;
void SetImuParsed(bool bImuParsed);
public:
float GetBatteryLevel() const;
void SetBatteryLevel(float BatteryLevel);
bool IsCharging() const;
void SetIsCharging(bool bCharging);
public:
bool Equals(const FSGNovaGloveSensorDataImpl& NovaGloveSensorDataImpl) const;
@@ -156,4 +150,4 @@ public:
FString ToString() const;
FString Serialize() const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGSenseGloveHandProfileImpl.h
+1 -11
View File
@@ -135,24 +135,14 @@ public:
public:
bool IsRight() const;
void SetIsRight(bool bRightHanded);
FSGHandInterpolatorImpl GetInterpolationSet() const;
void SetInterpolationSet(const FSGHandInterpolatorImpl& InterpolationSet);
ESGThumbSolver GetThumbSolver() const;
void SetThumbSolver(ESGThumbSolver ThumbSolver);
ESGFingerSolver GetFingerSolver() const;
void SetFingerSolver(ESGFingerSolver FingerSolver);
TArray<FVector> GetFingerThimbleOffset() const;
void SetFingerThimbleOffset(const TArray<FVector>& FingerThimbleOffset);
public:
bool Equals(const FSGSenseGloveHandProfileImpl& SenseGloveHandProfileImpl) const;
@@ -160,4 +150,4 @@ public:
public:
FString Serialize() const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGSenseGloveInfoImpl.h
+1 -12
View File
@@ -135,37 +135,26 @@ public:
public:
FString GetDeviceId() const;
void SetDeviceId(const FString& DeviceId);
FString GetHardwareVersion() const;
void SetHardwareVersion(const FString& HardwareVersion);
int32 GetFirmwareVersion() const;
void SetFirmwareVersion(int32 FirmwareVersion);
int32 GetSubFirmwareVersion() const;
void SetSubFirmwareVersion(int32 SubFirmwareVersion);
bool IsRight() const;
void SetIsRight(bool bRightHanded);
int32 GetNumberOfSensors() const;
void SetNumberOfSensors(int32 NumberOfSensors);
FQuat GetImuCorrection() const;
void SetImuCorrection(const FQuat& ImuCorrection);
TArray<FVector> GetStartPositions() const;
void SetStartPositions(const TArray<FVector>& StartPositions);
TArray<FQuat> GetStartRotations() const;
void SetStartRotations(const TArray<FQuat>& StartRotations);
TArray<TArray<FVector>> GetGloveLengths() const;
void SetGloveLengths(const TArray<TArray<FVector>>& GloveLengths) const;
TArray<bool> GetFunctions() const;
void SetFunctions(const TArray<bool>& Functions) const;
public:
FVector GetStartPosition(ESGFinger Finger) const;
@@ -185,4 +174,4 @@ public:
FString ToString() const;
FString Serialize() const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGSenseGlovePoseImpl.h
+1 -5
View File
@@ -132,16 +132,12 @@ public:
public:
bool IsRight() const;
void SetIsRight(bool bRightHanded) const;
TArray<TArray<FVector>> GetJointPositions() const;
void SetJointPositions(const TArray<TArray<FVector>>& JointPositions) const;
TArray<TArray<FQuat>> GetJointRotations() const;
void SetJointRotations(const TArray<TArray<FQuat>>& JointRotations) const;
TArray<TArray<FVector>> GetGloveAngles() const;
void SetGloveAngles(const TArray<TArray<FVector>>& GloveAngles) const;
public:
TArray<FVector> GetThimblePositions() const;
@@ -160,4 +156,4 @@ public:
FString ToString(bool bShortFormat = true) const;
FString Serialize() const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGSenseGloveSensorDataImpl.h
+1 -5
View File
@@ -131,21 +131,17 @@ public:
public:
TArray<TArray<float>> GetSensorAngles() const;
void SetSensorAngles(const TArray<TArray<float>>& SensorAngles);
TArray<float> GetSensorAngles(ESGFinger Finger) const;
TArray<float> GetAngleSequence() const;
FQuat GetImuRotation() const;
void SetImuRotation(const FQuat& ImuRotation);
int32 GetParsedValues() const;
void SetParsedValues(int32 ParsedValues);
public:
bool IsImuParsed() const;
void SetImuParsed(bool bImuParsed);
public:
bool Equals(const FSGSenseGloveSensorDataImpl& SenseGloveSensorDataImpl) const;
@@ -154,4 +150,4 @@ public:
FString ToString() const;
FString Serialize() const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGSenseGloveVarsImpl.h
+1 -1
View File
@@ -82,4 +82,4 @@ public:
public:
FSGSenseGloveVarsImpl() = delete;
virtual ~FSGSenseGloveVarsImpl() = delete;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGSensorRangeImpl.h
+1 -1
View File
@@ -150,4 +150,4 @@ public:
FString ToString(bool bYOnly = true) const;
FString Serialize() const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGThumperCommandImpl.h
+1 -1
View File
@@ -129,4 +129,4 @@ public:
FSGThumperCommandImpl Merge(const FSGThumperCommandImpl& ThumperCommandImpl) const;
virtual bool Equals(const FSGThumperCommandImpl& ThumperCommandImpl) const;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGTimedBuzzCommandImpl.h
+1 -7
View File
@@ -154,16 +154,10 @@ public:
public:
virtual FSGBuzzCommandImpl GetBaseCommand() const;
void SetBaseCommand(const FSGBuzzCommandImpl& BaseCommand);
int32 GetMagnitude() const;
void SetMagnitude(int32 Magnitude);
float GetDuration() const;
void SetDuration(float Duration);
float GetElapsedTime() const;
void SetElapsedTime(float ElapsedTime);
virtual bool HasTimeElapsed() const;
@@ -175,4 +169,4 @@ public:
public:
virtual FString ToString() const override;
};
};
Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGTimedThumpCommandImpl.h
+1 -4
View File
@@ -127,13 +127,10 @@ public:
public:
int32 GetMagnitude() const;
void SetMagnitude(int32 Magnitude);
float GetDuration() const;
void SetDuration(float Duration);
float GetElapsedTime() const;
void SetElapsedTime(float ElapsedTime);
bool HasTimeElapsed() const;
@@ -146,4 +143,4 @@ public:
public:
virtual FString ToString() const;
};
};