shorten mangled blueprint nodes in order to avoid doc generation issues

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGBasicHandModelKismetLibrary.cpp

@@ -43,15 +43,14 @@ USGBasicHandModel* USGBasicHandModelKismetLibrary::MakeBasicHandModel(UObject* W
     return USGBasicHandModel::NewBasicHandModel(WorldContextObject);
 }
 
-USGBasicHandModel* USGBasicHandModelKismetLibrary::MakeBasicHandModel_bRightHanded_Lengths_StartPositions(
+USGBasicHandModel* USGBasicHandModelKismetLibrary::MakeBasicHandModel_bRH_L_SP(
     UObject* WorldContextObject,
     const bool bRightHanded, const TArray<FSGFloatArray>& Lengths, const TArray<FVector>& StartPositions)
 {
     return USGBasicHandModel::NewBasicHandModel(WorldContextObject, bRightHanded, Lengths, StartPositions);
 }
 
-USGBasicHandModel* USGBasicHandModelKismetLibrary::
+USGBasicHandModel* USGBasicHandModelKismetLibrary::MakeBasicHandModel_bRH_L_SP_TArrayFQuat_SR(
-MakeBasicHandModel_bRightHanded_Lengths_StartPositions_TArrayFQuatStartRotations(
     UObject* WorldContextObject,
     const bool bRightHanded, const TArray<FSGFloatArray>& Lengths,
     const TArray<FVector>& StartPositions, const TArray<FQuat>& StartRotations)
@@ -60,8 +59,7 @@ MakeBasicHandModel_bRightHanded_Lengths_StartPositions_TArrayFQuatStartRotations
                                                 StartPositions, StartRotations);
 }
 
-USGBasicHandModel* USGBasicHandModelKismetLibrary::
+USGBasicHandModel* USGBasicHandModelKismetLibrary::MakeBasicHandModel_bRH_L_SP_TArrayFRotator_SR(
-MakeBasicHandModel_bRightHanded_Lengths_StartPositions_TArrayFRotatorStartRotations(
     UObject* WorldContextObject,
     const bool bRightHanded, const TArray<FSGFloatArray>& Lengths,
     const TArray<FVector>& StartPositions, const TArray<FRotator>& StartRotations)
@@ -106,20 +104,21 @@ TArray<FSGFloatArray> USGBasicHandModelKismetLibrary::GetFingerLengths(const USG
     return FSGArrayUtils::ToBPNestedArray<float, FSGFloatArray>(BasicHandModel->GetFingerLengths());
 }
 
-TArray<float> USGBasicHandModelKismetLibrary::GetFingerLengths_ESGFinger(const USGBasicHandModel* BasicHandModel,
+TArray<float> USGBasicHandModelKismetLibrary::GetFingerLengths_F(const USGBasicHandModel* BasicHandModel,
-                                                                         const ESGFinger Finger)
+                                                                 const ESGFinger Finger)
 {
     return BasicHandModel->GetFingerLengths(Finger);
 }
 
-void USGBasicHandModelKismetLibrary::SetFingerLengths_ESGFinger(USGBasicHandModel* BasicHandModel,
+void USGBasicHandModelKismetLibrary::SetFingerLengths_ESGFinger_F_L(USGBasicHandModel* BasicHandModel,
-                                                                const ESGFinger Finger, const TArray<float>& Lengths)
+                                                                    const ESGFinger Finger,
+                                                                    const TArray<float>& Lengths)
 {
     BasicHandModel->SetFingerLengths(Finger, Lengths);
 }
 
-void USGBasicHandModelKismetLibrary::SetFingerLengths_uint8Finger(USGBasicHandModel* BasicHandModel,
+void USGBasicHandModelKismetLibrary::SetFingerLengths_uint8_F_L(USGBasicHandModel* BasicHandModel,
-                                                                  const uint8 Finger, const TArray<float>& Lengths)
+                                                                const uint8 Finger, const TArray<float>& Lengths)
 {
     BasicHandModel->SetFingerLengths(Finger, Lengths);
 }
@@ -129,8 +128,8 @@ TArray<FSGFloatArray> USGBasicHandModelKismetLibrary::GetFingerRatios(const USGB
     return FSGArrayUtils::ToBPNestedArray<float, FSGFloatArray>(BasicHandModel->GetFingerRatios());
 }
 
-TArray<float> USGBasicHandModelKismetLibrary::GetFingerRatios_Finger(const USGBasicHandModel* BasicHandModel,
+TArray<float> USGBasicHandModelKismetLibrary::GetFingerRatios_F(const USGBasicHandModel* BasicHandModel,
-                                                                     const ESGFinger Finger)
+                                                                const ESGFinger Finger)
 {
     return BasicHandModel->GetFingerRatios(Finger);
 }
@@ -140,14 +139,15 @@ TArray<FVector> USGBasicHandModelKismetLibrary::GetStartJointPositions(const USG
     return BasicHandModel->GetStartJointPositions();
 }
 
-void USGBasicHandModelKismetLibrary::SetStartJointPosition_ESGFinger(USGBasicHandModel* BasicHandModel,
+void USGBasicHandModelKismetLibrary::SetStartJointPosition_ESGFinger_F_P(USGBasicHandModel* BasicHandModel,
-                                                                     const ESGFinger Finger, const FVector& Position)
+                                                                         const ESGFinger Finger,
+                                                                         const FVector& Position)
 {
     BasicHandModel->SetStartJointPosition(Finger, Position);
 }
 
-void USGBasicHandModelKismetLibrary::SetStartJointPosition_uint8Finger(USGBasicHandModel* BasicHandModel,
+void USGBasicHandModelKismetLibrary::SetStartJointPosition_uint8_F_P(USGBasicHandModel* BasicHandModel,
-                                                                       const uint8 Finger, const FVector& Position)
+                                                                     const uint8 Finger, const FVector& Position)
 {
     BasicHandModel->SetStartJointPosition(Finger, Position);
 }
@@ -188,14 +188,14 @@ FRotator USGBasicHandModelKismetLibrary::GetJointRotation_FRotator(const USGBasi
     return BasicHandModel->GetJointRotation(Finger);
 }
 
-void USGBasicHandModelKismetLibrary::SetJointRotation_FQuatNewRotation_Finger(
+void USGBasicHandModelKismetLibrary::SetJointRotation_FQuat_NR_F(USGBasicHandModel* BasicHandModel,
-    USGBasicHandModel* BasicHandModel, const FQuat& NewRotation, const ESGFinger Finger)
+                                                                 const FQuat& NewRotation, const ESGFinger Finger)
 {
     return BasicHandModel->SetJointRotation(NewRotation, Finger);
 }
 
-void USGBasicHandModelKismetLibrary::SetJointRotation_FRotatorNewRotation_Finger(
+void USGBasicHandModelKismetLibrary::SetJointRotation_FRotator_NR_F(USGBasicHandModel* BasicHandModel,
-    USGBasicHandModel* BasicHandModel, const FRotator& NewRotation, const ESGFinger Finger)
+                                                                    const FRotator& NewRotation, const ESGFinger Finger)
 {
     return BasicHandModel->SetJointRotation(NewRotation, Finger);
 }
@@ -226,8 +226,7 @@ FString USGBasicHandModelKismetLibrary::ToString(const USGBasicHandModel* BasicH
     return BasicHandModel->ToString();
 }
 
-FString USGBasicHandModelKismetLibrary::ToString_bLengthsOnly(const USGBasicHandModel* BasicHandModel,
+FString USGBasicHandModelKismetLibrary::ToString_bLO(const USGBasicHandModel* BasicHandModel, const bool bLengthsOnly)
-                                                              const bool bLengthsOnly)
 {
     return BasicHandModel->ToString(bLengthsOnly);
 }

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGBuzzCommandKismetLibrary.cpp

@@ -42,20 +42,20 @@ USGBuzzCommand* USGBuzzCommandKismetLibrary::MakeBuzzCommand(UObject* WorldConte
     return USGBuzzCommand::NewBuzzCommand(WorldContextObject);
 }
 
-USGBuzzCommand* USGBuzzCommandKismetLibrary::MakeBuzzCommand_BuzzLevels(
+USGBuzzCommand* USGBuzzCommandKismetLibrary::MakeBuzzCommand_BL(
     UObject* WorldContextObject, const TArray<int32>& BuzzLevels)
 {
     return USGBuzzCommand::NewBuzzCommand(WorldContextObject, BuzzLevels);
 }
 
-USGBuzzCommand* USGBuzzCommandKismetLibrary::MakeBuzzCommand_Thumb_Index_Middle_Ring_Pinky(
+USGBuzzCommand* USGBuzzCommandKismetLibrary::MakeBuzzCommand_T_I_M_R_P(
     UObject* WorldContextObject,
     const int32 Thumb, const int32 Index, const int32 Middle, const int32 Ring, const int32 Pinky)
 {
     return USGBuzzCommand::NewBuzzCommand(WorldContextObject, Thumb, Index, Middle, Ring, Pinky);
 }
 
-USGBuzzCommand* USGBuzzCommandKismetLibrary::MakeBuzzCommand_Finger_BuzzLevel(
+USGBuzzCommand* USGBuzzCommandKismetLibrary::MakeBuzzCommand_F_BL(
     UObject* WorldContextObject, const ESGFinger Finger, const int32 BuzzLevel)
 {
     return USGBuzzCommand::NewBuzzCommand(WorldContextObject, Finger, BuzzLevel);

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGCalibrationDataPointKismetLibrary.cpp

@@ -42,7 +42,7 @@ USGCalibrationDataPoint* USGCalibrationDataPointKismetLibrary::MakeCalibrationDa
     return USGCalibrationDataPoint::NewCalibrationDataPoint(WorldContextObject);
 }
 
-USGCalibrationDataPoint* USGCalibrationDataPointKismetLibrary::MakeCalibrationDataPoint_CurrentStage_CalibrationValues(
+USGCalibrationDataPoint* USGCalibrationDataPointKismetLibrary::MakeCalibrationDataPoint_CS_CV(
     UObject* WorldContextObject, const int32 CurrentStage, const TArray<FVector>& CalibrationValues)
 {
     return USGCalibrationDataPoint::NewCalibrationDataPoint(WorldContextObject, CurrentStage, CalibrationValues);

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGDeviceKismetLibrary.cpp

@@ -42,7 +42,7 @@ void USGDeviceKismetLibrary::ParseFirmware(const FString& RawFirmware, int32& Ou
     return USGDevice::ParseFirmware(RawFirmware, OutMainVersion, OutSubVersion);
 }
 
-FString USGDeviceKismetLibrary::ToString_DeviceType(ESGDeviceType DeviceType)
+FString USGDeviceKismetLibrary::ToString_DT(const ESGDeviceType DeviceType)
 {
     return USGDevice::ToString(DeviceType);
 }
@@ -122,7 +122,7 @@ bool USGDeviceKismetLibrary::GetBatteryLevel(USGDevice* SGDevice, float& OutLeve
     return SGDevice->GetBatteryLevel(OutLevel);
 }
 
-FString USGDeviceKismetLibrary::ToString_SGDevice(const USGDevice* SGDevice)
+FString USGDeviceKismetLibrary::ToString(const USGDevice* SGDevice)
 {
     return SGDevice->ToString();
 }

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGDeviceListKismetLibrary.cpp

@@ -63,14 +63,14 @@ TArray<USGDevice*> USGDeviceListKismetLibrary::GetDevices(UObject* WorldContextO
     return FSGDeviceList::GetDevices(WorldContextObject);
 }
 
-TArray<USGDevice*> USGDeviceListKismetLibrary::GetDevices_TSubclassOf_USGDevice(UObject* WorldContextObject,
+TArray<USGDevice*> USGDeviceListKismetLibrary::GetDevices_TSubclassOfUSGDevice_DT(
-    const TSubclassOf<USGDevice>& DeviceType)
+    UObject* WorldContextObject, const TSubclassOf<USGDevice>& DeviceType)
 {
     return FSGDeviceList::GetDevices(WorldContextObject, DeviceType);
 }
 
-TArray<USGDevice*> USGDeviceListKismetLibrary::GetDevices_ESGDeviceType(UObject* WorldContextObject,
+TArray<USGDevice*> USGDeviceListKismetLibrary::GetDevices_ESGDeviceType_DT(
-                                                                        const ESGDeviceType DeviceType)
+    UObject* WorldContextObject, const ESGDeviceType DeviceType)
 {
     return FSGDeviceList::GetDevices(WorldContextObject, DeviceType);
 }

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGDeviceModelKismetLibrary.cpp

@@ -42,7 +42,7 @@ USGDeviceModel* USGDeviceModelKismetLibrary::MakeDeviceModel(UObject* WorldConte
     return USGDeviceModel::NewDeviceModel(WorldContextObject);
 }
 
-USGDeviceModel* USGDeviceModelKismetLibrary::MakeDeviceModel_Id_HardwareVersion_FirmwareVersion_SubFirmwareVersion(
+USGDeviceModel* USGDeviceModelKismetLibrary::MakeDeviceModel_I_HV_FV_SFV(
     UObject* WorldContextObject,
     const FString& Id, const FString& HardwareVersion, const int32 FirmwareVersion, const int32 SubFirmwareVersion)
 {

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGForceFeedbackCommandKismetLibrary.cpp

@@ -42,13 +42,13 @@ USGForceFeedbackCommand* USGForceFeedbackCommandKismetLibrary::MakeForceFeedback
     return USGForceFeedbackCommand::NewForceFeedbackCommand(WorldContextObject);
 }
 
-USGForceFeedbackCommand* USGForceFeedbackCommandKismetLibrary::MakeForceFeedbackCommand_ForceFeedbackLevels(
+USGForceFeedbackCommand* USGForceFeedbackCommandKismetLibrary::MakeForceFeedbackCommand_FFL(
     UObject* WorldContextObject, const TArray<int32>& ForceFeedbackLevels)
 {
     return USGForceFeedbackCommand::NewForceFeedbackCommand(WorldContextObject, ForceFeedbackLevels);
 }
 
-USGForceFeedbackCommand* USGForceFeedbackCommandKismetLibrary::MakeForceFeedbackCommand_Thumb_Index_Middle_Ring_Pinky(
+USGForceFeedbackCommand* USGForceFeedbackCommandKismetLibrary::MakeForceFeedbackCommand_T_I_M_R_P(
     UObject* WorldContextObject,
     const int32 Thumb, const int32 Index, const int32 Middle, const int32 Ring, const int32 Pinky)
 {
@@ -56,7 +56,7 @@ USGForceFeedbackCommand* USGForceFeedbackCommandKismetLibrary::MakeForceFeedback
         WorldContextObject, Thumb, Index, Middle, Ring, Pinky);
 }
 
-USGForceFeedbackCommand* USGForceFeedbackCommandKismetLibrary::MakeForceFeedbackCommand_Finger_BuzzLevel(
+USGForceFeedbackCommand* USGForceFeedbackCommandKismetLibrary::MakeForceFeedbackCommand_F_BL(
     UObject* WorldContextObject, const ESGFinger Finger, const int32 BuzzLevel)
 {
     return USGForceFeedbackCommand::NewForceFeedbackCommand(WorldContextObject, Finger, BuzzLevel);

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGHandInterpolatorKismetLibrary.cpp

@@ -43,21 +43,20 @@ USGHandInterpolator* USGHandInterpolatorKismetLibrary::MakeHandInterpolator(UObj
     return USGHandInterpolator::NewHandInterpolator(WorldContextObject);
 }
 
-USGHandInterpolator* USGHandInterpolatorKismetLibrary::MakeHandInterpolator_JointInterpolations(
+USGHandInterpolator* USGHandInterpolatorKismetLibrary::MakeHandInterpolator_JI(
     UObject* WorldContextObject, const TArray<FSGInterpolationSetArray>& JointInterpolations)
 {
     return USGHandInterpolator::NewHandInterpolator(WorldContextObject, JointInterpolations);
 }
 
-USGHandInterpolator* USGHandInterpolatorKismetLibrary::MakeHandInterpolator_JointInterpolations_FQuatCmcStartRotation(
+USGHandInterpolator* USGHandInterpolatorKismetLibrary::MakeHandInterpolator_JI_FQuat_CSR(
     UObject* WorldContextObject,
     const TArray<FSGInterpolationSetArray>& JointInterpolations, const FQuat& CmcStartRotation)
 {
     return USGHandInterpolator::NewHandInterpolator(WorldContextObject, JointInterpolations, CmcStartRotation);
 }
 
-USGHandInterpolator*
+USGHandInterpolator* USGHandInterpolatorKismetLibrary::MakeHandInterpolator_JI_FRotator_CSR(
-USGHandInterpolatorKismetLibrary::MakeHandInterpolator_JointInterpolations_FRotatorCmcStartRotation(
     UObject* WorldContextObject,
     const TArray<FSGInterpolationSetArray>& JointInterpolations, const FRotator& CmcStartRotation)
 {
@@ -112,41 +111,41 @@ FRotator USGHandInterpolatorKismetLibrary::GetCmcStartRotation_FRotator(
     return HandInterpolator->GetCmcStartRotation();
 }
 
-float USGHandInterpolatorKismetLibrary::CalculateAngle_Finger_int32Movement_Value(
+float USGHandInterpolatorKismetLibrary::CalculateAngle_F_int32_M_V(
     const USGHandInterpolator* HandInterpolator, const ESGFinger Finger, const int32 Movement, const float Value)
 {
     return HandInterpolator->CalculateAngle(Finger, Movement, Value);
 }
 
-float USGHandInterpolatorKismetLibrary::CalculateAngle_Finger_ESGFingerMovement_Value(
+float USGHandInterpolatorKismetLibrary::CalculateAngle_F_ESGFingerMovement_M_V(
     const USGHandInterpolator* HandInterpolator, const ESGFinger Finger, const ESGFingerMovement Movement,
     const float Value)
 {
     return HandInterpolator->CalculateAngle(Finger, Movement, Value);
 }
 
-float USGHandInterpolatorKismetLibrary::CalculateAngle_Finger_ESGThumbMovement_Value(
+float USGHandInterpolatorKismetLibrary::CalculateAngle_F_ESGThumbMovement_M_V(
     const USGHandInterpolator* HandInterpolator, const ESGFinger Finger, const ESGThumbMovement Movement,
     const float Value)
 {
     return HandInterpolator->CalculateAngle(Finger, Movement, Value);
 }
 
-void USGHandInterpolatorKismetLibrary::SetInterpolation_int32Finger_int32Movement_InputAt0_InputAt1_AngleAt0_AngleAt1(
+void USGHandInterpolatorKismetLibrary::SetInterpolation_int32_F_int32_M_IA0_IA1_AA0_AA1(
     USGHandInterpolator* HandInterpolator, const int32 Finger, const int32 Movement,
     const float InputAt0, const float InputAt1, const float AngleAt0, const float AngleAt1)
 {
     return HandInterpolator->SetInterpolation(Finger, Movement, InputAt0, InputAt1, AngleAt0, AngleAt1);
 }
 
-void USGHandInterpolatorKismetLibrary::SetInterpolation_ESGFinger_ESGFingerMovement_InputAt0_InputAt1_AngleAt0_AngleAt1(
+void USGHandInterpolatorKismetLibrary::SetInterpolation_ESGFinger_F_ESGFingerMovement_M_IA0_IA1_AA0_AA1(
     USGHandInterpolator* HandInterpolator, const ESGFinger Finger, const ESGFingerMovement Movement,
     const float InputAt0, const float InputAt1, const float AngleAt0, const float AngleAt1)
 {
     return HandInterpolator->SetInterpolation(Finger, Movement, InputAt0, InputAt1, AngleAt0, AngleAt1);
 }
 
-void USGHandInterpolatorKismetLibrary::SetInterpolation_Movement_InputAt0_InputAt1_AngleAt0_AngleAt1(
+void USGHandInterpolatorKismetLibrary::SetInterpolation_M_IA0_IA1_AA0_AA1(
     USGHandInterpolator* HandInterpolator, const ESGThumbMovement Movement,
     const float InputAt0, const float InputAt1, const float AngleAt0, const float AngleAt1)
 {

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGHandPoseKismetLibrary.cpp

@@ -44,7 +44,7 @@ USGHandPose* USGHandPoseKismetLibrary::MakeHandPose(UObject* WorldContextObject)
     return USGHandPose::NewHandPose(WorldContextObject);
 }
 
-USGHandPose* USGHandPoseKismetLibrary::MakeHandPose_bRightHanded_JointPositions_FSGQuatArrayJointRotations_HandAngles(
+USGHandPose* USGHandPoseKismetLibrary::MakeHandPose_bRH_JP_FSGQuatArray_JR_HA(
     UObject* WorldContextObject,
     const bool bRightHanded, const TArray<FSGVectorArray>& JointPositions, const TArray<FSGQuatArray>& JointRotations,
     const TArray<FSGVectorArray>& HandAngles)
@@ -52,8 +52,7 @@ USGHandPose* USGHandPoseKismetLibrary::MakeHandPose_bRightHanded_JointPositions_
     return USGHandPose::NewHandPose(WorldContextObject, bRightHanded, JointPositions, JointRotations, HandAngles);
 }
 
-USGHandPose* USGHandPoseKismetLibrary::
+USGHandPose* USGHandPoseKismetLibrary::MakeHandPose_bRH_JP_FSGRotatorArray_JR_HA(
-MakeHandPose_bRightHanded_JointPositions_FSGRotatorArrayJointRotations_HandAngles(
     UObject* WorldContextObject,
     const bool bRightHanded,
     const TArray<FSGVectorArray>& JointPositions, const TArray<FSGRotatorArray>& JointRotations,
@@ -67,7 +66,7 @@ USGHandPose* USGHandPoseKismetLibrary::Deserialize(UObject* WorldContextObject,
     return USGHandPose::Deserialize(WorldContextObject, SerializedString);
 }
 
-USGHandPose* USGHandPoseKismetLibrary::FromHandAngles_HandAngles_bRightHanded_HandDimensions(
+USGHandPose* USGHandPoseKismetLibrary::FromHandAngles_HA_bRH_HD(
     UObject* WorldContextObject,
     const TArray<FSGVectorArray>& HandAngles, const bool bRightHanded, const USGBasicHandModel* HandDimensions)
 {
@@ -78,7 +77,7 @@ USGHandPose* USGHandPoseKismetLibrary::FromHandAngles_HandAngles_bRightHanded_Ha
                                        HandDimensions);
 }
 
-USGHandPose* USGHandPoseKismetLibrary::FromHandAngles_HandAngles_bRightHanded(
+USGHandPose* USGHandPoseKismetLibrary::FromHandAngles_HA_bRH(
     UObject* WorldContextObject, const TArray<FSGVectorArray>& HandAngles, const bool bRightHanded)
 {
     TArray<TArray<FVector>> HandAnglesNestedArray{
@@ -87,47 +86,46 @@ USGHandPose* USGHandPoseKismetLibrary::FromHandAngles_HandAngles_bRightHanded(
     return USGHandPose::FromHandAngles(WorldContextObject, MoveTemp(HandAnglesNestedArray), bRightHanded);
 }
 
-USGHandPose* USGHandPoseKismetLibrary::DefaultIdle_bRightHanded_HandDimensions(
+USGHandPose* USGHandPoseKismetLibrary::DefaultIdle_bRH_HD(
     UObject* WorldContextObject, const bool bRightHanded, const USGBasicHandModel* HandDimensions)
 {
     return USGHandPose::DefaultIdle(WorldContextObject, bRightHanded, HandDimensions);
 }
 
-USGHandPose* USGHandPoseKismetLibrary::DefaultIdle_bRightHanded(UObject* WorldContextObject,
+USGHandPose* USGHandPoseKismetLibrary::DefaultIdle_bRH(UObject* WorldContextObject, const bool bRightHanded)
-                                                                const bool bRightHanded)
 {
     return USGHandPose::DefaultIdle(WorldContextObject, bRightHanded);
 }
 
-USGHandPose* USGHandPoseKismetLibrary::FlatHand_bRightHanded_HandDimensions(
+USGHandPose* USGHandPoseKismetLibrary::FlatHand_bRH_HD(
     UObject* WorldContextObject, const bool bRightHanded, const USGBasicHandModel* HandDimensions)
 {
     return USGHandPose::FlatHand(WorldContextObject, bRightHanded, HandDimensions);
 }
 
-USGHandPose* USGHandPoseKismetLibrary::FlatHand_bRightHanded(UObject* WorldContextObject, const bool bRightHanded)
+USGHandPose* USGHandPoseKismetLibrary::FlatHand_bRH(UObject* WorldContextObject, const bool bRightHanded)
 {
     return USGHandPose::FlatHand(WorldContextObject, bRightHanded);
 }
 
-USGHandPose* USGHandPoseKismetLibrary::ThumbsUp_bRightHanded_HandDimensions(
+USGHandPose* USGHandPoseKismetLibrary::ThumbsUp_bRH_HD(
     UObject* WorldContextObject, const bool bRightHanded, const USGBasicHandModel* HandDimensions)
 {
     return USGHandPose::ThumbsUp(WorldContextObject, bRightHanded, HandDimensions);
 }
 
-USGHandPose* USGHandPoseKismetLibrary::ThumbsUp_bRightHanded(UObject* WorldContextObject, const bool bRightHanded)
+USGHandPose* USGHandPoseKismetLibrary::ThumbsUp_bRH(UObject* WorldContextObject, const bool bRightHanded)
 {
     return USGHandPose::ThumbsUp(WorldContextObject, bRightHanded);
 }
 
-USGHandPose* USGHandPoseKismetLibrary::Fist_bRightHanded_HandDimensions(
+USGHandPose* USGHandPoseKismetLibrary::Fist_bRH_HD(
     UObject* WorldContextObject, const bool bRightHanded, const USGBasicHandModel* HandDimensions)
 {
     return USGHandPose::Fist(WorldContextObject, bRightHanded, HandDimensions);
 }
 
-USGHandPose* USGHandPoseKismetLibrary::Fist_bRightHanded(UObject* WorldContextObject, const bool bRightHanded)
+USGHandPose* USGHandPoseKismetLibrary::Fist_bRH(UObject* WorldContextObject, const bool bRightHanded)
 {
     return USGHandPose::Fist(WorldContextObject, bRightHanded);
 }
@@ -162,13 +160,13 @@ bool USGHandPoseKismetLibrary::Equals(const USGHandPose* A, const USGHandPose* B
     return A->Equals(B);
 }
 
-float USGHandPoseKismetLibrary::GetNormalizedFlexion_Finger_bClamp01(
+float USGHandPoseKismetLibrary::GetNormalizedFlexion_F_bC01(
     const USGHandPose* HandPose, const ESGFinger Finger, const bool bClamp01)
 {
     return HandPose->GetNormalizedFlexion(Finger, bClamp01);
 }
 
-TArray<float> USGHandPoseKismetLibrary::GetNormalizedFlexion_bClamp01(
+TArray<float> USGHandPoseKismetLibrary::GetNormalizedFlexion_bC01(
     const USGHandPose* HandPose, const bool bClamp01)
 {
     return HandPose->GetNormalizedFlexion(bClamp01);

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGHandProfileKismetLibrary.cpp

@@ -42,7 +42,7 @@ USGHandProfile* USGHandProfileKismetLibrary::MakeHandProfile(UObject* WorldConte
     return USGHandProfile::NewHandProfile(WorldContextObject);
 }
 
-USGHandProfile* USGHandProfileKismetLibrary::MakeHandProfile_bRightHanded_SenseGloveHandProfile_NovaGloveHandProfile(
+USGHandProfile* USGHandProfileKismetLibrary::MakeHandProfile_bRH_SGHP_NGHP(
     UObject* WorldContextObject,
     const bool bRightHanded,
     const USGSenseGloveHandProfile* SenseGloveHandProfile, const USGNovaGloveHandProfile* NovaGloveHandProfile)

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGHapticGloveCalibrationCheckKismetLibrary.cpp

@@ -44,8 +44,7 @@ USGHapticGloveCalibrationCheck* USGHapticGloveCalibrationCheckKismetLibrary::Mak
     return USGHapticGloveCalibrationCheck::NewHapticGloveCalibrationCheck(WorldContextObject);
 }
 
-USGHapticGloveCalibrationCheck* USGHapticGloveCalibrationCheckKismetLibrary::
+USGHapticGloveCalibrationCheck* USGHapticGloveCalibrationCheckKismetLibrary::MakeHapticGloveCalibrationCheck_LCR(
-MakeHapticGloveCalibrationCheck_LastCalibrationRange(
     UObject* WorldContextObject, const USGSensorRange* LastCalibrationRange)
 {
     return USGHapticGloveCalibrationCheck::NewHapticGloveCalibrationCheck(WorldContextObject, LastCalibrationRange);

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGHapticGloveCalibrationSequenceKismetLibrary.cpp

@@ -37,8 +37,9 @@
 
 #include "SGCore/SGHapticGloveCalibrationSequence.h"
 
-USGHapticGloveCalibrationSequence* USGHapticGloveCalibrationSequenceKismetLibrary::
+USGHapticGloveCalibrationSequence*
-MakeHapticGloveCalibrationSequence_GloveToCalibrate(UObject* WorldContextObject, const USGHapticGlove* GloveToCalibrate)
+USGHapticGloveCalibrationSequenceKismetLibrary::MakeHapticGloveCalibrationSequence_GTC(
+    UObject* WorldContextObject, const USGHapticGlove* GloveToCalibrate)
 {
     return USGHapticGloveCalibrationSequence::NewHapticGloveCalibrationSequence(WorldContextObject, GloveToCalibrate);
 }
@@ -48,9 +49,10 @@ int32 USGHapticGloveCalibrationSequenceKismetLibrary::GetMaxDataPoints()
     return USGHapticGloveCalibrationSequence::GetMaxDataPoints();
 }
 
-bool USGHapticGloveCalibrationSequenceKismetLibrary::CompileProfile_SensorRange_ForDevice_bRightHanded_OutProfile(
+bool USGHapticGloveCalibrationSequenceKismetLibrary::CompileProfile_SR_FD_bRH_OutP(
     UObject* WorldContextObject,
-    const USGSensorRange* SensorRange, ESGDeviceType ForDevice, bool bRightHanded, USGHandProfile*& OutProfile)
+    const USGSensorRange* SensorRange, const ESGDeviceType ForDevice, const bool bRightHanded,
+    USGHandProfile*& OutProfile)
 {
     return USGHapticGloveCalibrationSequence::CompileProfile(WorldContextObject,
                                                              SensorRange, ForDevice, bRightHanded, OutProfile);
@@ -143,22 +145,22 @@ bool USGHapticGloveCalibrationSequenceKismetLibrary::CompileRange(
     return HapticGloveCalibrationSequence->CompileRange(WorldContextObject, OutSensorRange);
 }
 
-bool USGHapticGloveCalibrationSequenceKismetLibrary::CompileProfile_ForDevice_bRightHanded_OutProfile(
+bool USGHapticGloveCalibrationSequenceKismetLibrary::CompileProfile_FD_bRH_OutP(
     UObject* WorldContextObject,
-    const USGHapticGloveCalibrationSequence* HapticGloveCalibrationSequence, ESGDeviceType ForDevice, bool bRightHanded,
+    const USGHapticGloveCalibrationSequence* HapticGloveCalibrationSequence,
-    USGHandProfile*& OutProfile)
+    const ESGDeviceType ForDevice, const bool bRightHanded, USGHandProfile*& OutProfile)
 {
     return HapticGloveCalibrationSequence->CompileProfile(WorldContextObject, ForDevice, bRightHanded, OutProfile);
 }
 
-bool USGHapticGloveCalibrationSequenceKismetLibrary::GetHandPose_OutCurrentHandPose(
+bool USGHapticGloveCalibrationSequenceKismetLibrary::GetHandPose_OutCHP(
     UObject* WorldContextObject,
     const USGHapticGloveCalibrationSequence* HapticGloveCalibrationSequence, USGHandPose*& OutCurrentHandPose)
 {
     return HapticGloveCalibrationSequence->GetHandPose(WorldContextObject, OutCurrentHandPose);
 }
 
-bool USGHapticGloveCalibrationSequenceKismetLibrary::GetHandPose_bRightHanded_OutCurrentHandPose(
+bool USGHapticGloveCalibrationSequenceKismetLibrary::GetHandPose_bRH_OutCHP(
     UObject* WorldContextObject,
     const USGHapticGloveCalibrationSequence* HapticGloveCalibrationSequence,
     const bool bRightHanded, USGHandPose*& OutCurrentHandPose)

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGHapticGloveCommandBufferKismetLibrary.cpp

@@ -76,7 +76,7 @@ TArray<USGTimedBuzzCommand*> USGHapticGloveCommandBufferKismetLibrary::GetBuzzCo
 }
 
 TArray<USGTimedThumpCommand*> USGHapticGloveCommandBufferKismetLibrary::GetThumperCommandsQueue(
-        UObject* WorldContextObject,
+    UObject* WorldContextObject,
     const USGHapticGloveCommandBuffer* HapticGloveCommandBuffer)
 {
     return HapticGloveCommandBuffer->GetThumperCommandsQueue(WorldContextObject);
@@ -155,8 +155,7 @@ USGThumperCommand* USGHapticGloveCommandBufferKismetLibrary::GetTotalThumperLeve
     return HapticGloveCommandBuffer->GetTotalThumperLevels(WorldContextObject);
 }
 
-void USGHapticGloveCommandBufferKismetLibrary::
+void USGHapticGloveCommandBufferKismetLibrary::FlushHaptics_LBL_OutFFC_OutBC_OutTC_bCFFQ(
-FlushHaptics_LastBrakeLevel_OutForceFeedbackCommand_OutBuzzCommand_OutThumperCommand_bClearForceFeedbackQueue(
     UObject* WorldContextObject,
     USGHapticGloveCommandBuffer* HapticGloveCommandBuffer,
     const USGForceFeedbackCommand* LastBrakeLevel,
@@ -166,13 +165,12 @@ FlushHaptics_LastBrakeLevel_OutForceFeedbackCommand_OutBuzzCommand_OutThumperCom
     const bool bClearForceFeedbackQueue)
 {
     HapticGloveCommandBuffer->FlushHaptics(WorldContextObject,
-                                          LastBrakeLevel,
+                                           LastBrakeLevel,
-                                          OutForceFeedbackCommand, OutBuzzCommand, OutThumperCommand,
+                                           OutForceFeedbackCommand, OutBuzzCommand, OutThumperCommand,
-                                          bClearForceFeedbackQueue);
+                                           bClearForceFeedbackQueue);
 }
 
-void USGHapticGloveCommandBufferKismetLibrary::
+void USGHapticGloveCommandBufferKismetLibrary::FlushHaptics_DS_LBL_OutFFC_OutBuzzCommand_OutTC(
-FlushHaptics_DeltaSeconds_LastBrakeLevel_OutForceFeedbackCommand_OutBuzzCommand_OutThumperCommand(
     UObject* WorldContextObject,
     USGHapticGloveCommandBuffer* HapticGloveCommandBuffer,
     const float DeltaSeconds,
@@ -182,6 +180,6 @@ FlushHaptics_DeltaSeconds_LastBrakeLevel_OutForceFeedbackCommand_OutBuzzCommand_
     USGThumperCommand*& OutThumperCommand)
 {
     HapticGloveCommandBuffer->FlushHaptics(WorldContextObject,
-                                          DeltaSeconds, LastBrakeLevel,
+                                           DeltaSeconds, LastBrakeLevel,
-                                          OutForceFeedbackCommand, OutBuzzCommand, OutThumperCommand);
+                                           OutForceFeedbackCommand, OutBuzzCommand, OutThumperCommand);
 }

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGHapticGloveHandProfilesKismetLibrary.cpp

@@ -79,12 +79,12 @@ void USGHapticGloveHandProfilesKismetLibrary::GetProfile(UObject* WorldContextOb
     FSGHapticGloveHandProfiles::GetProfile(WorldContextObject, bRightHanded, OutHandProfile);
 }
 
-void USGHapticGloveHandProfilesKismetLibrary::SetProfile_HandProfile(const USGHandProfile* HandProfile)
+void USGHapticGloveHandProfilesKismetLibrary::SetProfile_HP(const USGHandProfile* HandProfile)
 {
     FSGHapticGloveHandProfiles::SetProfile(HandProfile);
 }
 
-void USGHapticGloveHandProfilesKismetLibrary::SetProfile_HandProfile_bRightHanded(const USGHandProfile* HandProfile,
+void USGHapticGloveHandProfilesKismetLibrary::SetProfile_HP_bRH(const USGHandProfile* HandProfile,
     const bool bRightHanded)
 {
     FSGHapticGloveHandProfiles::SetProfile(HandProfile, bRightHanded);
@@ -95,7 +95,7 @@ void USGHapticGloveHandProfilesKismetLibrary::RestoreDefaults()
     FSGHapticGloveHandProfiles::RestoreDefaults();
 }
 
-void USGHapticGloveHandProfilesKismetLibrary::RestoreDefaults_bRightHanded(const bool bRightHanded)
+void USGHapticGloveHandProfilesKismetLibrary::RestoreDefaults_bRH(const bool bRightHanded)
 {
     FSGHapticGloveHandProfiles::RestoreDefaults(bRightHanded);
 }

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGHapticGloveKismetLibrary.cpp

@@ -48,13 +48,13 @@ TArray<USGHapticGlove*> USGHapticGloveKismetLibrary::GetHapticGloves(UObject* Wo
     return USGHapticGlove::GetHapticGloves(WorldContextObject);
 }
 
-bool USGHapticGloveKismetLibrary::GetGlove_OutGlove(UObject* WorldContextObject, USGHapticGlove*& OutGlove)
+bool USGHapticGloveKismetLibrary::GetGlove_OutG(UObject* WorldContextObject, USGHapticGlove*& OutGlove)
 {
     return USGHapticGlove::GetGlove(WorldContextObject, OutGlove);
 }
 
-bool USGHapticGloveKismetLibrary::GetGlove_bRightHanded_OutGlove(UObject* WorldContextObject,
+bool USGHapticGloveKismetLibrary::GetGlove_bRH_OutG(UObject* WorldContextObject,
-                                                                 const bool bRightHanded, USGHapticGlove*& OutGlove)
+                                                    const bool bRightHanded, USGHapticGlove*& OutGlove)
 {
     return USGHapticGlove::GetGlove(WorldContextObject, bRightHanded, OutGlove);
 }
@@ -89,38 +89,38 @@ bool USGHapticGloveKismetLibrary::IsRight(const USGHapticGlove* HapticGlove)
     return HapticGlove->IsRight();
 }
 
-bool USGHapticGloveKismetLibrary::GetImuRotation_FQuatOutImu(USGHapticGlove* HapticGlove, FQuat& OutImu)
+bool USGHapticGloveKismetLibrary::GetImuRotation_FQuat_OutI(USGHapticGlove* HapticGlove, FQuat& OutImu)
 {
     return HapticGlove->GetImuRotation(OutImu);
 }
 
-bool USGHapticGloveKismetLibrary::GetImuRotation_FRotatorOutImu(USGHapticGlove* HapticGlove, FRotator& OutImu)
+bool USGHapticGloveKismetLibrary::GetImuRotation_FRotator_OutI(USGHapticGlove* HapticGlove, FRotator& OutImu)
 {
     return HapticGlove->GetImuRotation(OutImu);
 }
 
-bool USGHapticGloveKismetLibrary::GetHandPose_HandGeometry_HandProfile_OutHandPose(
+bool USGHapticGloveKismetLibrary::GetHandPose_HG_HP_OutHP(
     UObject* WorldContextObject, USGHapticGlove* HapticGlove,
     const USGBasicHandModel* HandGeometry, const USGHandProfile* HandProfile, USGHandPose*& OutHandPose)
 {
     return HapticGlove->GetHandPose(WorldContextObject, HandGeometry, HandProfile, OutHandPose);
 }
 
-bool USGHapticGloveKismetLibrary::GetHandPose_HandProfile_OutHandPose(
+bool USGHapticGloveKismetLibrary::GetHandPose_HP_OutHP(
     UObject* WorldContextObject,
     USGHapticGlove* HapticGlove, const USGHandProfile* HandProfile, USGHandPose*& OutHandPose)
 {
     return HapticGlove->GetHandPose(WorldContextObject, HandProfile, OutHandPose);
 }
 
-bool USGHapticGloveKismetLibrary::GetHandPose_HandGeometry_OutHandPose(
+bool USGHapticGloveKismetLibrary::GetHandPose_HG_OutHP(
     UObject* WorldContextObject,
     USGHapticGlove* HapticGlove, const USGBasicHandModel* HandGeometry, USGHandPose*& OutHandPose)
 {
     return HapticGlove->GetHandPose(WorldContextObject, HandGeometry, OutHandPose);
 }
 
-bool USGHapticGloveKismetLibrary::GetHandPose_OutHandPose(
+bool USGHapticGloveKismetLibrary::GetHandPose_OutHP(
     UObject* WorldContextObject, USGHapticGlove* HapticGlove, USGHandPose*& OutHandPose)
 {
     return HapticGlove->GetHandPose(WorldContextObject, OutHandPose);
@@ -136,32 +136,32 @@ void USGHapticGloveKismetLibrary::StopVibrations(USGHapticGlove* HapticGlove)
     return HapticGlove->StopVibrations();
 }
 
-void USGHapticGloveKismetLibrary::SendHaptics_ForceFeedbackCommand(
+void USGHapticGloveKismetLibrary::SendHaptics_FFC(
     USGHapticGlove* HapticGlove, const USGForceFeedbackCommand* ForceFeedbackCommand)
 {
     return HapticGlove->SendHaptics(ForceFeedbackCommand);
 }
 
-void USGHapticGloveKismetLibrary::SendHaptics_BuzzCommand(
+void USGHapticGloveKismetLibrary::SendHaptics_BC(
     USGHapticGlove* HapticGlove, const USGBuzzCommand* BuzzCommand)
 {
     return HapticGlove->SendHaptics(BuzzCommand);
 }
 
-void USGHapticGloveKismetLibrary::SendHaptics_ThumperCommand(
+void USGHapticGloveKismetLibrary::SendHaptics_TC(
     USGHapticGlove* HapticGlove, const USGThumperCommand* ThumperCommand)
 {
     return HapticGlove->SendHaptics(ThumperCommand);
 }
 
-void USGHapticGloveKismetLibrary::SendHaptics_ForceFeedbackCommand_BuzzCommand(
+void USGHapticGloveKismetLibrary::SendHaptics_FFC_BC(
     USGHapticGlove* HapticGlove,
     const USGForceFeedbackCommand* ForceFeedbackCommand, const USGBuzzCommand* BuzzCommand)
 {
     return HapticGlove->SendHaptics(ForceFeedbackCommand, BuzzCommand);
 }
 
-void USGHapticGloveKismetLibrary::SendHaptics_ForceFeedbackCommand_BuzzCommand_ThumperCommand(
+void USGHapticGloveKismetLibrary::SendHaptics_FFC_BC_TC(
     USGHapticGlove* HapticGlove,
     const USGForceFeedbackCommand* ForceFeedbackCommand,
     const USGBuzzCommand* BuzzCommand,
@@ -185,7 +185,7 @@ void USGHapticGloveKismetLibrary::UpdateCalibrationRange(USGHapticGlove* HapticG
     HapticGlove->UpdateCalibrationRange();
 }
 
-void USGHapticGloveKismetLibrary::UpdateCalibrationRange_CalibrationValues(USGHapticGlove* HapticGlove,
+void USGHapticGloveKismetLibrary::UpdateCalibrationRange_CV(USGHapticGlove* HapticGlove,
                                                                            const TArray<FVector>& CalibrationValues)
 {
     HapticGlove->UpdateCalibrationRange(CalibrationValues);
@@ -210,8 +210,7 @@ void USGHapticGloveKismetLibrary::ApplyCalibration(
     HapticGlove->ApplyCalibration(WorldContextObject, OutProfile);
 }
 
-void USGHapticGloveKismetLibrary::
+void USGHapticGloveKismetLibrary::GetWristLocation_RP_FQuat_RR_TH_OutWP_Out_WR(
-GetWristLocation_ReferencePosition_ReferenceRotation_TrackingHardware_OutWristPosition_OutWristLocation(
     const USGHapticGlove* HapticGlove,
     const FVector& ReferencePosition, const FQuat& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware,
@@ -222,8 +221,7 @@ GetWristLocation_ReferencePosition_ReferenceRotation_TrackingHardware_OutWristPo
                                   OutWristPosition, OutWristRotation);
 }
 
-void USGHapticGloveKismetLibrary::
+void USGHapticGloveKismetLibrary::GetWristLocation_RP_FRotator_RR_TH_OutWP_OutWR(
-GetWristLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_OutWristPosition_FRotatorOutWristLocation(
     const USGHapticGlove* HapticGlove,
     const FVector& ReferencePosition, const FRotator& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware,
@@ -234,8 +232,7 @@ GetWristLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_Ou
                                   OutWristPosition, OutWristRotation);
 }
 
-void USGHapticGloveKismetLibrary::
+void USGHapticGloveKismetLibrary::GetGloveLocation_RP_FQuat_RR_TH_OutGP_OutGR(
-GetGloveLocation_ReferencePosition_ReferenceRotation_TrackingHardware_OutGlovePosition_OutGloveRotation(
     const USGHapticGlove* HapticGlove,
     const FVector& ReferencePosition, const FQuat& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware,
@@ -246,8 +243,7 @@ GetGloveLocation_ReferencePosition_ReferenceRotation_TrackingHardware_OutGlovePo
                                   OutGlovePosition, OutGloveRotation);
 }
 
-void USGHapticGloveKismetLibrary::
+void USGHapticGloveKismetLibrary::GetGloveLocation_RP_FRotator_RR_TH_OutGP_OutGR(
-GetGloveLocation_FRotatorReferencePosition_ReferenceRotation_TrackingHardware_OutGlovePosition_FRotatorOutGloveRotation(
     const USGHapticGlove* HapticGlove,
     const FVector& ReferencePosition, const FRotator& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware,

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGHapticGloveQuickCalibrationKismetLibrary.cpp

@@ -41,10 +41,8 @@ USGHapticGloveQuickCalibration* USGHapticGloveQuickCalibrationKismetLibrary::Mak
     return USGHapticGloveQuickCalibration::NewHapticGloveQuickCalibration(WorldContextObject);
 }
 
-USGHapticGloveQuickCalibration* USGHapticGloveQuickCalibrationKismetLibrary::
+USGHapticGloveQuickCalibration* USGHapticGloveQuickCalibrationKismetLibrary::MakeHapticGloveQuickCalibration_GTC_AET(
-MakeHapticGloveQuickCalibration_GloveToCalibrate_AutoEndTimeout(UObject* WorldContextObject,
+    UObject* WorldContextObject, const USGHapticGlove* GloveToCalibrate, const float AutoEndTimeout)
-                                                                const USGHapticGlove* GloveToCalibrate,
-                                                                const float AutoEndTimeout)
 {
     return USGHapticGloveQuickCalibration::NewHapticGloveQuickCalibration(
         WorldContextObject, GloveToCalibrate, AutoEndTimeout);

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGInterpolationSetKismetLibrary.cpp

@@ -42,13 +42,13 @@ USGInterpolationSet* USGInterpolationSetKismetLibrary::MakeInterpolationSet(UObj
     return USGInterpolationSet::NewInterpolationSet(WorldContextObject);
 }
 
-USGInterpolationSet* USGInterpolationSetKismetLibrary::MakeInterpolationSet_From1_From2_To1_To2(
+USGInterpolationSet* USGInterpolationSetKismetLibrary::MakeInterpolationSet_F1_F2_T1_T2(
     UObject* WorldContextObject, const float From1, const float From2, const float To1, const float To2)
 {
     return USGInterpolationSet::NewInterpolationSet(WorldContextObject, From1, From2, To1, To2);
 }
 
-USGInterpolationSet* USGInterpolationSetKismetLibrary::MakeInterpolationSet_From1_From2_To1_To2_Min_Max(
+USGInterpolationSet* USGInterpolationSetKismetLibrary::MakeInterpolationSet_F1_F2_T1_T2_M_M(
     UObject* WorldContextObject,
     const float From1, const float From2, const float To1, const float To2, const float Min, const float Max)
 {
@@ -137,8 +137,7 @@ FString USGInterpolationSetKismetLibrary::ToString(const USGInterpolationSet* In
     return InterpolationSet->ToString();
 }
 
-FString USGInterpolationSetKismetLibrary::ToString_bLimits(const USGInterpolationSet* InterpolationSet,
+FString USGInterpolationSetKismetLibrary::ToString_bL(const USGInterpolationSet* InterpolationSet, const bool bLimits)
-                                                           const bool bLimits)
 {
     return InterpolationSet->ToString(bLimits);
 }

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGJointKinematicsKismetLibrary.cpp

@@ -37,8 +37,7 @@
 
 #include "SGCore/SGJointKinematics.h"
 
-bool USGJointKinematicsKismetLibrary::
+bool USGJointKinematicsKismetLibrary::ForwardKinematics_SP_FQuat_SR_JL_JA_OutNP_TArrayFQuat_OutNR(
-ForwardKinematics_StartPosition_FQuatStartRotation_JointLengths_JointAngles_OutNewPositions_TArrayFQuatOutNewRotations(
     const FVector& StartPosition, const FQuat& StartRotation, const TArray<FVector>& JointLengths,
     const TArray<FVector>& JointAngles, TArray<FVector>& OutNewPositions, TArray<FQuat>& OutNewRotations)
 {
@@ -46,8 +45,7 @@ ForwardKinematics_StartPosition_FQuatStartRotation_JointLengths_JointAngles_OutN
                                                  OutNewPositions, OutNewRotations);
 }
 
-bool USGJointKinematicsKismetLibrary::
+bool USGJointKinematicsKismetLibrary::ForwardKinematics_SP_FRotator_SR_JL_JA_OutNP_TArrayFRotator_OutNR(
-ForwardKinematics_StartPosition_FRotatorStartRotation_JointLengths_JointAngles_OutNewPositions_TArrayFRotatorOutNewRotations(
     const FVector& StartPosition, const FRotator& StartRotation, const TArray<FVector>& JointLengths,
     const TArray<FVector>& JointAngles, TArray<FVector>& OutNewPositions, TArray<FRotator>& OutNewRotations)
 {
@@ -56,7 +54,7 @@ ForwardKinematics_StartPosition_FRotatorStartRotation_JointLengths_JointAngles_O
 }
 
 bool
-USGJointKinematicsKismetLibrary::ForwardKinematics_Profile_Finger_JointAngles_OutNewPositions_TArrayFQuatOutNewRotations(
+USGJointKinematicsKismetLibrary::ForwardKinematics_P_F_JA_OutNP_TArrayFQuat_OutNR(
     const USGBasicHandModel* Profile, const ESGFinger Finger, const TArray<FVector>& JointAngles,
     TArray<FVector>& OutNewPositions, TArray<FQuat>& OutNewRotations)
 {
@@ -64,7 +62,7 @@ USGJointKinematicsKismetLibrary::ForwardKinematics_Profile_Finger_JointAngles_Ou
 }
 
 bool
-USGJointKinematicsKismetLibrary::ForwardKinematics_Profile_Finger_JointAngles_OutNewPositions_TArrayFRotatorOutNewRotations(
+USGJointKinematicsKismetLibrary::ForwardKinematics_P_F_JA_OutNP_TArrayFRotator_OutNR(
     const USGBasicHandModel* Profile, const ESGFinger Finger, const TArray<FVector>& JointAngles,
     TArray<FVector>& OutNewPositions, TArray<FRotator>& OutNewRotations)
 {

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGNovaGloveHandProfileKismetLibrary.cpp

@@ -43,7 +43,7 @@ USGNovaGloveHandProfile* USGNovaGloveHandProfileKismetLibrary::MakeNovaGloveHand
     return USGNovaGloveHandProfile::NewNovaGloveHandProfile(WorldContextObject);
 }
 
-USGNovaGloveHandProfile* USGNovaGloveHandProfileKismetLibrary::MakeNovaGloveHandProfile_bRightHanded_Interpolator(
+USGNovaGloveHandProfile* USGNovaGloveHandProfileKismetLibrary::MakeNovaGloveHandProfile_bRH_I(
     UObject* WorldContextObject, const bool bRightHanded, const USGHandInterpolator* Interpolator)
 {
     return USGNovaGloveHandProfile::NewNovaGloveHandProfile(WorldContextObject, bRightHanded, Interpolator);

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGNovaGloveInfoKismetLibrary.cpp

@@ -42,8 +42,7 @@ USGNovaGloveInfo* USGNovaGloveInfoKismetLibrary::MakeNovaGloveInfo(UObject* Worl
     return USGNovaGloveInfo::NewNovaGloveInfo(WorldContextObject);
 }
 
-USGNovaGloveInfo* USGNovaGloveInfoKismetLibrary::
+USGNovaGloveInfo* USGNovaGloveInfoKismetLibrary::MakeNovaGloveInfo_DI_HV_FV_SFV_bRH_IC_NOS(
-MakeNovaGloveInfo_DeviceId_HardwareVersion_FirmwareVersion_SubFirmwareVersion_bRightHanded_ImuCorrection_NumberOfSensors(
     UObject* WorldContextObject,
     const FString& DeviceId,
     const FString& HardwareVersion, const int32 FirmwareVersion, const int32 SubFirmwareVersion,

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGNovaGloveKismetLibrary.cpp

@@ -71,18 +71,18 @@ TArray<USGNovaGlove*> USGNovaGloveKismetLibrary::GetNovaGloves(UObject* WorldCon
     return USGNovaGlove::GetNovaGloves(WorldContextObject);
 }
 
-bool USGNovaGloveKismetLibrary::GetNovaGlove_OutGlove(UObject* WorldContextObject, USGNovaGlove*& OutGlove)
+bool USGNovaGloveKismetLibrary::GetNovaGlove_OutG(UObject* WorldContextObject, USGNovaGlove*& OutGlove)
 {
     return USGNovaGlove::GetNovaGlove(WorldContextObject, OutGlove);
 }
 
-bool USGNovaGloveKismetLibrary::GetNovaGlove_bRightHanded_OutGlove(UObject* WorldContextObject,
+bool USGNovaGloveKismetLibrary::GetNovaGlove_bRH_OutG(UObject* WorldContextObject,
-                                                                   const bool bRightHanded, USGNovaGlove*& OutGlove)
+                                                      const bool bRightHanded, USGNovaGlove*& OutGlove)
 {
     return USGNovaGlove::GetNovaGlove(WorldContextObject, bRightHanded, OutGlove);
 }
 
-TArray<FVector> USGNovaGloveKismetLibrary::GetCalibrationValues_SensorData(const USGNovaGloveSensorData* SensorData)
+TArray<FVector> USGNovaGloveKismetLibrary::GetCalibrationValues_SD(const USGNovaGloveSensorData* SensorData)
 {
     return USGNovaGlove::GetCalibrationValues(SensorData);
 }
@@ -94,8 +94,7 @@ void USGNovaGloveKismetLibrary::CalibrateInterpolation(
     USGNovaGlove::CalibrateInterpolation(WorldContextObject, MinValues, MaxValues, OutProfile);
 }
 
-void USGNovaGloveKismetLibrary::
+void USGNovaGloveKismetLibrary::CalculateGloveLocation_RP_FQuat_RR_TH_bRH_OutGP_OutGR(
-CalculateGloveLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_bRightHanded_OutGlovePosition_FQuatOutGloveRotation(
     const FVector& ReferencePosition, const FQuat& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware, const bool bRightHanded,
     FVector& OutGlovePosition, FQuat& OutGloveRotation)
@@ -105,8 +104,7 @@ CalculateGloveLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware
                                          OutGlovePosition, OutGloveRotation);
 }
 
-void USGNovaGloveKismetLibrary::
+void USGNovaGloveKismetLibrary::CalculateGloveLocation_RP_FRotator_RR_TH_bRH_OutGP_OutGR(
-CalculateGloveLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_bRightHanded_OutGlovePosition_FRotatorOutGloveRotation(
     const FVector& ReferencePosition, const FRotator& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware, const bool bRightHanded,
     FVector& OutGlovePosition, FRotator& OutGloveRotation)
@@ -116,8 +114,7 @@ CalculateGloveLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardw
                                          OutGlovePosition, OutGloveRotation);
 }
 
-void USGNovaGloveKismetLibrary::
+void USGNovaGloveKismetLibrary::CalculateWristLocation_RP_FQuat_RR_TH_bRH_OutWP_OutWR(
-CalculateWristLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_bRightHanded_OutWristPosition_FQuatOutWristRotation(
     const FVector& ReferencePosition, const FQuat& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware, const bool bRightHanded,
     FVector& OutWristPosition, FQuat& OutWristRotation)
@@ -127,8 +124,7 @@ CalculateWristLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware
                                          OutWristPosition, OutWristRotation);
 }
 
-void
+void USGNovaGloveKismetLibrary::CalculateWristLocation_RP_FRotator_RR_TH_bRH_OutWP_OutWR(
-USGNovaGloveKismetLibrary::CalculateWristLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_bRightHanded_OutWristPosition_FRotatorOutWristRotation(
     const FVector& ReferencePosition, const FRotator& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware, const bool bRightHanded,
     FVector& OutWristPosition, FRotator& OutWristRotation)
@@ -138,17 +134,17 @@ USGNovaGloveKismetLibrary::CalculateWristLocation_ReferencePosition_FRotatorRefe
                                          OutWristPosition, OutWristRotation);
 }
 
-FString USGNovaGloveKismetLibrary::ToBytes_ThumperCommand(const USGThumperCommand* ThumperCommand)
+FString USGNovaGloveKismetLibrary::ToBytes_TC(const USGThumperCommand* ThumperCommand)
 {
     return USGNovaGlove::ToBytes(ThumperCommand);
 }
 
-FString USGNovaGloveKismetLibrary::ToBytes_ForceFeedbackCommand(const USGForceFeedbackCommand* ForceFeedbackCommand)
+FString USGNovaGloveKismetLibrary::ToBytes_FFC(const USGForceFeedbackCommand* ForceFeedbackCommand)
 {
     return USGNovaGlove::ToBytes(ForceFeedbackCommand);
 }
 
-FString USGNovaGloveKismetLibrary::ToBytes_BuzzCommand(const USGBuzzCommand* BuzzCommand)
+FString USGNovaGloveKismetLibrary::ToBytes_BC(const USGBuzzCommand* BuzzCommand)
 {
     return USGNovaGlove::ToBytes(BuzzCommand);
 }
@@ -199,84 +195,79 @@ bool USGNovaGloveKismetLibrary::GetSensorData(
     return NovaGlove->GetSensorData(WorldContextObject, OutSensorData);
 }
 
-bool USGNovaGloveKismetLibrary::GetImuRotation_FQuatOutImu(USGNovaGlove* NovaGlove, FQuat& OutImu)
+bool USGNovaGloveKismetLibrary::GetImuRotation_FQuat_OutI(USGNovaGlove* NovaGlove, FQuat& OutImu)
 {
     return NovaGlove->GetImuRotation(OutImu);
 }
 
-bool USGNovaGloveKismetLibrary::GetImuRotation_FRotatorOutImu(USGNovaGlove* NovaGlove, FRotator& OutImu)
+bool USGNovaGloveKismetLibrary::GetImuRotation_FRotator_OutI(USGNovaGlove* NovaGlove, FRotator& OutImu)
 {
     return NovaGlove->GetImuRotation(OutImu);
 }
 
-bool USGNovaGloveKismetLibrary::GetHandPose_HandModel_Profile_OutHandPose(
+bool USGNovaGloveKismetLibrary::GetHandPose_HM_P_OutHP(
     UObject* WorldContextObject, USGNovaGlove* NovaGlove,
     const USGBasicHandModel* HandModel, const USGNovaGloveHandProfile* Profile, USGHandPose*& OutHandPose)
 {
     return NovaGlove->GetHandPose(WorldContextObject, HandModel, Profile, OutHandPose);
 }
 
-bool USGNovaGloveKismetLibrary::GetHandPose_HandGeometry_HandProfile_OutHandPose(
+bool USGNovaGloveKismetLibrary::GetHandPose_HG_HP_OutHP(
     UObject* WorldContextObject, USGNovaGlove* NovaGlove,
     const USGBasicHandModel* HandGeometry, const USGHandProfile* HandProfile, USGHandPose*& OutHandPose)
 {
     return NovaGlove->GetHandPose(WorldContextObject, HandGeometry, HandProfile, OutHandPose);
 }
 
-bool USGNovaGloveKismetLibrary::GetHandPose_HandProfile_OutHandPose(
+bool USGNovaGloveKismetLibrary::GetHandPose_HP_OutHP(
     UObject* WorldContextObject, USGNovaGlove* NovaGlove,
     const USGHandProfile* HandProfile, USGHandPose*& OutHandPose)
 {
     return NovaGlove->GetHandPose(WorldContextObject, HandProfile, OutHandPose);
 }
 
-void USGNovaGloveKismetLibrary::SendHaptics_ForceFeedbackCommand(
+void USGNovaGloveKismetLibrary::SendHaptics_FFC(USGNovaGlove* NovaGlove,
-    USGNovaGlove* NovaGlove, const USGForceFeedbackCommand* ForceFeedbackCommand)
+                                                const USGForceFeedbackCommand* ForceFeedbackCommand)
 {
     NovaGlove->SendHaptics(ForceFeedbackCommand);
 }
 
-void USGNovaGloveKismetLibrary::SendHaptics_BuzzCommand(
+void USGNovaGloveKismetLibrary::SendHaptics_BC(USGNovaGlove* NovaGlove, const USGBuzzCommand* BuzzCommand)
-    USGNovaGlove* NovaGlove, const USGBuzzCommand* BuzzCommand)
 {
     NovaGlove->SendHaptics(BuzzCommand);
 }
 
-void USGNovaGloveKismetLibrary::SendHaptics_ThumperCommand(
+void USGNovaGloveKismetLibrary::SendHaptics_TC(USGNovaGlove* NovaGlove, const USGThumperCommand* ThumperCommand)
-    USGNovaGlove* NovaGlove, const USGThumperCommand* ThumperCommand)
 {
     NovaGlove->SendHaptics(ThumperCommand);
 }
 
-void USGNovaGloveKismetLibrary::SendHaptics_ForceFeedbackCommand_BuzzCommand_ThumperCommand(
+void USGNovaGloveKismetLibrary::SendHaptics_FFC_BC_TC(USGNovaGlove* NovaGlove,
-    USGNovaGlove* NovaGlove,
+                                                      const USGForceFeedbackCommand* ForceFeedbackCommand,
-    const USGForceFeedbackCommand* ForceFeedbackCommand,
+                                                      const USGBuzzCommand* BuzzCommand,
-    const USGBuzzCommand* BuzzCommand,
+                                                      const USGThumperCommand* ThumperCommand)
-    const USGThumperCommand* ThumperCommand)
 {
     NovaGlove->SendHaptics(ForceFeedbackCommand, BuzzCommand, ThumperCommand);
 }
 
-bool USGNovaGloveKismetLibrary::GetCalibrationValues_OutValues(USGNovaGlove* NovaGlove,
+bool USGNovaGloveKismetLibrary::GetCalibrationValues_OutV(USGNovaGlove* NovaGlove, TArray<FVector>& OutValues)
-                                                               TArray<FVector>& OutValues)
 {
     return NovaGlove->GetCalibrationValues(OutValues);
 }
 
-void USGNovaGloveKismetLibrary::ApplyCalibration_HandProfile(
+void USGNovaGloveKismetLibrary::ApplyCalibration_USGHandProfile_OutP(
     UObject* WorldContextObject, const USGNovaGlove* NovaGlove, USGHandProfile*& OutProfile)
 {
     return NovaGlove->ApplyCalibration(WorldContextObject, OutProfile);
 }
 
-void USGNovaGloveKismetLibrary::ApplyCalibration_NovaGloveHandProfile(
+void USGNovaGloveKismetLibrary::ApplyCalibration_USGNovaGloveHandProfile_OutP(
     UObject* WorldContextObject, const USGNovaGlove* NovaGlove, USGNovaGloveHandProfile*& OutProfile)
 {
     return NovaGlove->ApplyCalibration(WorldContextObject, OutProfile);
 }
 
-void USGNovaGloveKismetLibrary::
+void USGNovaGloveKismetLibrary::GetGloveLocation_RP_FQuat_RR_TH_OutGP_FQuat_OutGR(
-GetGloveLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_OutGlovePosition_FQuatOutGloveRotation(
     const USGNovaGlove* NovaGlove,
     const FVector& ReferencePosition, const FQuat& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware,
@@ -287,8 +278,7 @@ GetGloveLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_OutGl
                                        OutGlovePosition, OutGloveRotation);
 }
 
-void USGNovaGloveKismetLibrary::
+void USGNovaGloveKismetLibrary::GetGloveLocation_RP_FRotator_RR_TH_OutGP_FRotator_OutGR(
-GetGloveLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_OutGlovePosition_FRotatorOutGloveRotation(
     const USGNovaGlove* NovaGlove,
     const FVector& ReferencePosition, const FRotator& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware,
@@ -299,8 +289,7 @@ GetGloveLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_Ou
                                        OutGlovePosition, OutGloveRotation);
 }
 
-void USGNovaGloveKismetLibrary::
+void USGNovaGloveKismetLibrary::GetWristLocation_RP_FQuat_RR_TH_OutWP_FQuat_OutWR(
-GetWristLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_OutWristPosition_FQuatOutWristRotation(
     const USGNovaGlove* NovaGlove,
     const FVector& ReferencePosition, const FQuat& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware,
@@ -311,8 +300,7 @@ GetWristLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_OutWr
                                        OutWristPosition, OutWristRotation);
 }
 
-void USGNovaGloveKismetLibrary::
+void USGNovaGloveKismetLibrary::GetWristLocation_RP_FRotator_RR_TH_OutWP_FRotator_OutWR(
-GetWristLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_OutWristPosition_FRotatorOutWristRotation(
     const USGNovaGlove* NovaGlove,
     const FVector& ReferencePosition, const FRotator& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware,

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGNovaGloveSensorDataKismetLibrary.cpp

@@ -42,8 +42,7 @@ USGNovaGloveSensorData* USGNovaGloveSensorDataKismetLibrary::MakeNovaGloveSensor
     return USGNovaGloveSensorData::NewNovaGloveSensorData(WorldContextObject);
 }
 
-USGNovaGloveSensorData* USGNovaGloveSensorDataKismetLibrary::
+USGNovaGloveSensorData* USGNovaGloveSensorDataKismetLibrary::MakeNovaGloveSensorData_V_PV_FQuat_IR_bIP_BL_bC(
-MakeNovaGloveSensorData_Values_ParsedValues_FQuatImuRotation_bImuParsed_BatteryLevel_bCharging(
     UObject* WorldContextObject, const TArray<FVector>& Values, const int32 ParsedValues,
     const FQuat& ImuRotation, const bool bImuParsed, const float BatteryLevel, const bool bCharging)
 {
@@ -51,8 +50,7 @@ MakeNovaGloveSensorData_Values_ParsedValues_FQuatImuRotation_bImuParsed_BatteryL
         WorldContextObject, Values, ParsedValues, ImuRotation, bImuParsed, BatteryLevel, bCharging);
 }
 
-USGNovaGloveSensorData* USGNovaGloveSensorDataKismetLibrary::
+USGNovaGloveSensorData* USGNovaGloveSensorDataKismetLibrary::MakeNovaGloveSensorData_V_PV_FRotator_IR_bIP_BL_b(
-MakeNovaGloveSensorData_Values_ParsedValues_FRotatorImuRotation_bImuParsed_BatteryLevel_bCharging(
     UObject* WorldContextObject, const TArray<FVector>& Values, const int32 ParsedValues,
     const FRotator& ImuRotation, const bool bImuParsed, const float BatteryLevel, const bool bCharging)
 {

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGSenseComKismetLibrary.cpp

@@ -42,7 +42,7 @@ bool USGSenseComKismetLibrary::RegisterExe()
     return FSGSenseCom::RegisterExe();
 }
 
-bool USGSenseComKismetLibrary::RegisterExe_ExePath(const FString& ExePath)
+bool USGSenseComKismetLibrary::RegisterExe_EP(const FString& ExePath)
 {
     return FSGSenseCom::RegisterExe(ExePath);
 }

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGSenseGloveHandProfileKismetLibrary.cpp

@@ -42,8 +42,7 @@ USGSenseGloveHandProfile* USGSenseGloveHandProfileKismetLibrary::MakeSenseGloveH
     return USGSenseGloveHandProfile::NewSenseGloveHandProfile(WorldContextObject);
 }
 
-USGSenseGloveHandProfile*
+USGSenseGloveHandProfile* USGSenseGloveHandProfileKismetLibrary::MakeSenseGloveHandProfile_bRH_I_TS_FS_FTO(
-USGSenseGloveHandProfileKismetLibrary::MakeSenseGloveHandProfile_bRightHanded_Interpolator_ThumbSolver_FingerSolver_FingerThimbleOffset(
     UObject* WorldContextObject, const bool bRightHanded, const USGHandInterpolator* Interpolator,
     const ESGThumbSolver ThumbSolver, const ESGFingerSolver FingerSolver, const TArray<FVector>& FingerThimbleOffset)
 {

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGSenseGloveInfoKismetLibrary.cpp

@@ -44,7 +44,7 @@ USGSenseGloveInfo* USGSenseGloveInfoKismetLibrary::MakeSenseGloveInfo(UObject* W
 }
 
 USGSenseGloveInfo*
-USGSenseGloveInfoKismetLibrary::MakeSenseGloveInfo_DeviceId_HardwareVersion_FirmwareVersion_SubFirmwareVersion_bRightHanded_NumberOfSensors_FQuatImuCorrection_StartPositions_TArrayFQuatStartRotations_GloveLengths_Functions(
+USGSenseGloveInfoKismetLibrary::MakeSenseGloveInfo_DI_HV_FV_SFV_bRH_NOS_FQuat_IC_SP_TArrayFQuat_SR_GL_F(
     UObject* WorldContextObject, const FString& DeviceId,
     const FString& HardwareVersion, const int32 FirmwareVersion, const int32 SubFirmwareVersion,
     const bool bRightHanded, const int32 NumberOfSensors, const FQuat& ImuCorrection,
@@ -59,7 +59,7 @@ USGSenseGloveInfoKismetLibrary::MakeSenseGloveInfo_DeviceId_HardwareVersion_Firm
 }
 
 USGSenseGloveInfo*
-USGSenseGloveInfoKismetLibrary::MakeSenseGloveInfo_DeviceId_HardwareVersion_FirmwareVersion_SubFirmwareVersion_bRightHanded_NumberOfSensors_FRotatorImuCorrection_StartPositions_TArrayFRotatorStartRotations_GloveLengths_Functions(
+USGSenseGloveInfoKismetLibrary::MakeSenseGloveInfo_DI_HV_FV_SFV_bRH_NOS_FRotator_IC_SP_TArrayFRotator_SR_GL_F(
     UObject* WorldContextObject, const FString& DeviceId,
     const FString& HardwareVersion, const int32 FirmwareVersion, const int32 SubFirmwareVersion,
     const bool bRightHanded, const int32 NumberOfSensors, const FRotator& ImuCorrection,
@@ -170,8 +170,8 @@ FRotator USGSenseGloveInfoKismetLibrary::GetStartRotation_FRotator(const USGSens
     return SenseGloveInfo->GetStartRotation(Finger);
 }
 
-TArray<FVector> USGSenseGloveInfoKismetLibrary::GetGloveLengths_Finger(const USGSenseGloveInfo* SenseGloveInfo,
+TArray<FVector> USGSenseGloveInfoKismetLibrary::GetGloveLengths_F(const USGSenseGloveInfo* SenseGloveInfo,
-                                                                       const ESGFinger Finger)
+                                                                  const ESGFinger Finger)
 {
     return SenseGloveInfo->GetGloveLengths(Finger);
 }
@@ -200,8 +200,7 @@ FString USGSenseGloveInfoKismetLibrary::ToString(const USGSenseGloveInfo* SenseG
     return SenseGloveInfo->ToString();
 }
 
-FString USGSenseGloveInfoKismetLibrary::ToString_bShortNotation(const USGSenseGloveInfo* SenseGloveInfo,
+FString USGSenseGloveInfoKismetLibrary::ToString_bSN(const USGSenseGloveInfo* SenseGloveInfo, const bool bShortNotation)
-                                                                const bool bShortNotation)
 {
     return SenseGloveInfo->ToString(bShortNotation);
 }

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGSenseGloveKismetLibrary.cpp

@@ -50,14 +50,14 @@ FString USGSenseGloveKismetLibrary::GetThumperByte()
     return FString::Printf(TEXT("%c"), USGSenseGlove::GetThumperByte());
 }
 
-USGSenseGlovePose* USGSenseGloveKismetLibrary::CalculateGlovePose_SensorData_GloveModel(
+USGSenseGlovePose* USGSenseGloveKismetLibrary::CalculateGlovePose_SD_GM(
     UObject* WorldContextObject,
     const USGSenseGloveSensorData* SensorData, const USGSenseGloveInfo* GloveModel)
 {
     return USGSenseGlove::CalculateGlovePose(WorldContextObject, SensorData, GloveModel);
 }
 
-USGSenseGlovePose* USGSenseGloveKismetLibrary::CalculateGlovePose_GloveAngles_GloveModel(
+USGSenseGlovePose* USGSenseGloveKismetLibrary::CalculateGlovePose_GA_GM(
     UObject* WorldContextObject,
     const TArray<FSGVectorArray>& GloveAngles, const USGSenseGloveInfo* GloveModel)
 {
@@ -84,13 +84,13 @@ TArray<USGSenseGlove*> USGSenseGloveKismetLibrary::GetSenseGloves(UObject* World
     return USGSenseGlove::GetSenseGloves(WorldContextObject);
 }
 
-bool USGSenseGloveKismetLibrary::GetSenseGlove_OutGlove(UObject* WorldContextObject, USGSenseGlove*& OutGlove)
+bool USGSenseGloveKismetLibrary::GetSenseGlove_OutG(UObject* WorldContextObject, USGSenseGlove*& OutGlove)
 {
     return USGSenseGlove::GetSenseGlove(WorldContextObject, OutGlove);
 }
 
-bool USGSenseGloveKismetLibrary::GetSenseGlove_bRightHanded_OutGlove(UObject* WorldContextObject,
+bool USGSenseGloveKismetLibrary::GetSenseGlove_bRH_OutG(UObject* WorldContextObject,
-                                                                     const bool bRightHanded, USGSenseGlove*& OutGlove)
+                                                        const bool bRightHanded, USGSenseGlove*& OutGlove)
 {
     return USGSenseGlove::GetSenseGlove(WorldContextObject, bRightHanded, OutGlove);
 }
@@ -108,8 +108,7 @@ void USGSenseGloveKismetLibrary::CalibrateInterpolation(
     USGSenseGlove::CalibrateInterpolation(WorldContextObject, MinValues, MaxValues, bRightHanded, OutProfile);
 }
 
-void USGSenseGloveKismetLibrary::
+void USGSenseGloveKismetLibrary::CalculateGloveLocation_RP_FQuat_RR_TH_bRH_MO_OutGP_FQuat_OutGR(
-CalculateGloveLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_bRightHanded_MountedOn_OutGlovePosition_FQuatOutGloveRotation(
     const FVector& ReferencePosition, const FQuat& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware, const bool bRightHanded, const ESGFinger MountedOn,
     FVector& OutGlovePosition, FQuat& OutGloveRotation)
@@ -119,8 +118,7 @@ CalculateGloveLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware
                                           OutGlovePosition, OutGloveRotation);
 }
 
-void USGSenseGloveKismetLibrary::
+void USGSenseGloveKismetLibrary::CalculateGloveLocation_RP_FRotator_RR_TH_bRH_MO_OutGP_FRotator_OutGR(
-CalculateGloveLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_bRightHanded_MountedOn_OutGlovePosition_FRotatorOutGloveRotation(
     const FVector& ReferencePosition, const FRotator& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware, const bool bRightHanded, const ESGFinger MountedOn,
     FVector& OutGlovePosition, FRotator& OutGloveRotation)
@@ -130,8 +128,7 @@ CalculateGloveLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardw
                                           OutGlovePosition, OutGloveRotation);
 }
 
-void USGSenseGloveKismetLibrary::
+void USGSenseGloveKismetLibrary::CalculateWristLocation_RP_FQuat_RR_TH_bRH_MO_GWPOffset_FQuat_GWRO_OutWP_FQuat_OutWR(
-CalculateWristLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_bRightHanded_MountedOn_GloveWristPositionOffset_FQuatGloveWristRotationOffset_OutWristPosition_FQuatOutWristRotation(
     const FVector& ReferencePosition, const FQuat& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware, const bool bRightHanded, const ESGFinger MountedOn,
     const FVector& GloveWristPositionOffset, const FQuat& GloveWristRotationOffset,
@@ -143,8 +140,8 @@ CalculateWristLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware
                                           OutWristPosition, OutWristRotation);
 }
 
-void USGSenseGloveKismetLibrary::
+void
-CalculateWristLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_bRightHanded_MountedOn_GloveWristPositionOffset_FRotatorGloveWristRotationOffset_OutWristPosition_FRotatorOutWristRotation(
+USGSenseGloveKismetLibrary::CalculateWristLocation_RP_FRotator_RR_TH_bRH_MO_GWPOffset_FRotator_GWRO_OutWP_FRotator_OutWR(
     const FVector& ReferencePosition, const FRotator& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware, const bool bRightHanded, const ESGFinger MountedOn,
     const FVector& GloveWristPositionOffset, const FRotator& GloveWristRotationOffset,
@@ -198,73 +195,70 @@ bool USGSenseGloveKismetLibrary::GetSensorData(UObject* WorldContextObject, cons
     return SenseGlove->GetSensorData(WorldContextObject, OutSensorData);
 }
 
-bool USGSenseGloveKismetLibrary::GetImuRotation_FQuatOutImu(USGSenseGlove* SenseGlove, FQuat& OutImu)
+bool USGSenseGloveKismetLibrary::GetImuRotation_FQuat_OutI(USGSenseGlove* SenseGlove, FQuat& OutImu)
 {
     return SenseGlove->GetImuRotation(OutImu);
 }
 
-bool USGSenseGloveKismetLibrary::GetImuRotation_FRotatorOutImu(USGSenseGlove* SenseGlove, FRotator& OutImu)
+bool USGSenseGloveKismetLibrary::GetImuRotation_FRotator_OutI(USGSenseGlove* SenseGlove, FRotator& OutImu)
 {
     return SenseGlove->GetImuRotation(OutImu);
 }
 
-bool USGSenseGloveKismetLibrary::GetGlovePose_OutGlovePose(UObject* WorldContextObject, USGSenseGlove* SenseGlove,
+bool USGSenseGloveKismetLibrary::GetGlovePose_OutGP(UObject* WorldContextObject, USGSenseGlove* SenseGlove,
-                                                           USGSenseGlovePose*& OutGlovePose)
+                                                    USGSenseGlovePose*& OutGlovePose)
 {
     return SenseGlove->GetGlovePose(WorldContextObject, OutGlovePose);
 }
 
-bool USGSenseGloveKismetLibrary::GetGlovePose_SensorData_OutGlovePose(
+bool USGSenseGloveKismetLibrary::GetGlovePose_SD_OutGP(
     UObject* WorldContextObject, USGSenseGlove* SenseGlove,
     const USGSenseGloveSensorData* SensorData, USGSenseGlovePose*& OutGlovePose)
 {
     return SenseGlove->GetGlovePose(WorldContextObject, SensorData, OutGlovePose);
 }
 
-bool USGSenseGloveKismetLibrary::GetHandPose_HandModel_Profile_OutHandPose(
+bool USGSenseGloveKismetLibrary::GetHandPose_HM_P_OutHP(
     UObject* WorldContextObject, USGSenseGlove* SenseGlove,
     const USGBasicHandModel* HandModel, const USGSenseGloveHandProfile* Profile, USGHandPose*& OutHandPose)
 {
     return SenseGlove->GetHandPose(WorldContextObject, HandModel, Profile, OutHandPose);
 }
 
-bool USGSenseGloveKismetLibrary::GetHandPose_HandGeometry_HandProfile_OutHandPose(
+bool USGSenseGloveKismetLibrary::GetHandPose_HG_HP_OutHP(
     UObject* WorldContextObject, USGSenseGlove* SenseGlove,
     const USGBasicHandModel* HandGeometry, const USGHandProfile* HandProfile, USGHandPose*& OutHandPose)
 {
     return SenseGlove->GetHandPose(WorldContextObject, HandGeometry, HandProfile, OutHandPose);
 }
 
-bool USGSenseGloveKismetLibrary::GetHandPose_HandProfile_OutHandPose(
+bool USGSenseGloveKismetLibrary::GetHandPose_HP_OutHP(
     UObject* WorldContextObject, USGSenseGlove* SenseGlove,
     const USGHandProfile* HandProfile, USGHandPose*& OutHandPose)
 {
     return SenseGlove->GetHandPose(WorldContextObject, HandProfile, OutHandPose);
 }
 
-void USGSenseGloveKismetLibrary::SendHaptics_ForceFeedbackCommand(USGSenseGlove* SenseGlove,
+void USGSenseGloveKismetLibrary::SendHaptics_FFC(USGSenseGlove* SenseGlove,
-                                                                  const USGForceFeedbackCommand* ForceFeedbackCommand)
+                                                 const USGForceFeedbackCommand* ForceFeedbackCommand)
 {
     SenseGlove->SendHaptics(ForceFeedbackCommand);
 }
 
-void USGSenseGloveKismetLibrary::SendHaptics_BuzzCommand(USGSenseGlove* SenseGlove,
+void USGSenseGloveKismetLibrary::SendHaptics_BC(USGSenseGlove* SenseGlove,const USGBuzzCommand* BuzzCommand)
-                                                         const USGBuzzCommand* BuzzCommand)
 {
     SenseGlove->SendHaptics(BuzzCommand);
 }
 
-void USGSenseGloveKismetLibrary::SendHaptics_ForceFeedbackCommand_BuzzCommand_ThumperCommand(
+void USGSenseGloveKismetLibrary::SendHaptics_FFC_BC_TC(USGSenseGlove* SenseGlove,
-    USGSenseGlove* SenseGlove,
+                                                       const USGForceFeedbackCommand* ForceFeedbackCommand,
-    const USGForceFeedbackCommand* ForceFeedbackCommand,
+                                                       const USGBuzzCommand* BuzzCommand,
-    const USGBuzzCommand* BuzzCommand,
+                                                       const USGThumperCommand* ThumperCommand)
-    const USGThumperCommand* ThumperCommand)
 {
     SenseGlove->SendHaptics(ForceFeedbackCommand, BuzzCommand, ThumperCommand);
 }
 
-bool USGSenseGloveKismetLibrary::GetCalibrationValues_OutValues(USGSenseGlove* SenseGlove,
+bool USGSenseGloveKismetLibrary::GetCalibrationValues_OutV(USGSenseGlove* SenseGlove, TArray<FVector>& OutValues)
-                                                                TArray<FVector>& OutValues)
 {
     return SenseGlove->GetCalibrationValues(OutValues);
 }
@@ -274,20 +268,19 @@ void USGSenseGloveKismetLibrary::ResetCalibrationRange(USGSenseGlove* SenseGlove
     SenseGlove->ResetCalibrationRange();
 }
 
-void USGSenseGloveKismetLibrary::ApplyCalibration_HandProfile(
+void USGSenseGloveKismetLibrary::ApplyCalibration_USGHandProfile_OutP(
     UObject* WorldContextObject, const USGSenseGlove* SenseGlove, USGHandProfile*& OutProfile)
 {
     return SenseGlove->ApplyCalibration(WorldContextObject, OutProfile);
 }
 
-void USGSenseGloveKismetLibrary::ApplyCalibration_SenseGloveHandProfile(
+void USGSenseGloveKismetLibrary::ApplyCalibration_USGSenseGloveHandProfile_OutP(
     UObject* WorldContextObject, const USGSenseGlove* SenseGlove, USGSenseGloveHandProfile*& OutProfile)
 {
     return SenseGlove->ApplyCalibration(WorldContextObject, OutProfile);
 }
 
-void USGSenseGloveKismetLibrary::
+void USGSenseGloveKismetLibrary::GetGloveLocation_RP_FQuat_RR_TH_OutGP_FQuat_OutGR(
-GetGloveLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_OutGlovePosition_FQuatOutGloveRotation(
     const USGSenseGlove* SenseGlove,
     const FVector& ReferencePosition, const FQuat& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware,
@@ -298,8 +291,7 @@ GetGloveLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_OutGl
                                         OutGlovePosition, OutGloveRotation);
 }
 
-void USGSenseGloveKismetLibrary::
+void USGSenseGloveKismetLibrary::GetGloveLocation_RP_FRotator_RR_TH_OutGP_FRotator_OutGR(
-GetGloveLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_OutGlovePosition_FRotatorOutGloveRotation(
     const USGSenseGlove* SenseGlove,
     const FVector& ReferencePosition, const FRotator& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware,
@@ -310,8 +302,7 @@ GetGloveLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_Ou
                                         OutGlovePosition, OutGloveRotation);
 }
 
-void USGSenseGloveKismetLibrary::
+void USGSenseGloveKismetLibrary::GetGloveLocation_RP_FQuat_RR_TH_MO_OutGP_FQuat_OutGR(
-GetGloveLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_MountedOn_OutGlovePosition_FQuatOutGloveRotation(
     const USGSenseGlove* SenseGlove,
     const FVector& ReferencePosition, const FQuat& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware, const ESGFinger MountedOn,
@@ -322,8 +313,7 @@ GetGloveLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_Mount
                                         OutGlovePosition, OutGloveRotation);
 }
 
-void USGSenseGloveKismetLibrary::
+void USGSenseGloveKismetLibrary::GetGloveLocation_RP_FRotator_RR_TH_MO_OutGP_FRotator_OutGR(
-GetGloveLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_MountedOn_OutGlovePosition_FRotatorOutGloveRotation(
     const USGSenseGlove* SenseGlove,
     const FVector& ReferencePosition, const FRotator& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware, const ESGFinger MountedOn, FVector& OutGlovePosition,
@@ -334,8 +324,7 @@ GetGloveLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_Mo
                                         OutGlovePosition, OutGloveRotation);
 }
 
-void USGSenseGloveKismetLibrary::
+void USGSenseGloveKismetLibrary::GetWristLocation_RP_FQuat_RR_TH_OutWP_FQuat_OutWR(
-GetWristLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_OutWristPosition_FQuatOutWristRotation(
     const USGSenseGlove* SenseGlove,
     const FVector& ReferencePosition, const FQuat& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware,
@@ -346,8 +335,7 @@ GetWristLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_OutWr
                                         OutWristPosition, OutWristRotation);
 }
 
-void USGSenseGloveKismetLibrary::
+void USGSenseGloveKismetLibrary::GetWristLocation_RP_FRotator_RR_TH_OutWP_FRotator_OutWR(
-GetWristLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_OutWristPosition_FRotatorOutWristRotation(
     const USGSenseGlove* SenseGlove,
     const FVector& ReferencePosition, const FRotator& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware,
@@ -358,8 +346,7 @@ GetWristLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_Ou
                                         OutWristPosition, OutWristRotation);
 }
 
-void USGSenseGloveKismetLibrary::
+void USGSenseGloveKismetLibrary::GetWristLocation_RP_FQuat_RR_TH_GWPO_FQuat_GWRO_OutWP_FQuat_OutWR(
-GetWristLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_GloveWristPositionOffset_FQuatGloveWristRotationOffset_OutWristPosition_FQuatOutWristRotation(
     const USGSenseGlove* SenseGlove,
     const FVector& ReferencePosition, const FQuat& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware,
@@ -372,8 +359,7 @@ GetWristLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_Glove
                                         OutWristPosition, OutWristRotation);
 }
 
-void USGSenseGloveKismetLibrary::
+void USGSenseGloveKismetLibrary::GetWristLocation_RP_FRotator_RR_TH_GWPO_FRotator_GWRO_OutWP_FRotator_OutWR(
-GetWristLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_GloveWristPositionOffset_FRotatorGloveWristRotationOffset_OutWristPosition_FRotatorOutWristRotation(
     const USGSenseGlove* SenseGlove,
     const FVector& ReferencePosition, const FRotator& ReferenceRotation,
     const ESGPositionalTrackingHardware TrackingHardware,

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGSenseGlovePoseKismetLibrary.cpp

@@ -43,8 +43,7 @@ USGSenseGlovePose* USGSenseGlovePoseKismetLibrary::MakeSenseGlovePose(UObject* W
     return USGSenseGlovePose::NewSenseGlovePose(WorldContextObject);
 }
 
-USGSenseGlovePose*
+USGSenseGlovePose* USGSenseGlovePoseKismetLibrary::MakeSenseGlovePose_bRH_JP_TArrayFSGQuatArray_JR_GA(
-USGSenseGlovePoseKismetLibrary::MakeSenseGlovePose_bRightHanded_JointPositions_TArrayFSGQuatArrayJointRotations_GloveAngles(
     UObject* WorldContextObject, const bool bRightHanded,
     const TArray<FSGVectorArray>& JointPositions, const TArray<FSGQuatArray>& JointRotations,
     const TArray<FSGVectorArray>& GloveAngles)
@@ -53,8 +52,7 @@ USGSenseGlovePoseKismetLibrary::MakeSenseGlovePose_bRightHanded_JointPositions_T
                                                 JointPositions, JointRotations, GloveAngles);
 }
 
-USGSenseGlovePose*
+USGSenseGlovePose* USGSenseGlovePoseKismetLibrary::MakeSenseGlovePose_bRH_JP_TArrayFSGRotatorArray_JR_GA(
-USGSenseGlovePoseKismetLibrary::MakeSenseGlovePose_bRightHanded_JointPositions_TArrayFSGRotatorArrayJointRotations_GloveAngles(
     UObject* WorldContextObject, const bool bRightHanded,
     const TArray<FSGVectorArray>& JointPositions, const TArray<FSGRotatorArray>& JointRotations,
     const TArray<FSGVectorArray>& GloveAngles)

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGSenseGloveSensorDataKismetLibrary.cpp

@@ -42,18 +42,18 @@ USGSenseGloveSensorData* USGSenseGloveSensorDataKismetLibrary::MakeSenseGloveSen
     return USGSenseGloveSensorData::NewSenseGloveSensorData(WorldContextObject);
 }
 
-USGSenseGloveSensorData*
+USGSenseGloveSensorData* USGSenseGloveSensorDataKismetLibrary::MakeSenseGloveSensorData_SA_FQuatImuRotation_PV_bIP(
-USGSenseGloveSensorDataKismetLibrary::MakeSenseGloveSensorData_SensorAngles_FQuatImuRotation_ParsedValues_bImuParsed(
+    UObject* WorldContextObject,
-    UObject* WorldContextObject, const TArray<FSGFloatArray>& SensorAngles,
+    const TArray<FSGFloatArray>& SensorAngles,
     const FQuat& ImuRotation, const int32 ParsedValues, const bool bImuParsed)
 {
     return USGSenseGloveSensorData::NewSenseGloveSensorData(WorldContextObject, SensorAngles,
                                                             ImuRotation, ParsedValues, bImuParsed);
 }
 
-USGSenseGloveSensorData*
+USGSenseGloveSensorData* USGSenseGloveSensorDataKismetLibrary::MakeSenseGloveSensorData_SA_FRotatorImuRotation_PV_bIP(
-USGSenseGloveSensorDataKismetLibrary::MakeSenseGloveSensorData_SensorAngles_FRotatorImuRotation_ParsedValues_bImuParsed(
+    UObject* WorldContextObject,
-    UObject* WorldContextObject, const TArray<FSGFloatArray>& SensorAngles,
+    const TArray<FSGFloatArray>& SensorAngles,
     const FRotator& ImuRotation, const int32 ParsedValues, const bool bImuParsed)
 {
     return USGSenseGloveSensorData::NewSenseGloveSensorData(WorldContextObject, SensorAngles,
@@ -105,7 +105,7 @@ bool USGSenseGloveSensorDataKismetLibrary::IsImuParsed(const USGSenseGloveSensor
     return SenseGloveSensorData->IsImuParsed();
 }
 
-TArray<float> USGSenseGloveSensorDataKismetLibrary::GetSensorAngles_Finger(
+TArray<float> USGSenseGloveSensorDataKismetLibrary::GetSensorAngles_F(
     const USGSenseGloveSensorData* SenseGloveSensorData, const ESGFinger Finger)
 {
     return SenseGloveSensorData->GetSensorAngles(Finger);

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGSenseGloveVarsKismetLibrary.cpp

@@ -98,8 +98,7 @@ TArray<bool> USGSenseGloveVarsKismetLibrary::GetFunctions(const FString& Hardwar
     return FSGSenseGloveVars::GetFunctions(HardwareVersion, FirmwareVersion, SubFirmwareVersion);
 }
 
-USGSenseGloveInfo* USGSenseGloveVarsKismetLibrary::
+USGSenseGloveInfo* USGSenseGloveVarsKismetLibrary::GenerateGloveModel_HV_FV_SFV_bRH(
-GenerateGloveModel_HardwareVersion_FirmwareVersion_SubFirmwareVersion_bRightHanded(
     UObject* WorldContextObject,
     const FString& HardwareVersion, const int32 FirmwareVersion, const int32 SubFirmwareVersion,
     const bool bRightHanded)
@@ -108,8 +107,7 @@ GenerateGloveModel_HardwareVersion_FirmwareVersion_SubFirmwareVersion_bRightHand
                                                  HardwareVersion, FirmwareVersion, SubFirmwareVersion, bRightHanded);
 }
 
-USGSenseGloveInfo* USGSenseGloveVarsKismetLibrary::
+USGSenseGloveInfo* USGSenseGloveVarsKismetLibrary::GenerateGloveModel_HV_FV_SFV_bRH_CI(
-GenerateGloveModel_HardwareVersion_FirmwareVersion_SubFirmwareVersion_bRightHanded_CustomId(
     UObject* WorldContextObject,
     const FString& HardwareVersion, const int32 FirmwareVersion, const int32 SubFirmwareVersion,
     const bool bRightHanded, const FString& CustomId)

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGSensorRangeKismetLibrary.cpp

@@ -42,7 +42,7 @@ USGSensorRange* USGSensorRangeKismetLibrary::MakeSensorRange(UObject* WorldConte
     return USGSensorRange::NewSensorRange(WorldContextObject);
 }
 
-USGSensorRange* USGSensorRangeKismetLibrary::MakeSensorRange_MinValues_MaxValues(
+USGSensorRange* USGSensorRangeKismetLibrary::MakeSensorRange_MV_MV(
     UObject* WorldContextObject, const TArray<FVector>& MinValues, const TArray<FVector>& MaxValues)
 {
     return USGSensorRange::NewSensorRange(WorldContextObject, MinValues, MaxValues);

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGThumperCommandKismetLibrary.cpp

@@ -42,7 +42,7 @@ USGThumperCommand* USGThumperCommandKismetLibrary::MakeThumperCommand(UObject* W
     return USGThumperCommand::NewThumperCommand(WorldContextObject);
 }
 
-USGThumperCommand* USGThumperCommandKismetLibrary::MakeThumperCommand_Magnitude(
+USGThumperCommand* USGThumperCommandKismetLibrary::MakeThumperCommand_M(
     UObject* WorldContextObject, const int32 Magnitude)
 {
     return USGThumperCommand::NewThumperCommand(WorldContextObject, Magnitude);

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGTimedBuzzCommandKismetLibrary.cpp

@@ -42,8 +42,7 @@ USGTimedBuzzCommand* USGTimedBuzzCommandKismetLibrary::MakeTimedBuzzCommand(UObj
     return USGTimedBuzzCommand::NewTimedBuzzCommand(WorldContextObject);
 }
 
-USGTimedBuzzCommand* USGTimedBuzzCommandKismetLibrary::
+USGTimedBuzzCommand* USGTimedBuzzCommandKismetLibrary::MakeTimedBuzzCommand_F_M_DS_STS(
-MakeTimedBuzzCommand_Finger_Magnitude_DurationSeconds_StartTimeSeconds(
     UObject* WorldContextObject,
     const ESGFinger Finger, const int32 Magnitude, const float DurationSeconds, const float StartTimeSeconds)
 {
@@ -51,8 +50,7 @@ MakeTimedBuzzCommand_Finger_Magnitude_DurationSeconds_StartTimeSeconds(
                                                     Finger, Magnitude, DurationSeconds, StartTimeSeconds);
 }
 
-USGTimedBuzzCommand* USGTimedBuzzCommandKismetLibrary::
+USGTimedBuzzCommand* USGTimedBuzzCommandKismetLibrary::MakeTimedBuzzCommand_BC_DS_STS(
-MakeTimedBuzzCommand_BaseCommand_DurationSeconds_StartTimeSeconds(
     UObject* WorldContextObject,
     const USGBuzzCommand* BaseCommand, const float DurationSeconds, const float StartTimeSeconds)
 {

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGTimedThumpCommandKismetLibrary.cpp

@@ -43,14 +43,14 @@ USGTimedThumpCommand* USGTimedThumpCommandKismetLibrary::MakeTimedThumpCommand(U
 }
 
 USGTimedThumpCommand*
-USGTimedThumpCommandKismetLibrary::MakeTimedThumpCommand_Magnitude_DurationSeconds_StartTimeSeconds(
+USGTimedThumpCommandKismetLibrary::MakeTimedThumpCommand_M_DS_STS(
     UObject* WorldContextObject, const int32 Magnitude, const float DurationSeconds, const float StartTimeSeconds)
 {
     return USGTimedThumpCommand::NewTimedThumpCommand(WorldContextObject, Magnitude, DurationSeconds, StartTimeSeconds);
 }
 
 USGTimedThumpCommand*
-USGTimedThumpCommandKismetLibrary::MakeTimedThumpCommand_BaseCommand_DurationSeconds_StartTimeSeconds(
+USGTimedThumpCommandKismetLibrary::MakeTimedThumpCommand_BC_DS_STS(
     UObject* WorldContextObject,
     const USGThumperCommand* BaseCommand, const float DurationSeconds, const float StartTimeSeconds)
 {

Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGTrackingKismetLibrary.cpp

@@ -37,8 +37,7 @@
 
 #include "SGCore/SGTracking.h"
 
-void
+void USGTrackingKismetLibrary::CalculateLocation_TP_FQuat_TR_PO_FQuat_RO_OutNP_FQuat_OutNR(
-USGTrackingKismetLibrary::CalculateLocation_TrackedPosition_FQuatTrackedRotation_PositionOffset_FQuatRotationOffset_OutNewPosition_FQuatOutNewRotation(
     const FVector& TrackedPosition, const FQuat& TrackedRotation,
     const FVector& PositionOffset, const FQuat& RotationOffset,
     FVector& OutNewPosition, FQuat& OutNewRotation)
@@ -47,8 +46,7 @@ USGTrackingKismetLibrary::CalculateLocation_TrackedPosition_FQuatTrackedRotation
                                           OutNewPosition, OutNewRotation);
 }
 
-void
+void USGTrackingKismetLibrary::CalculateLocation_TP_FRotator_TR_PO_FRotator_RO_OutNP_FRotator_OutNR(
-USGTrackingKismetLibrary::CalculateLocation_TrackedPosition_FRotatorTrackedRotation_PositionOffset_FRotatorRotationOffset_OutNewPosition_FRotatorOutNewRotation(
     const FVector& TrackedPosition, const FRotator& TrackedRotation,
     const FVector& PositionOffset, const FRotator& RotationOffset,
     FVector& OutNewPosition, FRotator& OutNewRotation)
@@ -87,22 +85,21 @@ FRotator USGTrackingKismetLibrary::GetSenseGloveWristRotationOffset_FRotator()
     return FSGTracking::GetSenseGloveWristRotationOffset();
 }
 
-void USGTrackingKismetLibrary::GetSenseGloveMountOffset_bRightHanded_ToFinger_OutIPosition_FQuatOutIRotation(
+void USGTrackingKismetLibrary::GetSenseGloveMountOffset_bRH_TF_OutIP_FQuat_OutIR(
     const bool bRightHanded, const ESGFinger ToFinger,
     FVector& OutIPosition, FQuat& OutIRotation)
 {
     return FSGTracking::GetSenseGloveMountOffset(bRightHanded, ToFinger, OutIPosition, OutIRotation);
 }
 
-void USGTrackingKismetLibrary::GetSenseGloveMountOffset_bRightHanded_ToFinger_OutIPosition_FRotatorOutIRotation(
+void USGTrackingKismetLibrary::GetSenseGloveMountOffset_bRH_TF_OutIP_FRotator_OutIR(
     const bool bRightHanded, const ESGFinger ToFinger,
     FVector& OutIPosition, FRotator& OutIRotation)
 {
     return FSGTracking::GetSenseGloveMountOffset(bRightHanded, ToFinger, OutIPosition, OutIRotation);
 }
 
-void
+void USGTrackingKismetLibrary::GetSenseGloveTrackerMountOffset_H_bRH_OutPO_FQuat_OutRO(
-USGTrackingKismetLibrary::GetSenseGloveTrackerMountOffset_Hardware_bRightHanded_OutPositionOffset_FQuatOutRotationOffset(
     const ESGPositionalTrackingHardware Hardware, const bool bRightHanded,
     FVector& OutPositionOffset, FQuat& OutRotationOffset)
 {
@@ -110,8 +107,7 @@ USGTrackingKismetLibrary::GetSenseGloveTrackerMountOffset_Hardware_bRightHanded_
                                                         OutPositionOffset, OutRotationOffset);
 }
 
-void
+void USGTrackingKismetLibrary::GetSenseGloveTrackerMountOffset_H_bRH_OutPO_FRotator_OutRO(
-USGTrackingKismetLibrary::GetSenseGloveTrackerMountOffset_Hardware_bRightHanded_OutPositionOffset_FRotatorOutRotationOffset(
     const ESGPositionalTrackingHardware Hardware, const bool bRightHanded,
     FVector& OutPositionOffset, FRotator& OutRotationOffset)
 {
@@ -164,13 +160,13 @@ FRotator USGTrackingKismetLibrary::GetNovaToWristRotationOffset_FRotator()
     return FSGTracking::GetNovaToWristRotationOffset();
 }
 
-void USGTrackingKismetLibrary::GetNovaGloveWristOffset_bRightHanded_OutPositionOffset_FQuatOutRotationOffset(
+void USGTrackingKismetLibrary::GetNovaGloveWristOffset_bRH_OutPO_FQuat_OutRO(
     const bool bRightHanded, FVector& OutPositionOffset, FQuat& OutRotationOffset)
 {
     return FSGTracking::GetNovaGloveWristOffset(bRightHanded, OutPositionOffset, OutRotationOffset);
 }
 
-void USGTrackingKismetLibrary::GetNovaGloveWristOffset_bRightHanded_OutPositionOffset_FRotatorOutRotationOffset(
+void USGTrackingKismetLibrary::GetNovaGloveWristOffset_bRH_OutPO_FRotator_OutRO(
     const bool bRightHanded, FVector& OutPositionOffset, FRotator& OutRotationOffset)
 {
     return FSGTracking::GetNovaGloveWristOffset(bRightHanded, OutPositionOffset, OutRotationOffset);
@@ -261,7 +257,7 @@ FRotator USGTrackingKismetLibrary::GetLeftNovaPico2ToAttachRotation_FRotator()
     return FSGTracking::GetLeftNovaPico2ToAttachRotation();
 }
 
-void USGTrackingKismetLibrary::GetNovaGloveTrackerOffset_Hardware_bRightHanded_OutPositionOffset_FQuatOutRotationOffset(
+void USGTrackingKismetLibrary::GetNovaGloveTrackerOffset_H_bRH_OutPO_FQuat_OutRO(
     const ESGPositionalTrackingHardware Hardware, const bool bRightHanded,
     FVector& OutPositionOffset, FQuat& OutRotationOffset)
 {
@@ -269,7 +265,7 @@ void USGTrackingKismetLibrary::GetNovaGloveTrackerOffset_Hardware_bRightHanded_O
 }
 
 void
-USGTrackingKismetLibrary::GetNovaGloveTrackerOffset_Hardware_bRightHanded_OutPositionOffset_FRotatorOutRotationOffset(
+USGTrackingKismetLibrary::GetNovaGloveTrackerOffset_H_bRH_OutPO_FRotator_OutRO(
     const ESGPositionalTrackingHardware Hardware, const bool bRightHanded,
     FVector& OutPositionOffset, FRotator& OutRotationOffset)
 {

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGBasicHandModelKismetLibrary.h

@@ -56,14 +56,14 @@ public:
     UFUNCTION(BlueprintCallable, DisplayName="Make Basic Hand Model",
         Category="SenseGlove | Core | Kinematics | Basic Hand Model",
         meta=(WorldContext="WorldContextObject"))
-    static USGBasicHandModel* MakeBasicHandModel_bRightHanded_Lengths_StartPositions(
+    static USGBasicHandModel* MakeBasicHandModel_bRH_L_SP(
         UObject* WorldContextObject,
         bool bRightHanded, const TArray<FSGFloatArray>& Lengths, const TArray<FVector>& StartPositions);
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Basic Hand Model",
         Category="SenseGlove | Core | Kinematics | Basic Hand Model",
         meta=(WorldContext="WorldContextObject"))
-    static USGBasicHandModel* MakeBasicHandModel_bRightHanded_Lengths_StartPositions_TArrayFQuatStartRotations(
+    static USGBasicHandModel* MakeBasicHandModel_bRH_L_SP_TArrayFQuat_SR(
         UObject* WorldContextObject,
         bool bRightHanded, const TArray<FSGFloatArray>& Lengths,
         const TArray<FVector>& StartPositions, const TArray<FQuat>& StartRotations);
@@ -71,7 +71,7 @@ public:
     UFUNCTION(BlueprintCallable, DisplayName="Make Basic Hand Model",
         Category="SenseGlove | Core | Kinematics | Basic Hand Model",
         meta=(WorldContext="WorldContextObject"))
-    static USGBasicHandModel* MakeBasicHandModel_bRightHanded_Lengths_StartPositions_TArrayFRotatorStartRotations(
+    static USGBasicHandModel* MakeBasicHandModel_bRH_L_SP_TArrayFRotator_SR(
         UObject* WorldContextObject,
         bool bRightHanded, const TArray<FSGFloatArray>& Lengths,
         const TArray<FVector>& StartPositions, const TArray<FRotator>& StartRotations);
@@ -101,16 +101,16 @@ public:
 
     UFUNCTION(BlueprintPure, DisplayName="Get Finger Lengths",
         Category="SenseGlove | Core | Kinematics | Basic Hand Model")
-    static TArray<float> GetFingerLengths_ESGFinger(const USGBasicHandModel* BasicHandModel, ESGFinger Finger);
+    static TArray<float> GetFingerLengths_F(const USGBasicHandModel* BasicHandModel, ESGFinger Finger);
 
     UFUNCTION(BlueprintCallable, DisplayName="Set Finger Lengths",
         Category="SenseGlove | Core | Kinematics | Basic Hand Model")
-    static void SetFingerLengths_ESGFinger(UPARAM(ref) USGBasicHandModel* BasicHandModel, ESGFinger Finger,
+    static void SetFingerLengths_ESGFinger_F_L(UPARAM(ref) USGBasicHandModel* BasicHandModel, ESGFinger Finger,
                                            const TArray<float>& Lengths);
 
     UFUNCTION(BlueprintCallable, DisplayName="Set Finger Lengths",
         Category="SenseGlove | Core | Kinematics | Basic Hand Model")
-    static void SetFingerLengths_uint8Finger(UPARAM(ref) USGBasicHandModel* BasicHandModel, uint8 Finger,
+    static void SetFingerLengths_uint8_F_L(UPARAM(ref) USGBasicHandModel* BasicHandModel, uint8 Finger,
                                              const TArray<float>& Lengths);
 
     UFUNCTION(BlueprintPure, Category="SenseGlove | Core | Kinematics | Basic Hand Model")
@@ -118,19 +118,19 @@ public:
 
     UFUNCTION(BlueprintPure, DisplayName="Get Finger Ratios",
         Category="SenseGlove | Core | Kinematics | Basic Hand Model")
-    static TArray<float> GetFingerRatios_Finger(const USGBasicHandModel* BasicHandModel, ESGFinger Finger);
+    static TArray<float> GetFingerRatios_F(const USGBasicHandModel* BasicHandModel, ESGFinger Finger);
 
     UFUNCTION(BlueprintPure, Category="SenseGlove | Core | Kinematics | Basic Hand Model")
     static TArray<FVector> GetStartJointPositions(const USGBasicHandModel* BasicHandModel);
 
     UFUNCTION(BlueprintCallable, DisplayName="Set Start Joint Position",
         Category="SenseGlove | Core | Kinematics | Basic Hand Model")
-    static void SetStartJointPosition_ESGFinger(UPARAM(ref) USGBasicHandModel* BasicHandModel, ESGFinger Finger,
+    static void SetStartJointPosition_ESGFinger_F_P(UPARAM(ref) USGBasicHandModel* BasicHandModel, ESGFinger Finger,
                                                 const FVector& Position);
 
     UFUNCTION(BlueprintPure, DisplayName="Set Start Joint Position",
         Category="SenseGlove | Core | Kinematics | Basic Hand Model")
-    static void SetStartJointPosition_uint8Finger(UPARAM(ref) USGBasicHandModel* BasicHandModel, uint8 Finger,
+    static void SetStartJointPosition_uint8_F_P(UPARAM(ref) USGBasicHandModel* BasicHandModel, uint8 Finger,
                                                   const FVector& Position);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Start Joint Rotations",
@@ -158,12 +158,12 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Set Joint Rotation",
         Category="SenseGlove | Core | Kinematics | Basic Hand Model")
-    static void SetJointRotation_FQuatNewRotation_Finger(
+    static void SetJointRotation_FQuat_NR_F(
         UPARAM(ref) USGBasicHandModel* BasicHandModel, const FQuat& NewRotation, ESGFinger Finger);
 
     UFUNCTION(BlueprintCallable, DisplayName="Set Joint Rotation",
         Category="SenseGlove | Core | Kinematics | Basic Hand Model")
-    static void SetJointRotation_FRotatorNewRotation_Finger(
+    static void SetJointRotation_FRotator_NR_F(
         UPARAM(ref) USGBasicHandModel* BasicHandModel, const FRotator& NewRotation, ESGFinger Finger);
 
     UFUNCTION(BlueprintPure, Category="SenseGlove | Core | Kinematics | Basic Hand Model")
@@ -182,7 +182,7 @@ public:
     static FString ToString(const USGBasicHandModel* BasicHandModel);
 
     UFUNCTION(BlueprintPure, DisplayName="To String", Category="SenseGlove | Core | Kinematics | Basic Hand Model")
-    static FString ToString_bLengthsOnly(const USGBasicHandModel* BasicHandModel, bool bLengthsOnly);
+    static FString ToString_bLO(const USGBasicHandModel* BasicHandModel, bool bLengthsOnly);
 
     UFUNCTION(BlueprintPure, DisplayName="Serialize", Category="SenseGlove | Core | Kinematics | Basic Hand Model")
     static FString SGSerialize(const USGBasicHandModel* BasicHandModel);

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGBuzzCommandKismetLibrary.h

@@ -54,18 +54,16 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Buzz Command", Category="SenseGlove | Core | Haptics | Buzz Command",
         meta=(WorldContext="WorldContextObject"))
-    static USGBuzzCommand* MakeBuzzCommand_BuzzLevels(UObject* WorldContextObject, const TArray<int32>& BuzzLevels);
+    static USGBuzzCommand* MakeBuzzCommand_BL(UObject* WorldContextObject, const TArray<int32>& BuzzLevels);
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Buzz Command", Category="SenseGlove | Core | Haptics | Buzz Command",
         meta=(WorldContext="WorldContextObject"))
-    static USGBuzzCommand* MakeBuzzCommand_Thumb_Index_Middle_Ring_Pinky(UObject* WorldContextObject,
+    static USGBuzzCommand* MakeBuzzCommand_T_I_M_R_P(UObject* WorldContextObject,
-                                                                         int32 Thumb, int32 Index, int32 Middle,
+                                                     int32 Thumb, int32 Index, int32 Middle, int32 Ring, int32 Pinky);
-                                                                         int32 Ring, int32 Pinky);
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Buzz Command", Category="SenseGlove | Core | Haptics | Buzz Command",
         meta=(WorldContext="WorldContextObject"))
-    static USGBuzzCommand* MakeBuzzCommand_Finger_BuzzLevel(UObject* WorldContextObject, ESGFinger Finger,
+    static USGBuzzCommand* MakeBuzzCommand_F_BL(UObject* WorldContextObject, ESGFinger Finger, int32 BuzzLevel);
-                                                            int32 BuzzLevel);
 
     UFUNCTION(BlueprintCallable, Category="SenseGlove | Core | Haptics | Buzz Command",
         meta=(WorldContext="WorldContextObject"))

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGCalibrationDataPointKismetLibrary.h

@@ -53,7 +53,7 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Calibration Data Point",
         Category="SenseGlove | Core | Calibration | Calibraion Data Point", meta=(WorldContext="WorldContextObject"))
-    static USGCalibrationDataPoint* MakeCalibrationDataPoint_CurrentStage_CalibrationValues(
+    static USGCalibrationDataPoint* MakeCalibrationDataPoint_CS_CV(
         UObject* WorldContextObject,
         int32 CurrentStage, const TArray<FVector>& CalibrationValues);
 

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGDeviceKismetLibrary.h

@@ -52,7 +52,7 @@ public:
     static void ParseFirmware(const FString& RawFirmware, int32& OutMainVersion, int32& OutSubVersion);
 
     UFUNCTION(BlueprintCallable, DisplayName="To String", Category="SenseGlove | Core | SGDevice")
-    static FString ToString_DeviceType(ESGDeviceType DeviceType);
+    static FString ToString_DT(ESGDeviceType DeviceType);
 
     UFUNCTION(BlueprintPure, Category="SenseGlove | Core | SGDevice")
     static ESGDeviceType GetDeviceType(const USGDevice* SGDevice);
@@ -99,6 +99,6 @@ public:
     UFUNCTION(BlueprintCallable, Category="SenseGlove | Core | SGDevice")
     static bool GetBatteryLevel(UPARAM(ref) USGDevice* SGDevice, float& OutLevel);
 
-    UFUNCTION(BlueprintPure, DisplayName="To String", Category="SenseGlove | Core | SGDevice")
+    UFUNCTION(BlueprintPure, Category="SenseGlove | Core | SGDevice")
-    static FString ToString_SGDevice(const USGDevice* SGDevice);
+    static FString ToString(const USGDevice* SGDevice);
 };

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGDeviceListKismetLibrary.h

@@ -69,12 +69,12 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Devices", Category="SenseGlove | Core | Device List",
         meta=(WorldContext="WorldContextObject"))
-    static TArray<USGDevice*> GetDevices_TSubclassOf_USGDevice(UObject* WorldContextObject,
+    static TArray<USGDevice*> GetDevices_TSubclassOfUSGDevice_DT(UObject* WorldContextObject,
-                                                               const TSubclassOf<USGDevice>& DeviceType);
+                                                                 const TSubclassOf<USGDevice>& DeviceType);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Devices", Category="SenseGlove | Core | Device List",
         meta=(WorldContext="WorldContextObject"))
-    static TArray<USGDevice*> GetDevices_ESGDeviceType(UObject* WorldContextObject, ESGDeviceType DeviceType);
+    static TArray<USGDevice*> GetDevices_ESGDeviceType_DT(UObject* WorldContextObject, ESGDeviceType DeviceType);
 
     UFUNCTION(BlueprintCallable, Category="SenseGlove | Core | Device List")
     static bool GetSensorDataString(int32 IpcIndex, const FString& IpcAddress, FString& OutString);

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGDeviceModelKismetLibrary.h

@@ -56,7 +56,7 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Device Model", Category="SenseGlove | Core | Device Model",
         meta=(WorldContext="WorldContextObject"))
-    static USGDeviceModel* MakeDeviceModel_Id_HardwareVersion_FirmwareVersion_SubFirmwareVersion(
+    static USGDeviceModel* MakeDeviceModel_I_HV_FV_SFV(
         UObject* WorldContextObject,
         const FString& Id, const FString& HardwareVersion, int32 FirmwareVersion, int32 SubFirmwareVersion);
 

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGForceFeedbackCommandKismetLibrary.h

@@ -55,19 +55,19 @@ public:
     UFUNCTION(BlueprintCallable, DisplayName="Make Force Feedback Command",
         Category="SenseGlove | Core | Haptics | Force Feedback Command",
         meta=(WorldContext="WorldContextObject"))
-    static USGForceFeedbackCommand* MakeForceFeedbackCommand_ForceFeedbackLevels(
+    static USGForceFeedbackCommand* MakeForceFeedbackCommand_FFL(
         UObject* WorldContextObject, const TArray<int32>& ForceFeedbackLevels);
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Force Feedback Command",
         Category="SenseGlove | Core | Haptics | Force Feedback Command",
         meta=(WorldContext="WorldContextObject"))
-    static USGForceFeedbackCommand* MakeForceFeedbackCommand_Thumb_Index_Middle_Ring_Pinky(
+    static USGForceFeedbackCommand* MakeForceFeedbackCommand_T_I_M_R_P(
         UObject* WorldContextObject, int32 Thumb, int32 Index, int32 Middle, int32 Ring, int32 Pinky);
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Force Feedback Command",
         Category="SenseGlove | Core | Haptics | Force Feedback Command",
         meta=(WorldContext="WorldContextObject"))
-    static USGForceFeedbackCommand* MakeForceFeedbackCommand_Finger_BuzzLevel(
+    static USGForceFeedbackCommand* MakeForceFeedbackCommand_F_BL(
         UObject* WorldContextObject, ESGFinger Finger, int32 BuzzLevel);
 
     UFUNCTION(BlueprintCallable, Category="SenseGlove | Core | Haptics | Force Feedback Command",

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGHandInterpolatorKismetLibrary.h

@@ -56,19 +56,19 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Hand Interpolator",
         Category="SenseGlove | Core | Kinematics | Hand Interpolator", meta=(WorldContext="WorldContextObject"))
-    static USGHandInterpolator* MakeHandInterpolator_JointInterpolations(
+    static USGHandInterpolator* MakeHandInterpolator_JI(
         UObject* WorldContextObject,
         const TArray<FSGInterpolationSetArray>& JointInterpolations);
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Hand Interpolator",
         Category="SenseGlove | Core | Kinematics | Hand Interpolator", meta=(WorldContext="WorldContextObject"))
-    static USGHandInterpolator* MakeHandInterpolator_JointInterpolations_FQuatCmcStartRotation(
+    static USGHandInterpolator* MakeHandInterpolator_JI_FQuat_CSR(
         UObject* WorldContextObject,
         const TArray<FSGInterpolationSetArray>& JointInterpolations, const FQuat& CmcStartRotation);
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Hand Interpolator",
         Category="SenseGlove | Core | Kinematics | Hand Interpolator", meta=(WorldContext="WorldContextObject"))
-    static USGHandInterpolator* MakeHandInterpolator_JointInterpolations_FRotatorCmcStartRotation(
+    static USGHandInterpolator* MakeHandInterpolator_JI_FRotator_CSR(
         UObject* WorldContextObject,
         const TArray<FSGInterpolationSetArray>& JointInterpolations, const FRotator& CmcStartRotation);
 
@@ -107,35 +107,34 @@ public:
 
     UFUNCTION(BlueprintPure, DisplayName="CalculateAngle",
         Category="SenseGlove | Core | Kinematics | Hand Interpolator")
-    static float CalculateAngle_Finger_int32Movement_Value(const USGHandInterpolator* HandInterpolator,
+    static float CalculateAngle_F_int32_M_V(const USGHandInterpolator* HandInterpolator,
-                                                           ESGFinger Finger, int32 Movement, float Value);
+                                            ESGFinger Finger, int32 Movement, float Value);
 
     UFUNCTION(BlueprintPure, DisplayName="CalculateAngle",
         Category="SenseGlove | Core | Kinematics | Hand Interpolator")
-    static float CalculateAngle_Finger_ESGFingerMovement_Value(const USGHandInterpolator* HandInterpolator,
+    static float CalculateAngle_F_ESGFingerMovement_M_V(const USGHandInterpolator* HandInterpolator,
-                                                               ESGFinger Finger, ESGFingerMovement Movement,
+                                                        ESGFinger Finger, ESGFingerMovement Movement, float Value);
-                                                               float Value);
 
     UFUNCTION(BlueprintPure, DisplayName="CalculateAngle",
         Category="SenseGlove | Core | Kinematics | Hand Interpolator")
-    static float CalculateAngle_Finger_ESGThumbMovement_Value(
+    static float CalculateAngle_F_ESGThumbMovement_M_V(const USGHandInterpolator* HandInterpolator,
-        const USGHandInterpolator* HandInterpolator, ESGFinger Finger, ESGThumbMovement Movement, float Value);
+                                                       ESGFinger Finger, ESGThumbMovement Movement, float Value);
 
     UFUNCTION(BlueprintCallable, DisplayName="SetInterpolation",
         Category="SenseGlove | Core | Kinematics | Hand Interpolator")
-    static void SetInterpolation_int32Finger_int32Movement_InputAt0_InputAt1_AngleAt0_AngleAt1(
+    static void SetInterpolation_int32_F_int32_M_IA0_IA1_AA0_AA1(
         UPARAM(ref) USGHandInterpolator* HandInterpolator, int32 Finger, int32 Movement,
         float InputAt0, float InputAt1, float AngleAt0, float AngleAt1);
 
     UFUNCTION(BlueprintCallable, DisplayName="SetInterpolation",
         Category="SenseGlove | Core | Kinematics | Hand Interpolator")
-    static void SetInterpolation_ESGFinger_ESGFingerMovement_InputAt0_InputAt1_AngleAt0_AngleAt1(
+    static void SetInterpolation_ESGFinger_F_ESGFingerMovement_M_IA0_IA1_AA0_AA1(
         UPARAM(ref) USGHandInterpolator* HandInterpolator, ESGFinger Finger, ESGFingerMovement Movement,
         float InputAt0, float InputAt1, float AngleAt0, float AngleAt1);
 
     UFUNCTION(BlueprintCallable, DisplayName="SetInterpolation",
         Category="SenseGlove | Core | Kinematics | Hand Interpolator")
-    static void SetInterpolation_Movement_InputAt0_InputAt1_AngleAt0_AngleAt1(
+    static void SetInterpolation_M_IA0_IA1_AA0_AA1(
         UPARAM(ref) USGHandInterpolator* HandInterpolator, ESGThumbMovement Movement,
         float InputAt0, float InputAt1, float AngleAt0, float AngleAt1);
 

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGHandPoseKismetLibrary.h

@@ -57,72 +57,67 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Hand Pose", Category="SenseGlove | Core | Hand Pose",
         meta=(WorldContext="WorldContextObject"))
-    static USGHandPose* MakeHandPose_bRightHanded_JointPositions_FSGQuatArrayJointRotations_HandAngles(
+    static USGHandPose* MakeHandPose_bRH_JP_FSGQuatArray_JR_HA(
         UObject* WorldContextObject,
         bool bRightHanded, const TArray<FSGVectorArray>& JointPositions, const TArray<FSGQuatArray>& JointRotations,
         const TArray<FSGVectorArray>& HandAngles);
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Hand Pose", Category="SenseGlove | Core | Hand Pose",
         meta=(WorldContext="WorldContextObject"))
-    static USGHandPose* MakeHandPose_bRightHanded_JointPositions_FSGRotatorArrayJointRotations_HandAngles(
+    static USGHandPose* MakeHandPose_bRH_JP_FSGRotatorArray_JR_HA(
         UObject* WorldContextObject,
         bool bRightHanded, const TArray<FSGVectorArray>& JointPositions, const TArray<FSGRotatorArray>& JointRotations,
         const TArray<FSGVectorArray>& HandAngles);
 
-    UFUNCTION(BlueprintCallable, Category="SenseGlove | Core | Hand Pose",
+    UFUNCTION(BlueprintCallable, Category="SenseGlove | Core | Hand Pose", meta=(WorldContext="WorldContextObject"))
-        meta=(WorldContext="WorldContextObject"))
     static USGHandPose* Deserialize(UObject* WorldContextObject, const FString& SerializedString);
 
     UFUNCTION(BlueprintCallable, DisplayName="From Hand Angles", Category="SenseGlove | Core | Hand Pose",
         meta=(WorldContext="WorldContextObject"))
-    static USGHandPose* FromHandAngles_HandAngles_bRightHanded_HandDimensions(
+    static USGHandPose* FromHandAngles_HA_bRH_HD(
         UObject* WorldContextObject,
         const TArray<FSGVectorArray>& HandAngles, bool bRightHanded, const USGBasicHandModel* HandDimensions);
 
     UFUNCTION(BlueprintCallable, DisplayName="From Hand Angles", Category="SenseGlove | Core | Hand Pose",
         meta=(WorldContext="WorldContextObject"))
-    static USGHandPose* FromHandAngles_HandAngles_bRightHanded(
+    static USGHandPose* FromHandAngles_HA_bRH(UObject* WorldContextObject,
-        UObject* WorldContextObject,
+                                              const TArray<FSGVectorArray>& HandAngles, bool bRightHanded);
-        const TArray<FSGVectorArray>& HandAngles, bool bRightHanded);
 
     UFUNCTION(BlueprintCallable, DisplayName="Default Idle", Category="SenseGlove | Core | Hand Pose",
         meta=(WorldContext="WorldContextObject"))
-    static USGHandPose* DefaultIdle_bRightHanded_HandDimensions(
+    static USGHandPose* DefaultIdle_bRH_HD(UObject* WorldContextObject,
-        UObject* WorldContextObject,
+                                           bool bRightHanded, const USGBasicHandModel* HandDimensions);
-        bool bRightHanded, const USGBasicHandModel* HandDimensions);
 
     UFUNCTION(BlueprintCallable, DisplayName="Default Idle", Category="SenseGlove | Core | Hand Pose",
         meta=(WorldContext="WorldContextObject"))
-    static USGHandPose* DefaultIdle_bRightHanded(UObject* WorldContextObject, bool bRightHanded);
+    static USGHandPose* DefaultIdle_bRH(UObject* WorldContextObject, bool bRightHanded);
 
     UFUNCTION(BlueprintCallable, DisplayName="Flat Hand", Category="SenseGlove | Core | Hand Pose",
         meta=(WorldContext="WorldContextObject"))
-    static USGHandPose*
+    static USGHandPose* FlatHand_bRH_HD(UObject* WorldContextObject,
-    FlatHand_bRightHanded_HandDimensions(UObject* WorldContextObject,
+                                        bool bRightHanded, const USGBasicHandModel* HandDimensions);
-                                         bool bRightHanded, const USGBasicHandModel* HandDimensions);
 
     UFUNCTION(BlueprintCallable, DisplayName="Flat Hand", Category="SenseGlove | Core | Hand Pose",
         meta=(WorldContext="WorldContextObject"))
-    static USGHandPose* FlatHand_bRightHanded(UObject* WorldContextObject, bool bRightHanded);
+    static USGHandPose* FlatHand_bRH(UObject* WorldContextObject, bool bRightHanded);
 
     UFUNCTION(BlueprintCallable, DisplayName="Thumbs Up", Category="SenseGlove | Core | Hand Pose",
         meta=(WorldContext="WorldContextObject"))
-    static USGHandPose*
+    static USGHandPose* ThumbsUp_bRH_HD(UObject* WorldContextObject, bool bRightHanded,
-    ThumbsUp_bRightHanded_HandDimensions(UObject* WorldContextObject, bool bRightHanded,
+                                        const USGBasicHandModel* HandDimensions);
-                                         const USGBasicHandModel* HandDimensions);
 
     UFUNCTION(BlueprintCallable, DisplayName="Thumbs Up", Category="SenseGlove | Core | Hand Pose",
         meta=(WorldContext="WorldContextObject"))
-    static USGHandPose* ThumbsUp_bRightHanded(UObject* WorldContextObject, bool bRightHanded);
+    static USGHandPose* ThumbsUp_bRH(UObject* WorldContextObject, bool bRightHanded);
 
     UFUNCTION(BlueprintCallable, DisplayName="Fist", Category="SenseGlove | Core | Hand Pose",
         meta=(WorldContext="WorldContextObject"))
-    static USGHandPose* Fist_bRightHanded_HandDimensions(UObject* WorldContextObject,
+    static USGHandPose* Fist_bRH_HD(UObject* WorldContextObject,
-                                                         bool bRightHanded, const USGBasicHandModel* HandDimensions);
+                                    bool bRightHanded, const USGBasicHandModel* HandDimensions);
 
     UFUNCTION(BlueprintCallable, DisplayName="Fist", Category="SenseGlove | Core | Hand Pose",
         meta=(WorldContext="WorldContextObject"))
-    static USGHandPose* Fist_bRightHanded(UObject* WorldContextObject, bool bRightHanded);
+    static USGHandPose* Fist_bRH(UObject* WorldContextObject, bool bRightHanded);
 
     UFUNCTION(BlueprintPure, Category="SenseGlove | Core | Hand Pose")
     static bool IsRight(const USGHandPose* HandPose);
@@ -143,11 +138,10 @@ public:
     static bool Equals(const USGHandPose* A, const USGHandPose* B);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Normalized Flexion", Category="SenseGlove | Core | Hand Pose")
-    static float GetNormalizedFlexion_Finger_bClamp01(const USGHandPose* HandPose,
+    static float GetNormalizedFlexion_F_bC01(const USGHandPose* HandPose, ESGFinger Finger, bool bClamp01 = true);
-                                                      ESGFinger Finger, bool bClamp01 = true);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Normalized Flexion", Category="SenseGlove | Core | Hand Pose")
-    static TArray<float> GetNormalizedFlexion_bClamp01(const USGHandPose* HandPose, bool bClamp01 = true);
+    static TArray<float> GetNormalizedFlexion_bC01(const USGHandPose* HandPose, bool bClamp01 = true);
 
     UFUNCTION(BlueprintPure, Category="SenseGlove | Core | Hand Pose")
     static FString ToString(const USGHandPose* HandPose, bool bShortFormat = false);

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGHandProfileKismetLibrary.h

@@ -54,7 +54,7 @@ public:
 
     UFUNCTION(BlueprintPure, DisplayName="Make Hand Profile", Category="SenseGlove | Core | Hand Profile",
         meta=(WorldContext="WorldContextObject"))
-    static USGHandProfile* MakeHandProfile_bRightHanded_SenseGloveHandProfile_NovaGloveHandProfile(
+    static USGHandProfile* MakeHandProfile_bRH_SGHP_NGHP(
         UObject* WorldContextObject,
         bool bRightHanded,
         const USGSenseGloveHandProfile* SenseGloveHandProfile,

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGHapticGloveCalibrationCheckKismetLibrary.h

@@ -57,7 +57,7 @@ public:
     UFUNCTION(BlueprintCallable, DisplayName="Make Haptic Glove Calibration Check",
         Category="SenseGlove | Core | Calibration | Haptic Glove Calibration Check",
         meta=(WorldContext="WorldContextObject"))
-    static USGHapticGloveCalibrationCheck* MakeHapticGloveCalibrationCheck_LastCalibrationRange(
+    static USGHapticGloveCalibrationCheck* MakeHapticGloveCalibrationCheck_LCR(
         UObject* WorldContextObject, const USGSensorRange* LastCalibrationRange);
 
     UFUNCTION(BlueprintCallable, Category="SenseGlove | Core | Calibration | Haptic Glove Calibration Check")

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGHapticGloveCalibrationSequenceKismetLibrary.h

@@ -56,7 +56,7 @@ public:
     UFUNCTION(BlueprintCallable, DisplayName="Make Haptic Glove Calibration Sequence",
         Category="SenseGlove | Core | Calibration | Haptic Glove Calibration Sequence",
         meta=(WorldContext="WorldContextObject"))
-    static USGHapticGloveCalibrationSequence* MakeHapticGloveCalibrationSequence_GloveToCalibrate(
+    static USGHapticGloveCalibrationSequence* MakeHapticGloveCalibrationSequence_GTC(
         UObject* WorldContextObject,
         const USGHapticGlove* GloveToCalibrate);
 
@@ -66,7 +66,7 @@ public:
     UFUNCTION(BlueprintCallable, DisplayName="CompileProfile",
         Category="SenseGlove | Core | Calibration | Haptic Glove Calibration Sequence",
         meta=(WorldContext="WorldContextObject"))
-    static bool CompileProfile_SensorRange_ForDevice_bRightHanded_OutProfile(
+    static bool CompileProfile_SR_FD_bRH_OutP(
         UObject* WorldContextObject,
         const USGSensorRange* SensorRange, ESGDeviceType ForDevice, bool bRightHanded, USGHandProfile*& OutProfile);
 
@@ -126,8 +126,7 @@ public:
     UFUNCTION(BlueprintPure, DisplayName="CompileProfile",
         Category="SenseGlove | Core | Calibration | Haptic Glove Calibration Sequence",
         meta=(WorldContext="WorldContextObject"))
-
+    static bool CompileProfile_FD_bRH_OutP(
-    static bool CompileProfile_ForDevice_bRightHanded_OutProfile(
         UObject* WorldContextObject,
         const USGHapticGloveCalibrationSequence* HapticGloveCalibrationSequence,
         ESGDeviceType ForDevice, bool bRightHanded, USGHandProfile*& OutProfile);
@@ -135,14 +134,14 @@ public:
     UFUNCTION(BlueprintPure, DisplayName="Get Hand Pose",
         Category="SenseGlove | Core | Calibration | Haptic Glove Calibration Sequence",
         meta=(WorldContext="WorldContextObject"))
-    static bool GetHandPose_OutCurrentHandPose(UObject* WorldContextObject,
+    static bool GetHandPose_OutCHP(UObject* WorldContextObject,
-                                               const USGHapticGloveCalibrationSequence* HapticGloveCalibrationSequence,
+                                   const USGHapticGloveCalibrationSequence* HapticGloveCalibrationSequence,
-                                               USGHandPose*& OutCurrentHandPose);
+                                   USGHandPose*& OutCurrentHandPose);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Hand Pose",
         Category="SenseGlove | Core | Calibration | Haptic Glove Calibration Sequence",
         meta=(WorldContext="WorldContextObject"))
-    static bool GetHandPose_bRightHanded_OutCurrentHandPose(
+    static bool GetHandPose_bRH_OutCHP(
         UObject* WorldContextObject,
         const USGHapticGloveCalibrationSequence* HapticGloveCalibrationSequence,
         bool bRightHanded,

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGHapticGloveCommandBufferKismetLibrary.h

@@ -137,8 +137,7 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Flush Haptics",
         Category="SenseGlove | Core | Haptics | Haptic Glove Command Buffer", meta=(WorldContext="WorldContextObject"))
-    static void
+    static void FlushHaptics_LBL_OutFFC_OutBC_OutTC_bCFFQ(
-    FlushHaptics_LastBrakeLevel_OutForceFeedbackCommand_OutBuzzCommand_OutThumperCommand_bClearForceFeedbackQueue(
         UObject* WorldContextObject,
         UPARAM(ref) USGHapticGloveCommandBuffer* HapticGloveCommandBuffer,
         const USGForceFeedbackCommand* LastBrakeLevel,
@@ -149,7 +148,7 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Flush Haptics",
         Category="SenseGlove | Core | Haptics | Haptic Glove Command Buffer", meta=(WorldContext="WorldContextObject"))
-    static void FlushHaptics_DeltaSeconds_LastBrakeLevel_OutForceFeedbackCommand_OutBuzzCommand_OutThumperCommand(
+    static void FlushHaptics_DS_LBL_OutFFC_OutBuzzCommand_OutTC(
         UObject* WorldContextObject,
         UPARAM(ref) USGHapticGloveCommandBuffer* HapticGloveCommandBuffer,
         float DeltaSeconds,

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGHapticGloveHandProfilesKismetLibrary.h

@@ -74,17 +74,17 @@ public:
     static void GetProfile(UObject* WorldContextObject, bool bRightHanded, USGHandProfile*& OutHandProfile);
 
     UFUNCTION(BlueprintCallable, DisplayName="Set Profile", Category="SenseGlove | Core | Haptic Glove Hand Profiles")
-    static void SetProfile_HandProfile(const USGHandProfile* HandProfile);
+    static void SetProfile_HP(const USGHandProfile* HandProfile);
 
     UFUNCTION(BlueprintCallable, DisplayName="Set Profile", Category="SenseGlove | Core | Haptic Glove Hand Profiles")
-    static void SetProfile_HandProfile_bRightHanded(const USGHandProfile* HandProfile, bool bRightHanded);
+    static void SetProfile_HP_bRH(const USGHandProfile* HandProfile, bool bRightHanded);
 
     UFUNCTION(BlueprintCallable, Category="SenseGlove | Core | Haptic Glove Hand Profiles")
     static void RestoreDefaults();
 
     UFUNCTION(BlueprintCallable, DisplayName="Restore Defaults",
         Category="SenseGlove | Core | Haptic Glove Hand Profiles")
-    static void RestoreDefaults_bRightHanded(bool bRightHanded);
+    static void RestoreDefaults_bRH(bool bRightHanded);
 
     UFUNCTION(BlueprintCallable, Category="SenseGlove | Core | Haptic Glove Hand Profiles")
     static void TryLoadingFromDisk();

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGHapticGloveKismetLibrary.h

@@ -59,12 +59,12 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Glove", Category="SenseGlove | Core | Haptic Glove",
         meta=(WorldContext="WorldContextObject"))
-    static bool GetGlove_OutGlove(UObject* WorldContextObject, USGHapticGlove*& OutGlove);
+    static bool GetGlove_OutG(UObject* WorldContextObject, USGHapticGlove*& OutGlove);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Glove", Category="SenseGlove | Core | Haptic Glove",
         meta=(WorldContext="WorldContextObject"))
-    static bool GetGlove_bRightHanded_OutGlove(UObject* WorldContextObject, bool bRightHanded,
+    static bool GetGlove_bRH_OutG(UObject* WorldContextObject, bool bRightHanded,
-                                               USGHapticGlove*& OutGlove);
+                                  USGHapticGlove*& OutGlove);
 
     UFUNCTION(BlueprintPure, Category="SenseGlove | Core | Haptic Glove")
     static ESGDeviceType GetDeviceType(const USGHapticGlove* HapticGlove);
@@ -85,39 +85,39 @@ public:
     static bool IsRight(const USGHapticGlove* HapticGlove);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Imu Rotation", Category="SenseGlove | Core | Haptic Glove")
-    static bool GetImuRotation_FQuatOutImu(UPARAM(ref) USGHapticGlove* HapticGlove, FQuat& OutImu);
+    static bool GetImuRotation_FQuat_OutI(UPARAM(ref) USGHapticGlove* HapticGlove, FQuat& OutImu);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Imu Rotation", Category="SenseGlove | Core | Haptic Glove")
-    static bool GetImuRotation_FRotatorOutImu(UPARAM(ref) USGHapticGlove* HapticGlove, FRotator& OutImu);
+    static bool GetImuRotation_FRotator_OutI(UPARAM(ref) USGHapticGlove* HapticGlove, FRotator& OutImu);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Hand Pose", Category="SenseGlove | Core | Haptic Glove",
         meta=(WorldContext="WorldContextObject"))
-    static bool GetHandPose_HandGeometry_HandProfile_OutHandPose(UObject* WorldContextObject,
+    static bool GetHandPose_HG_HP_OutHP(UObject* WorldContextObject,
-                                                                 UPARAM(ref) USGHapticGlove* HapticGlove,
-                                                                 const USGBasicHandModel* HandGeometry,
-                                                                 const USGHandProfile* HandProfile,
-                                                                 USGHandPose*& OutHandPose);
-
-    UFUNCTION(BlueprintCallable, DisplayName="Get Hand Pose", Category="SenseGlove | Core | Haptic Glove",
-        meta=(WorldContext="WorldContextObject"))
-    static bool GetHandPose_HandProfile_OutHandPose(UObject* WorldContextObject,
-                                                    UPARAM(ref) USGHapticGlove* HapticGlove,
-                                                    const USGHandProfile* HandProfile,
-                                                    USGHandPose*& OutHandPose);
-
-    UFUNCTION(BlueprintCallable, DisplayName="Get Hand Pose", Category="SenseGlove | Core | Haptic Glove",
-        meta=(WorldContext="WorldContextObject"))
-    static bool GetHandPose_HandGeometry_OutHandPose(UObject* WorldContextObject,
-                                                     UPARAM(ref) USGHapticGlove* HapticGlove,
-                                                     const USGBasicHandModel* HandGeometry,
-                                                     USGHandPose*& OutHandPose);
-
-    UFUNCTION(BlueprintCallable, DisplayName="Get Hand Pose", Category="SenseGlove | Core | Haptic Glove",
-        meta=(WorldContext="WorldContextObject"))
-    static bool GetHandPose_OutHandPose(UObject* WorldContextObject,
                                         UPARAM(ref) USGHapticGlove* HapticGlove,
+                                        const USGBasicHandModel* HandGeometry,
+                                        const USGHandProfile* HandProfile,
                                         USGHandPose*& OutHandPose);
 
+    UFUNCTION(BlueprintCallable, DisplayName="Get Hand Pose", Category="SenseGlove | Core | Haptic Glove",
+        meta=(WorldContext="WorldContextObject"))
+    static bool GetHandPose_HP_OutHP(UObject* WorldContextObject,
+                                     UPARAM(ref) USGHapticGlove* HapticGlove,
+                                     const USGHandProfile* HandProfile,
+                                     USGHandPose*& OutHandPose);
+
+    UFUNCTION(BlueprintCallable, DisplayName="Get Hand Pose", Category="SenseGlove | Core | Haptic Glove",
+        meta=(WorldContext="WorldContextObject"))
+    static bool GetHandPose_HG_OutHP(UObject* WorldContextObject,
+                                     UPARAM(ref) USGHapticGlove* HapticGlove,
+                                     const USGBasicHandModel* HandGeometry,
+                                     USGHandPose*& OutHandPose);
+
+    UFUNCTION(BlueprintCallable, DisplayName="Get Hand Pose", Category="SenseGlove | Core | Haptic Glove",
+        meta=(WorldContext="WorldContextObject"))
+    static bool GetHandPose_OutHP(UObject* WorldContextObject,
+                                  UPARAM(ref) USGHapticGlove* HapticGlove,
+                                  USGHandPose*& OutHandPose);
+
     UFUNCTION(BlueprintCallable, Category="SenseGlove | Core | Haptic Glove")
     static void StopHaptics(UPARAM(ref) USGHapticGlove* HapticGlove);
 
@@ -125,29 +125,27 @@ public:
     static void StopVibrations(UPARAM(ref) USGHapticGlove* HapticGlove);
 
     UFUNCTION(BlueprintCallable, DisplayName="Send Haptics", Category="SenseGlove | Core | Haptic Glove")
-    static void SendHaptics_ForceFeedbackCommand(UPARAM(ref) USGHapticGlove* HapticGlove,
+    static void SendHaptics_FFC(UPARAM(ref) USGHapticGlove* HapticGlove,
-                                                 const USGForceFeedbackCommand* ForceFeedbackCommand);
+                                const USGForceFeedbackCommand* ForceFeedbackCommand);
 
     UFUNCTION(BlueprintCallable, DisplayName="Send Haptics", Category="SenseGlove | Core | Haptic Glove")
-    static void SendHaptics_BuzzCommand(UPARAM(ref) USGHapticGlove* HapticGlove,
+    static void SendHaptics_BC(UPARAM(ref) USGHapticGlove* HapticGlove,
-                                        const USGBuzzCommand* BuzzCommand);
+                               const USGBuzzCommand* BuzzCommand);
 
     UFUNCTION(BlueprintCallable, DisplayName="Send Haptics", Category="SenseGlove | Core | Haptic Glove")
-    static void SendHaptics_ThumperCommand(UPARAM(ref) USGHapticGlove* HapticGlove,
+    static void SendHaptics_TC(UPARAM(ref) USGHapticGlove* HapticGlove,
-                                           const USGThumperCommand* ThumperCommand);
+                               const USGThumperCommand* ThumperCommand);
 
     UFUNCTION(BlueprintCallable, DisplayName="Send Haptics", Category="SenseGlove | Core | Haptic Glove")
-    static void SendHaptics_ForceFeedbackCommand_BuzzCommand(
+    static void SendHaptics_FFC_BC(UPARAM(ref) USGHapticGlove* HapticGlove,
-        UPARAM(ref) USGHapticGlove* HapticGlove,
+                                   const USGForceFeedbackCommand* ForceFeedbackCommand,
-        const USGForceFeedbackCommand* ForceFeedbackCommand,
+                                   const USGBuzzCommand* BuzzCommand);
-        const USGBuzzCommand* BuzzCommand);
 
     UFUNCTION(BlueprintCallable, DisplayName="Send Haptics", Category="SenseGlove | Core | Haptic Glove")
-    static void SendHaptics_ForceFeedbackCommand_BuzzCommand_ThumperCommand(
+    static void SendHaptics_FFC_BC_TC(UPARAM(ref) USGHapticGlove* HapticGlove,
-        UPARAM(ref) USGHapticGlove* HapticGlove,
+                                      const USGForceFeedbackCommand* ForceFeedbackCommand,
-        const USGForceFeedbackCommand* ForceFeedbackCommand,
+                                      const USGBuzzCommand* BuzzCommand,
-        const USGBuzzCommand* BuzzCommand,
+                                      const USGThumperCommand* ThumperCommand);
-        const USGThumperCommand* ThumperCommand);
 
     UFUNCTION(BlueprintCallable, Category="SenseGlove | Core | Haptic Glove")
     static bool GetCalibrationValues(UPARAM(ref) USGHapticGlove* HapticGlove, TArray<FVector>& OutValues);
@@ -159,8 +157,8 @@ public:
     static void UpdateCalibrationRange(UPARAM(ref) USGHapticGlove* HapticGlove);
 
     UFUNCTION(BlueprintCallable, DisplayName="Update Calibration", Category="SenseGlove | Core | Haptic Glove")
-    static void UpdateCalibrationRange_CalibrationValues(UPARAM(ref) USGHapticGlove* HapticGlove,
+    static void UpdateCalibrationRange_CV(UPARAM(ref) USGHapticGlove* HapticGlove,
-                                                         const TArray<FVector>& CalibrationValues);
+                                          const TArray<FVector>& CalibrationValues);
 
     UFUNCTION(BlueprintCallable, Category="SenseGlove | Core | Haptic Glove")
     static void GetCalibrationRange(UPARAM(ref) USGHapticGlove* HapticGlove,
@@ -175,30 +173,28 @@ public:
                                  const USGHapticGlove* HapticGlove, USGHandProfile*& OutProfile);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Wrist Location", Category="SenseGlove | Core | Haptic Glove")
-    static void GetWristLocation_ReferencePosition_ReferenceRotation_TrackingHardware_OutWristPosition_OutWristLocation(
+    static void GetWristLocation_RP_FQuat_RR_TH_OutWP_Out_WR(
         const USGHapticGlove* HapticGlove,
         const FVector& ReferencePosition, const FQuat& ReferenceRotation,
         ESGPositionalTrackingHardware TrackingHardware,
         FVector& OutWristPosition, FQuat& OutWristRotation);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Wrist Location", Category="SenseGlove | Core | Haptic Glove")
-    static void
+    static void GetWristLocation_RP_FRotator_RR_TH_OutWP_OutWR(
-    GetWristLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_OutWristPosition_FRotatorOutWristLocation(
         const USGHapticGlove* HapticGlove,
         const FVector& ReferencePosition, const FRotator& ReferenceRotation,
         ESGPositionalTrackingHardware TrackingHardware,
         FVector& OutWristPosition, FRotator& OutWristRotation);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Glove Location", Category="SenseGlove | Core | Haptic Glove")
-    static void GetGloveLocation_ReferencePosition_ReferenceRotation_TrackingHardware_OutGlovePosition_OutGloveRotation(
+    static void GetGloveLocation_RP_FQuat_RR_TH_OutGP_OutGR(
         const USGHapticGlove* HapticGlove,
         const FVector& ReferencePosition, const FQuat& ReferenceRotation,
         ESGPositionalTrackingHardware TrackingHardware,
         FVector& OutGlovePosition, FQuat& OutGloveRotation);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Glove Location", Category="SenseGlove | Core | Haptic Glove")
-    static void
+    static void GetGloveLocation_RP_FRotator_RR_TH_OutGP_OutGR(
-    GetGloveLocation_FRotatorReferencePosition_ReferenceRotation_TrackingHardware_OutGlovePosition_FRotatorOutGloveRotation(
         const USGHapticGlove* HapticGlove,
         const FVector& ReferencePosition, const FRotator& ReferenceRotation,
         ESGPositionalTrackingHardware TrackingHardware,

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGHapticGloveQuickCalibrationKismetLibrary.h

@@ -54,7 +54,7 @@ public:
     UFUNCTION(BlueprintCallable, DisplayName="Make Haptic Glove Quick Calibration",
         Category="SenseGlove | Core | Calibration | Haptic Glove Quick Calibration",
         meta=(WorldContext="WorldContextObject"))
-    static USGHapticGloveQuickCalibration* MakeHapticGloveQuickCalibration_GloveToCalibrate_AutoEndTimeout(
+    static USGHapticGloveQuickCalibration* MakeHapticGloveQuickCalibration_GTC_AET(
         UObject* WorldContextObject,
         const USGHapticGlove* GloveToCalibrate,
         float AutoEndTimeout);

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGInterpolationSetKismetLibrary.h

@@ -53,12 +53,12 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Interpolation Set",
         Category="SenseGlove | Core | Kinematics | Interpolation Set", meta=(WorldContext="WorldContextObject"))
-    static USGInterpolationSet* MakeInterpolationSet_From1_From2_To1_To2(
+    static USGInterpolationSet* MakeInterpolationSet_F1_F2_T1_T2(
         UObject* WorldContextObject, float From1, float From2, float To1, float To2);
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Interpolation Set",
         Category="SenseGlove | Core | Kinematics | Interpolation Set", meta=(WorldContext="WorldContextObject"))
-    static USGInterpolationSet* MakeInterpolationSet_From1_From2_To1_To2_Min_Max(
+    static USGInterpolationSet* MakeInterpolationSet_F1_F2_T1_T2_M_M(
         UObject* WorldContextObject, float From1, float From2, float To1, float To2, float Min, float Max);
 
     UFUNCTION(BlueprintCallable, Category="SenseGlove | Core | Kinematics | Interpolation Set",
@@ -112,7 +112,7 @@ public:
     static FString ToString(const USGInterpolationSet* InterpolationSet);
 
     UFUNCTION(BlueprintPure, DisplayName="To String", Category="SenseGlove | Core | Kinematics | Interpolation Set")
-    static FString ToString_bLimits(const USGInterpolationSet* InterpolationSet, bool bLimits);
+    static FString ToString_bL(const USGInterpolationSet* InterpolationSet, bool bLimits);
 
     UFUNCTION(BlueprintPure, DisplayName="Serialize", Category="SenseGlove | Core | Kinematics | Interpolation Set")
     static FString SGSerialize(const USGInterpolationSet* InterpolationSet);

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGJointKinematicsKismetLibrary.h

@@ -53,27 +53,28 @@ class SENSEGLOVECOREKISMET_API USGJointKinematicsKismetLibrary final : public US
 public:
     UFUNCTION(BlueprintCallable, DisplayName="Forward Kinematics",
         Category="SenseGlove | Core | Kinematics | Joint Kinematics")
-    static bool ForwardKinematics_StartPosition_FQuatStartRotation_JointLengths_JointAngles_OutNewPositions_TArrayFQuatOutNewRotations(
+    static bool ForwardKinematics_SP_FQuat_SR_JL_JA_OutNP_TArrayFQuat_OutNR(
         const FVector& StartPosition, const FQuat& StartRotation,
         const TArray<FVector>& JointLengths, const TArray<FVector>& JointAngles,
         TArray<FVector>& OutNewPositions, TArray<FQuat>& OutNewRotations);
 
     UFUNCTION(BlueprintCallable, DisplayName="Forward Kinematics",
         Category="SenseGlove | Core | Kinematics | Joint Kinematics")
-    static bool ForwardKinematics_StartPosition_FRotatorStartRotation_JointLengths_JointAngles_OutNewPositions_TArrayFRotatorOutNewRotations(
+    static bool
+    ForwardKinematics_SP_FRotator_SR_JL_JA_OutNP_TArrayFRotator_OutNR(
         const FVector& StartPosition, const FRotator& StartRotation,
         const TArray<FVector>& JointLengths, const TArray<FVector>& JointAngles,
         TArray<FVector>& OutNewPositions, TArray<FRotator>& OutNewRotations);
 
     UFUNCTION(BlueprintCallable, DisplayName="Forward Kinematics",
         Category="SenseGlove | Core | Kinematics | Joint Kinematics")
-    static bool ForwardKinematics_Profile_Finger_JointAngles_OutNewPositions_TArrayFQuatOutNewRotations(
+    static bool ForwardKinematics_P_F_JA_OutNP_TArrayFQuat_OutNR(
         const USGBasicHandModel* Profile, ESGFinger Finger, const TArray<FVector>& JointAngles,
         TArray<FVector>& OutNewPositions, TArray<FQuat>& OutNewRotations);
 
     UFUNCTION(BlueprintCallable, DisplayName="Forward Kinematics",
         Category="SenseGlove | Core | Kinematics | Joint Kinematics")
-    static bool ForwardKinematics_Profile_Finger_JointAngles_OutNewPositions_TArrayFRotatorOutNewRotations(
+    static bool ForwardKinematics_P_F_JA_OutNP_TArrayFRotator_OutNR(
         const USGBasicHandModel* Profile, ESGFinger Finger, const TArray<FVector>& JointAngles,
         TArray<FVector>& OutNewPositions, TArray<FRotator>& OutNewRotations);
 };

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGNovaGloveHandProfileKismetLibrary.h

@@ -54,7 +54,7 @@ public:
 
     UFUNCTION(BlueprintPure, DisplayName="Make Nova Glove Hand Profile",
         Category="SenseGlove | Core | Nova | Nova Glove Hand Profile", meta=(WorldContext="WorldContextObject"))
-    static USGNovaGloveHandProfile* MakeNovaGloveHandProfile_bRightHanded_Interpolator(
+    static USGNovaGloveHandProfile* MakeNovaGloveHandProfile_bRH_I(
         UObject* WorldContextObject, bool bRightHanded, const USGHandInterpolator* Interpolator);
 
     UFUNCTION(BlueprintPure, Category="SenseGlove | Core | Nova | Nova Glove Hand Profile")

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGNovaGloveInfoKismetLibrary.h

@@ -53,8 +53,7 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Nova Glove Info",
         Category="SenseGlove | Core | Nova | Nova Glove Info", meta=(WorldContext="WorldContextObject"))
-    static USGNovaGloveInfo*
+    static USGNovaGloveInfo* MakeNovaGloveInfo_DI_HV_FV_SFV_bRH_IC_NOS(
-    MakeNovaGloveInfo_DeviceId_HardwareVersion_FirmwareVersion_SubFirmwareVersion_bRightHanded_ImuCorrection_NumberOfSensors(
         UObject* WorldContextObject,
         const FString& DeviceId, const FString& HardwareVersion, int32 FirmwareVersion, int32 SubFirmwareVersion,
         bool bRightHanded, const FQuat& ImuCorrection, int32 NumberOfSensors);

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGNovaGloveKismetLibrary.h

@@ -80,15 +80,15 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Nova Glove", Category="SenseGlove | Core | Nova | Nova Glove",
         meta=(WorldContext="WorldContextObject"))
-    static bool GetNovaGlove_OutGlove(UObject* WorldContextObject, USGNovaGlove*& OutGlove);
+    static bool GetNovaGlove_OutG(UObject* WorldContextObject, USGNovaGlove*& OutGlove);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Nova Glove", Category="SenseGlove | Core | Nova | Nova Glove",
         meta=(WorldContext="WorldContextObject"))
-    static bool GetNovaGlove_bRightHanded_OutGlove(UObject* WorldContextObject,
+    static bool GetNovaGlove_bRH_OutG(UObject* WorldContextObject,
-                                                   bool bRightHanded, USGNovaGlove*& OutGlove);
+                                      bool bRightHanded, USGNovaGlove*& OutGlove);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Calibration Values", Category="SenseGlove | Core | Nova | Nova Glove")
-    static TArray<FVector> GetCalibrationValues_SensorData(const USGNovaGloveSensorData* SensorData);
+    static TArray<FVector> GetCalibrationValues_SD(const USGNovaGloveSensorData* SensorData);
 
     UFUNCTION(BlueprintCallable, Category="SenseGlove | Core | Nova | Nova Glove",
         meta=(WorldContext="WorldContextObject"))
@@ -98,44 +98,40 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Calculate Glove Location",
         Category="SenseGlove | Core | Nova | Nova Glove")
-    static void
+    static void CalculateGloveLocation_RP_FQuat_RR_TH_bRH_OutGP_OutGR(
-    CalculateGloveLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_bRightHanded_OutGlovePosition_FQuatOutGloveRotation(
         const FVector& ReferencePosition, const FQuat& ReferenceRotation,
         ESGPositionalTrackingHardware TrackingHardware, bool bRightHanded,
         FVector& OutGlovePosition, FQuat& OutGloveRotation);
 
     UFUNCTION(BlueprintCallable, DisplayName="Calculate Glove Location",
         Category="SenseGlove | Core | Nova | Nova Glove")
-    static void
+    static void CalculateGloveLocation_RP_FRotator_RR_TH_bRH_OutGP_OutGR(
-    CalculateGloveLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_bRightHanded_OutGlovePosition_FRotatorOutGloveRotation(
         const FVector& ReferencePosition, const FRotator& ReferenceRotation,
         ESGPositionalTrackingHardware TrackingHardware, bool bRightHanded,
         FVector& OutGlovePosition, FRotator& OutGloveRotation);
 
     UFUNCTION(BlueprintCallable, DisplayName="Calculate Wrist Location",
         Category="SenseGlove | Core | Nova | Nova Glove")
-    static void
+    static void CalculateWristLocation_RP_FQuat_RR_TH_bRH_OutWP_OutWR(
-    CalculateWristLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_bRightHanded_OutWristPosition_FQuatOutWristRotation(
         const FVector& ReferencePosition, const FQuat& ReferenceRotation,
         ESGPositionalTrackingHardware TrackingHardware, bool bRightHanded,
         FVector& OutWristPosition, FQuat& OutWristRotation);
 
     UFUNCTION(BlueprintCallable, DisplayName="Calculate Wrist Location",
         Category="SenseGlove | Core | Nova | Nova Glove")
-    static void
+    static void CalculateWristLocation_RP_FRotator_RR_TH_bRH_OutWP_OutWR(
-    CalculateWristLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_bRightHanded_OutWristPosition_FRotatorOutWristRotation(
         const FVector& ReferencePosition, const FRotator& ReferenceRotation,
         ESGPositionalTrackingHardware TrackingHardware, bool bRightHanded,
         FVector& OutWristPosition, FRotator& OutWristRotation);
 
     UFUNCTION(BlueprintCallable, DisplayName="To Bytes", Category="SenseGlove | Core | Nova | Nova Glove")
-    static FString ToBytes_ThumperCommand(const USGThumperCommand* ThumperCommand);
+    static FString ToBytes_TC(const USGThumperCommand* ThumperCommand);
 
     UFUNCTION(BlueprintCallable, DisplayName="To Bytes", Category="SenseGlove | Core | Nova | Nova Glove")
-    static FString ToBytes_ForceFeedbackCommand(const USGForceFeedbackCommand* ForceFeedbackCommand);
+    static FString ToBytes_FFC(const USGForceFeedbackCommand* ForceFeedbackCommand);
 
     UFUNCTION(BlueprintCallable, DisplayName="To Bytes", Category="SenseGlove | Core | Nova | Nova Glove")
-    static FString ToBytes_BuzzCommand(const USGBuzzCommand* BuzzCommand);
+    static FString ToBytes_BC(const USGBuzzCommand* BuzzCommand);
 
     UFUNCTION(BlueprintPure, Category="SenseGlove | Core | Nova | Nova Glove")
     static ESGDeviceType GetDeviceType(const USGNovaGlove* NovaGlove);
@@ -167,96 +163,89 @@ public:
                               UPARAM(ref) USGNovaGlove* NovaGlove, USGNovaGloveSensorData*& OutSensorData);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Imu Rotation", Category="SenseGlove | Core | Nova | Nova Glove")
-    static bool GetImuRotation_FQuatOutImu(UPARAM(ref) USGNovaGlove* NovaGlove, FQuat& OutImu);
+    static bool GetImuRotation_FQuat_OutI(UPARAM(ref) USGNovaGlove* NovaGlove, FQuat& OutImu);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Imu Rotation", Category="SenseGlove | Core | Nova | Nova Glove")
-    static bool GetImuRotation_FRotatorOutImu(UPARAM(ref) USGNovaGlove* NovaGlove, FRotator& OutImu);
+    static bool GetImuRotation_FRotator_OutI(UPARAM(ref) USGNovaGlove* NovaGlove, FRotator& OutImu);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Hand Pose", Category="SenseGlove | Core | Nova | Nova Glove",
         meta=(WorldContext="WorldContextObject"))
-    static bool GetHandPose_HandModel_Profile_OutHandPose(UObject* WorldContextObject,
+    static bool GetHandPose_HM_P_OutHP(UObject* WorldContextObject,
-                                                          UPARAM(ref) USGNovaGlove* NovaGlove,
+                                       UPARAM(ref) USGNovaGlove* NovaGlove,
-                                                          const USGBasicHandModel* HandModel,
+                                       const USGBasicHandModel* HandModel,
-                                                          const USGNovaGloveHandProfile* Profile,
+                                       const USGNovaGloveHandProfile* Profile,
-                                                          USGHandPose*& OutHandPose);
+                                       USGHandPose*& OutHandPose);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Hand Pose", Category="SenseGlove | Core | Nova | Nova Glove",
         meta=(WorldContext="WorldContextObject"))
-    static bool GetHandPose_HandGeometry_HandProfile_OutHandPose(UObject* WorldContextObject,
+    static bool GetHandPose_HG_HP_OutHP(UObject* WorldContextObject,
-                                                                 UPARAM(ref) USGNovaGlove* NovaGlove,
+                                        UPARAM(ref) USGNovaGlove* NovaGlove,
-                                                                 const USGBasicHandModel* HandGeometry,
+                                        const USGBasicHandModel* HandGeometry,
-                                                                 const USGHandProfile* HandProfile,
+                                        const USGHandProfile* HandProfile,
-                                                                 USGHandPose*& OutHandPose);
+                                        USGHandPose*& OutHandPose);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Hand Pose", Category="SenseGlove | Core | Nova | Nova Glove",
         meta=(WorldContext="WorldContextObject"))
-    static bool GetHandPose_HandProfile_OutHandPose(UObject* WorldContextObject,
+    static bool GetHandPose_HP_OutHP(UObject* WorldContextObject,
-                                                    UPARAM(ref) USGNovaGlove* NovaGlove,
+                                     UPARAM(ref) USGNovaGlove* NovaGlove,
-                                                    const USGHandProfile* HandProfile,
+                                     const USGHandProfile* HandProfile,
-                                                    USGHandPose*& OutHandPose);
+                                     USGHandPose*& OutHandPose);
 
     UFUNCTION(BlueprintCallable, DisplayName="Send Haptics", Category="SenseGlove | Core | Nova | Nova Glove")
-    static void SendHaptics_ForceFeedbackCommand(UPARAM(ref) USGNovaGlove* NovaGlove,
+    static void SendHaptics_FFC(UPARAM(ref) USGNovaGlove* NovaGlove,
-                                                 const USGForceFeedbackCommand* ForceFeedbackCommand);
+                                const USGForceFeedbackCommand* ForceFeedbackCommand);
 
     UFUNCTION(BlueprintCallable, DisplayName="Send Haptics", Category="SenseGlove | Core | Nova | Nova Glove")
-    static void SendHaptics_BuzzCommand(UPARAM(ref) USGNovaGlove* NovaGlove,
+    static void SendHaptics_BC(UPARAM(ref) USGNovaGlove* NovaGlove, const USGBuzzCommand* BuzzCommand);
-                                        const USGBuzzCommand* BuzzCommand);
 
     UFUNCTION(BlueprintCallable, DisplayName="Send Haptics", Category="SenseGlove | Core | Nova | Nova Glove")
-    static void SendHaptics_ThumperCommand(UPARAM(ref) USGNovaGlove* NovaGlove,
+    static void SendHaptics_TC(UPARAM(ref) USGNovaGlove* NovaGlove, const USGThumperCommand* ThumperCommand);
-                                           const USGThumperCommand* ThumperCommand);
 
     UFUNCTION(BlueprintCallable, DisplayName="Send Haptics", Category="SenseGlove | Core | Nova | Nova Glove")
-    static void SendHaptics_ForceFeedbackCommand_BuzzCommand_ThumperCommand(
+    static void SendHaptics_FFC_BC_TC(
         UPARAM(ref) USGNovaGlove* NovaGlove,
         const USGForceFeedbackCommand* ForceFeedbackCommand,
         const USGBuzzCommand* BuzzCommand,
         const USGThumperCommand* ThumperCommand);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Calibration Values", Category="SenseGlove | Core | Nova | Nova Glove")
-    static bool GetCalibrationValues_OutValues(UPARAM(ref) USGNovaGlove* NovaGlove,
+    static bool GetCalibrationValues_OutV(UPARAM(ref) USGNovaGlove* NovaGlove, TArray<FVector>& OutValues);
-                                               TArray<FVector>& OutValues);
 
     UFUNCTION(BlueprintPure, DisplayName="Apply Calibration", Category="SenseGlove | Core | Nova | Nova Glove",
         meta=(WorldContext="WorldContextObject"))
-    static void ApplyCalibration_HandProfile(UObject* WorldContextObject,
+    static void ApplyCalibration_USGHandProfile_OutP(UObject* WorldContextObject,
-                                             const USGNovaGlove* NovaGlove,
+                                                     const USGNovaGlove* NovaGlove,
-                                             USGHandProfile*& OutProfile);
+                                                     USGHandProfile*& OutProfile);
 
     UFUNCTION(BlueprintPure, DisplayName="Apply Calibration", Category="SenseGlove | Core | Nova | Nova Glove",
         meta=(WorldContext="WorldContextObject"))
-    static void ApplyCalibration_NovaGloveHandProfile(UObject* WorldContextObject,
+    static void ApplyCalibration_USGNovaGloveHandProfile_OutP(UObject* WorldContextObject,
-                                                      const USGNovaGlove* NovaGlove,
+                                                              const USGNovaGlove* NovaGlove,
-                                                      USGNovaGloveHandProfile*& OutProfile);
+                                                              USGNovaGloveHandProfile*& OutProfile);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Glove Location", Category="SenseGlove | Core | Nova | Nova Glove")
-    static void
+    static void GetGloveLocation_RP_FQuat_RR_TH_OutGP_FQuat_OutGR(
-    GetGloveLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_OutGlovePosition_FQuatOutGloveRotation(
         const USGNovaGlove* NovaGlove,
         const FVector& ReferencePosition, const FQuat& ReferenceRotation,
         ESGPositionalTrackingHardware TrackingHardware,
         FVector& OutGlovePosition, FQuat& OutGloveRotation);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Glove Location", Category="SenseGlove | Core | Nova | Nova Glove")
-    static void
+    static void GetGloveLocation_RP_FRotator_RR_TH_OutGP_FRotator_OutGR(
-    GetGloveLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_OutGlovePosition_FRotatorOutGloveRotation(
         const USGNovaGlove* NovaGlove,
         const FVector& ReferencePosition, const FRotator& ReferenceRotation,
         ESGPositionalTrackingHardware TrackingHardware,
         FVector& OutGlovePosition, FRotator& OutGloveRotation);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Wrist Location", Category="SenseGlove | Core | Nova | Nova Glove")
-    static void
+    static void GetWristLocation_RP_FQuat_RR_TH_OutWP_FQuat_OutWR(
-    GetWristLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_OutWristPosition_FQuatOutWristRotation(
         const USGNovaGlove* NovaGlove,
         const FVector& ReferencePosition, const FQuat& ReferenceRotation,
         ESGPositionalTrackingHardware TrackingHardware,
         FVector& OutWristPosition, FQuat& OutWristRotation);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Wrist Location", Category="SenseGlove | Core | Nova | Nova Glove")
-    static void
+    static void GetWristLocation_RP_FRotator_RR_TH_OutWP_FRotator_OutWR(
-    GetWristLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_OutWristPosition_FRotatorOutWristRotation(
         const USGNovaGlove* NovaGlove,
         const FVector& ReferencePosition, const FRotator& ReferenceRotation,
         ESGPositionalTrackingHardware TrackingHardware,

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGNovaGloveSensorDataKismetLibrary.h

@@ -54,15 +54,13 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Nova Glove Sensor Data",
         Category="SenseGlove | Core | Nova | Nova Glove Sensor Data", meta=(WorldContext="WorldContextObject"))
-    static USGNovaGloveSensorData*
+    static USGNovaGloveSensorData* MakeNovaGloveSensorData_V_PV_FQuat_IR_bIP_BL_bC(
-    MakeNovaGloveSensorData_Values_ParsedValues_FQuatImuRotation_bImuParsed_BatteryLevel_bCharging(
         UObject* WorldContextObject, const TArray<FVector>& Values, int32 ParsedValues,
         const FQuat& ImuRotation, bool bImuParsed, float BatteryLevel, bool bCharging);
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Nova Glove Sensor Data",
         Category="SenseGlove | Core | Nova | Nova Glove Sensor Data", meta=(WorldContext="WorldContextObject"))
-    static USGNovaGloveSensorData*
+    static USGNovaGloveSensorData* MakeNovaGloveSensorData_V_PV_FRotator_IR_bIP_BL_b(
-    MakeNovaGloveSensorData_Values_ParsedValues_FRotatorImuRotation_bImuParsed_BatteryLevel_bCharging(
         UObject* WorldContextObject, const TArray<FVector>& Values, int32 ParsedValues,
         const FRotator& ImuRotation, bool bImuParsed, float BatteryLevel, bool bCharging);
 

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGSenseComKismetLibrary.h

@@ -53,7 +53,7 @@ public:
     static bool RegisterExe();
 
     UFUNCTION(BlueprintCallable, DisplayName="Register Exe", Category="SenseGlove | Core | SenseCom")
-    static bool RegisterExe_ExePath(const FString& ExePath);
+    static bool RegisterExe_EP(const FString& ExePath);
 
     UFUNCTION(BlueprintCallable, Category="SenseGlove | Core | SenseCom")
     static bool GetExePath(FString& OutExePath);

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGSenseGloveHandProfileKismetLibrary.h

@@ -55,8 +55,7 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Sense Glove Hand Profile",
         Category="SenseGlove | Core | SG | Sense Glove Hand Profile", meta=(WorldContext="WorldContextObject"))
-    static USGSenseGloveHandProfile*
+    static USGSenseGloveHandProfile* MakeSenseGloveHandProfile_bRH_I_TS_FS_FTO(
-    MakeSenseGloveHandProfile_bRightHanded_Interpolator_ThumbSolver_FingerSolver_FingerThimbleOffset(
         UObject* WorldContextObject, bool bRightHanded, const USGHandInterpolator* Interpolator,
         ESGThumbSolver ThumbSolver, ESGFingerSolver FingerSolver, const TArray<FVector>& FingerThimbleOffset);
 

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGSenseGloveInfoKismetLibrary.h

@@ -56,8 +56,7 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Sense Glove Info",
         Category="SenseGlove | Core | SG | Sense Glove Info", meta=(WorldContext="WorldContextObject"))
-    static USGSenseGloveInfo*
+    static USGSenseGloveInfo* MakeSenseGloveInfo_DI_HV_FV_SFV_bRH_NOS_FQuat_IC_SP_TArrayFQuat_SR_GL_F(
-    MakeSenseGloveInfo_DeviceId_HardwareVersion_FirmwareVersion_SubFirmwareVersion_bRightHanded_NumberOfSensors_FQuatImuCorrection_StartPositions_TArrayFQuatStartRotations_GloveLengths_Functions(
         UObject* WorldContextObject, const FString& DeviceId,
         const FString& HardwareVersion, int32 FirmwareVersion, int32 SubFirmwareVersion,
         bool bRightHanded, int32 NumberOfSensors, const FQuat& ImuCorrection,
@@ -66,8 +65,7 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Sense Glove Info",
         Category="SenseGlove | Core | SG | Sense Glove Info", meta=(WorldContext="WorldContextObject"))
-    static USGSenseGloveInfo*
+    static USGSenseGloveInfo* MakeSenseGloveInfo_DI_HV_FV_SFV_bRH_NOS_FRotator_IC_SP_TArrayFRotator_SR_GL_F(
-    MakeSenseGloveInfo_DeviceId_HardwareVersion_FirmwareVersion_SubFirmwareVersion_bRightHanded_NumberOfSensors_FRotatorImuCorrection_StartPositions_TArrayFRotatorStartRotations_GloveLengths_Functions(
         UObject* WorldContextObject, const FString& DeviceId,
         const FString& HardwareVersion, int32 FirmwareVersion, int32 SubFirmwareVersion,
         bool bRightHanded, int32 NumberOfSensors, const FRotator& ImuCorrection,
@@ -133,7 +131,7 @@ public:
     static FRotator GetStartRotation_FRotator(const USGSenseGloveInfo* SenseGloveInfo, ESGFinger Finger);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Glove Lengths", Category="SenseGlove | Core | SG | Sense Glove Info")
-    static TArray<FVector> GetGloveLengths_Finger(const USGSenseGloveInfo* SenseGloveInfo, ESGFinger Finger);
+    static TArray<FVector> GetGloveLengths_F(const USGSenseGloveInfo* SenseGloveInfo, ESGFinger Finger);
 
     UFUNCTION(BlueprintPure, Category="SenseGlove | Core | SG | Sense Glove Info")
     static TArray<FSGVectorArray> ToGloveAngles(const USGSenseGloveInfo* SenseGloveInfo,
@@ -146,7 +144,7 @@ public:
     static FString ToString(const USGSenseGloveInfo* SenseGloveInfo);
 
     UFUNCTION(BlueprintPure, DisplayName="To String", Category="SenseGlove | Core | SG | Sense Glove Info")
-    static FString ToString_bShortNotation(const USGSenseGloveInfo* SenseGloveInfo, bool bShortNotation);
+    static FString ToString_bSN(const USGSenseGloveInfo* SenseGloveInfo, bool bShortNotation);
 
     UFUNCTION(BlueprintPure, DisplayName="Serialize", Category="SenseGlove | Core | SG | Sense Glove Info")
     static FString SGSerialize(const USGSenseGloveInfo* SenseGloveInfo);

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGSenseGloveKismetLibrary.h

@@ -64,13 +64,13 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Calculate Glove Pose", Category="SenseGlove | Core | SG | Sense Glove",
         meta=(WorldContext="WorldContextObject"))
-    static USGSenseGlovePose* CalculateGlovePose_SensorData_GloveModel(
+    static USGSenseGlovePose* CalculateGlovePose_SD_GM(
         UObject* WorldContextObject,
         const USGSenseGloveSensorData* SensorData, const USGSenseGloveInfo* GloveModel);
 
     UFUNCTION(BlueprintCallable, DisplayName="Calculate Glove Pose", Category="SenseGlove | Core | SG | Sense Glove",
         meta=(WorldContext="WorldContextObject"))
-    static USGSenseGlovePose* CalculateGlovePose_GloveAngles_GloveModel(
+    static USGSenseGlovePose* CalculateGlovePose_GA_GM(
         UObject* WorldContextObject,
         const TArray<FSGVectorArray>& GloveAngles, const USGSenseGloveInfo* GloveModel);
 
@@ -91,12 +91,11 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Sense Glove", Category="SenseGlove | Core | SG | Sense Glove",
         meta=(WorldContext="WorldContextObject"))
-    static bool GetSenseGlove_OutGlove(UObject* WorldContextObject, USGSenseGlove*& OutGlove);
+    static bool GetSenseGlove_OutG(UObject* WorldContextObject, USGSenseGlove*& OutGlove);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Sense Glove", Category="SenseGlove | Core | SG | Sense Glove",
         meta=(WorldContext="WorldContextObject"))
-    static bool GetSenseGlove_bRightHanded_OutGlove(UObject* WorldContextObject, bool bRightHanded,
+    static bool GetSenseGlove_bRH_OutG(UObject* WorldContextObject, bool bRightHanded, USGSenseGlove*& OutGlove);
-                                                    USGSenseGlove*& OutGlove);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Calibration Values", Category="SenseGlove | Core | SG | Sense Glove")
     static TArray<FVector> GetCalibrationValues_GlovePose(const USGSenseGlovePose* GlovePose);
@@ -109,43 +108,32 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Calculate Glove Location",
         Category="SenseGlove | Core | SG | Sense Glove")
-    static void
+    static void CalculateGloveLocation_RP_FQuat_RR_TH_bRH_MO_OutGP_FQuat_OutGR(
-    CalculateGloveLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_bRightHanded_MountedOn_OutGlovePosition_FQuatOutGloveRotation(
         const FVector& ReferencePosition, const FQuat& ReferenceRotation,
-        ESGPositionalTrackingHardware TrackingHardware,
+        ESGPositionalTrackingHardware TrackingHardware, bool bRightHanded, ESGFinger MountedOn,
-        bool bRightHanded, ESGFinger MountedOn,
         FVector& OutGlovePosition, FQuat& OutGloveRotation);
 
     UFUNCTION(BlueprintCallable, DisplayName="Calculate Glove Location",
         Category="SenseGlove | Core | SG | Sense Glove")
-    static void
+    static void CalculateGloveLocation_RP_FRotator_RR_TH_bRH_MO_OutGP_FRotator_OutGR(
-    CalculateGloveLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_bRightHanded_MountedOn_OutGlovePosition_FRotatorOutGloveRotation(
         const FVector& ReferencePosition, const FRotator& ReferenceRotation,
-        ESGPositionalTrackingHardware TrackingHardware,
+        ESGPositionalTrackingHardware TrackingHardware, bool bRightHanded, ESGFinger MountedOn,
-        bool bRightHanded, ESGFinger MountedOn,
         FVector& OutGlovePosition, FRotator& OutGloveRotation);
 
     UFUNCTION(BlueprintCallable, DisplayName="Calculate Wrist Location",
         Category="SenseGlove | Core | SG | Sense Glove")
-    static void
+    static void CalculateWristLocation_RP_FQuat_RR_TH_bRH_MO_GWPOffset_FQuat_GWRO_OutWP_FQuat_OutWR(
-    CalculateWristLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_bRightHanded_MountedOn_GloveWristPositionOffset_FQuatGloveWristRotationOffset_OutWristPosition_FQuatOutWristRotation
-    (
         const FVector& ReferencePosition, const FQuat& ReferenceRotation,
-        ESGPositionalTrackingHardware TrackingHardware,
+        ESGPositionalTrackingHardware TrackingHardware, bool bRightHanded, ESGFinger MountedOn,
-        bool bRightHanded, ESGFinger MountedOn,
+        const FVector& GloveWristPositionOffset, const FQuat& GloveWristRotationOffset,
-        const FVector& GloveWristPositionOffset,
-        const FQuat& GloveWristRotationOffset,
         FVector& OutWristPosition, FQuat& OutWristRotation);
 
     UFUNCTION(BlueprintCallable, DisplayName="Calculate Wrist Location",
         Category="SenseGlove | Core | SG | Sense Glove")
-    static void
+    static void CalculateWristLocation_RP_FRotator_RR_TH_bRH_MO_GWPOffset_FRotator_GWRO_OutWP_FRotator_OutWR(
-    CalculateWristLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_bRightHanded_MountedOn_GloveWristPositionOffset_FRotatorGloveWristRotationOffset_OutWristPosition_FRotatorOutWristRotation(
         const FVector& ReferencePosition, const FRotator& ReferenceRotation,
-        ESGPositionalTrackingHardware TrackingHardware,
+        ESGPositionalTrackingHardware TrackingHardware, bool bRightHanded, ESGFinger MountedOn,
-        bool bRightHanded, ESGFinger MountedOn,
+        const FVector& GloveWristPositionOffset, const FRotator& GloveWristRotationOffset,
-        const FVector& GloveWristPositionOffset,
-        const FRotator& GloveWristRotationOffset,
         FVector& OutWristPosition, FRotator& OutWristRotation);
 
     UFUNCTION(BlueprintPure, Category="SenseGlove | Core | SG | Sense Glove", meta=(WorldContext="WorldContextObject"))
@@ -174,132 +162,123 @@ public:
                               const USGSenseGlove* SenseGlove, USGSenseGloveSensorData*& OutSensorData);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Imu Rotation", Category="SenseGlove | Core | SG | Sense Glove")
-    static bool GetImuRotation_FQuatOutImu(UPARAM(ref) USGSenseGlove* SenseGlove, FQuat& OutImu);
+    static bool GetImuRotation_FQuat_OutI(UPARAM(ref) USGSenseGlove* SenseGlove, FQuat& OutImu);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Imu Rotation", Category="SenseGlove | Core | SG | Sense Glove")
-    static bool GetImuRotation_FRotatorOutImu(UPARAM(ref) USGSenseGlove* SenseGlove, FRotator& OutImu);
+    static bool GetImuRotation_FRotator_OutI(UPARAM(ref) USGSenseGlove* SenseGlove, FRotator& OutImu);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Glove Pose", Category="SenseGlove | Core | SG | Sense Glove",
         meta=(WorldContext="WorldContextObject"))
-    static bool GetGlovePose_OutGlovePose(UObject* WorldContextObject,
+    static bool GetGlovePose_OutGP(UObject* WorldContextObject,
-                                          UPARAM(ref) USGSenseGlove* SenseGlove,
+                                   UPARAM(ref) USGSenseGlove* SenseGlove,
-                                          USGSenseGlovePose*& OutGlovePose);
+                                   USGSenseGlovePose*& OutGlovePose);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Glove Pose", Category="SenseGlove | Core | SG | Sense Glove",
         meta=(WorldContext="WorldContextObject"))
-    static bool GetGlovePose_SensorData_OutGlovePose(UObject* WorldContextObject,
+    static bool GetGlovePose_SD_OutGP(UObject* WorldContextObject,
-                                                     UPARAM(ref) USGSenseGlove* SenseGlove,
+                                      UPARAM(ref) USGSenseGlove* SenseGlove,
-                                                     const USGSenseGloveSensorData* SensorData,
+                                      const USGSenseGloveSensorData* SensorData,
-                                                     USGSenseGlovePose*& OutGlovePose);
+                                      USGSenseGlovePose*& OutGlovePose);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Hand Pose", Category="SenseGlove | Core | SG | Sense Glove",
         meta=(WorldContext="WorldContextObject"))
-    static bool GetHandPose_HandModel_Profile_OutHandPose(UObject* WorldContextObject,
+    static bool GetHandPose_HM_P_OutHP(UObject* WorldContextObject,
-                                                          UPARAM(ref) USGSenseGlove* SenseGlove,
+                                       UPARAM(ref) USGSenseGlove* SenseGlove,
-                                                          const USGBasicHandModel* HandModel,
+                                       const USGBasicHandModel* HandModel,
-                                                          const USGSenseGloveHandProfile* Profile,
+                                       const USGSenseGloveHandProfile* Profile,
-                                                          USGHandPose*& OutHandPose);
+                                       USGHandPose*& OutHandPose);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Hand Pose", Category="SenseGlove | Core | SG | Sense Glove",
         meta=(WorldContext="WorldContextObject"))
-    static bool GetHandPose_HandGeometry_HandProfile_OutHandPose(UObject* WorldContextObject,
+    static bool GetHandPose_HG_HP_OutHP(UObject* WorldContextObject,
-                                                                 UPARAM(ref) USGSenseGlove* SenseGlove,
+                                        UPARAM(ref) USGSenseGlove* SenseGlove,
-                                                                 const USGBasicHandModel* HandGeometry,
+                                        const USGBasicHandModel* HandGeometry,
-                                                                 const USGHandProfile* HandProfile,
+                                        const USGHandProfile* HandProfile,
-                                                                 USGHandPose*& OutHandPose);
+                                        USGHandPose*& OutHandPose);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Hand Pose", Category="SenseGlove | Core | SG | Sense Glove",
         meta=(WorldContext="WorldContextObject"))
-    static bool GetHandPose_HandProfile_OutHandPose(UObject* WorldContextObject,
+    static bool GetHandPose_HP_OutHP(UObject* WorldContextObject,
-                                                    UPARAM(ref) USGSenseGlove* SenseGlove,
+                                     UPARAM(ref) USGSenseGlove* SenseGlove,
-                                                    const USGHandProfile* HandProfile,
+                                     const USGHandProfile* HandProfile,
-                                                    USGHandPose*& OutHandPose);
+                                     USGHandPose*& OutHandPose);
 
     UFUNCTION(BlueprintCallable, DisplayName="Send Haptics", Category="SenseGlove | Core | SG | Sense Glove")
-    static void SendHaptics_ForceFeedbackCommand(UPARAM(ref) USGSenseGlove* SenseGlove,
+    static void SendHaptics_FFC(UPARAM(ref) USGSenseGlove* SenseGlove,
-                                                 const USGForceFeedbackCommand* ForceFeedbackCommand);
+                                const USGForceFeedbackCommand* ForceFeedbackCommand);
 
     UFUNCTION(BlueprintCallable, DisplayName="Send Haptics", Category="SenseGlove | Core | SG | Sense Glove")
-    static void SendHaptics_BuzzCommand(UPARAM(ref) USGSenseGlove* SenseGlove,
+    static void SendHaptics_BC(UPARAM(ref) USGSenseGlove* SenseGlove, const USGBuzzCommand* BuzzCommand);
-                                        const USGBuzzCommand* BuzzCommand);
 
     UFUNCTION(BlueprintCallable, DisplayName="Send Haptics", Category="SenseGlove | Core | SG | Sense Glove")
-    static void SendHaptics_ForceFeedbackCommand_BuzzCommand_ThumperCommand(
+    static void SendHaptics_FFC_BC_TC(
         UPARAM(ref) USGSenseGlove* SenseGlove,
         const USGForceFeedbackCommand* ForceFeedbackCommand,
         const USGBuzzCommand* BuzzCommand,
         const USGThumperCommand* ThumperCommand);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Calibration Values", Category="SenseGlove | Core | SG | Sense Glove")
-    static bool GetCalibrationValues_OutValues(UPARAM(ref) USGSenseGlove* SenseGlove,
+    static bool GetCalibrationValues_OutV(UPARAM(ref) USGSenseGlove* SenseGlove, TArray<FVector>& OutValues);
-                                               TArray<FVector>& OutValues);
 
     UFUNCTION(BlueprintCallable, Category="SenseGlove | Core | SG | Sense Glove")
     static void ResetCalibrationRange(UPARAM(ref) USGSenseGlove* SenseGlove);
 
     UFUNCTION(BlueprintPure, DisplayName="Apply Calibration", Category="SenseGlove | Core | SG | Sense Glove",
         meta=(WorldContext="WorldContextObject"))
-    static void ApplyCalibration_HandProfile(UObject* WorldContextObject,
+    static void ApplyCalibration_USGHandProfile_OutP(UObject* WorldContextObject,
-                                             const USGSenseGlove* SenseGlove,
+                                                     const USGSenseGlove* SenseGlove,
-                                             USGHandProfile*& OutProfile);
+                                                     USGHandProfile*& OutProfile);
 
     UFUNCTION(BlueprintPure, DisplayName="Apply Calibration", Category="SenseGlove | Core | SG | Sense Glove",
         meta=(WorldContext="WorldContextObject"))
-    static void ApplyCalibration_SenseGloveHandProfile(UObject* WorldContextObject,
+    static void ApplyCalibration_USGSenseGloveHandProfile_OutP(UObject* WorldContextObject,
-                                                       const USGSenseGlove* SenseGlove,
+                                                               const USGSenseGlove* SenseGlove,
-                                                       USGSenseGloveHandProfile*& OutProfile);
+                                                               USGSenseGloveHandProfile*& OutProfile);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Glove Location", Category="SenseGlove | Core | SG | Sense Glove")
-    static void
+    static void GetGloveLocation_RP_FQuat_RR_TH_OutGP_FQuat_OutGR(
-    GetGloveLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_OutGlovePosition_FQuatOutGloveRotation(
         const USGSenseGlove* SenseGlove,
         const FVector& ReferencePosition, const FQuat& ReferenceRotation,
         ESGPositionalTrackingHardware TrackingHardware,
         FVector& OutGlovePosition, FQuat& OutGloveRotation);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Glove Location", Category="SenseGlove | Core | SG | Sense Glove")
-    static void
+    static void GetGloveLocation_RP_FRotator_RR_TH_OutGP_FRotator_OutGR(
-    GetGloveLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_OutGlovePosition_FRotatorOutGloveRotation(
         const USGSenseGlove* SenseGlove,
         const FVector& ReferencePosition, const FRotator& ReferenceRotation,
         ESGPositionalTrackingHardware TrackingHardware,
         FVector& OutGlovePosition, FRotator& OutGloveRotation);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Glove Location", Category="SenseGlove | Core | SG | Sense Glove")
-    static void
+    static void GetGloveLocation_RP_FQuat_RR_TH_MO_OutGP_FQuat_OutGR(
-    GetGloveLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_MountedOn_OutGlovePosition_FQuatOutGloveRotation(
         const USGSenseGlove* SenseGlove,
         const FVector& ReferencePosition, const FQuat& ReferenceRotation,
         ESGPositionalTrackingHardware TrackingHardware, ESGFinger MountedOn,
         FVector& OutGlovePosition, FQuat& OutGloveRotation);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Glove Location", Category="SenseGlove | Core | SG | Sense Glove")
-    static void
+    static void GetGloveLocation_RP_FRotator_RR_TH_MO_OutGP_FRotator_OutGR(
-    GetGloveLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_MountedOn_OutGlovePosition_FRotatorOutGloveRotation(
         const USGSenseGlove* SenseGlove,
         const FVector& ReferencePosition, const FRotator& ReferenceRotation,
         ESGPositionalTrackingHardware TrackingHardware, ESGFinger MountedOn,
         FVector& OutGlovePosition, FRotator& OutGloveRotation);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Wrist Location", Category="SenseGlove | Core | SG | Sense Glove")
-    static void
+    static void GetWristLocation_RP_FQuat_RR_TH_OutWP_FQuat_OutWR(
-    GetWristLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_OutWristPosition_FQuatOutWristRotation(
         const USGSenseGlove* SenseGlove,
         const FVector& ReferencePosition, const FQuat& ReferenceRotation,
         ESGPositionalTrackingHardware TrackingHardware,
         FVector& OutWristPosition, FQuat& OutWristRotation);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Wrist Location", Category="SenseGlove | Core | SG | Sense Glove")
-    static void
+    static void GetWristLocation_RP_FRotator_RR_TH_OutWP_FRotator_OutWR(
-    GetWristLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_OutWristPosition_FRotatorOutWristRotation(
         const USGSenseGlove* SenseGlove,
         const FVector& ReferencePosition, const FRotator& ReferenceRotation,
         ESGPositionalTrackingHardware TrackingHardware,
         FVector& OutWristPosition, FRotator& OutWristRotation);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Wrist Location", Category="SenseGlove | Core | SG | Sense Glove")
-    static void
+    static void GetWristLocation_RP_FQuat_RR_TH_GWPO_FQuat_GWRO_OutWP_FQuat_OutWR(
-    GetWristLocation_ReferencePosition_FQuatReferenceRotation_TrackingHardware_GloveWristPositionOffset_FQuatGloveWristRotationOffset_OutWristPosition_FQuatOutWristRotation(
         const USGSenseGlove* SenseGlove,
         const FVector& ReferencePosition, const FQuat& ReferenceRotation,
         ESGPositionalTrackingHardware TrackingHardware,
@@ -308,8 +287,7 @@ public:
         FVector& OutWristPosition, FQuat& OutWristRotation);
 
     UFUNCTION(BlueprintPure, DisplayName="Get Wrist Location", Category="SenseGlove | Core | SG | Sense Glove")
-    static void
+    static void GetWristLocation_RP_FRotator_RR_TH_GWPO_FRotator_GWRO_OutWP_FRotator_OutWR(
-    GetWristLocation_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_GloveWristPositionOffset_FRotatorGloveWristRotationOffset_OutWristPosition_FRotatorOutWristRotation(
         const USGSenseGlove* SenseGlove,
         const FVector& ReferencePosition, const FRotator& ReferenceRotation,
         ESGPositionalTrackingHardware TrackingHardware,

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGSenseGlovePoseKismetLibrary.h

@@ -58,8 +58,7 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Sense Glove Pose",
         Category="SenseGlove | Core | SG | Sense Glove Pose", meta=(WorldContext="WorldContextObject"))
-    static USGSenseGlovePose*
+    static USGSenseGlovePose* MakeSenseGlovePose_bRH_JP_TArrayFSGQuatArray_JR_GA(
-    MakeSenseGlovePose_bRightHanded_JointPositions_TArrayFSGQuatArrayJointRotations_GloveAngles(
         UObject* WorldContextObject, bool bRightHanded,
         const TArray<FSGVectorArray>& JointPositions,
         const TArray<FSGQuatArray>& JointRotations,
@@ -67,8 +66,7 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Sense Glove Pose",
         Category="SenseGlove | Core | SG | Sense Glove Pose", meta=(WorldContext="WorldContextObject"))
-    static USGSenseGlovePose*
+    static USGSenseGlovePose* MakeSenseGlovePose_bRH_JP_TArrayFSGRotatorArray_JR_GA(
-    MakeSenseGlovePose_bRightHanded_JointPositions_TArrayFSGRotatorArrayJointRotations_GloveAngles(
         UObject* WorldContextObject, bool bRightHanded,
         const TArray<FSGVectorArray>& JointPositions,
         const TArray<FSGRotatorArray>& JointRotations,

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGSenseGloveSensorDataKismetLibrary.h

@@ -56,15 +56,15 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Sense Glove Sensor Data",
         Category="SenseGlove | Core | SG | Sense Glove Sensor Data", meta=(WorldContext="WorldContextObject"))
-    static USGSenseGloveSensorData* MakeSenseGloveSensorData_SensorAngles_FQuatImuRotation_ParsedValues_bImuParsed(
+    static USGSenseGloveSensorData* MakeSenseGloveSensorData_SA_FQuatImuRotation_PV_bIP(
-        UObject* WorldContextObject, const TArray<FSGFloatArray>& SensorAngles,
+        UObject* WorldContextObject,
-        const FQuat& ImuRotation, int32 ParsedValues, bool bImuParsed);
+        const TArray<FSGFloatArray>& SensorAngles, const FQuat& ImuRotation, int32 ParsedValues, bool bImuParsed);
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Sense Glove Sensor Data",
         Category="SenseGlove | Core | SG | Sense Glove Sensor Data", meta=(WorldContext="WorldContextObject"))
-    static USGSenseGloveSensorData* MakeSenseGloveSensorData_SensorAngles_FRotatorImuRotation_ParsedValues_bImuParsed(
+    static USGSenseGloveSensorData* MakeSenseGloveSensorData_SA_FRotatorImuRotation_PV_bIP(
-        UObject* WorldContextObject, const TArray<FSGFloatArray>& SensorAngles,
+        UObject* WorldContextObject,
-        const FRotator& ImuRotation, int32 ParsedValues, bool bImuParsed);
+        const TArray<FSGFloatArray>& SensorAngles, const FRotator& ImuRotation, int32 ParsedValues, bool bImuParsed);
 
     UFUNCTION(BlueprintCallable, Category="SenseGlove | Core | SG | Sense Glove Sensor Data",
         meta=(WorldContext="WorldContextObject"))
@@ -98,7 +98,7 @@ public:
 
     UFUNCTION(BlueprintPure, DisplayName="Get Sensor Angles",
         Category="SenseGlove | Core | SG | Sense Glove Sensor Data")
-    static TArray<float> GetSensorAngles_Finger(const USGSenseGloveSensorData* SenseGloveSensorData, ESGFinger Finger);
+    static TArray<float> GetSensorAngles_F(const USGSenseGloveSensorData* SenseGloveSensorData, ESGFinger Finger);
 
     UFUNCTION(BlueprintPure, Category="SenseGlove | Core | SG | Sense Glove Sensor Data")
     static TArray<float> GetAngleSequence(const USGSenseGloveSensorData* SenseGloveSensorData);

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGSenseGloveVarsKismetLibrary.h

@@ -90,14 +90,13 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="GenerateGloveModel", Category="SenseGlove | Core | SG | Sense Glove Vars",
         meta=(WorldContext="WorldContextObject"))
-    static USGSenseGloveInfo* GenerateGloveModel_HardwareVersion_FirmwareVersion_SubFirmwareVersion_bRightHanded(
+    static USGSenseGloveInfo* GenerateGloveModel_HV_FV_SFV_bRH(
         UObject* WorldContextObject,
         const FString& HardwareVersion, int32 FirmwareVersion, int32 SubFirmwareVersion, bool bRightHanded);
 
     UFUNCTION(BlueprintCallable, DisplayName="GenerateGloveModel", Category="SenseGlove | Core | SG | Sense Glove Vars",
         meta=(WorldContext="WorldContextObject"))
-    static USGSenseGloveInfo*
+    static USGSenseGloveInfo* GenerateGloveModel_HV_FV_SFV_bRH_CI(
-    GenerateGloveModel_HardwareVersion_FirmwareVersion_SubFirmwareVersion_bRightHanded_CustomId(
         UObject* WorldContextObject,
         const FString& HardwareVersion, int32 FirmwareVersion, int32 SubFirmwareVersion, bool bRightHanded,
         const FString& CustomId);

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGSensorRangeKismetLibrary.h

@@ -53,7 +53,7 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Sensor Range",
         Category="SenseGlove | Core | Calibration | Sensor Range", meta=(WorldContext="WorldContextObject"))
-    static USGSensorRange* MakeSensorRange_MinValues_MaxValues(
+    static USGSensorRange* MakeSensorRange_MV_MV(
         UObject* WorldContextObject, const TArray<FVector>& MinValues, const TArray<FVector>& MaxValues);
 
     UFUNCTION(BlueprintCallable, Category="SenseGlove | Core | Calibration | Sensor Range",

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGThumperCommandKismetLibrary.h

@@ -53,7 +53,7 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Thumper Command",
         Category="SenseGlove | Core | Haptics | Thumper Command", meta=(WorldContext="WorldContextObject"))
-    static USGThumperCommand* MakeThumperCommand_Magnitude(UObject* WorldContextObject, int32 Magnitude);
+    static USGThumperCommand* MakeThumperCommand_M(UObject* WorldContextObject, int32 Magnitude);
 
     UFUNCTION(BlueprintCallable, Category="SenseGlove | Core | Haptics | Thumper Command",
         meta=(WorldContext="WorldContextObject"))

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGTimedBuzzCommandKismetLibrary.h

@@ -55,13 +55,13 @@ public:
 
     UFUNCTION(BlueprintPure, DisplayName="Make Timed Buzz Command",
         Category="SenseGlove | Core | Haptics | Timed Buzz Command", meta=(WorldContext="WorldContextObject"))
-    static USGTimedBuzzCommand* MakeTimedBuzzCommand_Finger_Magnitude_DurationSeconds_StartTimeSeconds(
+    static USGTimedBuzzCommand* MakeTimedBuzzCommand_F_M_DS_STS(
         UObject* WorldContextObject,
         ESGFinger Finger, int32 Magnitude, float DurationSeconds, float StartTimeSeconds = 0.0f);
 
     UFUNCTION(BlueprintPure, DisplayName="Make Timed Buzz Command",
         Category="SenseGlove | Core | Haptics | Timed Buzz Command", meta=(WorldContext="WorldContextObject"))
-    static USGTimedBuzzCommand* MakeTimedBuzzCommand_BaseCommand_DurationSeconds_StartTimeSeconds(
+    static USGTimedBuzzCommand* MakeTimedBuzzCommand_BC_DS_STS(
         UObject* WorldContextObject,
         const USGBuzzCommand* BaseCommand, float DurationSeconds, float StartTimeSeconds = 0.0f);
 

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGTimedThumpCommandKismetLibrary.h

@@ -54,12 +54,12 @@ public:
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Timed Thump Command",
         Category="SenseGlove | Core | Haptics | Timed Thump Command", meta=(WorldContext="WorldContextObject"))
-    static USGTimedThumpCommand* MakeTimedThumpCommand_Magnitude_DurationSeconds_StartTimeSeconds(
+    static USGTimedThumpCommand* MakeTimedThumpCommand_M_DS_STS(
         UObject* WorldContextObject, int32 Magnitude, float DurationSeconds, float StartTimeSeconds = 0.0f);
 
     UFUNCTION(BlueprintCallable, DisplayName="Make Timed Thump Command",
         Category="SenseGlove | Core | Haptics | Timed Thump Command", meta=(WorldContext="WorldContextObject"))
-    static USGTimedThumpCommand* MakeTimedThumpCommand_BaseCommand_DurationSeconds_StartTimeSeconds(
+    static USGTimedThumpCommand* MakeTimedThumpCommand_BC_DS_STS(
         UObject* WorldContextObject,
         const USGThumperCommand* BaseCommand, float DurationSeconds, float StartTimeSeconds = 0.0f);
 

Source/SenseGloveCoreKismet/Public/SGCoreKismet/SGTrackingKismetLibrary.h

@@ -52,15 +52,13 @@ class SENSEGLOVECOREKISMET_API USGTrackingKismetLibrary final : public USGBluepr
 
 public:
     UFUNCTION(BlueprintCallable, DisplayName="Calculate Location", Category="SenseGlove | Core | Tracking")
-    static void
+    static void CalculateLocation_TP_FQuat_TR_PO_FQuat_RO_OutNP_FQuat_OutNR(
-    CalculateLocation_TrackedPosition_FQuatTrackedRotation_PositionOffset_FQuatRotationOffset_OutNewPosition_FQuatOutNewRotation(
         const FVector& TrackedPosition, const FQuat& TrackedRotation,
         const FVector& PositionOffset, const FQuat& RotationOffset,
         FVector& OutNewPosition, FQuat& OutNewRotation);
 
     UFUNCTION(BlueprintCallable, DisplayName="Calculate Location", Category="SenseGlove | Core | Tracking")
-    static void
+    static void CalculateLocation_TP_FRotator_TR_PO_FRotator_RO_OutNP_FRotator_OutNR(
-    CalculateLocation_TrackedPosition_FRotatorTrackedRotation_PositionOffset_FRotatorRotationOffset_OutNewPosition_FRotatorOutNewRotation(
         const FVector& TrackedPosition, const FRotator& TrackedRotation,
         const FVector& PositionOffset, const FRotator& RotationOffset,
         FVector& OutNewPosition, FRotator& OutNewRotation);
@@ -88,24 +86,22 @@ public:
     static FRotator GetSenseGloveWristRotationOffset_FRotator();
 
     UFUNCTION(BlueprintCallable, DisplayName="Get SenseGlove Mount Offset", Category="SenseGlove | Core | Tracking")
-    static void GetSenseGloveMountOffset_bRightHanded_ToFinger_OutIPosition_FQuatOutIRotation(
+    static void GetSenseGloveMountOffset_bRH_TF_OutIP_FQuat_OutIR(
-        bool bRightHanded, ESGFinger ToFinger,
+        bool bRightHanded, ESGFinger ToFinger, FVector& OutIPosition, FQuat& OutIRotation);
-        FVector& OutIPosition, FQuat& OutIRotation);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get SenseGlove Mount Offset", Category="SenseGlove | Core | Tracking")
-    static void GetSenseGloveMountOffset_bRightHanded_ToFinger_OutIPosition_FRotatorOutIRotation(
+    static void GetSenseGloveMountOffset_bRH_TF_OutIP_FRotator_OutIR(
-        bool bRightHanded, ESGFinger ToFinger,
+        bool bRightHanded, ESGFinger ToFinger, FVector& OutIPosition, FRotator& OutIRotation);
-        FVector& OutIPosition, FRotator& OutIRotation);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get SenseGlove Tracker Mouunt Offset",
         Category="SenseGlove | Core | Tracking")
-    static void GetSenseGloveTrackerMountOffset_Hardware_bRightHanded_OutPositionOffset_FQuatOutRotationOffset(
+    static void GetSenseGloveTrackerMountOffset_H_bRH_OutPO_FQuat_OutRO(
         ESGPositionalTrackingHardware Hardware, bool bRightHanded,
         FVector& OutPositionOffset, FQuat& OutRotationOffset);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get SenseGlove Tracker Mouunt Offset",
         Category="SenseGlove | Core | Tracking")
-    static void GetSenseGloveTrackerMountOffset_Hardware_bRightHanded_OutPositionOffset_FRotatorOutRotationOffset(
+    static void GetSenseGloveTrackerMountOffset_H_bRH_OutPO_FRotator_OutRO(
         ESGPositionalTrackingHardware Hardware, bool bRightHanded,
         FVector& OutPositionOffset, FRotator& OutRotationOffset);
 
@@ -143,11 +139,11 @@ public:
     static FRotator GetNovaToWristRotationOffset_FRotator();
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Nova Glove Wrist Offset", Category="SenseGlove | Core | Tracking")
-    static void GetNovaGloveWristOffset_bRightHanded_OutPositionOffset_FQuatOutRotationOffset(
+    static void GetNovaGloveWristOffset_bRH_OutPO_FQuat_OutRO(
         bool bRightHanded, FVector& OutPositionOffset, FQuat& OutRotationOffset);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Nova Glove Wrist Offset", Category="SenseGlove | Core | Tracking")
-    static void GetNovaGloveWristOffset_bRightHanded_OutPositionOffset_FRotatorOutRotationOffset(
+    static void GetNovaGloveWristOffset_bRH_OutPO_FRotator_OutRO(
         bool bRightHanded, FVector& OutPositionOffset, FRotator& OutRotationOffset);
 
     UFUNCTION(BlueprintCallable, Category="SenseGlove | Core | Tracking")
@@ -214,12 +210,12 @@ public:
     static FRotator GetLeftNovaPico2ToAttachRotation_FRotator();
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Nova Glove Tracker Offset", Category="SenseGlove | Core | Tracking")
-    static void GetNovaGloveTrackerOffset_Hardware_bRightHanded_OutPositionOffset_FQuatOutRotationOffset(
+    static void GetNovaGloveTrackerOffset_H_bRH_OutPO_FQuat_OutRO(
         ESGPositionalTrackingHardware Hardware, bool bRightHanded,
         FVector& OutPositionOffset, FQuat& OutRotationOffset);
 
     UFUNCTION(BlueprintCallable, DisplayName="Get Nova Glove Tracker Offset", Category="SenseGlove | Core | Tracking")
-    static void GetNovaGloveTrackerOffset_Hardware_bRightHanded_OutPositionOffset_FRotatorOutRotationOffset(
+    static void GetNovaGloveTrackerOffset_H_bRH_OutPO_FRotator_OutRO(
         ESGPositionalTrackingHardware Hardware, bool bRightHanded,
         FVector& OutPositionOffset, FRotator& OutRotationOffset);