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

add FRotator overloads for every method that accepts or returns FQuat and some other bug fixes

Browse Source
This commit is contained in:
Mamadou Babaei
2022-11-11 11:39:35 +01:00
parent 6eecb407c9
commit 643200e9cc
56 changed files with 2744 additions and 269 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/SenseGloveCore/Private/SGCore/SGBasicHandModel.cpp
+113 -3
View File
@@ -143,6 +143,22 @@ USGBasicHandModel* USGBasicHandModel::NewBasicHandModel(UObject* Outer, const bo
return NewBasicHandModel(Outer, MoveTemp(OutBasicHandModelImplContainer.BasicHandModelImpl));
}
USGBasicHandModel* USGBasicHandModel::NewBasicHandModel(UObject* Outer, const bool bRightHanded,
const TArray<TArray<float>>& Lengths,
const TArray<FVector>& StartPositions,
const TArray<FRotator>& StartRotations)
{
FSGIC_FSGBasicHandModelImpl OutBasicHandModelImplContainer;
FSGIC_TArray_TArray_float LengthsContainer{Lengths};
FSGIC_TArray_FVector StartPositionsContainer{StartPositions};
FSGIC_TArray_FQuat StartRotationsContainer{FSGArrayUtils::RotatorsToQuats(StartRotations)};
SGCoreImpl_FSGBasicHandModelImpl_ctor_bRightHanded_Lengths_StartPositions_StartRotations(
&OutBasicHandModelImplContainer, bRightHanded, &LengthsContainer,
&StartPositionsContainer, &StartRotationsContainer);
return NewBasicHandModel(Outer, MoveTemp(OutBasicHandModelImplContainer.BasicHandModelImpl));
}
USGBasicHandModel* USGBasicHandModel::NewBasicHandModel(UObject* Outer, const bool bRightHanded,
const TArray<FSGFloatArray>& Lengths,
const TArray<FVector>& StartPositions,
@@ -161,6 +177,24 @@ USGBasicHandModel* USGBasicHandModel::NewBasicHandModel(UObject* Outer, const bo
return NewBasicHandModel(Outer, MoveTemp(OutBasicHandModelImplContainer.BasicHandModelImpl));
}
USGBasicHandModel* USGBasicHandModel::NewBasicHandModel(UObject* Outer, const bool bRightHanded,
const TArray<FSGFloatArray>& Lengths,
const TArray<FVector>& StartPositions,
const TArray<FRotator>& StartRotations)
{
FSGIC_FSGBasicHandModelImpl OutBasicHandModelImplContainer;
FSGIC_TArray_TArray_float LengthsContainer{
FSGArrayUtils::FromBPNestedArray<float, FSGFloatArray, &FSGFloatArray::FloatArray>(Lengths)
};
FSGIC_TArray_FVector StartPositionsContainer{StartPositions};
FSGIC_TArray_FQuat StartRotationsContainer{FSGArrayUtils::RotatorsToQuats(StartRotations)};
SGCoreImpl_FSGBasicHandModelImpl_ctor_bRightHanded_Lengths_StartPositions_StartRotations(
&OutBasicHandModelImplContainer, bRightHanded, &LengthsContainer,
&StartPositionsContainer, &StartRotationsContainer);
return NewBasicHandModel(Outer, MoveTemp(OutBasicHandModelImplContainer.BasicHandModelImpl));
}
USGBasicHandModel* USGBasicHandModel::Default(UObject* Outer, const bool bRightHanded)
{
FSGIC_FSGBasicHandModelImpl OutBasicHandModelImplContainer;
@@ -273,7 +307,28 @@ USGBasicHandModel::USGBasicHandModel(const bool bRightHanded, const TArray<TArra
Pimpl->SyncUProperties();
}
USGBasicHandModel::USGBasicHandModel(bool bRightHanded, const TArray<FSGFloatArray>& Lengths,
USGBasicHandModel::USGBasicHandModel(const bool bRightHanded, const TArray<TArray<float>>& Lengths,
const TArray<FVector>& StartPositions, const TArray<FRotator>& StartRotations)
:
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
#else
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
#endif /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 ) */
{
FSGIC_FSGBasicHandModelImpl OutBasicHandModelImplContainer;
FSGIC_TArray_TArray_float LengthsContainer{Lengths};
FSGIC_TArray_FVector StartPositionsContainer{StartPositions};
FSGIC_TArray_FQuat StartRotationsContainer{FSGArrayUtils::RotatorsToQuats(StartRotations)};
SGCoreImpl_FSGBasicHandModelImpl_ctor_bRightHanded_Lengths_StartPositions_StartRotations(
&OutBasicHandModelImplContainer, bRightHanded, &LengthsContainer,
&StartPositionsContainer, &StartRotationsContainer);
Pimpl->BasicHandModelImpl = MoveTemp(OutBasicHandModelImplContainer.BasicHandModelImpl);
Pimpl->SyncUProperties();
}
USGBasicHandModel::USGBasicHandModel(const bool bRightHanded, const TArray<FSGFloatArray>& Lengths,
const TArray<FVector>& StartPositions, const TArray<FQuat>& StartRotations)
:
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
@@ -296,6 +351,29 @@ USGBasicHandModel::USGBasicHandModel(bool bRightHanded, const TArray<FSGFloatArr
Pimpl->SyncUProperties();
}
USGBasicHandModel::USGBasicHandModel(const bool bRightHanded, const TArray<FSGFloatArray>& Lengths,
const TArray<FVector>& StartPositions, const TArray<FRotator>& StartRotations)
:
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
#else
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
#endif /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 ) */
{
FSGIC_FSGBasicHandModelImpl OutBasicHandModelImplContainer;
FSGIC_TArray_TArray_float LengthsContainer{
FSGArrayUtils::FromBPNestedArray<float, FSGFloatArray, &FSGFloatArray::FloatArray>(Lengths)
};
FSGIC_TArray_FVector StartPositionsContainer{StartPositions};
FSGIC_TArray_FQuat StartRotationsContainer{FSGArrayUtils::RotatorsToQuats(StartRotations)};
SGCoreImpl_FSGBasicHandModelImpl_ctor_bRightHanded_Lengths_StartPositions_StartRotations(
&OutBasicHandModelImplContainer, bRightHanded, &LengthsContainer,
&StartPositionsContainer, &StartRotationsContainer);
Pimpl->BasicHandModelImpl = MoveTemp(OutBasicHandModelImplContainer.BasicHandModelImpl);
Pimpl->SyncUProperties();
}
USGBasicHandModel::USGBasicHandModel(const FSGBasicHandModelImpl& BasicHandModelImpl)
:
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
@@ -432,7 +510,7 @@ void USGBasicHandModel::SetStartJointPosition(const uint8 Finger, const FVector&
Pimpl->SyncUProperties();
}
TArray<FQuat> USGBasicHandModel::GetStartJointRotations() const
TArray<FQuat> USGBasicHandModel::GetStartJointRotationsQ() const
{
FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
FSGIC_TArray_FQuat OutRotationsContainer;
@@ -440,6 +518,14 @@ TArray<FQuat> USGBasicHandModel::GetStartJointRotations() const
return MoveTemp(OutRotationsContainer.Array);
}
TArray<FRotator> USGBasicHandModel::GetStartJointRotations() const
{
FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
FSGIC_TArray_FQuat OutRotationsContainer;
SGCoreImpl_FSGBasicHandModelImpl_GetStartJointRotations(&InstanceContainer, &OutRotationsContainer);
return FSGArrayUtils::QuatsToRotators(OutRotationsContainer.Array);
}
FVector USGBasicHandModel::GetJointPosition(const ESGFinger Finger) const
{
Pimpl->SyncImplObject();
@@ -464,7 +550,7 @@ void USGBasicHandModel::SetJointPosition(const FVector& NewPosition, const ESGFi
Pimpl->SyncUProperties();
}
FQuat USGBasicHandModel::GetJointRotation(const ESGFinger Finger) const
FQuat USGBasicHandModel::GetJointRotationQ(const ESGFinger Finger) const
{
Pimpl->SyncImplObject();
@@ -476,6 +562,18 @@ FQuat USGBasicHandModel::GetJointRotation(const ESGFinger Finger) const
return MoveTemp(OutRotationContainer.Quat);
}
FRotator USGBasicHandModel::GetJointRotation(const ESGFinger Finger) const
{
Pimpl->SyncImplObject();
FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
FSGIC_FQuat OutRotationContainer;
FSGIC_ESGFinger FingerContainer{Finger};
SGCoreImpl_FSGBasicHandModelImpl_GetJointRotation(&InstanceContainer, &OutRotationContainer, &FingerContainer);
return OutRotationContainer.Quat.Rotator();
}
void USGBasicHandModel::SetJointRotation(const FQuat& NewRotation, const ESGFinger Finger)
{
Pimpl->SyncImplObject();
@@ -488,6 +586,18 @@ void USGBasicHandModel::SetJointRotation(const FQuat& NewRotation, const ESGFing
Pimpl->SyncUProperties();
}
void USGBasicHandModel::SetJointRotation(const FRotator& NewRotation, const ESGFinger Finger)
{
Pimpl->SyncImplObject();
FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
FSGIC_FQuat NewRotationContainer{NewRotation.Quaternion()};
FSGIC_ESGFinger FingerContainer{Finger};
SGCoreImpl_FSGBasicHandModelImpl_SetJointRotation(&InstanceContainer, &NewRotationContainer, &FingerContainer);
Pimpl->SyncUProperties();
}
TArray<float> USGBasicHandModel::GetTotalLengths() const
{
FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
Source/SenseGloveCore/Private/SGCore/SGHandInterpolator.cpp
+87 -1
View File
@@ -151,6 +151,21 @@ USGHandInterpolator* USGHandInterpolator::NewHandInterpolator(
return NewHandInterpolator(Outer, MoveTemp(OutHandInterpolatorImplContainer.HandInterpolatorImpl));
}
USGHandInterpolator* USGHandInterpolator::NewHandInterpolator(
UObject* Outer,
const TArray<TArray<USGInterpolationSet*>>& JointInterpolations, const FRotator& CmcStartRotation)
{
FSGIC_FSGHandInterpolatorImpl OutHandInterpolatorImplContainer;
FSGIC_TArray_TArray_FSGInterpolationSetImpl JointInterpolationsContainer{
FSGArrayUtils::ToImplType<USGInterpolationSet, FSGInterpolationSetImpl,
&USGInterpolationSet::ToInterpolationSetImpl>(JointInterpolations)};
FSGIC_FQuat CmcStartRotationContainer{CmcStartRotation.Quaternion()};
SGCoreImpl_FSGHandInterpolatorImpl_ctor_JointInterpolations_CmcStartRotation(
&OutHandInterpolatorImplContainer, &JointInterpolationsContainer, &CmcStartRotationContainer);
return NewHandInterpolator(Outer, MoveTemp(OutHandInterpolatorImplContainer.HandInterpolatorImpl));
}
USGHandInterpolator* USGHandInterpolator::NewHandInterpolator(
UObject* Outer,
const TArray<FSGInterpolationSetArray>& JointInterpolations, const FQuat& CmcStartRotation)
@@ -169,6 +184,24 @@ USGHandInterpolator* USGHandInterpolator::NewHandInterpolator(
return NewHandInterpolator(Outer, MoveTemp(OutHandInterpolatorImplContainer.HandInterpolatorImpl));
}
USGHandInterpolator* USGHandInterpolator::NewHandInterpolator(
UObject* Outer,
const TArray<FSGInterpolationSetArray>& JointInterpolations, const FRotator& CmcStartRotation)
{
FSGIC_FSGHandInterpolatorImpl OutHandInterpolatorImplContainer;
FSGIC_TArray_TArray_FSGInterpolationSetImpl JointInterpolationsContainer{
FSGArrayUtils::ToImplType<
USGInterpolationSet, FSGInterpolationSetImpl,
&USGInterpolationSet::ToInterpolationSetImpl,
FSGInterpolationSetArray, &FSGInterpolationSetArray::InterpolationSetArray>(
JointInterpolations)};
FSGIC_FQuat CmcStartRotationContainer{CmcStartRotation.Quaternion()};
SGCoreImpl_FSGHandInterpolatorImpl_ctor_JointInterpolations_CmcStartRotation(
&OutHandInterpolatorImplContainer, &JointInterpolationsContainer, &CmcStartRotationContainer);
return NewHandInterpolator(Outer, MoveTemp(OutHandInterpolatorImplContainer.HandInterpolatorImpl));
}
USGHandInterpolator* USGHandInterpolator::Default(UObject* Outer, const bool bRightHanded)
{
FSGIC_FSGHandInterpolatorImpl OutHandInterpolatorImplContainer;
@@ -298,6 +331,27 @@ USGHandInterpolator::USGHandInterpolator(const TArray<TArray<USGInterpolationSet
Pimpl->SyncUProperties();
}
USGHandInterpolator::USGHandInterpolator(const TArray<TArray<USGInterpolationSet*>>& JointInterpolations,
const FRotator& CmcStartRotation)
:
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
#else
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
#endif /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 ) */
{
FSGIC_FSGHandInterpolatorImpl OutHandInterpolatorImplContainer;
FSGIC_TArray_TArray_FSGInterpolationSetImpl JointInterpolationsContainer{
FSGArrayUtils::ToImplType<USGInterpolationSet, FSGInterpolationSetImpl,
&USGInterpolationSet::ToInterpolationSetImpl>(JointInterpolations)};
FSGIC_FQuat CmcStartRotationContainer{CmcStartRotation.Quaternion()};
SGCoreImpl_FSGHandInterpolatorImpl_ctor_JointInterpolations_CmcStartRotation(
&OutHandInterpolatorImplContainer, &JointInterpolationsContainer, &CmcStartRotationContainer);
Pimpl->HandInterpolatorImpl = MoveTemp(OutHandInterpolatorImplContainer.HandInterpolatorImpl);
Pimpl->SyncUProperties();
}
USGHandInterpolator::USGHandInterpolator(const TArray<FSGInterpolationSetArray>& JointInterpolations,
const FQuat& CmcStartRotation)
:
@@ -322,6 +376,30 @@ USGHandInterpolator::USGHandInterpolator(const TArray<FSGInterpolationSetArray>&
Pimpl->SyncUProperties();
}
USGHandInterpolator::USGHandInterpolator(const TArray<FSGInterpolationSetArray>& JointInterpolations,
const FRotator& CmcStartRotation)
:
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
#else
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
#endif /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 ) */
{
FSGIC_FSGHandInterpolatorImpl OutHandInterpolatorImplContainer;
FSGIC_TArray_TArray_FSGInterpolationSetImpl JointInterpolationsContainer{
FSGArrayUtils::ToImplType<
USGInterpolationSet, FSGInterpolationSetImpl,
&USGInterpolationSet::ToInterpolationSetImpl,
FSGInterpolationSetArray, &FSGInterpolationSetArray::InterpolationSetArray>(
JointInterpolations)};
FSGIC_FQuat CmcStartRotationContainer{CmcStartRotation.Quaternion()};
SGCoreImpl_FSGHandInterpolatorImpl_ctor_JointInterpolations_CmcStartRotation(
&OutHandInterpolatorImplContainer, &JointInterpolationsContainer, &CmcStartRotationContainer);
Pimpl->HandInterpolatorImpl = MoveTemp(OutHandInterpolatorImplContainer.HandInterpolatorImpl);
Pimpl->SyncUProperties();
}
USGHandInterpolator::USGHandInterpolator(const FSGHandInterpolatorImpl& HandInterpolatorImpl)
:
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
@@ -365,7 +443,7 @@ TArray<TArray<USGInterpolationSet*>> USGHandInterpolator::GetJointInterpolations
return JointInterpolations;
}
FQuat USGHandInterpolator::GetCmcStartRotation() const
FQuat USGHandInterpolator::GetCmcStartRotationQ() const
{
FSGIC_FSGHandInterpolatorImpl InstanceContainer{ToHandInterpolatorImpl()};
FSGIC_FQuat OutRotationContainer;
@@ -373,6 +451,14 @@ FQuat USGHandInterpolator::GetCmcStartRotation() const
return MoveTemp(OutRotationContainer.Quat);
}
FRotator USGHandInterpolator::GetCmcStartRotation() const
{
FSGIC_FSGHandInterpolatorImpl InstanceContainer{ToHandInterpolatorImpl()};
FSGIC_FQuat OutRotationContainer;
SGCoreImpl_FSGHandInterpolatorImpl_GetCmcStartRotation(&InstanceContainer, &OutRotationContainer);
return OutRotationContainer.Quat.Rotator();
}
float USGHandInterpolator::CalculateAngle(const ESGFinger Finger, const int32 Movement, const float Value) const
{
Pimpl->SyncImplObject();
Source/SenseGloveCore/Private/SGCore/SGHandPose.cpp
+106 -5
View File
@@ -36,6 +36,7 @@
#include "SGCore/SGHandPose.h"
#include "Runtime/Launch/Resources/Version.h"
#include "SGCore/SGRotatorArray.h"
#include "SGCoreImpl/SGExportedFunctions.h"
#include "SGCoreImpl/SGHandPoseImpl.h"
@@ -114,6 +115,23 @@ USGHandPose* USGHandPose::NewHandPose(
return NewHandPose(Outer, MoveTemp(OutHandPoseImplContainer.HandPoseImpl));
}
USGHandPose* USGHandPose::NewHandPose(
UObject* Outer,
const bool bRightHanded,
const TArray<TArray<FVector>>& JointPositions, const TArray<TArray<FRotator>>& JointRotations,
const TArray<TArray<FVector>>& HandAngles)
{
FSGIC_FSGHandPoseImpl OutHandPoseImplContainer;
FSGIC_TArray_TArray_FVector JointPositionsContainer{JointPositions};
FSGIC_TArray_TArray_FQuat JointRotationsContainer{FSGArrayUtils::RotatorsToQuats(JointRotations)};
FSGIC_TArray_TArray_FVector HandAnglesContainer{HandAngles};
SGCoreImpl_FSGHandPoseImpl_ctor_bRightHanded_JointPositions_JointRotations_HandAngles(
&OutHandPoseImplContainer, bRightHanded, &JointPositionsContainer,
&JointRotationsContainer, &HandAnglesContainer);
return NewHandPose(Outer, MoveTemp(OutHandPoseImplContainer.HandPoseImpl));
}
USGHandPose* USGHandPose::NewHandPose(
UObject* Outer,
const bool bRightHanded, const TArray<FSGVectorArray>& JointPositions, const TArray<FSGQuatArray>& JointRotations,
@@ -136,6 +154,29 @@ USGHandPose* USGHandPose::NewHandPose(
return NewHandPose(Outer, MoveTemp(OutHandPoseImplContainer.HandPoseImpl));
}
USGHandPose* USGHandPose::NewHandPose(
UObject* Outer,
const bool bRightHanded,
const TArray<FSGVectorArray>& JointPositions, const TArray<FSGRotatorArray>& JointRotations,
const TArray<FSGVectorArray>& HandAngles)
{
FSGIC_FSGHandPoseImpl OutHandPoseImplContainer;
FSGIC_TArray_TArray_FVector JointPositionsContainer{
FSGArrayUtils::FromBPNestedArray<FVector, FSGVectorArray, &FSGVectorArray::VectorArray>(JointPositions)
};
FSGIC_TArray_TArray_FQuat JointRotationsContainer{
FSGArrayUtils::RotatorsToQuats<FSGRotatorArray, &FSGRotatorArray::RotatorArray>(JointRotations)
};
FSGIC_TArray_TArray_FVector HandAnglesContainer{
FSGArrayUtils::FromBPNestedArray<FVector, FSGVectorArray, &FSGVectorArray::VectorArray>(HandAngles)
};
SGCoreImpl_FSGHandPoseImpl_ctor_bRightHanded_JointPositions_JointRotations_HandAngles(
&OutHandPoseImplContainer, bRightHanded, &JointPositionsContainer,
&JointRotationsContainer, &HandAnglesContainer);
return NewHandPose(Outer, MoveTemp(OutHandPoseImplContainer.HandPoseImpl));
}
USGHandPose* USGHandPose::Deserialize(UObject* Outer, const FString& SerializedString)
{
FSGIC_FSGHandPoseImpl OutHandPoseImplContainer;
@@ -256,8 +297,9 @@ USGHandPose::USGHandPose()
Pimpl->SyncUProperties();
}
USGHandPose::USGHandPose(const bool bRightHanded, const TArray<TArray<FVector>>& JointPositions,
const TArray<TArray<FQuat>>& JointRotations, const TArray<TArray<FVector>>& HandAngles)
USGHandPose::USGHandPose(const bool bRightHanded,
const TArray<TArray<FVector>>& JointPositions, const TArray<TArray<FQuat>>& JointRotations,
const TArray<TArray<FVector>>& HandAngles)
:
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
@@ -277,8 +319,31 @@ USGHandPose::USGHandPose(const bool bRightHanded, const TArray<TArray<FVector>>&
Pimpl->SyncUProperties();
}
USGHandPose::USGHandPose(const bool bRightHanded, const TArray<FSGVectorArray>& JointPositions,
const TArray<FSGQuatArray>& JointRotations, const TArray<FSGVectorArray>& HandAngles)
USGHandPose::USGHandPose(const bool bRightHanded,
const TArray<TArray<FVector>>& JointPositions, const TArray<TArray<FRotator>>& JointRotations,
const TArray<TArray<FVector>>& HandAngles)
:
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
#else
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
#endif /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 ) */
{
FSGIC_FSGHandPoseImpl OutHandPoseImplContainer;
FSGIC_TArray_TArray_FVector JointPositionsContainer{JointPositions};
FSGIC_TArray_TArray_FQuat JointRotationsContainer{FSGArrayUtils::RotatorsToQuats(JointRotations)};
FSGIC_TArray_TArray_FVector HandAnglesContainer{HandAngles};
SGCoreImpl_FSGHandPoseImpl_ctor_bRightHanded_JointPositions_JointRotations_HandAngles(
&OutHandPoseImplContainer, bRightHanded, &JointPositionsContainer,
&JointRotationsContainer, &HandAnglesContainer);
Pimpl->HandPoseImpl = MoveTemp(OutHandPoseImplContainer.HandPoseImpl);
Pimpl->SyncUProperties();
}
USGHandPose::USGHandPose(const bool bRightHanded, const
TArray<FSGVectorArray>& JointPositions, const TArray<FSGQuatArray>& JointRotations,
const TArray<FSGVectorArray>& HandAngles)
:
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
@@ -304,6 +369,34 @@ USGHandPose::USGHandPose(const bool bRightHanded, const TArray<FSGVectorArray>&
Pimpl->SyncUProperties();
}
USGHandPose::USGHandPose(const bool bRightHanded,
const TArray<FSGVectorArray>& JointPositions, const TArray<FSGRotatorArray>& JointRotations,
const TArray<FSGVectorArray>& HandAngles)
:
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
#else
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
#endif /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 ) */
{
FSGIC_FSGHandPoseImpl OutHandPoseImplContainer;
FSGIC_TArray_TArray_FVector JointPositionsContainer{
FSGArrayUtils::FromBPNestedArray<FVector, FSGVectorArray, &FSGVectorArray::VectorArray>(JointPositions)
};
FSGIC_TArray_TArray_FQuat JointRotationsContainer{
FSGArrayUtils::RotatorsToQuats<FSGRotatorArray, &FSGRotatorArray::RotatorArray>(JointRotations)
};
FSGIC_TArray_TArray_FVector HandAnglesContainer{
FSGArrayUtils::FromBPNestedArray<FVector, FSGVectorArray, &FSGVectorArray::VectorArray>(HandAngles)
};
SGCoreImpl_FSGHandPoseImpl_ctor_bRightHanded_JointPositions_JointRotations_HandAngles(
&OutHandPoseImplContainer, bRightHanded, &JointPositionsContainer,
&JointRotationsContainer, &HandAnglesContainer);
Pimpl->HandPoseImpl = MoveTemp(OutHandPoseImplContainer.HandPoseImpl);
Pimpl->SyncUProperties();
}
USGHandPose::USGHandPose(const FSGHandPoseImpl& HandPoseImpl)
:
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
@@ -346,7 +439,7 @@ TArray<TArray<FVector>> USGHandPose::GetJointPositions() const
return MoveTemp(OutPositionsContainer.Array);
}
TArray<TArray<FQuat>> USGHandPose::GetJointRotations() const
TArray<TArray<FQuat>> USGHandPose::GetJointRotationsQ() const
{
FSGIC_FSGHandPoseImpl InstanceContainer{ToHandPoseImpl()};
FSGIC_TArray_TArray_FQuat OutRotationsContainer;
@@ -354,6 +447,14 @@ TArray<TArray<FQuat>> USGHandPose::GetJointRotations() const
return MoveTemp(OutRotationsContainer.Array);
}
TArray<TArray<FRotator>> USGHandPose::GetJointRotations() const
{
FSGIC_FSGHandPoseImpl InstanceContainer{ToHandPoseImpl()};
FSGIC_TArray_TArray_FQuat OutRotationsContainer;
SGCoreImpl_FSGHandPoseImpl_GetJointRotations(&InstanceContainer, &OutRotationsContainer);
return FSGArrayUtils::QuatsToRotators(OutRotationsContainer.Array);
}
TArray<TArray<FVector>> USGHandPose::GetHandAngles() const
{
FSGIC_FSGHandPoseImpl InstanceContainer{ToHandPoseImpl()};
Source/SenseGloveCore/Private/SGCore/SGHapticGlove.cpp
+63
View File
@@ -349,6 +349,24 @@ bool USGHapticGlove::GetImuRotation(FQuat& OutImu)
return bResult;
}
bool USGHapticGlove::GetImuRotation(FRotator& OutImu)
{
SyncImplObject();
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
FSGIC_FQuat OutImuContainer;
const bool bResult = SGCoreImpl_FSGHapticGloveImpl_GetImuRotation(&InstanceContainer, &OutImuContainer);
SyncUProperties();
if (bResult)
{
OutImu = OutImuContainer.Quat.Rotator();
}
return bResult;
}
bool USGHapticGlove::GetHandPose(
UObject* Outer,
const USGBasicHandModel* HandGeometry, const USGHandProfile* HandProfile, USGHandPose*& OutHandPose)
@@ -628,6 +646,28 @@ void USGHapticGlove::GetWristLocation(const FVector& ReferencePosition, const FQ
OutWristRotation = MoveTemp(OutWristRotationContainer.Quat);
}
void USGHapticGlove::GetWristLocation(const FVector& ReferencePosition, const FRotator& ReferenceRotation,
const ESGPositionalTrackingHardware TrackingHardware,
FVector& OutWristPosition, FRotator& OutWristRotation) const
{
SyncImplObject();
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
FSGIC_FVector ReferencePositionContainer{ReferencePosition};
FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
FSGIC_FVector OutWristPositionContainer;
FSGIC_FQuat OutWristRotationContainer;
SGCoreImpl_FSGHapticGloveImpl_GetWristLocation(
&InstanceContainer,
&ReferencePositionContainer, &ReferenceRotationContainer,
&TrackingHardwareContainer,
&OutWristPositionContainer, &OutWristRotationContainer);
OutWristPosition = MoveTemp(OutWristPositionContainer.Vector);
OutWristRotation = OutWristRotationContainer.Quat.Rotator();
}
void USGHapticGlove::GetGloveLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
const ESGPositionalTrackingHardware TrackingHardware,
FVector& OutGlovePosition, FQuat& OutGloveRotation) const
@@ -651,6 +691,29 @@ void USGHapticGlove::GetGloveLocation(const FVector& ReferencePosition, const FQ
OutGloveRotation = MoveTemp(OutGloveRotationContainer.Quat);
}
void USGHapticGlove::GetGloveLocation(const FVector& ReferencePosition, const FRotator& ReferenceRotation,
const ESGPositionalTrackingHardware TrackingHardware,
FVector& OutGlovePosition, FRotator& OutGloveRotation) const
{
SyncImplObject();
FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
FSGIC_FVector ReferencePositionContainer{ReferencePosition};
FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
FSGIC_FVector OutGlovePositionContainer;
FSGIC_FQuat OutGloveRotationContainer;
SGCoreImpl_FSGHapticGloveImpl_GetGloveLocation(
&InstanceContainer,
&ReferencePositionContainer, &ReferenceRotationContainer,
&TrackingHardwareContainer,
&OutGlovePositionContainer, &OutGloveRotationContainer);
OutGlovePosition = MoveTemp(OutGlovePositionContainer.Vector);
OutGloveRotation = OutGloveRotationContainer.Quat.Rotator();
}
USGHapticGlove::FImpl::FImpl(USGHapticGlove* InOwner)
: Owner(InOwner)
{
Source/SenseGloveCore/Private/SGCore/SGJointKinematics.cpp
+60 -4
View File
@@ -54,14 +54,42 @@ bool FSGJointKinematics::ForwardKinematics(
FSGIC_TArray_FVector JointAnglesContainer{JointAngles};
FSGIC_TArray_FVector OutNewPositionsContainer;
FSGIC_TArray_FQuat OutNewRotationsContainer;
return
const bool bResult =
SGCoreImpl_FSGJointKinematicsImpl_ForwardKinematics_StartPosition_StartRotation_JointLengths_JointAngles_OutNewPositions_OutNewRotations(
&StartPositionContainer, &StartRotationContainer, &JointLengthsContainer, &JointAnglesContainer,
&OutNewPositionsContainer, &OutNewRotationsContainer);
OutNewPositions = MoveTemp(OutNewPositionsContainer.Array);
OutNewRotations = MoveTemp(OutNewRotationsContainer.Array);
return bResult;
}
bool FSGJointKinematics::ForwardKinematics(
const USGBasicHandModel* Profile, ESGFinger Finger, const TArray<FVector>& JointAngles,
const FVector& StartPosition, const FRotator& StartRotation, const TArray<FVector>& JointLengths,
const TArray<FVector>& JointAngles, TArray<FVector>& OutNewPositions, TArray<FRotator>& OutNewRotations)
{
FSGIC_FVector StartPositionContainer{StartPosition};
FSGIC_FQuat StartRotationContainer{StartRotation.Quaternion()};
FSGIC_TArray_FVector JointLengthsContainer{JointLengths};
FSGIC_TArray_FVector JointAnglesContainer{JointAngles};
FSGIC_TArray_FVector OutNewPositionsContainer;
FSGIC_TArray_FQuat OutNewRotationsContainer;
const bool bResult =
SGCoreImpl_FSGJointKinematicsImpl_ForwardKinematics_StartPosition_StartRotation_JointLengths_JointAngles_OutNewPositions_OutNewRotations(
&StartPositionContainer, &StartRotationContainer, &JointLengthsContainer, &JointAnglesContainer,
&OutNewPositionsContainer, &OutNewRotationsContainer);
OutNewPositions = MoveTemp(OutNewPositionsContainer.Array);
OutNewRotations = FSGArrayUtils::QuatsToRotators(OutNewRotationsContainer.Array);
return bResult;
}
bool FSGJointKinematics::ForwardKinematics(
const USGBasicHandModel* Profile, const ESGFinger Finger, const TArray<FVector>& JointAngles,
TArray<FVector>& OutNewPositions, TArray<FQuat>& OutNewRotations)
{
FSGIC_FSGBasicHandModelImpl ProfileContainer{Profile->ToBasicHandModelImpl()};
@@ -69,7 +97,35 @@ bool FSGJointKinematics::ForwardKinematics(
FSGIC_TArray_FVector JointAnglesContainer{JointAngles};
FSGIC_TArray_FVector OutNewPositionsContainer;
FSGIC_TArray_FQuat OutNewRotationsContainer;
return
const bool bResult =
SGCoreImpl_FSGJointKinematicsImpl_ForwardKinematics_Profile_Finger_JointAngles_OutNewPositions_OutNewRotations(
&ProfileContainer, &FingerContainer, &JointAnglesContainer, &OutNewPositions, &OutNewRotations);
&ProfileContainer, &FingerContainer, &JointAnglesContainer,
&OutNewPositionsContainer, &OutNewRotationsContainer);
OutNewPositions = MoveTemp(OutNewPositionsContainer.Array);
OutNewRotations = MoveTemp(OutNewRotationsContainer.Array);
return bResult;
}
bool FSGJointKinematics::ForwardKinematics(
const USGBasicHandModel* Profile, const ESGFinger Finger, const TArray<FVector>& JointAngles,
TArray<FVector>& OutNewPositions, TArray<FRotator>& OutNewRotations)
{
FSGIC_FSGBasicHandModelImpl ProfileContainer{Profile->ToBasicHandModelImpl()};
FSGIC_ESGFinger FingerContainer{Finger};
FSGIC_TArray_FVector JointAnglesContainer{JointAngles};
FSGIC_TArray_FVector OutNewPositionsContainer;
FSGIC_TArray_FQuat OutNewRotationsContainer;
const bool bResult =
SGCoreImpl_FSGJointKinematicsImpl_ForwardKinematics_Profile_Finger_JointAngles_OutNewPositions_OutNewRotations(
&ProfileContainer, &FingerContainer, &JointAnglesContainer,
&OutNewPositionsContainer, &OutNewRotationsContainer);
OutNewPositions = MoveTemp(OutNewPositionsContainer.Array);
OutNewRotations = FSGArrayUtils::QuatsToRotators(OutNewRotationsContainer.Array);
return bResult;
}
Source/SenseGloveCore/Private/SGCore/SGNovaGlove.cpp
+101
View File
@@ -247,6 +247,25 @@ void USGNovaGlove::CalculateGloveLocation(const FVector& ReferencePosition, cons
OutGloveRotation = MoveTemp(OutGloveRotationContainer.Quat);
}
void USGNovaGlove::CalculateGloveLocation(const FVector& ReferencePosition, const FRotator& ReferenceRotation,
const ESGPositionalTrackingHardware TrackingHardware, const bool bRightHanded,
FVector& OutGlovePosition, FRotator& OutGloveRotation)
{
FSGIC_FVector ReferencePositionContainer{ReferencePosition};
FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
FSGIC_FVector OutGlovePositionContainer;
FSGIC_FQuat OutGloveRotationContainer;
SGCoreImpl_FSGNovaGloveImpl_CalculateGloveLocation(
&ReferencePositionContainer, &ReferenceRotationContainer,
&TrackingHardwareContainer, bRightHanded,
&OutGlovePositionContainer, &OutGloveRotationContainer);
OutGlovePosition = MoveTemp(OutGlovePositionContainer.Vector);
OutGloveRotation = OutGloveRotationContainer.Quat.Rotator();
}
void USGNovaGlove::CalculateWristLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
const ESGPositionalTrackingHardware TrackingHardware, const bool bRightHanded,
FVector& OutWristPosition, FQuat& OutWristRotation)
@@ -266,6 +285,25 @@ void USGNovaGlove::CalculateWristLocation(const FVector& ReferencePosition, cons
OutWristRotation = MoveTemp(OutWristRotationContainer.Quat);
}
void USGNovaGlove::CalculateWristLocation(const FVector& ReferencePosition, const FRotator& ReferenceRotation,
const ESGPositionalTrackingHardware TrackingHardware, const bool bRightHanded,
FVector& OutWristPosition, FRotator& OutWristRotation)
{
FSGIC_FVector ReferencePositionContainer{ReferencePosition};
FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
FSGIC_FVector OutWristPositionContainer;
FSGIC_FQuat OutWristRotationContainer;
SGCoreImpl_FSGNovaGloveImpl_CalculateWristLocation(
&ReferencePositionContainer, &ReferenceRotationContainer,
&TrackingHardwareContainer, bRightHanded,
&OutWristPositionContainer, &OutWristRotationContainer);
OutWristPosition = MoveTemp(OutWristPositionContainer.Vector);
OutWristRotation = OutWristRotationContainer.Quat.Rotator();
}
FString USGNovaGlove::ToBytes(const USGThumperCommand* ThumperCommand)
{
FSGIC_FSGThumperCommandImpl ThumperCommandContainer{ThumperCommand->ToThumperCommandImpl()};
@@ -521,6 +559,24 @@ bool USGNovaGlove::GetImuRotation(FQuat& OutImu)
return bResult;
}
bool USGNovaGlove::GetImuRotation(FRotator& OutImu)
{
SyncImplObject();
FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
FSGIC_FQuat OutImuContainer;
const bool bResult = SGCoreImpl_FSGNovaGloveImpl_GetImuRotation(&InstanceContainer, &OutImuContainer);
SyncUProperties();
if (bResult)
{
OutImu = OutImuContainer.Quat.Rotator();
}
return bResult;
}
bool USGNovaGlove::GetHandPose(
UObject* Outer, const USGBasicHandModel* HandModel, const USGNovaGloveHandProfile* Profile,
USGHandPose*& OutHandPose)
@@ -700,6 +756,29 @@ void USGNovaGlove::GetGloveLocation(const FVector& ReferencePosition, const FQua
OutGloveRotation = MoveTemp(OutGloveRotationContainer.Quat);
}
void USGNovaGlove::GetGloveLocation(const FVector& ReferencePosition, const FRotator& ReferenceRotation,
const ESGPositionalTrackingHardware TrackingHardware,
FVector& OutGlovePosition, FRotator& OutGloveRotation) const
{
SyncImplObject();
FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
FSGIC_FVector ReferencePositionContainer{ReferencePosition};
FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
FSGIC_FVector OutGlovePositionContainer;
FSGIC_FQuat OutGloveRotationContainer;
SGCoreImpl_FSGNovaGloveImpl_GetGloveLocation(
&InstanceContainer,
&ReferencePositionContainer, &ReferenceRotationContainer,
&TrackingHardwareContainer,
&OutGlovePositionContainer, &OutGloveRotationContainer);
OutGlovePosition = MoveTemp(OutGlovePositionContainer.Vector);
OutGloveRotation = OutGloveRotationContainer.Quat.Rotator();
}
void USGNovaGlove::GetWristLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
const ESGPositionalTrackingHardware TrackingHardware,
FVector& OutWristPosition, FQuat& OutWristRotation) const
@@ -722,6 +801,28 @@ void USGNovaGlove::GetWristLocation(const FVector& ReferencePosition, const FQua
OutWristRotation = MoveTemp(OutWristRotationContainer.Quat);
}
void USGNovaGlove::GetWristLocation(const FVector& ReferencePosition, const FRotator& ReferenceRotation,
const ESGPositionalTrackingHardware TrackingHardware,
FVector& OutWristPosition, FRotator& OutWristRotation) const
{
SyncImplObject();
FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
FSGIC_FVector ReferencePositionContainer{ReferencePosition};
FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
FSGIC_FVector OutWristPositionContainer;
FSGIC_FQuat OutWristRotationContainer;
SGCoreImpl_FSGNovaGloveImpl_GetWristLocation(
&InstanceContainer,
&ReferencePositionContainer, &ReferenceRotationContainer,
&TrackingHardwareContainer,
&OutWristPositionContainer, &OutWristRotationContainer);
OutWristPosition = MoveTemp(OutWristPositionContainer.Vector);
OutWristRotation = OutWristRotationContainer.Quat.Rotator();
}
FString USGNovaGlove::ToString() const
{
SyncImplObject();
Source/SenseGloveCore/Private/SGCore/SGNovaGloveSensorData.cpp
+44 -1
View File
@@ -111,6 +111,20 @@ USGNovaGloveSensorData* USGNovaGloveSensorData::NewNovaGloveSensorData(
return NewNovaGloveSensorData(Outer, MoveTemp(OutNovaGloveSensorDataImplContainer.NovaGloveSensorDataImpl));
}
USGNovaGloveSensorData* USGNovaGloveSensorData::NewNovaGloveSensorData(
UObject* Outer, const TArray<FVector>& Values, const int32 ParsedValues,
const FRotator& ImuRotation, const bool bImuParsed, const float BatteryLevel, const bool bCharging)
{
FSGIC_FSGNovaGloveSensorDataImpl OutNovaGloveSensorDataImplContainer;
FSGIC_TArray_FVector ValuesContainer{Values};
FSGIC_FQuat ImuRotationContainer{ImuRotation.Quaternion()};
SGCoreImpl_FSGNovaGloveSensorDataImpl_ctor_Values_ParsedValues_ImuRotation_bImuParsed_BatteryLevel_bCharging(
&OutNovaGloveSensorDataImplContainer, &ValuesContainer, ParsedValues,
&ImuRotationContainer, bImuParsed, BatteryLevel, bCharging);
return NewNovaGloveSensorData(Outer, MoveTemp(OutNovaGloveSensorDataImplContainer.NovaGloveSensorDataImpl));
}
USGNovaGloveSensorData* USGNovaGloveSensorData::Empty(UObject* Outer)
{
FSGIC_FSGNovaGloveSensorDataImpl OutNovaGloveSensorDataImplContainer;
@@ -176,6 +190,27 @@ USGNovaGloveSensorData::USGNovaGloveSensorData(const TArray<FVector>& Values, co
Pimpl->SyncUProperties();
}
USGNovaGloveSensorData::USGNovaGloveSensorData(const TArray<FVector>& Values, const int32 ParsedValues,
const FRotator& ImuRotation, const bool bImuParsed,
const float BatteryLevel, const bool bCharging)
:
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
#else
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
#endif /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 ) */
{
FSGIC_FSGNovaGloveSensorDataImpl OutNovaGloveSensorDataImplContainer;
FSGIC_TArray_FVector ValuesContainer{Values};
FSGIC_FQuat ImuRotationContainer{ImuRotation.Quaternion()};
SGCoreImpl_FSGNovaGloveSensorDataImpl_ctor_Values_ParsedValues_ImuRotation_bImuParsed_BatteryLevel_bCharging(
&OutNovaGloveSensorDataImplContainer, &ValuesContainer, ParsedValues,
&ImuRotationContainer, bImuParsed, BatteryLevel, bCharging);
Pimpl->NovaGloveSensorDataImpl = MoveTemp(OutNovaGloveSensorDataImplContainer.NovaGloveSensorDataImpl);
Pimpl->SyncUProperties();
}
USGNovaGloveSensorData::USGNovaGloveSensorData(const FSGNovaGloveSensorDataImpl& NovaGloveSensorDataImpl)
:
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
@@ -212,7 +247,7 @@ TArray<FVector> USGNovaGloveSensorData::GetSensorValues() const
return MoveTemp(OutValuesContainer.Array);
}
FQuat USGNovaGloveSensorData::GetImuRotation() const
FQuat USGNovaGloveSensorData::GetImuRotationQ() const
{
FSGIC_FSGNovaGloveSensorDataImpl InstanceContainer{ToNovaGloveSensorDataImpl()};
FSGIC_FQuat OutRotationContainer;
@@ -220,6 +255,14 @@ FQuat USGNovaGloveSensorData::GetImuRotation() const
return MoveTemp(OutRotationContainer.Quat);
}
FRotator USGNovaGloveSensorData::GetImuRotation() const
{
FSGIC_FSGNovaGloveSensorDataImpl InstanceContainer{ToNovaGloveSensorDataImpl()};
FSGIC_FQuat OutRotationContainer;
SGCoreImpl_FSGNovaGloveSensorDataImpl_GetImuRotation(&InstanceContainer, &OutRotationContainer);
return OutRotationContainer.Quat.Rotator();
}
int32 USGNovaGloveSensorData::GetParsedValues() const
{
FSGIC_FSGNovaGloveSensorDataImpl InstanceContainer{ToNovaGloveSensorDataImpl()};
Source/SenseGloveCore/Private/SGCore/SGRotatorArray.cpp
+36
View File
@@ -0,0 +1,36 @@
/**
* @file
*
* @author Mamadou Babaei <mamadou@senseglove.com>
*
* @section LICENSE
*
* (The MIT License)
*
* Copyright (c) 2020 - 2022 SenseGlove
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* @section DESCRIPTION
*
*
*/
#include "SGCore/SGRotatorArray.h"
Source/SenseGloveCore/Private/SGCore/SGSenseGlove.cpp
+163
View File
@@ -276,6 +276,28 @@ void USGSenseGlove::CalculateGloveLocation(const FVector& ReferencePosition, con
OutGloveRotation = MoveTemp(OutGloveRotationContainer.Quat);
}
void USGSenseGlove::CalculateGloveLocation(const FVector& ReferencePosition, const FRotator& ReferenceRotation,
const ESGPositionalTrackingHardware TrackingHardware,
const bool bRightHanded, const ESGFinger MountedOn,
FVector& OutGlovePosition, FRotator& OutGloveRotation)
{
FSGIC_FVector ReferencePositionContainer{ReferencePosition};
FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
FSGIC_ESGFinger MountedOnContainer{MountedOn};
FSGIC_FVector OutGlovePositionContainer;
FSGIC_FQuat OutGloveRotationContainer;
SGCoreImpl_FSGSenseGloveImpl_CalculateGloveLocation(
&ReferencePositionContainer, &ReferenceRotationContainer,
&TrackingHardwareContainer,
bRightHanded, &MountedOnContainer,
&OutGlovePositionContainer, &OutGloveRotationContainer);
OutGlovePosition = MoveTemp(OutGlovePositionContainer.Vector);
OutGloveRotation = OutGloveRotationContainer.Quat.Rotator();
}
void USGSenseGlove::CalculateWristLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
const ESGPositionalTrackingHardware TrackingHardware,
const bool bRightHanded, const ESGFinger MountedOn,
@@ -303,6 +325,33 @@ void USGSenseGlove::CalculateWristLocation(const FVector& ReferencePosition, con
OutWristRotation = MoveTemp(OutWristRotationContainer.Quat);
}
void USGSenseGlove::CalculateWristLocation(const FVector& ReferencePosition, const FRotator& ReferenceRotation,
const ESGPositionalTrackingHardware TrackingHardware,
const bool bRightHanded, const ESGFinger MountedOn,
const FVector& GloveWristPositionOffset,
const FRotator& GloveWristRotationOffset,
FVector& OutWristPosition, FRotator& OutWristRotation)
{
FSGIC_FVector ReferencePositionContainer{ReferencePosition};
FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
FSGIC_ESGFinger MountedOnContainer{MountedOn};
FSGIC_FVector GloveWristPositionOffsetContainer{GloveWristPositionOffset};
FSGIC_FQuat GloveWristRotationOffsetContainer{GloveWristRotationOffset.Quaternion()};
FSGIC_FVector OutWristPositionContainer;
FSGIC_FQuat OutWristRotationContainer;
SGCoreImpl_FSGSenseGloveImpl_CalculateWristLocation(
&ReferencePositionContainer, &ReferenceRotationContainer,
&TrackingHardwareContainer,
bRightHanded, &MountedOnContainer,
&GloveWristPositionOffsetContainer, &GloveWristRotationOffsetContainer,
&OutWristPositionContainer, &OutWristRotationContainer);
OutWristPosition = MoveTemp(OutWristPositionContainer.Vector);
OutWristRotation = OutWristRotationContainer.Quat.Rotator();
}
USGSenseGlove::USGSenseGlove()
: USGHapticGlove(),
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
@@ -520,6 +569,24 @@ bool USGSenseGlove::GetImuRotation(FQuat& OutImu)
return bResult;
}
bool USGSenseGlove::GetImuRotation(FRotator& OutImu)
{
SyncImplObject();
FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
FSGIC_FQuat OutImuContainer;
const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetImuRotation(&InstanceContainer, &OutImuContainer);
SyncUProperties();
if (bResult)
{
OutImu = OutImuContainer.Quat.Rotator();
}
return bResult;
}
bool USGSenseGlove::GetGlovePose(UObject* Outer, USGSenseGlovePose*& OutGlovePose)
{
SyncImplObject();
@@ -738,6 +805,29 @@ void USGSenseGlove::GetGloveLocation(const FVector& ReferencePosition, const FQu
OutGloveRotation = MoveTemp(OutGloveRotationContainer.Quat);
}
void USGSenseGlove::GetGloveLocation(const FVector& ReferencePosition, const FRotator& ReferenceRotation,
const ESGPositionalTrackingHardware TrackingHardware,
FVector& OutGlovePosition, FRotator& OutGloveRotation) const
{
SyncImplObject();
FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
FSGIC_FVector ReferencePositionContainer{ReferencePosition};
FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
FSGIC_FVector OutGlovePositionContainer;
FSGIC_FQuat OutGloveRotationContainer;
SGCoreImpl_FSGSenseGloveImpl_GetGloveLocation_ReferencePosition_ReferenceRotation_TrackingHardware_OutGlovePosition_OutGloveRotation(
&InstanceContainer,
&ReferencePositionContainer, &ReferenceRotationContainer,
&TrackingHardwareContainer,
&OutGlovePositionContainer, &OutGloveRotationContainer);
OutGlovePosition = MoveTemp(OutGlovePositionContainer.Vector);
OutGloveRotation = OutGloveRotationContainer.Quat.Rotator();
}
void USGSenseGlove::GetGloveLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
const ESGPositionalTrackingHardware TrackingHardware, const ESGFinger MountedOn,
FVector& OutGlovePosition, FQuat& OutGloveRotation) const
@@ -762,6 +852,30 @@ void USGSenseGlove::GetGloveLocation(const FVector& ReferencePosition, const FQu
OutGloveRotation = MoveTemp(OutGloveRotationContainer.Quat);
}
void USGSenseGlove::GetGloveLocation(const FVector& ReferencePosition, const FRotator& ReferenceRotation,
const ESGPositionalTrackingHardware TrackingHardware, const ESGFinger MountedOn,
FVector& OutGlovePosition, FRotator& OutGloveRotation) const
{
SyncImplObject();
FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
FSGIC_FVector ReferencePositionContainer{ReferencePosition};
FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
FSGIC_ESGFinger MountedOnContainer{MountedOn};
FSGIC_FVector OutGlovePositionContainer;
FSGIC_FQuat OutGloveRotationContainer;
SGCoreImpl_FSGSenseGloveImpl_GetGloveLocation_ReferencePosition_ReferenceRotation_TrackingHardware_MountedOn_OutGlovePosition_OutGloveRotation(
&InstanceContainer,
&ReferencePositionContainer, &ReferenceRotationContainer,
&TrackingHardwareContainer, &MountedOnContainer,
&OutGlovePositionContainer, &OutGloveRotationContainer);
OutGlovePosition = MoveTemp(OutGlovePositionContainer.Vector);
OutGloveRotation = OutGloveRotationContainer.Quat.Rotator();
}
void USGSenseGlove::GetWristLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
const ESGPositionalTrackingHardware TrackingHardware,
FVector& OutWristPosition, FQuat& OutWristRotation) const
@@ -784,6 +898,28 @@ void USGSenseGlove::GetWristLocation(const FVector& ReferencePosition, const FQu
OutWristRotation = MoveTemp(OutWristRotationContainer.Quat);
}
void USGSenseGlove::GetWristLocation(const FVector& ReferencePosition, const FRotator& ReferenceRotation,
const ESGPositionalTrackingHardware TrackingHardware,
FVector& OutWristPosition, FRotator& OutWristRotation) const
{
SyncImplObject();
FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
FSGIC_FVector ReferencePositionContainer{ReferencePosition};
FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
FSGIC_FVector OutWristPositionContainer;
FSGIC_FQuat OutWristRotationContainer;
SGCoreImpl_FSGSenseGloveImpl_GetWristLocation_ReferencePosition_ReferenceRotation_TrackingHardware_OutWristPosition_OutWristRotation(
&InstanceContainer,
&ReferencePositionContainer, &ReferenceRotationContainer,
&TrackingHardwareContainer,
&OutWristPositionContainer, &OutWristRotationContainer);
OutWristPosition = MoveTemp(OutWristPositionContainer.Vector);
OutWristRotation = OutWristRotationContainer.Quat.Rotator();
}
void USGSenseGlove::GetWristLocation(const FVector& ReferencePosition, const FQuat& ReferenceRotation,
const ESGPositionalTrackingHardware TrackingHardware,
const FVector& GloveWristPositionOffset,
@@ -811,6 +947,33 @@ void USGSenseGlove::GetWristLocation(const FVector& ReferencePosition, const FQu
OutWristRotation = MoveTemp(OutWristRotationContainer.Quat);
}
void USGSenseGlove::GetWristLocation(const FVector& ReferencePosition, const FRotator& ReferenceRotation,
const ESGPositionalTrackingHardware TrackingHardware,
const FVector& GloveWristPositionOffset,
const FRotator& GloveWristRotationOffset,
FVector& OutWristPosition, FRotator& OutWristRotation) const
{
SyncImplObject();
FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
FSGIC_FVector ReferencePositionContainer{ReferencePosition};
FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
FSGIC_ESGPositionalTrackingHardware TrackingHardwareContainer{TrackingHardware};
FSGIC_FVector GloveWristPositionOffsetContainer{GloveWristPositionOffset};
FSGIC_FQuat GloveWristRotationOffsetContainer{GloveWristRotationOffset.Quaternion()};
FSGIC_FVector OutWristPositionContainer;
FSGIC_FQuat OutWristRotationContainer;
SGCoreImpl_FSGSenseGloveImpl_GetWristLocation_ReferencePosition_ReferenceRotation_TrackingHardware_GloveWristPositionOffset_GloveWristRotationOffset_OutWristPosition_OutWristRotation(
&InstanceContainer,
&ReferencePositionContainer, &ReferenceRotationContainer,
&TrackingHardwareContainer,
&GloveWristPositionOffsetContainer, &GloveWristRotationOffsetContainer,
&OutWristPositionContainer, &OutWristRotationContainer);
OutWristPosition = MoveTemp(OutWristPositionContainer.Vector);
OutWristRotation = OutWristRotationContainer.Quat.Rotator();
}
FString USGSenseGlove::ToString() const
{
SyncImplObject();
Source/SenseGloveCore/Private/SGCore/SGSenseGloveInfo.cpp
+152 -9
View File
@@ -101,9 +101,9 @@ USGSenseGloveInfo* USGSenseGloveInfo::NewSenseGloveInfo(UObject* Outer)
}
USGSenseGloveInfo* USGSenseGloveInfo::NewSenseGloveInfo(UObject* Outer, const FString& DeviceId,
const FString& HardwareVersion, int32 FirmwareVersion,
int32 SubFirmwareVersion, bool bRightHanded,
int32 NumberOfSensors, const FQuat& ImuCorrection,
const FString& HardwareVersion, const int32 FirmwareVersion,
const int32 SubFirmwareVersion, const bool bRightHanded,
const int32 NumberOfSensors, const FQuat& ImuCorrection,
const TArray<FVector>& StartPositions,
const TArray<FQuat>& StartRotations,
const TArray<TArray<FVector>>& GloveLengths,
@@ -128,9 +128,36 @@ USGSenseGloveInfo* USGSenseGloveInfo::NewSenseGloveInfo(UObject* Outer, const FS
}
USGSenseGloveInfo* USGSenseGloveInfo::NewSenseGloveInfo(UObject* Outer, const FString& DeviceId,
const FString& HardwareVersion, int32 FirmwareVersion,
int32 SubFirmwareVersion, bool bRightHanded,
int32 NumberOfSensors, const FQuat& ImuCorrection,
const FString& HardwareVersion, const int32 FirmwareVersion,
const int32 SubFirmwareVersion, const bool bRightHanded,
const int32 NumberOfSensors, const FRotator& ImuCorrection,
const TArray<FVector>& StartPositions,
const TArray<FRotator>& StartRotations,
const TArray<TArray<FVector>>& GloveLengths,
const TArray<bool>& Functions)
{
FSGIC_FSGSenseGloveInfoImpl OutSenseGloveInfoImplContainer;
FSGIC_FString DeviceIdContainer{DeviceId};
FSGIC_FString HardwareVersionContainer{HardwareVersion};
FSGIC_FQuat ImuCorrectionContainer{ImuCorrection.Quaternion()};
FSGIC_TArray_FVector StartPositionsContainer{StartPositions};
FSGIC_TArray_FQuat StartRotationsContainer{FSGArrayUtils::RotatorsToQuats(StartRotations)};
FSGIC_TArray_TArray_FVector GloveLengthsContainer{GloveLengths};
FSGIC_TArray_bool FunctionsContainer{Functions};
SGCoreImpl_FSGSenseGloveInfoImpl_ctor_DeviceId_HardwareVersion_FirmwareVersion_SubFirmwareVersion_bRightHanded_NumberOfSensors_ImuCorrection_StartPositions_StartRotations_GloveLengths_Functions(
&OutSenseGloveInfoImplContainer,
&DeviceIdContainer, &HardwareVersionContainer, FirmwareVersion, SubFirmwareVersion,
bRightHanded, NumberOfSensors, &ImuCorrectionContainer,
&StartPositionsContainer, &StartRotationsContainer,
&GloveLengthsContainer, &FunctionsContainer);
return NewSenseGloveInfo(Outer, MoveTemp(OutSenseGloveInfoImplContainer.SenseGloveInfoImpl));
}
USGSenseGloveInfo* USGSenseGloveInfo::NewSenseGloveInfo(UObject* Outer, const FString& DeviceId,
const FString& HardwareVersion, const int32 FirmwareVersion,
const int32 SubFirmwareVersion, const bool bRightHanded,
const int32 NumberOfSensors, const FQuat& ImuCorrection,
const TArray<FVector>& StartPositions,
const TArray<FQuat>& StartRotations,
const TArray<FSGVectorArray>& GloveLengths,
@@ -156,6 +183,35 @@ USGSenseGloveInfo* USGSenseGloveInfo::NewSenseGloveInfo(UObject* Outer, const FS
return NewSenseGloveInfo(Outer, MoveTemp(OutSenseGloveInfoImplContainer.SenseGloveInfoImpl));
}
USGSenseGloveInfo* USGSenseGloveInfo::NewSenseGloveInfo(UObject* Outer, const FString& DeviceId,
const FString& HardwareVersion, const int32 FirmwareVersion,
const int32 SubFirmwareVersion, const bool bRightHanded,
const int32 NumberOfSensors, const FRotator& ImuCorrection,
const TArray<FVector>& StartPositions,
const TArray<FRotator>& StartRotations,
const TArray<FSGVectorArray>& GloveLengths,
const TArray<bool>& Functions)
{
FSGIC_FSGSenseGloveInfoImpl OutSenseGloveInfoImplContainer;
FSGIC_FString DeviceIdContainer{DeviceId};
FSGIC_FString HardwareVersionContainer{HardwareVersion};
FSGIC_FQuat ImuCorrectionContainer{ImuCorrection.Quaternion()};
FSGIC_TArray_FVector StartPositionsContainer{StartPositions};
FSGIC_TArray_FQuat StartRotationsContainer{FSGArrayUtils::RotatorsToQuats(StartRotations)};
FSGIC_TArray_TArray_FVector GloveLengthsContainer{
FSGArrayUtils::FromBPNestedArray<FVector, FSGVectorArray, &FSGVectorArray::VectorArray>(GloveLengths)
};
FSGIC_TArray_bool FunctionsContainer{Functions};
SGCoreImpl_FSGSenseGloveInfoImpl_ctor_DeviceId_HardwareVersion_FirmwareVersion_SubFirmwareVersion_bRightHanded_NumberOfSensors_ImuCorrection_StartPositions_StartRotations_GloveLengths_Functions(
&OutSenseGloveInfoImplContainer,
&DeviceIdContainer, &HardwareVersionContainer, FirmwareVersion, SubFirmwareVersion,
bRightHanded, NumberOfSensors, &ImuCorrectionContainer,
&StartPositionsContainer, &StartRotationsContainer,
&GloveLengthsContainer, &FunctionsContainer);
return NewSenseGloveInfo(Outer, MoveTemp(OutSenseGloveInfoImplContainer.SenseGloveInfoImpl));
}
bool USGSenseGloveInfo::Parse(UObject* Outer, const FString& ConstantsString, USGSenseGloveInfo*& OutGloveInfo,
const bool bUpdateOldModels)
{
@@ -228,6 +284,38 @@ USGSenseGloveInfo::USGSenseGloveInfo(
Pimpl->SyncUProperties();
}
USGSenseGloveInfo::USGSenseGloveInfo(
const FString& DeviceId,
const FString& HardwareVersion, const int32 FirmwareVersion, const int32 SubFirmwareVersion,
const bool bRightHanded, const int32 NumberOfSensors, const FRotator& ImuCorrection,
const TArray<FVector>& StartPositions, const TArray<FRotator>& StartRotations,
const TArray<TArray<FVector>>& GloveLengths, const TArray<bool>& Functions)
:
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
#else
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
#endif /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 ) */
{
FSGIC_FSGSenseGloveInfoImpl OutSenseGloveInfoImplContainer;
FSGIC_FString DeviceIdContainer{DeviceId};
FSGIC_FString HardwareVersionContainer{HardwareVersion};
FSGIC_FQuat ImuCorrectionContainer{ImuCorrection.Quaternion()};
FSGIC_TArray_FVector StartPositionsContainer{StartPositions};
FSGIC_TArray_FQuat StartRotationsContainer{FSGArrayUtils::RotatorsToQuats(StartRotations)};
FSGIC_TArray_TArray_FVector GloveLengthsContainer{GloveLengths};
FSGIC_TArray_bool FunctionsContainer{Functions};
SGCoreImpl_FSGSenseGloveInfoImpl_ctor_DeviceId_HardwareVersion_FirmwareVersion_SubFirmwareVersion_bRightHanded_NumberOfSensors_ImuCorrection_StartPositions_StartRotations_GloveLengths_Functions(
&OutSenseGloveInfoImplContainer,
&DeviceIdContainer, &HardwareVersionContainer, FirmwareVersion, SubFirmwareVersion,
bRightHanded, NumberOfSensors, &ImuCorrectionContainer,
&StartPositionsContainer, &StartRotationsContainer,
&GloveLengthsContainer, &FunctionsContainer);
Pimpl->SenseGloveInfoImpl = MoveTemp(OutSenseGloveInfoImplContainer.SenseGloveInfoImpl);
Pimpl->SyncUProperties();
}
USGSenseGloveInfo::USGSenseGloveInfo(
const FString& DeviceId,
const FString& HardwareVersion, const int32 FirmwareVersion, const int32 SubFirmwareVersion,
@@ -256,6 +344,34 @@ USGSenseGloveInfo::USGSenseGloveInfo(
Pimpl->SyncUProperties();
}
USGSenseGloveInfo::USGSenseGloveInfo(
const FString& DeviceId,
const FString& HardwareVersion, const int32 FirmwareVersion, const int32 SubFirmwareVersion,
const bool bRightHanded, const int32 NumberOfSensors, const FRotator& ImuCorrection,
const TArray<FVector>& StartPositions, const TArray<FRotator>& StartRotations,
const TArray<FSGVectorArray>& GloveLengths, const TArray<bool>& Functions)
{
FSGIC_FSGSenseGloveInfoImpl OutSenseGloveInfoImplContainer;
FSGIC_FString DeviceIdContainer{DeviceId};
FSGIC_FString HardwareVersionContainer{HardwareVersion};
FSGIC_FQuat ImuCorrectionContainer{ImuCorrection.Quaternion()};
FSGIC_TArray_FVector StartPositionsContainer{StartPositions};
FSGIC_TArray_FQuat StartRotationsContainer{FSGArrayUtils::RotatorsToQuats(StartRotations)};
FSGIC_TArray_TArray_FVector GloveLengthsContainer{
FSGArrayUtils::FromBPNestedArray<FVector, FSGVectorArray, &FSGVectorArray::VectorArray>(GloveLengths)
};
FSGIC_TArray_bool FunctionsContainer{Functions};
SGCoreImpl_FSGSenseGloveInfoImpl_ctor_DeviceId_HardwareVersion_FirmwareVersion_SubFirmwareVersion_bRightHanded_NumberOfSensors_ImuCorrection_StartPositions_StartRotations_GloveLengths_Functions(
&OutSenseGloveInfoImplContainer,
&DeviceIdContainer, &HardwareVersionContainer, FirmwareVersion, SubFirmwareVersion,
bRightHanded, NumberOfSensors, &ImuCorrectionContainer,
&StartPositionsContainer, &StartRotationsContainer,
&GloveLengthsContainer, &FunctionsContainer);
Pimpl->SenseGloveInfoImpl = MoveTemp(OutSenseGloveInfoImplContainer.SenseGloveInfoImpl);
Pimpl->SyncUProperties();
}
USGSenseGloveInfo::USGSenseGloveInfo(const FSGSenseGloveInfoImpl& SenseGloveInfoImpl)
:
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
@@ -330,7 +446,7 @@ int32 USGSenseGloveInfo::GetNumberOfSensors() const
return SGCoreImpl_FSGSenseGloveInfoImpl_GetNumberOfSensors(&InstanceContainer);
}
FQuat USGSenseGloveInfo::GetImuCorrection() const
FQuat USGSenseGloveInfo::GetImuCorrectionQ() const
{
FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
FSGIC_FQuat OutCorrectionContainer;
@@ -338,6 +454,14 @@ FQuat USGSenseGloveInfo::GetImuCorrection() const
return MoveTemp(OutCorrectionContainer.Quat);
}
FRotator USGSenseGloveInfo::GetImuCorrection() const
{
FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
FSGIC_FQuat OutCorrectionContainer;
SGCoreImpl_FSGSenseGloveInfoImpl_GetImuCorrection(&InstanceContainer, &OutCorrectionContainer);
return OutCorrectionContainer.Quat.Rotator();
}
TArray<FVector> USGSenseGloveInfo::GetStartPositions() const
{
FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
@@ -346,7 +470,7 @@ TArray<FVector> USGSenseGloveInfo::GetStartPositions() const
return MoveTemp(OutPositionsContainer.Array);
}
TArray<FQuat> USGSenseGloveInfo::GetStartRotations() const
TArray<FQuat> USGSenseGloveInfo::GetStartRotationsQ() const
{
FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
FSGIC_TArray_FQuat OutRotationsContainer;
@@ -354,6 +478,14 @@ TArray<FQuat> USGSenseGloveInfo::GetStartRotations() const
return MoveTemp(OutRotationsContainer.Array);
}
TArray<FRotator> USGSenseGloveInfo::GetStartRotations() const
{
FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
FSGIC_TArray_FQuat OutRotationsContainer;
SGCoreImpl_FSGSenseGloveInfoImpl_GetStartRotations(&InstanceContainer, &OutRotationsContainer);
return FSGArrayUtils::QuatsToRotators(OutRotationsContainer.Array);
}
TArray<TArray<FVector>> USGSenseGloveInfo::GetGloveLengths() const
{
FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
@@ -381,7 +513,7 @@ FVector USGSenseGloveInfo::GetStartPosition(const ESGFinger Finger) const
return MoveTemp(OutPositionContainer.Vector);
}
FQuat USGSenseGloveInfo::GetStartRotation(const ESGFinger Finger) const
FQuat USGSenseGloveInfo::GetStartRotationQ(const ESGFinger Finger) const
{
Pimpl->SyncImplObject();
@@ -392,6 +524,17 @@ FQuat USGSenseGloveInfo::GetStartRotation(const ESGFinger Finger) const
return MoveTemp(OutRotationContainer.Quat);
}
FRotator USGSenseGloveInfo::GetStartRotation(const ESGFinger Finger) const
{
Pimpl->SyncImplObject();
FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
FSGIC_FQuat OutRotationContainer;
FSGIC_ESGFinger FingerContainer{Finger};
SGCoreImpl_FSGSenseGloveInfoImpl_GetStartRotation(&InstanceContainer, &OutRotationContainer, &FingerContainer);
return OutRotationContainer.Quat.Rotator();
}
TArray<FVector> USGSenseGloveInfo::GetGloveLengths(const ESGFinger Finger) const
{
Pimpl->SyncImplObject();
Source/SenseGloveCore/Private/SGCore/SGSenseGlovePose.cpp
+104 -2
View File
@@ -115,6 +115,22 @@ USGSenseGlovePose* USGSenseGlovePose::NewSenseGlovePose(UObject* Outer, const bo
return NewSenseGlovePose(Outer, MoveTemp(OutSenseGlovePoseImplContainer.SenseGlovePoseImpl));
}
USGSenseGlovePose* USGSenseGlovePose::NewSenseGlovePose(UObject* Outer, const bool bRightHanded,
const TArray<TArray<FVector>>& JointPositions,
const TArray<TArray<FRotator>>& JointRotations,
const TArray<TArray<FVector>>& GloveAngles)
{
FSGIC_FSGSenseGlovePoseImpl OutSenseGlovePoseImplContainer;
FSGIC_TArray_TArray_FVector JointPositionsContainer{JointPositions};
FSGIC_TArray_TArray_FQuat JointRotationsContainer{FSGArrayUtils::RotatorsToQuats(JointRotations)};
FSGIC_TArray_TArray_FVector GloveAnglesContainer{GloveAngles};
SGCoreImpl_FSGSenseGlovePoseImpl_ctor_bRightHanded_JointPositions_JointRotations_GloveAngles(
&OutSenseGlovePoseImplContainer, bRightHanded, &JointPositionsContainer,
&JointRotationsContainer, &GloveAnglesContainer);
return NewSenseGlovePose(Outer, MoveTemp(OutSenseGlovePoseImplContainer.SenseGlovePoseImpl));
}
USGSenseGlovePose* USGSenseGlovePose::NewSenseGlovePose(UObject* Outer, const bool bRightHanded,
const TArray<FSGVectorArray>& JointPositions,
const TArray<FSGQuatArray>& JointRotations,
@@ -137,6 +153,28 @@ USGSenseGlovePose* USGSenseGlovePose::NewSenseGlovePose(UObject* Outer, const bo
return NewSenseGlovePose(Outer, MoveTemp(OutSenseGlovePoseImplContainer.SenseGlovePoseImpl));
}
USGSenseGlovePose* USGSenseGlovePose::NewSenseGlovePose(UObject* Outer, const bool bRightHanded,
const TArray<FSGVectorArray>& JointPositions,
const TArray<FSGRotatorArray>& JointRotations,
const TArray<FSGVectorArray>& GloveAngles)
{
FSGIC_FSGSenseGlovePoseImpl OutSenseGlovePoseImplContainer;
FSGIC_TArray_TArray_FVector JointPositionsContainer{
FSGArrayUtils::FromBPNestedArray<FVector, FSGVectorArray, &FSGVectorArray::VectorArray>(JointPositions)
};
FSGIC_TArray_TArray_FQuat JointRotationsContainer{
FSGArrayUtils::RotatorsToQuats<FSGRotatorArray, &FSGRotatorArray::RotatorArray>(JointRotations)
};
FSGIC_TArray_TArray_FVector GloveAnglesContainer{
FSGArrayUtils::FromBPNestedArray<FVector, FSGVectorArray, &FSGVectorArray::VectorArray>(GloveAngles)
};
SGCoreImpl_FSGSenseGlovePoseImpl_ctor_bRightHanded_JointPositions_JointRotations_GloveAngles(
&OutSenseGlovePoseImplContainer, bRightHanded, &JointPositionsContainer,
&JointRotationsContainer, &GloveAnglesContainer);
return NewSenseGlovePose(Outer, MoveTemp(OutSenseGlovePoseImplContainer.SenseGlovePoseImpl));
}
USGSenseGlovePose* USGSenseGlovePose::IdlePose(UObject* Outer, const USGSenseGloveInfo* GloveInfo)
{
FSGIC_FSGSenseGlovePoseImpl OutSenseGlovePoseImplContainer;
@@ -193,6 +231,29 @@ USGSenseGlovePose::USGSenseGlovePose(const bool bRightHanded,
Pimpl->SyncUProperties();
}
USGSenseGlovePose::USGSenseGlovePose(const bool bRightHanded,
const TArray<TArray<FVector>>& JointPositions,
const TArray<TArray<FRotator>>& JointRotations,
const TArray<TArray<FVector>>& GloveAngles)
:
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
#else
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
#endif /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 ) */
{
FSGIC_FSGSenseGlovePoseImpl OutSenseGlovePoseImplContainer;
FSGIC_TArray_TArray_FVector JointPositionsContainer{JointPositions};
FSGIC_TArray_TArray_FQuat JointRotationsContainer{FSGArrayUtils::RotatorsToQuats(JointRotations)};
FSGIC_TArray_TArray_FVector GloveAnglesContainer{GloveAngles};
SGCoreImpl_FSGSenseGlovePoseImpl_ctor_bRightHanded_JointPositions_JointRotations_GloveAngles(
&OutSenseGlovePoseImplContainer, bRightHanded, &JointPositionsContainer,
&JointRotationsContainer, &GloveAnglesContainer);
Pimpl->SenseGlovePoseImpl = MoveTemp(OutSenseGlovePoseImplContainer.SenseGlovePoseImpl);
Pimpl->SyncUProperties();
}
USGSenseGlovePose::USGSenseGlovePose(const bool bRightHanded,
const TArray<FSGVectorArray>& JointPositions,
const TArray<FSGQuatArray>& JointRotations,
@@ -216,6 +277,29 @@ USGSenseGlovePose::USGSenseGlovePose(const bool bRightHanded,
Pimpl->SyncUProperties();
}
USGSenseGlovePose::USGSenseGlovePose(const bool bRightHanded,
const TArray<FSGVectorArray>& JointPositions,
const TArray<FSGRotatorArray>& JointRotations,
const TArray<FSGVectorArray>& GloveAngles)
{
FSGIC_FSGSenseGlovePoseImpl OutSenseGlovePoseImplContainer;
FSGIC_TArray_TArray_FVector JointPositionsContainer{
FSGArrayUtils::FromBPNestedArray<FVector, FSGVectorArray, &FSGVectorArray::VectorArray>(JointPositions)
};
FSGIC_TArray_TArray_FQuat JointRotationsContainer{
FSGArrayUtils::RotatorsToQuats<FSGRotatorArray, &FSGRotatorArray::RotatorArray>(JointRotations)
};
FSGIC_TArray_TArray_FVector GloveAnglesContainer{
FSGArrayUtils::FromBPNestedArray<FVector, FSGVectorArray, &FSGVectorArray::VectorArray>(GloveAngles)
};
SGCoreImpl_FSGSenseGlovePoseImpl_ctor_bRightHanded_JointPositions_JointRotations_GloveAngles(
&OutSenseGlovePoseImplContainer, bRightHanded, &JointPositionsContainer,
&JointRotationsContainer, &GloveAnglesContainer);
Pimpl->SenseGlovePoseImpl = MoveTemp(OutSenseGlovePoseImplContainer.SenseGlovePoseImpl);
Pimpl->SyncUProperties();
}
USGSenseGlovePose::USGSenseGlovePose(const FSGSenseGlovePoseImpl& SenseGlovePoseImpl)
:
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
@@ -258,7 +342,7 @@ TArray<TArray<FVector>> USGSenseGlovePose::GetJointPositions() const
return MoveTemp(OutPositionsContainer.Array);
}
TArray<TArray<FQuat>> USGSenseGlovePose::GetJointRotations() const
TArray<TArray<FQuat>> USGSenseGlovePose::GetJointRotationsQ() const
{
FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
FSGIC_TArray_TArray_FQuat OutRotationsContainer;
@@ -266,6 +350,14 @@ TArray<TArray<FQuat>> USGSenseGlovePose::GetJointRotations() const
return MoveTemp(OutRotationsContainer.Array);
}
TArray<TArray<FRotator>> USGSenseGlovePose::GetJointRotations() const
{
FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
FSGIC_TArray_TArray_FQuat OutRotationsContainer;
SGCoreImpl_FSGSenseGlovePoseImpl_GetJointRotations(&InstanceContainer, &OutRotationsContainer);
return FSGArrayUtils::QuatsToRotators(OutRotationsContainer.Array);
}
TArray<TArray<FVector>> USGSenseGlovePose::GetGloveAngles() const
{
FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
@@ -284,7 +376,7 @@ TArray<FVector> USGSenseGlovePose::GetThimblePositions() const
return MoveTemp(OutPositionsContainer.Array);
}
TArray<FQuat> USGSenseGlovePose::GetThimbleRotations() const
TArray<FQuat> USGSenseGlovePose::GetThimbleRotationsQ() const
{
Pimpl->SyncImplObject();
@@ -294,6 +386,16 @@ TArray<FQuat> USGSenseGlovePose::GetThimbleRotations() const
return MoveTemp(OutRotationsContainer.Array);
}
TArray<FRotator> USGSenseGlovePose::GetThimbleRotations() const
{
Pimpl->SyncImplObject();
FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
FSGIC_TArray_FQuat OutRotationsContainer;
SGCoreImpl_FSGSenseGlovePoseImpl_GetThimbleRotations(&InstanceContainer, &OutRotationsContainer);
return FSGArrayUtils::QuatsToRotators(OutRotationsContainer.Array);
}
TArray<FVector> USGSenseGlovePose::GetTotalGloveAngles() const
{
Pimpl->SyncImplObject();
Source/SenseGloveCore/Private/SGCore/SGSenseGloveSensorData.cpp
+71 -1
View File
@@ -112,6 +112,19 @@ USGSenseGloveSensorData* USGSenseGloveSensorData::NewSenseGloveSensorData(
return NewSenseGloveSensorData(Outer, MoveTemp(OutSenseGloveSensorDataImplContainer.SenseGloveSensorDataImpl));
}
USGSenseGloveSensorData* USGSenseGloveSensorData::NewSenseGloveSensorData(
UObject* Outer, const TArray<TArray<float>>& SensorAngles,
const FRotator& ImuRotation, const int32 ParsedValues, const bool bImuParsed)
{
FSGIC_FSGSenseGloveSensorDataImpl OutSenseGloveSensorDataImplContainer;
FSGIC_TArray_TArray_float SensorAnglesContainer{SensorAngles};
FSGIC_FQuat ImuRotationContainer{ImuRotation.Quaternion()};
SGCoreImpl_FSGSenseGloveSensorDataImpl_ctor_SensorAngles_ImuRotation_ParsedValues_bImuParsed(
&OutSenseGloveSensorDataImplContainer, &SensorAnglesContainer, &ImuRotationContainer, ParsedValues, bImuParsed);
return NewSenseGloveSensorData(Outer, MoveTemp(OutSenseGloveSensorDataImplContainer.SenseGloveSensorDataImpl));
}
USGSenseGloveSensorData* USGSenseGloveSensorData::NewSenseGloveSensorData(
UObject* Outer, const TArray<FSGFloatArray>& SensorAngles,
const FQuat& ImuRotation, const int32 ParsedValues, const bool bImuParsed)
@@ -127,6 +140,21 @@ USGSenseGloveSensorData* USGSenseGloveSensorData::NewSenseGloveSensorData(
return NewSenseGloveSensorData(Outer, MoveTemp(OutSenseGloveSensorDataImplContainer.SenseGloveSensorDataImpl));
}
USGSenseGloveSensorData* USGSenseGloveSensorData::NewSenseGloveSensorData(
UObject* Outer, const TArray<FSGFloatArray>& SensorAngles,
const FRotator& ImuRotation, const int32 ParsedValues, const bool bImuParsed)
{
FSGIC_FSGSenseGloveSensorDataImpl OutSenseGloveSensorDataImplContainer;
FSGIC_TArray_TArray_float SensorAnglesContainer{
FSGArrayUtils::FromBPNestedArray<float, FSGFloatArray, &FSGFloatArray::FloatArray>(SensorAngles)
};
FSGIC_FQuat ImuRotationContainer{ImuRotation.Quaternion()};
SGCoreImpl_FSGSenseGloveSensorDataImpl_ctor_SensorAngles_ImuRotation_ParsedValues_bImuParsed(
&OutSenseGloveSensorDataImplContainer, &SensorAnglesContainer, &ImuRotationContainer, ParsedValues, bImuParsed);
return NewSenseGloveSensorData(Outer, MoveTemp(OutSenseGloveSensorDataImplContainer.SenseGloveSensorDataImpl));
}
USGSenseGloveSensorData* USGSenseGloveSensorData::Empty(UObject* Outer)
{
FSGIC_FSGSenseGloveSensorDataImpl OutSenseGloveSensorDataImplContainer;
@@ -191,6 +219,25 @@ USGSenseGloveSensorData::USGSenseGloveSensorData(const TArray<TArray<float>>& Se
Pimpl->SyncUProperties();
}
USGSenseGloveSensorData::USGSenseGloveSensorData(const TArray<TArray<float>>& SensorAngles, const FRotator& ImuRotation,
const int32 ParsedValues, const bool bImuParsed)
:
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
#else
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
#endif /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 ) */
{
FSGIC_FSGSenseGloveSensorDataImpl OutSenseGloveSensorDataImplContainer;
FSGIC_TArray_TArray_float SensorAnglesContainer{SensorAngles};
FSGIC_FQuat ImuRotationContainer{ImuRotation.Quaternion()};
SGCoreImpl_FSGSenseGloveSensorDataImpl_ctor_SensorAngles_ImuRotation_ParsedValues_bImuParsed(
&OutSenseGloveSensorDataImplContainer, &SensorAnglesContainer, &ImuRotationContainer, ParsedValues, bImuParsed);
Pimpl->SenseGloveSensorDataImpl = MoveTemp(OutSenseGloveSensorDataImplContainer.SenseGloveSensorDataImpl);
Pimpl->SyncUProperties();
}
USGSenseGloveSensorData::USGSenseGloveSensorData(const TArray<FSGFloatArray>& SensorAngles, const FQuat& ImuRotation,
const int32 ParsedValues, const bool bImuParsed)
{
@@ -206,6 +253,21 @@ USGSenseGloveSensorData::USGSenseGloveSensorData(const TArray<FSGFloatArray>& Se
Pimpl->SyncUProperties();
}
USGSenseGloveSensorData::USGSenseGloveSensorData(const TArray<FSGFloatArray>& SensorAngles, const FRotator& ImuRotation,
const int32 ParsedValues, const bool bImuParsed)
{
FSGIC_FSGSenseGloveSensorDataImpl OutSenseGloveSensorDataImplContainer;
FSGIC_TArray_TArray_float SensorAnglesContainer{
FSGArrayUtils::FromBPNestedArray<float, FSGFloatArray, &FSGFloatArray::FloatArray>(SensorAngles)
};
FSGIC_FQuat ImuRotationContainer{ImuRotation.Quaternion()};
SGCoreImpl_FSGSenseGloveSensorDataImpl_ctor_SensorAngles_ImuRotation_ParsedValues_bImuParsed(
&OutSenseGloveSensorDataImplContainer, &SensorAnglesContainer, &ImuRotationContainer, ParsedValues, bImuParsed);
Pimpl->SenseGloveSensorDataImpl = MoveTemp(OutSenseGloveSensorDataImplContainer.SenseGloveSensorDataImpl);
Pimpl->SyncUProperties();
}
USGSenseGloveSensorData::USGSenseGloveSensorData(const FSGSenseGloveSensorDataImpl& SenseGloveSensorDataImpl)
:
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 )
@@ -242,7 +304,7 @@ TArray<TArray<float>> USGSenseGloveSensorData::GetSensorAngles() const
return MoveTemp(OutAnglesContainer.Array);
}
FQuat USGSenseGloveSensorData::GetImuRotation() const
FQuat USGSenseGloveSensorData::GetImuRotationQ() const
{
FSGIC_FSGSenseGloveSensorDataImpl InstanceContainer{ToSenseGloveSensorDataImpl()};
FSGIC_FQuat OutRotationContainer;
@@ -250,6 +312,14 @@ FQuat USGSenseGloveSensorData::GetImuRotation() const
return MoveTemp(OutRotationContainer.Quat);
}
FRotator USGSenseGloveSensorData::GetImuRotation() const
{
FSGIC_FSGSenseGloveSensorDataImpl InstanceContainer{ToSenseGloveSensorDataImpl()};
FSGIC_FQuat OutRotationContainer;
SGCoreImpl_FSGSenseGloveSensorDataImpl_GetImuRotation(&InstanceContainer, &OutRotationContainer);
return OutRotationContainer.Quat.Rotator();
}
int32 USGSenseGloveSensorData::GetParsedValues() const
{
FSGIC_FSGSenseGloveSensorDataImpl InstanceContainer{ToSenseGloveSensorDataImpl()};
Source/SenseGloveCore/Private/SGCore/SGSenseGloveVars.cpp
+23 -5
View File
@@ -72,7 +72,7 @@ TArray<FVector> FSGSenseGloveVars::GetStartPositions(const FString& HardwareVers
return MoveTemp(OutPositionsContainer.Array);
}
TArray<FQuat> FSGSenseGloveVars::GetStartRotations(const FString& HardwareVersion, const bool bRightHanded)
TArray<FQuat> FSGSenseGloveVars::GetStartRotationsQ(const FString& HardwareVersion, const bool bRightHanded)
{
FSGIC_TArray_FQuat OutRotationsContainer;
FSGIC_FString HardwareVersionContainer{HardwareVersion};
@@ -80,6 +80,14 @@ TArray<FQuat> FSGSenseGloveVars::GetStartRotations(const FString& HardwareVersio
return MoveTemp(OutRotationsContainer.Array);
}
TArray<FRotator> FSGSenseGloveVars::GetStartRotations(const FString& HardwareVersion, const bool bRightHanded)
{
FSGIC_TArray_FQuat OutRotationsContainer;
FSGIC_FString HardwareVersionContainer{HardwareVersion};
SGCoreImpl_FSGSenseGloveVarsImpl_GetStartRotations(&OutRotationsContainer, &HardwareVersionContainer, bRightHanded);
return FSGArrayUtils::QuatsToRotators(OutRotationsContainer.Array);
}
TArray<TArray<FVector>> FSGSenseGloveVars::GetGloveLengths(const FString& HardwareVersion)
{
FSGIC_TArray_TArray_FVector OutLengthsContainer;
@@ -100,8 +108,8 @@ int32 FSGSenseGloveVars::GetSensors(const FString& HardwareVersion)
return SGCoreImpl_FSGSenseGloveVarsImpl_GetSensors(&HardwareVersionContainer);
}
FQuat FSGSenseGloveVars::GetImuCorrection(const FString& HardwareVersion, const int32 FirmwareVersion,
const int32 SubFirmwareVersion)
FQuat FSGSenseGloveVars::GetImuCorrectionQ(const FString& HardwareVersion,
const int32 FirmwareVersion, const int32 SubFirmwareVersion)
{
FSGIC_FQuat OutCorrectionContainer;
FSGIC_FString HardwareVersionContainer{HardwareVersion};
@@ -110,8 +118,18 @@ FQuat FSGSenseGloveVars::GetImuCorrection(const FString& HardwareVersion, const
return MoveTemp(OutCorrectionContainer.Quat);
}
TArray<bool> FSGSenseGloveVars::GetFunctions(const FString& HardwareVersion, const int32 FirmwareVersion,
const int32 SubFirmwareVersion)
FRotator FSGSenseGloveVars::GetImuCorrection(const FString& HardwareVersion,
const int32 FirmwareVersion, const int32 SubFirmwareVersion)
{
FSGIC_FQuat OutCorrectionContainer;
FSGIC_FString HardwareVersionContainer{HardwareVersion};
SGCoreImpl_FSGSenseGloveVarsImpl_GetImuCorrection(&OutCorrectionContainer,
&HardwareVersionContainer, FirmwareVersion, SubFirmwareVersion);
return OutCorrectionContainer.Quat.Rotator();
}
TArray<bool> FSGSenseGloveVars::GetFunctions(const FString& HardwareVersion,
const int32 FirmwareVersion, const int32 SubFirmwareVersion)
{
FSGIC_TArray_bool OutFunctionsContainer;
FSGIC_FString HardwareVersionContainer{HardwareVersion};
Source/SenseGloveCore/Private/SGCore/SGTracking.cpp
+165 -11
View File
@@ -43,6 +43,7 @@
#include "SGInterop/SGIC_FVector.h"
#include "SGInterop/SGIC_TArray_FQuat.h"
#include "SGInterop/SGIC_TArray_FVector.h"
#include "SGUtils/SGArrayUtils.h"
void FSGTracking::CalculateLocation(const FVector& TrackedPosition, const FQuat& TrackedRotation,
const FVector& PositionOffset, const FQuat& RotationOffset,
@@ -64,6 +65,26 @@ void FSGTracking::CalculateLocation(const FVector& TrackedPosition, const FQuat&
OutNewRotation = MoveTemp(OutNewRotationContainer.Quat);
}
void FSGTracking::CalculateLocation(const FVector& TrackedPosition, const FRotator& TrackedRotation,
const FVector& PositionOffset, const FRotator& RotationOffset,
FVector& OutNewPosition, FRotator& OutNewRotation)
{
FSGIC_FVector TrackedPositionContainer{TrackedPosition};
FSGIC_FQuat TrackedRotationContainer{TrackedRotation.Quaternion()};
FSGIC_FVector PositionOffsetContainer{PositionOffset};
FSGIC_FQuat RotationOffsetContainer{RotationOffset.Quaternion()};
FSGIC_FVector OutNewPositionContainer;
FSGIC_FQuat OutNewRotationContainer;
SGCoreImpl_FSGTrackingImpl_CalculateLocation(
&TrackedPositionContainer, &TrackedRotationContainer,
&PositionOffsetContainer, &RotationOffsetContainer,
&OutNewPositionContainer, &OutNewRotationContainer);
OutNewPosition = MoveTemp(OutNewPositionContainer.Vector);
OutNewRotation = OutNewRotationContainer.Quat.Rotator();
}
TArray<FVector> FSGTracking::GetSenseGloveFingerToGlovePositionOrigin()
{
FSGIC_TArray_FVector OutOriginContainer;
@@ -71,13 +92,20 @@ TArray<FVector> FSGTracking::GetSenseGloveFingerToGlovePositionOrigin()
return MoveTemp(OutOriginContainer.Array);
}
TArray<FQuat> FSGTracking::GetSenseGloveFingerToGloveRotationOrigin()
TArray<FQuat> FSGTracking::GetSenseGloveFingerToGloveRotationOriginQ()
{
FSGIC_TArray_FQuat OutOriginContainer;
SGCoreImpl_FSGTrackingImpl_GetSenseGloveFingerToGloveRotationOrigin(&OutOriginContainer);
return MoveTemp(OutOriginContainer.Array);
}
TArray<FRotator> FSGTracking::GetSenseGloveFingerToGloveRotationOrigin()
{
FSGIC_TArray_FQuat OutOriginContainer;
SGCoreImpl_FSGTrackingImpl_GetSenseGloveFingerToGloveRotationOrigin(&OutOriginContainer);
return FSGArrayUtils::QuatsToRotators(OutOriginContainer.Array);
}
FVector FSGTracking::GetSenseGloveWristPositionOffset()
{
FSGIC_FVector OutOffsetContainer;
@@ -85,13 +113,20 @@ FVector FSGTracking::GetSenseGloveWristPositionOffset()
return MoveTemp(OutOffsetContainer.Vector);
}
FQuat FSGTracking::GetSenseGloveWristRotationOffset()
FQuat FSGTracking::GetSenseGloveWristRotationOffsetQ()
{
FSGIC_FQuat OutOffsetContainer;
SGCoreImpl_FSGTrackingImpl_GetSenseGloveWristRotationOffset(&OutOffsetContainer);
return MoveTemp(OutOffsetContainer.Quat);
}
FRotator FSGTracking::GetSenseGloveWristRotationOffset()
{
FSGIC_FQuat OutOffsetContainer;
SGCoreImpl_FSGTrackingImpl_GetSenseGloveWristRotationOffset(&OutOffsetContainer);
return OutOffsetContainer.Quat.Rotator();
}
void FSGTracking::GetSenseGloveMountOffset(const bool bRightHanded, const ESGFinger ToFinger,
FVector& OutIPosition, FQuat& OutIRotation)
{
@@ -106,6 +141,20 @@ void FSGTracking::GetSenseGloveMountOffset(const bool bRightHanded, const ESGFin
OutIRotation = MoveTemp(OutIRotationContainer.Quat);
}
void FSGTracking::GetSenseGloveMountOffset(const bool bRightHanded, const ESGFinger ToFinger,
FVector& OutIPosition, FRotator& OutIRotation)
{
FSGIC_ESGFinger ToFingerContainer{ToFinger};
FSGIC_FVector OutIPositionContainer;
FSGIC_FQuat OutIRotationContainer;
SGCoreImpl_FSGTrackingImpl_GetSenseGloveMountOffset(bRightHanded, &ToFingerContainer,
&OutIPositionContainer, &OutIRotationContainer);
OutIPosition = MoveTemp(OutIPositionContainer.Vector);
OutIRotation = OutIRotationContainer.Quat.Rotator();
}
void FSGTracking::GetSenseGloveTrackerMountOffset(const ESGPositionalTrackingHardware Hardware, const bool bRightHanded,
FVector& OutPositionOffset, FQuat& OutRotationOffset)
{
@@ -121,6 +170,21 @@ void FSGTracking::GetSenseGloveTrackerMountOffset(const ESGPositionalTrackingHar
OutRotationOffset = MoveTemp(OutRotationOffsetContainer.Quat);
}
void FSGTracking::GetSenseGloveTrackerMountOffset(const ESGPositionalTrackingHardware Hardware, const bool bRightHanded,
FVector& OutPositionOffset, FRotator& OutRotationOffset)
{
FSGIC_ESGPositionalTrackingHardware HardwareContainer;
FSGIC_FVector OutPositionOffsetContainer;
FSGIC_FQuat OutRotationOffsetContainer;
SGCoreImpl_FSGTrackingImpl_GetSenseGloveTrackerMountOffset(&HardwareContainer, bRightHanded,
&OutPositionOffsetContainer,
&OutRotationOffsetContainer);
OutPositionOffset = MoveTemp(OutPositionOffsetContainer.Vector);
OutRotationOffset = OutRotationOffsetContainer.Quat.Rotator();
}
FVector FSGTracking::GetSenseGloveViveToAttachPosition()
{
FSGIC_FVector OutPositionContainer;
@@ -128,13 +192,20 @@ FVector FSGTracking::GetSenseGloveViveToAttachPosition()
return MoveTemp(OutPositionContainer.Vector);
}
FQuat FSGTracking::GetSenseGloveViveToAttachRotation()
FQuat FSGTracking::GetSenseGloveViveToAttachRotationQ()
{
FSGIC_FQuat OutRotationContainer;
SGCoreImpl_FSGTrackingImpl_GetSenseGloveViveToAttachRotation(&OutRotationContainer);
return MoveTemp(OutRotationContainer.Quat);
}
FRotator FSGTracking::GetSenseGloveViveToAttachRotation()
{
FSGIC_FQuat OutRotationContainer;
SGCoreImpl_FSGTrackingImpl_GetSenseGloveViveToAttachRotation(&OutRotationContainer);
return OutRotationContainer.Quat.Rotator();
}
FVector FSGTracking::GetSenseGloveOculusTouchToAttachPosition()
{
FSGIC_FVector OutPositionContainer;
@@ -142,13 +213,20 @@ FVector FSGTracking::GetSenseGloveOculusTouchToAttachPosition()
return MoveTemp(OutPositionContainer.Vector);
}
FQuat FSGTracking::GetSenseGloveOculusTouchToAttachRotation()
FQuat FSGTracking::GetSenseGloveOculusTouchToAttachRotationQ()
{
FSGIC_FQuat OutRotationContainer;
SGCoreImpl_FSGTrackingImpl_GetSenseGloveOculusTouchToAttachRotation(&OutRotationContainer);
return MoveTemp(OutRotationContainer.Quat);
}
FRotator FSGTracking::GetSenseGloveOculusTouchToAttachRotation()
{
FSGIC_FQuat OutRotationContainer;
SGCoreImpl_FSGTrackingImpl_GetSenseGloveOculusTouchToAttachRotation(&OutRotationContainer);
return OutRotationContainer.Quat.Rotator();
}
FVector FSGTracking::GetNovaToWristPositionOffset()
{
FSGIC_FVector OutOffsetContainer;
@@ -156,13 +234,20 @@ FVector FSGTracking::GetNovaToWristPositionOffset()
return MoveTemp(OutOffsetContainer.Vector);
}
FQuat FSGTracking::GetNovaToWristRotationOffset()
FQuat FSGTracking::GetNovaToWristRotationOffsetQ()
{
FSGIC_FQuat OutOffsetContainer;
SGCoreImpl_FSGTrackingImpl_GetNovaToWristRotationOffset(&OutOffsetContainer);
return MoveTemp(OutOffsetContainer.Quat);
}
FRotator FSGTracking::GetNovaToWristRotationOffset()
{
FSGIC_FQuat OutOffsetContainer;
SGCoreImpl_FSGTrackingImpl_GetNovaToWristRotationOffset(&OutOffsetContainer);
return OutOffsetContainer.Quat.Rotator();
}
void FSGTracking::GetNovaGloveWristOffset(const bool bRightHanded, FVector& OutPositionOffset, FQuat& OutRotationOffset)
{
FSGIC_FVector OutPositionOffsetContainer;
@@ -175,6 +260,19 @@ void FSGTracking::GetNovaGloveWristOffset(const bool bRightHanded, FVector& OutP
OutRotationOffset = MoveTemp(OutRotationOffsetContainer.Quat);
}
void FSGTracking::GetNovaGloveWristOffset(const bool bRightHanded,
FVector& OutPositionOffset, FRotator& OutRotationOffset)
{
FSGIC_FVector OutPositionOffsetContainer;
FSGIC_FQuat OutRotationOffsetContainer;
SGCoreImpl_FSGTrackingImpl_GetNovaGloveWristOffset(bRightHanded,
&OutPositionOffsetContainer, &OutRotationOffsetContainer);
OutPositionOffset = MoveTemp(OutPositionOffsetContainer.Vector);
OutRotationOffset = OutRotationOffsetContainer.Quat.Rotator();
}
FVector FSGTracking::GetRightNovaViveToAttachPosition()
{
FSGIC_FVector OutPositionContainer;
@@ -182,13 +280,20 @@ FVector FSGTracking::GetRightNovaViveToAttachPosition()
return MoveTemp(OutPositionContainer.Vector);
}
FQuat FSGTracking::GetRightNovaViveToAttachRotation()
FQuat FSGTracking::GetRightNovaViveToAttachRotationQ()
{
FSGIC_FQuat OutRotationContainer;
SGCoreImpl_FSGTrackingImpl_GetRightNovaViveToAttachRotation(&OutRotationContainer);
return MoveTemp(OutRotationContainer.Quat);
}
FRotator FSGTracking::GetRightNovaViveToAttachRotation()
{
FSGIC_FQuat OutRotationContainer;
SGCoreImpl_FSGTrackingImpl_GetRightNovaViveToAttachRotation(&OutRotationContainer);
return OutRotationContainer.Quat.Rotator();
}
FVector FSGTracking::GetLeftNovaViveToAttachPosition()
{
FSGIC_FVector OutPositionContainer;
@@ -196,13 +301,20 @@ FVector FSGTracking::GetLeftNovaViveToAttachPosition()
return MoveTemp(OutPositionContainer.Vector);
}
FQuat FSGTracking::GetLeftNovaViveToAttachRotation()
FQuat FSGTracking::GetLeftNovaViveToAttachRotationQ()
{
FSGIC_FQuat OutRotationContainer;
SGCoreImpl_FSGTrackingImpl_GetLeftNovaViveToAttachRotation(&OutRotationContainer);
return MoveTemp(OutRotationContainer.Quat);
}
FRotator FSGTracking::GetLeftNovaViveToAttachRotation()
{
FSGIC_FQuat OutRotationContainer;
SGCoreImpl_FSGTrackingImpl_GetLeftNovaViveToAttachRotation(&OutRotationContainer);
return OutRotationContainer.Quat.Rotator();
}
FVector FSGTracking::GetRightNovaQuest2ToAttachPosition()
{
FSGIC_FVector OutPositionContainer;
@@ -210,13 +322,20 @@ FVector FSGTracking::GetRightNovaQuest2ToAttachPosition()
return MoveTemp(OutPositionContainer.Vector);
}
FQuat FSGTracking::GetRightNovaQuest2ToAttachRotation()
FQuat FSGTracking::GetRightNovaQuest2ToAttachRotationQ()
{
FSGIC_FQuat OutRotationContainer;
SGCoreImpl_FSGTrackingImpl_GetRightNovaQuest2ToAttachRotation(&OutRotationContainer);
return MoveTemp(OutRotationContainer.Quat);
}
FRotator FSGTracking::GetRightNovaQuest2ToAttachRotation()
{
FSGIC_FQuat OutRotationContainer;
SGCoreImpl_FSGTrackingImpl_GetRightNovaQuest2ToAttachRotation(&OutRotationContainer);
return OutRotationContainer.Quat.Rotator();
}
FVector FSGTracking::GetLeftNovaQuest2ToAttachPosition()
{
FSGIC_FVector OutPositionContainer;
@@ -224,13 +343,20 @@ FVector FSGTracking::GetLeftNovaQuest2ToAttachPosition()
return MoveTemp(OutPositionContainer.Vector);
}
FQuat FSGTracking::GetLeftNovaQuest2ToAttachRotation()
FQuat FSGTracking::GetLeftNovaQuest2ToAttachRotationQ()
{
FSGIC_FQuat OutRotationContainer;
SGCoreImpl_FSGTrackingImpl_GetLeftNovaQuest2ToAttachRotation(&OutRotationContainer);
return MoveTemp(OutRotationContainer.Quat);
}
FRotator FSGTracking::GetLeftNovaQuest2ToAttachRotation()
{
FSGIC_FQuat OutRotationContainer;
SGCoreImpl_FSGTrackingImpl_GetLeftNovaQuest2ToAttachRotation(&OutRotationContainer);
return OutRotationContainer.Quat.Rotator();
}
FVector FSGTracking::GetRightNovaPico2ToAttachPosition()
{
FSGIC_FVector OutPositionContainer;
@@ -238,20 +364,34 @@ FVector FSGTracking::GetRightNovaPico2ToAttachPosition()
return MoveTemp(OutPositionContainer.Vector);
}
FQuat FSGTracking::GetRightNovaPico2ToAttachRotation()
FQuat FSGTracking::GetRightNovaPico2ToAttachRotationQ()
{
FSGIC_FQuat OutRotationContainer;
SGCoreImpl_FSGTrackingImpl_GetRightNovaPico2ToAttachRotation(&OutRotationContainer);
return MoveTemp(OutRotationContainer.Quat);
}
FQuat FSGTracking::GetLeftNovaPico2ToAttachRotation()
FRotator FSGTracking::GetRightNovaPico2ToAttachRotation()
{
FSGIC_FQuat OutRotationContainer;
SGCoreImpl_FSGTrackingImpl_GetRightNovaPico2ToAttachRotation(&OutRotationContainer);
return OutRotationContainer.Quat.Rotator();
}
FQuat FSGTracking::GetLeftNovaPico2ToAttachRotationQ()
{
FSGIC_FQuat OutRotationContainer;
SGCoreImpl_FSGTrackingImpl_GetLeftNovaPico2ToAttachRotation(&OutRotationContainer);
return MoveTemp(OutRotationContainer.Quat);
}
FRotator FSGTracking::GetLeftNovaPico2ToAttachRotation()
{
FSGIC_FQuat OutRotationContainer;
SGCoreImpl_FSGTrackingImpl_GetLeftNovaPico2ToAttachRotation(&OutRotationContainer);
return OutRotationContainer.Quat.Rotator();
}
void FSGTracking::GetNovaGloveTrackerOffset(const ESGPositionalTrackingHardware Hardware, const bool bRightHanded,
FVector& OutPositionOffset, FQuat& OutRotationOffset)
{
@@ -266,6 +406,20 @@ void FSGTracking::GetNovaGloveTrackerOffset(const ESGPositionalTrackingHardware
OutRotationOffset = MoveTemp(OutRotationOffsetContainer.Quat);
}
void FSGTracking::GetNovaGloveTrackerOffset(const ESGPositionalTrackingHardware Hardware, const bool bRightHanded,
FVector& OutPositionOffset, FRotator& OutRotationOffset)
{
FSGIC_ESGPositionalTrackingHardware HardwareContainer{Hardware};
FSGIC_FVector OutPositionOffsetContainer;
FSGIC_FQuat OutRotationOffsetContainer;
SGCoreImpl_FSGTrackingImpl_GetNovaGloveTrackerOffset(&HardwareContainer, bRightHanded,
&OutPositionOffsetContainer, &OutRotationOffsetContainer);
OutPositionOffset = MoveTemp(OutPositionOffsetContainer.Vector);
OutRotationOffset = OutRotationOffsetContainer.Quat.Rotator();
}
FString FSGTracking::ToString(const ESGPositionalTrackingHardware Hardware)
{
FSGIC_FString OutStringContainer;