implement proper mm/cm conversions

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGBasicHandModelImpl.cpp

@@ -93,7 +93,7 @@ FSGBasicHandModelImpl FSGBasicHandModelImpl::Deserialize(const FString& Serializ
 const TArray<TArray<float>>& FSGBasicHandModelImpl::GetBaseFingerLengths()
 {
     static const TArray<TArray<float>> BaseFingerLengths{
-        FSGArrayUtils::FromStdVector<float>(
+        FSGArrayUtils::FromMillimeters(
             FSGBasicHandModelImpl::FBasicHandModelType::GetBaseFingerLengths())
     };
     return BaseFingerLengths;
@@ -102,7 +102,7 @@ const TArray<TArray<float>>& FSGBasicHandModelImpl::GetBaseFingerLengths()
 const TArray<FVector>& FSGBasicHandModelImpl::GetBaseJointPositions()
 {
     static const TArray<FVector> BaseJointPositions{
-        FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
+        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             FBasicHandModelType::GetBaseJointPositions())
     };
     return BaseJointPositions;
@@ -137,11 +137,12 @@ FSGBasicHandModelImpl::FSGBasicHandModelImpl(bool bRightHanded, const TArray<TAr
 #endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 ) */
 {
     std::vector<std::vector<float>> LengthsVector{
-        FSGArrayUtils::ToStdVector<float>(Lengths)
+        FSGArrayUtils::ToMillimeters(Lengths)
     };
 
-    std::vector<FSGVect3DImpl::FVect3DType> StartPositionsVector{FSGArrayUtils::ToStdVector<
-        FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(StartPositions)};
+    std::vector<FSGVect3DImpl::FVect3DType> StartPositionsVector{
+        FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(StartPositions)
+    };
 
     Pimpl->BasicHandModel = FSGBasicHandModelImpl::FBasicHandModelType(bRightHanded, MoveTemp(LengthsVector),
                                                                        MoveTemp(StartPositionsVector));
@@ -157,14 +158,16 @@ FSGBasicHandModelImpl::FSGBasicHandModelImpl(bool bRightHanded, const TArray<TAr
 #endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 ) */
 {
     std::vector<std::vector<float>> LengthsVector{
-        FSGArrayUtils::ToStdVector<float>(Lengths)
+        FSGArrayUtils::ToMillimeters(Lengths)
     };
 
-    std::vector<FSGVect3DImpl::FVect3DType> StartPositionsVector{FSGArrayUtils::ToStdVector<
-        FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(StartPositions)};
+    std::vector<FSGVect3DImpl::FVect3DType> StartPositionsVector{
+        FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(StartPositions)
+    };
 
-    std::vector<FSGQuatImpl::FQuatType> StartRotationsVector{FSGArrayUtils::ToStdVector<
-        FQuat, FSGQuatImpl::FQuatType, FSGQuatImpl, &FSGQuatImpl::ToQuat>(StartRotations)};
+    std::vector<FSGQuatImpl::FQuatType> StartRotationsVector{
+        FSGArrayUtils::ToStdVector<FQuat, FSGQuatImpl::FQuatType, FSGQuatImpl, &FSGQuatImpl::ToQuat>(StartRotations)
+    };
 
     Pimpl->BasicHandModel = FSGBasicHandModelImpl::FBasicHandModelType(bRightHanded, MoveTemp(LengthsVector),
                                                                        MoveTemp(StartPositionsVector),
@@ -280,7 +283,7 @@ TArray<float> FSGBasicHandModelImpl::GetFingerRatios(const ESGFinger Finger) con
 TArray<FVector> FSGBasicHandModelImpl::GetStartJointPositions() const
 {
     TArray<FVector> StartJointPositions{
-        FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
+        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             Pimpl->BasicHandModel.GetStartJointPositions())
     };
     return MoveTemp(StartJointPositions);
@@ -289,21 +292,23 @@ TArray<FVector> FSGBasicHandModelImpl::GetStartJointPositions() const
 void FSGBasicHandModelImpl::SetStartJointPositions(const TArray<FVector>& StartJointPositions)
 {
     std::vector<FSGVect3DImpl::FVect3DType> StartJointPositionsVector{
-        FSGArrayUtils::ToStdVector<
-            FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(StartJointPositions)
+        FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(StartJointPositions)
     };
     Pimpl->BasicHandModel.SetStartJointPositions(MoveTemp(StartJointPositionsVector));
 }
 
-void FSGBasicHandModelImpl::SetStartJointPosition(ESGFinger Finger, const FVector& Position)
+void FSGBasicHandModelImpl::SetStartJointPosition(const ESGFinger Finger, const FVector& Position)
 {
-    Pimpl->BasicHandModel.SetStartJointPosition(FSGCoreEnumCast::ToEFinger(Finger),
-                                                FSGVect3DImpl(Position).ToVect3D());
+    Pimpl->BasicHandModel.SetStartJointPosition(
+        FSGCoreEnumCast::ToEFinger(Finger),
+        FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(Position));
 }
 
 void FSGBasicHandModelImpl::SetStartJointPosition(const uint8 Finger, const FVector& Position)
 {
-    Pimpl->BasicHandModel.SetStartJointPosition(Finger, FSGVect3DImpl(Position).ToVect3D());
+    Pimpl->BasicHandModel.SetStartJointPosition(
+        Finger,
+        FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(Position));
 }
 
 TArray<FQuat> FSGBasicHandModelImpl::GetStartJointRotations() const
@@ -327,13 +332,15 @@ void FSGBasicHandModelImpl::SetStartJointRotations(const TArray<FQuat>& StartJoi
 
 FVector FSGBasicHandModelImpl::GetJointPosition(const ESGFinger Finger) const
 {
-    const FSGVect3DImpl Position(Pimpl->BasicHandModel.GetJointPosition(FSGCoreEnumCast::ToEFinger(Finger)));
-    return Position.ToFVector();
+    return FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+        Pimpl->BasicHandModel.GetJointPosition(FSGCoreEnumCast::ToEFinger(Finger)));
 }
 
 void FSGBasicHandModelImpl::SetJointPosition(const FVector& NewPosition, const ESGFinger Finger)
 {
-    Pimpl->BasicHandModel.SetJointPosition(FSGVect3DImpl(NewPosition).ToVect3D(), FSGCoreEnumCast::ToEFinger(Finger));
+    Pimpl->BasicHandModel.SetJointPosition(
+        FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(NewPosition),
+        FSGCoreEnumCast::ToEFinger(Finger));
 }
 
 FQuat FSGBasicHandModelImpl::GetJointRotation(const ESGFinger Finger) const
@@ -364,7 +371,7 @@ float FSGBasicHandModelImpl::GetTotalLength(const ESGFinger Finger) const
 TArray<FVector> FSGBasicHandModelImpl::Get3DLengths(const ESGFinger Finger) const
 {
     const TArray<FVector> Lengths{
-        FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
+        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             Pimpl->BasicHandModel.Get3DLengths(FSGCoreEnumCast::ToEFinger(Finger)))
     };
     return Lengths;
@@ -403,4 +410,4 @@ FSGBasicHandModelImpl::FImpl::~FImpl() = default;
 void FSGBasicHandModelImpl::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
-}
+}

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGHandPoseImpl.cpp

@@ -155,7 +155,7 @@ FSGHandPoseImpl::FSGHandPoseImpl()
 {
 }
 
-FSGHandPoseImpl::FSGHandPoseImpl(bool bRightHanded, const TArray<TArray<FVector>>& JointPositions,
+FSGHandPoseImpl::FSGHandPoseImpl(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 )
@@ -165,8 +165,7 @@ FSGHandPoseImpl::FSGHandPoseImpl(bool bRightHanded, const TArray<TArray<FVector>
 #endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 ) */
 {
     std::vector<std::vector<FSGVect3DImpl::FVect3DType>> JointPositionsVector{
-        FSGArrayUtils::ToStdVector<FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(
-            JointPositions)
+        FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(JointPositions)
     };
 
     std::vector<std::vector<FSGQuatImpl::FQuatType>> JointRotationsVector{
@@ -236,7 +235,7 @@ void FSGHandPoseImpl::SetIsRight(const bool bRightHanded) const
 TArray<TArray<FVector>> FSGHandPoseImpl::GetJointPositions() const
 {
     TArray<TArray<FVector>> JointPositions{
-        FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
+        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             Pimpl->HandPose.GetJointPositions())
     };
     return MoveTemp(JointPositions);
@@ -245,7 +244,7 @@ TArray<TArray<FVector>> FSGHandPoseImpl::GetJointPositions() const
 void FSGHandPoseImpl::SetJointPositions(const TArray<TArray<FVector>>& JointPositions) const
 {
     std::vector<std::vector<FSGVect3DImpl::FVect3DType>> JointPositionsVector{
-        FSGArrayUtils::ToStdVector<FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(
+        FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             JointPositions)
     };
     Pimpl->HandPose.SetJointPositions(MoveTemp(JointPositionsVector));

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGHapticGloveImpl.cpp

@@ -357,12 +357,14 @@ void FSGHapticGloveImpl::GetWristLocation(const FVector& ReferencePosition, cons
     FSGVect3DImpl::FVect3DType WristPosition;
     FSGQuatImpl::FQuatType WristRotation;
 
-    ToHapticGlovePtrChecked()->GetWristLocation(FSGVect3DImpl(ReferencePosition).ToVect3D(),
-                                                FSGQuatImpl(ReferenceRotation).ToQuat(),
-                                                FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
-                                                WristPosition, WristRotation);
+    ToHapticGlovePtrChecked()->GetWristLocation(
+        FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(ReferencePosition),
+        FSGQuatImpl(ReferenceRotation).ToQuat(),
+        FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
+        WristPosition, WristRotation);
 
-    OutWristPosition = FSGVect3DImpl(MoveTemp(WristPosition)).ToFVector();
+    OutWristPosition = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+        MoveTemp(WristPosition));
     OutWristRotation = FSGQuatImpl(MoveTemp(WristRotation)).ToFQuat();
 }
 
@@ -373,12 +375,14 @@ void FSGHapticGloveImpl::GetGloveLocation(const FVector& ReferencePosition, cons
     FSGVect3DImpl::FVect3DType GlovePosition;
     FSGQuatImpl::FQuatType GloveRotation;
 
-    ToHapticGlovePtrChecked()->GetGloveLocation(FSGVect3DImpl(ReferencePosition).ToVect3D(),
-                                                FSGQuatImpl(ReferenceRotation).ToQuat(),
-                                                FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
-                                                GlovePosition, GloveRotation);
+    ToHapticGlovePtrChecked()->GetGloveLocation(
+        FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(ReferencePosition),
+        FSGQuatImpl(ReferenceRotation).ToQuat(),
+        FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
+        GlovePosition, GloveRotation);
 
-    OutGlovePosition = FSGVect3DImpl(MoveTemp(GlovePosition)).ToFVector();
+    OutGlovePosition = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+        MoveTemp(GlovePosition));
     OutGloveRotation = FSGQuatImpl(MoveTemp(GloveRotation)).ToFQuat();
 }
 

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGJointKinematicsImpl.cpp

@@ -48,14 +48,18 @@ bool FSGJointKinematicsImpl::ForwardKinematics(const FVector& StartPosition, con
                                                const TArray<FVector>& JointLengths, const TArray<FVector>& JointAngles,
                                                TArray<FVector>& OutNewPositions, TArray<FQuat>& OutNewRotations)
 {
-    FSGVect3DImpl::FVect3DType StartPositionVect3D(FSGVect3DImpl(StartPosition).ToVect3D());
+    FSGVect3DImpl::FVect3DType StartPositionVect3D(
+        FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(StartPosition));
     FSGQuatImpl::FQuatType StartRotationQuat(FSGQuatImpl(StartRotation).ToQuat());
 
-    std::vector<FSGVect3DImpl::FVect3DType> JointLengthsVector{FSGArrayUtils::ToStdVector<
-        FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(JointLengths)};
+    std::vector<FSGVect3DImpl::FVect3DType> JointLengthsVector{
+        FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(JointLengths)
+    };
 
-    std::vector<FSGVect3DImpl::FVect3DType> JointAnglesVector{FSGArrayUtils::ToStdVector<
-        FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(JointAngles)};
+    std::vector<FSGVect3DImpl::FVect3DType> JointAnglesVector{
+        FSGArrayUtils::ToStdVector<FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(
+            JointAngles)
+    };
 
     std::vector<FSGVect3DImpl::FVect3DType> NewPositions;
     std::vector<FSGQuatImpl::FQuatType> NewRotations;
@@ -65,20 +69,21 @@ bool FSGJointKinematicsImpl::ForwardKinematics(const FVector& StartPosition, con
         MoveTemp(JointLengthsVector), MoveTemp(JointAnglesVector),
         NewPositions, NewRotations);
 
-    OutNewPositions = FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector,
-                                                   FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(NewPositions);;
+    OutNewPositions = FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(NewPositions);;
     OutNewRotations = FSGArrayUtils::FromStdVector<FSGQuatImpl::FQuatType, FQuat,
                                                    FSGQuatImpl, &FSGQuatImpl::ToFQuat>(NewRotations);;
 
     return bResults;
 }
 
-bool FSGJointKinematicsImpl::ForwardKinematics(const FSGBasicHandModelImpl& Profile, ESGFinger Finger,
+bool FSGJointKinematicsImpl::ForwardKinematics(const FSGBasicHandModelImpl& Profile, const ESGFinger Finger,
                                                const TArray<FVector>& JointAngles,
                                                TArray<FVector>& OutNewPositions, TArray<FQuat>& OutNewRotations)
 {
-    std::vector<FSGVect3DImpl::FVect3DType> JointAnglesVector(FSGArrayUtils::ToStdVector<
-        FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(JointAngles));
+    std::vector<FSGVect3DImpl::FVect3DType> JointAnglesVector{
+        FSGArrayUtils::ToStdVector<FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(
+            JointAngles)
+    };
 
     std::vector<FSGVect3DImpl::FVect3DType> NewPositions;
     std::vector<FSGQuatImpl::FQuatType> NewRotations;
@@ -87,8 +92,7 @@ bool FSGJointKinematicsImpl::ForwardKinematics(const FSGBasicHandModelImpl& Prof
         Profile.ToBasicHandModel(), FSGCoreEnumCast::ToEFinger(Finger), MoveTemp(JointAnglesVector),
         NewPositions, NewRotations);
 
-    OutNewPositions = FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector,
-                                                   FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(NewPositions);;
+    OutNewPositions = FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(NewPositions);;
     OutNewRotations = FSGArrayUtils::FromStdVector<FSGQuatImpl::FQuatType, FQuat,
                                                    FSGQuatImpl, &FSGQuatImpl::ToFQuat>(NewRotations);;
 

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGNovaGloveImpl.cpp

@@ -185,12 +185,16 @@ void FSGNovaGloveImpl::CalculateGloveLocation(const FVector& ReferencePosition,
 {
     FSGVect3DImpl::FVect3DType GlovePosition;
     FSGQuatImpl::FQuatType GloveRotation;
-    FNovaGloveType::CalculateGloveLocation(FSGVect3DImpl{ReferencePosition}.ToVect3D(),
-                                           FSGQuatImpl{ReferenceRotation}.ToQuat(),
-                                           FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
-                                           bRightHanded,
-                                           GlovePosition, GloveRotation);
-    OutGlovePosition = FSGVect3DImpl{MoveTemp(GlovePosition)}.ToFVector();
+
+    FNovaGloveType::CalculateGloveLocation(
+        FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(ReferencePosition),
+        FSGQuatImpl{ReferenceRotation}.ToQuat(),
+        FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
+        bRightHanded,
+        GlovePosition, GloveRotation);
+
+    OutGlovePosition = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+        MoveTemp(GlovePosition));
     OutGloveRotation = FSGQuatImpl{MoveTemp(GloveRotation)}.ToFQuat();
 }
 
@@ -201,12 +205,16 @@ void FSGNovaGloveImpl::CalculateWristLocation(const FVector& ReferencePosition,
 {
     FSGVect3DImpl::FVect3DType WristPosition;
     FSGQuatImpl::FQuatType WristRotation;
-    FNovaGloveType::CalculateWristLocation(FSGVect3DImpl{ReferencePosition}.ToVect3D(),
-                                           FSGQuatImpl{ReferenceRotation}.ToQuat(),
-                                           FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
-                                           bRightHanded,
-                                           WristPosition, WristRotation);
-    OutWristPosition = FSGVect3DImpl{MoveTemp(WristPosition)}.ToFVector();
+
+    FNovaGloveType::CalculateWristLocation(
+        FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(ReferencePosition),
+        FSGQuatImpl{ReferenceRotation}.ToQuat(),
+        FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
+        bRightHanded,
+        WristPosition, WristRotation);
+
+    OutWristPosition = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+        MoveTemp(WristPosition));
     OutWristRotation = FSGQuatImpl{MoveTemp(WristRotation)}.ToFQuat();
 }
 
@@ -447,11 +455,15 @@ void FSGNovaGloveImpl::GetGloveLocation(const FVector& ReferencePosition, const
 {
     FSGVect3DImpl::FVect3DType GlovePosition;
     FSGQuatImpl::FQuatType GloveRotation;
-    ToNovaGlovePtrChecked()->GetGloveLocation(FSGVect3DImpl{ReferencePosition}.ToVect3D(),
-                                              FSGQuatImpl{ReferenceRotation}.ToQuat(),
-                                              FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
-                                              GlovePosition, GloveRotation);
-    OutGlovePosition = FSGVect3DImpl{MoveTemp(GlovePosition)}.ToFVector();
+
+    ToNovaGlovePtrChecked()->GetGloveLocation(
+        FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(ReferencePosition),
+        FSGQuatImpl{ReferenceRotation}.ToQuat(),
+        FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
+        GlovePosition, GloveRotation);
+
+    OutGlovePosition = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+        MoveTemp(GlovePosition));
     OutGloveRotation = FSGQuatImpl{MoveTemp(GloveRotation)}.ToFQuat();
 }
 
@@ -461,11 +473,15 @@ void FSGNovaGloveImpl::GetWristLocation(const FVector& ReferencePosition, const
 {
     FSGVect3DImpl::FVect3DType WristPosition;
     FSGQuatImpl::FQuatType WristRotation;
-    ToNovaGlovePtrChecked()->GetWristLocation(FSGVect3DImpl{ReferencePosition}.ToVect3D(),
-                                              FSGQuatImpl{ReferenceRotation}.ToQuat(),
-                                              FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
-                                              WristPosition, WristRotation);
-    OutWristPosition = FSGVect3DImpl{MoveTemp(WristPosition)}.ToFVector();
+
+    ToNovaGlovePtrChecked()->GetWristLocation(
+        FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(ReferencePosition),
+        FSGQuatImpl{ReferenceRotation}.ToQuat(),
+        FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
+        WristPosition, WristRotation);
+
+    OutWristPosition = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+        MoveTemp(WristPosition));
     OutWristRotation = FSGQuatImpl{MoveTemp(WristRotation)}.ToFQuat();
 }
 

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGSenseGloveHandProfileImpl.cpp

@@ -121,8 +121,7 @@ FSGSenseGloveHandProfileImpl::FSGSenseGloveHandProfileImpl(const bool bRightHand
 #endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 ) */
 {
     std::vector<FSGVect3DImpl::FVect3DType> FingerThimbleOffsetVector{
-        FSGArrayUtils::ToStdVector<FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(
-            FingerThimbleOffset)
+        FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(FingerThimbleOffset)
     };
     Pimpl->SenseGloveHandProfile = FSenseGloveHandProfileType(
         bRightHanded, Interpolator.ToHandInterpolator(),
@@ -218,7 +217,7 @@ void FSGSenseGloveHandProfileImpl::SetFingerSolver(const ESGFingerSolver FingerS
 TArray<FVector> FSGSenseGloveHandProfileImpl::GetFingerThimbleOffset() const
 {
     const TArray<FVector> FingerThimbleOffset{
-        FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
+        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             Pimpl->SenseGloveHandProfile.GetFingerThimbleOffset())
     };
     return FingerThimbleOffset;
@@ -227,8 +226,7 @@ TArray<FVector> FSGSenseGloveHandProfileImpl::GetFingerThimbleOffset() const
 void FSGSenseGloveHandProfileImpl::SetFingerThimbleOffset(const TArray<FVector>& FingerThimbleOffset)
 {
     std::vector<FSGVect3DImpl::FVect3DType> FingerThimbleOffsetVector{
-        FSGArrayUtils::ToStdVector<FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(
-            FingerThimbleOffset)
+        FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(FingerThimbleOffset)
     };
     Pimpl->SenseGloveHandProfile.SetFingerThimbleOffset(MoveTemp(FingerThimbleOffsetVector));
 }

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGSenseGloveImpl.cpp

@@ -210,12 +210,16 @@ void FSGSenseGloveImpl::CalculateGloveLocation(const FVector& ReferencePosition,
 {
     FSGVect3DImpl::FVect3DType GlovePosition;
     FSGQuatImpl::FQuatType GloveRotation;
-    FSenseGloveType::CalculateGloveLocation(FSGVect3DImpl{ReferencePosition}.ToVect3D(),
-                                            FSGQuatImpl{ReferenceRotation}.ToQuat(),
-                                            FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
-                                            bRightHanded, FSGCoreEnumCast::ToEFinger(MountedOn),
-                                            GlovePosition, GloveRotation);
-    OutGlovePosition = FSGVect3DImpl{MoveTemp(GlovePosition)}.ToFVector();
+
+    FSenseGloveType::CalculateGloveLocation(
+        FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(ReferencePosition),
+        FSGQuatImpl{ReferenceRotation}.ToQuat(),
+        FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
+        bRightHanded, FSGCoreEnumCast::ToEFinger(MountedOn),
+        GlovePosition, GloveRotation);
+
+    OutGlovePosition = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+        MoveTemp(GlovePosition));;
     OutGloveRotation = FSGQuatImpl{MoveTemp(GloveRotation)}.ToFQuat();
 }
 
@@ -228,14 +232,18 @@ void FSGSenseGloveImpl::CalculateWristLocation(const FVector& ReferencePosition,
 {
     FSGVect3DImpl::FVect3DType WristPosition;
     FSGQuatImpl::FQuatType WristRotation;
-    FSenseGloveType::CalculateWristLocation(FSGVect3DImpl{ReferencePosition}.ToVect3D(),
-                                            FSGQuatImpl{ReferenceRotation}.ToQuat(),
-                                            FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
-                                            bRightHanded, FSGCoreEnumCast::ToEFinger(MountedOn),
-                                            FSGVect3DImpl(GloveWristPositionOffset).ToVect3D(),
-                                            FSGQuatImpl(GloveWristRotationOffset).ToQuat(),
-                                            WristPosition, WristRotation);
-    OutWristPosition = FSGVect3DImpl{MoveTemp(WristPosition)}.ToFVector();
+
+    FSenseGloveType::CalculateWristLocation(
+        FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(ReferencePosition),
+        FSGQuatImpl{ReferenceRotation}.ToQuat(),
+        FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
+        bRightHanded, FSGCoreEnumCast::ToEFinger(MountedOn),
+        FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(GloveWristPositionOffset),
+        FSGQuatImpl(GloveWristRotationOffset).ToQuat(),
+        WristPosition, WristRotation);
+
+    OutWristPosition = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+        MoveTemp(WristPosition));
     OutWristRotation = FSGQuatImpl{MoveTemp(WristRotation)}.ToFQuat();
 }
 
@@ -470,11 +478,15 @@ void FSGSenseGloveImpl::GetGloveLocation(const FVector& ReferencePosition, const
 {
     FSGVect3DImpl::FVect3DType GlovePosition;
     FSGQuatImpl::FQuatType GloveRotation;
-    ToSenseGlovePtrChecked()->GetGloveLocation(FSGVect3DImpl{ReferencePosition}.ToVect3D(),
-                                               FSGQuatImpl{ReferenceRotation}.ToQuat(),
-                                               FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
-                                               GlovePosition, GloveRotation);
-    OutGlovePosition = FSGVect3DImpl{MoveTemp(GlovePosition)}.ToFVector();
+
+    ToSenseGlovePtrChecked()->GetGloveLocation(
+        FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(ReferencePosition),
+        FSGQuatImpl{ReferenceRotation}.ToQuat(),
+        FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
+        GlovePosition, GloveRotation);
+
+    OutGlovePosition = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+        MoveTemp(GlovePosition));
     OutGloveRotation = FSGQuatImpl{MoveTemp(GloveRotation)}.ToFQuat();
 }
 
@@ -485,12 +497,16 @@ void FSGSenseGloveImpl::GetGloveLocation(const FVector& ReferencePosition, const
 {
     FSGVect3DImpl::FVect3DType GlovePosition;
     FSGQuatImpl::FQuatType GloveRotation;
-    ToSenseGlovePtrChecked()->GetGloveLocation(FSGVect3DImpl{ReferencePosition}.ToVect3D(),
-                                               FSGQuatImpl{ReferenceRotation}.ToQuat(),
-                                               FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
-                                               FSGCoreEnumCast::ToEFinger(MountedOn),
-                                               GlovePosition, GloveRotation);
-    OutGlovePosition = FSGVect3DImpl{MoveTemp(GlovePosition)}.ToFVector();
+
+    ToSenseGlovePtrChecked()->GetGloveLocation(
+        FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(ReferencePosition),
+        FSGQuatImpl{ReferenceRotation}.ToQuat(),
+        FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
+        FSGCoreEnumCast::ToEFinger(MountedOn),
+        GlovePosition, GloveRotation);
+
+    OutGlovePosition = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+        MoveTemp(GlovePosition));
     OutGloveRotation = FSGQuatImpl{MoveTemp(GloveRotation)}.ToFQuat();
 }
 
@@ -500,11 +516,15 @@ void FSGSenseGloveImpl::GetWristLocation(const FVector& ReferencePosition, const
 {
     FSGVect3DImpl::FVect3DType WristPosition;
     FSGQuatImpl::FQuatType WristRotation;
-    ToSenseGlovePtrChecked()->GetWristLocation(FSGVect3DImpl{ReferencePosition}.ToVect3D(),
-                                               FSGQuatImpl{ReferenceRotation}.ToQuat(),
-                                               FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
-                                               WristPosition, WristRotation);
-    OutWristPosition = FSGVect3DImpl{MoveTemp(WristPosition)}.ToFVector();
+
+    ToSenseGlovePtrChecked()->GetWristLocation(
+        FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(ReferencePosition),
+        FSGQuatImpl{ReferenceRotation}.ToQuat(),
+        FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
+        WristPosition, WristRotation);
+
+    OutWristPosition = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+        MoveTemp(WristPosition));
     OutWristRotation = FSGQuatImpl{MoveTemp(WristRotation)}.ToFQuat();
 }
 
@@ -515,13 +535,17 @@ void FSGSenseGloveImpl::GetWristLocation(const FVector& ReferencePosition, const
 {
     FSGVect3DImpl::FVect3DType WristPosition;
     FSGQuatImpl::FQuatType WristRotation;
-    ToSenseGlovePtrChecked()->GetWristLocation(FSGVect3DImpl{ReferencePosition}.ToVect3D(),
-                                               FSGQuatImpl{ReferenceRotation}.ToQuat(),
-                                               FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
-                                               FSGVect3DImpl(GloveWristPositionOffset).ToVect3D(),
-                                               FSGQuatImpl(GloveWristRotationOffset).ToQuat(),
-                                               WristPosition, WristRotation);
-    OutWristPosition = FSGVect3DImpl{MoveTemp(WristPosition)}.ToFVector();
+
+    ToSenseGlovePtrChecked()->GetWristLocation(
+        FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(ReferencePosition),
+        FSGQuatImpl{ReferenceRotation}.ToQuat(),
+        FSGCoreEnumCast::ToEPositionalTrackingHardware(TrackingHardware),
+        FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(GloveWristPositionOffset),
+        FSGQuatImpl(GloveWristRotationOffset).ToQuat(),
+        WristPosition, WristRotation);
+
+    OutWristPosition = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+        MoveTemp(WristPosition));
     OutWristRotation = FSGQuatImpl{MoveTemp(WristRotation)}.ToFQuat();
 }
 

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGSenseGloveInfoImpl.cpp

@@ -127,15 +127,16 @@ FSGSenseGloveInfoImpl::FSGSenseGloveInfoImpl(const FString& DeviceId,
     std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
     FSGQuatImpl::FQuatType ImuCorrectionQuat(FSGQuatImpl(ImuCorrection).ToQuat());
 
-    std::vector<FSGVect3DImpl::FVect3DType> StartPositionsVector(FSGArrayUtils::ToStdVector<
-        FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(StartPositions));
+    std::vector<FSGVect3DImpl::FVect3DType> StartPositionsVector{
+        FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(StartPositions)
+    };
 
-    std::vector<FSGQuatImpl::FQuatType> StartRotationsVector(FSGArrayUtils::ToStdVector<
-        FQuat, FSGQuatImpl::FQuatType, FSGQuatImpl, &FSGQuatImpl::ToQuat>(StartRotations));
+    std::vector<FSGQuatImpl::FQuatType> StartRotationsVector{
+        FSGArrayUtils::ToStdVector<FQuat, FSGQuatImpl::FQuatType, FSGQuatImpl, &FSGQuatImpl::ToQuat>(StartRotations)
+    };
 
     std::vector<std::vector<FSGVect3DImpl::FVect3DType>> GloveLengthsVector{
-        FSGArrayUtils::ToStdVector<FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(
-            GloveLengths)
+        FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(GloveLengths)
     };
 
     std::vector<bool> FunctionsVector{FSGArrayUtils::ToStdVector(Functions)};
@@ -264,7 +265,7 @@ void FSGSenseGloveInfoImpl::SetImuCorrection(const FQuat& ImuCorrection)
 TArray<FVector> FSGSenseGloveInfoImpl::GetStartPositions() const
 {
     TArray<FVector> StartPositionsArray{
-        FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
+        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             Pimpl->SenseGloveInfo.GetStartPositions())};
     return MoveTemp(StartPositionsArray);
 }
@@ -272,8 +273,7 @@ TArray<FVector> FSGSenseGloveInfoImpl::GetStartPositions() const
 void FSGSenseGloveInfoImpl::SetStartPositions(const TArray<FVector>& StartPositions)
 {
     std::vector<FSGVect3DImpl::FVect3DType> StartPositionsVector{
-        FSGArrayUtils::ToStdVector<FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(
-            StartPositions)
+        FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(StartPositions)
     };
     Pimpl->SenseGloveInfo.SetStartPositions(MoveTemp(StartPositionsVector));
 }
@@ -298,8 +298,7 @@ void FSGSenseGloveInfoImpl::SetStartRotations(const TArray<FQuat>& StartRotation
 TArray<TArray<FVector>> FSGSenseGloveInfoImpl::GetGloveLengths() const
 {
     TArray<TArray<FVector>> GloveLengths{
-        FSGArrayUtils::FromStdVector<
-            FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
+        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             Pimpl->SenseGloveInfo.GetGloveLengths())
     };
     return MoveTemp(GloveLengths);
@@ -308,8 +307,7 @@ TArray<TArray<FVector>> FSGSenseGloveInfoImpl::GetGloveLengths() const
 void FSGSenseGloveInfoImpl::SetGloveLengths(const TArray<TArray<FVector>>& GloveLengths) const
 {
     std::vector<std::vector<FSGVect3DImpl::FVect3DType>> GloveLengthsVector{
-        FSGArrayUtils::ToStdVector<FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(
-            GloveLengths)
+        FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(GloveLengths)
     };
     Pimpl->SenseGloveInfo.SetGloveLengths(MoveTemp(GloveLengthsVector));
 }
@@ -328,8 +326,9 @@ void FSGSenseGloveInfoImpl::SetFunctions(const TArray<bool>& Functions) const
 
 FVector FSGSenseGloveInfoImpl::GetStartPosition(const ESGFinger Finger) const
 {
-    FVector StartPosition(FSGVect3DImpl(Pimpl->SenseGloveInfo.GetStartPosition(
-        FSGCoreEnumCast::ToEFinger(Finger))).ToFVector());
+    FVector StartPosition{FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+        Pimpl->SenseGloveInfo.GetStartPosition(FSGCoreEnumCast::ToEFinger(Finger)))
+    };
     return MoveTemp(StartPosition);
 }
 
@@ -343,10 +342,11 @@ FQuat FSGSenseGloveInfoImpl::GetStartRotation(const ESGFinger Finger) const
 TArray<FVector> FSGSenseGloveInfoImpl::GetGloveLengths(const ESGFinger Finger) const
 {
     std::vector<FSGVect3DImpl::FVect3DType> GloveLengthsVector{
-        Pimpl->SenseGloveInfo.GetGloveLengths(FSGCoreEnumCast::ToEFinger(Finger))};
+        Pimpl->SenseGloveInfo.GetGloveLengths(FSGCoreEnumCast::ToEFinger(Finger))
+    };
     TArray<FVector> GloveLengthsArray{
-        FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
-            MoveTemp(GloveLengthsVector))};
+        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(MoveTemp(GloveLengthsVector))
+    };
     return MoveTemp(GloveLengthsArray);
 }
 

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGSenseGlovePoseImpl.cpp

@@ -113,8 +113,7 @@ FSGSenseGlovePoseImpl::FSGSenseGlovePoseImpl(bool bRightHanded, const TArray<TAr
 #endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 22 ) */
 {
     std::vector<std::vector<FSGVect3DImpl::FVect3DType>> JointPositionsVector{
-        FSGArrayUtils::ToStdVector<FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(
-            JointPositions)
+        FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(JointPositions)
     };
     std::vector<std::vector<FSGQuatImpl::FQuatType>> JointRotationsVector{
         FSGArrayUtils::ToStdVector<FQuat, FSGQuatImpl::FQuatType, FSGQuatImpl, &FSGQuatImpl::ToQuat>(
@@ -184,7 +183,7 @@ void FSGSenseGlovePoseImpl::SetIsRight(const bool bRightHanded) const
 TArray<TArray<FVector>> FSGSenseGlovePoseImpl::GetJointPositions() const
 {
     const TArray<TArray<FVector>> JointPositions{
-        FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
+        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             Pimpl->SenseGlovePose.GetJointPositions())
     };
     return JointPositions;
@@ -193,8 +192,7 @@ TArray<TArray<FVector>> FSGSenseGlovePoseImpl::GetJointPositions() const
 void FSGSenseGlovePoseImpl::SetJointPositions(const TArray<TArray<FVector>>& JointPositions) const
 {
     std::vector<std::vector<FSGVect3DImpl::FVect3DType>> JointPositionsVector{
-        FSGArrayUtils::ToStdVector<FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(
-            JointPositions)
+        FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(JointPositions)
     };
     Pimpl->SenseGlovePose.SetJointPositions(MoveTemp(JointPositionsVector));
 }
@@ -238,7 +236,7 @@ void FSGSenseGlovePoseImpl::SetGloveAngles(const TArray<TArray<FVector>>& GloveA
 TArray<FVector> FSGSenseGlovePoseImpl::GetThimblePositions() const
 {
     const TArray<FVector> ThimblePositions{
-        FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
+        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             Pimpl->SenseGlovePose.GetThimblePositions())
     };
     return ThimblePositions;
@@ -266,7 +264,7 @@ TArray<FVector> FSGSenseGlovePoseImpl::CalculateFingerTips(
     const FSGSenseGloveHandProfileImpl& SenseGloveHandProfileImpl) const
 {
     const TArray<FVector> FingerTips{
-        FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
+        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             Pimpl->SenseGlovePose.CalculateFingerTips(SenseGloveHandProfileImpl.ToSenseGloveHandProfile()))
     };
     return FingerTips;
@@ -275,11 +273,10 @@ TArray<FVector> FSGSenseGlovePoseImpl::CalculateFingerTips(
 TArray<FVector> FSGSenseGlovePoseImpl::CalculateFingerTips(const TArray<FVector>& FingerOffsets) const
 {
     std::vector<FSGVect3DImpl::FVect3DType> FingerOffsetsVector{
-        FSGArrayUtils::ToStdVector<FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(
-            FingerOffsets)
+        FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(FingerOffsets)
     };
     TArray<FVector> FingerTips{
-        FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
+        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             Pimpl->SenseGlovePose.CalculateFingerTips(MoveTemp(FingerOffsetsVector)))
     };
     return FingerTips;

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGSenseGloveVarsImpl.cpp

@@ -68,7 +68,7 @@ TArray<FVector> FSGSenseGloveVarsImpl::GetStartPositions(const FString& Hardware
 {
     std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
     const TArray<FVector> StartPositions{
-        FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
+        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             FSenseGloveVarsType::GetStartPositions(MoveTemp(HardwareVersionString), bRightHanded))
     };
     return StartPositions;
@@ -88,7 +88,7 @@ TArray<TArray<FVector>> FSGSenseGloveVarsImpl::GetGloveLengths(const FString& Ha
 {
     std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
     const TArray<TArray<FVector>> GloveLengths{
-        FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
+        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             FSenseGloveVarsType::GetGloveLengths(MoveTemp(HardwareVersionString)))
     };
     return GloveLengths;

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGTrackingImpl.cpp

@@ -48,9 +48,13 @@ void FSGTrackingImpl::CalculateLocation(const FVector& TrackedPosition, const FQ
                                         const FVector& PositionOffset, const FQuat& RotationOffset,
                                         FVector& OutNewPosition, FQuat& OutNewRotation)
 {
-    FSGVect3DImpl::FVect3DType TrackedPositionVect3D(FSGVect3DImpl(TrackedPosition).ToVect3D());
+    FSGVect3DImpl::FVect3DType TrackedPositionVect3D{
+        FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(TrackedPosition)
+    };
     FSGQuatImpl::FQuatType TrackedRotationQuat(FSGQuatImpl(TrackedRotation).ToQuat());
-    FSGVect3DImpl::FVect3DType PositionOffsetVect3D(FSGVect3DImpl(PositionOffset).ToVect3D());
+    FSGVect3DImpl::FVect3DType PositionOffsetVect3D{
+        FSGUnits::CentimetersToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(PositionOffset)
+    };
     FSGQuatImpl::FQuatType RotationOffsetQuat(FSGQuatImpl(RotationOffset).ToQuat());
     FSGVect3DImpl::FVect3DType NewPosition;
     FSGQuatImpl::FQuatType NewRotation;
@@ -62,37 +66,40 @@ void FSGTrackingImpl::CalculateLocation(const FVector& TrackedPosition, const FQ
                                      NewPosition,
                                      NewRotation);
 
-    OutNewPosition = FSGVect3DImpl(NewPosition).ToFVector();
+    OutNewPosition = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(NewPosition);
     OutNewRotation = FSGQuatImpl(NewRotation).ToFQuat();
 }
 
 const TArray<FVector>& FSGTrackingImpl::GetSenseGloveFingerToGlovePositionOrigin()
 {
-    static const TArray<FVector> GlovePositionOrigin{FSGArrayUtils::FromStdVector<
-        FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
-        FTrackingType::GetSenseGloveFingerToGlovePositionOrigin()
-        )};
+    static const TArray<FVector> GlovePositionOrigin{
+        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+            FTrackingType::GetSenseGloveFingerToGlovePositionOrigin())
+    };
     return GlovePositionOrigin;
 }
 
 const TArray<FQuat>& FSGTrackingImpl::GetSenseGloveFingerToGloveRotationOrigin()
 {
-    static const TArray<FQuat> GloveRotationOrigin{FSGArrayUtils::FromStdVector<
-        FSGQuatImpl::FQuatType, FQuat, FSGQuatImpl, &FSGQuatImpl::ToFQuat>(
-        FTrackingType::GetSenseGloveFingerToGloveRotationOrigin()
-        )};
+    static const TArray<FQuat> GloveRotationOrigin{
+        FSGArrayUtils::FromStdVector<FSGQuatImpl::FQuatType, FQuat, FSGQuatImpl, &FSGQuatImpl::ToFQuat>(
+            FTrackingType::GetSenseGloveFingerToGloveRotationOrigin())
+    };
     return GloveRotationOrigin;
 }
 
 const FVector& FSGTrackingImpl::GetSenseGloveWristPositionOffset()
 {
-    static const FVector Offset(FSGVect3DImpl(FTrackingType::GetSenseGloveWristPositionOffset()).ToFVector());
+    static const FVector Offset{
+        FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+            FTrackingType::GetSenseGloveWristPositionOffset())
+    };
     return Offset;
 }
 
 const FQuat& FSGTrackingImpl::GetSenseGloveWristRotationOffset()
 {
-    static FQuat Offset(FSGQuatImpl(FTrackingType::GetSenseGloveWristRotationOffset()).ToFQuat());
+    static FQuat Offset{FSGQuatImpl(FTrackingType::GetSenseGloveWristRotationOffset()).ToFQuat()};
     return Offset;
 }
 
@@ -105,7 +112,7 @@ void FSGTrackingImpl::GetSenseGloveMountOffset(const bool bRightHanded, const ES
     FTrackingType::GetSenseGloveMountOffset(bRightHanded, FSGCoreEnumCast::ToEFinger(ToFinger),
                                             IPosition, IRotation);
 
-    OutIPosition = FSGVect3DImpl(IPosition).ToFVector();
+    OutIPosition = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(IPosition);
     OutIRotation = FSGQuatImpl(IRotation).ToFQuat();
 }
 
@@ -119,13 +126,16 @@ void FSGTrackingImpl::GetSenseGloveTrackerMountOffset(const ESGPositionalTrackin
     FTrackingType::GetSenseGloveTrackerMountOffset(FSGCoreEnumCast::ToEPositionalTrackingHardware(Hardware),
                                                    bRightHanded, PositionOffset, RotationOffset);
 
-    OutPositionOffset = FSGVect3DImpl(PositionOffset).ToFVector();
+    OutPositionOffset = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(PositionOffset);
     OutRotationOffset = FSGQuatImpl(RotationOffset).ToFQuat();
 }
 
 const FVector& FSGTrackingImpl::GetSenseGloveViveToAttachPosition()
 {
-    static const FVector Position(FSGVect3DImpl(FTrackingType::GetSenseGloveViveToAttachPosition()).ToFVector());
+    static const FVector Position{
+        FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+            FTrackingType::GetSenseGloveViveToAttachPosition())
+    };
     return Position;
 }
 
@@ -137,7 +147,10 @@ const FQuat& FSGTrackingImpl::GetSenseGloveViveToAttachRotation()
 
 const FVector& FSGTrackingImpl::GetSenseGloveOculusTouchToAttachPosition()
 {
-    static const FVector Position(FSGVect3DImpl(FTrackingType::GetSenseGloveOculusTouchToAttachPosition()).ToFVector());
+    static const FVector Position{
+        FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+            FTrackingType::GetSenseGloveOculusTouchToAttachPosition())
+    };
     return Position;
 }
 
@@ -149,7 +162,10 @@ const FQuat& FSGTrackingImpl::GetSenseGloveOculusTouchToAttachRotation()
 
 const FVector& FSGTrackingImpl::GetNovaToWristPositionOffset()
 {
-    static const FVector Offset(FSGVect3DImpl(FTrackingType::GetNovaToWristPositionOffset()).ToFVector());
+    static const FVector Offset{
+        FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+            FTrackingType::GetNovaToWristPositionOffset())
+    };
     return Offset;
 }
 
@@ -167,13 +183,16 @@ void FSGTrackingImpl::GetNovaGloveWristOffset(const bool bRightHanded,
 
     FTrackingType::GetNovaGloveWristOffset(bRightHanded, PositionOffset, RotationOffset);
 
-    OutPositionOffset = FSGVect3DImpl(PositionOffset).ToFVector();
+    OutPositionOffset = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(PositionOffset);
     OutRotationOffset = FSGQuatImpl(RotationOffset).ToFQuat();
 }
 
 const FVector& FSGTrackingImpl::GetRightNovaViveToAttachPosition()
 {
-    static const FVector Position(FSGVect3DImpl(FTrackingType::GetRightNovaViveToAttachPosition()).ToFVector());
+    static const FVector Position{
+        FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+            FTrackingType::GetRightNovaViveToAttachPosition())
+    };
     return Position;
 }
 
@@ -185,7 +204,10 @@ const FQuat& FSGTrackingImpl::GetRightNovaViveToAttachRotation()
 
 const FVector& FSGTrackingImpl::GetLeftNovaViveToAttachPosition()
 {
-    static const FVector Position(FSGVect3DImpl(FTrackingType::GetLeftNovaViveToAttachPosition()).ToFVector());
+    static const FVector Position{
+        FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+            FTrackingType::GetLeftNovaViveToAttachPosition())
+    };
     return Position;
 }
 
@@ -197,7 +219,10 @@ const FQuat& FSGTrackingImpl::GetLeftNovaViveToAttachRotation()
 
 const FVector& FSGTrackingImpl::GetRightNovaQuest2ToAttachPosition()
 {
-    static const FVector Position(FSGVect3DImpl(FTrackingType::GetRightNovaQuest2ToAttachPosition()).ToFVector());
+    static const FVector Position{
+        FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+            FTrackingType::GetRightNovaQuest2ToAttachPosition())
+    };
     return Position;
 }
 
@@ -209,7 +234,10 @@ const FQuat& FSGTrackingImpl::GetRightNovaQuest2ToAttachRotation()
 
 const FVector& FSGTrackingImpl::GetLeftNovaQuest2ToAttachPosition()
 {
-    static const FVector Position(FSGVect3DImpl(FTrackingType::GetLeftNovaQuest2ToAttachPosition()).ToFVector());
+    static const FVector Position{
+        FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+            FTrackingType::GetLeftNovaQuest2ToAttachPosition())
+    };
     return Position;
 }
 
@@ -221,7 +249,10 @@ const FQuat& FSGTrackingImpl::GetLeftNovaQuest2ToAttachRotation()
 
 const FVector& FSGTrackingImpl::GetRightNovaPico2ToAttachPosition()
 {
-    static FVector Position(FSGVect3DImpl(FTrackingType::GetRightNovaPico2ToAttachPosition()).ToFVector());
+    static FVector Position{
+        FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+            FTrackingType::GetRightNovaPico2ToAttachPosition())
+    };
     return Position;
 }
 
@@ -246,7 +277,7 @@ void FSGTrackingImpl::GetNovaGloveTrackerOffset(const ESGPositionalTrackingHardw
     FTrackingType::GetNovaGloveTrackerOffset(FSGCoreEnumCast::ToEPositionalTrackingHardware(Hardware), bRightHanded,
                                              PositionOffset, RotationOffset);
 
-    OutPositionOffset = FSGVect3DImpl(PositionOffset).ToFVector();
+    OutPositionOffset = FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(PositionOffset);
     OutRotationOffset = FSGQuatImpl(RotationOffset).ToFQuat();
 }