- List existing SenseGlove components under `SenseGlove``ClassGroup` inside Unreal's Blueprint Editor. This chagnes `ClassGroup` for `USGGrabComponent`, `USGTouchComponent`, `USGVirtualHandComponent`, and `USGWristTrackerComponent`.
- Bumped [mdBook](https://rust-lang.github.io/mdBook/) to `v0.5.2`
- Bumped the [Michael-F-Bryan/mdbook-epub](https://github.com/Michael-F-Bryan/mdbook-epub) crate to [`21a1c8134134201a2d555313447c96e56e2a8996`](https://github.com/Michael-F-Bryan/mdbook-epub/commit/21a1c8134134201a2d555313447c96e56e2a8996), which addresses issue [#133](https://github.com/Michael-F-Bryan/mdbook-epub/issues/133). This allowed upgrading mdBook from `0.4.49` to `v0.5.2` without breaking images inside the generated ePub version of the handbook.
- Bumped [HollowMan6/mdbook-pdf](https://github.com/HollowMan6/mdbook-pdf) to `v0.1.13`.
- Removed [lambdalisue/rs-mdbook-alerts](https://github.com/lambdalisue/rs-mdbook-alerts) as it's incompatible with mdBook `v0.5.x`. The good news is that mdBook itself is now able to support this feature natively.
This patch release resolves build issues affecting Unreal Engine `5.7` on Linux `Arm64` architecture.
### Fixed
- Fixed an issue in UE `5.7` projects where Linux `Arm64` builds were incorrectly linking against third-party libraries compiled with Epic Native/Cross Toolchain `v25` (shipped with UE `5.6`), instead of the required Toolchain `v26` binaries (shipped with UE `5.7`).
- Resolved a critical deadlock between the rendering and game threads in Unreal Engine `5.5` that when `IHeadMountedDisplay::GetHMDMonitorInfo()` is invoked from `FSGXRTracker::GetControllerTransform()` in certain conditions; specifically while SenseCom is running and gloves are present and connected. This issue is [related to critical deadlock issue (UE-212224), occurring during PipelinedFrameState acquisition, which had already been addressed for the plugin versions running on UE `5.6+`](#260---2025-06-04). Because it only gets triggered under specific project settings, we were previously unaware that it also affected IHeadMountedDisplay::GetHMDMonitorInfo() in UE `5.5`.
- Locked the [mdbook-pdf](https://github.com/HollowMan6/mdbook-pdf) crate to [`v0.1.11`](https://github.com/HollowMan6/mdbook-pdf/releases/tag/v0.1.11) due to the following `v0.1.12` panick during PDF generation: called `Result::unwrap()` on an `Err` value: Unable to deserialize the `RenderContext`.
This minor release focuses on delivering performance improvements, made possible by major optimizations in the underlying proprietary SenseGlove libraries, while also introducing some breaking changes.
- Added support for Android NDK `r27c`, which is the recommend Android SDK since UE `5.6.1` and the default for UE `5.7+` for Android Standalone builds.
- Added support for Epic Cross and Native Toolchains `v26`, which is shipped with the UE `5.7` and GNU/Linux support.
- Added prebuilt binaries for third-party library [{fmt} Formatting Library](https://github.com/fmtlib/fmt) on all supported platforms. This third-party library is a required dependency of SenseGlove libraries >= `v2.300.0`.
- Added prebuilt binaries for third-party library: [Loguru Logging Library](https://github.com/emilk/loguru) on all supported platforms. This third-party library is a required dependency of SenseGlove libraries >= `v2.300.0`.
- Added third-party module `SGWjwwoodSerialThirdPartyLibs` to replace `SGSerialThirdPartyLibs` while retaining `SGSerialThirdPartyLibs` for a different purpose. See the relevant comment in the Changed section below.
- Fix a typo in the function name `SGDeviceList::SenseCommRunning()`. This fix breaks ABI and API compatibility with previous versions of the plugin and affects both C++ and Blueprint code.
### Changed
-`SGDeviceList::SenseCommRunning()` has been renamed to `SGDeviceList::SenseComRunning()` due to a typo. This change breaks ABI and API compatibility with previous versions of the plugin and affects both C++ and Blueprint code.
- Bumped the SenseGlove libraries to `v2.305.3-17a820b6e`. This release of the SenseGlove libraries disables RTTI/Exceptions for the most parts and isolates it to a minor portion of the code base, which yields noticable performance gains. Futhermore, some optiomizations are done in the multi-threaded code, such as replacing Spinlocks with Adaptive Mutexes (a hybrid Mutex/Spinlock).
- As a result of SenseGlove libraries >= `v2.300.0` changing it's directory structure, the `ThirdParty` folder's directory structure has been revamped.
- Renamed third-party module `SGSerialThirdPartyLibs` to `SGWjwwoodSerialThirdPartyLibs` since SenseGlove libraries >= `v2.300.0` ships a new static library named `sgserial`. Thus, to avoid confusion and naming conflicts the third-party `serial` static library is now provided by the `SGWjwwoodSerialThirdPartyLibs` module and `sgserial` is provided by the `SGSerialThirdPartyLibs` module.
-`FSGGloveTrackingSettings::GloveConnectivityCheckInterval` settings have been renamed to `FSGGloveTrackingSettings::DataRetrievalRefreshRate` for adoption other than glove connectivity use cases.
-`SGPawn` and `SGTouchComponent` no longer use the legacy `QueueVibroLevels` method for applying vibrotactile feedback. Instead it's been replaced with `SendCustomWaveform`.
- Changed `USGTouchComponent::VibrotactileDuration` UPROPERTY's maximum value to `1.0f`. Previously it was uncapped, and now any value beyond `1.0f` seconds is clamped.
- Cleaned up remnants of the long-removed Unreal Engine `5.2` from `SenseGlove.Build.cs`, `SenseGloveKismet.Build.cs`, `SenseGloveTracking.Build.cs`, files.
- **This is the last major/minor release to support Unreal Engine `5.4`**, and its support will be removed in future minor or major releases. This is **important to keep in mind if your target development and deployment platform is [HTC VIVE in Standalone Mode](../getting-started/enabling-xr-ext-hand-tracking-vr-headsets/standalone-mode/index.html#htc-vive)**. Unfortunately, HTC has not released any updates to their HTC ViveOpenXR plugin since December 6, 2024. Their [latest release](https://developer.vive.com/resources/openxr/unreal/unreal-download/latest/) [[1]](https://web.archive.org/web/20251113165658/https://developer.vive.com/resources/openxr/unreal/unreal-download/latest/) [[2]](https://archive.ph/DlrLr), ViveOpenXR Plugin `v2.5.0`, supports only Unreal Engine `5.3` and `5.4`. [HTC VIVE PCVR Mode](../getting-started/enabling-xr-ext-hand-tracking-vr-headsets/pcvr-mode/index.html#htc-vive) is unaffected and will remain fully functional because, on Microsoft Windows, it is supported via the [OpenXRViveTracker Plugin](../getting-started/enabling-xr-ext-hand-tracking-vr-headsets/pcvr-mode/index.html#openxrvivetracker-plugin), which is bundled with Unreal Engine and officially maintained by Epic Games. If you still intend to target HTC in Standalone Mode, you are welcome to continue using the latest SenseGlove Unreal Engine Plugin `v2.7.x`, which will retain HTC Standalone Mode support. However, please keep in mind that once newer versions of the SenseGlove Unreal Engine Plugin are released and UE `5.4` is no longer supported, the latest release of the plugin supporting UE `5.4` will not receive new features, hardware support, or bug fixes. If at any point in the future HTC releases a new version of their ViveOpenXR plugin that supports any Unreal Engine version we actively support, [in accordance with our support policy and Platform Support Matrix](../appendix/platform-support-matrix.html), we will make every reasonable effort to reintroduce HTC Standalone Mode support.
- Added [a third-party tutorial to the Android Standalone Mode Deployment](../misc/android-standalone-deployment/third-party-tutorials/) section for UE `5.7` which provides a one-click Android development and build environment setup, instructions on how to setup and use the new UE `5.7` project launcher, and how to enabled OpenXR hand-tracking support on Meta Quest and HTC VIVE devices.
- Fix a linking issue on GNU/Linux with UE `5.6` where SenseGlove libraries were built against dynamic versions of `libc++` and `libc++abi` libraries rather than the static versions.
- Fix an issue where SenseGlove libraries for some targets were not actually built with `C++20` and still were built against `C++17`.
- Fix an issue where SenseGlove libraries for some targets were built or linked with incorrect settings.
- Additional minor fixes and improvements that may not be listed here.
### Changed
- Bumped the SenseGlove libraries to `v2.204.0-3a37b1977`.
### Removed
- SenseGlove plugin no longer ships Boost or wjwwood's Serial Communication Library header files as SenseGlove public headers shipped with `v2.204.0-3a37b1977` render them redundant. This significantly removes clutter, free up disk space, and speed up builds to some extent.
This minor release delivers broad compatibility, stability, and maintainability enhancements, focusing on bringing full Unreal Engine `5.6` support, C++20 migration, and resolving various GNU/Linux build issues.
- Resolved GNU/Linux build issues for Unreal Engine `5.5` and `5.6` caused by incorrect linkage to GNU/GCC's `libstdc++` instead of LLVM/Clang's `libc++`.
- Fix `SGLog` build issues on GNU/Linux with UE `5.6`.
- Fix type conversion safety and consistency issues across all `SGLog` formatters.
- Resolved a critical deadlock between the rendering and game threads in Unreal Engine `5.6` that occurrs when `IHeadMountedDisplay::GetHMDMonitorInfo()` is invoked from `FSGXRTracker::GetControllerTransform()`. This is similar to another [critical deadlock issue (UE-212224), occurring during PipelinedFrameState acquisition, addressed in the `v2.5.0` release](#250---2025-05-09).
- Additional minor fixes and improvements that may not be listed here.
- Replaced Epic Native Toolchain `v24` support with Epic Native Toolchain `v25` due to the fact that now `v25` is the default Linux toolchain for UE `5.6`.
- Revamped `FSGHMDTracker` to resolve a critical deadlock between the rendering and game threads in Unreal Engine `5.6` that occurrs when `IHeadMountedDisplay::GetHMDMonitorInfo()` is invoked from `FSGXRTracker::GetControllerTransform()`. This is similar to another [critical deadlock issue (UE-212224), occurring during PipelinedFrameState acquisition, addressed in the `v2.5.0` release](#250---2025-05-09).
- Revamped the UBT logic for importing third-party headers and libraries by introducing third-party dependency modules, `SGBleThirdPartyLibs`, `SGConnectThirdPartyHeaders`, `SGConnectThirdPartyLibs`, `SGCoreThirdPartyLibs`, and `SGSerialThirdPartyLibs`, which significantly reduces UBT boilerplate code and increases maintainability.
- Dropped support for Epic Native Toolchain `v24`, which was last shipped with the preview release of UE `5.6`, but has been removed from the `5.6` branch on GitHub.
- Revised the outdated [Plugin Directory Structure](./directory-structure.html) section to accurately reflect the latest changes to the `Source/ThirdParty` directory layout changes.
- Fix [a critical issue introduced by UE `5.5`](https://github.com/EpicGames/UnrealEngine/blob/ef1397773d160d39423feb90cb2196ddfaa1e2ae/Engine/Plugins/Runtime/OpenXR/Source/OpenXRHMD/Private/OpenXRHMD.cpp#L1740) that [also affects the upcoming UE `5.6`](https://github.com/EpicGames/UnrealEngine/blob/bedc5631b81cd39aaac8d61f303eacc86d4220f0/Engine/Plugins/Runtime/OpenXR/Source/OpenXRHMD/Private/OpenXRHMD.cpp#L1772). This is known as issue `UE-212224`, which leads to a deadlock during `PipelinedFrameState` acquisition between the game and rendering threads.
- The error codes returned from `FSGConnectJNI::Initialize()` and `FSGCoreJNI::Initialize()` have been changed. This is a breaking change for any code that relies on handling the return codes from those functions.
- Dropped support for Unreal Engine `5.2` and Epic Native Toolchain `v21` (previously used for building UE `5.2` Linux dependencies), as they were already deprecated in the `v2.4.x` release series.
- Revamped [SenseCom documentation](../getting-started/sensecom) in order to divide the SenseCom instructions section into [Bluetooth Low Energy instructions for SenseCom](../getting-started/sensecom/bluetooth-low-energy) and [Bluetooth Serial instructions for SenseCom](../getting-started/sensecom/bluetooth-serial) sections.
- Added [Bluetooth Low Energy instructions for SenseCom](../getting-started/sensecom/bluetooth-low-energy).
- Added [Bluetooth Serial instructions for Android](../getting-started/sensecom/bluetooth-serial/android.html).
- Bumped the [mdbook-epub](https://github.com/Michael-F-Bryan/mdbook-epub) crate to [`cac03b7f4b151f106f7f05b13da4c33fc098dd2c`](https://github.com/Michael-F-Bryan/mdbook-epub/commit/cac03b7f4b151f106f7f05b13da4c33fc098dd2c).
- Fix a bug that breaks the custom CSS styles on the Handbook's release URLs (e.g. `https://unreal.docs.senseglove.com/2.4/`) by reverting an unintentional change from the `v2.4.0`.
- Added `FSGConnectJNI::Initialize()` and `FSGCoreJNI::Initialize()` return codes to Android logs for detailed debugging purposes through `adb logcat`.
- Added support for HTC Vive Wrist Trackers support on Android using the official `ViveOpenXR` plugin's OpenXR positional tracking provider `OpenXRViveWristTracker`.
- Added the `OpenXRPositionalTrackingProvider` option to the plugin's wrist-tracker settings to either manually set the positional tracking provider or auto-detect it based on a combination of tracker hardware settings, targeted platform, available OpenXR plugins, or the auto-detected HMD hardware.
- Fix a critical issue where `HandStates->GetTransform(KeyPoint)` was incorrectly resolving to `(&HandStates[0])->GetTransform(KeyPoint)`, causing both hands to use the left hand's wrist transform under specific conditions. This occurred when the `bFallbackToHandTrackingIfNoGloveDetected` option was enabled, two gloves were present, and no hardware wrist-tracking device was active, resulting in both hands overlapping at the same transform.
-`FSGArrayUtils` optimizations that affect the plugin performance as a whole.
- Now the motion sources for the wrist-tracking hardware or hand-tracking are queried and populated dynamically rather than relying on the hardcoded `EControllerHand` enum. This allows the SenseGlove Unreal Engine Plugin to integrate better into other plugins such as `ViveOpenXR`, which when enabled, provides many more options as the motion source for their various wrist-tracking hardware.
-`FSGWristTrackingSettings::LeftHandMotionSource` and `FSGWristTrackingSettings::RightHandMotionSource` types have changed from `EControllerHand` to `FName`.
- Revamped the [Enabling XR_EXT_hand_tracking OpenXR Extension on VR Headsets](../getting-started/enabling-xr-ext-hand-tracking-vr-headsets/) and [Deploying to Android (Standalone)](../misc/android-standalone-deployment/) documentation, and added the `ViveOpenXR`-compatibile instructions as well.
- Significantly improved the [Setting Up the Wrist Tracking Hardware](../getting-started/setup-wrist-tracking-hardware/) section by providing more detailed documentation and example configuration per HMD and wrist tracking hardware.
- Added [HTC VIVE specific optimization tips for running in standalone mode](../misc/optimize-higher-fps/#htc-vive-specific-optimizations-in-standalone-mode).
- Reintroduced [mdbook-epub](https://github.com/Michael-F-Bryan/mdbook-epub) at [`d1536bbbdc1ca00320522ad73a967e15057ef573`](https://github.com/Michael-F-Bryan/mdbook-epub/commit/d1536bbbdc1ca00320522ad73a967e15057ef573) from the [`master` branch](https://github.com/Michael-F-Bryan/mdbook-epub/tree/master) as the blocking issues in [#115](https://github.com/Michael-F-Bryan/mdbook-epub/issues/115) have been address in [`1ca2a860f6ed405c00914a3aadd8057d5050b29b`](https://github.com/Michael-F-Bryan/mdbook-epub/commit/1ca2a860f6ed405c00914a3aadd8057d5050b29b#diff-b21e2a96624fabac44d6c5ecc34bff0835565999be6a320fe75bd0401d5c8e87R148).
- Added third-party tutorials to the following sections: [Enabling XR_EXT_hand_tracking on VR Headsets](../getting-started/enabling-xr-ext-hand-tracking-vr-headsets/third-party-tutorials/), [Deploying to Android (Standalone)](../misc/android-standalone-deployment/third-party-tutorials/), and [OpenXR](../advanced-topics/openxr/third-party-tutorials/).
- Fix a critical issue backported from the upcoming `2.4.x` release where `HandStates->GetTransform(KeyPoint)` was incorrectly resolving to `(&HandStates[0])->GetTransform(KeyPoint)`, causing both hands to use the left hand's wrist transform under specific conditions. This occurred when the `bFallbackToHandTrackingIfNoGloveDetected` option was enabled, two gloves were present, and no hardware wrist-tracking device was active, resulting in both hands overlapping at the same transform.
- Additional minor fixes and improvements that may not be listed here.
### Changed
- The SenseGlove Sockets Editor now calculates hand bone reference transforms using the current virtual hand mesh being edited, rather than the reference mesh, when adding SenseGlove sockets.
This minor release includes some improvements and adds official Unreal Engine `5.5` Fab support.
### Added
- Added `USGAndroidPermissions` to the `SenseGloveAndroid` module, enhancing the plugin's permission request process on Android. Now, a pop-up prompts the user to grant permissions, preventing silent crashes when permissions haven't been granted beforehand.
- Fixed a chain of critical bugs that gets triggered due to `GloveConnectivityCheckInterval` getting passed as seconds to the engine rather than milliseconds. Thus, the default or any large value for `GloveConnectivityCheckInterval` causes noticeable long delays between glove-connectivity-check intervals and consequently renders the hand-tracking state invalid in certain situations when the `bFallbackToHandTrackingIfNoGloveDetected` option is false.
This patch release focuses exclusively on updates to the documentation.
### Documentation
- Updated all URLs, screenshots, and tutorials to reflect the transition from the Unreal Engine Marketplace to Fab, Epic’s new unified content marketplace.
- Revised documentation now points to the new home of the SenseGlove Unreal Engine Plugin on Fab, ensuring users have access to the latest resources and information.
This is a minor release with some breaking API and ABI changes, focusing mainly on migrating away from the deprecated `FXRMotionControllerData` in favor of `FXRMotionControllerState` and `FXRHandTrackingState` on Unreal Engine `5.5+`.
### Added
- Completed support for the upcoming Unreal Engine `5.5` release.
- Added `USGVirtualHandComponent::GetMotionControllerState()` and the equivalent Blueprint function`UVirtualHandComponentKismetLibrary::GetMotionControllerState` on UE `5.5+`.
- Added `USGVirtualHandComponent::GetHandTrackingState()` and the equivalent Blueprint function `UVirtualHandComponentKismetLibrary::GetHandTrackingState` on UE `5.5+`.
- Added `USGWristTrackerComponent::GetMotionControllerState()` and the equivalent Blueprint function `UWristTrackerComponentKismetLibrary::GetMotionControllerState` on UE `5.5+`.
- Added `USGWristTrackerComponent::GetHandTrackingState()` and the equivalent Blueprint function `UWristTrackerComponentKismetLibrary::GetHandTrackingState` on UE `5.5+`.
- Added a variant of `FSGDebugVirtualHand::Draw()` and the equivalent Blueprint function `USGDebugVirtualHandKismetLibrary::Draw_FXRHandTrackingState()` which accept `FXRHandTrackingState` on UE `5.5+`.
- Added the new member `bTracked` to the `FSGXRHandState` struct.
- Added `FSGXRTracker::GetMotionControllerState()` and the equivalent Blueprint function `USGXRTrackerKismetLibrary::GetMotionControllerState()`.
- Added `FSGXRTracker::GetHandTrackingState()` and the equivalent Blueprint function `USGXRTrackerKismetLibrary::GetHandTrackingState()`.
### Fixed
- Additional minor fixes and improvements that may not be listed here.
### Changed
- Replaced all internal usages of the `FXRMotionControllerData` struct with either `FXRMotionControllerState` or `FXRHandTrackingState` on UE `5.5+`.
- Deprecated `USGVirtualHandComponent::GetMotionControllerData()` on UE `5.5+`.
- Deprecated `USGWristTrackerComponent::GetMotionControllerData()` on UE `5.5+`.
- Deprecated the variant of `FSGDebugVirtualHand::Draw()` which accepts `FXRMotionControllerData` as a parameter on UE `5.5+`.
- Renamed `USGDebugVirtualHandKismetLibrary::Draw` to `USGDebugVirtualHandKismetLibrary::Draw_FXRMotionControllerData` for more clarification.
- Renamed an `FSGXRHandState` member from `bReceivedJointPoses` to `bHasReceivedJointPoses`.
- Changed the `FSGXRTracker::GetAllKeypointStates()` signature on UE `5.5+` to match the `IHandTracker` interface API changes.
- The animation system on UE `5.5+` has been revamped to utilize `FXRHandTrackingState` instead of `FXRMotionControllerData`.
- The wrist tracking system on UE `5.5+` has been revamped to utilize `FXRHandTrackingState` instead of `FXRMotionControllerData`.
- The hand interaction manipulation on UE `5.5+` has been revamped to utilize `FXRHandTrackingState`.
- The virtual hand debugging system on UE `5.5+` has been revamped to utilize `FXRHandTrackingState`.
- Added initial support for the upcoming Unreal Engine `5.5` release. Please note that, while the plugin is functional, a few adjustments are still required to address deprecation warnings. Specifically, the `FXRMotionControllerData` struct needs to be replaced with the newly introduced `FXRMotionControllerState` and `FXRHandTrackingState` structs, along with adjustments to adhere to the new hand-tracking API changes.
- Fix a bug inside `USGVirtualHandComponent::PostEditChangeProperty()` where the get member name check happens against the wrong class and member names.
- Fix `LogPython: Warning: 'SGHMDTrackerKismetLibrary' and 'SGXRTrackerKismetLibrary' have the same name (SenseGloveHeadMountDisplayKismetLibrary) when exposed to Python. Rename one of them using 'ScriptName' meta-data` when packaging the game.
This is a bugfix release with no actual plugin code changes, mostly addressing issues in the documentation and third-party dependencies caused by source control merge conflicts.
### Fixed
- Fix the messed up changelog file caused by cherry-picking merge conflicts between the dev branch and the master branch.
- Fix a bug that causes a handbook revision mismatch when deploying the handbook from the dev branch.
- Fix a bug where `SG_GIT_IS_SHALLOW_CLONE` while building the handbook is always set to `yes` even if it's not a shadow clone because `SG_DOT_GIT_SHALLOW_FILE` evaluates to an empty string when the `.git/shallow` file does not exist.
This is a minor release focusing mainly on bringing OpenXR-compatible hand tracking support (`XR_EXT_hand_tracking`) and Head-mounted Display automatic detection for adjusting wrist tracker offsets automatically at runtime.
- Added SenseGloveTracking and module which provides OpenXR-compatible hand tracking by implementing `XR_EXT_hand_tracking` support, HMD auto-detection, and SenseGlove device tracking.
- Added `USenseGloveTrackingKismet` module in order to expose part of the SenseGloveTracking functionality to Blueprint.
- Added `FSGXRTracker`, the underlying main class that implements the OpenXR compatibility.
- Added `USGXRTrackerKismetLibrary` in order to allow Blueprint to retrieve the `FXRMotionControllerData` directly from our tracking module.
- Added the `SGTrackingTypes` header to the `SenseGloveTypes` module in order to define and share `SenseGloveTracking` module types through this header across the plugin modules.
- A fallback to HMD and wrist tracker hardware auto-detection mechanism has been added to be triggered in situations when automatic detection of the wrist tracker hardware is desired, e.g., either by not setting it explicitly, or setting it to the default None value. Please note that this is still highly experimental and HTC VIVE Focus 3 and HTC XR Elite cannot be distinguished in the current iteration. Though, since the tracker devices and offsets for both headsets are the same in the end it does not make a difference if both headsets are detected as each other.
- Added `ESGHeadMountedDisplayDevice` enum with supported HMDs list.
- Added `ESGViveHMDDetectionPriority` enum in order to choose which headset we attempt to detect between VIVE Focus 3 and VIVE XR Elite as we cannot distinguish them, yet.
- Added the `FSGHMDTracker` utility class, in order to easily gather information about the HMD device at runtime.
- Added `USGHMDTrackerKismetLibrary` which exposes the equivalent C++ HMD auto-detection functionality to Blueprint.
- Added `FSGHMDTrackingSettings` config struct.
- Added the `FSGGloveTracer` utility class, in order to easily check the left or right glove connectivity or retrieve the connected glove instances.
- Added `USGGloveTrackerKismetLibrary` which exposes the equivalent C++ functionality to Blueprint.
- Added `USGVirtualHandComponent::OnHandVisibilityChanged()` event in order to notify other components/actors whenever the virtual hand mesh appears or disappears (for example, this could happen when a glove is connected/disconnected).
-`GetMotionControllerData()` has been introduced to the `USGVitualHandComponent` in order to retrieve the OpenXR-compatible glove data in Unreal's `FXRMotionControllerData` format.
- Added `FSGVirtualHandAnimInstanceProxy::GetMotionControllerData()` and many more accessor methods usable only by child classes to allow consumption of the data required for manipulating the virtual hand mesh animations.
-`GetMotionControllerData()` has been introduced to the `USGWristTrackerComponent` in order to retrieve the OpenXR-compatible glove data in Unreal's `FXRMotionControllerData` format.
- Added the `SenseGloveDebugKismet` module in order to allow drawing of debugging, cubes, gizmos, and virtual hands from Blueprint.
- Added `USGDebugCubeKismetLibrary` in order to expose the `FSGDebugCube` functionalities to Blueprint.
- Added `USGDebugGizmoKismetLibrary` in order to expose the `FSGDebugGizmo` functionalities to Blueprint.
- Added`USGDebugVirtualHandKismetLibrary` in order to expose the `FSGDebugVirtualHand` functionalities to Blueprint.
- Added a new static `Draw()` method overload to `DebugGizmo` which allows passing an `FQuat` instead of a `FRotator`.
- Introduced a new `FXRMotionControllerData` compatible hand animation system with the ability to take the mesh bone's transforms into account for a more reliable hand animation.
- Introduced a new `FXRMotionControllerData` compatible wrist tracking system.
- Introduced a new `FXRMotionControllerData` compatible hand interaction manipulation system.
- Added the ability to fallback to hand tracking when a glove is not present and use the bare hands for interactions, or a combination of glove and hand tracking if no motion controller input is detected.
- Added the SenseGlove grab/touch sockets one-click-setup ability on any Epic-compliant virtual hand mesh from within the Unreal Editor's Content Browser, Skeleton Editor, or Skeletal Mesh Editor by extending the Unreal Editor.
- Added the `FSGInitializationSettings` config struct in order to control how the plugin is initialized.
- Introduced the `FSGGameUserSettings` for managing the Engine Scalability Settings through the SenseGlove plugin in order to change the graphics settings on the fly.
- Added `USGGameUserSettingsKismetLibrary` in order to allow all the Engine Scalability Settings to be managed from the Blueprint side.
- Merged the `pack` utility branch to the plugin's source code at `/Packager` which adds the SenseGlove Unreal Engine Marketplace Packager `v0.4.0-a65bb20` binaries and configurations.
- Fixed a bug when the virtual hand inside the game is not visible but still collides with other objects inside the scene, mistakenly triggering events like `OnGrabStateUpdated` and `OnTouchStateUpdated`.
- Fixed a bug where `USGGrabComponent`'s `bAffectPhysicsState` does not enables physics on its owning actor at `BeginPlay()`.
- Now, if `bValidateIfDefaultClassesAreSGCompliant` option from `FSGInitializationSettings` is enabled (default) the SenseGlove plugin checks for default SenseGlove-compliant `GameMode`, `GameInstance`, etc, at module initialization and tries to set to default, native SenseGlove classes, if any of those default classes are not a SenseGlove or a SenseGlove-derived class.
- The`USGSettings` has been fully revamped with more customizations added and categorized in a different manner adding many new structs and removing some, in order to have fine-grained control over the various aspects and functionality of the plugin components.
- The `USGSettings` constructor visibility has been changed from public to private.
- The Settings override system has been overhauled as well affecting how we override settings from the `USGVirtualHandComponent` and `USGWristTrackerComponent`.
- The SenseGlove libraries have been updated to `v2.104.1-55fddbd2`.
-`GetHandPose()` has been replaced by `GetMotionControllerData()` inside `USGVirtualHandComponent` (see the relevant entry in the Added and Removed sections).
- Many functions inside `USGVirtualHandComponent` for retrieving bone names or reference transforms has been renamed to return different data types; e.g. `GetLeftHandFingerBoneNames()`, `GetRightHandFingerBoneNames()`, `GetLeftHandFingerBoneName()`, and `GetRightHandFingerBoneName()` renamed to `GetLeftHandBoneNames()`, `GetRightHandBoneNames()`, `GetLeftHandBoneName()`, and `GetRightHandBoneName()` respectively.
-`bHiddenInGameIfNoGloveDetected` uproperty from `USGVirtualHandComponent` has been renamed to `bVisibleWhenHandDataUnavailable` and accordingly all of its getters and setters; `bVisibleWhenHandDataUnavailable = false` now acts as `bHiddenInGameIfNoGloveDetected = true`, and vice-versa.
-`USGWristTrackerComponent` now uses `FXRMotionControllerData` for wrist tracking instead of calculating the wrist location by calling the SenseGlove API.
-`FSGVirtualHandAnimInstanceProxy` now relies on `FXRMotionControllerData` to animate the hands instead of a `TMap` of bone names and rotations which allows it to also apply the bone locations.
-`FSGDebugVirtualHand::Draw()` now accepts a `FXRMotionControllerData` parameter instead of all `WristLocation`, `WristRotation`, `JointPositions`, and `JointRotations` parameters.
-`FSGDebugVirtualHandSettings` has been renamed to `FSGVirtualHandDebuggingSettings`.
- The value for `USGGrabComponent`'s `AttachmentSocketName` uproperty now defaults to the value of the plugin's `GrabAttachPointSocketName` instead of `Name_NONE`.
- The `SGGrabComponent` now enables `bGravityEnabled`, `bSimulatePhysics`, and calls `WakeRigidBody` on its owning actor at `BeginPlay()` if `bAffectPhysicsState` is enabled.
- The `/CHANGELOG.md` file has been migrated to `/Handbook/src/overview/changelog.md`
- The `/LICENSE.md` file has been migrated to `/Handbook/src/license/senseglove-unreal-engine-plugin.md`
- The `/LICENSE-THIRD-PARTY.md` file has been migrated to `/Handbook/src/license/third-party.md` and every third-party component's license has been split; adding `/Handbook/src/license/senseglove-sdk.md` for the SenseGlove SDK, `/Handbook/src/license/boost-cpp-libraries.md` for the Boost C++ Libraries, and `/Handbook/src/license/serial-communication-library.md` for the Serial Communication Library.
- The Platform Support Matrix section of the main README file has been migrated to `/Handbook/src/overview/platform-support-matrix.md`.
- The Planned Features Completion Status section of the main README file has been migrated to `/Handbook/src/overview/planned-features-completion-status.md`.
- The Directory Structure section of the main README file has been migrated to `/Handbook/src/overview/directory-structure.md`.
- The SenseGlove settings' main config struct is now marked as DefaultConfig which means it does not require to be saved when settings are changed and they take effect immediately as the user updates them.
- Changed the DocsURL from the [old Blueprint docs website](https://senseglove.gitlab.io/unreal-blueprint-docs/) to [the new SenseGlove Unreal Engine Handbook website](https://unreal.docs.senseglove.com/).
- The Blueprint signature for various overloads of the Blueprint-exposed function `Queue Command Vibro Level` has been changed to expose sensible display names.
- Removed `USGVirtualHandComponent::GetHandPose()` and it's no longer possible to get the hand pose data from `USGVirtualHandComponent` as `GetHandPose()` has been removed. If you need it, you could always use the SenseGlove low-level API to retrieve it from the glove.
- Removed also `GetFingerBoneName()`, `GetFingerBoneRefTransform()`, `GetFingerBoneRefRotation()` and `GetFingerBoneRefRotation()` from `USGVirtualHandComponent`.
- Removed some remnants of UE `5.1` and older releases from the C++ code.
- With the new OpenXR release, the separation of the real and virtual hand rendering is broken. The reason is the animation system now uses the OpenXR data in the world transforms which yields better animations, but comes at the cost of overriding the the hand position set by the wrist tracker component's position and rotation. If `FXRMotionControllerData` is invalid and `bVisibleWhenHandDataUnavailable` is enabled for example, the system works as expected, since the animation system won't proceed to animate the hand meshes without valid `FXRMotionControllerData`. Since the animation system is only aware of the hand mesh it's animating versus the real hand and virtual hand meshes it means either it should become aware of the physics events like begin and end overlap events and also the real vs virtual hands, or it should resort back to animating the virtual hand meshes in local or component space. This release marks this feature as broken for now until we come up with a reasonable solution in the future.
- The `UXRDeviceVisualizationComponent` provided by Unreal Engine is used in the `SGPawn` class as `ControllerVisualizerLeft` and `ControllerVisualizerRight` for implementing the wrist tracking hardware visualization feature. However, it is not compatible with the new OpenXR system in certain scenarios. For instance, when the motion controllers serve as wrist tracking hardware since the SenseGlove plugin is now introduced to the engine as an `OpenXRHandTracking` system, it causes the `UXRDeviceVisualizationComponent` to visualize the wrist tracking hardware at coordinates (`0.0f`, `0.0f`, `0.0f`) instead of their actual location and rotation in the world. This happens because the component incorrectly registers them as inactive, possibly because it's assumed hand tracking and motion controllers cannot be in use at the same time. Currently, we use this feature solely for debugging, and we have an alternative in the form of wrist-tracking debug gizmos, which can be toggled on or off via the settings system. In future releases, we might remove this feature due to its incompatibility, unless we find a solution to make the `UXRDeviceVisualizationComponent` work with the new system. Alternatively, we may develop our own version of the `UXRDeviceVisualizationComponent`.
- Although the SenseGlove OpenXR implementation is fully compatible with the `IOpenXRHMD` interface and the `FOpenXRHMD``XRTrackingSystem`, it is not compatible with the `FOculusXRHMD` backend provided by the Meta XR plugin. The same issue likely applies to the VIVE OpenXR plugin. So, if these plugins are enabled in your project, the SenseGlove OpenXR will not function as intended, effectively breaking the plugin's functionality. It seems these plugins are necessary in order to make the fallback to the hand-tracking feature work on Android. While we may add support and compatibility with Meta XR and VIVE OpenXR plugins in the future, for the time being, if your project requires these plugins, we advise continuing with the `v2.0.x` release of the SenseGlove Unreal Engine plugin until this issue is addressed.
- Fix a bug where the `SGPawn` right-hand grab colliders' default size is mistakenly set to the default value for the left-hand grab colliders at CDO initialization time.
- Make the Allbreaker assets compatible with UE5.1+ again as the `v2.0.5` update breaks compatibility with UE versions earlier than `5.4`, thus leaving the engine unable to load those assets.
This is a bugfix release with no actual plugin code changes, only focusing on fixing the Allbreaker virtual hand model issues.
### Fixed
- Fix the wrong palm bone names on the Allbreaker virtual hand models.
## [2.0.4] - 2024-05-17
This is a bugfix release with no actual plugin's code change.
### Fixed
- Fix our in-house Unreal Engine Marketplace submission tool's configurations where the Content folder (containing the Allbreaker hand model) is mistakenly ignored during the submission. This release reintroduces the Virtual Hand Model and its material missing from the previous release.
- Fix UE `5.4` RunUAT build issue: "Asking CppCompileEnvironment for a single Architecture, but it has multiple Architectures (arm64, x64)", affecting `SenseGloveConnectImpl` and `SenseGloveCoreImpl` modues.
- Improved target platform detection when building `SenseGloveConnectImpl` and `SenseGloveCoreImpl` modules and also distinguishing the `x64` builds from `arm64` on Microsoft Windows.
- Fix other UE `5.4` RunUAT build issues, mostly caused by missing headers.
- Updated the Platform Support Matrix with the latest changes. This is the last release to support Unreal Engine `5.1` as we no longer are able to push updates for this release to the Unreal Engine Marketplace. The `v2.0.1` release for Unreal Engine `5.1` can be obtained from the Unreal Engine Marketplace, and `v2.0.2` through our Microsoft Azure DevOps repositories. Please note that there are no actual code changes between these two releases and in terms of functionality they are almost identical.
- Fix a bug inside both `SGVirtualHandComponent` and `SGWristTrackerComponent` where the connected glove's `UObject` instance gets destroyed and re-instantiated every frame. With this fix now the glove instance will be created or destroyed only when a glove connects to or disconnects from the system.
- SenseGlove libraries have been updated to `v2.102.0-35d4de3f`.
- Together, SenseGlove libraries `v2.102.0-35d4de3f` and SenseCom `v1.6.1` remove the need to call ResetCalibration every time and are able to store and load calibration profiles from disk.
- SesenGloveBackend module is no longer calling `FSGHandLayer::ResetCalibration()` on every backend initialization.
This is the second major release of the SenseGlove Unreal Engine Plugin adding support for Nova 2 with enormous breaking changes to the current C++ and Blueprint APIs.
### Added
- Added support for the SenseGlove Nova 2 devices.
- Added a pair of default production-ready virtual hand meshes for the left and right hands, courtesy of [Allbreaker LLC Columbia](https://www.allbreaker.co/). For usage and redistribution, please consult the [LICENSE-THIRD-PARTY.md](LICENSE-THIRD-PARTY.md) file.
- A few critical bug fixes that have already been backported to the `v1.x.x` series through `v1.9.3` to `v1.9.8` releases.
- Revamped the way we do `FVector` <-> `SGVect3D`, `FQuat` <-> `SGQuat`, and SenseGlove <-> Unreal Engine angles conversions in order to properly translate between the SenseGlove and Unreal Engine coordinate systems.
- Fix the modules' order inside the `.uplugin` file.
- Fix a build issue inside `FSGArrayUtils::FromStdVector()` introduced by newer MVSC updates due to stricter implicit `uint64` to `int32` conversions.
- Fix a build issues inside `FSGArrayUtils` when performing non-Unity builds due to the missing `<string>` header.
- Fix other build issues in `USGDevice`, `USGNovaGloveSensorData`, `FSGDeviceImpl`, and `FSGSenseGloveVarsImpl` when performing non-Unity builds due to the missing relevant headers.
- The SenseGlove Unreal Engine Plugin now declares the OpenXR plugin as a dependency, so that the OpenXR plugin will be enabled automatically as soon as the SenseGlove Unreal Engine Plugin gets enabled.
- Various classes and parts of the API have been changed in order to reflect and adhere to upstream SenseGlove libraries.
- Reverse the Platform Support Matrix order from newer Unreal Engine versions to the older ones.
- Clarify the engine support policy in the main readme file by adding the corresponding references from the Epic Marketplace Guidelines and a URL to their guidelines page.
- The `SGTouchComponent` uproperties BuzzDuration and BuzzLevel now utilize different different names in order to correspond to the underlying API changes. They have been renamed to `VibrotactileDuration` and `VibrotactileLevel`.
- The `SGTouchComponent` uproperties ForceFeedbackLevel and BuzzLevel (now `VibrotactileLevel`) parameters type have changed from `int32` to `float` with the value range varying between `0.0f` to `1.0f` instead of `1` to `100` in order to correspond to the underlying API changes.
- The `SGVirtualHandComponent` now assumes the default grab point's name as `GenericGrabPoint` instead of `GrabPoint` as default if not specified in the Unreal Blueprint Editor.
- The `SGPawn` on UE `5.2+` now utilizes `UXRDeviceVisualizationComponent` in order to properly display the controller meshes shipped with Unreal Engine's OpenXR plugin, or a user-provided mesh. On UE `5.1` this could still be set on the `WristTrackerLeft` and `WristTrackerRight` components. Please note that despite the fact that on UE `5.2+` it's still possible to utilize the `WristTrackerLeft` and `WristTrackerRight` for setting the controller meshes, this has been deprecated in UE `5.2+` and is no longer supported.
- The BonesRotations TMap is no longer a public field of `FSGVirtualHandAnimInstanceProxy` and instead could be retrieved by calling the `GetBonesRotations()` method.
- Fix various bugs inside the `SGPlayerController` which occur when the thumb and pinky fingers are simultaneously touching different `SGTouchComponents`, or only one of them is in touch with such a component. In this case pinky's buzz and force-feedback levels are determined from the `SGTouchComponent` that is in collision with the thumb instead of the one that is touched by the pinky. Or, the pinky could ignore the buzz and force-feedback level if the thumb is not in collision with an `SGTouchComponent`. Or, the pinky could have reacted with a buzz or force feedback while only the thumb is in contact with an `SGTouchComponent`.
- Fix the `BuzzDuration` uproperty range in order not to get clamped at `100.0f` and also use `float` values for `ClampMin` and `UIMin` specifiers instead of integer values.
- Fix a few critical bugs inside the `NovaGlove` class where the higher levels of the API including constructors, Parse, and `NewNovaGlove` methods mistakenly instantiate a `SenseGloveImpl` class instead of a `NovaGloveImpl` class.
- Fix a wrong type-casting inside `SGDeviceModel::ParseFirmware()` where `OutMainVersion` and `OutSubVersion` arguments are getting passed to the lower levels of the API. This could potentially result in a segfault at the FFI boundary between lower and higher levels of the API.
This is a bugfix release addressing mostly Blueprint API issues with ABI breaking changes inside the Blueprint layer, backported from the next major release of the plugin as documented below.
- Fix the Blueprint Parse function signature for the `NovaGloveInfoKismetLibrary` where the `OutGloveInfo` passed by the caller was never actually assigned as it was not getting passed by reference.
This is a hotfix release addressing a few critical issues that might result in crashes or malfunctions for users of the low-level SenseGlove API, backported from the next major release of the plugin as documented below.
- Fix a potential memory corruption inside one of the `SGBasicHandModel` constructors where the StartPositions parameter gets passed as the StartRotations parameter to lower levels of the API.
- Fix a potential memory corruption inside one of the `SGSenseGloveInfo` constructors where the StartPositions parameter gets passed as the Functions parameter to lower levels of the API.
- Fix a potential memory corruption where inside the `SGHapticGloveCalibrationSequence::GetCurrentInstruction()` method, the return statement of the function is getting assigned to the const parameter `NextStepKey`, thus the return statement of the function will always be empty as well.
- Fix a potential memory corruption where inside one of the overloads of the `SGSenseGloveImpl::GetGlovePose()` method, the out parameter of the method is getting passed as the SensorData parameter to the lower levels of the API.
- Fix multiple Equals methods for a few classes such as `SGInterpolationSet`, `SGNovaGloveHandProfile`, `SGNovaGloveInfo`, `SGSenseGloveHandProfile`, `SenseGloveInfo`, `SenseGlovePose`, where the Equal method compares the current instance against itself instead of the other instance passed to as the parameter to the method.
- Removed a redundant code statement inside the `SGNovaGloveImpl::GetSubFirmwareVersion()` method.
- Add the missing Unreal Engine C++ header to files that rely on the `ENGINE_*_VERSION` macros in order to fix the Epic Store build failures on UE `5.3`.
- The `BlueprintImplementableEvent` ufunction specifier for the `OnGrabStateUpdated`, `OnTouchStateUpdated`, `OnActorGrabbed`, `OnActorReleased`, `OnActorBeginTouch`, and `OnActorEndTouch` events have been changed to BlueprintNativeEvent in order to allow them to be implemented from the child C++ classes as well. This won't break any existing Blueprint code that relies on the previous BlueprintImplementableEvent signature.
- Introduced new `SGPawn` events: `OnActorGrabbed`, `OnActorReleased`, `OnActorBeginTouch`, and `OnActorEndTouch`.
- Exposed `OnGrabStateUpdated`, `OnTouchStateUpdated`, `OnActorGrabbed`, `OnActorReleased`, `OnActorBeginTouch`, and `OnActorEndTouch` events to Blueprint as `BlueprintImplementableEvent`.
- Fix a bug where the `OnTouchStateUpdated` event is mistakenly triggered instead of the `OnGrabStateUpdated` when the right thumb fingertip grab collider overlaps with a grabbable actor.
- Fix the `DECLARE_EVENT` macro signature for `OnGrabStateUpdated` and `OnTouchStateUpdated` events.
- Introduce `SGGameInstance`, a customized SenseGlove game instance for future use.
- Added the new `SenseGloveBackend` and `SenseGloveBackendKismet` modules.
- Added `SG_CPP20` C++ macro for C++20 detection, which is now default from UE `5.3` onwards.
- Added `SG_CAPTURE_THIS` C++ macro as a workaround for `error C4855: implicit capture of 'this' via '[=]' is deprecated in /std:c++20` in order to build the same lambda captures without extra `#ifdef`s on all supported engine versions.
- Fix a build issue with Android shipping builds due to `sgconnect.jar` not getting copied automatically in the AFSProject which is compiled for shipping builds when `AndroidFileServer (AFS)` is enabled.
- Added two options to the wrist tracker settings (to the global plugin settings and the overrides in the wrist tracker component) in order to be able to specify a custom motion source for the left and right hands, so that it allows SteamVR-based trackers such as HTC VIVE or HTC VIVE Focus 3 to operate with the `SGPawn`.
- Dropped support for the Epic Native Toolchain `v19`, MSVC `v141` (Visual Studio 2017), and thus Unreal Engine `4.27` as it has been marked as deprecated since `v1.4.x`.
This is a hotfix release addressing a critical Android crash.
### Fixed
- Fix a critical Android crash that happens where the default development hand meshes are not found, which means almost always since we don't ship any default virtual hand mesh at the moment.
- Added an optional feature in order to automatically stop all haptics on the EndPlay event, wherever the virtual hand component is used. By default, it's enabled.
- The Virtual Hand and the Wrist Tracker debug gizmos (the intended use is only for SenseGlove developers for really low-level stuff; thus won't affect the users of the plugin at all) have been disabled and will be ignored due to an esoteric bug in the settings systems which has been scheduled to be fixed in the future releases.
- This is the last release to support Unreal Engine `4.27` and please keep in mind that the current release is not obtainable through the Unreal Engine Marketplace. The latest published version on the Marketplace for `4.27` is `v1.3.1`. Per Epic's Marketplace policy regarding Code Plugins, we are only able to distribute or update the SenseGlove plugin for the last three stable versions of Unreal Engine. As a result, we won't be able to publish updates or bug fixes for the older versions of the Engine except on rare occasions and only through our official repository on Microsoft Azure DevOps.
This release breaks ABI/API compatibility with the previous versions in addition to breaking coordinates systems conversions between Unreal Engine and the SenseGlove libraries.
- Fix the wrist tracker miscalculations for the Quest 2 controllers (other headsets might need fixing as well, in that case, future releases will address that).
- Introduced the animated Virtual Hand Model (as a set of virtual hand and wrist tracker components and an actor) with in-editor animation availability.
- Exposed SenseGloveTypes as a public dependency in SenseGloveConnect and SenseGloveCore modules, so that the C++ users of the API don't need to explicitly add it as a dependency.
- Cleaned up the redundant headers/modules dependencies from SGCore headers.
