allow the c++ compiler the opportunity to perform rvo/nrvo if applicable

2024-03-22 21:00:28 +01:00
parent 5136d1eb1b
commit 8ab60555c5
59 changed files with 591 additions and 573 deletions
@@ -423,8 +423,8 @@ const FTransform& USGVirtualHandComponent::GetFingerBoneRefTransform(const int32
 FRotator USGVirtualHandComponent::GetFingerBoneRefRotation(const int32 Finger, const int32 Joint) const
 {
    const FTransform BoneTransform{GetFingerBoneRefTransform(Finger, Joint)};
-    FRotator BoneRotation{BoneTransform.GetRotation().Rotator()};
-    return MoveTemp(BoneRotation);
+    const FRotator BoneRotation{BoneTransform.GetRotation().Rotator()};
+    return BoneRotation;
 }

 TMap<FName, FRotator> USGVirtualHandComponent::GetFingersBonesRotations()
@@ -433,13 +433,13 @@ TMap<FName, FRotator> USGVirtualHandComponent::GetFingersBonesRotations()

    if (!IsGloveConnected())
    {
-        return MoveTemp(Rotations);
+        return Rotations;
    }

    const USGHandPose* HandPose = GetHandPose();
    if (!IsValid(HandPose))
    {
-        return MoveTemp(Rotations);
+        return Rotations;
    }

    const TArray<TArray<FVector>>& HandAngles{HandPose->GetHandAngles()};
@@ -463,7 +463,7 @@ TMap<FName, FRotator> USGVirtualHandComponent::GetFingersBonesRotations()
        }
    }

-    return MoveTemp(Rotations);
+    return Rotations;
 }

 USGVirtualHandComponent::FImpl::FImpl(USGVirtualHandComponent* InOwner)
@@ -497,7 +497,7 @@ FString USGVirtualHandComponent::FImpl::GetDefaultMeshPath() const
        SkeletalMeshPath = GetDefaultLeftHandMeshPath();
    }

-    return MoveTemp(SkeletalMeshPath);
+    return SkeletalMeshPath;
 }

 bool USGVirtualHandComponent::FImpl::IsUsingDefaultMesh() const
@@ -208,7 +208,7 @@ TArray<float> ASGPlayerController::FImpl::GetForceFeedbackLevels(
    const float RingForceFeedbackLevel = GetForceFeedbackLevel(ActorRingTouching);
    const float PinkyForceFeedbackLevel = GetForceFeedbackLevel(ActorPinkyTouching);

-    TArray<float> ForceFeedbackLevels{
+    const TArray<float> ForceFeedbackLevels{
        ThumbForceFeedbackLevel,
        IndexForceFeedbackLevel,
        MiddleForceFeedbackLevel,
@@ -216,7 +216,7 @@ TArray<float> ASGPlayerController::FImpl::GetForceFeedbackLevels(
        PinkyForceFeedbackLevel,
    };

-    return MoveTemp(ForceFeedbackLevels);
+    return ForceFeedbackLevels;
 }

 TArray<float> ASGPlayerController::FImpl::GetVibrotactileLevels(
@@ -232,7 +232,7 @@ TArray<float> ASGPlayerController::FImpl::GetVibrotactileLevels(
    const float RingVibrotactileLevel = GetVibrotactileLevel(ActorRingTouching);
    const float PinkyVibrotactileLevel = GetVibrotactileLevel(ActorPinkyTouching);

-    TArray<float> ForceFeedbackLevels{
+    const TArray<float> ForceFeedbackLevels{
        ThumbVibrotactileLevel,
        IndexVibrotactileLevel,
        MiddleVibrotactileLevel,
@@ -240,7 +240,7 @@ TArray<float> ASGPlayerController::FImpl::GetVibrotactileLevels(
        PinkyVibrotactileLevel,
    };

-    return MoveTemp(ForceFeedbackLevels);
+    return ForceFeedbackLevels;
 }

 ASGPlayerController::ASGPlayerController(const FObjectInitializer& ObjectInitializer)
@@ -88,26 +88,26 @@ TArray<TArray<FVector>> FSGAnatomy::GetDefaultHandAngles(const bool bRightHanded
 {
    FSGIC_TArray_TArray_FVector OutAnglesContainer;
    SGCoreImpl_FSGAnatomyImpl_GetDefaultHandAngles(&OutAnglesContainer, bRightHanded);
-    return MoveTemp(OutAnglesContainer.Array);
+    return OutAnglesContainer.Array;
 }

 TArray<TArray<FVector>> FSGAnatomy::GetFlatHandAngles(const bool bRightHanded)
 {
    FSGIC_TArray_TArray_FVector OutAnglesContainer;
    SGCoreImpl_FSGAnatomyImpl_GetFlatHandAngles(&OutAnglesContainer, bRightHanded);
-    return MoveTemp(OutAnglesContainer.Array);
+    return OutAnglesContainer.Array;
 }

 TArray<TArray<FVector>> FSGAnatomy::GetThumbsUpHandAngles(const bool bRightHanded)
 {
    FSGIC_TArray_TArray_FVector OutAnglesContainer;
    SGCoreImpl_FSGAnatomyImpl_GetThumbsUpHandAngles(&OutAnglesContainer, bRightHanded);
-    return MoveTemp(OutAnglesContainer.Array);
+    return OutAnglesContainer.Array;
 }

 TArray<TArray<FVector>> FSGAnatomy::GetFistHandAngles(const bool bRightHanded)
 {
    FSGIC_TArray_TArray_FVector OutAnglesContainer;
    SGCoreImpl_FSGAnatomyImpl_GetFistHandAngles(&OutAnglesContainer, bRightHanded);
-    return MoveTemp(OutAnglesContainer.Array);
+    return OutAnglesContainer.Array;
 }
@@ -206,21 +206,21 @@ TArray<TArray<float>> USGBasicHandModel::GetBaseFingerLengths()
 {
    FSGIC_TArray_TArray_float OutLengthsContainer;
    SGCoreImpl_FSGBasicHandModelImpl_GetBaseFingerLengths(&OutLengthsContainer);
-    return MoveTemp(OutLengthsContainer.Array);
+    return OutLengthsContainer.Array;
 }

 TArray<FVector> USGBasicHandModel::GetBaseJointPositions()
 {
    FSGIC_TArray_FVector OutPositionsContainer;
    SGCoreImpl_FSGBasicHandModelImpl_GetBaseJointPositions(&OutPositionsContainer);
-    return MoveTemp(OutPositionsContainer.Array);
+    return OutPositionsContainer.Array;
 }

 TArray<FVector> USGBasicHandModel::GetBaseJointAngles()
 {
    FSGIC_TArray_FVector OutRotationsContainer;
    SGCoreImpl_FSGBasicHandModelImpl_GetBaseJointAngles(&OutRotationsContainer);
-    return MoveTemp(OutRotationsContainer.Array);
+    return OutRotationsContainer.Array;
 }

 USGBasicHandModel::USGBasicHandModel()
@@ -361,7 +361,7 @@ TArray<TArray<float>> USGBasicHandModel::GetFingerLengths() const
    FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
    FSGIC_TArray_TArray_float OutLengthsContainer;
    SGCoreImpl_FSGBasicHandModelImpl_GetFingerLengths(&InstanceContainer, &OutLengthsContainer);
-    return MoveTemp(OutLengthsContainer.Array);
+    return OutLengthsContainer.Array;
 }

 TArray<float> USGBasicHandModel::GetFingerLengths(const ESGFinger Finger) const
@@ -371,7 +371,7 @@ TArray<float> USGBasicHandModel::GetFingerLengths(const ESGFinger Finger) const
    FSGIC_ESGFinger FingerContainer{Finger};
    SGCoreImpl_FSGBasicHandModelImpl_GetFingerLengths_Finger(&InstanceContainer, &OutLengthsContainer,
                                                             &FingerContainer);
-    return MoveTemp(OutLengthsContainer.Array);
+    return OutLengthsContainer.Array;
 }

 void USGBasicHandModel::SetFingerLengths(const ESGFinger Finger, const TArray<float>& Lengths)
@@ -395,7 +395,7 @@ TArray<TArray<float>> USGBasicHandModel::GetFingerRatios() const
    FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
    FSGIC_TArray_TArray_float OutRatiosContainer;
    SGCoreImpl_FSGBasicHandModelImpl_GetFingerRatios(&InstanceContainer, &OutRatiosContainer);
-    return MoveTemp(OutRatiosContainer.Array);
+    return OutRatiosContainer.Array;
 }

 TArray<float> USGBasicHandModel::GetFingerRatios(const ESGFinger Finger) const
@@ -405,7 +405,7 @@ TArray<float> USGBasicHandModel::GetFingerRatios(const ESGFinger Finger) const
    FSGIC_TArray_float OutRatiosContainer;
    SGCoreImpl_FSGBasicHandModelImpl_GetFingerRatios_Finger(&InstanceContainer, &OutRatiosContainer,
                                                            &FingerContainer);
-    return MoveTemp(OutRatiosContainer.Array);
+    return OutRatiosContainer.Array;
 }

 TArray<FVector> USGBasicHandModel::GetStartJointPositions() const
@@ -413,7 +413,7 @@ TArray<FVector> USGBasicHandModel::GetStartJointPositions() const
    FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
    FSGIC_TArray_FVector OutPositionsContainer;
    SGCoreImpl_FSGBasicHandModelImpl_GetStartJointPositions(&InstanceContainer, &OutPositionsContainer);
-    return MoveTemp(OutPositionsContainer.Array);
+    return OutPositionsContainer.Array;
 }

 void USGBasicHandModel::SetStartJointPosition(const ESGFinger Finger, const FVector& Position)
@@ -437,7 +437,7 @@ TArray<FQuat> USGBasicHandModel::GetStartJointRotationsQ() const
    FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
    FSGIC_TArray_FQuat OutRotationsContainer;
    SGCoreImpl_FSGBasicHandModelImpl_GetStartJointRotations(&InstanceContainer, &OutRotationsContainer);
-    return MoveTemp(OutRotationsContainer.Array);
+    return OutRotationsContainer.Array;
 }

 TArray<FRotator> USGBasicHandModel::GetStartJointRotations() const
@@ -454,7 +454,7 @@ FVector USGBasicHandModel::GetJointPosition(const ESGFinger Finger) const
    FSGIC_FVector OutPositionContainer;
    FSGIC_ESGFinger FingerContainer{Finger};
    SGCoreImpl_FSGBasicHandModelImpl_GetJointPosition(&InstanceContainer, &OutPositionContainer, &FingerContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 void USGBasicHandModel::SetJointPosition(const FVector& NewPosition, const ESGFinger Finger)
@@ -471,7 +471,7 @@ FQuat USGBasicHandModel::GetJointRotationQ(const ESGFinger Finger) const
    FSGIC_FQuat OutRotationContainer;
    FSGIC_ESGFinger FingerContainer{Finger};
    SGCoreImpl_FSGBasicHandModelImpl_GetJointRotation(&InstanceContainer, &OutRotationContainer, &FingerContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator USGBasicHandModel::GetJointRotation(const ESGFinger Finger) const
@@ -504,7 +504,7 @@ TArray<float> USGBasicHandModel::GetTotalLengths() const
    FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
    FSGIC_TArray_float OutLengthsContainer;
    SGCoreImpl_FSGBasicHandModelImpl_GetTotalLengths(&InstanceContainer, &OutLengthsContainer);
-    return MoveTemp(OutLengthsContainer.Array);
+    return OutLengthsContainer.Array;
 }

 float USGBasicHandModel::GetTotalLength(const ESGFinger Finger) const
@@ -521,7 +521,7 @@ TArray<FVector> USGBasicHandModel::Get3DLengths(const ESGFinger Finger) const
    FSGIC_ESGFinger FingerContainer{Finger};
    SGCoreImpl_FSGBasicHandModelImpl_Get3DLengths(&InstanceContainer, &OutLengthsContainer,
                                                  &FingerContainer);
-    return MoveTemp(OutLengthsContainer.Array);
+    return OutLengthsContainer.Array;
 }

 bool USGBasicHandModel::Equals(const USGBasicHandModel* BasicHandModel) const
@@ -536,7 +536,7 @@ FString USGBasicHandModel::ToString() const
    FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGBasicHandModelImpl_ToString(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 FString USGBasicHandModel::ToString(const bool bLengthsOnly) const
@@ -544,7 +544,7 @@ FString USGBasicHandModel::ToString(const bool bLengthsOnly) const
    FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGBasicHandModelImpl_ToString_bLengthsOnly(&InstanceContainer, &OutStringContainer, bLengthsOnly);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 FString USGBasicHandModel::SGSerialize() const
@@ -552,7 +552,7 @@ FString USGBasicHandModel::SGSerialize() const
    FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGBasicHandModelImpl_Serialize(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 USGBasicHandModel::FImpl::FImpl(USGBasicHandModel* InOwner)
@@ -145,7 +145,7 @@ FString USGBetaDevice::GetDeviceId() const
    FSGIC_TSharedPtr_FSGBetaDeviceImpl InstanceContainer{ToBetaDeviceImpl()};
    FSGIC_FString OutIdContainer;
    SGCoreImpl_FSGBetaDeviceImpl_GetDeviceId(&InstanceContainer, &OutIdContainer);
-    return MoveTemp(OutIdContainer.String);
+    return OutIdContainer.String;
 }

 FString USGBetaDevice::GetHardwareVersion() const
@@ -173,7 +173,7 @@ FString USGBetaDevice::GetConstantsString() const
    FSGIC_TSharedPtr_FSGBetaDeviceImpl InstanceContainer{ToBetaDeviceImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGBetaDeviceImpl_GetConstantsString(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 FString USGBetaDevice::GetSensorData() const
@@ -181,7 +181,7 @@ FString USGBetaDevice::GetSensorData() const
    FSGIC_TSharedPtr_FSGBetaDeviceImpl InstanceContainer{ToBetaDeviceImpl()};
    FSGIC_FString OutDataContainer;
    SGCoreImpl_FSGBetaDeviceImpl_GetSensorData(&InstanceContainer, &OutDataContainer);
-    return MoveTemp(OutDataContainer.String);
+    return OutDataContainer.String;
 }

 FString USGBetaDevice::GetLastCommand() const
@@ -189,7 +189,7 @@ FString USGBetaDevice::GetLastCommand() const
    FSGIC_TSharedPtr_FSGBetaDeviceImpl InstanceContainer{ToBetaDeviceImpl()};
    FSGIC_FString OutCommandContainer;
    SGCoreImpl_FSGBetaDeviceImpl_GetLastCommand(&InstanceContainer, &OutCommandContainer);
-    return MoveTemp(OutCommandContainer.String);
+    return OutCommandContainer.String;
 }

 bool USGBetaDevice::SendHaptics(const FString& Command) const
@@ -204,5 +204,5 @@ FString USGBetaDevice::ToString() const
    FSGIC_TSharedPtr_FSGBetaDeviceImpl InstanceContainer{ToBetaDeviceImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGBetaDeviceImpl_ToString(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }
@@ -108,7 +108,7 @@ FString USGCustomWaveform::ToString(const ESGWaveformType Type)
    FSGIC_ESGWaveformType TypeContainer{Type};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGCustomWaveformImpl_ToString_Type(&OutStringContainer, &TypeContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 USGCustomWaveform::USGCustomWaveform()
@@ -176,7 +176,7 @@ ESGWaveformType USGCustomWaveform::GetWaveType() const
    FSGIC_FSGCustomWaveformImpl InstanceContainer{ToCustomWaveformImpl()};
    FSGIC_ESGWaveformType OutTypeContainer;
    SGCoreImpl_FSGCustomWaveformImpl_GetWaveType(&InstanceContainer, &OutTypeContainer);
-    return MoveTemp(OutTypeContainer.Type);
+    return OutTypeContainer.Type;
 }

 void USGCustomWaveform::SetWaveType(const ESGWaveformType Type)
@@ -324,7 +324,7 @@ FString USGCustomWaveform::ToString() const
    FSGIC_FSGCustomWaveformImpl InstanceContainer{ToCustomWaveformImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGCustomWaveformImpl_ToString(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 USGCustomWaveform::FImpl::FImpl(USGCustomWaveform* InOwner)
@@ -122,7 +122,7 @@ FString USGDevice::ToString(const ESGDeviceType DeviceType)
    FSGIC_ESGDeviceType DeviceTypeContainer{DeviceType};
    FSGIC_FString OutString;
    SGCoreImpl_FSGDeviceImpl_ToString(&DeviceTypeContainer, &OutString);
-    return MoveTemp(OutString.String);
+    return OutString.String;
 }

 USGDevice::USGDevice()
@@ -419,7 +419,7 @@ FString USGDevice::GetFirmwareString() const
    FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGDeviceImpl_GetFirmwareString(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 bool USGDevice::FirmwareNewerThan(int32 FirmwareMain, int32 FirmwareSub, bool bInclusive) const
@@ -534,7 +534,7 @@ FString USGDevice::ToString() const
    FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGDeviceImpl_ToString(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 USGDevice::FImpl::FImpl(USGDevice* InOwner)
@@ -101,7 +101,7 @@ TArray<bool> USGDeviceModel::ParseFunctions(const int32 Value, const int32 Size)
 {
    FSGIC_TArray_bool OutParseFunctionsContainer;
    SGCoreImpl_FSGDeviceModelImpl_ParseFunctions(&OutParseFunctionsContainer, Value, Size);
-    return MoveTemp(OutParseFunctionsContainer.Array);
+    return OutParseFunctionsContainer.Array;
 }

 void USGDeviceModel::ParseFirmware(const FString& RawFirmware, int32& OutMainVersion, int32& OutSubVersion)
@@ -163,7 +163,7 @@ FString USGDeviceModel::GetDeviceId() const
    FSGIC_FSGDeviceModelImpl InstanceContainer{ToDeviceModelImpl()};
    FSGIC_FString OutIdContainer;
    SGCoreImpl_FSGDeviceModelImpl_GetDeviceId(&InstanceContainer, &OutIdContainer);
-    return MoveTemp(OutIdContainer.String);
+    return OutIdContainer.String;
 }

 FString USGDeviceModel::GetHardwareVersion() const
@@ -171,7 +171,7 @@ FString USGDeviceModel::GetHardwareVersion() const
    FSGIC_FSGDeviceModelImpl InstanceContainer{ToDeviceModelImpl()};
    FSGIC_FString OutVersionContainer;
    SGCoreImpl_FSGDeviceModelImpl_GetHardwareVersion(&InstanceContainer, &OutVersionContainer);
-    return MoveTemp(OutVersionContainer.String);
+    return OutVersionContainer.String;
 }

 int32 USGDeviceModel::GetFirmwareVersion() const
@@ -188,7 +188,7 @@ TArray<TArray<FVector>> USGHandInterpolator::InterpolateHandAngles(
    FSGIC_TArray_float AbductionsContainer{Abductions};
    SGCoreImpl_FSGHandInterpolatorImpl_InterpolateHandAngles(
        &InstanceContainer, &OutAnglesContainer, &FlexionsContainer, &AbductionsContainer, CmcTwist);
-    return MoveTemp(OutAnglesContainer.Array);
+    return OutAnglesContainer.Array;
 }

 bool USGHandInterpolator::Equals(const USGHandInterpolator* HandInterpolator) const
@@ -204,7 +204,7 @@ FString USGHandInterpolator::SGSerialize() const
    FSGIC_FSGHandInterpolatorImpl InstanceContainer{ToHandInterpolatorImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGHandInterpolatorImpl_Serialize(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 USGHandInterpolator::FImpl::FImpl(USGHandInterpolator* InOwner)
@@ -92,7 +92,7 @@ FString FSGHandLayer::GetCalibrationInstructions(const bool bRightHanded)
 {
    FSGIC_FString CalibrationInstructionsContainer;
    SGCoreImpl_FSGHandLayerImpl_GetCalibrationInstructions(&CalibrationInstructionsContainer, bRightHanded);
-    return MoveTemp(CalibrationInstructionsContainer.String);
+    return CalibrationInstructionsContainer.String;
 }

 void FSGHandLayer::ResetCalibration(const bool bRightHanded)
@@ -392,7 +392,7 @@ TArray<TArray<FVector>> USGHandPose::GetJointPositions() const
    FSGIC_FSGHandPoseImpl InstanceContainer{ToHandPoseImpl()};
    FSGIC_TArray_TArray_FVector OutPositionsContainer;
    SGCoreImpl_FSGHandPoseImpl_GetJointPositions(&InstanceContainer, &OutPositionsContainer);
-    return MoveTemp(OutPositionsContainer.Array);
+    return OutPositionsContainer.Array;
 }

 TArray<TArray<FQuat>> USGHandPose::GetJointRotationsQ() const
@@ -400,7 +400,7 @@ TArray<TArray<FQuat>> USGHandPose::GetJointRotationsQ() const
    FSGIC_FSGHandPoseImpl InstanceContainer{ToHandPoseImpl()};
    FSGIC_TArray_TArray_FQuat OutRotationsContainer;
    SGCoreImpl_FSGHandPoseImpl_GetJointRotations(&InstanceContainer, &OutRotationsContainer);
-    return MoveTemp(OutRotationsContainer.Array);
+    return OutRotationsContainer.Array;
 }

 TArray<TArray<FRotator>> USGHandPose::GetJointRotations() const
@@ -416,7 +416,7 @@ TArray<TArray<FVector>> USGHandPose::GetHandAngles() const
    FSGIC_FSGHandPoseImpl InstanceContainer{ToHandPoseImpl()};
    FSGIC_TArray_TArray_FVector OutAnglesContainer;
    SGCoreImpl_FSGHandPoseImpl_GetHandAngles(&InstanceContainer, &OutAnglesContainer);
-    return MoveTemp(OutAnglesContainer.Array);
+    return OutAnglesContainer.Array;
 }

 bool USGHandPose::Equals(const USGHandPose* HandPose) const
@@ -439,7 +439,7 @@ TArray<float> USGHandPose::GetNormalizedFlexion(const bool bClamp01) const
    FSGIC_FSGHandPoseImpl InstanceContainer{ToHandPoseImpl()};
    FSGIC_TArray_float OutFlexionContainer;
    SGCoreImpl_FSGHandPoseImpl_GetNormalizedFlexion_bClamp01(&InstanceContainer, &OutFlexionContainer, bClamp01);
-    return MoveTemp(OutFlexionContainer.Array);
+    return OutFlexionContainer.Array;
 }

 FString USGHandPose::ToString(const bool bShortFormat) const
@@ -447,7 +447,7 @@ FString USGHandPose::ToString(const bool bShortFormat) const
    FSGIC_FSGHandPoseImpl InstanceContainer{ToHandPoseImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGHandPoseImpl_ToString(&InstanceContainer, &OutStringContainer, bShortFormat);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 FString USGHandPose::SGSerialize() const
@@ -455,7 +455,7 @@ FString USGHandPose::SGSerialize() const
    FSGIC_FSGHandPoseImpl InstanceContainer{ToHandPoseImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGHandPoseImpl_Serialize(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 USGHandPose::FImpl::FImpl(USGHandPose* InOwner)
@@ -106,7 +106,7 @@ FString USGHapticChannelInfo::GenerateAddress(const int32 DeviceIndex, const int
 {
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGHapticChannelInfoImpl_GenerateAddress(&OutStringContainer, DeviceIndex, ChannelIndex);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 USGHapticChannelInfo* USGHapticChannelInfo::Parse(UObject* Outer, const FString& IpcString)
@@ -194,7 +194,7 @@ FString USGHapticChannelInfo::GetAddress_Unguarded(const ESGHapticChannelType Ty
    FSGIC_ESGHapticChannelType TypeContainer{Type};
    SGCoreImpl_FSGHapticChannelInfoImpl_GetAddress_Unguarded(
        &InstanceContainer, &OutStringContainer, &TypeContainer, TypeIndex);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 void USGHapticChannelInfo::GetIpcParams_Unguarded(
@@ -220,7 +220,7 @@ TArray<FString> USGHapticChannelInfo::GetAllAddresses() const
    FSGIC_FSGHapticChannelInfoImpl InstanceContainer{ToHapticChannelInfoImpl()};
    FSGIC_TArray_FString* OutArrayContainer;
    SGCoreImpl_FSGHapticChannelInfoImpl_GetAllAddresses(&InstanceContainer, &OutArrayContainer);
-    return MoveTemp(OutArrayContainer->Array);
+    return OutArrayContainer->Array;
 }

 USGHapticChannelInfo::FImpl::FImpl(USGHapticChannelInfo* InOwner)
@@ -126,7 +126,7 @@ FString USGHapticGlove::ToString(const ESGHapticGloveCalibrationState State)
    FSGIC_ESGHapticGloveCalibrationState StateContainer{State};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGHapticGloveImpl_ToString_State(&StateContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 FString USGHapticGlove::ToString(const ESGHapticLocation Location)
@@ -134,7 +134,7 @@ FString USGHapticGlove::ToString(const ESGHapticLocation Location)
    FSGIC_ESGHapticLocation LocationContainer{Location};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGHapticGloveImpl_ToString_Location(&LocationContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 USGHapticGlove::USGHapticGlove()
@@ -216,7 +216,7 @@ FString USGHapticGlove::GetDeviceId() const
    FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
    FSGIC_FString OutIdContainer;
    SGCoreImpl_FSGHapticGloveImpl_GetDeviceId(&InstanceContainer, &OutIdContainer);
-    return MoveTemp(OutIdContainer.String);
+    return OutIdContainer.String;
 }

 FString USGHapticGlove::GetHardwareVersion() const
@@ -224,7 +224,7 @@ FString USGHapticGlove::GetHardwareVersion() const
    FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
    FSGIC_FString OutVersionContainer;
    SGCoreImpl_FSGHapticGloveImpl_GetHardwareVersion(&InstanceContainer, &OutVersionContainer);
-    return MoveTemp(OutVersionContainer.String);
+    return OutVersionContainer.String;
 }

 int32 USGHapticGlove::GetFirmwareVersion() const
@@ -360,7 +360,7 @@ FString USGHapticGlove::GetCalibrationInstruction() const
    FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGHapticGloveImpl_GetCalibrationInstruction(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 void USGHapticGlove::StopHaptics()
@@ -511,5 +511,5 @@ FString USGHapticGlove::ToString() const
    FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGHapticGloveImpl_ToString(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }
@@ -256,7 +256,7 @@ FString USGInterpolationSet::ToString() const
    FSGIC_FSGInterpolationSetImpl InstanceContainer{ToInterpolationSetImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGInterpolationSetImpl_ToString(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 FString USGInterpolationSet::ToString(const bool bLimits) const
@@ -264,7 +264,7 @@ FString USGInterpolationSet::ToString(const bool bLimits) const
    FSGIC_FSGInterpolationSetImpl InstanceContainer{ToInterpolationSetImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGInterpolationSetImpl_ToString_bLimits(&InstanceContainer, &OutStringContainer, bLimits);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 FString USGInterpolationSet::SGSerialize() const
@@ -272,7 +272,7 @@ FString USGInterpolationSet::SGSerialize() const
    FSGIC_FSGInterpolationSetImpl InstanceContainer{ToInterpolationSetImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGInterpolationSetImpl_Serialize(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 USGInterpolationSet::FImpl::FImpl(USGInterpolationSet* InOwner)
@@ -121,7 +121,7 @@ TArray<USGNova2Glove*> USGNova2Glove::GetNova2Gloves(UObject* Outer)
        USGNova2Glove* Nova2Glove = USGNova2Glove::NewNova2Glove(Outer, Nova2GloveImpl);
        Gloves.Add(Nova2Glove);
    }
-    return MoveTemp(Gloves);
+    return Gloves;
 }

 bool USGNova2Glove::GetNova2Glove(UObject* Outer, USGNova2Glove*& OutGlove)
@@ -244,7 +244,7 @@ TArray<float> USGNova2Glove::GetNova2SensorRanges()
 {
    FSGIC_TArray_float OutNova2SensorRangesContainer;
    SGCoreImpl_FSGNova2GloveImpl_GetNova2SensorRanges(&OutNova2SensorRangesContainer);
-    return MoveTemp(OutNova2SensorRangesContainer.Array);
+    return OutNova2SensorRangesContainer.Array;
 }

 TArray<float> USGNova2Glove::ToNormalizedValues(const USGNova2GloveSensorData* SensorData)
@@ -253,7 +253,7 @@ TArray<float> USGNova2Glove::ToNormalizedValues(const USGNova2GloveSensorData* S
    FSGIC_FSGNova2GloveSensorDataImpl SensorDataContainer{SensorData->ToNova2GloveSensorDataImpl()};
    SGCoreImpl_FSGNova2GloveImpl_ToNormalizedValues_SensorData(
        &OutNormalizedValuesContainer, &SensorDataContainer);
-    return MoveTemp(OutNormalizedValuesContainer.Array);
+    return OutNormalizedValuesContainer.Array;
 }

 TArray<float> USGNova2Glove::ToNormalizedValues(
@@ -268,7 +268,7 @@ TArray<float> USGNova2Glove::ToNormalizedValues(
    OutSensorNormalizer = USGSensorNormalization::NewSensorNormalization(
        Outer, MoveTemp(OutSensorNormalizerContainer.SensorNormalizationImpl));

-    return MoveTemp(OutNormalizedValuesContainer.Array);
+    return OutNormalizedValuesContainer.Array;
 }

 TArray<TArray<FVector>> USGNova2Glove::CalculateHandAngles(
@@ -279,7 +279,7 @@ TArray<TArray<FVector>> USGNova2Glove::CalculateHandAngles(
    FSGIC_FSGHandInterpolatorImpl InterpolatorContainer{Interpolator->ToHandInterpolatorImpl()};
    SGCoreImpl_FSGNova2GloveImpl_CalculateHandAngles(
        &OutHandAnglesContainer, &NormalizedValuesContainer, &InterpolatorContainer, bInfluenceIndex);
-    return MoveTemp(OutHandAnglesContainer.Array);
+    return OutHandAnglesContainer.Array;
 }

 TArray<TArray<FVector>> USGNova2Glove::ToNormalizedAngles(
@@ -290,7 +290,7 @@ TArray<TArray<FVector>> USGNova2Glove::ToNormalizedAngles(
    FSGIC_FSGNovaGloveInfoImpl GloveInfoContainer{GloveInfo->ToNovaGloveInfoImpl()};
    SGCoreImpl_FSGNova2GloveImpl_ToNormalizedAngles(
        &OutHandAnglesContainer, &NormalizedDataContainer, &GloveInfoContainer);
-    return MoveTemp(OutHandAnglesContainer.Array);
+    return OutHandAnglesContainer.Array;
 }

 USGNova2Glove::USGNova2Glove()
@@ -362,7 +362,7 @@ FString USGNova2Glove::GetDeviceId() const
    FSGIC_TSharedPtr_FSGNova2GloveImpl InstanceContainer{ToNova2GloveImpl()};
    FSGIC_FString OutIdContainer;
    SGCoreImpl_FSGNova2GloveImpl_GetDeviceId(&InstanceContainer, &OutIdContainer);
-    return MoveTemp(OutIdContainer.String);
+    return OutIdContainer.String;
 }

 FString USGNova2Glove::GetHardwareVersion() const
@@ -370,7 +370,7 @@ FString USGNova2Glove::GetHardwareVersion() const
    FSGIC_TSharedPtr_FSGNova2GloveImpl InstanceContainer{ToNova2GloveImpl()};
    FSGIC_FString OutVersionContainer;
    SGCoreImpl_FSGNova2GloveImpl_GetHardwareVersion(&InstanceContainer, &OutVersionContainer);
-    return MoveTemp(OutVersionContainer.String);
+    return OutVersionContainer.String;
 }

 int32 USGNova2Glove::GetFirmwareVersion() const
@@ -471,7 +471,7 @@ ESGHapticGloveCalibrationState USGNova2Glove::GetCalibrationState() const
    FSGIC_TSharedPtr_FSGNova2GloveImpl InstanceContainer{ToNova2GloveImpl()};
    FSGIC_ESGHapticGloveCalibrationState OutHapticGloveCalibrationStateContainer;
    SGCoreImpl_FSGNova2GloveImpl_GetCalibrationState(&InstanceContainer, &OutHapticGloveCalibrationStateContainer);
-    return MoveTemp(OutHapticGloveCalibrationStateContainer.State);
+    return OutHapticGloveCalibrationStateContainer.State;
 }

 void USGNova2Glove::EndCalibration()
@@ -738,5 +738,5 @@ FString USGNova2Glove::ToString() const
    FSGIC_TSharedPtr_FSGNova2GloveImpl InstanceContainer{ToNova2GloveImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGNova2GloveImpl_ToString(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);;
+    return OutStringContainer.String;;
 }
@@ -297,7 +297,7 @@ TArray<TArray<FVector>> USGNova2GloveSensorData::GetSensorValues() const
    FSGIC_FSGNova2GloveSensorDataImpl InstanceContainer{ToNova2GloveSensorDataImpl()};
    FSGIC_TArray_TArray_FVector OutValuesContainer;
    SGCoreImpl_FSGNova2GloveSensorDataImpl_GetSensorValues(&InstanceContainer, &OutValuesContainer);
-    return MoveTemp(OutValuesContainer.Array);
+    return OutValuesContainer.Array;
 }

 float USGNova2GloveSensorData::GetSensorValue(const ESGFinger Finger, const ESGNova2SensorLocation Location) const
@@ -320,7 +320,7 @@ FQuat USGNova2GloveSensorData::GetImuRotationQ() const
    FSGIC_FSGNova2GloveSensorDataImpl InstanceContainer{ToNova2GloveSensorDataImpl()};
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGNova2GloveSensorDataImpl_GetImuRotation(&InstanceContainer, &OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator USGNova2GloveSensorData::GetImuRotation() const
@@ -361,7 +361,7 @@ FString USGNova2GloveSensorData::ToString() const
    FSGIC_FSGNova2GloveSensorDataImpl InstanceContainer{ToNova2GloveSensorDataImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGNova2GloveSensorDataImpl_ToString(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 USGNova2GloveSensorData::FImpl::FImpl(USGNova2GloveSensorData* InOwner)
@@ -121,7 +121,7 @@ TArray<USGNovaGlove*> USGNovaGlove::GetNovaGloves(UObject* Outer)
        USGNovaGlove* NovaGlove = USGNovaGlove::NewNovaGlove(Outer, NovaGloveImpl);
        Gloves.Add(NovaGlove);
    }
-    return MoveTemp(Gloves);
+    return Gloves;
 }

 bool USGNovaGlove::GetNovaGlove(UObject* Outer, USGNovaGlove*& OutGlove)
@@ -250,7 +250,7 @@ TArray<float> USGNovaGlove::GetNovaSensorRanges()
 {
    FSGIC_TArray_float OutNovaSensorRangesContainer;
    SGCoreImpl_FSGNovaGloveImpl_GetNovaSensorRanges(&OutNovaSensorRangesContainer);
-    return MoveTemp(OutNovaSensorRangesContainer.Array);
+    return OutNovaSensorRangesContainer.Array;
 }

 TArray<float> USGNovaGlove::ToNormalizedValues(const USGNovaGloveSensorData* SensorData)
@@ -259,7 +259,7 @@ TArray<float> USGNovaGlove::ToNormalizedValues(const USGNovaGloveSensorData* Sen
    FSGIC_FSGNovaGloveSensorDataImpl SensorDataContainer{SensorData->ToNovaGloveSensorDataImpl()};
    SGCoreImpl_FSGNovaGloveImpl_ToNormalizedValues_SensorData(
        &OutNormalizedValuesContainer, &SensorDataContainer);
-    return MoveTemp(OutNormalizedValuesContainer.Array);
+    return OutNormalizedValuesContainer.Array;
 }

 TArray<float> USGNovaGlove::ToNormalizedValues(
@@ -274,7 +274,7 @@ TArray<float> USGNovaGlove::ToNormalizedValues(
    OutSensorNormalizer = USGSensorNormalization::NewSensorNormalization(
        Outer, MoveTemp(OutSensorNormalizerContainer.SensorNormalizationImpl));

-    return MoveTemp(OutNormalizedValuesContainer.Array);
+    return OutNormalizedValuesContainer.Array;
 }

 TArray<TArray<FVector>> USGNovaGlove::CalculateHandAngles(
@@ -285,7 +285,7 @@ TArray<TArray<FVector>> USGNovaGlove::CalculateHandAngles(
    FSGIC_FSGHandInterpolatorImpl InterpolatorContainer{Interpolator->ToHandInterpolatorImpl()};
    SGCoreImpl_FSGNovaGloveImpl_CalculateHandAngles(
        &OutHandAnglesContainer, &NormalizedValuesContainer, &InterpolatorContainer);
-    return MoveTemp(OutHandAnglesContainer.Array);
+    return OutHandAnglesContainer.Array;
 }

 FString USGNovaGlove::ToNovaCommandAsFlexion(const USGThresholdCommand* Thresholds)
@@ -293,7 +293,7 @@ FString USGNovaGlove::ToNovaCommandAsFlexion(const USGThresholdCommand* Threshol
    FSGIC_FString OutStringContainer;
    FSGIC_FSGThresholdCommandImpl ThresholdsContainer{Thresholds->ToThresholdCommandImpl()};
    SGCoreImpl_FSGNovaGloveImpl_ToNovaCommandAsFlexion(&OutStringContainer, &ThresholdsContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 FString USGNovaGlove::ToNovaCommandAsRaw(
@@ -304,7 +304,7 @@ FString USGNovaGlove::ToNovaCommandAsRaw(
    FSGIC_FSGSensorNormalizationImpl InterpolatorContainer{Interpolator->ToSensorNormalizationImpl()};
    SGCoreImpl_FSGNovaGloveImpl_ToNovaCommandAsRaw(
        &OutStringContainer, &ThresholdsContainer, &InterpolatorContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 USGNovaGlove::USGNovaGlove()
@@ -376,7 +376,7 @@ FString USGNovaGlove::GetDeviceId() const
    FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
    FSGIC_FString OutIdContainer;
    SGCoreImpl_FSGNovaGloveImpl_GetDeviceId(&InstanceContainer, &OutIdContainer);
-    return MoveTemp(OutIdContainer.String);
+    return OutIdContainer.String;
 }

 FString USGNovaGlove::GetHardwareVersion() const
@@ -384,7 +384,7 @@ FString USGNovaGlove::GetHardwareVersion() const
    FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
    FSGIC_FString OutVersionContainer;
    SGCoreImpl_FSGNovaGloveImpl_GetHardwareVersion(&InstanceContainer, &OutVersionContainer);
-    return MoveTemp(OutVersionContainer.String);
+    return OutVersionContainer.String;
 }

 int32 USGNovaGlove::GetFirmwareVersion() const
@@ -491,7 +491,7 @@ ESGHapticGloveCalibrationState USGNovaGlove::GetCalibrationState() const
    FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
    FSGIC_ESGHapticGloveCalibrationState OutHapticGloveCalibrationStateContainer;
    SGCoreImpl_FSGNovaGloveImpl_GetCalibrationState(&InstanceContainer, &OutHapticGloveCalibrationStateContainer);
-    return MoveTemp(OutHapticGloveCalibrationStateContainer.State);
+    return OutHapticGloveCalibrationStateContainer.State;
 }

 void USGNovaGlove::EndCalibration()
@@ -711,7 +711,7 @@ FString USGNovaGlove::ToNovaCommand(
    FSGIC_TArray_float BuzzLevelsContainer{BuzzLevels};
    SGCoreImpl_FSGNovaGloveImpl_ToNovaCommand(&InstanceContainer, &OutStringContainer,
                                              &ForceFeedbackLevelsContainer, &BuzzLevelsContainer, WristLevel);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 bool USGNovaGlove::QueueVibroLevel(const int32 Finger, const float Amplitude)
@@ -777,5 +777,5 @@ FString USGNovaGlove::ToString() const
    FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGNovaGloveImpl_ToString(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);;
+    return OutStringContainer.String;;
 }
@@ -182,7 +182,7 @@ FString USGNovaGloveInfo::GetDeviceId() const
    FSGIC_FSGNovaGloveInfoImpl InstanceContainer{ToNovaGloveInfoImpl()};
    FSGIC_FString OutIdContainer;
    SGCoreImpl_FSGNovaGloveInfoImpl_GetDeviceId(&InstanceContainer, &OutIdContainer);
-    return MoveTemp(OutIdContainer.String);
+    return OutIdContainer.String;
 }

 FString USGNovaGloveInfo::GetHardwareVersion() const
@@ -190,7 +190,7 @@ FString USGNovaGloveInfo::GetHardwareVersion() const
    FSGIC_FSGNovaGloveInfoImpl InstanceContainer{ToNovaGloveInfoImpl()};
    FSGIC_FString OutVersionContainer;
    SGCoreImpl_FSGNovaGloveInfoImpl_GetHardwareVersion(&InstanceContainer, &OutVersionContainer);
-    return MoveTemp(OutVersionContainer.String);
+    return OutVersionContainer.String;
 }

 int32 USGNovaGloveInfo::GetFirmwareVersion() const
@@ -216,7 +216,7 @@ FQuat USGNovaGloveInfo::GetImuCorrectionQ() const
    FSGIC_FSGNovaGloveInfoImpl InstanceContainer{ToNovaGloveInfoImpl()};
    FSGIC_FQuat OutCorrectionContainer;
    SGCoreImpl_FSGNovaGloveInfoImpl_GetImuCorrection(&InstanceContainer, &OutCorrectionContainer);
-    return MoveTemp(OutCorrectionContainer.Quat);
+    return OutCorrectionContainer.Quat;
 }

 FRotator USGNovaGloveInfo::GetImuCorrection() const
@@ -261,7 +261,7 @@ FString USGNovaGloveInfo::ToString() const
    FSGIC_FSGNovaGloveInfoImpl InstanceContainer{ToNovaGloveInfoImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGNovaGloveInfoImpl_ToString(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 FString USGNovaGloveInfo::SGSerialize() const
@@ -269,7 +269,7 @@ FString USGNovaGloveInfo::SGSerialize() const
    FSGIC_FSGNovaGloveInfoImpl InstanceContainer{ToNovaGloveInfoImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGNovaGloveInfoImpl_Serialize(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 USGNovaGloveInfo::FImpl::FImpl(USGNovaGloveInfo* InOwner)
@@ -213,7 +213,7 @@ TArray<FVector> USGNovaGloveSensorData::GetSensorValues() const
    FSGIC_FSGNovaGloveSensorDataImpl InstanceContainer{ToNovaGloveSensorDataImpl()};
    FSGIC_TArray_FVector OutValuesContainer;
    SGCoreImpl_FSGNovaGloveSensorDataImpl_GetSensorValues(&InstanceContainer, &OutValuesContainer);
-    return MoveTemp(OutValuesContainer.Array);
+    return OutValuesContainer.Array;
 }

 float USGNovaGloveSensorData::GetSensorValue(const ESGFinger Finger, const ESGNovaSensorLocation Location) const
@@ -236,7 +236,7 @@ FQuat USGNovaGloveSensorData::GetImuRotationQ() const
    FSGIC_FSGNovaGloveSensorDataImpl InstanceContainer{ToNovaGloveSensorDataImpl()};
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGNovaGloveSensorDataImpl_GetImuRotation(&InstanceContainer, &OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator USGNovaGloveSensorData::GetImuRotation() const
@@ -277,7 +277,7 @@ FString USGNovaGloveSensorData::ToString() const
    FSGIC_FSGNovaGloveSensorDataImpl InstanceContainer{ToNovaGloveSensorDataImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGNovaGloveSensorDataImpl_ToString(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 FString USGNovaGloveSensorData::SGSerialize() const
@@ -285,7 +285,7 @@ FString USGNovaGloveSensorData::SGSerialize() const
    FSGIC_FSGNovaGloveSensorDataImpl InstanceContainer{ToNovaGloveSensorDataImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGNovaGloveSensorDataImpl_Serialize(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 USGNovaGloveSensorData::FImpl::FImpl(USGNovaGloveSensorData* InOwner)
@@ -120,7 +120,7 @@ TArray<USGSenseGlove*> USGSenseGlove::GetSenseGloves(UObject* Outer)
        USGSenseGlove* SenseGlove = USGSenseGlove::NewSenseGlove(Outer, SenseGloveImpl);
        Gloves.Add(SenseGlove);
    }
-    return MoveTemp(Gloves);
+    return Gloves;
 }

 bool USGSenseGlove::GetSenseGlove(UObject* Outer, USGSenseGlove*& OutGlove)
@@ -262,7 +262,7 @@ FVector USGSenseGlove::GetDefaultThimbleOffset()
 {
    FSGIC_FVector OutOffsetContainer;
    SGCoreImpl_FSGSenseGloveImpl_GetDefaultThimbleOffset(&OutOffsetContainer);
-    return MoveTemp(OutOffsetContainer.Vector);
+    return OutOffsetContainer.Vector;
 }

 USGSenseGlovePose* USGSenseGlove::CalculateGlovePose(UObject* Outer,
@@ -401,7 +401,7 @@ FString USGSenseGlove::GetDeviceId() const
    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FString OutIdContainer;
    SGCoreImpl_FSGSenseGloveImpl_GetDeviceId(&InstanceContainer, &OutIdContainer);
-    return MoveTemp(OutIdContainer.String);
+    return OutIdContainer.String;
 }

 FString USGSenseGlove::GetHardwareVersion() const
@@ -409,7 +409,7 @@ FString USGSenseGlove::GetHardwareVersion() const
    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FString OutVersionContainer;
    SGCoreImpl_FSGSenseGloveImpl_GetHardwareVersion(&InstanceContainer, &OutVersionContainer);
-    return MoveTemp(OutVersionContainer.String);
+    return OutVersionContainer.String;
 }

 int32 USGSenseGlove::GetFirmwareVersion() const
@@ -488,7 +488,7 @@ ESGHapticGloveCalibrationState USGSenseGlove::GetCalibrationState() const
    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_ESGHapticGloveCalibrationState OutHapticGloveCalibrationStateContainer;
    SGCoreImpl_FSGSenseGloveImpl_GetCalibrationState(&InstanceContainer, &OutHapticGloveCalibrationStateContainer);
-    return MoveTemp(OutHapticGloveCalibrationStateContainer.State);
+    return OutHapticGloveCalibrationStateContainer.State;
 }

 void USGSenseGlove::EndCalibration()
@@ -739,7 +739,7 @@ TArray<FVector> USGSenseGlove::GetFingerThimbleOffsets() const
    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_TArray_FVector OutFingerThimbleOffsetsContainer;
    SGCoreImpl_FSGSenseGloveImpl_GetFingerThimbleOffsets(&InstanceContainer, &OutFingerThimbleOffsetsContainer);
-    return MoveTemp(OutFingerThimbleOffsetsContainer.Array);
+    return OutFingerThimbleOffsetsContainer.Array;
 }

 void USGSenseGlove::SetFingerThimbleOffset(const int32 Finger, const FVector& Offset)
@@ -822,5 +822,5 @@ FString USGSenseGlove::ToString() const
    FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGSenseGloveImpl_ToString(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);;
+    return OutStringContainer.String;;
 }
@@ -375,7 +375,7 @@ FString USGSenseGloveInfo::GetDeviceId() const
    FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
    FSGIC_FString OutIdContainer;
    SGCoreImpl_FSGSenseGloveInfoImpl_GetDeviceId(&InstanceContainer, &OutIdContainer);
-    return MoveTemp(OutIdContainer.String);
+    return OutIdContainer.String;
 }

 FString USGSenseGloveInfo::GetHardwareVersion() const
@@ -383,7 +383,7 @@ FString USGSenseGloveInfo::GetHardwareVersion() const
    FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
    FSGIC_FString OutVersionContainer;
    SGCoreImpl_FSGSenseGloveInfoImpl_GetHardwareVersion(&InstanceContainer, &OutVersionContainer);
-    return MoveTemp(OutVersionContainer.String);
+    return OutVersionContainer.String;
 }

 int32 USGSenseGloveInfo::GetFirmwareVersion() const
@@ -415,7 +415,7 @@ FQuat USGSenseGloveInfo::GetImuCorrectionQ() const
    FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
    FSGIC_FQuat OutCorrectionContainer;
    SGCoreImpl_FSGSenseGloveInfoImpl_GetImuCorrection(&InstanceContainer, &OutCorrectionContainer);
-    return MoveTemp(OutCorrectionContainer.Quat);
+    return OutCorrectionContainer.Quat;
 }

 FRotator USGSenseGloveInfo::GetImuCorrection() const
@@ -431,7 +431,7 @@ TArray<FVector> USGSenseGloveInfo::GetStartPositions() const
    FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
    FSGIC_TArray_FVector OutPositionsContainer;
    SGCoreImpl_FSGSenseGloveInfoImpl_GetStartPositions(&InstanceContainer, &OutPositionsContainer);
-    return MoveTemp(OutPositionsContainer.Array);
+    return OutPositionsContainer.Array;
 }

 TArray<FQuat> USGSenseGloveInfo::GetStartRotationsQ() const
@@ -439,7 +439,7 @@ TArray<FQuat> USGSenseGloveInfo::GetStartRotationsQ() const
    FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
    FSGIC_TArray_FQuat OutRotationsContainer;
    SGCoreImpl_FSGSenseGloveInfoImpl_GetStartRotations(&InstanceContainer, &OutRotationsContainer);
-    return MoveTemp(OutRotationsContainer.Array);
+    return OutRotationsContainer.Array;
 }

 TArray<FRotator> USGSenseGloveInfo::GetStartRotations() const
@@ -455,7 +455,7 @@ TArray<TArray<FVector>> USGSenseGloveInfo::GetGloveLengths() const
    FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
    FSGIC_TArray_TArray_FVector OutLengthsContainer;
    SGCoreImpl_FSGSenseGloveInfoImpl_GetGloveLengths(&InstanceContainer, &OutLengthsContainer);
-    return MoveTemp(OutLengthsContainer.Array);
+    return OutLengthsContainer.Array;
 }

 TArray<bool> USGSenseGloveInfo::GetFunctions() const
@@ -463,7 +463,7 @@ TArray<bool> USGSenseGloveInfo::GetFunctions() const
    FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
    FSGIC_TArray_bool OutFunctionsContainer;
    SGCoreImpl_FSGSenseGloveInfoImpl_GetFunctions(&InstanceContainer, &OutFunctionsContainer);
-    return MoveTemp(OutFunctionsContainer.Array);
+    return OutFunctionsContainer.Array;
 }

 FVector USGSenseGloveInfo::GetStartPosition(const ESGFinger Finger) const
@@ -472,7 +472,7 @@ FVector USGSenseGloveInfo::GetStartPosition(const ESGFinger Finger) const
    FSGIC_FVector OutPositionContainer;
    FSGIC_ESGFinger FingerContainer{Finger};
    SGCoreImpl_FSGSenseGloveInfoImpl_GetStartPosition(&InstanceContainer, &OutPositionContainer, &FingerContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat USGSenseGloveInfo::GetStartRotationQ(const ESGFinger Finger) const
@@ -481,7 +481,7 @@ FQuat USGSenseGloveInfo::GetStartRotationQ(const ESGFinger Finger) const
    FSGIC_FQuat OutRotationContainer;
    FSGIC_ESGFinger FingerContainer{Finger};
    SGCoreImpl_FSGSenseGloveInfoImpl_GetStartRotation(&InstanceContainer, &OutRotationContainer, &FingerContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator USGSenseGloveInfo::GetStartRotation(const ESGFinger Finger) const
@@ -499,7 +499,7 @@ TArray<FVector> USGSenseGloveInfo::GetGloveLengths(const ESGFinger Finger) const
    FSGIC_TArray_FVector OutLengths;
    FSGIC_ESGFinger FingerContainer{Finger};
    SGCoreImpl_FSGSenseGloveInfoImpl_GetGloveLengths_Finger(&InstanceContainer, &OutLengths, &FingerContainer);
-    return MoveTemp(OutLengths.Array);
+    return OutLengths.Array;
 }

 TArray<TArray<FVector>> USGSenseGloveInfo::ToGloveAngles(const TArray<TArray<float>>& SensorAngles) const
@@ -508,7 +508,7 @@ TArray<TArray<FVector>> USGSenseGloveInfo::ToGloveAngles(const TArray<TArray<flo
    FSGIC_TArray_TArray_FVector OutAnglesContainer;
    FSGIC_TArray_TArray_float SensorAnglesContainer{SensorAngles};
    SGCoreImpl_FSGSenseGloveInfoImpl_ToGloveAngles(&InstanceContainer, &OutAnglesContainer, &SensorAnglesContainer);
-    return MoveTemp(OutAnglesContainer.Array);
+    return OutAnglesContainer.Array;
 }

 bool USGSenseGloveInfo::Equals(const USGSenseGloveInfo* SenseGloveInfo) const
@@ -523,7 +523,7 @@ FString USGSenseGloveInfo::ToString(const bool bShortNotation) const
    FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGSenseGloveInfoImpl_ToString_bShortNotation(&InstanceContainer, &OutStringContainer, bShortNotation);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 FString USGSenseGloveInfo::ToString() const
@@ -531,7 +531,7 @@ FString USGSenseGloveInfo::ToString() const
    FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGSenseGloveInfoImpl_ToString(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 FString USGSenseGloveInfo::SGSerialize() const
@@ -539,7 +539,7 @@ FString USGSenseGloveInfo::SGSerialize() const
    FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGSenseGloveInfoImpl_Serialize(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 USGSenseGloveInfo::FImpl::FImpl(USGSenseGloveInfo* InOwner)
@@ -304,7 +304,7 @@ TArray<TArray<FVector>> USGSenseGlovePose::GetJointPositions() const
    FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
    FSGIC_TArray_TArray_FVector OutPositionsContainer;
    SGCoreImpl_FSGSenseGlovePoseImpl_GetJointPositions(&InstanceContainer, &OutPositionsContainer);
-    return MoveTemp(OutPositionsContainer.Array);
+    return OutPositionsContainer.Array;
 }

 TArray<TArray<FQuat>> USGSenseGlovePose::GetJointRotationsQ() const
@@ -312,7 +312,7 @@ TArray<TArray<FQuat>> USGSenseGlovePose::GetJointRotationsQ() const
    FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
    FSGIC_TArray_TArray_FQuat OutRotationsContainer;
    SGCoreImpl_FSGSenseGlovePoseImpl_GetJointRotations(&InstanceContainer, &OutRotationsContainer);
-    return MoveTemp(OutRotationsContainer.Array);
+    return OutRotationsContainer.Array;
 }

 TArray<TArray<FRotator>> USGSenseGlovePose::GetJointRotations() const
@@ -328,7 +328,7 @@ TArray<TArray<FVector>> USGSenseGlovePose::GetGloveAngles() const
    FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
    FSGIC_TArray_TArray_FVector OutAnglesContainer;
    SGCoreImpl_FSGSenseGlovePoseImpl_GetGloveAngles(&InstanceContainer, &OutAnglesContainer);
-    return MoveTemp(OutAnglesContainer.Array);
+    return OutAnglesContainer.Array;
 }

 TArray<FVector> USGSenseGlovePose::GetThimblePositions() const
@@ -336,7 +336,7 @@ TArray<FVector> USGSenseGlovePose::GetThimblePositions() const
    FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
    FSGIC_TArray_FVector OutPositionsContainer;
    SGCoreImpl_FSGSenseGlovePoseImpl_GetThimblePositions(&InstanceContainer, &OutPositionsContainer);
-    return MoveTemp(OutPositionsContainer.Array);
+    return OutPositionsContainer.Array;
 }

 TArray<FQuat> USGSenseGlovePose::GetThimbleRotationsQ() const
@@ -344,7 +344,7 @@ TArray<FQuat> USGSenseGlovePose::GetThimbleRotationsQ() const
    FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
    FSGIC_TArray_FQuat OutRotationsContainer;
    SGCoreImpl_FSGSenseGlovePoseImpl_GetThimbleRotations(&InstanceContainer, &OutRotationsContainer);
-    return MoveTemp(OutRotationsContainer.Array);
+    return OutRotationsContainer.Array;
 }

 TArray<FRotator> USGSenseGlovePose::GetThimbleRotations() const
@@ -360,7 +360,7 @@ TArray<FVector> USGSenseGlovePose::GetTotalGloveAngles() const
    FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
    FSGIC_TArray_FVector OutAnglesContainer;
    SGCoreImpl_FSGSenseGlovePoseImpl_GetTotalGloveAngles(&InstanceContainer, &OutAnglesContainer);
-    return MoveTemp(OutAnglesContainer.Array);
+    return OutAnglesContainer.Array;
 }

 TArray<FVector> USGSenseGlovePose::CalculateFingertips(const TArray<FVector>& FingerOffsets) const
@@ -370,7 +370,7 @@ TArray<FVector> USGSenseGlovePose::CalculateFingertips(const TArray<FVector>& Fi
    FSGIC_TArray_FVector FingerOffsetsContainer{FingerOffsets};
    SGCoreImpl_FSGSenseGlovePoseImpl_CalculateFingertips(&InstanceContainer, &OutFingertipsContainer,
                                                         &FingerOffsetsContainer);
-    return MoveTemp(OutFingertipsContainer.Array);
+    return OutFingertipsContainer.Array;
 }

 bool USGSenseGlovePose::Equals(const USGSenseGlovePose* SenseGlovePose) const
@@ -385,7 +385,7 @@ FString USGSenseGlovePose::ToString(const bool bShortFormat) const
    FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGSenseGlovePoseImpl_ToString(&InstanceContainer, &OutStringContainer, bShortFormat);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 FString USGSenseGlovePose::SGSerialize() const
@@ -393,7 +393,7 @@ FString USGSenseGlovePose::SGSerialize() const
    FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGSenseGlovePoseImpl_Serialize(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 USGSenseGlovePose::FImpl::FImpl(USGSenseGlovePose* InOwner)
@@ -266,7 +266,7 @@ TArray<TArray<float>> USGSenseGloveSensorData::GetSensorAngles() const
    FSGIC_FSGSenseGloveSensorDataImpl InstanceContainer{ToSenseGloveSensorDataImpl()};
    FSGIC_TArray_TArray_float OutAnglesContainer;
    SGCoreImpl_FSGSenseGloveSensorDataImpl_GetSensorAngles(&InstanceContainer, &OutAnglesContainer);
-    return MoveTemp(OutAnglesContainer.Array);
+    return OutAnglesContainer.Array;
 }

 TArray<float> USGSenseGloveSensorData::GetSensorAngles(const ESGFinger Finger) const
@@ -276,7 +276,7 @@ TArray<float> USGSenseGloveSensorData::GetSensorAngles(const ESGFinger Finger) c
    FSGIC_ESGFinger FingerContainer{Finger};
    SGCoreImpl_FSGSenseGloveSensorDataImpl_GetSensorAngles_Finger(&InstanceContainer, &OutAnglesContainer,
                                                                  &FingerContainer);
-    return MoveTemp(OutAnglesContainer.Array);
+    return OutAnglesContainer.Array;
 }

 TArray<float> USGSenseGloveSensorData::GetAngleSequence() const
@@ -284,7 +284,7 @@ TArray<float> USGSenseGloveSensorData::GetAngleSequence() const
    FSGIC_FSGSenseGloveSensorDataImpl InstanceContainer{ToSenseGloveSensorDataImpl()};
    FSGIC_TArray_float OutSequenceContainer;
    SGCoreImpl_FSGSenseGloveSensorDataImpl_GetAngleSequence(&InstanceContainer, &OutSequenceContainer);
-    return MoveTemp(OutSequenceContainer.Array);
+    return OutSequenceContainer.Array;
 }

 FQuat USGSenseGloveSensorData::GetImuRotationQ() const
@@ -292,7 +292,7 @@ FQuat USGSenseGloveSensorData::GetImuRotationQ() const
    FSGIC_FSGSenseGloveSensorDataImpl InstanceContainer{ToSenseGloveSensorDataImpl()};
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGSenseGloveSensorDataImpl_GetImuRotation(&InstanceContainer, &OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator USGSenseGloveSensorData::GetImuRotation() const
@@ -327,7 +327,7 @@ FString USGSenseGloveSensorData::ToString() const
    FSGIC_FSGSenseGloveSensorDataImpl InstanceContainer{ToSenseGloveSensorDataImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGSenseGloveSensorDataImpl_ToString(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 FString USGSenseGloveSensorData::SGSerialize() const
@@ -335,7 +335,7 @@ FString USGSenseGloveSensorData::SGSerialize() const
    FSGIC_FSGSenseGloveSensorDataImpl InstanceContainer{ToSenseGloveSensorDataImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGSenseGloveSensorDataImpl_Serialize(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 USGSenseGloveSensorData::FImpl::FImpl(USGSenseGloveSensorData* InOwner)
@@ -54,7 +54,7 @@ FString FSGSenseGloveVars::GetStandardConstantsString(const FString& HardwareVer
    SGCoreImpl_FSGSenseGloveVarsImpl_GetStandardConstantsString(&OutStringContainer,
                                                                &HardwareVersionContainer, FirmwareVersion,
                                                                bRightHanded);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 FString FSGSenseGloveVars::GetSensorString(const FString& HardwareVersion, const float FirmwareVersion)
@@ -62,7 +62,7 @@ FString FSGSenseGloveVars::GetSensorString(const FString& HardwareVersion, const
    FSGIC_FString OutStringContainer;
    FSGIC_FString HardwareVersionContainer{HardwareVersion};
    SGCoreImpl_FSGSenseGloveVarsImpl_GetSensorString(&OutStringContainer, &HardwareVersionContainer, FirmwareVersion);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 TArray<FVector> FSGSenseGloveVars::GetStartPositions(const FString& HardwareVersion, const bool bRightHanded)
@@ -70,7 +70,7 @@ TArray<FVector> FSGSenseGloveVars::GetStartPositions(const FString& HardwareVers
    FSGIC_TArray_FVector OutPositionsContainer;
    FSGIC_FString HardwareVersionContainer{HardwareVersion};
    SGCoreImpl_FSGSenseGloveVarsImpl_GetStartPositions(&OutPositionsContainer, &HardwareVersionContainer, bRightHanded);
-    return MoveTemp(OutPositionsContainer.Array);
+    return OutPositionsContainer.Array;
 }

 TArray<FQuat> FSGSenseGloveVars::GetStartRotationsQ(const FString& HardwareVersion, const bool bRightHanded)
@@ -78,7 +78,7 @@ TArray<FQuat> FSGSenseGloveVars::GetStartRotationsQ(const FString& HardwareVersi
    FSGIC_TArray_FQuat OutRotationsContainer;
    FSGIC_FString HardwareVersionContainer{HardwareVersion};
    SGCoreImpl_FSGSenseGloveVarsImpl_GetStartRotations(&OutRotationsContainer, &HardwareVersionContainer, bRightHanded);
-    return MoveTemp(OutRotationsContainer.Array);
+    return OutRotationsContainer.Array;
 }

 TArray<FRotator> FSGSenseGloveVars::GetStartRotations(const FString& HardwareVersion, const bool bRightHanded)
@@ -94,7 +94,7 @@ TArray<TArray<FVector>> FSGSenseGloveVars::GetGloveLengths(const FString& Hardwa
    FSGIC_TArray_TArray_FVector OutLengthsContainer;
    FSGIC_FString HardwareVersionContainer{HardwareVersion};
    SGCoreImpl_FSGSenseGloveVarsImpl_GetGloveLengths(&OutLengthsContainer, &HardwareVersionContainer);
-    return MoveTemp(OutLengthsContainer.Array);
+    return OutLengthsContainer.Array;
 }

 /*
@@ -116,7 +116,7 @@ FQuat FSGSenseGloveVars::GetImuCorrectionQ(const FString& HardwareVersion,
    FSGIC_FString HardwareVersionContainer{HardwareVersion};
    SGCoreImpl_FSGSenseGloveVarsImpl_GetImuCorrection(&OutCorrectionContainer,
                                                      &HardwareVersionContainer, FirmwareVersion, SubFirmwareVersion);
-    return MoveTemp(OutCorrectionContainer.Quat);
+    return OutCorrectionContainer.Quat;
 }

 FRotator FSGSenseGloveVars::GetImuCorrection(const FString& HardwareVersion,
@@ -136,7 +136,7 @@ TArray<bool> FSGSenseGloveVars::GetFunctions(const FString& HardwareVersion,
    FSGIC_FString HardwareVersionContainer{HardwareVersion};
    SGCoreImpl_FSGSenseGloveVarsImpl_GetFunctions(&OutFunctionsContainer,
                                                  &HardwareVersionContainer, FirmwareVersion, SubFirmwareVersion);
-    return MoveTemp(OutFunctionsContainer.Array);
+    return OutFunctionsContainer.Array;
 }

 USGSenseGloveInfo* FSGSenseGloveVars::GenerateGloveModel(UObject* Outer, const FString& HardwareVersion,
@@ -199,7 +199,7 @@ TArray<float> USGSensorNormalization::NormalizeValues(const TArray<float>& Value
    SGCoreImpl_FSGSensorNormalizationImpl_NormalizeValues(
        &InstanceContainer, &ValuesContainer, &OutNormalizedValuesContainer);

-    return MoveTemp(OutNormalizedValuesContainer.Array);
+    return OutNormalizedValuesContainer.Array;
 }

 bool USGSensorNormalization::MovedEnough(const int32 Index) const
@@ -159,7 +159,7 @@ TArray<float> USGThresholdCommand::GetThresholds() const
    FSGIC_FSGThresholdCommandImpl InstanceContainer{ToThresholdCommandImpl()};
    FSGIC_TArray_float ThresholdsContainer;
    SGCoreImpl_FSGThresholdCommandImpl_GetThresholds(&InstanceContainer, &ThresholdsContainer);
-    return MoveTemp(ThresholdsContainer.Array);
+    return ThresholdsContainer.Array;
 }

 void USGThresholdCommand::SetThresholds(const TArray<bool>& AffectedFingers, const TArray<float>& ThresholdValues)
@@ -182,7 +182,7 @@ TArray<bool> USGThresholdCommand::GetActiveFingers() const
    FSGIC_FSGThresholdCommandImpl InstanceContainer{ToThresholdCommandImpl()};
    FSGIC_TArray_bool OutActiveFingersContainer;
    SGCoreImpl_FSGThresholdCommandImpl_GetActiveFingers(&InstanceContainer, &OutActiveFingersContainer);
-    return MoveTemp(OutActiveFingersContainer.Array);
+    return OutActiveFingersContainer.Array;
 }

 void USGThresholdCommand::ClearThreshold(const int32 Finger)
@@ -209,7 +209,7 @@ FString USGThresholdCommand::ToString() const
    FSGIC_FSGThresholdCommandImpl InstanceContainer{ToThresholdCommandImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGThresholdCommandImpl_ToString(&InstanceContainer, &OutStringContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }

 USGThresholdCommand::FImpl::FImpl(USGThresholdCommand* InOwner)
@@ -89,14 +89,14 @@ TArray<FVector> FSGTracking::GetSenseGloveFingerToGlovePositionOrigin()
 {
    FSGIC_TArray_FVector OutOriginContainer;
    SGCoreImpl_FSGTrackingImpl_GetSenseGloveFingerToGlovePositionOrigin(&OutOriginContainer);
-    return MoveTemp(OutOriginContainer.Array);
+    return OutOriginContainer.Array;
 }

 TArray<FQuat> FSGTracking::GetSenseGloveFingerToGloveRotationOriginQ()
 {
    FSGIC_TArray_FQuat OutOriginContainer;
    SGCoreImpl_FSGTrackingImpl_GetSenseGloveFingerToGloveRotationOrigin(&OutOriginContainer);
-    return MoveTemp(OutOriginContainer.Array);
+    return OutOriginContainer.Array;
 }

 TArray<FRotator> FSGTracking::GetSenseGloveFingerToGloveRotationOrigin()
@@ -110,14 +110,14 @@ FVector FSGTracking::GetSenseGloveWristPositionOffset()
 {
    FSGIC_FVector OutOffsetContainer;
    SGCoreImpl_FSGTrackingImpl_GetSenseGloveWristPositionOffset(&OutOffsetContainer);
-    return MoveTemp(OutOffsetContainer.Vector);
+    return OutOffsetContainer.Vector;
 }

 FQuat FSGTracking::GetSenseGloveWristRotationOffsetQ()
 {
    FSGIC_FQuat OutOffsetContainer;
    SGCoreImpl_FSGTrackingImpl_GetSenseGloveWristRotationOffset(&OutOffsetContainer);
-    return MoveTemp(OutOffsetContainer.Quat);
+    return OutOffsetContainer.Quat;
 }

 FRotator FSGTracking::GetSenseGloveWristRotationOffset()
@@ -189,14 +189,14 @@ FVector FSGTracking::GetSenseGloveViveToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetSenseGloveViveToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetSenseGloveViveToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetSenseGloveViveToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetSenseGloveViveToAttachRotation()
@@ -210,14 +210,14 @@ FVector FSGTracking::GetSenseGloveOculusTouchToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetSenseGloveOculusTouchToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetSenseGloveOculusTouchToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetSenseGloveOculusTouchToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetSenseGloveOculusTouchToAttachRotation()
@@ -231,14 +231,14 @@ FVector FSGTracking::GetNovaToWristPositionOffset()
 {
    FSGIC_FVector OutOffsetContainer;
    SGCoreImpl_FSGTrackingImpl_GetNovaToWristPositionOffset(&OutOffsetContainer);
-    return MoveTemp(OutOffsetContainer.Vector);
+    return OutOffsetContainer.Vector;
 }

 FQuat FSGTracking::GetNovaToWristRotationOffsetQ()
 {
    FSGIC_FQuat OutOffsetContainer;
    SGCoreImpl_FSGTrackingImpl_GetNovaToWristRotationOffset(&OutOffsetContainer);
-    return MoveTemp(OutOffsetContainer.Quat);
+    return OutOffsetContainer.Quat;
 }

 FRotator FSGTracking::GetNovaToWristRotationOffset()
@@ -252,14 +252,14 @@ FVector FSGTracking::GetRightNovaViveToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNovaViveToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetRightNovaViveToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNovaViveToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetRightNovaViveToAttachRotation()
@@ -273,14 +273,14 @@ FVector FSGTracking::GetLeftNovaViveToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNovaViveToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetLeftNovaViveToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNovaViveToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetLeftNovaViveToAttachRotation()
@@ -294,14 +294,14 @@ FVector FSGTracking::GetRightNovaQuest2ToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNovaQuest2ToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetRightNovaQuest2ToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNovaQuest2ToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetRightNovaQuest2ToAttachRotation()
@@ -315,14 +315,14 @@ FVector FSGTracking::GetLeftNovaQuest2ToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNovaQuest2ToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetLeftNovaQuest2ToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNovaQuest2ToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetLeftNovaQuest2ToAttachRotation()
@@ -336,14 +336,14 @@ FVector FSGTracking::GetRightNovaPico2ToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNovaPico2ToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetRightNovaPico2ToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNovaPico2ToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetRightNovaPico2ToAttachRotation()
@@ -357,7 +357,7 @@ FQuat FSGTracking::GetLeftNovaPico2ToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNovaPico2ToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetLeftNovaPico2ToAttachRotation()
@@ -371,14 +371,14 @@ FVector FSGTracking::GetRightNovaQuestProToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNovaQuestProToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetRightNovaQuestProToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNovaQuestProToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetRightNovaQuestProToAttachRotation()
@@ -392,14 +392,14 @@ FVector FSGTracking::GetLeftNovaQuestProToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNovaQuestProToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetLeftNovaQuestProToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNovaQuestProToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetLeftNovaQuestProToAttachRotation()
@@ -413,14 +413,14 @@ FVector FSGTracking::GetRightNovaViveFocus3ToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNovaViveFocus3ToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetRightNovaViveFocus3ToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNovaViveFocus3ToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetRightNovaViveFocus3ToAttachRotation()
@@ -434,14 +434,14 @@ FVector FSGTracking::GetLeftNovaViveFocus3ToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNovaViveFocus3ToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetLeftNovaViveFocus3ToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNovaViveFocus3ToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetLeftNovaViveFocus3ToAttachRotation()
@@ -455,14 +455,14 @@ FVector FSGTracking::GetRightNovaQuest3ToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNovaQuest3ToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetRightNovaQuest3ToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNovaQuest3ToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetRightNovaQuest3ToAttachRotation()
@@ -476,14 +476,14 @@ FVector FSGTracking::GetLeftNovaQuest3ToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNovaQuest3ToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetLeftNovaQuest3ToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNovaQuest3ToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetLeftNovaQuest3ToAttachRotation()
@@ -550,14 +550,14 @@ FVector FSGTracking::GetRightNova2ToWristPositionOffset()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNova2ToWristPositionOffset(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetRightNova2ToWristRotationOffsetQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNova2ToWristRotationOffset(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetRightNova2ToWristRotationOffset()
@@ -571,14 +571,14 @@ FVector FSGTracking::GetLeftNova2ToWristPositionOffset()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNova2ToWristPositionOffset(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetLeftNova2ToWristRotationOffsetQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNova2ToWristRotationOffset(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetLeftNova2ToWristRotationOffset()
@@ -592,14 +592,14 @@ FVector FSGTracking::GetRightNova2Quest2ToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNova2Quest2ToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetRightNova2Quest2ToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNova2Quest2ToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetRightNova2Quest2ToAttachRotation()
@@ -613,14 +613,14 @@ FVector FSGTracking::GetLeftNova2Quest2ToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNova2Quest2ToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetLeftNova2Quest2ToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNova2Quest2ToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetLeftNova2Quest2ToAttachRotation()
@@ -634,14 +634,14 @@ FVector FSGTracking::GetRightNova2QuestProToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNovaQuest2ToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetRightNova2QuestProToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNova2QuestProToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetRightNova2QuestProToAttachRotation()
@@ -655,14 +655,14 @@ FVector FSGTracking::GetLeftNova2QuestProToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNovaQuest2ToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetLeftNova2QuestProToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNova2QuestProToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetLeftNova2QuestProToAttachRotation()
@@ -676,14 +676,14 @@ FVector FSGTracking::GetRightNova2ViveTrackerToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNova2ViveTrackerToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetRightNova2ViveTrackerToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNova2ViveTrackerToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetRightNova2ViveTrackerToAttachRotation()
@@ -697,14 +697,14 @@ FVector FSGTracking::GetLeftNova2ViveTrackerToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNova2ViveTrackerToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetLeftNova2ViveTrackerToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNova2ViveTrackerToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetLeftNova2ViveTrackerToAttachRotation()
@@ -718,28 +718,28 @@ FVector FSGTracking::GetRightNova2ViveWristTrackerToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNova2ViveWristTrackerToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetRightNova2ViveWristTrackerToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNova2ViveWristTrackerToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FVector FSGTracking::GetRightNova2Quest3ToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNova2Quest3ToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetRightNova2Quest3ToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetRightNova2Quest3ToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetRightNova2Quest3ToAttachRotation()
@@ -753,14 +753,14 @@ FVector FSGTracking::GetLeftNova2Quest3ToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNova2Quest3ToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetLeftNova2Quest3ToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNova2Quest3ToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetLeftNova2Quest3ToAttachRotation()
@@ -781,14 +781,14 @@ FVector FSGTracking::GetLeftNova2ViveWristTrackerToAttachPosition()
 {
    FSGIC_FVector OutPositionContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNova2ViveWristTrackerToAttachPosition(&OutPositionContainer);
-    return MoveTemp(OutPositionContainer.Vector);
+    return OutPositionContainer.Vector;
 }

 FQuat FSGTracking::GetLeftNova2ViveWristTrackerToAttachRotationQ()
 {
    FSGIC_FQuat OutRotationContainer;
    SGCoreImpl_FSGTrackingImpl_GetLeftNova2ViveWristTrackerToAttachRotation(&OutRotationContainer);
-    return MoveTemp(OutRotationContainer.Quat);
+    return OutRotationContainer.Quat;
 }

 FRotator FSGTracking::GetLeftNova2ViveWristTrackerToAttachRotation()
@@ -863,5 +863,5 @@ FString FSGTracking::ToString(const ESGPositionalTrackingHardware Hardware)
    FSGIC_FString OutStringContainer;
    FSGIC_ESGPositionalTrackingHardware HardwareContainer{Hardware};
    SGCoreImpl_FSGTrackingImpl_ToString(&OutStringContainer, &HardwareContainer);
-    return MoveTemp(OutStringContainer.String);
+    return OutStringContainer.String;
 }
@@ -99,36 +99,36 @@ float FSGAnatomyImpl::NormalizeThumbFlexion(const float FlexionInDegrees)

 TArray<TArray<FVector>> FSGAnatomyImpl::GetDefaultHandAngles(const bool bRightHanded)
 {
-    TArray<TArray<FVector>> DefaultHandAngles{
+    const TArray<TArray<FVector>> DefaultHandAngles{
        FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
            FAnatomyType::GetDefaultHandAngles(bRightHanded))
    };
-    return MoveTemp(DefaultHandAngles);
+    return DefaultHandAngles;
 }

 TArray<TArray<FVector>> FSGAnatomyImpl::GetFlatHandAngles(const bool bRightHanded)
 {
-    TArray<TArray<FVector>> FlatHandAngles{
+    const TArray<TArray<FVector>> FlatHandAngles{
        FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
            FAnatomyType::GetFlatHandAngles(bRightHanded))
    };
-    return MoveTemp(FlatHandAngles);
+    return FlatHandAngles;
 }

 TArray<TArray<FVector>> FSGAnatomyImpl::GetThumbsUpHandAngles(const bool bRightHanded)
 {
-    TArray<TArray<FVector>> ThumbsUpHandAngles{
+    const TArray<TArray<FVector>> ThumbsUpHandAngles{
        FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
            FAnatomyType::GetThumbsUpHandAngles(bRightHanded))
    };
-    return MoveTemp(ThumbsUpHandAngles);
+    return ThumbsUpHandAngles;
 }

 TArray<TArray<FVector>> FSGAnatomyImpl::GetFistHandAngles(const bool bRightHanded)
 {
-    TArray<TArray<FVector>> FistHandAngles{
+    const TArray<TArray<FVector>> FistHandAngles{
        FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
            FAnatomyType::GetFistHandAngles(bRightHanded))
    };
-    return MoveTemp(FistHandAngles);
+    return FistHandAngles;
 }
@@ -194,18 +194,18 @@ bool FSGBasicHandModelImpl::IsRight() const

 TArray<TArray<float>> FSGBasicHandModelImpl::GetFingerLengths() const
 {
-    TArray<TArray<float>> FingerLengths{
+    const TArray<TArray<float>> FingerLengths{
        FSGArrayUtils::FromMillimeters(Pimpl->BasicHandModel.GetFingerLengths())
    };
-    return MoveTemp(FingerLengths);
+    return FingerLengths;
 }

 TArray<float> FSGBasicHandModelImpl::GetFingerLengths(const ESGFinger Finger) const
 {
-    TArray<float> FingerLengths{
+    const TArray<float> FingerLengths{
        FSGArrayUtils::FromMillimeters(Pimpl->BasicHandModel.GetFingerLengths(FSGCoreEnumCast::ToEFinger(Finger)))
    };
-    return MoveTemp(FingerLengths);
+    return FingerLengths;
 }

 void FSGBasicHandModelImpl::SetFingerLengths(const ESGFinger Finger, const TArray<float>& Lengths)
@@ -226,27 +226,27 @@ void FSGBasicHandModelImpl::SetFingerLengths(const uint8 Finger, const TArray<fl

 TArray<TArray<float>> FSGBasicHandModelImpl::GetFingerRatios() const
 {
-    TArray<TArray<float>> FingerRatios{
+    const TArray<TArray<float>> FingerRatios{
        FSGArrayUtils::FromStdVector<float>(Pimpl->BasicHandModel.GetFingerRatios())
    };
-    return MoveTemp(FingerRatios);
+    return FingerRatios;
 }

 TArray<float> FSGBasicHandModelImpl::GetFingerRatios(const ESGFinger Finger) const
 {
-    TArray<float> FingerRatios{
+    const TArray<float> FingerRatios{
        FSGArrayUtils::FromStdVector<float>(Pimpl->BasicHandModel.GetFingerRatios(FSGCoreEnumCast::ToEFinger(Finger)))
    };
-    return MoveTemp(FingerRatios);
+    return FingerRatios;
 }

 TArray<FVector> FSGBasicHandModelImpl::GetStartJointPositions() const
 {
-    TArray<FVector> StartJointPositions{
+    const TArray<FVector> StartJointPositions{
        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
            Pimpl->BasicHandModel.GetStartJointPositions())
    };
-    return MoveTemp(StartJointPositions);
+    return StartJointPositions;
 }

 void FSGBasicHandModelImpl::SetStartJointPosition(const ESGFinger Finger, const FVector& Position)
@@ -265,12 +265,12 @@ void FSGBasicHandModelImpl::SetStartJointPosition(const uint8 Finger, const FVec

 TArray<FQuat> FSGBasicHandModelImpl::GetStartJointRotations() const
 {
-    TArray<FQuat> StartJointRotations{
+    const TArray<FQuat> StartJointRotations{
        FSGArrayUtils::FromStdVector<
            FSGQuatImpl::FQuatType, FQuat, FSGQuatImpl, &FSGQuatImpl::ToFQuat>(
            Pimpl->BasicHandModel.GetStartJointRotations())
    };
-    return MoveTemp(StartJointRotations);
+    return StartJointRotations;
 }

 FVector FSGBasicHandModelImpl::GetJointPosition(const ESGFinger Finger) const
@@ -299,10 +299,10 @@ void FSGBasicHandModelImpl::SetJointRotation(const FQuat& NewRotation, const ESG

 TArray<float> FSGBasicHandModelImpl::GetTotalLengths() const
 {
-    TArray<float> TotalLengths{
+    const TArray<float> TotalLengths{
        FSGArrayUtils::FromMillimeters(Pimpl->BasicHandModel.GetTotalLengths())
    };
-    return MoveTemp(TotalLengths);
+    return TotalLengths;
 }

 float FSGBasicHandModelImpl::GetTotalLength(const ESGFinger Finger) const
@@ -313,11 +313,11 @@ float FSGBasicHandModelImpl::GetTotalLength(const ESGFinger Finger) const

 TArray<FVector> FSGBasicHandModelImpl::Get3DLengths(const ESGFinger Finger) const
 {
-    TArray<FVector> Lengths{
+    const TArray<FVector> Lengths{
        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
            Pimpl->BasicHandModel.Get3DLengths(FSGCoreEnumCast::ToEFinger(Finger)))
    };
-    return MoveTemp(Lengths);
+    return Lengths;
 }

 bool FSGBasicHandModelImpl::Equals(const FSGBasicHandModelImpl& BasicHandModelImpl) const
@@ -327,20 +327,20 @@ bool FSGBasicHandModelImpl::Equals(const FSGBasicHandModelImpl& BasicHandModelIm

 FString FSGBasicHandModelImpl::ToString() const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->BasicHandModel.ToString().c_str()));
-    return MoveTemp(String);
+    const FString String(UTF8_TO_TCHAR(Pimpl->BasicHandModel.ToString().c_str()));
+    return String;
 }

 FString FSGBasicHandModelImpl::ToString(const bool bLengthsOnly) const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->BasicHandModel.ToString(bLengthsOnly).c_str()));
-    return MoveTemp(String);
+    const FString String(UTF8_TO_TCHAR(Pimpl->BasicHandModel.ToString(bLengthsOnly).c_str()));
+    return String;
 }

 FString FSGBasicHandModelImpl::Serialize() const
 {
-    FString Serialized(UTF8_TO_TCHAR(Pimpl->BasicHandModel.Serialize().c_str()));
-    return MoveTemp(Serialized);
+    const FString Serialized(UTF8_TO_TCHAR(Pimpl->BasicHandModel.Serialize().c_str()));
+    return Serialized;
 }

 FSGBasicHandModelImpl::FImpl::FImpl(FSGBasicHandModelImpl* InOwner)
@@ -69,9 +69,10 @@ TSharedRef<FSGBetaDeviceImpl> FSGBetaDeviceImpl::Parse(const FString& String)
 {
    FSGDevicePtrType SGDevicePtr{FBetaDeviceType::Parse(TCHAR_TO_UTF8(*String))};
    ensureAlwaysMsgf(SGDevicePtr, TEXT("Invalid SGDevice!"));
-    TSharedRef<FSGBetaDeviceImpl> BetaDeviceImpl{MakeShared<FSGBetaDeviceImpl>(
-        std::dynamic_pointer_cast<FBetaDeviceType>(MoveTemp(SGDevicePtr)))};
-    return MoveTemp(BetaDeviceImpl);
+    const TSharedRef<FSGBetaDeviceImpl> BetaDeviceImpl{
+        MakeShared<FSGBetaDeviceImpl>(std::dynamic_pointer_cast<FBetaDeviceType>(MoveTemp(SGDevicePtr)))
+    };
+    return BetaDeviceImpl;
 }

 FSGBetaDeviceImpl::FSGBetaDeviceImpl()
@@ -149,14 +150,14 @@ ESGDeviceType FSGBetaDeviceImpl::GetDeviceType() const

 FString FSGBetaDeviceImpl::GetDeviceId() const
 {
-    FString Id{UTF8_TO_TCHAR(ToBetaDevicePtrChecked()->GetDeviceId().c_str())};
-    return MoveTemp(Id);
+    const FString Id{UTF8_TO_TCHAR(ToBetaDevicePtrChecked()->GetDeviceId().c_str())};
+    return Id;
 }

 FString FSGBetaDeviceImpl::GetHardwareVersion() const
 {
-    FString Version{UTF8_TO_TCHAR(ToBetaDevicePtrChecked()->GetHardwareVersion().c_str())};
-    return MoveTemp(Version);
+    const FString Version{UTF8_TO_TCHAR(ToBetaDevicePtrChecked()->GetHardwareVersion().c_str())};
+    return Version;
 }

 int32 FSGBetaDeviceImpl::GetFirmwareVersion() const
@@ -171,20 +172,20 @@ int32 FSGBetaDeviceImpl::GetSubFirmwareVersion() const

 FString FSGBetaDeviceImpl::GetConstantsString() const
 {
-    FString String{UTF8_TO_TCHAR(ToBetaDevicePtrChecked()->GetConstantsString().c_str())};
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(ToBetaDevicePtrChecked()->GetConstantsString().c_str())};
+    return String;
 }

 FString FSGBetaDeviceImpl::GetSensorData() const
 {
-    FString Data{UTF8_TO_TCHAR(ToBetaDevicePtrChecked()->GetSensorData().c_str())};
-    return MoveTemp(Data);
+    const FString Data{UTF8_TO_TCHAR(ToBetaDevicePtrChecked()->GetSensorData().c_str())};
+    return Data;
 }

 FString FSGBetaDeviceImpl::GetLastCommand() const
 {
-    FString Command{UTF8_TO_TCHAR(ToBetaDevicePtrChecked()->GetLastCommand().c_str())};
-    return MoveTemp(Command);
+    const FString Command{UTF8_TO_TCHAR(ToBetaDevicePtrChecked()->GetLastCommand().c_str())};
+    return Command;
 }

 bool FSGBetaDeviceImpl::SendHaptics(const FString& Command, const int32 Channel) const
@@ -71,8 +71,8 @@ struct FSGCustomWaveformImpl::FImpl

 FString FSGCustomWaveformImpl::ToString(const ESGWaveformType Type)
 {
-    FString String{FCustomWaveformType::ToString(FSGCoreEnumCast::ToEWaveformType(Type)).c_str()};
-    return MoveTemp(String);
+    const FString String{FCustomWaveformType::ToString(FSGCoreEnumCast::ToEWaveformType(Type)).c_str()};
+    return String;
 }

 FSGCustomWaveformImpl::FSGCustomWaveformImpl()
@@ -259,8 +259,8 @@ bool FSGCustomWaveformImpl::Equals(const FSGCustomWaveformImpl& CustomWaveformIm

 FString FSGCustomWaveformImpl::ToString() const
 {
-    FString String{UTF8_TO_TCHAR(Pimpl->CustomWaveform.ToString().c_str())};
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(Pimpl->CustomWaveform.ToString().c_str())};
+    return String;
 }

 FSGCustomWaveformImpl::FImpl::FImpl(FSGCustomWaveformImpl* InOwner)
@@ -98,8 +98,8 @@ bool FSGDeviceImpl::FirmwareOlderThan(const int32 MyFirmwareMain, const int32 My

 FString FSGDeviceImpl::ToString(const ESGDeviceType DeviceType)
 {
-    FString String{UTF8_TO_TCHAR(FSGDeviceType::ToString(FSGCoreEnumCast::ToEDeviceType(DeviceType)).c_str())};
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(FSGDeviceType::ToString(FSGCoreEnumCast::ToEDeviceType(DeviceType)).c_str())};
+    return String;
 }

 FSGDeviceImpl::FSGDeviceImpl()
@@ -298,8 +298,8 @@ int32 FSGDeviceImpl::GetSubFirmwareVersion() const

 FString FSGDeviceImpl::GetFirmwareString() const
 {
-    FString String{UTF8_TO_TCHAR(ToSGDevicePtrChecked()->GetFirmwareString().c_str())};
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(ToSGDevicePtrChecked()->GetFirmwareString().c_str())};
+    return String;
 }

 bool FSGDeviceImpl::FirmwareNewerThan(const int32 FirmwareMain, const int32 FirmwareSub, const bool bInclusive) const
@@ -314,8 +314,8 @@ bool FSGDeviceImpl::FirmwareOlderThan(const int32 FirmwareMain, const int32 Firm

 FString FSGDeviceImpl::GetAddress() const
 {
-    FString String(UTF8_TO_TCHAR(ToSGDevicePtrChecked()->GetAddress().c_str()));
-    return MoveTemp(String);
+    const FString String(UTF8_TO_TCHAR(ToSGDevicePtrChecked()->GetAddress().c_str()));
+    return String;
 }

 bool FSGDeviceImpl::IsConnected() const
@@ -385,8 +385,8 @@ int32 FSGDeviceImpl::GetHapticChannelCount(const ESGHapticChannelType ChannelTyp

 FString FSGDeviceImpl::ToString() const
 {
-    FString String(UTF8_TO_TCHAR(ToSGDevicePtrChecked()->ToString().c_str()));
-    return MoveTemp(String);
+    const FString String(UTF8_TO_TCHAR(ToSGDevicePtrChecked()->ToString().c_str()));
+    return String;
 }

 FSGDeviceImpl::FImpl::FImpl(FSGDeviceImpl* InOwner)
@@ -146,7 +146,7 @@ TArray<TSharedRef<FSGDeviceImpl>> FSGDeviceListImpl::GetDevices()
        }
    }

-    return MoveTemp(DeviceImpls);
+    return DeviceImpls;
 }

 bool FSGDeviceListImpl::GetSensorDataString(const int32 IpcIndex, const FString& IpcAddress, FString& OutString)
@@ -169,16 +169,16 @@ bool FSGDeviceListImpl::SendHaptics(
 FString FSGDeviceListImpl::GetDeviceStringAt(const int32 IpcIndex, const FString& IpcAddress, const int32 Index)
 {
    std::string IpcAddressString(TCHAR_TO_UTF8(*IpcAddress));
-    FString String(
+    const FString String(
        UTF8_TO_TCHAR(FDeviceListType::GetDeviceStringAt(IpcIndex, MoveTemp(IpcAddressString), Index).c_str()));
-    return MoveTemp(String);
+    return String;
 }

 FString FSGDeviceListImpl::GetAddress(const int32 IpcIndex, const FString& IpcAddress)
 {
    std::string IpcAddressString(TCHAR_TO_UTF8(*IpcAddress));
-    FString Address(UTF8_TO_TCHAR(FDeviceListType::GetAddress(IpcIndex, MoveTemp(IpcAddressString)).c_str()));
-    return MoveTemp(Address);
+    const FString Address(UTF8_TO_TCHAR(FDeviceListType::GetAddress(IpcIndex, MoveTemp(IpcAddressString)).c_str()));
+    return Address;
 }

 ESGConnectionType FSGDeviceListImpl::GetConnectionType(const int32 IpcIndex, const FString& IpcAddress)
@@ -141,14 +141,14 @@ const FSGDeviceModelImpl::FDeviceModelType& FSGDeviceModelImpl::ToDeviceModel()

 FString FSGDeviceModelImpl::GetDeviceId() const
 {
-    FString DeviceId(UTF8_TO_TCHAR(Pimpl->DeviceModel.GetDeviceId().c_str()));
-    return MoveTemp(DeviceId);
+    const FString DeviceId(UTF8_TO_TCHAR(Pimpl->DeviceModel.GetDeviceId().c_str()));
+    return DeviceId;
 }

 FString FSGDeviceModelImpl::GetHardwareVersion() const
 {
-    FString HardwareVersion(UTF8_TO_TCHAR(Pimpl->DeviceModel.GetHardwareVersion().c_str()));
-    return MoveTemp(HardwareVersion);
+    const FString HardwareVersion(UTF8_TO_TCHAR(Pimpl->DeviceModel.GetHardwareVersion().c_str()));
+    return HardwareVersion;
 }

 int32 FSGDeviceModelImpl::GetFirmwareVersion() const
@@ -83,8 +83,8 @@ struct FSGHandInterpolatorImpl::FImpl
 FSGHandInterpolatorImpl FSGHandInterpolatorImpl::Deserialize(const FString& SerializedString, const bool bRightHanded)
 {
    std::string Serialized(TCHAR_TO_UTF8(*SerializedString));
-    FSGHandInterpolatorImpl GlovePose(FHandInterpolatorType::Deserialize(MoveTemp(Serialized), bRightHanded));
-    return MoveTemp(GlovePose);
+    const FSGHandInterpolatorImpl GlovePose(FHandInterpolatorType::Deserialize(MoveTemp(Serialized), bRightHanded));
+    return GlovePose;
 }

 FSGHandInterpolatorImpl::FSGHandInterpolatorImpl()
@@ -154,12 +154,12 @@ TArray<TArray<FVector>> FSGHandInterpolatorImpl::InterpolateHandAngles(
    std::vector<float> AbductionsVector{
        FSGArrayUtils::ToSenseGloveAngles(Abductions)
    };
-    TArray<TArray<FVector>> Angles{
+    const TArray<TArray<FVector>> Angles{
        FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
            Pimpl->HandInterpolator.InterpolateHandAngles(
                MoveTemp(FlexionsVector), MoveTemp(AbductionsVector), CmcTwist))
    };
-    return MoveTemp(Angles);
+    return Angles;
 }

 bool FSGHandInterpolatorImpl::Equals(const FSGHandInterpolatorImpl& HandInterpolatorImpl) const
@@ -169,8 +169,8 @@ bool FSGHandInterpolatorImpl::Equals(const FSGHandInterpolatorImpl& HandInterpol

 FString FSGHandInterpolatorImpl::Serialize() const
 {
-    FString Serialized(UTF8_TO_TCHAR(Pimpl->HandInterpolator.Serialize().c_str()));
-    return MoveTemp(Serialized);
+    const FString Serialized(UTF8_TO_TCHAR(Pimpl->HandInterpolator.Serialize().c_str()));
+    return Serialized;
 }

 FSGHandInterpolatorImpl::FImpl::FImpl(FSGHandInterpolatorImpl* InOwner)
@@ -93,8 +93,8 @@ ESGHapticGloveCalibrationState FSGHandLayerImpl::GetCalibrationState(const bool

 FString FSGHandLayerImpl::GetCalibrationInstructions(const bool bRightHanded)
 {
-    FString Instructions{UTF8_TO_TCHAR(FHandLayerType::GetCalibrationInstructions(bRightHanded).c_str())};
-    return MoveTemp(Instructions);
+    const FString Instructions{UTF8_TO_TCHAR(FHandLayerType::GetCalibrationInstructions(bRightHanded).c_str())};
+    return Instructions;
 }

 void FSGHandLayerImpl::ResetCalibration(const bool bRightHanded)
@@ -205,28 +205,28 @@ bool FSGHandPoseImpl::IsRight() const

 TArray<TArray<FVector>> FSGHandPoseImpl::GetJointPositions() const
 {
-    TArray<TArray<FVector>> JointPositions{
+    const TArray<TArray<FVector>> JointPositions{
        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
            Pimpl->HandPose.GetJointPositions())
    };
-    return MoveTemp(JointPositions);
+    return JointPositions;
 }

 TArray<TArray<FQuat>> FSGHandPoseImpl::GetJointRotations() const
 {
-    TArray<TArray<FQuat>> JointRotations{
+    const TArray<TArray<FQuat>> JointRotations{
        FSGArrayUtils::FromStdVector<FSGQuatImpl::FQuatType, FQuat, FSGQuatImpl, &FSGQuatImpl::ToFQuat>(
            Pimpl->HandPose.GetJointRotations())
    };
-    return MoveTemp(JointRotations);
+    return JointRotations;
 }

 TArray<TArray<FVector>> FSGHandPoseImpl::GetHandAngles() const
 {
-    TArray<TArray<FVector>> HandAngles{
+    const TArray<TArray<FVector>> HandAngles{
        FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(Pimpl->HandPose.GetHandAngles())
    };
-    return MoveTemp(HandAngles);
+    return HandAngles;
 }

 bool FSGHandPoseImpl::Equals(const FSGHandPoseImpl& HandPoseImpl) const
@@ -241,22 +241,22 @@ float FSGHandPoseImpl::GetNormalizedFlexion(ESGFinger Finger, bool bClamp01) con

 TArray<float> FSGHandPoseImpl::GetNormalizedFlexion(bool bClamp01) const
 {
-    TArray<float> NormalizedFlexion{
+    const TArray<float> NormalizedFlexion{
        FSGArrayUtils::FromStdVector<float>(Pimpl->HandPose.GetNormalizedFlexion(bClamp01))
    };
-    return MoveTemp(NormalizedFlexion);
+    return NormalizedFlexion;
 }

 FString FSGHandPoseImpl::ToString(bool bShortFormat) const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->HandPose.ToString(bShortFormat).c_str()));
-    return MoveTemp(String);
+    const FString String(UTF8_TO_TCHAR(Pimpl->HandPose.ToString(bShortFormat).c_str()));
+    return String;
 }

 FString FSGHandPoseImpl::Serialize() const
 {
-    FString Serialized(UTF8_TO_TCHAR(Pimpl->HandPose.Serialize().c_str()));
-    return MoveTemp(Serialized);
+    const FString Serialized(UTF8_TO_TCHAR(Pimpl->HandPose.Serialize().c_str()));
+    return Serialized;
 }

 FSGHandPoseImpl::FImpl::FImpl(FSGHandPoseImpl* InOwner)
@@ -72,16 +72,16 @@ struct FSGHapticChannelInfoImpl::FImpl

 FString FSGHapticChannelInfoImpl::GenerateAddress(const int32 DeviceIndex, const int32 ChannelIndex)
 {
-    FString Address{UTF8_TO_TCHAR(FHapticChannelInfoType::GenerateAddress(DeviceIndex, ChannelIndex).c_str())};
-    return MoveTemp(Address);
+    const FString Address{UTF8_TO_TCHAR(FHapticChannelInfoType::GenerateAddress(DeviceIndex, ChannelIndex).c_str())};
+    return Address;
 }

 FSGHapticChannelInfoImpl FSGHapticChannelInfoImpl::Parse(const FString& IpcString)
 {
    std::string IpcStdString{TCHAR_TO_UTF8(*IpcString)};
    FHapticChannelInfoType HapticChannelInfo{FHapticChannelInfoType::Parse(MoveTemp(IpcStdString))};
-    FSGHapticChannelInfoImpl HapticChannelInfoImpl{MoveTemp(HapticChannelInfo)};
-    return MoveTemp(HapticChannelInfoImpl);
+    const FSGHapticChannelInfoImpl HapticChannelInfoImpl{MoveTemp(HapticChannelInfo)};
+    return HapticChannelInfoImpl;
 }

 int32 FSGHapticChannelInfoImpl::GetStreamingType()
@@ -162,13 +162,13 @@ int32 FSGHapticChannelInfoImpl::GetTotalChannelCount() const

 FString FSGHapticChannelInfoImpl::GetAddress_Unguarded(const ESGHapticChannelType Type, const int32 TypeIndex) const
 {
-    FString Address{
+    const FString Address{
        UTF8_TO_TCHAR(
            Pimpl->HapticChannelInfo.GetAddress_Unguarded(
                FSGCoreEnumCast::ToEHapticChannelType(Type), TypeIndex).c_str(
            ))
    };
-    return MoveTemp(Address);
+    return Address;
 }

 void FSGHapticChannelInfoImpl::GetIpcParams_Unguarded(
@@ -187,10 +187,10 @@ void FSGHapticChannelInfoImpl::RegenerateAddresses(const int32 ForDeviceIndex)

 TArray<FString> FSGHapticChannelInfoImpl::GetAllAddresses() const
 {
-    TArray<FString> AddressesArray{
+    const TArray<FString> AddressesArray{
        FSGArrayUtils::FromStdVector(Pimpl->HapticChannelInfo.GetAllAddresses())
    };
-    return MoveTemp(AddressesArray);
+    return AddressesArray;
 }

 FSGHapticChannelInfoImpl::FImpl::FImpl(FSGHapticChannelInfoImpl* InOwner)
@@ -88,7 +88,7 @@ TArray<TSharedRef<FSGHapticGloveImpl>> FSGHapticGloveImpl::GetHapticGloves(const
        HapticGloveImpls.Push(MoveTemp(HapticGloveImpl));
    }

-    return MoveTemp(HapticGloveImpls);
+    return HapticGloveImpls;
 }

 bool FSGHapticGloveImpl::GetGlove(TSharedPtr<FSGHapticGloveImpl>& OutGlove)
@@ -119,18 +119,18 @@ bool FSGHapticGloveImpl::GetGlove(const bool bRightHanded, TSharedPtr<FSGHapticG

 FString FSGHapticGloveImpl::ToString(ESGHapticGloveCalibrationState State)
 {
-    FString String{
+    const FString String{
        UTF8_TO_TCHAR(FHapticGloveType::ToString(FSGCoreEnumCast::ToEHapticGloveCalibrationState(State)).c_str())
    };
-    return MoveTemp(String);
+    return String;
 }

 FString FSGHapticGloveImpl::ToString(ESGHapticLocation Location)
 {
-    FString String{
+    const FString String{
        UTF8_TO_TCHAR(FHapticGloveType::ToString(FSGCoreEnumCast::ToEHapticLocation(Location)).c_str())
    };
-    return MoveTemp(String);
+    return String;
 }

 FSGHapticGloveImpl::FSGHapticGloveImpl()
@@ -185,14 +185,14 @@ ESGDeviceType FSGHapticGloveImpl::GetDeviceType() const

 FString FSGHapticGloveImpl::GetDeviceId() const
 {
-    FString Id{UTF8_TO_TCHAR(ToHapticGlovePtrChecked()->GetDeviceId().c_str())};
-    return MoveTemp(Id);
+    const FString Id{UTF8_TO_TCHAR(ToHapticGlovePtrChecked()->GetDeviceId().c_str())};
+    return Id;
 }

 FString FSGHapticGloveImpl::GetHardwareVersion() const
 {
-    FString Version{UTF8_TO_TCHAR(ToHapticGlovePtrChecked()->GetHardwareVersion().c_str())};
-    return MoveTemp(Version);
+    const FString Version{UTF8_TO_TCHAR(ToHapticGlovePtrChecked()->GetHardwareVersion().c_str())};
+    return Version;
 }

 int32 FSGHapticGloveImpl::GetFirmwareVersion() const
@@ -270,8 +270,8 @@ void FSGHapticGloveImpl::ResetCalibration()

 FString FSGHapticGloveImpl::GetCalibrationInstruction() const
 {
-    FString Instruction{UTF8_TO_TCHAR(ToHapticGlovePtrChecked()->GetCalibrationInstruction().c_str())};
-    return MoveTemp(Instruction);
+    const FString Instruction{UTF8_TO_TCHAR(ToHapticGlovePtrChecked()->GetCalibrationInstruction().c_str())};
+    return Instruction;
 }

 void FSGHapticGloveImpl::StopHaptics()
@@ -360,8 +360,8 @@ void FSGHapticGloveImpl::GetGloveLocation(const FVector& ReferencePosition, cons

 FString FSGHapticGloveImpl::ToString() const
 {
-    FString String{UTF8_TO_TCHAR(ToHapticGlovePtrChecked()->ToString().c_str())};
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(ToHapticGlovePtrChecked()->ToString().c_str())};
+    return String;
 }

 FSGHapticGloveImpl::FImpl::FImpl(FSGHapticGloveImpl* InOwner)
@@ -199,20 +199,20 @@ bool FSGInterpolationSetImpl::Equals(const FSGInterpolationSetImpl& Interpolatio

 FString FSGInterpolationSetImpl::ToString() const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->InterpolationSet.ToString().c_str()));
-    return MoveTemp(String);
+    const FString String(UTF8_TO_TCHAR(Pimpl->InterpolationSet.ToString().c_str()));
+    return String;
 }

 FString FSGInterpolationSetImpl::ToString(const bool bLimits) const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->InterpolationSet.ToString(bLimits).c_str()));
-    return MoveTemp(String);
+    const FString String(UTF8_TO_TCHAR(Pimpl->InterpolationSet.ToString(bLimits).c_str()));
+    return String;
 }

 FString FSGInterpolationSetImpl::Serialize() const
 {
-    FString Serialized(UTF8_TO_TCHAR(Pimpl->InterpolationSet.Serialize().c_str()));
-    return MoveTemp(Serialized);
+    const FString Serialized(UTF8_TO_TCHAR(Pimpl->InterpolationSet.Serialize().c_str()));
+    return Serialized;
 }

 FSGInterpolationSetImpl::FImpl::FImpl(FSGInterpolationSetImpl* InOwner)
@@ -92,20 +92,21 @@ TSharedRef<FSGDeviceImpl> FSGNova2GloveImpl::Parse(const FString& ConstantsStrin
    std::string ConstantsStdString{TCHAR_TO_UTF8(*ConstantsString)};
    FSGDevicePtrType SGDevicePtr{FNova2GloveType::Parse(MoveTemp(ConstantsStdString))};
    ensureAlwaysMsgf(SGDevicePtr, TEXT("Invalid SGDevice!"));
-    TSharedRef<FSGNova2GloveImpl> Nova2GloveImpl{MakeShared<FSGNova2GloveImpl>(
-        std::dynamic_pointer_cast<FNova2GloveType>(MoveTemp(SGDevicePtr)))};
-    return MoveTemp(Nova2GloveImpl);
+    const TSharedRef<FSGNova2GloveImpl> Nova2GloveImpl{
+        MakeShared<FSGNova2GloveImpl>(std::dynamic_pointer_cast<FNova2GloveType>(MoveTemp(SGDevicePtr)))
+    };
+    return Nova2GloveImpl;
 }

 TArray<FSGNova2GloveImpl> FSGNova2GloveImpl::GetNova2Gloves()
 {
    FNova2GloveVectorType Vector{FNova2GloveType::GetNova2Gloves()};

-    TArray<FSGNova2GloveImpl> Array{
+    const TArray<FSGNova2GloveImpl> Array{
        FSGArrayUtils::FromStdVector<FNova2GloveType, FSGNova2GloveImpl>(MoveTemp(Vector))
    };

-    return MoveTemp(Array);
+    return Array;
 }


@@ -177,11 +178,11 @@ const TArray<float>& FSGNova2GloveImpl::GetNova2SensorRanges()

 TArray<float> FSGNova2GloveImpl::ToNormalizedValues(const FSGNova2GloveSensorDataImpl& SensorData)
 {
-    TArray<float> NormalizedValues{
+    const TArray<float> NormalizedValues{
        FSGArrayUtils::FromStdVector(
            FNova2GloveType::ToNormalizedValues(SensorData.ToNova2GloveSensorData()))
    };
-    return MoveTemp(NormalizedValues);
+    return NormalizedValues;
 }

 TArray<TArray<FVector>> FSGNova2GloveImpl::CalculateHandAngles(
@@ -189,13 +190,13 @@ TArray<TArray<FVector>> FSGNova2GloveImpl::CalculateHandAngles(
 {
    std::vector<float> NormalizedValuesVector{FSGArrayUtils::ToStdVector(NormalizedValues)};

-    TArray<TArray<FVector>> Angles{
+    const TArray<TArray<FVector>> Angles{
        FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
            FNova2GloveType::CalculateHandAngles(
                MoveTemp(NormalizedValuesVector), Interpolator.ToHandInterpolator(), bInfluenceIndex))
    };

-    return MoveTemp(Angles);
+    return Angles;
 }

 TArray<TArray<FVector>> FSGNova2GloveImpl::ToNormalizedAngles(
@@ -203,23 +204,23 @@ TArray<TArray<FVector>> FSGNova2GloveImpl::ToNormalizedAngles(
 {
    std::vector<float> NormalizedDataVector{FSGArrayUtils::ToStdVector(NormalizedData)};

-    TArray<TArray<FVector>> Angles{
+    const TArray<TArray<FVector>> Angles{
        FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
            FNova2GloveType::ToNormalizedAngles(MoveTemp(NormalizedDataVector), GloveInfo.ToNovaGloveInfo()))
    };

-    return MoveTemp(Angles);
+    return Angles;
 }

 TArray<float> FSGNova2GloveImpl::ToNormalizedValues(const FSGNova2GloveSensorDataImpl& SensorData,
                                                    FSGSensorNormalizationImpl& OutSensorNormalizer)
 {
-    TArray<float> NormalizedValues{
+    const TArray<float> NormalizedValues{
        FSGArrayUtils::FromStdVector(
            FNova2GloveType::ToNormalizedValues(SensorData.ToNova2GloveSensorData(),
                                                OutSensorNormalizer.ToSensorNormalization()))
    };
-    return MoveTemp(NormalizedValues);
+    return NormalizedValues;
 }

 FSGNova2GloveImpl::FSGNova2GloveImpl()
@@ -461,8 +462,8 @@ void FSGNova2GloveImpl::GetWristLocation(const FVector& ReferencePosition, const

 FSGNovaGloveInfoImpl FSGNova2GloveImpl::GetGloveInfo() const
 {
-    FSGNovaGloveInfoImpl GloveInfo{ToNova2GlovePtrChecked()->GetGloveInfo()};
-    return MoveTemp(GloveInfo);
+    const FSGNovaGloveInfoImpl GloveInfo{ToNova2GlovePtrChecked()->GetGloveInfo()};
+    return GloveInfo;
 }

 bool FSGNova2GloveImpl::DoesIndexInfluenceOthers() const
@@ -532,8 +533,8 @@ bool FSGNova2GloveImpl::SendCustomWaveform_Nova2(FSGCustomWaveformImpl& OutWavef

 FString FSGNova2GloveImpl::ToString() const
 {
-    FString String{UTF8_TO_TCHAR(ToNova2GlovePtrChecked()->ToString().c_str())};
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(ToNova2GlovePtrChecked()->ToString().c_str())};
+    return String;
 }

 FSGNova2GloveImpl::FImpl::FImpl(FSGNova2GloveImpl* InOwner)
@@ -82,11 +82,10 @@ FSGNova2GloveSensorDataImpl FSGNova2GloveSensorDataImpl::Parse(const FString& Ra
                                                               const FSGNovaGloveInfoImpl& GloveInfo)
 {
    std::string RawDataString(TCHAR_TO_UTF8(*RawData));
-    FSGNova2GloveSensorDataImpl SensorData{
-        FNova2GloveSensorDataType::Parse(
-            MoveTemp(RawDataString), GloveInfo.ToNovaGloveInfo())
+    const FSGNova2GloveSensorDataImpl SensorData{
+        FNova2GloveSensorDataType::Parse(MoveTemp(RawDataString), GloveInfo.ToNovaGloveInfo())
    };
-    return MoveTemp(SensorData);
+    return SensorData;
 }

 FSGNova2GloveSensorDataImpl::FSGNova2GloveSensorDataImpl()
@@ -149,11 +148,11 @@ ESGNormalizationState FSGNova2GloveSensorDataImpl::GetSensorState() const

 TArray<TArray<FVector>> FSGNova2GloveSensorDataImpl::GetSensorValues() const
 {
-    TArray<TArray<FVector>> SensorValues{
+    const TArray<TArray<FVector>> SensorValues{
        FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
            Pimpl->Nova2GloveSensorData.GetSensorValues())
    };
-    return MoveTemp(SensorValues);
+    return SensorValues;
 }

 float FSGNova2GloveSensorDataImpl::GetSensorValue(const ESGFinger Finger, const ESGNova2SensorLocation Location) const
@@ -194,8 +193,8 @@ bool FSGNova2GloveSensorDataImpl::Equals(const FSGNova2GloveSensorDataImpl& Nova

 FString FSGNova2GloveSensorDataImpl::ToString() const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->Nova2GloveSensorData.ToString().c_str()));
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(Pimpl->Nova2GloveSensorData.ToString().c_str())};
+    return String;
 }

 FSGNova2GloveSensorDataImpl::FImpl::FImpl(FSGNova2GloveSensorDataImpl* InOwner)
@@ -94,17 +94,17 @@ TSharedRef<FSGDeviceImpl> FSGNovaGloveImpl::Parse(const FString& ConstantsString
    std::string ConstantsStdString{TCHAR_TO_UTF8(*ConstantsString)};
    FSGDevicePtrType SGDevicePtr{FNovaGloveType::Parse(MoveTemp(ConstantsStdString))};
    ensureAlwaysMsgf(SGDevicePtr, TEXT("Invalid SGDevice!"));
-    TSharedRef<FSGNovaGloveImpl> NovaGloveImpl{MakeShared<FSGNovaGloveImpl>(
+    const TSharedRef<FSGNovaGloveImpl> NovaGloveImpl{MakeShared<FSGNovaGloveImpl>(
        std::dynamic_pointer_cast<FNovaGloveType>(MoveTemp(SGDevicePtr)))};
-    return MoveTemp(NovaGloveImpl);
+    return NovaGloveImpl;
 }

 TArray<FSGNovaGloveImpl> FSGNovaGloveImpl::GetNovaGloves()
 {
-    TArray<FSGNovaGloveImpl> Gloves{
+    const TArray<FSGNovaGloveImpl> Gloves{
        FSGArrayUtils::FromStdVector<FNovaGloveType, FSGNovaGloveImpl>(FNovaGloveType::GetNovaGloves())
    };
-    return MoveTemp(Gloves);
+    return Gloves;
 }

 bool FSGNovaGloveImpl::GetNovaGlove(FSGNovaGloveImpl& OutGlove)
@@ -187,22 +187,22 @@ const TArray<float>& FSGNovaGloveImpl::GetNovaSensorRanges()

 TArray<float> FSGNovaGloveImpl::ToNormalizedValues(const FSGNovaGloveSensorDataImpl& SensorData)
 {
-    TArray<float> NormalizedValues{
+    const TArray<float> NormalizedValues{
        FSGArrayUtils::FromStdVector(
            FNovaGloveType::ToNormalizedValues(SensorData.ToNovaGloveSensorData()))
    };
-    return MoveTemp(NormalizedValues);
+    return NormalizedValues;
 }

 TArray<float> FSGNovaGloveImpl::ToNormalizedValues(const FSGNovaGloveSensorDataImpl& SensorData,
                                                   FSGSensorNormalizationImpl& OutSensorNormalizer)
 {
-    TArray<float> NormalizedValues{
+    const TArray<float> NormalizedValues{
        FSGArrayUtils::FromStdVector(
            FNovaGloveType::ToNormalizedValues(SensorData.ToNovaGloveSensorData(),
                                               OutSensorNormalizer.ToSensorNormalization()))
    };
-    return MoveTemp(NormalizedValues);
+    return NormalizedValues;
 }

 TArray<TArray<FVector>> FSGNovaGloveImpl::CalculateHandAngles(
@@ -210,30 +210,30 @@ TArray<TArray<FVector>> FSGNovaGloveImpl::CalculateHandAngles(
 {
    std::vector<float> NormalizedValuesVector{FSGArrayUtils::ToStdVector(NormalizedValues)};

-    TArray<TArray<FVector>> Angles{
+    const TArray<TArray<FVector>> Angles{
        FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
            FNovaGloveType::CalculateHandAngles(MoveTemp(NormalizedValuesVector), Interpolator.ToHandInterpolator()))
    };

-    return MoveTemp(Angles);
+    return Angles;
 }

 FString FSGNovaGloveImpl::ToNovaCommandAsFlexion(const FSGThresholdCommandImpl& Thresholds)
 {
-    FString Flexion{
+    const FString Flexion{
        UTF8_TO_TCHAR(FNovaGloveType::ToNovaCommandAsFlexion(Thresholds.ToThresholdCommand()).c_str())
    };
-    return MoveTemp(Flexion);
+    return Flexion;
 }

 FString FSGNovaGloveImpl::ToNovaCommandAsRaw(
    const FSGThresholdCommandImpl& Thresholds, const FSGSensorNormalizationImpl& Interpolator)
 {
-    FString Raw{
+    const FString Raw{
        UTF8_TO_TCHAR(FNovaGloveType::ToNovaCommandAsRaw(Thresholds.ToThresholdCommand(),
            Interpolator.ToSensorNormalization()).c_str())
    };
-    return MoveTemp(Raw);
+    return Raw;
 }

 FSGNovaGloveImpl::FSGNovaGloveImpl()
@@ -305,14 +305,14 @@ ESGDeviceType FSGNovaGloveImpl::GetDeviceType() const

 FString FSGNovaGloveImpl::GetDeviceId() const
 {
-    FString Id{UTF8_TO_TCHAR(ToNovaGlovePtrChecked()->GetDeviceId().c_str())};
-    return MoveTemp(Id);
+    const FString Id{UTF8_TO_TCHAR(ToNovaGlovePtrChecked()->GetDeviceId().c_str())};
+    return Id;
 }

 FString FSGNovaGloveImpl::GetHardwareVersion() const
 {
-    FString Version{UTF8_TO_TCHAR(ToNovaGlovePtrChecked()->GetHardwareVersion().c_str())};
-    return MoveTemp(Version);
+    const FString Version{UTF8_TO_TCHAR(ToNovaGlovePtrChecked()->GetHardwareVersion().c_str())};
+    return Version;
 }

 int32 FSGNovaGloveImpl::GetFirmwareVersion() const
@@ -464,8 +464,8 @@ void FSGNovaGloveImpl::GetWristLocation(const FVector& ReferencePosition, const

 FSGNovaGloveInfoImpl FSGNovaGloveImpl::GetGloveInfo() const
 {
-    FSGNovaGloveInfoImpl GloveInfo{ToNovaGlovePtrChecked()->GetGloveInfo()};
-    return MoveTemp(GloveInfo);
+    const FSGNovaGloveInfoImpl GloveInfo{ToNovaGlovePtrChecked()->GetGloveInfo()};
+    return GloveInfo;
 }

 bool FSGNovaGloveImpl::SupportsThresholds() const
@@ -504,9 +504,11 @@ FString FSGNovaGloveImpl::ToNovaCommand(
 {
    std::vector<float> ForceFeedbackLevelsVector{FSGArrayUtils::ToStdVector(ForceFeedbackLevels)};
    std::vector<float> BuzzLevelsVector{FSGArrayUtils::ToStdVector(BuzzLevels)};
-    FString Command{UTF8_TO_TCHAR(ToNovaGlovePtrChecked()->ToNovaCommand(
-        MoveTemp(ForceFeedbackLevelsVector), MoveTemp(BuzzLevelsVector), WristLevel).c_str())};
-    return MoveTemp(Command);
+    const FString Command{
+        UTF8_TO_TCHAR(ToNovaGlovePtrChecked()->ToNovaCommand(
+            MoveTemp(ForceFeedbackLevelsVector), MoveTemp(BuzzLevelsVector), WristLevel).c_str())
+    };
+    return Command;
 }

 bool FSGNovaGloveImpl::QueueVibroLevels(const TArray<float>& Amplitudes)
@@ -566,8 +568,8 @@ bool FSGNovaGloveImpl::QueueClearThreshold(const int32 Finger)

 FString FSGNovaGloveImpl::ToString() const
 {
-    FString String{UTF8_TO_TCHAR(ToNovaGlovePtrChecked()->ToString().c_str())};
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(ToNovaGlovePtrChecked()->ToString().c_str())};
+    return String;
 }

 FSGNovaGloveImpl::FImpl::FImpl(FSGNovaGloveImpl* InOwner)
@@ -157,11 +157,11 @@ ESGNormalizationState FSGNovaGloveSensorDataImpl::GetSensorState() const

 TArray<FVector> FSGNovaGloveSensorDataImpl::GetSensorValues() const
 {
-    TArray<FVector> SensorValues{
+    const TArray<FVector> SensorValues{
        FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
            Pimpl->NovaGloveSensorData.GetSensorValues())
    };
-    return MoveTemp(SensorValues);
+    return SensorValues;
 }

 float FSGNovaGloveSensorDataImpl::GetSensorValue(const ESGFinger Finger, const ESGNovaSensorLocation Location) const
@@ -202,14 +202,14 @@ bool FSGNovaGloveSensorDataImpl::Equals(const FSGNovaGloveSensorDataImpl& NovaGl

 FString FSGNovaGloveSensorDataImpl::ToString() const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->NovaGloveSensorData.ToString().c_str()));
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(Pimpl->NovaGloveSensorData.ToString().c_str())};
+    return String;
 }

 FString FSGNovaGloveSensorDataImpl::Serialize() const
 {
-    FString Serialized(UTF8_TO_TCHAR(Pimpl->NovaGloveSensorData.Serialize().c_str()));
-    return MoveTemp(Serialized);
+    const FString Serialized{UTF8_TO_TCHAR(Pimpl->NovaGloveSensorData.Serialize().c_str())};
+    return Serialized;
 }

 FSGNovaGloveSensorDataImpl::FImpl::FImpl(FSGNovaGloveSensorDataImpl* InOwner)
@@ -92,20 +92,21 @@ TSharedRef<FSGDeviceImpl> FSGSenseGloveImpl::Parse(const FString& ConstantsStrin
    std::string ConstantsStdString{TCHAR_TO_UTF8(*ConstantsString)};
    FSGDevicePtrType SGDevicePtr{FSenseGloveType::Parse(MoveTemp(ConstantsStdString))};
    ensureAlwaysMsgf(SGDevicePtr, TEXT("Invalid SGDevice!"));
-    TSharedRef<FSGSenseGloveImpl> SenseGloveImpl{MakeShared<FSGSenseGloveImpl>(
-        std::dynamic_pointer_cast<FSenseGloveType>(MoveTemp(SGDevicePtr)))};
-    return MoveTemp(SenseGloveImpl);
+    const TSharedRef<FSGSenseGloveImpl> SenseGloveImpl{
+        MakeShared<FSGSenseGloveImpl>(std::dynamic_pointer_cast<FSenseGloveType>(MoveTemp(SGDevicePtr)))
+    };
+    return SenseGloveImpl;
 }

 TArray<FSGSenseGloveImpl> FSGSenseGloveImpl::GetSenseGloves()
 {
    FSenseGloveVectorType Vector{FSenseGloveType::GetSenseGloves()};

-    TArray<FSGSenseGloveImpl> Array{
+    const TArray<FSGSenseGloveImpl> Array{
        FSGArrayUtils::FromStdVector<FSenseGloveType, FSGSenseGloveImpl>(MoveTemp(Vector))
    };

-    return MoveTemp(Array);
+    return Array;
 }

 bool FSGSenseGloveImpl::GetSenseGlove(FSGSenseGloveImpl& OutGlove)
@@ -189,10 +190,10 @@ const FVector& FSGSenseGloveImpl::GetDefaultThimbleOffset()
 FSGSenseGlovePoseImpl FSGSenseGloveImpl::CalculateGlovePose(const FSGSenseGloveSensorDataImpl& SensorData,
                                                            const FSGSenseGloveInfoImpl& GloveModel)
 {
-    FSGSenseGlovePoseImpl Pose{
+    const FSGSenseGlovePoseImpl Pose{
        FSenseGloveType::CalculateGlovePose(SensorData.ToSenseGloveSensorData(), GloveModel.ToSenseGloveInfo())
    };
-    return MoveTemp(Pose);
+    return Pose;
 }

 FSGSenseGlovePoseImpl FSGSenseGloveImpl::CalculateGlovePose(const TArray<TArray<FVector>>& GloveAngles,
@@ -202,11 +203,11 @@ FSGSenseGlovePoseImpl FSGSenseGloveImpl::CalculateGlovePose(const TArray<TArray<
        FSGArrayUtils::ToSenseGloveAngles<FSGVect3DImpl::FVect3DType>(GloveAngles)
    };

-    FSGSenseGlovePoseImpl Pose{
+    const FSGSenseGlovePoseImpl Pose{
        FSenseGloveType::CalculateGlovePose(MoveTemp(GloveAnglesVector), GloveModel.ToSenseGloveInfo())
    };

-    return MoveTemp(Pose);
+    return Pose;
 }

 void FSGSenseGloveImpl::NormalizeValues(
@@ -326,14 +327,14 @@ ESGDeviceType FSGSenseGloveImpl::GetDeviceType() const

 FString FSGSenseGloveImpl::GetDeviceId() const
 {
-    FString Id{UTF8_TO_TCHAR(ToSenseGlovePtrChecked()->GetDeviceId().c_str())};
-    return MoveTemp(Id);
+    const FString Id{UTF8_TO_TCHAR(ToSenseGlovePtrChecked()->GetDeviceId().c_str())};
+    return Id;
 }

 FString FSGSenseGloveImpl::GetHardwareVersion() const
 {
-    FString Version{UTF8_TO_TCHAR(ToSenseGlovePtrChecked()->GetHardwareVersion().c_str())};
-    return MoveTemp(Version);
+    const FString Version{UTF8_TO_TCHAR(ToSenseGlovePtrChecked()->GetHardwareVersion().c_str())};
+    return Version;
 }

 int32 FSGSenseGloveImpl::GetFirmwareVersion() const
@@ -509,16 +510,16 @@ void FSGSenseGloveImpl::GetWristLocation(
 FSGSenseGloveInfoImpl FSGSenseGloveImpl::GetGloveInfo() const
 {
    FSGSenseGloveInfoImpl GloveInfo{ToSenseGlovePtr()->GetGloveInfo()};
-    return MoveTemp(GloveInfo);
+    return GloveInfo;
 }

 TArray<FVector> FSGSenseGloveImpl::GetFingerThimbleOffsets() const
 {
-    TArray<FVector> Offsets{
+    const TArray<FVector> Offsets{
        FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
            ToSenseGlovePtrChecked()->GetFingerThimbleOffsets())
    };
-    return MoveTemp(Offsets);
+    return Offsets;
 }

 void FSGSenseGloveImpl::SetFingerThimbleOffset(const int32 Finger, const FVector& Offset)
@@ -568,8 +569,8 @@ bool FSGSenseGloveImpl::QueueThumperCommand(const ESGSenseGloveThumperCommand Co

 FString FSGSenseGloveImpl::ToString() const
 {
-    FString String{UTF8_TO_TCHAR(ToSenseGlovePtrChecked()->ToString().c_str())};
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(ToSenseGlovePtrChecked()->ToString().c_str())};
+    return String;
 }

 FSGSenseGloveImpl::FImpl::FImpl(FSGSenseGloveImpl* InOwner)
@@ -170,14 +170,14 @@ const FSGSenseGloveInfoImpl::FSenseGloveInfoType& FSGSenseGloveInfoImpl::ToSense

 FString FSGSenseGloveInfoImpl::GetDeviceId() const
 {
-    FString DeviceId(UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.GetDeviceId().c_str()));
-    return MoveTemp(DeviceId);
+    const FString DeviceId{UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.GetDeviceId().c_str())};
+    return DeviceId;
 }

 FString FSGSenseGloveInfoImpl::GetHardwareVersion() const
 {
-    FString HardwareVersion(UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.GetHardwareVersion().c_str()));
-    return MoveTemp(HardwareVersion);
+    const FString HardwareVersion{UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.GetHardwareVersion().c_str())};
+    return HardwareVersion;
 }

 int32 FSGSenseGloveInfoImpl::GetFirmwareVersion() const
@@ -202,54 +202,55 @@ int32 FSGSenseGloveInfoImpl::GetNumberOfSensors() const

 FQuat FSGSenseGloveInfoImpl::GetImuCorrection() const
 {
-    FQuat ImuCorrection(FSGQuatImpl(Pimpl->SenseGloveInfo.GetImuCorrection()).ToFQuat());
-    return MoveTemp(ImuCorrection);
+    const FQuat ImuCorrection{FSGQuatImpl(Pimpl->SenseGloveInfo.GetImuCorrection()).ToFQuat()};
+    return ImuCorrection;
 }

 TArray<FVector> FSGSenseGloveInfoImpl::GetStartPositions() const
 {
-    TArray<FVector> StartPositionsArray{
+    const TArray<FVector> StartPositionsArray{
        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
            Pimpl->SenseGloveInfo.GetStartPositions())};
-    return MoveTemp(StartPositionsArray);
+    return StartPositionsArray;
 }

 TArray<FQuat> FSGSenseGloveInfoImpl::GetStartRotations() const
 {
-    TArray<FQuat> StartRotationsArray{
+    const TArray<FQuat> StartRotationsArray{
        FSGArrayUtils::FromStdVector<FSGQuatImpl::FQuatType, FQuat, FSGQuatImpl, &FSGQuatImpl::ToFQuat>(
            Pimpl->SenseGloveInfo.GetStartRotations())};
-    return MoveTemp(StartRotationsArray);
+    return StartRotationsArray;
 }

 TArray<TArray<FVector>> FSGSenseGloveInfoImpl::GetGloveLengths() const
 {
-    TArray<TArray<FVector>> GloveLengths{
+    const TArray<TArray<FVector>> GloveLengths{
        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
            Pimpl->SenseGloveInfo.GetGloveLengths())
    };
-    return MoveTemp(GloveLengths);
+    return GloveLengths;
 }

 TArray<bool> FSGSenseGloveInfoImpl::GetFunctions() const
 {
-    TArray<bool> FunctionsArray{FSGArrayUtils::FromStdVector(Pimpl->SenseGloveInfo.GetFunctions())};
-    return MoveTemp(FunctionsArray);
+    const TArray<bool> FunctionsArray{FSGArrayUtils::FromStdVector(Pimpl->SenseGloveInfo.GetFunctions())};
+    return FunctionsArray;
 }

 FVector FSGSenseGloveInfoImpl::GetStartPosition(const ESGFinger Finger) const
 {
-    FVector StartPosition{FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
-        Pimpl->SenseGloveInfo.GetStartPosition(FSGCoreEnumCast::ToEFinger(Finger)))
+    const FVector StartPosition{
+        FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+            Pimpl->SenseGloveInfo.GetStartPosition(FSGCoreEnumCast::ToEFinger(Finger)))
    };
-    return MoveTemp(StartPosition);
+    return StartPosition;
 }

 FQuat FSGSenseGloveInfoImpl::GetStartRotation(const ESGFinger Finger) const
 {
-    FQuat StartRotation(FSGQuatImpl(Pimpl->SenseGloveInfo.GetStartRotation(
-        FSGCoreEnumCast::ToEFinger(Finger))).ToFQuat());
-    return MoveTemp(StartRotation);
+    const FQuat StartRotation(
+        FSGQuatImpl(Pimpl->SenseGloveInfo.GetStartRotation(FSGCoreEnumCast::ToEFinger(Finger))).ToFQuat());
+    return StartRotation;
 }

 TArray<FVector> FSGSenseGloveInfoImpl::GetGloveLengths(const ESGFinger Finger) const
@@ -257,10 +258,10 @@ TArray<FVector> FSGSenseGloveInfoImpl::GetGloveLengths(const ESGFinger Finger) c
    std::vector<FSGVect3DImpl::FVect3DType> GloveLengthsVector{
        Pimpl->SenseGloveInfo.GetGloveLengths(FSGCoreEnumCast::ToEFinger(Finger))
    };
-    TArray<FVector> GloveLengthsArray{
+    const TArray<FVector> GloveLengthsArray{
        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(MoveTemp(GloveLengthsVector))
    };
-    return MoveTemp(GloveLengthsArray);
+    return GloveLengthsArray;
 }

 TArray<TArray<FVector>> FSGSenseGloveInfoImpl::ToGloveAngles(const TArray<TArray<float>>& SensorAngles) const
@@ -270,11 +271,11 @@ TArray<TArray<FVector>> FSGSenseGloveInfoImpl::ToGloveAngles(const TArray<TArray
    std::vector<std::vector<float>> SensorAnglesVector{
        FSGArrayUtils::ToStdVector<float>(SensorAngles)
    };
-    TArray<TArray<FVector>> GloveAngles{
+    const TArray<TArray<FVector>> GloveAngles{
        FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
            Pimpl->SenseGloveInfo.ToGloveAngles(MoveTemp((SensorAnglesVector))))
    };
-    return MoveTemp(GloveAngles);
+    return GloveAngles;
 }

 bool FSGSenseGloveInfoImpl::Equals(const FSGSenseGloveInfoImpl& SGSenseGloveInfo, const bool bGeometryOnly) const
@@ -284,20 +285,20 @@ bool FSGSenseGloveInfoImpl::Equals(const FSGSenseGloveInfoImpl& SGSenseGloveInfo

 FString FSGSenseGloveInfoImpl::ToString(const bool bShortNotation) const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.ToString(bShortNotation).c_str()));
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.ToString(bShortNotation).c_str())};
+    return String;
 }

 FString FSGSenseGloveInfoImpl::ToString() const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.ToString().c_str()));
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.ToString().c_str())};
+    return String;
 }

 FString FSGSenseGloveInfoImpl::Serialize() const
 {
-    FString Serialized(UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.Serialize().c_str()));
-    return MoveTemp(Serialized);
+    const FString Serialized{UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.Serialize().c_str())};
+    return Serialized;
 }

 FSGSenseGloveInfoImpl::FImpl::FImpl(FSGSenseGloveInfoImpl* InOwner)
@@ -79,15 +79,15 @@ struct FSGSenseGlovePoseImpl::FImpl

 FSGSenseGlovePoseImpl FSGSenseGlovePoseImpl::IdlePose(const FSGSenseGloveInfoImpl& GloveInfo)
 {
-    FSGSenseGlovePoseImpl GlovePoseImpl(FSenseGlovePoseType::IdlePose(GloveInfo.ToSenseGloveInfo()));
-    return MoveTemp(GlovePoseImpl);
+    const FSGSenseGlovePoseImpl GlovePoseImpl{FSenseGlovePoseType::IdlePose(GloveInfo.ToSenseGloveInfo())};
+    return GlovePoseImpl;
 }

 FSGSenseGlovePoseImpl FSGSenseGlovePoseImpl::Deserialize(const FString& SerializedString)
 {
-    std::string Serialized(TCHAR_TO_UTF8(*SerializedString));
-    FSGSenseGlovePoseImpl GlovePose(FSenseGlovePoseType::Deserialize(MoveTemp(Serialized)));
-    return MoveTemp(GlovePose);
+    std::string Serialized{TCHAR_TO_UTF8(*SerializedString)};
+    const FSGSenseGlovePoseImpl GlovePose{FSenseGlovePoseType::Deserialize(MoveTemp(Serialized))};
+    return GlovePose;
 }

 FSGSenseGlovePoseImpl::FSGSenseGlovePoseImpl()
@@ -155,55 +155,55 @@ bool FSGSenseGlovePoseImpl::IsRight() const

 TArray<TArray<FVector>> FSGSenseGlovePoseImpl::GetJointPositions() const
 {
-    TArray<TArray<FVector>> JointPositions{
+    const TArray<TArray<FVector>> JointPositions{
        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
            Pimpl->SenseGlovePose.GetJointPositions())
    };
-    return MoveTemp(JointPositions);
+    return JointPositions;
 }

 TArray<TArray<FQuat>> FSGSenseGlovePoseImpl::GetJointRotations() const
 {
-    TArray<TArray<FQuat>> JointRotations{
+    const TArray<TArray<FQuat>> JointRotations{
        FSGArrayUtils::FromStdVector<FSGQuatImpl::FQuatType, FQuat, FSGQuatImpl, &FSGQuatImpl::ToFQuat>(
            Pimpl->SenseGlovePose.GetJointRotations())
    };
-    return MoveTemp(JointRotations);
+    return JointRotations;
 }

 TArray<TArray<FVector>> FSGSenseGlovePoseImpl::GetGloveAngles() const
 {
-    TArray<TArray<FVector>> GloveAngles{
+    const TArray<TArray<FVector>> GloveAngles{
        FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
            Pimpl->SenseGlovePose.GetGloveAngles())
    };
-    return MoveTemp(GloveAngles);
+    return GloveAngles;
 }

 TArray<FVector> FSGSenseGlovePoseImpl::GetThimblePositions() const
 {
-    TArray<FVector> ThimblePositions{
+    const TArray<FVector> ThimblePositions{
        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
            Pimpl->SenseGlovePose.GetThimblePositions())
    };
-    return MoveTemp(ThimblePositions);
+    return ThimblePositions;
 }

 TArray<FQuat> FSGSenseGlovePoseImpl::GetThimbleRotations() const
 {
-    TArray<FQuat> ThimbleRotations{
+    const TArray<FQuat> ThimbleRotations{
        FSGArrayUtils::FromStdVector<FSGQuatImpl::FQuatType, FQuat, FSGQuatImpl, &FSGQuatImpl::ToFQuat>(
            Pimpl->SenseGlovePose.GetThimbleRotations())
    };
-    return MoveTemp(ThimbleRotations);
+    return ThimbleRotations;
 }

 TArray<FVector> FSGSenseGlovePoseImpl::GetTotalGloveAngles() const
 {
-    TArray<FVector> TotalGloveAngles{
+    const TArray<FVector> TotalGloveAngles{
        FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(Pimpl->SenseGlovePose.GetTotalGloveAngles())
    };
-    return MoveTemp(TotalGloveAngles);
+    return TotalGloveAngles;
 }

 TArray<FVector> FSGSenseGlovePoseImpl::CalculateFingertips(const TArray<FVector>& FingerOffsets) const
@@ -211,11 +211,11 @@ TArray<FVector> FSGSenseGlovePoseImpl::CalculateFingertips(const TArray<FVector>
    std::vector<FSGVect3DImpl::FVect3DType> FingerOffsetsVector{
        FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(FingerOffsets)
    };
-    TArray<FVector> Fingertips{
+    const TArray<FVector> Fingertips{
        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
            Pimpl->SenseGlovePose.CalculateFingertips(MoveTemp(FingerOffsetsVector)))
    };
-    return MoveTemp(Fingertips);
+    return Fingertips;
 }

 bool FSGSenseGlovePoseImpl::Equals(const FSGSenseGlovePoseImpl& SenseGlovePoseImpl) const
@@ -225,14 +225,14 @@ bool FSGSenseGlovePoseImpl::Equals(const FSGSenseGlovePoseImpl& SenseGlovePoseIm

 FString FSGSenseGlovePoseImpl::ToString(const bool bShortFormat) const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->SenseGlovePose.ToString(bShortFormat).c_str()));
-    return MoveTemp(String);
+    const FString String(UTF8_TO_TCHAR(Pimpl->SenseGlovePose.ToString(bShortFormat).c_str()));
+    return String;
 }

 FString FSGSenseGlovePoseImpl::Serialize() const
 {
-    FString Serialized(UTF8_TO_TCHAR(Pimpl->SenseGlovePose.Serialize().c_str()));
-    return MoveTemp(Serialized);
+    const FString Serialized(UTF8_TO_TCHAR(Pimpl->SenseGlovePose.Serialize().c_str()));
+    return Serialized;
 }

 FSGSenseGlovePoseImpl::FImpl::FImpl(FSGSenseGlovePoseImpl* InOwner)
@@ -78,7 +78,7 @@ struct FSGSenseGloveSensorDataImpl::FImpl

 const FSGSenseGloveSensorDataImpl& FSGSenseGloveSensorDataImpl::Empty()
 {
-    static const FSGSenseGloveSensorDataImpl EmptyData(FSenseGloveSensorDataType::Empty());
+    static const FSGSenseGloveSensorDataImpl EmptyData{FSenseGloveSensorDataType::Empty()};
    return EmptyData;
 }

@@ -86,15 +86,16 @@ FSGSenseGloveSensorDataImpl FSGSenseGloveSensorDataImpl::Parse(const FString& Ra
                                                               const FSGSenseGloveInfoImpl& GloveInfo)
 {
    std::string RawDataString(TCHAR_TO_UTF8(*RawData));
-    const FSGSenseGloveSensorDataImpl SensorData(FSenseGloveSensorDataType::Parse(
-        MoveTemp(RawDataString), GloveInfo.ToSenseGloveInfo()));
+    const FSGSenseGloveSensorDataImpl SensorData{
+        FSenseGloveSensorDataType::Parse(MoveTemp(RawDataString), GloveInfo.ToSenseGloveInfo())
+    };
    return SensorData;
 }

 FSGSenseGloveSensorDataImpl FSGSenseGloveSensorDataImpl::Deserialize(const FString& SerializedString)
 {
-    std::string Serialized(TCHAR_TO_UTF8(*SerializedString));
-    const FSGSenseGloveSensorDataImpl SensorData(FSenseGloveSensorDataType::Deserialize(MoveTemp(Serialized)));
+    std::string Serialized{TCHAR_TO_UTF8(*SerializedString)};
+    const FSGSenseGloveSensorDataImpl SensorData{FSenseGloveSensorDataType::Deserialize(MoveTemp(Serialized))};
    return SensorData;
 }

@@ -147,27 +148,27 @@ const FSGSenseGloveSensorDataImpl::FSenseGloveSensorDataType& FSGSenseGloveSenso

 TArray<TArray<float>> FSGSenseGloveSensorDataImpl::GetSensorAngles() const
 {
-    TArray<TArray<float>> SensorAngles{
+    const TArray<TArray<float>> SensorAngles{
        FSGArrayUtils::FromSenseGloveAngles(Pimpl->SenseGloveSensorData.GetSensorAngles())
    };
-    return MoveTemp(SensorAngles);
+    return SensorAngles;
 }

 TArray<float> FSGSenseGloveSensorDataImpl::GetSensorAngles(ESGFinger Finger) const
 {
-    TArray<float> SensorAngles{
+    const TArray<float> SensorAngles{
        FSGArrayUtils::FromStdVector<float>(
            Pimpl->SenseGloveSensorData.GetSensorAngles(FSGCoreEnumCast::ToEFinger(Finger)))
    };
-    return MoveTemp(SensorAngles);
+    return SensorAngles;
 }

 TArray<float> FSGSenseGloveSensorDataImpl::GetAngleSequence() const
 {
-    TArray<float> AngleSequence{
+    const TArray<float> AngleSequence{
        FSGArrayUtils::FromStdVector<float>(Pimpl->SenseGloveSensorData.GetAngleSequence())
    };
-    return MoveTemp(AngleSequence);
+    return AngleSequence;
 }

 FQuat FSGSenseGloveSensorDataImpl::GetImuRotation() const
@@ -192,14 +193,14 @@ bool FSGSenseGloveSensorDataImpl::Equals(const FSGSenseGloveSensorDataImpl& Sens

 FString FSGSenseGloveSensorDataImpl::ToString() const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->SenseGloveSensorData.ToString().c_str()));
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(Pimpl->SenseGloveSensorData.ToString().c_str())};
+    return String;
 }

 FString FSGSenseGloveSensorDataImpl::Serialize() const
 {
-    FString Serialized(UTF8_TO_TCHAR(Pimpl->SenseGloveSensorData.Serialize().c_str()));
-    return MoveTemp(Serialized);
+    const FString Serialized{UTF8_TO_TCHAR(Pimpl->SenseGloveSensorData.Serialize().c_str())};
+    return Serialized;
 }

 FSGSenseGloveSensorDataImpl::FImpl::FImpl(FSGSenseGloveSensorDataImpl* InOwner)
@@ -50,60 +50,63 @@
 FString FSGSenseGloveVarsImpl::GetStandardConstantsString(const FString& HardwareVersion, const float FirmwareVersion,
                                                          const bool bRightHanded)
 {
-    std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
-    FString String(UTF8_TO_TCHAR(FSenseGloveVarsType::GetStandardConstantsString(MoveTemp(HardwareVersionString),
-        FirmwareVersion, bRightHanded).c_str()));
-    return MoveTemp(String);
+    std::string HardwareVersionString{TCHAR_TO_UTF8(*HardwareVersion)};
+    const FString String{
+        UTF8_TO_TCHAR(FSenseGloveVarsType::GetStandardConstantsString(
+            MoveTemp(HardwareVersionString), FirmwareVersion, bRightHanded).c_str())
+    };
+    return String;
 }

 FString FSGSenseGloveVarsImpl::GetSensorString(const FString& HardwareVersion, const float FirmwareVersion)
 {
-    std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
-    FString String(UTF8_TO_TCHAR(FSenseGloveVarsType::GetSensorString(MoveTemp(HardwareVersionString),
-        FirmwareVersion).c_str()));
-    return MoveTemp(String);
+    std::string HardwareVersionString{TCHAR_TO_UTF8(*HardwareVersion)};
+    const FString String{
+        UTF8_TO_TCHAR(FSenseGloveVarsType::GetSensorString(MoveTemp(HardwareVersionString),FirmwareVersion).c_str())
+    };
+    return String;
 }

 TArray<FVector> FSGSenseGloveVarsImpl::GetStartPositions(const FString& HardwareVersion, const bool bRightHanded)
 {
-    std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
-    TArray<FVector> StartPositions{
+    std::string HardwareVersionString{TCHAR_TO_UTF8(*HardwareVersion)};
+    const TArray<FVector> StartPositions{
        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
            FSenseGloveVarsType::GetStartPositions(MoveTemp(HardwareVersionString), bRightHanded))
    };
-    return MoveTemp(StartPositions);
+    return StartPositions;
 }

 TArray<FQuat> FSGSenseGloveVarsImpl::GetStartRotations(const FString& HardwareVersion, const bool bRightHanded)
 {
-    std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
-    TArray<FQuat> StartRotations{
+    std::string HardwareVersionString{TCHAR_TO_UTF8(*HardwareVersion)};
+    const TArray<FQuat> StartRotations{
        FSGArrayUtils::FromStdVector<FSGQuatImpl::FQuatType, FQuat, FSGQuatImpl, &FSGQuatImpl::ToFQuat>(
            FSenseGloveVarsType::GetStartRotations(MoveTemp(HardwareVersionString), bRightHanded))
    };
-    return MoveTemp(StartRotations);
+    return StartRotations;
 }

 TArray<TArray<FVector>> FSGSenseGloveVarsImpl::GetGloveLengths(const FString& HardwareVersion)
 {
-    std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
-    TArray<TArray<FVector>> GloveLengths{
+    std::string HardwareVersionString{TCHAR_TO_UTF8(*HardwareVersion)};
+    const TArray<TArray<FVector>> GloveLengths{
        FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
            FSenseGloveVarsType::GetGloveLengths(MoveTemp(HardwareVersionString)))
    };
-    return MoveTemp(GloveLengths);
+    return GloveLengths;
 }

 int32 FSGSenseGloveVarsImpl::GetSensors(const FString& HardwareVersion)
 {
-    std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
+    std::string HardwareVersionString{TCHAR_TO_UTF8(*HardwareVersion)};
    return FSenseGloveVarsType::GetSensors(MoveTemp(HardwareVersionString));
 }

 FQuat FSGSenseGloveVarsImpl::GetImuCorrection(const FString& HardwareVersion, const int32 FirmwareVersion,
                                              const int32 SubFirmwareVersion)
 {
-    std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
+    std::string HardwareVersionString{TCHAR_TO_UTF8(*HardwareVersion)};
    return FSGQuatImpl(FSenseGloveVarsType::GetImuCorrection(
        MoveTemp(HardwareVersionString), FirmwareVersion, SubFirmwareVersion)).ToFQuat();
 }
@@ -111,29 +114,33 @@ FQuat FSGSenseGloveVarsImpl::GetImuCorrection(const FString& HardwareVersion, co
 TArray<bool> FSGSenseGloveVarsImpl::GetFunctions(const FString& HardwareVersion, const int32 FirmwareVersion,
                                                 const int32 SubFirmwareVersion)
 {
-    std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
-    TArray<bool> Functions{FSGArrayUtils::FromStdVector(FSenseGloveVarsType::GetFunctions(
+    std::string HardwareVersionString{TCHAR_TO_UTF8(*HardwareVersion)};
+    const TArray<bool> Functions{FSGArrayUtils::FromStdVector(FSenseGloveVarsType::GetFunctions(
        MoveTemp(HardwareVersionString), FirmwareVersion, SubFirmwareVersion))
    };
-    return MoveTemp(Functions);
+    return Functions;
 }

-FSGSenseGloveInfoImpl FSGSenseGloveVarsImpl::GenerateGloveModel(const FString& HardwareVersion,
-                                                                const int32 FirmwareVersion,
-                                                                const int32 SubFirmwareVersion, const bool bRightHanded)
+FSGSenseGloveInfoImpl FSGSenseGloveVarsImpl::GenerateGloveModel(
+    const FString& HardwareVersion, const int32 FirmwareVersion, const int32 SubFirmwareVersion,
+    const bool bRightHanded)
 {
-    std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
-    return FSGSenseGloveInfoImpl(FSenseGloveVarsType::GenerateGloveModel(
-        MoveTemp(HardwareVersionString), FirmwareVersion, SubFirmwareVersion, bRightHanded));
+    std::string HardwareVersionString{TCHAR_TO_UTF8(*HardwareVersion)};
+    return FSGSenseGloveInfoImpl{
+        FSenseGloveVarsType::GenerateGloveModel(
+            MoveTemp(HardwareVersionString), FirmwareVersion, SubFirmwareVersion, bRightHanded)
+    };
 }

-FSGSenseGloveInfoImpl FSGSenseGloveVarsImpl::GenerateGloveModel(const FString& HardwareVersion,
-                                                                const int32 FirmwareVersion,
-                                                                const int32 SubFirmwareVersion, const bool bRightHanded,
-                                                                const FString& CustomId)
+FSGSenseGloveInfoImpl FSGSenseGloveVarsImpl::GenerateGloveModel(
+    const FString& HardwareVersion, const int32 FirmwareVersion, const int32 SubFirmwareVersion,
+    const bool bRightHanded, const FString& CustomId)
 {
-    std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
-    std::string CustomIdString(TCHAR_TO_UTF8(*CustomId));
-    return FSGSenseGloveInfoImpl(FSenseGloveVarsType::GenerateGloveModel(
-        MoveTemp(HardwareVersionString), FirmwareVersion, SubFirmwareVersion, bRightHanded, MoveTemp(CustomIdString)));
+    std::string HardwareVersionString{TCHAR_TO_UTF8(*HardwareVersion)};
+    std::string CustomIdString{TCHAR_TO_UTF8(*CustomId)};
+    return FSGSenseGloveInfoImpl{
+        FSenseGloveVarsType::GenerateGloveModel(
+            MoveTemp(HardwareVersionString), FirmwareVersion, SubFirmwareVersion,
+            bRightHanded, MoveTemp(CustomIdString))
+    };
 }
@@ -161,10 +161,10 @@ float FSGSensorNormalizationImpl::NormalizeValue(const float Value, const int32
 TArray<float> FSGSensorNormalizationImpl::NormalizeValues(const TArray<float>& Values)
 {
    std::vector<float> ValuesVector{FSGArrayUtils::ToStdVector(Values)};
-    TArray<float> NormalizedValues{
+    const TArray<float> NormalizedValues{
        FSGArrayUtils::FromStdVector(Pimpl->SensorNormalization.NormalizeValues(MoveTemp(ValuesVector)))
    };
-    return MoveTemp(NormalizedValues);
+    return NormalizedValues;
 }

 bool FSGSensorNormalizationImpl::MovedEnough(const int32 Index) const
@@ -131,8 +131,8 @@ void FSGThresholdCommandImpl::SetThreshold(const int32 Finger, const float Thres

 TArray<float> FSGThresholdCommandImpl::GetThresholds() const
 {
-    TArray<float> Thresholds{FSGArrayUtils::FromStdVector(Pimpl->ThresholdCommand.GetThresholds())};
-    return MoveTemp(Thresholds);
+    const TArray<float> Thresholds{FSGArrayUtils::FromStdVector(Pimpl->ThresholdCommand.GetThresholds())};
+    return Thresholds;
 }

 void FSGThresholdCommandImpl::SetThresholds(const TArray<bool>& AffectedFingers, const TArray<float>& ThresholdValues)
@@ -150,8 +150,8 @@ bool FSGThresholdCommandImpl::GetFingerActive(const int32 Finger) const

 TArray<bool> FSGThresholdCommandImpl::GetActiveFingers() const
 {
-    TArray<bool> ActiveFingers{FSGArrayUtils::FromStdVector(Pimpl->ThresholdCommand.GetActiveFingers())};
-    return MoveTemp(ActiveFingers);
+    const TArray<bool> ActiveFingers{FSGArrayUtils::FromStdVector(Pimpl->ThresholdCommand.GetActiveFingers())};
+    return ActiveFingers;
 }

 void FSGThresholdCommandImpl::ClearThreshold(const int32 Finger)
@@ -171,8 +171,8 @@ bool FSGThresholdCommandImpl::Equals(const FSGThresholdCommandImpl& ThresholdCom

 FString FSGThresholdCommandImpl::ToString() const
 {
-    FString String{UTF8_TO_TCHAR(Pimpl->ThresholdCommand.ToString().c_str())};
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(Pimpl->ThresholdCommand.ToString().c_str())};
+    return String;
 }

 FSGThresholdCommandImpl::FImpl::FImpl(FSGThresholdCommandImpl* InOwner)
@@ -153,7 +153,7 @@ FVector FSGVect3DImpl::ToFVector() const
    ///     Up      Z

    FVector Vector(Pimpl->Vect3D.GetX(), -Pimpl->Vect3D.GetY(), Pimpl->Vect3D.GetZ());
-    return MoveTemp(Vector);
+    return Vector;
 }

 FSGVect3DImpl FSGVect3DImpl::operator+(const FSGVect3DImpl& Vect3DImpl) const
@@ -78,12 +78,12 @@ TArray<FSGVectorArray> USGHandInterpolatorKismetLibrary::InterpolateHandAngles(
            float, FSGFloatArray, &FSGFloatArray::FloatArray>(Flexions)
    };

-    TArray<FSGVectorArray> Angles{
+    const TArray<FSGVectorArray> Angles{
        FSGArrayUtils::ToNestedBPArray<FVector, FSGVectorArray>(
-            HandInterpolator->InterpolateHandAngles(FlexionsNestedArray, Abductions, CmcTwist))
+            HandInterpolator->InterpolateHandAngles(MoveTemp(FlexionsNestedArray), Abductions, CmcTwist))
    };

-    return MoveTemp(Angles);
+    return Angles;
 }

 bool USGHandInterpolatorKismetLibrary::Equals(const USGHandInterpolator* A, const USGHandInterpolator* B)
@@ -126,9 +126,11 @@ TArray<float> USGNova2GloveKismetLibrary::ToNormalizedValues_SD_OutSN(
 TArray<FSGVectorArray> USGNova2GloveKismetLibrary::CalculateHandAngles(
    const TArray<float>& NormalizedValues, const USGHandInterpolator* Interpolator, const bool bInfluenceIndex)
 {
-    TArray<FSGVectorArray> HandAngles = FSGArrayUtils::ToNestedBPArray<FVector, FSGVectorArray>(
-        USGNova2Glove::CalculateHandAngles(NormalizedValues, Interpolator, bInfluenceIndex));
-    return MoveTemp(HandAngles);
+    const TArray<FSGVectorArray> HandAngles{
+        FSGArrayUtils::ToNestedBPArray<FVector, FSGVectorArray>(
+            USGNova2Glove::CalculateHandAngles(NormalizedValues, Interpolator, bInfluenceIndex))
+    };
+    return HandAngles;
 }

 TArray<FSGVectorArray> USGNova2GloveKismetLibrary::ToNormalizedAngles(
@@ -136,9 +136,11 @@ TArray<float> USGNovaGloveKismetLibrary::ToNormalizedValues_SD_OutSN(
 TArray<FSGVectorArray> USGNovaGloveKismetLibrary::CalculateHandAngles(
    const TArray<float>& NormalizedValues, const USGHandInterpolator* Interpolator)
 {
-    TArray<FSGVectorArray> HandAngles = FSGArrayUtils::ToNestedBPArray<FVector, FSGVectorArray>(
-        USGNovaGlove::CalculateHandAngles(NormalizedValues, Interpolator));
-    return MoveTemp(HandAngles);
+    const TArray<FSGVectorArray> HandAngles{
+        FSGArrayUtils::ToNestedBPArray<FVector, FSGVectorArray>(
+            USGNovaGlove::CalculateHandAngles(NormalizedValues, Interpolator))
+    };
+    return HandAngles;
 }

 FString USGNovaGloveKismetLibrary::ToNovaCommandAsFlexion(const USGThresholdCommand* Thresholds)
@@ -286,7 +288,7 @@ bool USGNovaGloveKismetLibrary::QueueVibroLevels(USGNovaGlove* NovaGlove, const
 }

 bool USGNovaGloveKismetLibrary::QueueVibroLevel_L_L(USGNovaGlove* NovaGlove,
-                                                const ESGHapticLocation Location, const float Level01)
+                                                    const ESGHapticLocation Location, const float Level01)
 {
    return NovaGlove->QueueVibroLevel(Location, Level01);
 }
@@ -183,11 +183,11 @@ TArray<FSGVectorArray> USGSenseGloveInfoKismetLibrary::ToGloveAngles(const USGSe
        FSGArrayUtils::FromNestedBPArray<
            float, FSGFloatArray, &FSGFloatArray::FloatArray>(SensorAngles)
    };
-    TArray<FSGVectorArray> GloveAngles{
+    const TArray<FSGVectorArray> GloveAngles{
        FSGArrayUtils::ToNestedBPArray<FVector, FSGVectorArray>(
            SenseGloveInfo->ToGloveAngles(MoveTemp(SensorAnglesNestedArray)))
    };
-    return MoveTemp(GloveAngles);
+    return GloveAngles;
 }

 bool USGSenseGloveInfoKismetLibrary::Equals(const USGSenseGloveInfo* A, const USGSenseGloveInfo* B)
@@ -47,7 +47,7 @@ TArray<FRotator> FSGArrayUtils::QuatsToRotators(const TArray<FQuat>& QuatsArray)
        RotatorsArray.Add(MoveTemp(Rotator));
    }

-    return MoveTemp(RotatorsArray);
+    return RotatorsArray;
 }

 TArray<TArray<FRotator>> FSGArrayUtils::QuatsToRotators(const TArray<TArray<FQuat>>& QuatsNestedArray)
@@ -60,7 +60,7 @@ TArray<TArray<FRotator>> FSGArrayUtils::QuatsToRotators(const TArray<TArray<FQua
        RotatorsNestedArray.Add(MoveTemp(InnerRotatorsArray));
    }

-    return MoveTemp(RotatorsNestedArray);
+    return RotatorsNestedArray;
 }

 TArray<FQuat> FSGArrayUtils::RotatorsToQuats(const TArray<FRotator>& RotatorsArray)
@@ -73,7 +73,7 @@ TArray<FQuat> FSGArrayUtils::RotatorsToQuats(const TArray<FRotator>& RotatorsArr
        QuatsArray.Add(MoveTemp(Quat));
    }

-    return MoveTemp(QuatsArray);
+    return QuatsArray;
 }

 TArray<TArray<FQuat>> FSGArrayUtils::RotatorsToQuats(const TArray<TArray<FRotator>>& RotatorsNestedArray)
@@ -86,7 +86,7 @@ TArray<TArray<FQuat>> FSGArrayUtils::RotatorsToQuats(const TArray<TArray<FRotato
        QuatsNestedArray.Add(MoveTemp(InnerQuatsArray));
    }

-    return MoveTemp(QuatsNestedArray);
+    return QuatsNestedArray;
 }

 TArray<float> FSGArrayUtils::FromMillimeters(const std::vector<float>& Vector)
@@ -98,7 +98,7 @@ TArray<float> FSGArrayUtils::FromMillimeters(const std::vector<float>& Vector)
        Array.Add(FSGUnits::MillimetersToCentimeters(Value));
    }

-    return MoveTemp(Array);
+    return Array;
 }

 TArray<TArray<float>> FSGArrayUtils::FromMillimeters(const std::vector<std::vector<float>>& NestedVector)
@@ -111,7 +111,7 @@ TArray<TArray<float>> FSGArrayUtils::FromMillimeters(const std::vector<std::vect
        NestedArray.Add(MoveTemp(InnerArray));
    }

-    return MoveTemp(NestedArray);
+    return NestedArray;
 }

 std::vector<float> FSGArrayUtils::ToMillimeters(const TArray<float>& Array)
@@ -123,7 +123,7 @@ std::vector<float> FSGArrayUtils::ToMillimeters(const TArray<float>& Array)
        Vector.emplace_back(FSGUnits::CentimetersToMillimeters(Value));
    }

-    return MoveTemp(Vector);
+    return Vector;
 }

 std::vector<std::vector<float>> FSGArrayUtils::ToMillimeters(const TArray<TArray<float>>& NestedArray)
@@ -136,5 +136,5 @@ std::vector<std::vector<float>> FSGArrayUtils::ToMillimeters(const TArray<TArray
        NestedVector.emplace_back(MoveTemp(InnerVector));
    }

-    return MoveTemp(NestedVector);
+    return NestedVector;
 }
@@ -50,8 +50,8 @@ public:
    template<typename T>
    static FORCEINLINE TArray<T> FromStdVector(const std::vector<T>& Vector)
    {
-        TArray<T> Array(&Vector[0], Vector.size());
-        return MoveTemp(Array);
+        const TArray<T> Array{&Vector[0], Vector.size()};
+        return Array;
    }

    /// NOTE
@@ -67,7 +67,7 @@ public:
            Array.Add(bValue);
        }

-        return MoveTemp(Array);
+        return Array;
    }

    static TArray<FString> FromStdVector(const std::vector<std::string>& Vector)
@@ -80,7 +80,7 @@ public:
            Array.Add(MoveTemp(String));
        }

-        return MoveTemp(Array);
+        return Array;
    }

    template<typename T>
@@ -94,7 +94,7 @@ public:
            NestedArray.Add(MoveTemp(InnerArray));
        }

-        return MoveTemp(NestedArray);
+        return NestedArray;
    }

    template<typename T1, typename T2>
@@ -108,7 +108,7 @@ public:
            Array.Add(MoveTemp(T2Element));
        }

-        return MoveTemp(Array);
+        return Array;
    }

    template<typename T1, typename T2>
@@ -122,7 +122,7 @@ public:
            NestedArray.Add(MoveTemp(InnerArray));
        }

-        return MoveTemp(NestedArray);
+        return NestedArray;
    }

    template<typename T1, typename T2, typename IntermediateImpl, T2(IntermediateImpl::*ToT2TypeMethod)() const>
@@ -137,7 +137,7 @@ public:
            Array.Add(MoveTemp(T2Element));
        }

-        return MoveTemp(Array);
+        return Array;
    }

    template<typename T1, typename T2, typename IntermediateImpl, T2(IntermediateImpl::*ToT2TypeMethod)() const>
@@ -151,14 +151,14 @@ public:
            NestedArray.Add(MoveTemp(InnerArray));
        }

-        return MoveTemp(NestedArray);
+        return NestedArray;
    }

    template<typename T>
    static FORCEINLINE std::vector<T> ToStdVector(const TArray<T>& Array)
    {
        std::vector<T> Vector(&Array[0], &Array[0] + Array.Num());
-        return MoveTemp(Vector);
+        return Vector;
    }

    static std::vector<std::string> ToStdVector(const TArray<FString>& Array)
@@ -171,7 +171,7 @@ public:
            Vector.emplace_back(MoveTemp(StdString));
        }

-        return MoveTemp(Vector);
+        return Vector;
    }

    template<typename T>
@@ -185,7 +185,7 @@ public:
            NestedVector.emplace_back(MoveTemp(InnerVector));
        }

-        return MoveTemp(NestedVector);
+        return NestedVector;
    }

    template<typename T1, typename T2, const T2&(T1::*ToUnderlyingTypeMethod)() const>
@@ -199,7 +199,7 @@ public:
            Vector.emplace_back(MoveTemp(T2Element));
        }

-        return MoveTemp(Vector);
+        return Vector;
    }

    template<typename T1, typename T2, const T2&(T1::*ToUnderlyingTypeMethod)() const>
@@ -213,7 +213,7 @@ public:
            NestedVector.emplace_back(MoveTemp(InnerVector));
        }

-        return MoveTemp(NestedVector);
+        return NestedVector;
    }

    template<typename T1, typename T2, typename IntermediateImpl,
@@ -229,7 +229,7 @@ public:
            Vector.emplace_back(MoveTemp(T2Element));
        }

-        return MoveTemp(Vector);
+        return Vector;
    }

    template<typename T1, typename T2, typename IntermediateImpl,
@@ -244,7 +244,7 @@ public:
            NestedVector.emplace_back(MoveTemp(InnerVector));
        }

-        return MoveTemp(NestedVector);
+        return NestedVector;
    }

    template<typename T1, typename T2>
@@ -258,7 +258,7 @@ public:
            Array.Add(MoveTemp(T2Element));
        }

-        return MoveTemp(Array);
+        return Array;
    }

    template<typename T1, typename T2, T2*(*NewObjectMethod)(UObject*, const T1&)>
@@ -272,7 +272,7 @@ public:
            Array.Add(MoveTemp(T2Element));
        }

-        return MoveTemp(Array);
+        return Array;
    }

    template<typename T1, typename T2>
@@ -286,7 +286,7 @@ public:
            NestedArray.Add(MoveTemp(InnerArray));
        }

-        return MoveTemp(NestedArray);
+        return NestedArray;
    }

    template<typename T1, typename T2, T2*(*NewObjectMethod)(UObject*, const T1&)>
@@ -300,7 +300,7 @@ public:
            NestedArray.Add(MoveTemp(InnerArray));
        }

-        return MoveTemp(NestedArray);
+        return NestedArray;
    }

    template<typename T1, typename T2, typename S>
@@ -315,7 +315,7 @@ public:
            NestedBPArray.Add(MoveTemp(InnerArrayContainer));
        }

-        return MoveTemp(NestedBPArray);
+        return NestedBPArray;
    }

    template<typename T1, typename T2, typename S, T2*(*NewObjectMethod)(UObject*, const T1&)>
@@ -330,7 +330,7 @@ public:
            Array.Add(MoveTemp(InnerArrayContainer));
        }

-        return MoveTemp(Array);
+        return Array;
    }

    template<typename T1, typename T2, typename S>
@@ -345,7 +345,7 @@ public:
            Array.Add(MoveTemp(InnerArrayContainer));
        }

-        return MoveTemp(Array);
+        return Array;
    }

    template<typename T1, typename T2, const T2&(T1::*ToUnderlyingTypeMethod)() const>
@@ -359,7 +359,7 @@ public:
            ImplArray.Add(MoveTemp(T2Element));
        }

-        return MoveTemp(ImplArray);
+        return ImplArray;
    }

    template<typename T1, typename T2, const T2&(T1::*ToUnderlyingTypeMethod)() const>
@@ -373,7 +373,7 @@ public:
            ImplArray.Add(MoveTemp(T2Element));
        }

-        return MoveTemp(ImplArray);
+        return ImplArray;
    }

    template<typename T1, typename T2, const T2&(T1::*ToUnderlyingTypeMethod)() const>
@@ -387,7 +387,7 @@ public:
            ImplArray.Add(MoveTemp(InnerImplArray));
        }

-        return MoveTemp(ImplArray);
+        return ImplArray;
    }

    template<typename T1, typename T2, const T2&(T1::*ToUnderlyingTypeMethod)() const>
@@ -401,7 +401,7 @@ public:
            ImplArray.Add(MoveTemp(InnerImplArray));
        }

-        return MoveTemp(ImplArray);
+        return ImplArray;
    }

    template<typename T1, typename T2, const T2&(T1::*ToUnderlyingTypeMethod)() const, typename S, TArray<T1> S::*
@@ -416,7 +416,7 @@ public:
            ImplArray.Add(MoveTemp(InnerImplArray));
        }

-        return MoveTemp(ImplArray);
+        return ImplArray;
    }

    template<typename T1, typename T2, const T2&(T1::*ToUnderlyingTypeMethod)() const, typename S, TArray<T1*> S::*
@@ -431,7 +431,7 @@ public:
            ImplArray.Add(MoveTemp(InnerImplArray));
        }

-        return MoveTemp(ImplArray);
+        return ImplArray;
    }

    template<typename T, typename S, TArray<T> S::*InnerArray>
@@ -444,7 +444,7 @@ public:
            NestedArray.Add(InnerBPArrayContainer.*InnerArray);
        }

-        return MoveTemp(NestedArray);
+        return NestedArray;
    }

    template<typename T, typename S>
@@ -458,7 +458,7 @@ public:
            NestedBPArray.Add(MoveTemp(InnerBPArrayContainer));
        }

-        return MoveTemp(NestedBPArray);
+        return NestedBPArray;
    }

    template<typename T, typename S>
@@ -472,7 +472,7 @@ public:
            NestedBPArray.Add(MoveTemp(InnerBPArrayContainer));
        }

-        return MoveTemp(NestedBPArray);
+        return NestedBPArray;
    }

    static TArray<FRotator> QuatsToRotators(const TArray<FQuat>& QuatsArray);
@@ -488,7 +488,7 @@ public:
            RotatorsArray.Add(QuatsToRotators(QuatsInnerBPArrayContainer.*InnerArray));
        }

-        return MoveTemp(RotatorsArray);
+        return RotatorsArray;
    }

    template<typename S>
@@ -502,7 +502,7 @@ public:
            RotatorsNestedBPArray.Add(MoveTemp(RotatorsInnerBPArrayContainer));
        }

-        return MoveTemp(RotatorsNestedBPArray);
+        return RotatorsNestedBPArray;
    }

    template<typename Q, typename R, TArray<FQuat> Q::*InnerArray>
@@ -516,7 +516,7 @@ public:
            RotatorsNestedBPArray.Add(MoveTemp(RotatorsInnerBPArrayContainer));
        }

-        return MoveTemp(RotatorsNestedBPArray);
+        return RotatorsNestedBPArray;
    }

    static TArray<FQuat> RotatorsToQuats(const TArray<FRotator>& RotatorsNestedArray);
@@ -532,7 +532,7 @@ public:
            QuatsArray.Add(RotatorsToQuats(RotatorsInnerBPArrayContainer.*InnerArray));
        }

-        return MoveTemp(QuatsArray);
+        return QuatsArray;
    }

    template<typename S>
@@ -546,7 +546,7 @@ public:
            QuatsNestedBPArray.Add(MoveTemp(QuatsInnerBPArrayContainer));
        }

-        return MoveTemp(QuatsNestedBPArray);
+        return QuatsNestedBPArray;
    }

    template<typename Q, typename R, TArray<FRotator> Q::*InnerArray>
@@ -560,7 +560,7 @@ public:
            QuatsNestedBPArray.Add(MoveTemp(QuatsInnerBPArrayContainer));
        }

-        return MoveTemp(QuatsNestedBPArray);
+        return QuatsNestedBPArray;
    }

    static TArray<float> FromMillimeters(const std::vector<float>& Vector);
@@ -576,7 +576,7 @@ public:
            Array.Add(FSGUnits::MillimetersToCentimeters<V3D, V3DImpl>(Value));
        }

-        return MoveTemp(Array);
+        return Array;
    }

    template<typename V3D, typename V3DImpl>
@@ -590,7 +590,7 @@ public:
            NestedArray.Add(MoveTemp(InnerArray));
        }

-        return MoveTemp(NestedArray);
+        return NestedArray;
    }

    static std::vector<float> ToMillimeters(const TArray<float>& Array);
@@ -607,7 +607,7 @@ public:
            NestedVector.emplace_back(MoveTemp(InnerVector));
        }

-        return MoveTemp(NestedVector);
+        return NestedVector;
    }

    template<typename V3D, typename V3DImpl>
@@ -620,7 +620,7 @@ public:
            Vector.emplace_back(FSGUnits::CentimetersToMillimeters<V3D, V3DImpl>(Value));
        }

-        return MoveTemp(Vector);
+        return Vector;
    }

    template<typename V3D, typename V3DImpl>
@@ -634,7 +634,7 @@ public:
            NestedVector.emplace_back(MoveTemp(InnerVector));
        }

-        return MoveTemp(NestedVector);
+        return NestedVector;
    }

    static std::vector<float> ToSenseGloveAngles(const TArray<float>& Array)
@@ -646,7 +646,7 @@ public:
            Vector.emplace_back(FSGAngles::TransformToSenseGlove(Value));
        }

-        return MoveTemp(Vector);
+        return Vector;
    }

    static std::vector<std::vector<float>> ToSenseGloveAngles(const TArray<TArray<float>>& NestedArray)
@@ -659,7 +659,7 @@ public:
            NestedVector.emplace_back(MoveTemp(InnerVector));
        }

-        return MoveTemp(NestedVector);
+        return NestedVector;
    }

    template<typename V3D>
@@ -672,7 +672,7 @@ public:
            Vector.emplace_back(FSGAngles::TransformToSenseGlove<V3D>(Value));
        }

-        return MoveTemp(Vector);
+        return Vector;
    }

    template<typename V3D>
@@ -686,7 +686,7 @@ public:
            NestedVector.emplace_back(MoveTemp(InnerVector));
        }

-        return MoveTemp(NestedVector);
+        return NestedVector;
    }

    static TArray<float> FromSenseGloveAngles(const std::vector<float>& Vector)
@@ -698,7 +698,7 @@ public:
            Array.Add(FSGAngles::TransformToUnreal(Value));
        }

-        return MoveTemp(Array);
+        return Array;
    }

    static TArray<TArray<float>> FromSenseGloveAngles(const std::vector<std::vector<float>>& NestedVector)
@@ -711,7 +711,7 @@ public:
            Array.Add(MoveTemp(InnerArray));
        }

-        return MoveTemp(Array);
+        return Array;
    }

    template<typename V3D>
@@ -724,7 +724,7 @@ public:
            Array.Add(FSGAngles::TransformToUnreal<V3D>(Value));
        }

-        return MoveTemp(Array);
+        return Array;
    }

    template<typename V3D>
@@ -738,7 +738,7 @@ public:
            NestedArray.Add(MoveTemp(InnerArray));
        }

-        return MoveTemp(NestedArray);
+        return NestedArray;
    }

 public: