diff --git a/Source/SenseGloveTracking/Private/SGTracking/SGXRTracker.cpp b/Source/SenseGloveTracking/Private/SGTracking/SGXRTracker.cpp index e1e7b2f4..9c2ca6c8 100644 --- a/Source/SenseGloveTracking/Private/SGTracking/SGXRTracker.cpp +++ b/Source/SenseGloveTracking/Private/SGTracking/SGXRTracker.cpp @@ -85,6 +85,13 @@ struct FSGXRTracker::FImpl * Static methods ************************/ + /** + * Parses the enum name removing the prefix. + */ + static FName ParseEOpenXRHandKeypointEnumName(const FName& EnumName); + + static FName GetEControllerHandEnumName(const EControllerHand ControllerHand); + FORCEINLINE static bool ShouldFallbackToHandTrackingIfNoGloveDetected() { const USGSettings* Settings{USGSettings::GetInstance()}; @@ -139,133 +146,175 @@ struct FSGXRTracker::FImpl return Settings->GetTrackingSettings().WristTrackingSettings; } - FORCEINLINE static const FName& GetDefaultLeftMotionSourceName() + FORCEINLINE static const FName& GetDefaultLeftHandTrackingMotionSourceName() { static const FName Name(TEXT("Left")); return Name; } - FORCEINLINE static const FName& GetDefaultRightMotionSourceName() + FORCEINLINE static const FName& GetDefaultRightHandTrackingMotionSourceName() { static const FName Name(TEXT("Right")); return Name; } - FORCEINLINE static const FName& GetDefaultMotionSourceName(const EControllerHand Hand) + FORCEINLINE static const FName& GetDefaultHandTrackingMotionSourceName(const EControllerHand Hand) { const FName& Name{ Hand == EControllerHand::Right - ? GetDefaultRightMotionSourceName() - : GetDefaultLeftMotionSourceName() + ? GetDefaultRightHandTrackingMotionSourceName() + : GetDefaultLeftHandTrackingMotionSourceName() }; return Name; } - FORCEINLINE static const FName& GetDefaultMotionSourceName(const bool bRight) + FORCEINLINE static const FName& GetDefaultHandTrackingMotionSourceName(const bool bRight) { const FName& Name{ bRight - ? GetDefaultRightMotionSourceName() - : GetDefaultLeftMotionSourceName() + ? GetDefaultRightHandTrackingMotionSourceName() + : GetDefaultLeftHandTrackingMotionSourceName() }; return Name; } - FORCEINLINE static const FName& GetLegacyControllerLeftMotionSourceName() + FORCEINLINE static const FName& GetLegacyControllerLeftHandTrackingMotionSourceName() { static const FName Name(TEXT("Left")); return Name; } - FORCEINLINE static const FName& GetLegacyControllerRightMotionSourceName() + FORCEINLINE static const FName& GetLegacyControllerRightHandTrackingMotionSourceName() { static const FName Name(TEXT("Right")); return Name; } - FORCEINLINE static const FName& GetLegacyControllerMotionSourceName(const EControllerHand Hand) + FORCEINLINE static const FName& GetLegacyControllerHandTrackingMotionSourceName(const EControllerHand Hand) { const FName& Name{ Hand == EControllerHand::Right - ? GetLegacyControllerRightMotionSourceName() - : GetLegacyControllerLeftMotionSourceName() + ? GetLegacyControllerRightHandTrackingMotionSourceName() + : GetLegacyControllerLeftHandTrackingMotionSourceName() }; return Name; } - FORCEINLINE static const FName& GetLegacyControllerMotionSourceName(const bool bRight) + FORCEINLINE static const FName& GetLegacyControllerHandTrackingMotionSourceName(const bool bRight) { const FName& Name{ bRight - ? GetLegacyControllerRightMotionSourceName() - : GetLegacyControllerLeftMotionSourceName() + ? GetLegacyControllerRightHandTrackingMotionSourceName() + : GetLegacyControllerLeftHandTrackingMotionSourceName() }; return Name; } - FORCEINLINE static const FName& GetMoreSpecificLeftMotionSourceName() + FORCEINLINE static const FName& GetMoreSpecificLeftHandTrackingMotionSourceName() { static const FName Name(TEXT("HandTrackingLeft")); return Name; } - FORCEINLINE static const FName& GetMoreSpecificRightMotionSourceName() + FORCEINLINE static const FName& GetMoreSpecificRightHandTrackingMotionSourceName() { static const FName Name(TEXT("HandTrackingRight")); return Name; } - FORCEINLINE static const FName& GetMoreSpecificMotionSourceName(const EControllerHand Hand) + FORCEINLINE static const FName& GetMoreSpecificHandTrackingMotionSourceName(const EControllerHand Hand) { const FName& Name{ Hand == EControllerHand::Right - ? GetMoreSpecificRightMotionSourceName() - : GetMoreSpecificLeftMotionSourceName() + ? GetMoreSpecificRightHandTrackingMotionSourceName() + : GetMoreSpecificLeftHandTrackingMotionSourceName() }; return Name; } - FORCEINLINE static const FName& GetMoreSpecificMotionSourceName(const bool bRight) + FORCEINLINE static const FName& GetMoreSpecificHandTrackingMotionSourceName(const bool bRight) { const FName& Name{ bRight - ? GetMoreSpecificRightMotionSourceName() - : GetMoreSpecificLeftMotionSourceName() + ? GetMoreSpecificRightHandTrackingMotionSourceName() + : GetMoreSpecificLeftHandTrackingMotionSourceName() }; return Name; } - FORCEINLINE static const FName& GetLeftMotionSourceName() + FORCEINLINE static const FName& GetLeftHandTrackingMotionSourceName() { const bool bUseMoreSpecificMotionSourceNames = ShouldUseMoreSpecificMotionSourceNames(); const FName& Name{ bUseMoreSpecificMotionSourceNames - ? GetMoreSpecificLeftMotionSourceName() - : GetDefaultLeftMotionSourceName() + ? GetMoreSpecificLeftHandTrackingMotionSourceName() + : GetDefaultLeftHandTrackingMotionSourceName() }; return Name; } - FORCEINLINE static const FName& GetRightMotionSourceName() + FORCEINLINE static const FName& GetRightHandTrackingMotionSourceName() { const bool bUseMoreSpecificMotionSourceNames = ShouldUseMoreSpecificMotionSourceNames(); const FName& Name{ bUseMoreSpecificMotionSourceNames - ? GetMoreSpecificRightMotionSourceName() - : GetDefaultRightMotionSourceName() + ? GetMoreSpecificRightHandTrackingMotionSourceName() + : GetDefaultRightHandTrackingMotionSourceName() }; return Name; } - FORCEINLINE static const FName& GetMotionSourceName(const EControllerHand Hand) + FORCEINLINE static const FName& GetHandTrackingMotionSourceName(const EControllerHand Hand) { - const FName& Name{Hand == EControllerHand::Right ? GetRightMotionSourceName() : GetLeftMotionSourceName()}; + const FName& Name{ + Hand == EControllerHand::Right + ? GetRightHandTrackingMotionSourceName() + : GetLeftHandTrackingMotionSourceName()}; return Name; } - FORCEINLINE static const FName& GetMotionSourceName(const bool bRight) + FORCEINLINE static const FName& GetHandTrackingMotionSourceName(const bool bRight) { - const FName& Name{bRight ? GetRightMotionSourceName() : GetLeftMotionSourceName()}; + const FName& Name{ + bRight + ? GetRightHandTrackingMotionSourceName() + : GetLeftHandTrackingMotionSourceName() + }; + return Name; + } + + FORCEINLINE static FName GetLeftPositionalTrackingHardwareMotionSourceName() + { + const FName Name{ + GetEControllerHandEnumName(GetWristTrackingSettings().LeftHandMotionSource) + }; + return Name; + } + + FORCEINLINE static FName GetRightPositionalTrackingHardwareMotionSourceName() + { + const FName Name{ + GetEControllerHandEnumName(GetWristTrackingSettings().RightHandMotionSource) + }; + return Name; + } + + FORCEINLINE static FName GetPositionalTrackingHardwareMotionSourceName(const EControllerHand Hand) + { + const FName Name{ + Hand == EControllerHand::Right + ? GetRightPositionalTrackingHardwareMotionSourceName() + : GetLeftPositionalTrackingHardwareMotionSourceName()}; + return Name; + } + + FORCEINLINE static FName GetPositionalTrackingHardwareMotionSourceName(const bool bRight) + { + const FName& Name{ + bRight + ? GetRightPositionalTrackingHardwareMotionSourceName() + : GetLeftPositionalTrackingHardwareMotionSourceName() + }; return Name; } @@ -579,8 +628,25 @@ struct FSGXRTracker::FImpl * Methods ************************/ - FSGXRHandState& GetLeftHandState(); - FSGXRHandState& GetRightHandState(); + FORCEINLINE const FSGXRHandState& GetLeftHandState() const + { + return HandStates[0]; + } + + FORCEINLINE FSGXRHandState& GetLeftHandState() + { + return HandStates[0]; + } + + FORCEINLINE const FSGXRHandState& GetRightHandState() const + { + return HandStates[1]; + } + + FORCEINLINE FSGXRHandState& GetRightHandState() + { + return HandStates[1]; + } void BuildMotionSourceToKeypointMap(); @@ -588,52 +654,65 @@ struct FSGXRTracker::FImpl bool UpdateXRHandTrackingData(FSGXRHandState& OutHandState, const XrHandJointsLocateInfoEXT& LocateInfo) const; - bool GetOpenXRHandTrackingWristTransform(EControllerHand DeviceHand, FTransform& OutTransform) const; - bool GetOpenXRWristTransform(const EControllerHand DeviceHand, - const IMotionController* MotionController, const FName& MotionSource, - FTransform& OutTransform) const; - bool GetWristTransform(EControllerHand DeviceHand, - FTransform& OutTransform, bool& bOutMotionSourceHandTracking) const; + bool GetControllerTransform(const FName MotionSource, const float WorldToMetersScale, + FTransform& OutTransform, bool& bOutMotionSourceHandTracking) const; + + bool GetWristTransform(bool bRight, FTransform& OutTransform) const; bool UpdateSGJointData(FSGXRHandState& OutHandState, const EHandKeypoint Joint, - const FTransform& JointTransform, const FTransform& WristTransform, - bool bMotionSourceHandTracking) const; + const FTransform& JointTransform, const FTransform& WristTransform) const; - bool UpdateSGWristJointData(FSGXRHandState& OutHandState, - const FTransform& WristTransform, bool bMotionSourceHandTracking) const; + bool UpdateSGWristJointData(FSGXRHandState& OutHandState, const FTransform& WristTransform) const; - bool UpdateSGPalmJointData( - FSGXRHandState& OutHandState, EControllerHand DeviceHand, - const FTransform& WristTransform, bool bMotionSourceHandTracking) const; + bool UpdateSGPalmJointData(FSGXRHandState& OutHandState, bool bRight, const FTransform& WristTransform) const; bool UpdateSGThumbJointData( FSGXRHandState& OutHandState, const TArray>& JointLocations, const TArray>& JointRotations, - const FTransform& WristTransform, bool bMotionSourceHandTracking) const; + const FTransform& WristTransform) const; bool UpdateSGIndexJointData( - FSGXRHandState& OutHandState, EControllerHand DeviceHand, + FSGXRHandState& OutHandState, bool bRight, const TArray>& JointLocations, const TArray>& JointRotations, - const FTransform& WristTransform, bool bMotionSourceHandTracking) const; + const FTransform& WristTransform) const; bool UpdateSGMiddleJointData( - FSGXRHandState& OutHandState, EControllerHand DeviceHand, + FSGXRHandState& OutHandState, bool bRight, const TArray>& JointLocations, const TArray>& JointRotations, - const FTransform& WristTransform, bool bMotionSourceHandTracking) const; + const FTransform& WristTransform) const; bool UpdateSGRingJointData( - FSGXRHandState& OutHandState, EControllerHand DeviceHand, + FSGXRHandState& OutHandState, bool bRight, const TArray>& JointLocations, const TArray>& JointRotations, - const FTransform& WristTransform, bool bMotionSourceHandTracking) const; + const FTransform& WristTransform) const; bool UpdateSGLittleJointData( - FSGXRHandState& OutHandState, EControllerHand DeviceHand, + FSGXRHandState& OutHandState, bool bRight, const TArray>& JointLocations, const TArray>& JointRotations, - const FTransform& WristTransform, bool bMotionSourceHandTracking) const; + const FTransform& WristTransform) const; - bool UpdateSGHandState(const EControllerHand DeviceHand, FSGXRHandState& OutHandState) const; + bool UpdateSGHandState(bool bRight, FSGXRHandState& OutHandState) const; }; +FName FSGXRTracker::FImpl::ParseEOpenXRHandKeypointEnumName(const FName& EnumName) +{ + static const int32 EnumNameLength = FString{TEXT("EHandKeypoint::")}.Len(); + const FString EnumString{EnumName.ToString()}; + const FName ParsedName{*EnumString.Right(EnumString.Len() - EnumNameLength)}; + return ParsedName; +} + +FName FSGXRTracker::FImpl::GetEControllerHandEnumName(const EControllerHand ControllerHand) +{ + static const int32 EnumNameLength = FString{TEXT("EControllerHand::")}.Len(); + const FName EnumName{ + StaticEnum()->GetNameByValue(static_cast(ControllerHand)) + }; + const FString EnumString{EnumName.ToString()}; + const FName ParsedName{*EnumString.Right(EnumString.Len() - EnumNameLength)}; + return ParsedName; +} + ESGPositionalTrackingHardware FSGXRTracker::FImpl::GetPositionalTrackingHardware() { ESGPositionalTrackingHardware TrackerHardware = GetWristTrackingSettings().TrackingHardware; @@ -896,14 +975,6 @@ FTransform FSGXRTracker::FImpl::GetMeshFingerStartBoneRefTransform( return Transform; } -FName FSGXRTracker::ParseEOpenXRHandKeypointEnumName(const FName& EnumName) -{ - static const int32 EnumNameLength = FString{TEXT("EHandKeypoint::")}.Len(); - const FString EnumString{EnumName.ToString()}; - const FName ParsedName{*EnumString.Right(EnumString.Len() - EnumNameLength)}; - return ParsedName; -} - FSGXRTracker::FSGXRTracker(const TSharedRef& InMessageHandler) : Pimpl(TUniquePtr(new FImpl{this}, PimplDeleter)) { @@ -1065,14 +1136,14 @@ void FSGXRTracker::UpdateDeviceLocations( /// It's necessary to call the UpdateXRHandTrackingData first for the wrist tracking to work properly when the /// motion controllers are not active and we rely on the OpenXRHandTracking data for wrist tracking. /// See the NOTE inside the FSGXRTracker::FImpl::GetWristTransform method. - Pimpl->UpdateXRHandTrackingData(Pimpl->HandStates[0], LocateInfo); - Pimpl->UpdateSGHandState(EControllerHand::Left, Pimpl->HandStates[0]); + Pimpl->UpdateXRHandTrackingData(Pimpl->GetLeftHandState(), LocateInfo); + Pimpl->UpdateSGHandState(false, Pimpl->GetLeftHandState()); } else { if (bFallbackToHandTrackingIfNoGloveDetected) { - Pimpl->UpdateXRHandTrackingData(Pimpl->HandStates[0], LocateInfo); + Pimpl->UpdateXRHandTrackingData(Pimpl->GetLeftHandState(), LocateInfo); } } @@ -1083,14 +1154,14 @@ void FSGXRTracker::UpdateDeviceLocations( /// It's necessary to call the UpdateXRHandTrackingData first for the wrist tracking to work properly when the /// motion controllers are not active and we rely on the OpenXRHandTracking data for wrist tracking. /// See the NOTE inside the FSGXRTracker::FImpl::GetWristLocationAndRotation method. - Pimpl->UpdateXRHandTrackingData(Pimpl->HandStates[1], LocateInfo); - Pimpl->UpdateSGHandState(EControllerHand::Right, Pimpl->HandStates[1]); + Pimpl->UpdateXRHandTrackingData(Pimpl->GetRightHandState(), LocateInfo); + Pimpl->UpdateSGHandState(true, Pimpl->GetRightHandState()); } else { if (bFallbackToHandTrackingIfNoGloveDetected) { - Pimpl->UpdateXRHandTrackingData(Pimpl->HandStates[1], LocateInfo); + Pimpl->UpdateXRHandTrackingData(Pimpl->GetRightHandState(), LocateInfo); } } } @@ -1122,82 +1193,20 @@ bool FSGXRTracker::GetControllerOrientationAndPosition(const int32 ControllerInd return false; } - bool bTracked = false; - - FTransform ControllerTransform{FTransform::Identity}; - #if ENGINE_MAJOR_VERSION >= 5 && ENGINE_MINOR_VERSION <= 2 - const FName& MotionSource{StaticEnum()->GetNameByValue(static_cast(DeviceHand))}; + const FName& MotionSource{GetEControllerHandEnumName(DeviceHand)}; #endif /* ENGINE_MAJOR_VERSION >= 5 && ENGINE_MINOR_VERSION <= 2 */ - const bool bFallbackToHandTrackingIfNoGloveDetected = FImpl::ShouldFallbackToHandTrackingIfNoGloveDetected(); - if (bFallbackToHandTrackingIfNoGloveDetected) - { - const FImpl::FSGMotionSourceInfo* KeyPointInfoPtr{Pimpl->MotionSourceToKeypointMap.Find(MotionSource)}; - if (KeyPointInfoPtr) - { - const EHandKeypoint KeyPoint = KeyPointInfoPtr->Key; - const bool bIsLeft = KeyPointInfoPtr->Value; - if (bIsLeft) - { - ControllerTransform = GetLeftHandState().GetTransform(KeyPoint); - bTracked = !!GetLeftHandState().bReceivedJointPoses; - } - else - { - ControllerTransform = GetRightHandState().GetTransform(KeyPoint); - bTracked = !!GetRightHandState().bReceivedJointPoses; - } - } - } + FTransform ControllerTransform; + bool bMotionSourceHandTracking; + const bool bGotTransform = Pimpl->GetControllerTransform(MotionSource, WorldToMetersScale, + ControllerTransform, bMotionSourceHandTracking); + (void)bMotionSourceHandTracking; - if (bTracked) - { - OutPosition = ControllerTransform.GetLocation(); - OutOrientation = ControllerTransform.GetRotation().Rotator(); - } - else - { - static const FName OpenXRName{TEXT("OpenXR")}; + OutOrientation = ControllerTransform.GetRotation().Rotator(); + OutPosition = ControllerTransform.GetLocation(); - static constexpr int32 CurrentPlayerControllerIndex = 0; - - const TArray MotionControllers{ - IModularFeatures::Get().GetModularFeatureImplementations( - IMotionController::GetModularFeatureName()) - }; - - for (const IMotionController* MotionController: MotionControllers) - { - if (!MotionController) - { - continue; - } - - const FName DeviceTypeName{MotionController->GetMotionControllerDeviceTypeName()}; - if (DeviceTypeName != OpenXRName) - { - continue; - } - - const ETrackingStatus TrackingStatus = MotionController->GetControllerTrackingStatus( - CurrentPlayerControllerIndex, MotionSource); - if (TrackingStatus == ETrackingStatus::NotTracked) - { - continue; - } - - const bool bGotTransform = MotionController->GetControllerOrientationAndPosition( - ControllerIndex, MotionSource, OutOrientation, OutPosition, WorldToMetersScale); - if (bGotTransform) - { - bTracked = true; - break; - } - } - } - - return bTracked; + return bGotTransform; } #if ENGINE_MAJOR_VERSION >= 5 && ENGINE_MINOR_VERSION >= 3 @@ -1213,25 +1222,29 @@ ETrackingStatus FSGXRTracker::GetControllerTrackingStatus(const int32 Controller } #if ENGINE_MAJOR_VERSION >= 5 && ENGINE_MINOR_VERSION <= 2 - const FName& MotionSource{StaticEnum()->GetNameByValue(static_cast(DeviceHand))}; + const FName& MotionSource{GetEControllerHandEnumName(DeviceHand)}; #endif /* ENGINE_MAJOR_VERSION >= 5 && ENGINE_MINOR_VERSION <= 2 */ const FImpl::FSGMotionSourceInfo* KeyPointInfoPtr{Pimpl->MotionSourceToKeypointMap.Find(MotionSource)}; - if (KeyPointInfoPtr) + if (!KeyPointInfoPtr) { - const bool bIsLeft = KeyPointInfoPtr->Value; + return ETrackingStatus::NotTracked; + } - if ((bIsLeft && FImpl::IsLeftGloveConnected()) || (!bIsLeft && FImpl::IsRightGloveConnected())) - { - return ETrackingStatus::Tracked; - } + const bool bRight = !KeyPointInfoPtr->Value; - const bool bFallbackToHandTrackingIfNoGloveDetected = FImpl::ShouldFallbackToHandTrackingIfNoGloveDetected(); - if (bFallbackToHandTrackingIfNoGloveDetected) - { - const FSGXRHandState& HandState{bIsLeft ? GetLeftHandState() : GetRightHandState()}; - return !!HandState.bReceivedJointPoses ? ETrackingStatus::Tracked : ETrackingStatus::NotTracked; - } + const bool bGlovePresent = + (bRight && FImpl::IsRightGloveConnected()) || (!bRight && FImpl::IsLeftGloveConnected()); + if (bGlovePresent) + { + return ETrackingStatus::Tracked; + } + + const bool bFallbackToHandTrackingIfNoGloveDetected = FImpl::ShouldFallbackToHandTrackingIfNoGloveDetected(); + if (bFallbackToHandTrackingIfNoGloveDetected) + { + const FSGXRHandState& HandState{bRight ? GetRightHandState() : GetLeftHandState()}; + return !!HandState.bReceivedJointPoses ? ETrackingStatus::Tracked : ETrackingStatus::NotTracked; } return ETrackingStatus::NotTracked; @@ -1254,12 +1267,12 @@ void FSGXRTracker::EnumerateSources(TArray& SourcesOut) }; ensureAlwaysMsgf(EnumPtr, TEXT("Failed to find the HMD hand keypoint!")); - const FName& Left(FImpl::GetLeftMotionSourceName()); - const FName& Right(FImpl::GetRightMotionSourceName()); + const FName& Left(FImpl::GetLeftHandTrackingMotionSourceName()); + const FName& Right(FImpl::GetRightHandTrackingMotionSourceName()); for (int32 Keypoint = 0; Keypoint < EHandKeypointCount; Keypoint++) { - const FString EnumString{ParseEOpenXRHandKeypointEnumName(EnumPtr->GetNameByValue(Keypoint)).ToString()}; + const FString EnumString{FImpl::ParseEOpenXRHandKeypointEnumName(EnumPtr->GetNameByValue(Keypoint)).ToString()}; const FString StringLeft{FString::Printf(TEXT("%s%s"), *Left.ToString(), *EnumString)}; const FString StringRight{FString::Printf(TEXT("%s%s"), *Right.ToString(), *EnumString)}; FName SourceL(*(StringLeft)); @@ -1340,26 +1353,11 @@ bool FSGXRTracker::GetKeypointState( return false; } - bool bGotTransform = false; - - /// NOTE - // Currently there is no OpenXR input simulation implementation. Maybe we will do that soon though? Leaving this - // for reference for now. - //#if WITH_INPUT_SIMULATION - // if (auto* InputSim = UOpenXRInputSimulationEngineSubsystem::GetInputSimulationIfEnabled()) - // { - // bGotTransform = InputSim->GetHandJointTransform(Hand, Keypoint, OutTransform); - // OutRadius = FSGXRHandState.Radii[static_cast(Keypoint)]; - // } - // else - //#endif - { - const FSGXRHandState& HandState{ - Hand == EControllerHand::Left ? GetLeftHandState() : GetRightHandState() - }; - bGotTransform = HandState.GetTransform(Keypoint, OutTransform); - OutRadius = HandState.Radii[static_cast(Keypoint)]; - } + const FSGXRHandState& HandState{ + Hand == EControllerHand::Left ? GetLeftHandState() : GetRightHandState() + }; + const bool bGotTransform = HandState.GetTransform(Keypoint, OutTransform); + OutRadius = HandState.Radii[static_cast(Keypoint)]; if (bGotTransform) { @@ -1444,16 +1442,6 @@ FSGXRTracker::FImpl::FImpl(FSGXRTracker* InOwner) FSGXRTracker::FImpl::~FImpl() = default; -FSGXRHandState& FSGXRTracker::FImpl::GetLeftHandState() -{ - return HandStates[0]; -} - -FSGXRHandState& FSGXRTracker::FImpl::GetRightHandState() -{ - return HandStates[1]; -} - void FSGXRTracker::FImpl::BuildMotionSourceToKeypointMap() { if (!MotionSourceToKeypointMap.IsEmpty()) @@ -1475,8 +1463,8 @@ void FSGXRTracker::FImpl::BuildMotionSourceToKeypointMap() ensureAlwaysMsgf(IsInGameThread(), TEXT("Is not in the game thread!")); - const FName& Left(GetLeftMotionSourceName()); - const FName& Right(GetRightMotionSourceName()); + const FName& Left(GetLeftHandTrackingMotionSourceName()); + const FName& Right(GetRightHandTrackingMotionSourceName()); for (int64 e = 0; e < EHandKeypointCount; ++e) { @@ -1491,13 +1479,27 @@ void FSGXRTracker::FImpl::BuildMotionSourceToKeypointMap() if (bSupportLegacyControllerMotionSources) { - const FName& LeftLegacyControllerMotionSourceName{GetLegacyControllerLeftMotionSourceName()}; - const FName& RightLegacyControllerMotionSourceName{GetLegacyControllerRightMotionSourceName()}; + const FName& LeftLegacyControllerHandTrackingMotionSourceName{ + GetLegacyControllerLeftHandTrackingMotionSourceName()}; + const FName& RightLegacyControllerHandTrackingMotionSourceName{ + GetLegacyControllerRightHandTrackingMotionSourceName()}; MotionSourceToKeypointMap.Add( - LeftLegacyControllerMotionSourceName, FSGMotionSourceInfo(EHandKeypoint::Wrist, true)); + LeftLegacyControllerHandTrackingMotionSourceName, FSGMotionSourceInfo(EHandKeypoint::Wrist, true)); MotionSourceToKeypointMap.Add( - RightLegacyControllerMotionSourceName, FSGMotionSourceInfo(EHandKeypoint::Wrist, false)); + RightLegacyControllerHandTrackingMotionSourceName, FSGMotionSourceInfo(EHandKeypoint::Wrist, false)); } + + FSGWristTrackingSettings WristTrackingSettings{GetWristTrackingSettings()}; + const FName LeftHandSGMotionSourceName{ + GetEControllerHandEnumName(WristTrackingSettings.LeftHandMotionSource) + }; + const FName RightHandSGMotionSourceName{ + GetEControllerHandEnumName(WristTrackingSettings.RightHandMotionSource) + }; + MotionSourceToKeypointMap.Add( + LeftHandSGMotionSourceName, FSGMotionSourceInfo(EHandKeypoint::Wrist, true)); + MotionSourceToKeypointMap.Add( + RightHandSGMotionSourceName, FSGMotionSourceInfo(EHandKeypoint::Wrist, false)); } bool FSGXRTracker::FImpl::CanOutputTrackingData(const EControllerHand Hand) const @@ -1555,184 +1557,204 @@ bool FSGXRTracker::FImpl::UpdateXRHandTrackingData( } return true; - - return false; } -bool FSGXRTracker::FImpl::GetOpenXRHandTrackingWristTransform( - const EControllerHand DeviceHand, FTransform& OutTransform) const +bool FSGXRTracker::FImpl::GetControllerTransform( + const FName MotionSource, const float WorldToMetersScale, + FTransform& OutTransform, bool& bOutMotionSourceHandTracking) const { - if (!ensureAlwaysMsgf(XRTrackingSystem, TEXT("Invalid XR tracking system!"))) + const FSGMotionSourceInfo* KeyPointInfoPtr{MotionSourceToKeypointMap.Find(MotionSource)}; + if (!KeyPointInfoPtr) { return false; } - UWorld* World{FSGEngineUtils::GetWorld()}; - - FXRMotionControllerData MotionControllerData; - XRTrackingSystem->GetMotionControllerData(World, DeviceHand, MotionControllerData); - if (!MotionControllerData.bValid) - { - return false; - } - - static constexpr int32_t WristJointIndex = static_cast(EHandKeypoint::Wrist); - OutTransform = FTransform{ - MotionControllerData.HandKeyRotations[WristJointIndex], - MotionControllerData.HandKeyPositions[WristJointIndex] - }; - - return true; -} - -bool FSGXRTracker::FImpl::GetOpenXRWristTransform( - const EControllerHand DeviceHand, - const IMotionController* MotionController, const FName& MotionSource, - FTransform& OutTransform) const -{ - static constexpr int32 CurrentPlayerControllerIndex = 0; - - const UWorld* World{FSGEngineUtils::GetWorld()}; - const float WorldToMetersScale = World ? World->GetWorldSettings()->WorldToMeters : 100.0f; - - FVector TrackerLocation; - FRotator TrackerRotation; - const bool bGotTransform = MotionController->GetControllerOrientationAndPosition( - CurrentPlayerControllerIndex, MotionSource, TrackerRotation, TrackerLocation, WorldToMetersScale); - if (!bGotTransform) - { - return false; - } - - const FSGWristTrackingSettings& Settings{GetWristTrackingSettings()}; - - const bool bIsRight = DeviceHand == Settings.RightHandMotionSource; - - const ESGPositionalTrackingHardware TrackingHardware = GetPositionalTrackingHardware(); - if (TrackingHardware == ESGPositionalTrackingHardware::Custom) - { - if (bIsRight) - { - TrackerLocation += Settings.TrackingHardwareLocationOffsetRightHand; - TrackerRotation += Settings.TrackingHardwareRotationOffsetRightHand; - } - else - { - TrackerLocation += Settings.TrackingHardwareLocationOffsetLeftHand; - TrackerRotation += Settings.TrackingHardwareRotationOffsetLeftHand; - } - } - - const USGHapticGlove* Glove{GetGlove(bIsRight)}; - if (!IsValid(Glove)) - { - return false; - } - - FVector WristLocation; - FRotator WristRotation; - Glove->GetWristLocation(TrackerLocation, TrackerRotation, TrackingHardware, - WristLocation, WristRotation); - - OutTransform = FTransform{MoveTemp(WristRotation), MoveTemp(WristLocation)}; - - return true; -} - -bool FSGXRTracker::FImpl::GetWristTransform( - const EControllerHand DeviceHand, FTransform& OutTransform, bool& bOutMotionSourceHandTracking) const -{ - static const FName OpenXRName{TEXT("OpenXR")}; - static const FName OpenXRHandTrackingName{TEXT("OpenXRHandTracking")}; - - static constexpr int32 CurrentPlayerControllerIndex = 0; - - const FName& OpenXRMotionSource{GetDefaultMotionSourceName(DeviceHand)}; - const FName& OpenXRHandTrackingMotionSource{GetMotionSourceName(DeviceHand)}; - + const bool bRight = !KeyPointInfoPtr->Value; + const bool bGlovePresent = + (bRight && IsRightGloveConnected()) || (!bRight && IsLeftGloveConnected()); const bool bFallbackToHandTrackingIfNoGloveDetected = ShouldFallbackToHandTrackingIfNoGloveDetected(); - const TArray MotionControllers{IModularFeatures::Get().GetModularFeatureImplementations< - IMotionController>(IMotionController::GetModularFeatureName())}; - - for (const IMotionController* MotionController: MotionControllers) + if (!bGlovePresent && !bFallbackToHandTrackingIfNoGloveDetected) { - if (!MotionController) + return false; + } + + static const FName OpenXRName{TEXT("OpenXR")}; + static const FName OpenXRViveTrackerName{TEXT("OpenXRViveTracker")}; + + const FSGWristTrackingSettings& WristTrackingSettings{GetWristTrackingSettings()}; + const EControllerHand PositionalTrackingHardwareHand = + bRight + ? WristTrackingSettings.RightHandMotionSource + : WristTrackingSettings.LeftHandMotionSource; + const FName& PositionalTrackingHardwareMotionSource{ + GetEControllerHandEnumName(PositionalTrackingHardwareHand) + }; + + bool bTracked = false; + + if (MotionSource == PositionalTrackingHardwareMotionSource) + { + const TArray MotionControllers{ + IModularFeatures::Get().GetModularFeatureImplementations( + IMotionController::GetModularFeatureName()) + }; + + bool bLookingForViveTrackers = false; + if (WristTrackingSettings.TrackingHardware == ESGPositionalTrackingHardware::ViveTracker + || WristTrackingSettings.TrackingHardware == ESGPositionalTrackingHardware::ViveFocus3WristTracker) { - continue; + bLookingForViveTrackers = true; + } + else if (WristTrackingSettings.TrackingHardware == ESGPositionalTrackingHardware::None) + { + const bool bIsAHtcViveDevice = FSGHMDTracker::IsAHtcViveDevice(); + if (bIsAHtcViveDevice) + { + bLookingForViveTrackers = true; + } } - const ETrackingStatus OpenXRMotionSourceTrackingStatus = - MotionController->GetControllerTrackingStatus(CurrentPlayerControllerIndex, OpenXRMotionSource); - - if (bFallbackToHandTrackingIfNoGloveDetected) + for (const IMotionController* MotionController: MotionControllers) { - const ETrackingStatus OpenXRHandTrackingMotionSourceTrackingStatus = - MotionController->GetControllerTrackingStatus( - CurrentPlayerControllerIndex, OpenXRHandTrackingMotionSource); - if (OpenXRMotionSourceTrackingStatus == ETrackingStatus::NotTracked - && OpenXRHandTrackingMotionSourceTrackingStatus == ETrackingStatus::NotTracked) + if (!MotionController) { continue; } + + const ETrackingStatus TrackingStatus = MotionController->GetControllerTrackingStatus( + DeviceIndex, PositionalTrackingHardwareMotionSource); + if (TrackingStatus == ETrackingStatus::NotTracked) + { + continue; + } + + if (bLookingForViveTrackers) + { + const FName DeviceTypeName{MotionController->GetMotionControllerDeviceTypeName()}; + if (DeviceTypeName != OpenXRViveTrackerName) + { + continue; + } + } + else + { + const FName DeviceTypeName{MotionController->GetMotionControllerDeviceTypeName()}; + if (DeviceTypeName != OpenXRName) + { + continue; + } + } + + FRotator Orientation; + FVector Position; + const bool bGotTransform = MotionController->GetControllerOrientationAndPosition( + DeviceIndex, PositionalTrackingHardwareMotionSource, + Orientation, Position, WorldToMetersScale); + if (bGotTransform) + { + OutTransform = FTransform{Orientation, Position}; + bOutMotionSourceHandTracking = false; + bTracked = true; + break; + } + } + } + + if (!bTracked && bFallbackToHandTrackingIfNoGloveDetected) + { + const FSGXRHandState& HandState{bRight ? Owner->GetRightHandState() : Owner->GetLeftHandState()}; + if (!HandState.bReceivedJointPoses) + { + return false; + } + + const EHandKeypoint KeyPoint = KeyPointInfoPtr->Key; + const FTransform& ControllerTransform{ + bRight + ? GetRightHandState().GetTransform(KeyPoint) + : GetLeftHandState().GetTransform(KeyPoint) + }; + + OutTransform = ControllerTransform; + bOutMotionSourceHandTracking = true; + bTracked = true; + } + + return bTracked; +} + +bool FSGXRTracker::FImpl::GetWristTransform(const bool bRight, FTransform& OutTransform) const +{ + const FSGWristTrackingSettings& WristTrackingSettings{GetWristTrackingSettings()}; + const EControllerHand PositionalTrackingHardwareHand = + bRight + ? WristTrackingSettings.RightHandMotionSource + : WristTrackingSettings.LeftHandMotionSource; + const FName& MotionSource{ + GetEControllerHandEnumName(PositionalTrackingHardwareHand) + }; + const float WorldToMetersScale = XRTrackingSystem->GetWorldToMetersScale(); + + bool bMotionSourceHandTracking = false; + FTransform ControllerTransform; + const bool bGotTransform = GetControllerTransform( + MotionSource, WorldToMetersScale, ControllerTransform, bMotionSourceHandTracking); + + if (bGotTransform) + { + if (bMotionSourceHandTracking) + { + OutTransform = MoveTemp(ControllerTransform); } else { - if (OpenXRMotionSourceTrackingStatus == ETrackingStatus::NotTracked) + if (WristTrackingSettings.TrackingHardware == ESGPositionalTrackingHardware::Custom) { - continue; + if (bRight) + { + ControllerTransform.SetRotation( + (ControllerTransform.GetRotation().Rotator() + + WristTrackingSettings.TrackingHardwareRotationOffsetRightHand).Quaternion()); + ControllerTransform.SetLocation( + ControllerTransform.GetLocation() + + WristTrackingSettings.TrackingHardwareLocationOffsetRightHand); + } + else + { + ControllerTransform.SetRotation( + (ControllerTransform.GetRotation().Rotator() + + WristTrackingSettings.TrackingHardwareRotationOffsetLeftHand).Quaternion()); + ControllerTransform.SetLocation( + ControllerTransform.GetLocation() + + WristTrackingSettings.TrackingHardwareLocationOffsetLeftHand); + } } - } - const FName DeviceTypeName{MotionController->GetMotionControllerDeviceTypeName()}; - - /// NOTE - // We have to always check the wrist tracking data from the OpenXRHandTracking system instead of OpenXR, - // otherwise even if the motion controllers become deactivated their tracking status sometimes mysteriously - // reported as Tracked. - - if (bFallbackToHandTrackingIfNoGloveDetected) - { - if (DeviceTypeName == OpenXRHandTrackingName) + const USGHapticGlove* Glove{GetGlove(bRight)}; + if (!IsValid(Glove)) { - bOutMotionSourceHandTracking = true; - // const bool bResult = GetOpenXRHandTrackingWristTransform(DeviceHand, OutTransform); - const bool bResult = GetOpenXRWristTransform( - DeviceHand, MotionController, OpenXRHandTrackingMotionSource, OutTransform); - return bResult; + return false; } - } - if (DeviceTypeName == OpenXRName) - { - bOutMotionSourceHandTracking = true; - const bool bResult = GetOpenXRWristTransform( - DeviceHand, MotionController, OpenXRMotionSource, OutTransform); - return bResult; + FVector WristLocation; + FRotator WristRotation; + Glove->GetWristLocation( + ControllerTransform.GetLocation(), + ControllerTransform.GetRotation().Rotator(), + WristTrackingSettings.TrackingHardware, + WristLocation, WristRotation); + + OutTransform = FTransform{MoveTemp(WristRotation), MoveTemp(WristLocation)}; } } - /// WORKAROUND - // Sometimes the motion controller array does not contain a OpenXRHandTracking though it's being tracked! So, as a - // last resort we always attempt at retrieving the OpenXRHandTracking wrist transform in case all other measures we - // have taken has already failed! - if (bFallbackToHandTrackingIfNoGloveDetected) - { - const bool bResult = GetOpenXRHandTrackingWristTransform(DeviceHand, OutTransform); - if (bResult) - { - bOutMotionSourceHandTracking = true; - } - return bResult; - } - - return false; + return bGotTransform; } bool FSGXRTracker::FImpl::UpdateSGJointData( FSGXRHandState& OutHandState, const EHandKeypoint Joint, - const FTransform& JointTransform, const FTransform& WristTransform, - const bool bMotionSourceHandTracking) const + const FTransform& JointTransform, const FTransform& WristTransform) const { if (!ensureAlwaysMsgf(XRTrackingSystem, TEXT("Invalid XR tracking system!"))) { @@ -1750,20 +1772,10 @@ bool FSGXRTracker::FImpl::UpdateSGJointData( const FQuat JointRotation{JointTransform.GetRotation()}; const FVector JointLocation{JointTransform.GetLocation()}; - FTransform Transform; - if (bMotionSourceHandTracking) - { - XrPosef Pose; - Pose.orientation = ToXrQuat(WristRotation * JointRotation); - Pose.position = ToXrVector(WristLocation + (WristRotation * JointLocation), WorldToMetersScale); - Transform = ToFTransform(MoveTemp(Pose), WorldToMetersScale); - Transform *= WorldToTrackingTransform; - } - else - { - Transform.SetRotation(WristRotation * JointRotation); - Transform.SetLocation(WristLocation + (WristRotation * JointLocation)); - } + FTransform Transform{ + WristRotation * JointRotation, + WristLocation + (WristRotation * JointLocation) + }; OutHandState.KeypointTransforms[JointIndex] = MoveTemp(Transform); OutHandState.Radii[JointIndex] = 0.01f * WorldToMetersScale; @@ -1772,8 +1784,7 @@ bool FSGXRTracker::FImpl::UpdateSGJointData( } bool FSGXRTracker::FImpl::UpdateSGWristJointData( - FSGXRHandState& OutHandState, - const FTransform& WristTransform, const bool bMotionSourceHandTracking) const + FSGXRHandState& OutHandState, const FTransform& WristTransform) const { if (!ensureAlwaysMsgf(XRTrackingSystem, TEXT("Invalid XR tracking system!"))) { @@ -1781,47 +1792,29 @@ bool FSGXRTracker::FImpl::UpdateSGWristJointData( } const FTransform& TrackingToWorldTransform{XRTrackingSystem->GetTrackingToWorldTransform()}; - const FTransform& WorldToTrackingTransform{TrackingToWorldTransform.Inverse()}; const float WorldToMetersScale = XRTrackingSystem->GetWorldToMetersScale(); static constexpr EHandKeypoint Joint = EHandKeypoint::Wrist; static constexpr int32_t JointIndex = static_cast(Joint); - FTransform Transform; - if (bMotionSourceHandTracking) - { - XrPosef Pose; - Pose.orientation = ToXrQuat(WristTransform.GetRotation()); - Pose.position = ToXrVector(WristTransform.GetLocation(), WorldToMetersScale); - Transform = ToFTransform(MoveTemp(Pose), WorldToMetersScale); - Transform *= WorldToTrackingTransform; - } - else - { - Transform.SetRotation(WristTransform.GetRotation()); - Transform.SetLocation(WristTransform.GetLocation()); - } - - OutHandState.KeypointTransforms[JointIndex] = MoveTemp(Transform); + OutHandState.KeypointTransforms[JointIndex] = WristTransform; OutHandState.Radii[JointIndex] = 0.01f * WorldToMetersScale; return true; } bool FSGXRTracker::FImpl::UpdateSGPalmJointData( - FSGXRHandState& OutHandState, const EControllerHand DeviceHand, - const FTransform& WristTransform, const bool bMotionSourceHandTracking) const + FSGXRHandState& OutHandState, const bool bRight, const FTransform& WristTransform) const { if (!ensureAlwaysMsgf(XRTrackingSystem, TEXT("Invalid XR tracking system!"))) { return false; } - FTransform JointTransform{GetMeshWristChildBoneRefTransform(DeviceHand, EHandKeypoint::Palm)}; + FTransform JointTransform{GetMeshWristChildBoneRefTransform(bRight, EHandKeypoint::Palm)}; if (!UpdateSGJointData(OutHandState, EHandKeypoint::Palm, - MoveTemp(JointTransform), WristTransform, - bMotionSourceHandTracking)) + MoveTemp(JointTransform), WristTransform)) { return false; } @@ -1832,7 +1825,7 @@ bool FSGXRTracker::FImpl::UpdateSGPalmJointData( bool FSGXRTracker::FImpl::UpdateSGThumbJointData( FSGXRHandState& OutHandState, const TArray>& JointLocations, const TArray>& JointRotations, - const FTransform& WristTransform, const bool bMotionSourceHandTracking) const + const FTransform& WristTransform) const { static constexpr int32 ThumbFingerIndex = 0; static constexpr int32 ThumbMetacarpalJointIndex = 0; @@ -1859,28 +1852,28 @@ bool FSGXRTracker::FImpl::UpdateSGThumbJointData( if (!UpdateSGJointData( OutHandState, EHandKeypoint::ThumbMetacarpal, - MoveTemp(ThumbMetacarpalTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(ThumbMetacarpalTransform), WristTransform)) { return false; } if (!UpdateSGJointData( OutHandState, EHandKeypoint::ThumbProximal, - MoveTemp(ThumbProximalTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(ThumbProximalTransform), WristTransform)) { return false; } if (!UpdateSGJointData( OutHandState, EHandKeypoint::ThumbDistal, - MoveTemp(ThumbDistalTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(ThumbDistalTransform), WristTransform)) { return false; } if (!UpdateSGJointData( OutHandState, EHandKeypoint::ThumbTip, - MoveTemp(ThumbTipTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(ThumbTipTransform), WristTransform)) { return false; } @@ -1889,9 +1882,9 @@ bool FSGXRTracker::FImpl::UpdateSGThumbJointData( } bool FSGXRTracker::FImpl::UpdateSGIndexJointData( - FSGXRHandState& OutHandState, const EControllerHand DeviceHand, + FSGXRHandState& OutHandState, const bool bRight, const TArray>& JointLocations, const TArray>& JointRotations, - const FTransform& WristTransform, const bool bMotionSourceHandTracking) const + const FTransform& WristTransform) const { static constexpr int32 IndexFingerIndex = 1; @@ -1901,7 +1894,7 @@ bool FSGXRTracker::FImpl::UpdateSGIndexJointData( static constexpr int32 IndexTipJointIndex = 3; FTransform IndexMetacarpalTransform{ - GetMeshWristChildBoneRefTransform(DeviceHand, EHandKeypoint::IndexMetacarpal) + GetMeshWristChildBoneRefTransform(bRight, EHandKeypoint::IndexMetacarpal) }; FTransform IndexProximalTransform{ JointRotations[IndexFingerIndex][IndexProximalJointIndex], @@ -1922,35 +1915,35 @@ bool FSGXRTracker::FImpl::UpdateSGIndexJointData( if (!UpdateSGJointData( OutHandState, EHandKeypoint::IndexMetacarpal, - MoveTemp(IndexMetacarpalTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(IndexMetacarpalTransform), WristTransform)) { return false; } if (!UpdateSGJointData( OutHandState, EHandKeypoint::IndexProximal, - MoveTemp(IndexProximalTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(IndexProximalTransform), WristTransform)) { return false; } if (!UpdateSGJointData( OutHandState, EHandKeypoint::IndexIntermediate, - MoveTemp(IndexIntermediateTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(IndexIntermediateTransform), WristTransform)) { return false; } if (!UpdateSGJointData( OutHandState, EHandKeypoint::IndexDistal, - MoveTemp(IndexDistalTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(IndexDistalTransform), WristTransform)) { return false; } if (!UpdateSGJointData( OutHandState, EHandKeypoint::IndexTip, - MoveTemp(IndexTipTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(IndexTipTransform), WristTransform)) { return false; } @@ -1959,9 +1952,9 @@ bool FSGXRTracker::FImpl::UpdateSGIndexJointData( } bool FSGXRTracker::FImpl::UpdateSGMiddleJointData( - FSGXRHandState& OutHandState, const EControllerHand DeviceHand, + FSGXRHandState& OutHandState, const bool bRight, const TArray>& JointLocations, const TArray>& JointRotations, - const FTransform& WristTransform, const bool bMotionSourceHandTracking) const + const FTransform& WristTransform) const { static constexpr int32 MiddleFingerMiddle = 2; @@ -1971,7 +1964,7 @@ bool FSGXRTracker::FImpl::UpdateSGMiddleJointData( static constexpr int32 MiddleTipJointMiddle = 3; FTransform MiddleMetacarpalTransform{ - GetMeshWristChildBoneRefTransform(DeviceHand, EHandKeypoint::MiddleMetacarpal) + GetMeshWristChildBoneRefTransform(bRight, EHandKeypoint::MiddleMetacarpal) }; FTransform MiddleProximalTransform{ JointRotations[MiddleFingerMiddle][MiddleProximalJointMiddle], @@ -1992,35 +1985,35 @@ bool FSGXRTracker::FImpl::UpdateSGMiddleJointData( if (!UpdateSGJointData( OutHandState, EHandKeypoint::MiddleMetacarpal, - MoveTemp(MiddleMetacarpalTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(MiddleMetacarpalTransform), WristTransform)) { return false; } if (!UpdateSGJointData( OutHandState, EHandKeypoint::MiddleProximal, - MoveTemp(MiddleProximalTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(MiddleProximalTransform), WristTransform)) { return false; } if (!UpdateSGJointData( OutHandState, EHandKeypoint::MiddleIntermediate, - MoveTemp(MiddleIntermediateTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(MiddleIntermediateTransform), WristTransform)) { return false; } if (!UpdateSGJointData( OutHandState, EHandKeypoint::MiddleDistal, - MoveTemp(MiddleDistalTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(MiddleDistalTransform), WristTransform)) { return false; } if (!UpdateSGJointData( OutHandState, EHandKeypoint::MiddleTip, - MoveTemp(MiddleTipTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(MiddleTipTransform), WristTransform)) { return false; } @@ -2029,9 +2022,9 @@ bool FSGXRTracker::FImpl::UpdateSGMiddleJointData( } bool FSGXRTracker::FImpl::UpdateSGRingJointData( - FSGXRHandState& OutHandState, const EControllerHand DeviceHand, + FSGXRHandState& OutHandState, const bool bRight, const TArray>& JointLocations, const TArray>& JointRotations, - const FTransform& WristTransform, const bool bMotionSourceHandTracking) const + const FTransform& WristTransform) const { static constexpr int32 RingFingerRing = 3; @@ -2041,7 +2034,7 @@ bool FSGXRTracker::FImpl::UpdateSGRingJointData( static constexpr int32 RingTipJointRing = 3; FTransform RingMetacarpalTransform{ - GetMeshWristChildBoneRefTransform(DeviceHand, EHandKeypoint::RingMetacarpal) + GetMeshWristChildBoneRefTransform(bRight, EHandKeypoint::RingMetacarpal) }; FTransform RingProximalTransform{ JointRotations[RingFingerRing][RingProximalJointRing], @@ -2062,35 +2055,35 @@ bool FSGXRTracker::FImpl::UpdateSGRingJointData( if (!UpdateSGJointData( OutHandState, EHandKeypoint::RingMetacarpal, - MoveTemp(RingMetacarpalTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(RingMetacarpalTransform), WristTransform)) { return false; } if (!UpdateSGJointData( OutHandState, EHandKeypoint::RingProximal, - MoveTemp(RingProximalTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(RingProximalTransform), WristTransform)) { return false; } if (!UpdateSGJointData( OutHandState, EHandKeypoint::RingIntermediate, - MoveTemp(RingIntermediateTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(RingIntermediateTransform), WristTransform)) { return false; } if (!UpdateSGJointData( OutHandState, EHandKeypoint::RingDistal, - MoveTemp(RingDistalTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(RingDistalTransform), WristTransform)) { return false; } if (!UpdateSGJointData( OutHandState, EHandKeypoint::RingTip, - MoveTemp(RingTipTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(RingTipTransform), WristTransform)) { return false; } @@ -2099,9 +2092,9 @@ bool FSGXRTracker::FImpl::UpdateSGRingJointData( } bool FSGXRTracker::FImpl::UpdateSGLittleJointData( - FSGXRHandState& OutHandState, const EControllerHand DeviceHand, + FSGXRHandState& OutHandState, const bool bRight, const TArray>& JointLocations, const TArray>& JointRotations, - const FTransform& WristTransform, const bool bMotionSourceHandTracking) const + const FTransform& WristTransform) const { static constexpr int32 LittleFingerLittle = 4; @@ -2111,7 +2104,7 @@ bool FSGXRTracker::FImpl::UpdateSGLittleJointData( static constexpr int32 LittleTipJointLittle = 3; FTransform LittleMetacarpalTransform{ - GetMeshWristChildBoneRefTransform(DeviceHand, EHandKeypoint::LittleMetacarpal) + GetMeshWristChildBoneRefTransform(bRight, EHandKeypoint::LittleMetacarpal) }; FTransform LittleProximalTransform{ JointRotations[LittleFingerLittle][LittleProximalJointLittle], @@ -2132,35 +2125,35 @@ bool FSGXRTracker::FImpl::UpdateSGLittleJointData( if (!UpdateSGJointData( OutHandState, EHandKeypoint::LittleMetacarpal, - MoveTemp(LittleMetacarpalTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(LittleMetacarpalTransform), WristTransform)) { return false; } if (!UpdateSGJointData( OutHandState, EHandKeypoint::LittleProximal, - MoveTemp(LittleProximalTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(LittleProximalTransform), WristTransform)) { return false; } if (!UpdateSGJointData( OutHandState, EHandKeypoint::LittleIntermediate, - MoveTemp(LittleIntermediateTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(LittleIntermediateTransform), WristTransform)) { return false; } if (!UpdateSGJointData( OutHandState, EHandKeypoint::LittleDistal, - MoveTemp(LittleDistalTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(LittleDistalTransform), WristTransform)) { return false; } if (!UpdateSGJointData( OutHandState, EHandKeypoint::LittleTip, - MoveTemp(LittleTipTransform), WristTransform, bMotionSourceHandTracking)) + MoveTemp(LittleTipTransform), WristTransform)) { return false; } @@ -2168,9 +2161,9 @@ bool FSGXRTracker::FImpl::UpdateSGLittleJointData( return true; } -bool FSGXRTracker::FImpl::UpdateSGHandState(const EControllerHand DeviceHand, FSGXRHandState& OutHandState) const +bool FSGXRTracker::FImpl::UpdateSGHandState(const bool bRight, FSGXRHandState& OutHandState) const { - const USGHandPose* HandPose{FImpl::GetHandPose(DeviceHand)}; + const USGHandPose* HandPose{GetHandPose(bRight)}; if (!IsValid(HandPose)) { return false; @@ -2182,8 +2175,7 @@ bool FSGXRTracker::FImpl::UpdateSGHandState(const EControllerHand DeviceHand, FS const TArray> JointRotations{HandPose->GetJointRotationsQ()}; FTransform WristTransform; - bool bMotionSourceHandTracking = false; - const bool bGotWristTransform = GetWristTransform(DeviceHand, WristTransform, bMotionSourceHandTracking); + const bool bGotWristTransform = GetWristTransform(bRight, WristTransform); /// NOTE // Even if we fail to get the wrist transform, the SenseGlove data needs to make it to the FXRMotionControllerData! @@ -2191,47 +2183,47 @@ bool FSGXRTracker::FImpl::UpdateSGHandState(const EControllerHand DeviceHand, FS // is disabled it will output the hand-tracking data. (void) bGotWristTransform; - if (!UpdateSGWristJointData(OutHandState, WristTransform, bMotionSourceHandTracking)) + if (!UpdateSGWristJointData(OutHandState, WristTransform)) { return false; } - if (!UpdateSGPalmJointData(OutHandState, DeviceHand, WristTransform, bMotionSourceHandTracking)) + if (!UpdateSGPalmJointData(OutHandState, bRight, WristTransform)) { return false; } if (!UpdateSGThumbJointData(OutHandState, JointLocations, JointRotations, - WristTransform, bMotionSourceHandTracking)) + WristTransform)) { return false; } - if (!UpdateSGIndexJointData(OutHandState, DeviceHand, + if (!UpdateSGIndexJointData(OutHandState, bRight, JointLocations, JointRotations, - WristTransform, bMotionSourceHandTracking)) + WristTransform)) { return false; } - if (!UpdateSGMiddleJointData(OutHandState, DeviceHand, + if (!UpdateSGMiddleJointData(OutHandState, bRight, JointLocations, JointRotations, - WristTransform, bMotionSourceHandTracking)) + WristTransform)) { return false; } - if (!UpdateSGRingJointData(OutHandState, DeviceHand, + if (!UpdateSGRingJointData(OutHandState, bRight, JointLocations, JointRotations, - WristTransform, bMotionSourceHandTracking)) + WristTransform)) { return false; } - if (!UpdateSGLittleJointData(OutHandState, DeviceHand, + if (!UpdateSGLittleJointData(OutHandState, bRight, JointLocations, JointRotations, - WristTransform, bMotionSourceHandTracking)) + WristTransform)) { return false; } diff --git a/Source/SenseGloveTracking/Public/SGTracking/SGXRTracker.h b/Source/SenseGloveTracking/Public/SGTracking/SGXRTracker.h index f60cce4c..a7bcfb05 100644 --- a/Source/SenseGloveTracking/Public/SGTracking/SGXRTracker.h +++ b/Source/SenseGloveTracking/Public/SGTracking/SGXRTracker.h @@ -54,11 +54,6 @@ class SENSEGLOVETRACKING_API FSGXRTracker final : public IOpenXRExtensionPlugin, public FXRMotionControllerBase, public IHandTracker { - /** - * Parses the enum name removing the prefix. - */ - static FName ParseEOpenXRHandKeypointEnumName(const FName& EnumName); - private: struct FImpl;