bump the plugin version to v1.2.1

CHANGELOG.md

@@ -5,6 +5,46 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [v1.2.1] - 2023-03-30
+
+### Fixed
+
+- Fix RunUAT build issues with Android.
+
+## [v1.2.0] - 2023-03-28
+
+This release breaks ABI/API compatibility with the previous versions.
+
+### Added
+
+- Android / Oculus on-device glove calibration.
+- Introduced the animated Virtual Hand Model (as a set of virtual hand and wrist tracker components and an actor) with in-editor animation availability.
+- Introduced SGPawn, SGPlayerController, SGGameModeBase, etc classes.
+- Added an internal SenseGloveCoreTypes module in order to share common SenseGloveCore types between various modules.
+- Segregated Android binaries for NDK r21e (UE 4.27 and 5.0) and r25b (UE 5.1, 5.2).
+- Fully functional and stable Linux development support.
+- Fully functional and stable Unreal Engine 5.2 preview support has been added.
+- Added a Plugin's settings manager and two new modules SenseGloveSettings and SenseGloveSettingsKismet.
+
+### Changed
+
+- SenseGlove libraries have been updated to the Linux-aware version: v2.5.0-8069342.
+- API has changed to use degrees instead of radians.
+- SGCoordinates utility class name has been changed to SGAngles and now the plugin API uses degrees in contrast of SenseGlove libraries by default.
+- Migrate common nested array types into the SenseGloveTypes module from the SenseGloveCore module.
+
+### Removed
+
+- Removed a few thousands lines of archaic pre-public-release dead code.
+- Dropped Android NDK r21b binaries used by the older engine versions.
+- Purged the dead code for dropped engine versions by v1.1.1 (4.22, 4.23, 4.24, 4.25, and 4.26) that carried over to the current version.
+- Removed redundant SGConnectImpl/SGPlatform.
+- Removed redundant SGTypes/SGConnectTypes.
+
+### Known Issues
+
+- Wrist Tracker's offsets are a bit off (e.g. on Quest 2), scheduled to be fixed in the next patch release.
+
 ## [1.1.1] - 2023-02-07
 
 ### Added
@@ -14,8 +54,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
-- Fix various Android build issues
-- Some minor fixes and improvements
+- Fix various Android build issues.
+- Some minor fixes and improvements.
 
 ### Changed
 

README.md

@@ -6,16 +6,17 @@ This repository relies on Git LFS for storing binary blobs (e.g. third-party lib
 
 ## Platform Support Matrix
 
-|      | **Windows (MSVC 2017)** | **Windows (MSVC 2019)** | **Windows (MSVC 2022)** | **Linux (Native Toolchain)** | **macOS** | **Oculus Mobile (Android NDK r21b)** |
-|------|:-----------------------:|:-----------------------:|:-----------------------:|:----------------------------:|:---------:|:------------------------------------:|
-| 4.22 |         ⚠️ v1.0.x        |         ⚠️ v1.0.x        |            ❌            |           ⚠️ v1.0.x           |     ❌     |                   ❌                  |
-| 4.23 |         ⚠️ v1.0.x        |         ⚠️ v1.0.x        |            ❌            |           ⚠️ v1.0.x           |     ❌     |                   ❌                  |
-| 4.24 |         ⚠️ v1.0.x        |         ⚠️ v1.0.x        |            ❌            |           ⚠️ v1.0.x           |     ❌     |                   ❌                  |
-| 4.25 |         ⚠️ v1.0.x        |         ⚠️ v1.0.x        |            ❌            |           ⚠️ v1.0.x           |     ❌     |                   ❌                  |
-| 4.26 |         ⚠️ v1.0.x        |         ⚠️ v1.0.x        |            ❌            |           ⚠️ v1.0.x           |     ❌     |                   ❌                  |
-| 4.27 |         ✅ v1.1.x        |         ✅ v1.1.x        |         ✅ v1.1.x        |           ✅ v1.1.x           |     ❌     |               ✅ v1.1.x               |
-| 5.0  |         ✅ v1.1.x        |         ✅ v1.1.x        |         ✅ v1.1.x        |           ✅ v1.1.x           |     ❌     |               ✅ v1.1.x               |
-| 5.1  |         ✅ v1.1.x        |         ✅ v1.1.x        |         ✅ v1.1.x        |           ✅ v1.1.x           |     ❌     |               ✅ v1.1.x               |
+|          | **Windows (MSVC 2017)** | **Windows (MSVC 2019)** | **Windows (MSVC 2022)** | **Linux (Native Toolchain)** | **macOS** | **Oculus Mobile (Android NDK)** |
+|:--------:|:-----------------------:|:-----------------------:|:-----------------------:|:----------------------------:|:---------:|:-------------------------------:|
+| **4.22** |         ⚠️ v1.0.x        |         ⚠️ v1.0.x        |            ❌            |           ⚠️ v1.0.x           |     ❌     |                ❌                |
+| **4.23** |         ⚠️ v1.0.x        |         ⚠️ v1.0.x        |            ❌            |           ⚠️ v1.0.x           |     ❌     |                ❌                |
+| **4.24** |         ⚠️ v1.0.x        |         ⚠️ v1.0.x        |            ❌            |           ⚠️ v1.0.x           |     ❌     |                ❌                |
+| **4.25** |         ⚠️ v1.0.x        |         ⚠️ v1.0.x        |            ❌            |           ⚠️ v1.0.x           |     ❌     |                ❌                |
+| **4.26** |         ⚠️ v1.0.x        |         ⚠️ v1.0.x        |            ❌            |           ⚠️ v1.0.x           |     ❌     |                ❌                |
+| **4.27** |         ✅ v1.2.x        |         ✅ v1.2.x        |         ✅ v1.2.x        |           ✅ v1.2.x           |     ❌     |         ✅ v1.2.x (r21e)         |
+|  **5.0** |         ✅ v1.2.x        |         ✅ v1.2.x        |         ✅ v1.2.x        |           ✅ v1.2.x           |     ❌     |         ✅ v1.2.x (r21e)         |
+|  **5.1** |         ✅ v1.2.x        |         ✅ v1.2.x        |         ✅ v1.2.x        |           ✅ v1.2.x           |     ❌     |         ✅ v1.2.x (r25b)         |
+|  **5.2** |         ✅ v1.2.x        |         ✅ v1.2.x        |         ✅ v1.2.x        |           ✅ v1.2.x           |     ❌     |         ✅ v1.2.x (r25b)         |
 
 * <code>✅</code> Supported
 * <code>⚠️</code> Not supported by the latest release and might be lacking features
@@ -25,8 +26,9 @@ This repository relies on Git LFS for storing binary blobs (e.g. third-party lib
 Remarks:
 * Microsoft Visual Studio 2022 is not supported by Unreal Engine 4.22 through 4.26.
 * All third-party libraries on Windows built against Windows SDK 10.0.
-* Oculus support is only provided through the recommended Android NDK r21b by Epic Games.
-* Supporting Unreal Engine 4.22 through 4.24 for Oculus development is a huge challenge due to limited Android NDK support (r14b to r18b); firstly, because of uncomplete C++11 standard library support, and second, as a result of a known bug in Unreal Engine, which falsely detects NDK r18b as unsupported r18c. Thus, only Unreal Engine 4.25+ support is provided for Android/Oculus development. Third, [wjwwood/serial](https://github.com/wjwwood/serial) requires Android NDK API Level 28+ in order to be built successfully, thus some older NDKs such as r14b, which is the recommended NDK by Epic Games for 4.22 to 4.24 cannot build the serial library.
+* Oculus support is only provided through the recommended Android NDK versions by Epic Games.
+* The Unreal Engine 4.27+ support is provided for Android/Oculus development.
+* [wjwwood/serial](https://github.com/wjwwood/serial) requires Android NDK API Level 28+ in order to be built successfully, thus some older NDKs such as r14b.
 * All third-party libraries target Android NDK API Level 29, thus any project relying on the plug-in should be build with the same NDK API Level.
 
 ## Changelog
@@ -62,6 +64,8 @@ Source
         │
         ├── SenseGlove (the UE-specific high-level API)
         │
+        ├── SenseGloveAndroid (the Android-specific module)
+        │
         ├── SenseGloveBuildHacks (uses Exceptions and RTTI, internally used for compiler-specific build hacks)
         │
         ├── SenseGloveConnect (exposes part of the SGConnect low-level API to C++)
@@ -76,19 +80,27 @@ Source
         │
         ├── SenseGloveCoreKismet (SGCoreCpp functionality exposed to Blueprints)
         │
+        ├── SenseGloveCoreTypes (exposes special public types from the SenseGloveCore module in order to be shared by with other modules)
+        │
         ├── SenseGloveEditor (the Editor module)
         │
         ├── SenseGloveInterop (internally used for interoperability between RTTI disabled/enabled modules)
         │
-        ├── SenseGloveKismet(exposes Blueprints-specific functionality from the SenseGlove module)
+        ├── SenseGloveKismet (exposes Blueprints-specific functionality from the SenseGlove module)
         │
         ├── SenseGloveLog (the internal log module)
         │
-        ├── SenseGloveTypes (exposes various enums from the backend libraries)
+        ├── SenseGloveSettings (the plugin's settings manager)
+        │
+        ├── SenseGloveSettingsKismet (exposes Blueprints-specific functionality from the SenseGloveSettings module)
+        │
+        ├── SenseGloveTypes (exposes various enums from the backend libraries and also types from the SenseGlove module)
         │
         ├── SenseGloveUtils (the internal utility module)
         │
         └── ThirdParty (3rd-party dependencies)
+              │
+              ├── android (.jar file Java libraries for Android)
               │
               ├── include (header files)
               │     │
@@ -103,6 +115,62 @@ Source
               │     └── serial
               │
               └── lib (platform-specific pre-built binary dependencies)
+                    │
+                    ├── android
+                    │     │
+                    │     ├── r21e (Android NDK r21e dependencies for UE 4.27 and 5.0)
+                    │     │     │
+                    │     │     │
+                    │     │     ├── arm64 (64-bit Arm variant of Android)
+                    │     │     │     │
+                    │     │     │     ├── debug
+                    │     │     │     │
+                    │     │     │     └── release
+                    │     │     │
+                    │     │     ├── armv7 (32-bit ARM variant of Android)
+                    │     │     │     │
+                    │     │     │     ├── debug
+                    │     │     │     │
+                    │     │     │     └── release
+                    │     │     │
+                    │     │     ├── x64 (64-bit x86-64 variant of Android)
+                    │     │     │     │
+                    │     │     │     ├── debug
+                    │     │     │     │
+                    │     │     │     └── release
+                    │     │     │
+                    │     │     └── x86 (32-bit x86 variant of Android)
+                    │     │           │
+                    │     │           ├── debug
+                    │     │           │
+                    │     │           └── release
+                    │     │
+                    │     └── r25b (Android NDK r21b dependencies for UE 5.1)
+                    │           │
+                    │           │
+                    │           ├── arm64 (64-bit Arm variant of Android)
+                    │           │     │
+                    │           │     ├── debug
+                    │           │     │
+                    │           │     └── release
+                    │           │
+                    │           ├── armv7 (32-bit ARM variant of Android)
+                    │           │     │
+                    │           │     ├── debug
+                    │           │     │
+                    │           │     └── release
+                    │           │
+                    │           ├── x64 (64-bit x86-64 variant of Android)
+                    │           │     │
+                    │           │     ├── debug
+                    │           │     │
+                    │           │     └── release
+                    │           │
+                    │           └── x86 (32-bit x86 variant of Android)
+                    │                 │
+                    │                 ├── debug
+                    │                 │
+                    │                 └── release
                     │
                     ├── linux
                     │     │
@@ -112,19 +180,25 @@ Source
                     │     │     │
                     │     │     └── release
                     │     │
-                    │     └── v20 (UE 5.0 and 5.1 Linux dependencies)
+                    │     ├── v20 (UE 5.0 and 5.1 Linux dependencies)
+                    │     │     │
+                    │     │     ├── debug
+                    │     │     │
+                    │     │     └── release
+                    │     │
+                    │     └── v21 (UE 5.2 Linux dependencies)
                     │           │
                     │           ├── debug
                     │           │
                     │           └── release
                     │
-                    ├── oculus
-                    │     │
-                    │     ├── debug
-                    │     │
-                    │     └── release
-                    │
                     └── win64
+                          │
+                          ├── msvc141 (Microsoft Visual Studio 2017 dependencies)
+                          │     │
+                          │     ├── debug
+                          │     │
+                          │     └── release
                           │
                           ├── msvc142 (Microsoft Visual Studio 2019 dependencies)
                           │     │

SenseGlove.uplugin

@@ -1,7 +1,7 @@
 {
 	"FileVersion": 3,
 	"Version": 1,
-	"VersionName": "1.1.1",
+	"VersionName": "1.2.1",
 	"FriendlyName": "SenseGlove",
 	"Description": "Integrating the SenseGlove haptic controller into Unreal Engine",
 	"Category": "Virtual Reality",
@@ -110,6 +110,16 @@
 				"Win64"
 			]
 		},
+		{
+			"Name": "SenseGloveCoreTypes",
+			"Type": "Runtime",
+			"LoadingPhase": "PreDefault",
+			"WhitelistPlatforms": [
+				"Android",
+				"Linux",
+				"Win64"
+			]
+		},
 		{
 			"Name": "SenseGloveEditor",
 			"Type": "Editor",
@@ -149,6 +159,26 @@
 				"Win64"
 			]
 		},
+		{
+			"Name": "SenseGloveSettings",
+			"Type": "Runtime",
+			"LoadingPhase": "PreDefault",
+			"WhitelistPlatforms": [
+				"Android",
+				"Linux",
+				"Win64"
+			]
+		},
+		{
+			"Name": "SenseGloveSettingsKismet",
+			"Type": "Runtime",
+			"LoadingPhase": "PreDefault",
+			"WhitelistPlatforms": [
+				"Android",
+				"Linux",
+				"Win64"
+			]
+		},
 		{
 			"Name": "SenseGloveTypes",
 			"Type": "Runtime",

Source/SenseGlove/Private/SenseGlove/Animation/SGVirtualHandAnimInstance.cpp

@@ -0,0 +1,46 @@
+/**
+ * @file
+ *
+ * @author  Mamadou Babaei <mamadou@senseglove.com>
+ *
+ * @section LICENSE
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2020 - 2023 SenseGlove
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * @section DESCRIPTION
+ *
+ *
+ */
+
+
+#include "SenseGlove/Animation/SGVirtualHandAnimInstance.h"
+
+USGVirtualHandAnimInstance::USGVirtualHandAnimInstance(const FObjectInitializer& ObjectInitializer)
+    : Super(ObjectInitializer)
+{
+}
+
+FSGVirtualHandAnimInstanceProxy* USGVirtualHandAnimInstance::CreateAnimInstanceProxy()
+{
+    return new FSGVirtualHandAnimInstanceProxy();
+}

Source/SenseGlove/Private/SenseGlove/Animation/SGVirtualHandAnimInstanceProxy.cpp

@@ -0,0 +1,158 @@
+/**
+ * @file
+ *
+ * @author  Mamadou Babaei <mamadou@senseglove.com>
+ *
+ * @section LICENSE
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2020 - 2023 SenseGlove
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * @section DESCRIPTION
+ *
+ *
+ */
+
+
+#include "SenseGlove/Animation/SGVirtualHandAnimInstanceProxy.h"
+
+#include "BoneContainer.h"
+#include "BoneControllers/AnimNode_ModifyBone.h"
+#include "BonePose.h"
+#include "Containers/Array.h"
+#include "Containers/Map.h"
+#include "Containers/UnrealString.h"
+#include "Engine/SkeletalMesh.h"
+#include "Math/Rotator.h"
+#include "Runtime/Launch/Resources/Version.h"
+#include "SGLog/SGLog.h"
+
+#include "SenseGlove/Components/SGVirtualHandComponent.h"
+
+FSGVirtualHandAnimInstanceProxy::FSGVirtualHandAnimInstanceProxy()
+    : FAnimInstanceProxy()
+{
+}
+
+FSGVirtualHandAnimInstanceProxy::FSGVirtualHandAnimInstanceProxy(UAnimInstance* Instance)
+    : FAnimInstanceProxy(Instance)
+{
+}
+
+void FSGVirtualHandAnimInstanceProxy::PreEvaluateAnimation(UAnimInstance* InAnimInstance)
+{
+    FAnimInstanceProxy::PreEvaluateAnimation(InAnimInstance);
+
+    if (!IsValid(InAnimInstance))
+    {
+        return;
+    }
+
+    USGVirtualHandComponent* VirtualHand{Cast<USGVirtualHandComponent>(GetSkelMeshComponent())};
+    if (!IsValid(VirtualHand))
+    {
+        return;
+    }
+
+    BonesRotations.Empty();
+
+    if (!VirtualHand->IsGloveConnected())
+    {
+        return;
+    }
+
+    BonesRotations = VirtualHand->GetFingersBonesRotations();
+}
+
+bool FSGVirtualHandAnimInstanceProxy::Evaluate(FPoseContext& Output)
+{
+    USGVirtualHandComponent* VirtualHand{Cast<USGVirtualHandComponent>(GetSkelMeshComponent())};
+    if (!IsValid(VirtualHand) && !VirtualHand->IsGloveConnected())
+    {
+        return FAnimInstanceProxy::Evaluate(Output);
+    }
+
+    const USkeletalMesh* HandMesh{VirtualHand->
+#if ENGINE_MAJOR_VERSION >= 5 && ENGINE_MINOR_VERSION >= 1
+        GetSkeletalMeshAsset()
+#else   /* ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 1 */
+        SkeletalMesh
+#endif  /* ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 1 */
+    };
+    if (!IsValid(HandMesh))
+    {
+        return FAnimInstanceProxy::Evaluate(Output);
+    }
+
+    const USkeleton* HandSkeleton{HandMesh->GetSkeleton()};
+    if (!IsValid(HandSkeleton))
+    {
+        return FAnimInstanceProxy::Evaluate(Output);
+    }
+
+    FComponentSpacePoseContext PoseContext{Output.AnimInstanceProxy};
+    PoseContext.Pose.InitPose(Output.Pose);
+
+    for (const TTuple<FName, FRotator>& Bone: BonesRotations)
+    {
+        FName BoneName{Bone.Key};
+        FRotator BoneRotation{Bone.Value};
+
+        const int32 BoneIndex = GetRequiredBones().GetPoseBoneIndexForBoneName(BoneName);
+        if (BoneIndex == INDEX_NONE)
+        {
+            SGLOG_WARNING(FString::Printf(TEXT("Could not find a bone index for '%s' finger bone!"),
+                *BoneName.ToString()));
+            continue;
+        }
+
+        FBoneReference BoneReference;
+        BoneReference.BoneName = MoveTemp(BoneName);
+        BoneReference.BoneIndex = BoneIndex;
+        BoneReference.bUseSkeletonIndex = true;
+
+        FAnimNode_ModifyBone BoneController;
+        BoneController.BoneToModify = MoveTemp(BoneReference);
+        BoneController.Rotation = MoveTemp(BoneRotation);
+        BoneController.RotationMode = EBoneModificationMode::BMM_Replace;
+        BoneController.RotationSpace = EBoneControlSpace::BCS_ParentBoneSpace;
+        BoneController.ScaleMode = EBoneModificationMode::BMM_Ignore;
+        BoneController.TranslationMode = EBoneModificationMode::BMM_Ignore;
+
+        if (BoneController.IsValidToEvaluate(HandSkeleton, Output.Pose.GetBoneContainer()))
+        {
+            TArray<FBoneTransform> BoneTransforms;
+            BoneController.EvaluateSkeletalControl_AnyThread(PoseContext, BoneTransforms);
+
+            const TArray<FBoneTransform>::SizeType BoneTransformsNum = BoneTransforms.Num();
+            if (BoneTransformsNum > 0)
+            {
+                PoseContext.Pose.LocalBlendCSBoneTransforms(BoneTransforms, 1.0f);
+                PoseContext.Pose.ConvertComponentPosesToLocalPoses(PoseContext.Pose, Output.Pose);
+
+                VirtualHand->MarkRenderStateDirty();
+            }
+        }
+    }
+
+    return true;
+}

Source/SenseGlove/Private/SenseGlove/Components/SGVirtualHandComponent.cpp

@@ -0,0 +1,686 @@
+/**
+ * @file
+ *
+ * @author  Mamadou Babaei <mamadou@senseglove.com>
+ *
+ * @section LICENSE
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2020 - 2023 SenseGlove
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * @section DESCRIPTION
+ *
+ *
+ */
+
+
+#include "SenseGlove/Components/SGVirtualHandComponent.h"
+
+#include "Animation/Skeleton.h"
+#include "Components/SkeletalMeshComponent.h"
+#include "Engine/SkeletalMesh.h"
+#include "Kismet/GameplayStatics.h"
+#include "Runtime/Launch/Resources/Version.h"
+#include "UObject/ConstructorHelpers.h"
+
+#include "SenseGlove/Animation/SGVirtualHandAnimInstance.h"
+#include "SGConnect/SGConnect.h"
+#include "SGCore/SGDeviceList.h"
+#include "SGCore/SGHandPose.h"
+#include "SGCore/SGHapticGlove.h"
+#include "SGCore/SGHapticGloveHandProfiles.h"
+#include "SGLog/SGLog.h"
+
+struct USGVirtualHandComponent::FImpl
+{
+    /************************
+     * Static methods
+     ************************/
+
+    FORCEINLINE static const FString& GetDefaultLeftHandMeshPath()
+    {
+        static const FString Path{TEXT("SkeletalMesh'/SenseGlove/Meshes/"
+            "SK_SenseGlove_VirtualHand_Left.SK_SenseGlove_VirtualHand_Left'")};
+        return Path;
+    }
+
+    FORCEINLINE static const FString& GetDefaultLeftHandMeshPathOnly()
+    {
+        static const FString Path{TEXT("/SenseGlove/Meshes/"
+            "SK_SenseGlove_VirtualHand_Left.SK_SenseGlove_VirtualHand_Left")};
+        return Path;
+    }
+
+    FORCEINLINE static const FString& GetDefaultRightHandMeshPath()
+    {
+        static const FString Path{TEXT("SkeletalMesh'/SenseGlove/Meshes/"
+            "SK_SenseGlove_VirtualHand_Right.SK_SenseGlove_VirtualHand_Right'")};
+        return Path;
+    }
+
+    FORCEINLINE static const FString& GetDefaultRightHandMeshPathOnly()
+    {
+        static const FString Path{TEXT("/SenseGlove/Meshes/"
+            "SK_SenseGlove_VirtualHand_Right.SK_SenseGlove_VirtualHand_Right")};
+        return Path;
+    }
+
+    /************************
+     * Owner object
+     ************************/
+
+    USGVirtualHandComponent* Owner;
+
+    /************************
+     * Constructor / Destructor
+     ************************/
+
+    explicit FImpl(USGVirtualHandComponent* InOwner);
+    ~FImpl();
+
+    /************************
+     * Default copy constructor & copy assignment operator
+     ************************/
+
+    FImpl(const FImpl& Rhs) = default;
+    FImpl& operator=(const FImpl& Rhs) = default;
+
+    /************************
+     * Methods
+     ************************/
+
+    bool IsEditor() const;
+
+    FString GetDefaultMeshPath() const;
+    bool IsUsingUserMesh() const;
+    USkeletalMesh* LoadDefaultMesh() const;
+    void SetDefaultMesh() const;
+
+    USkeletalMesh* GetMesh() const;
+    USkeleton* GetSkeleton() const;
+    const FReferenceSkeleton& GetRefSkeleton() const;
+
+    bool InitializeBackend() const;
+    bool UninitializeBackend() const;
+    bool CheckGlove() const;
+
+    void SetVisibility(bool bInVisible) const;
+};
+
+const TArray<TArray<FName>>& USGVirtualHandComponent::GetLeftHandFingerBoneNames()
+{
+    static const TArray<TArray<FName>> BoneNames{
+        {FName(TEXT("thumb_01_l")), FName(TEXT("thumb_02_l")), FName(TEXT("thumb_03_l"))},
+        {FName(TEXT("index_01_l")), FName(TEXT("index_02_l")), FName(TEXT("index_03_l"))},
+        {FName(TEXT("middle_01_l")), FName(TEXT("middle_02_l")), FName(TEXT("middle_03_l"))},
+        {FName(TEXT("ring_01_l")), FName(TEXT("ring_02_l")), FName(TEXT("ring_03_l"))},
+        {FName(TEXT("pinky_01_l")), FName(TEXT("pinky_02_l")), FName(TEXT("pinky_03_l"))},
+    };
+    return BoneNames;
+}
+
+const TArray<TArray<FName>>& USGVirtualHandComponent::GetRightHandFingerBoneNames()
+{
+    static const TArray<TArray<FName>> BoneNames{
+        {FName(TEXT("thumb_01_r")), FName(TEXT("thumb_02_r")), FName(TEXT("thumb_03_r"))},
+        {FName(TEXT("index_01_r")), FName(TEXT("index_02_r")), FName(TEXT("index_03_r"))},
+        {FName(TEXT("middle_01_r")), FName(TEXT("middle_02_r")), FName(TEXT("middle_03_r"))},
+        {FName(TEXT("ring_01_r")), FName(TEXT("ring_02_r")), FName(TEXT("ring_03_r"))},
+        {FName(TEXT("pinky_01_r")), FName(TEXT("pinky_02_r")), FName(TEXT("pinky_03_r"))},
+    };
+    return BoneNames;
+}
+
+const FName& USGVirtualHandComponent::GetLeftHandFingerBoneName(const int32 Finger, const int32 Joint)
+{
+    const TArray<TArray<FName>>& BoneNames{GetLeftHandFingerBoneNames()};
+
+    ensureAlwaysMsgf(Finger < BoneNames.Num(), TEXT("Finger index is out of bound!"));
+    ensureAlwaysMsgf(Joint < BoneNames[Finger].Num(), TEXT("Joint index is out of bound!"));
+
+    const FName& BoneName{BoneNames[Finger][Joint]};
+    return BoneName;
+}
+
+const FName& USGVirtualHandComponent::GetRightHandFingerBoneName(const int32 Finger, const int32 Joint)
+{
+    const TArray<TArray<FName>>& BoneNames{GetRightHandFingerBoneNames()};
+
+    ensureAlwaysMsgf(Finger < BoneNames.Num(), TEXT("Finger index is out of bound!"));
+    ensureAlwaysMsgf(Joint < BoneNames[Finger].Num(), TEXT("Joint index is out of bound!"));
+
+    const FName& BoneName{BoneNames[Finger][Joint]};
+    return BoneName;
+}
+
+USGVirtualHandComponent::USGVirtualHandComponent(const FObjectInitializer& ObjectInitializer)
+    : Super(ObjectInitializer),
+      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
+{
+    PrimaryComponentTick.bTickEvenWhenPaused = false;
+    PrimaryComponentTick.bCanEverTick = true;
+    PrimaryComponentTick.bStartWithTickEnabled = true;
+    bTickInEditor = true;
+    bNeverNeedsRenderUpdate = false;
+    bAllowConcurrentTick = true;
+    SetUpdateAnimationInEditor(true);
+
+    SetCastShadow(true);
+    SetCastHiddenShadow(false);
+    bCastDynamicShadow = true;
+    SetOnlyOwnerSee(false);
+    SetReceivesDecals(true);
+    SetCanEverAffectNavigation(false);
+    Super::SetCollisionObjectType(ECC_WorldDynamic);
+    Super::SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);
+    Super::SetCollisionResponseToAllChannels(ECR_Overlap);
+    Super::SetCollisionResponseToChannel(ECC_WorldStatic, ECR_Block);
+    Super::SetCollisionResponseToChannel(ECC_WorldDynamic, ECR_Block);
+    Super::SetCollisionResponseToChannel(ECC_Pawn, ECR_Block);
+    Super::SetCollisionResponseToChannel(ECC_Visibility, ECR_Block);
+    Super::SetCollisionResponseToChannel(ECC_PhysicsBody, ECR_Block);
+    Super::SetCollisionResponseToChannel(ECC_Vehicle, ECR_Block);
+    Super::SetCollisionResponseToChannel(ECC_Destructible, ECR_Block);
+
+    Super::SetAnimClass(USGVirtualHandAnimInstance::StaticClass());
+
+    bRight = true;
+    bHiddenInGameIfNoGloveDetected = false;
+
+    Super::SetSkeletalMesh(nullptr, true);
+
+    bBackendInitialized = false;
+    Glove = nullptr;
+}
+
+void USGVirtualHandComponent::SetRight(const bool bInRight)
+{
+    bRight = bInRight;
+
+    if (!Pimpl->IsUsingUserMesh())
+    {
+        Pimpl->SetDefaultMesh();
+    }
+}
+
+void USGVirtualHandComponent::SetAnimClass(UClass* NewClass)
+{
+    ensureAlwaysMsgf(Cast<USGVirtualHandAnimInstance>(NewClass),
+                     TEXT("The AnimInstance class must be a subclass of USGVirtualHandAnimInstance!"));
+
+    Super::SetAnimClass(NewClass);
+}
+
+void USGVirtualHandComponent::PostInitProperties()
+{
+    Super::PostInitProperties();
+
+    if (!Pimpl->IsUsingUserMesh())
+    {
+        Pimpl->SetDefaultMesh();
+    }
+}
+
+#if WITH_EDITOR
+void USGVirtualHandComponent::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
+{
+    Super::PostEditChangeProperty(PropertyChangedEvent);
+
+    const FName PropertyName{
+        PropertyChangedEvent.Property
+        ? PropertyChangedEvent.Property->GetFName()
+        : NAME_None
+    };
+    if (PropertyName == GET_MEMBER_NAME_CHECKED(USGVirtualHandComponent, bRight))
+    {
+        if (!Pimpl->IsUsingUserMesh())
+        {
+            Pimpl->SetDefaultMesh();
+        }
+    }
+}
+#endif  /* WITH_EDITOR */
+
+void USGVirtualHandComponent::InitializeComponent()
+{
+    Super::InitializeComponent();
+
+    if (!Pimpl->IsUsingUserMesh())
+    {
+        Pimpl->SetDefaultMesh();
+    }
+
+    if (Pimpl->InitializeBackend())
+    {
+        (void) Pimpl->CheckGlove();
+    }
+}
+
+void USGVirtualHandComponent::UninitializeComponent()
+{
+    Super::UninitializeComponent();
+
+    (void) Pimpl->UninitializeBackend();
+}
+
+void USGVirtualHandComponent::BeginPlay()
+{
+    Super::BeginPlay();
+
+    if (Pimpl->InitializeBackend())
+    {
+        (void) Pimpl->CheckGlove();
+    }
+}
+
+void USGVirtualHandComponent::EndPlay(const EEndPlayReason::Type EndPlayReason)
+{
+    Super::EndPlay(EndPlayReason);
+
+    (void) Pimpl->UninitializeBackend();
+}
+
+void USGVirtualHandComponent::TickComponent(
+    const float DeltaTime, const ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
+{
+#if WITH_EDITOR
+    if (Pimpl->IsEditor())
+    {
+        EditorTick(DeltaTime, TickType, ThisTickFunction);
+        return;
+    }
+#endif  /* WITH_EDITOR */
+
+    Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
+
+    (void) Pimpl->CheckGlove();
+}
+
+void USGVirtualHandComponent::SetSkeletalMesh(USkeletalMesh* NewMesh, const bool bReinitPose)
+{
+    if (IsValid(NewMesh))
+    {
+        Super::SetSkeletalMesh(NewMesh, bReinitPose);
+    }
+    else
+    {
+        Super::SetSkeletalMesh(Pimpl->LoadDefaultMesh(), bReinitPose);
+    }
+}
+
+void USGVirtualHandComponent::EditorTick(
+    const float DeltaTime, const ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
+{
+    (void) Pimpl->CheckGlove();
+}
+
+bool USGVirtualHandComponent::IsGloveConnected() const
+{
+    return Pimpl->CheckGlove();
+}
+
+USGHandPose* USGVirtualHandComponent::GetHandPose()
+{
+    USGHandPose* HandPose{nullptr};
+
+    if (IsValid(Glove))
+    {
+#if ! PLATFORM_ANDROID
+        Glove->GetHandPose(this, HandPose);
+#else   /* ! PLATFORM_ANDROID */
+        const UWorld* World{GetWorld()};
+        const float DeltaTime = UGameplayStatics::GetWorldDeltaSeconds(World);
+        Glove->GetHandPose(this, DeltaTime, HandPose);
+#endif   /* ! PLATFORM_ANDROID */
+    }
+
+    return HandPose;
+}
+
+const FName& USGVirtualHandComponent::GetFingerBoneName(const int32 Finger, const int32 Joint) const
+{
+    const FName& Name{
+        IsRight()
+        ? GetRightHandFingerBoneName(Finger, Joint)
+        : GetLeftHandFingerBoneName(Finger, Joint)
+    };
+    return Name;
+}
+
+const FTransform& USGVirtualHandComponent::GetFingerBoneRefTransform(const int32 Finger, const int32 Joint) const
+{
+    const FName& BoneName{GetFingerBoneName(Finger, Joint)};
+    const FReferenceSkeleton& ReferenceSkeleton{Pimpl->GetRefSkeleton()};
+    const int32 BoneIndex = ReferenceSkeleton.FindBoneIndex(BoneName);
+
+    if (BoneIndex == INDEX_NONE)
+    {
+        SGLOG_WARNING(FString::Printf(TEXT("Could not find a bone index for '%s' finger bone!"),
+            *BoneName.ToString()));
+        return FTransform::Identity;
+    }
+
+    const FTransform& BoneTransform{ReferenceSkeleton.GetRefBonePose()[BoneIndex]};
+    return BoneTransform;
+}
+
+FRotator USGVirtualHandComponent::GetFingerBoneRefRotation(const int32 Finger, const int32 Joint) const
+{
+    const FTransform BoneTransform{GetFingerBoneRefTransform(Finger, Joint)};
+    FRotator BoneRotation{BoneTransform.GetRotation().Rotator()};
+    return MoveTemp(BoneRotation);
+}
+
+TMap<FName, FRotator> USGVirtualHandComponent::GetFingersBonesRotations()
+{
+    TMap<FName, FRotator> Rotations;
+
+    if (!IsGloveConnected())
+    {
+        return MoveTemp(Rotations);
+    }
+
+    const USGHandPose* HandPose = GetHandPose();
+    if (!IsValid(HandPose))
+    {
+        return MoveTemp(Rotations);
+    }
+
+    const TArray<TArray<FVector>> HandAngles{HandPose->GetHandAngles()};
+
+    for (int32 FingerIndex = 0; FingerIndex < HandAngles.Num(); ++FingerIndex)
+    {
+        const TArray<FVector>& FingerJointAngles{HandAngles[FingerIndex]};
+
+        for (int32 JointIndex = 0; JointIndex < FingerJointAngles.Num(); ++JointIndex)
+        {
+            const FVector& JointAngle{FingerJointAngles[JointIndex]};
+            const FQuat JointRotation{FQuat::MakeFromEuler(JointAngle)};
+
+            const FTransform& BoneRefTransform{GetFingerBoneRefTransform(FingerIndex, JointIndex)};
+
+            FQuat NewBoneRotation{BoneRefTransform.GetRotation() * JointRotation};
+
+            FName BoneName{GetFingerBoneName(FingerIndex, JointIndex)};
+
+            Rotations.Emplace(MoveTemp(BoneName), MoveTemp(NewBoneRotation));
+        }
+    }
+
+    return MoveTemp(Rotations);
+}
+
+USGVirtualHandComponent::FImpl::FImpl(USGVirtualHandComponent* InOwner)
+    : Owner(InOwner)
+{
+}
+
+USGVirtualHandComponent::FImpl::~FImpl() = default;
+
+bool USGVirtualHandComponent::FImpl::IsEditor() const
+{
+    const UWorld* World{Owner->GetWorld()};
+    if (World && (World->WorldType == EWorldType::Editor || World->WorldType == EWorldType::EditorPreview))
+    {
+        return true;
+    }
+
+    return false;
+}
+
+FString USGVirtualHandComponent::FImpl::GetDefaultMeshPath() const
+{
+    FString SkeletalMeshPath;
+
+    if (Owner->IsRight())
+    {
+        SkeletalMeshPath = GetDefaultRightHandMeshPath();
+    }
+    else
+    {
+        SkeletalMeshPath = GetDefaultLeftHandMeshPath();
+    }
+
+    return MoveTemp(SkeletalMeshPath);
+}
+
+bool USGVirtualHandComponent::FImpl::IsUsingUserMesh() const
+{
+    const USkeletalMesh* CurrentMesh{GetMesh()};
+    if (!IsValid(CurrentMesh))
+    {
+        return false;
+    }
+
+    const FString CurrentMeshPath(CurrentMesh->GetPathName());
+    const FString LeftHandDefaultMeshPath(GetDefaultLeftHandMeshPath());
+    const FString LeftHandDefaultMeshPathOnly(GetDefaultLeftHandMeshPathOnly());
+    const FString RightHandDefaultMeshPath(GetDefaultRightHandMeshPath());
+    const FString RightHandDefaultMeshPathOnly(GetDefaultRightHandMeshPathOnly());
+    if (CurrentMeshPath == LeftHandDefaultMeshPath
+        || CurrentMeshPath == LeftHandDefaultMeshPathOnly
+        || CurrentMeshPath == RightHandDefaultMeshPath
+        || CurrentMeshPath == RightHandDefaultMeshPathOnly)
+    {
+        return false;
+    }
+
+    return true;
+}
+
+USkeletalMesh* USGVirtualHandComponent::FImpl::LoadDefaultMesh() const
+{
+    const FString DefaultMeshPath{GetDefaultMeshPath()};
+    USkeletalMesh* DefaultMesh{
+        Cast<USkeletalMesh>(StaticLoadObject(USkeletalMesh::StaticClass(), nullptr, *DefaultMeshPath))
+    };
+
+    if (!IsValid(DefaultMesh))
+    {
+        SGLOG_WARNING(FString::Printf(TEXT("Failed to load the default skeletal mesh: '%s'"), *DefaultMeshPath));
+    }
+
+    return DefaultMesh;
+}
+
+void USGVirtualHandComponent::FImpl::SetDefaultMesh() const
+{
+    Owner->SetSkeletalMesh(LoadDefaultMesh(), true);
+}
+
+USkeletalMesh* USGVirtualHandComponent::FImpl::GetMesh() const
+{
+    return Owner->
+#if ENGINE_MAJOR_VERSION >= 5 && ENGINE_MINOR_VERSION >= 1
+        GetSkeletalMeshAsset()
+#else   /* ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 1 */
+        SkeletalMesh
+#endif  /* ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 1 */
+        ;
+}
+
+USkeleton* USGVirtualHandComponent::FImpl::GetSkeleton() const
+{
+    USkeletalMesh* Mesh{GetMesh()};
+    ensureAlwaysMsgf(IsValid(Mesh), TEXT("Invalid SkeletalMesh object!"));
+    return Mesh->GetSkeleton();
+}
+
+const FReferenceSkeleton& USGVirtualHandComponent::FImpl::GetRefSkeleton() const
+{
+    const USkeletalMesh* Mesh{GetMesh()};
+    ensureAlwaysMsgf(IsValid(Mesh), TEXT("Invalid SkeletalMesh object!"));
+    return Mesh->GetRefSkeleton();
+}
+
+bool USGVirtualHandComponent::FImpl::InitializeBackend() const
+{
+    if (!Owner->bBackendInitialized)
+    {
+#if PLATFORM_ANDROID
+        const int32_t Result = FSGConnect::Init();
+        switch (Result)
+        {
+        case -3:
+            SGLOG_ERROR("An Unexpected error occurred. Please try again.");
+            return false;
+        case -2:
+            SGLOG_ERROR("Device Scanning is already running within a different program.");
+            return false;
+        case -1:
+            SGLOG_ERROR("Device Scanning already being initialized (function called twice in short succession).");
+            return false;
+        case 0:
+            // Do not pollute the logs!
+            //SGLOG_ERROR("Device Scanning is already running within this program.");
+            // We must return here in case there are two virtual hand components are present in the scene.
+            return true;
+        case 1:
+            SGLOG("Successfully started up DeviceScanning from the current program.");
+            break;
+        default:
+            ensureAlwaysMsgf(false, TEXT("Unhandled Init return status code!"));
+            return false;
+        }
+#endif  /* PLATFORM_ANDROID */
+
+        // Ensure that the device list is empty before doing anything.
+        FSGDeviceList::Dispose();
+        FSGDeviceList::Reinitialize();
+
+        // Load the latest hand profiles.
+        FSGHapticGloveHandProfiles::TryLoadingFromDisk();
+
+        Owner->bBackendInitialized = true;
+
+        return true;
+    }
+
+    return false;
+}
+
+bool USGVirtualHandComponent::FImpl::UninitializeBackend() const
+{
+    // NOTE
+    // In Editor builds we should be avoiding dispose, since stopping the game in PIE mode, causes the virtual-hand
+    // to disappear in the editor as the plugin won't be able to retrieve the glove status anymore.
+#if ! WITH_EDITOR
+    if (Owner->bBackendInitialized)
+    {
+        FSGDeviceList::Dispose();
+
+#if PLATFORM_ANDROID
+        const int32_t Result = FSGConnect::Dispose();
+        switch (Result)
+        {
+        case -3:
+            SGLOG_ERROR("An Unexpected error occurred. Please try again.");
+            return false;
+        case -2:
+            SGLOG_ERROR("Not allowed to dispose of Device Scanning because this is not the program which started it.");
+            return false;
+        case -1:
+            SGLOG_ERROR("Device Scanning is currently being disposed off. This takes a second or two. (function called twice in short succession).");
+            return false;
+        case 0:
+            SGLOG_ERROR("There is no deviceScanner running from any program, so disposing is skipped.");
+            return false;
+        case 1:
+            SGLOG("Successfully disposed of DeviceScanner resources.");
+            break;
+        default:
+            ensureAlwaysMsgf(false, TEXT("Unhandled Dispose return status code!"));
+            return false;
+        }
+#endif  /* PLATFORM_ANDROID */
+
+        Owner->bBackendInitialized = false;
+
+        return true;
+    }
+#endif  /* ! WITH_EDITOR */
+
+    return false;
+}
+
+bool USGVirtualHandComponent::FImpl::CheckGlove() const
+{
+    if (!Owner->bBackendInitialized)
+    {
+        const bool bSucceeded = InitializeBackend();
+        if (!bSucceeded)
+        {
+            return false;
+        }
+    }
+
+    const bool bGloveWasPresent = IsValid(Owner->Glove);
+    const bool bFoundGlove = USGHapticGlove::GetGlove(Owner, Owner->IsRight(), Owner->Glove);
+
+    if (!bFoundGlove && bGloveWasPresent)
+    {
+        SGLOG_ERROR(FString::Printf(TEXT("Could not find a %s glove!"),
+            (Owner->IsRight() ? TEXT("right-handed") : TEXT("left-handed"))));
+    }
+
+    const bool bIsEditor = IsEditor();
+    if (!bIsEditor)
+    {
+        const bool bIsVisible = Owner->IsVisible();
+        if (Owner->bHiddenInGameIfNoGloveDetected)
+        {
+            if (bFoundGlove)
+            {
+                if (!bIsVisible)
+                {
+                    SetVisibility(true);
+                }
+            }
+            else
+            {
+                if (bIsVisible)
+                {
+                    SetVisibility(false);
+                }
+            }
+        }
+        else
+        {
+            if (!bIsVisible)
+            {
+                SetVisibility(true);
+            }
+        }
+    }
+
+    return bFoundGlove;
+}
+
+void USGVirtualHandComponent::FImpl::SetVisibility(const bool bInVisible) const
+{
+    Owner->SetVisibility(bInVisible, true);
+}
+
+void USGVirtualHandComponent::FImplDeleter::operator()(const FImpl* P) const
+{
+    delete P;
+}

Source/SenseGlove/Private/SenseGlove/Components/SGWristTrackerComponent.cpp

@@ -0,0 +1,776 @@
+/**
+ * @file
+ *
+ * @author  Mamadou Babaei <mamadou@senseglove.com>
+ *
+ * @section LICENSE
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2020 - 2023 SenseGlove
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * @section DESCRIPTION
+ *
+ *
+ */
+
+
+#include "SenseGlove/Components/SGWristTrackerComponent.h"
+
+#include "Animation/Skeleton.h"
+#include "Components/SkeletalMeshComponent.h"
+#include "DrawDebugHelpers.h"
+#include "Engine/SkeletalMesh.h"
+#include "Kismet/GameplayStatics.h"
+#include "UObject/ConstructorHelpers.h"
+
+#include "SGConnect/SGConnect.h"
+#include "SGCore/SGDeviceList.h"
+#include "SGCore/SGHapticGlove.h"
+#include "SGCore/SGHapticGloveHandProfiles.h"
+#include "SGLog/SGLog.h"
+#include "SGSettings/SGSettings.h"
+
+struct USGWristTrackerComponent::FImpl
+{
+    /************************
+     * Static methods
+     ************************/
+
+    /************************
+     * Owner object
+     ************************/
+
+    USGWristTrackerComponent* Owner;
+
+    /************************
+     * Constructor / Destructor
+     ************************/
+
+    explicit FImpl(USGWristTrackerComponent* InOwner);
+    ~FImpl();
+
+    /************************
+     * Default copy constructor & copy assignment operator
+     ************************/
+
+    FImpl(const FImpl& Rhs) = default;
+    FImpl& operator=(const FImpl& Rhs) = default;
+
+    /************************
+     * Methods
+     ************************/
+
+    bool IsEditor() const;
+
+    bool InitializeBackend() const;
+    bool UninitializeBackend() const;
+    bool CheckGlove() const;
+
+    void UpdateWristTrackingData() const;
+    void DrawDebugGizmo();
+};
+
+USGWristTrackerComponent::USGWristTrackerComponent(const FObjectInitializer& ObjectInitializer)
+    : Super(ObjectInitializer),
+      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
+{
+    PrimaryComponentTick.bTickEvenWhenPaused = false;
+    PrimaryComponentTick.bCanEverTick = true;
+    PrimaryComponentTick.bStartWithTickEnabled = true;
+    bTickInEditor = true;
+    bNeverNeedsRenderUpdate = true;
+    bAllowConcurrentTick = true;
+
+    SetCastShadow(false);
+    SetCastHiddenShadow(false);
+    bCastDynamicShadow = false;
+    SetOnlyOwnerSee(false);
+    SetReceivesDecals(false);
+    SetCanEverAffectNavigation(false);
+
+    SetRight(true);
+
+    bOverridePluginWristTrackingSettings = false;
+    bDrawDebugWristTrackerGizmo = false;
+    TrackingHardware = ESGPositionalTrackingHardware::None;
+    TrackingHardwareLocationOffset = FVector::ZeroVector;
+    TrackingHardwareLocationOffset = FVector::ZeroVector;
+
+    bOverridePluginWristTrackingDebugSettings = false;
+    bDrawDebugWristTrackerGizmo = false;
+    DebugWristTrackerGizmoLength = 1.0f;
+    DebugWristTrackerGizmoXAxisColor = FColor(1.0f, 0.0f, 0.0f, 1.0f);
+    DebugWristTrackerGizmoYAxisColor = FColor(0.0f, 1.0f, 0.0f, 1.0f);
+    DebugWristTrackerGizmoZAxisColor = FColor(0.0f, 0.0f, 1.0f, 1.0f);
+    bDebugWristTrackerGizmoPersistentLines = false;
+    DebugWristTrackerGizmoLifeTimeModifier = 1.1f;
+    DebugWristTrackerGizmoDepthPriority = 0;
+    DebugWristTrackerGizmoThickness = 1.0f;
+
+    bBackendInitialized = false;
+    Glove = nullptr;
+    WristLocation = FVector::ZeroVector;
+    WristRotation = FRotator::ZeroRotator;
+}
+
+void USGWristTrackerComponent::SetRight(const bool bRight)
+{
+    SetTrackingSource(bRight ? EControllerHand::Right : EControllerHand::Left);
+}
+
+ESGPositionalTrackingHardware USGWristTrackerComponent::GetTrackingHardware() const
+{
+    if (OverridesPluginWristTrackingSettings())
+    {
+        return TrackingHardware;
+    }
+
+    return USGSettings::GetInstance()->GetTrackingHardware();
+}
+
+void USGWristTrackerComponent::SetTrackingHardware(const ESGPositionalTrackingHardware InTrackingHardware)
+{
+    ensureAlwaysMsgf(
+        OverridesPluginWristTrackingSettings(),
+        TEXT( "Setting TrackingHardware is only permitted when bOverridePluginWristTrackingSettings is enabled!"));
+
+    TrackingHardware = InTrackingHardware;
+}
+
+const FVector& USGWristTrackerComponent::GetTrackingHardwareLocationOffset() const
+{
+    ensureAlwaysMsgf(
+        GetTrackingHardware() == ESGPositionalTrackingHardware::Custom,
+        TEXT( "Getting TrackingHardwareLocationOffset is only permitted when TrackingHardware is set to Custom!"));
+
+    if (OverridesPluginWristTrackingSettings())
+    {
+        return TrackingHardwareLocationOffset;
+    }
+
+    return IsRight()
+        ? USGSettings::GetInstance()->GetTrackingHardwareLocationOffsetRightHand()
+        : USGSettings::GetInstance()->GetTrackingHardwareLocationOffsetLeftHand();
+}
+
+void USGWristTrackerComponent::SetTrackingHardwareLocationOffset(const FVector& InTrackingHardwareLocationOffset)
+{
+    ensureAlwaysMsgf(
+        OverridesPluginWristTrackingSettings(),
+        TEXT(
+            "Setting TrackingHardwareLocationOffset is only permitted when bOverridePluginWristTrackingSettings is enabled!"
+        ));
+
+    ensureAlwaysMsgf(
+        GetTrackingHardware() == ESGPositionalTrackingHardware::Custom,
+        TEXT( "Setting TrackingHardwareLocationOffset is only permitted when TrackingHardware is set to Custom!"));
+
+    TrackingHardwareLocationOffset = InTrackingHardwareLocationOffset;
+}
+
+const FRotator& USGWristTrackerComponent::GetTrackingHardwareRotationOffset() const
+{
+    ensureAlwaysMsgf(
+        GetTrackingHardware() == ESGPositionalTrackingHardware::Custom,
+        TEXT( "Getting TrackingHardwareRotationOffset is only permitted when TrackingHardware is set to Custom!"));
+
+    if (OverridesPluginWristTrackingSettings())
+    {
+        return TrackingHardwareRotationOffset;
+    }
+
+    return IsRight()
+        ? USGSettings::GetInstance()->GetTrackingHardwareRotationOffsetRightHand()
+        : USGSettings::GetInstance()->GetTrackingHardwareRotationOffsetLeftHand();
+}
+
+void USGWristTrackerComponent::SetTrackingHardwareRotationOffset(const FRotator& InTrackingHardwareRotationOffset)
+{
+    ensureAlwaysMsgf(
+        OverridesPluginWristTrackingSettings(),
+        TEXT(
+            "Setting TrackingHardwareRotationOffset is only permitted when bOverridePluginWristTrackingSettings is enabled!"
+        ));
+
+    ensureAlwaysMsgf(
+        GetTrackingHardware() == ESGPositionalTrackingHardware::Custom,
+        TEXT("Setting TrackingHardwareRotationOffsetRightHand is only permitted when TrackingHardware is set to Custom!"
+        ));
+
+    TrackingHardwareRotationOffset = InTrackingHardwareRotationOffset;
+}
+
+bool USGWristTrackerComponent::GetDrawDebugWristTrackerGizmo() const
+{
+    if (OverridesPluginWristTrackingDebugSettings())
+    {
+        return !!bDrawDebugWristTrackerGizmo;
+    }
+
+    return USGSettings::GetInstance()->GetDrawDebugWristTrackerGizmo();
+}
+
+void USGWristTrackerComponent::SetDrawDebugWristTrackerGizmo(const bool bInDrawDebugWristTrackerGizmo)
+{
+    ensureAlwaysMsgf(
+        OverridesPluginWristTrackingDebugSettings(),
+        TEXT( "Setting bDrawDebugWristTrackerGizmo is only permitted when bOverridePluginWristTrackingDebugSettings is"
+            " enabled!"));
+
+    bDrawDebugWristTrackerGizmo = bInDrawDebugWristTrackerGizmo;
+}
+
+float USGWristTrackerComponent::GetDebugWristTrackerGizmoLength() const
+{
+    ensureAlwaysMsgf(
+        GetDrawDebugWristTrackerGizmo(),
+        TEXT("Getting DebugWristTrackerGizmoLength is only permitted when bDrawDebugWristTrackerGizmo is enabled!"));
+
+    if (OverridesPluginWristTrackingDebugSettings())
+    {
+        return DebugWristTrackerGizmoLength;
+    }
+
+    return USGSettings::GetInstance()->GetDebugWristTrackerGizmoLength();
+}
+
+void USGWristTrackerComponent::SetDebugWristTrackerGizmoLength(const float InDebugWristTrackerGizmoLength)
+{
+    ensureAlwaysMsgf(
+        OverridesPluginWristTrackingDebugSettings(),
+        TEXT("Setting DebugWristTrackerGizmoLength is only permitted when bOverridePluginWristTrackingDebugSettings is"
+            " enabled!"));
+
+    ensureAlwaysMsgf(
+        GetDrawDebugWristTrackerGizmo(),
+        TEXT("Setting DebugWristTrackerGizmoLength is only permitted when bDrawDebugWristTrackerGizmo is enabled!"));
+
+    DebugWristTrackerGizmoLength = InDebugWristTrackerGizmoLength;
+}
+
+const FColor& USGWristTrackerComponent::GetDebugWristTrackerGizmoXAxisColor() const
+{
+    ensureAlwaysMsgf(
+        GetDrawDebugWristTrackerGizmo(),
+        TEXT("Getting DebugWristTrackerGizmoXAxisColor is only permitted when bDrawDebugWristTrackerGizmo is"
+            " enabled!"));
+
+    if (OverridesPluginWristTrackingDebugSettings())
+    {
+        return DebugWristTrackerGizmoXAxisColor;
+    }
+
+    return USGSettings::GetInstance()->GetDebugWristTrackerGizmoXAxisColor();
+}
+
+void USGWristTrackerComponent::SetDebugWristTrackerGizmoXAxisColor(
+    const FColor& InDebugWristTrackerGizmoXAxisColor)
+{
+    ensureAlwaysMsgf(
+        OverridesPluginWristTrackingDebugSettings(),
+        TEXT("Setting DebugWristTrackerGizmoXAxisColor is only permitted when bOverridePluginWristTrackingDebugSettings"
+            " is enabled!"));
+
+    ensureAlwaysMsgf(
+        GetDrawDebugWristTrackerGizmo(),
+        TEXT("Setting DebugWristTrackerGizmoXAxisColor is only permitted when bDrawDebugWristTrackerGizmo is"
+            " enabled!"));
+
+    DebugWristTrackerGizmoXAxisColor = InDebugWristTrackerGizmoXAxisColor;
+}
+
+const FColor& USGWristTrackerComponent::GetDebugWristTrackerGizmoYAxisColor() const
+{
+    ensureAlwaysMsgf(
+        GetDrawDebugWristTrackerGizmo(),
+        TEXT("Getting DebugWristTrackerGizmoYAxisColor is only permitted when bDrawDebugWristTrackerGizmo is"
+            " enabled!"));
+
+    if (OverridesPluginWristTrackingDebugSettings())
+    {
+        return DebugWristTrackerGizmoYAxisColor;
+    }
+
+    return USGSettings::GetInstance()->GetDebugWristTrackerGizmoYAxisColor();
+}
+
+void USGWristTrackerComponent::SetDebugWristTrackerGizmoYAxisColor(
+    const FColor& InDebugWristTrackerGizmoYAxisColor)
+{
+    ensureAlwaysMsgf(
+        OverridesPluginWristTrackingDebugSettings(),
+        TEXT("Setting DebugWristTrackerGizmoYAxisColor is only permitted when bOverridePluginWristTrackingDebugSettings"
+            " is enabled!"));
+
+    ensureAlwaysMsgf(
+        GetDrawDebugWristTrackerGizmo(),
+        TEXT("Setting DebugWristTrackerGizmoYAxisColor is only permitted when bDrawDebugWristTrackerGizmo is"
+            " enabled!"));
+
+    DebugWristTrackerGizmoYAxisColor = InDebugWristTrackerGizmoYAxisColor;
+}
+
+const FColor& USGWristTrackerComponent::GetDebugWristTrackerGizmoZAxisColor() const
+{
+    ensureAlwaysMsgf(
+        GetDrawDebugWristTrackerGizmo(),
+        TEXT("Getting DebugWristTrackerGizmoZAxisColor is only permitted when bDrawDebugWristTrackerGizmo is"
+            " enabled!"));
+
+    if (OverridesPluginWristTrackingDebugSettings())
+    {
+        return DebugWristTrackerGizmoZAxisColor;
+    }
+
+    return USGSettings::GetInstance()->GetDebugWristTrackerGizmoZAxisColor();
+}
+
+void USGWristTrackerComponent::SetDebugWristTrackerGizmoZAxisColor(
+    const FColor& InDebugWristTrackerGizmoZAxisColor)
+{
+    ensureAlwaysMsgf(
+        OverridesPluginWristTrackingDebugSettings(),
+        TEXT("Setting DebugWristTrackerGizmoZAxisColor is only permitted when bOverridePluginWristTrackingDebugSettings"
+            " is enabled!"));
+
+    ensureAlwaysMsgf(
+        GetDrawDebugWristTrackerGizmo(),
+        TEXT("Setting DebugWristTrackerGizmoZAxisColor is only permitted when bDrawDebugWristTrackerGizmo is"
+            " enabled!"));
+
+    DebugWristTrackerGizmoZAxisColor = InDebugWristTrackerGizmoZAxisColor;
+}
+
+bool USGWristTrackerComponent::GetDebugWristTrackerGizmoPersistentLines() const
+{
+    ensureAlwaysMsgf(
+        GetDrawDebugWristTrackerGizmo(),
+        TEXT("Getting bDebugWristTrackerGizmoPersistentLines is only permitted when bDrawDebugWristTrackerGizmo is"
+            " enabled!"));
+
+    if (OverridesPluginWristTrackingDebugSettings())
+    {
+        return !!bDebugWristTrackerGizmoPersistentLines;
+    }
+
+    return USGSettings::GetInstance()->GetDebugWristTrackerGizmoPersistentLines();
+}
+
+void USGWristTrackerComponent::SetDebugWristTrackerGizmoPersistentLines(
+    const bool bInDebugWristTrackerGizmoPersistentLines)
+{
+    ensureAlwaysMsgf(
+        OverridesPluginWristTrackingDebugSettings(),
+        TEXT("Setting DebugWristTrackerGizmoPersistentLines is only permitted when"
+            " bOverridePluginWristTrackingDebugSettings is enabled!"));
+
+    ensureAlwaysMsgf(
+        GetDrawDebugWristTrackerGizmo(),
+        TEXT("Setting bDebugWristTrackerGizmoPersistentLines is only permitted when bDrawDebugWristTrackerGizmo is"
+            " enabled!"));
+
+    bDebugWristTrackerGizmoPersistentLines = bInDebugWristTrackerGizmoPersistentLines;
+}
+
+float USGWristTrackerComponent::GetDebugWristTrackerGizmoLifeTimeModifier() const
+{
+    ensureAlwaysMsgf(
+        GetDrawDebugWristTrackerGizmo(),
+        TEXT("Getting DebugWristTrackerGizmoLifeTimeModifier is only permitted when bDrawDebugWristTrackerGizmo is"
+            " enabled!"));
+
+    if (OverridesPluginWristTrackingDebugSettings())
+    {
+        return DebugWristTrackerGizmoLifeTimeModifier;
+    }
+
+    return USGSettings::GetInstance()->GetDebugWristTrackerGizmoLifeTimeModifier();
+}
+
+void USGWristTrackerComponent::SetDebugWristTrackerGizmoLifeTimeModifier(
+    const float InDebugWristTrackerGizmoLifeTimeModifier)
+{
+    ensureAlwaysMsgf(
+        OverridesPluginWristTrackingDebugSettings(),
+        TEXT("Setting DebugWristTrackerGizmoLifetimeModifier is only permitted when"
+            " bOverridePluginWristTrackingDebugSettings is enabled!"));
+
+    ensureAlwaysMsgf(
+        GetDrawDebugWristTrackerGizmo(),
+        TEXT("Setting DebugWristTrackerGizmoLifeTimeModifier is only permitted when bDrawDebugWristTrackerGizmo is"
+            " enabled!"));
+
+    DebugWristTrackerGizmoLifeTimeModifier = InDebugWristTrackerGizmoLifeTimeModifier;
+}
+
+uint8 USGWristTrackerComponent::GetDebugWristTrackerGizmoDepthPriority() const
+{
+    ensureAlwaysMsgf(
+        GetDrawDebugWristTrackerGizmo(),
+        TEXT("Getting DebugWristTrackerGizmoDepthPriority is only permitted when bDrawDebugWristTrackerGizmo is"
+            " enabled!"));
+
+    if (OverridesPluginWristTrackingDebugSettings())
+    {
+        return DebugWristTrackerGizmoDepthPriority;
+    }
+
+    return USGSettings::GetInstance()->GetDebugWristTrackerGizmoDepthPriority();
+}
+
+void USGWristTrackerComponent::SetDebugWristTrackerGizmoDepthPriority(const uint8 InDebugWristTrackerGizmoDepthPriority)
+{
+    ensureAlwaysMsgf(
+        OverridesPluginWristTrackingDebugSettings(),
+        TEXT("Setting DebugWristTrackerGizmoDepthPriority is only permitted when"
+            " bOverridePluginWristTrackingDebugSettings is enabled!"));
+
+    ensureAlwaysMsgf(
+        GetDrawDebugWristTrackerGizmo(),
+        TEXT("Setting DebugWristTrackerGizmoDepthPriority is only permitted when bDrawDebugWristTrackerGizmo is"
+            " enabled!"));
+
+    DebugWristTrackerGizmoDepthPriority = InDebugWristTrackerGizmoDepthPriority;
+}
+
+float USGWristTrackerComponent::GetDebugWristTrackerGizmoThickness() const
+{
+    ensureAlwaysMsgf(
+        GetDrawDebugWristTrackerGizmo(),
+        TEXT("Getting DebugWristTrackerGizmoThickness is only permitted when bDrawDebugWristTrackerGizmo is enabled!"));
+
+    if (OverridesPluginWristTrackingDebugSettings())
+    {
+        return DebugWristTrackerGizmoThickness;
+    }
+
+    return USGSettings::GetInstance()->GetDebugWristTrackerGizmoThickness();
+}
+
+void USGWristTrackerComponent::SetDebugWristTrackerGizmoThickness(float InDebugWristTrackerGizmoThickness)
+{
+    ensureAlwaysMsgf(
+        OverridesPluginWristTrackingDebugSettings(),
+        TEXT("Setting DebugWristTrackerGizmoDepthThickness is only permitted when"
+            " bOverridePluginWristTrackingDebugSettings is enabled!"));
+
+    ensureAlwaysMsgf(
+        GetDrawDebugWristTrackerGizmo(),
+        TEXT("Setting DebugWristTrackerGizmoThickness is only permitted when bDrawDebugWristTrackerGizmo is enabled!"));
+
+    DebugWristTrackerGizmoThickness = InDebugWristTrackerGizmoThickness;
+}
+
+#if WITH_EDITOR
+void USGWristTrackerComponent::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
+{
+    Super::PostEditChangeProperty(PropertyChangedEvent);
+
+    const FName PropertyName{
+        PropertyChangedEvent.Property
+        ? PropertyChangedEvent.Property->GetFName()
+        : NAME_None
+    };
+
+    (void) PropertyName;
+}
+#endif  /* WITH_EDITOR */
+
+void USGWristTrackerComponent::InitializeComponent()
+{
+    Super::InitializeComponent();
+
+    if (Pimpl->InitializeBackend())
+    {
+        (void) Pimpl->CheckGlove();
+    }
+}
+
+void USGWristTrackerComponent::UninitializeComponent()
+{
+    Super::UninitializeComponent();
+
+    (void) Pimpl->UninitializeBackend();
+}
+
+void USGWristTrackerComponent::BeginPlay()
+{
+    Super::BeginPlay();
+
+    if (Pimpl->InitializeBackend())
+    {
+        (void) Pimpl->CheckGlove();
+    }
+}
+
+void USGWristTrackerComponent::EndPlay(const EEndPlayReason::Type EndPlayReason)
+{
+    Super::EndPlay(EndPlayReason);
+
+    (void) Pimpl->UninitializeBackend();
+}
+
+void USGWristTrackerComponent::TickComponent(
+    const float DeltaTime, const ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
+{
+#if WITH_EDITOR
+    if (Pimpl->IsEditor())
+    {
+        EditorTick(DeltaTime, TickType, ThisTickFunction);
+        return;
+    }
+#endif  /* WITH_EDITOR */
+
+    Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
+
+    if (GetDrawDebugWristTrackerGizmo())
+    {
+        Pimpl->DrawDebugGizmo();
+    }
+
+    (void) Pimpl->CheckGlove();
+}
+
+
+void USGWristTrackerComponent::EditorTick(
+    const float DeltaTime, const ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
+{
+    (void) Pimpl->CheckGlove();
+}
+
+USGWristTrackerComponent::FImpl::FImpl(USGWristTrackerComponent* InOwner)
+    : Owner(InOwner)
+{
+}
+
+USGWristTrackerComponent::FImpl::~FImpl() = default;
+
+bool USGWristTrackerComponent::FImpl::IsEditor() const
+{
+    const UWorld* World{Owner->GetWorld()};
+    if (World && (World->WorldType == EWorldType::Editor || World->WorldType == EWorldType::EditorPreview))
+    {
+        return true;
+    }
+
+    return false;
+}
+
+bool USGWristTrackerComponent::FImpl::InitializeBackend() const
+{
+    if (!Owner->bBackendInitialized)
+    {
+#if PLATFORM_ANDROID
+        const int32_t Result = FSGConnect::Init();
+        switch (Result)
+        {
+        case -3:
+            SGLOG_ERROR("An Unexpected error occurred. Please try again.");
+            return false;
+        case -2:
+            SGLOG_ERROR("Device Scanning is already running within a different program.");
+            return false;
+        case -1:
+            SGLOG_ERROR("Device Scanning already being initialized (function called twice in short succession).");
+            return false;
+        case 0:
+            // Do not pollute the logs!
+            //SGLOG_ERROR("Device Scanning is already running within this program.");
+            // We must return here in case there are two virtual hand components are present in the scene.
+            return true;
+        case 1:
+            SGLOG("Successfully started up DeviceScanning from the current program.");
+            break;
+        default:
+            ensureAlwaysMsgf(false, TEXT("Unhandled Init return status code!"));
+            return false;
+        }
+#endif  /* PLATFORM_ANDROID */
+
+        // Ensure that the device list is empty before doing anything.
+        FSGDeviceList::Dispose();
+        FSGDeviceList::Reinitialize();
+
+        // Load the latest hand profiles.
+        FSGHapticGloveHandProfiles::TryLoadingFromDisk();
+
+        Owner->bBackendInitialized = true;
+
+        return true;
+    }
+
+    return false;
+}
+
+bool USGWristTrackerComponent::FImpl::UninitializeBackend() const
+{
+    // NOTE
+    // In Editor builds we should be avoiding dispose, since stopping the game in PIE mode, causes the virtual-hand
+    // to disappear in the editor as the plugin won't be able to retrieve the glove status anymore.
+#if ! WITH_EDITOR
+    if (Owner->bBackendInitialized)
+    {
+        FSGDeviceList::Dispose();
+
+#if PLATFORM_ANDROID
+        const int32_t Result = FSGConnect::Dispose();
+        switch (Result)
+        {
+        case -3:
+            SGLOG_ERROR("An Unexpected error occurred. Please try again.");
+            return false;
+        case -2:
+            SGLOG_ERROR("Not allowed to dispose of Device Scanning because this is not the program which started it.");
+            return false;
+        case -1:
+            SGLOG_ERROR("Device Scanning is currently being disposed off. This takes a second or two. (function called twice in short succession).");
+            return false;
+        case 0:
+            SGLOG_ERROR("There is no deviceScanner running from any program, so disposing is skipped.");
+            return false;
+        case 1:
+            SGLOG("Successfully disposed of DeviceScanner resources.");
+            break;
+        default:
+            ensureAlwaysMsgf(false, TEXT("Unhandled Dispose return status code!"));
+            return false;
+        }
+#endif  /* PLATFORM_ANDROID */
+
+        Owner->bBackendInitialized = false;
+
+        return true;
+    }
+#endif  /* ! WITH_EDITOR */
+
+    return false;
+}
+
+bool USGWristTrackerComponent::FImpl::CheckGlove() const
+{
+    if (!Owner->bBackendInitialized)
+    {
+        const bool bSucceeded = InitializeBackend();
+        if (!bSucceeded)
+        {
+            return false;
+        }
+    }
+
+    const bool bGloveWasPresent = IsValid(Owner->Glove);
+    const bool bFoundGlove = USGHapticGlove::GetGlove(Owner, Owner->IsRight(), Owner->Glove);
+
+    if (!bFoundGlove && bGloveWasPresent)
+    {
+        SGLOG_ERROR(FString::Printf(TEXT("Could not find a %s glove!"),
+            (Owner->IsRight() ? TEXT("right-handed") : TEXT("left-handed"))));
+    }
+
+    if (bFoundGlove)
+    {
+        UpdateWristTrackingData();
+    }
+
+    return bFoundGlove;
+}
+
+void USGWristTrackerComponent::FImpl::UpdateWristTrackingData() const
+{
+    ensureAlwaysMsgf(Owner->Glove, TEXT("Invalid Glove!"));
+
+    FVector TrackerLocation{Owner->GetRelativeLocation()};
+    FRotator TrackerRotation{Owner->GetRelativeRotation()};
+
+    ESGPositionalTrackingHardware TrackerHardware = Owner->GetTrackingHardware();
+    if (TrackerHardware == ESGPositionalTrackingHardware::None)
+    {
+        TrackerHardware = ESGPositionalTrackingHardware::Custom;
+    }
+    else if (TrackerHardware == ESGPositionalTrackingHardware::Custom)
+    {
+        TrackerLocation += Owner->GetTrackingHardwareLocationOffset();
+        TrackerRotation += Owner->GetTrackingHardwareRotationOffset();
+    }
+
+    FVector NewWristLocation;
+    FRotator NewWristRotation;
+    Owner->Glove->GetWristLocation(TrackerLocation, TrackerRotation, TrackerHardware,
+                                   NewWristLocation, NewWristRotation);
+
+    const bool bLocationUpdated = !Owner->WristLocation.Equals(NewWristLocation, SMALL_NUMBER);
+    const bool bRotationUpdated = !Owner->WristRotation.Equals(NewWristRotation, SMALL_NUMBER);
+
+    if (bLocationUpdated)
+    {
+        Owner->WristLocation = MoveTemp(NewWristLocation);
+    }
+
+    if (bRotationUpdated)
+    {
+        Owner->WristRotation = MoveTemp(NewWristRotation);
+    }
+
+    if (bLocationUpdated && Owner->WristLocationChangedEvent.IsBound())
+    {
+        Owner->WristLocationChangedEvent.Broadcast(Owner->WristLocation);
+    }
+
+    if (bRotationUpdated && Owner->WristRotationChangedEvent.IsBound())
+    {
+        Owner->WristRotationChangedEvent.Broadcast(Owner->WristRotation);
+    }
+
+    if ((bLocationUpdated && bRotationUpdated) && Owner->WristLocationAndRotationChangedEvent.IsBound())
+    {
+        Owner->WristLocationAndRotationChangedEvent.Broadcast(Owner->WristLocation, Owner->WristRotation);
+    }
+}
+
+void USGWristTrackerComponent::FImpl::DrawDebugGizmo()
+{
+    const UWorld* World{Owner->GetWorld()};
+    const FVector& Location{Owner->GetRelativeLocation()};
+    const FRotator& Rotation{Owner->GetRelativeRotation()};
+    const float Length = Owner->GetDebugWristTrackerGizmoLength();
+    const bool bPersistentLines = Owner->GetDebugWristTrackerGizmoPersistentLines();
+    const float LifeTime = UGameplayStatics::GetWorldDeltaSeconds(World)
+        * Owner->GetDebugWristTrackerGizmoLifeTimeModifier();
+    const float DepthPriority = Owner->GetDebugWristTrackerGizmoDepthPriority();
+    const float Thickness = Owner->GetDebugWristTrackerGizmoThickness();
+    const FColor& XAxisColor{Owner->GetDebugWristTrackerGizmoXAxisColor()};
+    const FColor& YAxisColor{Owner->GetDebugWristTrackerGizmoYAxisColor()};
+    const FColor& ZAxisColor{Owner->GetDebugWristTrackerGizmoZAxisColor()};
+
+    const FVector XAxisLineEnd(Location + Rotation.RotateVector(FVector(Length, 0.0f, 0.0f)));
+    DrawDebugLine(World, Location, XAxisLineEnd, XAxisColor, bPersistentLines, LifeTime, DepthPriority, Thickness);
+
+    const FVector YAxisLineEnd(Location + Rotation.RotateVector(FVector{0.0f, Length, 0.0f}));
+    DrawDebugLine(World, Location, YAxisLineEnd, YAxisColor, bPersistentLines, LifeTime, DepthPriority, Thickness);
+
+    const FVector ZAxisLineEnd{Location + Rotation.RotateVector(FVector{0.0f, 0.0f, Length})};
+    DrawDebugLine(World, Location, ZAxisLineEnd, ZAxisColor, bPersistentLines, LifeTime, DepthPriority, Thickness);
+}
+
+void USGWristTrackerComponent::FImplDeleter::operator()(const FImpl* P) const
+{
+    delete P;
+}

Source/SenseGlove/Private/SenseGlove/GameFramework/SGGameModeBase.cpp

@@ -0,0 +1,46 @@
+/**
+ * @file
+ *
+ * @author  Mamadou Babaei <mamadou@senseglove.com>
+ *
+ * @section LICENSE
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2020 - 2023 SenseGlove
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * @section DESCRIPTION
+ *
+ *
+ */
+
+
+#include "SenseGlove/GameFramework//SGGameModeBase.h"
+
+#include "SenseGlove/GameFramework/SGPawn.h"
+#include "SenseGlove/GameFramework/SGPlayerController.h"
+
+ASGGameModeBase::ASGGameModeBase(const FObjectInitializer& ObjectInitializer)
+    : Super(ObjectInitializer)
+{
+    DefaultPawnClass = ASGPawn::StaticClass();
+    PlayerControllerClass = ASGPlayerController::StaticClass();
+}

Source/SenseGlove/Private/SenseGlove/GameFramework/SGPawn.cpp

@@ -0,0 +1,166 @@
+/**
+ * @file
+ *
+ * @author  Mamadou Babaei <mamadou@senseglove.com>
+ *
+ * @section LICENSE
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2020 - 2023 SenseGlove
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * @section DESCRIPTION
+ *
+ *
+ */
+
+
+#include "SenseGlove/GameFramework/SGPawn.h"
+
+#include "Camera/CameraComponent.h"
+
+#include "SenseGlove/Components/SGVirtualHandComponent.h"
+#include "SenseGlove/Components/SGWristTrackerComponent.h"
+
+struct ASGPawn::FImpl
+{
+    /************************
+     * Static methods
+     ************************/
+
+    /************************
+     * Owner object
+     ************************/
+
+    ASGPawn* Owner;
+
+    /************************
+     * Constructor / Destructor
+     ************************/
+
+    explicit FImpl(ASGPawn* InOwner);
+    ~FImpl();
+
+    /************************
+     * Default copy constructor & copy assignment operator
+     ************************/
+
+    FImpl(const FImpl& Rhs) = default;
+    FImpl& operator=(const FImpl& Rhs) = default;
+
+    /************************
+     * Methods
+     ************************/
+};
+
+ASGPawn::ASGPawn(const FObjectInitializer& ObjectInitializer)
+    : Super(ObjectInitializer),
+      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
+{
+    PrimaryActorTick.bCanEverTick = true;
+
+    SceneRoot = ObjectInitializer.CreateDefaultSubobject<USceneComponent>(this, TEXT("SceneRoot"));
+    SetRootComponent(SceneRoot);
+
+    Camera = ObjectInitializer.CreateDefaultSubobject<UCameraComponent>(this, TEXT("Camera"));
+    Camera->SetupAttachment(GetRootComponent());
+    Camera->SetCanEverAffectNavigation(false);
+
+    WristTrackerLeft = ObjectInitializer.CreateDefaultSubobject<USGWristTrackerComponent>(
+        this, TEXT("WristTrackerLeft"));
+    WristTrackerLeft->SetupAttachment(GetRootComponent());
+    WristTrackerLeft->SetRight(false);
+
+    HandLeft = ObjectInitializer.CreateDefaultSubobject<USGVirtualHandComponent>(this, TEXT("HandLeft"));
+    HandLeft->SetupAttachment(GetRootComponent());
+    HandLeft->SetRight(false);
+    HandLeft->SetHiddenIfNoGloveDetected(true);
+    HandLeft->SetRelativeRotation(FRotator{0.0f, -90.0f, 0.0f},
+                                  false, nullptr, ETeleportType::None);
+    HandLeft->SetRelativeLocation(FVector{30.0f, -20.0f, -10.0f},
+                                  false, nullptr, ETeleportType::None);
+
+    WristTrackerRight = ObjectInitializer.CreateDefaultSubobject<USGWristTrackerComponent>(
+        this, TEXT("WristTrackerRight"));
+    WristTrackerRight->SetupAttachment(GetRootComponent());
+    WristTrackerRight->SetRight(true);
+
+    HandRight = ObjectInitializer.CreateDefaultSubobject<USGVirtualHandComponent>(this, TEXT("HandRight"));
+    HandRight->SetupAttachment(GetRootComponent());
+    HandRight->SetRight(true);
+    HandRight->SetHiddenIfNoGloveDetected(true);
+    HandRight->SetRelativeRotation(FRotator{0.0f, -90.0f, 0.0f},
+                                  false, nullptr, ETeleportType::None);
+    HandRight->SetRelativeLocation(FVector{30.0f, 20.0f, -10.0f},
+                                   false, nullptr, ETeleportType::None);
+}
+
+void ASGPawn::BeginPlay()
+{
+    Super::BeginPlay();
+
+    ensureAlwaysMsgf(
+        WristTrackerLeft->IsLeft() && HandLeft->IsLeft(),
+        TEXT("The left hand and the left wrist do not track the left hand!"));
+    ensureAlwaysMsgf(
+        WristTrackerRight->IsRight() && HandRight->IsRight(),
+        TEXT("The right hand and the right wrist do not track the right hand!"));
+
+    WristTrackerLeft->OnWristLocationChanged().AddWeakLambda(this, [&](const FVector& Location)-> void
+    {
+        HandLeft->SetRelativeLocation(Location);
+    });
+
+    WristTrackerLeft->OnWristRotationChanged().AddWeakLambda(this, [&](const FRotator& Rotation)-> void
+    {
+        HandLeft->SetRelativeRotation(Rotation);
+    });
+
+    WristTrackerRight->OnWristLocationChanged().AddWeakLambda(this, [&](const FVector& Location)-> void
+    {
+        HandRight->SetRelativeLocation(Location);
+    });
+
+    WristTrackerRight->OnWristRotationChanged().AddWeakLambda(this, [&](const FRotator& Rotation)-> void
+    {
+        HandRight->SetRelativeRotation(Rotation);
+    });
+}
+
+void ASGPawn::PreInitializeComponents()
+{
+    Super::PreInitializeComponents();
+
+    WristTrackerLeft->SetRight(HandLeft->IsRight());
+    WristTrackerRight->SetRight(HandRight->IsRight());
+}
+
+ASGPawn::FImpl::FImpl(ASGPawn* InOwner)
+    : Owner(InOwner)
+{
+}
+
+ASGPawn::FImpl::~FImpl() = default;
+
+void ASGPawn::FImplDeleter::operator()(const FImpl* P) const
+{
+    delete P;
+}

Source/SenseGlove/Private/SenseGlove/GameFramework/SGPlayerController.cpp

@@ -0,0 +1,46 @@
+/**
+ * @file
+ *
+ * @author  Mamadou Babaei <mamadou@senseglove.com>
+ *
+ * @section LICENSE
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2020 - 2023 SenseGlove
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * @section DESCRIPTION
+ *
+ *
+ */
+
+
+#include "SenseGlove/GameFramework/SGPlayerController.h"
+
+ASGPlayerController::ASGPlayerController(const FObjectInitializer& ObjectInitializer)
+    : Super(ObjectInitializer)
+{
+}
+
+void ASGPlayerController::SetupInputComponent()
+{
+    Super::SetupInputComponent();
+}

Source/SenseGlove/Private/SenseGlove/GameFramework/SGVirtualHandActor.cpp

@@ -0,0 +1,146 @@
+/**
+ * @file
+ *
+ * @author  Mamadou Babaei <mamadou@senseglove.com>
+ *
+ * @section LICENSE
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2020 - 2023 SenseGlove
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * @section DESCRIPTION
+ *
+ *
+ */
+
+
+#include "SenseGlove/GameFramework/SGVirtualHandActor.h"
+
+#include "SenseGlove/Components/SGVirtualHandComponent.h"
+#include "SenseGlove/Components/SGWristTrackerComponent.h"
+
+struct ASGVirtualHandActor::FImpl
+{
+    /************************
+     * Owner object
+     ************************/
+
+    ASGVirtualHandActor* Owner;
+
+    /************************
+     * Constructor / Destructor
+     ************************/
+
+    explicit FImpl(ASGVirtualHandActor* InOwner);
+    ~FImpl();
+
+    /************************
+     * Default copy constructor & copy assignment operator
+     ************************/
+
+    FImpl(const FImpl& Rhs) = default;
+    FImpl& operator=(const FImpl& Rhs) = default;
+
+    /************************
+     * Methods
+     ************************/
+};
+
+ASGVirtualHandActor::ASGVirtualHandActor(const FObjectInitializer& ObjectInitializer)
+    : Super(ObjectInitializer),
+      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
+{
+    PrimaryActorTick.bCanEverTick = true;
+
+    SceneRoot = CreateDefaultSubobject<USceneComponent>(TEXT("SceneRoot"));
+    SetRootComponent(SceneRoot);
+
+    VirtualHand = CreateDefaultSubobject<USGVirtualHandComponent>(TEXT("VirtualHand"));
+    VirtualHand->SetupAttachment(RootComponent);
+    VirtualHand->SetRelativeRotation(FRotator{0.0f, -90.0f, 0.0f},
+                                     false, nullptr, ETeleportType::None);
+
+    WristTracker = CreateDefaultSubobject<USGWristTrackerComponent>(TEXT("WristTracker"));
+    WristTracker->SetupAttachment(RootComponent);
+
+    WristTracker->SetRight(VirtualHand->IsRight());
+}
+
+void ASGVirtualHandActor::BeginPlay()
+{
+    Super::BeginPlay();
+
+    ensureAlwaysMsgf(
+        (WristTracker->IsLeft() && VirtualHand->IsLeft())
+        || (WristTracker->IsRight() && VirtualHand->IsRight()),
+        TEXT("The virtual hand component and the wrist tracker component do not track the same hand!"));
+
+    WristTracker->OnWristLocationChanged().AddWeakLambda(this, [&](const FVector& Location)-> void
+    {
+        VirtualHand->SetRelativeLocation(Location);
+    });
+
+    WristTracker->OnWristRotationChanged().AddWeakLambda(this, [&](const FRotator& Rotation)-> void
+    {
+        VirtualHand->SetRelativeRotation(Rotation);
+    });
+}
+
+void ASGVirtualHandActor::PreInitializeComponents()
+{
+    Super::PreInitializeComponents();
+
+    WristTracker->SetRight(VirtualHand->IsRight());
+}
+
+bool ASGVirtualHandActor::IsLeft() const
+{
+    return WristTracker->IsLeft() && VirtualHand->IsLeft();
+}
+
+bool ASGVirtualHandActor::IsRight() const
+{
+    return WristTracker->IsRight() && VirtualHand->IsRight();
+}
+
+void ASGVirtualHandActor::SetRight(const bool bRight)
+{
+    WristTracker->SetRight(bRight);
+    VirtualHand->SetRight(bRight);
+}
+
+bool ASGVirtualHandActor::IsGloveConnected() const
+{
+    return VirtualHand->IsGloveConnected();
+}
+
+ASGVirtualHandActor::FImpl::FImpl(ASGVirtualHandActor* InOwner)
+    : Owner(InOwner)
+{
+}
+
+ASGVirtualHandActor::FImpl::~FImpl() = default;
+
+void ASGVirtualHandActor::FImplDeleter::operator()(const FImpl* P) const
+{
+    delete P;
+}

Source/SenseGlove/Public/SenseGlove/Animation/SGVirtualHandAnimInstance.h

@@ -0,0 +1,51 @@
+/**
+ * @file
+ *
+ * @author  Mamadou Babaei <mamadou@senseglove.com>
+ *
+ * @section LICENSE
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2020 - 2023 SenseGlove
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * @section DESCRIPTION
+ *
+ *
+ */
+
+
+#pragma once
+
+#include "Animation/AnimInstance.h"
+
+#include "SenseGlove/Animation/SGVirtualHandAnimInstanceProxy.h"
+
+#include "SGVirtualHandAnimInstance.generated.h"
+
+UCLASS(Transient, Blueprintable, BlueprintType, meta=(BlueprintThreadSafe), Within=SkeletalMeshComponent)
+class SENSEGLOVE_API USGVirtualHandAnimInstance : public UAnimInstance
+{
+    GENERATED_UCLASS_BODY()
+
+protected:
+    virtual FSGVirtualHandAnimInstanceProxy* CreateAnimInstanceProxy() override;
+};

Source/SenseGlove/Public/SenseGlove/Animation/SGVirtualHandAnimInstanceProxy.h

@@ -0,0 +1,60 @@
+/**
+ * @file
+ *
+ * @author  Mamadou Babaei <mamadou@senseglove.com>
+ *
+ * @section LICENSE
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2020 - 2023 SenseGlove
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * @section DESCRIPTION
+ *
+ *
+ */
+
+
+#pragma once
+
+#include "Animation/AnimInstanceProxy.h"
+#include "Templates/UniquePtr.h"
+#include "UObject/NameTypes.h"
+
+#include "SGVirtualHandAnimInstanceProxy.generated.h"
+
+USTRUCT()
+struct SENSEGLOVE_API FSGVirtualHandAnimInstanceProxy : public FAnimInstanceProxy
+{
+    GENERATED_USTRUCT_BODY()
+
+public:
+    TMap<FName, FRotator> BonesRotations;
+
+public:
+    FSGVirtualHandAnimInstanceProxy();
+    FSGVirtualHandAnimInstanceProxy(UAnimInstance* Instance);
+
+protected:
+    virtual void PreEvaluateAnimation(UAnimInstance* InAnimInstance) override;
+
+    virtual bool Evaluate(FPoseContext& Output) override;
+};

Source/SenseGlove/Public/SenseGlove/Components/SGVirtualHandComponent.h

@@ -0,0 +1,154 @@
+/**
+ * @file
+ *
+ * @author  Mamadou Babaei <mamadou@senseglove.com>
+ *
+ * @section LICENSE
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2020 - 2023 SenseGlove
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * @section DESCRIPTION
+ *
+ *
+ */
+
+
+#pragma once
+
+#include "Containers/Array.h"
+#include "Components/SkeletalMeshComponent.h"
+#include "Containers/Map.h"
+#include "GameFramework/Actor.h"
+#include "Math/Rotator.h"
+#include "Math/Transform.h"
+#include "ReferenceSkeleton.h"
+#include "Templates/UniquePtr.h"
+#include "UObject/NameTypes.h"
+
+#include "SGVirtualHandComponent.generated.h"
+
+class USkeletalMesh;
+
+class USGHandPose;
+class USGHapticGlove;
+
+UCLASS(Config=Engine, Blueprintable, ClassGroup=(Rendering, Common), hidecategories=(Object, "Mesh|SkeletalAsset"),
+    editinlinenew, meta=(BlueprintSpawnableComponent))
+class SENSEGLOVE_API USGVirtualHandComponent : public USkeletalMeshComponent
+{
+    GENERATED_UCLASS_BODY()
+
+public:
+    static const TArray<TArray<FName>>& GetLeftHandFingerBoneNames();
+    static const TArray<TArray<FName>>& GetRightHandFingerBoneNames();
+
+    static const FName& GetLeftHandFingerBoneName(int32 Finger, int32 Joint);
+    static const FName& GetRightHandFingerBoneName(int32 Finger, int32 Joint);
+
+private:
+    struct FImpl;
+
+    struct FImplDeleter
+    {
+        void operator()(const FImpl* P) const;
+    };
+
+    TUniquePtr<FImpl, FImplDeleter> Pimpl;
+    FImplDeleter PimplDeleter;
+
+private:
+    UPROPERTY(EditAnywhere, Category="SenseGlove", meta=(AllowPrivateAccess="false"))
+    uint8 bRight : 1;
+
+    UPROPERTY(EditAnywhere, Category="SenseGlove", meta=(AllowPrivateAccess="false"))
+    uint8 bHiddenInGameIfNoGloveDetected : 1;
+
+private:
+    UPROPERTY(Transient)
+    uint8 bBackendInitialized : 1;
+
+    UPROPERTY(Transient)
+    USGHapticGlove* Glove;
+
+public:
+    FORCEINLINE bool IsLeft() const
+    {
+        return !IsRight();
+    }
+
+    FORCEINLINE bool IsRight() const
+    {
+        return !!bRight;
+    }
+
+    void SetRight(const bool bInRight);
+
+    FORCEINLINE bool IsHiddenInGameIfNoGloveDetected() const
+    {
+        return !!bHiddenInGameIfNoGloveDetected;
+    }
+
+    FORCEINLINE void SetHiddenIfNoGloveDetected(const bool bInHiddenIfNoGloveDetected)
+    {
+        bHiddenInGameIfNoGloveDetected = bInHiddenIfNoGloveDetected;
+    }
+
+public:
+    virtual void SetAnimClass(class UClass* NewClass) override;
+
+	virtual void PostInitProperties() override;
+
+#if WITH_EDITOR
+    virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
+#endif  /* WITH_EDITOR */
+
+    virtual void InitializeComponent() override;
+
+    virtual void UninitializeComponent() override;
+
+    virtual void BeginPlay() override;
+
+    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
+
+    virtual void TickComponent(float DeltaTime,
+                               enum ELevelTick TickType,
+                               FActorComponentTickFunction* ThisTickFunction) override;
+
+    virtual void SetSkeletalMesh(USkeletalMesh* NewMesh, bool bReinitPose = true) override;
+
+protected:
+    virtual void EditorTick(float DeltaTime,
+                            enum ELevelTick TickType,
+                            FActorComponentTickFunction* ThisTickFunction);
+
+public:
+    bool IsGloveConnected() const;
+    USGHandPose* GetHandPose();
+
+public:
+    const FName& GetFingerBoneName(int32 Finger, int32 Joint) const;
+    const FTransform& GetFingerBoneRefTransform(int32 Finger, int32 Joint) const;
+
+    FRotator GetFingerBoneRefRotation(int32 Finger, int32 Joint) const;
+    TMap<FName, FRotator> GetFingersBonesRotations();
+};

Source/SenseGlove/Public/SenseGlove/Components/SGWristTrackerComponent.h

@@ -0,0 +1,311 @@
+/**
+ * @file
+ *
+ * @author  Mamadou Babaei <mamadou@senseglove.com>
+ *
+ * @section LICENSE
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2020 - 2023 SenseGlove
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * @section DESCRIPTION
+ *
+ *
+ */
+
+
+#pragma once
+
+#include "GameFramework/Actor.h"
+#include "Math/Rotator.h"
+#include "Math/Vector.h"
+#include "MotionControllerComponent.h"
+#include "Templates/UniquePtr.h"
+
+#include "SGTypes/SGCoreTypes.h"
+
+#include "SGWristTrackerComponent.generated.h"
+
+class USGHandPose;
+class USGHapticGlove;
+
+UCLASS(Blueprintable, ClassGroup = MotionController, meta = (BlueprintSpawnableComponent))
+class SENSEGLOVE_API USGWristTrackerComponent : public UMotionControllerComponent
+{
+    GENERATED_UCLASS_BODY()
+
+public:
+    DECLARE_EVENT_OneParam(USGWristTrackerComponent, FWristLocationChangedEvent, const FVector&)
+
+    FWristLocationChangedEvent& OnWristLocationChanged()
+    {
+        return WristLocationChangedEvent;
+    };
+
+    DECLARE_EVENT_OneParam(USGWristTrackerComponent, FWristRotationChangedEvent, const FRotator&)
+
+    FWristRotationChangedEvent& OnWristRotationChanged()
+    {
+        return WristRotationChangedEvent;
+    };
+
+    DECLARE_EVENT_TwoParams(USGWristTrackerComponent, FWristLocationAndRotationChangedEvent,
+                            const FVector&, const FRotator&)
+
+    FWristLocationAndRotationChangedEvent& OnWristLocationAndRotationChanged()
+    {
+        return WristLocationAndRotationChangedEvent;
+    };
+
+private:
+    FWristLocationChangedEvent WristLocationChangedEvent;
+    FWristRotationChangedEvent WristRotationChangedEvent;
+    FWristLocationAndRotationChangedEvent WristLocationAndRotationChangedEvent;
+
+private:
+    struct FImpl;
+
+    struct FImplDeleter
+    {
+        void operator()(const FImpl* P) const;
+    };
+
+    TUniquePtr<FImpl, FImplDeleter> Pimpl;
+    FImplDeleter PimplDeleter;
+
+private:
+    UPROPERTY(Config, EditAnywhere, Category = "Override Plugin Settings")
+    uint8 bOverridePluginWristTrackingSettings : 1;
+
+    /**
+     * If set to Custom, any desired location and rotation can be specified.
+     */
+    UPROPERTY(Config, EditAnywhere, Category = "Override Plugin Settings",
+        meta=(EditCondition="bOverridePluginWristTrackingSettings", EditConditionHides))
+    ESGPositionalTrackingHardware TrackingHardware;
+
+    /**
+     * Valid only if TrackingHardware is set to Custom.
+     */
+    UPROPERTY(Config, EditAnywhere, Category = "Override Plugin Settings",
+        meta=(EditCondition=
+            "bOverridePluginWristTrackingSettings && TrackingHardware == ESGPositionalTrackingHardware::Custom",
+            EditConditionHides))
+    FVector TrackingHardwareLocationOffset;
+
+    /**
+     * Valid only if TrackingHardware is set to Custom.
+     */
+    UPROPERTY(Config, EditAnywhere, Category = "Override Plugin Settings",
+        meta=(EditCondition=
+            "bOverridePluginWristTrackingSettings && TrackingHardware == ESGPositionalTrackingHardware::Custom",
+            EditConditionHides))
+    FRotator TrackingHardwareRotationOffset;
+
+    UPROPERTY(Config, EditAnywhere, Category = "Override Plugin Settings")
+    uint8 bOverridePluginWristTrackingDebugSettings : 1;
+
+    /**
+     * If enabled, draws debug Wrist trackers where possible.
+     */
+    UPROPERTY(Config, EditAnywhere, Category = "Override Plugin Settings",
+        meta=(EditCondition="bOverridePluginWristTrackingDebugSettings", EditConditionHides))
+    uint8 bDrawDebugWristTrackerGizmo : 1;
+
+    /**
+     * Valid only if bDrawDebugWristTrackerGizmo is enabled.
+     */
+    UPROPERTY(Config, EditAnywhere, Category = "Override Plugin Settings",
+        meta=(EditCondition="bOverridePluginWristTrackingDebugSettings && bDrawDebugWristTrackerGizmo",
+            EditConditionHides))
+    float DebugWristTrackerGizmoLength;
+
+    /**
+     * Valid only if bDrawDebugWristTrackerGizmo is enabled.
+     */
+    UPROPERTY(Config, EditAnywhere, Category = "Override Plugin Settings",
+        meta=(EditCondition="bOverridePluginWristTrackingDebugSettings && bDrawDebugWristTrackerGizmo",
+            EditConditionHides))
+    FColor DebugWristTrackerGizmoXAxisColor;
+
+    /**
+     * Valid only if bDrawDebugWristTrackerGizmo is enabled.
+     */
+    UPROPERTY(Config, EditAnywhere, Category = "Override Plugin Settings",
+        meta=(EditCondition="bOverridePluginWristTrackingDebugSettings && bDrawDebugWristTrackerGizmo",
+            EditConditionHides))
+    FColor DebugWristTrackerGizmoYAxisColor;
+
+    /**
+     * Valid only if bDrawDebugWristTrackerGizmo is enabled.
+     */
+    UPROPERTY(Config, EditAnywhere, Category = "Override Plugin Settings",
+        meta=(EditCondition="bOverridePluginWristTrackingDebugSettings && bDrawDebugWristTrackerGizmo",
+            EditConditionHides))
+    FColor DebugWristTrackerGizmoZAxisColor;
+
+    /**
+     * Valid only if bDrawDebugWristTrackerGizmo is enabled.
+     */
+    UPROPERTY(Config, EditAnywhere, Category = "Override Plugin Settings",
+        meta=(EditCondition="bOverridePluginWristTrackingDebugSettings && bDrawDebugWristTrackerGizmo",
+            EditConditionHides))
+    uint8 bDebugWristTrackerGizmoPersistentLines : 1;
+
+    /**
+     * Valid only if bDrawDebugWristTrackerGizmo is enabled.
+     */
+    UPROPERTY(Config, EditAnywhere, Category = "Override Plugin Settings",
+        meta=(EditCondition="bOverridePluginWristTrackingDebugSettings && bDrawDebugWristTrackerGizmo",
+            EditConditionHides))
+    float DebugWristTrackerGizmoLifeTimeModifier;
+
+    /**
+     * Valid only if bDrawDebugWristTrackerGizmo is enabled.
+     */
+    UPROPERTY(Config, EditAnywhere, Category = "Override Plugin Settings",
+        meta=(EditCondition="bOverridePluginWristTrackingDebugSettings && bDrawDebugWristTrackerGizmo",
+            EditConditionHides))
+    uint8 DebugWristTrackerGizmoDepthPriority;
+
+    /**
+     * Valid only if bDrawDebugWristTrackerGizmo is enabled.
+     */
+    UPROPERTY(Config, EditAnywhere, Category = "Override Plugin Settings",
+        meta=(EditCondition="bOverridePluginWristTrackingDebugSettings && bDrawDebugWristTrackerGizmo",
+            EditConditionHides))
+    float DebugWristTrackerGizmoThickness;
+
+private:
+    UPROPERTY(Transient)
+    uint8 bBackendInitialized : 1;
+
+    UPROPERTY(Transient)
+    USGHapticGlove* Glove;
+
+    UPROPERTY(Transient)
+    FVector WristLocation;
+
+    UPROPERTY(Transient)
+    FRotator WristRotation;
+
+public:
+    FORCEINLINE bool OverridesPluginWristTrackingSettings() const
+    {
+        return !!bOverridePluginWristTrackingSettings;
+    }
+
+    FORCEINLINE void OverridePluginWristTrackingSettings(const bool bInOverridePluginWristTrackingSettings)
+    {
+        bOverridePluginWristTrackingSettings = bInOverridePluginWristTrackingSettings;
+    }
+
+    ESGPositionalTrackingHardware GetTrackingHardware() const;
+    void SetTrackingHardware(ESGPositionalTrackingHardware InTrackingHardware);
+
+    const FVector& GetTrackingHardwareLocationOffset() const;
+    void SetTrackingHardwareLocationOffset(const FVector& InTrackingHardwareLocationOffset);
+
+    const FRotator& GetTrackingHardwareRotationOffset() const;
+    void SetTrackingHardwareRotationOffset(const FRotator& InTrackingHardwareRotationOffset);
+
+    FORCEINLINE bool OverridesPluginWristTrackingDebugSettings() const
+    {
+        return !!bOverridePluginWristTrackingDebugSettings;
+    }
+
+    FORCEINLINE void OverridePluginWristTrackingDebugSettings(const bool bInOverridePluginWristTrackingDebugSettings)
+    {
+        bOverridePluginWristTrackingDebugSettings = bInOverridePluginWristTrackingDebugSettings;
+    }
+
+    bool GetDrawDebugWristTrackerGizmo() const;
+    void SetDrawDebugWristTrackerGizmo(bool bInDrawDebugWristTrackerGizmo);
+
+    float GetDebugWristTrackerGizmoLength() const;
+    void SetDebugWristTrackerGizmoLength(float InDebugWristTrackerGizmoLength);
+
+    const FColor& GetDebugWristTrackerGizmoXAxisColor() const;
+    void SetDebugWristTrackerGizmoXAxisColor(const FColor& InDebugWristTrackerGizmoXAxisColor);
+
+    const FColor& GetDebugWristTrackerGizmoYAxisColor() const;
+    void SetDebugWristTrackerGizmoYAxisColor(const FColor& InDebugWristTrackerGizmoYAxisColor);
+
+    const FColor& GetDebugWristTrackerGizmoZAxisColor() const;
+    void SetDebugWristTrackerGizmoZAxisColor(const FColor& InDebugWristTrackerGizmoZAxisColor);
+
+    bool GetDebugWristTrackerGizmoPersistentLines() const;
+    void SetDebugWristTrackerGizmoPersistentLines(bool bInDebugWristTrackerGizmoPersistentLines);
+
+    float GetDebugWristTrackerGizmoLifeTimeModifier() const;
+    void SetDebugWristTrackerGizmoLifeTimeModifier(float InDebugWristTrackerGizmoLifeTimeModifier);
+
+    uint8 GetDebugWristTrackerGizmoDepthPriority() const;
+    void SetDebugWristTrackerGizmoDepthPriority(uint8 InDebugWristTrackerGizmoDepthPriority);
+
+    float GetDebugWristTrackerGizmoThickness() const;
+    void SetDebugWristTrackerGizmoThickness(float InDebugWristTrackerGizmoThickness);
+
+    FORCEINLINE bool IsLeft() const
+    {
+        return GetTrackingSource() == EControllerHand::Left;
+    }
+
+    FORCEINLINE bool IsRight() const
+    {
+        return GetTrackingSource() == EControllerHand::Right;
+    }
+
+    void SetRight(const bool bRight);
+
+    FORCEINLINE const FVector& GetWristLocation() const
+    {
+        return WristLocation;
+    }
+
+    FORCEINLINE const FRotator& GetWristRotation() const
+    {
+        return WristRotation;
+    }
+
+public:
+#if WITH_EDITOR
+    virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
+#endif  /* WITH_EDITOR */
+
+    virtual void InitializeComponent() override;
+
+    virtual void UninitializeComponent() override;
+
+    virtual void BeginPlay() override;
+
+    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
+
+    virtual void TickComponent(float DeltaTime,
+                               enum ELevelTick TickType,
+                               FActorComponentTickFunction* ThisTickFunction) override;
+
+protected:
+    virtual void EditorTick(float DeltaTime,
+                            enum ELevelTick TickType,
+                            FActorComponentTickFunction* ThisTickFunction);
+};

Source/SenseGlove/Public/SenseGlove/GameFramework/SGGameModeBase.h

@@ -0,0 +1,46 @@
+/**
+ * @file
+ *
+ * @author  Mamadou Babaei <mamadou@senseglove.com>
+ *
+ * @section LICENSE
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2020 - 2023 SenseGlove
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * @section DESCRIPTION
+ *
+ *
+ */
+
+
+#pragma once
+
+#include "GameFramework/GameModeBase.h"
+
+#include "SGGameModeBase.generated.h"
+
+UCLASS(Config=Game, NotPlaceable, BlueprintType, Blueprintable, Transient)
+class SENSEGLOVE_API ASGGameModeBase : public AGameModeBase
+{
+	GENERATED_UCLASS_BODY()
+};

Source/SenseGlove/Public/SenseGlove/GameFramework/SGPawn.h

@@ -0,0 +1,112 @@
+/**
+ * @file
+ *
+ * @author  Mamadou Babaei <mamadou@senseglove.com>
+ *
+ * @section LICENSE
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2020 - 2023 SenseGlove
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * @section DESCRIPTION
+ *
+ *
+ */
+
+
+#pragma once
+
+#include "GameFramework/Pawn.h"
+#include "Templates/UniquePtr.h"
+
+#include "SGPawn.generated.h"
+
+class UCameraComponent;
+
+class USGVirtualHandComponent;
+class USGWristTrackerComponent;
+
+UCLASS(Config=Game, BlueprintType, Blueprintable)
+class SENSEGLOVE_API ASGPawn : public APawn
+{
+    GENERATED_UCLASS_BODY()
+
+private:
+    struct FImpl;
+
+    struct FImplDeleter
+    {
+        void operator()(const FImpl* P) const;
+    };
+
+    TUniquePtr<FImpl, FImplDeleter> Pimpl;
+    FImplDeleter PimplDeleter;
+
+private:
+    UPROPERTY(VisibleAnywhere, Category="SenseGlove", meta=(AllowPrivateAccess="false"))
+    USceneComponent* SceneRoot;
+
+    UPROPERTY(VisibleAnywhere, Category="SenseGlove", meta=(AllowPrivateAccess="false"))
+    UCameraComponent* Camera;
+
+    UPROPERTY(VisibleAnywhere, Category="SenseGlove", meta=(AllowPrivateAccess="false"))
+    USGWristTrackerComponent* WristTrackerLeft;
+
+    UPROPERTY(VisibleAnywhere, Category="SenseGlove", meta=(AllowPrivateAccess="false"))
+    USGWristTrackerComponent* WristTrackerRight;
+
+    UPROPERTY(VisibleAnywhere, Category="SenseGlove", meta=(AllowPrivateAccess="false"))
+    USGVirtualHandComponent* HandLeft;
+
+    UPROPERTY(VisibleAnywhere, Category="SenseGlove", meta=(AllowPrivateAccess="false"))
+    USGVirtualHandComponent* HandRight;
+
+public:
+    FORCEINLINE UCameraComponent* GetCamera() const
+    {
+        return Camera;
+    }
+
+    FORCEINLINE USGWristTrackerComponent* GetWristTrackerLeft() const
+    {
+        return WristTrackerLeft;
+    }
+
+    FORCEINLINE USGWristTrackerComponent* GetWristTrackerRight() const
+    {
+        return WristTrackerRight;
+    }
+
+    FORCEINLINE USGVirtualHandComponent* GetHandLeft() const
+    {
+        return HandLeft;
+    }
+
+    FORCEINLINE USGVirtualHandComponent* GetHandRight() const
+    {
+        return HandRight;
+    }
+
+public:
+    virtual void BeginPlay() override;
+    virtual void PreInitializeComponents() override;
+};

Source/SenseGlove/Public/SenseGlove/GameFramework/SGPlayerController.h

@@ -35,8 +35,15 @@
 
 #pragma once
 
-#if ( ( defined( _MSVC_LANG ) && _MSVC_LANG >= 201703L ) || __cplusplus >= 201703L )
-#define SG_CPP17 1
-#else   /* ( ( defined( _MSVC_LANG ) && _MSVC_LANG >= 201703L ) || __cplusplus >= 201703L ) */
-#define SG_CPP17 0
-#endif  /* ( ( defined( _MSVC_LANG ) && _MSVC_LANG >= 201703L ) || __cplusplus >= 201703L ) */
+#include "GameFramework/PlayerController.h"
+
+#include "SGPlayerController.generated.h"
+
+UCLASS(Config=Game, BlueprintType, Blueprintable)
+class SENSEGLOVE_API ASGPlayerController : public APlayerController
+{
+    GENERATED_UCLASS_BODY()
+
+protected:
+    virtual void SetupInputComponent() override;
+};

Source/SenseGlove/Public/SenseGlove/GameFramework/SGVirtualHandActor.h

@@ -0,0 +1,107 @@
+/**
+ * @file
+ *
+ * @author  Mamadou Babaei <mamadou@senseglove.com>
+ *
+ * @section LICENSE
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2020 - 2023 SenseGlove
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * @section DESCRIPTION
+ *
+ *
+ */
+
+
+#pragma once
+
+#include "Containers/Array.h"
+#include "Containers/Map.h"
+#include "GameFramework/Actor.h"
+#include "Templates/UniquePtr.h"
+#include "UObject/NameTypes.h"
+
+#include "SGVirtualHandActor.generated.h"
+
+class USkeletalMesh;
+class USkeleton;
+class USceneComponent;
+
+class USGHandPose;
+class USGVirtualHandComponent;
+class USGWristTrackerComponent;
+
+UCLASS(Config=Game, BlueprintType)
+class SENSEGLOVE_API ASGVirtualHandActor : public AActor
+{
+    GENERATED_UCLASS_BODY()
+
+private:
+    struct FImpl;
+
+    struct FImplDeleter
+    {
+        void operator()(const FImpl* P) const;
+    };
+
+    TUniquePtr<FImpl, FImplDeleter> Pimpl;
+    FImplDeleter PimplDeleter;
+
+private:
+    UPROPERTY(VisibleAnywhere, Category="SenseGlove", meta=(AllowPrivateAccess="false"))
+    USceneComponent* SceneRoot;
+
+    UPROPERTY(VisibleAnywhere, Category="SenseGlove", meta=(AllowPrivateAccess="false"))
+    USGWristTrackerComponent* WristTracker;
+
+    UPROPERTY(VisibleAnywhere, Category="SenseGlove", meta=(AllowPrivateAccess="false"))
+    USGVirtualHandComponent* VirtualHand;
+
+public:
+    FORCEINLINE USGWristTrackerComponent* GetWristTracker() const
+    {
+        return WristTracker;
+    }
+
+    FORCEINLINE USGVirtualHandComponent* GetVirtualHand() const
+    {
+        return VirtualHand;
+    }
+
+protected:
+    FORCEINLINE void SetMesh(USGVirtualHandComponent* InVirtualHand)
+    {
+        VirtualHand = InVirtualHand;
+    }
+
+public:
+    virtual void BeginPlay() override;
+    virtual void PreInitializeComponents() override;
+
+public:
+    bool IsLeft() const;
+    bool IsRight() const;
+    void SetRight(bool bRight);
+
+    bool IsGloveConnected() const;
+};

Source/SenseGlove/SenseGlove.Build.cs

@@ -52,11 +52,14 @@ public class SenseGlove : ModuleRules
         PrivateDependencyModuleNames.AddRange(
             new string[]
             {
+                "AnimGraphRuntime",
                 "CoreUObject",
                 "Engine",
+                "HeadMountedDisplay",
                 "SenseGloveConnect",
                 "SenseGloveCore",
                 "SenseGloveLog",
+                "SenseGloveSettings",
                 "SenseGloveTypes",
             }
         );

Source/SenseGloveAndroid/Private/SGAndroid/SGConnectJNI.cpp

@@ -40,8 +40,11 @@
 #include "Android/AndroidJava.h"
 #endif  /* PLATFORM_ANDROID */
 
+#include "Misc/Paths.h"
+
 #if PLATFORM_ANDROID
 #include "SGConnectImpl/SGExportedFunctions.h"
+#include "SGInterop/SGIC_FString.h"
 #include "SGInterop/SGIC_jclass.h"
 #include "SGInterop/SGIC_jmethodID.h"
 #include "SGInterop/SGIC_JNIEnv_Ptr.h"
@@ -110,10 +113,13 @@ int32 FSGConnectJNI::Initialize()
     }
     FSGIC_jmethodID InGetLibraryVersionMethodIDContainer{GetLibraryVersionMethodID};
 
+    FSGIC_FString ProjectSavedDirContainer{FPaths::ProjectSavedDir()};
+
     Result = SGConnectImpl_Android_Initialize(&InEnvContainer, &InClassContainer,
                                               &InInitMethodIDContainer,
                                               &InDisposeMethodIDContainer,
-                                              &InGetLibraryVersionMethodIDContainer);
+                                              &InGetLibraryVersionMethodIDContainer,
+                                              &ProjectSavedDirContainer);
 #endif  /* PLATFORM_ANDROID */
 
     return Result;

Source/SenseGloveAndroid/Private/SGAndroid/SGCoreJNI.cpp

@@ -40,8 +40,11 @@
 #include "Android/AndroidJava.h"
 #endif  /* PLATFORM_ANDROID */
 
+#include "Misc/Paths.h"
+
 #if PLATFORM_ANDROID
 #include "SGCoreImpl/SGExportedFunctions.h"
+#include "SGInterop/SGIC_FString.h"
 #include "SGInterop/SGIC_jclass.h"
 #include "SGInterop/SGIC_jmethodID.h"
 #include "SGInterop/SGIC_JNIEnv_Ptr.h"
@@ -123,11 +126,14 @@ int32 FSGCoreJNI::Initialize()
     }
     FSGIC_jmethodID InWriteHapticsMethodIDContainer{WriteHapticsMethodID};
 
+    FSGIC_FString ProjectSavedDirContainer{FPaths::ProjectSavedDir()};
+
     Result = SGCoreImpl_Android_Initialize(&InEnvContainer, &InClassContainer,
                                            &InActiveDevicesMethodIDContainer,
                                            &InGetDeviceStringMethodIDContainer,
                                            &InGetSensorStringMethodIDContainer,
-                                           &InWriteHapticsMethodIDContainer);
+                                           &InWriteHapticsMethodIDContainer,
+                                           &ProjectSavedDirContainer);
 #endif  /* PLATFORM_ANDROID */
 
     return Result;

Source/SenseGloveAndroid/SenseGloveAndroid.Build.cs

@@ -64,15 +64,8 @@ public class SenseGloveAndroid : ModuleRules
 
         if (Target.Platform == UnrealTargetPlatform.Android)
         {
-            PrivateIncludePathModuleNames.AddRange(
-                new string[]
-                {
-                    "Launch",
-                    "Settings",
-                }
-            );
-
-            AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(ModuleDirectory, "SenseGloveAndroid_UPL.xml"));
+            AdditionalPropertiesForReceipt.Add("AndroidPlugin",
+                Path.Combine(ModuleDirectory, "SenseGloveAndroid_UPL.xml"));
         }
     }
 }

Source/SenseGloveConnectImpl/Private/SGConnectImpl/SGExportedFunctions.cpp

@@ -60,14 +60,16 @@ int32 SGConnectImpl_Android_Initialize(
     void* InClass,
     void* InInitMethodID,
     void* InDisposeMethodID,
-    void* InGetLibraryVersionMethodID)
+    void* InGetLibraryVersionMethodID,
+    void* StoragePath)
 {
     return SGConnect::Android::Initialize(
         StaticCast<FSGIC_JNIEnv_Ptr*>(InEnv)->Ptr,
         StaticCast<FSGIC_jclass*>(InClass)->Class,
         StaticCast<FSGIC_jmethodID*>(InInitMethodID)->MethodID,
         StaticCast<FSGIC_jmethodID*>(InDisposeMethodID)->MethodID,
-        StaticCast<FSGIC_jmethodID*>(InGetLibraryVersionMethodID)->MethodID);
+        StaticCast<FSGIC_jmethodID*>(InGetLibraryVersionMethodID)->MethodID,
+        std::string{TCHAR_TO_UTF8(*StaticCast<FSGIC_FString*>(StoragePath)->String)});
 }
 #endif  /* PLATFORM_ANDROID */
 

Source/SenseGloveConnectImpl/Public/SGConnectImpl/SGConnectImpl.h

@@ -47,7 +47,7 @@ public:
       * -3 : An Unexpected error occured. Please try again.
       * -2 : Device Scanning is already running within a different program.
       * -1 : Device Scanning already being initialized (function called twice in short succession).
-      * 0 : Device Scanning is already running in within this program.
+      * 0 : Device Scanning is already running within this program.
       * 1 : Successfully started up DeviceScanning from the current program.
      */
     static int32 Init();

Source/SenseGloveConnectImpl/Public/SGConnectImpl/SGExportedFunctions.h

@@ -74,7 +74,8 @@ SENSEGLOVECONNECTIMPL_PUBLIC_API int32 SGConnectImpl_Android_Initialize(
     void* InClass,
     void* InInitMethodID,
     void* InDisposeMethodID,
-    void* InGetLibraryVersionMethodID);
+    void* InGetLibraryVersionMethodID,
+    void* StoragePath);
 #endif  /* PLATFORM_ANDROID */
 
 /*******************************************************************************

Source/SenseGloveConnectImpl/SenseGloveConnectImpl.Build.cs

@@ -83,12 +83,33 @@ public class SenseGloveConnectImpl : ModuleRules
 
         if (Target.Platform == UnrealTargetPlatform.Android)
         {
-#if ! UE_5_2_OR_LATER
+            LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "android"));
+
+#if UE_5_1_OR_LATER
+            LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "r25b"));
+#elif UE_4_27_OR_LATER
+            LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "r21e"));
+#else
+            Debug.Assert(false, "Developing for Android on UE versions older than 4.27 is not supported!");
+#endif
+
+#if UE_5_2_OR_LATER
+            if (Target.Architecture == UnrealArch.Arm64)
+            {
+                LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "arm64"));
+            }
+            else if (Target.Architecture == UnrealArch.X64)
+            {
+                LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "x64"));
+            }
+            else
+            {
+                Debug.Assert(false, "Unsupported Android architecture!");
+            }
+#else
             IAndroidToolChain ToolChain = AndroidExports.CreateToolChain(Target.ProjectFile);
             List<string> Architectures = ToolChain.GetAllArchitectures();
 
-            LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "android"));
-
             foreach (string Arch in Architectures)
             {
                 if (Arch == "-arm64")
@@ -113,15 +134,13 @@ public class SenseGloveConnectImpl : ModuleRules
                 }
                 else
                 {
-                    Debug.Assert(false, "Only AArch64/ARM64 variant of Android is supported!");
+                    Debug.Assert(false, "Unsupported Android architecture!");
                     break;
                 }
             }
+#endif
 
             LibraryName = string.Format("lib{0}.a", LibraryName);
-#else
-            Debug.Assert(false, "Developing for Android on UE 5.2+ is not yet supported!");
-#endif
         }
         else if (Target.Platform == UnrealTargetPlatform.Linux)
         {
@@ -134,18 +153,8 @@ public class SenseGloveConnectImpl : ModuleRules
             LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "v20"));
 #elif UE_4_27_OR_LATER
             LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "v19"));
-#elif UE_4_26_OR_LATER
-            LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "v17"));
-#elif UE_4_25_OR_LATER
-            LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "v16"));
-#elif UE_4_24_OR_LATER
-            LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "v15"));
-#elif UE_4_23_OR_LATER
-            LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "v15"));
-#elif UE_4_22_OR_LATER
-            LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "v13"));
 #else
-            Debug.Assert(false, "Unsupported compiler!");
+            Debug.Assert(false, "Unsupported engine version or compiler!");
 #endif
         }
         else if (Target.Platform == UnrealTargetPlatform.Win64)
@@ -157,19 +166,17 @@ public class SenseGloveConnectImpl : ModuleRules
                 case WindowsCompiler.VisualStudio2022:
                     LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "msvc143"));
                     break;
-#endif
-#if UE_4_22_OR_LATER
                 case WindowsCompiler.VisualStudio2019:
                     LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "msvc142"));
                     break;
 #endif
-#if ! UE_5_0_OR_LATER && UE_4_17_OR_LATER
+#if ! UE_5_0_OR_LATER && UE_4_27_OR_LATER
                 case WindowsCompiler.VisualStudio2017:
                     LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "msvc141"));
                     break;
 #endif
                 default:
-                    Debug.Assert(false, "Unsupported compiler!");
+                    Debug.Assert(false, "Unsupported engine version or compiler!");
                     break;
             }
 
@@ -207,12 +214,33 @@ public class SenseGloveConnectImpl : ModuleRules
 
         if (Target.Platform == UnrealTargetPlatform.Android)
         {
-#if ! UE_5_2_OR_LATER
+            LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "android"));
+
+#if UE_5_1_OR_LATER
+            LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "r25b"));
+#elif UE_4_27_OR_LATER
+            LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "r21e"));
+#else
+            Debug.Assert(false, "Developing for Android on UE versions older than 4.27 is not supported!");
+#endif
+
+#if UE_5_2_OR_LATER
+            if (Target.Architecture == UnrealArch.Arm64)
+            {
+                LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "arm64"));
+            }
+            else if (Target.Architecture == UnrealArch.X64)
+            {
+                LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "x64"));
+            }
+            else
+            {
+                Debug.Assert(false, "Unsupported Android architecture!");
+            }
+#else
             IAndroidToolChain ToolChain = AndroidExports.CreateToolChain(Target.ProjectFile);
             List<string> Architectures = ToolChain.GetAllArchitectures();
 
-            LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "android"));
-
             foreach (string Arch in Architectures)
             {
                 if (Arch == "-arm64")
@@ -237,15 +265,13 @@ public class SenseGloveConnectImpl : ModuleRules
                 }
                 else
                 {
-                    Debug.Assert(false, "Only AArch64/ARM64 variant of Android is supported!");
+                    Debug.Assert(false, "Unsupported Android architecture!");
                     break;
                 }
             }
+#endif
 
             LibraryName = string.Format("lib{0}.a", LibraryName);
-#else
-            Debug.Assert(false, "Developing for Android on UE 5.2+ is not yet supported!");
-#endif
         }
         else if (Target.Platform == UnrealTargetPlatform.Linux)
         {
@@ -258,18 +284,8 @@ public class SenseGloveConnectImpl : ModuleRules
             LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "v20"));
 #elif UE_4_27_OR_LATER
             LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "v19"));
-#elif UE_4_26_OR_LATER
-            LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "v17"));
-#elif UE_4_25_OR_LATER
-            LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "v16"));
-#elif UE_4_24_OR_LATER
-            LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "v15"));
-#elif UE_4_23_OR_LATER
-            LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "v15"));
-#elif UE_4_22_OR_LATER
-            LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "v13"));
 #else
-            Debug.Assert(false, "Unsupported compiler!");
+            Debug.Assert(false, "Unsupported engine version or compiler!");
 #endif
         }
         else if (Target.Platform == UnrealTargetPlatform.Win64)
@@ -281,19 +297,17 @@ public class SenseGloveConnectImpl : ModuleRules
                 case WindowsCompiler.VisualStudio2022:
                     LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "msvc143"));
                     break;
-#endif
-#if UE_4_22_OR_LATER
                 case WindowsCompiler.VisualStudio2019:
                     LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "msvc142"));
                     break;
 #endif
-#if ! UE_5_0_OR_LATER && UE_4_17_OR_LATER
+#if ! UE_5_0_OR_LATER && UE_4_27_OR_LATER
                 case WindowsCompiler.VisualStudio2017:
                     LibraryPath = Path.GetFullPath(Path.Combine(LibraryPath, "msvc141"));
                     break;
 #endif
                 default:
-                    Debug.Assert(false, "Unsupported compiler!");
+                    Debug.Assert(false, "Unsupported engine version or compiler!");
                     break;
             }
 

Source/SenseGloveCore/Private/SGCore/SGAnatomy.cpp

@@ -68,14 +68,14 @@ float FSGAnatomy::GetThumbJointLimit(const bool bRightHanded, const int32 Joint,
     return SGCoreImpl_FSGAnatomyImpl_GetThumbJointLimit(bRightHanded, Joint, Movement, bMax);
 }
 
-float FSGAnatomy::NormalizeFingerFlexion(const float FlexionInRadians)
+float FSGAnatomy::NormalizeFingerFlexion(const float FlexionInDegrees)
 {
-    return SGCoreImpl_FSGAnatomyImpl_NormalizeFingerFlexion(FlexionInRadians);
+    return SGCoreImpl_FSGAnatomyImpl_NormalizeFingerFlexion(FlexionInDegrees);
 }
 
-float FSGAnatomy::NormalizeThumbFlexion(const float FlexionInRadians)
+float FSGAnatomy::NormalizeThumbFlexion(const float FlexionInDegrees)
 {
-    return SGCoreImpl_FSGAnatomyImpl_NormalizeThumbFlexion(FlexionInRadians);
+    return SGCoreImpl_FSGAnatomyImpl_NormalizeThumbFlexion(FlexionInDegrees);
 }
 
 TArray<TArray<FVector>> FSGAnatomy::GetDefaultHandAngles(const bool bRightHanded)

Source/SenseGloveCore/Private/SGCore/SGBasicHandModel.cpp

@@ -76,13 +76,6 @@ struct USGBasicHandModel::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-    void SyncImplObject();
 };
 
 USGBasicHandModel* USGBasicHandModel::NewBasicHandModel(UObject* Outer, const FSGBasicHandModelImpl& BasicHandModelImpl)
@@ -233,28 +226,17 @@ TArray<FVector> USGBasicHandModel::GetBaseJointAngles()
 }
 
 USGBasicHandModel::USGBasicHandModel()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGBasicHandModelImpl OutBasicHandModelImplContainer;
     SGCoreImpl_FSGBasicHandModelImpl_ctor(&OutBasicHandModelImplContainer);
 
     Pimpl->BasicHandModelImpl = MoveTemp(OutBasicHandModelImplContainer.BasicHandModelImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGBasicHandModel::USGBasicHandModel(const bool bRightHanded, const TArray<TArray<float>>& Lengths,
                                      const TArray<FVector>& StartPositions)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGBasicHandModelImpl OutBasicHandModelImplContainer;
     FSGIC_TArray_TArray_float LengthsContainer{Lengths};
@@ -263,17 +245,11 @@ USGBasicHandModel::USGBasicHandModel(const bool bRightHanded, const TArray<TArra
         &OutBasicHandModelImplContainer, bRightHanded, &LengthsContainer, &StartPositionsContainer);
 
     Pimpl->BasicHandModelImpl = MoveTemp(OutBasicHandModelImplContainer.BasicHandModelImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGBasicHandModel::USGBasicHandModel(bool bRightHanded, const TArray<FSGFloatArray>& Lengths,
                                      const TArray<FVector>& StartPositions)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGBasicHandModelImpl OutBasicHandModelImplContainer;
     FSGIC_TArray_TArray_float LengthsContainer{
@@ -284,17 +260,11 @@ USGBasicHandModel::USGBasicHandModel(bool bRightHanded, const TArray<FSGFloatArr
         &OutBasicHandModelImplContainer, bRightHanded, &LengthsContainer, &StartPositionsContainer);
 
     Pimpl->BasicHandModelImpl = MoveTemp(OutBasicHandModelImplContainer.BasicHandModelImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGBasicHandModel::USGBasicHandModel(const bool bRightHanded, const TArray<TArray<float>>& Lengths,
                                      const TArray<FVector>& StartPositions, const TArray<FQuat>& StartRotations)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGBasicHandModelImpl OutBasicHandModelImplContainer;
     FSGIC_TArray_TArray_float LengthsContainer{Lengths};
@@ -305,17 +275,11 @@ USGBasicHandModel::USGBasicHandModel(const bool bRightHanded, const TArray<TArra
         &StartPositionsContainer, &StartRotationsContainer);
 
     Pimpl->BasicHandModelImpl = MoveTemp(OutBasicHandModelImplContainer.BasicHandModelImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGBasicHandModel::USGBasicHandModel(const bool bRightHanded, const TArray<TArray<float>>& Lengths,
                                      const TArray<FVector>& StartPositions, const TArray<FRotator>& StartRotations)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGBasicHandModelImpl OutBasicHandModelImplContainer;
     FSGIC_TArray_TArray_float LengthsContainer{Lengths};
@@ -326,17 +290,11 @@ USGBasicHandModel::USGBasicHandModel(const bool bRightHanded, const TArray<TArra
         &StartPositionsContainer, &StartRotationsContainer);
 
     Pimpl->BasicHandModelImpl = MoveTemp(OutBasicHandModelImplContainer.BasicHandModelImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGBasicHandModel::USGBasicHandModel(const bool bRightHanded, const TArray<FSGFloatArray>& Lengths,
                                      const TArray<FVector>& StartPositions, const TArray<FQuat>& StartRotations)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGBasicHandModelImpl OutBasicHandModelImplContainer;
     FSGIC_TArray_TArray_float LengthsContainer{
@@ -349,17 +307,11 @@ USGBasicHandModel::USGBasicHandModel(const bool bRightHanded, const TArray<FSGFl
         &StartPositionsContainer, &StartRotationsContainer);
 
     Pimpl->BasicHandModelImpl = MoveTemp(OutBasicHandModelImplContainer.BasicHandModelImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGBasicHandModel::USGBasicHandModel(const bool bRightHanded, const TArray<FSGFloatArray>& Lengths,
                                      const TArray<FVector>& StartPositions, const TArray<FRotator>& StartRotations)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGBasicHandModelImpl OutBasicHandModelImplContainer;
     FSGIC_TArray_TArray_float LengthsContainer{
@@ -372,19 +324,12 @@ USGBasicHandModel::USGBasicHandModel(const bool bRightHanded, const TArray<FSGFl
         &StartPositionsContainer, &StartRotationsContainer);
 
     Pimpl->BasicHandModelImpl = MoveTemp(OutBasicHandModelImplContainer.BasicHandModelImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGBasicHandModel::USGBasicHandModel(const FSGBasicHandModelImpl& BasicHandModelImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     SetBasicHandModelImpl(BasicHandModelImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGBasicHandModel::~USGBasicHandModel() = default;
@@ -399,13 +344,11 @@ void USGBasicHandModel::SetBasicHandModelImpl(const FSGBasicHandModelImpl& Basic
 
 const FSGBasicHandModelImpl& USGBasicHandModel::ToBasicHandModelImpl() const
 {
-    Pimpl->SyncImplObject();
     return Pimpl->BasicHandModelImpl;
 }
 
 FSGBasicHandModelImpl& USGBasicHandModel::ToBasicHandModelImpl()
 {
-    Pimpl->SyncImplObject();
     return Pimpl->BasicHandModelImpl;
 }
 
@@ -425,8 +368,6 @@ TArray<TArray<float>> USGBasicHandModel::GetFingerLengths() const
 
 TArray<float> USGBasicHandModel::GetFingerLengths(const ESGFinger Finger) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
     FSGIC_TArray_float OutLengthsContainer;
     FSGIC_ESGFinger FingerContainer{Finger};
@@ -437,26 +378,18 @@ TArray<float> USGBasicHandModel::GetFingerLengths(const ESGFinger Finger) const
 
 void USGBasicHandModel::SetFingerLengths(const ESGFinger Finger, const TArray<float>& Lengths)
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
     FSGIC_ESGFinger FingerContainer{Finger};
     FSGIC_TArray_float LengthsContainer{Lengths};
     SGCoreImpl_FSGBasicHandModelImpl_SetFingerLengths_ESGFinger(&InstanceContainer, &FingerContainer,
                                                                 &LengthsContainer);
-
-    Pimpl->SyncUProperties();
 }
 
 void USGBasicHandModel::SetFingerLengths(const uint8 Finger, const TArray<float>& Lengths)
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
     FSGIC_TArray_float LengthsContainer{Lengths};
     SGCoreImpl_FSGBasicHandModelImpl_SetFingerLengths_uint8Finger(&InstanceContainer, Finger, &LengthsContainer);
-
-    Pimpl->SyncUProperties();
 }
 
 TArray<TArray<float>> USGBasicHandModel::GetFingerRatios() const
@@ -469,8 +402,6 @@ TArray<TArray<float>> USGBasicHandModel::GetFingerRatios() const
 
 TArray<float> USGBasicHandModel::GetFingerRatios(const ESGFinger Finger) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
     FSGIC_ESGFinger FingerContainer{Finger};
     FSGIC_TArray_float OutRatiosContainer;
@@ -489,26 +420,18 @@ TArray<FVector> USGBasicHandModel::GetStartJointPositions() const
 
 void USGBasicHandModel::SetStartJointPosition(const ESGFinger Finger, const FVector& Position)
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
     FSGIC_ESGFinger FingerContainer{Finger};
     FSGIC_FVector PositionContainer{Position};
     SGCoreImpl_FSGBasicHandModelImpl_SetStartJointPosition_ESGFinger(&InstanceContainer, &FingerContainer,
                                                                      &PositionContainer);
-
-    Pimpl->SyncUProperties();
 }
 
 void USGBasicHandModel::SetStartJointPosition(const uint8 Finger, const FVector& Position)
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
     FSGIC_FVector PositionContainer{Position};
     SGCoreImpl_FSGBasicHandModelImpl_SetStartJointPosition_uin8Finger(&InstanceContainer, Finger, &PositionContainer);
-
-    Pimpl->SyncUProperties();
 }
 
 TArray<FQuat> USGBasicHandModel::GetStartJointRotationsQ() const
@@ -529,74 +452,53 @@ TArray<FRotator> USGBasicHandModel::GetStartJointRotations() const
 
 FVector USGBasicHandModel::GetJointPosition(const ESGFinger Finger) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
     FSGIC_FVector OutPositionContainer;
     FSGIC_ESGFinger FingerContainer{Finger};
     SGCoreImpl_FSGBasicHandModelImpl_GetJointPosition(&InstanceContainer, &OutPositionContainer, &FingerContainer);
-
     return MoveTemp(OutPositionContainer.Vector);
 }
 
 void USGBasicHandModel::SetJointPosition(const FVector& NewPosition, const ESGFinger Finger)
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
     FSGIC_FVector NewPositionContainer{NewPosition};
     FSGIC_ESGFinger FingerContainer{Finger};
     SGCoreImpl_FSGBasicHandModelImpl_SetJointPosition(&InstanceContainer, &NewPositionContainer, &FingerContainer);
-
-    Pimpl->SyncUProperties();
 }
 
 FQuat USGBasicHandModel::GetJointRotationQ(const ESGFinger Finger) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
     FSGIC_FQuat OutRotationContainer;
     FSGIC_ESGFinger FingerContainer{Finger};
     SGCoreImpl_FSGBasicHandModelImpl_GetJointRotation(&InstanceContainer, &OutRotationContainer, &FingerContainer);
-
     return MoveTemp(OutRotationContainer.Quat);
 }
 
 FRotator USGBasicHandModel::GetJointRotation(const ESGFinger Finger) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
     FSGIC_FQuat OutRotationContainer;
     FSGIC_ESGFinger FingerContainer{Finger};
     SGCoreImpl_FSGBasicHandModelImpl_GetJointRotation(&InstanceContainer, &OutRotationContainer, &FingerContainer);
-
     return OutRotationContainer.Quat.Rotator();
 }
 
 void USGBasicHandModel::SetJointRotation(const FQuat& NewRotation, const ESGFinger Finger)
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
     FSGIC_FQuat NewRotationContainer{NewRotation};
     FSGIC_ESGFinger FingerContainer{Finger};
     SGCoreImpl_FSGBasicHandModelImpl_SetJointRotation(&InstanceContainer, &NewRotationContainer, &FingerContainer);
-
-    Pimpl->SyncUProperties();
 }
 
 void USGBasicHandModel::SetJointRotation(const FRotator& NewRotation, const ESGFinger Finger)
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
     FSGIC_FQuat NewRotationContainer{NewRotation.Quaternion()};
     FSGIC_ESGFinger FingerContainer{Finger};
     SGCoreImpl_FSGBasicHandModelImpl_SetJointRotation(&InstanceContainer, &NewRotationContainer, &FingerContainer);
-
-    Pimpl->SyncUProperties();
 }
 
 TArray<float> USGBasicHandModel::GetTotalLengths() const
@@ -609,8 +511,6 @@ TArray<float> USGBasicHandModel::GetTotalLengths() const
 
 float USGBasicHandModel::GetTotalLength(const ESGFinger Finger) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
     FSGIC_ESGFinger FingerContainer{Finger};
     return SGCoreImpl_FSGBasicHandModelImpl_GetTotalLength(&InstanceContainer, &FingerContainer);
@@ -618,8 +518,6 @@ float USGBasicHandModel::GetTotalLength(const ESGFinger Finger) const
 
 TArray<FVector> USGBasicHandModel::Get3DLengths(const ESGFinger Finger) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
     FSGIC_TArray_FVector OutLengthsContainer;
     FSGIC_ESGFinger FingerContainer{Finger};
@@ -630,8 +528,6 @@ TArray<FVector> USGBasicHandModel::Get3DLengths(const ESGFinger Finger) const
 
 bool USGBasicHandModel::Equals(const USGBasicHandModel* BasicHandModel) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
     FSGIC_FSGBasicHandModelImpl BasicHandModelContainer{BasicHandModel->ToBasicHandModelImpl()};
     return SGCoreImpl_FSGBasicHandModelImpl_Equals(&InstanceContainer, &BasicHandModelContainer);
@@ -639,8 +535,6 @@ bool USGBasicHandModel::Equals(const USGBasicHandModel* BasicHandModel) const
 
 FString USGBasicHandModel::ToString() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGBasicHandModelImpl_ToString(&InstanceContainer, &OutStringContainer);
@@ -649,8 +543,6 @@ FString USGBasicHandModel::ToString() const
 
 FString USGBasicHandModel::ToString(const bool bLengthsOnly) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGBasicHandModelImpl_ToString_bLengthsOnly(&InstanceContainer, &OutStringContainer, bLengthsOnly);
@@ -659,8 +551,6 @@ FString USGBasicHandModel::ToString(const bool bLengthsOnly) const
 
 FString USGBasicHandModel::SGSerialize() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGBasicHandModelImpl InstanceContainer{ToBasicHandModelImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGBasicHandModelImpl_Serialize(&InstanceContainer, &OutStringContainer);
@@ -678,11 +568,3 @@ void USGBasicHandModel::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
 }
-
-void USGBasicHandModel::FImpl::SyncUProperties()
-{
-}
-
-void USGBasicHandModel::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGBetaDevice.cpp

@@ -46,42 +46,6 @@
 #include "SGInterop/SGIC_FString.h"
 #include "SGInterop/SGIC_TSharedPtr_FSGBetaDeviceImpl.h"
 
-struct USGBetaDevice::FImpl
-{
-    /************************
-     * Member variables
-     ************************/
-
-
-    /************************
-     * Owner object
-     ************************/
-
-    USGDevice* Owner;
-
-    /************************
-     * Constructor / Destructor
-     ************************/
-
-    explicit FImpl(USGBetaDevice* InOwner);
-    ~FImpl();
-
-    /************************
-     * Default copy constructor & copy assignment operator
-     ************************/
-
-    FImpl(const FImpl& Rhs) = default;
-    FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-
-    void SyncImplObject();
-};
-
 USGBetaDevice* USGBetaDevice::NewBetaDevice(UObject* Outer, const FSGBetaDeviceImpl& BetaDeviceImpl)
 {
     USGBetaDevice* Instance = NewObject<USGBetaDevice>(Outer);
@@ -128,29 +92,18 @@ USGBetaDevice* USGBetaDevice::Parse(UObject* Outer, const FString& String)
 }
 
 USGBetaDevice::USGBetaDevice()
-    : USGDevice(),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGDevice()
 {
     FSGIC_TSharedPtr_FSGBetaDeviceImpl OutSharedPtrContainer;
     SGCoreImpl_FSGBetaDeviceImpl_ctor_MakeShared(&OutSharedPtrContainer);
 
     SetSGDeviceImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
-    Pimpl->SyncUProperties();
 }
 
 USGBetaDevice::USGBetaDevice(const FString& ConstantsString, const FString& DeviceId,
                              const FString& HardwareVersion,
                              const int32 FirmwareVersion, const int32 SubFirmwareVersion)
-    : USGDevice(),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGDevice()
 {
     FSGIC_TSharedPtr_FSGBetaDeviceImpl OutSharedPtrContainer;
     FSGIC_FString ConstantsStringContainer{ConstantsString};
@@ -161,55 +114,27 @@ USGBetaDevice::USGBetaDevice(const FString& ConstantsString, const FString& Devi
         &HardwareVersionContainer, FirmwareVersion, SubFirmwareVersion);
 
     SetSGDeviceImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
-    Pimpl->SyncUProperties();
 }
 
 USGBetaDevice::USGBetaDevice(const FSGBetaDeviceImpl& BetaDeviceImpl)
-    : USGDevice(BetaDeviceImpl),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGDevice(BetaDeviceImpl)
 {
-    Pimpl->SyncUProperties();
 }
 
 USGBetaDevice::USGBetaDevice(TSharedRef<FSGBetaDeviceImpl> BetaDeviceImpl)
-    : USGDevice(MoveTemp(BetaDeviceImpl)),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGDevice(MoveTemp(BetaDeviceImpl))
 {
-    Pimpl->SyncUProperties();
 }
 
 USGBetaDevice::~USGBetaDevice() = default;
 
 TSharedRef<FSGBetaDeviceImpl> USGBetaDevice::ToBetaDeviceImpl() const
 {
-    SyncImplObject();
     return FSGDeviceImplCast::ToBetaDeviceImpl(ToSGDeviceImpl());
 }
 
-void USGBetaDevice::SyncImplObject() const
-{
-    Super::SyncImplObject();
-    Pimpl->SyncImplObject();
-}
-
-void USGBetaDevice::SyncUProperties()
-{
-    Super::SyncUProperties();
-    Pimpl->SyncUProperties();
-}
-
 ESGDeviceType USGBetaDevice::GetDeviceType() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGBetaDeviceImpl InstanceContainer{ToBetaDeviceImpl()};
     FSGIC_ESGDeviceType OutTypeContainer;
     SGCoreImpl_FSGBetaDeviceImpl_GetDeviceType(&InstanceContainer, &OutTypeContainer);
@@ -218,8 +143,6 @@ ESGDeviceType USGBetaDevice::GetDeviceType() const
 
 FString USGBetaDevice::GetDeviceId() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGBetaDeviceImpl InstanceContainer{ToBetaDeviceImpl()};
     FSGIC_FString OutIdContainer;
     SGCoreImpl_FSGBetaDeviceImpl_GetDeviceId(&InstanceContainer, &OutIdContainer);
@@ -228,8 +151,6 @@ FString USGBetaDevice::GetDeviceId() const
 
 FString USGBetaDevice::GetHardwareVersion() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGBetaDeviceImpl InstanceContainer{ToBetaDeviceImpl()};
     FSGIC_FString VersionContainer;
     SGCoreImpl_FSGBetaDeviceImpl_GetHardwareVersion(&InstanceContainer, &VersionContainer);
@@ -238,24 +159,18 @@ FString USGBetaDevice::GetHardwareVersion() const
 
 int32 USGBetaDevice::GetFirmwareVersion() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGBetaDeviceImpl InstanceContainer{ToBetaDeviceImpl()};
     return SGCoreImpl_FSGBetaDeviceImpl_GetFirmwareVersion(&InstanceContainer);
 }
 
 int32 USGBetaDevice::GetSubFirmwareVersion() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGBetaDeviceImpl InstanceContainer{ToBetaDeviceImpl()};
     return SGCoreImpl_FSGBetaDeviceImpl_GetSubFirmwareVersion(&InstanceContainer);
 }
 
 FString USGBetaDevice::GetConstantsString() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGBetaDeviceImpl InstanceContainer{ToBetaDeviceImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGBetaDeviceImpl_GetConstantsString(&InstanceContainer, &OutStringContainer);
@@ -264,8 +179,6 @@ FString USGBetaDevice::GetConstantsString() const
 
 FString USGBetaDevice::GetSensorData() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGBetaDeviceImpl InstanceContainer{ToBetaDeviceImpl()};
     FSGIC_FString OutDataContainer;
     SGCoreImpl_FSGBetaDeviceImpl_GetSensorData(&InstanceContainer, &OutDataContainer);
@@ -274,8 +187,6 @@ FString USGBetaDevice::GetSensorData() const
 
 FString USGBetaDevice::GetLastCommand() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGBetaDeviceImpl InstanceContainer{ToBetaDeviceImpl()};
     FSGIC_FString OutCommandContainer;
     SGCoreImpl_FSGBetaDeviceImpl_GetLastCommand(&InstanceContainer, &OutCommandContainer);
@@ -284,8 +195,6 @@ FString USGBetaDevice::GetLastCommand() const
 
 bool USGBetaDevice::SendHaptics(const FString& Command) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGBetaDeviceImpl InstanceContainer{ToBetaDeviceImpl()};
     FSGIC_FString CommandContainer{Command};
     return SGCoreImpl_FSGBetaDeviceImpl_SendHaptics(&InstanceContainer, &CommandContainer);
@@ -293,30 +202,8 @@ bool USGBetaDevice::SendHaptics(const FString& Command) const
 
 FString USGBetaDevice::ToString() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGBetaDeviceImpl InstanceContainer{ToBetaDeviceImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGBetaDeviceImpl_ToString(&InstanceContainer, &OutStringContainer);
     return MoveTemp(OutStringContainer.String);
 }
-
-USGBetaDevice::FImpl::FImpl(USGBetaDevice* InOwner)
-    : Owner(InOwner)
-{
-}
-
-USGBetaDevice::FImpl::~FImpl() = default;
-
-void USGBetaDevice::FImplDeleter::operator()(const FImpl* P) const
-{
-    delete P;
-}
-
-void USGBetaDevice::FImpl::SyncUProperties()
-{
-}
-
-void USGBetaDevice::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGBuzzCommand.cpp

@@ -44,42 +44,6 @@
 #include "SGInterop/SGIC_TArray_int32.h"
 #include "SGInterop/SGIC_TSharedPtr_FSGBuzzCommandImpl.h"
 
-struct USGBuzzCommand::FImpl
-{
-    /************************
-     * Member variables
-     ************************/
-
-
-    /************************
-     * Owner object
-     ************************/
-
-    USGBuzzCommand* Owner;
-
-    /************************
-     * Constructor / Destructor
-     ************************/
-
-    explicit FImpl(USGBuzzCommand* InOwner);
-    ~FImpl();
-
-    /************************
-     * Default copy constructor & copy assignment operator
-     ************************/
-
-    FImpl(const FImpl& Rhs) = default;
-    FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-
-    void SyncImplObject();
-};
-
 USGBuzzCommand* USGBuzzCommand::NewBuzzCommand(UObject* Outer, const FSGBuzzCommandImpl& BuzzCommandImpl)
 {
     USGBuzzCommand* Instance = NewObject<USGBuzzCommand>(Outer);
@@ -140,27 +104,16 @@ USGBuzzCommand* USGBuzzCommand::Off(UObject* Outer)
 }
 
 USGBuzzCommand::USGBuzzCommand()
-    : USGFingerCommand(),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGFingerCommand()
 {
     FSGIC_TSharedPtr_FSGBuzzCommandImpl OutSharedPtrContainer;
     SGCoreImpl_FSGBuzzCommandImpl_ctor_MakeShared(&OutSharedPtrContainer);
 
     SetFingerCommandImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
-    Pimpl->SyncUProperties();
 }
 
 USGBuzzCommand::USGBuzzCommand(const TArray<int32>& BuzzLevels)
-    : USGFingerCommand(BuzzLevels),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGFingerCommand(BuzzLevels)
 {
     FSGIC_TSharedPtr_FSGBuzzCommandImpl OutSharedPtrContainer;
     FSGIC_TArray_int32 BuzzLevelsContainer{BuzzLevels};
@@ -168,33 +121,21 @@ USGBuzzCommand::USGBuzzCommand(const TArray<int32>& BuzzLevels)
         &OutSharedPtrContainer, &BuzzLevelsContainer);
 
     SetFingerCommandImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
-    Pimpl->SyncUProperties();
 }
 
 USGBuzzCommand::USGBuzzCommand(
     const int32 Thumb, const int32 Index, const int32 Middle, const int32 Ring, const int32 Pinky)
-    : USGFingerCommand(),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGFingerCommand()
 {
     FSGIC_TSharedPtr_FSGBuzzCommandImpl OutSharedPtrContainer;
     SGCoreImpl_FSGBuzzCommandImpl_ctor_Thumb_Index_Middle_Ring_Pinky_MakeShared(
         &OutSharedPtrContainer, Thumb, Index, Middle, Ring, Pinky);
 
     SetFingerCommandImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
-    Pimpl->SyncUProperties();
 }
 
 USGBuzzCommand::USGBuzzCommand(const ESGFinger Finger, const int32 BuzzLevel)
-    : USGFingerCommand(),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGFingerCommand()
 {
     FSGIC_TSharedPtr_FSGBuzzCommandImpl OutSharedPtrContainer;
     FSGIC_ESGFinger FingerContainer{Finger};
@@ -202,55 +143,27 @@ USGBuzzCommand::USGBuzzCommand(const ESGFinger Finger, const int32 BuzzLevel)
         &OutSharedPtrContainer, &FingerContainer, BuzzLevel);
 
     SetFingerCommandImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
-    Pimpl->SyncUProperties();
 }
 
 USGBuzzCommand::USGBuzzCommand(const FSGBuzzCommandImpl& BuzzCommandImpl)
-    : USGFingerCommand(BuzzCommandImpl),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGFingerCommand(BuzzCommandImpl)
 {
-    Pimpl->SyncUProperties();
 }
 
 USGBuzzCommand::USGBuzzCommand(TSharedRef<FSGBuzzCommandImpl> BuzzCommandImpl)
-    : USGFingerCommand(MoveTemp(BuzzCommandImpl)),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGFingerCommand(MoveTemp(BuzzCommandImpl))
 {
-    Pimpl->SyncUProperties();
 }
 
 USGBuzzCommand::~USGBuzzCommand() = default;
 
 TSharedRef<FSGBuzzCommandImpl> USGBuzzCommand::ToBuzzCommandImpl() const
 {
-    SyncImplObject();
     return FSGFingerCommandImplCast::ToBuzzCommandImpl(ToFingerCommandImpl());
 }
 
-void USGBuzzCommand::SyncImplObject() const
-{
-    Super::SyncImplObject();
-    Pimpl->SyncImplObject();
-}
-
-void USGBuzzCommand::SyncUProperties()
-{
-    Super::SyncUProperties();
-    Pimpl->SyncUProperties();
-}
-
 USGBuzzCommand* USGBuzzCommand::Copy(UObject* Outer) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGBuzzCommandImpl InstanceContainer{ToBuzzCommandImpl()};
     FSGIC_FSGBuzzCommandImpl OutBuzzCommandImplContainer;
     SGCoreImpl_FSGBuzzCommandImpl_Copy(&InstanceContainer, &OutBuzzCommandImplContainer);
@@ -259,31 +172,9 @@ USGBuzzCommand* USGBuzzCommand::Copy(UObject* Outer) const
 
 USGBuzzCommand* USGBuzzCommand::Merge(UObject* Outer, const USGBuzzCommand* BuzzCommand) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGBuzzCommandImpl InstanceContainer{ToBuzzCommandImpl()};
     FSGIC_FSGBuzzCommandImpl BuzzCommandImplContainer{BuzzCommand->ToBuzzCommandImpl().Get()};
     FSGIC_FSGBuzzCommandImpl OutBuzzCommandImplContainer;
     SGCoreImpl_FSGBuzzCommandImpl_Merge(&InstanceContainer, &OutBuzzCommandImplContainer, &BuzzCommandImplContainer);
     return NewBuzzCommand(Outer, MoveTemp(OutBuzzCommandImplContainer.BuzzCommandImpl));
 }
-
-USGBuzzCommand::FImpl::FImpl(USGBuzzCommand* InOwner)
-    : Owner(InOwner)
-{
-}
-
-USGBuzzCommand::FImpl::~FImpl() = default;
-
-void USGBuzzCommand::FImplDeleter::operator()(const FImpl* P) const
-{
-    delete P;
-}
-
-void USGBuzzCommand::FImpl::SyncUProperties()
-{
-}
-
-void USGBuzzCommand::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGCalibrationDataPoint.cpp

@@ -69,14 +69,6 @@ struct USGCalibrationDataPoint::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-
-    void SyncImplObject();
 };
 
 USGCalibrationDataPoint* USGCalibrationDataPoint::NewCalibrationDataPoint(
@@ -107,27 +99,16 @@ USGCalibrationDataPoint* USGCalibrationDataPoint::NewCalibrationDataPoint(
 }
 
 USGCalibrationDataPoint::USGCalibrationDataPoint()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGCalibrationDataPointImpl OutCalibrationDataPointImplContainer;
     SGCoreImpl_FSGCalibrationDataPointImpl_ctor(&OutCalibrationDataPointImplContainer);
 
     Pimpl->CalibrationDataPointImpl = MoveTemp(OutCalibrationDataPointImplContainer.CalibrationDataPointImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGCalibrationDataPoint::USGCalibrationDataPoint(const int32 CurrentStage, const TArray<FVector>& CalibrationValues)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGCalibrationDataPointImpl OutCalibrationDataPointImplContainer;
     FSGIC_TArray_FVector CalibrationValuesContainer{CalibrationValues};
@@ -135,19 +116,12 @@ USGCalibrationDataPoint::USGCalibrationDataPoint(const int32 CurrentStage, const
         &OutCalibrationDataPointImplContainer, CurrentStage, &CalibrationValuesContainer);
 
     Pimpl->CalibrationDataPointImpl = MoveTemp(OutCalibrationDataPointImplContainer.CalibrationDataPointImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGCalibrationDataPoint::USGCalibrationDataPoint(const FSGCalibrationDataPointImpl& CalibrationDataPointImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     SetCalibrationDataPointImpl(CalibrationDataPointImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGCalibrationDataPoint::~USGCalibrationDataPoint() = default;
@@ -162,7 +136,6 @@ void USGCalibrationDataPoint::SetCalibrationDataPointImpl(const FSGCalibrationDa
 
 const FSGCalibrationDataPointImpl& USGCalibrationDataPoint::ToCalibrationDataPointImpl() const
 {
-    Pimpl->SyncImplObject();
     return Pimpl->CalibrationDataPointImpl;
 }
 
@@ -200,11 +173,3 @@ void USGCalibrationDataPoint::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
 }
-
-void USGCalibrationDataPoint::FImpl::SyncUProperties()
-{
-}
-
-void USGCalibrationDataPoint::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGDevice.cpp

@@ -85,14 +85,6 @@ struct USGDevice::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-
-    void SyncImplObject();
 };
 
 void USGDevice::ParseFirmware(const FString& RawFirmware, int32& OutMainVersion, int32& OutSubVersion)
@@ -110,43 +102,26 @@ FString USGDevice::ToString(const ESGDeviceType DeviceType)
 }
 
 USGDevice::USGDevice()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_TSharedPtr_FSGDeviceImpl OutSharedPtrContainer;
     SGCoreImpl_FSGDeviceImpl_ctor_MakeShared(&OutSharedPtrContainer);
 
     Pimpl->SGDeviceImpl = MoveTemp(OutSharedPtrContainer.Ptr);
-    Pimpl->SyncUProperties();
 }
 
 USGDevice::USGDevice(const FSGDeviceImpl& SGDeviceImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_TSharedPtr_FSGDeviceImpl OutSharedPtrContainer;
     FSGIC_FSGDeviceImpl RhsContainer{SGDeviceImpl};
     SGCoreImpl_FSGDeviceImpl_ctor_copy_MakeShared(&OutSharedPtrContainer, &RhsContainer);
 
     Pimpl->SGDeviceImpl = MoveTemp(OutSharedPtrContainer.Ptr);
-    Pimpl->SyncUProperties();
 }
 
 USGDevice::USGDevice(const FSGBetaDeviceImpl& BetaDeviceImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_TSharedPtr_FSGBetaDeviceImpl OutSharedPtrContainer;
     FSGIC_FSGBetaDeviceImpl RhsContainer{BetaDeviceImpl};
@@ -156,111 +131,63 @@ USGDevice::USGDevice(const FSGBetaDeviceImpl& BetaDeviceImpl)
 }
 
 USGDevice::USGDevice(const FSGHapticGloveImpl& HapticGloveImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_TSharedPtr_FSGHapticGloveImpl OutSharedPtrContainer;
     FSGIC_FSGHapticGloveImpl RhsContainer{HapticGloveImpl};
     SGCoreImpl_FSGHapticGloveImpl_ctor_copy_MakeShared(&OutSharedPtrContainer, &RhsContainer);
 
     Pimpl->SGDeviceImpl = MoveTemp(OutSharedPtrContainer.Ptr);
-    Pimpl->SyncUProperties();
 }
 
 USGDevice::USGDevice(const FSGNovaGloveImpl& NovaGloveImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_TSharedPtr_FSGNovaGloveImpl OutSharedPtrContainer;
     FSGIC_FSGNovaGloveImpl RhsContainer{NovaGloveImpl};
     SGCoreImpl_FSGNovaGloveImpl_ctor_copy_MakeShared(&OutSharedPtrContainer, &RhsContainer);
 
     Pimpl->SGDeviceImpl = MoveTemp(OutSharedPtrContainer.Ptr);
-    Pimpl->SyncUProperties();
 }
 
 USGDevice::USGDevice(const FSGSenseGloveImpl& SenseGloveImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_TSharedPtr_FSGSenseGloveImpl OutSharedPtrContainer;
     FSGIC_FSGSenseGloveImpl RhsContainer{SenseGloveImpl};
     SGCoreImpl_FSGSenseGloveImpl_ctor_copy_MakeShared(&OutSharedPtrContainer, &RhsContainer);
 
     Pimpl->SGDeviceImpl = MoveTemp(OutSharedPtrContainer.Ptr);
-    Pimpl->SyncUProperties();
 }
 
 USGDevice::USGDevice(TSharedRef<FSGDeviceImpl> SGDeviceImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     Pimpl->SGDeviceImpl = MoveTemp(SGDeviceImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGDevice::USGDevice(TSharedRef<FSGBetaDeviceImpl> BetaDeviceImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     Pimpl->SGDeviceImpl = MoveTemp(BetaDeviceImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGDevice::USGDevice(TSharedRef<FSGHapticGloveImpl> HapticGloveImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     Pimpl->SGDeviceImpl = MoveTemp(HapticGloveImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGDevice::USGDevice(TSharedRef<FSGNovaGloveImpl> NovaGloveImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     Pimpl->SGDeviceImpl = MoveTemp(NovaGloveImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGDevice::USGDevice(TSharedRef<FSGSenseGloveImpl> SenseGloveImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     Pimpl->SGDeviceImpl = MoveTemp(SenseGloveImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGDevice::~USGDevice() = default;
@@ -332,24 +259,11 @@ void USGDevice::SetSGDeviceImpl(TSharedRef<FSGSenseGloveImpl> SenseGloveImpl)
 
 TSharedRef<FSGDeviceImpl> USGDevice::ToSGDeviceImpl() const
 {
-    SyncImplObject();
     return Pimpl->SGDeviceImpl.ToSharedRef();
 }
 
-void USGDevice::SyncImplObject() const
-{
-    Pimpl->SyncImplObject();
-}
-
-void USGDevice::SyncUProperties()
-{
-    Pimpl->SyncUProperties();
-}
-
 ESGDeviceType USGDevice::GetDeviceType() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
     FSGIC_ESGDeviceType OutTypeContainer;
     SGCoreImpl_FSGDeviceImpl_GetDeviceType(&InstanceContainer, &OutTypeContainer);
@@ -358,16 +272,12 @@ ESGDeviceType USGDevice::GetDeviceType() const
 
 int32 USGDevice::GetSubFirmwareVersion() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
     return SGCoreImpl_FSGDeviceImpl_GetSubFirmwareVersion(&InstanceContainer);
 }
 
 FString USGDevice::GetFirmwareString() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGDeviceImpl_GetFirmwareString(&InstanceContainer, &OutStringContainer);
@@ -376,8 +286,6 @@ FString USGDevice::GetFirmwareString() const
 
 FString USGDevice::GetAddress() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
     FSGIC_FString AddressContainer;
     SGCoreImpl_FSGDeviceImpl_GetAddress(&InstanceContainer, &AddressContainer);
@@ -386,16 +294,12 @@ FString USGDevice::GetAddress() const
 
 bool USGDevice::IsConnected() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
     return SGCoreImpl_FSGDeviceImpl_IsConnected(&InstanceContainer);
 }
 
 ESGConnectionType USGDevice::GetConnectionType() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
     FSGIC_ESGConnectionType OutTypeContainer;
     SGCoreImpl_FSGDeviceImpl_GetConnectionType(&InstanceContainer, &OutTypeContainer);
@@ -404,82 +308,57 @@ ESGConnectionType USGDevice::GetConnectionType() const
 
 int32 USGDevice::PacketsPerSecondReceived() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
     return SGCoreImpl_FSGDeviceImpl_PacketsPerSecondReceived(&InstanceContainer);
 }
 
 int32 USGDevice::PacketsPerSecondSent() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
     return SGCoreImpl_FSGDeviceImpl_PacketsPerSecondSent(&InstanceContainer);
 }
 
 int32 USGDevice::GetDeviceIndex() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
     return SGCoreImpl_FSGDeviceImpl_GetDeviceIndex(&InstanceContainer);
 }
 
 void USGDevice::SetDeviceIndex(const int32 NewIndex)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
     SGCoreImpl_FSGDeviceImpl_SetDeviceIndex(&InstanceContainer, NewIndex);
-
-    SyncUProperties();
 }
 
 bool USGDevice::IsWireless() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
     return SGCoreImpl_FSGDeviceImpl_IsWireless(&InstanceContainer);
 }
 
 bool USGDevice::HasBattery() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
     return SGCoreImpl_FSGDeviceImpl_HasBattery(&InstanceContainer);
 }
 
 bool USGDevice::IsCharging()
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
     const bool bResult = SGCoreImpl_FSGDeviceImpl_IsCharging(&InstanceContainer);
 
-    SyncUProperties();
-
     return bResult;
 }
 
 bool USGDevice::GetBatteryLevel(float& OutLevel)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
     const bool bResult = SGCoreImpl_FSGDeviceImpl_GetBatteryLevel(&InstanceContainer, &OutLevel);
-
-    SyncUProperties();
-
     return bResult;
 }
 
 FString USGDevice::ToString() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGDeviceImpl_ToString(&InstanceContainer, &OutStringContainer);
@@ -497,11 +376,3 @@ void USGDevice::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
 }
-
-void USGDevice::FImpl::SyncUProperties()
-{
-}
-
-void USGDevice::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGDeviceModel.cpp

@@ -69,13 +69,6 @@ struct USGDeviceModel::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-    void SyncImplObject();
 };
 
 USGDeviceModel* USGDeviceModel::NewDeviceModel(UObject* Outer, const FSGDeviceModelImpl& DeviceModelImpl)
@@ -120,28 +113,17 @@ void USGDeviceModel::ParseFirmware(const FString& RawFirmware, int32& OutMainVer
 }
 
 USGDeviceModel::USGDeviceModel()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGDeviceModelImpl OutDeviceModelImplContainer;
     SGCoreImpl_FSGDeviceModelImpl_ctor(&OutDeviceModelImplContainer);
 
     Pimpl->DeviceModelImpl = MoveTemp(OutDeviceModelImplContainer.DeviceModelImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGDeviceModel::USGDeviceModel(const FString& Id, const FString& HardwareVersion,
                                const int32 FirmwareVersion, const int32 SubFirmwareVersion)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGDeviceModelImpl OutDeviceModelImplContainer;
     FSGIC_FString IdContainer{Id};
@@ -150,19 +132,12 @@ USGDeviceModel::USGDeviceModel(const FString& Id, const FString& HardwareVersion
         &OutDeviceModelImplContainer, &IdContainer, &HardwareVersionContainer, FirmwareVersion, SubFirmwareVersion);
 
     Pimpl->DeviceModelImpl = MoveTemp(OutDeviceModelImplContainer.DeviceModelImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGDeviceModel::USGDeviceModel(const FSGDeviceModelImpl& DeviceModelImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     SetDeviceModelImpl(DeviceModelImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGDeviceModel::~USGDeviceModel() = default;
@@ -177,13 +152,11 @@ void USGDeviceModel::SetDeviceModelImpl(const FSGDeviceModelImpl& DeviceModelImp
 
 const FSGDeviceModelImpl& USGDeviceModel::ToDeviceModelImpl() const
 {
-    Pimpl->SyncImplObject();
     return Pimpl->DeviceModelImpl;
 }
 
 FSGDeviceModelImpl& USGDeviceModel::ToDeviceModelImpl()
 {
-    Pimpl->SyncImplObject();
     return Pimpl->DeviceModelImpl;
 }
 
@@ -226,11 +199,3 @@ void USGDeviceModel::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
 }
-
-void USGDeviceModel::FImpl::SyncUProperties()
-{
-}
-
-void USGDeviceModel::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGFingerCommand.cpp

@@ -76,54 +76,29 @@ struct USGFingerCommand::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-
-    void SyncImplObject();
 };
 
 USGFingerCommand::USGFingerCommand()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_TSharedPtr_FSGFingerCommandImpl OutSharedPtrContainer;
     SGCoreImpl_FSGFingerCommandImpl_ctor_MakeShared(&OutSharedPtrContainer);
 
     Pimpl->FingerCommandImpl = MoveTemp(OutSharedPtrContainer.Ptr);
-    Pimpl->SyncUProperties();
 }
 
 USGFingerCommand::USGFingerCommand(const TArray<int32>& InLevels)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_TSharedPtr_FSGFingerCommandImpl OutSharedPtrContainer;
     FSGIC_TArray_int32 LevelsContainer{InLevels};
     SGCoreImpl_FSGFingerCommandImpl_ctor_Levels_MakeShared(&OutSharedPtrContainer, &LevelsContainer);
 
     Pimpl->FingerCommandImpl = MoveTemp(OutSharedPtrContainer.Ptr);
-    Pimpl->SyncUProperties();
 }
 
 USGFingerCommand::USGFingerCommand(const FSGFingerCommandImpl& FingerCommandImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_TSharedPtr_FSGFingerCommandImpl OutSharedPtrContainer;
     FSGIC_FSGFingerCommandImpl RhsContainer{FingerCommandImpl};
@@ -131,16 +106,10 @@ USGFingerCommand::USGFingerCommand(const FSGFingerCommandImpl& FingerCommandImpl
         &OutSharedPtrContainer, &RhsContainer);
 
     Pimpl->FingerCommandImpl = MoveTemp(OutSharedPtrContainer.Ptr);
-    Pimpl->SyncUProperties();
 }
 
 USGFingerCommand::USGFingerCommand(const FSGBuzzCommandImpl& BuzzCommandImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_TSharedPtr_FSGBuzzCommandImpl OutSharedPtrContainer;
     FSGIC_FSGBuzzCommandImpl RhsContainer{BuzzCommandImpl};
@@ -148,16 +117,10 @@ USGFingerCommand::USGFingerCommand(const FSGBuzzCommandImpl& BuzzCommandImpl)
         &OutSharedPtrContainer, &RhsContainer);
 
     Pimpl->FingerCommandImpl = MoveTemp(OutSharedPtrContainer.Ptr);
-    Pimpl->SyncUProperties();
 }
 
 USGFingerCommand::USGFingerCommand(const FSGForceFeedbackCommandImpl& ForceFeedbackCommandImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_TSharedPtr_FSGForceFeedbackCommandImpl OutSharedPtrContainer;
     FSGIC_FSGForceFeedbackCommandImpl RhsContainer{ForceFeedbackCommandImpl};
@@ -165,16 +128,10 @@ USGFingerCommand::USGFingerCommand(const FSGForceFeedbackCommandImpl& ForceFeedb
         &OutSharedPtrContainer, &RhsContainer);
 
     Pimpl->FingerCommandImpl = MoveTemp(OutSharedPtrContainer.Ptr);
-    Pimpl->SyncUProperties();
 }
 
 USGFingerCommand::USGFingerCommand(const FSGTimedBuzzCommandImpl& TimedBuzzCommandImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl OutSharedPtrContainer;
     FSGIC_FSGTimedBuzzCommandImpl RhsContainer{TimedBuzzCommandImpl};
@@ -182,55 +139,30 @@ USGFingerCommand::USGFingerCommand(const FSGTimedBuzzCommandImpl& TimedBuzzComma
         &OutSharedPtrContainer, &RhsContainer);
 
     Pimpl->FingerCommandImpl = MoveTemp(OutSharedPtrContainer.Ptr);
-    Pimpl->SyncUProperties();
 }
 
 USGFingerCommand::USGFingerCommand(TSharedRef<FSGFingerCommandImpl> FingerCommandImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     Pimpl->FingerCommandImpl = MoveTemp(FingerCommandImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGFingerCommand::USGFingerCommand(TSharedRef<FSGBuzzCommandImpl> BuzzCommandImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     Pimpl->FingerCommandImpl = MoveTemp(BuzzCommandImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGFingerCommand::USGFingerCommand(TSharedRef<FSGForceFeedbackCommandImpl> ForceFeedbackCommandImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     Pimpl->FingerCommandImpl = MoveTemp(ForceFeedbackCommandImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGFingerCommand::USGFingerCommand(TSharedRef<FSGTimedBuzzCommandImpl> TimedBuzzCommandImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     Pimpl->FingerCommandImpl = MoveTemp(TimedBuzzCommandImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGFingerCommand::~USGFingerCommand() = default;
@@ -289,20 +221,9 @@ void USGFingerCommand::SetFingerCommandImpl(TSharedRef<FSGTimedBuzzCommandImpl>
 
 TSharedRef<FSGFingerCommandImpl> USGFingerCommand::ToFingerCommandImpl() const
 {
-    SyncImplObject();
     return Pimpl->FingerCommandImpl.ToSharedRef();
 }
 
-void USGFingerCommand::SyncImplObject() const
-{
-    Pimpl->SyncImplObject();
-}
-
-void USGFingerCommand::SyncUProperties()
-{
-    Pimpl->SyncUProperties();
-}
-
 TArray<int32> USGFingerCommand::GetLevels() const
 {
     FSGIC_TSharedPtr_FSGFingerCommandImpl InstanceContainer{ToFingerCommandImpl()};
@@ -313,28 +234,19 @@ TArray<int32> USGFingerCommand::GetLevels() const
 
 int32 USGFingerCommand::GetLevel(const int32 Finger) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGFingerCommandImpl InstanceContainer{ToFingerCommandImpl()};
     const int32 Level = SGCoreImpl_FSGFingerCommandImpl_GetLevel(&InstanceContainer, Finger);
-
     return Level;
 }
 
 void USGFingerCommand::SetLevel(const int32 Finger, const int32 Value)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGFingerCommandImpl InstanceContainer{ToFingerCommandImpl()};
     SGCoreImpl_FSGFingerCommandImpl_SetLevel(&InstanceContainer, Finger, Value);
-
-    SyncUProperties();
 }
 
 bool USGFingerCommand::Equals(const USGFingerCommand* FingerCommand) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGFingerCommandImpl InstanceContainer{ToFingerCommandImpl()};
     FSGIC_FSGFingerCommandImpl FingerCommandImplContainer{FingerCommand->ToFingerCommandImpl().Get()};
     const bool bEquals = SGCoreImpl_FSGFingerCommandImpl_Equals(&InstanceContainer, &FingerCommandImplContainer);
@@ -343,8 +255,6 @@ bool USGFingerCommand::Equals(const USGFingerCommand* FingerCommand) const
 
 FString USGFingerCommand::ToString() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGFingerCommandImpl InstanceContainer{ToFingerCommandImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGFingerCommandImpl_ToString(&InstanceContainer, &OutStringContainer);
@@ -362,11 +272,3 @@ void USGFingerCommand::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
 }
-
-void USGFingerCommand::FImpl::SyncUProperties()
-{
-}
-
-void USGFingerCommand::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGForceFeedbackCommand.cpp

@@ -42,42 +42,6 @@
 #include "SGInterop/SGIC_TArray_int32.h"
 #include "SGInterop/SGIC_TSharedPtr_FSGForceFeedbackCommandImpl.h"
 
-struct USGForceFeedbackCommand::FImpl
-{
-    /************************
-     * Member variables
-     ************************/
-
-
-    /************************
-     * Owner object
-     ************************/
-
-    USGForceFeedbackCommand* Owner;
-
-    /************************
-     * Constructor / Destructor
-     ************************/
-
-    explicit FImpl(USGForceFeedbackCommand* InOwner);
-    ~FImpl();
-
-    /************************
-     * Default copy constructor & copy assignment operator
-     ************************/
-
-    FImpl(const FImpl& Rhs) = default;
-    FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-
-    void SyncImplObject();
-};
-
 USGForceFeedbackCommand* USGForceFeedbackCommand::NewForceFeedbackCommand(UObject* Outer,
                                                                           const FSGForceFeedbackCommandImpl&
                                                                           ForceFeedbackCommandImpl)
@@ -144,27 +108,16 @@ USGForceFeedbackCommand* USGForceFeedbackCommand::Off(UObject* Outer)
 }
 
 USGForceFeedbackCommand::USGForceFeedbackCommand()
-    : USGFingerCommand(),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGFingerCommand()
 {
     FSGIC_TSharedPtr_FSGForceFeedbackCommandImpl OutSharedPtrContainer;
     SGCoreImpl_FSGForceFeedbackCommandImpl_ctor_MakeShared(&OutSharedPtrContainer);
 
     SetFingerCommandImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
-    Pimpl->SyncUProperties();
 }
 
 USGForceFeedbackCommand::USGForceFeedbackCommand(const TArray<int32>& ForceFeedbackLevels)
-    : USGFingerCommand(ForceFeedbackLevels),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGFingerCommand(ForceFeedbackLevels)
 {
     FSGIC_TSharedPtr_FSGForceFeedbackCommandImpl OutSharedPtrContainer;
     FSGIC_TArray_int32 ForceFeedbackLevelsContainer{ForceFeedbackLevels};
@@ -172,33 +125,21 @@ USGForceFeedbackCommand::USGForceFeedbackCommand(const TArray<int32>& ForceFeedb
         &OutSharedPtrContainer, &ForceFeedbackLevelsContainer);
 
     SetFingerCommandImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
-    Pimpl->SyncUProperties();
 }
 
 USGForceFeedbackCommand::USGForceFeedbackCommand(
     const int32 Thumb, const int32 Index, const int32 Middle, const int32 Ring, const int32 Pinky)
-    : USGFingerCommand(),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGFingerCommand()
 {
     FSGIC_TSharedPtr_FSGForceFeedbackCommandImpl OutSharedPtrContainer;
     SGCoreImpl_FSGForceFeedbackCommandImpl_ctor_Thumb_Index_Middle_Ring_Pinky_MakeShared(
         &OutSharedPtrContainer, Thumb, Index, Middle, Ring, Pinky);
 
     SetFingerCommandImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
-    Pimpl->SyncUProperties();
 }
 
 USGForceFeedbackCommand::USGForceFeedbackCommand(const ESGFinger Finger, const int32 BuzzLevel)
-    : USGFingerCommand(),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGFingerCommand()
 {
     FSGIC_TSharedPtr_FSGForceFeedbackCommandImpl OutSharedPtrContainer;
     FSGIC_ESGFinger FingerContainer{Finger};
@@ -206,55 +147,27 @@ USGForceFeedbackCommand::USGForceFeedbackCommand(const ESGFinger Finger, const i
         &OutSharedPtrContainer, &FingerContainer, BuzzLevel);
 
     SetFingerCommandImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
-    Pimpl->SyncUProperties();
 }
 
 USGForceFeedbackCommand::USGForceFeedbackCommand(const FSGForceFeedbackCommandImpl& ForceFeedbackCommandImpl)
-    : USGFingerCommand(ForceFeedbackCommandImpl),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGFingerCommand(ForceFeedbackCommandImpl)
 {
-    Pimpl->SyncUProperties();
 }
 
 USGForceFeedbackCommand::USGForceFeedbackCommand(TSharedRef<FSGForceFeedbackCommandImpl> ForceFeedbackCommandImpl)
-    : USGFingerCommand(MoveTemp(ForceFeedbackCommandImpl)),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGFingerCommand(MoveTemp(ForceFeedbackCommandImpl))
 {
-    Pimpl->SyncUProperties();
 }
 
 USGForceFeedbackCommand::~USGForceFeedbackCommand() = default;
 
 TSharedRef<FSGForceFeedbackCommandImpl> USGForceFeedbackCommand::ToForceFeedbackCommandImpl() const
 {
-    SyncImplObject();
     return FSGFingerCommandImplCast::ToForceFeedbackCommandImpl(ToFingerCommandImpl());
 }
 
-void USGForceFeedbackCommand::SyncImplObject() const
-{
-    Super::SyncImplObject();
-    Pimpl->SyncImplObject();
-}
-
-void USGForceFeedbackCommand::SyncUProperties()
-{
-    Super::SyncUProperties();
-    Pimpl->SyncUProperties();
-}
-
 USGForceFeedbackCommand* USGForceFeedbackCommand::Copy(UObject* Outer) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGForceFeedbackCommandImpl InstanceContainer{ToForceFeedbackCommandImpl()};
     FSGIC_FSGForceFeedbackCommandImpl OutForceFeedbackCommandImplContainer;
     SGCoreImpl_FSGForceFeedbackCommandImpl_Copy(&InstanceContainer, &OutForceFeedbackCommandImplContainer);
@@ -264,8 +177,6 @@ USGForceFeedbackCommand* USGForceFeedbackCommand::Copy(UObject* Outer) const
 USGForceFeedbackCommand* USGForceFeedbackCommand::Merge(UObject* Outer,
                                                         const USGForceFeedbackCommand* ForceFeedbackCommand) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGForceFeedbackCommandImpl InstanceContainer{ToForceFeedbackCommandImpl()};
     FSGIC_FSGForceFeedbackCommandImpl ForceFeedbackCommandImplContainer{
         ForceFeedbackCommand->ToForceFeedbackCommandImpl().Get()};
@@ -274,23 +185,3 @@ USGForceFeedbackCommand* USGForceFeedbackCommand::Merge(UObject* Outer,
                                                  &ForceFeedbackCommandImplContainer);
     return NewForceFeedbackCommand(Outer, MoveTemp(OutForceFeedbackCommandImplContainer.ForceFeedbackCommandImpl));
 }
-
-USGForceFeedbackCommand::FImpl::FImpl(USGForceFeedbackCommand* InOwner)
-    : Owner(InOwner)
-{
-}
-
-USGForceFeedbackCommand::FImpl::~FImpl() = default;
-
-void USGForceFeedbackCommand::FImplDeleter::operator()(const FImpl* P) const
-{
-    delete P;
-}
-
-void USGForceFeedbackCommand::FImpl::SyncUProperties()
-{
-}
-
-void USGForceFeedbackCommand::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGHandInterpolator.cpp

@@ -81,13 +81,6 @@ struct USGHandInterpolator::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-    void SyncImplObject();
 };
 
 USGHandInterpolator* USGHandInterpolator::NewHandInterpolator(
@@ -256,27 +249,16 @@ TArray<TArray<FVector>> USGHandInterpolator::InterpolateHandAngles(const USGHand
 }
 
 USGHandInterpolator::USGHandInterpolator()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGHandInterpolatorImpl OutHandInterpolatorImplContainer;
     SGCoreImpl_FSGHandInterpolatorImpl_ctor(&OutHandInterpolatorImplContainer);
 
     Pimpl->HandInterpolatorImpl = MoveTemp(OutHandInterpolatorImplContainer.HandInterpolatorImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHandInterpolator::USGHandInterpolator(const TArray<TArray<USGInterpolationSet*>>& JointInterpolations)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGHandInterpolatorImpl OutHandInterpolatorImplContainer;
     FSGIC_TArray_TArray_FSGInterpolationSetImpl JointInterpolationsContainer{
@@ -286,16 +268,10 @@ USGHandInterpolator::USGHandInterpolator(const TArray<TArray<USGInterpolationSet
                                                                 &JointInterpolationsContainer);
 
     Pimpl->HandInterpolatorImpl = MoveTemp(OutHandInterpolatorImplContainer.HandInterpolatorImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHandInterpolator::USGHandInterpolator(const TArray<FSGInterpolationSetArray>& JointInterpolations)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGHandInterpolatorImpl OutHandInterpolatorImplContainer;
     FSGIC_TArray_TArray_FSGInterpolationSetImpl JointInterpolationsContainer{
@@ -308,17 +284,11 @@ USGHandInterpolator::USGHandInterpolator(const TArray<FSGInterpolationSetArray>&
                                                                 &JointInterpolationsContainer);
 
     Pimpl->HandInterpolatorImpl = MoveTemp(OutHandInterpolatorImplContainer.HandInterpolatorImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHandInterpolator::USGHandInterpolator(const TArray<TArray<USGInterpolationSet*>>& JointInterpolations,
                                          const FQuat& CmcStartRotation)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGHandInterpolatorImpl OutHandInterpolatorImplContainer;
     FSGIC_TArray_TArray_FSGInterpolationSetImpl JointInterpolationsContainer{
@@ -329,17 +299,11 @@ USGHandInterpolator::USGHandInterpolator(const TArray<TArray<USGInterpolationSet
         &OutHandInterpolatorImplContainer, &JointInterpolationsContainer, &CmcStartRotationContainer);
 
     Pimpl->HandInterpolatorImpl = MoveTemp(OutHandInterpolatorImplContainer.HandInterpolatorImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHandInterpolator::USGHandInterpolator(const TArray<TArray<USGInterpolationSet*>>& JointInterpolations,
                                          const FRotator& CmcStartRotation)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGHandInterpolatorImpl OutHandInterpolatorImplContainer;
     FSGIC_TArray_TArray_FSGInterpolationSetImpl JointInterpolationsContainer{
@@ -350,17 +314,11 @@ USGHandInterpolator::USGHandInterpolator(const TArray<TArray<USGInterpolationSet
         &OutHandInterpolatorImplContainer, &JointInterpolationsContainer, &CmcStartRotationContainer);
 
     Pimpl->HandInterpolatorImpl = MoveTemp(OutHandInterpolatorImplContainer.HandInterpolatorImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHandInterpolator::USGHandInterpolator(const TArray<FSGInterpolationSetArray>& JointInterpolations,
                                          const FQuat& CmcStartRotation)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGHandInterpolatorImpl OutHandInterpolatorImplContainer;
     FSGIC_TArray_TArray_FSGInterpolationSetImpl JointInterpolationsContainer{
@@ -374,17 +332,11 @@ USGHandInterpolator::USGHandInterpolator(const TArray<FSGInterpolationSetArray>&
         &OutHandInterpolatorImplContainer, &JointInterpolationsContainer, &CmcStartRotationContainer);
 
     Pimpl->HandInterpolatorImpl = MoveTemp(OutHandInterpolatorImplContainer.HandInterpolatorImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHandInterpolator::USGHandInterpolator(const TArray<FSGInterpolationSetArray>& JointInterpolations,
                                          const FRotator& CmcStartRotation)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGHandInterpolatorImpl OutHandInterpolatorImplContainer;
     FSGIC_TArray_TArray_FSGInterpolationSetImpl JointInterpolationsContainer{
@@ -398,19 +350,12 @@ USGHandInterpolator::USGHandInterpolator(const TArray<FSGInterpolationSetArray>&
         &OutHandInterpolatorImplContainer, &JointInterpolationsContainer, &CmcStartRotationContainer);
 
     Pimpl->HandInterpolatorImpl = MoveTemp(OutHandInterpolatorImplContainer.HandInterpolatorImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHandInterpolator::USGHandInterpolator(const FSGHandInterpolatorImpl& HandInterpolatorImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     SetHandInterpolatorImpl(HandInterpolatorImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHandInterpolator::~USGHandInterpolator() = default;
@@ -425,7 +370,6 @@ void USGHandInterpolator::SetHandInterpolatorImpl(const FSGHandInterpolatorImpl&
 
 const FSGHandInterpolatorImpl& USGHandInterpolator::ToHandInterpolatorImpl() const
 {
-    Pimpl->SyncImplObject();
     return Pimpl->HandInterpolatorImpl;
 }
 
@@ -462,8 +406,6 @@ FRotator USGHandInterpolator::GetCmcStartRotation() const
 
 float USGHandInterpolator::CalculateAngle(const ESGFinger Finger, const int32 Movement, const float Value) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHandInterpolatorImpl InstanceContainer{ToHandInterpolatorImpl()};
     FSGIC_ESGFinger FingerContainer{Finger};
     const float Angle = SGCoreImpl_FSGHandInterpolatorImpl_CalculateAngle_Finger_int32Movement_Value(
@@ -474,8 +416,6 @@ float USGHandInterpolator::CalculateAngle(const ESGFinger Finger, const int32 Mo
 float USGHandInterpolator::CalculateAngle(const ESGFinger Finger, const ESGFingerMovement Movement,
                                           const float Value) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHandInterpolatorImpl InstanceContainer{ToHandInterpolatorImpl()};
     FSGIC_ESGFinger FingerContainer{Finger};
     FSGIC_ESGFingerMovement MovementContainer{Movement};
@@ -487,8 +427,6 @@ float USGHandInterpolator::CalculateAngle(const ESGFinger Finger, const ESGFinge
 float USGHandInterpolator::CalculateAngle(const ESGFinger Finger, const ESGThumbMovement Movement,
                                           const float Value) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHandInterpolatorImpl InstanceContainer{ToHandInterpolatorImpl()};
     FSGIC_ESGFinger FingerContainer{Finger};
     FSGIC_ESGThumbMovement MovementContainer{Movement};
@@ -500,48 +438,34 @@ float USGHandInterpolator::CalculateAngle(const ESGFinger Finger, const ESGThumb
 void USGHandInterpolator::SetInterpolation(const int32 Finger, const int32 Movement, const float InputAt0,
                                            const float InputAt1, const float AngleAt0, const float AngleAt1)
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHandInterpolatorImpl InstanceContainer{ToHandInterpolatorImpl()};
     SGCoreImpl_FSGHandInterpolatorImpl_SetInterpolation_int32Finger_int32Movement_InputAt0_InputAt1_AngleAt0_AngleAt1(
         &InstanceContainer, Finger, Movement, InputAt0, InputAt1, AngleAt0, AngleAt1);
-
-    Pimpl->SyncUProperties();
 }
 
 void USGHandInterpolator::SetInterpolation(const ESGFinger Finger, const ESGFingerMovement Movement,
                                            const float InputAt0, const float InputAt1, const float AngleAt0,
                                            const float AngleAt1)
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHandInterpolatorImpl InstanceContainer{ToHandInterpolatorImpl()};
     FSGIC_ESGFinger FingerContainer{Finger};
     FSGIC_ESGFingerMovement MovementContainer{Movement};
     SGCoreImpl_FSGHandInterpolatorImpl_SetInterpolation_ESGFinger_ESGFingerMovement_InputAt0_InputAt1_AngleAt0_AngleAt1(
         &InstanceContainer, &FingerContainer, &MovementContainer, InputAt0, InputAt1, AngleAt0, AngleAt1);
-
-    Pimpl->SyncUProperties();
 }
 
 void USGHandInterpolator::SetInterpolation(const ESGThumbMovement Movement, const float InputAt0, const float InputAt1,
                                            const float AngleAt0, const float AngleAt1)
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHandInterpolatorImpl InstanceContainer{ToHandInterpolatorImpl()};
     FSGIC_ESGThumbMovement MovementContainer{Movement};
     SGCoreImpl_FSGHandInterpolatorImpl_SetInterpolation_Movement_InputAt0_InputAt1_AngleAt0_AngleAt1(
         &InstanceContainer, &MovementContainer, InputAt0, InputAt1, AngleAt0, AngleAt1);
-
-    Pimpl->SyncUProperties();
 }
 
 USGInterpolationSet* USGHandInterpolator::GetInterpolation(UObject* Outer,
                                                            const int32 Finger, const int32 Movement) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHandInterpolatorImpl InstanceContainer{ToHandInterpolatorImpl()};
     FSGIC_FSGInterpolationSetImpl OutInterpolationContainer;
     SGCoreImpl_FSGHandInterpolatorImpl_GetInterpolation(&InstanceContainer, &OutInterpolationContainer, Finger,
@@ -551,8 +475,6 @@ USGInterpolationSet* USGHandInterpolator::GetInterpolation(UObject* Outer,
 
 bool USGHandInterpolator::Equals(const USGHandInterpolator* HandInterpolator) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHandInterpolatorImpl InstanceContainer{ToHandInterpolatorImpl()};
     FSGIC_FSGHandInterpolatorImpl HandInterpolatorContainer{HandInterpolator->ToHandInterpolatorImpl()};
     const bool bEquals = SGCoreImpl_FSGHandInterpolatorImpl_Equals(&InstanceContainer, &HandInterpolatorContainer);
@@ -561,8 +483,6 @@ bool USGHandInterpolator::Equals(const USGHandInterpolator* HandInterpolator) co
 
 FString USGHandInterpolator::SGSerialize() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHandInterpolatorImpl InstanceContainer{ToHandInterpolatorImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGHandInterpolatorImpl_Serialize(&InstanceContainer, &OutStringContainer);
@@ -580,11 +500,3 @@ void USGHandInterpolator::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
 }
-
-void USGHandInterpolator::FImpl::SyncUProperties()
-{
-}
-
-void USGHandInterpolator::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGHandPose.cpp

@@ -36,7 +36,6 @@
 #include "SGCore/SGHandPose.h"
 
 #include "Runtime/Launch/Resources/Version.h"
-#include "SGCore/SGRotatorArray.h"
 
 #include "SGCore/SGBasicHandModel.h"
 #include "SGCoreImpl/SGExportedFunctions.h"
@@ -48,6 +47,8 @@
 #include "SGInterop/SGIC_TArray_float.h"
 #include "SGInterop/SGIC_TArray_TArray_FQuat.h"
 #include "SGInterop/SGIC_TArray_TArray_FVector.h"
+#include "SGTypes/SGRotatorArray.h"
+#include "SGUtils/SGArrayUtils.h"
 
 struct USGHandPose::FImpl
 {
@@ -76,13 +77,6 @@ struct USGHandPose::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-    void SyncImplObject();
 };
 
 USGHandPose* USGHandPose::NewHandPose(UObject* Outer, const FSGHandPoseImpl& HandPoseImpl)
@@ -284,29 +278,18 @@ USGHandPose* USGHandPose::Fist(UObject* Outer, const bool bRightHanded)
 }
 
 USGHandPose::USGHandPose()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGHandPoseImpl OutHandPoseImplContainer;
     SGCoreImpl_FSGHandPoseImpl_ctor(&OutHandPoseImplContainer);
 
     Pimpl->HandPoseImpl = MoveTemp(OutHandPoseImplContainer.HandPoseImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHandPose::USGHandPose(const bool bRightHanded,
                          const TArray<TArray<FVector>>& JointPositions, const TArray<TArray<FQuat>>& JointRotations,
                          const TArray<TArray<FVector>>& HandAngles)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGHandPoseImpl OutHandPoseImplContainer;
     FSGIC_TArray_TArray_FVector JointPositionsContainer{JointPositions};
@@ -317,18 +300,12 @@ USGHandPose::USGHandPose(const bool bRightHanded,
         &JointRotationsContainer, &HandAnglesContainer);
 
     Pimpl->HandPoseImpl = MoveTemp(OutHandPoseImplContainer.HandPoseImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHandPose::USGHandPose(const bool bRightHanded,
                          const TArray<TArray<FVector>>& JointPositions, const TArray<TArray<FRotator>>& JointRotations,
                          const TArray<TArray<FVector>>& HandAngles)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGHandPoseImpl OutHandPoseImplContainer;
     FSGIC_TArray_TArray_FVector JointPositionsContainer{JointPositions};
@@ -339,18 +316,12 @@ USGHandPose::USGHandPose(const bool bRightHanded,
         &JointRotationsContainer, &HandAnglesContainer);
 
     Pimpl->HandPoseImpl = MoveTemp(OutHandPoseImplContainer.HandPoseImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHandPose::USGHandPose(const bool bRightHanded, const
                          TArray<FSGVectorArray>& JointPositions, const TArray<FSGQuatArray>& JointRotations,
                          const TArray<FSGVectorArray>& HandAngles)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGHandPoseImpl OutHandPoseImplContainer;
     FSGIC_TArray_TArray_FVector JointPositionsContainer{
@@ -367,18 +338,12 @@ USGHandPose::USGHandPose(const bool bRightHanded, const
         &JointRotationsContainer, &HandAnglesContainer);
 
     Pimpl->HandPoseImpl = MoveTemp(OutHandPoseImplContainer.HandPoseImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHandPose::USGHandPose(const bool bRightHanded,
                          const TArray<FSGVectorArray>& JointPositions, const TArray<FSGRotatorArray>& JointRotations,
                          const TArray<FSGVectorArray>& HandAngles)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGHandPoseImpl OutHandPoseImplContainer;
     FSGIC_TArray_TArray_FVector JointPositionsContainer{
@@ -395,19 +360,12 @@ USGHandPose::USGHandPose(const bool bRightHanded,
         &JointRotationsContainer, &HandAnglesContainer);
 
     Pimpl->HandPoseImpl = MoveTemp(OutHandPoseImplContainer.HandPoseImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHandPose::USGHandPose(const FSGHandPoseImpl& HandPoseImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     SetHandPoseImpl(HandPoseImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHandPose::~USGHandPose() = default;
@@ -422,7 +380,6 @@ void USGHandPose::SetHandPoseImpl(const FSGHandPoseImpl& HandPoseImpl)
 
 const FSGHandPoseImpl& USGHandPose::ToHandPoseImpl() const
 {
-    Pimpl->SyncImplObject();
     return Pimpl->HandPoseImpl;
 }
 
@@ -466,7 +423,6 @@ TArray<TArray<FVector>> USGHandPose::GetHandAngles() const
 
 bool USGHandPose::Equals(const USGHandPose* HandPose) const
 {
-    Pimpl->SyncImplObject();
 
     FSGIC_FSGHandPoseImpl InstanceContainer{ToHandPoseImpl()};
     FSGIC_FSGHandPoseImpl HandPoseContainer{HandPose->ToHandPoseImpl()};
@@ -475,8 +431,6 @@ bool USGHandPose::Equals(const USGHandPose* HandPose) const
 
 float USGHandPose::GetNormalizedFlexion(const ESGFinger Finger, const bool bClamp01) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHandPoseImpl InstanceContainer{ToHandPoseImpl()};
     FSGIC_ESGFinger FingerContainer{Finger};
     return SGCoreImpl_FSGHandPoseImpl_GetNormalizedFlexion_Finger_bClamp01(
@@ -485,8 +439,6 @@ float USGHandPose::GetNormalizedFlexion(const ESGFinger Finger, const bool bClam
 
 TArray<float> USGHandPose::GetNormalizedFlexion(const bool bClamp01) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHandPoseImpl InstanceContainer{ToHandPoseImpl()};
     FSGIC_TArray_float OutFlexionContainer;
     SGCoreImpl_FSGHandPoseImpl_GetNormalizedFlexion_bClamp01(&InstanceContainer, &OutFlexionContainer, bClamp01);
@@ -495,8 +447,6 @@ TArray<float> USGHandPose::GetNormalizedFlexion(const bool bClamp01) const
 
 FString USGHandPose::ToString(const bool bShortFormat) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHandPoseImpl InstanceContainer{ToHandPoseImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGHandPoseImpl_ToString(&InstanceContainer, &OutStringContainer, bShortFormat);
@@ -505,8 +455,6 @@ FString USGHandPose::ToString(const bool bShortFormat) const
 
 FString USGHandPose::SGSerialize() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHandPoseImpl InstanceContainer{ToHandPoseImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGHandPoseImpl_Serialize(&InstanceContainer, &OutStringContainer);
@@ -524,11 +472,3 @@ void USGHandPose::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
 }
-
-void USGHandPose::FImpl::SyncUProperties()
-{
-}
-
-void USGHandPose::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGHandProfile.cpp

@@ -73,13 +73,6 @@ struct USGHandProfile::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-    void SyncImplObject();
 };
 
 USGHandProfile* USGHandProfile::NewHandProfile(UObject* Outer, const FSGHandProfileImpl& HandProfileImpl)
@@ -186,29 +179,18 @@ void USGHandProfile::ResetCalibration(const bool bOnDisk)
 }
 
 USGHandProfile::USGHandProfile()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGHandProfileImpl OutHandProfileImplContainer;
     SGCoreImpl_FSGHandProfileImpl_ctor(&OutHandProfileImplContainer);
 
     Pimpl->HandProfileImpl = MoveTemp(OutHandProfileImplContainer.HandProfileImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHandProfile::USGHandProfile(const bool bRightHanded,
                                const USGSenseGloveHandProfile* SenseGloveHandProfile,
                                const USGNovaGloveHandProfile* NovaGloveHandProfile)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGHandProfileImpl OutHandProfileImplContainer;
     FSGIC_FSGSenseGloveHandProfileImpl SenseGloveHandProfileContainer
@@ -219,19 +201,12 @@ USGHandProfile::USGHandProfile(const bool bRightHanded,
         &OutHandProfileImplContainer, bRightHanded, &SenseGloveHandProfileContainer, &NovaGloveHandProfileContainer);
 
     Pimpl->HandProfileImpl = MoveTemp(OutHandProfileImplContainer.HandProfileImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHandProfile::USGHandProfile(const FSGHandProfileImpl& HandProfileImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     SetHandProfileImpl(HandProfileImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHandProfile::~USGHandProfile() = default;
@@ -246,7 +221,6 @@ void USGHandProfile::SetHandProfileImpl(const FSGHandProfileImpl& HandProfileImp
 
 const FSGHandProfileImpl& USGHandProfile::ToHandProfileImpl() const
 {
-    Pimpl->SyncImplObject();
     return Pimpl->HandProfileImpl;
 }
 
@@ -278,8 +252,6 @@ USGNovaGloveHandProfile* USGHandProfile::GetNovaGloveHandProfile(UObject* Outer)
 
 bool USGHandProfile::Equals(const USGHandProfile* HandProfile) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHandProfileImpl InstanceContainer{ToHandProfileImpl()};
     FSGIC_FSGHandProfileImpl HandProfileContainer{HandProfile->ToHandProfileImpl()};
     return SGCoreImpl_FSGHandProfileImpl_Equals(&InstanceContainer, &HandProfileContainer);
@@ -287,18 +259,12 @@ bool USGHandProfile::Equals(const USGHandProfile* HandProfile) const
 
 void USGHandProfile::Reset()
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHandProfileImpl InstanceContainer{ToHandProfileImpl()};
     SGCoreImpl_FSGHandProfileImpl_Reset(&InstanceContainer);
-
-    Pimpl->SyncUProperties();
 }
 
 FString USGHandProfile::SGSerialize() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHandProfileImpl InstanceContainer{ToHandProfileImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGHandProfileImpl_Serialize(&InstanceContainer, &OutStringContainer);
@@ -316,11 +282,3 @@ void USGHandProfile::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
 }
-
-void USGHandProfile::FImpl::SyncUProperties()
-{
-}
-
-void USGHandProfile::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGHapticGlove.cpp

@@ -58,42 +58,6 @@
 #include "SGInterop/SGIC_TArray_TSharedRef_FSGHapticGloveImpl.h"
 #include "SGInterop/SGIC_TSharedPtr_FSGHapticGloveImpl.h"
 
-struct USGHapticGlove::FImpl
-{
-    /************************
-     * Member variables
-     ************************/
-
-
-    /************************
-     * Owner object
-     ************************/
-
-    USGDevice* Owner;
-
-    /************************
-     * Constructor / Destructor
-     ************************/
-
-    explicit FImpl(USGHapticGlove* InOwner);
-    ~FImpl();
-
-    /************************
-     * Default copy constructor & copy assignment operator
-     ************************/
-
-    FImpl(const FImpl& Rhs) = default;
-    FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-
-    void SyncImplObject();
-};
-
 USGHapticGlove* USGHapticGlove::NewHapticGlove(UObject* Outer, const FSGHapticGloveImpl& HapticGloveImpl)
 {
     USGHapticGlove* Instance = NewObject<USGHapticGlove>(Outer);
@@ -155,132 +119,63 @@ bool USGHapticGlove::GetGlove(UObject* Outer, const bool bRightHanded, USGHaptic
 }
 
 USGHapticGlove::USGHapticGlove()
-    : USGDevice(),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGDevice()
 {
     FSGIC_TSharedPtr_FSGHapticGloveImpl OutSharedPtrContainer;
     SGCoreImpl_FSGBetaDeviceImpl_ctor_MakeShared(&OutSharedPtrContainer);
 
     SetSGDeviceImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGlove::USGHapticGlove(const FSGDeviceImpl& SGDeviceImpl)
-    : USGDevice(SGDeviceImpl),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGDevice(SGDeviceImpl)
 {
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGlove::USGHapticGlove(const FSGHapticGloveImpl& HapticGloveImpl)
-    : USGDevice(HapticGloveImpl),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGDevice(HapticGloveImpl)
 {
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGlove::USGHapticGlove(const FSGNovaGloveImpl& NovaGloveImpl)
-    : USGDevice(NovaGloveImpl),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGDevice(NovaGloveImpl)
 {
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGlove::USGHapticGlove(const FSGSenseGloveImpl& SenseGloveImpl)
-    : USGDevice(SenseGloveImpl),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGDevice(SenseGloveImpl)
 {
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGlove::USGHapticGlove(TSharedRef<FSGDeviceImpl> SGDeviceImpl)
-    : USGDevice(MoveTemp(SGDeviceImpl)),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGDevice(MoveTemp(SGDeviceImpl))
 {
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGlove::USGHapticGlove(TSharedRef<FSGHapticGloveImpl> HapticGloveImpl)
-    : USGDevice(MoveTemp(HapticGloveImpl)),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGDevice(MoveTemp(HapticGloveImpl))
 {
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGlove::USGHapticGlove(TSharedRef<FSGNovaGloveImpl> NovaGloveImpl)
-    : USGDevice(MoveTemp(NovaGloveImpl)),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGDevice(MoveTemp(NovaGloveImpl))
 {
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGlove::USGHapticGlove(TSharedRef<FSGSenseGloveImpl> SenseGloveImpl)
-    : USGDevice(MoveTemp(SenseGloveImpl)),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGDevice(MoveTemp(SenseGloveImpl))
 {
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGlove::~USGHapticGlove() = default;
 
 TSharedRef<FSGHapticGloveImpl> USGHapticGlove::ToHapticGloveImpl() const
 {
-    SyncImplObject();
     return FSGDeviceImplCast::ToHapticGloveImpl(ToSGDeviceImpl());
 }
 
-void USGHapticGlove::SyncImplObject() const
-{
-    Super::SyncImplObject();
-    Pimpl->SyncImplObject();
-}
-
-void USGHapticGlove::SyncUProperties()
-{
-    Super::SyncUProperties();
-    Pimpl->SyncUProperties();
-}
-
 ESGDeviceType USGHapticGlove::GetDeviceType() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_ESGDeviceType OutTypeContainer;
     SGCoreImpl_FSGHapticGloveImpl_GetDeviceType(&InstanceContainer, &OutTypeContainer);
@@ -289,8 +184,6 @@ ESGDeviceType USGHapticGlove::GetDeviceType() const
 
 FString USGHapticGlove::GetDeviceId() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_FString OutIdContainer;
     SGCoreImpl_FSGHapticGloveImpl_GetDeviceId(&InstanceContainer, &OutIdContainer);
@@ -299,8 +192,6 @@ FString USGHapticGlove::GetDeviceId() const
 
 FString USGHapticGlove::GetHardwareVersion() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_FString OutVersionContainer;
     SGCoreImpl_FSGHapticGloveImpl_GetHardwareVersion(&InstanceContainer, &OutVersionContainer);
@@ -309,38 +200,28 @@ FString USGHapticGlove::GetHardwareVersion() const
 
 int32 USGHapticGlove::GetFirmwareVersion() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     return SGCoreImpl_FSGHapticGloveImpl_GetFirmwareVersion(&InstanceContainer);
 }
 
 int32 USGHapticGlove::GetSubFirmwareVersion() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     return SGCoreImpl_FSGHapticGloveImpl_GetSubFirmwareVersion(&InstanceContainer);
 }
 
 bool USGHapticGlove::IsRight() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     return SGCoreImpl_FSGHapticGloveImpl_IsRight(&InstanceContainer);
 }
 
 bool USGHapticGlove::GetImuRotation(FQuat& OutImu)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_FQuat OutImuContainer;
     const bool bResult = SGCoreImpl_FSGHapticGloveImpl_GetImuRotation(&InstanceContainer, &OutImuContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutImu = MoveTemp(OutImuContainer.Quat);
@@ -351,14 +232,10 @@ bool USGHapticGlove::GetImuRotation(FQuat& OutImu)
 
 bool USGHapticGlove::GetImuRotation(FRotator& OutImu)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_FQuat OutImuContainer;
     const bool bResult = SGCoreImpl_FSGHapticGloveImpl_GetImuRotation(&InstanceContainer, &OutImuContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutImu = OutImuContainer.Quat.Rotator();
@@ -371,8 +248,6 @@ bool USGHapticGlove::GetHandPose(
     UObject* Outer,
     const USGBasicHandModel* HandGeometry, const USGHandProfile* HandProfile, USGHandPose*& OutHandPose)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_FSGBasicHandModelImpl HandGeometryContainer{HandGeometry->ToBasicHandModelImpl()};
     FSGIC_FSGHandProfileImpl HandProfileContainer{HandProfile->ToHandProfileImpl()};
@@ -380,8 +255,6 @@ bool USGHapticGlove::GetHandPose(
     const bool bResult = SGCoreImpl_FSGHapticGloveImpl_GetHandPose_HandGeometry_HandProfile_OutHandPose(
         &InstanceContainer, &HandGeometryContainer, &HandProfileContainer, &OutHandPoseContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutHandPose = USGHandPose::NewHandPose(Outer, MoveTemp(OutHandPoseContainer.HandPoseImpl));
@@ -392,16 +265,12 @@ bool USGHapticGlove::GetHandPose(
 
 bool USGHapticGlove::GetHandPose(UObject* Outer, const USGHandProfile* HandProfile, USGHandPose*& OutHandPose)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_FSGHandProfileImpl HandProfileContainer{HandProfile->ToHandProfileImpl()};
     FSGIC_FSGHandPoseImpl OutHandPoseContainer;
     const bool bResult = SGCoreImpl_FSGHapticGloveImpl_GetHandPose_HandProfile_OutHandPose(
         &InstanceContainer, &HandProfileContainer, &OutHandPoseContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutHandPose = USGHandPose::NewHandPose(Outer, MoveTemp(OutHandPoseContainer.HandPoseImpl));
@@ -412,16 +281,12 @@ bool USGHapticGlove::GetHandPose(UObject* Outer, const USGHandProfile* HandProfi
 
 bool USGHapticGlove::GetHandPose(UObject* Outer, const USGBasicHandModel* HandGeometry, USGHandPose*& OutHandPose)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_FSGBasicHandModelImpl HandGeometryContainer{HandGeometry->ToBasicHandModelImpl()};
     FSGIC_FSGHandPoseImpl OutHandPoseContainer;
     const bool bResult = SGCoreImpl_FSGHapticGloveImpl_GetHandPose_HandGeometry_OutHandPose(
         &InstanceContainer, &HandGeometryContainer, &OutHandPoseContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutHandPose = USGHandPose::NewHandPose(Outer, MoveTemp(OutHandPoseContainer.HandPoseImpl));
@@ -432,15 +297,11 @@ bool USGHapticGlove::GetHandPose(UObject* Outer, const USGBasicHandModel* HandGe
 
 bool USGHapticGlove::GetHandPose(UObject* Outer, USGHandPose*& OutHandPose)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_FSGHandPoseImpl OutHandPoseContainer;
     const bool bResult = SGCoreImpl_FSGHapticGloveImpl_GetHandPose_OutHandPose(
         &InstanceContainer, &OutHandPoseContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutHandPose = USGHandPose::NewHandPose(Outer, MoveTemp(OutHandPoseContainer.HandPoseImpl));
@@ -449,81 +310,72 @@ bool USGHapticGlove::GetHandPose(UObject* Outer, USGHandPose*& OutHandPose)
     return bResult;
 }
 
+#if PLATFORM_ANDROID
+bool USGHapticGlove::GetHandPose(UObject* Outer, const float DeltaTime,  USGHandPose*& OutHandPose)
+{
+    FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
+    FSGIC_FSGHandPoseImpl OutHandPoseContainer;
+    const bool bResult = SGCoreImpl_FSGHapticGloveImpl_GetHandPose_DeltaTime_OutHandPose(
+        &InstanceContainer, DeltaTime, &OutHandPoseContainer);
+
+    if (bResult)
+    {
+        OutHandPose = USGHandPose::NewHandPose(Outer, MoveTemp(OutHandPoseContainer.HandPoseImpl));
+    }
+
+    return bResult;
+}
+#endif  /* PLATFORM_ANDROID */
+
 void USGHapticGlove::StopHaptics()
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     SGCoreImpl_FSGHapticGloveImpl_StopHaptics(&InstanceContainer);
-
-    SyncUProperties();
 }
 
 void USGHapticGlove::StopVibrations()
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     SGCoreImpl_FSGHapticGloveImpl_StopVibrations(&InstanceContainer);
-
-    SyncUProperties();
 }
 
 void USGHapticGlove::SendHaptics(const USGForceFeedbackCommand* ForceFeedbackCommand)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_FSGForceFeedbackCommandImpl ForceFeedbackCommandContainer{
         ForceFeedbackCommand->ToForceFeedbackCommandImpl().Get()};
     SGCoreImpl_FSGHapticGloveImpl_SendHaptics_ForceFeedbackCommand(&InstanceContainer, &ForceFeedbackCommandContainer);
-
-    SyncUProperties();
 }
 
 void USGHapticGlove::SendHaptics(const USGBuzzCommand* BuzzCommand)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_FSGBuzzCommandImpl BuzzCommandContainer{BuzzCommand->ToBuzzCommandImpl().Get()};
     SGCoreImpl_FSGHapticGloveImpl_SendHaptics_BuzzCommand(&InstanceContainer, &BuzzCommandContainer);
-
-    SyncUProperties();
 }
 
 void USGHapticGlove::SendHaptics(const USGThumperCommand* ThumperCommand)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_FSGThumperCommandImpl ThumperCommandContainer{ThumperCommand->ToThumperCommandImpl()};
     SGCoreImpl_FSGHapticGloveImpl_SendHaptics_ThumperCommand(&InstanceContainer, &ThumperCommandContainer);
-
-    SyncUProperties();
 }
 
 void USGHapticGlove::SendHaptics(const USGForceFeedbackCommand* ForceFeedbackCommand,
                                  const USGBuzzCommand* BuzzCommand)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_FSGForceFeedbackCommandImpl ForceFeedbackCommandContainer{
         ForceFeedbackCommand->ToForceFeedbackCommandImpl().Get()};
     FSGIC_FSGBuzzCommandImpl BuzzCommandContainer{BuzzCommand->ToBuzzCommandImpl().Get()};
     SGCoreImpl_FSGHapticGloveImpl_SendHaptics_ForceFeedbackCommand_BuzzCommand(
         &InstanceContainer, &ForceFeedbackCommandContainer, &BuzzCommandContainer);
-
-    SyncUProperties();
 }
 
 void USGHapticGlove::SendHaptics(const USGForceFeedbackCommand* ForceFeedbackCommand,
                                  const USGBuzzCommand* BuzzCommand,
                                  const USGThumperCommand* ThumperCommand)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_FSGForceFeedbackCommandImpl ForceFeedbackCommandContainer{
         ForceFeedbackCommand->ToForceFeedbackCommandImpl().Get()};
@@ -531,20 +383,14 @@ void USGHapticGlove::SendHaptics(const USGForceFeedbackCommand* ForceFeedbackCom
     FSGIC_FSGThumperCommandImpl ThumperCommandContainer{ThumperCommand->ToThumperCommandImpl()};
     SGCoreImpl_FSGHapticGloveImpl_SendHaptics_ForceFeedbackCommand_BuzzCommand_ThumperCommand(
         &InstanceContainer, &ForceFeedbackCommandContainer, &BuzzCommandContainer, &ThumperCommandContainer);
-
-    SyncUProperties();
 }
 
 bool USGHapticGlove::GetCalibrationValues(TArray<FVector>& OutValues)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_TArray_FVector OutValuesContainer;
     const bool bResult = SGCoreImpl_FSGHapticGloveImpl_GetCalibrationValues(&InstanceContainer, &OutValuesContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutValues = MoveTemp(OutValuesContainer.Array);
@@ -555,68 +401,46 @@ bool USGHapticGlove::GetCalibrationValues(TArray<FVector>& OutValues)
 
 void USGHapticGlove::ResetCalibrationRange()
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     SGCoreImpl_FSGHapticGloveImpl_ResetCalibrationRange(&InstanceContainer);
-
-    SyncUProperties();
 }
 
 void USGHapticGlove::UpdateCalibrationRange()
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     SGCoreImpl_FSGHapticGloveImpl_UpdateCalibrationRange(&InstanceContainer);
-
-    SyncUProperties();
 }
 
 void USGHapticGlove::UpdateCalibrationRange(const TArray<FVector>& CalibrationValues)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_TArray_FVector CalibrationValuesContainer{CalibrationValues};
     SGCoreImpl_FSGHapticGloveImpl_UpdateCalibrationRange_CalibrationValues(
         &InstanceContainer, &CalibrationValuesContainer);
-
-    SyncUProperties();
 }
 
 void USGHapticGlove::GetCalibrationRange(TArray<FVector>& OutMinValues, TArray<FVector>& OutMaxValues)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_TArray_FVector OutMinValuesContainer;
     FSGIC_TArray_FVector OutMaxValuesContainer;
     SGCoreImpl_FSGHapticGloveImpl_GetCalibrationRange(&InstanceContainer, &OutMinValues, &OutMaxValues);
 
-    SyncUProperties();
-
     OutMinValues = MoveTemp(OutMinValuesContainer.Array);
     OutMaxValues = MoveTemp(OutMaxValuesContainer.Array);
 }
 
 void USGHapticGlove::UpdateCalibration(UObject* Outer, USGHandProfile*& OutProfile)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_FSGHandProfileImpl OutProfileContainer;
     SGCoreImpl_FSGHapticGloveImpl_UpdateCalibration(&InstanceContainer, &OutProfileContainer);
 
-    SyncUProperties();
-
     OutProfile = USGHandProfile::NewHandProfile(Outer, MoveTemp(OutProfileContainer.HandProfileImpl));
 }
 
 void USGHapticGlove::ApplyCalibration(UObject* Outer, USGHandProfile*& OutProfile) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_FSGHandProfileImpl OutProfileContainer;
     SGCoreImpl_FSGHapticGloveImpl_ApplyCalibration(&InstanceContainer, &OutProfileContainer);
@@ -628,8 +452,6 @@ void USGHapticGlove::GetWristLocation(const FVector& ReferencePosition, const FQ
                                       const ESGPositionalTrackingHardware TrackingHardware,
                                       FVector& OutWristPosition, FQuat& OutWristRotation) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_FVector ReferencePositionContainer{ReferencePosition};
     FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation};
@@ -650,8 +472,6 @@ void USGHapticGlove::GetWristLocation(const FVector& ReferencePosition, const FR
                                       const ESGPositionalTrackingHardware TrackingHardware,
                                       FVector& OutWristPosition, FRotator& OutWristRotation) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_FVector ReferencePositionContainer{ReferencePosition};
     FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
@@ -672,8 +492,6 @@ void USGHapticGlove::GetGloveLocation(const FVector& ReferencePosition, const FQ
                                       const ESGPositionalTrackingHardware TrackingHardware,
                                       FVector& OutGlovePosition, FQuat& OutGloveRotation) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_FVector ReferencePositionContainer{ReferencePosition};
     FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation};
@@ -695,8 +513,6 @@ void USGHapticGlove::GetGloveLocation(const FVector& ReferencePosition, const FR
                                       const ESGPositionalTrackingHardware TrackingHardware,
                                       FVector& OutGlovePosition, FRotator& OutGloveRotation) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveImpl InstanceContainer{ToHapticGloveImpl()};
     FSGIC_FVector ReferencePositionContainer{ReferencePosition};
     FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
@@ -713,23 +529,3 @@ void USGHapticGlove::GetGloveLocation(const FVector& ReferencePosition, const FR
     OutGlovePosition = MoveTemp(OutGlovePositionContainer.Vector);
     OutGloveRotation = OutGloveRotationContainer.Quat.Rotator();
 }
-
-USGHapticGlove::FImpl::FImpl(USGHapticGlove* InOwner)
-    : Owner(InOwner)
-{
-}
-
-USGHapticGlove::FImpl::~FImpl() = default;
-
-void USGHapticGlove::FImplDeleter::operator()(const FImpl* P) const
-{
-    delete P;
-}
-
-void USGHapticGlove::FImpl::SyncUProperties()
-{
-}
-
-void USGHapticGlove::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGHapticGloveCalibrationCheck.cpp

@@ -74,13 +74,6 @@ struct USGHapticGloveCalibrationCheck::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-    void SyncImplObject();
 };
 
 USGHapticGloveCalibrationCheck* USGHapticGloveCalibrationCheck::NewHapticGloveCalibrationCheck(
@@ -176,28 +169,17 @@ bool USGHapticGloveCalibrationCheck::MatchesLast(const TArray<FVector>& CurrentR
 }
 
 USGHapticGloveCalibrationCheck::USGHapticGloveCalibrationCheck()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGHapticGloveCalibrationCheckImpl OutHapticGloveCalibrationCheckImplContainer;
     SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_ctor(&OutHapticGloveCalibrationCheckImplContainer);
 
     Pimpl->HapticGloveCalibrationCheckImpl = MoveTemp(
         OutHapticGloveCalibrationCheckImplContainer.HapticGloveCalibrationCheckImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGloveCalibrationCheck::USGHapticGloveCalibrationCheck(const USGSensorRange* LastCalibrationRange)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGHapticGloveCalibrationCheckImpl OutHapticGloveCalibrationCheckImplContainer;
     FSGIC_FSGSensorRangeImpl LastCalibrationRangeContainer{LastCalibrationRange->ToSensorRangeImpl()};
@@ -206,20 +188,13 @@ USGHapticGloveCalibrationCheck::USGHapticGloveCalibrationCheck(const USGSensorRa
 
     Pimpl->HapticGloveCalibrationCheckImpl = MoveTemp(
         OutHapticGloveCalibrationCheckImplContainer.HapticGloveCalibrationCheckImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGloveCalibrationCheck::USGHapticGloveCalibrationCheck(
     const FSGHapticGloveCalibrationCheckImpl& HapticGloveCalibrationCheckImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     SetHapticGloveCalibrationCheckImpl(HapticGloveCalibrationCheckImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGloveCalibrationCheck::~USGHapticGloveCalibrationCheck() = default;
@@ -236,22 +211,11 @@ void USGHapticGloveCalibrationCheck::SetHapticGloveCalibrationCheckImpl(
 
 const FSGHapticGloveCalibrationCheckImpl& USGHapticGloveCalibrationCheck::ToHapticGloveCalibrationCheckImpl() const
 {
-    Pimpl->SyncImplObject();
     return Pimpl->HapticGloveCalibrationCheckImpl;
 }
 
-USGSensorRange* USGHapticGloveCalibrationCheck::GetLastSensorRange(UObject* Outer) const
-{
-    FSGIC_FSGHapticGloveCalibrationCheckImpl InstanceContainer{ToHapticGloveCalibrationCheckImpl()};
-    FSGIC_FSGSensorRangeImpl OutLastSensorRangeContainer;
-    SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_GetLastSensorRange(&InstanceContainer, &OutLastSensorRangeContainer);
-    return USGSensorRange::NewSensorRange(Outer, MoveTemp(OutLastSensorRangeContainer.SensorRangeImpl));
-}
-
 ESGCalibrationStage USGHapticGloveCalibrationCheck::GetCalibrationStage() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHapticGloveCalibrationCheckImpl InstanceContainer{ToHapticGloveCalibrationCheckImpl()};
     FSGIC_ESGCalibrationStage OutStageContainer;
     SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_GetCalibrationStage(&InstanceContainer, &OutStageContainer);
@@ -261,7 +225,6 @@ ESGCalibrationStage USGHapticGloveCalibrationCheck::GetCalibrationStage() const
 
 bool USGHapticGloveCalibrationCheck::ReachedConclusion() const
 {
-    Pimpl->SyncImplObject();
 
     FSGIC_FSGHapticGloveCalibrationCheckImpl InstanceContainer{ToHapticGloveCalibrationCheckImpl()};
     return SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_ReachedConclusion(&InstanceContainer);
@@ -269,26 +232,18 @@ bool USGHapticGloveCalibrationCheck::ReachedConclusion() const
 
 void USGHapticGloveCalibrationCheck::Reset()
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHapticGloveCalibrationCheckImpl InstanceContainer{ToHapticGloveCalibrationCheckImpl()};
     SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_Reset(&InstanceContainer);
-
-    Pimpl->SyncUProperties();
 }
 
 void USGHapticGloveCalibrationCheck::CheckRange(
     const TArray<FVector>& CurrentValues, const float DeltaSeconds, const ESGDeviceType DeviceType)
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHapticGloveCalibrationCheckImpl InstanceContainer{ToHapticGloveCalibrationCheckImpl()};
     FSGIC_TArray_FVector CurrentValuesContainer{CurrentValues};
     FSGIC_ESGDeviceType DeviceTypeContainer{DeviceType};
     SGCoreImpl_FSGHapticGloveCalibrationCheckImpl_CheckRange(&InstanceContainer, &CurrentValuesContainer,
                                                              DeltaSeconds, &DeviceTypeContainer);
-
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGloveCalibrationCheck::FImpl::FImpl(USGHapticGloveCalibrationCheck* InOwner)
@@ -302,11 +257,3 @@ void USGHapticGloveCalibrationCheck::FImplDeleter::operator()(const FImpl* P) co
 {
     delete P;
 }
-
-void USGHapticGloveCalibrationCheck::FImpl::SyncUProperties()
-{
-}
-
-void USGHapticGloveCalibrationCheck::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGHapticGloveCalibrationSequence.cpp

@@ -84,14 +84,6 @@ struct USGHapticGloveCalibrationSequence::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-
-    void SyncImplObject();
 };
 
 USGHapticGloveCalibrationSequence* USGHapticGloveCalibrationSequence::NewHapticGloveCalibrationSequence(UObject* Outer,
@@ -154,27 +146,16 @@ bool USGHapticGloveCalibrationSequence::CompileProfile(UObject* Outer,
 }
 
 USGHapticGloveCalibrationSequence::USGHapticGloveCalibrationSequence()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl OutSharedPtrContainer;
     SGCoreImpl_FSGHapticGloveCalibrationSequenceImpl_ctor_MakeShared(&OutSharedPtrContainer);
 
     Pimpl->HapticGloveCalibrationSequenceImpl = MoveTemp(OutSharedPtrContainer.Ptr);
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGloveCalibrationSequence::USGHapticGloveCalibrationSequence(const USGHapticGlove* LinkedGlove)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl OutSharedPtrContainer;
     FSGIC_TSharedPtr_FSGHapticGloveImpl LinkedGloveContainer{LinkedGlove->ToHapticGloveImpl()};
@@ -182,17 +163,11 @@ USGHapticGloveCalibrationSequence::USGHapticGloveCalibrationSequence(const USGHa
         &OutSharedPtrContainer, &LinkedGloveContainer);
 
     Pimpl->HapticGloveCalibrationSequenceImpl = MoveTemp(OutSharedPtrContainer.Ptr);
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGloveCalibrationSequence::USGHapticGloveCalibrationSequence(
     const FSGHapticGloveCalibrationSequenceImpl& HapticGloveCalibrationSequenceImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl OutSharedPtrContainer;
     FSGIC_FSGHapticGloveCalibrationSequenceImpl RhsContainer{HapticGloveCalibrationSequenceImpl};
@@ -200,17 +175,11 @@ USGHapticGloveCalibrationSequence::USGHapticGloveCalibrationSequence(
         &OutSharedPtrContainer, &RhsContainer);
 
     Pimpl->HapticGloveCalibrationSequenceImpl = MoveTemp(OutSharedPtrContainer.Ptr);
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGloveCalibrationSequence::USGHapticGloveCalibrationSequence(
     const FSGHapticGloveQuickCalibrationImpl& HapticGloveQuickCalibrationImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_TSharedPtr_FSGHapticGloveQuickCalibrationImpl OutSharedPtrContainer;
     FSGIC_FSGHapticGloveQuickCalibrationImpl RhsContainer{HapticGloveQuickCalibrationImpl};
@@ -218,33 +187,20 @@ USGHapticGloveCalibrationSequence::USGHapticGloveCalibrationSequence(
         &OutSharedPtrContainer, &RhsContainer);
 
     Pimpl->HapticGloveCalibrationSequenceImpl = MoveTemp(OutSharedPtrContainer.Ptr);
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGloveCalibrationSequence::USGHapticGloveCalibrationSequence(
     TSharedRef<FSGHapticGloveCalibrationSequenceImpl> HapticGloveCalibrationSequenceImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     Pimpl->HapticGloveCalibrationSequenceImpl = MoveTemp(HapticGloveCalibrationSequenceImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGloveCalibrationSequence::USGHapticGloveCalibrationSequence(
     TSharedRef<FSGHapticGloveQuickCalibrationImpl> HapticGloveQuickCalibrationImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     Pimpl->HapticGloveCalibrationSequenceImpl = MoveTemp(HapticGloveQuickCalibrationImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGloveCalibrationSequence::~USGHapticGloveCalibrationSequence() = default;
@@ -282,24 +238,11 @@ void USGHapticGloveCalibrationSequence::SetHapticGloveCalibrationSequenceImpl(
 TSharedRef<FSGHapticGloveCalibrationSequenceImpl>
 USGHapticGloveCalibrationSequence::ToHapticGloveCalibrationSequenceImpl() const
 {
-    SyncImplObject();
     return Pimpl->HapticGloveCalibrationSequenceImpl.ToSharedRef();
 }
 
-void USGHapticGloveCalibrationSequence::SyncImplObject() const
-{
-    Pimpl->SyncImplObject();
-}
-
-void USGHapticGloveCalibrationSequence::SyncUProperties()
-{
-    Pimpl->SyncUProperties();
-}
-
 USGHapticGlove* USGHapticGloveCalibrationSequence::GetLinkedGlove(UObject* Outer) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl InstanceContainer{ToHapticGloveCalibrationSequenceImpl()};
     FSGIC_TSharedPtr_FSGHapticGloveImpl OutGloveContainer;
     SGCoreImpl_FSGHapticGloveCalibrationSequenceImpl_GetLinkedGlove(&InstanceContainer, &OutGloveContainer);
@@ -308,19 +251,13 @@ USGHapticGlove* USGHapticGloveCalibrationSequence::GetLinkedGlove(UObject* Outer
 
 void USGHapticGloveCalibrationSequence::SetLinkedGlove(const USGHapticGlove* LinkedGlove)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl InstanceContainer{ToHapticGloveCalibrationSequenceImpl()};
     FSGIC_TSharedPtr_FSGHapticGloveImpl LinkedGloveContainer{LinkedGlove->ToHapticGloveImpl()};
     SGCoreImpl_FSGHapticGloveCalibrationSequenceImpl_SetLinkedGlove(&InstanceContainer, &LinkedGloveContainer);
-
-    SyncUProperties();
 }
 
 TArray<USGCalibrationDataPoint*> USGHapticGloveCalibrationSequence::GetCalibrationPoints(UObject* Outer) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl InstanceContainer{ToHapticGloveCalibrationSequenceImpl()};
     FSGIC_TArray_FSGCalibrationDataPointImpl OutPoints;
     SGCoreImpl_FSGHapticGloveCalibrationSequenceImpl_GetCalibrationPoints(&InstanceContainer, &OutPoints);
@@ -336,97 +273,67 @@ TArray<USGCalibrationDataPoint*> USGHapticGloveCalibrationSequence::GetCalibrati
 
 float USGHapticGloveCalibrationSequence::GetElapsedTime() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl InstanceContainer{ToHapticGloveCalibrationSequenceImpl()};
     return SGCoreImpl_FSGHapticGloveCalibrationSequenceImpl_GetElapsedTime(&InstanceContainer);
 }
 
 bool USGHapticGloveCalibrationSequence::IsManuallyCompleted() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl InstanceContainer{ToHapticGloveCalibrationSequenceImpl()};
     return SGCoreImpl_FSGHapticGloveCalibrationSequenceImpl_IsManuallyCompleted(&InstanceContainer);
 }
 
 int32 USGHapticGloveCalibrationSequence::GetCurrentStage() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl InstanceContainer{ToHapticGloveCalibrationSequenceImpl()};
     return SGCoreImpl_FSGHapticGloveCalibrationSequenceImpl_GetCurrentStage(&InstanceContainer);
 }
 
 SIZE_T USGHapticGloveCalibrationSequence::GetCalibrationPointsCount() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl InstanceContainer{ToHapticGloveCalibrationSequenceImpl()};
     return SGCoreImpl_FSGHapticGloveCalibrationSequenceImpl_GetCalibrationPointsCount(&InstanceContainer);
 }
 
 bool USGHapticGloveCalibrationSequence::AutoCompleted() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl InstanceContainer{ToHapticGloveCalibrationSequenceImpl()};
     return SGCoreImpl_FSGHapticGloveCalibrationSequenceImpl_AutoCompleted(&InstanceContainer);
 }
 
 bool USGHapticGloveCalibrationSequence::Completed() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl InstanceContainer{ToHapticGloveCalibrationSequenceImpl()};
     return SGCoreImpl_FSGHapticGloveCalibrationSequenceImpl_Completed(&InstanceContainer);
 }
 
 void USGHapticGloveCalibrationSequence::Reset()
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl InstanceContainer{ToHapticGloveCalibrationSequenceImpl()};
     SGCoreImpl_FSGHapticGloveCalibrationSequenceImpl_Reset(&InstanceContainer);
-
-    SyncUProperties();
 }
 
 void USGHapticGloveCalibrationSequence::AddDataPoint(const TArray<FVector>& CalibrationPoints)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl InstanceContainer{ToHapticGloveCalibrationSequenceImpl()};
     FSGIC_TArray_FVector CalibrationPointsContainer{CalibrationPoints};
     SGCoreImpl_FSGHapticGloveCalibrationSequenceImpl_AddDataPoint(&InstanceContainer, &CalibrationPointsContainer);
-
-    SyncUProperties();
 }
 
 void USGHapticGloveCalibrationSequence::Update(const float DeltaSeconds)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl InstanceContainer{ToHapticGloveCalibrationSequenceImpl()};
     SGCoreImpl_FSGHapticGloveCalibrationSequenceImpl_Update(&InstanceContainer, DeltaSeconds);
-
-    SyncUProperties();
 }
 
 void USGHapticGloveCalibrationSequence::ConfirmCurrentStep()
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl InstanceContainer{ToHapticGloveCalibrationSequenceImpl()};
     SGCoreImpl_FSGHapticGloveCalibrationSequenceImpl_ConfirmCurrentStep(&InstanceContainer);
-
-    SyncUProperties();
 }
 
 bool USGHapticGloveCalibrationSequence::CompileRange(UObject* Outer, USGSensorRange*& OutSensorRange) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl InstanceContainer{ToHapticGloveCalibrationSequenceImpl()};
     FSGIC_FSGSensorRangeImpl OutSensorRangeContainer;
     const bool bResult = SGCoreImpl_FSGHapticGloveCalibrationSequenceImpl_CompileRange(
@@ -444,8 +351,6 @@ bool USGHapticGloveCalibrationSequence::CompileProfile(UObject* Outer,
                                                        const ESGDeviceType ForDevice, const bool bRightHanded,
                                                        USGHandProfile*& OutProfile) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl InstanceContainer{ToHapticGloveCalibrationSequenceImpl()};
     FSGIC_ESGDeviceType ForDeviceContainer{ForDevice};
     FSGIC_FSGHandProfileImpl OutProfileContainer;
@@ -463,8 +368,6 @@ bool USGHapticGloveCalibrationSequence::CompileProfile(UObject* Outer,
 
 bool USGHapticGloveCalibrationSequence::GetHandPose(UObject* Outer, USGHandPose*& OutCurrentHandPose) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl InstanceContainer{ToHapticGloveCalibrationSequenceImpl()};
     FSGIC_FSGHandPoseImpl OutCurrentHandPoseContainer;
     const bool bResult = SGCoreImpl_FSGHapticGloveCalibrationSequenceImpl_GetHandPose_OutCurrentHandPose(
@@ -481,8 +384,6 @@ bool USGHapticGloveCalibrationSequence::GetHandPose(UObject* Outer, USGHandPose*
 bool USGHapticGloveCalibrationSequence::GetHandPose(UObject* Outer,
                                                     const bool bRightHanded, USGHandPose*& OutCurrentHandPose) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl InstanceContainer{ToHapticGloveCalibrationSequenceImpl()};
     FSGIC_FSGHandPoseImpl OutCurrentHandPoseContainer;
     const bool bResult = SGCoreImpl_FSGHapticGloveCalibrationSequenceImpl_GetHandPose_bRightHanded_OutCurrentHandPose(
@@ -498,8 +399,6 @@ bool USGHapticGloveCalibrationSequence::GetHandPose(UObject* Outer,
 
 FString USGHapticGloveCalibrationSequence::GetCurrentInstruction(const FString& NextStepKey) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveCalibrationSequenceImpl InstanceContainer{ToHapticGloveCalibrationSequenceImpl()};
     FSGIC_FString OutInstructionContainer;
     FSGIC_FString NextStepKeyContainer{NextStepKey};
@@ -520,11 +419,3 @@ void USGHapticGloveCalibrationSequence::FImplDeleter::operator()(const FImpl* P)
 {
     delete P;
 }
-
-void USGHapticGloveCalibrationSequence::FImpl::SyncUProperties()
-{
-}
-
-void USGHapticGloveCalibrationSequence::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGHapticGloveCommandBuffer.cpp

@@ -80,13 +80,6 @@ struct USGHapticGloveCommandBuffer::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-    void SyncImplObject();
 };
 
 USGHapticGloveCommandBuffer* USGHapticGloveCommandBuffer::NewHapticGloveCommandBuffer(
@@ -122,32 +115,20 @@ int32 USGHapticGloveCommandBuffer::GetMaxThumpCommands()
 }
 
 USGHapticGloveCommandBuffer::USGHapticGloveCommandBuffer()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGHapticGloveCommandBufferImpl OutHapticGloveCommandBufferImplContainer;
     SGCoreImpl_FSGHapticGloveCommandBufferImpl_ctor(&OutHapticGloveCommandBufferImplContainer);
 
     Pimpl->HapticGloveCommandBufferImpl = MoveTemp(
         OutHapticGloveCommandBufferImplContainer.HapticGloveCommandBufferImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGloveCommandBuffer::USGHapticGloveCommandBuffer(
     const FSGHapticGloveCommandBufferImpl& HapticGloveCommandBufferImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     SetHapticGloveCommandBufferImpl(HapticGloveCommandBufferImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGloveCommandBuffer::~USGHapticGloveCommandBuffer() = default;
@@ -163,14 +144,11 @@ void USGHapticGloveCommandBuffer::SetHapticGloveCommandBufferImpl(
 
 const FSGHapticGloveCommandBufferImpl& USGHapticGloveCommandBuffer::ToHapticGloveCommandBufferImpl() const
 {
-    Pimpl->SyncImplObject();
     return Pimpl->HapticGloveCommandBufferImpl;
 }
 
 TArray<USGForceFeedbackCommand*> USGHapticGloveCommandBuffer::GetForceFeedbackCommandsQueue(UObject* Outer) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHapticGloveCommandBufferImpl InstanceContainer{ToHapticGloveCommandBufferImpl()};
     FSGIC_TArray_FSGForceFeedbackCommandImpl OutForceFeedbackCommandsQueueContainer;
     SGCoreImpl_FSGHapticGloveCommandBufferImpl_GetForceFeedbackCommandsQueue(&InstanceContainer,
@@ -188,8 +166,6 @@ TArray<USGForceFeedbackCommand*> USGHapticGloveCommandBuffer::GetForceFeedbackCo
 
 TArray<USGTimedBuzzCommand*> USGHapticGloveCommandBuffer::GetBuzzCommandsQueue(UObject* Outer) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHapticGloveCommandBufferImpl InstanceContainer{ToHapticGloveCommandBufferImpl()};
     FSGIC_TArray_FSGTimedBuzzCommandImpl OutBuzzCommandsQueueContainer;
     SGCoreImpl_FSGHapticGloveCommandBufferImpl_GetBuzzCommandsQueue(&InstanceContainer, &OutBuzzCommandsQueueContainer);
@@ -205,8 +181,6 @@ TArray<USGTimedBuzzCommand*> USGHapticGloveCommandBuffer::GetBuzzCommandsQueue(U
 
 TArray<USGTimedThumpCommand*> USGHapticGloveCommandBuffer::GetThumperCommandsQueue(UObject* Outer) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHapticGloveCommandBufferImpl InstanceContainer{ToHapticGloveCommandBufferImpl()};
     FSGIC_TArray_FSGTimedThumpCommandImpl OutThumperCommandsQueueContainer;
     SGCoreImpl_FSGHapticGloveCommandBufferImpl_GetThumperCommandsQueue(&InstanceContainer,
@@ -223,84 +197,54 @@ TArray<USGTimedThumpCommand*> USGHapticGloveCommandBuffer::GetThumperCommandsQue
 
 void USGHapticGloveCommandBuffer::ClearForceFeedbackCommandsQueue()
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHapticGloveCommandBufferImpl InstanceContainer{ToHapticGloveCommandBufferImpl()};
     SGCoreImpl_FSGHapticGloveCommandBufferImpl_ClearForceFeedbackCommandsQueue(&InstanceContainer);
-
-    Pimpl->SyncUProperties();
 }
 
 void USGHapticGloveCommandBuffer::ClearVibrations()
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHapticGloveCommandBufferImpl InstanceContainer{ToHapticGloveCommandBufferImpl()};
     SGCoreImpl_FSGHapticGloveCommandBufferImpl_ClearVibrations(&InstanceContainer);
-
-    Pimpl->SyncUProperties();
 }
 
 void USGHapticGloveCommandBuffer::Clear()
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHapticGloveCommandBufferImpl InstanceContainer{ToHapticGloveCommandBufferImpl()};
     SGCoreImpl_FSGHapticGloveCommandBufferImpl_Clear(&InstanceContainer);
-
-    Pimpl->SyncUProperties();
 }
 
 void USGHapticGloveCommandBuffer::AddCommand(const USGForceFeedbackCommand* ForceFeedbackCommand)
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHapticGloveCommandBufferImpl InstanceContainer{ToHapticGloveCommandBufferImpl()};
     FSGIC_FSGForceFeedbackCommandImpl ForceFeedbackCommandContainer{
         ForceFeedbackCommand->ToForceFeedbackCommandImpl().Get()};
     SGCoreImpl_FSGHapticGloveCommandBufferImpl_AddCommand_ForceFeedbackCommand(
         &InstanceContainer, &ForceFeedbackCommandContainer);
-
-    Pimpl->SyncUProperties();
 }
 
 void USGHapticGloveCommandBuffer::AddCommand(const USGTimedBuzzCommand* BuzzCommand)
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHapticGloveCommandBufferImpl InstanceContainer{ToHapticGloveCommandBufferImpl()};
     FSGIC_FSGTimedBuzzCommandImpl BuzzCommandContainer{BuzzCommand->ToTimedBuzzCommandImpl().Get()};
     SGCoreImpl_FSGHapticGloveCommandBufferImpl_AddCommand_BuzzCommand(&InstanceContainer, &BuzzCommandContainer);
-
-    Pimpl->SyncUProperties();
 }
 
 void USGHapticGloveCommandBuffer::AddCommand(const USGTimedThumpCommand* ThumpCommand)
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHapticGloveCommandBufferImpl InstanceContainer{ToHapticGloveCommandBufferImpl()};
     FSGIC_FSGTimedThumpCommandImpl ThumpCommandContainer{ThumpCommand->ToTimedThumpCommandImpl()};
     SGCoreImpl_FSGHapticGloveCommandBufferImpl_AddCommand_ThumpCommand(&InstanceContainer, &ThumpCommandContainer);
-
-    Pimpl->SyncUProperties();
 }
 
 void USGHapticGloveCommandBuffer::UpdateTimedCommands(const float DeltaSeconds)
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHapticGloveCommandBufferImpl InstanceContainer{ToHapticGloveCommandBufferImpl()};
     SGCoreImpl_FSGHapticGloveCommandBufferImpl_UpdateTimedCommands(&InstanceContainer, DeltaSeconds);
-
-    Pimpl->SyncUProperties();
 }
 
 USGForceFeedbackCommand* USGHapticGloveCommandBuffer::GetTotalForceFeedbackLevels(
     UObject* Outer, const USGForceFeedbackCommand* LastForceFeedbackCommand) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHapticGloveCommandBufferImpl InstanceContainer{ToHapticGloveCommandBufferImpl()};
     FSGIC_FSGForceFeedbackCommandImpl OutForceFeedbackCommandImplContainer;
     FSGIC_FSGForceFeedbackCommandImpl LastForceFeedbackCommandContainer{
@@ -314,8 +258,6 @@ USGForceFeedbackCommand* USGHapticGloveCommandBuffer::GetTotalForceFeedbackLevel
 
 USGForceFeedbackCommand* USGHapticGloveCommandBuffer::GetTotalForceFeedbackLevels(UObject* Outer) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHapticGloveCommandBufferImpl InstanceContainer{ToHapticGloveCommandBufferImpl()};
     FSGIC_FSGForceFeedbackCommandImpl OutForceFeedbackCommandImplContainer;
     SGCoreImpl_FSGHapticGloveCommandBufferImpl_GetTotalForceFeedbackLevels(
@@ -327,8 +269,6 @@ USGForceFeedbackCommand* USGHapticGloveCommandBuffer::GetTotalForceFeedbackLevel
 
 USGBuzzCommand* USGHapticGloveCommandBuffer::GetTotalBuzzLevels(UObject* Outer) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHapticGloveCommandBufferImpl InstanceContainer{ToHapticGloveCommandBufferImpl()};
     FSGIC_FSGBuzzCommandImpl OutBuzzCommandImplContainer;
     SGCoreImpl_FSGHapticGloveCommandBufferImpl_GetTotalBuzzLevels(&InstanceContainer, &OutBuzzCommandImplContainer);
@@ -338,8 +278,6 @@ USGBuzzCommand* USGHapticGloveCommandBuffer::GetTotalBuzzLevels(UObject* Outer)
 
 USGThumperCommand* USGHapticGloveCommandBuffer::GetTotalThumperLevels(UObject* Outer) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHapticGloveCommandBufferImpl InstanceContainer{ToHapticGloveCommandBufferImpl()};
     FSGIC_FSGThumperCommandImpl OutThumperCommandImplContainer;
     SGCoreImpl_FSGHapticGloveCommandBufferImpl_GetTotalThumperLevels(&InstanceContainer,
@@ -355,8 +293,6 @@ void USGHapticGloveCommandBuffer::FlushHaptics(UObject* Outer,
                                                USGThumperCommand*& OutThumperCommand,
                                                const bool bClearForceFeedbackQueue)
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHapticGloveCommandBufferImpl InstanceContainer{ToHapticGloveCommandBufferImpl()};
     FSGIC_FSGForceFeedbackCommandImpl LastBrakeLevelContainer{LastBrakeLevel->ToForceFeedbackCommandImpl().Get()};
     FSGIC_FSGForceFeedbackCommandImpl OutForceFeedbackCommandImplContainer;
@@ -371,8 +307,6 @@ void USGHapticGloveCommandBuffer::FlushHaptics(UObject* Outer,
     OutBuzzCommand = USGBuzzCommand::NewBuzzCommand(Outer, MoveTemp(OutBuzzCommandImplContainer.BuzzCommandImpl));
     OutThumperCommand = USGThumperCommand::NewThumperCommand(
         Outer, MoveTemp(OutThumperCommandImplContainer.ThumperCommandImpl));
-
-    Pimpl->SyncUProperties();
 }
 
 void USGHapticGloveCommandBuffer::FlushHaptics(UObject* Outer,
@@ -382,8 +316,6 @@ void USGHapticGloveCommandBuffer::FlushHaptics(UObject* Outer,
                                                USGBuzzCommand*& OutBuzzCommand,
                                                USGThumperCommand*& OutThumperCommand)
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGHapticGloveCommandBufferImpl InstanceContainer{ToHapticGloveCommandBufferImpl()};
     FSGIC_FSGForceFeedbackCommandImpl LastBrakeLevelContainer{LastBrakeLevel->ToForceFeedbackCommandImpl().Get()};
     FSGIC_FSGForceFeedbackCommandImpl OutForceFeedbackCommandImplContainer;
@@ -398,8 +330,6 @@ void USGHapticGloveCommandBuffer::FlushHaptics(UObject* Outer,
     OutBuzzCommand = USGBuzzCommand::NewBuzzCommand(Outer, MoveTemp(OutBuzzCommandImplContainer.BuzzCommandImpl));
     OutThumperCommand = USGThumperCommand::NewThumperCommand(
         Outer, MoveTemp(OutThumperCommandImplContainer.ThumperCommandImpl));
-
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGloveCommandBuffer::FImpl::FImpl(USGHapticGloveCommandBuffer* InOwner)
@@ -413,11 +343,3 @@ void USGHapticGloveCommandBuffer::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
 }
-
-void USGHapticGloveCommandBuffer::FImpl::SyncUProperties()
-{
-}
-
-void USGHapticGloveCommandBuffer::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGHapticGloveQuickCalibration.cpp

@@ -38,6 +38,9 @@
 #include "SGHapticGloveCalibrationSequenceImplCast.h"
 #include "Runtime/Launch/Resources/Version.h"
 
+#include "SGCore/SGHandPose.h"
+#include "SGCore/SGHandProfile.h"
+#include "SGCore/SGSensorRange.h"
 #include "SGCoreImpl/SGExportedFunctions.h"
 #include "SGInterop/SGIC_FSGHandPoseImpl.h"
 #include "SGInterop/SGIC_FSGHandProfileImpl.h"
@@ -48,42 +51,6 @@
 #include "SGInterop/SGIC_TSharedPtr_FSGHapticGloveQuickCalibrationImpl.h"
 #include "SGUtils/SGArrayUtils.h"
 
-struct USGHapticGloveQuickCalibration::FImpl
-{
-    /************************
-     * Member variables
-     ************************/
-
-
-    /************************
-     * Owner object
-     ************************/
-
-    USGHapticGloveQuickCalibration* Owner;
-
-    /************************
-     * Constructor / Destructor
-     ************************/
-
-    explicit FImpl(USGHapticGloveQuickCalibration* InOwner);
-    ~FImpl();
-
-    /************************
-     * Default copy constructor & copy assignment operator
-     ************************/
-
-    FImpl(const FImpl& Rhs) = default;
-    FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-
-    void SyncImplObject();
-};
-
 USGHapticGloveQuickCalibration* USGHapticGloveQuickCalibration::NewHapticGloveQuickCalibration(UObject* Outer,
     const FSGHapticGloveQuickCalibrationImpl& HapticGloveQuickCalibration)
 {
@@ -125,28 +92,17 @@ float USGHapticGloveQuickCalibration::GetDefaultAutoEndTimeout()
 }
 
 USGHapticGloveQuickCalibration::USGHapticGloveQuickCalibration()
-    : USGHapticGloveCalibrationSequence(),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGHapticGloveCalibrationSequence()
 {
     FSGIC_TSharedPtr_FSGHapticGloveQuickCalibrationImpl OutSharedPtrContainer;
     SGCoreImpl_FSGHapticGloveQuickCalibrationImpl_ctor_MakeShared(&OutSharedPtrContainer);
 
     SetHapticGloveCalibrationSequenceImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGloveQuickCalibration::USGHapticGloveQuickCalibration(
     const USGHapticGlove* GloveToCalibrate, const float AutoEndTimeout)
-    : USGHapticGloveCalibrationSequence(GloveToCalibrate),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGHapticGloveCalibrationSequence(GloveToCalibrate)
 {
     FSGIC_TSharedPtr_FSGHapticGloveQuickCalibrationImpl OutSharedPtrContainer;
     FSGIC_TSharedPtr_FSGHapticGloveImpl GloveToCalibrateContainer{GloveToCalibrate->ToHapticGloveImpl()};
@@ -154,54 +110,28 @@ USGHapticGloveQuickCalibration::USGHapticGloveQuickCalibration(
         &OutSharedPtrContainer, &GloveToCalibrateContainer, AutoEndTimeout);
 
     SetHapticGloveCalibrationSequenceImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGloveQuickCalibration::USGHapticGloveQuickCalibration(
     const FSGHapticGloveQuickCalibrationImpl& HapticGloveQuickCalibrationImpl)
-    : USGHapticGloveCalibrationSequence(HapticGloveQuickCalibrationImpl),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGHapticGloveCalibrationSequence(HapticGloveQuickCalibrationImpl)
 {
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGloveQuickCalibration::USGHapticGloveQuickCalibration(
     TSharedRef<FSGHapticGloveQuickCalibrationImpl> HapticGloveQuickCalibrationImpl)
-    : USGHapticGloveCalibrationSequence(MoveTemp(HapticGloveQuickCalibrationImpl)),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGHapticGloveCalibrationSequence(MoveTemp(HapticGloveQuickCalibrationImpl))
 {
-    Pimpl->SyncUProperties();
 }
 
 USGHapticGloveQuickCalibration::~USGHapticGloveQuickCalibration() = default;
 
 TSharedRef<FSGHapticGloveQuickCalibrationImpl> USGHapticGloveQuickCalibration::ToHapticGloveQuickCalibrationImpl() const
 {
-    SyncImplObject();
     return FSGHapticGloveCalibrationSequenceImplCast::ToHapticGloveQuickCalibrationImpl(
         ToHapticGloveCalibrationSequenceImpl());
 }
 
-void USGHapticGloveQuickCalibration::SyncImplObject() const
-{
-    Super::SyncImplObject();
-    Pimpl->SyncImplObject();
-}
-
-void USGHapticGloveQuickCalibration::SyncUProperties()
-{
-    Super::SyncUProperties();
-    Pimpl->SyncUProperties();
-}
-
 float USGHapticGloveQuickCalibration::GetAutoEndTimeout() const
 {
     FSGIC_TSharedPtr_FSGHapticGloveQuickCalibrationImpl InstanceContainer{ToHapticGloveQuickCalibrationImpl()};
@@ -210,16 +140,12 @@ float USGHapticGloveQuickCalibration::GetAutoEndTimeout() const
 
 int32 USGHapticGloveQuickCalibration::GetSmoothingSamples() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveQuickCalibrationImpl InstanceContainer{ToHapticGloveQuickCalibrationImpl()};
     return SGCoreImpl_FSGHapticGloveQuickCalibrationImpl_GetSmoothingSamples(&InstanceContainer);
 }
 
 USGSensorRange* USGHapticGloveQuickCalibration::GetSensorRange(UObject* Outer) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveQuickCalibrationImpl InstanceContainer{ToHapticGloveQuickCalibrationImpl()};
     FSGIC_FSGSensorRangeImpl OutRangeContainer;
     SGCoreImpl_FSGHapticGloveQuickCalibrationImpl_GetSensorRange(&InstanceContainer, &OutRangeContainer);
@@ -229,8 +155,6 @@ USGSensorRange* USGHapticGloveQuickCalibration::GetSensorRange(UObject* Outer) c
 
 USGHandProfile* USGHapticGloveQuickCalibration::GetTemporaryProfile(UObject* Outer) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveQuickCalibrationImpl InstanceContainer{ToHapticGloveQuickCalibrationImpl()};
     FSGIC_FSGHandProfileImpl OutProfileContainer;
     SGCoreImpl_FSGHapticGloveQuickCalibrationImpl_GetTemporaryProfile(&InstanceContainer, &OutProfileContainer);
@@ -240,65 +164,43 @@ USGHandProfile* USGHapticGloveQuickCalibration::GetTemporaryProfile(UObject* Out
 
 bool USGHapticGloveQuickCalibration::CanAnimate() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveQuickCalibrationImpl InstanceContainer{ToHapticGloveQuickCalibrationImpl()};
     return SGCoreImpl_FSGHapticGloveQuickCalibrationImpl_CanAnimate(&InstanceContainer);
 }
 
 bool USGHapticGloveQuickCalibration::AutoCompleted() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveQuickCalibrationImpl InstanceContainer{ToHapticGloveQuickCalibrationImpl()};
     return SGCoreImpl_FSGHapticGloveQuickCalibrationImpl_AutoCompleted(&InstanceContainer);
 }
 
 void USGHapticGloveQuickCalibration::Reset()
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveQuickCalibrationImpl InstanceContainer{ToHapticGloveQuickCalibrationImpl()};
     SGCoreImpl_FSGHapticGloveQuickCalibrationImpl_Reset(&InstanceContainer);
-
-    SyncUProperties();
 }
 
 void USGHapticGloveQuickCalibration::Update(const float DeltaSeconds)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveQuickCalibrationImpl InstanceContainer{ToHapticGloveQuickCalibrationImpl()};
     SGCoreImpl_FSGHapticGloveQuickCalibrationImpl_Update(&InstanceContainer, DeltaSeconds);
-
-    SyncUProperties();
 }
 
 void USGHapticGloveQuickCalibration::AddDataPoint(const TArray<FVector>& CalibrationPoints)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveQuickCalibrationImpl InstanceContainer{ToHapticGloveQuickCalibrationImpl()};
     FSGIC_TArray_FVector CalibrationPointsContainer{CalibrationPoints};
     SGCoreImpl_FSGHapticGloveQuickCalibrationImpl_AddDataPoint(&InstanceContainer, &CalibrationPointsContainer);
-
-    SyncUProperties();
 }
 
 void USGHapticGloveQuickCalibration::ConfirmCurrentStep()
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveQuickCalibrationImpl InstanceContainer{ToHapticGloveQuickCalibrationImpl()};
     SGCoreImpl_FSGHapticGloveQuickCalibrationImpl_ConfirmCurrentStep(&InstanceContainer);
-
-    SyncUProperties();
 }
 
 bool USGHapticGloveQuickCalibration::CompileRange(UObject* Outer, USGSensorRange*& OutSensorRange) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveQuickCalibrationImpl InstanceContainer{ToHapticGloveQuickCalibrationImpl()};
     FSGIC_FSGSensorRangeImpl OutSensorRangeContainer;
     const bool bResult = SGCoreImpl_FSGHapticGloveQuickCalibrationImpl_CompileRange(
@@ -312,8 +214,6 @@ bool USGHapticGloveQuickCalibration::CompileRange(UObject* Outer, USGSensorRange
 bool USGHapticGloveQuickCalibration::GetHandPose(UObject* Outer,
                                                  const bool bRightHanded, USGHandPose*& OutCurrentHandPose) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveQuickCalibrationImpl InstanceContainer{ToHapticGloveQuickCalibrationImpl()};
     FSGIC_FSGHandPoseImpl OutCurrentHandPoseContainer;
     const bool bResult = SGCoreImpl_FSGHapticGloveQuickCalibrationImpl_GetHandPose(
@@ -326,8 +226,6 @@ bool USGHapticGloveQuickCalibration::GetHandPose(UObject* Outer,
 
 FString USGHapticGloveQuickCalibration::GetCurrentInstruction(const FString& NextStepKey) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGHapticGloveQuickCalibrationImpl InstanceContainer{ToHapticGloveQuickCalibrationImpl()};
     FSGIC_FString OutInstructionContainer;
     FSGIC_FString NextStepKeyContainer{NextStepKey};
@@ -336,23 +234,3 @@ FString USGHapticGloveQuickCalibration::GetCurrentInstruction(const FString& Nex
 
     return MoveTemp(OutInstructionContainer.String);
 }
-
-USGHapticGloveQuickCalibration::FImpl::FImpl(USGHapticGloveQuickCalibration* InOwner)
-    : Owner(InOwner)
-{
-}
-
-USGHapticGloveQuickCalibration::FImpl::~FImpl() = default;
-
-void USGHapticGloveQuickCalibration::FImplDeleter::operator()(const FImpl* P) const
-{
-    delete P;
-}
-
-void USGHapticGloveQuickCalibration::FImpl::SyncUProperties()
-{
-}
-
-void USGHapticGloveQuickCalibration::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGInterpolationSet.cpp

@@ -69,13 +69,6 @@ struct USGInterpolationSet::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-    void SyncImplObject();
 };
 
 USGInterpolationSet* USGInterpolationSet::NewInterpolationSet(UObject* Outer,
@@ -125,63 +118,39 @@ USGInterpolationSet* USGInterpolationSet::Deserialize(UObject* Outer, const FStr
 }
 
 USGInterpolationSet::USGInterpolationSet()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGInterpolationSetImpl OutInterpolationSetImplContainer;
     SGCoreImpl_FSGInterpolationSetImpl_ctor(&OutInterpolationSetImplContainer);
 
     Pimpl->InterpolationSetImpl = MoveTemp(OutInterpolationSetImplContainer.InterpolationSetImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGInterpolationSet::USGInterpolationSet(const float From1, const float From2, const float To1, const float To2)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGInterpolationSetImpl OutInterpolationSetImplContainer;
     SGCoreImpl_FSGInterpolationSetImpl_ctor_From1_From2_To1_To2(&OutInterpolationSetImplContainer,
                                                                 From1, From2, To1, To2);
 
     Pimpl->InterpolationSetImpl = MoveTemp(OutInterpolationSetImplContainer.InterpolationSetImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGInterpolationSet::USGInterpolationSet(const float From1, const float From2, const float To1, const float To2,
                                          const float Min, const float Max)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGInterpolationSetImpl OutInterpolationSetImplContainer;
     SGCoreImpl_FSGInterpolationSetImpl_ctor_From1_From2_To1_To2_Min_Max(&OutInterpolationSetImplContainer,
                                                                         From1, From2, To1, To2, Min, Max);
 
     Pimpl->InterpolationSetImpl = MoveTemp(OutInterpolationSetImplContainer.InterpolationSetImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGInterpolationSet::USGInterpolationSet(const FSGInterpolationSetImpl& InterpolationSetImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     SetInterpolationSetImpl(InterpolationSetImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGInterpolationSet::~USGInterpolationSet() = default;
@@ -196,7 +165,6 @@ void USGInterpolationSet::SetInterpolationSetImpl(const FSGInterpolationSetImpl&
 
 const FSGInterpolationSetImpl& USGInterpolationSet::ToInterpolationSetImpl() const
 {
-    Pimpl->SyncImplObject();
     return Pimpl->InterpolationSetImpl;
 }
 
@@ -274,16 +242,12 @@ void USGInterpolationSet::SetMax(const float Max)
 
 float USGInterpolationSet::Get(const float Value, const bool bLimit, const bool bNormalizeAngle) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGInterpolationSetImpl InstanceContainer{ToInterpolationSetImpl()};
     return SGCoreImpl_FSGInterpolationSetImpl_Get(&InstanceContainer, Value, bLimit, bNormalizeAngle);
 }
 
 bool USGInterpolationSet::Equals(const USGInterpolationSet* InterpolationSet) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGInterpolationSetImpl InstanceContainer{ToInterpolationSetImpl()};
     FSGIC_FSGInterpolationSetImpl InterpolationSetContainer{InterpolationSet->ToInterpolationSetImpl()};
     return SGCoreImpl_FSGInterpolationSetImpl_Equals(&InstanceContainer, &InterpolationSetContainer);
@@ -291,8 +255,6 @@ bool USGInterpolationSet::Equals(const USGInterpolationSet* InterpolationSet) co
 
 FString USGInterpolationSet::ToString() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGInterpolationSetImpl InstanceContainer{ToInterpolationSetImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGInterpolationSetImpl_ToString(&InstanceContainer, &OutStringContainer);
@@ -301,8 +263,6 @@ FString USGInterpolationSet::ToString() const
 
 FString USGInterpolationSet::ToString(const bool bLimits) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGInterpolationSetImpl InstanceContainer{ToInterpolationSetImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGInterpolationSetImpl_ToString_bLimits(&InstanceContainer, &OutStringContainer, bLimits);
@@ -311,8 +271,6 @@ FString USGInterpolationSet::ToString(const bool bLimits) const
 
 FString USGInterpolationSet::SGSerialize() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGInterpolationSetImpl InstanceContainer{ToInterpolationSetImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGInterpolationSetImpl_Serialize(&InstanceContainer, &OutStringContainer);
@@ -330,11 +288,3 @@ void USGInterpolationSet::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
 }
-
-void USGInterpolationSet::FImpl::SyncUProperties()
-{
-}
-
-void USGInterpolationSet::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGJointKinematics.cpp

@@ -43,6 +43,7 @@
 #include "SGInterop/SGIC_FVector.h"
 #include "SGInterop/SGIC_TArray_FQuat.h"
 #include "SGInterop/SGIC_TArray_FVector.h"
+#include "SGUtils/SGArrayUtils.h"
 
 bool FSGJointKinematics::ForwardKinematics(
     const FVector& StartPosition, const FQuat& StartRotation, const TArray<FVector>& JointLengths,

Source/SenseGloveCore/Private/SGCore/SGNovaGlove.cpp

@@ -43,6 +43,7 @@
 #include "SGCore/SGForceFeedbackCommand.h"
 #include "SGCore/SGHandPose.h"
 #include "SGCore/SGHandProfile.h"
+#include "SGCore/SGNovaGloveHandProfile.h"
 #include "SGCore/SGNovaGloveInfo.h"
 #include "SGCore/SGNovaGloveSensorData.h"
 #include "SGCore/SGThumperCommand.h"
@@ -69,42 +70,6 @@
 #include "SGInterop/SGIC_TArray_FVector.h"
 #include "SGInterop/SGIC_TSharedPtr_FSGNovaGloveImpl.h"
 
-struct USGNovaGlove::FImpl
-{
-    /************************
-     * Member variables
-     ************************/
-
-
-    /************************
-     * Owner object
-     ************************/
-
-    USGDevice* Owner;
-
-    /************************
-     * Constructor / Destructor
-     ************************/
-
-    explicit FImpl(USGNovaGlove* InOwner);
-    ~FImpl();
-
-    /************************
-     * Default copy constructor & copy assignment operator
-     ************************/
-
-    FImpl(const FImpl& Rhs) = default;
-    FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-
-    void SyncImplObject();
-};
-
 USGNovaGlove* USGNovaGlove::NewNovaGlove(UObject* Outer, const FSGNovaGloveImpl& NovaGloveImpl)
 {
     USGNovaGlove* Instance = NewObject<USGNovaGlove>(Outer);
@@ -335,126 +300,63 @@ FString USGNovaGlove::ToBytes(const USGBuzzCommand* BuzzCommand)
 }
 
 USGNovaGlove::USGNovaGlove()
-    : USGHapticGlove(),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGHapticGlove()
 {
     FSGIC_TSharedPtr_FSGNovaGloveImpl OutSharedPtrContainer;
     SGCoreImpl_FSGSenseGloveImpl_ctor_MakeShared(&OutSharedPtrContainer);
 
     SetSGDeviceImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
-    Pimpl->SyncUProperties();
 }
 
 USGNovaGlove::USGNovaGlove(const USGNovaGloveInfo& DeviceInfo)
-    : USGHapticGlove(),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGHapticGlove()
 {
     FSGIC_TSharedPtr_FSGNovaGloveImpl OutSharedPtrContainer;
     FSGIC_FSGNovaGloveInfoImpl DeviceInfoContainer{DeviceInfo.ToNovaGloveInfoImpl()};
     SGCoreImpl_FSGSenseGloveImpl_ctor_Model_MakeShared(&OutSharedPtrContainer, &DeviceInfoContainer);
 
     SetSGDeviceImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
-    Pimpl->SyncUProperties();
 }
 
 USGNovaGlove::USGNovaGlove(const FSGDeviceImpl& SGDeviceImpl)
-    : USGHapticGlove(SGDeviceImpl),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGHapticGlove(SGDeviceImpl)
 {
-    Pimpl->SyncUProperties();
 }
 
 USGNovaGlove::USGNovaGlove(const FSGHapticGloveImpl& HapticGloveImpl)
-    : USGHapticGlove(HapticGloveImpl),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGHapticGlove(HapticGloveImpl)
 {
-    Pimpl->SyncUProperties();
 }
 
 USGNovaGlove::USGNovaGlove(const FSGNovaGloveImpl& NovaGloveImpl)
-    : USGHapticGlove(NovaGloveImpl),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGHapticGlove(NovaGloveImpl)
 {
-    Pimpl->SyncUProperties();
 }
 
 USGNovaGlove::USGNovaGlove(const TSharedRef<FSGDeviceImpl> SGDeviceImpl)
-    : USGHapticGlove(SGDeviceImpl),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGHapticGlove(SGDeviceImpl)
 {
-    Pimpl->SyncUProperties();
 }
 
 USGNovaGlove::USGNovaGlove(const TSharedRef<FSGHapticGloveImpl> HapticGloveImpl)
-    : USGHapticGlove(HapticGloveImpl),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGHapticGlove(HapticGloveImpl)
 {
-    Pimpl->SyncUProperties();
 }
 
 USGNovaGlove::USGNovaGlove(const TSharedRef<FSGNovaGloveImpl> NovaGloveImpl)
-    : USGHapticGlove(NovaGloveImpl),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGHapticGlove(NovaGloveImpl)
 {
-    Pimpl->SyncUProperties();
 }
 
 USGNovaGlove::~USGNovaGlove() = default;
 
 TSharedRef<FSGNovaGloveImpl> USGNovaGlove::ToNovaGloveImpl() const
 {
-    SyncImplObject();
     return FSGDeviceImplCast::ToNovaGloveImpl(ToSGDeviceImpl());
 }
 
-void USGNovaGlove::SyncImplObject() const
-{
-    Super::SyncImplObject();
-    Pimpl->SyncImplObject();
-}
-
-void USGNovaGlove::SyncUProperties()
-{
-    Super::SyncUProperties();
-    Pimpl->SyncUProperties();
-}
-
 ESGDeviceType USGNovaGlove::GetDeviceType() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_ESGDeviceType OutTypeContainer;
     SGCoreImpl_FSGNovaGloveImpl_GetDeviceType(&InstanceContainer, &OutTypeContainer);
@@ -463,8 +365,6 @@ ESGDeviceType USGNovaGlove::GetDeviceType() const
 
 FString USGNovaGlove::GetDeviceId() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_FString OutIdContainer;
     SGCoreImpl_FSGNovaGloveImpl_GetDeviceId(&InstanceContainer, &OutIdContainer);
@@ -473,8 +373,6 @@ FString USGNovaGlove::GetDeviceId() const
 
 FString USGNovaGlove::GetHardwareVersion() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_FString OutVersionContainer;
     SGCoreImpl_FSGNovaGloveImpl_GetHardwareVersion(&InstanceContainer, &OutVersionContainer);
@@ -483,56 +381,38 @@ FString USGNovaGlove::GetHardwareVersion() const
 
 int32 USGNovaGlove::GetFirmwareVersion() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     return SGCoreImpl_FSGNovaGloveImpl_GetFirmwareVersion(&InstanceContainer);
 }
 
 int32 USGNovaGlove::GetSubFirmwareVersion() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     return SGCoreImpl_FSGNovaGloveImpl_GetSubFirmwareVersion(&InstanceContainer);
 }
 
 bool USGNovaGlove::HasBattery() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     return SGCoreImpl_FSGNovaGloveImpl_HasBattery(&InstanceContainer);
 }
 
 bool USGNovaGlove::IsCharging()
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     const bool bResult = SGCoreImpl_FSGNovaGloveImpl_IsCharging(&InstanceContainer);
-
-    SyncUProperties();
-
     return bResult;
 }
 
 bool USGNovaGlove::GetBatteryLevel(float& OutBatteryLevel)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     const bool bResult = SGCoreImpl_FSGNovaGloveImpl_GetBatteryLevel(&InstanceContainer, &OutBatteryLevel);
-
-    SyncUProperties();
-
     return bResult;
 }
 
 bool USGNovaGlove::GetSensorData(UObject* Outer, USGNovaGloveSensorData*& OutSensorData)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_FSGNovaGloveSensorDataImpl OutSensorDataContainer;
     const bool bResult = SGCoreImpl_FSGNovaGloveImpl_GetSensorData(&InstanceContainer, &OutSensorDataContainer);
@@ -548,14 +428,10 @@ bool USGNovaGlove::GetSensorData(UObject* Outer, USGNovaGloveSensorData*& OutSen
 
 bool USGNovaGlove::GetImuRotation(FQuat& OutImu)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_FQuat OutImuContainer;
     const bool bResult = SGCoreImpl_FSGNovaGloveImpl_GetImuRotation(&InstanceContainer, &OutImuContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutImu = MoveTemp(OutImuContainer.Quat);
@@ -566,14 +442,10 @@ bool USGNovaGlove::GetImuRotation(FQuat& OutImu)
 
 bool USGNovaGlove::GetImuRotation(FRotator& OutImu)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_FQuat OutImuContainer;
     const bool bResult = SGCoreImpl_FSGNovaGloveImpl_GetImuRotation(&InstanceContainer, &OutImuContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutImu = OutImuContainer.Quat.Rotator();
@@ -586,8 +458,6 @@ bool USGNovaGlove::GetHandPose(
     UObject* Outer, const USGBasicHandModel* HandModel, const USGNovaGloveHandProfile* Profile,
     USGHandPose*& OutHandPose)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_FSGBasicHandModelImpl HandModelContainer{HandModel->ToBasicHandModelImpl()};
     FSGIC_FSGNovaGloveHandProfileImpl ProfileContainer{Profile->ToNovaGloveHandProfileImpl()};
@@ -595,8 +465,6 @@ bool USGNovaGlove::GetHandPose(
     const bool bResult = SGCoreImpl_FSGNovaGloveImpl_GetHandPose_HandModel_Profile_OutHandPose(
         &InstanceContainer, &HandModelContainer, &ProfileContainer, &OutHandPoseContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutHandPose = USGHandPose::NewHandPose(Outer, MoveTemp(OutHandPoseContainer.HandPoseImpl));
@@ -608,8 +476,6 @@ bool USGNovaGlove::GetHandPose(
 bool USGNovaGlove::GetHandPose(UObject* Outer, const USGBasicHandModel* HandGeometry, const USGHandProfile* HandProfile,
                                USGHandPose*& OutHandPose)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_FSGBasicHandModelImpl HandGeometryContainer{HandGeometry->ToBasicHandModelImpl()};
     FSGIC_FSGHandProfileImpl ProfileContainer{HandProfile->ToHandProfileImpl()};
@@ -617,8 +483,6 @@ bool USGNovaGlove::GetHandPose(UObject* Outer, const USGBasicHandModel* HandGeom
     const bool bResult = SGCoreImpl_FSGNovaGloveImpl_GetHandPose_HandGeometry_HandProfile_OutHandPose(
         &InstanceContainer, &HandGeometryContainer, &ProfileContainer, &OutHandPoseContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutHandPose = USGHandPose::NewHandPose(Outer, MoveTemp(OutHandPoseContainer.HandPoseImpl));
@@ -629,16 +493,12 @@ bool USGNovaGlove::GetHandPose(UObject* Outer, const USGBasicHandModel* HandGeom
 
 bool USGNovaGlove::GetHandPose(UObject* Outer, const USGHandProfile* HandProfile, USGHandPose*& OutHandPose)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_FSGHandProfileImpl ProfileContainer{HandProfile->ToHandProfileImpl()};
     FSGIC_FSGHandPoseImpl OutHandPoseContainer;
     const bool bResult = SGCoreImpl_FSGNovaGloveImpl_GetHandPose_HandProfile_OutHandPose(
         &InstanceContainer, &ProfileContainer, &OutHandPoseContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutHandPose = USGHandPose::NewHandPose(Outer, MoveTemp(OutHandPoseContainer.HandPoseImpl));
@@ -651,8 +511,6 @@ void USGNovaGlove::SendHaptics(const USGForceFeedbackCommand* ForceFeedbackComma
                                const USGBuzzCommand* BuzzCommand,
                                const USGThumperCommand* ThumperCommand)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_FSGForceFeedbackCommandImpl ForceFeedbackCommandContainer{
         ForceFeedbackCommand->ToForceFeedbackCommandImpl().Get()};
@@ -660,55 +518,37 @@ void USGNovaGlove::SendHaptics(const USGForceFeedbackCommand* ForceFeedbackComma
     FSGIC_FSGThumperCommandImpl ThumperCommandContainer{ThumperCommand->ToThumperCommandImpl()};
     SGCoreImpl_FSGNovaGloveImpl_SendHaptics_ForceFeedbackCommand_BuzzCommand_ThumperCommand(
         &InstanceContainer, &ForceFeedbackCommandContainer, &BuzzCommandContainer, &ThumperCommandContainer);
-
-    SyncUProperties();
 }
 
 void USGNovaGlove::SendHaptics(const USGForceFeedbackCommand* ForceFeedbackCommand)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_FSGForceFeedbackCommandImpl ForceFeedbackCommandContainer{
         ForceFeedbackCommand->ToForceFeedbackCommandImpl().Get()};
     SGCoreImpl_FSGNovaGloveImpl_SendHaptics_ForceFeedbackCommand(&InstanceContainer, &ForceFeedbackCommandContainer);
-
-    SyncUProperties();
 }
 
 void USGNovaGlove::SendHaptics(const USGBuzzCommand* BuzzCommand)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_FSGBuzzCommandImpl BuzzCommandContainer{BuzzCommand->ToBuzzCommandImpl().Get()};
     SGCoreImpl_FSGNovaGloveImpl_SendHaptics_ForceFeedbackCommand(&InstanceContainer, &BuzzCommandContainer);
-
-    SyncUProperties();
 }
 
 void USGNovaGlove::SendHaptics(const USGThumperCommand* ThumperCommand)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_FSGThumperCommandImpl ThumperCommandContainer{ThumperCommand->ToThumperCommandImpl()};
     SGCoreImpl_FSGNovaGloveImpl_SendHaptics_ForceFeedbackCommand(&InstanceContainer, &ThumperCommandContainer);
-
-    SyncUProperties();
 }
 
 bool USGNovaGlove::GetCalibrationValues(TArray<FVector>& OutValues)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_TArray_FVector OutValuesContainer;
     const bool bResult = SGCoreImpl_FSGNovaGloveImpl_GetCalibrationValues_OutValues(
         &InstanceContainer, &OutValuesContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutValues = MoveTemp(OutValuesContainer.Array);
@@ -719,8 +559,6 @@ bool USGNovaGlove::GetCalibrationValues(TArray<FVector>& OutValues)
 
 void USGNovaGlove::ApplyCalibration(UObject* Outer, USGHandProfile*& OutProfile) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_FSGHandProfileImpl OutProfileContainer;
     SGCoreImpl_FSGNovaGloveImpl_ApplyCalibration_HandProfile(&InstanceContainer, &OutProfileContainer);
@@ -729,8 +567,6 @@ void USGNovaGlove::ApplyCalibration(UObject* Outer, USGHandProfile*& OutProfile)
 
 void USGNovaGlove::ApplyCalibration(UObject* Outer, USGNovaGloveHandProfile*& OutProfile) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_FSGNovaGloveHandProfileImpl OutProfileContainer;
     SGCoreImpl_FSGNovaGloveImpl_ApplyCalibration_NovaGloveHandProfile(&InstanceContainer, &OutProfileContainer);
@@ -742,8 +578,6 @@ void USGNovaGlove::GetGloveLocation(const FVector& ReferencePosition, const FQua
                                     const ESGPositionalTrackingHardware TrackingHardware,
                                     FVector& OutGlovePosition, FQuat& OutGloveRotation) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_FVector ReferencePositionContainer{ReferencePosition};
     FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation};
@@ -765,8 +599,6 @@ void USGNovaGlove::GetGloveLocation(const FVector& ReferencePosition, const FRot
                                     const ESGPositionalTrackingHardware TrackingHardware,
                                     FVector& OutGlovePosition, FRotator& OutGloveRotation) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_FVector ReferencePositionContainer{ReferencePosition};
     FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
@@ -788,8 +620,6 @@ void USGNovaGlove::GetWristLocation(const FVector& ReferencePosition, const FQua
                                     const ESGPositionalTrackingHardware TrackingHardware,
                                     FVector& OutWristPosition, FQuat& OutWristRotation) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_FVector ReferencePositionContainer{ReferencePosition};
     FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation};
@@ -810,8 +640,6 @@ void USGNovaGlove::GetWristLocation(const FVector& ReferencePosition, const FRot
                                     const ESGPositionalTrackingHardware TrackingHardware,
                                     FVector& OutWristPosition, FRotator& OutWristRotation) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_FVector ReferencePositionContainer{ReferencePosition};
     FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
@@ -830,30 +658,8 @@ void USGNovaGlove::GetWristLocation(const FVector& ReferencePosition, const FRot
 
 FString USGNovaGlove::ToString() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGNovaGloveImpl InstanceContainer{ToNovaGloveImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGNovaGloveImpl_ToString(&InstanceContainer, &OutStringContainer);
     return MoveTemp(OutStringContainer.String);;
 }
-
-USGNovaGlove::FImpl::FImpl(USGNovaGlove* InOwner)
-    : Owner(InOwner)
-{
-}
-
-USGNovaGlove::FImpl::~FImpl() = default;
-
-void USGNovaGlove::FImplDeleter::operator()(const FImpl* P) const
-{
-    delete P;
-}
-
-void USGNovaGlove::FImpl::SyncUProperties()
-{
-}
-
-void USGNovaGlove::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGNovaGloveHandProfile.cpp

@@ -71,14 +71,6 @@ struct USGNovaGloveHandProfile::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-
-    void SyncImplObject();
 };
 
 USGNovaGloveHandProfile* USGNovaGloveHandProfile::NewNovaGloveHandProfile(
@@ -121,33 +113,22 @@ USGNovaGloveHandProfile* USGNovaGloveHandProfile::Deserialize(UObject* Outer, co
     FSGIC_FSGNovaGloveHandProfileImpl OutNovaGloveHandProfileImplContainer;
     FSGIC_FString SerializedStringContainer{SerializedString};
     SGCoreImpl_FSGNovaGloveHandProfileImpl_Deserialize(&OutNovaGloveHandProfileImplContainer,
-                                                        &SerializedStringContainer);
+                                                       &SerializedStringContainer);
 
     return NewNovaGloveHandProfile(Outer, MoveTemp(OutNovaGloveHandProfileImplContainer.NovaGloveHandProfileImpl));
 }
 
 USGNovaGloveHandProfile::USGNovaGloveHandProfile()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGNovaGloveHandProfileImpl OutNovaGloveHandProfileImplContainer;
     SGCoreImpl_FSGNovaGloveHandProfileImpl_ctor(&OutNovaGloveHandProfileImplContainer);
 
     Pimpl->NovaGloveHandProfileImpl = MoveTemp(OutNovaGloveHandProfileImplContainer.NovaGloveHandProfileImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGNovaGloveHandProfile::USGNovaGloveHandProfile(const bool bRightHanded, const USGHandInterpolator* Interpolator)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGNovaGloveHandProfileImpl OutNovaGloveHandProfileImplContainer;
     FSGIC_FSGHandInterpolatorImpl InterpolatorContainer{Interpolator->ToHandInterpolatorImpl()};
@@ -155,19 +136,12 @@ USGNovaGloveHandProfile::USGNovaGloveHandProfile(const bool bRightHanded, const
         &OutNovaGloveHandProfileImplContainer, bRightHanded, &InterpolatorContainer);
 
     Pimpl->NovaGloveHandProfileImpl = MoveTemp(OutNovaGloveHandProfileImplContainer.NovaGloveHandProfileImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGNovaGloveHandProfile::USGNovaGloveHandProfile(const FSGNovaGloveHandProfileImpl& NovaGloveHandProfileImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     SetNovaGloveHandProfileImpl(NovaGloveHandProfileImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGNovaGloveHandProfile::~USGNovaGloveHandProfile() = default;
@@ -182,7 +156,6 @@ void USGNovaGloveHandProfile::SetNovaGloveHandProfileImpl(const FSGNovaGloveHand
 
 const FSGNovaGloveHandProfileImpl& USGNovaGloveHandProfile::ToNovaGloveHandProfileImpl() const
 {
-    Pimpl->SyncImplObject();
     return Pimpl->NovaGloveHandProfileImpl;
 }
 
@@ -203,8 +176,6 @@ USGHandInterpolator* USGNovaGloveHandProfile::GetInterpolationSet(UObject* Outer
 
 bool USGNovaGloveHandProfile::Equals(const USGNovaGloveHandProfile* NovaGloveHandProfile) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGNovaGloveHandProfileImpl InstanceContainer{ToNovaGloveHandProfileImpl()};
     FSGIC_FSGNovaGloveHandProfileImpl NovaGloveHandProfileContainer{NovaGloveHandProfile->ToNovaGloveHandProfileImpl()};
     return SGCoreImpl_FSGNovaGloveHandProfileImpl_Equals(&InstanceContainer, &NovaGloveHandProfileContainer);
@@ -212,18 +183,12 @@ bool USGNovaGloveHandProfile::Equals(const USGNovaGloveHandProfile* NovaGloveHan
 
 void USGNovaGloveHandProfile::Reset()
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGNovaGloveHandProfileImpl InstanceContainer{ToNovaGloveHandProfileImpl()};
     SGCoreImpl_FSGNovaGloveHandProfileImpl_Reset(&InstanceContainer);
-
-    Pimpl->SyncUProperties();
 }
 
 FString USGNovaGloveHandProfile::SGSerialize() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGNovaGloveHandProfileImpl InstanceContainer{ToNovaGloveHandProfileImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGNovaGloveHandProfileImpl_Serialize(&InstanceContainer, &OutStringContainer);
@@ -241,11 +206,3 @@ void USGNovaGloveHandProfile::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
 }
-
-void USGNovaGloveHandProfile::FImpl::SyncUProperties()
-{
-}
-
-void USGNovaGloveHandProfile::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGNovaGloveInfo.cpp

@@ -69,13 +69,6 @@ struct USGNovaGloveInfo::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-    void SyncImplObject();
 };
 
 USGNovaGloveInfo* USGNovaGloveInfo::NewNovaGloveInfo(UObject* Outer, const FSGNovaGloveInfoImpl& NovaGloveInfoImpl)
@@ -134,30 +127,19 @@ USGNovaGloveInfo* USGNovaGloveInfo::Deserialize(UObject* Outer, const FString& S
 }
 
 USGNovaGloveInfo::USGNovaGloveInfo()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGNovaGloveInfoImpl OutNovaGloveInfoImplContainer;
     SGCoreImpl_FSGNovaGloveInfoImpl_ctor(&OutNovaGloveInfoImplContainer);
 
     Pimpl->NovaGloveInfoImpl = MoveTemp(OutNovaGloveInfoImplContainer.NovaGloveInfoImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGNovaGloveInfo::USGNovaGloveInfo(
     const FString& DeviceId,
     const FString& HardwareVersion, const int32 FirmwareVersion, const int32 SubFirmwareVersion,
     const bool bRightHanded, const FQuat& ImuCorrection, const int32 NumberOfSensors)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGNovaGloveInfoImpl OutNovaGloveInfoImplContainer;
     FSGIC_FString DeviceIdContainer{DeviceId};
@@ -169,19 +151,12 @@ USGNovaGloveInfo::USGNovaGloveInfo(
         bRightHanded, &ImuCorrectionContainer, NumberOfSensors);
 
     Pimpl->NovaGloveInfoImpl = MoveTemp(OutNovaGloveInfoImplContainer.NovaGloveInfoImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGNovaGloveInfo::USGNovaGloveInfo(const FSGNovaGloveInfoImpl& NovaGloveInfoImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     SetNovaGloveInfoImpl(NovaGloveInfoImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGNovaGloveInfo::~USGNovaGloveInfo() = default;
@@ -196,13 +171,11 @@ void USGNovaGloveInfo::SetNovaGloveInfoImpl(const FSGNovaGloveInfoImpl& NovaGlov
 
 const FSGNovaGloveInfoImpl& USGNovaGloveInfo::ToNovaGloveInfoImpl() const
 {
-    Pimpl->SyncImplObject();
     return Pimpl->NovaGloveInfoImpl;
 }
 
 FSGNovaGloveInfoImpl& USGNovaGloveInfo::ToNovaGloveInfoImpl()
 {
-    Pimpl->SyncImplObject();
     return Pimpl->NovaGloveInfoImpl;
 }
 
@@ -264,8 +237,6 @@ int32 USGNovaGloveInfo::GetNumberOfSensors() const
 
 bool USGNovaGloveInfo::Equals(const USGNovaGloveInfo* NovaGloveInfo) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGNovaGloveInfoImpl InstanceContainer{ToNovaGloveInfoImpl()};
     FSGIC_FSGNovaGloveInfoImpl NovaGloveInfoImplContainer{NovaGloveInfo->ToNovaGloveInfoImpl()};
     return SGCoreImpl_FSGNovaGloveInfoImpl_Equals(&InstanceContainer, &NovaGloveInfoImplContainer);
@@ -273,8 +244,6 @@ bool USGNovaGloveInfo::Equals(const USGNovaGloveInfo* NovaGloveInfo) const
 
 FString USGNovaGloveInfo::ToString() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGNovaGloveInfoImpl InstanceContainer{ToNovaGloveInfoImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGNovaGloveInfoImpl_ToString(&InstanceContainer, &OutStringContainer);
@@ -283,8 +252,6 @@ FString USGNovaGloveInfo::ToString() const
 
 FString USGNovaGloveInfo::SGSerialize() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGNovaGloveInfoImpl InstanceContainer{ToNovaGloveInfoImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGNovaGloveInfoImpl_Serialize(&InstanceContainer, &OutStringContainer);
@@ -302,11 +269,3 @@ void USGNovaGloveInfo::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
 }
-
-void USGNovaGloveInfo::FImpl::SyncUProperties()
-{
-}
-
-void USGNovaGloveInfo::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGNovaGloveSensorData.cpp

@@ -73,13 +73,6 @@ struct USGNovaGloveSensorData::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-    void SyncImplObject();
 };
 
 USGNovaGloveSensorData* USGNovaGloveSensorData::NewNovaGloveSensorData(
@@ -156,29 +149,18 @@ USGNovaGloveSensorData* USGNovaGloveSensorData::Deserialize(UObject* Outer, cons
 }
 
 USGNovaGloveSensorData::USGNovaGloveSensorData()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGNovaGloveSensorDataImpl OutNovaGloveSensorDataImplContainer;
     SGCoreImpl_FSGNovaGloveSensorDataImpl_ctor(&OutNovaGloveSensorDataImplContainer);
 
     Pimpl->NovaGloveSensorDataImpl = MoveTemp(OutNovaGloveSensorDataImplContainer.NovaGloveSensorDataImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGNovaGloveSensorData::USGNovaGloveSensorData(const TArray<FVector>& Values, const int32 ParsedValues,
                                                const FQuat& ImuRotation, const bool bImuParsed,
                                                const float BatteryLevel, const bool bCharging)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGNovaGloveSensorDataImpl OutNovaGloveSensorDataImplContainer;
     FSGIC_TArray_FVector ValuesContainer{Values};
@@ -188,18 +170,12 @@ USGNovaGloveSensorData::USGNovaGloveSensorData(const TArray<FVector>& Values, co
         &ImuRotationContainer, bImuParsed, BatteryLevel, bCharging);
 
     Pimpl->NovaGloveSensorDataImpl = MoveTemp(OutNovaGloveSensorDataImplContainer.NovaGloveSensorDataImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGNovaGloveSensorData::USGNovaGloveSensorData(const TArray<FVector>& Values, const int32 ParsedValues,
                                                const FRotator& ImuRotation, const bool bImuParsed,
                                                const float BatteryLevel, const bool bCharging)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGNovaGloveSensorDataImpl OutNovaGloveSensorDataImplContainer;
     FSGIC_TArray_FVector ValuesContainer{Values};
@@ -209,19 +185,12 @@ USGNovaGloveSensorData::USGNovaGloveSensorData(const TArray<FVector>& Values, co
         &ImuRotationContainer, bImuParsed, BatteryLevel, bCharging);
 
     Pimpl->NovaGloveSensorDataImpl = MoveTemp(OutNovaGloveSensorDataImplContainer.NovaGloveSensorDataImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGNovaGloveSensorData::USGNovaGloveSensorData(const FSGNovaGloveSensorDataImpl& NovaGloveSensorDataImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     SetNovaGloveSensorDataImpl(NovaGloveSensorDataImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGNovaGloveSensorData::~USGNovaGloveSensorData() = default;
@@ -236,7 +205,6 @@ void USGNovaGloveSensorData::SetNovaGloveSensorDataImpl(const FSGNovaGloveSensor
 
 const FSGNovaGloveSensorDataImpl& USGNovaGloveSensorData::ToNovaGloveSensorDataImpl() const
 {
-    Pimpl->SyncImplObject();
     return Pimpl->NovaGloveSensorDataImpl;
 }
 
@@ -290,8 +258,6 @@ bool USGNovaGloveSensorData::IsCharging() const
 
 bool USGNovaGloveSensorData::Equals(const USGNovaGloveSensorData* NovaGloveSensorData) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGNovaGloveSensorDataImpl InstanceContainer{ToNovaGloveSensorDataImpl()};
     FSGIC_FSGNovaGloveSensorDataImpl NovaGloveSensorDataContainer{NovaGloveSensorData->ToNovaGloveSensorDataImpl()};
     return SGCoreImpl_FSGNovaGloveSensorDataImpl_Equals(&InstanceContainer, &NovaGloveSensorDataContainer);
@@ -299,8 +265,6 @@ bool USGNovaGloveSensorData::Equals(const USGNovaGloveSensorData* NovaGloveSenso
 
 FString USGNovaGloveSensorData::ToString() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGNovaGloveSensorDataImpl InstanceContainer{ToNovaGloveSensorDataImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGNovaGloveSensorDataImpl_ToString(&InstanceContainer, &OutStringContainer);
@@ -309,8 +273,6 @@ FString USGNovaGloveSensorData::ToString() const
 
 FString USGNovaGloveSensorData::SGSerialize() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGNovaGloveSensorDataImpl InstanceContainer{ToNovaGloveSensorDataImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGNovaGloveSensorDataImpl_Serialize(&InstanceContainer, &OutStringContainer);
@@ -328,11 +290,3 @@ void USGNovaGloveSensorData::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
 }
-
-void USGNovaGloveSensorData::FImpl::SyncUProperties()
-{
-}
-
-void USGNovaGloveSensorData::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGSenseGlove.cpp

@@ -67,42 +67,6 @@
 #include "SGInterop/SGIC_TArray_TArray_FVector.h"
 #include "SGInterop/SGIC_TSharedPtr_FSGSenseGloveImpl.h"
 
-struct USGSenseGlove::FImpl
-{
-    /************************
-     * Member variables
-     ************************/
-
-
-    /************************
-     * Owner object
-     ************************/
-
-    USGDevice* Owner;
-
-    /************************
-     * Constructor / Destructor
-     ************************/
-
-    explicit FImpl(USGSenseGlove* InOwner);
-    ~FImpl();
-
-    /************************
-     * Default copy constructor & copy assignment operator
-     ************************/
-
-    FImpl(const FImpl& Rhs) = default;
-    FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-
-    void SyncImplObject();
-};
-
 USGSenseGlove* USGSenseGlove::NewSenseGlove(UObject* Outer, const FSGSenseGloveImpl& SenseGloveImpl)
 {
     USGSenseGlove* Instance = NewObject<USGSenseGlove>(Outer);
@@ -354,126 +318,58 @@ void USGSenseGlove::CalculateWristLocation(const FVector& ReferencePosition, con
 }
 
 USGSenseGlove::USGSenseGlove()
-    : USGHapticGlove(),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGHapticGlove()
 {
     FSGIC_TSharedPtr_FSGSenseGloveImpl OutSharedPtrContainer;
     SGCoreImpl_FSGSenseGloveImpl_ctor_MakeShared(&OutSharedPtrContainer);
 
     SetSGDeviceImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGlove::USGSenseGlove(const USGSenseGloveInfo& Model)
-    : USGHapticGlove(),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGHapticGlove()
 {
-    FSGIC_TSharedPtr_FSGSenseGloveImpl OutSharedPtrContainer;
-    FSGIC_FSGSenseGloveInfoImpl ModelContainer{Model.ToSenseGloveInfoImpl()};
-    SGCoreImpl_FSGSenseGloveImpl_ctor_Model_MakeShared(&OutSharedPtrContainer, &ModelContainer);
-
-    SetSGDeviceImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGlove::USGSenseGlove(const FSGDeviceImpl& SGDeviceImpl)
-    : USGHapticGlove(SGDeviceImpl),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGHapticGlove(SGDeviceImpl)
 {
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGlove::USGSenseGlove(const FSGHapticGloveImpl& HapticGloveImpl)
-    : USGHapticGlove(HapticGloveImpl),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGHapticGlove(HapticGloveImpl)
 {
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGlove::USGSenseGlove(const FSGSenseGloveImpl& SenseGloveImpl)
-    : USGHapticGlove(SenseGloveImpl),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGHapticGlove(SenseGloveImpl)
 {
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGlove::USGSenseGlove(TSharedRef<FSGDeviceImpl> SGDeviceImpl)
-    : USGHapticGlove(MoveTemp(SGDeviceImpl)),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGHapticGlove(MoveTemp(SGDeviceImpl))
 {
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGlove::USGSenseGlove(TSharedRef<FSGHapticGloveImpl> HapticGloveImpl)
-    : USGHapticGlove(MoveTemp(HapticGloveImpl)),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGHapticGlove(MoveTemp(HapticGloveImpl))
 {
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGlove::USGSenseGlove(TSharedRef<FSGSenseGloveImpl> SenseGloveImpl)
-    : USGHapticGlove(MoveTemp(SenseGloveImpl)),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGHapticGlove(MoveTemp(SenseGloveImpl))
 {
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGlove::~USGSenseGlove() = default;
 
 TSharedRef<FSGSenseGloveImpl> USGSenseGlove::ToSenseGloveImpl() const
 {
-    SyncImplObject();
     return FSGDeviceImplCast::ToSenseGloveImpl(ToSGDeviceImpl());
 }
 
-void USGSenseGlove::SyncImplObject() const
-{
-    Super::SyncImplObject();
-    Pimpl->SyncImplObject();
-}
-
-void USGSenseGlove::SyncUProperties()
-{
-    Super::SyncUProperties();
-    Pimpl->SyncUProperties();
-}
-
 USGSenseGloveInfo* USGSenseGlove::GetGloveModel(UObject* Outer) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FSGSenseGloveInfoImpl OutModelContainer;
     SGCoreImpl_FSGSenseGloveImpl_GetGloveModel(&InstanceContainer, &OutModelContainer);
@@ -483,16 +379,12 @@ USGSenseGloveInfo* USGSenseGlove::GetGloveModel(UObject* Outer) const
 
 bool USGSenseGlove::IsRight() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     return SGCoreImpl_FSGSenseGloveImpl_IsRight(&InstanceContainer);
 }
 
 ESGDeviceType USGSenseGlove::GetDeviceType() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_ESGDeviceType OutTypeContainer;
     SGCoreImpl_FSGSenseGloveImpl_GetDeviceType(&InstanceContainer, &OutTypeContainer);
@@ -501,8 +393,6 @@ ESGDeviceType USGSenseGlove::GetDeviceType() const
 
 FString USGSenseGlove::GetDeviceId() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FString OutIdContainer;
     SGCoreImpl_FSGSenseGloveImpl_GetDeviceId(&InstanceContainer, &OutIdContainer);
@@ -511,8 +401,6 @@ FString USGSenseGlove::GetDeviceId() const
 
 FString USGSenseGlove::GetHardwareVersion() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FString OutVersionContainer;
     SGCoreImpl_FSGSenseGloveImpl_GetHardwareVersion(&InstanceContainer, &OutVersionContainer);
@@ -521,24 +409,18 @@ FString USGSenseGlove::GetHardwareVersion() const
 
 int32 USGSenseGlove::GetFirmwareVersion() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     return SGCoreImpl_FSGSenseGloveImpl_GetFirmwareVersion(&InstanceContainer);
 }
 
 int32 USGSenseGlove::GetSubFirmwareVersion() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     return SGCoreImpl_FSGSenseGloveImpl_GetSubFirmwareVersion(&InstanceContainer);
 }
 
 bool USGSenseGlove::GetSensorData(UObject* Outer, USGSenseGloveSensorData*& OutSensorData) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FSGSenseGloveSensorDataImpl OutSensorDataContainer;
     const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetSensorData(&InstanceContainer, &OutSensorDataContainer);
@@ -554,14 +436,10 @@ bool USGSenseGlove::GetSensorData(UObject* Outer, USGSenseGloveSensorData*& OutS
 
 bool USGSenseGlove::GetImuRotation(FQuat& OutImu)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FQuat OutImuContainer;
     const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetImuRotation(&InstanceContainer, &OutImuContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutImu = MoveTemp(OutImuContainer.Quat);
@@ -572,14 +450,10 @@ bool USGSenseGlove::GetImuRotation(FQuat& OutImu)
 
 bool USGSenseGlove::GetImuRotation(FRotator& OutImu)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FQuat OutImuContainer;
     const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetImuRotation(&InstanceContainer, &OutImuContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutImu = OutImuContainer.Quat.Rotator();
@@ -590,15 +464,11 @@ bool USGSenseGlove::GetImuRotation(FRotator& OutImu)
 
 bool USGSenseGlove::GetGlovePose(UObject* Outer, USGSenseGlovePose*& OutGlovePose)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FSGSenseGlovePoseImpl OutGlovePoseContainer;
     const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetGlovePose_OutGlovePose(
         &InstanceContainer, &OutGlovePoseContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutGlovePose = USGSenseGlovePose::NewSenseGlovePose(Outer, MoveTemp(OutGlovePoseContainer.SenseGlovePoseImpl));
@@ -610,16 +480,12 @@ bool USGSenseGlove::GetGlovePose(UObject* Outer, USGSenseGlovePose*& OutGlovePos
 bool USGSenseGlove::GetGlovePose(
     UObject* Outer, const USGSenseGloveSensorData* SensorData, USGSenseGlovePose*& OutGlovePose)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FSGSenseGloveSensorDataImpl SensorDataContainer{SensorData->ToSenseGloveSensorDataImpl()};
     FSGIC_FSGSenseGlovePoseImpl OutGlovePoseContainer;
     const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetGlovePose_SensorData_OutGlovePose(
         &InstanceContainer, &SensorDataContainer, &OutGlovePoseContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutGlovePose = USGSenseGlovePose::NewSenseGlovePose(Outer, MoveTemp(OutGlovePoseContainer.SenseGlovePoseImpl));
@@ -632,8 +498,6 @@ bool USGSenseGlove::GetHandPose(
     UObject* Outer, const USGBasicHandModel* HandModel, const USGSenseGloveHandProfile* Profile,
     USGHandPose*& OutHandPose)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FSGBasicHandModelImpl HandModelContainer{HandModel->ToBasicHandModelImpl()};
     FSGIC_FSGSenseGloveHandProfileImpl ProfileContainer{Profile->ToSenseGloveHandProfileImpl()};
@@ -641,8 +505,6 @@ bool USGSenseGlove::GetHandPose(
     const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetHandPose_HandModel_Profile_OutHandPose(
         &InstanceContainer, &HandModelContainer, &ProfileContainer, &OutHandPoseContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutHandPose = USGHandPose::NewHandPose(Outer, MoveTemp(OutHandPoseContainer.HandPoseImpl));
@@ -654,8 +516,6 @@ bool USGSenseGlove::GetHandPose(
 bool USGSenseGlove::GetHandPose(
     UObject* Outer, const USGBasicHandModel* HandGeometry, const USGHandProfile* HandProfile, USGHandPose*& OutHandPose)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FSGBasicHandModelImpl HandGeometryContainer{HandGeometry->ToBasicHandModelImpl()};
     FSGIC_FSGHandProfileImpl ProfileContainer{HandProfile->ToHandProfileImpl()};
@@ -663,8 +523,6 @@ bool USGSenseGlove::GetHandPose(
     const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetHandPose_HandGeometry_HandProfile_OutHandPose(
         &InstanceContainer, &HandGeometryContainer, &ProfileContainer, &OutHandPoseContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutHandPose = USGHandPose::NewHandPose(Outer, MoveTemp(OutHandPoseContainer.HandPoseImpl));
@@ -675,16 +533,12 @@ bool USGSenseGlove::GetHandPose(
 
 bool USGSenseGlove::GetHandPose(UObject* Outer, const USGHandProfile* HandProfile, USGHandPose*& OutHandPose)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FSGHandProfileImpl ProfileContainer{HandProfile->ToHandProfileImpl()};
     FSGIC_FSGHandPoseImpl OutHandPoseContainer;
     const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetHandPose_HandProfile_OutHandPose(
         &InstanceContainer, &ProfileContainer, &OutHandPoseContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutHandPose = USGHandPose::NewHandPose(Outer, MoveTemp(OutHandPoseContainer.HandPoseImpl));
@@ -696,8 +550,6 @@ bool USGSenseGlove::GetHandPose(UObject* Outer, const USGHandProfile* HandProfil
 bool USGSenseGlove::SendHaptics(const USGForceFeedbackCommand* ForceFeedbackCommand, const USGBuzzCommand* BuzzCommand,
                                 ESGSenseGloveThumperCommand ThumperCommand)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FSGForceFeedbackCommandImpl ForceFeedbackCommandContainer{
         ForceFeedbackCommand->ToForceFeedbackCommandImpl().Get()
@@ -710,55 +562,39 @@ bool USGSenseGlove::SendHaptics(const USGForceFeedbackCommand* ForceFeedbackComm
         SGCoreImpl_FSGSenseGloveImpl_SendHaptics_ForceFeedbackCommand_BuzzCommand_ESenseGloveThumperCommand(
             &InstanceContainer, &ForceFeedbackCommandContainer, &BuzzCommandContainer, &ThumperCommandContainer);
 
-    SyncUProperties();
-
     return bResult;
 }
 
 bool USGSenseGlove::SendHaptics(ESGSenseGloveThumperCommand ThumperCommand)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_ESGSenseGloveThumperCommand ThumperCommandContainer{ThumperCommand};
     const bool bResult = SGCoreImpl_FSGSenseGloveImpl_SendHaptics_ThumperCommand(
         &InstanceContainer, &ThumperCommandContainer);
 
-    SyncUProperties();
-
     return bResult;
 }
 
 void USGSenseGlove::SendHaptics(const USGForceFeedbackCommand* ForceFeedbackCommand)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FSGForceFeedbackCommandImpl ForceFeedbackCommandContainer{
         ForceFeedbackCommand->ToForceFeedbackCommandImpl().Get()
     };
     SGCoreImpl_FSGSenseGloveImpl_SendHaptics_ForceFeedbackCommand(&InstanceContainer, &ForceFeedbackCommandContainer);
-
-    SyncUProperties();
 }
 
 void USGSenseGlove::SendHaptics(const USGBuzzCommand* BuzzCommand)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FSGBuzzCommandImpl BuzzCommandContainer{BuzzCommand->ToBuzzCommandImpl().Get()};
     SGCoreImpl_FSGSenseGloveImpl_SendHaptics_ForceFeedbackCommand(&InstanceContainer, &BuzzCommandContainer);
-
-    SyncUProperties();
 }
 
 void USGSenseGlove::SendHaptics(const USGForceFeedbackCommand* ForceFeedbackCommand,
                                 const USGBuzzCommand* BuzzCommand,
                                 const USGThumperCommand* ThumperCommand)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FSGForceFeedbackCommandImpl ForceFeedbackCommandContainer{
         ForceFeedbackCommand->ToForceFeedbackCommandImpl().Get()
@@ -767,21 +603,15 @@ void USGSenseGlove::SendHaptics(const USGForceFeedbackCommand* ForceFeedbackComm
     FSGIC_FSGThumperCommandImpl ThumperCommandContainer{ThumperCommand->ToThumperCommandImpl()};
     SGCoreImpl_FSGSenseGloveImpl_SendHaptics_ForceFeedbackCommand_BuzzCommand_ThumperCommand(
         &InstanceContainer, &ForceFeedbackCommandContainer, &BuzzCommandContainer, &ThumperCommandContainer);
-
-    SyncUProperties();
 }
 
 bool USGSenseGlove::GetCalibrationValues(TArray<FVector>& OutValues)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_TArray_FVector OutValuesContainer;
     const bool bResult = SGCoreImpl_FSGSenseGloveImpl_GetCalibrationValues_OutValues(
         &InstanceContainer, &OutValuesContainer);
 
-    SyncUProperties();
-
     if (bResult)
     {
         OutValues = MoveTemp(OutValuesContainer.Array);
@@ -792,18 +622,12 @@ bool USGSenseGlove::GetCalibrationValues(TArray<FVector>& OutValues)
 
 void USGSenseGlove::ResetCalibrationRange()
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     SGCoreImpl_FSGSenseGloveImpl_ResetCalibrationRange(&InstanceContainer);
-
-    SyncUProperties();
 }
 
 void USGSenseGlove::ApplyCalibration(UObject* Outer, USGHandProfile*& OutProfile) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FSGHandProfileImpl OutProfileContainer;
     SGCoreImpl_FSGSenseGloveImpl_ApplyCalibration_HandProfile(&InstanceContainer, &OutProfileContainer);
@@ -812,8 +636,6 @@ void USGSenseGlove::ApplyCalibration(UObject* Outer, USGHandProfile*& OutProfile
 
 void USGSenseGlove::ApplyCalibration(UObject* Outer, USGSenseGloveHandProfile*& OutProfile) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FSGSenseGloveHandProfileImpl OutProfileContainer;
     SGCoreImpl_FSGSenseGloveImpl_ApplyCalibration_SenseGloveHandProfile(&InstanceContainer, &OutProfileContainer);
@@ -825,8 +647,6 @@ void USGSenseGlove::GetGloveLocation(const FVector& ReferencePosition, const FQu
                                      const ESGPositionalTrackingHardware TrackingHardware,
                                      FVector& OutGlovePosition, FQuat& OutGloveRotation) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FVector ReferencePositionContainer{ReferencePosition};
     FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation};
@@ -848,8 +668,6 @@ void USGSenseGlove::GetGloveLocation(const FVector& ReferencePosition, const FRo
                                      const ESGPositionalTrackingHardware TrackingHardware,
                                      FVector& OutGlovePosition, FRotator& OutGloveRotation) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FVector ReferencePositionContainer{ReferencePosition};
     FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
@@ -871,8 +689,6 @@ void USGSenseGlove::GetGloveLocation(const FVector& ReferencePosition, const FQu
                                      const ESGPositionalTrackingHardware TrackingHardware, const ESGFinger MountedOn,
                                      FVector& OutGlovePosition, FQuat& OutGloveRotation) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FVector ReferencePositionContainer{ReferencePosition};
     FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation};
@@ -895,8 +711,6 @@ void USGSenseGlove::GetGloveLocation(const FVector& ReferencePosition, const FRo
                                      const ESGPositionalTrackingHardware TrackingHardware, const ESGFinger MountedOn,
                                      FVector& OutGlovePosition, FRotator& OutGloveRotation) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FVector ReferencePositionContainer{ReferencePosition};
     FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
@@ -919,8 +733,6 @@ void USGSenseGlove::GetWristLocation(const FVector& ReferencePosition, const FQu
                                      const ESGPositionalTrackingHardware TrackingHardware,
                                      FVector& OutWristPosition, FQuat& OutWristRotation) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FVector ReferencePositionContainer{ReferencePosition};
     FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation};
@@ -941,8 +753,6 @@ void USGSenseGlove::GetWristLocation(const FVector& ReferencePosition, const FRo
                                      const ESGPositionalTrackingHardware TrackingHardware,
                                      FVector& OutWristPosition, FRotator& OutWristRotation) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FVector ReferencePositionContainer{ReferencePosition};
     FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
@@ -965,8 +775,6 @@ void USGSenseGlove::GetWristLocation(const FVector& ReferencePosition, const FQu
                                      const FQuat& GloveWristRotationOffset,
                                      FVector& OutWristPosition, FQuat& OutWristRotation) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FVector ReferencePositionContainer{ReferencePosition};
     FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation};
@@ -992,8 +800,6 @@ void USGSenseGlove::GetWristLocation(const FVector& ReferencePosition, const FRo
                                      const FRotator& GloveWristRotationOffset,
                                      FVector& OutWristPosition, FRotator& OutWristRotation) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FVector ReferencePositionContainer{ReferencePosition};
     FSGIC_FQuat ReferenceRotationContainer{ReferenceRotation.Quaternion()};
@@ -1015,30 +821,8 @@ void USGSenseGlove::GetWristLocation(const FVector& ReferencePosition, const FRo
 
 FString USGSenseGlove::ToString() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGSenseGloveImpl InstanceContainer{ToSenseGloveImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGSenseGloveImpl_ToString(&InstanceContainer, &OutStringContainer);
     return MoveTemp(OutStringContainer.String);;
 }
-
-USGSenseGlove::FImpl::FImpl(USGSenseGlove* InOwner)
-    : Owner(InOwner)
-{
-}
-
-USGSenseGlove::FImpl::~FImpl() = default;
-
-void USGSenseGlove::FImplDeleter::operator()(const FImpl* P) const
-{
-    delete P;
-}
-
-void USGSenseGlove::FImpl::SyncUProperties()
-{
-}
-
-void USGSenseGlove::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGSenseGloveHandProfile.cpp

@@ -75,13 +75,6 @@ struct USGSenseGloveHandProfile::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-    void SyncImplObject();
 };
 
 USGSenseGloveHandProfile* USGSenseGloveHandProfile::NewSenseGloveHandProfile(
@@ -142,29 +135,18 @@ FVector USGSenseGloveHandProfile::GetDefaultThimbleOffset()
 }
 
 USGSenseGloveHandProfile::USGSenseGloveHandProfile()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGSenseGloveHandProfileImpl OutSenseGloveHandProfileImplContainer;
     SGCoreImpl_FSGSenseGloveHandProfileImpl_ctor(&OutSenseGloveHandProfileImplContainer);
 
     Pimpl->SenseGloveHandProfileImpl = MoveTemp(OutSenseGloveHandProfileImplContainer.SenseGloveHandProfileImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGloveHandProfile::USGSenseGloveHandProfile(const bool bRightHanded, const USGHandInterpolator* Interpolator,
                                                    const ESGThumbSolver ThumbSolver, const ESGFingerSolver FingerSolver,
                                                    const TArray<FVector>& FingerThimbleOffset)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGSenseGloveHandProfileImpl OutSenseGloveHandProfileImplContainer;
     FSGIC_FSGHandInterpolatorImpl InterpolatorContainer{Interpolator->ToHandInterpolatorImpl()};
@@ -176,19 +158,12 @@ USGSenseGloveHandProfile::USGSenseGloveHandProfile(const bool bRightHanded, cons
         &ThumbSolverContainer, &FingerSolverContainer, &FingerThimbleOffsetContainer);
 
     Pimpl->SenseGloveHandProfileImpl = MoveTemp(OutSenseGloveHandProfileImplContainer.SenseGloveHandProfileImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGloveHandProfile::USGSenseGloveHandProfile(const FSGSenseGloveHandProfileImpl& SenseGloveHandProfileImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     SetSenseGloveHandProfileImpl(SenseGloveHandProfileImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGloveHandProfile::~USGSenseGloveHandProfile() = default;
@@ -204,7 +179,6 @@ void USGSenseGloveHandProfile::SetSenseGloveHandProfileImpl(
 
 const FSGSenseGloveHandProfileImpl& USGSenseGloveHandProfile::ToSenseGloveHandProfileImpl() const
 {
-    Pimpl->SyncImplObject();
     return Pimpl->SenseGloveHandProfileImpl;
 }
 
@@ -249,8 +223,6 @@ TArray<FVector> USGSenseGloveHandProfile::GetFingerThimbleOffset() const
 
 bool USGSenseGloveHandProfile::Equals(const USGSenseGloveHandProfile* SenseGloveHandProfile) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGloveHandProfileImpl InstanceContainer{ToSenseGloveHandProfileImpl()};
     FSGIC_FSGSenseGloveHandProfileImpl SenseGloveHandProfileContainer{
         SenseGloveHandProfile->ToSenseGloveHandProfileImpl()};
@@ -259,18 +231,12 @@ bool USGSenseGloveHandProfile::Equals(const USGSenseGloveHandProfile* SenseGlove
 
 void USGSenseGloveHandProfile::Reset()
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGloveHandProfileImpl InstanceContainer{ToSenseGloveHandProfileImpl()};
     SGCoreImpl_FSGSenseGloveHandProfileImpl_Reset(&InstanceContainer);
-
-    Pimpl->SyncUProperties();
 }
 
 FString USGSenseGloveHandProfile::SGSerialize() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGloveHandProfileImpl InstanceContainer{ToSenseGloveHandProfileImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGSenseGloveHandProfileImpl_Serialize(&InstanceContainer, &OutStringContainer);
@@ -288,11 +254,3 @@ void USGSenseGloveHandProfile::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
 }
-
-void USGSenseGloveHandProfile::FImpl::SyncUProperties()
-{
-}
-
-void USGSenseGloveHandProfile::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGSenseGloveInfo.cpp

@@ -48,6 +48,7 @@
 #include "SGInterop/SGIC_TArray_FVector.h"
 #include "SGInterop/SGIC_TArray_TArray_float.h"
 #include "SGInterop/SGIC_TArray_TArray_FVector.h"
+#include "SGUtils/SGArrayUtils.h"
 
 struct USGSenseGloveInfo::FImpl
 {
@@ -76,13 +77,6 @@ struct USGSenseGloveInfo::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-    void SyncImplObject();
 };
 
 USGSenseGloveInfo* USGSenseGloveInfo::NewSenseGloveInfo(UObject* Outer, const FSGSenseGloveInfoImpl& SenseGloveInfoImpl)
@@ -238,18 +232,12 @@ USGSenseGloveInfo* USGSenseGloveInfo::Deserialize(UObject* Outer, const FString&
 }
 
 USGSenseGloveInfo::USGSenseGloveInfo()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGSenseGloveInfoImpl OutSenseGloveInfoImplContainer;
     SGCoreImpl_FSGSenseGloveInfoImpl_ctor(&OutSenseGloveInfoImplContainer);
 
     Pimpl->SenseGloveInfoImpl = MoveTemp(OutSenseGloveInfoImplContainer.SenseGloveInfoImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGloveInfo::USGSenseGloveInfo(
@@ -258,12 +246,7 @@ USGSenseGloveInfo::USGSenseGloveInfo(
     const bool bRightHanded, const int32 NumberOfSensors, const FQuat& ImuCorrection,
     const TArray<FVector>& StartPositions, const TArray<FQuat>& StartRotations,
     const TArray<TArray<FVector>>& GloveLengths, const TArray<bool>& Functions)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGSenseGloveInfoImpl OutSenseGloveInfoImplContainer;
     FSGIC_FString DeviceIdContainer{DeviceId};
@@ -281,7 +264,6 @@ USGSenseGloveInfo::USGSenseGloveInfo(
         &GloveLengthsContainer, &FunctionsContainer);
 
     Pimpl->SenseGloveInfoImpl = MoveTemp(OutSenseGloveInfoImplContainer.SenseGloveInfoImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGloveInfo::USGSenseGloveInfo(
@@ -290,12 +272,7 @@ USGSenseGloveInfo::USGSenseGloveInfo(
     const bool bRightHanded, const int32 NumberOfSensors, const FRotator& ImuCorrection,
     const TArray<FVector>& StartPositions, const TArray<FRotator>& StartRotations,
     const TArray<TArray<FVector>>& GloveLengths, const TArray<bool>& Functions)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGSenseGloveInfoImpl OutSenseGloveInfoImplContainer;
     FSGIC_FString DeviceIdContainer{DeviceId};
@@ -313,7 +290,6 @@ USGSenseGloveInfo::USGSenseGloveInfo(
         &GloveLengthsContainer, &FunctionsContainer);
 
     Pimpl->SenseGloveInfoImpl = MoveTemp(OutSenseGloveInfoImplContainer.SenseGloveInfoImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGloveInfo::USGSenseGloveInfo(
@@ -341,7 +317,6 @@ USGSenseGloveInfo::USGSenseGloveInfo(
         &GloveLengthsContainer, &FunctionsContainer);
 
     Pimpl->SenseGloveInfoImpl = MoveTemp(OutSenseGloveInfoImplContainer.SenseGloveInfoImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGloveInfo::USGSenseGloveInfo(
@@ -369,19 +344,12 @@ USGSenseGloveInfo::USGSenseGloveInfo(
         &GloveLengthsContainer, &FunctionsContainer);
 
     Pimpl->SenseGloveInfoImpl = MoveTemp(OutSenseGloveInfoImplContainer.SenseGloveInfoImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGloveInfo::USGSenseGloveInfo(const FSGSenseGloveInfoImpl& SenseGloveInfoImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     SetSenseGloveInfoImpl(SenseGloveInfoImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGloveInfo::~USGSenseGloveInfo() = default;
@@ -396,13 +364,11 @@ void USGSenseGloveInfo::SetSenseGloveInfoImpl(const FSGSenseGloveInfoImpl& Sense
 
 const FSGSenseGloveInfoImpl& USGSenseGloveInfo::ToSenseGloveInfoImpl() const
 {
-    Pimpl->SyncImplObject();
     return Pimpl->SenseGloveInfoImpl;
 }
 
 FSGSenseGloveInfoImpl& USGSenseGloveInfo::ToSenseGloveInfoImpl()
 {
-    Pimpl->SyncImplObject();
     return Pimpl->SenseGloveInfoImpl;
 }
 
@@ -504,8 +470,6 @@ TArray<bool> USGSenseGloveInfo::GetFunctions() const
 
 FVector USGSenseGloveInfo::GetStartPosition(const ESGFinger Finger) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
     FSGIC_FVector OutPositionContainer;
     FSGIC_ESGFinger FingerContainer{Finger};
@@ -515,8 +479,6 @@ FVector USGSenseGloveInfo::GetStartPosition(const ESGFinger Finger) const
 
 FQuat USGSenseGloveInfo::GetStartRotationQ(const ESGFinger Finger) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
     FSGIC_FQuat OutRotationContainer;
     FSGIC_ESGFinger FingerContainer{Finger};
@@ -526,8 +488,6 @@ FQuat USGSenseGloveInfo::GetStartRotationQ(const ESGFinger Finger) const
 
 FRotator USGSenseGloveInfo::GetStartRotation(const ESGFinger Finger) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
     FSGIC_FQuat OutRotationContainer;
     FSGIC_ESGFinger FingerContainer{Finger};
@@ -537,8 +497,6 @@ FRotator USGSenseGloveInfo::GetStartRotation(const ESGFinger Finger) const
 
 TArray<FVector> USGSenseGloveInfo::GetGloveLengths(const ESGFinger Finger) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
     FSGIC_TArray_FVector OutLengths;
     FSGIC_ESGFinger FingerContainer{Finger};
@@ -548,8 +506,6 @@ TArray<FVector> USGSenseGloveInfo::GetGloveLengths(const ESGFinger Finger) const
 
 TArray<TArray<FVector>> USGSenseGloveInfo::ToGloveAngles(const TArray<TArray<float>>& SensorAngles) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
     FSGIC_TArray_TArray_FVector OutAnglesContainer;
     FSGIC_TArray_TArray_float SensorAnglesContainer{SensorAngles};
@@ -559,8 +515,6 @@ TArray<TArray<FVector>> USGSenseGloveInfo::ToGloveAngles(const TArray<TArray<flo
 
 bool USGSenseGloveInfo::Equals(const USGSenseGloveInfo* SenseGloveInfo) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
     FSGIC_FSGSenseGloveInfoImpl SenseGloveInfoImplContainer{SenseGloveInfo->ToSenseGloveInfoImpl()};
     return SGCoreImpl_FSGSenseGloveInfoImpl_Equals(&InstanceContainer, &SenseGloveInfoImplContainer);
@@ -568,8 +522,6 @@ bool USGSenseGloveInfo::Equals(const USGSenseGloveInfo* SenseGloveInfo) const
 
 FString USGSenseGloveInfo::ToString() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGSenseGloveInfoImpl_ToString(&InstanceContainer, &OutStringContainer);
@@ -578,8 +530,6 @@ FString USGSenseGloveInfo::ToString() const
 
 FString USGSenseGloveInfo::ToString(const bool bShortNotation) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGSenseGloveInfoImpl_ToString_bShortNotation(&InstanceContainer, &OutStringContainer, bShortNotation);
@@ -588,8 +538,6 @@ FString USGSenseGloveInfo::ToString(const bool bShortNotation) const
 
 FString USGSenseGloveInfo::SGSerialize() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGloveInfoImpl InstanceContainer{ToSenseGloveInfoImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGSenseGloveInfoImpl_Serialize(&InstanceContainer, &OutStringContainer);
@@ -607,11 +555,3 @@ void USGSenseGloveInfo::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
 }
-
-void USGSenseGloveInfo::FImpl::SyncUProperties()
-{
-}
-
-void USGSenseGloveInfo::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGSenseGlovePose.cpp

@@ -49,6 +49,7 @@
 #include "SGInterop/SGIC_TArray_FVector.h"
 #include "SGInterop/SGIC_TArray_TArray_FQuat.h"
 #include "SGInterop/SGIC_TArray_TArray_FVector.h"
+#include "SGUtils/SGArrayUtils.h"
 
 struct USGSenseGlovePose::FImpl
 {
@@ -77,13 +78,6 @@ struct USGSenseGlovePose::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-    void SyncImplObject();
 };
 
 USGSenseGlovePose* USGSenseGlovePose::NewSenseGlovePose(UObject* Outer, const FSGSenseGlovePoseImpl& SenseGlovePoseImpl)
@@ -196,30 +190,19 @@ USGSenseGlovePose* USGSenseGlovePose::Deserialize(UObject* Outer, const FString&
 }
 
 USGSenseGlovePose::USGSenseGlovePose()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGSenseGlovePoseImpl OutSenseGlovePoseImplContainer;
     SGCoreImpl_FSGSenseGlovePoseImpl_ctor(&OutSenseGlovePoseImplContainer);
 
     Pimpl->SenseGlovePoseImpl = MoveTemp(OutSenseGlovePoseImplContainer.SenseGlovePoseImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGlovePose::USGSenseGlovePose(const bool bRightHanded,
                                      const TArray<TArray<FVector>>& JointPositions,
                                      const TArray<TArray<FQuat>>& JointRotations,
                                      const TArray<TArray<FVector>>& GloveAngles)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGSenseGlovePoseImpl OutSenseGlovePoseImplContainer;
     FSGIC_TArray_TArray_FVector JointPositionsContainer{JointPositions};
@@ -230,19 +213,13 @@ USGSenseGlovePose::USGSenseGlovePose(const bool bRightHanded,
         &JointRotationsContainer, &GloveAnglesContainer);
 
     Pimpl->SenseGlovePoseImpl = MoveTemp(OutSenseGlovePoseImplContainer.SenseGlovePoseImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGlovePose::USGSenseGlovePose(const bool bRightHanded,
                                      const TArray<TArray<FVector>>& JointPositions,
                                      const TArray<TArray<FRotator>>& JointRotations,
                                      const TArray<TArray<FVector>>& GloveAngles)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGSenseGlovePoseImpl OutSenseGlovePoseImplContainer;
     FSGIC_TArray_TArray_FVector JointPositionsContainer{JointPositions};
@@ -253,7 +230,6 @@ USGSenseGlovePose::USGSenseGlovePose(const bool bRightHanded,
         &JointRotationsContainer, &GloveAnglesContainer);
 
     Pimpl->SenseGlovePoseImpl = MoveTemp(OutSenseGlovePoseImplContainer.SenseGlovePoseImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGlovePose::USGSenseGlovePose(const bool bRightHanded,
@@ -276,7 +252,6 @@ USGSenseGlovePose::USGSenseGlovePose(const bool bRightHanded,
         &JointRotationsContainer, &GloveAnglesContainer);
 
     Pimpl->SenseGlovePoseImpl = MoveTemp(OutSenseGlovePoseImplContainer.SenseGlovePoseImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGlovePose::USGSenseGlovePose(const bool bRightHanded,
@@ -299,19 +274,12 @@ USGSenseGlovePose::USGSenseGlovePose(const bool bRightHanded,
         &JointRotationsContainer, &GloveAnglesContainer);
 
     Pimpl->SenseGlovePoseImpl = MoveTemp(OutSenseGlovePoseImplContainer.SenseGlovePoseImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGlovePose::USGSenseGlovePose(const FSGSenseGlovePoseImpl& SenseGlovePoseImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     SetSenseGlovePoseImpl(SenseGlovePoseImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGlovePose::~USGSenseGlovePose() = default;
@@ -326,7 +294,6 @@ void USGSenseGlovePose::SetSenseGlovePoseImpl(const FSGSenseGlovePoseImpl& Sense
 
 const FSGSenseGlovePoseImpl& USGSenseGlovePose::ToSenseGlovePoseImpl() const
 {
-    Pimpl->SyncImplObject();
     return Pimpl->SenseGlovePoseImpl;
 }
 
@@ -370,8 +337,6 @@ TArray<TArray<FVector>> USGSenseGlovePose::GetGloveAngles() const
 
 TArray<FVector> USGSenseGlovePose::GetThimblePositions() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
     FSGIC_TArray_FVector OutPositionsContainer;
     SGCoreImpl_FSGSenseGlovePoseImpl_GetThimblePositions(&InstanceContainer, &OutPositionsContainer);
@@ -380,8 +345,6 @@ TArray<FVector> USGSenseGlovePose::GetThimblePositions() const
 
 TArray<FQuat> USGSenseGlovePose::GetThimbleRotationsQ() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
     FSGIC_TArray_FQuat OutRotationsContainer;
     SGCoreImpl_FSGSenseGlovePoseImpl_GetThimbleRotations(&InstanceContainer, &OutRotationsContainer);
@@ -390,8 +353,6 @@ TArray<FQuat> USGSenseGlovePose::GetThimbleRotationsQ() const
 
 TArray<FRotator> USGSenseGlovePose::GetThimbleRotations() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
     FSGIC_TArray_FQuat OutRotationsContainer;
     SGCoreImpl_FSGSenseGlovePoseImpl_GetThimbleRotations(&InstanceContainer, &OutRotationsContainer);
@@ -400,8 +361,6 @@ TArray<FRotator> USGSenseGlovePose::GetThimbleRotations() const
 
 TArray<FVector> USGSenseGlovePose::GetTotalGloveAngles() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
     FSGIC_TArray_FVector OutAnglesContainer;
     SGCoreImpl_FSGSenseGlovePoseImpl_GetTotalGloveAngles(&InstanceContainer, &OutAnglesContainer);
@@ -410,8 +369,6 @@ TArray<FVector> USGSenseGlovePose::GetTotalGloveAngles() const
 
 TArray<FVector> USGSenseGlovePose::CalculateFingerTips(const USGSenseGloveHandProfile* SenseGloveHandProfile) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
     FSGIC_TArray_FVector OutFingerTipsContainer;
     FSGIC_FSGSenseGloveHandProfileImpl SenseGloveHandProfileImplContainer{
@@ -423,8 +380,6 @@ TArray<FVector> USGSenseGlovePose::CalculateFingerTips(const USGSenseGloveHandPr
 
 TArray<FVector> USGSenseGlovePose::CalculateFingerTips(const TArray<FVector>& FingerOffsets) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
     FSGIC_TArray_FVector OutFingerTipsContainer;
     FSGIC_TArray_FVector FingerOffsetsContainer{FingerOffsets};
@@ -435,8 +390,6 @@ TArray<FVector> USGSenseGlovePose::CalculateFingerTips(const TArray<FVector>& Fi
 
 bool USGSenseGlovePose::Equals(const USGSenseGlovePose* SenseGlovePose) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
     FSGIC_FSGSenseGlovePoseImpl SenseGlovePoseContainer{SenseGlovePose->ToSenseGlovePoseImpl()};
     return SGCoreImpl_FSGSenseGlovePoseImpl_Equals(&InstanceContainer, &SenseGlovePoseContainer);
@@ -444,8 +397,6 @@ bool USGSenseGlovePose::Equals(const USGSenseGlovePose* SenseGlovePose) const
 
 FString USGSenseGlovePose::ToString(const bool bShortFormat) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGSenseGlovePoseImpl_ToString(&InstanceContainer, &OutStringContainer, bShortFormat);
@@ -454,8 +405,6 @@ FString USGSenseGlovePose::ToString(const bool bShortFormat) const
 
 FString USGSenseGlovePose::SGSerialize() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGlovePoseImpl InstanceContainer{ToSenseGlovePoseImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGSenseGlovePoseImpl_Serialize(&InstanceContainer, &OutStringContainer);
@@ -473,11 +422,3 @@ void USGSenseGlovePose::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
 }
-
-void USGSenseGlovePose::FImpl::SyncUProperties()
-{
-}
-
-void USGSenseGlovePose::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGSenseGloveSensorData.cpp

@@ -46,6 +46,7 @@
 #include "SGInterop/SGIC_FString.h"
 #include "SGInterop/SGIC_TArray_float.h"
 #include "SGInterop/SGIC_TArray_TArray_float.h"
+#include "SGUtils/SGArrayUtils.h"
 
 struct USGSenseGloveSensorData::FImpl
 {
@@ -74,13 +75,6 @@ struct USGSenseGloveSensorData::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-    void SyncImplObject();
 };
 
 USGSenseGloveSensorData* USGSenseGloveSensorData::NewSenseGloveSensorData(
@@ -186,28 +180,17 @@ USGSenseGloveSensorData* USGSenseGloveSensorData::Deserialize(UObject* Outer, co
 }
 
 USGSenseGloveSensorData::USGSenseGloveSensorData()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGSenseGloveSensorDataImpl OutSenseGloveSensorDataImplContainer;
     SGCoreImpl_FSGSenseGloveSensorDataImpl_ctor(&OutSenseGloveSensorDataImplContainer);
 
     Pimpl->SenseGloveSensorDataImpl = MoveTemp(OutSenseGloveSensorDataImplContainer.SenseGloveSensorDataImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGloveSensorData::USGSenseGloveSensorData(const TArray<TArray<float>>& SensorAngles, const FQuat& ImuRotation,
                                                  const int32 ParsedValues, const bool bImuParsed)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGSenseGloveSensorDataImpl OutSenseGloveSensorDataImplContainer;
     FSGIC_TArray_TArray_float SensorAnglesContainer{SensorAngles};
@@ -216,17 +199,11 @@ USGSenseGloveSensorData::USGSenseGloveSensorData(const TArray<TArray<float>>& Se
         &OutSenseGloveSensorDataImplContainer, &SensorAnglesContainer, &ImuRotationContainer, ParsedValues, bImuParsed);
 
     Pimpl->SenseGloveSensorDataImpl = MoveTemp(OutSenseGloveSensorDataImplContainer.SenseGloveSensorDataImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGloveSensorData::USGSenseGloveSensorData(const TArray<TArray<float>>& SensorAngles, const FRotator& ImuRotation,
                                                  const int32 ParsedValues, const bool bImuParsed)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGSenseGloveSensorDataImpl OutSenseGloveSensorDataImplContainer;
     FSGIC_TArray_TArray_float SensorAnglesContainer{SensorAngles};
@@ -235,7 +212,6 @@ USGSenseGloveSensorData::USGSenseGloveSensorData(const TArray<TArray<float>>& Se
         &OutSenseGloveSensorDataImplContainer, &SensorAnglesContainer, &ImuRotationContainer, ParsedValues, bImuParsed);
 
     Pimpl->SenseGloveSensorDataImpl = MoveTemp(OutSenseGloveSensorDataImplContainer.SenseGloveSensorDataImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGloveSensorData::USGSenseGloveSensorData(const TArray<FSGFloatArray>& SensorAngles, const FQuat& ImuRotation,
@@ -250,7 +226,6 @@ USGSenseGloveSensorData::USGSenseGloveSensorData(const TArray<FSGFloatArray>& Se
         &OutSenseGloveSensorDataImplContainer, &SensorAnglesContainer, &ImuRotationContainer, ParsedValues, bImuParsed);
 
     Pimpl->SenseGloveSensorDataImpl = MoveTemp(OutSenseGloveSensorDataImplContainer.SenseGloveSensorDataImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGloveSensorData::USGSenseGloveSensorData(const TArray<FSGFloatArray>& SensorAngles, const FRotator& ImuRotation,
@@ -265,19 +240,12 @@ USGSenseGloveSensorData::USGSenseGloveSensorData(const TArray<FSGFloatArray>& Se
         &OutSenseGloveSensorDataImplContainer, &SensorAnglesContainer, &ImuRotationContainer, ParsedValues, bImuParsed);
 
     Pimpl->SenseGloveSensorDataImpl = MoveTemp(OutSenseGloveSensorDataImplContainer.SenseGloveSensorDataImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGloveSensorData::USGSenseGloveSensorData(const FSGSenseGloveSensorDataImpl& SenseGloveSensorDataImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     SetSenseGloveSensorDataImpl(SenseGloveSensorDataImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSenseGloveSensorData::~USGSenseGloveSensorData() = default;
@@ -292,7 +260,6 @@ void USGSenseGloveSensorData::SetSenseGloveSensorDataImpl(const FSGSenseGloveSen
 
 const FSGSenseGloveSensorDataImpl& USGSenseGloveSensorData::ToSenseGloveSensorDataImpl() const
 {
-    Pimpl->SyncImplObject();
     return Pimpl->SenseGloveSensorDataImpl;
 }
 
@@ -334,8 +301,6 @@ bool USGSenseGloveSensorData::IsImuParsed() const
 
 TArray<float> USGSenseGloveSensorData::GetSensorAngles(const ESGFinger Finger) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGloveSensorDataImpl InstanceContainer{ToSenseGloveSensorDataImpl()};
     FSGIC_TArray_float OutAnglesContainer;
     FSGIC_ESGFinger FingerContainer{Finger};
@@ -354,8 +319,6 @@ TArray<float> USGSenseGloveSensorData::GetAngleSequence() const
 
 bool USGSenseGloveSensorData::Equals(const USGSenseGloveSensorData* SenseGloveSensorData) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGloveSensorDataImpl InstanceContainer{ToSenseGloveSensorDataImpl()};
     FSGIC_FSGSenseGloveSensorDataImpl SenseGloveSensorDataContainer{SenseGloveSensorData->ToSenseGloveSensorDataImpl()};
     return SGCoreImpl_FSGSenseGloveSensorDataImpl_Equals(&InstanceContainer, &SenseGloveSensorDataContainer);
@@ -363,8 +326,6 @@ bool USGSenseGloveSensorData::Equals(const USGSenseGloveSensorData* SenseGloveSe
 
 FString USGSenseGloveSensorData::ToString() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGloveSensorDataImpl InstanceContainer{ToSenseGloveSensorDataImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGSenseGloveSensorDataImpl_ToString(&InstanceContainer, &OutStringContainer);
@@ -373,8 +334,6 @@ FString USGSenseGloveSensorData::ToString() const
 
 FString USGSenseGloveSensorData::SGSerialize() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSenseGloveSensorDataImpl InstanceContainer{ToSenseGloveSensorDataImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGSenseGloveSensorDataImpl_Serialize(&InstanceContainer, &OutStringContainer);
@@ -392,11 +351,3 @@ void USGSenseGloveSensorData::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
 }
-
-void USGSenseGloveSensorData::FImpl::SyncUProperties()
-{
-}
-
-void USGSenseGloveSensorData::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGSensorRange.cpp

@@ -70,13 +70,6 @@ struct USGSensorRange::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-    void SyncImplObject();
 };
 
 USGSensorRange* USGSensorRange::NewSensorRange(UObject* Outer, const FSGSensorRangeImpl& SensorRangeImpl)
@@ -140,27 +133,16 @@ void USGSensorRange::CheckMin(const FVector& CurrentValues, FVector& OutMinValue
 }
 
 USGSensorRange::USGSensorRange()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGSensorRangeImpl OutSensorRangeImplContainer;
     SGCoreImpl_FSGSensorRangeImpl_ctor(&OutSensorRangeImplContainer);
 
     Pimpl->SensorRangeImpl = MoveTemp(OutSensorRangeImplContainer.SensorRangeImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSensorRange::USGSensorRange(const TArray<FVector>& MinValues, const TArray<FVector>& MaxValues)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGSensorRangeImpl OutSensorRangeImplContainer;
     FSGIC_TArray_FVector MinValuesContainer{MinValues};
@@ -169,19 +151,12 @@ USGSensorRange::USGSensorRange(const TArray<FVector>& MinValues, const TArray<FV
         &OutSensorRangeImplContainer, &MinValuesContainer, &MaxValuesContainer);
 
     Pimpl->SensorRangeImpl = MoveTemp(OutSensorRangeImplContainer.SensorRangeImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSensorRange::USGSensorRange(const FSGSensorRangeImpl& SensorRangeImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     SetSensorRangeImpl(SensorRangeImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGSensorRange::~USGSensorRange() = default;
@@ -196,7 +171,6 @@ void USGSensorRange::SetSensorRangeImpl(const FSGSensorRangeImpl& SensorRangeImp
 
 const FSGSensorRangeImpl& USGSensorRange::ToSensorRangeImpl() const
 {
-    Pimpl->SyncImplObject();
     return Pimpl->SensorRangeImpl;
 }
 
@@ -240,29 +214,19 @@ TArray<FVector> USGSensorRange::GetRange() const
 
 void USGSensorRange::UpdateRange()
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSensorRangeImpl InstanceContainer{ToSensorRangeImpl()};
     SGCoreImpl_FSGSensorRangeImpl_UpdateRange(&InstanceContainer);
-
-    Pimpl->SyncUProperties();
 }
 
 void USGSensorRange::CheckForExtremes(const TArray<FVector>& OtherValues)
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSensorRangeImpl InstanceContainer{ToSensorRangeImpl()};
     FSGIC_TArray_FVector OtherValuesContainer{OtherValues};
     SGCoreImpl_FSGSensorRangeImpl_CheckForExtremes(&InstanceContainer, &OtherValuesContainer);
-
-    Pimpl->SyncUProperties();
 }
 
 FString USGSensorRange::RangeString(const bool bYOnly) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSensorRangeImpl InstanceContainer{ToSensorRangeImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGSensorRangeImpl_RangeString(&InstanceContainer, &OutStringContainer, bYOnly);
@@ -271,8 +235,6 @@ FString USGSensorRange::RangeString(const bool bYOnly) const
 
 FString USGSensorRange::ToString(const bool bYOnly) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSensorRangeImpl InstanceContainer{ToSensorRangeImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGSensorRangeImpl_ToString(&InstanceContainer, &OutStringContainer, bYOnly);
@@ -281,8 +243,6 @@ FString USGSensorRange::ToString(const bool bYOnly) const
 
 FString USGSensorRange::SGSerialize() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGSensorRangeImpl InstanceContainer{ToSensorRangeImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGSensorRangeImpl_Serialize(&InstanceContainer, &OutStringContainer);
@@ -300,11 +260,3 @@ void USGSensorRange::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
 }
-
-void USGSensorRange::FImpl::SyncUProperties()
-{
-}
-
-void USGSensorRange::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGThumperCommand.cpp

@@ -65,13 +65,6 @@ struct USGThumperCommand::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-    void SyncImplObject();
 };
 
 USGThumperCommand* USGThumperCommand::NewThumperCommand(UObject* Outer, const FSGThumperCommandImpl& ThumperCommandImpl)
@@ -106,45 +99,27 @@ USGThumperCommand* USGThumperCommand::Off(UObject* Outer)
 }
 
 USGThumperCommand::USGThumperCommand()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGThumperCommandImpl OutThumperCommandImplContainer;
     SGCoreImpl_FSGThumperCommandImpl_ctor(&OutThumperCommandImplContainer);
 
     Pimpl->ThumperCommandImpl = MoveTemp(OutThumperCommandImplContainer.ThumperCommandImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGThumperCommand::USGThumperCommand(const int32 Magnitude)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGThumperCommandImpl OutThumperCommandImplContainer;
     SGCoreImpl_FSGThumperCommandImpl_ctor_Magnitude(&OutThumperCommandImplContainer, Magnitude);
 
     Pimpl->ThumperCommandImpl = MoveTemp(OutThumperCommandImplContainer.ThumperCommandImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGThumperCommand::USGThumperCommand(const FSGThumperCommandImpl& ThumperCommandImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     SetThumperCommandImpl(ThumperCommandImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGThumperCommand::~USGThumperCommand() = default;
@@ -164,26 +139,18 @@ const FSGThumperCommandImpl& USGThumperCommand::ToThumperCommandImpl() const
 
 int32 USGThumperCommand::GetMagnitude() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGThumperCommandImpl ThumperCommandImplContainer{ToThumperCommandImpl()};
     return SGCoreImpl_FSGThumperCommandImpl_GetMagnitude(&ThumperCommandImplContainer);
 }
 
 void USGThumperCommand::SetMagnitude(const int32 Magnitude)
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGThumperCommandImpl ThumperCommandImplContainer{ToThumperCommandImpl()};
     SGCoreImpl_FSGThumperCommandImpl_SetMagnitude(&ThumperCommandImplContainer, Magnitude);
-
-    Pimpl->SyncUProperties();
 }
 
 USGThumperCommand* USGThumperCommand::Copy(UObject* Outer) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGThumperCommandImpl InstanceContainer{ToThumperCommandImpl()};
     FSGIC_FSGThumperCommandImpl OutThumperCommandImplContainer;
     SGCoreImpl_FSGThumperCommandImpl_Copy(&InstanceContainer, &OutThumperCommandImplContainer);
@@ -192,8 +159,6 @@ USGThumperCommand* USGThumperCommand::Copy(UObject* Outer) const
 
 USGThumperCommand* USGThumperCommand::Merge(UObject* Outer, const USGThumperCommand* ThumperCommand) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGThumperCommandImpl InstanceContainer{ToThumperCommandImpl()};
     FSGIC_FSGThumperCommandImpl ThumperCommandImplContainer{ThumperCommand->ToThumperCommandImpl()};
     FSGIC_FSGThumperCommandImpl OutThumperCommandImplContainer;
@@ -204,8 +169,6 @@ USGThumperCommand* USGThumperCommand::Merge(UObject* Outer, const USGThumperComm
 
 bool USGThumperCommand::Equals(const USGThumperCommand* ThumperCommand) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGThumperCommandImpl InstanceContainer{ToThumperCommandImpl()};
     FSGIC_FSGThumperCommandImpl ThumperCommandImplContainer{ThumperCommand->ToThumperCommandImpl()};
     return SGCoreImpl_FSGThumperCommandImpl_Equals(&InstanceContainer, &ThumperCommandImplContainer);
@@ -222,11 +185,3 @@ void USGThumperCommand::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
 }
-
-void USGThumperCommand::FImpl::SyncImplObject()
-{
-}
-
-void USGThumperCommand::FImpl::SyncUProperties()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGTimedBuzzCommand.cpp

@@ -47,42 +47,6 @@
 #include "SGInterop/SGIC_FString.h"
 #include "SGInterop/SGIC_TSharedPtr_FSGTimedBuzzCommandImpl.h"
 
-struct USGTimedBuzzCommand::FImpl
-{
-    /************************
-     * Member variables
-     ************************/
-
-
-    /************************
-     * Owner object
-     ************************/
-
-    USGTimedBuzzCommand* Owner;
-
-    /************************
-     * Constructor / Destructor
-     ************************/
-
-    explicit FImpl(USGTimedBuzzCommand* InOwner);
-    ~FImpl();
-
-    /************************
-     * Default copy constructor & copy assignment operator
-     ************************/
-
-    FImpl(const FImpl& Rhs) = default;
-    FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-
-    void SyncImplObject();
-};
-
 USGTimedBuzzCommand* USGTimedBuzzCommand::NewTimedBuzzCommand(
     UObject* Outer, const FSGTimedBuzzCommandImpl& TimedBuzzCommandImpl)
 {
@@ -132,28 +96,17 @@ USGTimedBuzzCommand* USGTimedBuzzCommand::NewTimedBuzzCommand(
 }
 
 USGTimedBuzzCommand::USGTimedBuzzCommand()
-    : USGBuzzCommand(),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGBuzzCommand()
 {
     FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl OutTimedBuzzCommandImplContainer;
     SGCoreImpl_FSGTimedBuzzCommandImpl_ctor_MakeShared(&OutTimedBuzzCommandImplContainer);
 
     SetFingerCommandImpl(OutTimedBuzzCommandImplContainer.Ptr.ToSharedRef());
-    Pimpl->SyncUProperties();
 }
 
 USGTimedBuzzCommand::USGTimedBuzzCommand(const ESGFinger Finger, const int32 Magnitude,
                                          const float DurationSeconds, const float StartTimeSeconds)
-    : USGBuzzCommand(),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGBuzzCommand()
 {
     FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl OutSharedPtrContainer;
     FSGIC_ESGFinger FingerContainer{Finger};
@@ -161,17 +114,11 @@ USGTimedBuzzCommand::USGTimedBuzzCommand(const ESGFinger Finger, const int32 Mag
         &OutSharedPtrContainer, &FingerContainer, Magnitude, DurationSeconds, StartTimeSeconds);
 
     SetFingerCommandImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
-    Pimpl->SyncUProperties();
 }
 
 USGTimedBuzzCommand::USGTimedBuzzCommand(const USGBuzzCommand* BaseCommand,
                                          const float DurationSeconds, const float StartTimeSeconds)
-    : USGBuzzCommand(),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGBuzzCommand()
 {
     FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl OutSharedPtrContainer;
     FSGIC_FSGBuzzCommandImpl BaseCommandContainer{BaseCommand->ToBuzzCommandImpl().Get()};
@@ -179,55 +126,27 @@ USGTimedBuzzCommand::USGTimedBuzzCommand(const USGBuzzCommand* BaseCommand,
         &OutSharedPtrContainer, &BaseCommandContainer, DurationSeconds, StartTimeSeconds);
 
     SetFingerCommandImpl(OutSharedPtrContainer.Ptr.ToSharedRef());
-    Pimpl->SyncUProperties();
 }
 
 USGTimedBuzzCommand::USGTimedBuzzCommand(const FSGTimedBuzzCommandImpl& TimedBuzzCommandImpl)
-    : USGBuzzCommand(TimedBuzzCommandImpl),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGBuzzCommand(TimedBuzzCommandImpl)
 {
-    Pimpl->SyncUProperties();
 }
 
 USGTimedBuzzCommand::USGTimedBuzzCommand(TSharedRef<FSGTimedBuzzCommandImpl> TimedBuzzCommandImpl)
-    : USGBuzzCommand(MoveTemp(TimedBuzzCommandImpl)),
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : USGBuzzCommand(MoveTemp(TimedBuzzCommandImpl))
 {
-    Pimpl->SyncUProperties();
 }
 
 USGTimedBuzzCommand::~USGTimedBuzzCommand() = default;
 
 TSharedRef<FSGTimedBuzzCommandImpl> USGTimedBuzzCommand::ToTimedBuzzCommandImpl() const
 {
-    SyncImplObject();
     return FSGFingerCommandImplCast::ToTimedBuzzCommandImpl(ToFingerCommandImpl());
 }
 
-void USGTimedBuzzCommand::SyncImplObject() const
-{
-    Super::SyncImplObject();
-    Pimpl->SyncImplObject();
-}
-
-void USGTimedBuzzCommand::SyncUProperties()
-{
-    Super::SyncUProperties();
-    Pimpl->SyncUProperties();
-}
-
 USGBuzzCommand* USGTimedBuzzCommand::Copy(UObject* Outer) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl InstanceContainer{ToTimedBuzzCommandImpl()};
     FSGIC_FSGBuzzCommandImpl OutBuzzCommandImplContainer;
     SGCoreImpl_FSGTimedBuzzCommandImpl_Copy(&InstanceContainer, &OutBuzzCommandImplContainer);
@@ -237,8 +156,6 @@ USGBuzzCommand* USGTimedBuzzCommand::Copy(UObject* Outer) const
 
 USGBuzzCommand* USGTimedBuzzCommand::Merge(UObject* Outer, const USGBuzzCommand* BuzzCommand) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl InstanceContainer{ToTimedBuzzCommandImpl()};
     FSGIC_FSGBuzzCommandImpl BuzzCommandImplContainer{BuzzCommand->ToBuzzCommandImpl().Get()};
     FSGIC_FSGBuzzCommandImpl OutBuzzCommandImplContainer;
@@ -256,12 +173,6 @@ USGBuzzCommand* USGTimedBuzzCommand::GetBaseCommand(UObject* Outer) const
     return NewBuzzCommand(Outer, MoveTemp(OutCommandContainer.BuzzCommandImpl));
 }
 
-int32 USGTimedBuzzCommand::GetMagnitude() const
-{
-    FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl InstanceContainer{ToTimedBuzzCommandImpl()};
-    return SGCoreImpl_FSGTimedBuzzCommandImpl_GetMagnitude(&InstanceContainer);
-}
-
 float USGTimedBuzzCommand::GetDuration() const
 {
     FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl InstanceContainer{ToTimedBuzzCommandImpl()};
@@ -276,66 +187,32 @@ float USGTimedBuzzCommand::GetElapsedTime() const
 
 bool USGTimedBuzzCommand::HasTimeElapsed() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl InstanceContainer{ToTimedBuzzCommandImpl()};
     return SGCoreImpl_FSGTimedBuzzCommandImpl_HasTimeElapsed(&InstanceContainer);
 }
 
 float USGTimedBuzzCommand::NormalizedTime(const bool bClamp01) const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl InstanceContainer{ToTimedBuzzCommandImpl()};
     return SGCoreImpl_FSGTimedBuzzCommandImpl_NormalizedTime(&InstanceContainer, bClamp01);
 }
 
 void USGTimedBuzzCommand::ResetTiming()
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl InstanceContainer{ToTimedBuzzCommandImpl()};
     SGCoreImpl_FSGTimedBuzzCommandImpl_ResetTiming(&InstanceContainer);
-
-    SyncUProperties();
 }
 
 void USGTimedBuzzCommand::UpdateTiming(const float DeltaSeconds)
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl InstanceContainer{ToTimedBuzzCommandImpl()};
     SGCoreImpl_FSGTimedBuzzCommandImpl_UpdateTiming(&InstanceContainer, DeltaSeconds);
-
-    SyncUProperties();
 }
 
 FString USGTimedBuzzCommand::ToString() const
 {
-    SyncImplObject();
-
     FSGIC_TSharedPtr_FSGTimedBuzzCommandImpl InstanceContainer{ToTimedBuzzCommandImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGTimedBuzzCommandImpl_ToString(&InstanceContainer, &OutStringContainer);
     return MoveTemp(OutStringContainer.String);
 }
-
-USGTimedBuzzCommand::FImpl::FImpl(USGTimedBuzzCommand* InOwner)
-    : Owner(InOwner)
-{
-}
-
-USGTimedBuzzCommand::FImpl::~FImpl() = default;
-
-void USGTimedBuzzCommand::FImplDeleter::operator()(const FImpl* P) const
-{
-    delete P;
-}
-
-void USGTimedBuzzCommand::FImpl::SyncUProperties()
-{
-}
-
-void USGTimedBuzzCommand::FImpl::SyncImplObject()
-{
-}

Source/SenseGloveCore/Private/SGCore/SGTimedThumpCommand.cpp

@@ -70,13 +70,6 @@ struct USGTimedThumpCommand::FImpl
 
     FImpl(const FImpl& Rhs) = default;
     FImpl& operator=(const FImpl& Rhs) = default;
-
-    /************************
-     * Methods
-     ************************/
-
-    void SyncUProperties();
-    void SyncImplObject();
 };
 
 USGTimedThumpCommand* USGTimedThumpCommand::NewTimedThumpCommand(
@@ -117,45 +110,28 @@ USGTimedThumpCommand* USGTimedThumpCommand::NewTimedThumpCommand(
 }
 
 USGTimedThumpCommand::USGTimedThumpCommand()
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGTimedThumpCommandImpl OutTimedThumpCommandImplContainer;
     SGCoreImpl_FSGTimedThumpCommandImpl_ctor(&OutTimedThumpCommandImplContainer);
 
     Pimpl->TimedThumpCommandImpl = MoveTemp(OutTimedThumpCommandImplContainer.TimedThumpCommandImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGTimedThumpCommand::USGTimedThumpCommand(const int32 Magnitude,
                                            const float DurationSeconds, const float StartTimeSeconds)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGTimedThumpCommandImpl OutTimedThumpCommandImplContainer;
     SGCoreImpl_FSGTimedThumpCommandImpl_ctor_Magnitude_DurationSeconds_StartTimeSeconds(
         &OutTimedThumpCommandImplContainer, Magnitude, DurationSeconds, StartTimeSeconds);
 
     Pimpl->TimedThumpCommandImpl = MoveTemp(OutTimedThumpCommandImplContainer.TimedThumpCommandImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGTimedThumpCommand::USGTimedThumpCommand(const USGThumperCommand* BaseCommand,
                                            const float DurationSeconds, const float StartTimeSeconds)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     FSGIC_FSGTimedThumpCommandImpl OutTimedThumpCommandImplContainer;
     FSGIC_FSGThumperCommandImpl BaseCommandContainer{BaseCommand->ToThumperCommandImpl()};
@@ -163,19 +139,12 @@ USGTimedThumpCommand::USGTimedThumpCommand(const USGThumperCommand* BaseCommand,
         &OutTimedThumpCommandImplContainer, &BaseCommandContainer, DurationSeconds, StartTimeSeconds);
 
     Pimpl->TimedThumpCommandImpl = MoveTemp(OutTimedThumpCommandImplContainer.TimedThumpCommandImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGTimedThumpCommand::USGTimedThumpCommand(const FSGTimedThumpCommandImpl& TimedThumpCommandImpl)
-    :
-#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     SetTimedThumpCommandImpl(TimedThumpCommandImpl);
-    Pimpl->SyncUProperties();
 }
 
 USGTimedThumpCommand::~USGTimedThumpCommand() = default;
@@ -190,7 +159,6 @@ void USGTimedThumpCommand::SetTimedThumpCommandImpl(const FSGTimedThumpCommandIm
 
 const FSGTimedThumpCommandImpl& USGTimedThumpCommand::ToTimedThumpCommandImpl() const
 {
-    Pimpl->SyncImplObject();
     return Pimpl->TimedThumpCommandImpl;
 }
 
@@ -200,48 +168,26 @@ int32 USGTimedThumpCommand::GetMagnitude() const
     return SGCoreImpl_FSGTimedThumpCommandImpl_GetMagnitude(&InstanceContainer);
 }
 
-void USGTimedThumpCommand::SetMagnitude(int32 Magnitude)
-{
-    FSGIC_FSGTimedThumpCommandImpl InstanceContainer{ToTimedThumpCommandImpl()};
-    SGCoreImpl_FSGTimedThumpCommandImpl_SetMagnitude(&InstanceContainer, Magnitude);
-}
-
 float USGTimedThumpCommand::GetDuration() const
 {
     FSGIC_FSGTimedThumpCommandImpl InstanceContainer{ToTimedThumpCommandImpl()};
     return SGCoreImpl_FSGTimedThumpCommandImpl_GetDuration(&InstanceContainer);
 }
 
-void USGTimedThumpCommand::SetDuration(const float Duration)
-{
-    FSGIC_FSGTimedThumpCommandImpl InstanceContainer{ToTimedThumpCommandImpl()};
-    SGCoreImpl_FSGTimedThumpCommandImpl_SetDuration(&InstanceContainer, Duration);
-}
-
 float USGTimedThumpCommand::GetElapsedTime() const
 {
     FSGIC_FSGTimedThumpCommandImpl InstanceContainer{ToTimedThumpCommandImpl()};
     return SGCoreImpl_FSGTimedThumpCommandImpl_GetElapsedTime(&InstanceContainer);
 }
 
-void USGTimedThumpCommand::SetElapsedTime(const float ElapsedTime)
-{
-    FSGIC_FSGTimedThumpCommandImpl InstanceContainer{ToTimedThumpCommandImpl()};
-    SGCoreImpl_FSGTimedThumpCommandImpl_SetElapsedTime(&InstanceContainer, ElapsedTime);
-}
-
 bool USGTimedThumpCommand::HasTimeElapsed() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGTimedThumpCommandImpl InstanceContainer{ToTimedThumpCommandImpl()};
     return SGCoreImpl_FSGTimedThumpCommandImpl_HasTimeElapsed(&InstanceContainer);
 }
 
 USGTimedThumpCommand* USGTimedThumpCommand::Copy(UObject* Outer, const bool bCopyElapsed) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGTimedThumpCommandImpl InstanceContainer{ToTimedThumpCommandImpl()};
     FSGIC_FSGTimedThumpCommandImpl OutTimedThumpCommandImplContainer;
     SGCoreImpl_FSGTimedThumpCommandImpl_Copy(&InstanceContainer, &OutTimedThumpCommandImplContainer, bCopyElapsed);
@@ -251,16 +197,12 @@ USGTimedThumpCommand* USGTimedThumpCommand::Copy(UObject* Outer, const bool bCop
 
 void USGTimedThumpCommand::Update(const float DeltaSeconds)
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGTimedThumpCommandImpl InstanceContainer{ToTimedThumpCommandImpl()};
     SGCoreImpl_FSGTimedThumpCommandImpl_Update(&InstanceContainer, DeltaSeconds);
 }
 
 bool USGTimedThumpCommand::Equals(const USGTimedThumpCommand* TimedThumpCommand) const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGTimedThumpCommandImpl InstanceContainer{ToTimedThumpCommandImpl()};
     FSGIC_FSGTimedThumpCommandImpl TimedThumpCommandImplContainer{TimedThumpCommand->ToTimedThumpCommandImpl()};
     return SGCoreImpl_FSGTimedThumpCommandImpl_Equals(&InstanceContainer, &TimedThumpCommandImplContainer);
@@ -268,8 +210,6 @@ bool USGTimedThumpCommand::Equals(const USGTimedThumpCommand* TimedThumpCommand)
 
 FString USGTimedThumpCommand::ToString() const
 {
-    Pimpl->SyncImplObject();
-
     FSGIC_FSGTimedThumpCommandImpl InstanceContainer{ToTimedThumpCommandImpl()};
     FSGIC_FString OutStringContainer;
     SGCoreImpl_FSGTimedThumpCommandImpl_ToString(&InstanceContainer, &OutStringContainer);
@@ -287,11 +227,3 @@ void USGTimedThumpCommand::FImplDeleter::operator()(const FImpl* P) const
 {
     delete P;
 }
-
-void USGTimedThumpCommand::FImpl::SyncImplObject()
-{
-}
-
-void USGTimedThumpCommand::FImpl::SyncUProperties()
-{
-}

Source/SenseGloveCore/Public/SGCore/SGAnatomy.h

@@ -82,14 +82,14 @@ public:
     static float GetThumbJointLimit(bool bRightHanded, int32 Joint, int32 Movement, bool bMax);
 
     /**
-     * Convert a total finger flexion in radians into a 0..1 representation.
+     * Convert a total finger flexion in degrees into a 0..1 representation.
      */
-    static float NormalizeFingerFlexion(float FlexionInRadians);
+    static float NormalizeFingerFlexion(float FlexionInDegrees);
 
     /**
-     * Convert a total thumb flexion in radians into a 0..1 representation.
+     * Convert a total thumb flexion in degrees into a 0..1 representation.
      */
-    static float NormalizeThumbFlexion(float FlexionInRadians);
+    static float NormalizeThumbFlexion(float FlexionInDegrees);
 
     /**
      * Get Hand Angles that would make a Default (Idle) Pose.

Source/SenseGloveCore/Public/SGCore/SGBasicHandModel.h

@@ -46,8 +46,8 @@
 #include "UObject/Object.h"
 #include "UObject/ObjectMacros.h"
 
-#include "SGCore/SGFloatArray.h"
 #include "SGTypes/SGCoreTypes.h"
+#include "SGTypes/SGFloatArray.h"
 
 #include "SGBasicHandModel.generated.h"
 

Source/SenseGloveCore/Public/SGCore/SGBetaDevice.h

@@ -38,8 +38,6 @@
 
 #pragma once
 
-#include "Templates/UniquePtr.h"
-
 #include "SGCore/SGDevice.h"
 #include "SGTypes/SGCoreTypes.h"
 
@@ -81,17 +79,6 @@ public:
      */
     static USGBetaDevice* Parse(UObject* Outer, const FString& String);
 
-private:
-    struct FImpl;
-
-    struct FImplDeleter
-    {
-        void operator()(const FImpl* P) const;
-    };
-
-    TUniquePtr<FImpl, FImplDeleter> Pimpl;
-    FImplDeleter PimplDeleter;
-
 public:
     /**
      * The basic class constructor.
@@ -128,17 +115,6 @@ protected:
      */
     TSharedRef<FSGBetaDeviceImpl> ToBetaDeviceImpl() const;
 
-protected:
-    /**
-     * Allows the child classes to synchronize the parent's underlying object at any time.
-     */
-    virtual void SyncImplObject() const override;
-
-    /**
-     * Allows the child classes to synchronize the parent's uproperties at any time.
-     */
-    virtual void SyncUProperties() override;
-
 public:
     /**
      * Get the DeviceType enumerator of this SenseGlove, used in DeviceList enumeration.

Source/SenseGloveCore/Public/SGCore/SGBuzzCommand.h

@@ -37,7 +37,6 @@
 
 #include "HAL/Platform.h"
 #include "Templates/SharedPointer.h"
-#include "Templates/UniquePtr.h"
 #include "UObject/ObjectMacros.h"
 
 #include "SGCore/SGFingerCommand.h"
@@ -88,17 +87,6 @@ public:
      */
     static USGBuzzCommand* Off(UObject* Outer);
 
-private:
-    struct FImpl;
-
-    struct FImplDeleter
-    {
-        void operator()(const FImpl* P) const;
-    };
-
-    TUniquePtr<FImpl, FImplDeleter> Pimpl;
-    FImplDeleter PimplDeleter;
-
 public:
     /**
      * The basic constructor.
@@ -144,17 +132,6 @@ public:
      */
     TSharedRef<FSGBuzzCommandImpl> ToBuzzCommandImpl() const;
 
-protected:
-    /**
-     * Allows the child classes to synchronize the parent's underlying object at any time.
-     */
-    virtual void SyncImplObject() const override;
-
-    /**
-     * Allows the child classes to synchronize the parent's uproperties at any time.
-     */
-    virtual void SyncUProperties() override;
-
 public:
     /**
      * Copy this Buzz Command into a new object.

Source/SenseGloveCore/Public/SGCore/SGDevice.h

@@ -202,17 +202,6 @@ public:
      */
     TSharedRef<FSGDeviceImpl> ToSGDeviceImpl() const;
 
-protected:
-    /**
-     * Allows the child classes to synchronize the parent's underlying object at any time.
-     */
-    virtual void SyncImplObject() const;
-
-    /**
-     * Allows the child classes to synchronize the parent's uproperties at any time.
-     */
-    virtual void SyncUProperties();
-
 public:
     /**
      * Check which DeviceType this class belongs to.

Source/SenseGloveCore/Public/SGCore/SGFingerCommand.h

@@ -174,17 +174,6 @@ public:
      */
     TSharedRef<FSGFingerCommandImpl> ToFingerCommandImpl() const;
 
-protected:
-    /**
-     * Allows the child classes to synchronize the parent's underlying object at any time.
-     */
-    virtual void SyncImplObject() const;
-
-    /**
-     * Allows the child classes to synchronize the parent's uproperties at any time.
-     */
-    virtual void SyncUProperties();
-
 public:
     /**
      *

Source/SenseGloveCore/Public/SGCore/SGForceFeedbackCommand.h

@@ -37,7 +37,6 @@
 
 #include "HAL/Platform.h"
 #include "Templates/SharedPointer.h"
-#include "Templates/UniquePtr.h"
 #include "UObject/ObjectMacros.h"
 
 #include "SGCore/SGFingerCommand.h"
@@ -92,17 +91,6 @@ public:
      */
     static USGForceFeedbackCommand* Off(UObject* Outer);
 
-private:
-    struct FImpl;
-
-    struct FImplDeleter
-    {
-        void operator()(const FImpl* P) const;
-    };
-
-    TUniquePtr<FImpl, FImplDeleter> Pimpl;
-    FImplDeleter PimplDeleter;
-
 public:
     /**
      * Empty constructor for internal initialization.
@@ -148,17 +136,6 @@ public:
      */
     TSharedRef<FSGForceFeedbackCommandImpl> ToForceFeedbackCommandImpl() const;
 
-protected:
-    /**
-     * Allows the child classes to synchronize the parent's underlying object at any time.
-     */
-    virtual void SyncImplObject() const override;
-
-    /**
-     * Allows the child classes to synchronize the parent's uproperties at any time.
-     */
-    virtual void SyncUProperties() override;
-
 public:
     /**
      * Copy this ForceFeedback Command into a new object.

Source/SenseGloveCore/Public/SGCore/SGHandInterpolator.h

@@ -44,7 +44,7 @@
 #include "UObject/Object.h"
 #include "UObject/ObjectMacros.h"
 
-#include "SGCore/SGInterpolationSetArray.h"
+#include "SGCoreTypes/SGInterpolationSetArray.h"
 #include "SGTypes/SGCoreTypes.h"
 
 #include "SGHandInterpolator.generated.h"
@@ -236,16 +236,22 @@ public:
 public:
     /**
      * Calculate any finger's movement rotation, using an input value.
+     *
+     * WARNING: This method is for internal use only. Avoid using it!
      */
     float CalculateAngle(ESGFinger Finger, int32 Movement, float Value) const;
 
     /**
      * Calculate a finger movement's rotation, using an input value.
+     *
+     * WARNING: This method is for internal use only. Avoid using it!
      */
     float CalculateAngle(ESGFinger Finger, ESGFingerMovement Movement, float Value) const;
 
     /**
      * Calculate a thumb movement's rotation, using an input value.
+     *
+     * WARNING: This method is for internal use only. Avoid using it!
      */
     float CalculateAngle(ESGFinger Finger, ESGThumbMovement Movement, float Value) const;
 

Source/SenseGloveCore/Public/SGCore/SGHandPose.h

@@ -44,10 +44,10 @@
 #include "UObject/Object.h"
 #include "UObject/ObjectMacros.h"
 
-#include "SGCore/SGQuatArray.h"
-#include "SGCore/SGRotatorArray.h"
-#include "SGCore/SGVectorArray.h"
 #include "SGTypes/SGCoreTypes.h"
+#include "SGTypes/SGQuatArray.h"
+#include "SGTypes/SGRotatorArray.h"
+#include "SGTypes/SGVectorArray.h"
 
 #include "SGHandPose.generated.h"
 

Source/SenseGloveCore/Public/SGCore/SGHapticGlove.h

@@ -94,17 +94,6 @@ public:
      */
     static bool GetGlove(UObject* Outer, bool bRightHanded, USGHapticGlove*& OutGlove);
 
-private:
-    struct FImpl;
-
-    struct FImplDeleter
-    {
-        void operator()(const FImpl* P) const;
-    };
-
-    TUniquePtr<FImpl, FImplDeleter> Pimpl;
-    FImplDeleter PimplDeleter;
-
 protected:
     /**
      * The basic constructor.
@@ -165,17 +154,6 @@ public:
      */
     TSharedRef<FSGHapticGloveImpl> ToHapticGloveImpl() const;
 
-protected:
-    /**
-     * Allows the child classes to synchronize the parent's underlying object at any time.
-     */
-    virtual void SyncImplObject() const override;
-
-    /**
-     * Allows the child classes to synchronize the parent's uproperties at any time.
-     */
-    virtual void SyncUProperties() override;
-
 public:
     /**
      * Get the DeviceType enumerator of this device; used to check if its a SenseGlove/Nova/etc.
@@ -239,6 +217,10 @@ public:
      */
     virtual bool GetHandPose(UObject* Outer, USGHandPose*& OutHandPose);
 
+#if PLATFORM_ANDROID
+    virtual bool GetHandPose(UObject* Outer, float DeltaTime, USGHandPose*& OutHandPose);
+#endif  /* PLATFORM_ANDROID */
+
 public:
     /**
      * Stops all Haptic effects if any are currently playing. Useful at the end of simulations or when resetting.

Source/SenseGloveCore/Public/SGCore/SGHapticGloveCalibrationCheck.h

@@ -172,12 +172,6 @@ public:
      */
     const FSGHapticGloveCalibrationCheckImpl& ToHapticGloveCalibrationCheckImpl() const;
 
-public:
-    /**
-     *
-     */
-    USGSensorRange* GetLastSensorRange(UObject* Outer) const;
-
 public:
     /**
      *

Source/SenseGloveCore/Public/SGCore/SGHapticGloveCalibrationSequence.h

@@ -180,17 +180,6 @@ public:
      */
     TSharedRef<FSGHapticGloveCalibrationSequenceImpl> ToHapticGloveCalibrationSequenceImpl() const;
 
-protected:
-    /**
-     * Allows the child classes to synchronize the parent's underlying object at any time.
-     */
-    virtual void SyncImplObject() const;
-
-    /**
-     * Allows the child classes to synchronize the parent's uproperties at any time.
-     */
-    virtual void SyncUProperties();
-
 public:
     /**
      * Glove linked to this calibration sequence. Will attempt to grab data from this glove evey time Update() is called.

Source/SenseGloveCore/Public/SGCore/SGHapticGloveQuickCalibration.h

@@ -37,7 +37,6 @@
 
 #include "Containers/Array.h"
 #include "Containers/UnrealString.h"
-#include "Templates/UniquePtr.h"
 
 #include "SGCore/SGHapticGloveCalibrationSequence.h"
 
@@ -80,17 +79,6 @@ public:
      */
     static float GetDefaultAutoEndTimeout();
 
-private:
-    struct FImpl;
-
-    struct FImplDeleter
-    {
-        void operator()(const FImpl* P) const;
-    };
-
-    TUniquePtr<FImpl, FImplDeleter> Pimpl;
-    FImplDeleter PimplDeleter;
-
 public:
     /**
      *
@@ -128,17 +116,6 @@ public:
      */
     TSharedRef<FSGHapticGloveQuickCalibrationImpl> ToHapticGloveQuickCalibrationImpl() const;
 
-protected:
-    /**
-     * Allows the child classes to synchronize the parent's underlying object at any time.
-     */
-    virtual void SyncImplObject() const override;
-
-    /**
-     * Allows the child classes to synchronize the parent's uproperties at any time.
-     */
-    virtual void SyncUProperties() override;
-
 public:
     /**
      * Time, in seconds, after which this sequence stops gathering data. Based on the deltaSeconds variable passed in the Update() function.

Source/SenseGloveCore/Public/SGCore/SGNovaGlove.h

@@ -177,17 +177,6 @@ public:
      */
     static FString ToBytes(const USGBuzzCommand* BuzzCommand);
 
-private:
-    struct FImpl;
-
-    struct FImplDeleter
-    {
-        void operator()(const FImpl* P) const;
-    };
-
-    TUniquePtr<FImpl, FImplDeleter> Pimpl;
-    FImplDeleter PimplDeleter;
-
 protected:
     USGNovaGlove();
 
@@ -237,17 +226,6 @@ public:
      */
     TSharedRef<FSGNovaGloveImpl> ToNovaGloveImpl() const;
 
-protected:
-    /**
-     * Allows the child classes to synchronize the parent's underlying object at any time.
-     */
-    virtual void SyncImplObject() const override;
-
-    /**
-     * Allows the child classes to synchronize the parent's uproperties at any time.
-     */
-    virtual void SyncUProperties() override;
-
 public:
     /**
      * Return the DeviceType of this Nova.

Source/SenseGloveCore/Public/SGCore/SGSenseGlove.h

@@ -190,17 +190,6 @@ public:
                                        const FRotator& GloveWristRotationOffset,
                                        FVector& OutWristPosition, FRotator& OutWristRotation);
 
-private:
-    struct FImpl;
-
-    struct FImplDeleter
-    {
-        void operator()(const FImpl* P) const;
-    };
-
-    TUniquePtr<FImpl, FImplDeleter> Pimpl;
-    FImplDeleter PimplDeleter;
-
 protected:
     /**
      *
@@ -256,17 +245,6 @@ public:
      */
     TSharedRef<FSGSenseGloveImpl> ToSenseGloveImpl() const;
 
-protected:
-    /**
-     * Allows the child classes to synchronize the parent's underlying object at any time.
-     */
-    virtual void SyncImplObject() const override;
-
-    /**
-     * Allows the child classes to synchronize the parent's uproperties at any time.
-     */
-    virtual void SyncUProperties() override;
-
 public:
     /**
      * Retrieve this glove's hardware model, which contains its hardware data.

Source/SenseGloveCore/Public/SGCore/SGSenseGloveInfo.h

@@ -41,8 +41,8 @@
 #include "UObject/Object.h"
 #include "UObject/ObjectMacros.h"
 
-#include "SGCore/SGVectorArray.h"
 #include "SGTypes/SGCoreTypes.h"
+#include "SGTypes/SGVectorArray.h"
 
 #include "SGSenseGloveInfo.generated.h"
 

Source/SenseGloveCore/Public/SGCore/SGSenseGlovePose.h

@@ -44,9 +44,9 @@
 #include "UObject/Object.h"
 #include "UObject/ObjectMacros.h"
 
-#include "SGCore/SGQuatArray.h"
-#include "SGCore/SGRotatorArray.h"
-#include "SGCore/SGVectorArray.h"
+#include "SGTypes/SGQuatArray.h"
+#include "SGTypes/SGRotatorArray.h"
+#include "SGTypes/SGVectorArray.h"
 
 #include "SGSenseGlovePose.generated.h"
 

Source/SenseGloveCore/Public/SGCore/SGSenseGloveSensorData.h

@@ -42,8 +42,8 @@
 #include "UObject/Object.h"
 #include "UObject/ObjectMacros.h"
 
-#include "SGCore/SGFloatArray.h"
 #include "SGCore/SGSenseGloveInfo.h"
+#include "SGTypes/SGFloatArray.h"
 
 #include "SGSenseGloveSensorData.generated.h"
 
@@ -178,7 +178,7 @@ public:
 
 public:
     /**
-     * Glove angles in radians, sorted by finger, from proximal to distal.
+     * Glove angles in degrees, sorted by finger, from proximal to distal.
      */
     TArray<TArray<float>> GetSensorAngles() const;
 

Source/SenseGloveCore/Public/SGCore/SGTimedBuzzCommand.h

@@ -37,7 +37,6 @@
 
 #include "HAL/Platform.h"
 #include "Templates/SharedPointer.h"
-#include "Templates/UniquePtr.h"
 #include "UObject/ObjectMacros.h"
 
 #include "SGTimedBuzzCommand.generated.h"
@@ -82,17 +81,6 @@ public:
         UObject* Outer,
         const USGBuzzCommand* BaseCommand, float DurationSeconds, float StartTimeSeconds = 0.0f);
 
-private:
-    struct FImpl;
-
-    struct FImplDeleter
-    {
-        void operator()(const FImpl* P) const;
-    };
-
-    TUniquePtr<FImpl, FImplDeleter> Pimpl;
-    FImplDeleter PimplDeleter;
-
 public:
     /**
      * Empty constructor for inheritance.
@@ -133,17 +121,6 @@ public:
      */
     TSharedRef<FSGTimedBuzzCommandImpl> ToTimedBuzzCommandImpl() const;
 
-protected:
-    /**
-     * Allows the child classes to synchronize the parent's underlying object at any time.
-     */
-    virtual void SyncImplObject() const override;
-
-    /**
-     * Allows the child classes to synchronize the parent's uproperties at any time.
-     */
-    virtual void SyncUProperties() override;
-
 public:
     /**
      * Copy this Buzz Command's values into a new object.
@@ -161,11 +138,6 @@ public:
      */
     USGBuzzCommand* GetBaseCommand(UObject* Outer) const;
 
-    /**
-     *
-     */
-    int32 GetMagnitude() const;
-
     /**
      * The total time [milliseconds] each buzz motor should be vibrating for.
      */

Source/SenseGloveCore/Public/SGCore/SGTimedThumpCommand.h

@@ -132,31 +132,16 @@ public:
      */
     int32 GetMagnitude() const;
 
-    /**
-     *
-     */
-    void SetMagnitude(int32 Magnitude);
-
     /**
      * Duration in seconds.
      */
     float GetDuration() const;
 
-    /**
-     *
-     */
-    void SetDuration(float Duration);
-
     /**
      * The elapsed time so far.
      */
     float GetElapsedTime() const;
 
-    /**
-     *
-     */
-    void SetElapsedTime(float ElapsedTime);
-
 public:
     /**
      * Returns true if the timed command has elapsed.

Source/SenseGloveCore/SenseGloveCore.Build.cs

@@ -62,5 +62,12 @@ public class SenseGloveCore : ModuleRules
                 "SenseGloveUtils",
             }
         );
+
+        PrivateIncludePathModuleNames.AddRange(
+            new string[]
+            {
+                "SenseGloveCoreTypes",
+            }
+        );
     }
 }

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGAnatomyImpl.cpp

@@ -38,8 +38,8 @@
 #include "SGBuildHacks/SGInclude_Core_Anatomy.h"
 #include "SGBuildHacks/SGInclude_Core_Vect3D.h"
 #include "SGCoreImpl/SGVect3DImpl.h"
+#include "SGUtils/SGAngles.h"
 #include "SGUtils/SGArrayUtils.h"
-#include "SGUtils/SGCoordinates.h"
 
 float FSGAnatomyImpl::GetTotalFingerFlexion()
 {
@@ -64,25 +64,31 @@ float FSGAnatomyImpl::GetTotalThumbExtension()
 float FSGAnatomyImpl::GetFingerJointLimit(
     const bool bRightHanded, const int32 Joint, const int32 Movement, const bool bMax)
 {
-    return FSGCoordinates::TransformToUnreal(
+    return FSGAngles::TransformToUnreal(
         Movement, FAnatomyType::GetFingerJointLimit(bRightHanded, Joint, Movement, bMax));
 }
 
 float FSGAnatomyImpl::GetThumbJointLimit(
     const bool bRightHanded, const int32 Joint, const int32 Movement, const bool bMax)
 {
-    return FSGCoordinates::TransformToUnreal(
+    return FSGAngles::TransformToUnreal(
         Movement, FAnatomyType::GetThumbJointLimit(bRightHanded, Joint, Movement, bMax));
 }
 
-float FSGAnatomyImpl::NormalizeFingerFlexion(const float FlexionInRadians)
+float FSGAnatomyImpl::NormalizeFingerFlexion(const float FlexionInDegrees)
 {
-    return FAnatomyType::NormalizeFingerFlexion(FlexionInRadians);
+    return FSGAngles::TransformToUnreal(
+        FAnatomyType::NormalizeFingerFlexion(
+            FSGAngles::TransformToSenseGlove(
+                FlexionInDegrees)));
 }
 
-float FSGAnatomyImpl::NormalizeThumbFlexion(const float FlexionInRadians)
+float FSGAnatomyImpl::NormalizeThumbFlexion(const float FlexionInDegrees)
 {
-    return FAnatomyType::NormalizeThumbFlexion(FlexionInRadians);
+    return FSGAngles::TransformToUnreal(
+        FAnatomyType::NormalizeThumbFlexion(
+            FSGAngles::TransformToSenseGlove(
+                FlexionInDegrees)));
 }
 
 TArray<TArray<FVector>> FSGAnatomyImpl::GetDefaultHandAngles(const bool bRightHanded)

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGBasicHandModelImpl.cpp

@@ -118,23 +118,13 @@ const TArray<FVector>& FSGBasicHandModelImpl::GetBaseJointAngles()
 }
 
 FSGBasicHandModelImpl::FSGBasicHandModelImpl()
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
 }
 
 FSGBasicHandModelImpl::FSGBasicHandModelImpl(const bool bRightHanded, const TArray<TArray<float>>& Lengths,
                                              const TArray<FVector>& StartPositions)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     std::vector<std::vector<float>> LengthsVector{
         FSGArrayUtils::ToMillimeters(Lengths)
@@ -150,12 +140,7 @@ FSGBasicHandModelImpl::FSGBasicHandModelImpl(const bool bRightHanded, const TArr
 
 FSGBasicHandModelImpl::FSGBasicHandModelImpl(const bool bRightHanded, const TArray<TArray<float>>& Lengths,
                                              const TArray<FVector>& StartPositions, const TArray<FQuat>& StartRotations)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     std::vector<std::vector<float>> LengthsVector{
         FSGArrayUtils::ToMillimeters(Lengths)
@@ -175,32 +160,18 @@ FSGBasicHandModelImpl::FSGBasicHandModelImpl(const bool bRightHanded, const TArr
 }
 
 FSGBasicHandModelImpl::FSGBasicHandModelImpl(const FBasicHandModelType& BasicHandModel)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     Pimpl->BasicHandModel = BasicHandModel;
 }
 
 FSGBasicHandModelImpl::FSGBasicHandModelImpl(const FSGBasicHandModelImpl& Rhs)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
 {
     Pimpl->Owner = this;
 }
 
-FSGBasicHandModelImpl::FSGBasicHandModelImpl(FSGBasicHandModelImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
-    = default;
+FSGBasicHandModelImpl::FSGBasicHandModelImpl(FSGBasicHandModelImpl&& Rhs) SG_NOEXCEPT = default;
 
 FSGBasicHandModelImpl::~FSGBasicHandModelImpl() = default;
 
@@ -211,11 +182,7 @@ FSGBasicHandModelImpl& FSGBasicHandModelImpl::operator=(const FSGBasicHandModelI
     return *this;
 }
 
-FSGBasicHandModelImpl& FSGBasicHandModelImpl::operator=(FSGBasicHandModelImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
-    = default;
+FSGBasicHandModelImpl& FSGBasicHandModelImpl::operator=(FSGBasicHandModelImpl&& Rhs) SG_NOEXCEPT = default;
 
 const FSGBasicHandModelImpl::FBasicHandModelType& FSGBasicHandModelImpl::ToBasicHandModel() const
 {
@@ -227,11 +194,6 @@ bool FSGBasicHandModelImpl::IsRight() const
     return Pimpl->BasicHandModel.IsRight();
 }
 
-void FSGBasicHandModelImpl::SetIsRight(const bool bRightHanded)
-{
-    Pimpl->BasicHandModel.SetIsRight(bRightHanded);
-}
-
 TArray<TArray<float>> FSGBasicHandModelImpl::GetFingerLengths() const
 {
     TArray<TArray<float>> FingerLengths{
@@ -240,14 +202,6 @@ TArray<TArray<float>> FSGBasicHandModelImpl::GetFingerLengths() const
     return MoveTemp(FingerLengths);
 }
 
-void FSGBasicHandModelImpl::SetFingerLengths(const TArray<TArray<float>>& FingerLengths)
-{
-    std::vector<std::vector<float>> FingerLengthsVector{
-        FSGArrayUtils::ToMillimeters(FingerLengths)
-    };
-    Pimpl->BasicHandModel.SetFingerLengths(MoveTemp(FingerLengthsVector));
-}
-
 TArray<float> FSGBasicHandModelImpl::GetFingerLengths(const ESGFinger Finger) const
 {
     TArray<float> FingerLengths{
@@ -297,14 +251,6 @@ TArray<FVector> FSGBasicHandModelImpl::GetStartJointPositions() const
     return MoveTemp(StartJointPositions);
 }
 
-void FSGBasicHandModelImpl::SetStartJointPositions(const TArray<FVector>& StartJointPositions)
-{
-    std::vector<FSGVect3DImpl::FVect3DType> StartJointPositionsVector{
-        FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(StartJointPositions)
-    };
-    Pimpl->BasicHandModel.SetStartJointPositions(MoveTemp(StartJointPositionsVector));
-}
-
 void FSGBasicHandModelImpl::SetStartJointPosition(const ESGFinger Finger, const FVector& Position)
 {
     Pimpl->BasicHandModel.SetStartJointPosition(
@@ -329,15 +275,6 @@ TArray<FQuat> FSGBasicHandModelImpl::GetStartJointRotations() const
     return MoveTemp(StartJointRotations);
 }
 
-void FSGBasicHandModelImpl::SetStartJointRotations(const TArray<FQuat>& StartJointRotations)
-{
-    std::vector<FSGQuatImpl::FQuatType> StartJointRotationsVector{
-        FSGArrayUtils::ToStdVector<
-            FQuat, FSGQuatImpl::FQuatType, FSGQuatImpl, &FSGQuatImpl::ToQuat>(StartJointRotations)
-    };
-    Pimpl->BasicHandModel.SetStartJointRotations(MoveTemp(StartJointRotationsVector));
-}
-
 FVector FSGBasicHandModelImpl::GetJointPosition(const ESGFinger Finger) const
 {
     return FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGBetaDeviceImpl.cpp

@@ -77,11 +77,7 @@ TSharedRef<FSGBetaDeviceImpl> FSGBetaDeviceImpl::Parse(const FString& String)
 
 FSGBetaDeviceImpl::FSGBetaDeviceImpl()
     : FSGDeviceImpl(),
-#if SG_CPP17
       Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
 {
 }
 
@@ -93,50 +89,30 @@ FSGBetaDeviceImpl::FSGBetaDeviceImpl(const FString& ConstantsString, const FStri
           TCHAR_TO_UTF8(*HardwareVersion),
           FirmwareVersion,
           SubFirmwareVersion)),
-#if SG_CPP17
       Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
 {
 }
 
 FSGBetaDeviceImpl::FSGBetaDeviceImpl(const FBetaDeviceType BetaDevice)
     : FSGDeviceImpl(std::make_shared<FBetaDeviceType>(BetaDevice)),
-#if SG_CPP17
       Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
 {
 }
 
 FSGBetaDeviceImpl::FSGBetaDeviceImpl(const FBetaDevicePtrType BetaDevice)
     : FSGDeviceImpl(BetaDevice),
-#if SG_CPP17
       Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
 {
 }
 
 FSGBetaDeviceImpl::FSGBetaDeviceImpl(const FSGBetaDeviceImpl& Rhs)
     : FSGDeviceImpl(Rhs),
-#if SG_CPP17
       Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}))
-#endif  /* SG_CPP17 */
 {
     Pimpl->Owner = this;
 }
 
-FSGBetaDeviceImpl::FSGBetaDeviceImpl(FSGBetaDeviceImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
-    = default;
+FSGBetaDeviceImpl::FSGBetaDeviceImpl(FSGBetaDeviceImpl&& Rhs) SG_NOEXCEPT = default;
 
 FSGBetaDeviceImpl::~FSGBetaDeviceImpl() = default;
 
@@ -148,11 +124,7 @@ FSGBetaDeviceImpl& FSGBetaDeviceImpl::operator=(const FSGBetaDeviceImpl& Rhs)
     return *this;
 }
 
-FSGBetaDeviceImpl& FSGBetaDeviceImpl::operator=(FSGBetaDeviceImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
-    = default;
+FSGBetaDeviceImpl& FSGBetaDeviceImpl::operator=(FSGBetaDeviceImpl&& Rhs) SG_NOEXCEPT = default;
 
 FSGBetaDeviceImpl::FBetaDeviceType FSGBetaDeviceImpl::ToBetaDevice() const
 {

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGBuzzCommandImpl.cpp

@@ -75,81 +75,49 @@ const FSGBuzzCommandImpl& FSGBuzzCommandImpl::Off()
 
 FSGBuzzCommandImpl::FSGBuzzCommandImpl()
     : FSGFingerCommandImpl(MakeShared<FBuzzCommandType>()),
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
 }
 
 FSGBuzzCommandImpl::FSGBuzzCommandImpl(const TArray<int32>& BuzzLevels)
     : FSGFingerCommandImpl(MakeShared<FBuzzCommandType>(FSGArrayUtils::ToStdVector<int32>(BuzzLevels))),
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
 }
 
 FSGBuzzCommandImpl::FSGBuzzCommandImpl(const int32 Thumb, const int32 Index, const int32 Middle, const int32 Ring,
                                        const int32 Pinky)
     : FSGFingerCommandImpl(MakeShared<FBuzzCommandType>(Thumb, Index, Middle, Ring, Pinky)),
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
 }
 
 FSGBuzzCommandImpl::FSGBuzzCommandImpl(const ESGFinger Finger, const int32 BuzzLevel)
     : FSGFingerCommandImpl(MakeShared<FBuzzCommandType>(FSGCoreEnumCast::ToEFinger(Finger), BuzzLevel)),
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
 }
 
 FSGBuzzCommandImpl::FSGBuzzCommandImpl(const FBuzzCommandType& BuzzCommand)
     : FSGFingerCommandImpl(MakeShared<FBuzzCommandType>(BuzzCommand)),
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
 }
 
 FSGBuzzCommandImpl::FSGBuzzCommandImpl(const TSharedRef<FBuzzCommandType> BuzzCommand)
     : FSGFingerCommandImpl(BuzzCommand),
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
 }
 
 FSGBuzzCommandImpl::FSGBuzzCommandImpl(const FSGBuzzCommandImpl& Rhs)
     : FSGFingerCommandImpl(Rhs),
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}))
-#endif  /* SG_CPP17 */
+      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
 {
     Pimpl->Owner = this;
 }
 
-FSGBuzzCommandImpl::FSGBuzzCommandImpl(FSGBuzzCommandImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
-    = default;
+FSGBuzzCommandImpl::FSGBuzzCommandImpl(FSGBuzzCommandImpl&& Rhs) SG_NOEXCEPT = default;
 
 FSGBuzzCommandImpl::~FSGBuzzCommandImpl() = default;
 
@@ -161,11 +129,7 @@ FSGBuzzCommandImpl& FSGBuzzCommandImpl::operator=(const FSGBuzzCommandImpl& Rhs)
     return *this;
 }
 
-FSGBuzzCommandImpl& FSGBuzzCommandImpl::operator=(FSGBuzzCommandImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
-    = default;
+FSGBuzzCommandImpl& FSGBuzzCommandImpl::operator=(FSGBuzzCommandImpl&& Rhs) SG_NOEXCEPT = default;
 
 const FSGBuzzCommandImpl::FBuzzCommandType& FSGBuzzCommandImpl::ToBuzzCommand() const
 {

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGCalibrationDataPointImpl.cpp

@@ -76,23 +76,13 @@ struct FSGCalibrationDataPointImpl::FImpl
 };
 
 FSGCalibrationDataPointImpl::FSGCalibrationDataPointImpl()
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
 }
 
 FSGCalibrationDataPointImpl::FSGCalibrationDataPointImpl(const int32 CurrentStage,
                                                          const TArray<FVector>& CalibrationValues)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     std::vector<FSGVect3DImpl::FVect3DType> Values(
         FSGArrayUtils::ToStdVector<FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(
@@ -101,32 +91,18 @@ FSGCalibrationDataPointImpl::FSGCalibrationDataPointImpl(const int32 CurrentStag
 }
 
 FSGCalibrationDataPointImpl::FSGCalibrationDataPointImpl(const FCalibrationDataPointType& CalibrationDataPoint)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     Pimpl->CalibrationDataPoint = CalibrationDataPoint;
 }
 
 FSGCalibrationDataPointImpl::FSGCalibrationDataPointImpl(const FSGCalibrationDataPointImpl& Rhs)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
 {
     Pimpl->Owner = this;
 }
 
-FSGCalibrationDataPointImpl::FSGCalibrationDataPointImpl(FSGCalibrationDataPointImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
-    = default;
+FSGCalibrationDataPointImpl::FSGCalibrationDataPointImpl(FSGCalibrationDataPointImpl&& Rhs) SG_NOEXCEPT = default;
 
 FSGCalibrationDataPointImpl::~FSGCalibrationDataPointImpl() = default;
 
@@ -137,10 +113,7 @@ FSGCalibrationDataPointImpl& FSGCalibrationDataPointImpl::operator=(const FSGCal
     return *this;
 }
 
-FSGCalibrationDataPointImpl& FSGCalibrationDataPointImpl::operator=(FSGCalibrationDataPointImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
+FSGCalibrationDataPointImpl& FSGCalibrationDataPointImpl::operator=(FSGCalibrationDataPointImpl&& Rhs) SG_NOEXCEPT
 = default;
 
 const FSGCalibrationDataPointImpl::FCalibrationDataPointType&
@@ -159,25 +132,11 @@ TArray<FVector> FSGCalibrationDataPointImpl::GetCalibrationValues() const
     return CalibrationValues;
 }
 
-void FSGCalibrationDataPointImpl::SetCalibrationValues(const TArray<FVector>& CalibrationValues)
-{
-    std::vector<FSGVect3DImpl::FVect3DType> CalibrationValuesVector{
-        FSGArrayUtils::ToStdVector<FVector, FSGVect3DImpl::FVect3DType, FSGVect3DImpl, &FSGVect3DImpl::ToVect3D>(
-            CalibrationValues)
-    };
-    Pimpl->CalibrationDataPoint.SetCalibrationValues(MoveTemp(CalibrationValuesVector));
-}
-
 int32 FSGCalibrationDataPointImpl::GetStage() const
 {
     return Pimpl->CalibrationDataPoint.GetStage();
 }
 
-void FSGCalibrationDataPointImpl::SetStage(const int32 Stage)
-{
-    Pimpl->CalibrationDataPoint.SetStage(Stage);
-}
-
 FString FSGCalibrationDataPointImpl::ToLogData(const FString& Delimiter) const
 {
     std::string DelimiterString(TCHAR_TO_UTF8(*Delimiter));

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGDeviceImpl.cpp

@@ -89,43 +89,24 @@ FString FSGDeviceImpl::ToString(ESGDeviceType DeviceType)
 }
 
 FSGDeviceImpl::FSGDeviceImpl()
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
 }
 
 FSGDeviceImpl::FSGDeviceImpl(const FSGDevicePtrType SGDevice)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     ensureAlwaysMsgf(SGDevice.get(), TEXT("Invalid SGDevice!"));
     Pimpl->SGDevice = SGDevice;
 }
 
 FSGDeviceImpl::FSGDeviceImpl(const FSGDeviceImpl& Rhs)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
 {
     Pimpl->Owner = this;
 }
 
-FSGDeviceImpl::FSGDeviceImpl(FSGDeviceImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
-    = default;
+FSGDeviceImpl::FSGDeviceImpl(FSGDeviceImpl&& Rhs) SG_NOEXCEPT = default;
 
 FSGDeviceImpl::~FSGDeviceImpl() = default;
 
@@ -136,11 +117,7 @@ FSGDeviceImpl& FSGDeviceImpl::operator=(const FSGDeviceImpl& Rhs)
     return *this;
 }
 
-FSGDeviceImpl& FSGDeviceImpl::operator=(FSGDeviceImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
-    = default;
+FSGDeviceImpl& FSGDeviceImpl::operator=(FSGDeviceImpl&& Rhs) SG_NOEXCEPT = default;
 
 FSGDeviceImpl::FSGDevicePtrType FSGDeviceImpl::ToSGDevicePtr() const
 {

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGDeviceModelImpl.cpp

@@ -96,23 +96,13 @@ void FSGDeviceModelImpl::ParseFirmware(const FString& RawFirmware, int32& OutMai
 }
 
 FSGDeviceModelImpl::FSGDeviceModelImpl()
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
 }
 
 FSGDeviceModelImpl::FSGDeviceModelImpl(
     const FString& Id, const FString& HardwareVersion, const int32 FirmwareVersion, const int32 SubFirmwareVersion)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     std::string IdString(TCHAR_TO_UTF8(*Id));
     std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
@@ -121,32 +111,18 @@ FSGDeviceModelImpl::FSGDeviceModelImpl(
 }
 
 FSGDeviceModelImpl::FSGDeviceModelImpl(const FDeviceModelType& DeviceModel)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     Pimpl->DeviceModel = DeviceModel;
 }
 
 FSGDeviceModelImpl::FSGDeviceModelImpl(const FSGDeviceModelImpl& Rhs)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
 {
     Pimpl->Owner = this;
 }
 
-FSGDeviceModelImpl::FSGDeviceModelImpl(FSGDeviceModelImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
-    = default;
+FSGDeviceModelImpl::FSGDeviceModelImpl(FSGDeviceModelImpl&& Rhs) SG_NOEXCEPT = default;
 
 FSGDeviceModelImpl::~FSGDeviceModelImpl() = default;
 
@@ -157,11 +133,7 @@ FSGDeviceModelImpl& FSGDeviceModelImpl::operator=(const FSGDeviceModelImpl& Rhs)
     return *this;
 }
 
-FSGDeviceModelImpl& FSGDeviceModelImpl::operator=(FSGDeviceModelImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
-    = default;
+FSGDeviceModelImpl& FSGDeviceModelImpl::operator=(FSGDeviceModelImpl&& Rhs) SG_NOEXCEPT = default;
 
 const FSGDeviceModelImpl::FDeviceModelType& FSGDeviceModelImpl::ToDeviceModel() const
 {
@@ -174,42 +146,22 @@ FString FSGDeviceModelImpl::GetDeviceId() const
     return MoveTemp(DeviceId);
 }
 
-void FSGDeviceModelImpl::SetDeviceId(const FString& Id) const
-{
-    Pimpl->DeviceModel.SetDeviceId(TCHAR_TO_UTF8(*Id));
-}
-
 FString FSGDeviceModelImpl::GetHardwareVersion() const
 {
     FString HardwareVersion(UTF8_TO_TCHAR(Pimpl->DeviceModel.GetHardwareVersion().c_str()));
     return MoveTemp(HardwareVersion);
 }
 
-void FSGDeviceModelImpl::SetHardwareVersion(const FString& Version) const
-{
-    Pimpl->DeviceModel.SetHardwareVersion(TCHAR_TO_UTF8(*Version));
-}
-
 int32 FSGDeviceModelImpl::GetFirmwareVersion() const
 {
     return Pimpl->DeviceModel.GetFirmwareVersion();
 }
 
-void FSGDeviceModelImpl::SetFirmwareVersion(const int32 Version) const
-{
-    Pimpl->DeviceModel.SetFirmwareVersion(Version);
-}
-
 int32 FSGDeviceModelImpl::GetSubFirmwareVersion() const
 {
     return Pimpl->DeviceModel.GetSubFirmwareVersion();
 }
 
-void FSGDeviceModelImpl::SetSubFirmwareVersion(const int32 Version) const
-{
-    Pimpl->DeviceModel.SetSubFirmwareVersion(Version);
-}
-
 FSGDeviceModelImpl::FImpl::FImpl(FSGDeviceModelImpl* InOwner)
     : Owner(InOwner)
 {

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGFingerCommandImpl.cpp

@@ -83,22 +83,12 @@ struct FSGFingerCommandImpl::FImpl
 };
 
 FSGFingerCommandImpl::FSGFingerCommandImpl()
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
 }
 
 FSGFingerCommandImpl::FSGFingerCommandImpl(const TArray<int32>& Levels)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     std::vector<int32> LevelsVector{
         FSGArrayUtils::ToStdVector<int32>(Levels)
@@ -107,44 +97,25 @@ FSGFingerCommandImpl::FSGFingerCommandImpl(const TArray<int32>& Levels)
 }
 
 FSGFingerCommandImpl::FSGFingerCommandImpl(const FFingerCommandType& FingerCommand)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     Pimpl->FingerCommand = MakeShared<FFingerCommandType>(FingerCommand);
 }
 
 FSGFingerCommandImpl::FSGFingerCommandImpl(const TSharedRef<FFingerCommandType> FingerCommand)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     Pimpl->FingerCommand = FImpl::MakeNewFingerCommand(FingerCommand);
 }
 
 FSGFingerCommandImpl::FSGFingerCommandImpl(const FSGFingerCommandImpl& Rhs)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
 {
     Pimpl->Owner = this;
     Pimpl->FingerCommand = FImpl::MakeNewFingerCommand(Rhs.Pimpl->FingerCommand);
 }
 
-FSGFingerCommandImpl::FSGFingerCommandImpl(FSGFingerCommandImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
-    = default;
+FSGFingerCommandImpl::FSGFingerCommandImpl(FSGFingerCommandImpl&& Rhs) SG_NOEXCEPT = default;
 
 FSGFingerCommandImpl::~FSGFingerCommandImpl() = default;
 
@@ -155,11 +126,7 @@ FSGFingerCommandImpl& FSGFingerCommandImpl::operator=(const FSGFingerCommandImpl
     return *this;
 }
 
-FSGFingerCommandImpl& FSGFingerCommandImpl::operator=(FSGFingerCommandImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
-    = default;
+FSGFingerCommandImpl& FSGFingerCommandImpl::operator=(FSGFingerCommandImpl&& Rhs) SG_NOEXCEPT = default;
 
 const FSGFingerCommandImpl::FFingerCommandType& FSGFingerCommandImpl::ToFingerCommand() const
 {
@@ -213,12 +180,6 @@ TArray<int32> FSGFingerCommandImpl::GetLevels() const
     return FSGArrayUtils::FromStdVector<int32>(Pimpl->FingerCommand->GetLevels());
 }
 
-void FSGFingerCommandImpl::SetLevels(const TArray<int32>& Levels)
-{
-    std::vector<int32> LevelsVector{FSGArrayUtils::ToStdVector<int32>(Levels)};
-    Pimpl->FingerCommand->SetLevels(MoveTemp(LevelsVector));
-}
-
 int32 FSGFingerCommandImpl::GetLevel(const int32 Finger) const
 {
     return Pimpl->FingerCommand->GetLevel(Finger);

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGForceFeedbackCommandImpl.cpp

@@ -75,82 +75,51 @@ const FSGForceFeedbackCommandImpl& FSGForceFeedbackCommandImpl::Off()
 
 FSGForceFeedbackCommandImpl::FSGForceFeedbackCommandImpl()
     : FSGFingerCommandImpl(MakeShared<FForceFeedbackCommandType>()),
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
 }
 
 FSGForceFeedbackCommandImpl::FSGForceFeedbackCommandImpl(const TArray<int32>& ForceFeedbackLevels)
     : FSGFingerCommandImpl(MakeShared<FForceFeedbackCommandType>(
-        FSGArrayUtils::ToStdVector<int32>(ForceFeedbackLevels))),
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+          FSGArrayUtils::ToStdVector<int32>(ForceFeedbackLevels))),
+      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
 }
 
 FSGForceFeedbackCommandImpl::FSGForceFeedbackCommandImpl(const int32 Thumb, const int32 Index, const int32 Middle,
                                                          const int32 Ring, const int32 Pinky)
     : FSGFingerCommandImpl(MakeShared<FForceFeedbackCommandType>(Thumb, Index, Middle, Ring, Pinky)),
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
 }
 
 FSGForceFeedbackCommandImpl::FSGForceFeedbackCommandImpl(const ESGFinger Finger, const int32 BuzzLevel)
     : FSGFingerCommandImpl(MakeShared<FForceFeedbackCommandType>(FSGCoreEnumCast::ToEFinger(Finger), BuzzLevel)),
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
 }
 
 FSGForceFeedbackCommandImpl::FSGForceFeedbackCommandImpl(const FForceFeedbackCommandType& ForceFeedbackCommand)
     : FSGFingerCommandImpl(MakeShared<FForceFeedbackCommandType>(ForceFeedbackCommand)),
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
 }
 
-FSGForceFeedbackCommandImpl::FSGForceFeedbackCommandImpl(const TSharedRef<FForceFeedbackCommandType> ForceFeedbackCommand)
+FSGForceFeedbackCommandImpl::FSGForceFeedbackCommandImpl(
+    const TSharedRef<FForceFeedbackCommandType> ForceFeedbackCommand)
     : FSGFingerCommandImpl(ForceFeedbackCommand),
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
 }
 
 FSGForceFeedbackCommandImpl::FSGForceFeedbackCommandImpl(const FSGForceFeedbackCommandImpl& Rhs)
     : FSGFingerCommandImpl(Rhs),
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}))
-#endif  /* SG_CPP17 */
+      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
 {
     Pimpl->Owner = this;
 }
 
-FSGForceFeedbackCommandImpl::FSGForceFeedbackCommandImpl(FSGForceFeedbackCommandImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
-    = default;
+FSGForceFeedbackCommandImpl::FSGForceFeedbackCommandImpl(FSGForceFeedbackCommandImpl&& Rhs) SG_NOEXCEPT = default;
 
 FSGForceFeedbackCommandImpl::~FSGForceFeedbackCommandImpl() = default;
 
@@ -162,18 +131,17 @@ FSGForceFeedbackCommandImpl& FSGForceFeedbackCommandImpl::operator=(const FSGFor
     return *this;
 }
 
-FSGForceFeedbackCommandImpl& FSGForceFeedbackCommandImpl::operator=(FSGForceFeedbackCommandImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
+FSGForceFeedbackCommandImpl& FSGForceFeedbackCommandImpl::operator=(FSGForceFeedbackCommandImpl&& Rhs) SG_NOEXCEPT
 = default;
 
-const FSGForceFeedbackCommandImpl::FForceFeedbackCommandType& FSGForceFeedbackCommandImpl::ToForceFeedbackCommand() const
+const FSGForceFeedbackCommandImpl::FForceFeedbackCommandType&
+FSGForceFeedbackCommandImpl::ToForceFeedbackCommand() const
 {
     return *StaticCastSharedRef<FForceFeedbackCommandType>(ToFingerCommandRef());
 }
 
-TSharedRef<FSGForceFeedbackCommandImpl::FForceFeedbackCommandType> FSGForceFeedbackCommandImpl::ToForceFeedbackCommandRef() const
+TSharedRef<FSGForceFeedbackCommandImpl::FForceFeedbackCommandType>
+FSGForceFeedbackCommandImpl::ToForceFeedbackCommandRef() const
 {
     return StaticCastSharedRef<FForceFeedbackCommandType>(ToFingerCommandRef());
 }

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGHandInterpolatorImpl.cpp

@@ -48,8 +48,8 @@
 #include "SGCoreImpl/SGInterpolationSetImpl.h"
 #include "SGCoreImpl/SGQuatImpl.h"
 #include "SGCoreImpl/SGVect3DImpl.h"
+#include "SGUtils/SGAngles.h"
 #include "SGUtils/SGArrayUtils.h"
-#include "SGUtils/SGCoordinates.h"
 
 struct FSGHandInterpolatorImpl::FImpl
 {
@@ -100,7 +100,7 @@ TArray<FVector> FSGHandInterpolatorImpl::InterpolateFingerAngles(
         FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
             FHandInterpolatorType::InterpolateFingerAngles(
                 FSGCoreEnumCast::ToEFinger(Finger), Interpolator.ToHandInterpolator(),
-                FSGCoordinates::TransformToSenseGlove<FSGVect3DImpl::FVect3DType>(TotalGloveAngles)))
+                FSGAngles::TransformToSenseGlove<FSGVect3DImpl::FVect3DType>(TotalGloveAngles)))
     };
     return MoveTemp(Angles);
 }
@@ -112,7 +112,7 @@ TArray<FVector> FSGHandInterpolatorImpl::InterpolateThumbAngles(const FSGHandInt
         FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
             FHandInterpolatorType::InterpolateThumbAngles(
                 Interpolator.ToHandInterpolator(),
-                FSGCoordinates::TransformToSenseGlove<FSGVect3DImpl::FVect3DType>(TotalGloveAngles)))
+                FSGAngles::TransformToSenseGlove<FSGVect3DImpl::FVect3DType>(TotalGloveAngles)))
     };
     return MoveTemp(Angles);
 }
@@ -132,22 +132,12 @@ TArray<TArray<FVector>> FSGHandInterpolatorImpl::InterpolateHandAngles(const FSG
 }
 
 FSGHandInterpolatorImpl::FSGHandInterpolatorImpl()
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
 }
 
 FSGHandInterpolatorImpl::FSGHandInterpolatorImpl(const TArray<TArray<FSGInterpolationSetImpl>>& JointInterpolations)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     std::vector<std::vector<FSGInterpolationSetImpl::FInterpolationSetType>> JointInterpolationsVector{
         FSGArrayUtils::ToStdVector<FSGInterpolationSetImpl, FSGInterpolationSetImpl::FInterpolationSetType,
@@ -158,12 +148,7 @@ FSGHandInterpolatorImpl::FSGHandInterpolatorImpl(const TArray<TArray<FSGInterpol
 
 FSGHandInterpolatorImpl::FSGHandInterpolatorImpl(const TArray<TArray<FSGInterpolationSetImpl>>& JointInterpolations,
                                                  const FQuat& CmcStartRotation)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     std::vector<std::vector<FSGInterpolationSetImpl::FInterpolationSetType>> JointInterpolationsVector{
         FSGArrayUtils::ToStdVector<FSGInterpolationSetImpl, FSGInterpolationSetImpl::FInterpolationSetType,
@@ -174,32 +159,18 @@ FSGHandInterpolatorImpl::FSGHandInterpolatorImpl(const TArray<TArray<FSGInterpol
 }
 
 FSGHandInterpolatorImpl::FSGHandInterpolatorImpl(const FHandInterpolatorType& HandInterpolator)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     Pimpl->HandInterpolator = HandInterpolator;
 }
 
 FSGHandInterpolatorImpl::FSGHandInterpolatorImpl(const FSGHandInterpolatorImpl& Rhs)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
 {
     Pimpl->Owner = this;
 }
 
-FSGHandInterpolatorImpl::FSGHandInterpolatorImpl(FSGHandInterpolatorImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
-    = default;
+FSGHandInterpolatorImpl::FSGHandInterpolatorImpl(FSGHandInterpolatorImpl&& Rhs) SG_NOEXCEPT = default;
 
 FSGHandInterpolatorImpl::~FSGHandInterpolatorImpl() = default;
 
@@ -210,11 +181,7 @@ FSGHandInterpolatorImpl& FSGHandInterpolatorImpl::operator=(const FSGHandInterpo
     return *this;
 }
 
-FSGHandInterpolatorImpl& FSGHandInterpolatorImpl::operator=(FSGHandInterpolatorImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
-= default;
+FSGHandInterpolatorImpl& FSGHandInterpolatorImpl::operator=(FSGHandInterpolatorImpl&& Rhs) SG_NOEXCEPT = default;
 
 const FSGHandInterpolatorImpl::FHandInterpolatorType& FSGHandInterpolatorImpl::ToHandInterpolator(
     ) const
@@ -231,33 +198,21 @@ TArray<TArray<FSGInterpolationSetImpl>> FSGHandInterpolatorImpl::GetJointInterpo
     return JointInterpolations;
 }
 
-void FSGHandInterpolatorImpl::SetJointInterpolations(const TArray<TArray<FSGInterpolationSetImpl>>& JointInterpolations)
-{
-    Pimpl->HandInterpolator.SetJointInterpolations(
-        FSGArrayUtils::ToStdVector<FSGInterpolationSetImpl, FSGInterpolationSetImpl::FInterpolationSetType,
-                                   &FSGInterpolationSetImpl::ToInterpolationSet>(JointInterpolations));
-}
-
 FQuat FSGHandInterpolatorImpl::GetCmcStartRotation() const
 {
     return FSGQuatImpl(Pimpl->HandInterpolator.GetCmcStartRotation()).ToFQuat();
 }
 
-void FSGHandInterpolatorImpl::SetCmcStartRotation(const FQuat& CmcStartRotation)
-{
-    Pimpl->HandInterpolator.SetCmcStartRotation(FSGQuatImpl(CmcStartRotation).ToQuat());
-}
-
 float FSGHandInterpolatorImpl::CalculateAngle(const ESGFinger Finger, const int32 Movement, const float Value) const
 {
-    return FSGCoordinates::TransformToUnreal(
+    return FSGAngles::TransformToUnreal(
         Movement, Pimpl->HandInterpolator.CalculateAngle(FSGCoreEnumCast::ToEFinger(Finger), Movement, Value));
 }
 
 float FSGHandInterpolatorImpl::CalculateAngle(const ESGFinger Finger, const ESGFingerMovement Movement,
                                               const float Value) const
 {
-    return FSGCoordinates::TransformToUnreal(
+    return FSGAngles::TransformToUnreal(
         Movement, Pimpl->HandInterpolator.CalculateAngle(FSGCoreEnumCast::ToEFinger(Finger),
                                                          FSGCoreEnumCast::ToEFingerMovement(Movement), Value));
 }
@@ -265,7 +220,7 @@ float FSGHandInterpolatorImpl::CalculateAngle(const ESGFinger Finger, const ESGF
 float FSGHandInterpolatorImpl::CalculateAngle(const ESGFinger Finger, const ESGThumbMovement Movement,
                                               const float Value) const
 {
-    return FSGCoordinates::TransformToUnreal(
+    return FSGAngles::TransformToUnreal(
         Movement, Pimpl->HandInterpolator.CalculateAngle(FSGCoreEnumCast::ToEFinger(Finger),
                                                          FSGCoreEnumCast::ToEThumbMovement(Movement), Value));
 }
@@ -275,8 +230,8 @@ void FSGHandInterpolatorImpl::SetInterpolation(
     const float InputAt0, const float InputAt1, const float AngleAt0, const float AngleAt1)
 {
     Pimpl->HandInterpolator.SetInterpolation(Finger, Movement, InputAt0, InputAt1,
-                                             FSGCoordinates::TransformToUnreal(Movement, AngleAt0),
-                                             FSGCoordinates::TransformToUnreal(Movement, AngleAt1));
+                                             FSGAngles::TransformToUnreal(Movement, AngleAt0),
+                                             FSGAngles::TransformToUnreal(Movement, AngleAt1));
 }
 
 void FSGHandInterpolatorImpl::SetInterpolation(
@@ -286,8 +241,8 @@ void FSGHandInterpolatorImpl::SetInterpolation(
     Pimpl->HandInterpolator.SetInterpolation(
         FSGCoreEnumCast::ToEFinger(Finger), FSGCoreEnumCast::ToEFingerMovement(Movement),
         InputAt0, InputAt1,
-        FSGCoordinates::TransformToUnreal(Movement, AngleAt0),
-        FSGCoordinates::TransformToUnreal(Movement, AngleAt1));
+        FSGAngles::TransformToUnreal(Movement, AngleAt0),
+        FSGAngles::TransformToUnreal(Movement, AngleAt1));
 }
 
 void FSGHandInterpolatorImpl::SetInterpolation(
@@ -296,8 +251,8 @@ void FSGHandInterpolatorImpl::SetInterpolation(
 {
     Pimpl->HandInterpolator.SetInterpolation(FSGCoreEnumCast::ToEThumbMovement(Movement),
                                              InputAt0, InputAt1,
-                                             FSGCoordinates::TransformToUnreal(Movement, AngleAt0),
-                                             FSGCoordinates::TransformToUnreal(Movement, AngleAt1));
+                                             FSGAngles::TransformToUnreal(Movement, AngleAt0),
+                                             FSGAngles::TransformToUnreal(Movement, AngleAt1));
 }
 
 FSGInterpolationSetImpl FSGHandInterpolatorImpl::GetInterpolation(const int32 Finger, const int32 Movement) const

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGHandPoseImpl.cpp

@@ -47,8 +47,8 @@
 #include "SGCoreImpl/SGCoreEnumCast.h"
 #include "SGCoreImpl/SGQuatImpl.h"
 #include "SGCoreImpl/SGVect3DImpl.h"
+#include "SGUtils/SGAngles.h"
 #include "SGUtils/SGArrayUtils.h"
-#include "SGUtils/SGCoordinates.h"
 
 struct FSGHandPoseImpl::FImpl
 {
@@ -145,23 +145,13 @@ FSGHandPoseImpl FSGHandPoseImpl::Fist(const bool bRightHanded)
 }
 
 FSGHandPoseImpl::FSGHandPoseImpl()
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
 }
 
 FSGHandPoseImpl::FSGHandPoseImpl(const bool bRightHanded, const TArray<TArray<FVector>>& JointPositions,
                                  const TArray<TArray<FQuat>>& JointRotations, const TArray<TArray<FVector>>& HandAngles)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     std::vector<std::vector<FSGVect3DImpl::FVect3DType>> JointPositionsVector{
         FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(JointPositions)
@@ -180,32 +170,18 @@ FSGHandPoseImpl::FSGHandPoseImpl(const bool bRightHanded, const TArray<TArray<FV
 }
 
 FSGHandPoseImpl::FSGHandPoseImpl(const FHandPoseType& SenseGloveHandPose)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     Pimpl->HandPose = SenseGloveHandPose;
 }
 
 FSGHandPoseImpl::FSGHandPoseImpl(const FSGHandPoseImpl& Rhs)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
 {
     Pimpl->Owner = this;
 }
 
-FSGHandPoseImpl::FSGHandPoseImpl(FSGHandPoseImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
-    = default;
+FSGHandPoseImpl::FSGHandPoseImpl(FSGHandPoseImpl&& Rhs) SG_NOEXCEPT = default;
 
 FSGHandPoseImpl::~FSGHandPoseImpl() = default;
 
@@ -216,11 +192,7 @@ FSGHandPoseImpl& FSGHandPoseImpl::operator=(const FSGHandPoseImpl& Rhs)
     return *this;
 }
 
-FSGHandPoseImpl& FSGHandPoseImpl::operator=(FSGHandPoseImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
-= default;
+FSGHandPoseImpl& FSGHandPoseImpl::operator=(FSGHandPoseImpl&& Rhs) SG_NOEXCEPT = default;
 
 const FSGHandPoseImpl::FHandPoseType& FSGHandPoseImpl::ToHandPose() const
 {
@@ -232,11 +204,6 @@ bool FSGHandPoseImpl::IsRight() const
     return Pimpl->HandPose.IsRight();
 }
 
-void FSGHandPoseImpl::SetIsRight(const bool bRightHanded) const
-{
-    Pimpl->HandPose.SetIsRight(bRightHanded);
-}
-
 TArray<TArray<FVector>> FSGHandPoseImpl::GetJointPositions() const
 {
     TArray<TArray<FVector>> JointPositions{
@@ -246,15 +213,6 @@ TArray<TArray<FVector>> FSGHandPoseImpl::GetJointPositions() const
     return MoveTemp(JointPositions);
 }
 
-void FSGHandPoseImpl::SetJointPositions(const TArray<TArray<FVector>>& JointPositions) const
-{
-    std::vector<std::vector<FSGVect3DImpl::FVect3DType>> JointPositionsVector{
-        FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
-            JointPositions)
-    };
-    Pimpl->HandPose.SetJointPositions(MoveTemp(JointPositionsVector));
-}
-
 TArray<TArray<FQuat>> FSGHandPoseImpl::GetJointRotations() const
 {
     TArray<TArray<FQuat>> JointRotations{
@@ -264,15 +222,6 @@ TArray<TArray<FQuat>> FSGHandPoseImpl::GetJointRotations() const
     return MoveTemp(JointRotations);
 }
 
-void FSGHandPoseImpl::SetJointRotations(const TArray<TArray<FQuat>>& JointRotations) const
-{
-    std::vector<std::vector<FSGQuatImpl::FQuatType>> JointRotationsVector{
-        FSGArrayUtils::ToStdVector<FQuat, FSGQuatImpl::FQuatType, FSGQuatImpl, &FSGQuatImpl::ToQuat>(
-            JointRotations)
-    };
-    Pimpl->HandPose.SetJointRotations(MoveTemp(JointRotationsVector));
-}
-
 TArray<TArray<FVector>> FSGHandPoseImpl::GetHandAngles() const
 {
     TArray<TArray<FVector>> HandAngles{
@@ -281,14 +230,6 @@ TArray<TArray<FVector>> FSGHandPoseImpl::GetHandAngles() const
     return MoveTemp(HandAngles);
 }
 
-void FSGHandPoseImpl::SetHandAngles(const TArray<TArray<FVector>>& HandAngles) const
-{
-    std::vector<std::vector<FSGVect3DImpl::FVect3DType>> HandAnglesVector{
-        FSGArrayUtils::ToSenseGloveAngles<FSGVect3DImpl::FVect3DType>(HandAngles)
-    };
-    Pimpl->HandPose.SetHandAngles(MoveTemp(HandAnglesVector));
-}
-
 bool FSGHandPoseImpl::Equals(const FSGHandPoseImpl& HandPoseImpl) const
 {
     return Pimpl->HandPose.Equals(HandPoseImpl.ToHandPose());

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGHandProfileImpl.cpp

@@ -141,56 +141,32 @@ void FSGHandProfileImpl::ResetCalibration(const bool bOnDisk)
 }
 
 FSGHandProfileImpl::FSGHandProfileImpl()
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
 }
 
 FSGHandProfileImpl::FSGHandProfileImpl(const bool bRightHanded,
                                        const FSGSenseGloveHandProfileImpl& SenseGloveHandProfile,
                                        const FSGNovaGloveHandProfileImpl& NovaGloveHandProfile)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     Pimpl->HandProfile = FHandProfileType(
         bRightHanded, SenseGloveHandProfile.ToSenseGloveHandProfile(), NovaGloveHandProfile.ToNovaGloveHandProfile());
 }
 
 FSGHandProfileImpl::FSGHandProfileImpl(const FHandProfileType& SenseGloveHandProfile)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
 {
     Pimpl->HandProfile = SenseGloveHandProfile;
 }
 
 FSGHandProfileImpl::FSGHandProfileImpl(const FSGHandProfileImpl& Rhs)
-    :
-#if SG_CPP17
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
-#else
-    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}))
-#endif  /* SG_CPP17 */
+    : Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{*Rhs.Pimpl}, PimplDeleter))
 {
     Pimpl->Owner = this;
 }
 
-FSGHandProfileImpl::FSGHandProfileImpl(FSGHandProfileImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
-    = default;
+FSGHandProfileImpl::FSGHandProfileImpl(FSGHandProfileImpl&& Rhs) SG_NOEXCEPT = default;
 
 FSGHandProfileImpl::~FSGHandProfileImpl() = default;
 
@@ -201,11 +177,7 @@ FSGHandProfileImpl& FSGHandProfileImpl::operator=(const FSGHandProfileImpl& Rhs)
     return *this;
 }
 
-FSGHandProfileImpl& FSGHandProfileImpl::operator=(FSGHandProfileImpl&& Rhs)
-#if SG_CPP17
-    noexcept
-#endif  /* SG_CPP17 */
-= default;
+FSGHandProfileImpl& FSGHandProfileImpl::operator=(FSGHandProfileImpl&& Rhs) SG_NOEXCEPT = default;
 
 const FSGHandProfileImpl::FHandProfileType& FSGHandProfileImpl::ToHandProfile(
     ) const
@@ -218,31 +190,16 @@ bool FSGHandProfileImpl::IsRight() const
     return Pimpl->HandProfile.IsRight();
 }
 
-void FSGHandProfileImpl::SetIsRight(const bool bRightHanded) const
-{
-    Pimpl->HandProfile.SetIsRight(bRightHanded);
-}
-
 FSGSenseGloveHandProfileImpl FSGHandProfileImpl::GetSenseGloveHandProfile() const
 {
     return FSGSenseGloveHandProfileImpl(Pimpl->HandProfile.GetSenseGloveHandProfile());
 }
 
-void FSGHandProfileImpl::SetSenseGloveHandProfile(const FSGSenseGloveHandProfileImpl& SenseGloveHandProfile)
-{
-    Pimpl->HandProfile.SetSenseGloveHandProfile(SenseGloveHandProfile.ToSenseGloveHandProfile());
-}
-
 FSGNovaGloveHandProfileImpl FSGHandProfileImpl::GetNovaGloveHandProfile() const
 {
     return FSGNovaGloveHandProfileImpl(Pimpl->HandProfile.GetNovaGloveHandProfile());
 }
 
-void FSGHandProfileImpl::SetNovaGloveHandProfile(const FSGNovaGloveHandProfileImpl& NovaGloveHandProfile)
-{
-    Pimpl->HandProfile.SetNovaGloveHandProfile(NovaGloveHandProfile.ToNovaGloveHandProfile());
-}
-
 bool FSGHandProfileImpl::Equals(const FSGHandProfileImpl& HandProfileImpl) const
 {
     return Pimpl->HandProfile.Equals(HandProfileImpl.ToHandProfile());